import { describe, expect, it } from 'vitest';
import { hebeVertraeglicheAuf, leiteAb, verbindeMitGruppe } from '@/domain/geometrie/ableitung';
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';

/**
 * Aufheben eines Konflikts, wenn eine Signalgruppe MEHRERE Stroeme fuehrt.
 *
 * Der Vorschlag steht je Strompaar, der Konflikt steht je Signalgruppenpaar.
 * Ein Signalgeber fuer geradeaus UND rechts ist der Regelfall - dann gehoeren
 * zu einem Gruppenpaar mehrere Strompaare, und es gilt das unguenstigste.
 * Wird die Beziehung schon aufgehoben, weil EIN Strompaar vertraeglich ist,
 * verliert das feindliche Strompaar derselben Gruppen seine Zwischenzeit.
 */

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_ZUFAHRT = 'hl-nord';
const HL_FURT = 'hl-ost';

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

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

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

/** Rechtsabbieger aus derselben Zufahrt - kreuzt die Furt im Osten. */
const RECHTS = linie(
  'L2 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(
  'L3 Furt',
  [
    { x: 60, y: 5 },
    { x: 60, y: 30 },
  ],
  {
    mode: 'fuss',
    movement: 'querung',
    breiteMeter: REGELBREITE.fuss,
    haltlinieId: HL_FURT,
    signalGroupId: 'sg-b',
  },
);

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('Aufheben', FIXED_DATE);
  return {
    ...leer,
    signalGroups: [
      gruppe('sg-a'),
      gruppe('sg-b', { mode: 'fuss', movement: 'querung', vehicleClass: 'keine' }),
    ],
    conflicts: [...conflicts],
    lageplan,
  };
}

/** Sucht den Vorschlag zu einem Linienpaar, unabhaengig von der Reihenfolge. */
function paar(
  vorschlaege: ReturnType<typeof leiteAb>['vertraeglichkeit'],
  a: string,
  b: string,
): (typeof vorschlaege)[number] {
  const treffer = vorschlaege.find(
    (v) => (v.aName === a && v.bName === b) || (v.aName === b && v.bName === a),
  );
  if (treffer === undefined) throw new Error(`Kein Vorschlag fuer "${a}" und "${b}"`);
  return treffer;
}

describe('Konflikte aufheben bei einer Signalgruppe mit mehreren Stroemen', () => {
  it('laesst die Zuordnung von geradeaus und rechts auf einen Signalgeber zu', () => {
    // Grundlage des Falls: Die Buendelung ist zulaessig, sonst waere er nicht
    // erreichbar.
    const lageplan = plan([{ ...GERADEAUS, signalGroupId: null }, RECHTS, FURT]);
    const p = projekt(lageplan, []);

    const ergebnis = verbindeMitGruppe(p, lageplan, GERADEAUS.id, 'sg-a');

    expect(ergebnis.hinweis).toBeNull();
    expect(ergebnis.lageplan.linien.find((l) => l.id === GERADEAUS.id)?.signalGroupId).toBe('sg-a');
  });

  it('stellt genau ein vertraegliches und ein feindliches Strompaar derselben Gruppen fest', () => {
    const lageplan = plan([GERADEAUS, RECHTS, FURT]);
    const p = projekt(lageplan, [konflikt('k-hin', 'sg-a', 'sg-b')]);

    const ableitung = leiteAb(p, lageplan);

    expect(paar(ableitung.vertraeglichkeit, GERADEAUS.name, FURT.name).feindlich).toBe(false);
    expect(paar(ableitung.vertraeglichkeit, GERADEAUS.name, FURT.name).imProjekt).toBe(true);
    expect(paar(ableitung.vertraeglichkeit, RECHTS.name, FURT.name).feindlich).toBe(true);
  });

  it('haelt den Konflikt, solange ein Strompaar derselben Gruppen feindlich bleibt', () => {
    // Ohne die Verdichtung auf Gruppenpaare reisst das vertraegliche Paar
    // "geradeaus und Furt" die Beziehung SG-A/SG-B mit. Der Rechtsabbieger und
    // die Furt bekaemen danach gleichzeitig Freigabe, ohne Zwischenzeit.
    const lageplan = plan([GERADEAUS, RECHTS, FURT]);
    const p = projekt(lageplan, [
      konflikt('k-hin', 'sg-a', 'sg-b'),
      konflikt('k-rueck', 'sg-b', 'sg-a'),
    ]);
    const ableitung = leiteAb(p, lageplan);

    const ergebnis = hebeVertraeglicheAuf(p, lageplan, ableitung);

    expect(ergebnis.aufgehoben).toBe(0);
    expect(ergebnis.project.conflicts.map((c) => c.id).sort()).toEqual(['k-hin', 'k-rueck']);
  });

  it('haelt den Konflikt, solange ein Strom der Gruppen nicht fertig gezeichnet ist', () => {
    // Der Rechtsabbieger hat nur einen Punkt. leiteAb nimmt ihn von der
    // Auswertung aus ("linie-unfertig"), also steht kein Strompaar
    // "rechts/Furt" in den Vorschlaegen. Wuerde allein danach entschieden,
    // saehe das Gruppenpaar vertraeglich aus, und der Anwender verloere die
    // Zwischenzeit zwischen Rechtsabbieger und Furt fuer einen Strom, den
    // niemand geprueft hat.
    const lageplan = plan([GERADEAUS, { ...RECHTS, punkte: [{ x: 35, y: 0 }] }, FURT]);
    const p = projekt(lageplan, [
      konflikt('k-hin', 'sg-a', 'sg-b'),
      konflikt('k-rueck', 'sg-b', 'sg-a'),
    ]);
    const ableitung = leiteAb(p, lageplan);

    // Grundlage: Das feindliche Strompaar fehlt in den Vorschlaegen wirklich.
    expect(
      ableitung.vertraeglichkeit.some(
        (v) =>
          (v.aName === RECHTS.name && v.bName === FURT.name) ||
          (v.aName === FURT.name && v.bName === RECHTS.name),
      ),
    ).toBe(false);
    expect(ableitung.hinweise.some((h) => h.code === 'linie-unfertig')).toBe(true);

    const ergebnis = hebeVertraeglicheAuf(p, lageplan, ableitung);

    expect(ergebnis.aufgehoben).toBe(0);
    expect(ergebnis.project.conflicts.map((c) => c.id).sort()).toEqual(['k-hin', 'k-rueck']);
  });

  it('hebt einen Konflikt auf, den eine unfertige Linie anderer Gruppen nicht beruehrt', () => {
    // Gegenprobe gegen die Ueberkorrektur: Die unfertige Linie gehoert zu
    // SG-C. Das Gruppenpaar SG-A/SG-B ist davon unberuehrt und muss weiter
    // aufhebbar bleiben.
    const unfertig = linie('L4 unfertig', [{ x: 10, y: 0 }], { signalGroupId: 'sg-c' });
    const lageplan = plan([GERADEAUS, FURT, unfertig]);
    const leer = projekt(lageplan, [
      konflikt('k-hin', 'sg-a', 'sg-b'),
      konflikt('k-rueck', 'sg-b', 'sg-a'),
    ]);
    const p: Project = { ...leer, signalGroups: [...leer.signalGroups, gruppe('sg-c')] };
    const ableitung = leiteAb(p, lageplan);

    const ergebnis = hebeVertraeglicheAuf(p, lageplan, ableitung);

    expect(ergebnis.aufgehoben).toBe(1);
    expect(ergebnis.project.conflicts).toHaveLength(0);
  });

  it('hebt den Konflikt auf, sobald ALLE Strompaare der Gruppen vertraeglich sind', () => {
    // Gegenprobe: Ohne den Rechtsabbieger bleibt nur das vertraegliche
    // Strompaar - dann ist das Aufheben richtig und muss weiter geschehen.
    const lageplan = plan([GERADEAUS, FURT]);
    const p = projekt(lageplan, [
      konflikt('k-hin', 'sg-a', 'sg-b'),
      konflikt('k-rueck', 'sg-b', 'sg-a'),
    ]);
    const ableitung = leiteAb(p, lageplan);

    const ergebnis = hebeVertraeglicheAuf(p, lageplan, ableitung);

    expect(ergebnis.aufgehoben).toBe(1);
    expect(ergebnis.project.conflicts).toHaveLength(0);
  });
});