import { describe, expect, it } from 'vitest';
import * as actions from '@/app/actions';
import { ProjectStore } from '@/app/store';
import { createStandardIntersectionProject } from '@/domain/model/factory';
import { koordinierungView } from '@/ui/views/koordinierungView';
import type { Project } from '@/domain/model/project';

/**
 * Die Ansicht "Koordinierung".
 *
 * DIE HAEUFIGSTE FEHLERWARTUNG an eine solche Ansicht ist, der Versatz
 * verschiebe den eigenen Signalzeitenplan. Er tut es nicht - er gilt zwischen
 * Anlagen. Das muss auf dem Schirm stehen, nicht nur im Quelltext.
 */

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

function basis(): Project {
  return createStandardIntersectionProject('Hauptstraße / Bahnhofstraße', STICHTAG);
}

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

/**
 * Ein Zahlenfeld an seiner Beschriftung.
 *
 * ZWEI WEGE, WEIL ES ZWEI FORMEN GIBT: Ein Feld in einer Karte haengt an einem
 * `label`, eines in einer Tabellenzelle traegt seine Beschriftung als
 * `aria-label` - dort waere ein sichtbares Etikett je Zelle eine Wand aus
 * Text. Beide Formen sind fuer eine Sprachausgabe benannt, und dieser Helfer
 * findet beide.
 */
function zahlenfeld(wurzel: ParentNode, beschriftung: string): HTMLInputElement {
  const ueberEtikett = [...wurzel.querySelectorAll('label')].find((l) =>
    l.textContent?.includes(beschriftung),
  );
  const feld =
    ueberEtikett?.querySelector<HTMLInputElement>('input[type="number"]') ??
    ueberEtikett?.parentElement?.querySelector<HTMLInputElement>('input[type="number"]') ??
    [...wurzel.querySelectorAll<HTMLInputElement>('input[type="number"]')].find(
      (i) => i.getAttribute('aria-label') === beschriftung,
    );
  if (!feld) throw new Error(`Zahlenfeld "${beschriftung}" nicht gefunden.`);
  return feld;
}

function auswahl(wurzel: ParentNode, beschriftung: string): HTMLSelectElement {
  const treffer = [...wurzel.querySelectorAll('label')].find((l) =>
    l.textContent?.includes(beschriftung),
  );
  const feld = treffer?.querySelector('select') ?? treffer?.parentElement?.querySelector('select');
  if (!feld) throw new Error(`Auswahl "${beschriftung}" nicht gefunden.`);
  return feld;
}

/** Traegt einen Wert in ein Zahlenfeld ein, wie es die Bedienung tut. */
function trage(feld: HTMLInputElement, wert: string): void {
  feld.value = wert;
  feld.dispatchEvent(new Event('input', { bubbles: true }));
  feld.dispatchEvent(new Event('change', { bubbles: true }));
  feld.dispatchEvent(new FocusEvent('blur'));
}

function knopf(wurzel: ParentNode, text: string): HTMLButtonElement {
  const treffer = [...wurzel.querySelectorAll('button')].find(
    (b) => b.textContent?.trim() === text,
  );
  if (!treffer) throw new Error(`Schaltfläche "${text}" nicht gefunden.`);
  return treffer;
}

/** Ein Knotenpunkt mit einer Nachbaranlage und fester Umlaufzeit. */
function mitKette(): Project {
  const roh = basis();
  let projekt: Project = {
    ...roh,
    program: { ...roh.program, method: 'manuell', manualCycleTime: 60 },
  };
  projekt = actions.setzeKoordinierung(projekt, {
    hauptrichtung: roh.signalGroups[0]!.id,
    progressionsgeschwindigkeit: 36,
    platz: 0,
  });
  projekt = actions.koordinierungsknotenAnlegen(projekt, 'Weststraße');
  const west = projekt.koordinierung!.nachbarn[0]!;
  return actions.koordinierungsknotenAendern(projekt, west.id, {
    abstand: 200,
    freigabeBeginn: 20,
    freigabeDauer: 25,
  });
}

describe('Ansicht Koordinierung', () => {
  it('bietet ohne Straßenzug das Anlegen an', () => {
    const { wurzel, store, aufraeumen } = zeichne(basis());
    try {
      expect(wurzel.textContent).toContain('keine Koordinierung erfasst');
      knopf(wurzel, 'Koordinierung anlegen').click();
      expect(store.getProject().koordinierung).not.toBeNull();
      // Und sie beginnt leer: Ein erfundener Nachbar waere eine Behauptung
      // ueber die Oertlichkeit.
      expect(store.getProject().koordinierung?.nachbarn).toEqual([]);
    } finally {
      aufraeumen();
    }
  });

  it('sagt, dass der Versatz den eigenen Plan nicht verschiebt', () => {
    const { wurzel, aufraeumen } = zeichne(mitKette());
    try {
      expect(wurzel.textContent).toContain('verschiebt den Signalzeitenplan dieses Knotenpunkts');
      expect(wurzel.textContent).toContain('gilt zwischen den Anlagen');
    } finally {
      aufraeumen();
    }
  });

  it('zeigt Versatzzeiten, Bandbreite und das Diagramm', () => {
    const { wurzel, aufraeumen } = zeichne(mitKette());
    try {
      expect(wurzel.textContent).toContain('Empfohlener Versatz');
      expect(wurzel.textContent).toContain('Bandbreite Hinrichtung');
      expect(wurzel.querySelector('canvas.zeitweg')).not.toBeNull();
    } finally {
      aufraeumen();
    }
  });

  it('benennt die fehlende Gegenrichtung', () => {
    const { wurzel, aufraeumen } = zeichne(mitKette());
    try {
      expect(wurzel.textContent).toContain('nicht erfasst');
      expect(wurzel.textContent).toContain('keines angenommen');
    } finally {
      aufraeumen();
    }
  });

  it('trägt Abstand und Freigabezeiten der Nachbaranlage ein', () => {
    const { wurzel, store, aufraeumen } = zeichne(mitKette());
    try {
      trage(zahlenfeld(wurzel, 'Abstand zur vorigen, Weststraße'), '420');
      expect(store.getProject().koordinierung?.nachbarn[0]?.abstand).toBe(420);

      trage(zahlenfeld(wurzel, 'Gegenrichtung ab, Weststraße'), '15');
      trage(zahlenfeld(wurzel, 'Gegenrichtung Freigabezeit, Weststraße'), '20');
      const nachbar = store.getProject().koordinierung?.nachbarn[0];
      expect(nachbar?.gegenBeginn).toBe(15);
      expect(nachbar?.gegenDauer).toBe(20);
    } finally {
      aufraeumen();
    }
  });

  it('stellt Hauptrichtung, Geschwindigkeit und Platz um', () => {
    const { wurzel, store, aufraeumen } = zeichne(mitKette());
    try {
      const gegen = auswahl(wurzel, 'Signalgruppe der Gegenrichtung');
      const zweite = store.getProject().signalGroups[1]!.id;
      gegen.value = zweite;
      gegen.dispatchEvent(new Event('change'));
      expect(store.getProject().koordinierung?.gegenrichtung).toBe(zweite);

      trage(zahlenfeld(wurzel, 'Progressionsgeschwindigkeit'), '45');
      expect(store.getProject().koordinierung?.progressionsgeschwindigkeit).toBe(45);

      trage(zahlenfeld(wurzel, 'Platz dieses Knotenpunkts'), '1');
      expect(store.getProject().koordinierung?.platz).toBe(1);

      trage(zahlenfeld(wurzel, 'Abstand zur vorhergehenden Anlage'), '250');
      expect(store.getProject().koordinierung?.eigenerAbstand).toBe(250);
    } finally {
      aufraeumen();
    }
  });

  it('sagt, warum keine Grüne Welle gerechnet werden kann', () => {
    // Ohne zugeordnete Hauptrichtung gibt es kein Freigabefenster und damit
    // kein Band. Die Ansicht nennt den Grund, statt eine leere Tafel zu zeigen.
    const ohneRichtung = actions.setzeKoordinierung(mitKette(), { hauptrichtung: null });
    const { wurzel, aufraeumen } = zeichne(ohneRichtung);
    try {
      expect(wurzel.textContent).toContain('nicht festgelegt, welche Signalgruppe');
      expect(wurzel.querySelector('canvas.zeitweg')).toBeNull();
    } finally {
      aufraeumen();
    }
  });

  it('entfernt die Koordinierung erst nach Rückfrage', async () => {
    const { wurzel, store, aufraeumen } = zeichne(mitKette());
    try {
      knopf(wurzel, 'Koordinierung entfernen').click();
      const dialog = document.querySelector<HTMLElement>('[role="dialog"]');
      expect(dialog, 'Ohne Rückfrage wäre die Kette mit einem Klick fort').not.toBeNull();
      const loeschen = [...dialog!.querySelectorAll('button')].find(
        (b) => b.textContent?.trim() === 'Entfernen',
      )!;
      loeschen.click();
      await new Promise((fertig) => setTimeout(fertig, 0));
      expect(store.getProject().koordinierung).toBeNull();
    } finally {
      aufraeumen();
    }
  });

  it('legt eine Nachbaranlage an und entfernt sie wieder', () => {
    const { wurzel, store, aufraeumen } = zeichne(mitKette());
    try {
      knopf(wurzel, 'Nachbaranlage hinzufügen').click();
      expect(store.getProject().koordinierung?.nachbarn).toHaveLength(2);
      knopf(wurzel, 'Entfernen').click();
      expect(store.getProject().koordinierung?.nachbarn).toHaveLength(1);
    } finally {
      aufraeumen();
    }
  });
});