import { mkdirSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs"
import { tmpdir } from "node:os"
import path from "node:path"

import { afterEach, expect, test } from "vitest"

import { generateApiList } from "#Source/http/bin/generate-api-list/generate-api-list.ts"

const temporaryDirectorySet = new Set<string>()

afterEach(() => {
  for (const temporaryDirectory of temporaryDirectorySet) {
    rmSync(temporaryDirectory, { recursive: true, force: true })
  }
  temporaryDirectorySet.clear()
})

const createApiFixtureFile = (filePath: string): void => {
  writeFileSync(
    filePath,
    [
      "export type ApiSchema = {}",
      "export const apiSchema = {}",
      "export type Api = {}",
      "export const api = {}",
      "",
    ].join("\n"),
  )
}

const createTemporaryProject = (): string => {
  const temporaryDirectory = mkdtempSync(path.join(tmpdir(), "mobius-generate-api-list-"))
  temporaryDirectorySet.add(temporaryDirectory)

  writeFileSync(
    path.join(temporaryDirectory, "tsconfig.json"),
    JSON.stringify(
      {
        compilerOptions: {
          target: "ESNext",
          module: "ESNext",
          moduleResolution: "Bundler",
        },
        include: ["src/**/*.ts"],
      },
      null,
      2,
    ),
  )

  return temporaryDirectory
}

test("generateApiList includes api.ts and .api.ts files inside api folder", () => {
  const temporaryDirectory = createTemporaryProject()

  mkdirSync(path.join(temporaryDirectory, "src", "api", "nested"), { recursive: true })
  createApiFixtureFile(path.join(temporaryDirectory, "src", "api", "hello.api.ts"))
  createApiFixtureFile(path.join(temporaryDirectory, "src", "api", "nested", "api.ts"))

  generateApiList({ startPath: temporaryDirectory })

  const apiListFileContent = readFileSync(
    path.join(temporaryDirectory, "src", "api", "api-list.ts"),
    "utf8",
  )

  expect(apiListFileContent).toContain('import * as Hello from "./hello.api.ts"')
  expect(apiListFileContent).toContain('import * as Nested from "./nested/api.ts"')
})

test("generateApiList derives the same namespace shape for register.api.ts as register/api.ts", () => {
  const dottedTemporaryDirectory = createTemporaryProject()
  mkdirSync(path.join(dottedTemporaryDirectory, "src", "api", "user"), { recursive: true })
  createApiFixtureFile(path.join(dottedTemporaryDirectory, "src", "api", "user", "register.api.ts"))

  generateApiList({ startPath: dottedTemporaryDirectory })

  const dottedApiListFileContent = readFileSync(
    path.join(dottedTemporaryDirectory, "src", "api", "api-list.ts"),
    "utf8",
  )

  expect(dottedApiListFileContent).toContain(
    'import * as UserRegister from "./user/register.api.ts"',
  )
  expect(dottedApiListFileContent).not.toContain("UserRegisterApi")

  const nestedTemporaryDirectory = createTemporaryProject()
  mkdirSync(path.join(nestedTemporaryDirectory, "src", "api", "user", "register"), {
    recursive: true,
  })
  createApiFixtureFile(
    path.join(nestedTemporaryDirectory, "src", "api", "user", "register", "api.ts"),
  )

  generateApiList({ startPath: nestedTemporaryDirectory })

  const nestedApiListFileContent = readFileSync(
    path.join(nestedTemporaryDirectory, "src", "api", "api-list.ts"),
    "utf8",
  )

  expect(nestedApiListFileContent).toContain(
    'import * as UserRegister from "./user/register/api.ts"',
  )
})