import { describe, expect, it } from 'vitest';
import {
  REGELBREITE,
  konfliktbereich,
  kreuzenSich,
  laenge,
  linieInMeter,
  massstabAusStrecke,
  schneide,
  vermesseWege,
  type Fahrlinie,
} from '@/domain/geometrie/vermessung';
import { computeIntergreen } from '@/domain/rilsa/intergreen';

/** Waagerechte Fahrlinie nach Osten, Haltlinie bei x = start. */
function waagerecht(
  id: string,
  startX: number,
  y: number,
  laengeM: number,
  breite: number,
): Fahrlinie {
  return {
    id,
    punkte: [
      { x: startX, y },
      { x: startX + laengeM, y },
    ],
    breite,
  };
}

/** Senkrechte Fahrlinie nach Norden, Haltlinie bei y = start. */
function senkrecht(
  id: string,
  x: number,
  startY: number,
  laengeM: number,
  breite: number,
): Fahrlinie {
  return {
    id,
    punkte: [
      { x, y: startY },
      { x, y: startY + laengeM },
    ],
    breite,
  };
}

describe('Vermessung aus der Zeichnung', () => {
  it('misst die Laenge eines Linienzugs', () => {
    const linie: Fahrlinie = {
      id: 'a',
      punkte: [
        { x: 0, y: 0 },
        { x: 3, y: 4 },
        { x: 3, y: 14 },
      ],
      breite: 3.25,
    };
    expect(laenge(linie)).toBeCloseTo(15, 6);
  });

  it('findet den Schnittpunkt zweier kreuzender Fahrlinien', () => {
    // A laeuft von (0,0) nach Osten, B von (20,-10) nach Norden.
    const a = waagerecht('a', 0, 0, 40, REGELBREITE.kfz);
    const b = senkrecht('b', 20, -10, 40, REGELBREITE.kfz);

    const schnitte = schneide(a, b);
    expect(schnitte).toHaveLength(1);
    expect(schnitte[0]!.punkt.x).toBeCloseTo(20, 6);
    expect(schnitte[0]!.punkt.y).toBeCloseTo(0, 6);
    expect(schnitte[0]!.abstandA).toBeCloseTo(20, 6);
    expect(schnitte[0]!.abstandB).toBeCloseTo(10, 6);
    // Rechter Winkel.
    expect((schnitte[0]!.winkel * 180) / Math.PI).toBeCloseTo(90, 6);
  });

  it('erkennt parallele Stroeme als vertraeglich', () => {
    const a = waagerecht('a', 0, 0, 40, REGELBREITE.kfz);
    const b = waagerecht('b', 0, 4, 40, REGELBREITE.kfz);
    expect(kreuzenSich(a, b)).toBe(false);
    expect(vermesseWege(a, b)).toBeNull();
  });

  it('leitet Raeum- und Einfahrweg aus der Geometrie ab', () => {
    const a = waagerecht('a', 0, 0, 40, REGELBREITE.kfz);
    const b = senkrecht('b', 20, -10, 40, REGELBREITE.kfz);

    const wege = vermesseWege(a, b)!;
    expect(wege).not.toBeNull();

    // Rechtwinkliger Schnitt: Der Konfliktbereich reicht um die halbe Breite
    // des jeweils anderen Stroms ueber den Schnittpunkt hinaus.
    // Raeumweg  = 20 m + 3,25/2 = 21,625 -> 21,63
    // Einfahrweg = 10 m − 3,25/2 =  8,375 ->  8,38
    expect(wege.raeumweg).toBeCloseTo(21.63, 2);
    expect(wege.einfahrweg).toBeCloseTo(8.38, 2);
    expect(wege.winkelGrad).toBeCloseTo(90, 1);
  });

  it('verlaengert den Konfliktbereich bei schraegem Schnitt', () => {
    // B kreuzt unter 45 Grad: Der Strom ist laenger im Konfliktbereich,
    // der Raeumweg wird entsprechend groesser.
    const a = waagerecht('a', 0, 0, 40, REGELBREITE.kfz);
    const schraeg: Fahrlinie = {
      id: 'b',
      punkte: [
        { x: 10, y: -10 },
        { x: 30, y: 10 },
      ],
      breite: REGELBREITE.kfz,
    };

    const rechtwinklig = vermesseWege(a, senkrecht('b', 20, -10, 40, REGELBREITE.kfz))!;
    const unter45 = vermesseWege(a, schraeg)!;

    expect(unter45.winkelGrad).toBeCloseTo(45, 1);
    // 1 / sin(45 Grad) = 1,414
    const erwartet = 20 + REGELBREITE.kfz / 2 / Math.sin(Math.PI / 4);
    expect(unter45.raeumweg).toBeCloseTo(erwartet, 2);
    expect(unter45.raeumweg).toBeGreaterThan(rechtwinklig.raeumweg);
  });

  it('beruecksichtigt die Breite der Fussgaengerfurt', () => {
    const kfz = waagerecht('k', 0, 0, 40, REGELBREITE.kfz);
    const furt = senkrecht('f', 20, -10, 20, REGELBREITE.fuss);

    const wege = vermesseWege(kfz, furt)!;
    // Die Furt ist 4 m breit: Das Kfz durchfaehrt sie ueber 4 m.
    expect(wege.raeumweg).toBeCloseTo(20 + REGELBREITE.fuss / 2, 2);
    // Der Fussgaenger erreicht den Kfz-Korridor nach 10 − 3,25/2 = 8,375 m.
    // Ausgegeben wird auf Zentimeter gerundet - feiner laesst sich ein
    // Lageplan ohnehin nicht abgreifen.
    expect(wege.einfahrweg).toBe(8.38);
  });

  it('bildet bei mehrfacher Kreuzung die Huellkurve', () => {
    // Ein Abbieger, der dieselbe Furt zweimal schneidet.
    const zickzack: Fahrlinie = {
      id: 'a',
      punkte: [
        { x: 0, y: -5 },
        { x: 20, y: 5 },
        { x: 40, y: -5 },
      ],
      breite: REGELBREITE.kfz,
    };
    const furt = waagerecht('f', -10, 0, 60, REGELBREITE.fuss);

    const bereich = konfliktbereich(zickzack, furt)!;
    expect(bereich.schnitte).toBe(2);
    // Der Bereich reicht vom ersten Eintritt bis zum letzten Austritt.
    expect(bereich.bisA - bereich.vonA).toBeGreaterThan(20);
  });

  it('gibt fuer die Gegenrichtung andere Wege aus', () => {
    // Konflikte sind gerichtet - das muss sich in den Wegen niederschlagen.
    const a = waagerecht('a', 0, 0, 40, REGELBREITE.kfz);
    const b = senkrecht('b', 25, -8, 40, REGELBREITE.kfz);

    const hin = vermesseWege(a, b)!;
    const zurueck = vermesseWege(b, a)!;

    expect(hin.raeumweg).not.toBeCloseTo(zurueck.raeumweg, 1);
    // 25 + 1,625 = 26,625 bzw. 8 + 1,625 = 9,625, jeweils auf Zentimeter gerundet.
    expect(hin.raeumweg).toBe(26.63);
    expect(zurueck.raeumweg).toBe(9.63);
  });

  it('faengt entartete Linien ab', () => {
    const punkt: Fahrlinie = { id: 'p', punkte: [{ x: 0, y: 0 }], breite: 3 };
    const ohneBreite: Fahrlinie = { ...waagerecht('a', 0, 0, 10, 3), breite: 0 };
    const gut = senkrecht('b', 5, -5, 10, 3);

    expect(vermesseWege(punkt, gut)).toBeNull();
    expect(vermesseWege(ohneBreite, gut)).toBeNull();
    expect(kreuzenSich(punkt, gut)).toBe(false);
  });
});

describe('Massstab aus einer bekannten Strecke', () => {
  it('rechnet Bildpunkte in Meter um', () => {
    // Im Bild sind 200 Bildpunkte eine 50 m lange Strecke.
    const massstab = massstabAusStrecke({ x: 100, y: 100 }, { x: 300, y: 100 }, 50)!;
    expect(massstab.meterJeBildpunkt).toBeCloseTo(0.25, 6);

    const linie: Fahrlinie = {
      id: 'a',
      punkte: [
        { x: 0, y: 0 },
        { x: 80, y: 0 },
      ],
      breite: 13,
    };
    expect(laenge(linieInMeter(linie, massstab))).toBeCloseTo(20, 6);
  });

  it('weist unbrauchbare Kalibrierungen ab', () => {
    expect(massstabAusStrecke({ x: 0, y: 0 }, { x: 0, y: 0 }, 10)).toBeNull();
    expect(massstabAusStrecke({ x: 0, y: 0 }, { x: 100, y: 0 }, 0)).toBeNull();
    expect(massstabAusStrecke({ x: 0, y: 0 }, { x: 100, y: 0 }, Number.NaN)).toBeNull();
  });
});

describe('Zusammenspiel mit der Zwischenzeitberechnung', () => {
  it('liefert Wege, aus denen sich unmittelbar die Zwischenzeit ergibt', () => {
    const kfz = waagerecht('k', 0, 0, 40, REGELBREITE.kfz);
    const quer = senkrecht('q', 22, -9, 40, REGELBREITE.kfz);
    const wege = vermesseWege(kfz, quer)!;

    const ergebnis = computeIntergreen(
      {
        mode: 'kfz',
        movement: 'geradeaus',
        clearingDistance: wege.raeumweg,
        vehicleClass: 'pkw',
        vZul: 50,
      },
      { mode: 'kfz', movement: 'geradeaus', enteringDistance: wege.einfahrweg },
    );

    // sr = 23,63 + 6 m Fahrzeuglaenge = 29,63 m; vr = 10 m/s -> tr = 2,963 s
    // se = 7,38 m; ve = 11,1 m/s -> te = 0,664 s
    // tz = 3 + 2,963 − 0,664 = 5,299 -> 6 s
    expect(wege.raeumweg).toBeCloseTo(23.63, 2);
    expect(wege.einfahrweg).toBeCloseTo(7.38, 2);
    expect(ergebnis.clearingPath).toBeCloseTo(29.63, 2);
    expect(ergebnis.intergreen).toBe(6);
  });

  it('erkennt genau die Paare als feindlich, die sich kreuzen', () => {
    // Zwei parallele Nord-Sued-Stroeme und ein kreuzender Ost-West-Strom.
    const nord = senkrecht('n', 10, -20, 40, REGELBREITE.kfz);
    const sued = senkrecht('s', 14, -20, 40, REGELBREITE.kfz);
    const ost = waagerecht('o', -20, 0, 60, REGELBREITE.kfz);

    expect(kreuzenSich(nord, sued)).toBe(false);
    expect(kreuzenSich(nord, ost)).toBe(true);
    expect(kreuzenSich(sued, ost)).toBe(true);
  });
});