import assert from "node:assert/strict";
import { readFileSync } from "node:fs";
import test from "node:test";

import { applyRectificationChoice } from "../src/lib/rectification-agentic/v9/answer-choice.ts";
import {
  CHOICE_ACTION,
  STOP_ACTION,
  composeChoiceNarration,
  quoteIsFromAssistantQuestion,
  userVisibleChoiceLine,
} from "../src/lib/rectification-agentic/v9/choice-action.ts";
import { isNearBottom, shouldFollowLatest, shouldShowJumpToLatest } from "../src/lib/rectification-sticky-scroll.ts";
import { projectTurnDecision, TURN_DECISION_MAX_BYTES, turnDecisionByteLength } from "../src/lib/rectification-agentic/v9/turn-decision.ts";
import {
  mapModelFinishToErrorCode,
  userFacingRunFailure,
  isIncompleteRunBanner,
} from "../src/lib/rectification-agentic/v9/run-diagnostic.ts";
import { buildInferenceState } from "../src/lib/rectification-agentic/core/build-state.ts";
import { parseV9CaseDossier, RectificationToolServiceError } from "../src/lib/rectification-agentic/v9/tool-service.ts";
import {
  CASE_ID,
  FOCUS_ID,
  SESSION_ID,
  TURN_ID,
  USER_ID,
  activeFocusFixture,
  candidateSnapshotFixture,
  conversationSummaryFixture,
  dossierFixture,
  fakeAccounting,
  receiptHandlers,
} from "./rectification-v9-test-support.ts";

const ACTION_ID = "aaaaaaaa-aaaa-4aaa-8aaa-aaaaaaaaaaaa";
const QUESTION_ID = "question-1";

function inferenceState() {
  return buildInferenceState({
    range_start: "04:50",
    range_end: "05:10",
    candidates: [
      { id: "05:00", time: "05:00", relative_support: 10 },
      { id: "05:10", time: "05:10", relative_support: 10 },
    ],
    events: [
      { id: "e1", domain: "education", year: 2016, precision: "month" },
      { id: "e2", domain: "career", year: 2018, precision: "year" },
      { id: "e3", domain: "relationship", year: 2021, precision: "year" },
      { id: "e4", domain: "family", year: 2023, precision: "year" },
    ],
    probes: [{
      id: "p-cd",
      semantic_key: "career.2015",
      candidate_split_hash: "05:00|05:10",
      domain: "career",
      year: 2015,
      question: "2016 年前后有没有高考或重要考试发挥失常？",
      candidate_ids: ["05:00", "05:10"],
      expected_outcomes: [
        { answer_class: "yes", supports: ["05:00"], conflicts: ["05:10"] },
        { answer_class: "no", supports: ["05:10"], conflicts: ["05:00"] },
        { answer_class: "unsure", supports: [], conflicts: [] },
      ],
      information_gain: 0.4,
      source: "dasha_boundary",
    }],
  });
}

function choiceDossier() {
  const inference = inferenceState();
  const snapshot = candidateSnapshotFixture();
  Object.assign(snapshot.decision_receipt, { inference_state: inference });
  return dossierFixture({
    latestResult: snapshot,
    conversationSummary: conversationSummaryFixture({
      activeFocus: activeFocusFixture({
        expectedAnswerSchema: {
          choice: {
            prompt: "2016 年前后，有没有明显高考或重要考试发挥失常？",
            option_a: "是，大概就在那段时间",
            option_b: "有类似，但年份不对或不够重大",
            option_c: "没有明显发生",
            option_d: "不记得 / 不确定",
          },
          probe_id: "p-cd",
          semantic_key: "career.2015",
        },
      }),
    }),
  });
}

function choiceAccounting(overrides: Parameters<typeof fakeAccounting>[0] = {}) {
  const receipts = new Map<string, Record<string, unknown>>();
  return fakeAccounting({
    ...receiptHandlers,
    get_agentic_rectification_case_dossier: () => choiceDossier(),
    apply_agentic_rectification_choice_action: (_fn, args) => {
      const existing = receipts.get(String(args.p_action_id));
      if (existing) return { ...existing, idempotent: true };
      const receipt = {
        action_id: args.p_action_id,
        status: "applied",
        idempotent: false,
        question_id: args.p_question_id,
        option_id: args.p_option_id,
        probe_id: args.p_inference && typeof args.p_inference === "object"
          ? (args.p_inference as { probe_id?: string }).probe_id ?? "p-cd"
          : "p-cd",
        revision: Number(args.p_expected_revision) + 1,
        source_quote: args.p_source_quote,
        derived_context: args.p_derived_context,
        narration: args.p_narration,
        focus_status: args.p_focus_status,
      };
      receipts.set(String(args.p_action_id), receipt);
      return receipt;
    },
    append_agentic_rectification_turn: () => ({ turn_id: TURN_ID, idempotent: false }),
    ...overrides,
  });
}

test("does not force-follow when the reader has scrolled upward", () => {
  assert.equal(isNearBottom(1_000, 100, 400), false);
  assert.equal(shouldFollowLatest(false), false);
  assert.equal(isNearBottom(1_000, 520, 400), true);
  assert.equal(shouldFollowLatest(true), true);
});

test("jump-to-latest stays hidden while a choice card still sits in the overlay band", () => {
  assert.equal(shouldShowJumpToLatest(1_000, 100, 400), true);
  assert.equal(shouldShowJumpToLatest(1_000, 520, 400), false);
  assert.equal(shouldShowJumpToLatest(1_000, 500, 400, true), false);
  assert.equal(shouldShowJumpToLatest(1_000, 200, 400, true), true);
});

test("choice quotes come from the option label, not the assistant question year", () => {
  const question = "2016 年前后，有没有明显高考或重要考试发挥失常？";
  assert.equal(quoteIsFromAssistantQuestion("2016年", question), true);
  assert.equal(quoteIsFromAssistantQuestion("是，大概就在那段时间", question), false);
  const card = {
    question_id: QUESTION_ID,
    method_id: "d5",
    prompt: question,
    why: "",
    varga: null,
    choice_mode: "A/B/C/D" as const,
    options: [
      { key: "A" as const, label: "是，大概就在那段时间", role: "primary" as const },
      { key: "B" as const, label: "有类似，但年份不对或不够重大", role: "primary" as const },
      { key: "C" as const, label: "没有明显发生", role: "primary" as const },
      { key: "D" as const, label: "不记得 / 不确定", role: "secondary" as const },
    ],
    stop_label: "先这样，先看当前范围",
    stop_message: "先这样",
    scoring: true,
    probe_id: "p-cd",
    case_revision: 1,
    focus_id: FOCUS_ID,
  };
  assert.equal(userVisibleChoiceLine(card, "A"), "A. 是，大概就在那段时间");
});

test("clicking A applies the choice without invoking a language model", async () => {
  const accounting = choiceAccounting();
  const applied = await applyRectificationChoice(accounting.client, {
    userId: USER_ID,
    caseId: CASE_ID,
    sessionId: SESSION_ID,
    actionId: ACTION_ID,
    action: CHOICE_ACTION,
    focusId: FOCUS_ID,
    questionId: QUESTION_ID,
    probeId: "p-cd",
    optionId: "A",
    expectedRevision: inferenceState().revision,
  });
  assert.equal(applied.applied, true);
  assert.equal(applied.focusId, FOCUS_ID);
  assert.equal(applied.optionId, "A");
  assert.equal(applied.sourceQuote, "是，大概就在那段时间");
  assert.equal(applied.derivedContext.sourceType, "structured_probe_answer");
  assert.deepEqual(applied.derivedContext.referencedDateRange, {
    start: "2015-01-01",
    end: "2015-12-31",
  });
  assert.equal(applied.narration, composeChoiceNarration({
    optionId: "A",
    scoring: true,
    appliedInference: true,
  }));
  const fns = accounting.calls.map((call) => call.fn);
  assert.ok(fns.includes("apply_agentic_rectification_choice_action"));
  assert.ok(fns.includes("append_agentic_rectification_turn"));
  assert.equal(fns.includes("record_agentic_rectification_evidence_batch"), false);
  assert.equal(fns.some((fn) => fn === "create_agentic_rectification_run_attempt" || fn.includes("stream")), false);
  const persist = accounting.calls.find((call) => call.fn === "apply_agentic_rectification_choice_action");
  assert.equal(persist?.args.p_focus_id, FOCUS_ID);
  assert.equal(persist?.args.p_focus_status, "resolved");
  assert.equal(persist?.args.p_source_quote, "是，大概就在那段时间");
  assert.notEqual(persist?.args.p_source_quote, "2016年");
  assert.ok(persist?.args.p_inference);
  assert.equal(applied.nextAction.type === "ask_candidate_discriminator"
    || applied.nextAction.type === "ask_holdout_validation"
    || applied.nextAction.type === "offer_provisional_range"
    || applied.nextAction.type === "complete_with_range"
    || applied.nextAction.type === "ready_to_adopt"
    || applied.nextAction.type === "ask_fact_collection", true);
});

test("replaying the same actionId does not duplicate the applied receipt", async () => {
  const accounting = choiceAccounting();
  const command = {
    userId: USER_ID,
    caseId: CASE_ID,
    sessionId: SESSION_ID,
    actionId: ACTION_ID,
    action: CHOICE_ACTION,
    focusId: FOCUS_ID,
    questionId: QUESTION_ID,
    probeId: "p-cd",
    optionId: "A" as const,
    expectedRevision: inferenceState().revision,
  };
  const first = await applyRectificationChoice(accounting.client, command);
  const second = await applyRectificationChoice(accounting.client, command);
  assert.equal(first.idempotent, false);
  assert.equal(second.idempotent, true);
  assert.equal(
    accounting.calls.filter((call) => call.fn === "apply_agentic_rectification_choice_action").length,
    2,
  );
  const secondCall = accounting.calls.filter((call) => call.fn === "apply_agentic_rectification_choice_action").at(-1);
  assert.equal(secondCall?.args.p_action_id, ACTION_ID);
});

test("keeps the applied answer when narration persistence fails", async () => {
  const accounting = choiceAccounting({
    append_agentic_rectification_turn: () => {
      throw new Error("turn_write_failed");
    },
  });
  const applied = await applyRectificationChoice(accounting.client, {
    userId: USER_ID,
    caseId: CASE_ID,
    sessionId: SESSION_ID,
    actionId: ACTION_ID,
    action: CHOICE_ACTION,
    focusId: FOCUS_ID,
    questionId: QUESTION_ID,
    probeId: "p-cd",
    optionId: "A",
    expectedRevision: inferenceState().revision,
  });
  assert.equal(applied.applied, true);
  assert.equal(applied.status, "applied");
  assert.equal(applied.narrationPersisted, false);
  assert.match(applied.narration, /已记录你的选择/);
});

test("stop_and_review does not write an inference transition", async () => {
  const accounting = choiceAccounting();
  const applied = await applyRectificationChoice(accounting.client, {
    userId: USER_ID,
    caseId: CASE_ID,
    sessionId: SESSION_ID,
    actionId: ACTION_ID,
    action: STOP_ACTION,
    focusId: FOCUS_ID,
    questionId: QUESTION_ID,
    optionId: "stop",
    expectedRevision: inferenceState().revision,
  });
  assert.equal(applied.optionId, "stop");
  const persist = accounting.calls.find((call) => call.fn === "apply_agentic_rectification_choice_action");
  assert.equal(persist?.args.p_inference, null);
  assert.equal(persist?.args.p_focus_status, "skipped");
});

test("turn_decision stays inside the configured byte budget", () => {
  const dossier = parseV9CaseDossier(choiceDossier());
  assert.ok(dossier);
  const projection = projectTurnDecision(dossier);
  assert.equal(projection.projection, "turn_decision");
  const currentQuestion = projection.current_question as { prompt?: string } | null;
  assert.equal(currentQuestion?.prompt, "2016 年前后，有没有明显高考或重要考试发挥失常？");
  assert.ok(turnDecisionByteLength(projection) <= TURN_DECISION_MAX_BYTES);
  assert.ok(!("birth_context" in projection));
  assert.ok(!("baseline_birth_snapshot" in projection));
});

test("truncated and timed-out runs return concrete finish reasons", () => {
  assert.equal(mapModelFinishToErrorCode({
    finishReason: "length",
    aborted: false,
    timedOut: false,
    answerText: "部分回答",
    stepCount: 1,
    maxSteps: 8,
  }), "answer_truncated");
  assert.equal(mapModelFinishToErrorCode({
    finishReason: "stop",
    aborted: true,
    timedOut: true,
    answerText: "",
    stepCount: 1,
    maxSteps: 8,
  }), "run_timeout");
  assert.equal(userFacingRunFailure("answer_truncated"), "模型输出达到上限，状态已记录。");
  assert.equal(userFacingRunFailure("run_timeout"), "服务端运行超时，状态已记录。");
  assert.equal(isIncompleteRunBanner("本轮处理未完成，请稍后再试"), true);
  assert.equal(isIncompleteRunBanner("已记录你的选择，并更新了候选比较。"), false);
});

test("the public agent route treats structured choice as a non-model command", () => {
  const route = readFileSync(new URL("../src/app/api/rectification/agent/route.ts", import.meta.url), "utf8");
  const start = route.indexOf("if (isStructuredChoice)");
  const end = route.indexOf("const selectedModel", start);
  assert.ok(start >= 0 && end > start);
  const block = route.slice(start, end);
  assert.match(block, /applyRectificationChoice\(accounting/);
  assert.doesNotMatch(block, /runV9AgentTurn/);
  assert.doesNotMatch(block, /getRectificationV9Agent/);
  assert.doesNotMatch(block, /authorizeUsage/);
  assert.match(route, /"answer_choice"/);
  assert.match(route, /"stop_and_review"/);
  assert.match(route, /export const maxDuration = 240/);
  const chat = readFileSync(new URL("../src/components/rectification-agentic-chat.tsx", import.meta.url), "utf8");
  assert.match(chat, /isPersistedFocusId\(focusId\)/);
  assert.match(chat, /focusId,/);
  assert.match(chat, /回到最新/);
  assert.match(chat, /followTailRef\.current/);
});

test("rectification attempt timeout stays under the agent route budget", () => {
  const agentRun = readFileSync(new URL("../src/lib/rectification-agentic/v9/agent-run.ts", import.meta.url), "utf8");
  const regenerate = readFileSync(
    new URL("../src/app/api/rectification/cases/[caseId]/turns/[turnId]/regenerate/route.ts", import.meta.url),
    "utf8",
  );
  assert.match(agentRun, /RECTIFICATION_AGENT_ATTEMPT_TIMEOUT_MS = 210_000/);
  assert.match(agentRun, /RECTIFICATION_AGENT_ROUTE_MAX_DURATION_S = 240/);
  assert.match(regenerate, /export const maxDuration = 240/);
  assert.ok(210_000 < 240_000);
  assert.match(agentRun, /RETRYABLE_ERROR_CODES = new Set\(\[/);
  assert.doesNotMatch(agentRun, /stale_question/);
  assert.doesNotMatch(agentRun, /revision_conflict/);
});

test("derived questionId is an audit label, not the choice identity", async () => {
  const accounting = choiceAccounting();
  const applied = await applyRectificationChoice(accounting.client, {
    userId: USER_ID,
    caseId: CASE_ID,
    sessionId: SESSION_ID,
    actionId: ACTION_ID,
    action: CHOICE_ACTION,
    focusId: FOCUS_ID,
    questionId: "derived-from-stem:not-the-db-row",
    probeId: "p-cd",
    optionId: "A",
    expectedRevision: inferenceState().revision,
  });
  assert.equal(applied.applied, true);
  assert.equal(applied.focusId, FOCUS_ID);
  const persist = accounting.calls.find((call) => call.fn === "apply_agentic_rectification_choice_action");
  assert.equal(persist?.args.p_focus_id, FOCUS_ID);
  assert.equal(persist?.args.p_question_id, QUESTION_ID);
});

test("a mismatched focusId is stale_question even when questionId matches", async () => {
  await assert.rejects(
    () => applyRectificationChoice(choiceAccounting().client, {
      userId: USER_ID,
      caseId: CASE_ID,
      sessionId: SESSION_ID,
      actionId: ACTION_ID,
      action: CHOICE_ACTION,
      focusId: "cdcdcdcd-cdcd-4dcd-8dcd-cdcdcdcdcdcd",
      questionId: QUESTION_ID,
      probeId: "p-cd",
      optionId: "A",
      expectedRevision: inferenceState().revision,
    }),
    (error: unknown) => {
      assert.ok(error instanceof RectificationToolServiceError);
      assert.match(error.message, /stale_question/);
      return true;
    },
  );
});

test("choice identity SQL keys stale_question to inactive focus, not question_id", () => {
  const migration = readFileSync(
    new URL("../supabase/migrations/20260826020000_rectification_choice_focus_identity.sql", import.meta.url),
    "utf8",
  );
  assert.match(migration, /v_focus\.status is distinct from 'active'/);
  assert.doesNotMatch(migration, /v_focus\.question_id is distinct from/);
  assert.doesNotMatch(migration, /p_question_id is distinct from v_focus\.question_id/);
  const route = readFileSync(new URL("../src/app/api/rectification/agent/route.ts", import.meta.url), "utf8");
  assert.match(route, /focusId: z\.string\(\)\.uuid\(\)/);
  assert.match(route, /选择题请求缺少 actionId、focusId 或 expectedRevision/);
});