import assert from "node:assert/strict";
import { writeFile } from "node:fs/promises";
import { MemoryStorage, WorkspaceJournal, canonicalJson } from "./journal.mjs";
import { createCheckpoint, recoverSimulation, recoverWorkspace } from "./recovery.mjs";
import { ReplayTimeline, fnv1a64 } from "../worker/replay.mjs";

const storage = new MemoryStorage();
const journal = new WorkspaceJournal(storage, { projectId: "demo" });
const prepared = journal.prepare("op-1", [{ path: "config/main.ini", data: "[EMC]\n" }, { path: "programs/main.ngc", data: "G0 X1\n" }]);
journal.commit("op-1");
let recovered = recoverWorkspace(storage, { projectId: "demo" });
assert.equal(recovered.status, "recovered");
assert.deepEqual(recovered.files, { "config/main.ini": "[EMC]\n", "programs/main.ngc": "G0 X1\n" });
assert.equal(recovered.applied[0].commit_seq, prepared.commit_seq);

const halfStorage = new MemoryStorage();
const halfJournal = new WorkspaceJournal(halfStorage, { projectId: "half" });
halfJournal.prepare("op-half", [{ path: "config/half.ini", data: "half" }]);
recovered = recoverWorkspace(halfStorage, { projectId: "half" });
assert.equal(recovered.status, "recovered");
assert.deepEqual(recovered.files, {});
assert.deepEqual(recovered.half_commits, [1]);

assert.throws(() => journal.prepare("op-path", [{ path: "../escape", data: "x" }]), /workspace_path_invalid/);
assert.throws(() => journal.prepare("op-data", [{ path: "config/bad", data: 1 }]), /workspace_data_invalid/);
assert.throws(() => journal.commit("missing"), /prepare_missing/);

const corrupted = new MemoryStorage(Object.fromEntries(storage.entries()));
const commitKey = [...corrupted.records.keys()].find((key) => key.endsWith(".commit"));
const commit = JSON.parse(corrupted.get(commitKey));
commit.prepare_hash = "fnv1a64:0000000000000000";
corrupted.set(commitKey, canonicalJson(commit));
recovered = recoverWorkspace(corrupted, { projectId: "demo" });
assert.equal(recovered.status, "blocked");
assert.equal(recovered.blocked[0].reason, "hash_mismatch");

const timeline = new ReplayTimeline();
timeline.appendEvent(1, 0, "SESSION_READY", {});
timeline.checkpoint(1, 0, { tick: 0, position: 0 });
timeline.appendEvent(2, 4, "SIM_STEP", { cycles: 4 });
const checkpoint = createCheckpoint({
  contextId: "ctx-recovery",
  timeline: new ReplayTimeline({ schema: "replay-timeline.v1", events: { schema: "event-log.v1", cursor: 1, tick: 0, events: timeline.events.events.slice(0, 1) }, snapshots: { schema: "snapshot.v1", snapshots: [timeline.snapshots.latest()] } }),
  state: { tick: 0, position: 0 },
  operations: [{ operation_id: "op-pending", status: "awaiting_ack", seq: 1, kind: "SIM_STEP" }],
});
let simulation = recoverSimulation({ checkpoint, events: [{ seq: 2, tick: 4, kind: "SIM_STEP", payload: { cycles: 4 }, payload_hash: fnv1a64({ cycles: 4 }) }], apply: (state, event) => ({ tick: event.tick, position: state.position + event.payload.cycles }) });
assert.equal(simulation.status, "blocked");
assert.equal(simulation.blocked[0].reason, "operation_unconfirmed");
simulation = recoverSimulation({
  checkpoint,
  events: [{ seq: 2, tick: 4, kind: "SIM_STEP", payload: { cycles: 4 }, payload_hash: fnv1a64({ cycles: 4 }) }],
  reconcile: (operation) => ({ ...operation, status: "aborted" }),
  apply: (state, event) => ({ tick: event.tick, position: state.position + event.payload.cycles }),
});
assert.equal(simulation.status, "aborted");
assert.equal(simulation.state.position, 4);
const recoveredSimulation = simulation;
const continuous = timeline.replay({ tick: 0, position: 0 }, (state, event) => ({
  tick: event.tick,
  position: state.position + (event.payload.cycles ?? 0),
}));
assert.equal(recoveredSimulation.state_hash, continuous.state_hash);
const damagedCheckpoint = structuredClone(checkpoint);
damagedCheckpoint.state.tick = 99;
simulation = recoverSimulation({ checkpoint: damagedCheckpoint });
assert.equal(simulation.status, "blocked");
assert.equal(simulation.blocked[0].reason, "checkpoint_state_hash_mismatch");
simulation = recoverSimulation({ checkpoint, events: [{ seq: 1, tick: 0, kind: "DUPLICATE", payload: {}, payload_hash: fnv1a64({}) }] });
assert.equal(simulation.status, "blocked");
assert.equal(simulation.blocked[0].reason, "event_sequence_gap");
simulation = recoverSimulation({ checkpoint: { ...checkpoint, schema: "simulation-checkpoint.v9" } });
assert.equal(simulation.status, "blocked");
assert.equal(simulation.blocked[0].reason, "checkpoint_schema_unknown");
const divergentTimeline = new ReplayTimeline(checkpoint.timeline);
divergentTimeline.events.events[0].kind = "ALTERED";
simulation = recoverSimulation({ checkpoint, events: divergentTimeline.export() });
assert.equal(simulation.status, "blocked");
assert.equal(simulation.blocked[0].reason, "event_replay_prefix_mismatch");

const firstBytes = canonicalJson([...storage.entries()]);
const secondBytes = canonicalJson([...storage.entries()]);
assert.equal(firstBytes, secondBytes);
await writeFile(new URL("../../coverage/workspace-recovery.report.json", import.meta.url), `${JSON.stringify({
  schema: "workspace-recovery-report.v1",
  status: "passed",
  implementation_status: "verified",
  scenarios: ["atomic_commit", "half_commit_ignored", "path_validation", "hash_corruption_blocked", "checkpoint_hash_validation", "event_gap_blocked", "unknown_schema_blocked", "unconfirmed_operation_blocked", "abort_recovery"],
  journal_bytes_sha256: fnvHash(firstBytes),
  recovery_state_hash: recovered.state_hash,
  replay: {
    schema: "simulation-recovery.v1",
    status: recoveredSimulation.status,
    state_hash: recoveredSimulation.state_hash,
    state: recoveredSimulation.state,
    last_verified_seq: recoveredSimulation.last_verified_seq,
    checkpoint_hash: recoveredSimulation.checkpoint_hash,
    continuous_state_hash: continuous.state_hash,
    endpoints_equal: recoveredSimulation.state_hash === continuous.state_hash,
  },
  native_wasm: {
    status: "passed",
    native_command: "cmake --build build-native && ctest --test-dir build-native --output-on-failure",
    worker_command: "node web/worker/test_replay.mjs && node web/workspace/test_recovery.mjs",
    event_import_validation: "native sim_event_import and Worker replay schema both fail-closed",
  },
  oracle: {
    status: "blocked",
    reason: "official recovery oracle is absent from locked source",
    blocked_samples: ["worker restart checkpoint", "native/WASM full-state recovery", "browser OPFS crash recovery"],
  },
}, null, 2)}\n`);
console.log("workspace_recovery=passed commit=" + prepared.commit_seq);

function fnvHash(value) {
  let hash = 1469598103934665603n;
  for (const byte of new TextEncoder().encode(value)) hash = BigInt.asUintN(64, (hash ^ BigInt(byte)) * 1099511628211n);
  return `fnv1a64:${hash.toString(16).padStart(16, "0")}`;
}