import assert from "node:assert/strict";
import test from "node:test";

import { createCodeAgentSessionRegistry } from "./code-agent-session-registry.mjs";
import { handleCodeAgentChat, validateCodeAgentChatSchema } from "./code-agent-chat.mjs";
import {
  classifyCodexRunnerCapability,
  classifyCodeAgentChatReadiness
} from "../../scripts/src/code-agent-response-contract.mjs";

test("code agent session registry creates, reuses, and expires sessions without storing secrets", () => {
  const registry = createCodeAgentSessionRegistry({
    idleTimeoutMs: 1000,
    idFactory: () => "ses_test-registry"
  });
  const first = registry.acquire({
    conversationId: "cnv_registry",
    workspace: "/workspace/hwlab",
    sandbox: "read-only",
    runnerKind: "hwlab-readonly-runner",
    capabilityLevel: "read-only-session-tools",
    traceId: "trc_registry_1",
    now: "2026-05-23T00:00:00.000Z"
  });
  assert.equal(first.ok, true);
  assert.equal(first.reused, false);
  assert.equal(first.session.sessionId, "ses_test-registry");
  assert.equal(first.session.status, "busy");
  assert.equal(first.session.idleTimeoutMs, 1000);
  assert.equal(first.session.lastTraceId, "trc_registry_1");
  assert.equal(first.session.secretMaterialStored, false);
  assert.equal(first.session.valuesRedacted, true);
  registry.release(first.session.sessionId, {
    conversationId: "cnv_registry",
    traceId: "trc_registry_1",
    reused: first.session.reused,
    now: "2026-05-23T00:00:00.010Z"
  });

  const second = registry.acquire({
    conversationId: "cnv_registry",
    workspace: "/workspace/hwlab",
    sandbox: "read-only",
    runnerKind: "hwlab-readonly-runner",
    capabilityLevel: "read-only-session-tools",
    traceId: "trc_registry_2",
    now: "2026-05-23T00:00:00.500Z"
  });
  assert.equal(second.ok, true);
  assert.equal(second.reused, true);
  assert.equal(second.session.sessionId, "ses_test-registry");
  assert.equal(second.session.turn, 2);
  assert.equal(second.session.lastTraceId, "trc_registry_2");
  registry.release(second.session.sessionId, {
    conversationId: "cnv_registry",
    traceId: "trc_registry_2",
    reused: second.session.reused,
    now: "2026-05-23T00:00:00.510Z"
  });

  const expired = registry.acquire({
    conversationId: "cnv_registry",
    workspace: "/workspace/hwlab",
    sandbox: "read-only",
    runnerKind: "hwlab-readonly-runner",
    capabilityLevel: "read-only-session-tools",
    traceId: "trc_registry_expired",
    now: "2026-05-23T00:00:02.000Z"
  });
  assert.equal(expired.ok, false);
  assert.equal(expired.code, "session_expired");
  assert.equal(expired.session.status, "expired");
  assert.equal(expired.blocker.sourceIssue, "pikasTech/HWLAB#317");
});

test("code agent session registry reports busy sessions as structured blocker", () => {
  const registry = createCodeAgentSessionRegistry({
    idFactory: () => "ses_busy"
  });
  const first = registry.acquire({
    conversationId: "cnv_busy",
    workspace: "/workspace/hwlab",
    sandbox: "read-only",
    runnerKind: "hwlab-readonly-runner",
    capabilityLevel: "read-only-session-tools",
    traceId: "trc_busy_1",
    now: "2026-05-23T00:00:00.000Z"
  });
  assert.equal(first.ok, true);
  const busy = registry.acquire({
    conversationId: "cnv_busy",
    workspace: "/workspace/hwlab",
    sandbox: "read-only",
    runnerKind: "hwlab-readonly-runner",
    capabilityLevel: "read-only-session-tools",
    traceId: "trc_busy_2",
    now: "2026-05-23T00:00:01.000Z"
  });
  assert.equal(busy.ok, false);
  assert.equal(busy.code, "session_busy");
  assert.equal(busy.session.status, "busy");
  assert.equal(busy.session.currentTraceId, "trc_busy_1");
});

test("read-only runner returns session registry evidence and blocked long-lived gate", async () => {
  const registry = createCodeAgentSessionRegistry({
    idFactory: () => "ses_chat_registry"
  });
  const first = await handleCodeAgentChat(
    {
      conversationId: "cnv_chat_registry",
      traceId: "trc_chat_registry_pwd",
      message: "pwd"
    },
    {
      now: () => "2026-05-23T00:01:00.000Z",
      sessionRegistry: registry,
      env: {
        PATH: process.env.PATH,
        HWLAB_CODE_AGENT_WORKSPACE: process.cwd()
      }
    }
  );
  validateCodeAgentChatSchema(first);
  assert.equal(first.status, "completed");
  assert.equal(first.sessionId, "ses_chat_registry");
  assert.equal(first.session.sessionId, "ses_chat_registry");
  assert.equal(first.session.status, "idle");
  assert.equal(first.session.workspace, process.cwd());
  assert.equal(first.session.lastTraceId, "trc_chat_registry_pwd");
  assert.equal(first.capabilityLevel, "read-only-session-tools");
  assert.equal(first.longLivedSessionGate.status, "blocked");
  assert.equal(first.longLivedSessionGate.pass, false);
  assert.ok(first.longLivedSessionGate.blockers.some((blocker) => blocker.code === "stdio_protocol_not_wired"));

  const second = await handleCodeAgentChat(
    {
      conversationId: "cnv_chat_registry",
      traceId: "trc_chat_registry_ls",
      message: "ls ."
    },
    {
      now: () => "2026-05-23T00:01:01.000Z",
      sessionRegistry: registry,
      env: {
        PATH: process.env.PATH,
        HWLAB_CODE_AGENT_WORKSPACE: process.cwd()
      }
    }
  );
  assert.equal(second.status, "completed");
  assert.equal(second.sessionId, first.sessionId);
  assert.equal(second.sessionReuse.reused, true);
  assert.equal(second.sessionReuse.turn, 2);
  assert.equal(second.session.lastTraceId, "trc_chat_registry_ls");
  assert.equal(classifyCodexRunnerCapability(second, { httpStatus: 200 }).capabilityPass, true);
});

test("expired and busy session states are surfaced as structured blockers", async () => {
  const expiredRegistry = createCodeAgentSessionRegistry({
    idleTimeoutMs: 10,
    idFactory: () => "ses_expired_chat"
  });
  const first = expiredRegistry.acquire({
    conversationId: "cnv_expired_chat",
    workspace: process.cwd(),
    sandbox: "read-only",
    runnerKind: "hwlab-readonly-runner",
    capabilityLevel: "read-only-session-tools",
    traceId: "trc_expired_seed",
    now: "2026-05-23T00:02:00.000Z"
  });
  expiredRegistry.release(first.session.sessionId, {
    conversationId: "cnv_expired_chat",
    traceId: "trc_expired_seed",
    now: "2026-05-23T00:02:00.001Z"
  });
  const expired = await handleCodeAgentChat(
    {
      conversationId: "cnv_expired_chat",
      traceId: "trc_expired_request",
      message: "pwd"
    },
    {
      now: () => "2026-05-23T00:02:01.000Z",
      sessionRegistry: expiredRegistry,
      env: {
        PATH: process.env.PATH,
        HWLAB_CODE_AGENT_WORKSPACE: process.cwd()
      }
    }
  );
  assert.equal(expired.status, "failed");
  assert.equal(expired.error.code, "session_expired");
  assert.equal(expired.session.status, "expired");
  assert.equal(expired.capabilityLevel, "blocked");
  assert.equal(expired.longLivedSessionGate.status, "blocked");

  const busyRegistry = createCodeAgentSessionRegistry({
    idFactory: () => "ses_busy_chat"
  });
  busyRegistry.acquire({
    conversationId: "cnv_busy_chat",
    workspace: process.cwd(),
    sandbox: "read-only",
    runnerKind: "hwlab-readonly-runner",
    capabilityLevel: "read-only-session-tools",
    traceId: "trc_busy_seed",
    now: "2026-05-23T00:03:00.000Z"
  });
  const busy = await handleCodeAgentChat(
    {
      conversationId: "cnv_busy_chat",
      traceId: "trc_busy_request",
      message: "pwd"
    },
    {
      now: () => "2026-05-23T00:03:01.000Z",
      sessionRegistry: busyRegistry,
      env: {
        PATH: process.env.PATH,
        HWLAB_CODE_AGENT_WORKSPACE: process.cwd()
      }
    }
  );
  assert.equal(busy.status, "failed");
  assert.equal(busy.error.code, "session_busy");
  assert.equal(busy.session.status, "busy");
  assert.equal(busy.capabilityLevel, "blocked");
  assert.equal(busy.error.blockers[0].sourceIssue, "pikasTech/HWLAB#317");
});

test("OpenAI fallback and codex one-shot do not pass the long-lived session gate", async () => {
  const fallback = await handleCodeAgentChat(
    {
      conversationId: "cnv_fallback_gate",
      traceId: "trc_fallback_gate",
      message: "你好"
    },
    {
      now: () => "2026-05-23T00:04:00.000Z",
      callProvider: async ({ providerPlan }) => ({
        provider: providerPlan.provider,
        model: providerPlan.model,
        backend: providerPlan.backend,
        content: "普通文本回复。",
        usage: null,
        providerTrace: {
          source: "test-provider"
        }
      })
    }
  );
  assert.equal(fallback.status, "completed");
  assert.equal(fallback.runner.kind, "openai-responses-fallback");
  assert.equal(fallback.capabilityLevel, "text-chat-only");
  assert.equal(fallback.longLivedSessionGate.status, "blocked");
  assert.ok(fallback.longLivedSessionGate.blockers.some((blocker) => blocker.code === "openai_responses_fallback_not_session"));
  assert.equal(classifyCodexRunnerCapability(fallback, { httpStatus: 200 }).capabilityPass, false);

  const oneShot = {
    ...fallback,
    provider: "codex-cli",
    backend: "hwlab-cloud-api/codex-cli",
    runner: {
      kind: "codex-cli-one-shot-ephemeral",
      codexStdio: false,
      writeCapable: false,
      durableSession: false
    },
    sessionMode: "ephemeral-one-shot",
    implementationType: "codex-cli-one-shot-ephemeral",
    longLivedSessionGate: {
      status: "blocked",
      pass: false,
      blockers: [{ code: "one_shot_runner_not_long_lived", sourceIssue: "pikasTech/HWLAB#317" }]
    }
  };
  assert.equal(classifyCodexRunnerCapability(oneShot, { httpStatus: 200 }).capabilityPass, false);
  assert.equal(classifyCodeAgentChatReadiness(oneShot, { realDevLive: true, httpStatus: 200 }).devLiveReplyPass, true);
});