import { describe, expect, it } from 'vitest';
import { computeCapacity, criticalFlowRatio, saturationFlow } from '@/domain/rilsa/capacity';
import { computeDelay, serviceLevelFor } from '@/domain/rilsa/delay';
import { computeCoordination, travelTime } from '@/domain/rilsa/coordination';

describe('Kapazitaet', () => {
  it('mindert die Saettigungsverkehrsstaerke abbiegender Stroeme', () => {
    expect(saturationFlow('geradeaus', 1)).toBe(2000);
    expect(saturationFlow('geradeaus', 2)).toBe(4000);
    expect(saturationFlow('links', 1)).toBeCloseTo(1800, 6);
  });

  it('rechnet c = qS * tA / tU mit der Abflusszeit tA = tF + 1 s (HBS)', () => {
    const result = computeCapacity(29, 90, 1800);
    expect(result.abflusszeit).toBe(30);
    expect(result.greenRatio).toBeCloseTo(1 / 3, 4);
    expect(result.capacity).toBe(600);
    expect(result.verfahren).toBe('HBS');
  });

  it('rechnet nach HCM mit der Freigabezeit selbst', () => {
    const result = computeCapacity(30, 90, 1800, undefined, { verfahren: 'HCM' });
    expect(result.abflusszeit).toBe(30);
    expect(result.capacity).toBe(600);
  });

  it('rechnet den Auslastungsgrad tatsaechlich aus der Verkehrsstaerke', () => {
    // Der Altbestand gab hier konstant 0 aus.
    const result = computeCapacity(29, 90, 1800, 540);
    expect(result.degreeOfSaturation).toBeCloseTo(0.9, 4);
    expect(result.notes.some((n) => n.code === 'auslastung-kritisch')).toBe(false);
  });

  it('meldet eine Nachfrage ueber der Kapazitaet', () => {
    const result = computeCapacity(29, 90, 1800, 900);
    expect(result.degreeOfSaturation).toBeCloseTo(1.5, 4);
    expect(result.notes.some((n) => n.code === 'auslastung-ueber-100')).toBe(true);
  });

  it('meldet eine Freigabezeit laenger als die Umlaufzeit', () => {
    const result = computeCapacity(100, 90, 1800);
    expect(result.notes.some((n) => n.code === 'freigabezeit-ueber-umlaufzeit')).toBe(true);
  });

  it('liefert bei fehlender Saettigung keinen NaN-Wert', () => {
    expect(criticalFlowRatio(500, 0)).toBe(Number.POSITIVE_INFINITY);
    expect(criticalFlowRatio(Number.NaN, 1800)).toBe(0);
  });
});

describe('Wartezeit und Qualitaetsstufe', () => {
  const wartezeit = (demand: number, verfahren: 'HBS' | 'HCM' = 'HBS') =>
    computeDelay({ cycleTime: 90, greenTime: 30, capacity: 600, demand, verfahren, mode: 'kfz' });

  it('setzt sich aus Grundwartezeit und Reststauanteil zusammen', () => {
    for (const verfahren of ['HBS', 'HCM'] as const) {
      const result = wartezeit(400, verfahren);
      expect(result.uniformDelay).toBeGreaterThan(0);
      expect(result.incrementalDelay).toBeGreaterThanOrEqual(0);
      expect(result.averageDelay).toBeCloseTo(result.uniformDelay + result.incrementalDelay, 0);
    }
  });

  it('waechst mit steigender Auslastung deutlich an', () => {
    for (const verfahren of ['HBS', 'HCM'] as const) {
      const low = wartezeit(200, verfahren);
      const high = wartezeit(580, verfahren);
      // Der Altbestand rechnete mit fest eingetragenem x = 0,85 und lieferte
      // deshalb fuer beide Faelle denselben Wert.
      expect(high.averageDelay).toBeGreaterThan(low.averageDelay * 1.5);
    }
  });

  it('meldet Ueberlastung und vergibt dafuer die Stufe F', () => {
    const result = wartezeit(700);
    expect(result.degreeOfSaturation).toBeGreaterThan(1);
    expect(result.notes.some((n) => n.code === 'ueberlastet')).toBe(true);
    expect(result.serviceLevel?.grade).toBe('F');
    expect(result.serviceLevel?.kriterium).toBe('ueberlastung');
  });

  it('bewertet nach dem gewaehlten Verfahren und weist es aus', () => {
    expect(serviceLevelFor(15, 'HBS')?.grade).toBe('A');
    expect(serviceLevelFor(15, 'HCM')?.grade).toBe('B');
    expect(serviceLevelFor(15, 'HBS')?.scale).toBe('HBS');
    // Nach HBS 2015 ist E nach oben offen; F gibt es nur bei Ueberlastung.
    expect(serviceLevelFor(500, 'HBS')?.grade).toBe('E');
    expect(serviceLevelFor(500, 'HBS', { degreeOfSaturation: 1.2 })?.grade).toBe('F');
    expect(serviceLevelFor(500, 'HCM')?.grade).toBe('F');
  });

  it('faengt eine Kapazitaet von 0 ab', () => {
    const result = computeDelay({
      cycleTime: 90,
      greenTime: 0,
      capacity: 0,
      demand: 400,
      verfahren: 'HBS',
      mode: 'kfz',
    });
    expect(result.notes.some((n) => n.code === 'kapazitaet-null')).toBe(true);
    expect(Number.isNaN(result.averageDelay)).toBe(false);
    // Nachfrage ohne Kapazitaet ist Ueberlastung.
    expect(result.serviceLevel?.grade).toBe('F');
  });
});

describe('Koordinierung', () => {
  it('rechnet die Reisezeit aus Abstand und Geschwindigkeit', () => {
    // 500 m bei 50 km/h = 13,889 m/s -> 36 s
    expect(travelTime(500, 50)).toBeCloseTo(36, 1);
  });

  it('ermittelt Versatzzeiten und Bandbreite aus den Freigabefenstern', () => {
    const result = computeCoordination(
      [
        { id: 'a', name: 'Knoten A', distanceToPrevious: 0, greenStart: 0, greenDuration: 40 },
        { id: 'b', name: 'Knoten B', distanceToPrevious: 500, greenStart: 36, greenDuration: 40 },
      ],
      90,
      50,
    );

    expect(result.intersections[1]!.travelTime).toBeCloseTo(36, 1);
    expect(result.intersections[1]!.offset).toBeCloseTo(36, 1);
    // Beide Fenster decken sich nach Verschiebung vollstaendig.
    expect(result.bandwidth).toBeCloseTo(40, 1);
    expect(result.quality).toBe('gut');
  });

  it('erkennt unpassende Versaetze', () => {
    // Der Altbestand meldete hier "kleinste Freigabezeit minus 5 s" und
    // beruecksichtigte den Versatz gar nicht.
    const result = computeCoordination(
      [
        { id: 'a', name: 'Knoten A', distanceToPrevious: 0, greenStart: 0, greenDuration: 30 },
        { id: 'b', name: 'Knoten B', distanceToPrevious: 500, greenStart: 0, greenDuration: 30 },
      ],
      90,
      50,
    );

    expect(result.bandwidth).toBe(0);
    expect(result.notes.some((n) => n.code === 'keine-bandbreite')).toBe(true);
  });

  it('verlangt mindestens zwei Knotenpunkte', () => {
    const result = computeCoordination(
      [{ id: 'a', name: 'A', distanceToPrevious: 0, greenStart: 0, greenDuration: 30 }],
      90,
    );
    expect(result.notes.some((n) => n.code === 'zu-wenige-knoten')).toBe(true);
  });
});