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 { buildSegmentSummary, type SegmentMinute, type TargetChart } from "../src/lib/rectification-agentic/core/segment-summary.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));
const origin = "2000-06-14T23:55";
const at = (offset: number) => new Date(Date.parse(`${origin}:00Z`) + offset * 60000).toISOString().slice(0, 16);

// Fictional SQL algorithm/policy boundary inputs, not calibrated/native chart fixtures.
function boundaryInput(kind: "empty-d1" | "empty-d9" | "clamp" | "gap-tie") {
  const targets: TargetChart[] = kind === "empty-d9" ? ["D10", "D9"] : ["D10", "D9", "D1"];
  const minutes: SegmentMinute[] = Array.from({ length: 21 }, (_, offset) => ({
    offset, time: at(offset).slice(11), date: at(offset).slice(0, 10),
    signs: kind.startsWith("empty") ? {
      D1: offset <= 4 ? 1 : offset % 2 ? 2 : 3,
      D9: offset >= 5 && offset <= 13 ? 4 : offset % 2 ? 5 : 6,
      D10: offset >= 14 ? 7 : offset % 2 ? 8 : 9,
    } : { D1: 1, D9: 2, D10: 3 },
  }));
  const spans = kind.startsWith("empty") ? [[0, 2], [8, 10], [16, 18]] : kind === "clamp" ? [[0, 4]] : [[0, 4], [16, 20]];
  const candidates = spans.map(([start, end], index) => {
    const offset = Math.floor((start! + end!) / 2), stamp = at(offset);
    return { id: stamp.slice(11), time: stamp.slice(11), candidate_date: stamp.slice(0, 10),
      window_index: offset, window_offset_minutes: offset, segment_index: 0,
      rank: index + 1, relative_support: kind.startsWith("empty") ? 50 - index : 50,
      raw_score: kind.startsWith("empty") ? 12 - index : 10, tied_minute_count: end! - start! + 1,
      cluster_times: minutes.slice(start, end! + 1).map(minute => minute.time),
      cluster_intervals: [{ segment_index: 0, start_index: start!, end_index: end!,
        start_offset_minutes: start!, end_offset_minutes: end!, start_at: at(start!), end_at: at(end!) }] };
  });
  const inference = buildInferenceState({ range_start: "23:55", range_end: "00:15", candidates, events: [], probes: [],
    segment_minutes: minutes, segment_targets: targets, segment_scan_complete: true });
  return { targets, minutes, candidates, inference };
}

test("fictional D7 controls cover empty head intersections and nearest earlier gap points without changing chart priority", () => {
  for (const kind of ["empty-d1", "empty-d9", "clamp"] as const) {
    const { inference } = boundaryInput(kind);
    const summary = inference.segment_summary!;
    const heads = summary.charts.map(chart => chart.segments[chart.top_segment!]!);
    if (kind.startsWith("empty")) assert.ok(Math.max(...heads.map(head => head.start)) > Math.min(...heads.map(head => head.end)));
    assert.equal(summary.adoption_minute?.offset, kind === "empty-d1" ? 2 : kind === "empty-d9" ? 9 : 4);
  }
  const { targets, minutes, candidates } = boundaryInput("gap-tie");
  const summary = buildSegmentSummary({ targets, minutes, windowMinutes: 21, scanComplete: true,
    deliveredOffsets: [[0, 4], [16, 20]], candidates: candidates.map(candidate => ({ ...candidate, score: candidate.raw_score })) });
  assert.equal(summary.adoption_minute?.offset, 4, "equal distances to midpoint 10 choose earlier delivered point 4, never the gap");
});

test("D7 PostgreSQL recomputes priority, clamp and gap tie and rolls back stale or malformed segment adoption", { skip: !docker && "docker unavailable" }, async () => {
  const fixture = startPostgresFixture();
  const url = fixture.connectionUrl("service_runtime", "service-runtime-test-password");
  try {
    const migrated = spawnSync(process.execPath, [runner], { encoding: "utf8", env: {
      ...process.env, SCHEMA_DATABASE_URL: fixture.connectionUrl("schema_owner", "schema-owner-test-password"),
    } });
    assert.equal(migrated.status, 0, migrated.stderr);
    const service = createLocalPostgresDataClient(url, null, "service_role");
    const seed = async (kind: Parameters<typeof boundaryInput>[0]) => {
      const userId = randomUUID(), sessionId = randomUUID(), caseId = randomUUID();
      const { candidates, inference, minutes, targets } = boundaryInput(kind);
      const snapshot = { birth_date: "2000-06-14", reported_birth_time: "23:59", active_birth_time: null,
        birth_time_source: "family_exact", birth_time_period: null, uncertainty_before_minutes: 15, uncertainty_after_minutes: 15,
        latitude: 40, longitude: -74, timezone_id: null, timezone_offset: -4 };
      const intervals = [{ start_at: origin, end_at: at(20) }];
      const range = { start_time: "23:55", end_time: "00:15", candidate_intervals: intervals };
      fixture.psqlAs("identity_runtime", "identity-runtime-test-password", `insert into identity.users(id,name,email,email_verified)
        values('${userId}','Fictional D7 Boundary','${userId}@example.invalid',true)`);
      fixture.psql(`update public.profiles set birth_date='2000-06-14',reported_birth_time='23:59',birth_time_source='family_exact',birth_time_status='reported',
          uncertainty_before_minutes=15,uncertainty_after_minutes=15,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}','Fictional D7 boundary','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 persisted = await service.rpc("persist_agentic_rectification_candidate_v2", {
        p_user_id: userId, p_case_id: caseId, p_engine_result_id: "fictional-d7-policy",
        p_evidence_ledger_fingerprint: "b".repeat(64), p_candidate_range_fingerprint: "c".repeat(64),
        p_skill_version: "9.0.0", p_algorithm_version: "fictional-d7-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: inference.representative_time, overall_confidence: "low", margin_percent: 1,
          candidate_window_contract: "dated-v1", candidate_intervals: intervals, candidate_timezone_offset: -4,
          candidate_timezone_id: null, inference_state: inference },
        p_execution_ledger: [{ phase: "candidate.score", status: "completed", engine: "fictional-d7-policy" }],
      });
      assert.equal(persisted.error, null, JSON.stringify(persisted.error));
      const result = persisted.data as { result_id: string; candidates: { time: string; candidate_id: string }[] };
      const anchor = result.candidates.find(candidate => candidate.time === inference.representative_time)!;
      const accept = (owner = userId) => service.rpc("accept_agentic_rectification_segment_for_case_v1", {
        p_user_id: owner, p_case_id: caseId, p_result_id: result.result_id, p_candidate_id: anchor.candidate_id, p_request_id: randomUUID(),
      });
      const stateSnapshot = () => 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='${result.result_id}'),
        'decisions',(select jsonb_agg(to_jsonb(d) order by created_at,id) from public.agentic_rectification_candidate_decisions d where case_id='${caseId}'))`);
      return { userId, caseId, result, accept, stateSnapshot, inference, minutes, targets, candidates };
    };
    for (const kind of ["empty-d1", "empty-d9", "clamp"] as const) {
      const row = await seed(kind);
      const saved = await row.accept();
      assert.equal(saved.error, null, JSON.stringify(saved.error));
      assert.equal((saved.data as Record<string, unknown>).saved_time, row.inference.segment_summary!.adoption_minute!.time);
      assert.equal((saved.data as Record<string, unknown>).saved_date, row.inference.segment_summary!.adoption_minute!.date);
    }
    // Internal algorithm-only SQL control: a gap is not a lawful dated-v1 adoption
    // envelope. The public RPC below must still reject the fictional disjoint ledger.
    const gap = await seed("gap-tie");
    const gapState = { ...structuredClone(gap.inference),
      credible_intervals: gap.candidates.flatMap(candidate => candidate.cluster_intervals), credible_range: null,
      segment_summary: buildSegmentSummary({ targets: gap.targets, minutes: gap.minutes, windowMinutes: 21,
        scanComplete: true, deliveredOffsets: [[0, 4], [16, 20]],
        candidates: gap.candidates.map(candidate => ({ ...candidate, score: candidate.raw_score })) }),
    };
    const computed = JSON.parse(fixture.psql(`select public.rectification_segment_adoption_minute(c,r,'${JSON.stringify(gapState)}'::jsonb)
      from public.agentic_rectification_cases c join public.agentic_rectification_results r on r.case_id=c.id where r.id='${gap.result.result_id}'`));
    assert.equal(computed.offset, 4);
    fixture.psql(`update public.agentic_rectification_results set decision_receipt=jsonb_set(decision_receipt,'{inference_state}','${JSON.stringify(gapState)}') where id='${gap.result.result_id}'`);
    const gapBefore = gap.stateSnapshot();
    assert.equal((await gap.accept()).error?.message, "agentic_rectification_candidate_state_inconsistent");
    assert.equal(gap.stateSnapshot(), gapBefore, "dated gate is not bypassed to claim a legal gap adoption");
    for (const mutation of ["owner", "malformed", "expired", "newer", "manual", "timezone", "confirmed"] as const) {
      const row = await seed("clamp");
      if (mutation === "manual" || mutation === "timezone" || mutation === "confirmed") {
        assert.equal((await row.accept()).error, null, "fresh accepted identity precedes retry mutation");
      }
      if (mutation === "malformed") {
        const broken = structuredClone(row.inference);
        (broken.segment_minutes![5] as { date: string }).date = "2000-06-14";
        fixture.psql(`update public.agentic_rectification_results set decision_receipt=jsonb_set(decision_receipt,'{inference_state}','${JSON.stringify(broken)}') where id='${row.result.result_id}'`);
      } else if (mutation === "expired") fixture.psql(`update public.agentic_rectification_results set expires_at=now()-interval '1 second' where id='${row.result.result_id}'`);
      else if (mutation === "newer") fixture.psql(`insert into public.agentic_rectification_results(
          user_id,session_id,case_id,engine_result_id,canonical_input_hash,skill_version,algorithm_version,
          evidence_ledger_fingerprint,candidate_range_fingerprint,candidate_range,candidates,overall_confidence,
          baseline_birth_date,baseline_latitude,baseline_longitude,baseline_timezone_offset,created_at)
        select user_id,session_id,case_id,'fictional-newer',canonical_input_hash,skill_version,algorithm_version,
          evidence_ledger_fingerprint,candidate_range_fingerprint,candidate_range,candidates,overall_confidence,
          baseline_birth_date,baseline_latitude,baseline_longitude,baseline_timezone_offset,now()+interval '1 second'
          from public.agentic_rectification_results where id='${row.result.result_id}'`);
      else if (mutation === "manual") fixture.psql(`update public.profiles set active_birth_time='00:12' where id='${row.userId}'`);
      else if (mutation === "timezone") fixture.psql(`update public.profiles set timezone_offset=-5 where id='${row.userId}'`);
      else if (mutation === "confirmed") {
        // State-boundary corruption control, not a substitute for the old lawful confirmation positive.
        fixture.psql(`update public.profiles set birth_time_status='confirmed' where id='${row.userId}';
          update public.agentic_rectification_cases set status='confirmed',completed_at=now() where id='${row.caseId}'`);
      }
      const before = row.stateSnapshot();
      assert.ok((await row.accept(mutation === "owner" ? randomUUID() : row.userId)).error, mutation);
      assert.equal(row.stateSnapshot(), before, `${mutation} rejection leaves all four tables unchanged`);
    }
  } finally {
    await closeLocalPostgresDataPool(url);
    fixture.stop();
  }
});