import { beforeAll, describe, expect, it, vi } from 'vitest';
import { ladeSitzung, saveProjectToFile, saveSession } from '@/services/storage';
import type { FileOperationResult } from '@/services/storage';

/**
 * Aenderungen waehrend des Dateischreibens duerfen nicht als gespeichert gelten
 * (Befund 16).
 *
 * Was der Anwender sonst erlebt: Ein Projekt mit eingebettetem Luftbild liegt
 * auf einem Netzlaufwerk. Er drueckt Strg+S und arbeitet waehrend des
 * Schreibens weiter - eine Fahrlinie ziehen, in ein Textfeld tippen. Der
 * Dateiinhalt steht seit dem Aufruf fest (`serializeProject` laeuft vor dem
 * `await`), die Aenderung ist also nicht darin. Danach loescht
 * `store.markSaved()` die Aenderungsmarke trotzdem: Die Kopfzeile meldet
 * "gespeichert", "Neu" und "Öffnen" verwerfen ohne Rueckfrage, und die Datei -
 * die angeordnete Unterlage - traegt still den aelteren Stand.
 *
 * Geprueft wird am echten Einstiegspunkt: `src/main.ts` wird eingelesen und
 * startet die ganze Anwendung; ersetzt sind nur Sitzungsspeicher und
 * Dateizugriff.
 */

vi.mock('@/services/storage', async (importOriginal) => {
  const echt = await importOriginal<typeof import('@/services/storage')>();
  return {
    ...echt,
    ladeSitzung: vi.fn(),
    saveSession: vi.fn(),
    addRecoveryPoint: vi.fn(),
    saveProjectToFile: vi.fn(),
  };
});

async function warte(ms = 0): Promise<void> {
  await new Promise((fertig) => setTimeout(fertig, ms));
}

function offeneFenster(): string[] {
  return [...document.querySelectorAll('.dialog-hintergrund h2')].map(
    (h) => h.textContent?.trim() ?? '',
  );
}

/** Das Eingabefeld zu einer sichtbaren Beschriftung. */
function feld(beschriftung: string): HTMLInputElement {
  const label = [...document.querySelectorAll('label')].find(
    (l) => l.textContent?.trim() === beschriftung,
  );
  const id = label?.getAttribute('for');
  const eingabe = id === null || id === undefined ? null : document.getElementById(id);
  if (!(eingabe instanceof HTMLInputElement)) {
    throw new Error(`Eingabefeld "${beschriftung}" nicht gefunden.`);
  }
  return eingabe;
}

function druecke(taste: string): void {
  window.dispatchEvent(
    new KeyboardEvent('keydown', { key: taste, ctrlKey: true, bubbles: true, cancelable: true }),
  );
}

/** Der Dateischreibvorgang, der erst auf Zuruf fertig wird. */
let fertigstellen: ((ergebnis: FileOperationResult) => void) | null = null;

beforeAll(async () => {
  vi.mocked(ladeSitzung).mockResolvedValue({ art: 'leer' });
  vi.mocked(saveSession).mockResolvedValue({ ok: true, message: '' });
  vi.mocked(saveProjectToFile).mockReturnValue(
    new Promise<FileOperationResult>((erfuellen) => {
      fertigstellen = erfuellen;
    }),
  );

  document.body.replaceChildren();
  const wurzel = document.createElement('div');
  wurzel.id = 'anwendung';
  document.body.append(wurzel);

  await import('@/main');
  await warte(20);
});

describe('Aenderung waehrend des Dateischreibens', () => {
  it('behaelt die Aenderungsmarke, wenn sich das Projekt inzwischen geaendert hat', async () => {
    druecke('s');
    await warte(0);
    expect(saveProjectToFile).toHaveBeenCalledTimes(1);

    // Der Schreibvorgang laeuft noch - der Anwender tippt weiter.
    const name = feld('Projektbezeichnung');
    name.value = 'Bahnhofstraße / Ringstraße';
    name.dispatchEvent(new Event('change'));
    await warte(0);

    fertigstellen?.({
      ok: true,
      canceled: false,
      filePath: 'C:/Plaene/knoten.lsap',
      message: 'Projekt gespeichert.',
    });
    await warte(20);

    // Die Probe: Steht der Stand noch aus, muss "Neu" zurueckfragen.
    druecke('n');
    await warte(10);
    expect(offeneFenster()).toEqual(['Ungespeicherte Änderungen']);

    document.querySelector<HTMLButtonElement>('.dialog-hintergrund button')?.click();
  });
});