import { existsSync, readFileSync, statSync } from 'node:fs';
import path from 'node:path';
import { describe, expect, it } from 'vitest';
import { ANSICHT_DATEINAME } from '@/../electron/schriftgroesse';
import { PRUEFSTAND_LABELS, QUELLEN } from '@/domain/rilsa/quellen';
import { PROJECT_FILE_EXTENSION, PROJECT_FILE_FILTERS } from '@/services/storage';

/**
 * `LIESMICH.txt` - das einzige Blatt im Paket, das sich an den Empfaenger
 * richtet.
 *
 * WARUM ES SIE GIBT. Neben der Programmdatei lagen sieben Beilagen, und alle
 * sieben waren Lizenztexte. Wer das Paket bekam, fand kein Wort darueber, was
 * Windows beim Start eines unsignierten Installationsprogramms meldet, welche
 * der beiden fast gleich grossen Programmdateien er nehmen soll, wo seine
 * Daten liegen und woher eine neue Fassung kommt.
 *
 * SEIT 5.43.0 GILT DAS BLATT FUER JEDEN WEG ZUM PROGRAMM ZUGLEICH. Es geht mit
 * jedem Paket und muss deshalb fuer Setup, tragbare Fassung und jede andere
 * Installationsart gleichzeitig wahr sein. Vier Aussagen waren es nur fuer die
 * ersten beiden: die fehlende Signatur, die Pruefsumme, das Selbstholen neuer
 * Fassungen und der Datenordner. Die Faelle dazu pruefen deshalb nicht mehr das
 * ganze Blatt, sondern den Abschnitt und den Satz, in dem die Aussage steht -
 * eine Warnung "NICHT signiert" irgendwo im Blatt waere auch dann gruen, wenn
 * sie sich auf ein Paket bezoege, das ein Vertriebsdienst selbst signiert. Bei
 * derselben Durchsicht fiel die Abgrenzung auf: Sie nannte die Koordinierung
 * mehrerer Anlagen als etwas, das das Programm nicht tut, und die gibt es seit
 * 5.35.0.
 *
 * WIEDERHERGESTELLT NOCH IN FASSUNG 5.43.0. Bei dieser Durchsicht war der Fall
 * zu den Vorbehalten des Blattes (offene Kennwerte, fachliche Verantwortung,
 * kein PDF/UA, kein Konformitaetsnachweis) ersatzlos weggefallen, und kein
 * anderer Test las diese Saetze. Er steht wieder da, auf den Abschnitt
 * eingegrenzt - und nicht mehr mit "abzugleichen" irgendwo im Blatt: Der Satz
 * dazu war falsch ("Fuenf rechenwirksame Kennwerte tragen dort abzugleichen ...
 * nicht an einer Originalausgabe nachgeschlagen"), und die alte Pruefung hielt
 * ihn gruen. Die Zahl haengt jetzt an einer eigenen Pruefung. Im selben Zug
 * bekam die Pruefsumme ihre Grenze: Das Blatt sagte, sie belege die
 * ausgelieferte Datei, und damit mehr als PRUEFSUMMEN-<Fassung>.txt selbst.
 *
 * WAS DIESE DATEI BEWACHT, ist nicht die Prosa, sondern die pruefbaren
 * Angaben darin: die Dateinamen im Benutzerprofil, die Liste der Beilagen und
 * die Zusagen, die anderswo im Baum eine Entsprechung haben. Ein Beiblatt, das
 * still veraltet, ist schlimmer als keines - der Empfaenger richtet sich
 * danach.
 *
 * WAS SIE NICHT KANN: pruefen, ob der Text verstaendlich ist. Das entscheidet,
 * wer ihn liest. Und die Messungen an einer Installation wiederholen, bei der
 * Windows die Benutzerdaten gesondert fuehrt - die stehen mit Datum im Blatt
 * und in docs/datenschutz.md, und ein Testfall installiert kein Programm.
 */

const LIESMICH = readFileSync('LIESMICH.txt', 'utf8');
const EINZEILIG = LIESMICH.replace(/\s+/gu, ' ');
const PAKET = JSON.parse(readFileSync('package.json', 'utf8')) as {
  readonly name: string;
  readonly version: string;
  readonly build: {
    readonly extraFiles: readonly { readonly from: string; readonly to: string }[];
    readonly productName: string;
  };
};

/** Eine Ueberschrift des Blattes: eine Zeile nur aus Grossbuchstaben und Satzzeichen. */
const UEBERSCHRIFT = /^[A-ZÄÖÜ][A-ZÄÖÜ .,-]*$/u;

/**
 * Der Text unter einer Ueberschrift bis zur naechsten, auf eine Zeile
 * zusammengezogen. Fehlt die Ueberschrift, schlaegt der Fall hier fehl und
 * nicht erst an einem leeren Text, der alles `not.toContain` besteht.
 */
function abschnitt(titel: string): string {
  const zeilen = LIESMICH.split(/\r?\n/u);
  const anfang = zeilen.indexOf(titel);
  expect(anfang, `Abschnitt "${titel}" fehlt im Blatt`).toBeGreaterThanOrEqual(0);
  const rest = zeilen.slice(anfang + 1);
  const ende = rest.findIndex((zeile) => UEBERSCHRIFT.test(zeile));
  return (ende < 0 ? rest : rest.slice(0, ende)).join(' ').replace(/\s+/gu, ' ');
}

/** Zahlwoerter, wie das Blatt sie schreibt. */
const ZAHLWOERTER: Readonly<Record<string, number>> = {
  zwei: 2,
  drei: 3,
  vier: 4,
  fünf: 5,
  sechs: 6,
  sieben: 7,
  acht: 8,
  neun: 9,
  zehn: 10,
  elf: 11,
  zwölf: 12,
};

/** Der eine Satz eines Abschnitts, der `teil` enthaelt. */
function satzMit(text: string, teil: string): string {
  const treffer = text.split(/(?<=[.!?])\s+/u).filter((satz) => satz.includes(teil));
  expect(treffer, `kein Satz mit "${teil}"`).toHaveLength(1);
  return String(treffer[0]);
}

describe('LIESMICH.txt geht mit dem Paket', () => {
  it('steht in build.extraFiles und liegt im Baum', () => {
    const namen = PAKET.build.extraFiles.map((e) => e.to);
    expect(namen, 'die Datei geht nicht mit').toContain('LIESMICH.txt');
    expect(existsSync('LIESMICH.txt')).toBe(true);
  });

  it('zaehlt die Beilagen auf, die wirklich mitgehen', () => {
    /*
     * Die Liste am Ende des Blattes nennt, was daneben liegt. Kommt eine
     * Beilage hinzu oder faellt eine fort, laeuft sie sonst auseinander - und
     * der Empfaenger sucht eine Datei, die es nicht gibt.
     *
     * Zwei der Namen stehen nicht in `extraFiles`: LICENSE.electron.txt und
     * LICENSES.chromium.html legt electron-builder von sich aus daneben, und
     * PRUEFSUMMEN-<Fassung>.txt entsteht erst beim Bau. Beide sind hier
     * namentlich ausgenommen.
     */
    for (const eintrag of PAKET.build.extraFiles) {
      if (eintrag.to === 'LIESMICH.txt') continue;
      expect(LIESMICH, `${eintrag.to} fehlt in der Aufzaehlung`).toContain(eintrag.to);
    }
  });

  it('nennt die Dateien im Benutzerprofil so, wie sie wirklich heissen', () => {
    /*
     * DER ORDNER HAENGT AM FELD name DER package.json, NICHT AM productName.
     * Hier stand `%APPDATA%\${build.productName}\`, und das Blatt nannte
     * entsprechend %APPDATA%\LSA-Planer Professional\ - einen Ordner, den
     * keine gebaute Fassung anlegt. Electron nimmt den Namen der App aus der
     * package.json IM app.asar, dort aus productName und sonst aus name, und
     * build.productName gelangt nicht dorthin. Nachgesehen am 17.09.2026 im
     * app.asar der Fassung 5.43.0 (release/win-unpacked): name
     * "lsa-planer-professional", kein productName; die Daten des Arbeitsplatzes liegen unter
     * %APPDATA%\lsa-planer-professional. Der Fall war gruen, weil er die
     * falsche Annahme mit dem falschen Text verglich.
     */
    const daten = abschnitt('WO DAS PROGRAMM DATEN ABLEGT');
    expect(daten, 'der Ordner von Setup und tragbarer Fassung').toContain(
      `%APPDATA%\\${PAKET.name}\\`,
    );
    expect(LIESMICH, 'der Ordner, den keine Fassung anlegt').not.toContain(
      `%APPDATA%\\${PAKET.build.productName}\\`,
    );
    expect(LIESMICH, 'die Ansichtsdatei').toContain(ANSICHT_DATEINAME);
    /*
     * ansicht.json fuehrt die Schriftgroesse und sonst nichts
     * (electron/schriftgroesse.ts). "Fenstergröße und zuletzt gewählte
     * Ansicht" stand hier - die Fenstergroesse kuendigt der Kopf jener Datei
     * nur als kuenftig an, die zuletzt gewaehlte Ansicht gar nicht.
     */
    const ansichtszeile = LIESMICH.split(/\r?\n/u).find((z) => z.includes(ANSICHT_DATEINAME));
    expect(String(ansichtszeile), 'was ansicht.json enthaelt').toContain('Schriftgröße');
    expect(String(ansichtszeile), 'was ansicht.json nicht enthaelt').not.toContain('Fenstergröße');
    const protokoll = readFileSync(path.join('electron', 'protokoll.ts'), 'utf8');
    const treffer = /path\.join\(verzeichnis, '([^']+)'\)/u.exec(protokoll);
    expect(treffer, 'der Name der Protokolldatei').not.toBeNull();
    /*
     * ALS GANZES WORT und nicht als Teilkette. Mit `toContain` blieb dieser
     * Fall gruen, als die Datei im Programm zu "protokoll.log" umbenannt
     * wurde: Das steht in "fehlerprotokoll.log" mit drin, und das Beiblatt
     * haette weiter den alten Namen genannt. Eine Mutation hat es gezeigt.
     */
    const name = String(treffer?.[1]);
    const alsWort = new RegExp(`(^|[^\\w.-])${name.replace(/[.]/gu, '\\.')}([^\\w-]|$)`, 'u');
    expect(alsWort.test(LIESMICH), `das Beiblatt nennt "${name}" nicht`).toBe(true);
  });

  it('nennt jede Endung, die der Speichern-Dialog fuer Projekte anbietet', () => {
    /*
     * Fassung 5.43.0: Das Blatt sagte, Projekte liegen "als Datei mit der
     * Endung .lsap" - der Speichern-Dialog bietet aber auch "JSON-Datei" an
     * (PROJECT_FILE_FILTERS), und dann liegt das Projekt mit allem, was
     * eingetragen ist, als .json da. Dieselbe Angabe in docs/datenschutz.md
     * haelt tests/domain/datenschutz.test.ts.
     */
    const satz = satzMit(abschnitt('WO DAS PROGRAMM DATEN ABLEGT'), 'Ihre Projekte liegen');
    const endungen = PROJECT_FILE_FILTERS.flatMap((filter) => [...filter.extensions]);
    expect(endungen, 'Voraussetzung: die Endung der Projektdatei').toContain(
      PROJECT_FILE_EXTENSION,
    );
    for (const endung of endungen) {
      expect(satz, `Endung .${endung}`).toMatch(new RegExp(`\\.${endung}\\b`, 'u'));
    }
  });

  it('nennt den Speicherort des Quellcodes, den auch QUELLCODE.txt nennt', () => {
    const quelle = readFileSync('QUELLCODE.txt', 'utf8');
    const adresse = /https:\/\/[\w.-]+/u.exec(quelle);
    expect(adresse, 'QUELLCODE.txt nennt keine Adresse').not.toBeNull();
    expect(LIESMICH, 'zwei Adressen fuer denselben Zweck').toContain(String(adresse?.[0]));
    /*
     * WOHER SETUP UND TRAGBARE FASSUNG KOMMEN, steht mit der Adresse selbst da.
     * Hier stand "von der Internetseite des Herausgebers", und das Hilfemenue
     * fuehrt einen Eintrag "Internetseite des Herstellers", der auf eine
     * andere Adresse geht (electron/menu.ts) - wer beide las, hielt sie fuer
     * dieselbe Seite.
     */
    const wege = abschnitt('WEGE ZUM PROGRAMM');
    expect(wege, 'die Adresse bei den Dateien von der Internetseite').toContain(
      String(adresse?.[0]),
    );
    expect(wege, 'die verwechselbare Umschreibung').not.toMatch(/Internetseite des Herausgebers/u);
    /*
     * "Dort finden Sie auch, was sich je Fassung geändert hat" stand hier, ohne
     * zu sagen, wo dort. Bis 5.43.1 nannte das Blatt dafuer eine Datei im
     * Quellcode; seit 5.43.2 geht diese Datei nicht mehr mit
     * dem Quellcode hinaus. Der erste Wortlaut zu 5.43.2 verwies stattdessen
     * auf die Seite des Programms und sagte einen Aenderungsbericht zu, der
     * die geaenderten Zahlen nennt - einen solchen Abschnitt hatte die Seite
     * nicht (nachgesehen am 18.09.2026). Das Blatt sagt jetzt nur, was ohne
     * ihn stimmt: dass sich gerechnete Zahlen aendern koennen, und wo steht,
     * was das fuer eine Unterlage heisst.
     */
    const aktualisierungen = abschnitt('AKTUALISIERUNGEN');
    expect(aktualisierungen, 'die Zusage eines Aenderungsberichts').not.toMatch(
      /Änderungsbericht|je Fassung geändert/u,
    );
    expect(aktualisierungen, 'dass sich Zahlen aendern koennen').toContain(
      'können sich gerechnete Zahlen ändern',
    );
    expect(aktualisierungen, 'der Verweis auf die Unterlagen').toContain('im nächsten Abschnitt');
  });

  it('sagt, was das Programm nicht tut - als Abgrenzung und nicht als Luecke', () => {
    /*
     * Die Abgrenzung ist eine Entscheidung des Projekts. Ein Beiblatt, das
     * dem Empfaenger etwas anderes verspricht, waere die schlechteste Art von
     * Fehler: Er merkt es erst, wenn er es braucht.
     */
    expect(EINZEILIG).toContain('verkehrsabhängige Steuerung');
    expect(EINZEILIG).toContain('Bevorrechtigung des ÖPNV');
    expect(EINZEILIG, 'als Entscheidung und nicht als Lücke').toContain(
      'getroffene Abgrenzung und keine Lücke',
    );
  });

  it('fuehrt die Koordinierung nicht mehr unter dem, was das Programm nicht tut', () => {
    /*
     * Bis 5.42.1 stand "Koordinierung mehrerer Anlagen" in der Abgrenzung,
     * obwohl es sie seit 5.35.0 gibt; das Blatt, seit 5.26.0 unveraendert, war
     * nicht nachgezogen. Geprueft wird der Absatz der Abgrenzung, nicht das
     * ganze Blatt: Anderswo darf und soll die Koordinierung vorkommen.
     */
    const absatz = /WAS ES NICHT TUT[\s\S]*?(?:\r?\n[ \t]*\r?\n|$)/u.exec(LIESMICH);
    expect(absatz, 'der Absatz der Abgrenzung fehlt').not.toBeNull();
    expect(String(absatz?.[0]), 'die Abgrenzung nennt die Koordinierung').not.toContain(
      'Koordinierung',
    );
    expect(
      abschnitt('WAS DAS PROGRAMM TUT'),
      'die Koordinierung fehlt unter dem, was es tut',
    ).toContain('Koordinierung');
    /*
     * "Lageplanzeichnung nach RSA 21" stand daneben. Ein Lageplanblatt gibt
     * es seit 5.32.0, einen bemassten Signallageplan und einen
     * Verkehrszeichenplan weiterhin nicht - das Blatt sagt beides.
     */
    expect(EINZEILIG, 'der Signallageplan').toContain('bemaßten Signallageplan');
    expect(EINZEILIG, 'der Verkehrszeichenplan').toContain('Verkehrszeichenplan');
  });

  it('verschweigt die Vorbehalte nicht, die das Programm selbst fuehrt', () => {
    /*
     * Bis 5.42.1 hier mit `toContain` ueber das ganze Blatt, darunter
     * "abzugleichen"; in 5.43.0 zunaechst gestrichen, dann
     * wiederhergestellt (Kopf dieser Datei).
     */
    const unterlagen = abschnitt('WAS SIE ÜBER DIE UNTERLAGEN WISSEN SOLLTEN');
    expect(unterlagen, 'die fachliche Verantwortung').toContain(
      'nimmt Ihnen die fachliche Verantwortung für den Plan nicht ab',
    );
    expect(unterlagen, 'die Barrierefreiheit des PDF').toContain('kein PDF/UA');
    expect(unterlagen, 'die Auskunft zur Barrierefreiheit').toContain(
      'Zur Barrierefreiheit der Bedienoberfläche gibt der Hersteller auf Anfrage Auskunft; ' +
        'sie ist kein Konformitätsnachweis.',
    );

    /*
     * DIE OFFENEN KENNWERTE. Hier stand "Fuenf rechenwirksame Kennwerte tragen
     * dort "abzugleichen": Sie sind praxisueblich, aber nicht an einer
     * Originalausgabe des Regelwerks nachgeschlagen." Die Zahl stimmte, der
     * Satz um sie herum nicht: Den Pruefstand tragen in quellen.ts neunzehn
     * Eintraege, weil er auch Werte kennzeichnet, fuer die kein Regelwerk eine
     * Zahl nennt, und von den fuenf offenen ist einer an der gekauften RiLSA
     * 2015 teilweise beantwortet. Die Zahl im Satz haelt eine eigene Pruefung.
     */
    expect(unterlagen, 'die alte Aussage').not.toMatch(
      /nicht an einer Originalausgabe[^.]*nachgeschlagen/u,
    );
    const satz = satzMit(unterlagen, 'Originalausgabe');
    const treffer = /Bei (\S+) Kennwerten aus (.+?) steht das ganz oder teilweise aus\./u.exec(
      satz,
    );
    expect(treffer, `Satz zur Zahl der offenen Kennwerte in: ${satz}`).not.toBeNull();
    const wort = treffer?.[1] ?? '';
    const offen = ZAHLWOERTER[wort] ?? Number(wort);
    expect(offen, `Zahl der offenen Kennwerte: ${wort}`).toBeGreaterThan(0);

    // Und wer die Unterlage aufschlaegt, findet den Pruefstand oefter.
    const beschriftung = PRUEFSTAND_LABELS.abzugleichen;
    const mitPruefstand = Object.values(QUELLEN).filter((q) => q.pruefstand === 'abzugleichen');
    expect(mitPruefstand.length, 'Eintraege mit dem Pruefstand').toBeGreaterThan(offen);
    expect(satzMit(unterlagen, `"${beschriftung}"`), 'mehr Kennwerte mit dem Pruefstand').toContain(
      'mehr Kennwerte',
    );
  });

  it('warnt vor dem, was Windows bei den unsignierten Dateien von der Internetseite meldet', () => {
    /*
     * EINGEGRENZT seit 5.43.0: Die Warnung gilt fuer Setup und tragbare
     * Fassung. Ein Paket, das ein Vertriebsdienst selbst signiert, ist
     * signiert; ein Satz "NICHT signiert", der nicht sagt, wofuer er gilt,
     * schickte dessen Anwender auf die Suche nach einer Pruefsumme, die es
     * fuer ihn nicht gibt.
     */
    const start = abschnitt('BEIM ERSTEN START MELDET SICH WINDOWS');
    expect(start, 'die fehlende Signatur').toContain('NICHT mit einem Codesignaturzertifikat');
    expect(start, 'was der Anwender sieht').toContain('Unbekannt');
    expect(start, 'der Rat, vorher die Prüfsumme zu rechnen').toContain('Prüfsumme');
    /*
     * WAS DIE PRUEFSUMME BELEGT, mit ihrer Grenze. Hier stand "Sie belegt, dass
     * die Datei unveraendert die ist, die ausgeliefert wurde" - unmittelbar
     * hinter dem Rat, die Warnung zu uebergehen, und staerker als
     * PRUEFSUMMEN-<Fassung>.txt selbst (scripts/pruefsummen.mjs): Wer die
     * Programmdatei austauschen kann, kann die Liste daneben ebenso
     * austauschen.
     */
    expect(start, 'die Grenze der Pruefsumme').toContain('Quelle stammt, der Sie trauen');
    expect(start, 'die Zusage ohne Grenze').not.toContain('die ausgeliefert wurde');
    const satz = satzMit(start, 'NICHT mit einem Codesignaturzertifikat');
    expect(satz, 'wofuer die fehlende Signatur gilt').toContain('Internetseite');
    expect(satz, 'die fehlende Signatur gilt nicht beim Vertriebsdienst').not.toContain(
      'Vertriebsdienst',
    );
  });

  it('sagt, dass beim Bezug ueber einen Vertriebsdienst, der selbst signiert, der Hinweis entfaellt', () => {
    const start = abschnitt('BEIM ERSTEN START MELDET SICH WINDOWS');
    const satz = satzMit(start, 'Vertriebsdienst');
    expect(satz, 'wer signiert').toContain('selbst signiert');
    expect(satz, 'dass der Hinweis dort entfaellt').toContain('diesen Hinweis nicht');
  });

  it('sagt, dass sich das Programm nicht selbst aktualisiert', () => {
    // Es gibt keinen Aktualisierungsweg im Programm; das ist eine Eigenschaft,
    // die der Empfaenger kennen muss, damit er von Zeit zu Zeit nachsieht.
    expect(EINZEILIG).toContain('sucht nicht selbst nach neuen Fassungen');
  });

  it('sagt, dass ein Vertriebsdienst selbst aktualisiert und ueber aeltere Fassungen selbst bestimmt', () => {
    /*
     * "Sucht nicht selbst" stimmt fuer das Programm auf jedem Weg - nur kommt
     * die neue Fassung ueber einen Vertriebsdienst trotzdem, auch ohne dass
     * der Anwender sie holt. Wer eine Unterlage mit ihrem Rechenstand
     * nachvollziehen muss, erfaehrt es im Abschnitt ueber die Unterlagen,
     * weil es dort darauf ankommt. Bis 5.43.1 stand dort, eine aeltere
     * Fassung gebe es auf jenem Weg nicht; das bestimmt der Dienst, nicht das
     * Programm.
     */
    expect(abschnitt('AKTUALISIERUNGEN'), 'wer ueber den Dienst aktualisiert').toContain(
      'bekommt neue Fassungen von dort',
    );
    const unterlagen = abschnitt('WAS SIE ÜBER DIE UNTERLAGEN WISSEN SOLLTEN');
    expect(unterlagen, 'die neue Fassung ohne Rueckfrage').toContain('ohne Rückfrage');
    expect(unterlagen, 'aeltere Fassungen bestimmt der Dienst').toContain(
      'ob er eine ältere herausgibt, bestimmt er',
    );
  });

  it('sagt, dass Windows das Verzeichnis je nach Installationsart gesondert fuehrt', () => {
    /*
     * Gemessen am 17.09.2026 unter Windows 11 (Build 26200): Ohne einen
     * vorhandenen %APPDATA%\lsa-planer-professional fuehrt Windows die Daten
     * je nach Installationsart in einem gesonderten Bereich, und die
     * Deinstallation entfernt sie. Seit 5.43.2 nennt das Blatt diesen Bereich
     * nicht mehr mit Pfad; es sagt, dass es ihn gibt, was mit ihm geschieht
     * und wann das nachgesehen ist.
     */
    const daten = abschnitt('WO DAS PROGRAMM DATEN ABLEGT');
    expect(daten, 'die gesonderte Ablage').toContain('Je nach Installationsart');
    expect(daten, 'was die Deinstallation tut').toContain('entfernt es mit der Deinstallation');
    expect(daten, 'das Messdatum').toContain('17.09.2026');
  });

  it('nennt die Ausnahme fuer Umsteiger, bei der der Ordner stehen bleibt', () => {
    /*
     * Die zweite Messung desselben Tages: Lag %APPDATA%\lsa-planer-professional
     * schon vom Setup oder vom tragbaren Programm da, schrieb das Programm
     * dorthin, auch neue Dateien, und nach der Deinstallation stand der
     * Ordner samt neuer Protokollzeile noch. Ein Blatt, das nur "entfernt
     * es mit der Deinstallation" sagt, verspricht dem Umsteiger eine
     * Bereinigung, die nicht stattfindet.
     */
    const daten = abschnitt('WO DAS PROGRAMM DATEN ABLEGT');
    expect(daten, 'die Ausnahme').toContain('Umsteiger');
    expect(daten, 'auch neue Dateien').toContain('auch neue Dateien');
    expect(daten, 'was dann bleibt').toContain('lässt das Verzeichnis stehen');
    const ordner = `%APPDATA%\\${PAKET.name}\\`;
    expect(daten.split(ordner).length - 1, 'der Ordner in der Ausnahme').toBeGreaterThanOrEqual(2);
    /*
     * NUR FUER DAS GEMESSENE. Gemessen ist unter Windows 11 (Build 26200);
     * das Blatt nennt als Untergrenze Windows 10 Version 1809, und fuer
     * Windows 10 vor Version 1903 beschreibt Microsoft (abgerufen am
     * 17.09.2026), dass in diesem Fall jeder Schreibzugriff unter AppData in
     * eine eigene Kopie geht - dort teilten sich die beiden Programme nichts.
     * Die Ausnahme stand als allgemeine Tatsache da.
     */
    expect(satzMit(daten, 'Umsteiger'), 'wofuer die Ausnahme gemessen ist').toContain('Windows 11');
    expect(daten, 'was unter Windows 10 nicht nachgesehen ist').toContain('unter Windows 10 nicht');
  });

  it('verspricht nach einem Absturz nicht mehr, als die Sicherung haelt', () => {
    /*
     * "er sorgt dafür, dass nach einem Absturz nichts verloren ist" stand
     * hier. src/services/autosave.ts sagt selbst weniger - gesichert wird
     * verzoegert nach der Aenderung, die letzte Eingabe kann fehlen -, das
     * Zwischenspeichern laesst sich abschalten (`autoSaveEnabled` in
     * src/services/storage.ts), und nach dem Befund 'nicht-lesbar' sperrt es
     * sich selbst. Das Blatt sagt jetzt, dass die Sicherung Arbeit retten
     * kann und das Speichern nicht ersetzt.
     */
    const einstellungen = readFileSync(path.join('src', 'services', 'storage.ts'), 'utf8');
    expect(einstellungen, 'das Zwischenspeichern ist abschaltbar').toContain(
      'readonly autoSaveEnabled: boolean',
    );
    const daten = abschnitt('WO DAS PROGRAMM DATEN ABLEGT');
    expect(daten, 'die Zusage ohne Verlust').not.toContain('nichts verloren');
    expect(daten, 'die Grenze der Sicherung').toContain('ersetzt aber nicht das Speichern');
  });

  it('fuehrt zum Fehlerprotokoll und zu den Datenschutzhinweisen ueber das Menue', () => {
    /*
     * Je nach Installationsart liegt das Fehlerprotokoll nicht unbedingt unter
     * dem Pfad, den das Programm nennt; der Menueeintrag liest es dort, wo das Programm
     * es kennt. Die Beschriftung kommt aus electron/menu.ts, damit das Blatt
     * nicht "..." schreibt, wo das Menue "…" zeigt.
     */
    const menue = readFileSync(path.join('electron', 'menu.ts'), 'utf8');
    const eintrag = /label: '(Fehlerprotokoll[^']*)'/u.exec(menue);
    expect(eintrag, 'der Menueeintrag zum Fehlerprotokoll').not.toBeNull();
    expect(EINZEILIG, 'der Menueweg zum Fehlerprotokoll').toContain(
      `Hilfe → ${String(eintrag?.[1])}`,
    );
    // Ein Menueweg steht auf einer Zeile: hinter "Hilfe →" umbrochen, liest er
    // sich im Editor als zwei Angaben, und die Anfuehrung reisst auseinander.
    for (const zeile of LIESMICH.split(/\r?\n/u)) {
      expect(zeile, 'ein Menueweg ist hinter dem Pfeil umbrochen').not.toMatch(/→\s*$/u);
      expect(zeile, 'ein Menueweg ist vor dem Pfeil umbrochen').not.toMatch(/^\s*→/u);
    }
    const ueber = readFileSync(path.join('src', 'ui', 'ueber.ts'), 'utf8');
    expect(ueber, 'die Schaltflaeche im Über-Fenster').toContain("label: 'Datenschutz'");
    expect(EINZEILIG, 'der Weg zu den Datenschutzhinweisen').toContain(
      'Hilfe → Über LSA-Planer Professional → Datenschutz',
    );
  });

  it('sagt in QUELLCODE.txt, wie eine vierstellige Fassungsnummer zur Programmfassung steht', () => {
    /*
     * "Die Fassung dort trägt dieselbe Nummer wie das Programm daneben" - je
     * nach Installationsart nennt Windows die Nummer vierstellig. Dass die
     * vierte Stelle 0 bleibt, prueft dieser Fall nicht.
     */
    const quelle = readFileSync('QUELLCODE.txt', 'utf8').replace(/\s+/gu, ' ');
    expect(quelle, 'die Zusage').toContain('dieselbe Nummer wie das Programm daneben');
    expect(quelle, 'die vierstellige Nummer').toContain('vierstellig, mit einer 0 an vierter');
    expect(satzMit(quelle, 'vierstellig'), 'wann Windows vierstellig zaehlt').toContain(
      'Je nach Installationsart',
    );
  });
});

describe('Die Groessenangabe des Blattes gegen das Bauergebnis', () => {
  const dateien = [
    `release/LSA-Planer Professional ${PAKET.version}.exe`,
    `release/LSA-Planer Professional Setup ${PAKET.version}.exe`,
  ];
  const OHNE_BAU = !dateien.every((datei) => existsSync(datei));

  it.skipIf(OHNE_BAU)(
    'stimmt die Groesse in Millionen Byte und so, wie Windows sie anzeigt (nur mit Bauergebnis messbar)',
    () => {
      /*
       * Die Pakete der Fassung 5.43.0 hatten am 17.09.2026 111.778.492 und
       * 112.075.939 Byte. Ohne Bauergebnis uebersprungen - kein Rueckfall auf
       * eine Zahl hier.
       *
       * ZWEI ZAHLEN, WEIL WINDOWS ANDERS RECHNET. Hier stand "rund 112 MB",
       * dezimal gerundet - und wer die Groesse nachsah, fand 106 MB: Windows
       * teilt durch 1024 hoch 2 und schreibt trotzdem "MB". GEMESSEN am
       * 17.09.2026 an beiden Dateien: StrFormatByteSizeW (shlwapi, die
       * Anzeige der Dateieigenschaften) und die Groessenspalte des Explorers
       * zeigen je "106 MB". Die zweite Datei hat 106,88 MiB - gerundet waere
       * das 107; Windows schneidet also ab, und deshalb steht hier
       * `Math.floor`. Das gilt fuer drei Stellen vor dem Komma: Am selben Tag
       * zeigte StrFormatByteSizeW fuer 104.333.312 Byte "99,5 MB" und fuer
       * 1.048.576.000 Byte "0,97 GB". Faellt ein Paket in einen dieser
       * Bereiche, bricht dieser Fall an der Angabe des Blattes, und das ist
       * gewollt.
       */
      const dezimal = /rund (\d+) Millionen Byte/u.exec(EINZEILIG);
      const anzeige = /Windows zeigt das als (\d+) MB an/u.exec(EINZEILIG);
      expect(dezimal, 'die Groesse in Millionen Byte fehlt').not.toBeNull();
      expect(anzeige, 'die Groesse, wie Windows sie anzeigt, fehlt').not.toBeNull();
      for (const datei of dateien) {
        const byte = statSync(datei).size;
        expect(Math.round(byte / 1e6), `${datei}, Millionen Byte`).toBe(Number(dezimal?.[1]));
        expect(Math.floor(byte / 1024 ** 2), `${datei}, Anzeige`).toBe(Number(anzeige?.[1]));
      }
    },
  );
});

describe('Die Beilagen im Bauergebnis gegen den Quellbaum', () => {
  /*
   * Ein Bau mit veralteter Beilage blieb gruen: Die Lizenztexte hielt
   * tests/tools/eigeneLizenzImPaket.test.ts, die beiden Blaetter niemand.
   * GEMESSEN am 17.09.2026: Nach der Ueberarbeitung beider Blaetter lagen im
   * Bauergebnis noch die alten.
   *
   * Verglichen wird in dem Verzeichnis, aus dem electron-builder das Setup und
   * die tragbare Fassung schnuert. Ohne fertige Programmdatei dort ist nichts
   * zu messen, und der Fall wird uebersprungen - ein halb gefuellter Ordner
   * darf nicht als Bauergebnis durchgehen. Rot heisst: Der Bau ist aelter als
   * die Beilage, und `npm run dist:win` ist neu zu fahren.
   *
   * FREMDBESTANDTEILE.md kam am 18.09.2026 dazu, vor dem Commit zu 5.43.0:
   * Die Beilage ist docs/fremdbestandteile.md woertlich (build.extraFiles),
   * und am Bau von 00:02 Uhr trug sie noch den Satz, ein Paket dieses Standes
   * liege nicht vor, samt einer Byte-Zahl von vorher, waehrend dieser Fall
   * gruen blieb, weil er nur die zwei Blaetter kannte, an denen der Fehler
   * zuerst gesehen worden war.
   */
  for (const verzeichnis of [path.join('release', 'win-unpacked')]) {
    const ohneBau = !existsSync(path.join(verzeichnis, `${PAKET.build.productName}.exe`));
    it.skipIf(ohneBau)(
      `liegen LIESMICH.txt, QUELLCODE.txt und FREMDBESTANDTEILE.md in ${verzeichnis} so wie im Baum (nur mit Bauergebnis messbar)`,
      () => {
        for (const [beilage, quelle] of [
          ['LIESMICH.txt', 'LIESMICH.txt'],
          ['QUELLCODE.txt', 'QUELLCODE.txt'],
          ['FREMDBESTANDTEILE.md', path.join('docs', 'fremdbestandteile.md')],
        ] as const) {
          expect(
            readFileSync(path.join(verzeichnis, beilage)).equals(readFileSync(quelle)),
            `${beilage} in ${verzeichnis} weicht vom Quellbaum ab (${quelle})`,
          ).toBe(true);
        }
      },
    );
  }
});