import { describe, expect, it } from "vitest";
import { footprint, type Vec2 } from "@fp/shared/rules";
import {
  aussenPolygon,
  clearanceRect,
  computeTransform,
  distanz,
  footprintPoints,
  innwardNormal,
  naechsteEcke,
  rasten,
  toScreen,
  toWorld,
  wallQuad,
  wandBaender,
  wandEcken,
  wandLuecken,
  yawAusZeiger,
} from "./plan2d.ts";

const RAUM: Vec2[] = [
  [0, 0],
  [3, 0],
  [3, 2.4],
  [0, 2.4],
];

describe("computeTransform / toScreen", () => {
  it("füllt die längere Achse randbündig und hält gleichen Massstab", () => {
    const t = computeTransform(RAUM, 1000, 40);
    expect(t.scale).toBeCloseTo(920 / 3, 6); // 3 m ist die längere Achse
    // x-Spanne nutzt die volle Innenbreite [40, 960]
    expect(toScreen([0, 0], t)[0]).toBeCloseTo(40, 6);
    expect(toScreen([3, 0], t)[0]).toBeCloseTo(960, 6);
    // alle Ecken liegen im Rahmen
    for (const ecke of RAUM) {
      const [sx, sy] = toScreen(ecke, t);
      expect(sx).toBeGreaterThanOrEqual(40 - 1e-6);
      expect(sx).toBeLessThanOrEqual(960 + 1e-6);
      expect(sy).toBeGreaterThanOrEqual(40 - 1e-6);
      expect(sy).toBeLessThanOrEqual(960 + 1e-6);
    }
  });

  it("ist linear (gleicher Massstab in x und z)", () => {
    const t = computeTransform(RAUM, 1000, 40);
    const o = toScreen([0, 0], t);
    const p = toScreen([1, 1], t);
    expect(p[0] - o[0]).toBeCloseTo(t.scale, 6);
    expect(p[1] - o[1]).toBeCloseTo(t.scale, 6);
  });

  it("toWorld ist die exakte Umkehrung von toScreen", () => {
    const t = computeTransform(RAUM, 1000, 40);
    for (const welt of [
      [0, 0],
      [1.5, 1.2],
      [3, 2.4],
    ] as Vec2[]) {
      const zurueck = toWorld(toScreen(welt, t), t);
      expect(zurueck[0]).toBeCloseTo(welt[0], 9);
      expect(zurueck[1]).toBeCloseTo(welt[1], 9);
    }
  });
});

describe("footprintPoints", () => {
  it("achsparalleles Objekt (yaw 0) → achsparalleles Rechteck der Breite w·scale", () => {
    const t = computeTransform(RAUM, 1000, 40);
    const pts: [number, number][] = footprintPoints([1, 1], 0.4, 0.6, 0, t)
      .split(" ")
      .map((s) => {
        const teile = s.split(",");
        return [Number(teile[0]), Number(teile[1])];
      });
    expect(pts).toHaveLength(4);
    const [a, b, c] = pts as [[number, number], [number, number], [number, number]];
    // Ecken 0/1 teilen eine y-Kante, 1/2 eine x-Kante (achsparallel)
    expect(a[1]).toBeCloseTo(b[1], 6);
    expect(b[0]).toBeCloseTo(c[0], 6);
    expect(Math.abs(b[0] - a[0])).toBeCloseTo(0.4 * t.scale, 1);
    expect(Math.abs(c[1] - b[1])).toBeCloseTo(0.6 * t.scale, 1);
  });

  it("nutzt exakt die footprint()-Konvention von @fp/shared/rules", () => {
    const t = computeTransform(RAUM, 1000, 40);
    const erwartet = footprint([1.5, 1.2], 0.5, 0.3, 90)
      .map((e) =>
        toScreen(e, t)
          .map((n) => Math.round(n * 100) / 100)
          .join(","),
      )
      .join(" ");
    expect(footprintPoints([1.5, 1.2], 0.5, 0.3, 90, t)).toBe(erwartet);
  });
});

describe("innwardNormal", () => {
  it("zeigt von einer Wand ins Rauminnere", () => {
    // untere Wand [0,0]→[3,0]: Innenseite ist +z
    expect(innwardNormal([0, 0], [3, 0], RAUM)).toEqual([0, 1]);
    // obere Wand [3,2.4]→[0,2.4]: Innenseite ist −z
    expect(innwardNormal([3, 2.4], [0, 2.4], RAUM)).toEqual([0, -1]);
  });
});

describe("wallQuad", () => {
  it("erzeugt ein Rechteck der Länge×Dicke, mittig auf der Wandachse", () => {
    const q = wallQuad([0, 0], [3, 0], 0.1);
    expect(q).toHaveLength(4);
    // Dicke 0.1 → je 0.05 nach ±z
    expect(q).toEqual([
      [0, 0.05],
      [3, 0.05],
      [3, -0.05],
      [0, -0.05],
    ]);
  });

  it("steht senkrecht auf einer vertikalen Wand", () => {
    const q = wallQuad([0, 0], [0, 2], 0.2);
    // Wand entlang +z → Dicke entlang x (±0.1)
    for (const p of q) expect(Math.abs(p[0])).toBeCloseTo(0.1, 9);
  });
});

describe("aussenPolygon (CAD-Wände: Polygon = Innenkante, Stärke nach aussen)", () => {
  it("versetzt jede Ecke gehrungsgenau nach aussen (Rechteck)", () => {
    const outer = aussenPolygon(RAUM, 0.12);
    expect(outer).toHaveLength(4);
    // 3.0×2.4-Raum plus 0.12 rundum → [-0.12,-0.12] … [3.12,2.52]
    const erwartet: Vec2[] = [
      [-0.12, -0.12],
      [3.12, -0.12],
      [3.12, 2.52],
      [-0.12, 2.52],
    ];
    outer.forEach((p, i) => {
      const e = erwartet[i] as Vec2;
      expect(p[0]).toBeCloseTo(e[0], 9);
      expect(p[1]).toBeCloseTo(e[1], 9);
    });
  });

  it("Aussen-Bbox = Polygon + 2×thickness in beiden Dimensionen (Rechteck)", () => {
    const th = 0.12;
    const outer = aussenPolygon(RAUM, th);
    const xs = outer.map((p) => p[0]);
    const zs = outer.map((p) => p[1]);
    // Raum 3.0×2.4 → aussen 3.24×2.64
    expect(Math.max(...xs) - Math.min(...xs)).toBeCloseTo(3 + 2 * th, 9);
    expect(Math.max(...zs) - Math.min(...zs)).toBeCloseTo(2.4 + 2 * th, 9);
  });

  it("das Aussenpolygon liegt vollständig ausserhalb der Kontur (jede Ecke weiter von der Mitte)", () => {
    const outer = aussenPolygon(RAUM, 0.2);
    const mitte: Vec2 = [1.5, 1.2];
    outer.forEach((p, i) => {
      const a = RAUM[i] as Vec2;
      const dAussen = Math.hypot(p[0] - mitte[0], p[1] - mitte[1]);
      const dPoly = Math.hypot(a[0] - mitte[0], a[1] - mitte[1]);
      expect(dAussen).toBeGreaterThan(dPoly);
    });
  });

  it("L-Form: eine einspringende (konkave) Ecke wird ebenfalls sauber versetzt (kein NaN)", () => {
    const L: Vec2[] = [
      [0, 0],
      [3, 0],
      [3, 1.5],
      [1.5, 1.5],
      [1.5, 3],
      [0, 3],
    ];
    const outer = aussenPolygon(L, 0.1);
    expect(outer).toHaveLength(6);
    for (const p of outer) {
      expect(Number.isFinite(p[0])).toBe(true);
      expect(Number.isFinite(p[1])).toBe(true);
    }
  });
});

describe("wandBaender (Wand-Band mit Innenkante auf der Polygon-Linie)", () => {
  const outer = aussenPolygon(RAUM, 0.12);
  const eck = new Map(RAUM.map((p, i) => [`${p[0]},${p[1]}`, outer[i]]));

  it("volle Wand: ein Band, Innenkante exakt auf der Wandachse (= Polygon-Linie)", () => {
    // untere Wand [0,0]→[3,0]; innen = +z ⇒ aussen = −z = [0,-1]
    const baender = wandBaender([0, 0], [3, 0], [0, -1], 0.12, [], eck.get("0,0"), eck.get("3,0"));
    expect(baender).toHaveLength(1);
    // Reihenfolge [innenA, innenB, aussenB, aussenA]
    const [iA, iB, aB, aA] = baender[0] as [Vec2, Vec2, Vec2, Vec2];
    expect(iA).toEqual([0, 0]); // Innenkante auf der Polygon-Linie z=0
    expect(iB).toEqual([3, 0]);
    // Aussenkante = Gehrungs-Ecken (nach aussen versetzt)
    expect(aB[1]).toBeCloseTo(-0.12, 9);
    expect(aA[1]).toBeCloseTo(-0.12, 9);
    // Ecken teilen sich die Aussenpunkte mit dem Aussenpolygon
    expect(aA).toEqual(outer[0]);
    expect(aB).toEqual(outer[1]);
  });

  it("mit Öffnung: zwei Bänder, Laibung senkrecht auf die Aussenkante versetzt", () => {
    const baender = wandBaender(
      [0, 0],
      [3, 0],
      [0, -1],
      0.12,
      [{ offset: 1, width: 0.8 }],
      eck.get("0,0"),
      eck.get("3,0"),
    );
    expect(baender).toHaveLength(2);
    const b0 = baender[0] as [Vec2, Vec2, Vec2, Vec2];
    const b1 = baender[1] as [Vec2, Vec2, Vec2, Vec2];
    // erstes Band bis zur Laibung x=1; [innenA, innenB, aussenB, aussenA]
    expect(b0[1]).toEqual([1, 0]); // Innenkante an der Laibung (auf der Linie)
    expect(b0[2]).toEqual([1, -0.12]); // Aussenkante = reiner Normalversatz
    // zweites Band ab x=1.8
    expect(b1[0]).toEqual([1.8, 0]);
    expect(b1[3]).toEqual([1.8, -0.12]);
  });

  it("benachbarte Wände teilen sich exakt denselben Aussen-Eckpunkt (keine Lücke)", () => {
    const unten = wandBaender([0, 0], [3, 0], [0, -1], 0.12, [], eck.get("0,0"), eck.get("3,0"));
    const rechts = wandBaender(
      [3, 0],
      [3, 2.4],
      [1, 0],
      0.12,
      [],
      eck.get("3,0"),
      eck.get("3,2.4"),
    );
    // Aussenpunkt der unteren Wand am Eck [3,0] == Aussenpunkt der rechten Wand dort
    const u0 = unten[0] as [Vec2, Vec2, Vec2, Vec2];
    const r0 = rechts[0] as [Vec2, Vec2, Vec2, Vec2];
    expect(u0[2]).toEqual(r0[3]); // aussenB (unten) == aussenA (rechts)
  });
});

describe("distanz / wandEcken / naechsteEcke", () => {
  it("misst euklidische Distanz in Metern", () => {
    expect(distanz([0, 0], [3, 4])).toBeCloseTo(5, 9);
  });

  it("sammelt alle Wand-Endpunkte", () => {
    const ecken = wandEcken([
      { start: [0, 0], end: [3, 0] },
      { start: [3, 0], end: [3, 2] },
    ]);
    expect(ecken).toHaveLength(4);
    expect(ecken).toContainEqual([3, 0]);
  });

  it("snappt einen nahen Punkt auf die Ecke, einen fernen nicht", () => {
    const ecken: Vec2[] = [
      [0, 0],
      [3, 0],
    ];
    expect(naechsteEcke([0.1, 0.05], ecken, 0.15)).toEqual([0, 0]); // < 15 cm → snap
    expect(naechsteEcke([1.5, 1], ecken, 0.15)).toEqual([1.5, 1]); // zu weit → unverändert
  });
});

describe("yawAusZeiger", () => {
  it("front lokal +z: Zeiger nach +z ⇒ 0°, nach +x ⇒ 90°", () => {
    const c: Vec2 = [1, 1];
    expect(yawAusZeiger(c, [1, 2], 15)).toBe(0); // +z
    expect(yawAusZeiger(c, [2, 1], 15)).toBe(90); // +x
    expect(yawAusZeiger(c, [1, 0], 15)).toBe(180); // −z
    expect(yawAusZeiger(c, [0, 1], 15)).toBe(270); // −x
  });

  it("rastet auf 15°-Schritte und normalisiert auf [0,360)", () => {
    const y = yawAusZeiger(
      [0, 0],
      [Math.sin((100 * Math.PI) / 180), Math.cos((100 * Math.PI) / 180)],
      15,
    );
    expect(y % 15).toBe(0);
    expect(y).toBeGreaterThanOrEqual(0);
    expect(y).toBeLessThan(360);
  });
});

describe("rasten", () => {
  it("rundet auf 5-cm-Raster (Default)", () => {
    expect(rasten(1.23)).toBeCloseTo(1.25, 9);
    expect(rasten(1.21)).toBeCloseTo(1.2, 9);
  });
});

describe("clearanceRect", () => {
  it("yaw 0: Rechteck vor der Objekt-Front (+z), richtige Breite/Tiefe", () => {
    // Objekt bei [1,1], Tiefe d=0.6 → Front bei z=1.3; Zone 0.6 breit × 0.6 tief.
    const [c1, c2, c3, c4] = clearanceRect([1, 1], 0.6, 0, 0.6, 0.6);
    expect(c1).toEqual([0.7, 1.3]); // linke vordere Kante an der Front
    expect(c2).toEqual([1.3, 1.3]); // rechte vordere Kante an der Front
    expect(c3).toEqual([1.3, 1.9]); // rechte ferne Kante (0.6 m tief nach +z)
    expect(c4).toEqual([0.7, 1.9]);
    const xs = [c1, c2, c3, c4].map((p) => p[0]);
    const zs = [c1, c2, c3, c4].map((p) => p[1]);
    expect(Math.max(...xs) - Math.min(...xs)).toBeCloseTo(0.6, 9); // Breite
    expect(Math.max(...zs) - Math.min(...zs)).toBeCloseTo(0.6, 9); // Tiefe
    expect(Math.min(...zs)).toBeGreaterThan(1); // liegt vor dem Zentrum (+z)
  });

  it("yaw 90: Front zeigt +x, die Zone ist entsprechend rotiert", () => {
    const [c1, c2, c3, c4] = clearanceRect([1, 1], 0.6, 90, 0.6, 0.6);
    // Front bei x=1.3; Tiefe erstreckt sich nach +x, Breite entlang z.
    expect(c1).toEqual([1.3, 1.3]);
    expect(c2).toEqual([1.3, 0.7]);
    expect(c3).toEqual([1.9, 0.7]);
    expect(c4).toEqual([1.9, 1.3]);
    const xs = [c1, c2, c3, c4].map((p) => p[0]);
    expect(Math.min(...xs)).toBeGreaterThan(1); // Zone vor dem Zentrum (+x)
    expect(Math.max(...xs) - Math.min(...xs)).toBeCloseTo(0.6, 9); // Tiefe in x
  });

  it("breite ≠ tiefe wird korrekt zugeordnet (Lavabo 0.7×0.6)", () => {
    const pts = clearanceRect([0, 0], 0.5, 0, 0.6, 0.7);
    const xs = pts.map((p) => p[0]);
    const zs = pts.map((p) => p[1]);
    expect(Math.max(...xs) - Math.min(...xs)).toBeCloseTo(0.7, 9); // Breite
    expect(Math.max(...zs) - Math.min(...zs)).toBeCloseTo(0.6, 9); // Tiefe
  });
});

describe("wandLuecken", () => {
  it("ohne Öffnung: ein Vollsegment über die ganze Wand", () => {
    const { segmente, luecken } = wandLuecken(3, []);
    expect(luecken).toEqual([]);
    expect(segmente).toEqual([{ a: 0, b: 3 }]);
  });

  it("eine Öffnung: zwei Segmente links/rechts der Lücke", () => {
    const { segmente, luecken } = wandLuecken(3, [{ offset: 1, width: 0.8 }]);
    expect(luecken).toEqual([{ a: 1, b: 1.8 }]);
    expect(segmente).toEqual([
      { a: 0, b: 1 },
      { a: 1.8, b: 3 },
    ]);
  });

  it("überlappende Öffnungen werden zu einer Lücke gemerged", () => {
    const { segmente, luecken } = wandLuecken(3, [
      { offset: 0.5, width: 0.5 },
      { offset: 0.8, width: 0.5 },
    ]);
    expect(luecken).toEqual([{ a: 0.5, b: 1.3 }]);
    expect(segmente).toEqual([
      { a: 0, b: 0.5 },
      { a: 1.3, b: 3 },
    ]);
  });

  it("clampt auf die Wandlänge (Öffnung ragt über das Wandende hinaus)", () => {
    const { segmente, luecken } = wandLuecken(3, [{ offset: 2.8, width: 0.5 }]);
    expect(luecken).toEqual([{ a: 2.8, b: 3 }]);
    expect(segmente).toEqual([{ a: 0, b: 2.8 }]);
  });
});