import { afterEach, describe, expect, it } from 'vitest';
import { ProjectStore } from '@/app/store';
import { createPhase, createStandardIntersectionProject } from '@/domain/model/factory';
import { RILSA_DEFAULTS, type RilsaDefaults } from '@/domain/rilsa/constants';
import { QUELLEN } from '@/domain/rilsa/quellen';
import { resolveRilsaSettings } from '@/domain/rilsa/settings';
import type { Project } from '@/domain/model/project';
import type { ViewDefinition } from '@/ui/shell';
import { buildSignalPlan } from '@/domain/plan/signalPlan';
import { gelbzeitstaffelSatz } from '@/services/export/bewertung';
import { FREIGABEFENSTER_FUSSNOTE, freigabefensterZelle } from '@/services/export/csv';
import { ASSISTENT_VORGABE, fuelleEngstellenkasten, projektAusAngaben } from '@/ui/assistent';
import { planView } from '@/ui/views/planView';
import { projectView } from '@/ui/views/projectView';
import { settingsView } from '@/ui/views/settingsView';
import { erhoehterZeitbedarfBeschriftung, signalGroupsView } from '@/ui/views/signalGroupsView';
import { simulationView } from '@/ui/views/simulationView';

/**
 * Was die Oberflaeche ueber ihre eigenen Zahlen behauptet (Befunde C20, C21,
 * D1 und D5).
 *
 * - C20: Die Vorgabenansicht schrieb "Diese Kennwerte gehen unmittelbar in
 *   jede Berechnung ein" und fuehrte darunter drei Koordinierungs-Kennwerte,
 *   die in keine Zahl eingehen.
 * - C21: Die Beschriftung des erhoehten Zeitbedarfs nannte fest "1,0 m/s statt
 *   1,2 m/s" - beide Werte sind ueber die Vorgabenverwaltung einstellbar.
 * - D1: Die Engstellen-Vorschau des Assistenten rechnete mit den Regelwerten
 *   statt mit den Kennwerten der Planung.
 * - D5: "Mittlere Wartezeit" heisst in der Simulation und im Signalzeitenplan
 *   nicht dasselbe - die Simulation wichtet mit den angekommenen Fahrzeugen,
 *   der Plan mittelt ungewichtet je Signalgruppe. Beide Zahlen stehen unter
 *   derselben Ueberschrift und weichen voneinander ab.
 *
 * Gegen den Altstand schlagen diese Faelle fehl: Dort gab es weder den
 * Wirkungsvermerk noch die Mittelungsbasis der Simulation, die Beschriftung
 * stand fest im Quelltext, und fuelleEngstellenkasten nahm keine Kennwerte
 * entgegen.
 */

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

function zeichne(
  view: ViewDefinition,
  project: Project,
): { wurzel: HTMLElement; aufraeumen: () => void } {
  const wurzel = document.createElement('div');
  document.body.append(wurzel);
  const store = new ProjectStore(project);
  const abmelden = view.render(wurzel, {
    store,
    refresh: () => {},
    navigate: () => {},
    target: null,
  });
  return {
    wurzel,
    aufraeumen: () => {
      abmelden();
      wurzel.remove();
    },
  };
}

function mitVorgaben(vorgaben: Record<string, number>): Project {
  const basis = createStandardIntersectionProject('Anzeige', FESTES_DATUM);
  return { ...basis, settings: { ...basis.settings, rilsa: vorgaben } };
}

/** Kennzahl der Kennzahlenleiste, an ihrer Beschriftung gesucht. */
function kennzahl(wurzel: HTMLElement, beschriftung: string): HTMLElement {
  const knoten = [...wurzel.querySelectorAll<HTMLElement>('.kennzahl')].find(
    (k) => k.querySelector('dt')?.textContent === beschriftung,
  );
  if (!knoten) throw new Error(`Kennzahl "${beschriftung}" fehlt`);
  return knoten;
}

/** Abschnitt der Vorgabenansicht, an seiner Ueberschrift gesucht. */
function abschnitt(wurzel: HTMLElement, ueberschrift: string): HTMLElement {
  const kopf = [...wurzel.querySelectorAll('h2, h3')].find(
    (h) => h.textContent?.trim() === ueberschrift,
  );
  if (!kopf) throw new Error(`Abschnitt "${ueberschrift}" fehlt`);
  const karte = kopf.closest('section.karte');
  if (!karte) throw new Error(`Abschnitt "${ueberschrift}" liegt auf keiner Karte`);
  return karte as HTMLElement;
}

afterEach(() => {
  document.body.replaceChildren();
});

describe('C20 - Vorgabenansicht kennzeichnet die Koordinierung als wirkungslos', () => {
  it('behauptet im Kopf nicht mehr, jeder Kennwert gehe in jede Berechnung ein', () => {
    const { wurzel, aufraeumen } = zeichne(settingsView, mitVorgaben({}));
    try {
      const kopf = wurzel.querySelector('.ansicht-kopf')!;
      expect(kopf.textContent).not.toContain('gehen unmittelbar in jede Berechnung ein');
      expect(kopf.textContent).toContain('sofern der Abschnitt nichts anderes vermerkt');
    } finally {
      aufraeumen();
    }
  });

  it('fuehrt die drei Kennwerte in einem eigenen Abschnitt mit sichtbarem Vermerk', () => {
    const { wurzel, aufraeumen } = zeichne(settingsView, mitVorgaben({}));
    try {
      const karte = abschnitt(wurzel, 'Koordinierung (wirkt in der Ansicht „Koordinierung")');
      const balken = karte.querySelector('.hinweisbalken');
      expect(balken, 'Der Vermerk steht nicht als Balken über der Tabelle').not.toBeNull();
      // Seit 5.35.0 haengt der Vermerk am Projekt: Dieses hat keinen
      // Strassenzug erfasst, also gilt er.
      expect(balken!.textContent).toContain('Ohne erfassten Straßenzug ohne Wirkung');
      expect(balken!.textContent).toContain('ein Versatz gilt zwischen Anlagen');
      expect(balken!.textContent).toContain('Erfassen Sie unter „Koordinierung"');

      // Und die Felder stehen wirklich in DIESEM Abschnitt, nicht zwischen den
      // Kennwerten der Umlaufzeit.
      const zeilen = [...karte.querySelectorAll('tbody tr')].map(
        (tr) => tr.children[0]?.textContent ?? '',
      );
      expect(zeilen).toEqual([
        'Kleinste Progressionsgeschwindigkeit',
        'Größte Progressionsgeschwindigkeit',
        'Progressionsgeschwindigkeit',
      ]);
    } finally {
      aufraeumen();
    }
  });

  it('kennzeichnet eine abweichende Progressionsgeschwindigkeit im Abweichungsbalken', () => {
    const { wurzel, aufraeumen } = zeichne(
      settingsView,
      mitVorgaben({ coordinationDefaultSpeed: 70 }),
    );
    try {
      const balken = [...wurzel.querySelectorAll('.hinweisbalken-warnung')].find((b) =>
        b.textContent?.includes('weichen vom Regelwerk ab'),
      );
      expect(balken, 'Abweichungsbalken fehlt').toBeDefined();
      // Nicht mehr pauschal "Jede Abweichung ist zu begruenden".
      expect(balken!.textContent).toContain('Jede wirksame Abweichung');
      const eintrag = [...balken!.querySelectorAll('li')].find((li) =>
        li.textContent?.startsWith('Progressionsgeschwindigkeit'),
      );
      expect(
        eintrag,
        'Die Abweichung fehlt in der Liste - sie darf nicht verschwiegen werden',
      ).toBeDefined();
      expect(eintrag!.textContent).toContain('70 km/h statt 50 km/h');
      expect(eintrag!.textContent).toContain('(ohne Wirkung: keine Koordinierung erfasst)');
    } finally {
      aufraeumen();
    }
  });

  it('haengt den Vermerk auch an die Kennwertliste im Fundstellenverzeichnis', () => {
    const { wurzel, aufraeumen } = zeichne(settingsView, mitVorgaben({}));
    try {
      const knopf = [...wurzel.querySelectorAll('button')].find(
        (b) => b.textContent?.trim() === 'Fundstellenverzeichnis',
      )!;
      knopf.click();
      const dialog = document.querySelector<HTMLElement>('[role="dialog"]')!;
      const quelle = QUELLEN['rilsa-koordinierung'];
      const karte = [...dialog.querySelectorAll('h3')]
        .find((h) => h.textContent === `${quelle.kurz} – ${quelle.sachgebiet}`)
        ?.closest('section.karte');
      expect(karte, 'Abschnitt zur Koordinierung fehlt im Verzeichnis').toBeTruthy();
      expect(karte!.textContent).toContain(
        'Progressionsgeschwindigkeit (ohne Wirkung: keine Koordinierung erfasst)',
      );
    } finally {
      aufraeumen();
    }
  });

  it('nimmt den Vermerk zurück, sobald ein Straßenzug erfasst ist', () => {
    /*
     * DIE GEGENPROBE, und sie ist die eigentliche Zusage: Ein
     * Balken, der "wirkungslos" sagt, waehrend die Zahl in Reisezeit, Versatz
     * und Bandbreite eingeht, ist genau der Fehler, den Befund C20 in der
     * Gegenrichtung geruegt hat.
     */
    const roh = mitVorgaben({ coordinationDefaultSpeed: 70 });
    const mitStrassenzug: Project = {
      ...roh,
      koordinierung: {
        progressionsgeschwindigkeit: null,
        hauptrichtung: null,
        gegenrichtung: null,
        eigenerAbstand: 0,
        platz: 0,
        nachbarn: [
          {
            id: 'knoten-west',
            name: 'Nachbaranlage',
            abstand: 300,
            freigabeBeginn: 0,
            freigabeDauer: 30,
          },
        ],
      },
    };
    const { wurzel, aufraeumen } = zeichne(settingsView, mitStrassenzug);
    try {
      const karte = abschnitt(wurzel, 'Koordinierung (wirkt in der Ansicht „Koordinierung")');
      expect(karte.querySelector('.hinweisbalken')).toBeNull();
      const balken = [...wurzel.querySelectorAll('.hinweisbalken-warnung')].find((b) =>
        b.textContent?.includes('weichen vom Regelwerk ab'),
      );
      const eintrag = [...(balken?.querySelectorAll('li') ?? [])].find((li) =>
        li.textContent?.startsWith('Progressionsgeschwindigkeit'),
      );
      expect(eintrag!.textContent).not.toContain('ohne Wirkung');
    } finally {
      aufraeumen();
    }
  });

  /*
   * Der Vermerk hing an der ZUSAMMENGEFUEGTEN Liste und las sich, als betraefe
   * er nur den letzten Wert. Der Ausdruck setzt ihn an jede Zeile; am
   * Bildschirm muss dasselbe stehen.
   */
  it('setzt den Vermerk an jeden Kennwert, nicht nur an den letzten', () => {
    const { wurzel, aufraeumen } = zeichne(settingsView, mitVorgaben({}));
    try {
      const knopf = [...wurzel.querySelectorAll('button')].find(
        (b) => b.textContent?.trim() === 'Fundstellenverzeichnis',
      )!;
      knopf.click();
      const dialog = document.querySelector<HTMLElement>('[role="dialog"]')!;
      const quelle = QUELLEN['rilsa-koordinierung'];
      const karte = [...dialog.querySelectorAll('h3')]
        .find((h) => h.textContent === `${quelle.kurz} – ${quelle.sachgebiet}`)!
        .closest('section.karte')!;
      const liste = [...karte.querySelectorAll('p')]
        .find((p) => p.textContent?.startsWith('Betroffene Kennwerte:'))!
        .textContent.replace('Betroffene Kennwerte: ', '');
      const kennwerte = liste.split(', ');
      expect(kennwerte.length, 'Die Koordinierung hat mehr als einen Kennwert').toBeGreaterThan(1);
      for (const kennwert of kennwerte) {
        expect(kennwert).toContain('(ohne Wirkung: keine Koordinierung erfasst)');
      }
    } finally {
      aufraeumen();
    }
  });
});

describe('C21 - Feldhinweise nennen den wirksamen Wert', () => {
  it('bildet die Beschriftung des erhoehten Zeitbedarfs aus den Kennwerten', () => {
    expect(erhoehterZeitbedarfBeschriftung(RILSA_DEFAULTS)).toBe(
      'Furt mit erhöhtem Zeitbedarf (1,0 m/s statt 1,2 m/s)',
    );
    const geaendert = resolveRilsaSettings(
      { clearingSpeedFussReducedMobility: 0.8, clearingSpeedFuss: 1.1 },
      undefined,
      'knotenpunkt',
    ).defaults;
    expect(erhoehterZeitbedarfBeschriftung(geaendert)).toBe(
      'Furt mit erhöhtem Zeitbedarf (0,8 m/s statt 1,1 m/s)',
    );
  });

  it('zeigt an der Furt die Vorgabe des Projekts, nicht den Regelwert', () => {
    const { wurzel, aufraeumen } = zeichne(
      signalGroupsView,
      mitVorgaben({ clearingSpeedFussReducedMobility: 0.8 }),
    );
    try {
      const kaestchen = [
        ...wurzel.querySelectorAll<HTMLInputElement>('input[type="checkbox"]'),
      ].filter((i) => i.title.startsWith('Furt mit erhöhtem Zeitbedarf'));
      expect(kaestchen.length, 'Keine Fußgängergruppe in der Tabelle').toBeGreaterThan(0);
      for (const feld of kaestchen) {
        expect(feld.title).toBe('Furt mit erhöhtem Zeitbedarf (0,8 m/s statt 1,2 m/s)');
        /*
         * Die vorgelesene BESCHREIBUNG traegt denselben Wert.
         *
         * Hier stand `expect(feld.getAttribute('aria-label')).toBe(feld.title)`.
         * Gemeint war mit C21 der wirksame Kennwert im Hinweis - festgehalten
         * hat der strenge Vergleich zusaetzlich, dass der Erklaersatz der NAME
         * des Feldes ist. Das war falsches Verhalten: In jeder Furtzeile hiess
         * das Kaestchen gleich, und keiner der Namen sagte, um welche Furt es
         * geht (Befund 18 zur Fassung 5.10.0). `aria-label` ERSETZT
         * den Namen; der Erklaersatz gehoert nach `aria-describedby`, den Namen
         * vergibt `beschrifteTabelle()` aus Spaltenkopf und Zeile. Geprueft
         * wird deshalb weiterhin der Wert - nur an der Stelle, an der er jetzt
         * steht. Dass der Name die Zeile nennt, sichert
         * tests/ui/kaestchennamen.test.ts.
         */
        const beschreibung = wurzel.querySelector(
          `[id="${feld.getAttribute('aria-describedby') ?? ''}"]`,
        );
        expect(beschreibung?.textContent).toBe(feld.title);
        expect(feld.title).not.toContain('1,0 m/s');
      }
    } finally {
      aufraeumen();
    }
  });

  /*
   * Die zweite in C21 ausdruecklich genannte Stelle: der Hinweis am vZul-Feld.
   * Er trug die Gelbstaffel als feste Zahlenreihe, obwohl yellowKfzUpTo50,
   * yellowKfzUpTo60 und yellowKfzAbove60 Vorgabenfelder sind.
   */
  it('setzt die Gelbzeitstaffel aus den Kennwerten zusammen', () => {
    expect(gelbzeitstaffelSatz(RILSA_DEFAULTS)).toBe(
      '3 s bis 50 km/h, 4 s bis 60 km/h, 5 s bis 70 km/h',
    );
    const geaendert = resolveRilsaSettings(
      { yellowKfzUpTo50: 4 },
      undefined,
      'knotenpunkt',
    ).defaults;
    expect(gelbzeitstaffelSatz(geaendert)).toBe(
      '4 s bis 50 km/h, 4 s bis 60 km/h, 5 s bis 70 km/h',
    );
  });

  it('nennt am vZul-Feld die vorgegebene Gelbzeit, nicht die Regelstaffel', () => {
    const { wurzel, aufraeumen } = zeichne(projectView, mitVorgaben({ yellowKfzUpTo50: 4 }));
    try {
      const feld = [...wurzel.querySelectorAll<HTMLElement>('div.feld')].find(
        (f) => f.querySelector('label')?.textContent === 'Zulässige Höchstgeschwindigkeit',
      );
      expect(feld, 'Feld "Zulässige Höchstgeschwindigkeit" fehlt').toBeDefined();
      const text = feld!.querySelector('.feld-hinweis')?.textContent ?? '';
      // Der Wortlaut davor lautete "Bestimmt die Gelbzeit: ...". Er schrieb dem
      // Knotenpunktwert eine Wirkung zu, die er nicht hat (Befund 23 zur
      // Fassung 5.10.0) - die Gelbzeit folgt `SignalGroup.vZul`. Was
      // dieser Prueffall begruendet, bleibt unberuehrt: Die Staffel stammt aus
      // den aufgeloesten Vorgaben, nicht aus einer festen Zahlenreihe.
      expect(text).toContain('4 s bis 50 km/h');
      // Genau die Behauptung, die der Plan mit dieser Vorgabe nicht mehr deckt.
      expect(text).not.toContain('bis 50 km/h 3 s');
    } finally {
      aufraeumen();
    }
  });
});

/*
 * C22 auf dem Bildschirm: Die Signalzeitentabelle der Ansicht
 * "Signalzeitenplan" fuehrte weiterhin "Freigabe von"/"Freigabe bis" aus
 * greens[0] neben einer Freigabezeit, die die Summe aller Fenster nannte -
 * waehrend Ausdruck und Tabellenausgabe bereits alle Fenster zeigten. Wer beide
 * nebeneinanderlegt, liest die Abweichung als Fehler in der Schaltung.
 */
describe('C22 - Signalzeitentabelle am Bildschirm nennt alle Freigabefenster', () => {
  /*
   * Vierphasiger Umlauf wie in tests/export/pdfFreigabefenster.test.ts: K1/K2 in
   * Phase 1 und 3, K3/K4 in Phase 2 und 4. Vier Phasen und nicht drei - bei
   * drei waeren Phase 1 und 3 ueber das Umlaufende benachbart, und der
   * Planaufbau fasste beide zu EINEM Fenster zusammen.
   */
  function mitZweiFenstern(): Project {
    const roh = createStandardIntersectionProject('Zwei Fenster', FESTES_DATUM);
    const id = (name: string): string => roh.signalGroups.find((g) => g.name === name)!.id;
    const nordSued = [id('K1'), id('K2'), id('F1')];
    const ostWest = [id('K3'), id('K4'), id('F2')];
    const phasen = [
      createPhase('Phase 1 - Nord/Süd', nordSued),
      createPhase('Phase 2 - Ost/West', ostWest),
      createPhase('Phase 3 - Nord/Süd', nordSued),
      createPhase('Phase 4 - Ost/West', ostWest),
    ];
    return {
      ...roh,
      phases: phasen,
      program: { ...roh.program, phaseOrder: phasen.map((p) => p.id) },
      // Vier Phasen kosten doppelt so viele Uebergaenge; mit den
      // Verkehrsstaerken der Vorlage stuenden die Freigabezeiten auf einem
      // Ersatzwert. Geprueft wird die Fensterspalte, nicht die Uebersaettigung.
      demands: roh.demands.map((d) => ({ ...d, volume: Math.round(d.volume / 2) })),
    };
  }

  it('legt der Pruefung wirklich eine Gruppe mit zwei Fenstern vor', () => {
    const plan = buildSignalPlan(mitZweiFenstern());
    expect(plan.groups.some((g) => g.greens.length > 1)).toBe(true);
  });

  it('fuehrt eine Fensterspalte und eine Summenspalte statt "von"/"bis"', () => {
    const { wurzel, aufraeumen } = zeichne(planView, mitZweiFenstern());
    try {
      const kopfzeilen = [...wurzel.querySelectorAll<HTMLElement>('th')].map(
        (th) => th.textContent,
      );
      expect(kopfzeilen).toContain('Freigabefenster (von–bis) [s]');
      expect(kopfzeilen).toContain('Freigabezeit (Summe)');
      expect(kopfzeilen).not.toContain('Freigabe von');
      expect(kopfzeilen).not.toContain('Freigabe bis');
    } finally {
      aufraeumen();
    }
  });

  it('zeigt dieselbe Zeichenkette wie Ausdruck und Tabellenausgabe', () => {
    const projekt = mitZweiFenstern();
    const plan = buildSignalPlan(projekt);
    const mehrfach = plan.groups.find((g) => g.greens.length > 1)!;
    const erwartet = freigabefensterZelle(mehrfach.greens, plan.cycleTime);
    expect(erwartet).toContain(';');

    const { wurzel, aufraeumen } = zeichne(planView, projekt);
    try {
      // Die erste Zelle der Zeile - seit Befund 46 ist sie der Zeilenkopf
      // (`th scope="row"`) und kein `td` mehr. Gesucht wird die Zeile, geprueft
      // die Fensterspalte; die Auszeichnung der ersten Zelle sichert
      // tests/ui/zeilenkopf.test.ts.
      const zeile = [...wurzel.querySelectorAll<HTMLElement>('tbody tr')].find((tr) =>
        tr.children[0]?.textContent?.includes(mehrfach.name),
      );
      expect(zeile, `Zeile zu ${mehrfach.name} fehlt`).toBeDefined();
      const zellen = [...zeile!.querySelectorAll('td')].map((td) => td.textContent);
      expect(zellen).toContain(erwartet);
    } finally {
      aufraeumen();
    }
  });

  it('stellt die Fussnote unter die Tabelle', () => {
    const { wurzel, aufraeumen } = zeichne(planView, mitZweiFenstern());
    try {
      expect(wurzel.textContent).toContain(FREIGABEFENSTER_FUSSNOTE);
    } finally {
      aufraeumen();
    }
  });
});

describe('D1 - Engstellen-Vorschau des Assistenten rechnet mit den Kennwerten der Planung', () => {
  const kasten = (laenge: number, defaults?: RilsaDefaults): HTMLElement => {
    const knoten = document.createElement('div');
    const angaben = {
      ...ASSISTENT_VORGABE,
      form: 'einstreifig' as const,
      engstellenlaenge: laenge,
    };
    // Ohne dritten Wert: derselbe Aufruf wie vor dem Befund - die Vorschau
    // muss dann die Kennwerte der neu anzulegenden Planung nehmen.
    if (defaults === undefined) fuelleEngstellenkasten(knoten, angaben);
    else fuelleEngstellenkasten(knoten, angaben, defaults);
    return knoten;
  };

  it('nennt mit dem Regelwert 40 s Zwischenzeit bei 400 m', () => {
    // Seit 5.27.0 nach RiLSA 2015, Abschnitt 5.2.2: 4 + 400/40 * 3,6 = 40 s
    // (bis 5.26.0 nach der Knotenpunktformel 3 + 406/10 = 43,6 -> 44 s).
    expect(kasten(400).textContent).toContain('Die Zwischenzeit beträgt je Fahrtrichtung 40 s');
  });

  it('aendert die Vorschau, wenn die Raeumgeschwindigkeit vorgegeben ist', () => {
    const langsam = resolveRilsaSettings(
      { clearingSpeedKfzStraight: 8 },
      undefined,
      'einstreifig',
    ).defaults;
    const text = kasten(400, langsam).textContent ?? '';
    expect(text).toContain('Die Zwischenzeit beträgt je Fahrtrichtung 54 s');
    // Umlauf 2 x 54 + 2 x 5 = 118 s, Wartezeit 2 x 54 + 5 = 113 s.
    expect(text).toContain('118 s');
    expect(text).toContain('113 s');
    expect(text).not.toContain('40 s');
  });
});

describe('D5 - Mittlere Wartezeit nennt ihre Mittelungsbasis', () => {
  function mitVerkehr(): Project {
    return projektAusAngaben(
      { ...ASSISTENT_VORGABE, fussgaenger: true, verkehrsstaerke: 400 },
      'Mittelung',
      FESTES_DATUM,
    );
  }

  it('sagt im Signalzeitenplan, dass ungewichtet je Signalgruppe gemittelt wird', () => {
    const { wurzel, aufraeumen } = zeichne(planView, mitVerkehr());
    try {
      const knoten = kennzahl(wurzel, 'Mittlere Wartezeit');
      const fussnote = knoten.querySelector('.kennzahl-fussnote')!;
      expect(fussnote.textContent).toContain('ungewichtetes Mittel je Signalgruppe');
      // Und dass die Simulation eine andere Basis hat - sonst sieht der
      // Unterschied zwischen beiden Zahlen nach einem Rechenfehler aus.
      expect(fussnote.textContent).toContain('Simulation');
      expect(fussnote.textContent).toContain('angekommenen Fahrzeugen');
    } finally {
      aufraeumen();
    }
  });

  it('sagt in der Simulation, dass mit den angekommenen Fahrzeugen gewichtet wird', () => {
    const { wurzel, aufraeumen } = zeichne(simulationView, mitVerkehr());
    try {
      const knoten = kennzahl(wurzel, 'Mittlere Wartezeit');
      const fussnote = knoten.querySelector('.kennzahl-fussnote')!;
      expect(fussnote, 'Die Kennzahl steht ohne Mittelungsbasis da').not.toBeNull();
      expect(fussnote.textContent).toContain('verkehrsstärkegewichtet');
      expect(fussnote.textContent).toContain('ungewichtet je Signalgruppe');
    } finally {
      aufraeumen();
    }
  });

  it('nennt auch in der Tabelle je Signalgruppe, worueber gemittelt wird', () => {
    const { wurzel, aufraeumen } = zeichne(simulationView, mitVerkehr());
    try {
      const kopf = [...wurzel.querySelectorAll<HTMLElement>('th')].find(
        (th) => th.textContent === 'Mittlere Wartezeit',
      );
      expect(kopf, 'Spalte fehlt').toBeDefined();
      expect(kopf!.title).toBe('Mittel über die bisher angekommenen Fahrzeuge dieser Signalgruppe');
    } finally {
      aufraeumen();
    }
  });
});