import { mkdtempSync, readFileSync } from 'node:fs';
import { tmpdir } from 'node:os';
import { join } from 'node:path';

import {
  _electron as electron,
  expect,
  test,
  type ElectronApplication,
  type Page,
} from '@playwright/test';

/**
 * Rauchtest: Startet die gebaute Anwendung wirklich?
 *
 * Die Modultests pruefen Fachlogik, Ausdruck und Oberflaechenfunktionen -
 * aber keiner von ihnen startet das Programm. Genau dort liegen die Fehler, die
 * erst beim Anwender auffallen: ein Preload-Bundle, das nach dem Bauen nicht
 * mehr passt; ein Pfad, der nur im Paket anders liegt; eine Sicherheits-
 * richtlinie, die das Einsetzen beim Bauen nicht ueberlebt hat und die eigenen
 * Skripte blockt.
 *
 * Dieser Test laeuft deshalb gegen `build/` - gegen das Erzeugnis, nicht gegen
 * den Quelltext. Er braucht `npm run build` davor; `npm run e2e` erledigt das.
 *
 * Er prueft bewusst wenig, aber das Richtige: Startet sie, ist die Bruecke
 * vollstaendig, haelt die Abschottung, und kam die Sicherheitsrichtlinie an?
 */

const WURZEL = join(__dirname, '..');

/** Die Methoden, die `electron/preload.ts` ueber contextBridge freigibt. */
const BRUECKE = [
  'platform',
  'saveFile',
  'openFile',
  'writeFile',
  'readFile',
  'setDirty',
  'reportError',
  'logPath',
  'fetchMapImage',
  'onMenuCommand',
  'onBeforeClose',
] as const;

let anwendung: ElectronApplication;
let fenster: Page;
const fehlerBeimStart: string[] = [];

test.beforeAll(async () => {
  /*
   * Eigenes, leeres Anwenderverzeichnis je Lauf.
   *
   * Ohne das laeuft der Rauchtest gegen den Sitzungsspeicher des Rechners, auf
   * dem er startet - und beurteilt damit nicht das Erzeugnis, sondern was
   * jemand zuletzt darin bearbeitet hat. Gemessen: Beim ersten Lauf gruen, beim
   * zweiten rot, weil der erste beim Schliessen seinen Stand hinterlassen
   * hatte. Ein Rauchtest, dessen Ergebnis vom vorigen Lauf abhaengt, taugt als
   * Wache nichts.
   *
   * Geprueft wird damit der Start, den ein Anwender nach der Installation
   * vorfindet.
   */
  const anwenderverzeichnis = mkdtempSync(join(tmpdir(), 'lsa-planer-rauchtest-'));

  anwendung = await electron.launch({
    args: [WURZEL, `--user-data-dir=${anwenderverzeichnis}`],
    cwd: WURZEL,
  });

  fenster = await anwendung.firstWindow();

  // Alles einsammeln, was der Renderer beim Hochfahren an Fehlern wirft.
  // Ein Programm, das startet und dabei Ausnahmen schluckt, ist nicht heil.
  fenster.on('pageerror', (fehler) => fehlerBeimStart.push(String(fehler)));
  fenster.on('console', (zeile) => {
    if (zeile.type() === 'error') {
      fehlerBeimStart.push(zeile.text());
    }
  });

  await fenster.waitForLoadState('domcontentloaded');
});

test.afterAll(async () => {
  // Das Fragezeichen sieht nach dem Typ ueberfluessig aus (der Linter meldet
  // es auch), ist es aber nicht: `anwendung` wird erst in beforeAll gesetzt.
  // Schlaegt der Start fehl, laeuft afterAll trotzdem - und ohne die Abfrage
  // ueberdeckte hier ein TypeError den eigentlichen Startfehler, also genau
  // die Meldung, wegen der es diesen Test gibt.
  // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition -- anwendung ist vor beforeAll undefined; siehe darueber
  await anwendung?.close();
});

test('das Fenster oeffnet sich und der Renderer setzt den Titel', async () => {
  // Nicht auf den festen Titel aus index.html pruefen: Den traegt das Fenster
  // schon, bevor irgendetwas laeuft. Die Anwendung stellt ihm zur Laufzeit den
  // Projektnamen voran - genau daran zeigt sich, dass der Renderer uebernommen
  // hat und nicht bloss die HTML-Huelle dasteht.
  await expect(fenster).toHaveTitle(/^Projekt .+ – LSA-Planer Professional$/u);
});

test('die Oberflaeche baut sich auf, nicht nur die leere Huelle', async () => {
  const wurzel = fenster.locator('#anwendung');
  await expect(wurzel).toBeAttached();

  // Ohne diese Pruefung wuerde auch eine Anwendung bestehen, die zwar ein
  // Fenster oeffnet, in dem aber nur das <noscript> aus index.html steht.
  await expect
    .poll(async () => (await wurzel.innerHTML()).length, { timeout: 15_000 })
    .toBeGreaterThan(500);
});

test('das Fenster laesst sich nicht wegnavigieren', async () => {
  /*
   * DIE NAVIGATIONSGRENZE AM GEBAUTEN STAND.
   *
   * `will-navigate` in electron/main.ts bricht jede Navigation ab, die nicht
   * die geladene `index.html` ist. Bis zu dieser Fassung pruefte das kein
   * einziger Test - waehrend `vitest.config.ts` die Abdeckungsluecke in
   * `electron/main.ts` ausdruecklich damit begruendete, "genau das" pruefe der
   * Rauchtest hier. Sechs Faelle, null Nennungen: eine Ausnahme, gedeckt von
   * einem Test, den es nicht gab.
   *
   * WARUM MIT `http:` UND NICHT MIT `https:`: Eine https-Adresse gibt die
   * Wache an den Standardbrowser weiter - dieser Test oeffnete dann bei jedem
   * Lauf ein Browserfenster auf dem Rechner dessen, der ihn faehrt. Geprueft
   * wird deshalb hier die Verdrahtung an einer Adresse, die NICHT hinausgeht;
   * dass die Entscheidung fuer jedes Protokoll richtig faellt, prueft
   * `tests/tools/navigationGrenze.test.ts` an der reinen Funktion.
   *
   * Die Adresse zeigt auf `.invalid` - eine Namensendung, die nach RFC 2606
   * niemals aufgeloest wird. Selbst wenn die Wache fiele, ginge kein Abruf an
   * einen fremden Rechner.
   */
  const vorher = fenster.url();
  expect(vorher, 'der Rauchtest laeuft nicht auf der eigenen Seite').toContain('index.html');

  await fenster.evaluate(() => {
    globalThis.location.href = 'http://wegnavigiert.invalid/';
  });

  // Kurz warten: Eine Navigation, die durchginge, braucht einen Augenblick.
  await fenster.waitForTimeout(500);
  expect(fenster.url(), 'das Fenster hat die eigene Seite verlassen').toBe(vorher);

  /*
   * Und die Oberflaeche steht noch - ein Abbruch, der das Dokument leert, waere
   * kein Abbruch.
   *
   * Ueber `evaluate` und nicht ueber einen Locator: Chromium fuehrt nach dem
   * abgebrochenen Versuch noch eine schwebende Navigation, und `toBeAttached`
   * wartet darauf, dass sie endet - sie endet nie, und der Fall lief in die
   * Zeitschranke, obwohl die Wache getan hatte, was sie soll. GEMESSEN: Die
   * Zeile darueber war gruen, erst diese fiel. `evaluate` fragt den
   * gegenwaertigen Baum, ohne auf eine Navigation zu warten.
   */
  const stehtNoch = await fenster.evaluate(
    () => document.getElementById('anwendung')?.childElementCount ?? 0,
  );
  expect(stehtNoch, 'die Oberflaeche ist beim Abbruch leer geworden').toBeGreaterThan(0);
});

test('der Renderer meldet beim Start keine Fehler', () => {
  expect(fehlerBeimStart).toEqual([]);
});

test('die Bruecke ist vollstaendig freigegeben', async () => {
  const vorhanden = await fenster.evaluate(() => {
    const bruecke = (globalThis as unknown as { lsaPlaner?: Record<string, unknown> }).lsaPlaner;
    return bruecke ? Object.keys(bruecke).sort() : null;
  });

  expect(vorhanden).not.toBeNull();
  for (const name of BRUECKE) {
    expect(vorhanden).toContain(name);
  }
});

test('der Renderer kommt nicht an Node heran', async () => {
  // contextIsolation und sandbox stehen in electron/main.ts. Ob sie im
  // gebauten Stand tatsaechlich greifen, zeigt sich nur hier: Kaeme der
  // Renderer an `require`, waere die Abschottung offen, und eine praeparierte
  // Projektdatei koennte beliebigen Code ausfuehren.
  const erreichbar = await fenster.evaluate(() => {
    const global = globalThis as unknown as Record<string, unknown>;
    return {
      require: typeof global.require,
      process: typeof global.process,
      module: typeof global.module,
      electron: typeof global.electron,
    };
  });

  expect(erreichbar).toEqual({
    require: 'undefined',
    process: 'undefined',
    module: 'undefined',
    electron: 'undefined',
  });
});

test('die Sicherheitsrichtlinie hat das Bauen ueberstanden', () => {
  // Das Einsetzen erledigt ein Vite-Plugin (vite.config.ts,
  // "lsa-inhaltssicherheitsrichtlinie") und nur im Auslieferungsstand. Faellt
  // es aus, sieht man das dem laufenden Programm nicht an - die Anwendung
  // startet weiterhin, nur ohne Richtlinie.
  const html = readFileSync(join(WURZEL, 'build', 'renderer', 'index.html'), 'utf8');

  expect(html).toContain('http-equiv="Content-Security-Policy"');
  expect(html).toContain("default-src 'none'");
  expect(html).not.toContain('<!--sicherheitsrichtlinie-->');
});