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

/**
 * Befund 14 zur Fassung 5.9.0.
 *
 * `saveProject` fuehrte kein Merkmal "laeuft gerade". Weder die
 * Kopfzeilenschaltflaeche (sie bekommt kein `enabled` und ist damit nie
 * gesperrt) noch der Tastenweg noch der Menuebefehl hielten einen zweiten Lauf
 * auf. Der Waechter aus Befund 16 vergleicht nur den EIGENEN Stand mit dem
 * jetzigen und weiss von einem zweiten Lauf nichts.
 *
 * Folge bei zwei ueberlappenden Laeufen mit verschiedenem Inhalt (A alt, B neu):
 * Lauf B endet zuerst, sieht seinen Stand unveraendert und ruft `markSaved` -
 * die Aenderungsmarke faellt, Kopfzeile und Fenstertitel melden "gespeichert".
 * Lauf A endet danach, benennt zuletzt um und legt damit den AELTEREN Stand auf
 * die Platte; er warnt zwar, ruft aber nur `setFilePath` - die Marke bleibt
 * geloescht. Der Anwender hat danach eine Datei mit dem alten Stand, ein
 * Programm, das "gespeichert" sagt, und keinen Waechter mehr vor "Neu",
 * "Öffnen" oder dem Schliessen. Ging bei dem Stand ein VERLAENGERTER Raeumweg
 * verloren, traegt die angeordnete Unterlage weiter die kuerzere Zwischenzeit.
 *
 * Der Sitzungsspeicher fuehrt denselben Riegel laengst (services/autosave.ts:
 * "Es laeuft nie mehr als ein Schreibvorgang gleichzeitig").
 *
 * 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 }),
  );
}

function benenne(name: string): void {
  const eingabe = feld('Projektbezeichnung');
  eingabe.value = name;
  eingabe.dispatchEvent(new Event('change'));
}

/** Jeder Aufruf bekommt seine eigene Zusage, die erst auf Zuruf fertig wird. */
const offeneSchreibvorgaenge: ((ergebnis: FileOperationResult) => void)[] = [];

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

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

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

describe('Ein zweites Strg+S während des Schreibens', () => {
  it('startet keinen zweiten Speichervorgang daneben', async () => {
    benenne('Bahnhofstraße');
    await warte(0);

    druecke('s');
    await warte(0);
    expect(saveProjectToFile).toHaveBeenCalledTimes(1);

    // Der Schreibvorgang laeuft noch - der Anwender berichtigt einen Raeumweg
    // und drueckt erneut Strg+S.
    benenne('Bahnhofstraße / Ringstraße');
    await warte(0);
    druecke('s');
    await warte(10);

    expect(
      saveProjectToFile,
      'Ein zweiter Speichervorgang laeuft neben dem ersten',
    ).toHaveBeenCalledTimes(1);
  });

  it('lässt die Änderungsmarke stehen, weil der geschriebene Stand nicht mehr gilt', async () => {
    // Alles, was noch aussteht, wird fertig. Beim Riegel ist das genau ein
    // Lauf, und er trug den Stand von vor der zweiten Eingabe. Ohne den Riegel
    // sind es zwei, und der zweite - mit dem jetzt geltenden Stand - loeschte
    // die Aenderungsmarke, obwohl der erste danach den aelteren Stand auf die
    // Platte legt.
    while (offeneSchreibvorgaenge.length > 0) {
      offeneSchreibvorgaenge.shift()?.({
        ok: true,
        canceled: false,
        filePath: 'C:/Plaene/knoten.lsap',
        message: 'Gespeichert: C:/Plaene/knoten.lsap',
      });
    }
    await warte(20);

    // Die Probe: Steht der Stand noch aus, muss "Neu" zurueckfragen. Ohne den
    // Riegel haette der zweite Lauf hier bereits `markSaved` gerufen.
    druecke('n');
    await warte(10);
    expect(offeneFenster()).toEqual(['Ungespeicherte Änderungen']);

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