import { afterAll, expect, test } from "bun:test";
import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
import { join } from "node:path";
import { runBuild } from "../src/build.ts";

// This is the regression test for a CRITICAL boot-order bug (C1): in the
// generated production entry, app middleware was emitted as a static import
// AFTER the authz merge/set happened in the entry's own body. ES modules
// evaluate every static import (including middleware) before the importing
// module's body runs, so a middleware module reading getAuthzCatalog() at its
// own module scope — the SAME eager shape authzMiddleware({ catalog, ... })
// itself requires, and the same pattern examples/basic-app's
// app/middleware/logger.ts uses for `export default requestLogger({...})` —
// saw an unset catalog and threw, taking the app down at deploy while every
// other gate (typecheck/lint/tests/a plain `bun run build`) stayed green.
// A manual build+boot caught it once; this makes that check permanent.
//
// Fixtures live inside the repo tree, not os.tmpdir(): both the scaffolded
// app files AND the code Bun.build bundles from them import "@wrnexus/authz"
// by bare specifier, which resolves via the root tsconfig.json `paths` map
// walked from the *importing file's* location — an out-of-tree path never
// reaches it.
const scratchRoot = join(import.meta.dir, ".tmp-authz-coldstart");
mkdirSync(scratchRoot, { recursive: true });

afterAll(() => {
  rmSync(scratchRoot, { recursive: true, force: true });
});

test("a module-eval getAuthzCatalog() in app middleware survives a real production cold start", async () => {
  const root = mkdtempSync(join(scratchRoot, "app-"));
  const appDir = join(root, "app");
  mkdirSync(join(appDir, "api"), { recursive: true });
  mkdirSync(join(appDir, "authz"), { recursive: true });
  mkdirSync(join(appDir, "middleware"), { recursive: true });
  writeFileSync(
    join(root, "package.json"),
    JSON.stringify({ name: "authz-coldstart-fixture" }),
    "utf8",
  );
  writeFileSync(
    join(appDir, "api", "health.ts"),
    `export function GET() {
  return Response.json({ ok: true });
}
`,
    "utf8",
  );
  writeFileSync(
    join(appDir, "authz", "main.ts"),
    `import { defineAuthz } from "@wrnexus/authz";

export default defineAuthz({ permissions: { "post:read": {} } });
`,
    "utf8",
  );
  writeFileSync(
    join(appDir, "middleware", "authz-probe.ts"),
    `import { authzMiddleware, getAuthzCatalog, memoryPermissionStore } from "@wrnexus/authz";

// Module-eval-time read, on purpose: this is exactly the pattern the
// setAuthzCatalog() singleton exists for, and exactly what took the app down
// under the pre-fix boot order. If getAuthzCatalog() throws here, this WHOLE
// MODULE fails to evaluate and the entry crashes at import time, before
// Bun.serve is ever reached.
export default authzMiddleware({ catalog: getAuthzCatalog(), store: memoryPermissionStore() });
`,
    "utf8",
  );

  await runBuild(root);

  const serverPath = join(root, "dist", "server.js");
  const proc = Bun.spawn({
    cmd: ["bun", serverPath],
    env: { ...process.env, PORT: "0" },
    stdout: "pipe",
    stderr: "pipe",
    cwd: root,
  });

  let port: number | undefined;
  let stderrText = "";
  try {
    const reader = proc.stdout.getReader();
    const errReader = proc.stderr.getReader();
    const decoder = new TextDecoder();
    let buffered = "";
    const deadline = Date.now() + 20_000;
    const TIMED_OUT = Symbol("timed out");
    while (port === undefined && Date.now() < deadline) {
      const outcome = await Promise.race([
        reader.read(),
        new Promise<typeof TIMED_OUT>((resolve) => setTimeout(() => resolve(TIMED_OUT), 250)),
      ]);
      if (outcome === TIMED_OUT) continue;
      const { value, done } = outcome;
      if (done) break;
      buffered += decoder.decode(value);
      const match = /listening on http:\/\/[^:]+:(\d+)/.exec(buffered);
      if (match) port = Number(match[1]);
    }
    reader.releaseLock();

    if (port === undefined) {
      // Drain stderr for a useful failure message before giving up.
      const errOutcome = await Promise.race([
        errReader.read(),
        new Promise<typeof TIMED_OUT>((resolve) => setTimeout(() => resolve(TIMED_OUT), 500)),
      ]);
      if (errOutcome !== TIMED_OUT && errOutcome.value) {
        stderrText += decoder.decode(errOutcome.value);
      }
      errReader.releaseLock();
      throw new Error(
        `production server never printed a "listening on" line within 20s. stderr:\n${stderrText}`,
      );
    }
    errReader.releaseLock();

    const response = await fetch(`http://127.0.0.1:${port}/api/health`);
    expect(response.status).toBe(200);
    expect(await response.json()).toEqual({ ok: true });
  } finally {
    proc.kill();
    await proc.exited;
  }
}, 30_000);