import { test } from 'node:test';
import assert from 'node:assert/strict';
import { createDocument, createEditor, createRegistry, builtinComponents } from '../../src/lib/canvas-core/index.ts';
import { planCreationSize } from '../../src/lib/canvas-core/creation-size-plan.ts';
import { applyChanges, invert } from '../../src/lib/canvas-core/document.ts';
import { describeHistoryTransition, applyHistoryTransition } from '../../src/lib/canvas-core/history-transition.ts';

const registry = createRegistry(builtinComponents());
const target = { id: 'image', incarnation: 1 };
function setup(options = {}) {
  let id = 0;
  const editor = createEditor({ document: createDocument('p', [{ id: 'root', parent: null }], []), registry, createId: () => `id-${++id}`, ...options });
  const element = { ...target, ownerCanvasId: 'root', componentId: 'image', dataVersion: 1, structure: 'node', data: { title: 'Image', text: '', assetId: 'asset' }, geometry: { x: 10, y: 20, width: 260, height: 200, rotation: 0 } };
  assert.equal(editor.dispatch({ type: 'element.create', element }).status, 'applied');
  const entry = editor.getSnapshot().history.undo[0];
  return { editor, entry, propose() { const { document, history } = editor.getSnapshot(); return planCreationSize(document, history, registry, entry, target, { width: 260, height: 130 }); } };
}
function traverse(plan) {
  let document = plan.document;
  for (const id of [...plan.history.undo].reverse()) document = applyChanges(document, invert(plan.history.entries.get(id).changes));
  assert.equal(document.elements.size, 0);
  for (const id of plan.history.undo) document = applyChanges(document, plan.history.entries.get(id).changes);
  assert.deepEqual(document.elements.get('image'), plan.document.elements.get('image'));
  return document;
}
test('default size enriches the creation unit across move, rotation and title edits without mutating issued intents', () => {
  const { editor, entry, propose } = setup();
  editor.dispatch({ type: 'element.geometry', target, patch: { x: 80, rotation: 25 } });
  editor.dispatch({ type: 'element.data', target, patch: { title: 'Renamed' } });
  const before = editor.getSnapshot(), intents = [...before.operations.values()].map(value => JSON.stringify(value));
  const plan = propose();
  assert.deepEqual(plan.history.undo, before.history.undo);
  assert.equal(plan.history.entries.get(entry).changes[0].after.geometry.height, 130);
  assert.deepEqual(plan.document.elements.get('image').geometry, { x: 80, y: 20, width: 260, height: 130, rotation: 25 });
  assert.equal(plan.document.elements.get('image').data.title, 'Renamed');
  assert.strictEqual(editor.getSnapshot(), before);
  assert.deepEqual([...before.operations.values()].map(value => JSON.stringify(value)), intents);
  traverse(plan);
});
test('an unrelated redo stack is retained and rebased without becoming the working document', () => {
  const { editor, propose } = setup();
  editor.dispatch({ type: 'element.geometry', target, patch: { x: 90 } }); editor.history.undo();
  const before = editor.getSnapshot(), plan = propose();
  assert.deepEqual(plan.history.redo, before.history.redo);
  assert.equal(plan.document.elements.get('image').geometry.x, 10);
  let document = traverse(plan);
  document = applyChanges(document, plan.history.entries.get(plan.history.redo.at(-1)).changes);
  assert.equal(document.elements.get('image').geometry.x, 90);
  assert.equal(document.elements.get('image').geometry.height, 130);
});
test('a future explicit resize keeps the chosen dimensions, with a corrected undo baseline', () => {
  const { editor, propose } = setup();
  editor.dispatch({ type: 'element.geometry', target, patch: { width: 400, height: 300 } }); editor.history.undo();
  const plan = propose(), resize = plan.history.entries.get(plan.history.redo.at(-1));
  const resized = applyChanges(plan.document, resize.changes);
  assert.equal(resized.elements.get('image').geometry.height, 300);
  assert.equal(applyChanges(resized, invert(resize.changes)).elements.get('image').geometry.height, 130);
});
test('applied resize rejects even after a later resize returns to the initial dimensions', () => {
  const { editor, propose } = setup();
  editor.dispatch({ type: 'element.geometry', target, patch: { height: 400 } });
  editor.dispatch({ type: 'element.geometry', target, patch: { height: 200 } });
  const before = editor.getSnapshot();
  assert.throws(propose, { code: 'creation_size_user_resized' }); assert.strictEqual(editor.getSnapshot(), before);
});
test('an undone creation cannot be enriched', () => {
  const { editor, propose } = setup(); editor.history.undo();
  assert.throws(propose, { code: 'creation_size_target_changed' });
});
test('a restored element has a new incarnation and rejects the old asynchronous task', () => {
  const { editor, propose } = setup(); editor.dispatch({ type: 'element.remove', target }); editor.history.undo();
  // Undo of removal creates a new incarnation: an old asynchronous task is stale.
  assert.throws(propose, { code: 'creation_size_target_changed' });
});
test('the complete history proposal is reversible using the existing transition proof format', () => {
  const { editor, entry, propose } = setup(); editor.dispatch({ type: 'element.geometry', target, patch: { x: 50 } });
  const before = editor.getSnapshot(), plan = propose();
  const transition = describeHistoryTransition(before.history, plan.history, before.rootRevision + 1, entry);
  const replay = applyHistoryTransition(before.history, JSON.parse(JSON.stringify(transition)), 'forward');
  assert.deepEqual([...replay.entries], [...plan.history.entries]);
  const restored = applyHistoryTransition(replay, transition, 'reverse');
  assert.deepEqual([...restored.entries], [...before.history.entries]);
  assert.equal(plan.history.entries.set, undefined);
});
test('a logical unit conversion preserves size, latest position and the full undo path', () => {
  const { editor, propose } = setup({ allowRawChanges: true });
  const before = editor.getSnapshot().document.elements.get('image');
  editor.transaction(tx => {
    tx.dispatch({ type: 'changes.apply', changes: [
      { kind: 'field', target, field: 'geometry', before: before.geometry, after: { ...before.geometry, x: 45, width: 520, height: 400 } },
      { kind: 'field', target, field: 'data.presentation', before: null, beforePresent: false, after: { unitScale: 2 } },
    ] });
  });
  const plan = propose();
  assert.equal(plan.document.elements.get('image').geometry.height, 260);
  assert.equal(plan.document.elements.get('image').geometry.x, 45);
  traverse(plan);
});
test('a real move into a scaled child canvas is retained through enrichment and undo', () => {
  const frame = { id: 'frame', incarnation: 1, ownerCanvasId: 'root', componentId: 'frame', dataVersion: 1, structure: 'node', data: { title: 'Frame', text: '', presentation: { contentScale: 2 } }, geometry: { x: 0, y: 0, width: 600, height: 400, rotation: 0 } };
  const { editor, propose } = setup({ document: createDocument('p', [{ id: 'root', parent: null }, { id: 'child', parent: { canvasId: 'root', entryElementId: 'frame' } }], [frame]) });
  assert.equal(editor.dispatch({ type: 'element.move', target, canvasId: 'child' }).status, 'applied');
  const current = editor.getSnapshot().document.elements.get('image'), plan = propose();
  assert.equal(plan.document.elements.get('image').ownerCanvasId, 'child');
  assert.equal(plan.document.elements.get('image').geometry.x, current.geometry.x);
  assert.equal(plan.document.elements.get('image').geometry.height, 65);
  let document = plan.document;
  for (const id of [...plan.history.undo].reverse()) document = applyChanges(document, invert(plan.history.entries.get(id).changes));
  assert.equal(document.elements.has('image'), false); assert.equal(document.elements.has('frame'), true);
  for (const id of plan.history.undo) document = applyChanges(document, plan.history.entries.get(id).changes);
  assert.deepEqual(document.elements.get('image'), plan.document.elements.get('image'));
});
test('evicted creation history is rejected without synthesizing a new undo entry', () => {
  const { editor, propose } = setup({ historyLimit: 1 });
  editor.dispatch({ type: 'element.data', target, patch: { title: 'New title' } });
  assert.throws(propose, { code: 'creation_size_target_changed' });
});
test('a future resize followed by movement retains the user size through both redo entries', () => {
  const { editor, propose } = setup();
  editor.dispatch({ type: 'element.geometry', target, patch: { height: 300 } });
  editor.dispatch({ type: 'element.geometry', target, patch: { x: 75 } });
  editor.history.undo(); editor.history.undo();
  const plan = propose(); let document = plan.document;
  for (const id of [...plan.history.redo].reverse()) document = applyChanges(document, plan.history.entries.get(id).changes);
  assert.equal(document.elements.get('image').geometry.height, 300);
  assert.equal(document.elements.get('image').geometry.x, 75);
  for (const id of plan.history.redo) document = applyChanges(document, invert(plan.history.entries.get(id).changes));
  assert.deepEqual(document.elements.get('image'), plan.document.elements.get('image'));
});
test('invalid sizes and stale document baselines are rejected without mutation', () => {
  const { editor, entry } = setup(); const root = editor.getSnapshot();
  assert.throws(() => planCreationSize(root.document, root.history, registry, entry, target, { width: Infinity, height: 1 }), { code: 'invalid_creation_size' });
  editor.dispatch({ type: 'element.data', target, patch: { title: 'Remote change' } }, { origin: 'remote' });
  const stale = editor.getSnapshot();
  assert.throws(() => planCreationSize(stale.document, stale.history, registry, entry, target, { width: 260, height: 130 }), { code: 'element_conflict' });
  assert.strictEqual(editor.getSnapshot(), stale);
});
test('component constraints cannot be bypassed by a default size proposal', () => {
  const { editor, entry } = setup(); const root = editor.getSnapshot();
  assert.throws(() => planCreationSize(root.document, root.history, registry, entry, target, { width: 260, height: 0.5 }), { code: 'creation_size_constraint' });
});
test('a redo edit to one size axis preserves the corrected default on the other axis', () => {
  const { editor, entry } = setup();
  editor.dispatch({ type: 'element.geometry', target, patch: { height: 300 } });
  editor.dispatch({ type: 'element.geometry', target, patch: { x: 75 } });
  editor.history.undo(); editor.history.undo();
  const root = editor.getSnapshot(), plan = planCreationSize(root.document, root.history, registry, entry, target, { width: 520, height: 130 });
  assert.equal(plan.document.elements.get('image').geometry.width, 520);
  assert.equal(plan.document.elements.get('image').geometry.height, 130);
  let document = plan.document;
  for (const id of [...plan.history.redo].reverse()) document = applyChanges(document, plan.history.entries.get(id).changes);
  assert.equal(document.elements.get('image').geometry.width, 520);
  assert.equal(document.elements.get('image').geometry.height, 300);
});