import { describe, expect, it } from 'vitest';
import { geometriefaktor, saturationFlow } from '@/domain/rilsa/capacity';
import { HBS_STANDARDBEDINGUNGEN, RILSA_DEFAULTS } from '@/domain/rilsa/constants';
import { buildSignalPlan } from '@/domain/plan/signalPlan';
import { validateProject } from '@/domain/validation';
import { createStandardIntersectionProject } from '@/domain/model/factory';
import { loadProject } from '@/domain/model/migrate';
import type { Project, SignalGroup } from '@/domain/model/project';

/**
 * Fassung 5.30.0 - die geometrischen Anpassungsfaktoren des Zeitbedarfswerts
 * (BASt V 400).
 *
 * WARUM SIE GEBAUT WURDEN: Ohne sie rechnete das Programm jede Zufahrt unter
 * Standardbedingungen, und die eigene Unterlage nannte das die unsichere
 * Richtung. An einer 2,50 m breiten Zufahrt fiel die
 * Saettigungsverkehrsstaerke um 18,8 % zu gross aus.
 *
 * Alle Zahlen hier sind aus den drei Geraden von Hand nachgerechnet:
 *   fb = -0,375 b + 2,125   (nur unter 3,00 m)
 *   fR = -0,015 R + 1,3     (nur unter 20 m)
 *   fs =  0,03  s + 1
 *   angesetzt wird max(1; max(fb, fR, fs) * min(1; fs))
 */

const DATUM = new Date('2026-01-01T00:00:00Z');

describe('Geometriefaktoren - die drei Geraden', () => {
  it('geht an den Grenzpunkten stetig in den Regelfall über', () => {
    // fb(3,00) = -1,125 + 2,125 = 1,000; fR(20) = -0,30 + 1,30 = 1,000;
    // fs(0) = 1,000. Ein Sprung an der Schwelle waere ein Rechenfehler.
    const b = geometriefaktor(
      { breite: HBS_STANDARDBEDINGUNGEN.fahrstreifenbreiteAb },
      'geradeaus',
    );
    const r = geometriefaktor({ radius: HBS_STANDARDBEDINGUNGEN.kurvenradiusAb }, 'geradeaus');
    const s = geometriefaktor({ neigung: 0 }, 'geradeaus');
    expect(b.fb).toBe(1);
    expect(r.fR).toBe(1);
    expect(s.fs).toBe(1);
    for (const ergebnis of [b, r, s]) expect(ergebnis.gesamt).toBe(1);
  });

  it('mindert eine schmale Zufahrt', () => {
    // fb(2,50) = -0,9375 + 2,125 = 1,1875
    const ergebnis = geometriefaktor({ breite: 2.5 }, 'geradeaus');
    expect(ergebnis.fb).toBeCloseTo(1.1875, 6);
    expect(ergebnis.gesamt).toBeCloseTo(1.1875, 6);
    // 2000 / 1,1875 = 1684,2 Kfz/h - die Zahl aus der Schemachronik.
    expect(saturationFlow('geradeaus', 1, RILSA_DEFAULTS, { breite: 2.5 })).toBeCloseTo(1684.2, 1);
  });

  it('mindert einen engen Bogen im durchgehenden Fahrstreifen', () => {
    // fR(10) = -0,15 + 1,30 = 1,15
    const ergebnis = geometriefaktor({ radius: 10 }, 'geradeaus');
    expect(ergebnis.fR).toBeCloseTo(1.15, 6);
    expect(ergebnis.gesamt).toBeCloseTo(1.15, 6);
  });

  it('mindert eine Steigung', () => {
    // fs(4) = 0,12 + 1 = 1,12; 2000 / 1,12 = 1785,7 Kfz/h
    const ergebnis = geometriefaktor({ neigung: 4 }, 'geradeaus');
    expect(ergebnis.fs).toBeCloseTo(1.12, 6);
    expect(ergebnis.gesamt).toBeCloseTo(1.12, 6);
    expect(saturationFlow('geradeaus', 1, RILSA_DEFAULTS, { neigung: 4 })).toBeCloseTo(1785.7, 1);
  });

  it('nimmt den größten der drei Faktoren, nicht ihr Produkt', () => {
    // f1 = max(1,1875; 1,15; 1,06) = 1,1875 - und NICHT 1,1875 * 1,15 * 1,06.
    // Ein Produkt waere eine dreifache Abminderung derselben Engstelle.
    const ergebnis = geometriefaktor({ breite: 2.5, radius: 10, neigung: 2 }, 'geradeaus');
    expect(ergebnis.f1).toBeCloseTo(1.1875, 6);
    expect(ergebnis.gesamt).toBeCloseTo(1.1875, 6);
  });

  it('lässt eine fehlende oder unbrauchbare Angabe als Standardbedingung gelten', () => {
    for (const geometrie of [
      {},
      { breite: undefined, radius: undefined, neigung: undefined },
      { breite: Number.NaN, radius: Number.POSITIVE_INFINITY, neigung: Number.NaN },
    ]) {
      const ergebnis = geometriefaktor(geometrie, 'geradeaus');
      expect(ergebnis.gesamt, JSON.stringify(geometrie)).toBe(1);
      expect(ergebnis.gedeckelt).toBe(false);
    }
    // Und die Saettigungsverkehrsstaerke bleibt der Grundwert - der Stand bis
    // Schema 13. Ohne diese Zusage waere jede Bestandsdatei betroffen.
    expect(saturationFlow('geradeaus', 1, RILSA_DEFAULTS)).toBe(
      RILSA_DEFAULTS.capacity.saturationFlow,
    );
    expect(saturationFlow('geradeaus', 1, RILSA_DEFAULTS, {})).toBe(
      RILSA_DEFAULTS.capacity.saturationFlow,
    );
  });
});

describe('Geometriefaktoren - der Deckel bei 1', () => {
  it('lässt ein Gefälle die Sättigungsverkehrsstärke nicht anheben', () => {
    /*
     * DIE SICHERHEITSENTSCHEIDUNG DIESES PUNKTES. fs(-4) = -0,12 + 1 = 0,88;
     * f1 = max(1; 1; 0,88) = 1, f2 = min(1; 0,88) = 0,88, also 0,88 nach der
     * geschlossenen Formel - und 2000 / 0,88 = 2273 Kfz/h, 13,6 % ueber dem
     * Grundwert. Dieses Programm setzt 1,000 an.
     */
    const ergebnis = geometriefaktor({ neigung: -4 }, 'geradeaus');
    expect(ergebnis.fs).toBeCloseTo(0.88, 6);
    expect(ergebnis.f1).toBe(1);
    expect(ergebnis.f2).toBeCloseTo(0.88, 6);
    expect(ergebnis.gesamt, 'gedeckelt bei 1').toBe(1);
    expect(ergebnis.gedeckelt).toBe(true);
    expect(saturationFlow('geradeaus', 1, RILSA_DEFAULTS, { neigung: -4 })).toBe(
      RILSA_DEFAULTS.capacity.saturationFlow,
    );
  });

  it('lässt ein Gefälle eine andere Abminderung trotzdem mildern', () => {
    /*
     * Der Deckel greift am PRODUKT, nicht an f2. Schmale Zufahrt mit Gefaelle:
     * f1 = 1,1875, f2 = 0,88, Produkt 1,045 - das liegt ueber 1 und bleibt
     * stehen. Die Zufahrt ist immer noch schmal, nur weniger schlimm.
     */
    const ergebnis = geometriefaktor({ breite: 2.5, neigung: -4 }, 'geradeaus');
    expect(ergebnis.gesamt).toBeCloseTo(1.045, 3);
    expect(ergebnis.gedeckelt).toBe(false);
  });

  it('meldet den greifenden Deckel im Prüfbericht', () => {
    const bericht = validateProject(mitGeometrie({ laengsneigung: -4 }));
    const meldung = bericht.findings.find(
      (f) => f.rule === 'leistungsfaehigkeit.geometrie-gefaelle-gedeckelt',
    );
    expect(meldung, 'die Abweichung wird nicht verschwiegen').toBeDefined();
    expect(meldung?.severity).toBe('hinweis');
    expect(meldung?.message).toContain('13,6');
  });

  it('schweigt, wo keine Geometrie erfasst ist', () => {
    // Eine Meldung an jeder Signalgruppe jedes Plans saehe niemand mehr an.
    const bericht = validateProject(createStandardIntersectionProject('Ohne Geometrie', DATUM));
    expect(bericht.findings.some((f) => f.rule.startsWith('leistungsfaehigkeit.geometrie-'))).toBe(
      false,
    );
  });
});

describe('Geometriefaktoren - kein fR am Abbieger', () => {
  it('lässt den Radius an abbiegenden Strömen ohne Wirkung', () => {
    /*
     * Sonst mindert der Radius zweimal ab: Der pauschale Abbiegerfaktor 0,90
     * ist in quellen.ts ausdruecklich als Ersatz fuer die differenzierten
     * HBS-Faktoren nach Abbiegeradius, Gegenverkehr und Fussgaengerquerung
     * gefuehrt. 0,90 / 1,15 waeren 0,783 des Grundwerts.
     */
    for (const movement of ['links', 'rechts'] as const) {
      const ergebnis = geometriefaktor({ radius: 10 }, movement);
      expect(ergebnis.fR, movement).toBe(1);
      expect(ergebnis.gesamt, movement).toBe(1);
      expect(ergebnis.radiusVomAbbiegerfaktorGedeckt, movement).toBe(true);
    }
    // Der Abbiegerfaktor selbst bleibt: 2000 * 0,9 = 1800 Kfz/h.
    expect(saturationFlow('rechts', 1, RILSA_DEFAULTS, { radius: 10 })).toBeCloseTo(
      RILSA_DEFAULTS.capacity.saturationFlow * RILSA_DEFAULTS.capacity.turningFactor,
      6,
    );
  });

  it('lässt Breite und Neigung am Abbieger sehr wohl wirken', () => {
    // Nur der Radius ist vom pauschalen Faktor gedeckt, die beiden anderen
    // nicht - sie pauschal mit auszunehmen waere die unsichere Richtung.
    const ergebnis = geometriefaktor({ breite: 2.5, neigung: 4 }, 'links');
    expect(ergebnis.gesamt).toBeCloseTo(1.1875, 6);
    expect(ergebnis.radiusVomAbbiegerfaktorGedeckt).toBe(false);
  });

  it('meldet den wirkungslosen Eintrag im Prüfbericht', () => {
    const bericht = validateProject(mitGeometrie({ kurvenradius: 10 }, 'links'));
    const meldung = bericht.findings.find(
      (f) => f.rule === 'leistungsfaehigkeit.geometrie-radius-ohne-wirkung',
    );
    expect(meldung, 'ein Eintrag ohne Wirkung wird benannt').toBeDefined();
    expect(meldung?.message).toContain('Abbiegerfaktor');
  });
});

describe('Geometriefaktoren - im Plan und in der Datei', () => {
  it('senkt die Kapazität der betroffenen Signalgruppe', () => {
    /*
     * BEIDE PLAENE AUS DEMSELBEN PROJEKT. `createStandardIntersectionProject`
     * vergibt bei jedem Aufruf neue Kennungen; wer zweimal aufruft und die
     * Gruppen ueber `groupId` gegeneinanderhaelt, findet keine - und ein
     * `?? 0` daneben macht aus dem leeren Vergleich einen bestandenen Fall.
     * Genau so stand dieser Fall zuerst da, und er hat nichts geprueft.
     */
    const basis = ohneGeometrie();
    const gruppenId = basis.signalGroups.find((g) => g.mode === 'kfz')?.id;
    expect(gruppenId, 'die Vorlage führt eine Kfz-Signalgruppe').toBeDefined();

    const ohne = buildSignalPlan(basis);
    const mit = buildSignalPlan({
      ...basis,
      signalGroups: basis.signalGroups.map((g) =>
        g.id === gruppenId ? { ...g, fahrstreifenbreite: 2.5 } : g,
      ),
    });

    const vorher = ohne.groups.find((g) => g.groupId === gruppenId);
    const nachher = mit.groups.find((g) => g.groupId === gruppenId);
    expect(vorher?.capacity, 'die Gruppe steht im Plan').not.toBeNull();
    expect(nachher?.capacity, 'und auch im zweiten Plan').not.toBeNull();
    // fb(2,50) = 1,1875 - dieselbe Minderung wie an der reinen Funktion.
    expect(nachher?.capacity?.saturationFlow).toBeCloseTo(
      (vorher?.capacity?.saturationFlow ?? 0) / 1.1875,
      6,
    );

    // Die uebrigen Gruppen bleiben unberuehrt: Die Geometrie haengt an der
    // Signalgruppe und nicht an der Anlage.
    for (const gruppe of mit.groups) {
      if (gruppe.groupId === gruppenId || gruppe.capacity === null) continue;
      const gegenstueck = ohne.groups.find((g) => g.groupId === gruppe.groupId);
      expect(gruppe.capacity.saturationFlow, gruppe.name).toBe(
        gegenstueck?.capacity?.saturationFlow,
      );
    }
  });

  it('trägt die drei Felder unverändert durch Datei und Einlesen', () => {
    const projekt = mitGeometrie({ fahrstreifenbreite: 2.75, kurvenradius: 12, laengsneigung: 3 });
    const geladen = loadProject(JSON.parse(JSON.stringify(projekt)));
    const gruppe = geladen.project.signalGroups[0];
    expect(geladen.project.schemaVersion).toBe(19);
    expect(gruppe?.fahrstreifenbreite).toBe(2.75);
    expect(gruppe?.kurvenradius).toBe(12);
    expect(gruppe?.laengsneigung).toBe(3);
  });

  it('erfindet für eine Altdatei keine Vermessung', () => {
    /*
     * Ein fehlendes Feld bleibt fehlend - es wird nicht mit einem Regelwert
     * gefuellt. Sonst stuende in jeder alten Datei nach dem naechsten Speichern
     * eine Angabe, die niemand gemacht hat (dasselbe Muster wie beim
     * Blindenzusatz in Schema 11).
     */
    const roh = JSON.parse(JSON.stringify(mitGeometrie({}))) as Record<string, unknown>;
    const gruppen = roh['signalGroups'] as Record<string, unknown>[];
    expect(gruppen[0], 'die Vorlage traegt kein Geometriefeld').not.toHaveProperty(
      'fahrstreifenbreite',
    );
    const geladen = loadProject(roh);
    expect(geladen.project.signalGroups[0]?.fahrstreifenbreite).toBeUndefined();
  });

  it('meldet einen unlesbaren Eintrag, statt still mit Standardbedingung zu rechnen', () => {
    const roh = JSON.parse(JSON.stringify(mitGeometrie({}))) as Record<string, unknown>;
    const gruppen = roh['signalGroups'] as Record<string, unknown>[];
    (gruppen[0] as Record<string, unknown>)['fahrstreifenbreite'] = 'schmal';
    const geladen = loadProject(roh);
    expect(geladen.project.signalGroups[0]?.fahrstreifenbreite).toBeUndefined();
    const meldung = geladen.issues.find((i) => i.path.endsWith('.fahrstreifenbreite'));
    expect(meldung, 'die Meldung fehlt').toBeDefined();
    // Die Fehlerrichtung gehoert in die Meldung: Ohne den Wert faellt die
    // Saettigungsverkehrsstaerke GROESSER aus.
    expect(meldung?.message).toContain('größer');
  });
});

/** Standardknotenpunkt mit Verkehrsstaerken, ohne jede Geometrie. */
function ohneGeometrie(): Project {
  const roh = createStandardIntersectionProject('Geometrie', DATUM);
  return {
    ...roh,
    demands: roh.signalGroups
      .filter((g) => g.mode === 'kfz')
      .map((g) => ({ signalGroupId: g.id, volume: 500, heavyVehicleShare: 0.05 })),
  };
}

/** Standardknotenpunkt, dessen erste Kfz-Gruppe die Geometrie traegt. */
function mitGeometrie(
  geometrie: Partial<Pick<SignalGroup, 'fahrstreifenbreite' | 'kurvenradius' | 'laengsneigung'>>,
  movement?: SignalGroup['movement'],
): Project {
  const roh = createStandardIntersectionProject('Geometrie', DATUM);
  let gesetzt = false;
  return {
    ...roh,
    signalGroups: roh.signalGroups.map((gruppe) => {
      if (gesetzt || gruppe.mode !== 'kfz') return gruppe;
      gesetzt = true;
      return {
        ...gruppe,
        ...(movement === undefined ? {} : { movement }),
        ...geometrie,
      };
    }),
    demands: roh.signalGroups
      .filter((g) => g.mode === 'kfz')
      .map((g) => ({ signalGroupId: g.id, volume: 500, heavyVehicleShare: 0.05 })),
  };
}