import { afterEach, describe, expect, it } from 'vitest';
import { ProjectStore } from '@/app/store';
import type { Haltlinie, Lageplan, Planlinie } from '@/domain/geometrie/lageplan';
import { REGELBREITE } from '@/domain/geometrie/vermessung';
import { createEmptyProject } from '@/domain/model/factory';
import {
  WEGNACHWEIS_UNBESTIMMT,
  type Conflict,
  type Project,
  type SignalGroup,
} from '@/domain/model/project';
import { lageplanView } from '@/ui/views/lageplanView';

/**
 * Folge aus Befund 1: Die Ansicht zaehlte und benannte auf
 * Strompaar-Ebene, waehrend das Aufheben auf Signalgruppenpaar-Ebene
 * entscheidet.
 *
 * WAS DER ANWENDER SONST ERLEBT
 *
 * Signalgruppe A schaltet geradeaus UND rechts aus derselben Zufahrt - der
 * Regelfall eines Signalgebers. Rechts kreuzt die Furt der Gruppe B, geradeaus
 * nicht. Das Aufheben laesst die Beziehung A/B deshalb zu Recht stehen: Zwischen
 * Stroemen einer Gruppe gibt es keine Zwischenzeit, der Rechtsabbieger verloere
 * seine Sicherung.
 *
 * Der Warnbalken zaehlte trotzdem "1 erfasste Konflikte kreuzen sich im Plan
 * nicht", der Bestaetigungstext nannte "geradeaus und Furt", und danach meldete
 * das Programm "0 Konflikt(e) aufgehoben" - ohne Grund. Der Balken blieb stehen
 * und liess sich ueber diesen Weg nie abtragen.
 *
 * Beide Seiten benutzen jetzt dieselbe Verdichtung aus `ableitung.ts`. Was
 * nicht aufhebbar ist, steht mit seinem Grund in einem eigenen Abschnitt.
 */

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

/** 1 Bildpunkt = 1 m, damit sich die Masse unmittelbar ablesen lassen. */
const KALIBRIERUNG = {
  von: { x: 0, y: 0 },
  bis: { x: 100, y: 0 },
  laengeMeter: 100,
  herkunft: 'gemessen',
} as const;

const HL_NORD = 'hl-nord';
const HL_FURT = 'hl-furt';
const HL_WEST = 'hl-west';

const HALTLINIEN: readonly Haltlinie[] = [
  {
    id: HL_NORD,
    name: 'Zufahrt Nord',
    art: 'zufahrt',
    armId: 'arm-nord',
    von: { x: 0, y: 0 },
    bis: { x: 70, y: 0 },
  },
  {
    id: HL_FURT,
    name: 'Querung Ost',
    art: 'querung',
    armId: 'arm-ost',
    von: { x: 60, y: 5 },
    bis: { x: 60, y: 30 },
  },
  {
    id: HL_WEST,
    name: 'Zufahrt West',
    art: 'zufahrt',
    armId: 'arm-west',
    von: { x: 200, y: 0 },
    bis: { x: 240, y: 0 },
  },
];

const linie = (
  id: string,
  name: string,
  punkte: readonly { x: number; y: number }[],
  patch: Partial<Planlinie> = {},
): Planlinie => ({
  id,
  name,
  mode: 'kfz',
  movement: 'geradeaus',
  breiteMeter: REGELBREITE.kfz,
  punkte,
  haltlinieId: HL_NORD,
  startT: 0.5,
  signalGroupId: null,
  ...patch,
});

/** Geradeaus aus der Nordzufahrt - kreuzt die Querung im Osten nicht. */
const GERADEAUS = linie(
  'l-gerade',
  'Nord geradeaus',
  [
    { x: 35, y: 0 },
    { x: 35, y: 40 },
  ],
  { signalGroupId: 'sg-a' },
);

/** Rechtsabbieger aus DERSELBEN Zufahrt und DERSELBEN Gruppe - kreuzt die Querung. */
const RECHTS = linie(
  'l-rechts',
  'Nord rechts',
  [
    { x: 35, y: 0 },
    { x: 38, y: 12 },
    { x: 70, y: 16 },
  ],
  { movement: 'rechts', signalGroupId: 'sg-a' },
);

/** Fussgaengerfurt ueber den Ausfahrtarm Ost. */
const FURT = linie(
  'l-furt',
  'Querung Ost',
  [
    { x: 60, y: 5 },
    { x: 60, y: 30 },
  ],
  {
    mode: 'fuss',
    movement: 'querung',
    breiteMeter: REGELBREITE.fuss,
    haltlinieId: HL_FURT,
    signalGroupId: 'sg-b',
  },
);

/**
 * Ein Strom weit ab vom Knotenpunkt, allein in seiner Gruppe.
 *
 * Er ist die Gegenprobe: Sein Gruppenpaar mit der Querung ist wirklich
 * aufhebbar, und nur er darf gezaehlt und im Bestaetigungstext genannt werden.
 */
const WEST = linie(
  'l-west',
  'West geradeaus',
  [
    { x: 220, y: 0 },
    { x: 220, y: 40 },
  ],
  { haltlinieId: HL_WEST, signalGroupId: 'sg-c' },
);

function plan(linien: readonly Planlinie[]): Lageplan {
  return {
    bild: null,
    kalibrierung: KALIBRIERUNG,
    haltlinien: HALTLINIEN,
    linien,
    arbeitsbereiche: [],
    signalgeber: [],
  };
}

const gruppe = (id: string, patch: Partial<SignalGroup> = {}): SignalGroup => ({
  id,
  name: id,
  mode: 'kfz',
  movement: 'geradeaus',
  armId: null,
  vZul: 50,
  lanes: 1,
  vehicleClass: 'pkw',
  minGreenOverride: null,
  maxGreenOverride: null,
  reducedMobility: false,
  color: '#2f6fd0',
  ...patch,
});

const konflikt = (id: string, fromId: string, toId: string): Conflict => ({
  id,
  fromId,
  toId,
  clearingDistance: 25,
  enteringDistance: 5,
  clearingSpeedOverride: null,
  enteringSpeedOverride: null,
  crossingTimeOverride: null,
  manualIntergreen: null,
  wegnachweis: WEGNACHWEIS_UNBESTIMMT,
  note: '',
});

function projekt(lageplan: Lageplan, conflicts: readonly Conflict[]): Project {
  const leer = createEmptyProject('Verdichtung', FIXED_DATE);
  return {
    ...leer,
    signalGroups: [
      gruppe('sg-a'),
      gruppe('sg-b', { mode: 'fuss', movement: 'querung', vehicleClass: 'keine' }),
      gruppe('sg-c'),
    ],
    conflicts: [...conflicts],
    lageplan,
  };
}

interface Ansicht {
  readonly store: ProjectStore;
  readonly wurzel: HTMLElement;
  readonly aufraeumen: () => void;
}

function baueAnsicht(project: Project): Ansicht {
  const store = new ProjectStore(project);
  const wurzel = document.createElement('div');
  document.body.append(wurzel);
  const schliessen = lageplanView.render(wurzel, {
    store,
    refresh: () => {},
    navigate: () => {},
    target: null,
  });

  return {
    store,
    wurzel,
    aufraeumen: () => {
      schliessen();
      wurzel.remove();
    },
  };
}

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

/** Laesst die angestossenen Zusagen der Reihe nach ablaufen. */
async function ruhe(): Promise<void> {
  for (let i = 0; i < 6; i += 1) {
    await new Promise((erfuellen) => setTimeout(erfuellen, 0));
  }
}

function knopf(ansicht: Ansicht, beschriftung: string): HTMLButtonElement | undefined {
  return [...ansicht.wurzel.querySelectorAll<HTMLButtonElement>('button')].find(
    (b) => (b.textContent ?? '').trim() === beschriftung,
  );
}

function text(ansicht: Ansicht): string {
  return ansicht.wurzel.textContent ?? '';
}

function dialogtext(): string {
  return document.querySelector('.dialog .dialog-text')?.textContent ?? '';
}

function knopfImFenster(beschriftung: string): HTMLButtonElement {
  const fenster = document.querySelector<HTMLElement>('.dialog');
  if (fenster === null) throw new Error('Es steht kein Fenster offen.');
  const treffer = [...fenster.querySelectorAll<HTMLButtonElement>('button')].find(
    (b) => (b.textContent ?? '').trim() === beschriftung,
  );
  if (treffer === undefined) throw new Error(`Kein Knopf "${beschriftung}" im Fenster`);
  return treffer;
}

function letzteWarnung(): string {
  const meldungen = [...document.querySelectorAll('.meldung-warnung')];
  return meldungen[meldungen.length - 1]?.textContent ?? '';
}

describe('Ableitung: Warnbalken und Bestätigungstext auf Signalgruppenpaar-Ebene', () => {
  it('zeigt keinen Warnbalken, wenn ein anderer Strom derselben Gruppen kreuzt', () => {
    const lageplan = plan([GERADEAUS, RECHTS, FURT]);
    const ansicht = baueAnsicht(
      projekt(lageplan, [konflikt('k-hin', 'sg-a', 'sg-b'), konflikt('k-rueck', 'sg-b', 'sg-a')]),
    );
    try {
      // Das Aufheben laesst die Beziehung stehen. Ein Balken, der ein Aufheben
      // ankuendigt, das nicht stattfindet, ist die Aufforderung zu einem
      // Bedienweg, der immer bei "0 Konflikt(e) aufgehoben" endet.
      expect(text(ansicht), 'der Warnbalken zählt noch Strompaare').not.toContain(
        'kreuzen sich im Plan nicht',
      );
      expect(knopf(ansicht, 'Konflikte prüfen und aufheben')).toBeUndefined();
    } finally {
      ansicht.aufraeumen();
    }
  });

  it('nennt den Grund, warum die verträgliche Beziehung trotzdem bestehen bleibt', () => {
    const lageplan = plan([GERADEAUS, RECHTS, FURT]);
    const ansicht = baueAnsicht(
      projekt(lageplan, [konflikt('k-hin', 'sg-a', 'sg-b'), konflikt('k-rueck', 'sg-b', 'sg-a')]),
    );
    try {
      const gelesen = text(ansicht);
      expect(gelesen).toContain('Nord geradeaus und Querung Ost');
      expect(gelesen).toContain('ein anderer Strom derselben Signalgruppen kreuzt');
    } finally {
      ansicht.aufraeumen();
    }
  });

  it('zählt und nennt nur das Gruppenpaar, das wirklich aufgehoben wird', async () => {
    const lageplan = plan([GERADEAUS, RECHTS, FURT, WEST]);
    const ansicht = baueAnsicht(
      projekt(lageplan, [
        konflikt('k-hin', 'sg-a', 'sg-b'),
        konflikt('k-rueck', 'sg-b', 'sg-a'),
        konflikt('k-west', 'sg-c', 'sg-b'),
      ]),
    );
    try {
      expect(text(ansicht)).toContain('1 erfasste Konflikte kreuzen sich im Plan nicht');

      const aufheben = knopf(ansicht, 'Konflikte prüfen und aufheben');
      expect(aufheben, 'ohne Knopf lässt sich der Balken nicht abtragen').toBeDefined();
      aufheben?.click();
      await ruhe();

      const gefragt = dialogtext();
      expect(gefragt).toContain('Querung Ost und West geradeaus');
      // Der Kern der Aenderung: Das Paar, das nicht aufgehoben wird, darf im
      // Bestaetigungstext nicht stehen - er kuendigt sonst etwas an, was nicht
      // geschieht.
      expect(gefragt, 'der Text nennt ein Paar, das bestehen bleibt').not.toContain(
        'Nord geradeaus',
      );

      knopfImFenster('Aufheben').click();
      await ruhe();

      expect(letzteWarnung()).toContain('1 Konflikt(e) aufgehoben');
      expect(
        ansicht.store
          .getProject()
          .conflicts.map((c) => c.id)
          .sort(),
      ).toEqual(['k-hin', 'k-rueck']);
      // Der Balken ist abgetragen - genau das ging ueber diesen Weg nie.
      expect(text(ansicht)).not.toContain('kreuzen sich im Plan nicht');
    } finally {
      ansicht.aufraeumen();
    }
  });
});