import { describe, expect, it } from 'vitest';
import { compareCycleTimeMethods, computeCycleTime, minimumCycleTime } from '@/domain/rilsa/cycle';

describe('Umlaufzeitermittlung', () => {
  it('rechnet Webster korrekt und rastert auf 5 s', () => {
    // (1,5 * 20 + 5) / (1 - 0,6) = 35 / 0,4 = 87,5 -> 90 s
    const result = computeCycleTime('webster', { lostTime: 20, criticalFlowRatios: [0.35, 0.25] });
    expect(result.totalFlowRatio).toBeCloseTo(0.6, 6);
    expect(result.raw).toBeCloseTo(87.5, 2);
    expect(result.cycleTime).toBe(90);
    expect(result.bounded).toBe('keine');
  });

  it('rechnet Akcelik als eigenstaendiges Verfahren', () => {
    // (1,4 * 20 + 6) / (1 - 0,6) = 34 / 0,4 = 85 s
    const result = computeCycleTime('akcelik', { lostTime: 20, criticalFlowRatios: [0.6] });
    expect(result.raw).toBeCloseTo(85, 2);
    // Der Altbestand rechnete hier Webster * 1,1 bzw. * 1,2.
    expect(result.raw).not.toBeCloseTo(87.5 * 1.1, 1);
  });

  it('beruecksichtigt beim kapazitaetsorientierten Verfahren die Saettigungsgrade', () => {
    // L * x / (x - Y) = 20 * 0,85 / (0,85 - 0,6) = 17 / 0,25 = 68 s
    const result = computeCycleTime('hbs', { lostTime: 20, criticalFlowRatios: [0.6] });
    expect(result.raw).toBeCloseTo(68, 2);
    // Der Altbestand rechnete L / (1 - 0,85) = 133,3 s, unabhaengig von Y.
    expect(result.raw).not.toBeCloseTo(133.3, 0);
  });

  it('erkennt einen uebersaettigten Knotenpunkt statt still auf 30 s zu klemmen', () => {
    const result = computeCycleTime('webster', { lostTime: 20, criticalFlowRatios: [0.7, 0.35] });
    expect(result.notes.some((n) => n.code === 'uebersaettigt' && n.severity === 'fehler')).toBe(
      true,
    );
    // Der Altbestand lieferte hier stillschweigend die Mindestumlaufzeit.
    expect(result.cycleTime).not.toBe(30);
  });

  it('meldet fehlende Verkehrsstaerken, statt einen Wert zu erfinden', () => {
    const result = computeCycleTime('webster', { lostTime: 20, criticalFlowRatios: [] });
    expect(result.notes.some((n) => n.code === 'saettigungsgrade-fehlen')).toBe(true);
  });

  it('haelt die Mindestumlaufzeit ein', () => {
    const result = computeCycleTime('webster', {
      lostTime: 10,
      criticalFlowRatios: [0.2],
      minimumCycle: 75,
    });
    expect(result.cycleTime).toBe(75);
    expect(result.bounded).toBe('mindestumlauf');
  });

  it('meldet eine Ueberschreitung des Hoechstwerts als Fehler', () => {
    const result = computeCycleTime('webster', { lostTime: 40, criticalFlowRatios: [0.55, 0.3] });
    expect(result.cycleTime).toBe(120);
    expect(result.bounded).toBe('maximum');
    expect(result.notes.some((n) => n.code === 'umlaufzeit-ueber-hoechstwert')).toBe(true);
  });

  it('liefert eine begruendete Empfehlung statt NaN', () => {
    const comparison = compareCycleTimeMethods({ lostTime: 20, criticalFlowRatios: [0.6] });
    // Der Altbestand addierte Objekte auf eine Zahl; das Ergebnis war immer NaN.
    //
    // SEIT FASSUNG 5.28.0 ist die Empfehlung ein WERT und kein
    // Verfahrensergebnis mehr - bei Gleichstand entschied zuvor die
    // Reihenfolge des Objektliterals. Die Faelle dazu stehen in
    // umlaufzeitvergleichEhrlichkeit.test.ts; hier bleibt die alte Frage: Ist
    // ueberhaupt eine Zahl herausgekommen?
    expect(comparison.recommendedCycleTime).not.toBeNull();
    expect(Number.isFinite(comparison.recommendedCycleTime ?? Number.NaN)).toBe(true);
    expect(comparison.recommendedCycleTime ?? 0).toBeGreaterThan(0);
    expect(comparison.reason).toContain('Empfohlen');
    for (const method of ['webster', 'akcelik', 'hbs', 'hcm'] as const) {
      expect(Number.isFinite(comparison.results[method].cycleTime)).toBe(true);
    }
  });

  it('summiert die Mindestumlaufzeit aus Freigabe- und Uebergangszeiten', () => {
    expect(minimumCycleTime([5, 5, 5], [6, 6, 6])).toBe(33);
    expect(minimumCycleTime([Number.NaN, 5], [6])).toBe(11);
  });
});