packages/shared/src/rules/interpreter.ts

/**
 * Deklarativer Regel-Interpreter (TS-Seite, Live-Feedback im Viewer).
 *
 * Liest dasselbe Regel-JSON (data/rules/) wie der Python-Interpreter und
 * füllt den constraintReport (Plan-Schema): je Regel Status der
 * Konfidenz-Ampel ok | knapp | verletzt | nicht-geprueft plus Marge in cm.
 * «knapp» = erfüllt, aber Marge < Messunsicherheit (estimatedError_cm;
 * 0 nach Nutzerbestätigung) → speist den Next-Steps-Leitfaden.
 *
 * ⚠️ PARITÄT: 1:1 gespiegelt in fp_engines/rules/interpreter.py. Jede
 * Änderung beidseitig + Fixtures aktualisieren (goldener Paritätstest).
 */
import {
  containmentViolation,
  distPointToSegment,
  frontDir,
  pointInPolygon,
  quadDistance,
  roundCm,
  separation,
  type Quad,
  type Vec2,
} from "./geometry.ts";
import type { Scene, SceneObject } from "./scene.ts";

export interface Rule {
  id: string;
  roomType: string;
  appliesTo: string;
  type: string;
  severity: string;
  params?: Record<string, number | string>;
  normProfile?: string;
  profilOverrides?: Record<string, Record<string, number | string>>;
  hinweis?: string;
}

export interface RuleResult {
  ruleId: string;
  status: "ok" | "knapp" | "verletzt" | "nicht-geprueft";
  margin_cm: number | null;
  placements: string[];
  hinweis?: string;
}

export interface ConstraintReport {
  hard: { ok: boolean; summary: { erfuellt: number; knapp: number; verletzt: number } };
  results: RuleResult[];
  softScore: { stil: number; ergonomie: number; relation: number };
}

const num = (params: Record<string, number | string>, key: string, fallback: number): number => {
  const v = params[key];
  return typeof v === "number" ? v : fallback;
};

const str = (params: Record<string, number | string>, key: string, fallback: string): string => {
  const v = params[key];
  return typeof v === "string" ? v : fallback;
};

function effectiveParams(rule: Rule, normProfile: string): Record<string, number | string> {
  // Normprofil-Overlay: Profilwerte überschreiben die Basis (Norm-Regelsatz-v0).
  return { ...(rule.params ?? {}), ...(rule.profilOverrides?.[normProfile] ?? {}) };
}

function matches(obj: SceneObject, appliesTo: string): boolean {
  return appliesTo === "*" || obj.funktionsTyp === appliesTo;
}

function massiveWalls(scene: Scene): Scene["walls"] {
  return scene.walls.filter((w) => w.kind === "massiv");
}

/** Rechteck-Zone vor der Front eines Objekts (depth tief, width breit, anliegend). */
function frontZone(obj: SceneObject, depth: number, width: number): Quad {
  const f = frontDir(obj.yawDeg);
  // Rechtsvektor = Front um −90° gedreht: (f.z, −f.x)
  const rx = f[1];
  const rz = -f[0];
  const frontCenter: Vec2 = [
    obj.center[0] + (f[0] * obj.d) / 2,
    obj.center[1] + (f[1] * obj.d) / 2,
  ];
  const hw = width / 2;
  const c1: Vec2 = [frontCenter[0] - rx * hw, frontCenter[1] - rz * hw];
  const c2: Vec2 = [frontCenter[0] + rx * hw, frontCenter[1] + rz * hw];
  const c3: Vec2 = [c2[0] + f[0] * depth, c2[1] + f[1] * depth];
  const c4: Vec2 = [c1[0] + f[0] * depth, c1[1] + f[1] * depth];
  return [c1, c2, c3, c4];
}

/** Zone vor einer Öffnung, ins Rauminnere extrudiert (Seite via Polygon-Test). */
function openingZone(scene: Scene, opening: Scene["openings"][number], depth: number): Quad | null {
  const wall = scene.walls.find((w) => w.id === opening.hostWall);
  if (!wall) return null;
  const dx = wall.end[0] - wall.start[0];
  const dz = wall.end[1] - wall.start[1];
  const len = Math.sqrt(dx * dx + dz * dz);
  if (len === 0) return null;
  const ux = dx / len;
  const uz = dz / len;
  const a: Vec2 = [wall.start[0] + ux * opening.offset, wall.start[1] + uz * opening.offset];
  const b: Vec2 = [a[0] + ux * opening.width, a[1] + uz * opening.width];
  for (const sgn of [1, -1]) {
    const nx = -uz * sgn;
    const nz = ux * sgn;
    const quad: Quad = [
      a,
      b,
      [b[0] + nx * depth, b[1] + nz * depth],
      [a[0] + nx * depth, a[1] + nz * depth],
    ];
    const cx = (quad[0][0] + quad[2][0]) / 2;
    const cz = (quad[0][1] + quad[2][1]) / 2;
    if (pointInPolygon([cx, cz], scene.floor)) return quad;
  }
  return null;
}

/** Marge einer Zone: muss im Raum liegen und frei von anderen Objekten sein. */
function zoneMargin(
  scene: Scene,
  zone: Quad,
  excludeIds: string[],
  offenders: string[],
  thresholdM: number,
  heightFilter: ((o: SceneObject) => boolean) | null = null,
): number | null {
  let margin: number | null = null;
  const contain = containmentViolation(zone, scene.floor);
  if (contain < 0) margin = contain;
  for (const o of scene.objects) {
    if (excludeIds.includes(o.id)) continue;
    if (heightFilter && !heightFilter(o)) continue;
    const sep = separation(zone, o.quad);
    if (margin === null || sep < margin) margin = sep;
    if (sep < thresholdM && o.isPlacement && !offenders.includes(o.id)) offenders.push(o.id);
  }
  return margin;
}

type Evaluator = (
  scene: Scene,
  params: Record<string, number | string>,
  appliesTo: string,
  offenders: string[],
) => number | null;

/** Wandobjekte über Bodenobjekten (Spiegel über Lavabo) kollidieren nicht:
 *  Kollision nur, wenn sich die Höhenintervalle [unterkante, oberkante]
 *  überlappen (Berührung = getrennt). */
function vertikalGetrennt(a: SceneObject, b: SceneObject): boolean {
  const aLo = a.mountHeight ?? 0;
  const bLo = b.mountHeight ?? 0;
  return aLo + a.h <= bLo || bLo + b.h <= aLo;
}

// --- Verkehrsweg-Freiraum (circulation), 1:1 zu interpreter.py ---------------
// Ganzzahlige Raster/Erosion-Analyse → bit-identisch zu Python. Float nur bei
// Zell-Mittelpunkten und der Schluss-Marge (gleiche Formeln/Reihenfolge).
const CIRC_CELL = 0.05; // Rasterweite (m). Läuft NICHT im Solver-Hot-Path (nur_hart), daher fein.
const CIRC_MAX_CELLS = 20000; // Schutz: riesige Räume vergröbern statt Speicher sprengen.
// Feste Nachbarschaftsreihenfolge – Determinismus/Parität (BFS-Erst-Treffer!).
const CIRC_NB: [number, number][] = [
  [1, 0],
  [-1, 0],
  [0, 1],
  [0, -1],
];

const evaluators: Record<string, Evaluator | null> = {
  collision(scene, _params, _appliesTo, offenders) {
    let margin: number | null = null;
    const track = (value: number, ids: SceneObject[], thresholdM: number): void => {
      if (margin === null || value < margin) margin = value;
      if (value < thresholdM) {
        for (const o of ids) {
          if (o.isPlacement && !offenders.includes(o.id)) offenders.push(o.id);
        }
      }
    };
    const thresholdM = sceneThreshold(scene);
    for (const o of scene.objects) {
      const contain = containmentViolation(o.quad, scene.floor);
      if (contain < 0) track(contain, [o], thresholdM);
    }
    for (let i = 0; i < scene.objects.length; i++) {
      for (let j = i + 1; j < scene.objects.length; j++) {
        const a = scene.objects[i] as SceneObject;
        const b = scene.objects[j] as SceneObject;
        if (vertikalGetrennt(a, b)) continue;
        track(separation(a.quad, b.quad), [a, b], thresholdM);
      }
    }
    return margin;
  },

  "wall-distance"(scene, params, appliesTo, offenders) {
    const minDist = num(params, "minDist", 0);
    let margin: number | null = null;
    for (const o of scene.objects.filter((x) => matches(x, appliesTo))) {
      let dist = Infinity;
      for (const w of massiveWalls(scene)) {
        const d = distPointToSegment(o.center, w.start, w.end);
        if (d < dist) dist = d;
      }
      if (dist === Infinity) continue;
      const m = dist - minDist;
      if (margin === null || m < margin) margin = m;
      if (m < sceneThreshold(scene) && o.isPlacement) offenders.push(o.id);
    }
    return margin;
  },

  "object-distance"(scene, params, appliesTo, offenders) {
    const minDist = num(params, "minDist", 0);
    const target = str(params, "target", "*");
    const measure = str(params, "measure", "edge");
    let margin: number | null = null;
    for (const a of scene.objects.filter((x) => matches(x, appliesTo))) {
      for (const b of scene.objects.filter((x) => matches(x, target))) {
        if (a.id === b.id) continue;
        const dist =
          measure === "center"
            ? Math.sqrt((a.center[0] - b.center[0]) ** 2 + (a.center[1] - b.center[1]) ** 2)
            : quadDistance(a.quad, b.quad);
        const m = dist - minDist;
        if (margin === null || m < margin) margin = m;
        if (m < sceneThreshold(scene)) {
          for (const o of [a, b]) {
            if (o.isPlacement && !offenders.includes(o.id)) offenders.push(o.id);
          }
        }
      }
    }
    return margin;
  },

  clearance(scene, params, appliesTo, offenders) {
    const depth = num(params, "depth", 0.6);
    let margin: number | null = null;
    for (const o of scene.objects.filter((x) => matches(x, appliesTo))) {
      const width = num(params, "width", o.w);
      const zone = frontZone(o, depth, width);
      const m = zoneMargin(scene, zone, [o.id], offenders, sceneThreshold(scene));
      if (m !== null && (margin === null || m < margin)) margin = m;
      if (m !== null && m < sceneThreshold(scene) && o.isPlacement && !offenders.includes(o.id)) {
        offenders.push(o.id);
      }
    }
    return margin;
  },

  "door-swing"(scene, params, _appliesTo, offenders) {
    const radius = num(params, "radius", 0.9);
    let margin: number | null = null;
    for (const opening of scene.openings.filter((o) => o.type === "door")) {
      // v0-Näherung: Rechteck Türbreite × radius statt Viertelkreis (konservativ,
      // identisch einfach in TS & Python). Echte Schwenkrichtung kommt mit M3.
      const zone = openingZone(scene, opening, radius);
      if (!zone) continue;
      const m = zoneMargin(scene, zone, [], offenders, sceneThreshold(scene));
      if (m !== null && (margin === null || m < margin)) margin = m;
    }
    return margin;
  },

  "keep-clear"(scene, params, _appliesTo, offenders) {
    const depth = num(params, "depth", 0.3);
    const maxH = num(params, "maxObjektHoehe", 0.9);
    let margin: number | null = null;
    for (const opening of scene.openings.filter((o) => o.type === "window")) {
      const zone = openingZone(scene, opening, depth);
      if (!zone) continue;
      // Nur hohe Objekte verstellen ein Fenster: Gesamthöhe = Montagehöhe + Korpus.
      const m = zoneMargin(
        scene,
        zone,
        [],
        offenders,
        sceneThreshold(scene),
        (o) => (o.mountHeight ?? 0) + o.h > maxH,
      );
      if (m !== null && (margin === null || m < margin)) margin = m;
    }
    return margin;
  },

  "host-binding"(scene, params, appliesTo, offenders) {
    const mount = str(params, "mount", "boden");
    let margin: number | null = null;
    for (const o of scene.objects.filter((x) => matches(x, appliesTo))) {
      let m: number | null = null;
      if (mount === "wand") {
        let dist = Infinity;
        for (const w of massiveWalls(scene)) {
          let d = Infinity;
          for (let i = 0; i < 4; i++) {
            const corner = o.quad[i] as Vec2;
            const dd = distPointToSegment(corner, w.start, w.end);
            if (dd < d) d = dd;
          }
          if (d < dist) dist = d;
        }
        const maxGap = num(params, "maxWandabstand", 0.05);
        m = dist === Infinity ? -maxGap : maxGap - dist;
      }
      // Höhenfenster (z.B. Lavabo-Oberkante 0.85–0.95): mountHeight = UNTERKANTE
      // über Boden (Plan-Schema) → geprüfte Oberkante = mountHeight + Korpushöhe.
      const minH = params["minHoehe"];
      const maxH = params["maxHoehe"];
      if (typeof minH === "number" && typeof maxH === "number") {
        const hk = o.mountHeight;
        const hm = hk === null ? -minH : Math.min(hk + o.h - minH, maxH - (hk + o.h));
        m = m === null ? hm : Math.min(m, hm);
      }
      if (m !== null) {
        if (margin === null || m < margin) margin = m;
        if (m < sceneThreshold(scene) && o.isPlacement) offenders.push(o.id);
      }
    }
    return margin;
  },

  connection(scene, params, appliesTo, offenders) {
    const typ = str(params, "anschluss", "wasser");
    const maxDist = num(params, "maxDist", 1.0);
    let margin: number | null = null;
    for (const o of scene.objects.filter((x) => matches(x, appliesTo))) {
      let dist = Infinity;
      for (const fp of scene.fixpoints.filter((f) => f.type === typ)) {
        // Punkt-zu-Footprint: 0, wenn der Fixpunkt im/auf dem Footprint liegt.
        let d: number;
        if (pointInPolygon(fp.position, o.quad)) {
          d = 0;
        } else {
          d = Infinity;
          for (let i = 0; i < 4; i++) {
            const dd = distPointToSegment(
              fp.position,
              o.quad[i] as Vec2,
              o.quad[(i + 1) % 4] as Vec2,
            );
            if (dd < d) d = dd;
          }
        }
        if (d < dist) dist = d;
      }
      const m = dist === Infinity ? -maxDist : maxDist - dist;
      if (margin === null || m < margin) margin = m;
      if (m < sceneThreshold(scene) && o.isPlacement) offenders.push(o.id);
    }
    return margin;
  },

  // Verkehrsweg-Freiraum v0 (Grid/Erosion) – 1:1-Spiegel von
  // fp_engines/rules/interpreter._eval_circulation (siehe Docstring dort).
  // Ganzzahlig (Grid/BFS/Union-Find) → bit-identisches Urteil zu Python.
  // v0 ohne Verursacher-Zuordnung → nur scene + params (Evaluator-Typ erlaubt weniger Args).
  circulation(scene, params) {
    const minWidth = num(params, "minWidth", 0.9);
    const floor = scene.floor;
    const xs = floor.map((p) => p[0]);
    const zs = floor.map((p) => p[1]);
    const x0 = Math.min(...xs);
    const x1 = Math.max(...xs);
    const z0 = Math.min(...zs);
    const z1 = Math.max(...zs);
    let cell = CIRC_CELL;
    let nx = Math.floor((x1 - x0) / cell) + 1;
    let nz = Math.floor((z1 - z0) / cell) + 1;
    while (nx * nz > CIRC_MAX_CELLS) {
      cell *= 2;
      nx = Math.floor((x1 - x0) / cell) + 1;
      nz = Math.floor((z1 - z0) / cell) + 1;
    }

    const boxes: [number, number, number, number][] = [];
    for (const o of scene.objects) {
      if (o.mount === "wand") continue;
      const qx = o.quad.map((c) => c[0]);
      const qz = o.quad.map((c) => c[1]);
      boxes.push([Math.min(...qx), Math.max(...qx), Math.min(...qz), Math.max(...qz)]);
    }

    const cx = (i: number): number => x0 + (i + 0.5) * cell;
    const cz = (j: number): number => z0 + (j + 0.5) * cell;

    // Flache typisierte Arrays (Index k = i*nz+j); Werte identisch zur 2D-Liste
    // in interpreter.py, nur TS-ergonomischer (Element-Typ number/boolean).
    const idx = (i: number, j: number): number => i * nz + j;
    const free = new Uint8Array(nx * nz);
    let nFree = 0;
    for (let i = 0; i < nx; i++) {
      const px = cx(i);
      for (let j = 0; j < nz; j++) {
        const pz = cz(j);
        if (!pointInPolygon([px, pz], floor)) continue;
        let blocked = false;
        for (const [xa, xb, za, zb] of boxes) {
          if (xa <= px && px <= xb && za <= pz && pz <= zb) {
            blocked = true;
            break;
          }
        }
        if (!blocked) {
          free[idx(i, j)] = 1;
          nFree++;
        }
      }
    }
    if (nFree === 0) return null;

    const inf = nx + nz + 1;
    const dist = new Int32Array(nx * nz);
    const queue: number[] = [];
    for (let i = 0; i < nx; i++) {
      for (let j = 0; j < nz; j++) {
        const k = idx(i, j);
        if (free[k]) dist[k] = inf;
        else queue.push(k);
      }
    }
    let head = 0;
    while (head < queue.length) {
      const c = queue[head] as number;
      head++;
      const i = Math.floor(c / nz);
      const j = c % nz;
      for (const [di, dj] of CIRC_NB) {
        const ni = i + di;
        const nj = j + dj;
        if (ni >= 0 && ni < nx && nj >= 0 && nj < nz) {
          const nk = idx(ni, nj);
          const dc = dist[c] as number;
          if ((dist[nk] as number) > dc + 1) {
            dist[nk] = dc + 1;
            queue.push(nk);
          }
        }
      }
    }

    const cellAt = (px: number, pz: number): number => {
      let ci = Math.floor((px - x0) / cell);
      let cj = Math.floor((pz - z0) / cell);
      ci = ci < 0 ? 0 : ci > nx - 1 ? nx - 1 : ci;
      cj = cj < 0 ? 0 : cj > nz - 1 ? nz - 1 : cj;
      return idx(ci, cj);
    };

    const nearestFree = (px: number, pz: number): number | null => {
      const start = cellAt(px, pz);
      if (free[start]) return start;
      const seen = new Set<number>([start]);
      const bfs: number[] = [start];
      let h = 0;
      while (h < bfs.length) {
        const c = bfs[h] as number;
        h++;
        const i = Math.floor(c / nz);
        const j = c % nz;
        for (const [di, dj] of CIRC_NB) {
          const ni = i + di;
          const nj = j + dj;
          if (ni >= 0 && ni < nx && nj >= 0 && nj < nz) {
            const nk = idx(ni, nj);
            if (!seen.has(nk)) {
              if (free[nk]) return nk;
              seen.add(nk);
              bfs.push(nk);
            }
          }
        }
      }
      return null;
    };

    const doors = scene.openings.filter((o) => o.type === "door");
    const anchors: number[] = [];
    for (const d of doors) {
      const wall = scene.walls.find((w) => w.id === d.hostWall);
      if (!wall) continue;
      const sx = wall.start[0];
      const sz = wall.start[1];
      const ex = wall.end[0];
      const ez = wall.end[1];
      const wl = Math.sqrt((ex - sx) ** 2 + (ez - sz) ** 2);
      if (wl === 0) continue;
      const ux = (ex - sx) / wl;
      const uz = (ez - sz) / wl;
      const mid = d.offset + d.width / 2;
      const mx = sx + ux * mid;
      const mz = sz + uz * mid;
      // Anker ins KORRIDOR-INNERE schieben (~minWidth/2), vorbei am Türpfosten:
      // misst den Innenraum-Korridor, nicht die fixe Türbreite (1:1 zu Python).
      for (const sgn of [1, -1]) {
        const innenX = -uz * sgn;
        const innenZ = ux * sgn;
        if (pointInPolygon([mx + innenX * 0.1, mz + innenZ * 0.1], floor)) {
          const a = nearestFree(mx + innenX * (minWidth / 2), mz + innenZ * (minWidth / 2));
          if (a !== null) anchors.push(a);
          break;
        }
      }
    }
    if (doors.length === 1) {
      let best: number | null = null;
      let bestC = -1;
      for (let i = 0; i < nx; i++) {
        for (let j = 0; j < nz; j++) {
          const k = idx(i, j);
          const clearance = dist[k] as number;
          if (free[k] && clearance > bestC) {
            bestC = clearance;
            best = k;
          }
        }
      }
      if (best !== null) anchors.push(best);
    }
    if (anchors.length < 2) return null;

    let maxLvl = 0;
    const buckets: number[][] = [];
    for (let i = 0; i < nx; i++) {
      for (let j = 0; j < nz; j++) {
        const k = idx(i, j);
        if (free[k]) {
          const lvl = dist[k] as number;
          (buckets[lvl] ??= []).push(k);
          if (lvl > maxLvl) maxLvl = lvl;
        }
      }
    }
    const parent = new Map<number, number>();
    const find = (x: number): number => {
      let r = x;
      while ((parent.get(r) as number) !== r) {
        parent.set(r, parent.get(parent.get(r) as number) as number);
        r = parent.get(r) as number;
      }
      return r;
    };

    const active = new Set<number>();
    let bottleneck = -1;
    for (let lvl = maxLvl; lvl >= 0; lvl--) {
      for (const c of buckets[lvl] ?? []) {
        parent.set(c, c);
        active.add(c);
        const ci = Math.floor(c / nz);
        const cj = c % nz;
        for (const [di, dj] of CIRC_NB) {
          const ni = ci + di;
          const nj = cj + dj;
          if (ni >= 0 && ni < nx && nj >= 0 && nj < nz) {
            const nb = idx(ni, nj);
            if (active.has(nb)) {
              const ra = find(c);
              const rb = find(nb);
              if (ra !== rb) parent.set(ra, rb);
            }
          }
        }
      }
      if (anchors.every((a) => active.has(a)) && new Set(anchors.map((a) => find(a))).size === 1) {
        bottleneck = lvl;
        break;
      }
    }

    if (bottleneck < 0) return -minWidth;
    return 2 * bottleneck * cell - minWidth;
  },
  relation: null,
};

/** Schwelle in Metern, unterhalb derer Beteiligte als «offenders» gelistet werden. */
function sceneThreshold(scene: Scene): number {
  return scene.margeCm / 100;
}

export function evaluateRules(scene: Scene, rules: Rule[]): ConstraintReport {
  const results: RuleResult[] = [];

  for (const rule of rules) {
    if (rule.roomType !== "alle" && rule.roomType !== scene.roomType) continue;
    if (rule.normProfile && rule.normProfile !== scene.normProfile) continue;

    const evaluator = evaluators[rule.type];
    if (evaluator === undefined) throw new Error(`Unbekannter Regel-Typ: ${rule.type}`);

    if (evaluator === null) {
      results.push({
        ruleId: rule.id,
        status: "nicht-geprueft",
        margin_cm: null,
        placements: [],
        ...(rule.hinweis !== undefined && { hinweis: rule.hinweis }),
      });
      continue;
    }

    const offenders: string[] = [];
    const marginM = evaluator(
      scene,
      effectiveParams(rule, scene.normProfile),
      rule.appliesTo,
      offenders,
    );

    let status: RuleResult["status"];
    let marginCm: number | null = null;
    if (marginM === null) {
      status = "ok"; // Regel hat keine anwendbaren Objekte → trivial erfüllt.
    } else {
      marginCm = roundCm(marginM);
      if (marginCm < 0) status = "verletzt";
      else if (marginCm < scene.margeCm) status = "knapp";
      else status = "ok";
    }

    results.push({
      ruleId: rule.id,
      status,
      margin_cm: marginCm,
      placements: status === "ok" ? [] : offenders,
      ...(rule.hinweis !== undefined && { hinweis: rule.hinweis }),
    });
  }

  const hardIds = new Set(rules.filter((r) => r.severity === "hard").map((r) => r.id));
  const summary = { erfuellt: 0, knapp: 0, verletzt: 0 };
  for (const r of results) {
    if (!hardIds.has(r.ruleId)) continue;
    if (r.status === "ok") summary.erfuellt += 1;
    else if (r.status === "knapp") summary.knapp += 1;
    else if (r.status === "verletzt") summary.verletzt += 1;
  }

  return {
    hard: { ok: summary.verletzt === 0, summary },
    results,
    softScore: { stil: 0, ergonomie: 0, relation: 0 },
  };
}