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

import {
  RectificationEngineError,
  mergeVedastroValidateIntoReceipt,
  runV9CandidateScore,
  runV9Diagnostics,
  runV9VedastroValidate,
  toEngineEvents,
  type V9EngineScoreResult,
} from "../src/lib/rectification-agentic/v9/engine-client.ts";

const RANGE = { start_time: "04:50", end_time: "05:10" };
const CANDIDATE_ID = "88888888-8888-4888-8888-888888888881";
const SECOND_CANDIDATE_ID = "88888888-8888-4888-8888-888888888882";
const THIRD_CANDIDATE_ID = "88888888-8888-4888-8888-888888888883";

const DECISION_RECEIPT = {
  receipt_version: "candidate-decision-receipt-v2",
  contract_version: "v2",
  event_contract_version: "rectification-event-contract-v2",
  policy_version: "rectification-candidate-policy-v2",
  decision_policy_version: "rectification-candidate-policy-v2",
  display_allowed: true,
  selection_allowed: true,
  acceptance_allowed: true,
  confirmation_allowed: false,
  accept_allowed: true,
  confirm_allowed: false,
  representative_candidate_id: CANDIDATE_ID,
  representative_time: "04:50",
  overall_confidence: "high",
  margin_percent: 42.5,
};

const EXECUTION_LEDGER = [
  { ledger_version: "rectification-execution-ledger-v2", stage: "technique_layer", method: "d1-rashi", status: "executed", source: "python-engine" },
  { ledger_version: "rectification-execution-ledger-v2", stage: "technique_layer", method: "gochara", status: "executed", source: "python-engine" },
  { ledger_version: "rectification-execution-ledger-v2", stage: "technique_layer", method: "d24-chaturvimshamsha", status: "not_executed", source: "python-engine" },
];

const ENGINE_SCORE_RESPONSE_V2 = {
  success: true,
  endpoint: "rectification_v5_score",
  result_id: "e4fbf2e0-85dc-5b42-a5a3-34e5dd4b7e62",
  algorithm_version: "rectification-event-contract-v2",
  event_contract_version: "rectification-event-contract-v2",
  decision_policy_version: "rectification-candidate-policy-v2",
  execution_ledger_version: "rectification-execution-ledger-v2",
  candidate_decisions: [
    { candidate_id: CANDIDATE_ID, time: "04:50", rank: 1, relative_support: 57, tied_minute_count: 1 },
    { candidate_id: SECOND_CANDIDATE_ID, time: "04:51", rank: 3, relative_support: 18, tied_minute_count: 2 },
    { candidate_id: THIRD_CANDIDATE_ID, time: "04:52", rank: 2, relative_support: 25, tied_minute_count: 2 },
  ],
  decision_receipt: DECISION_RECEIPT,
  execution_ledger: EXECUTION_LEDGER,
  diagnostics: {
    primary_secondary_margin_percent: 99,
    leave_one_event_out_retention_rate: 1,
  },
  candidate_scores: [
    { time: "04:59", score: 999999 },
  ],
};

const ENGINE_DIAGNOSTICS_RESPONSE_V2 = {
  success: true,
  endpoint: "rectification_v5_diagnostics",
  result_id: "e4fbf2e0-85dc-5b42-a5a3-34e5dd4b7e62",
  algorithm_version: "rectification-event-contract-v2",
  event_contract_version: "rectification-event-contract-v2",
  decision_policy_version: "rectification-candidate-policy-v2",
  execution_ledger_version: "rectification-execution-ledger-v2",
  candidate_decisions: ENGINE_SCORE_RESPONSE_V2.candidate_decisions,
  diagnostics: {
    primary_cluster_retention_rate: 0.86,
    leave_one_event_out_retention_rate: 0.81,
    leave_one_domain_out_retention_rate: 0.9,
    date_sensitivity_retention_rate: 0.72,
    neighbor_support_minutes: 2,
    primary_secondary_margin_percent: 42.5,
    unstable_event_ids: [],
    most_discriminating_layers: ["vimsottari_dasha"],
    candidate_splits: [{ candidate_id: SECOND_CANDIDATE_ID, width: 6 }],
  },
  missing_layers: ["KP_cusps"],
  decision_receipt: DECISION_RECEIPT,
  execution_ledger: EXECUTION_LEDGER,
};

function stubEngine(response: unknown, status = 200) {
  const previous = globalThis.fetch;
  globalThis.fetch = (async () => ({
    ok: status >= 200 && status < 300,
    status,
    json: async () => response,
  })) as unknown as typeof fetch;
  return () => {
    globalThis.fetch = previous;
  };
}

const SNAPSHOT = {
  birth_date: "1997-08-08",
  latitude: 36.420487,
  longitude: 114.209936,
  timezone_offset: 8,
  birth_time_source: "family_exact",
};

const EVIDENCE = [
  {
    id: "00000000-0000-4000-8000-000000000001",
    sourceTurnId: "33333333-3333-4333-8333-333333333333",
    subject: "self",
    eventKind: "education_start",
    domain: "education",
    occurredFrom: "2016-09-01",
    occurredTo: "2016-09-30",
    datePrecision: "month",
    summary: "大学入学",
    status: "confirmed",
    supersedesEvidenceId: null,
    createdAt: "2026-08-12T10:00:06.000Z",
    dateSource: "user_quote",
    dateReliability: "month_exact",
    dateCorroboration: "录取通知书",
    dateConflictStatus: "none",
  },
];

test("toEngineEvents preserves Event Contract v2 detailed kind and provenance", () => {
  const events = toEngineEvents(EVIDENCE);
  assert.equal(events.length, 1);
  assert.equal(events[0]!.domain, "education");
  assert.equal(events[0]!.event_kind, "education_start");
  assert.equal(events[0]!.date_start, "2016-09-01");
  assert.equal(events[0]!.precision, "month");
  assert.equal(events[0]!.date_source, "user_quote");
  assert.equal(events[0]!.date_reliability, "month_exact");
  assert.equal(events[0]!.date_corroboration, "录取通知书");
  assert.equal(events[0]!.date_conflict_status, "none");
  assert.equal(events[0]!.source_turn_id, EVIDENCE[0]!.sourceTurnId);
  assert.equal(events[0]!.subject, "self");
});

test("toEngineEvents keeps all scoreable detailed v2 kinds and drops background kinds", () => {
  const detailed = [
    "education_completion",
    "career_entry",
    "promotion",
    "career_pressure",
    "relationship_commitment",
    "relationship_separation",
    "finance_gain",
    "finance_loss",
    "self_health_event",
    "family_event",
  ].map((eventKind, index) => ({
    ...EVIDENCE[0]!,
    id: `00000000-0000-4000-8000-${String(index + 2).padStart(12, "0")}`,
    eventKind,
    domain: eventKind.startsWith("education") ? "education"
      : eventKind.startsWith("career") || eventKind === "promotion" ? "career"
        : eventKind.startsWith("relationship") ? "relationship"
          : eventKind.startsWith("finance") ? "finance"
            : eventKind === "family_event" ? "family"
              : "health",
  }));
  const background = [
    { ...EVIDENCE[0]!, id: "00000000-0000-4000-8000-000000000100", eventKind: "other", domain: "other" },
  ];
  assert.deepEqual(toEngineEvents([...detailed, ...background]).map((event) => event.event_kind), detailed.map((event) => event.eventKind));
  const family = toEngineEvents([{
    ...EVIDENCE[0]!,
    id: "00000000-0000-4000-8000-000000000200",
    eventKind: "family_event",
    domain: "family",
    subject: "self",
  }]);
  assert.equal(family[0]!.subject, "family");
  assert.deepEqual(toEngineEvents([{
    ...EVIDENCE[0]!,
    id: "00000000-0000-4000-8000-000000000201",
    eventKind: "appearance_note",
    domain: "appearance",
    datePrecision: "unknown",
    occurredFrom: null,
    occurredTo: null,
  }]), []);
  const datedAppearance = toEngineEvents([{
    ...EVIDENCE[0]!,
    id: "00000000-0000-4000-8000-000000000202",
    eventKind: "birthmark_or_scar",
    domain: "marks",
    datePrecision: "year",
    occurredFrom: "2010-01-01",
    occurredTo: "2010-12-31",
  }]);
  assert.equal(datedAppearance[0]!.event_kind, "birthmark_or_scar");
  assert.equal(datedAppearance[0]!.domain, "marks");
  const occupation = toEngineEvents([{
    ...EVIDENCE[0]!,
    id: "00000000-0000-4000-8000-000000000203",
    eventKind: "occupation_note",
    domain: "occupation",
    datePrecision: "year",
    occurredFrom: "2019-01-01",
    occurredTo: "2019-12-31",
  }]);
  assert.equal(occupation[0]!.event_kind, "occupation_note");
  assert.equal(occupation[0]!.domain, "occupation");
  const horary = toEngineEvents([{
    ...EVIDENCE[0]!,
    id: "00000000-0000-4000-8000-000000000204",
    eventKind: "horary_query",
    domain: "horary",
    datePrecision: "day",
    occurredFrom: "2024-01-15",
    occurredTo: "2024-01-15",
  }]);
  assert.equal(horary[0]!.event_kind, "horary_query");
  assert.equal(horary[0]!.domain, "horary");
  assert.deepEqual(toEngineEvents([{
    ...EVIDENCE[0]!,
    id: "00000000-0000-4000-8000-000000000205",
    eventKind: "horary_query",
    domain: "horary",
    datePrecision: "unknown",
    occurredFrom: null,
    occurredTo: null,
  }]), []);
});

test("runV9CandidateScore strictly consumes server candidate decisions and v2 receipt", async () => {
  const restore = stubEngine(ENGINE_SCORE_RESPONSE_V2);
  try {
    const result: V9EngineScoreResult = await runV9CandidateScore({
      baselineBirthSnapshot: SNAPSHOT,
      candidateRange: RANGE,
      events: toEngineEvents(EVIDENCE),
    });
    assert.deepEqual(result.candidates, [
      { candidateId: CANDIDATE_ID, time: "04:50", rank: 1, relativeSupport: 57, tiedMinuteCount: 1 },
      { candidateId: SECOND_CANDIDATE_ID, time: "04:51", rank: 3, relativeSupport: 18, tiedMinuteCount: 2 },
      { candidateId: THIRD_CANDIDATE_ID, time: "04:52", rank: 2, relativeSupport: 25, tiedMinuteCount: 2 },
    ], "Web must preserve server rank/support/tie instead of deriving or sorting them");
    assert.equal(result.representativeCandidateId, CANDIDATE_ID);
    assert.equal(result.representativeTime, "04:50");
    assert.equal(result.selectionAllowed, true);
    assert.equal(result.confirmationAllowed, false);
    assert.equal(result.overallConfidence, "high");
    assert.equal(result.policyVersion, "rectification-candidate-policy-v2");
    assert.deepEqual(result.decisionReceipt, DECISION_RECEIPT);
    assert.deepEqual(result.executionLedger, EXECUTION_LEDGER);
    assert.deepEqual(result.executedMethods, ["d1-rashi", "gochara"], "methods come only from executed server ledger entries");
    assert.equal(JSON.stringify(result).includes("999999"), false, "raw internal score must not enter the TS projection");
  } finally {
    restore();
  }
});

test("runV9CandidateScore fails closed without a v2 decision receipt", async () => {
  const missingReceipt = Object.fromEntries(
    Object.entries(ENGINE_SCORE_RESPONSE_V2).filter(([key]) => key !== "decision_receipt"),
  );
  const restore = stubEngine(missingReceipt);
  try {
    await assert.rejects(
      runV9CandidateScore({
        baselineBirthSnapshot: SNAPSHOT,
        candidateRange: RANGE,
        events: toEngineEvents(EVIDENCE),
      }),
      (error: unknown) => error instanceof RectificationEngineError && error.code === "engine_invalid_v2_receipt",
    );
  } finally {
    restore();
  }
});

test("runV9CandidateScore fails closed on invalid server candidate UUIDs", async () => {
  const restore = stubEngine({
    ...ENGINE_SCORE_RESPONSE_V2,
    candidate_decisions: [{ ...ENGINE_SCORE_RESPONSE_V2.candidate_decisions[0], candidate_id: "04:50" }],
  });
  try {
    await assert.rejects(
      runV9CandidateScore({
        baselineBirthSnapshot: SNAPSHOT,
        candidateRange: RANGE,
        events: toEngineEvents(EVIDENCE),
      }),
      (error: unknown) => error instanceof RectificationEngineError && error.code === "engine_invalid_candidate_decisions",
    );
  } finally {
    restore();
  }
});

test("runV9CandidateScore fails closed when no evidence is scoreable", async () => {
  const restore = stubEngine(ENGINE_SCORE_RESPONSE_V2);
  try {
    await assert.rejects(
      runV9CandidateScore({
        baselineBirthSnapshot: SNAPSHOT,
        candidateRange: RANGE,
        events: toEngineEvents([{ ...EVIDENCE[0]!, eventKind: "other", domain: "other" }]),
      }),
      (error: unknown) => error instanceof RectificationEngineError && error.code === "no_scorable_evidence",
    );
  } finally {
    restore();
  }
});

test("runV9Diagnostics maps diagnostics and receipt-owned confirmation", async () => {
  const restore = stubEngine(ENGINE_DIAGNOSTICS_RESPONSE_V2);
  try {
    const result = await runV9Diagnostics({
      baselineBirthSnapshot: SNAPSHOT,
      candidateRange: RANGE,
      events: toEngineEvents(EVIDENCE),
    });
    assert.equal(result.canConfirmExactMinute, false);
    assert.equal(result.missingLayers.join(","), "KP_cusps");
    assert.equal(result.diagnostics.primary_secondary_margin_percent, 42.5);
    assert.deepEqual(result.executedMethods, ["d1-rashi", "gochara"]);
    assert.equal(result.policyVersion, "rectification-candidate-policy-v2");
  } finally {
    restore();
  }
});

test("engine http failures surface as safe engine errors, never raw stack traces", async () => {
  const restore = stubEngine({ error: "invalid event kind" }, 400);
  try {
    await assert.rejects(
      runV9CandidateScore({
        baselineBirthSnapshot: SNAPSHOT,
        candidateRange: RANGE,
        events: toEngineEvents(EVIDENCE),
      }),
      (error: unknown) => error instanceof Error && error.message.includes("invalid event kind"),
    );
  } finally {
    restore();
  }
});

test("vedastro-validate maps pass/fail and never grants unique-minute confirmation", async () => {
  const restore = stubEngine({
    success: true,
    endpoint: "rectification_v5_vedastro_validate",
    status: "pass",
    passed: true,
    can_confirm_exact_minute: false,
    minute_sensitive_validation: { status: "pass", discriminated: true },
    event_validation: {
      status: "pass",
      search_events_primary_supports_local_winner: true,
    },
  });
  try {
    const result = await runV9VedastroValidate({
      baselineBirthSnapshot: SNAPSHOT,
      candidateRange: RANGE,
      events: toEngineEvents(EVIDENCE),
      candidateTimes: ["04:50", "04:51"],
    });
    assert.equal(result.status, "passed");
    assert.equal(result.canConfirmExactMinute, false);
    assert.equal(result.searchEventsSupportsLocalWinner, true);
    const merged = mergeVedastroValidateIntoReceipt(
      { ...DECISION_RECEIPT, gates: { exact_confirmation: { external_validation_status: "passed" } } },
      result,
    );
    const exact = (merged.gates as { exact_confirmation: Record<string, unknown> }).exact_confirmation;
    assert.equal(exact.external_validation_status, "passed");
    assert.equal(
      (exact.vedastro_event_validation as { search_events_primary_supports_local_winner: boolean })
        .search_events_primary_supports_local_winner,
      true,
    );
    assert.equal(merged.confirmation_allowed, false);
  } finally {
    restore();
  }
});

test("vedastro-validate timeout stays not_evaluated and is not described as fail", async () => {
  const previous = globalThis.fetch;
  globalThis.fetch = (async () => {
    throw new Error("timeout");
  }) as unknown as typeof fetch;
  try {
    const result = await runV9VedastroValidate({
      baselineBirthSnapshot: SNAPSHOT,
      candidateRange: RANGE,
      events: toEngineEvents(EVIDENCE),
      candidateTimes: ["04:50", "04:51"],
    });
    assert.equal(result.status, "not_evaluated");
    assert.notEqual(result.status, "failed");
    assert.equal(result.canConfirmExactMinute, false);
  } finally {
    globalThis.fetch = previous;
  }
});