import { describe, it, expect, beforeEach, vi } from 'vitest';
import { KGProjectStorage, DuplicateEntryError } from './KGProjectStorage';
import { KGConversationStorage } from './KGConversationStorage';
import { KGProject } from '../KGProject';
import { GlobalTrackType } from '../global-track';
import { KGKeySignatureRegion } from '../region/KGKeySignatureRegion';
import { KGMarkerRegion } from '../region/KGMarkerRegion';
import { KGChordRegion } from '../region/KGChordRegion';
import { KGTrack } from '../track/KGTrack';

// --- OPFS mock infrastructure ---

class MockFileSystemWritableFileStream {
  public data: string | ArrayBuffer = '';
  async write(content: string | ArrayBuffer) { this.data = content; }
  async close() {}
}

class MockFileSystemFileHandle {
  kind = 'file' as const;
  constructor(public name: string, private _content: string | ArrayBuffer = '') {}
  async getFile() {
    return {
      text: () => Promise.resolve(typeof this._content === 'string' ? this._content : new TextDecoder().decode(this._content)),
      arrayBuffer: () => Promise.resolve(
        typeof this._content === 'string'
          ? new TextEncoder().encode(this._content).buffer
          : this._content
      ),
    };
  }
  async createWritable() {
    const stream = new MockFileSystemWritableFileStream();
    // When stream closes, update our content
    const origClose = stream.close.bind(stream);
    stream.close = async () => {
      this._content = stream.data;
      await origClose();
    };
    return stream;
  }
}

class MockFileSystemDirectoryHandle {
  kind = 'directory' as const;
  private entries = new Map<string, MockFileSystemDirectoryHandle | MockFileSystemFileHandle>();

  constructor(public name: string) {}

  async getDirectoryHandle(name: string, options?: { create?: boolean }): Promise<MockFileSystemDirectoryHandle> {
    let entry = this.entries.get(name);
    if (!entry || entry.kind !== 'directory') {
      if (options?.create) {
        entry = new MockFileSystemDirectoryHandle(name);
        this.entries.set(name, entry);
      } else {
        throw new DOMException(`Directory "${name}" not found`, 'NotFoundError');
      }
    }
    return entry as MockFileSystemDirectoryHandle;
  }

  async getFileHandle(name: string, options?: { create?: boolean }): Promise<MockFileSystemFileHandle> {
    let entry = this.entries.get(name);
    if (!entry || entry.kind !== 'file') {
      if (options?.create) {
        entry = new MockFileSystemFileHandle(name);
        this.entries.set(name, entry);
      } else {
        throw new DOMException(`File "${name}" not found`, 'NotFoundError');
      }
    }
    return entry as MockFileSystemFileHandle;
  }

  async removeEntry(name: string, _options?: { recursive?: boolean }): Promise<void> {
    if (!this.entries.has(name)) {
      throw new DOMException(`Entry "${name}" not found`, 'NotFoundError');
    }
    this.entries.delete(name);
  }

  async *values(): AsyncIterableIterator<MockFileSystemDirectoryHandle | MockFileSystemFileHandle> {
    for (const entry of this.entries.values()) {
      yield entry;
    }
  }
}

// Install the mock
const mockRoot = new MockFileSystemDirectoryHandle('root');

vi.stubGlobal('navigator', {
  ...navigator,
  storage: {
    getDirectory: vi.fn(() => Promise.resolve(mockRoot)),
    persist: vi.fn(() => Promise.resolve(true)),
    estimate: vi.fn(() => Promise.resolve({ usage: 0, quota: 1e9 })),
  },
});

describe('KGProjectStorage', () => {
  let storage: KGProjectStorage;
  let conversationStorage: KGConversationStorage;

  beforeEach(async () => {
    // Reset singleton and mock filesystem
    ;(KGProjectStorage as unknown as { _instance: undefined })._instance = undefined;
    // Clear the mock root directory entries
    const entries = (mockRoot as unknown as { entries: Map<string, unknown> }).entries;
    entries.clear();

    storage = KGProjectStorage.getInstance();
    await storage.initialize();
    ;(KGConversationStorage as unknown as { _instance: undefined })._instance = undefined;
    conversationStorage = KGConversationStorage.getInstance();
    await conversationStorage.initialize();
  });

  function createTestProject(name = 'Test Project'): KGProject {
    return new KGProject(name, 16, 0, 120);
  }

  it('defaults the main-grid zoom to 2 and piano-roll zoom to 1 on a fresh project', () => {
    const project = new KGProject();

    expect(project.getBarWidthMultiplier()).toBe(2);
    expect(project.getPianoRollZoom()).toBe(1);
  });

  it('initializes and creates the projects directory', async () => {
    // The projects directory should exist after init
    const projects = await mockRoot.getDirectoryHandle('projects');
    expect(projects).toBeDefined();
    expect(projects.kind).toBe('directory');
  });

  it('saves and loads a project', async () => {
    const project = createTestProject('My Song');
    await storage.save('My Song', project);

    const loaded = await storage.load('My Song');
    expect(loaded).not.toBeNull();
    expect(loaded!.getName()).toBe('My Song');
    expect(loaded!.getBpm()).toBe(120);
  });

  it('preserves track mute and solo state when saving and loading', async () => {
    const track = new KGTrack('Track 1', 1);
    track.setMuted(true);
    track.setSolo(true);
    const project = new KGProject('My Song', 16, 0, 120, undefined, undefined, undefined, undefined, undefined, 1, [track], 11);

    await storage.save('My Song', project);

    const loaded = await storage.load('My Song');

    expect(loaded).not.toBeNull();
    expect(loaded!.getTracks()).toHaveLength(1);
    expect(loaded!.getTracks()[0].getMuted()).toBe(true);
    expect(loaded!.getTracks()[0].getSolo()).toBe(true);
  });

  it('preserves both main-grid and piano-roll zoom levels when saving and loading', async () => {
    const project = createTestProject('Zoom Song');
    project.setBarWidthMultiplier(3);
    project.setPianoRollZoom(5);

    await storage.save('Zoom Song', project);

    const loaded = await storage.load('Zoom Song');

    expect(loaded).not.toBeNull();
    expect(loaded!.getBarWidthMultiplier()).toBe(3);
    expect(loaded!.getPianoRollZoom()).toBe(5);
  });

  it('preserves playhead position when saving and loading', async () => {
    const project = createTestProject('Playhead Song');
    project.setPlayheadPosition(18.5);

    await storage.save('Playhead Song', project);

    const loaded = await storage.load('Playhead Song');

    expect(loaded).not.toBeNull();
    expect(loaded!.getPlayheadPosition()).toBe(18.5);
  });

  it('defaults playhead position to 0 when loading older project data without the field', async () => {
    const project = createTestProject('Legacy Song');
    await storage.save('Legacy Song', project);

    const projectsDir = await mockRoot.getDirectoryHandle('projects');
    const projectDir = await projectsDir.getDirectoryHandle('Legacy Song');
    const projectHandle = await projectDir.getFileHandle('project.json');
    const legacyPayload = JSON.parse(await (await projectHandle.getFile()).text()) as Record<string, unknown>;
    delete legacyPayload.playheadPosition;

    const writable = await projectHandle.createWritable();
    await writable.write(JSON.stringify(legacyPayload, null, 2));
    await writable.close();

    const loaded = await storage.load('Legacy Song');

    expect(loaded).not.toBeNull();
    expect(loaded!.getPlayheadPosition()).toBe(0);
  });

  it('preserves persisted global-track visibility and metronome state when saving and loading', async () => {
    const project = createTestProject('Toggle Song');
    project.setShowGlobalTracks(true);
    project.setIsMetronomeEnabled(true);

    await storage.save('Toggle Song', project);

    const loaded = await storage.load('Toggle Song');

    expect(loaded).not.toBeNull();
    expect(loaded!.getShowGlobalTracks()).toBe(true);
    expect(loaded!.getIsMetronomeEnabled()).toBe(true);
  });

  it('preserves global tracks and marker regions when saving and loading', async () => {
    const project = createTestProject('Marker Song');
    const markerTrack = project.getGlobalTracks().find(track => track.getType() === GlobalTrackType.Marker);

    expect(markerTrack).toBeDefined();
    markerTrack?.addRegion(new KGMarkerRegion('marker-1', markerTrack.getId(), markerTrack.getTrackIndex(), 'Intro', 0, 8));

    await storage.save('Marker Song', project);

    const loaded = await storage.load('Marker Song');
    const loadedMarkerTrack = loaded?.getGlobalTracks().find(track => track.getType() === GlobalTrackType.Marker);

    expect(loadedMarkerTrack).toBeDefined();
    expect(loadedMarkerTrack?.getRegions()).toHaveLength(1);
    expect(loadedMarkerTrack?.getRegions()[0]).toBeInstanceOf(KGMarkerRegion);
    expect(loadedMarkerTrack?.getRegions()[0].getName()).toBe('Intro');
  });

  it('preserves key signature regions when saving and loading', async () => {
    const project = createTestProject('Signature Song');
    const signatureTrack = project.getGlobalTracks().find(track => track.getType() === GlobalTrackType.Signature);

    expect(signatureTrack).toBeDefined();
    signatureTrack?.addRegion(new KGKeySignatureRegion('signature-1', signatureTrack.getId(), signatureTrack.getTrackIndex(), 'G major', 4, 12, 4));

    await storage.save('Signature Song', project);

    const loaded = await storage.load('Signature Song');
    const loadedSignatureTrack = loaded?.getGlobalTracks().find(track => track.getType() === GlobalTrackType.Signature);

    expect(loadedSignatureTrack).toBeDefined();
    expect(loadedSignatureTrack?.getRegions()).toHaveLength(1);
    expect(loadedSignatureTrack?.getRegions()[0]).toBeInstanceOf(KGKeySignatureRegion);
    expect((loadedSignatureTrack?.getRegions()[0] as KGKeySignatureRegion).getKeySignature()).toBe('G major');
    expect((loadedSignatureTrack?.getRegions()[0] as KGKeySignatureRegion).getStartBar()).toBe(4);
  });

  it('preserves chord regions when saving and loading', async () => {
    const project = createTestProject('Chord Song');
    const chordTrack = project.getGlobalTracks().find(track => track.getType() === GlobalTrackType.Chord);

    expect(chordTrack).toBeDefined();
    chordTrack?.addRegion(new KGChordRegion('chord-1', chordTrack.getId(), chordTrack.getTrackIndex(), 'Bm7b5', 5, 3));

    await storage.save('Chord Song', project);

    const loaded = await storage.load('Chord Song');
    const loadedChordTrack = loaded?.getGlobalTracks().find(track => track.getType() === GlobalTrackType.Chord);

    expect(loadedChordTrack).toBeDefined();
    expect(loadedChordTrack?.getRegions()).toHaveLength(1);
    expect(loadedChordTrack?.getRegions()[0]).toBeInstanceOf(KGChordRegion);
    expect((loadedChordTrack?.getRegions()[0] as KGChordRegion).getSymbol()).toBe('Bm7b5');
  });

  it('creates meta.json and media/ directory on save', async () => {
    const project = createTestProject('My Song');
    await storage.save('My Song', project);

    const projectsDir = await mockRoot.getDirectoryHandle('projects');
    const projectDir = await projectsDir.getDirectoryHandle('My Song');

    // meta.json should exist
    const metaHandle = await projectDir.getFileHandle('meta.json');
    const metaFile = await metaHandle.getFile();
    const meta = JSON.parse(await metaFile.text());
    expect(meta.name).toBe('My Song');
    expect(meta.createdAt).toBeGreaterThan(0);
    expect(meta.updatedAt).toBeGreaterThan(0);

    // media/ directory should exist
    const mediaDir = await projectDir.getDirectoryHandle('media');
    expect(mediaDir.kind).toBe('directory');
  });

  it('throws DuplicateEntryError when overwrite is false', async () => {
    const project = createTestProject('Duplicate');
    await storage.save('Duplicate', project);

    await expect(storage.save('Duplicate', project, false)).rejects.toThrow(DuplicateEntryError);
  });

  it('allows overwrite when overwrite is true', async () => {
    const project = createTestProject('Overwrite Test');
    await storage.save('Overwrite Test', project);

    project.setBpm(140);
    await storage.save('Overwrite Test', project, true);

    const loaded = await storage.load('Overwrite Test');
    expect(loaded!.getBpm()).toBe(140);
  });

  it('preserves createdAt on overwrite', async () => {
    const project = createTestProject('Preserve');
    await storage.save('Preserve', project);

    // Read the original createdAt
    const projectsDir = await mockRoot.getDirectoryHandle('projects');
    const projectDir = await projectsDir.getDirectoryHandle('Preserve');
    const metaHandle1 = await projectDir.getFileHandle('meta.json');
    const meta1 = JSON.parse(await (await metaHandle1.getFile()).text());

    // Save again (overwrite)
    await storage.save('Preserve', project, true);

    const metaHandle2 = await projectDir.getFileHandle('meta.json');
    const meta2 = JSON.parse(await (await metaHandle2.getFile()).text());

    expect(meta2.createdAt).toBe(meta1.createdAt);
    expect(meta2.updatedAt).toBeGreaterThanOrEqual(meta1.updatedAt);
  });

  it('lists project names', async () => {
    await storage.save('Alpha', createTestProject('Alpha'));
    await storage.save('Beta', createTestProject('Beta'));
    await storage.save('Charlie', createTestProject('Charlie'));

    const names = await storage.list();
    expect(names).toEqual(['Alpha', 'Beta', 'Charlie']);
  });

  it('checks if project exists', async () => {
    expect(await storage.exists('Nonexistent')).toBe(false);

    await storage.save('Exists', createTestProject('Exists'));
    expect(await storage.exists('Exists')).toBe(true);
  });

  it('deletes a project', async () => {
    await storage.save('ToDelete', createTestProject('ToDelete'));
    expect(await storage.exists('ToDelete')).toBe(true);

    await storage.delete('ToDelete');
    expect(await storage.exists('ToDelete')).toBe(false);
  });

  it('returns null for non-existent project on load', async () => {
    const result = await storage.load('Ghost');
    expect(result).toBeNull();
  });

  it('rejects invalid project names on save', async () => {
    const project = createTestProject();
    await expect(storage.save('my/song', project)).rejects.toThrow('Invalid project name');
    await expect(storage.save('my:song', project)).rejects.toThrow('Invalid project name');
    await expect(storage.save('', project)).rejects.toThrow('Invalid project name');
  });

  it('renames a project', async () => {
    await storage.save('Old Name', createTestProject('Old Name'));

    await storage.rename('Old Name', 'New Name');

    expect(await storage.exists('Old Name')).toBe(false);
    expect(await storage.exists('New Name')).toBe(true);

    const loaded = await storage.load('New Name');
    expect(loaded!.getName()).toBe('New Name');
  });

  it('copies conversation history when saving under a new project name', async () => {
    await storage.save('Source Song', createTestProject('Source Song'));
    await conversationStorage.saveConversation('Source Song', {
      version: 1,
      conversationId: 'conv_1',
      continuationState: {
        messages: [{ id: 'm1', role: 'user', content: 'hello', timestamp: 1 }],
        todos: [],
      },
      fullHistory: {
        messages: [{ id: 'm1', role: 'user', content: 'hello', timestamp: 1 }],
      },
      displayTranscript: [{ id: 'display_1', role: 'user', content: 'hello' }],
    }, {
      conversationId: 'conv_1',
      title: 'hello',
      createdAt: 1,
      updatedAt: 1,
      lastTurnAt: 1,
      messageCount: 1,
      preview: 'hello',
    });

    await storage.saveAs('Source Song', 'Copied Song', createTestProject('Copied Song'));

    const loadedConversation = await conversationStorage.loadConversation('Copied Song', 'conv_1');
    expect(loadedConversation?.document.conversationId).toBe('conv_1');
  });

  it('includes conversation history in project bundle export and import', async () => {
    await storage.save('Bundle Song', createTestProject('Bundle Song'));
    await conversationStorage.saveConversation('Bundle Song', {
      version: 1,
      conversationId: 'conv_bundle',
      continuationState: {
        messages: [{ id: 'm1', role: 'user', content: 'bundle', timestamp: 1 }],
        todos: [],
      },
      fullHistory: {
        messages: [{ id: 'm1', role: 'user', content: 'bundle', timestamp: 1 }],
      },
      displayTranscript: [{ id: 'display_1', role: 'user', content: 'bundle' }],
    }, {
      conversationId: 'conv_bundle',
      title: 'bundle',
      createdAt: 1,
      updatedAt: 1,
      lastTurnAt: 1,
      messageCount: 1,
      preview: 'bundle',
    });

    const bundle = await storage.exportAsZip('Bundle Song');
    const importedName = await storage.importFromZip(bundle);
    const loadedConversation = await conversationStorage.loadConversation(importedName, 'conv_bundle');

    expect(loadedConversation?.document.displayTranscript).toEqual([
      { id: 'display_1', role: 'user', content: 'bundle' },
    ]);
  });
});