import { inflateSync } from 'node:zlib';
import { describe, expect, it } from 'vitest';
import { ueberfahrzeitAnsatzSatz } from '@/services/export/bewertung';
import { buildProjectPdf, DEFAULT_PDF_OPTIONS } from '@/services/export/pdf';
import { buildSignalPlan } from '@/domain/plan/signalPlan';
import { validateProject } from '@/domain/validation';
import { createStandardIntersectionProject } from '@/domain/model/factory';
import { resolveRilsaSettings } from '@/domain/rilsa/settings';
import { UEBERFAHRZEIT_ANSATZ_LABELS } from '@/domain/rilsa/constants';
import { toWinAnsi } from '@/render/pdfSurface';
import type { Project } from '@/domain/model/project';
import type { RilsaOverrides } from '@/domain/rilsa/settings';

/*
 * Befunde 6 und 33 zur Fassung 5.9.0.
 *
 * Der Absatz unter der Zwischenzeitenmatrix setzte im Zweig 'gelbzeit' die
 * beiden festen Ueberfahrzeiten aus den WIRKSAMEN Vorgaben ein und haengte
 * daran eine fest eingeschriebene Aussage: "Behoerdliche Leitfaeden nennen
 * daneben feste Werte (…); gegen sie faellt dieser Ansatz beim Abbiegen und
 * bei 60 und 70 km/h laenger aus und ist damit die konservative Seite."
 *
 * Beide Vergleichsseiten sind einstellbar: crossingTimeKfzGeradeaus und
 * crossingTimeKfzAbbiegend von 1 bis 10 s, die Gelbzeitstaffel ueber
 * yellowKfzUpTo50/UpTo60/Above60. Mit 6 s/6 s liegt die groesste Gelbzeit (5 s)
 * darunter - der Satz behauptete die konservative Seite gegen zwei Zahlen, die
 * er selbst nannte, und schrieb eingetragene Vorgabewerte behoerdlichen
 * Leitfaeden zu. Beim Ansatz 'gelbzeit' geht keiner der beiden Werte in eine
 * Zwischenzeit ein; es ist kein Fehler der gefaehrlichen Richtung, sondern ein
 * Wortlautfehler der Planunterlage.
 *
 * Fuer den Zweig 'fest' ist derselbe Fehlertyp laengst behoben
 * (ueberfahrzeitAnsatzRichtungSatz in domain/rilsa/ansaetze.ts, Fassung 5.5.0, Befund B5);
 * der Regelzweig war dabei uebersehen worden.
 *
 * NACHGEBESSERT: Der Vergleichssatz begann mit "Gegen sie" und haengte damit am
 * Herkunftssatz davor - der im Abweichungsfall zwei Zahlenpaare nennt. Das
 * Bezugswort steht jetzt ausgeschrieben.
 *
 * MUTATIONSNACHWEIS (gemessen an einer Pruefkopie mit den HEAD-Fassungen von
 * bewertung.ts, csv.ts und pdfSurface.ts): 8 von 9 Faellen fallen; gruen bleibt
 * allein der letzte, der den unberuehrten Zweig 'fest' festhaelt.
 */

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

function satz(overrides: RilsaOverrides): string {
  const { defaults } = resolveRilsaSettings(overrides);
  return ueberfahrzeitAnsatzSatz('gelbzeit', defaults);
}

/** 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 t of inhalt.matchAll(/\(((?:[^()\\]|\\.)*)\)\s*Tj/g)) {
      teile.push(t[1]!.replace(/\\([()\\])/g, '$1'));
    }
  }
  return teile.join(' ').replace(/\s+/g, ' ');
}

const gedruckt = (text: string): string => toWinAnsi(text).replace(/\s+/g, ' ');

describe('Befunde 6 und 33 - der Regelansatz nennt Richtung und Herkunft aus den Vorgaben', () => {
  it('haelt an den Regelwerten die belegte Aussage fest', () => {
    const text = ueberfahrzeitAnsatzSatz('gelbzeit');

    // Seit 5.27.0 nennt der Satz die RiLSA: Die beiden Zahlen stehen in
    // Abschnitt 2.5.2 und nicht nur in behoerdlichen Leitfaeden.
    expect(text).toContain('Die RiLSA 2015 setzt in Abschnitt 2.5.2 feste Werte an');
    expect(text).toContain('3 s geradeaus und 2 s abbiegend');
    expect(text).toContain(
      'Gegen diese Regelwerte fällt dieser Ansatz beim Abbiegen um bis zu 3 s und geradeaus ' +
        'um bis zu 2 s länger',
    );
    expect(text).toContain('ist damit die konservative Seite');
    // Die Geschwindigkeitsschwellen standen fest im Satz, obwohl die
    // Gelbzeitstaffel einstellbar ist.
    expect(text).not.toContain('bei 60 und 70 km/h');
  });

  it('nennt das Zahlenpaar, gegen das verglichen wird, im Vergleichssatz selbst', () => {
    /*
     * Der Vergleichssatz begann mit "Gegen sie" und haengte damit am
     * Herkunftssatz davor. Weicht der Plan ab, nennt der ZWEI Zahlenpaare - die
     * eingetragenen und die belegten -, und das Bezugswort zeigte auf das
     * zuletzt genannte: auf die 3 s/2 s der Leitfaeden. Gegen die ist der
     * Regelansatz nirgends kuerzer; gerechnet wird gegen die Vorgabenwerte. Der
     * Satz las sich damit wieder gegen seine eigenen zwei Zahlen.
     */
    const text = satz({ crossingTimeKfzGeradeaus: 6, crossingTimeKfzAbbiegend: 6 });

    expect(text).toContain('Gegen diese Vorgabewerte fällt dieser Ansatz');
    expect(text).not.toContain('Gegen sie');
  });

  it('behauptet keine konservative Seite, wo der Ansatz kürzer ausfällt (Auslöser Befund 6)', () => {
    const text = satz({ crossingTimeKfzGeradeaus: 6, crossingTimeKfzAbbiegend: 6 });

    expect(text).toContain('6 s geradeaus und 6 s abbiegend');
    expect(text).toContain('beim Abbiegen um bis zu 3 s und geradeaus um bis zu 3 s kürzer');
    expect(text).toContain('die konservative Seite ist er damit nicht');
    expect(text).not.toContain('ist damit die konservative Seite');
    expect(text).not.toContain('länger aus');
  });

  it('schreibt eingetragene Vorgabewerte nicht behördlichen Leitfäden zu', () => {
    const text = satz({ crossingTimeKfzGeradeaus: 6, crossingTimeKfzAbbiegend: 6 });

    expect(text).not.toContain('Die RiLSA 2015 setzt in Abschnitt 2.5.2 feste Werte an');
    expect(text).toContain('Die Vorgaben dieses Plans');
    // Was das Regelwerk wirklich nennt, steht daneben - aus constants.ts.
    expect(text).toContain('nicht die 3 s geradeaus und 2 s abbiegend der RiLSA 2015');
  });

  it('rechnet die Größenordnung aus den eingetragenen Werten (Auslöser Befund 33)', () => {
    const text = satz({ crossingTimeKfzGeradeaus: 8, crossingTimeKfzAbbiegend: 7 });

    expect(text).toContain('8 s geradeaus und 7 s abbiegend');
    expect(text).toContain('beim Abbiegen um bis zu 4 s und geradeaus um bis zu 5 s kürzer');
    expect(text).not.toContain('ist damit die konservative Seite');
  });

  it('nimmt die Schwellen der Gelbzeitstaffel aus den Vorgaben, nicht aus dem Satz', () => {
    // Alle drei Gelbzeiten auf dem Mindestwert: geradeaus ist der Ansatz dann
    // nirgends mehr länger, nur beim Abbiegen um 1 s.
    const text = satz({ yellowKfzUpTo50: 3, yellowKfzUpTo60: 3, yellowKfzAbove60: 3 });

    expect(text).toContain('3 s bis 50 km/h, 3 s bis 60 km/h, 3 s bis 70 km/h');
    expect(text).toContain('beim Abbiegen um bis zu 1 s länger');
    expect(text).not.toContain('geradeaus um bis zu');
    expect(text).not.toContain('bei 60 und 70 km/h');
    // Nirgends kürzer bleibt er - die konservative Seite gilt hier weiter.
    expect(text).toContain('ist damit die konservative Seite');

    /*
     * BEKANNT UND AUSSERHALB DIESER LISTE: Die Beschriftung des Ansatzes traegt
     * die Staffel weiterhin als feste Zahlen
     * (UEBERFAHRZEIT_ANSATZ_LABELS.gelbzeit in src/domain/rilsa/constants.ts,
     * Fehlertyp C21) - obwohl sie ueber yellowKfzUpTo50/UpTo60/Above60
     * einstellbar ist. Mit 3/3/3 widerspricht der Absatz sich deshalb im selben
     * Atemzug: "(3/4/5 s nach zulässiger Höchstgeschwindigkeit)" gegen
     * "(3 s bis 50 km/h, 3 s bis 60 km/h, 3 s bis 70 km/h)". constants.ts stand
     * fuer diese Aenderung nicht zur Verfuegung; der Widerspruch steht hier
     * festgehalten, damit die Stelle nicht unbemerkt bleibt.
     */
    expect(UEBERFAHRZEIT_ANSATZ_LABELS.gelbzeit).toContain('3/4/5 s');
    expect(text).toContain('3/4/5 s nach zulässiger Höchstgeschwindigkeit');
  });

  it('nennt beide Richtungen, wo der Ansatz teils kürzer und teils länger ausfällt', () => {
    // Geradeaus 4 s gegen die Staffel 3/4/5: bei 50 km/h ist der Ansatz kürzer,
    // bei 70 km/h länger.
    const text = satz({ crossingTimeKfzGeradeaus: 4 });

    expect(text).toContain('geradeaus um bis zu 1 s kürzer');
    expect(text).toContain('beim Abbiegen um bis zu 3 s und geradeaus um bis zu 1 s länger');
    expect(text).not.toContain('ist damit die konservative Seite');
  });

  it('druckt die berichtigte Aussage in der Planunterlage', () => {
    const basis = createStandardIntersectionProject('Überfahrzeit', STICHTAG);
    const projekt: Project = {
      ...basis,
      settings: {
        ...basis.settings,
        rilsa: { crossingTimeKfzGeradeaus: 6, crossingTimeKfzAbbiegend: 6 },
        ueberfahrzeitAnsatz: 'gelbzeit',
      },
    };
    const plan = buildSignalPlan(projekt);
    const bericht = validateProject(projekt, plan, STICHTAG);
    const text = pdfText(buildProjectPdf(projekt, plan, bericht, DEFAULT_PDF_OPTIONS, STICHTAG));

    expect(text).toContain(gedruckt('Überfahrzeit des Kraftfahrzeugverkehrs: Gerechnet wurde'));
    expect(text).toContain(gedruckt('die konservative Seite ist er damit nicht'));
    expect(text).not.toContain(
      gedruckt('Die RiLSA 2015 setzt in Abschnitt 2.5.2 feste Werte an (6 s'),
    );
  });

  it('lässt den Zweig „feste Überfahrzeit" unberührt', () => {
    const { defaults } = resolveRilsaSettings({});
    const text = ueberfahrzeitAnsatzSatz('fest', defaults);

    expect(text).toContain('beim Abbiegen um bis zu 3 s');
    expect(text).toContain('Die Werte sind die Regelwerte der RiLSA 2015');
  });
});