import assert from "node:assert/strict";
import { randomUUID } from "node:crypto";
import { spawnSync } from "node:child_process";
import { fileURLToPath } from "node:url";
import test from "node:test";
import { closeLocalPostgresDataPool, createLocalPostgresDataClient } from "../src/lib/db/local-postgres-client-core.ts";
import { buildInferenceState } from "../src/lib/rectification-agentic/core/build-state.ts";
import { loadV9CaseDossier } from "../src/lib/rectification-agentic/v9/tool-service.ts";
import { startPostgresFixture } from "./helpers/postgres-fixture.ts";

const docker = spawnSync("docker", ["version"], { stdio: "ignore" }).status === 0;
const runner = fileURLToPath(new URL("../scripts/db-migrate.mjs", import.meta.url));

// Explicitly fictional legacy permission fixture, not a calibrated engine golden.
test("legacy clock-only segment new-request retry is read-only and preserves every frozen freshness gate", { skip: !docker && "docker unavailable" }, async () => {
  const fixture = startPostgresFixture();
  const url = fixture.connectionUrl("service_runtime", "service-runtime-test-password");
  try {
    const migration = spawnSync(process.execPath, [runner], { encoding: "utf8", env: {
      ...process.env, SCHEMA_DATABASE_URL: fixture.connectionUrl("schema_owner", "schema-owner-test-password"),
    } });
    assert.equal(migration.status, 0, migration.stderr);
    const userId = randomUUID(), sessionId = randomUUID(), caseId = randomUUID();
    const snapshot = { birth_date: "2000-06-14", reported_birth_time: "09:10", active_birth_time: null,
      birth_time_source: "family_exact", birth_time_period: null, uncertainty_before_minutes: 10, uncertainty_after_minutes: 10,
      latitude: 40, longitude: -74, timezone_id: null, timezone_offset: -4 };
    const range = { start_time: "09:00", end_time: "09:20" };
    const candidates = ["09:00", "09:20"].map((time, i) => ({ id: time, time, rank: i + 1,
      relative_support: 50, raw_score: 10, tied_minute_count: 1, cluster_times: [time] }));
    const minutes = Array.from({ length: 21 }, (_, offset) => ({ offset, date: "2000-06-14",
      time: `09:${String(offset).padStart(2, "0")}`, signs: { D1: 1 } }));
    const state = buildInferenceState({ range_start: range.start_time, range_end: range.end_time, candidates,
      events: [], probes: [], segment_minutes: minutes, segment_targets: ["D1"], segment_scan_complete: true });
    assert.equal(state.segment_summary?.adoption_minute?.time, "09:10");
    fixture.psqlAs("identity_runtime", "identity-runtime-test-password", `insert into identity.users(id,name,email,email_verified)
      values('${userId}','Synthetic Legacy Segment','${userId}@example.invalid',true)`);
    fixture.psql(`update public.profiles set birth_date='2000-06-14',reported_birth_time='09:10',birth_time_source='family_exact',birth_time_status='reported',
      uncertainty_before_minutes=10,uncertainty_after_minutes=10,latitude=40,longitude=-74,timezone_id=null,timezone_offset=-4 where id='${userId}';
      insert into public.chat_sessions(id,user_id,title,theme,session_type,messages)
        values('${sessionId}','${userId}','Synthetic legacy segment','general','birth_time_rectification','[]');
      insert into public.agentic_rectification_cases(id,user_id,session_id,status,skill_name,skill_version,baseline_profile_fingerprint,baseline_birth_snapshot,candidate_range)
        values('${caseId}','${userId}','${sessionId}','candidate_ready','jyotish-birth-time-rectification','9.0.0','${"a".repeat(64)}','${JSON.stringify(snapshot)}','${JSON.stringify(range)}')`);
    const service = createLocalPostgresDataClient(url, null, "service_role");
    const persisted = await service.rpc("persist_agentic_rectification_candidate_v2", {
      p_user_id: userId, p_case_id: caseId, p_engine_result_id: "synthetic-legacy-segment",
      p_evidence_ledger_fingerprint: "b".repeat(64), p_candidate_range_fingerprint: "c".repeat(64),
      p_skill_version: "9.0.0", p_algorithm_version: "synthetic-legacy-v1", p_event_contract_version: "rectification-event-contract-v2",
      p_decision_policy_version: "rectification-candidate-policy-v2", p_candidate_range: range, p_candidates: candidates,
      p_decision_receipt: { display_allowed: true, accept_allowed: true, confirm_allowed: false,
        representative_time: "09:00", overall_confidence: "low", margin_percent: 1, inference_state: state },
      p_execution_ledger: [{ phase: "candidate.score", status: "completed", engine: "synthetic-legacy" }],
    });
    assert.equal(persisted.error, null, JSON.stringify(persisted.error));
    const row = persisted.data as { result_id: string; candidates: { time: string; candidate_id: string }[] };
    const candidateId = row.candidates.find(candidate => candidate.time === "09:00")!.candidate_id;
    const accept = (requestId = randomUUID()) => service.rpc("accept_agentic_rectification_segment_for_case_v1", {
      p_user_id: userId, p_case_id: caseId, p_result_id: row.result_id, p_candidate_id: candidateId, p_request_id: requestId,
    });
    const requestId = randomUUID();
    const adopted = await accept(requestId);
    assert.equal(adopted.error, null, JSON.stringify(adopted.error));
    assert.equal((adopted.data as Record<string, unknown>).saved_time, "09:10");
    const reloaded = await loadV9CaseDossier(service as never, userId, caseId);
    assert.equal(reloaded.latestResult?.legacyCandidateDate, "2000-06-14",
      "legacy civil proof comes from the persisted compute baseline, not candidate metadata");
    assert.equal(reloaded.latestResult?.segmentSelection?.time, "09:10");
    assert.ok(reloaded.latestResult?.candidates.every(candidate => candidate.candidate_date === undefined));
    const identitySnapshot = () => fixture.psql(`select jsonb_build_object(
      'profile',(select to_jsonb(p) from public.profiles p where id='${userId}'),
      'case',(select to_jsonb(c) from public.agentic_rectification_cases c where id='${caseId}'),
      'result',(select to_jsonb(r) from public.agentic_rectification_results r where id='${row.result_id}'))`);
    const beforeRetry = identitySnapshot();
    const retry = await accept();
    assert.equal(retry.error, null, JSON.stringify(retry.error));
    assert.deepEqual(retry.data, { ...(adopted.data as object), idempotent: true });
    assert.equal(identitySnapshot(), beforeRetry, "selected_at, adopted_at, profile provenance and all update timestamps are unchanged");
    assert.equal(fixture.psql(`select count(*) from public.agentic_rectification_candidate_decisions where case_id='${caseId}'`), "2");
    // Corrupt only the server ledger to verify read-only retry does not bypass active/credible consistency.
    for (const patch of [
      { ...state, representative_time: "09:20" },
      { ...state, credible_range: ["09:01", "09:19"] },
      { ...state, candidates: state.candidates.map(candidate => candidate.time === "09:00" ? { ...candidate, status: "eliminated" } : candidate) },
    ]) {
      fixture.psql(`update public.agentic_rectification_results set decision_receipt=jsonb_set(decision_receipt,'{inference_state}','${JSON.stringify(patch)}') where id='${row.result_id}'`);
      const before = identitySnapshot();
      assert.ok((await accept()).error);
      assert.equal(identitySnapshot(), before, "inconsistent retry never bounces to candidate minute");
    }
    fixture.psql(`update public.agentic_rectification_results set decision_receipt=jsonb_set(decision_receipt,'{inference_state}','${JSON.stringify(state)}') where id='${row.result_id}'`);
    fixture.psql(`update public.profiles set active_birth_time='09:11' where id='${userId}'`);
    const manual = identitySnapshot();
    assert.equal((await accept()).error?.message, "agentic_rectification_candidate_selection_blocked");
    assert.equal(identitySnapshot(), manual);
    assert.equal((await accept(requestId)).error, null, "old request remains its original receipt, never a fresh write");
    assert.equal(identitySnapshot(), manual);
    assert.equal((await service.rpc("get_agentic_rectification_segment_selection_v1", {
      p_user_id: userId, p_case_id: caseId, p_result_id: row.result_id,
    })).data, null);
  } finally {
    await closeLocalPostgresDataPool(url);
    fixture.stop();
  }
});