import { inflateSync } from 'node:zlib';
import { describe, expect, it } from 'vitest';
import { buildProjectPdf, DEFAULT_PDF_OPTIONS } from '@/services/export/pdf';
import { FASSUNGSANGABE } from '@/fassung';
import { buildSignalPlan } from '@/domain/plan/signalPlan';
import { validateProject } from '@/domain/validation';
import { createStandardIntersectionProject, defaultVehicleClass } from '@/domain/model/factory';
import { ASSISTENT_VORGABE, projektAusAngaben, type Anlagenform } from '@/ui/assistent';
import type { Anlagenart, Project } from '@/domain/model/project';

/**
 * Die Planunterlage an der ECHTEN Geometrie der Anlagenart.
 *
 * DER BEFUND, DER DIESE DATEI AUSGELOEST HAT, war kein falsches Ergebnis,
 * sondern ein Pruefstueck, das die Frage nicht stellte:
 * `tests/export/pdfAnlagenart.test.ts` nimmt einen vierarmigen Standard-
 * knotenpunkt und ueberschreibt an ihm ein einziges Feld - `anlagenart`. Alles
 * andere bleibt ein Knotenpunkt: vier Arme, sechs Signalgruppen, zwoelf
 * Konfliktbeziehungen, Raeumwege um 22 m, zwei Fussgaengerfurten. Was dabei
 * geprueft wird, sind die Stellen des Ausdrucks, die an der ANLAGENART
 * haengen - und die sind damit auch richtig geprueft. Was dabei NICHT geprueft
 * wird, ist alles, was an der Geometrie haengt, und das ist der groessere Teil.
 *
 * GEMESSEN, was der ueberschriebene Knotenpunkt als einstreifige
 * Verkehrsfuehrung ausdruckt: "Die Engstelle ist mit 22 m erfasst" - 22 m ist
 * in Wahrheit der Raeumweg eines Knotenpunktstroms. Dazu "Bis 50 m kann nach
 * RSA 21 die Regelung nach Paragraf 6 StVO genuegen", also die Auskunft, die
 * Baustellenampel sei entbehrlich. Dazu ein Typklassensatz, der "kreuzende
 * Stroeme: K1, K2, K3, K4" nennt - eine einstreifige Wechselverkehrsfuehrung
 * hat zwei gegenlaeufige Stroeme und definitionsgemaess keine kreuzenden. Und
 * dazu der ganze Abschnitt "Fussgaenger und Radverkehr" samt Furtabsaetzen, in
 * einer Unterlage ohne eine einzige Furt.
 *
 * Kein einziger dieser Saetze ist ein Fehler des Programms: Es druckt genau
 * das, was in dem Projekt steht, das man ihm gibt. Der Fehler waere zu
 * glauben, damit sei der Weg "Assistent -> Ausdruck" fuer diese Anlagenarten
 * geprueft. Er war es fuer keine der beiden.
 *
 * DIESE DATEI PRUEFT DESHALB DEN WEG, DEN EIN ANWENDER GEHT: das Projekt aus
 * dem gefuehrten Einstieg, wie er es anlegt, durch Plan, Pruefbericht und
 * Ausdruck. Die Anlagenartstellen bleiben, wo sie sind - in
 * `pdfAnlagenart.test.ts`; hier steht, was nur an der echten Geometrie zu
 * sehen ist.
 */

const FIXED_DATE = new Date('2026-01-01T12:00:00Z');

/** Sichtbaren Text aus dem PDF lesen; die Inhaltsstroeme sind komprimiert. */
function pdfText(bytes: Uint8Array): string {
  const roh = new TextDecoder('latin1').decode(bytes);
  const teile: string[] = [];
  const suche = /stream\r?\n/g;
  let treffer: RegExpExecArray | null;

  while ((treffer = suche.exec(roh)) !== null) {
    const start = treffer.index + treffer[0].length;
    const ende = roh.indexOf('endstream', start);
    if (ende < 0) continue;
    let inhalt: string;
    try {
      inhalt = inflateSync(Buffer.from(roh.slice(start, ende), 'latin1')).toString('latin1');
    } catch {
      continue;
    }
    for (const stueck of inhalt.matchAll(/\((?:\\.|[^\\()])*\)\s*Tj/g)) {
      teile.push(stueck[0].slice(1, stueck[0].lastIndexOf(')')));
    }
  }
  // Lange Absaetze sind auf Zeilen umbrochen; fuer die Suche wieder
  // zusammenziehen, sonst findet contains() den halben Satz nicht.
  return teile.join(' ').replace(/\s+/g, ' ');
}

/** Das Projekt, das der gefuehrte Einstieg mit seinen Vorgaben anlegt. */
function ausDemAssistenten(form: Anlagenform): Project {
  return projektAusAngaben({ ...ASSISTENT_VORGABE, form }, 'Pruefstueck', FIXED_DATE);
}

/** Der ueberschriebene Knotenpunkt - das Pruefstueck, um das es hier geht. */
function ueberschrieben(anlagenart: Anlagenart): Project {
  const basis = createStandardIntersectionProject('Hauptstrasse / Bahnhofstrasse', FIXED_DATE);
  return { ...basis, anlagenart };
}

function ausdruck(project: Project): string {
  const plan = buildSignalPlan(project);
  const report = validateProject(project, plan, FIXED_DATE);
  return pdfText(buildProjectPdf(project, plan, report, DEFAULT_PDF_OPTIONS, FIXED_DATE));
}

describe('Fussgaengerschutzanlage - der Ausdruck an einer Fahrbahn mit einer Furt', () => {
  const text = ausdruck(ausDemAssistenten('fussgaengerschutzanlage'));

  it('druckt die zwei Signalgruppen, die es wirklich gibt', () => {
    // Der ueberschriebene Knotenpunkt fuehrt hier sechs. Die Zahl steht auf
    // dem Deckblatt und ist das erste, was ein Pruefer liest.
    expect(text).toContain('Anzahl Signalgruppen 2');
    // K3 und K4 gibt es an einer Fussgaengerschutzanlage nicht - und ihre
    // Namen stehen im Ausdruck des ueberschriebenen Knotenpunkts.
    expect(text, 'eine Signalgruppe aus der Knotenpunktvorlage').not.toContain('K3');
  });

  it('rechnet die Furtregel mit der eingegebenen Fahrbahnbreite', () => {
    /*
     * DIE ZAHL, UM DIE ES GEHT. Bei einer Fussgaengerschutzanlage ist die
     * Fahrbahnbreite die einzige Massangabe des Assistenten - aus ihr folgen
     * der Raeumweg der Furt und ueber den Haltlinienabstand der Raeumweg der
     * Fahrzeuge. Der ueberschriebene Knotenpunkt bringt stattdessen die 12 m
     * seiner Vorlage mit, und der Ausdruck rechnet die Furtregel damit durch.
     */
    expect(text).toContain('7,00 m');
    expect(text, 'die Furtbreite der Knotenpunktvorlage').not.toContain('halbe Furt 6,00 m');
  });

  it('nennt die Phasen so, wie der Assistent sie anlegt', () => {
    /*
     * MIT BINDESTRICH, obwohl der Assistent einen Gedankenstrich setzt
     * ("Phase 1 – Fahrzeuge", src/ui/assistent.ts). Das ist keine Eigenheit
     * des Auslesens, sondern eine Entscheidung des Programms: `toWinAnsi` in
     * src/render/pdfSurface.ts ersetzt Gedanken- und Geviertstrich durch den
     * Bindestrich, weil die Schrift des Ausdrucks sie nicht fuehrt. Auf dem
     * Papier steht deshalb etwas anderes als auf dem Bildschirm - hier
     * festgehalten, damit es nicht unbemerkt umschlaegt.
     */
    expect(text).toContain('Phase 1 - Fahrzeuge');
    expect(text).toContain('Phase 2 - Fußgänger');
    expect(text, 'der Gedankenstrich hat es doch in den Ausdruck geschafft').not.toContain(
      'Phase 1 – Fahrzeuge',
    );
  });
});

describe('Einstreifige Verkehrsfuehrung - der Ausdruck an einer Engstelle', () => {
  const text = ausdruck(ausDemAssistenten('einstreifig'));

  it('nennt die Engstelle mit ihrer wirklichen Laenge', () => {
    /*
     * Die Laenge der Engstelle ist an dieser Anlagenart die tragende Groesse:
     * Sie IST der Raeumweg beider Richtungen, sie bestimmt die Zwischenzeit
     * und ueber sie die Umlaufzeit. Der Assistent legt 120 m an
     * (ASSISTENT_VORGABE.engstellenlaenge); der ueberschriebene Knotenpunkt
     * bringt 22 m mit, und der Ausdruck schreibt sie als Engstellenlaenge
     * hin.
     */
    expect(text).toContain(`Die Engstelle ist mit ${ASSISTENT_VORGABE.engstellenlaenge} m erfasst`);
  });

  it('bescheinigt der Anlage nicht, sie sei entbehrlich', () => {
    /*
     * Der gefaehrlichste Satz des ueberschriebenen Ausdrucks. Bis 50 m nennt
     * die RSA 21 die Regelung nach Paragraf 6 StVO als Moeglichkeit - bei 22 m
     * Raeumweg schlaegt die Regel an und bescheinigt einer Baustellenampel,
     * dass es sie nicht braucht. Bei 120 m Engstelle darf davon nichts
     * dastehen.
     */
    expect(text).not.toContain('Signalregelung nicht zwingend');
    expect(text).not.toContain('Vorrang des Gegenverkehrs');
  });

  it('schreibt der Anlage keine Typklasse D vor', () => {
    /*
     * Die Regel zur Typklasse zaehlt Fussgaengergruppen und kreuzende Kfz-
     * Stroeme. Eine einstreifige Wechselverkehrsfuehrung hat zwei
     * GEGENLAEUFIGE Stroeme und definitionsgemaess keine kreuzenden - der
     * ueberschriebene Knotenpunkt bringt vier Kfz-Gruppen und zwei Furten mit
     * und laesst die Regel deshalb "Typklasse D zu prüfen" schreiben.
     *
     * Geprueft wird der Satz und nicht das Wort: "kreuzende Ströme" steht
     * auch im richtigen Ausdruck - dort aber in der Verneinung
     * ("... verlangten Fußgängersignale oder kreuzende Ströme Typ D").
     *
     * Der Wortlaut hat sich am 12.09.2026 geaendert: Bis dahin schrieb die
     * Regel "Typ D erforderlich", also eine Feststellung ueber ein Regelwerk,
     * das niemand aufgeschlagen hat (siehe
     * tests/domain/regelwerksaussageOhneAbgleich.test.ts).
     */
    expect(text).not.toContain('Typklasse D zu prüfen');
    expect(text).not.toContain('Fußgängergruppen');
  });

  it('druckt die Furtabsaetze nicht, die es hier nicht gibt', () => {
    /*
     * An dieser Anlage gibt es keine Furt. Der ueberschriebene Knotenpunkt
     * bringt zwei mit, und der Ausdruck erklaert dann in einer Unterlage ohne
     * eine einzige Furt, wie das Programm Furten rechnet.
     *
     * Geprueft wird der Absatz und nicht die Ueberschrift: "Fußgänger und
     * Radverkehr" steht auch im richtigen Ausdruck - in den Erlaeuterungen zu
     * Raeumgeschwindigkeit, Mindestfreigabezeit und Bewertungstafel, und die
     * gelten unabhaengig davon, ob die Anlage Fussgaenger fuehrt.
     */
    expect(text).not.toContain('Eine Furt mit Mittelinsel ist über die Insel hinweg zu vermessen');
  });

  it('rechnet die Zwischenzeit aus der Engstellenlaenge', () => {
    /*
     * Der Raeumweg sr, wie er im Rechenweg der Zwischenzeitenmatrix steht:
     * 120,0 m - der Abstand der Haltlinien, OHNE Fahrzeuglaenge. Daraus
     * tr = 10,8 s bei 40 km/h und tue = 4 s; eine Einfahrzeit wird nicht
     * abgezogen. tz = 14,8 s, aufgerundet 15 s (RiLSA 2015, Abschnitt 5.2.2).
     *
     * NACHGEZOGEN MIT 5.27.0: Bis dahin standen dort 126,0 m - 120 m Engstelle
     * zuzueglich 6 m Laengenzuschlag des Pkw -, und die Rechnung lief nach den
     * Knotenpunktregeln (tr = 12,6 s bei 10,0 m/s, tue = 3 s Gelbzeit,
     * tz = 15,6 -> 16 s).
     *
     * Die Zahl steht hier, weil sie ohne die echte Geometrie nicht entstehen
     * kann: Die groesste Zwischenzeit des ueberschriebenen Knotenpunkts
     * betraegt gemessen 10 s, die dieser Engstelle 15 s. Der Fall, um den es
     * an einer Engstelle ueberhaupt geht - ein langer Raeumweg treibt die
     * Umlaufzeit -, kommt in der Vorlage gar nicht vor.
     */
    expect(text).toContain('120,0 m');
    expect(text).not.toContain('126,0 m');
    /*
     * UND DIE FUSSNOTE DAZU: Zwei Zeilen mit derselben Spaltenueberschrift,
     * aber verschiedenen Formeln dahinter sind ohne sie nicht nachzurechnen.
     * Wer die Zeile mit der Knotenpunktformel nachrechnet, sucht sonst die
     * fehlenden 6 m.
     */
    expect(text).toContain('Abschnitt 5.2.2');
    expect(text).toContain('OHNE Fahrzeuglänge');
    expect(text).toContain('Eine Einfahrzeit wird nicht abgezogen');
  });
});

describe('Die beiden Pruefregeln aus 5.21.0 stehen auch auf dem Papier', () => {
  /*
   * EIN BEFUND, DEN NUR DER BILDSCHIRM ZEIGT, ist keiner. Die Anordnung geht
   * als Unterlage aus der Hand; wer sie prueft, hat den Bildschirm nicht. Die
   * beiden Regeln, die mit 5.21.0 dazugekommen sind, muessen deshalb im
   * gedruckten Pruefbericht stehen - mit dem Satz, der die Sache erklaert, und
   * nicht nur mit ihrer Kennung.
   */
  it('nennt die Unterlage die Voraussetzung des OePNV-Ansatzes', () => {
    const engstelle = ausDemAssistenten('einstreifig');
    const mitBus: Project = {
      ...engstelle,
      signalGroups: engstelle.signalGroups.map((g) =>
        g.name === 'K1'
          ? { ...g, mode: 'oepnv' as const, vehicleClass: defaultVehicleClass('oepnv') }
          : g,
      ),
    };
    const text = ausdruck(mitBus);
    expect(text).toContain('Räumgeschwindigkeit des ÖPNV an der Arbeitsstelle');
    expect(text, 'die beiden Geschwindigkeiten fehlen').toContain('13,9 m/s');
    expect(text, 'die Voraussetzung fehlt').toContain('gesondert signalisiert');

    // Und ohne OePNV steht davon nichts in der Unterlage.
    expect(ausdruck(engstelle)).not.toContain('Räumgeschwindigkeit des ÖPNV an der Arbeitsstelle');
  });

  it('sagt die Unterlage, wenn sie gar keine Bewertung enthaelt', () => {
    const anlage = ausDemAssistenten('fussgaengerschutzanlage');
    const nachHcm: Project = {
      ...anlage,
      settings: { ...anlage.settings, serviceLevelScale: 'HCM' },
    };
    const text = ausdruck(nachHcm);
    expect(text).toContain('Keine Bewertung: Fußgängerschutzanlage nach HCM');
    expect(text, 'der Weg heraus fehlt').toContain('Wählen Sie das Bewertungsverfahren HBS 2015');

    expect(ausdruck(anlage), 'nach HBS steht die Meldung trotzdem da').not.toContain(
      'Keine Bewertung: Fußgängerschutzanlage nach HCM',
    );
  });
});

describe('Der Unterschied ist nachweisbar und kein Geschmack', () => {
  it('sagt der ueberschriebene Knotenpunkt bei der Engstelle etwas anderes', () => {
    /*
     * DIE GEGENPROBE ZU DIESER GANZEN DATEI. Ohne sie waere nicht gezeigt,
     * dass die Faelle oben ueberhaupt etwas Neues pruefen - sie koennten
     * ebenso gut am alten Pruefstueck gruen sein, und dann waere die echte
     * Geometrie ein Aufwand ohne Ertrag.
     *
     * Zugleich ist dieser Fall die Wache dagegen, die Faelle oben spaeter
     * wieder auf die bequemere Vorlage umzustellen.
     */
    const vorlage = ausdruck(ueberschrieben('einstreifig'));

    /*
     * Geprueft wird hier nur die VORLAGE. Dass der richtige Ausdruck diese
     * Saetze nicht traegt, steht schon in den Faellen darueber; sie hier ein
     * zweites Mal hinzuschreiben, machte den Nachweis nicht staerker, sondern
     * nur die Pflege doppelt.
     */
    expect(vorlage, 'die Vorlage nennt nicht mehr ihren eigenen Raeumweg').toContain(
      'Die Engstelle ist mit 22 m erfasst',
    );
    expect(vorlage, 'die Vorlage bescheinigt die Anlage nicht mehr als entbehrlich').toContain(
      'Signalregelung nicht zwingend',
    );
    expect(vorlage, 'die Vorlage verlangt die Typklasse D nicht mehr zu prüfen').toContain(
      'Typklasse D zu prüfen',
    );
    expect(vorlage, 'die Vorlage druckt die Furtabsaetze nicht mehr').toContain(
      'Eine Furt mit Mittelinsel ist über die Insel hinweg zu vermessen',
    );
  });
});

describe('Die Planunterlage sagt, welcher Rechenstand sie erzeugt hat', () => {
  /*
   * DER BEFUND. Bis 5.25.0 nannte der Ausdruck die Programmfassung nirgends.
   * Zwischen 5.21.0 und 5.25.0 liegen der Deckel an der zulaessigen
   * Hoechstgeschwindigkeit (5.22.0) und die Verteilung des Freigabezeitrests
   * (5.23.0) - zwei Aenderungen, die fuer dasselbe Projekt andere Zahlen in
   * den Plan schreiben. Zwei Ausdrucke desselben Vorgangs sahen sonst gleich
   * aus, und welcher Stand welchen erzeugt hatte, war ihnen nicht anzusehen.
   *
   * Aufgefallen vor einer Auslieferung. Behoben ist es mit
   * einer Zeile auf dem Deckblatt; nachtraeglich kennzeichnen laesst sich eine
   * bereits abgegebene Unterlage nicht.
   */
  const text = ausdruck(ausDemAssistenten('kreuzung'));

  it('nennt die Programmfassung auf dem Deckblatt', () => {
    expect(text, 'die Beschriftung').toContain('Programmfassung');
    expect(text, 'der Name des Programms').toContain('LSA-Planer Professional');
    expect(text, 'die Fassung selbst').toContain(FASSUNGSANGABE);
  });

  it('nennt den Schemastand der Daten daneben', () => {
    // Er sagt, aus welchem Dateiformat die Angaben stammen; die mitgelieferte
    // Beispieldatei traegt bewusst einen aelteren.
    expect(text).toContain('Schemastand der Datei');
  });

  it('steht die Fassung nur einmal und nicht auf jeder Seite', () => {
    /*
     * Die Gegenprobe zur Menge: Die Herkunftsangabe gehoert auf das Deckblatt,
     * nicht in die Fusszeile jeder Seite - dort steht schon der Bearbeiter,
     * und die Zeile war bereits einmal zu lang (Befund 5).
     */
    const treffer = text.match(/Programmfassung/gu) ?? [];
    expect(treffer).toHaveLength(1);
  });
});