import { test } from 'node:test';
import assert from 'node:assert/strict';
import { createDocument, applyChanges, builtinComponents, createRegistry } from '../../src/lib/canvas-core/index.ts';
import { openProjectEngine } from '../../src/lib/canvas-runtime/engine.ts';
import { encodeRecovery, decodeRecovery } from '../../src/lib/canvas-runtime/recovery.ts';

const registry = createRegistry(builtinComponents());
const original = createDocument('project', [{ id: 'canvas', parent: null }], [{ id: 'a', incarnation: 1, structure: 'node', ownerCanvasId: 'canvas', componentId: 'text', dataVersion: 1, data: { title: 'a', text: '' }, geometry: { x: 0, y: 0, width: 100, height: 100, rotation: 0 } }]);
const scope = { accountId: 'account', workspaceId: 'workspace', projectId: 'project' }, target = { id: 'a', incarnation: 1 };
const deferred = () => { let resolve; const promise = new Promise(yes => { resolve = yes; }); return { promise, resolve }; };
const tick = async () => { for (let i = 0; i < 30; i++) await Promise.resolve(); };
function storageFixture() {
  let image = null, owner = null, fence = 0;
  const saved = [], fixture = {
    broken: false, saved,
    async claim(scope) { assert.equal(owner, null); const leader = { scope, fence: ++fence, active: true, async release() { owner = null; leader.active = false; } }; owner = leader; return leader; },
    async recover() { return image && structuredClone(image); },
    async commit(leader, batch) { if (fixture.broken) throw new Error('quota'); assert.equal(owner, leader); assert.equal(leader.active, true); if (image) assert.ok(batch.image.rootRevision === image.rootRevision + 1 || batch.image.rootRevision === image.rootRevision); image = structuredClone(batch.image); saved.push(image); return { durableRootRevision: image.rootRevision }; },
    async readFile() {}, close() {},
    image: () => structuredClone(image), owner: () => owner,
  };
  return fixture;
}
function persistenceFixture(overrides = {}) {
  let server = original, version = 1;
  const calls = [], receipts = new Map();
  const fixture = {
    calls, receipts,
    compile(intent, requestId, snapshot) { return { payload: { requestId, intent }, canvasIds: intent.canvasIds, expectedVersions: Object.fromEntries(intent.canvasIds.map(id => [id, snapshot.runtime.versions.get(id)])) }; },
    async submit(request) {
      calls.push(['submit', request]);
      if (!receipts.has(request.id)) { const { intent } = JSON.parse(request.body); server = applyChanges(server, intent.changes); version++; receipts.set(request.id, { document: server, versions: new Map([['canvas', version]]) }); }
      return { outcome: 'applied', canonical: { receipt: request.id } };
    },
    async query(request) { calls.push(['query', request]); return receipts.has(request.id) ? { outcome: 'applied', canonical: { receipt: request.id } } : { outcome: 'unresolved' }; },
    canonical(request) { return receipts.get(request.id); }, ...overrides,
  };
  return fixture;
}
async function open(storage, persistence, extra = {}) {
  let next = 0; const errors = [];
  const engine = await openProjectEngine({ scope, registry, document: original, versions: new Map([['canvas', 1]]), storage, persistence, createId: () => `identity-${++next}`, onError: error => errors.push(error), ...extra });
  return { engine, errors };
}

test('local document/history/ledger publish together; ACK replays edits made while a request is in flight', async () => {
  const storage = storageFixture(), port = persistenceFixture(), gate = deferred(), realSubmit = port.submit;
  port.submit = async request => { if (!port.calls.length) await gate.promise; return realSubmit(request); };
  const { engine } = await open(storage, port); await engine.persist();
  const first = engine.editor.dispatch({ type: 'element.data', target, patch: { title: 'local' } });
  assert.equal(engine.getSnapshot().history.undo.length, 1);
  assert.ok(engine.getSnapshot().runtime.ledger.operations.has(first.operationIds[0]));
  await tick();
  engine.editor.dispatch({ type: 'element.geometry', target, patch: { x: 200 } });
  assert.equal(engine.getSnapshot().document.elements.get('a').geometry.x, 200);
  gate.resolve(); await engine.settle();
  assert.equal(port.calls.length, 2);
  assert.equal(port.calls[1][1].expectedVersions.canvas, 2);
  assert.equal(engine.getSnapshot().document.elements.get('a').data.title, 'local');
  assert.equal(engine.getSnapshot().document.elements.get('a').geometry.x, 200);
  assert.equal(engine.getSnapshot().history.undo.length, 2);
  assert.ok([...engine.getSnapshot().runtime.ledger.operations.values()].every(operation => operation.phase === 'resolved'));
  assert.equal(engine.getDurability().durableRootRevision, engine.getSnapshot().rootRevision);
  assert.equal(engine.getSnapshot().runtime.ledger.durableGeneration, engine.getSnapshot().runtime.ledger.generation);
  const payload = storage.image().payload;
  assert.equal(payload.history.undo.length, 2); assert.equal(payload.runtime.ledger.requests.length, 2);
  await engine.close();
});

test('closing a view keeps jobs alive; closing/reopening the engine restores history and queries the original unknown request', async () => {
  const storage = storageFixture(), port = persistenceFixture(), realSubmit = port.submit;
  port.submit = async request => { await realSubmit(request); return { outcome: 'unresolved' }; };
  const { engine } = await open(storage, port);
  const detach = engine.sessions.attach('view');
  engine.editor.dispatch({ type: 'element.data', target, patch: { title: 'once' } }); detach();
  await engine.settle();
  assert.equal(port.calls.length, 1); const request = port.calls[0][1];
  await engine.close();
  const futureClock = { now: () => Date.now() + 100_000, setTimer: (callback, delay) => setTimeout(callback, delay), clearTimer: clearTimeout };
  const recovered = await open(storage, port, { clock: futureClock });
  await new Promise(resolve => setTimeout(resolve, 1)); await recovered.engine.settle();
  assert.equal(port.calls[1][0], 'query'); assert.equal(port.calls[1][1].id, request.id); assert.equal(port.calls[1][1].body, request.body);
  assert.equal(recovered.engine.getSnapshot().history.undo.length, 1);
  assert.equal(recovered.engine.getSnapshot().document.elements.get('a').data.title, 'once');
  assert.equal(recovered.engine.getSnapshot().operations.size, 1);
  await recovered.engine.close();
});

test('failed local durability preserves editing, prevents sends, and failed close retains the recovery leader', async () => {
  const storage = storageFixture(), port = persistenceFixture(), { engine, errors } = await open(storage, port);
  await engine.persist(); storage.broken = true;
  engine.editor.dispatch({ type: 'element.data', target, patch: { title: 'unsaved' } }); await tick();
  await assert.rejects(() => engine.persist(), /quota/); await tick();
  assert.equal(engine.getSnapshot().document.elements.get('a').data.title, 'unsaved'); assert.equal(port.calls.length, 0); assert.ok(errors.length);
  await assert.rejects(() => engine.close(), /quota/); assert.ok(storage.owner());
  assert.equal(engine.editor.dispatch({ type: 'element.data', target, patch: { title: 'too-late' } }).code, 'engine_closing');
  storage.broken = false; await engine.close(); assert.equal(storage.owner(), null);
});

test('canonical replay conflict preserves working content and the known receipt without releasing the writer', async () => {
  const storage = storageFixture(), port = persistenceFixture(), gate = deferred(), realSubmit = port.submit;
  port.submit = async request => { await gate.promise; return realSubmit(request); };
  const realCanonical = port.canonical;
  port.canonical = request => { const proposal = realCanonical(request); return { ...proposal, document: applyChanges(proposal.document, [{ kind: 'field', target, field: 'geometry', before: original.elements.get('a').geometry, after: { ...original.elements.get('a').geometry, x: 500 } }]) }; };
  const { engine } = await open(storage, port);
  engine.editor.dispatch({ type: 'element.data', target, patch: { title: 'first' } }); await tick();
  engine.editor.dispatch({ type: 'element.geometry', target, patch: { x: 200 } });
  gate.resolve(); await engine.settle();
  assert.equal(engine.getSnapshot().document.elements.get('a').geometry.x, 200);
  assert.equal(engine.getSnapshot().runtime.conflicts.size, 1); assert.equal(port.calls.length, 1);
  const request = [...engine.getSnapshot().runtime.ledger.requests.values()][0];
  assert.equal(request.outcome, 'applied'); assert.equal(request.phase, 'waiting');
  assert.ok(engine.getSnapshot().runtime.receipts.has(request.id));
  await engine.close();
});

test('recovery codec restores immutable maps and rejects broken history/dependency references', async () => {
  const storage = storageFixture(), port = persistenceFixture(), { engine } = await open(storage, port);
  engine.editor.dispatch({ type: 'element.data', target, patch: { title: 'encoded' } }); await engine.settle();
  const image = encodeRecovery(engine.getSnapshot()), restored = decodeRecovery(image, registry);
  assert.equal(typeof restored.document.elements.set, 'undefined'); assert.equal(restored.history.undo.length, 1);
  const corrupted = structuredClone(image); corrupted.payload.history.undo[0] = 'missing';
  assert.throws(() => decodeRecovery(corrupted, registry), /corrupt_recovery_image/);
  const cycle = structuredClone(image), record = cycle.payload.runtime.ledger.operations[0][1]; record.intent.dependencies = [record.intent.id];
  assert.throws(() => decodeRecovery(cycle, registry), /corrupt_recovery_image/);
  const changed = structuredClone(image); changed.payload.document.elements[0].data.title = 'mutated';
  assert.equal(restored.document.elements.get('a').data.title, 'encoded');
  await engine.close();
});