import { inflateSync } from 'node:zlib';
import { describe, expect, it } from 'vitest';
import { buildProjectPdf, DEFAULT_PDF_OPTIONS } from '@/services/export/pdf';
import { UMLAUFZEIT_ERSATZWERT_VERMERK, buildSignalPlan } from '@/domain/plan/signalPlan';
import { validateProject } from '@/domain/validation';
import { createStandardIntersectionProject } from '@/domain/model/factory';
import { ANLAGENART_GRENZEN } from '@/domain/rilsa/constants';
import type { Project } from '@/domain/model/project';

/**
 * Planunterlagen zu den Befunden C10 und C11.
 *
 * C11: Bei Uebersaettigung traegt der Plan die Obergrenze als Ersatzwert.
 * Deckblatt (Kennwerttabelle), Signalzeiten und Rechenweg der Wartezeit
 * druckten "120 s" wie ein Ergebnis; jetzt steht der Vermerk des Fachkerns
 * daneben ("nicht bemessbar (uebersaettigt) - Ersatzwert"). Er steht auch vor
 * den Phasentabellen und der Leistungsfaehigkeit (deren Zahlen haengen ebenso
 * an der Umlaufzeit) und in der Zeichnung selbst (Achsentext und Vermerkzeile).
 * Ohne Uebersaettigung darf der Vermerk nirgends stehen.
 *
 * C10: Der Abschnitt "Abweichungen von den Regelwerten" loest die Vorgaben mit
 * der Anlagenart des Projekts auf. Eine groesste Umlaufzeit von 250 s ist bei
 * einstreifiger Fuehrung zulaessig (Schranke 300 s) und muss als 250 s
 * gedruckt werden - nicht auf die 120 s des Knotenpunkts gekappt.
 *
 * Gegen den Altstand schlagen die Faelle fehl: Dort fehlte der Vermerk, und
 * drawSettingsDeviations rief resolveRilsaSettings ohne Anlagenart auf.
 */

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

/** Sichtbaren Text aus dem PDF lesen; derselbe Leser wie in pdfFurtregel.test.ts. */
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(')')));
    }
  }
  return teile
    .join(' ')
    .replace(/\\([()])/g, '$1')
    .replace(/\s+/g, ' ');
}

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, includeCalculationDetails: true },
      FIXED_DATE,
    ),
  );
}

/** Der Vermerk, wie er nach toWinAnsi im PDF steht (Gedankenstrich -> Bindestrich). */
const VERMERK_IM_PDF = UMLAUFZEIT_ERSATZWERT_VERMERK.replace(/[–—]/g, '-');

function uebersaettigt(): Project {
  const p = createStandardIntersectionProject('Ersatzwert', FIXED_DATE);
  return { ...p, demands: p.demands.map((d) => ({ ...d, volume: 1500 })) };
}

describe('Ausdruck: Umlaufzeit als Ersatzwert gekennzeichnet (Befund C11)', () => {
  it('druckt den Vermerk neben der Umlaufzeit auf dem Deckblatt und bei den Signalzeiten', () => {
    const p = uebersaettigt();
    const plan = buildSignalPlan(p);
    expect(plan.cycleResult?.bounded, 'Vorbedingung').toBe('uebersaettigt');
    const text = ausdruck(p);

    // Deckblatt: Kennwert "Umlaufzeit" mit Wert UND Vermerk.
    expect(text).toContain(`Umlaufzeit ${plan.cycleTime} s - ${VERMERK_IM_PDF}`);
    // Absatz vor jeder Tabelle, deren Zahlen an der Umlaufzeit haengen:
    // Phasen, Signalzeiten, Leistungsfaehigkeit, Rechenweg Wartezeit.
    const absatz =
      'Die folgenden Zeiten beruhen auf dem Ersatzwert und sind kein Bemessungsergebnis';
    expect(text).toContain(absatz);
    expect(text.split(absatz).length - 1).toBe(4);
    const vorTabelle = (titel: string): string =>
      `${titel} Umlaufzeit ${plan.cycleTime} s - ${VERMERK_IM_PDF}`;
    expect(text).toContain(vorTabelle('Phasen und Phasenübergänge'));
    expect(text).toContain(vorTabelle('Signalzeiten je Signalgruppe'));
    expect(text).toContain(vorTabelle('Kraftfahrzeuge und ÖPNV'));
    expect(text).toContain(vorTabelle('Rechenweg Wartezeit'));
    // Die Zeichnung selbst: Kurzvermerk am Achsentext, Vermerkzeile unter der Legende.
    expect(text).toContain(`Zeit [s] Umlaufzeit ${plan.cycleTime} s - Ersatzwert`);
    expect(text).toContain(
      `Umlaufzeit ${plan.cycleTime} s - ${VERMERK_IM_PDF}. Alle Zeiten des Plans beruhen auf dem Ersatzwert - siehe Prüfbericht.`,
    );
    // Deckblatt + Zeichnung + vier Absaetze: mindestens sechsmal der volle Vermerk.
    const treffer = text.split(VERMERK_IM_PDF).length - 1;
    expect(treffer).toBeGreaterThanOrEqual(6);
  });

  it('druckt ohne Uebersaettigung keinen Vermerk', () => {
    const p = createStandardIntersectionProject('Regelfall', FIXED_DATE);
    const plan = buildSignalPlan(p);
    expect(plan.cycleResult?.bounded).not.toBe('uebersaettigt');
    const text = ausdruck(p);
    expect(text).not.toContain(VERMERK_IM_PDF);
    expect(text).not.toContain('Ersatzwert');
    expect(text).toContain(`Umlaufzeit ${plan.cycleTime} s`);
  });
});

describe('Ausdruck: Abweichungen mit der Anlagenart aufgeloest (Befund C10)', () => {
  it('druckt bei einstreifiger Fuehrung eine groesste Umlaufzeit von 250 s ungekappt', () => {
    const roh = createStandardIntersectionProject('Einstreifig', FIXED_DATE);
    const p: Project = {
      ...roh,
      anlagenart: 'einstreifig',
      settings: { ...roh.settings, rilsa: { ...roh.settings.rilsa, cycleTimeMax: 250 } },
    };
    expect(ANLAGENART_GRENZEN.einstreifig.cycleTime.max).toBeGreaterThanOrEqual(250);
    expect(ANLAGENART_GRENZEN.knotenpunkt.cycleTime.max).toBeLessThan(250);
    const text = ausdruck(p);
    // Abschnitt vorhanden, Zeile "Groesste Umlaufzeit | 120 | 250 | s".
    expect(text).toContain('Abweichungen von den Regelwerten');
    expect(text).toMatch(/Größte Umlaufzeit\s+120\s+250\s+s/);
  });

  it('kappt dieselbe Vorgabe am Knotenpunkt auf 120 s - dann ist sie keine Abweichung mehr', () => {
    const roh = createStandardIntersectionProject('Knotenpunkt', FIXED_DATE);
    const p: Project = {
      ...roh,
      settings: { ...roh.settings, rilsa: { ...roh.settings.rilsa, cycleTimeMax: 250 } },
    };
    expect(p.anlagenart).toBe('knotenpunkt');
    const text = ausdruck(p);
    expect(text).not.toMatch(/Größte Umlaufzeit\s+120\s+250\s+s/);
  });
});