import { codexPrPreflightQueryForTest } from "./src/code-queue";

type JsonRecord = Record<string, unknown>;

function assertCondition(condition: unknown, message: string, detail: unknown = {}): void {
  if (!condition) throw new Error(`${message}: ${JSON.stringify(detail)}`);
}

function asRecord(value: unknown): JsonRecord {
  assertCondition(typeof value === "object" && value !== null && !Array.isArray(value), "expected JSON object", { value });
  return value as JsonRecord;
}

function fixtureRuntimePreflight(tokenPresent: boolean, overrides: { systemGhPresent?: boolean } = {}): JsonRecord {
  const systemGhPresent = overrides.systemGhPresent ?? true;
  return {
    ok: tokenPresent,
    checkedAt: "2026-05-20T00:00:00.000Z",
    cwd: "/workspace/unidesk",
    pid: 123,
    ports: {
      codex: { ok: true, commandPath: "/usr/local/bin/codex", version: "codex 0.128.0", errors: [] },
      opencode: { ok: true, commandPath: "/usr/local/bin/opencode", version: "opencode 1.14.48", errors: [] },
    },
    pullRequestDelivery: {
      ok: tokenPresent,
      checkedAt: "2026-05-20T00:00:00.000Z",
      tools: {
        git: { ok: true, path: "/usr/bin/git", version: "git version 2.43.0" },
        gh: { ok: systemGhPresent, path: systemGhPresent ? "/usr/bin/gh" : null, version: systemGhPresent ? "gh version 2.45.0" : null },
        hub: { ok: false, path: null, version: null },
        jq: { ok: true, path: "/usr/bin/jq", version: "jq-1.7" },
        ssh: { ok: true, path: "/usr/bin/ssh", version: "OpenSSH_9.6" },
        curl: { ok: true, path: "/usr/bin/curl", version: "curl 8.5.0" },
      },
      unideskGhCli: {
        ok: true,
        path: "/workspace/unidesk/scripts/cli.ts",
        present: true,
      },
      credentials: {
        ghTokenPresent: tokenPresent,
        githubTokenPresent: false,
        ghHostPresent: false,
        githubApiUrlPresent: false,
        ghRepoPresent: false,
        sshAuthSockPresent: false,
        gitAskpassPresent: false,
        ghHostsConfigPresent: false,
        gitCredentialsPresent: false,
      },
      githubContext: {
        host: "github.com",
        apiBaseUrl: "https://api.github.com",
        repo: "pikasTech/unidesk",
        issueProbeNumber: 20,
      },
      egress: {
        proxy: { selectedProxyHost: "d601-provider-egress-proxy.unidesk.svc.cluster.local", selectedProxyPort: "18789", selectedProxyHostResolvable: true },
        githubDefault: { command: "preflight", args: ["github-default-network"], ok: true, exitCode: 0, signal: null, error: null, stdout: "skipped", stderr: "" },
        apiDefault: { command: "preflight", args: ["github-api-default-network"], ok: true, exitCode: 0, signal: null, error: null, stdout: "skipped", stderr: "" },
        issueApi: null,
      },
      git: {
        insideWorktree: true,
        branch: "master",
        head: "abc1234",
        originMaster: "abc1234",
        remoteOrigin: "git@github.com:pikasTech/unidesk.git",
        home: "/root",
        homeWritable: true,
        knownHostsPresent: true,
        privateKeyPresent: true,
      },
      prCreateDryRun: tokenPresent ? { command: "sh", args: ["-lc", "bun scripts/cli.ts gh pr create --dry-run"], ok: true, exitCode: 0, signal: null, error: null, stdout: "{\"ok\":true,\"data\":{\"dryRun\":true}}", stderr: "" } : undefined,
      limitations: tokenPresent ? [] : ["GH_TOKEN/GITHUB_TOKEN is not present; gh cannot create PRs unless another gh credential store is mounted"],
      risks: systemGhPresent ? [] : ["system gh binary is missing; UniDesk REST gh CLI remains the supported PR create/comment path when scripts/cli.ts and GH_TOKEN/GITHUB_TOKEN are available"],
    },
  };
}

function fixtureResponse(tokenPresent: boolean, overrides: { systemGhPresent?: boolean } = {}): JsonRecord {
  return {
    ok: true,
    status: 200,
    body: {
      ok: true,
      runtimePreflight: fixtureRuntimePreflight(tokenPresent, overrides),
    },
  };
}

export function runCodeQueuePrPreflightContract(): JsonRecord {
  let observedPath = "";
  const missing = codexPrPreflightQueryForTest(["--remote", "--issue", "35"], (path) => {
    observedPath = path;
    return fixtureResponse(false);
  });
  assertCondition(
    observedPath === "/api/microservices/code-queue/proxy/api/runtime-preflight?remote=1&issue=35",
    "PR preflight should route to the stable code-queue runtime preflight path",
    { observedPath },
  );
  assertCondition(asRecord(missing).ok === false, "missing token preflight should set top-level ok=false", missing);
  assertCondition(asRecord(missing).runnerDisposition === "infra-blocked", "missing token preflight should expose root runnerDisposition", missing);
  const missingPreflight = asRecord(asRecord(missing).preflight);
  assertCondition(missingPreflight.ok === false, "missing token preflight should fail", missingPreflight);
  assertCondition(missingPreflight.runnerDisposition === "infra-blocked", "missing token must be infra-blocked", missingPreflight);
  const missingTokenCoverage = asRecord(missingPreflight.tokenCoverage);
  assertCondition(missingTokenCoverage.ok === false, "tokenCoverage should fail when no env token is present", missingTokenCoverage);
  assertCondition(Array.isArray(missingTokenCoverage.missing) && missingTokenCoverage.missing.includes("GH_TOKEN") && missingTokenCoverage.missing.includes("GITHUB_TOKEN"), "tokenCoverage should name both accepted env keys", missingTokenCoverage);
  assertCondition(!JSON.stringify(missing).includes("contract-token"), "preflight output must not leak token values", missing);

  const ready = codexPrPreflightQueryForTest(["--remote", "--push-dry-run", "--push-dry-run-ref", "refs/heads/probe/test"], (path) => {
    assertCondition(path === "/api/microservices/code-queue/proxy/api/runtime-preflight?remote=1&pushDryRun=1&pushDryRunRef=refs%2Fheads%2Fprobe%2Ftest", "push dry-run options should map to query string", { path });
    return fixtureResponse(true);
  });
  const readyPreflight = asRecord(asRecord(ready).preflight);
  assertCondition(asRecord(ready).ok === true, "token-ready preflight should set top-level ok=true", ready);
  assertCondition(asRecord(ready).runnerDisposition === "ready", "token-ready preflight should expose root runnerDisposition", ready);
  assertCondition(readyPreflight.ok === true, "token-ready preflight should pass fixture", readyPreflight);
  assertCondition(readyPreflight.runnerDisposition === "ready", "ready preflight should report ready disposition", readyPreflight);
  const readyTokenCoverage = asRecord(readyPreflight.tokenCoverage);
  assertCondition(readyTokenCoverage.source === "GH_TOKEN", "ready token source should be redacted to key name only", readyTokenCoverage);
  const readyContract = asRecord(readyPreflight.prCapabilityContract);
  assertCondition(readyContract.targetBranch === "master", "PR preflight should expose target branch", readyContract);
  const readyPushDryRun = asRecord(readyContract.pushDryRun);
  assertCondition(readyPushDryRun.requested === true && readyPushDryRun.writesRemote === false, "push dry-run contract should be explicit and non-writing", readyPushDryRun);
  const readyHandoff = asRecord(readyContract.expectedPrHandoff);
  assertCondition(readyHandoff.targetBranch === "master" && readyHandoff.commanderReviewsAndMerges === true && readyHandoff.preflightCreatesPr === false, "PR handoff should stop at runner PR creation evidence", readyHandoff);
  const readyMergeBoundary = asRecord(readyContract.unsupportedMergeBoundary);
  assertCondition(readyMergeBoundary.degradedReason === "unsupported-command" && readyMergeBoundary.runnerDisposition === "business-failed", "merge boundary should remain unsupported", readyMergeBoundary);
  const readyCliStatus = asRecord(readyContract.unideskGhCli);
  assertCondition(readyCliStatus.ok === true && readyCliStatus.requiresSystemGhBinary === false, "UniDesk gh CLI availability should be separate from system gh binary", readyCliStatus);

  const prCreateDryRun = codexPrPreflightQueryForTest(["--remote", "--pr-create-dry-run", "--pr-create-dry-run-head", "codequeue/pr-probe"], (path) => {
    assertCondition(path === "/api/microservices/code-queue/proxy/api/runtime-preflight?remote=1&prCreateDryRun=1&prCreateDryRunHead=codequeue%2Fpr-probe", "PR create dry-run options should map to query string", { path });
    return fixtureResponse(true);
  });
  const prCreateDryRunPreflight = asRecord(asRecord(prCreateDryRun).preflight);
  const prCreateDryRunProbe = asRecord(prCreateDryRunPreflight.prCreateDryRun);
  assertCondition(prCreateDryRunProbe.ok === true, "PR create dry-run probe should be compacted", prCreateDryRunProbe);
  const prCreateDryRunContract = asRecord(prCreateDryRunPreflight.prCapabilityContract);
  const prCreateDryRunSummary = asRecord(prCreateDryRunContract.prCreateDryRun);
  assertCondition(prCreateDryRunSummary.requested === true && prCreateDryRunSummary.headBranch === "codequeue/pr-probe" && prCreateDryRunSummary.writesRemote === false, "PR create dry-run contract should be explicit and non-writing", prCreateDryRunSummary);

  const noSystemGh = codexPrPreflightQueryForTest(["--remote"], (path) => {
    assertCondition(path === "/api/microservices/code-queue/proxy/api/runtime-preflight?remote=1", "system gh missing fixture should use remote preflight path", { path });
    return fixtureResponse(true, { systemGhPresent: false });
  });
  const noSystemGhPreflight = asRecord(asRecord(noSystemGh).preflight);
  assertCondition(noSystemGhPreflight.ok === true, "missing system gh should not block UniDesk REST PR CLI when token and scripts/cli.ts exist", noSystemGhPreflight);
  const noSystemGhTools = asRecord(noSystemGhPreflight.tools);
  assertCondition(asRecord(noSystemGhTools.systemGhBinary).ok === false, "system gh binary status should be explicit", noSystemGhTools);
  assertCondition(asRecord(noSystemGhTools.unideskGhCli).ok === true, "UniDesk gh CLI should stay available when system gh is missing", noSystemGhTools);

  return {
    ok: true,
    checks: [
      "stable runtime-preflight proxy path",
      "missing GitHub token is infra-blocked",
      "token key names are reported without values",
      "fake token source reports only the env key",
      "system gh binary and UniDesk REST gh CLI are distinct",
      "push dry-run options are forwarded",
      "PR create dry-run options are forwarded",
      "dry-run push and PR create are marked non-writing",
      "expected PR handoff and unsupported merge boundary are explicit",
    ],
  };
}

if (import.meta.main) {
  process.stdout.write(`${JSON.stringify(runCodeQueuePrPreflightContract(), null, 2)}\n`);
}