import { mkdtemp, mkdir, writeFile, rm } from "node:fs/promises";
import os from "node:os";
import path from "node:path";
import assert from "node:assert/strict";
import { ManagerClient } from "../mgr/client.js";
import type { BackendProfile, JsonRecord } from "../common/types.js";
import { backendProfileSpec } from "../common/backend-profiles.js";

export interface SelfTestContext {
  root: string;
  tmp: string;
  codexHome: string;
  deepseekHome: string;
  workspace: string;
  fakeCodexPath: string;
  fakeCodexCommand: string;
  fakeCodexArgs: string[];
  cleanup(): Promise<void>;
}

export interface SelfTestResult {
  name?: string;
  tests?: string[];
}

export type SelfTestCase = (context: SelfTestContext) => Promise<SelfTestResult> | SelfTestResult;

export async function createSelfTestContext(root: string): Promise<SelfTestContext> {
  const tmp = await mkdtemp(path.join(os.tmpdir(), "agentrun-selftest-"));
  const codexHome = path.join(tmp, "codex-home");
  const deepseekHome = path.join(tmp, "deepseek-home");
  const workspace = path.join(tmp, "workspace");
  await mkdir(codexHome, { recursive: true });
  await mkdir(deepseekHome, { recursive: true });
  await mkdir(workspace, { recursive: true });
  await writeFile(path.join(codexHome, "auth.json"), JSON.stringify({ token: "test-token-material" }));
  await writeFile(path.join(codexHome, "config.toml"), "model = \"gpt-test\"\n");
  await writeFile(path.join(deepseekHome, "auth.json"), JSON.stringify({ token: "test-token-material-deepseek" }));
  await writeFile(path.join(deepseekHome, "config.toml"), "model = \"deepseek-test\"\n");
  await writeFile(path.join(workspace, "README.md"), "self-test workspace\n");
  const fakeCodexPath = path.join(root, "src/selftest/fake-codex-app-server.ts");
  return {
    root,
    tmp,
    codexHome,
    deepseekHome,
    workspace,
    fakeCodexPath,
    fakeCodexCommand: process.env.AGENTRUN_SELFTEST_CODEX_COMMAND ?? defaultFakeCommand(),
    fakeCodexArgs: process.env.AGENTRUN_SELFTEST_CODEX_ARGS ? JSON.parse(process.env.AGENTRUN_SELFTEST_CODEX_ARGS) as string[] : defaultFakeArgs(fakeCodexPath),
    cleanup: () => rm(tmp, { recursive: true, force: true }),
  };
}

export async function createRunWithCommand(client: ManagerClient, context: Pick<SelfTestContext, "workspace" | "codexHome"> & Partial<Pick<SelfTestContext, "deepseekHome">> & { backendProfile?: BackendProfile; includeOnlyProfile?: BackendProfile }, prompt: string, idempotencyKey: string, timeoutMs: number): Promise<{ runId: string; commandId: string }> {
  const backendProfile = context.backendProfile ?? "codex";
  const run = await client.post("/api/v1/runs", {
    tenantId: "unidesk",
    projectId: "pikasTech/unidesk",
    workspaceRef: { kind: "host-path", path: context.workspace },
    providerId: "G14",
    backendProfile,
    executionPolicy: {
      sandbox: "workspace-write",
      approval: "never",
      timeoutMs,
      network: "default",
      secretScope: { allowCredentialEcho: false, providerCredentials: providerCredentials(context, backendProfile) },
    },
    traceSink: null,
  }) as { id: string };
  const command = await client.post(`/api/v1/runs/${run.id}/commands`, { type: "turn", payload: { prompt }, idempotencyKey }) as { id: string };
  const duplicate = await client.post(`/api/v1/runs/${run.id}/commands`, { type: "turn", payload: { prompt }, idempotencyKey }) as { id: string };
  assert.equal(duplicate.id, command.id);
  return { runId: run.id, commandId: command.id };
}

function providerCredentials(context: Pick<SelfTestContext, "codexHome"> & Partial<Pick<SelfTestContext, "deepseekHome">> & { includeOnlyProfile?: BackendProfile }, backendProfile: BackendProfile): JsonRecord[] {
  const profiles: BackendProfile[] = context.includeOnlyProfile ? [context.includeOnlyProfile] : [backendProfile];
  return profiles.map((profile) => ({
    profile,
    secretRef: {
      name: backendProfileSpec(profile)?.defaultSecretName ?? `agentrun-v01-provider-${profile}`,
      keys: ["auth.json", "config.toml"],
      mountPath: profile === "deepseek" ? context.deepseekHome ?? context.codexHome : context.codexHome,
    },
  }));
}

export function assertNoSecretLeak(value: unknown): void {
  const text = JSON.stringify(value);
  assert.equal(text.includes("test-token-material"), false);
  assert.equal(text.includes("test-token-material-deepseek"), false);
  assert.equal(text.includes("Bearer test-token"), false);
}

function defaultFakeCommand(): string {
  return process.versions.bun ? process.execPath : "npx";
}

function defaultFakeArgs(fakePath: string): string[] {
  return process.versions.bun ? [fakePath] : ["tsx", fakePath];
}