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 { parseSegmentMinutes } from "../src/lib/rectification-agentic/v9/segment-contract.ts";
import { loadV9CaseDossier } from "../src/lib/rectification-agentic/v9/tool-service.ts";
import { ACCOUNT_BIRTH_SELECT, globalBirthProfileFromAccountRow } from "../src/lib/server-owned-birth-profile.ts";
import { buildLongformBirthPayload } from "../src/lib/personal-report-longform-birth.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));

/** Real native computations on fictional birth data; no invented engine response or model interpretation. */
function nativeCalculation(input: Record<string, unknown>): Record<string, unknown> {
  const script = [
    "import json, sys, tempfile",
    "from pathlib import Path",
    "sys.path.insert(0, str(Path.cwd() / 'scripts'))",
    "from scripts.domain_calculation_service import compute_chart",
    "from scripts.rectification_varga_segments_api import scan_varga_segments",
    "from scripts import varga",
    "body = json.load(sys.stdin)",
    "if 'start_at' in body:",
    "    with tempfile.TemporaryDirectory() as tmp:",
    "        result = scan_varga_segments(body, cache_dir=Path(tmp))",
    "else:",
    "    chart = compute_chart(body)",
    "    asc = chart['ascendant']['lon']",
    "    planets = {key: value['lon'] for key, value in chart['planets'].items()}",
    "    signs = {'D1': int(asc // 30) % 12}",
    "    for row in varga.calc_all_vargas(planets, asc, divisions=[9, 10]).values():",
    "        signs['D' + str(row['_meta']['div'])] = int(row['Ascendant']['sign_idx'])",
    "    effective = chart['calculation_contract']['effective']",
    "    result = {'signs': signs, 'ayanamsa': effective['ayanamsa'], 'node_mode': effective['node_mode']}",
    "sys.stdout.write(json.dumps(result))",
  ].join("\n");
  const result = spawnSync(process.env.PYTHON ?? (process.platform === "win32" ? "python" : "python3"), ["-c", script], {
    cwd: fileURLToPath(new URL("../../", import.meta.url)), encoding: "utf8", input: JSON.stringify(input),
    maxBuffer: 16 * 1024 * 1024, env: { ...process.env, PYTHONIOENCODING: "utf-8", PYTHONDONTWRITEBYTECODE: "1" },
  });
  assert.equal(result.status, 0, `${result.error ?? ""}\n${result.stderr}`);
  return JSON.parse(result.stdout);
}

function nativeInference(scan: Record<string, unknown>) {
  const minutes = parseSegmentMinutes(scan.minutes);
  assert.ok(minutes);
  // Synthetic weights/gates isolate the saved-tuple contract, not calibration or real engine eligibility.
  // The scan and post-save chart are both genuine native outputs, not hand-authored signs.
  const candidates = [0, 16].map((offset, index) => {
    const minute = minutes[offset]!;
    const start = index ? 12 : 0, end = index ? 19 : 0;
    const first = minutes[start]!, last = minutes[end]!;
    return { id: minute.time, time: minute.time, candidate_date: minute.date, window_index: offset,
      window_offset_minutes: offset, segment_index: 0, rank: index ? 1 : 2, relative_support: index ? 90 : 10,
      raw_score: index ? 10 : 1, tied_minute_count: end - start + 1,
      cluster_times: minutes.slice(start, end + 1).map(member => member.time),
      cluster_intervals: [{ segment_index: 0, start_index: start, end_index: end,
        start_offset_minutes: start, end_offset_minutes: end, start_at: `${first.date}T${first.time}`, end_at: `${last.date}T${last.time}` }] };
  });
  const inference = buildInferenceState({ range_start: "23:55", range_end: "00:25",
    candidates, events: [], probes: [], segment_minutes: minutes, segment_targets: ["D1", "D9", "D10"], segment_scan_complete: true });
  return { minutes, candidates, inference };
}

test("fictional cross-midnight native scan and direct chart share the effective Raman/mean contract", () => {
  const scan = nativeCalculation({ start_at: "2000-06-14T23:55", end_at: "2000-06-15T00:25",
    latitude: 40, longitude: -74, timezone_offset: -4, target_charts: ["D1", "D9", "D10"] });
  const minutes = parseSegmentMinutes(scan.minutes);
  assert.ok(minutes);
  assert.equal(minutes.length, 31);
  const selected = minutes[14]!;
  const actual = nativeCalculation({ year: 2000, month: 6, day: 15, hour: 0, minute: 9,
    lat: 40, lon: -74, tz: -4, ayanamsa: "raman" });
  assert.equal(selected.time, "00:09");
  assert.deepEqual(actual.signs, selected.signs);
  assert.equal(actual.ayanamsa, scan.ayanamsa);
  assert.equal(actual.node_mode, scan.node_mode);
  const { inference, candidates } = nativeInference(scan);
  const adoption = inference.segment_summary?.adoption_minute;
  assert.ok(adoption);
  assert.equal(adoption.offset, 14);
  assert.equal(adoption.date, "2000-06-15");
  assert.equal(adoption.time, "00:09");
  assert.equal(candidates.some(candidate => candidate.time === adoption.time), false);
  assert.deepEqual(actual.signs, adoption.signs);
  for (const chart of inference.segment_summary!.charts) assert.equal((actual.signs as Record<string, number>)[chart.chart], chart.sign);
  // This checks native plumbing only; the separate PostgreSQL tests own the saved-profile chain.
});

for (const timezoneId of ["America/New_York", null]) {
  test(`saved segment civil tuple flows through the production longform payload to actual native signs${timezoneId === null ? " (offset-only)" : ""}`, { 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: "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: timezoneId, timezone_offset: -4 };
      const intervals = [{ start_at: "2000-06-14T23:55", end_at: "2000-06-15T00:25" }];
      const range = { start_time: "23:55", end_time: "00:25", candidate_intervals: intervals };
      const scan = nativeCalculation({ start_at: intervals[0].start_at, end_at: intervals[0].end_at,
        latitude: snapshot.latitude, longitude: snapshot.longitude, timezone_offset: snapshot.timezone_offset,
        target_charts: ["D1", "D9", "D10"] });
      const { candidates, inference } = nativeInference(scan);
      assert.equal(scan.ayanamsa, "raman");
      assert.equal(scan.node_mode, "mean");
      const adoption = inference.segment_summary?.adoption_minute;
      assert.ok(adoption);
      assert.equal(adoption.date, "2000-06-15");
      assert.equal(candidates.some(candidate => candidate.time === adoption.time), false, "saved minute is not a representative candidate");
      fixture.psqlAs("identity_runtime", "identity-runtime-test-password", `insert into identity.users(id,name,email,email_verified)
        values('${userId}','Fictional Saved Native Fixture','${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=${timezoneId ? `'${timezoneId}'` : "null"},timezone_offset=-4 where id='${userId}';
        insert into public.chat_sessions(id,user_id,title,theme,session_type,messages)
          values('${sessionId}','${userId}','Fictional saved native','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: "fictional-saved-native-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-policy-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: "00:11", overall_confidence: "low", margin_percent: 1,
          candidate_window_contract: "dated-v1", candidate_intervals: intervals, candidate_timezone_offset: -4,
          candidate_timezone_id: timezoneId, inference_state: inference },
        p_execution_ledger: [{ phase: "candidate.score", status: "completed", engine: "fictional-policy-native-scan" }],
      });
      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);
      assert.ok(anchor);
      const accepted = await service.rpc("accept_agentic_rectification_segment_for_case_v1", {
        p_user_id: userId, p_case_id: caseId, p_result_id: result.result_id, p_candidate_id: anchor.candidate_id, p_request_id: randomUUID(),
      });
      assert.equal(accepted.error, null, JSON.stringify(accepted.error));
      const saved = accepted.data as Record<string, unknown>;
      assert.equal(saved.saved_date, adoption.date);
      assert.equal(saved.saved_time, adoption.time);
      const loaded = await service.from("profiles").select(ACCOUNT_BIRTH_SELECT).eq("id", userId).single();
      assert.equal(loaded.error, null, JSON.stringify(loaded.error));
      assert.ok(loaded.data);
      const stored = loaded.data as Record<string, unknown>;
      const provenance = stored.active_birth_provenance as Record<string, unknown>;
      assert.equal(stored.birth_date, snapshot.birth_date, "declared date is preserved");
      assert.equal(stored.timezone_id, timezoneId);
      assert.equal(Number(stored.active_birth_timezone_offset), -4);
      assert.equal(provenance.contract, "segment-v1");
      assert.equal(provenance.candidate_date, adoption.date);
      assert.equal(provenance.candidate_time, adoption.time);
      assert.equal(Number(provenance.timezone_offset), -4);
      assert.equal(provenance.timezone_id, timezoneId);
      for (const sql of [
        `select to_char(selected_time,'HH24:MI') from public.agentic_rectification_results where id='${result.result_id}'`,
        `select to_char(accepted_time,'HH24:MI') from public.agentic_rectification_cases where id='${caseId}'`,
        `select response->>'saved_time' from public.agentic_rectification_candidate_decisions where result_id='${result.result_id}'`,
      ]) assert.equal(fixture.psql(sql), adoption.time);
      assert.equal(fixture.psql(`select adopted_credible_range->>'representative_date' from public.agentic_rectification_cases where id='${caseId}'`), adoption.date);
      assert.equal(fixture.psql(`select response->>'saved_date' from public.agentic_rectification_candidate_decisions where result_id='${result.result_id}'`), adoption.date);
      const selected = await service.rpc("get_agentic_rectification_segment_selection_v1", {
        p_user_id: userId, p_case_id: caseId, p_result_id: result.result_id,
      });
      assert.equal(selected.error, null);
      assert.deepEqual(selected.data, { result_id: result.result_id, candidate_id: anchor.candidate_id,
        date: adoption.date, time: adoption.time, contract: "segment-v1" });
      assert.equal(stored.active_birth_date, adoption.date);
      assert.equal(String(stored.active_birth_time).slice(0, 5), adoption.time);
      const profile = globalBirthProfileFromAccountRow(loaded.data);
      assert.equal(profile.date, saved.saved_date);
      assert.equal(profile.time, saved.saved_time);
      assert.equal(profile.birthTimeStatus, "accepted");
      const payload = buildLongformBirthPayload(loaded.data, { today: "2026-09-30", targetYear: 2026,
        candidateRange: range, birthTimeAccuracy: "provisional" });
      assert.ok(payload);
      assert.deepEqual([payload.year, payload.month, payload.day, payload.hour, payload.minute, payload.tz],
        [2000, 6, 15, Number(adoption.time.slice(0, 2)), Number(adoption.time.slice(3)), -4]);
      assert.equal(payload.birth_time_accuracy, "provisional");
      const recalculated = nativeCalculation(payload);
      assert.equal(recalculated.ayanamsa, "raman");
      assert.equal(recalculated.node_mode, "mean");
      assert.deepEqual(recalculated.signs, adoption.signs);
      for (const chart of inference.segment_summary!.charts) assert.equal((recalculated.signs as Record<string, number>)[chart.chart], chart.sign);
      const dossier = await loadV9CaseDossier(service, userId, caseId);
      assert.equal(dossier.latestResult?.segmentSelection?.date, saved.saved_date);
      assert.equal(dossier.latestResult?.segmentSelection?.time, saved.saved_time);
      assert.notEqual(dossier.latestResult?.representativeTime, saved.saved_time, "representative signature remains diagnostic, not the report input");
    } finally {
      await closeLocalPostgresDataPool(url);
      fixture.stop();
    }
  });
}