/**
 * HistoryManager Tests – Undo/Redo
 */
import { describe, it, expect, beforeEach } from 'vitest';
import { HistoryManager } from '../src/history/HistoryManager';
import type { CADStateSnapshot } from '../src/history/HistoryManager';
import type { CADElement, CADLayer, BlockDefinition } from '../src/types/cad.types';
import type { ElementGroup } from '../src/tools/modification/GroupTool';
import type { BackgroundConfig } from '../src/services/backgroundService';

function makeSnapshot(label: string, suffix: string = ''): Omit<CADStateSnapshot, 'timestamp' | 'label'> {
  const elements: CADElement[] = [
    { id: `el-${suffix}-1`, type: 'rect', layerId: 'layer-1', x: 0, y: 0, width: 10, height: 10, properties: {} },
    { id: `el-${suffix}-2`, type: 'circle', layerId: 'layer-1', x: 50, y: 50, width: 20, height: 20, properties: {} },
  ];
  const layers: CADLayer[] = [
    { id: 'layer-1', name: 'Layer 1', visible: true, locked: false, color: '#ffffff', lineType: 'solid', transparency: 0, sortOrder: 0, parentId: null },
  ];
  const blocks: BlockDefinition[] = [];
  const groups: ElementGroup[] = [];
  const bgConfig: BackgroundConfig | null = null;
  return { elements, layers, blocks, groups, bgConfig };
}

describe('HistoryManager', () => {
  let hm: HistoryManager;

  beforeEach(() => {
    hm = new HistoryManager();
  });

  describe('initialize', () => {
    it('should set initial state without undo history', () => {
      const snap = makeSnapshot('Initial');
      hm.initialize(snap);
      expect(hm.getCurrentState()).not.toBeNull();
      expect(hm.getCurrentState()?.label).toBe('Initial');
      expect(hm.canUndo()).toBe(false);
      expect(hm.canRedo()).toBe(false);
    });

    it('should reset undo and redo stacks on initialize', () => {
      const snap = makeSnapshot('Initial');
      hm.initialize(snap);
      hm.pushSnapshot(makeSnapshot('Change 1'), 'Change 1');
      hm.pushSnapshot(makeSnapshot('Change 2'), 'Change 2');

      // Re-initialize should clear history
      hm.initialize(snap);
      expect(hm.canUndo()).toBe(false);
      expect(hm.canRedo()).toBe(false);
      expect(hm.getUndoCount()).toBe(0);
      expect(hm.getRedoCount()).toBe(0);
    });
  });

  describe('pushSnapshot', () => {
    it('should push current state to undo stack and set new state', () => {
      hm.initialize(makeSnapshot('Initial'));
      hm.pushSnapshot(makeSnapshot('Change 1', 'v1'), 'Change 1');

      expect(hm.getCurrentState()?.label).toBe('Change 1');
      expect(hm.canUndo()).toBe(true);
      expect(hm.getUndoCount()).toBe(1);
    });

    it('should clear redo stack on new push', () => {
      hm.initialize(makeSnapshot('Initial'));
      hm.pushSnapshot(makeSnapshot('Change 1', 'v1'), 'Change 1');
      hm.undo(); // Now redo stack has 1 entry
      expect(hm.canRedo()).toBe(true);

      hm.pushSnapshot(makeSnapshot('Change 2', 'v2'), 'Change 2');
      expect(hm.canRedo()).toBe(false);
      expect(hm.getRedoCount()).toBe(0);
    });

    it('should store multiple snapshots', () => {
      hm.initialize(makeSnapshot('Initial'));
      for (let i = 1; i <= 5; i++) {
        hm.pushSnapshot(makeSnapshot(`Change ${i}`, `v${i}`), `Change ${i}`);
      }
      expect(hm.getUndoCount()).toBe(5);
      expect(hm.getCurrentState()?.label).toBe('Change 5');
    });
  });

  describe('undo', () => {
    it('should restore previous state', () => {
      hm.initialize(makeSnapshot('Initial'));
      hm.pushSnapshot(makeSnapshot('Change 1', 'v1'), 'Change 1');

      const prev = hm.undo();
      expect(prev).not.toBeNull();
      expect(prev?.label).toBe('Initial');
      expect(hm.getCurrentState()?.label).toBe('Initial');
    });

    it('should return null when no undo available', () => {
      hm.initialize(makeSnapshot('Initial'));
      const result = hm.undo();
      expect(result).toBeNull();
    });

    it('should move current state to redo stack', () => {
      hm.initialize(makeSnapshot('Initial'));
      hm.pushSnapshot(makeSnapshot('Change 1', 'v1'), 'Change 1');
      hm.undo();

      expect(hm.canRedo()).toBe(true);
      expect(hm.getRedoCount()).toBe(1);
    });

    it('should handle multiple undos', () => {
      hm.initialize(makeSnapshot('Initial'));
      hm.pushSnapshot(makeSnapshot('Change 1', 'v1'), 'Change 1');
      hm.pushSnapshot(makeSnapshot('Change 2', 'v2'), 'Change 2');
      hm.pushSnapshot(makeSnapshot('Change 3', 'v3'), 'Change 3');

      hm.undo();
      expect(hm.getCurrentState()?.label).toBe('Change 2');
      hm.undo();
      expect(hm.getCurrentState()?.label).toBe('Change 1');
      hm.undo();
      expect(hm.getCurrentState()?.label).toBe('Initial');
      expect(hm.canUndo()).toBe(false);
    });
  });

  describe('redo', () => {
    it('should restore next state after undo', () => {
      hm.initialize(makeSnapshot('Initial'));
      hm.pushSnapshot(makeSnapshot('Change 1', 'v1'), 'Change 1');
      hm.undo();

      const next = hm.redo();
      expect(next).not.toBeNull();
      expect(next?.label).toBe('Change 1');
      expect(hm.getCurrentState()?.label).toBe('Change 1');
    });

    it('should return null when no redo available', () => {
      hm.initialize(makeSnapshot('Initial'));
      const result = hm.redo();
      expect(result).toBeNull();
    });

    it('should move current state back to undo stack', () => {
      hm.initialize(makeSnapshot('Initial'));
      hm.pushSnapshot(makeSnapshot('Change 1', 'v1'), 'Change 1');
      hm.undo();
      hm.redo();

      expect(hm.canUndo()).toBe(true);
      expect(hm.getUndoCount()).toBe(1);
    });

    it('should handle multiple redos', () => {
      hm.initialize(makeSnapshot('Initial'));
      hm.pushSnapshot(makeSnapshot('Change 1', 'v1'), 'Change 1');
      hm.pushSnapshot(makeSnapshot('Change 2', 'v2'), 'Change 2');
      hm.pushSnapshot(makeSnapshot('Change 3', 'v3'), 'Change 3');

      // Undo all 3
      hm.undo(); hm.undo(); hm.undo();
      expect(hm.getCurrentState()?.label).toBe('Initial');

      // Redo all 3
      hm.redo();
      expect(hm.getCurrentState()?.label).toBe('Change 1');
      hm.redo();
      expect(hm.getCurrentState()?.label).toBe('Change 2');
      hm.redo();
      expect(hm.getCurrentState()?.label).toBe('Change 3');
      expect(hm.canRedo()).toBe(false);
    });
  });

  describe('canUndo & canRedo', () => {
    it('canUndo should be false initially', () => {
      hm.initialize(makeSnapshot('Initial'));
      expect(hm.canUndo()).toBe(false);
    });

    it('canUndo should be true after push', () => {
      hm.initialize(makeSnapshot('Initial'));
      hm.pushSnapshot(makeSnapshot('Change 1', 'v1'), 'Change 1');
      expect(hm.canUndo()).toBe(true);
    });

    it('canRedo should be false initially', () => {
      hm.initialize(makeSnapshot('Initial'));
      expect(hm.canRedo()).toBe(false);
    });

    it('canRedo should be true after undo', () => {
      hm.initialize(makeSnapshot('Initial'));
      hm.pushSnapshot(makeSnapshot('Change 1', 'v1'), 'Change 1');
      hm.undo();
      expect(hm.canRedo()).toBe(true);
    });
  });

  describe('getHistory', () => {
    it('should return history entries with current marked', () => {
      hm.initialize(makeSnapshot('Initial'));
      hm.pushSnapshot(makeSnapshot('Change 1', 'v1'), 'Change 1');
      hm.pushSnapshot(makeSnapshot('Change 2', 'v2'), 'Change 2');

      const history = hm.getHistory();
      expect(history.length).toBe(3); // 2 undo + 1 current
      const currentEntries = history.filter(e => e.isCurrent);
      expect(currentEntries.length).toBe(1);
      expect(currentEntries[0].label).toBe('Change 2');
    });

    it('should include redo entries after undo', () => {
      hm.initialize(makeSnapshot('Initial'));
      hm.pushSnapshot(makeSnapshot('Change 1', 'v1'), 'Change 1');
      hm.undo();

      const history = hm.getHistory();
      // 0 undo + 1 current (Initial) + 1 redo (Change 1)
      expect(history.length).toBe(2);
      const currentEntries = history.filter(e => e.isCurrent);
      expect(currentEntries.length).toBe(1);
      expect(currentEntries[0].label).toBe('Initial');
    });

    it('should return empty-ish history for fresh manager', () => {
      const history = hm.getHistory();
      expect(history.length).toBe(0);
    });
  });

  describe('jumpTo', () => {
    it('should jump to a specific undo entry', () => {
      hm.initialize(makeSnapshot('Initial'));
      hm.pushSnapshot(makeSnapshot('Change 1', 'v1'), 'Change 1');
      hm.pushSnapshot(makeSnapshot('Change 2', 'v2'), 'Change 2');
      hm.pushSnapshot(makeSnapshot('Change 3', 'v3'), 'Change 3');

      // Jump to undo-0 (Initial state)
      const result = hm.jumpTo('undo-0');
      expect(result).not.toBeNull();
      expect(hm.getCurrentState()?.label).toBe('Initial');
    });

    it('should jump to current', () => {
      hm.initialize(makeSnapshot('Initial'));
      hm.pushSnapshot(makeSnapshot('Change 1', 'v1'), 'Change 1');

      const result = hm.jumpTo('current');
      expect(result).not.toBeNull();
      expect(result?.label).toBe('Change 1');
    });

    it('should jump to a redo entry', () => {
      hm.initialize(makeSnapshot('Initial'));
      hm.pushSnapshot(makeSnapshot('Change 1', 'v1'), 'Change 1');
      hm.pushSnapshot(makeSnapshot('Change 2', 'v2'), 'Change 2');
      hm.undo();
      hm.undo();

      // Jump to redo-1 (Change 2)
      const result = hm.jumpTo('redo-1');
      expect(result).not.toBeNull();
      expect(hm.getCurrentState()?.label).toBe('Change 2');
    });

    it('should return null for unknown entry id', () => {
      hm.initialize(makeSnapshot('Initial'));
      const result = hm.jumpTo('unknown-id');
      expect(result).toBeNull();
    });
  });

  describe('clear', () => {
    it('should clear all history', () => {
      hm.initialize(makeSnapshot('Initial'));
      hm.pushSnapshot(makeSnapshot('Change 1', 'v1'), 'Change 1');
      hm.pushSnapshot(makeSnapshot('Change 2', 'v2'), 'Change 2');

      hm.clear();
      expect(hm.getCurrentState()).toBeNull();
      expect(hm.canUndo()).toBe(false);
      expect(hm.canRedo()).toBe(false);
      expect(hm.getUndoCount()).toBe(0);
      expect(hm.getRedoCount()).toBe(0);
    });
  });

  describe('subscribe', () => {
    it('should notify listeners on state change', () => {
      let callCount = 0;
      const unsubscribe = hm.subscribe(() => callCount++);

      hm.initialize(makeSnapshot('Initial'));
      expect(callCount).toBe(1);

      hm.pushSnapshot(makeSnapshot('Change 1', 'v1'), 'Change 1');
      expect(callCount).toBe(2);

      hm.undo();
      expect(callCount).toBe(3);

      unsubscribe();
      hm.pushSnapshot(makeSnapshot('Change 2', 'v2'), 'Change 2');
      expect(callCount).toBe(3); // No new calls after unsubscribe
    });

    it('should notify on clear', () => {
      let callCount = 0;
      hm.subscribe(() => callCount++);
      hm.initialize(makeSnapshot('Initial'));
      hm.clear();
      expect(callCount).toBe(2); // init + clear
    });
  });

  describe('maxStackSize', () => {
    it('should limit undo stack size', () => {
      const smallHM = new HistoryManager({ maxStackSize: 3 });
      smallHM.initialize(makeSnapshot('Initial'));

      for (let i = 1; i <= 10; i++) {
        smallHM.pushSnapshot(makeSnapshot(`Change ${i}`, `v${i}`), `Change ${i}`);
      }

      expect(smallHM.getUndoCount()).toBe(3);
    });

    it('should use default max size of 100', () => {
      const defaultHM = new HistoryManager();
      defaultHM.initialize(makeSnapshot('Initial'));

      for (let i = 1; i <= 150; i++) {
        defaultHM.pushSnapshot(makeSnapshot(`Change ${i}`, `v${i}`), `Change ${i}`);
      }

      expect(defaultHM.getUndoCount()).toBe(100);
    });
  });

  describe('getUndoCount & getRedoCount', () => {
    it('should track counts correctly', () => {
      hm.initialize(makeSnapshot('Initial'));
      expect(hm.getUndoCount()).toBe(0);
      expect(hm.getRedoCount()).toBe(0);

      hm.pushSnapshot(makeSnapshot('Change 1', 'v1'), 'Change 1');
      expect(hm.getUndoCount()).toBe(1);
      expect(hm.getRedoCount()).toBe(0);

      hm.undo();
      expect(hm.getUndoCount()).toBe(0);
      expect(hm.getRedoCount()).toBe(1);

      hm.redo();
      expect(hm.getUndoCount()).toBe(1);
      expect(hm.getRedoCount()).toBe(0);
    });
  });

  describe('snapshot data integrity', () => {
    it('should preserve elements in snapshots', () => {
      const snap = makeSnapshot('Test');
      hm.initialize(snap);
      const current = hm.getCurrentState();
      expect(current?.elements.length).toBe(2);
      expect(current?.elements[0].id).toBe('el--1');
    });

    it('should preserve different element sets across snapshots', () => {
      hm.initialize(makeSnapshot('Initial'));
      const snap1 = makeSnapshot('Change 1', 'v1');
      hm.pushSnapshot(snap1, 'Change 1');

      hm.undo();
      const afterUndo = hm.getCurrentState();
      expect(afterUndo?.elements[0].id).toBe('el--1'); // Initial state

      hm.redo();
      const afterRedo = hm.getCurrentState();
      expect(afterRedo?.elements[0].id).toBe('el-v1-1'); // Change 1 state
    });
  });
});