/**
 * FU-054 R3 Segmentation — Verification Script (multi-seam edition)
 *
 * Verifies the N-seam → (N+1)-segment audit-tamper drill.
 * With two registered seams (ID 76 + ID 161), expects three segments:
 *   segments[0]: rows 1-75        (pre-seam-76)
 *   seams[0]:    ID 76            (FU-024 break, documented)
 *   segments[1]: rows 77-160      (between seam-76 and seam-161)
 *   seams[1]:    ID 161           (FU-024 break, documented)
 *   segments[2]: rows 162-present (LIVE segment — tamper test runs here)
 *
 * Checks (11):
 *   1.  overall passed=true
 *   2.  segments[] length = 3 (N+1 = 2+1)
 *   3.  segments[0].valid=true  (pre-seam-76)
 *   4.  segments[1].valid=true  (between seams)
 *   5.  segments[2].valid=true  (live segment)
 *   6.  seams[] length = 2
 *   7.  seams[0]: id=76, matchesExpected=false (break documented)
 *   8.  seams[1]: id=161, matchesExpected=false (break documented)
 *   9.  knownDiscontinuities.length=2, both architectSignoffDates set (YYYY-MM-DD)
 *   10. unregisteredDiscontinuities empty
 *   11. tamperDetected=true (live-segment mutation caught)
 *
 * Architect PASSes:
 *   - Original R3 single-seam design: 2026-06-09
 *   - Multi-seam extension + FU-058 (ID 161): 2026-06-09
 */

import { runAuditChainTamperDrill } from "../server/lib/regulator-pilot-tier-a";

async function main() {
  console.log("=== FU-054 R3 Multi-Seam Verification (two seams → three segments) ===\n");

  let result: Awaited<ReturnType<typeof runAuditChainTamperDrill>>;
  try {
    result = await runAuditChainTamperDrill({ triggeredBy: "FU054-R3-MULTISEAM-VERIFY" });
  } catch (err) {
    console.error("FAIL — runAuditChainTamperDrill threw:", err);
    process.exit(1);
  }

  const checks: Array<{ name: string; pass: boolean; detail: string }> = [];
  const r = result as any;

  // Check 1: overall passed
  checks.push({
    name: "overall passed=true",
    pass: r.passed === true,
    detail: `passed=${r.passed}`,
  });

  // Check 2: segments array length = 3
  const segs = r.segments ?? [];
  checks.push({
    name: "segments[].length = 3 (two seams → three segments)",
    pass: segs.length === 3,
    detail: `segments.length=${segs.length}`,
  });

  // Check 3: segments[0] valid (rows before ID 76)
  checks.push({
    name: "segments[0].valid=true (pre-seam-76, rows 1–75)",
    pass: segs[0]?.valid === true,
    detail: segs[0]
      ? `valid=${segs[0].valid}, entryCount=${segs[0].entryCount}, fromId=${segs[0].fromId}, toId=${segs[0].toId}, newBreakAt=${segs[0].newBreakAt}`
      : "segments[0] absent",
  });

  // Check 4: segments[1] valid (rows 77-160 between the two seams)
  checks.push({
    name: "segments[1].valid=true (between seam-76 and seam-161)",
    pass: segs[1]?.valid === true,
    detail: segs[1]
      ? `valid=${segs[1].valid}, entryCount=${segs[1].entryCount}, fromId=${segs[1].fromId}, toId=${segs[1].toId}, newBreakAt=${segs[1].newBreakAt}`
      : "segments[1] absent",
  });

  // Check 5: segments[2] valid (live segment, rows 162+)
  checks.push({
    name: "segments[2].valid=true (live segment, rows 162+)",
    pass: segs[2]?.valid === true,
    detail: segs[2]
      ? `valid=${segs[2].valid}, entryCount=${segs[2].entryCount}, fromId=${segs[2].fromId}, toId=${segs[2].toId}, newBreakAt=${segs[2].newBreakAt}`
      : "segments[2] absent",
  });

  // Check 6: seams array length = 2
  const seams = r.seams ?? [];
  checks.push({
    name: "seams[].length = 2 (two registered seams)",
    pass: seams.length === 2,
    detail: `seams.length=${seams.length}`,
  });

  // Check 7: seams[0] — ID 76, matchesExpected=false
  const seam0 = seams[0];
  checks.push({
    name: "seams[0]: id=76, matchesExpected=false (FU-054 break documented)",
    pass: seam0?.id === 76 && seam0?.matchesExpected === false,
    detail: seam0
      ? `id=${seam0.id}, matchesExpected=${seam0.matchesExpected}, fuReference=${seam0.fuReference}, observedPrevHash=${String(seam0.observedPrevHash).slice(0, 12)}..., expected=${String(seam0.expectedPrevHashFromPrecedingSegmentEnd).slice(0, 12)}...`
      : "seams[0] absent",
  });

  // Check 8: seams[1] — ID 161, matchesExpected=false
  const seam1 = seams[1];
  checks.push({
    name: "seams[1]: id=161, matchesExpected=false (FU-058 break documented)",
    pass: seam1?.id === 161 && seam1?.matchesExpected === false,
    detail: seam1
      ? `id=${seam1.id}, matchesExpected=${seam1.matchesExpected}, fuReference=${seam1.fuReference}, observedPrevHash=${String(seam1.observedPrevHash).slice(0, 12)}..., expected=${String(seam1.expectedPrevHashFromPrecedingSegmentEnd).slice(0, 12)}...`
      : "seams[1] absent",
  });

  // Check 9: knownDiscontinuities — 2 entries, both with valid architectSignoffDates
  const kd = r.knownDiscontinuities ?? [];
  const kd0SignoffValid = /^\d{4}-\d{2}-\d{2}$/.test(kd[0]?.architectSignoffDate ?? "");
  const kd1SignoffValid = /^\d{4}-\d{2}-\d{2}$/.test(kd[1]?.architectSignoffDate ?? "");
  checks.push({
    name: "knownDiscontinuities.length=2, both architectSignoffDates valid (YYYY-MM-DD)",
    pass: kd.length === 2 && kd0SignoffValid && kd1SignoffValid,
    detail: `length=${kd.length}, kd[0].atId=${kd[0]?.atId} signoff="${kd[0]?.architectSignoffDate}" (${kd0SignoffValid ? "valid" : "INVALID"}), kd[1].atId=${kd[1]?.atId} signoff="${kd[1]?.architectSignoffDate}" (${kd1SignoffValid ? "valid" : "INVALID"})`,
  });

  // Check 10: unregisteredDiscontinuities empty
  const ud = r.unregisteredDiscontinuities ?? [];
  checks.push({
    name: "unregisteredDiscontinuities empty (no malformed/unsigned entries)",
    pass: ud.length === 0,
    detail: `unregisteredDiscontinuities.length=${ud.length}${ud.length > 0 ? " — " + JSON.stringify(ud) : ""}`,
  });

  // Check 11: tamperDetected=true (live-segment mutation caught)
  checks.push({
    name: "tamperDetected=true (live-segment mutation caught in segments[2])",
    pass: r.tamperDetected === true,
    detail: `tamperDetected=${r.tamperDetected}, tamperedRowId=${r.tamperedRowId}`,
  });

  // Print results
  let passed = 0;
  let failed = 0;
  for (const c of checks) {
    const status = c.pass ? "PASS" : "FAIL";
    if (c.pass) passed++;
    else failed++;
    console.log(`  [${status}] ${c.name}`);
    console.log(`         ${c.detail}`);
  }

  console.log(`\n=== ${passed}/${checks.length} checks passed ===`);

  if (failed > 0) {
    console.log("\nFull result (for diagnosis):");
    console.log(JSON.stringify(result, null, 2));
    process.exit(1);
  }

  console.log("\nReceipt summary:");
  console.log(`  drillRef:     ${r.drillRef}`);
  console.log(`  rowsScanned:  ${r.rowsScanned}`);
  for (let i = 0; i < segs.length; i++) {
    const s = segs[i];
    const live = s.isLiveSegment ? " ← LIVE" : "";
    console.log(`  segments[${i}]:  ${s.entryCount} entries (IDs ${s.fromId}–${s.toId}) valid=${s.valid}${live}`);
    if (seams[i]) {
      const sm = seams[i];
      console.log(`  seams[${i}]:     ID ${sm.id} (${sm.fuReference}) matchesExpected=${sm.matchesExpected}`);
    }
  }
  console.log(`  tamper:       detected=${r.tamperDetected} at row ${r.tamperedRowId}`);
  console.log(`  passed:       ${r.passed}`);
  console.log("\nFU-054 R3 multi-seam dev verification PASS — three-segment drill operating correctly.");
  process.exit(0);
}

main().catch(err => {
  console.error("Unexpected error:", err);
  process.exit(1);
});