import { afterEach, describe, expect, it } from 'vitest';
import { ProjectStore } from '@/app/store';
import { validateProject } from '@/domain/validation/engine';
import { buildSignalPlan } from '@/domain/plan/signalPlan';
import { createStandardIntersectionProject } from '@/domain/model/factory';
import { conflictsView } from '@/ui/views/conflictsView';
import type { Project } from '@/domain/model/project';

/*
 * Die Legende der Zwischenzeitenansicht erklaerte die rot unterstrichene 0 s
 * fuer "nicht zulaessig". Die Pruefregel zwischenzeiten.null meldet denselben
 * Wert als WARNUNG und haelt fest, unter welcher Bedingung er zulaessig ist.
 * Zwei Ansichten desselben Programms sagten damit Gegenteiliges ueber dieselbe
 * Zahl. (Bis 5.42.1 nannte die Regel den Wert "bei langen Furten" den
 * Regelfall; seit 5.43.0 nennt sie die Bedingung - Gruppe Furt.)
 */

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

let aufraeumen: (() => void) | null = null;
afterEach(() => {
  aufraeumen?.();
  aufraeumen = null;
  document.body.replaceChildren();
});

function legendentext(project: Project): string {
  const wurzel = document.createElement('div');
  document.body.append(wurzel);
  const schliesse = conflictsView.render(wurzel, {
    store: new ProjectStore(project),
    refresh: () => {},
    navigate: () => {},
    target: null,
  });
  aufraeumen = () => {
    schliesse();
    wurzel.remove();
  };
  return wurzel.querySelector('.plan-legende')?.textContent ?? '';
}

/** Projekt, in dem jede Beziehung rechnerisch 0 s ergibt. */
function nullzwischenzeiten(): Project {
  const roh = createStandardIntersectionProject('Legende', STICHTAG);
  return {
    ...roh,
    conflicts: roh.conflicts.map((c) => ({ ...c, clearingDistance: 3, enteringDistance: 60 })),
  };
}

describe('Legende und Pruefregel sagen dasselbe ueber eine Zwischenzeit von 0 s', () => {
  it('erklaert den Wert nicht fuer unzulaessig', () => {
    const text = legendentext(createStandardIntersectionProject('Legende', STICHTAG));

    expect(text).toContain('Zwischenzeit 0 s');
    expect(text, 'die Regel nennt den Wert unter einer Bedingung zulässig').not.toContain(
      'nicht zulässig',
    );
  });

  it('die Regel dazu ist eine Warnung und sperrt den Export nicht', () => {
    const projekt = nullzwischenzeiten();
    const bericht = validateProject(projekt, buildSignalPlan(projekt), STICHTAG);

    const befunde = bericht.findings.filter((f) => f.rule === 'zwischenzeiten.null');
    expect(befunde.length, 'Der Aufbau muss die Regel auslösen').toBeGreaterThan(0);
    expect(befunde.every((f) => f.severity === 'warnung')).toBe(true);
    expect(befunde[0]!.message).toContain('zulässig');

    // Gegenprobe: Die 0 s allein darf den Export nicht sperren.
    expect(
      bericht.findings.some((f) => f.severity === 'fehler' && f.category === 'zwischenzeiten'),
    ).toBe(false);
  });
});