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

/**
 * Befund 22 zur Fassung 5.9.0, der Rest.
 *
 * "Datei > Speichern" und "Datei > Speichern unter" tragen bereits
 * den Waechter `if (offeneFensterAnzahl() > 0) break;`. `case 'export'`
 * trug ihn nicht - und ein Ansichtswechsel ist hier kein harmloserer Vorgang
 * als ein Speichervorgang:
 *
 *  1. `shell.navigate` ist ein ORTSWECHSEL und endet mit `ziel.focus()` auf der
 *     Ueberschrift der neuen Ansicht. Der Hintergrund ist hinter einem modalen
 *     Fenster stillgelegt (`legeHintergrundStill`, aria-hidden und inert) - der
 *     Fokus wird also aus dem offenen Fenster heraus in einen stillgelegten
 *     Teilbaum gesetzt. Genau diesen Zustand beschreiben die
 *     Befunde M1/M8 als unzulaessig, und
 *     eine Sprachausgabe liest dann Inhalte vor, die optisch nicht da sind.
 *  2. Der Tastenempfaenger in `src/main.ts` bricht aus demselben Grund schon
 *     bei Strg+Z ab: "Strg+Z/Strg+Y bauten die stillgelegte Ansicht unter dem
 *     Dialog neu auf". Ein Ortswechsel tut mehr als ein Neuaufbau - er raeumt
 *     die Ansicht ab, aus der das offene Fenster stammt.
 *
 * Geprueft wird am echten Einstiegspunkt: `src/main.ts` startet die ganze
 * Anwendung; ersetzt sind nur Sitzungsspeicher, Dateizugriff und die
 * Desktop-Bruecke, ueber die der Menuebefehl hereinkommt.
 */

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() ?? '',
  );
}

/** Die Ueberschrift der gerade sichtbaren Ansicht. */
function sichtbareAnsicht(): string {
  return document.querySelector('main h1')?.textContent?.trim() ?? '';
}

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 Menuebefehl, so wie ihn der Hauptprozess schickt. */
let sendeMenuebefehl: (befehl: MenuCommand) => void = () => undefined;

beforeAll(async () => {
  vi.mocked(ladeSitzung).mockResolvedValue({ art: 'leer' });
  vi.mocked(saveSession).mockResolvedValue({ ok: true, message: '' });
  vi.mocked(saveProjectToFile).mockResolvedValue({
    ok: true,
    canceled: false,
    filePath: 'C:/Plaene/knoten.lsap',
    message: 'Gespeichert: C:/Plaene/knoten.lsap',
  });

  (window as unknown as { lsaPlaner: unknown }).lsaPlaner = {
    platform: 'electron',
    appVersion: 'pruefung',
    setDirty: () => undefined,
    reportError: () => undefined,
    logPath: () => Promise.resolve('C:/Protokoll/lsa-planer.log'),
    onMenuCommand: (behandler: (befehl: MenuCommand) => void) => {
      sendeMenuebefehl = behandler;
      return () => undefined;
    },
    onBeforeClose: () => undefined,
  };

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

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

describe('Datei > Ausgabe aus dem Anwendungsmenü', () => {
  it('wechselt hinter einem offenen Fenster die Ansicht nicht', async () => {
    const name = feld('Projektbezeichnung');
    name.value = 'Bahnhofstraße';
    name.dispatchEvent(new Event('change'));
    await warte(0);

    expect(sichtbareAnsicht(), 'Vorbedingung: die Anwendung steht in "Projekt"').toBe('Projekt');

    // Der Anwender greift zu "Neu"; wegen der ungespeicherten Aenderung steht
    // die Rueckfrage offen. Das Anwendungsmenue bleibt daneben bedienbar - es
    // wird von der Stilllegung des Hintergrunds nicht erfasst.
    druecke('n');
    await warte(10);
    expect(offeneFenster()).toEqual(['Ungespeicherte Änderungen']);
    const dialog = document.querySelector('.dialog-hintergrund .dialog');
    expect(
      dialog?.contains(document.activeElement),
      'Vorbedingung: der Fokus steht im Fenster',
    ).toBe(true);

    sendeMenuebefehl('export');
    await warte(10);

    expect(
      sichtbareAnsicht(),
      'Der Menueweg wechselt hinter der offenen Rueckfrage die Ansicht',
    ).toBe('Projekt');
    expect(
      dialog?.contains(document.activeElement),
      'Der Ansichtswechsel zieht den Fokus aus dem offenen Fenster in den stillgelegten Hintergrund',
    ).toBe(true);
    expect(offeneFenster()).toEqual(['Ungespeicherte Änderungen']);

    // Die Rueckfrage abbrechen; das Fenster ist danach vom Stapel.
    document.querySelector<HTMLButtonElement>('.dialog-hintergrund button')?.click();
    await warte(10);
    expect(offeneFenster()).toEqual([]);
  });

  it('wechselt ohne offenes Fenster weiterhin in die Ausgabe', async () => {
    // Grenzwache zur vorigen Pruefung: Der Waechter darf den Regelweg nicht
    // mitsperren.
    sendeMenuebefehl('export');
    await warte(10);

    expect(sichtbareAnsicht()).toBe('Ausgabe');
  });
});