import { expect, test } from "vitest"

import type { ApiHandler } from "#Source/http/index.ts"
import { SuccessResult, createApi, createApiSchema } from "#Source/http/index.ts"
import type { Standard } from "#Source/validation/index.ts"

const isRecord = (value: unknown): value is Record<string, unknown> => {
  return typeof value === "object" && value !== null
}

const createSchema = <Output>(
  validate: (value: unknown) => Standard.Schema.Result<Output>,
): Standard.Schema<unknown, Output> => {
  return {
    "~standard": {
      version: 1 as const,
      vendor: "mobius-http-test",
      validate,
    },
  }
}

class TestSuccessResult extends SuccessResult<{ status: "success" }> {
  constructor() {
    super({})
  }

  async handle(): Promise<void> {
    await Promise.resolve()
  }
}

const inputQuerySchema = createSchema<{ page: string }>((value) => {
  if (isRecord(value) && typeof value["page"] === "string") {
    return {
      value: {
        page: value["page"],
      },
    }
  }

  return {
    issues: [{ message: "page is required" }],
  }
})

const inputBodySchema = createSchema<{ name: string }>((value) => {
  if (isRecord(value) && typeof value["name"] === "string") {
    return {
      value: {
        name: value["name"],
      },
    }
  }

  return {
    issues: [{ message: "name is required" }],
  }
})

const outputErrorSchema = createSchema<{ status: "error" }>((value) => {
  if (
    typeof value === "object" &&
    value !== null &&
    (value as { status?: unknown }).status === "error"
  ) {
    return {
      value: {
        status: "error",
      },
    }
  }

  return {
    issues: [{ message: "status must be error" }],
  }
})

const outputSuccessSchema = createSchema<{ status: "success" }>((value) => {
  if (
    typeof value === "object" &&
    value !== null &&
    (value as { status?: unknown }).status === "success"
  ) {
    return {
      value: {
        status: "success",
      },
    }
  }

  return {
    issues: [{ message: "status must be success" }],
  }
})

const apiSchema = createApiSchema({
  path: "/users",
  method: "post",
  inputQuerySchema,
  inputBodySchema,
  outputErrorSchema,
  outputSuccessSchema,
})

const apiHandler: ApiHandler<
  "/users",
  "post",
  typeof inputQuerySchema,
  typeof inputBodySchema,
  typeof outputErrorSchema,
  typeof outputSuccessSchema
> = async () => {
  await Promise.resolve()
  return new TestSuccessResult()
}

const api = createApi({
  apiSchema,
  apiHandler,
})

test("Api.getApiSchema returns the configured schema", () => {
  expect(api.getApiSchema()).toBe(apiSchema)
})

test("Api.getApiHandler returns the configured handler", () => {
  expect(api.getApiHandler()).toBe(apiHandler)
})