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

/*
 * Befund 10, behoben in Fassung 5.10.0.
 *
 * tz = tue + tr - te. Eine NIEDRIGERE Einfahrgeschwindigkeit vergroessert te
 * und verkuerzt damit die Zwischenzeit - die gefaehrliche Richtung. Bei jeder
 * Raeumgeschwindigkeit riegelt das Programm diese Richtung ab (Feldschranke
 * gegen SAFETY_FLOORS oder nachgelagerter Quervergleich in
 * resolveRilsaSettings); die vier Einfahrgeschwindigkeitsfelder hatten weder
 * das eine noch das andere. Kfz liess sich auf 5 m/s absenken - weniger als
 * die Haelfte des Regelwerts von 11,1 m/s.
 */

interface Einfahrfeld {
  readonly key: keyof RilsaOverrides;
  readonly mode: TrafficMode;
  readonly regelwert: number;
  /** Wert, den das Feld VOR der Behebung noch angenommen hat. */
  readonly abgesenkt: number;
}

const EINFAHRFELDER: readonly Einfahrfeld[] = [
  {
    key: 'enteringSpeedKfz',
    mode: 'kfz',
    regelwert: RILSA_DEFAULTS.enteringSpeed.kfz,
    abgesenkt: 5,
  },
  {
    key: 'enteringSpeedRad',
    mode: 'rad',
    regelwert: RILSA_DEFAULTS.enteringSpeed.rad,
    abgesenkt: 2,
  },
  {
    key: 'enteringSpeedFuss',
    mode: 'fuss',
    regelwert: RILSA_DEFAULTS.enteringSpeed.fuss,
    abgesenkt: 0.8,
  },
  {
    key: 'enteringSpeedOepnv',
    mode: 'oepnv',
    regelwert: RILSA_DEFAULTS.enteringSpeed.oepnv,
    abgesenkt: 5,
  },
];

const kfzRaeumt = (): ClearingStream => ({
  mode: 'kfz',
  movement: 'geradeaus',
  clearingDistance: 22,
  vehicleClass: 'pkw',
  vZul: 50,
});

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

describe('Befund 10 - Einfahrgeschwindigkeit ist nach unten gesichert', () => {
  it('hebt jede unter den Regelwert abgesenkte Vorgabe an und meldet sie als Fehler', () => {
    for (const feld of EINFAHRFELDER) {
      const { defaults, notes } = resolveRilsaSettings({ [feld.key]: feld.abgesenkt });
      expect(defaults.enteringSpeed[feld.mode], feld.key).toBe(feld.regelwert);
      expect(
        notes.some(
          (n) => n.code === `vorgabe-unterschritten:${feld.key}` && n.severity === 'fehler',
        ),
        feld.key,
      ).toBe(true);
    }
  });

  it('haelt die Untergrenze in SAFETY_FLOORS und nicht als Zahl im Feld', () => {
    // Dieselbe Systematik wie bei den Raeumgeschwindigkeiten, nur spiegelbildlich:
    // dort ist der Regelwert die Ober-, hier die Untergrenze.
    expect(SAFETY_FLOORS.minEnteringSpeedKfz).toBe(RILSA_DEFAULTS.enteringSpeed.kfz);
    expect(SAFETY_FLOORS.minEnteringSpeedRad).toBe(RILSA_DEFAULTS.enteringSpeed.rad);
    expect(SAFETY_FLOORS.minEnteringSpeedFuss).toBe(RILSA_DEFAULTS.enteringSpeed.fuss);
    expect(SAFETY_FLOORS.minEnteringSpeedOepnv).toBe(RILSA_DEFAULTS.enteringSpeed.oepnv);
  });

  it('begruendet die Schranke an jedem der vier Felder', () => {
    const felder = settingFields();
    for (const feld of EINFAHRFELDER) {
      const beschreibung = felder.find((f) => f.key === feld.key);
      expect(beschreibung, feld.key).toBeDefined();
      expect(beschreibung!.min, feld.key).toBe(feld.regelwert);
      expect(beschreibung!.schrankenBegruendung, feld.key).not.toBeNull();
      expect(beschreibung!.schrankenBegruendung!, feld.key).toContain('verkürzt');
    }
  });

  it('begruendet die Kappung nach oben mit der Obergrenze und nicht mit der Untergrenze', () => {
    /*
     * NACHTRAG (Fassung 5.10.0): begruendungFuer reicht eine
     * Zeichenkette an BEIDE Schranken durch. Solange die vier Begruendungen
     * Zeichenketten waren, endete die Meldung zur UEBERSCHRITTENEN Obergrenze
     * mit dem Satz zur Untergrenze - ein falscher Satz in Pruefbericht und
     * Planunterlage. Nach oben bleibt es bei der Plausibilitaetsschranke; eine
     * Sicherheitsschranke ist dort nicht noetig.
     */
    const obergrenzen: readonly (readonly [keyof RilsaOverrides, number])[] = [
      ['enteringSpeedKfz', 20],
      ['enteringSpeedRad', 8],
      ['enteringSpeedFuss', 2.5],
      ['enteringSpeedOepnv', 20],
    ];
    for (const [key, obergrenze] of obergrenzen) {
      const beschreibung = settingFields().find((f) => f.key === key);
      expect(beschreibung, key).toBeDefined();
      expect(beschreibung!.max, key).toBe(obergrenze);

      const { defaults, notes } = resolveRilsaSettings({ [key]: obergrenze + 5 });
      const meldung = notes.find((n) => n.code === `vorgabe-ueberschritten:${key}`);
      expect(meldung, key).toBeDefined();
      expect(meldung!.message, key).toContain('Der Wert wurde auf die Obergrenze begrenzt.');
      expect(meldung!.message, key).not.toContain('Untergrenze');
      expect(defaults.enteringSpeed, key).toBeDefined();
    }

    const { notes } = resolveRilsaSettings({ enteringSpeedKfz: 25 });
    expect(notes.find((n) => n.code === 'vorgabe-ueberschritten:enteringSpeedKfz')!.message).toBe(
      '"Einfahrgeschwindigkeit Kfz" wurde auf 25 m/s gesetzt, zulässig ist höchstens 20 m/s. ' +
        'Der Wert wurde auf die Obergrenze begrenzt.',
    );
  });

  it('laesst eine hoehere Einfahrgeschwindigkeit weiter zu - sie ist die sichere Richtung', () => {
    const { defaults, notes } = resolveRilsaSettings({ enteringSpeedKfz: 13 });
    expect(defaults.enteringSpeed.kfz).toBe(13);
    expect(notes.filter((n) => n.severity === 'fehler')).toHaveLength(0);
  });

  it('laesst die Warnung je Konfliktbeziehung nicht durch eine abgesenkte Vorgabe verstummen', () => {
    /*
     * Zweite Wirkung des Befundes: resolveEnteringSpeed vergleicht die
     * Handeingabe gegen defaults.enteringSpeed[mode] - also gegen den bereits
     * aufgeloesten Kennwertsatz. Wanderte die Vorgabe auf 5 m/s mit, war eine
     * Handeingabe von 5 m/s kein Unterschreiten mehr, und die Warnung blieb
     * aus. Mit der Untergrenze kann der Massstab nicht mehr mitwandern.
     */
    const { defaults } = resolveRilsaSettings({ enteringSpeedKfz: 5 });
    const ergebnis = computeIntergreen(
      kfzRaeumt(),
      kfzFaehrtEin({ enteringSpeedOverride: 5 }),
      defaults,
    );
    expect(ergebnis.notes.some((n) => n.code === 'einfahrgeschwindigkeit-unter-regelwert')).toBe(
      true,
    );
  });

  it('verkuerzt keine Zwischenzeit mehr ueber die Vorgabenverwaltung', () => {
    const mitRegelwert = computeIntergreen(kfzRaeumt(), kfzFaehrtEin(), RILSA_DEFAULTS);
    const { defaults } = resolveRilsaSettings({ enteringSpeedKfz: 5 });
    const mitVorgabe = computeIntergreen(kfzRaeumt(), kfzFaehrtEin(), defaults);
    expect(mitVorgabe.intergreen).toBe(mitRegelwert.intergreen);
  });
});