import { describe, expect, it } from 'vitest';
import {
  REGELBREITE,
  ueberlappung,
  vermesseWege,
  type Fahrlinie,
  type Punkt,
} from '@/domain/geometrie/vermessung';

/**
 * Gerade Fahrlinie von (0;y) bis (laengeM;y), zerlegt in Stuecke der
 * angegebenen Schrittweite. So entsteht dieselbe Geometrie wie mit zwei
 * Punkten - nur mit der Stuetzpunktdichte, die beim Nachfahren im Lageplan
 * tatsaechlich anfaellt.
 */
function geradeMitSchrittweite(
  id: string,
  y: number,
  laengeM: number,
  schritt: number,
  breite: number,
): Fahrlinie {
  const punkte: Punkt[] = [];
  const stuecke = Math.round(laengeM / schritt);
  for (let i = 0; i <= stuecke; i += 1) {
    punkte.push({ x: Math.min(i * schritt, laengeM), y });
  }
  return { id, punkte, breite };
}

describe('Ueberlagerung haengt nicht an der Zahl der gesetzten Stuetzpunkte', () => {
  // Fussgaengerfurt laengs einer Fahrlinie, Achsabstand 0,5 m. Die Korridore
  // ueberdecken sich ueber die vollen 20 m - Grenzabstand ist (3,25+4,0)/2.
  const furt: Fahrlinie = {
    id: 'furt',
    punkte: [
      { x: 0, y: 0.5 },
      { x: 20, y: 0.5 },
    ],
    breite: REGELBREITE.fuss,
  };
  const grob = geradeMitSchrittweite('kfz-grob', 0, 20, 20, REGELBREITE.kfz);
  const dicht = geradeMitSchrittweite('kfz-dicht', 0, 20, 0.8, REGELBREITE.kfz);

  it('meldet die 20 m Ueberlagerung auch, wenn die Fahrlinie im Abstand von 0,8 m nachgefahren wurde', () => {
    // Sonst erlebt der Anwender: Dieselbe Furt neben derselben Fahrlinie gilt
    // als vertraeglich, sobald er die Linie mit mehr als einem Klick je Meter
    // gezeichnet hat - es entsteht weder Konflikt noch Zwischenzeit.
    expect(ueberlappung(grob, furt)?.laenge).toBeCloseTo(20, 3);
    expect(ueberlappung(dicht, furt)?.laenge).toBeCloseTo(20, 3);
  });

  it('meldet sie auch, wenn die dicht gezeichnete Linie die zweite ist', () => {
    expect(ueberlappung(furt, dicht)?.laenge).toBeCloseTo(20, 3);
  });

  it('vermisst dieselben Wege wie bei der grob gezeichneten Linie', () => {
    const wegeGrob = vermesseWege(grob, furt);
    const wegeDicht = vermesseWege(dicht, furt);
    expect(wegeGrob).not.toBeNull();
    expect(wegeDicht).not.toBeNull();
    expect(wegeDicht?.raeumweg).toBe(wegeGrob?.raeumweg);
    expect(wegeDicht?.einfahrweg).toBe(wegeGrob?.einfahrweg);
  });

  it('haelt die Rauschschwelle ein: ein gemeinsames Stueck unter 1 m bleibt unbeachtet', () => {
    const vorne: Fahrlinie = {
      id: 'vorne',
      punkte: [
        { x: 0, y: 0 },
        { x: 20, y: 0 },
      ],
      breite: REGELBREITE.kfz,
    };
    const anschluss: Fahrlinie = {
      id: 'anschluss',
      punkte: [
        { x: 19.5, y: 0 },
        { x: 40, y: 0 },
      ],
      breite: REGELBREITE.kfz,
    };
    expect(ueberlappung(vorne, anschluss)).toBeNull();
  });
});