import assert from "node:assert/strict";
import { readFileSync } from "node:fs";
import test from "node:test";
import React from "react";
import { renderToStaticMarkup } from "react-dom/server";

import { ConversationalRectificationSurface } from "../src/components/conversational-birth-time-rectification.tsx";
import { createConversationalRectificationController } from "../src/hooks/use-conversational-rectification.ts";
import type { ConversationalRectificationController } from "../src/hooks/use-conversational-rectification.ts";
import { prepareConsultationRoute } from "../src/lib/consultation-route-service.ts";
import type { ConversationalRectificationTurn } from "../src/lib/conversational-rectification/contracts.ts";
import {
  createRectificationQuestionHandoffCoordinator,
} from "../src/lib/rectification-question-handoff.ts";

Object.assign(globalThis, { React });

const pendingQuestion = "未来半年是否适合换工作？";

function confirmedTurn(): ConversationalRectificationTurn {
  return {
    caseId: "00000000-0000-4000-8000-000000001010",
    journeyProtocol: "conversational-evidence-v3",
    status: "completed",
    turnVersion: 5,
    narrative: "候选时间已经完成确认。",
    candidate: {
      status: "confirmed",
      representativeTime: "05:18",
      rangeStart: "05:16",
      rangeEnd: "05:20",
    },
    technicalReceipt: {
      calculationVersion: "rectification-technical-v1",
      stableLayers: ["D1"],
      sensitiveLayers: ["D9", "D10"],
      candidateDifferenceRefs: ["candidate-05:18"],
    },
    evidenceRequest: null,
    evidenceRecap: [],
    actions: ["continue_original_question"],
    pendingConsultationQuestion: pendingQuestion,
  };
}

function controllerFor(turn: ConversationalRectificationTurn): ConversationalRectificationController {
  const snapshot = {
    turn,
    draft: "",
    selectedDomain: null,
    correctionTarget: null,
    pending: false,
    error: "",
  } as const;
  return {
    ...snapshot,
    getSnapshot: () => snapshot,
    subscribe: () => () => undefined,
    synchronizeInitialTurn: () => undefined,
    setDraft: () => undefined,
    selectDomain: () => undefined,
    beginEvidenceCorrection: () => undefined,
    cancelEvidenceCorrection: () => undefined,
    start: async () => turn,
    resume: async () => turn,
    answer: async () => turn,
    pause: async () => turn,
    abandon: async () => turn,
    confirm: async () => turn,
  };
}

test("confirmed surface requires an explicit click before continuing the original question", () => {
  let continuationCalls = 0;
  const markup = renderToStaticMarkup(React.createElement(
    ConversationalRectificationSurface,
    {
      controller: controllerFor(confirmedTurn()),
      onContinueOriginalQuestion: () => { continuationCalls += 1; },
    },
  ));

  assert.match(markup, /原问题：未来半年是否适合换工作？/);
  assert.match(markup, />使用新确认时间继续回答原问题</);
  assert.equal(continuationCalls, 0);
});

test("continuation action is visibly locked while ordinary consultation is pending", () => {
  const markup = renderToStaticMarkup(React.createElement(
    ConversationalRectificationSurface,
    {
      controller: controllerFor(confirmedTurn()),
      continuationPending: true,
      onContinueOriginalQuestion: () => undefined,
    },
  ));

  assert.match(markup, /<button[^>]+disabled=""[^>]*>正在继续回答原问题…<\/button>/);
});

test("choosing rectify-first captures the visible question and passes it only to v3 start", async () => {
  const coordinator = createRectificationQuestionHandoffCoordinator<"career" | "general">();
  const commands: unknown[] = [];
  const handoff = coordinator.capture({
    question: `  ${pendingQuestion}  `,
    sessionId: "session-original",
    theme: "career",
  });
  const firstTurn: ConversationalRectificationTurn = {
    ...confirmedTurn(),
    status: "active" as const,
    turnVersion: 0,
    candidate: {
      ...confirmedTurn().candidate,
      status: "pending_validation" as const,
    },
    actions: ["answer", "pause", "abandon"],
  };
  const rectification = createConversationalRectificationController({
    async send(command) {
      commands.push(command);
      return firstTurn;
    },
    createActionId: () => "00000000-0000-4000-8000-000000001011",
  });

  await rectification.start(handoff.question);

  assert.deepEqual(commands, [{
    type: "start",
    actionId: "00000000-0000-4000-8000-000000001011",
    pendingConsultationQuestion: pendingQuestion,
  }]);
});

test("pause, refresh, and a new device recover the durable question without losing local session and theme", () => {
  const paused = {
    ...confirmedTurn(),
    status: "paused" as const,
    candidate: {
      ...confirmedTurn().candidate,
      status: "pending_validation" as const,
    },
    actions: ["answer", "abandon"] as const,
  };
  const local = createRectificationQuestionHandoffCoordinator<"career" | "timing">();
  local.capture({ question: pendingQuestion, sessionId: "session-original", theme: "career" });

  assert.deepEqual(local.synchronizeDurableQuestion(
    paused.pendingConsultationQuestion,
    { sessionId: "session-after-refresh", theme: "timing" },
  ), {
    question: pendingQuestion,
    sessionId: "session-original",
    theme: "career",
  });

  const newDevice = createRectificationQuestionHandoffCoordinator<"career" | "timing">();
  assert.deepEqual(newDevice.synchronizeDurableQuestion(
    paused.pendingConsultationQuestion,
    { sessionId: "session-current-device", theme: "timing" },
  ), {
    question: pendingQuestion,
    sessionId: "session-current-device",
    theme: "timing",
  });
});

test("explicit continuation uses the confirmed server profile, original session and theme, and one normal reservation", async () => {
  const coordinator = createRectificationQuestionHandoffCoordinator<"career" | "timing">();
  coordinator.capture({ question: pendingQuestion, sessionId: "session-original", theme: "career" });
  let consultationCalls = 0;
  let reservationCalls = 0;
  let selectedMinute = -1;
  let sentContext: unknown = null;

  const continued = await coordinator.continueOriginalQuestion(
    pendingQuestion,
    { sessionId: "session-fallback", theme: "timing" },
    async (context) => {
      consultationCalls += 1;
      sentContext = context;
      const prepared = await prepareConsultationRoute({
        userId: "synthetic-user",
        mode: "verified_chart",
        loadProfile: async () => ({
          name: "测试用户",
          birth_date: "1990-01-02",
          reported_birth_time: "05:30:00",
          active_birth_time: "05:18:00",
          birth_time_source: "approximate",
          birth_time_status: "confirmed",
          country_code: "CN",
          province_code: "130000",
          city_code: "130400",
          district_code: "130406",
          latitude: 36.420487,
          longitude: 114.209936,
          timezone_offset: 8,
        }),
        reserve: async () => {
          reservationCalls += 1;
          return "reserved";
        },
      });
      selectedMinute = prepared.serverChart?.toolInput.minute ?? -1;
      return true;
    },
  );

  assert.equal(continued, true);
  assert.deepEqual(sentContext, {
    question: pendingQuestion,
    sessionId: "session-original",
    theme: "career",
  });
  assert.equal(selectedMinute, 18);
  assert.equal(consultationCalls, 1);
  assert.equal(reservationCalls, 1);
  assert.equal(coordinator.peek(), null);
});

test("double click shares one in-flight continuation and cannot reserve twice", async () => {
  const coordinator = createRectificationQuestionHandoffCoordinator<"career">();
  coordinator.capture({ question: pendingQuestion, sessionId: "session-original", theme: "career" });
  let release!: (success: boolean) => void;
  const result = new Promise<boolean>((resolve) => { release = resolve; });
  let consultationCalls = 0;
  const send = async () => {
    consultationCalls += 1;
    return result;
  };

  const first = coordinator.continueOriginalQuestion(
    pendingQuestion,
    { sessionId: "session-fallback", theme: "career" },
    send,
  );
  const second = coordinator.continueOriginalQuestion(
    pendingQuestion,
    { sessionId: "session-fallback", theme: "career" },
    send,
  );
  release(true);

  assert.equal(await first, true);
  assert.equal(await second, true);
  assert.equal(consultationCalls, 1);
  assert.equal(await coordinator.continueOriginalQuestion(
    pendingQuestion,
    { sessionId: "session-fallback", theme: "career" },
    send,
  ), false);
  assert.equal(consultationCalls, 1);
});

test("failed continuation keeps the question and can retry once the pending lock releases", async () => {
  const coordinator = createRectificationQuestionHandoffCoordinator<"career">();
  const expected = coordinator.capture({
    question: pendingQuestion,
    sessionId: "session-original",
    theme: "career",
  });
  let attempts = 0;
  const send = async () => {
    attempts += 1;
    return attempts > 1;
  };

  assert.equal(await coordinator.continueOriginalQuestion(
    pendingQuestion,
    { sessionId: "session-fallback", theme: "career" },
    send,
  ), false);
  assert.deepEqual(coordinator.peek(), expected);

  assert.equal(await coordinator.continueOriginalQuestion(
    pendingQuestion,
    { sessionId: "session-fallback", theme: "career" },
    send,
  ), true);
  assert.equal(attempts, 2);
  assert.equal(coordinator.peek(), null);
});

test("returning from rectification restores the composer context without consulting or charging", () => {
  const coordinator = createRectificationQuestionHandoffCoordinator<"career" | "timing">();
  const restored = coordinator.synchronizeDurableQuestion(
    pendingQuestion,
    { sessionId: "session-current", theme: "timing" },
  );
  coordinator.clear();

  assert.deepEqual(restored, {
    question: pendingQuestion,
    sessionId: "session-current",
    theme: "timing",
  });
  assert.equal(coordinator.peek(), null);
});

test("homepage wires the tested handoff coordinator without carrying hidden rectification routing", () => {
  const page = readFileSync(new URL("../src/app/page.tsx", import.meta.url), "utf8");
  const chooseStart = page.indexOf("function rectifyBeforePendingConsultation");
  const chooseEnd = page.indexOf("function cancelPendingBirthTimeChoice", chooseStart);
  const chooseHandler = page.slice(chooseStart, chooseEnd);
  const continuationStart = page.indexOf("async function continueRectificationOriginalQuestion");
  const continuationEnd = page.indexOf("function restoreQuestionFromRectification", continuationStart);
  const continuationHandler = page.slice(continuationStart, continuationEnd);
  const restoreStart = continuationEnd;
  const restoreEnd = page.indexOf("function useUnverifiedTimeForPendingConsultation", restoreStart);
  const restoreHandler = page.slice(restoreStart, restoreEnd);

  assert.match(page, /createRectificationQuestionHandoffCoordinator/);
  assert.match(chooseHandler, /\.capture\(\{[\s\S]*question:\s*pending\.question,[\s\S]*sessionId:\s*pending\.sessionId,[\s\S]*theme:\s*pending\.theme/);
  assert.doesNotMatch(chooseHandler, /\/api\/consult|\bsend\(/);
  assert.match(continuationHandler, /continueOriginalQuestion\(/);
  assert.match(continuationHandler, /send\(context\.question, context\.theme, null, null, context\.sessionId\)/);
  assert.match(continuationHandler, /if \(completed\)[\s\S]*setRectificationSurfaceOpen\(false\)/);
  assert.match(restoreHandler, /setDraft\(handoff\.question\)/);
  assert.match(restoreHandler, /setDraftTheme\(handoff\.theme\)/);
  assert.match(restoreHandler, /setDraftEntrypoint\(null\)/);
  assert.doesNotMatch(restoreHandler, /\/api\/consult|\bsend\(/);
  assert.match(page, /continuationPending=\{rectificationContinuationPending\}/);
  assert.match(page, /onContinueOriginalQuestion=\{\(question\) => void continueRectificationOriginalQuestion\(question\)\}/);
  assert.match(page, /\? "返回并恢复原问题"\s*:\s*"返回首页"/);
});

test("ordinary consult remains strict and bills the confirmed continuation through the normal route", () => {
  const route = readFileSync(new URL("../src/app/api/consult/route.ts", import.meta.url), "utf8");
  const chartSchema = route.slice(
    route.indexOf("const chartChatRequestSchema"),
    route.indexOf("const generalChatRequestSchema"),
  );
  const parse = route.indexOf("chatRequestSchema.safeParse");
  const legacyRejection = route.indexOf('parsed.data.entrypoint === "birth_time_rectification"', parse);
  const prepare = route.indexOf("prepareConsultationRoute({", parse);
  const reserve = route.indexOf("reserveConsultationModel(", prepare);

  assert.match(chartSchema, /consultationInputSchema\.extend\([\s\S]*?\)\.strict\(\);/);
  assert.doesNotMatch(route, /continue_original_question|rectificationHandoff|skipBilling/);
  assert.ok(parse >= 0 && legacyRejection > parse && prepare > legacyRejection && reserve > prepare);
  assert.match(route, /"begin_consultation_credit"/);
  assert.match(route, /"complete_consultation_credit"/);
  assert.match(route, /"cancel_consultation_credit"/);
});