import { describe, expect, it } from 'vitest';
import { leiteAb, uebernimmWege, wegSchluessel } 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';

/**
 * Rest aus Befund 2 (Fassung 5.9.0): `uebernimmWege` sucht die Beziehung
 * ueber das Paar (fromId, toId), schreibt sie aber ueber `c.id`.
 *
 * WAS DER ANWENDER SONST ERLEBT
 *
 * Er uebernimmt die Wege eines Knotenpunkts aus dem Lageplan. Traegt eine
 * zweite Konfliktbeziehung dieselbe Kennung - eine von Hand zusammengefuegte
 * Projektdatei, ein Stand aus einer aelteren Fassung -, bekommt sie beim
 * Schreiben Raeumweg, Einfahrweg und Bemerkung der ersten mit. Sie gehoert zu
 * ganz anderen Signalgruppen, und niemand hat sie angefasst: Der Raeumweg
 * dieser zweiten Beziehung wird stillschweigend auf einen fremden Wert gesetzt,
 * und ist er kuerzer als der wahre, faellt ihre Zwischenzeit zu kurz aus - die
 * gefaehrliche Richtung.
 *
 * Die erste Behebung hat die Neuvergabe der Kennungen beim Einlesen eingebaut
 * (`schema.ts`). Das entschaerft nur Daten, die durch `parseProject` laufen -
 * im Arbeitsstand entstandene Doppelungen nicht. Geschrieben wird deshalb ueber
 * dasselbe Paar, ueber das auch gesucht wird.
 */

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_OST = 'hl-ost';

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

/** Geradeaus aus der Nordzufahrt - kreuzt die Furt bei (10 | 30). */
const GERADEAUS: Planlinie = {
  id: 'l-gerade',
  name: 'L1 geradeaus',
  mode: 'kfz',
  movement: 'geradeaus',
  breiteMeter: REGELBREITE.kfz,
  punkte: [
    { x: 10, y: 0 },
    { x: 10, y: 60 },
  ],
  haltlinieId: HL_NORD,
  startT: 0.5,
  signalGroupId: 'sg-a',
};

/** Fussgaengerfurt quer ueber die Nordzufahrt. */
const FURT: Planlinie = {
  id: 'l-furt',
  name: 'L2 Furt',
  mode: 'fuss',
  movement: 'querung',
  breiteMeter: REGELBREITE.fuss,
  punkte: [
    { x: 0, y: 30 },
    { x: 30, y: 30 },
  ],
  haltlinieId: HL_OST,
  startT: 0,
  signalGroupId: 'sg-b',
};

const LAGEPLAN: Lageplan = {
  arbeitsbereiche: [],
  signalgeber: [],
  bild: null,
  kalibrierung: KALIBRIERUNG,
  haltlinien: HALTLINIEN,
  linien: [GERADEAUS, FURT],
};

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,
});

/**
 * Zwei Beziehungen mit DERSELBEN Kennung.
 *
 * Die eine steht zwischen den Gruppen der gezeichneten Stroeme, die andere
 * zwischen zwei ganz anderen. Nur die erste wird uebernommen.
 */
const DOPPELTE_KENNUNG = 'cf-doppelt';

const konflikt = (fromId: string, toId: string, patch: Partial<Conflict> = {}): Conflict => ({
  id: DOPPELTE_KENNUNG,
  fromId,
  toId,
  clearingDistance: 99,
  enteringDistance: 88,
  clearingSpeedOverride: null,
  enteringSpeedOverride: null,
  crossingTimeOverride: null,
  manualIntergreen: null,
  wegnachweis: WEGNACHWEIS_UNBESTIMMT,
  note: '',
  ...patch,
});

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

describe('Wege aus dem Lageplan uebernehmen bei doppelter Konfliktkennung', () => {
  it('schreibt nur die Beziehung des uebernommenen Gruppenpaares', () => {
    const p = projekt();
    const ableitung = leiteAb(p, LAGEPLAN);
    const weg = ableitung.wege.find(
      (w) => w.vonLinieId === GERADEAUS.id && w.nachLinieId === FURT.id,
    );
    // Grundlage des Falls: Es gibt ueberhaupt einen Weg zu uebernehmen.
    expect(weg, 'die beiden Stroeme kreuzen sich nicht').toBeDefined();

    const ergebnis = uebernimmWege(p, LAGEPLAN, ableitung, [wegSchluessel(weg!)]);

    const geschrieben = ergebnis.project.conflicts.find(
      (c) => c.fromId === 'sg-a' && c.toId === 'sg-b',
    );
    const fremd = ergebnis.project.conflicts.find((c) => c.fromId === 'sg-c' && c.toId === 'sg-d');

    expect(ergebnis.uebernommen).toBe(1);
    expect(geschrieben?.clearingDistance, 'die gemeinte Beziehung wurde nicht geschrieben').toBe(
      weg!.raeumweg,
    );
    // Der Kern des Falls: Die zweite Beziehung teilt nur die Kennung. Sie
    // gehoert zu sg-c/sg-d, wurde nicht gewaehlt und muss unberuehrt bleiben.
    expect(fremd?.clearingDistance, 'die fremde Beziehung wurde mitgeschrieben').toBe(99);
    expect(fremd?.enteringDistance, 'die fremde Beziehung wurde mitgeschrieben').toBe(88);
    expect(fremd?.note, 'die fremde Beziehung trägt jetzt eine fremde Bemerkung').toBe('');
    expect(fremd?.wegnachweis, 'die fremde Beziehung behauptet jetzt den Lageplan').toBe(
      WEGNACHWEIS_UNBESTIMMT,
    );
  });
});