import { describe, expect, it } from 'vitest';
import { computeIntergreen, clearingSpeedFor } from '@/domain/rilsa/intergreen';
import { RILSA_DEFAULTS, SAFETY_FLOORS } from '@/domain/rilsa/constants';
import type { ClearingStream, EnteringStream } from '@/domain/rilsa/types';

const kfzClearing = (overrides: Partial<ClearingStream> = {}): ClearingStream => ({
  mode: 'kfz',
  movement: 'geradeaus',
  clearingDistance: 22,
  vehicleClass: 'pkw',
  vZul: 50,
  ...overrides,
});

const kfzEntering = (overrides: Partial<EnteringStream> = {}): EnteringStream => ({
  mode: 'kfz',
  movement: 'geradeaus',
  enteringDistance: 8,
  ...overrides,
});

describe('Zwischenzeitberechnung nach RiLSA', () => {
  it('rechnet tz = tue + tr - te und rundet nur das Endergebnis auf', () => {
    const result = computeIntergreen(kfzClearing(), kfzEntering());

    // sr = 22 m + 6 m Fahrzeuglaenge = 28 m, vr = 10 m/s -> tr = 2,8 s
    expect(result.clearingPath).toBe(28);
    expect(result.clearingSpeed).toBe(10);
    expect(result.clearingTime).toBeCloseTo(2.8, 6);

    // se = 8 m, ve = 11,1 m/s -> te = 0,7207 s
    expect(result.enteringSpeed).toBe(11.1);
    expect(result.enteringTime).toBeCloseTo(0.721, 3);

    // tue = Gelbzeit bei 50 km/h = 3 s
    expect(result.crossingTime).toBe(3);

    // 3 + 2,8 - 0,7207 = 5,0793 -> 6 s
    expect(result.raw).toBeCloseTo(5.079, 3);
    expect(result.intergreen).toBe(6);
  });

  it('rundet die Teilzeiten NICHT einzeln auf', () => {
    // Der Altbestand rundete tr und te einzeln auf: ceil(2,8) - ceil(0,72) = 3 - 1 = 2,
    // zusammen mit tue = 3 also 5 s statt der richtigen 6 s.
    const result = computeIntergreen(kfzClearing(), kfzEntering());
    expect(result.clearingTime).not.toBe(Math.ceil(result.clearingTime));
    expect(result.enteringTime).not.toBe(Math.ceil(result.enteringTime));
    expect(result.intergreen).toBe(6);
  });

  it('setzt fuer abbiegende Kraftfahrzeuge die geringere Raeumgeschwindigkeit an', () => {
    const straight = computeIntergreen(kfzClearing({ movement: 'geradeaus' }), kfzEntering());
    const turning = computeIntergreen(kfzClearing({ movement: 'links' }), kfzEntering());

    expect(straight.clearingSpeed).toBe(RILSA_DEFAULTS.clearingSpeed.kfzStraight);
    expect(turning.clearingSpeed).toBe(RILSA_DEFAULTS.clearingSpeed.kfzTurning);
    // Langsameres Raeumen ergibt eine laengere - also sicherere - Zwischenzeit.
    expect(turning.intergreen).toBeGreaterThan(straight.intergreen);
  });

  it('rechnet Fussgaenger in m/s und ohne Ueberfahrzeit', () => {
    const result = computeIntergreen(
      {
        mode: 'fuss',
        movement: 'querung',
        clearingDistance: 12,
        vehicleClass: 'keine',
        vZul: 0,
      },
      kfzEntering(),
    );

    // Der Altbestand teilte die in m/s hinterlegten 1,2 nochmals durch 3,6.
    expect(result.clearingSpeed).toBe(1.2);
    expect(result.clearingTime).toBeCloseTo(10, 6);
    expect(result.crossingTime).toBe(0);
    expect(result.intergreen).toBe(10);
  });

  it('beruecksichtigt erhoehten Zeitbedarf bei Fussgaengerfurten', () => {
    const normal = computeIntergreen(
      { mode: 'fuss', movement: 'querung', clearingDistance: 12, vehicleClass: 'keine', vZul: 0 },
      kfzEntering(),
    );
    const reduced = computeIntergreen(
      {
        mode: 'fuss',
        movement: 'querung',
        clearingDistance: 12,
        vehicleClass: 'keine',
        vZul: 0,
        reducedMobility: true,
      },
      kfzEntering(),
    );

    expect(reduced.clearingSpeed).toBe(1.0);
    expect(reduced.intergreen).toBeGreaterThan(normal.intergreen);
  });

  it('staffelt die Ueberfahrzeit von Kraftfahrzeugen nach der Hoechstgeschwindigkeit', () => {
    expect(computeIntergreen(kfzClearing({ vZul: 50 }), kfzEntering()).crossingTime).toBe(3);
    expect(computeIntergreen(kfzClearing({ vZul: 60 }), kfzEntering()).crossingTime).toBe(4);
    expect(computeIntergreen(kfzClearing({ vZul: 70 }), kfzEntering()).crossingTime).toBe(5);
  });

  it('beruecksichtigt den Laengenzuschlag der Fahrzeugart', () => {
    // RiLSA-Rechenlaengen (Befund B5): 6 m fuer alle Kraftfahrzeuge
    // einschliesslich Lastzug - hier standen 18,75 m (Par. 32 StVZO). Eine
    // Strassenbahn raeumt mit 15 m.
    const pkw = computeIntergreen(kfzClearing({ vehicleClass: 'pkw' }), kfzEntering());
    const lastzug = computeIntergreen(kfzClearing({ vehicleClass: 'lastzug' }), kfzEntering());
    const bahn = computeIntergreen(kfzClearing({ vehicleClass: 'strassenbahn' }), kfzEntering());

    expect(pkw.vehicleLength).toBe(6);
    expect(lastzug.vehicleLength).toBe(6);
    expect(lastzug.clearingPath).toBe(22 + 6);
    expect(lastzug.intergreen).toBe(pkw.intergreen);
    expect(bahn.vehicleLength).toBe(15);
    expect(bahn.clearingPath).toBe(22 + 15);
    expect(bahn.clearingTime).toBeGreaterThan(pkw.clearingTime);
    // Wer laenger ansetzen will, tut das ueber die Vorgaben - als Verschaerfung.
    const verschaerft = computeIntergreen(kfzClearing({ vehicleClass: 'lastzug' }), kfzEntering(), {
      ...RILSA_DEFAULTS,
      vehicleLength: { ...RILSA_DEFAULTS.vehicleLength, lastzug: 18.75 },
    });
    expect(verschaerft.vehicleLength).toBe(18.75);
    expect(verschaerft.intergreen).toBeGreaterThan(pkw.intergreen);
  });

  it('setzt eine rechnerisch negative Zwischenzeit auf 0 s und meldet das', () => {
    const result = computeIntergreen(
      { mode: 'fuss', movement: 'querung', clearingDistance: 0, vehicleClass: 'keine', vZul: 0 },
      kfzEntering({ enteringDistance: 30 }),
    );

    expect(result.raw).toBeLessThan(0);
    expect(result.intergreen).toBe(0);
    expect(result.clampedToZero).toBe(true);
    expect(result.notes.some((n) => n.code === 'zwischenzeit-negativ')).toBe(true);
  });

  it('begrenzt eine zu hoch vorgegebene Raeumgeschwindigkeit', () => {
    const result = computeIntergreen(kfzClearing({ clearingSpeedOverride: 25 }), kfzEntering());

    expect(result.clearingSpeed).toBe(SAFETY_FLOORS.maxClearingSpeedKfz);
    expect(
      result.notes.some(
        (n) => n.code === 'raeumgeschwindigkeit-zu-hoch' && n.severity === 'fehler',
      ),
    ).toBe(true);
  });

  it('laesst eine niedrigere Raeumgeschwindigkeit zu, weil sie auf der sicheren Seite liegt', () => {
    const result = computeIntergreen(kfzClearing({ clearingSpeedOverride: 6 }), kfzEntering());
    expect(result.clearingSpeed).toBe(6);
    expect(result.notes.some((n) => n.severity === 'fehler')).toBe(false);
  });

  it('warnt, wenn die Einfahrgeschwindigkeit unter dem Regelwert liegt', () => {
    const result = computeIntergreen(kfzClearing(), kfzEntering({ enteringSpeedOverride: 5 }));
    expect(result.enteringSpeed).toBe(5);
    expect(result.notes.some((n) => n.code === 'einfahrgeschwindigkeit-unter-regelwert')).toBe(
      true,
    );
  });

  /*
   * Fuer Kraftfahrzeuge IST die Ueberfahrzeit die Gelbzeit. Sie war das einzige
   * Vorgabefeld der Zwischenzeitenansicht ohne jede Schranke: Eine eingetragene
   * 0 senkte die Zwischenzeit von 6 s auf 3 s und hebelte damit
   * SAFETY_FLOORS.yellowKfz ueber ein Eingabefeld aus - ohne eine einzige
   * Meldung.
   */
  it('kappt eine Ueberfahrzeit unter der Gelbzeitschranke und meldet das', () => {
    const ohne = computeIntergreen(kfzClearing(), kfzEntering());
    const mitNull = computeIntergreen(kfzClearing({ crossingTimeOverride: 0 }), kfzEntering());

    expect(ohne.crossingTime).toBe(3);
    expect(ohne.intergreen).toBe(6);

    // Angesetzt wird die Schranke, nicht die 0.
    expect(mitNull.crossingTime).toBe(SAFETY_FLOORS.yellowKfz);
    expect(mitNull.intergreen).toBe(ohne.intergreen);
    expect(
      mitNull.notes.some(
        (n) => n.code === 'ueberfahrzeit-unter-gelbzeitschranke' && n.severity === 'fehler',
      ),
    ).toBe(true);
  });

  /*
   * Massgebend ist die Gelbzeit DIESER Signalgruppe, nicht die kuerzeste
   * ueberhaupt zulaessige. Waere nur gegen SAFETY_FLOORS.yellowKfz geprueft,
   * bliebe die Zwischenzeit bei 70 km/h um 2 s zu kurz - und der Anwender
   * koennte den Fehler durch Eintragen ebendieser 3 s in eine blosse Warnung
   * verwandeln, ohne dass sich am Ergebnis etwas aendert.
   */
  it('kappt fuer Kfz auf die Gelbzeit der Signalgruppe, nicht auf die unterste Schranke', () => {
    const regel = computeIntergreen(kfzClearing({ vZul: 70 }), kfzEntering());
    expect(regel.crossingTime).toBe(5);

    for (const vorgabe of [0, SAFETY_FLOORS.yellowKfz, 4]) {
      const gekuerzt = computeIntergreen(
        kfzClearing({ vZul: 70, crossingTimeOverride: vorgabe }),
        kfzEntering(),
      );
      expect(gekuerzt.crossingTime, `Vorgabe ${vorgabe}`).toBe(5);
      expect(gekuerzt.intergreen, `Vorgabe ${vorgabe}`).toBe(regel.intergreen);
      expect(
        gekuerzt.notes.some(
          (n) => n.code === 'ueberfahrzeit-unter-gelbzeitschranke' && n.severity === 'fehler',
        ),
        `Vorgabe ${vorgabe}`,
      ).toBe(true);
    }
  });

  it('nennt in der Meldung die Gelbzeit, die tatsaechlich zu zeigen ist', () => {
    const gekuerzt = computeIntergreen(
      kfzClearing({ vZul: 70, crossingTimeOverride: 0 }),
      kfzEntering(),
    );
    const meldung = gekuerzt.notes.find((n) => n.code === 'ueberfahrzeit-unter-gelbzeitschranke');
    // Ohne die richtige Zahl im Text traegt der Anwender die falsche ein.
    expect(meldung?.message).toContain('5 s');
    expect(meldung?.message).toContain('70 km/h');
  });

  it('warnt beim Radverkehr nur, weil es dort keine Gelbzeit gibt', () => {
    const radRaeumend: ClearingStream = {
      mode: 'rad',
      movement: 'geradeaus',
      clearingDistance: 20,
      vehicleClass: 'rad',
      vZul: 25,
    };
    const regel = computeIntergreen(radRaeumend, kfzEntering());
    const gekuerzt = computeIntergreen({ ...radRaeumend, crossingTimeOverride: 0 }, kfzEntering());

    expect(gekuerzt.crossingTime).toBe(0);
    expect(gekuerzt.crossingTime).toBeLessThan(regel.crossingTime);
    expect(
      gekuerzt.notes.some(
        (n) => n.code === 'ueberfahrzeit-unter-regelwert' && n.severity === 'warnung',
      ),
    ).toBe(true);
    expect(gekuerzt.notes.some((n) => n.severity === 'fehler')).toBe(false);
  });

  it('laesst eine laengere Ueberfahrzeit ohne Meldung zu, weil sie sicher liegt', () => {
    const result = computeIntergreen(kfzClearing({ crossingTimeOverride: 5 }), kfzEntering());
    expect(result.crossingTime).toBe(5);
    expect(result.notes.some((n) => n.code?.startsWith('ueberfahrzeit'))).toBe(false);
  });

  it('faengt fehlende und negative Wege ab, statt mit NaN weiterzurechnen', () => {
    const missing = computeIntergreen(
      kfzClearing({ clearingDistance: Number.NaN }),
      kfzEntering({ enteringDistance: Number.NaN }),
    );
    expect(Number.isFinite(missing.intergreen)).toBe(true);
    expect(missing.notes.some((n) => n.code === 'raeumweg-fehlt')).toBe(true);

    const negative = computeIntergreen(kfzClearing({ clearingDistance: -22 }), kfzEntering());
    expect(negative.clearingPath).toBe(28);
    expect(negative.notes.some((n) => n.code === 'raeumweg-negativ')).toBe(true);
  });

  it('liefert fuer jede Verkehrsart eine definierte Raeumgeschwindigkeit', () => {
    for (const mode of ['kfz', 'rad', 'fuss', 'oepnv'] as const) {
      for (const movement of ['geradeaus', 'rechts', 'links', 'querung'] as const) {
        const speed = clearingSpeedFor({ mode, movement });
        expect(Number.isFinite(speed)).toBe(true);
        expect(speed).toBeGreaterThan(0);
      }
    }
  });
});