Room outline, walls and openings

export function roomPts(room) {
  const W = room.w, D = room.d;
  const box = [[0, 0], [W, 0], [W, D], [0, D]];
  if (room.shape === 'free' && Array.isArray(room.pts)) return room.pts.map((p) => [p[0], p[1]]);
  const n = room.notch;
  if (room.shape === 'L' && n) {
    const nw = clamp(n.w, 1, W - 1), nd = clamp(n.d, 1, D - 1);
    switch (n.at) {
      case 'NW': return [[0, 0], [W, 0], [W, D], [nw, D], [nw, D - nd], [0, D - nd]];
      case 'SE': return [[0, 0], [W - nw, 0], [W - nw, nd], [W, nd], [W, D], [0, D]];
      case 'SW': return [[nw, 0], [W, 0], [W, D], [0, D], [0, nd], [nw, nd]];
      default: return [[0, 0], [W, 0], [W, D - nd], [W - nw, D - nd], [W - nw, D], [0, D]];   // NE
    }
  }
  if (room.shape === 'U' && n) {
    const horiz = n.at === 'N' || n.at === 'S';
    const nw = clamp(n.w, 1, (horiz ? W : D) - 2), nd = clamp(n.d, 1, (horiz ? D : W) - 1);
    if (n.at === 'S') { const a = (W - nw) / 2; return [[0, 0], [a, 0], [a, nd], [a + nw, nd], [a + nw, 0], [W, 0], [W, D], [0, D]]; }
    if (n.at === 'E') { const a = (D - nw) / 2; return [[0, 0], [W, 0], [W, a], [W - nd, a], [W - nd, a + nw], [W, a + nw], [W, D], [0, D]]; }
    if (n.at === 'W') { const a = (D - nw) / 2; return [[0, 0], [W, 0], [W, D], [0, D], [0, a + nw], [nd, a + nw], [nd, a], [0, a]]; }
    const a = (W - nw) / 2;   // N
    return [[0, 0], [W, 0], [W, D], [a + nw, D], [a + nw, D - nd], [a, D - nd], [a, D], [0, D]];
  }
  return box;
}

/** A free outline made safe: right angles only, no repeated or collinear corners, no crossing edges, counter-clockwise, moved to (0, 0). null when it cannot be one. */
export function cleanOutline(raw) {
  if (!Array.isArray(raw)) return null;
  let pts = [];
  for (const p of raw.slice(0, MAX_PTS)) {
    if (!Array.isArray(p)) return null;
    const x = num(p[0], NaN), y = num(p[1], NaN);
    if (!Number.isFinite(x) || !Number.isFinite(y) || Math.abs(x) > 1e5 || Math.abs(y) > 1e5) return null;
    pts.push([x, y]);
  }
  // drop repeats, then collinear corners
  pts = pts.filter((p, i) => { const q = pts[(i + 1) % pts.length]; return Math.abs(p[0] - q[0]) > EPS || Math.abs(p[1] - q[1]) > EPS; });
  for (let again = true; again && pts.length >= 4;) {
    again = false;
    for (let i = 0; i < pts.length; i++) {
      const a = pts[(i + pts.length - 1) % pts.length], b = pts[i], c = pts[(i + 1) % pts.length];
      if ((Math.abs(a[0] - b[0]) < EPS && Math.abs(b[0] - c[0]) < EPS) || (Math.abs(a[1] - b[1]) < EPS && Math.abs(b[1] - c[1]) < EPS)) { pts.splice(i, 1); again = true; break; }
    }
  }
  if (pts.length < 4) return null;
  for (let i = 0; i < pts.length; i++) {
    const a = pts[i], b = pts[(i + 1) % pts.length];
    if (Math.abs(a[0] - b[0]) > EPS && Math.abs(a[1] - b[1]) > EPS) return null;   // a slanted edge
  }
  for (let i = 0; i < pts.length; i++) for (let j = i + 2; j < pts.length; j++) {
    if (i === 0 && j === pts.length - 1) continue;
    if (segCross(pts[i], pts[(i + 1) % pts.length], pts[j], pts[(j + 1) % pts.length])) return null;
  }
  const A = area2(pts);
  if (Math.abs(A) < 1) return null;
  if (A < 0) pts.reverse();
  const x0 = Math.min(...pts.map((p) => p[0])), y0 = Math.min(...pts.map((p) => p[1]));
  return pts.map((p) => [r6(p[0] - x0), r6(p[1] - y0)]);
}

function segCross(a, b, c, d) {
  const o = (p, q, r) => (q[0] - p[0]) * (r[1] - p[1]) - (q[1] - p[1]) * (r[0] - p[0]);
  const d1 = o(a, b, c), d2 = o(a, b, d), d3 = o(c, d, a), d4 = o(c, d, b);
  return ((d1 > EPS && d2 < -EPS) || (d1 < -EPS && d2 > EPS)) && ((d3 > EPS && d4 < -EPS) || (d3 < -EPS && d4 > EPS));
}

/** The outline as a polygon with the arcs written out as short chords (for inside tests, areas and drawing). */
export function outlineOf(pts, arcs = []) {
  const out = [];
  const sw = new Map((arcs || []).map((a) => [a.i, a.sweep]));
  for (let i = 0; i < pts.length; i++) {
    const a = pts[i], b = pts[(i + 1) % pts.length];
    if (sw.has(i)) {
      // enough chords that the polygon is within 0.5 of the true arc (a unit-free guess of 1 mm = 1 unit is fine: a smaller job just gets more chords)
      const g = arcGeom(a, b, sw.get(i));
      const step = g ? 2 * Math.acos(Math.max(0, 1 - 0.5 / g.r)) : 0.2;
      const n = Math.max(4, Math.min(400, Math.ceil(Math.abs(sw.get(i)) * Math.PI / 180 / Math.max(step, 1e-3))));
      out.push(...arcPoints(a, b, sw.get(i), n).slice(0, -1));
    } else out.push(a);
  }
  return out;
}

/**
 * A free outline of ANY angle, with arc edges: { pts, arcs } counter-clockwise and moved so its bounding box starts at (0, 0), or null when it cannot be one
 * (fewer than three corners, repeated corners, edges that cross, a wall shorter than 1). Collinear corners are dropped unless an arc starts or ends there.
 */
export function cleanShape(raw, rawArcs) {
  if (!Array.isArray(raw)) return null;
  let pts = [];
  for (const p of raw.slice(0, MAX_PTS)) {
    if (!Array.isArray(p)) return null;
    const x = num(p[0], NaN), y = num(p[1], NaN);
    if (!Number.isFinite(x) || !Number.isFinite(y) || Math.abs(x) > 1e5 || Math.abs(y) > 1e5) return null;
    pts.push([x, y]);
  }
  let arcs = cleanArcs(rawArcs, pts.length);
  const keep = pts.map(() => true);
  // a repeated corner (same as the next one) is dropped; an arc on it goes too
  for (let i = 0; i < pts.length; i++) { const q = pts[(i + 1) % pts.length]; if (Math.abs(pts[i][0] - q[0]) <= EPS && Math.abs(pts[i][1] - q[1]) <= EPS) keep[i] = false; }
  if (arcs.some((a) => !keep[a.i])) arcs = arcs.filter((a) => keep[a.i]);
  const arcAt = new Set();
  arcs.forEach((a) => { arcAt.add(a.i); arcAt.add((a.i + 1) % pts.length); });
  let list = pts.map((p, i) => ({ p, i, arc: arcs.find((a) => a.i === i) || null, isEnd: arcAt.has(i) })).filter((_, i) => keep[i]);
  for (let again = true; again && list.length >= 4;) {
    again = false;
    for (let i = 0; i < list.length; i++) {
      const e = list[i];
      if (e.isEnd) continue;
      const a = list[(i + list.length - 1) % list.length].p, b = e.p, c = list[(i + 1) % list.length].p;
      const cr = (b[0] - a[0]) * (c[1] - b[1]) - (b[1] - a[1]) * (c[0] - b[0]);
      if (Math.abs(cr) < 1e-9 * Math.max(1, Math.hypot(b[0] - a[0], b[1] - a[1]) * Math.hypot(c[0] - b[0], c[1] - b[1])) && ((b[0] - a[0]) * (c[0] - b[0]) + (b[1] - a[1]) * (c[1] - b[1])) > 0) { list.splice(i, 1); again = true; break; }
    }
  }
  if (list.length < 3) return null;
  let P = list.map((e) => e.p);
  let A = list.map((e, k) => (e.arc ? { i: k, sweep: e.arc.sweep } : null)).filter(Boolean);
  for (let i = 0; i < P.length; i++) { const q = P[(i + 1) % P.length]; if (Math.hypot(P[i][0] - q[0], P[i][1] - q[1]) < 1) return null; }
  // orientation from the corners (the arcs' signs are physical: + away from the room, so they do not change when the order is reversed)
  if (polyArea2(P) < 0) {
    const n = P.length;
    P = P.slice().reverse();
    A = A.map((a) => ({ i: (n - 2 - a.i + n) % n, sweep: a.sweep })).sort((x, y) => x.i - y.i);
  }
  const poly0 = outlineOf(P, A);
  for (let i = 0; i < poly0.length; i++) for (let j = i + 2; j < poly0.length; j++) {
    if (i === 0 && j === poly0.length - 1) continue;
    if (segCross(poly0[i], poly0[(i + 1) % poly0.length], poly0[j], poly0[(j + 1) % poly0.length])) return null;
  }
  if (Math.abs(polyArea2(poly0)) < 1) return null;
  const poly = outlineOf(P, A);
  const x0 = Math.min(...poly.map((p) => p[0])), y0 = Math.min(...poly.map((p) => p[1]));
  return { pts: P.map((p) => [r6(p[0] - x0), r6(p[1] - y0)]), arcs: A, w: r6(Math.max(...poly.map((p) => p[0])) - x0), d: r6(Math.max(...poly.map((p) => p[1])) - y0) };
}

/**
 * The walls, counter-clockwise: each has the frame the layout uses (origin = the wall's start corner, u along it, n into the room). A slanted wall's frame
 * is rotated; an ARC wall's frame is its CHORD's (u from corner to corner) and it also has `arc` (angled.js arcGeom), `chord` and `len` = the arc length.
 * `turnStart` / `turnEnd` = how far the boundary turns at its two corners, degrees, + = left (a room corner), − = right (an inside corner).
 */
export function walls(room) {
  const pts = roomPts(room);
  const rect = room.shape === 'rect' || !room.shape;
  const ids = rect ? ['S', 'E', 'N', 'W'] : pts.map((_, i) => 'P' + (i + 1));
  const n = pts.length;
  const sw = new Map((room.shape === 'free' && room.arcs ? room.arcs : []).map((a) => [a.i, a.sweep]));
  const out = pts.map((a, i) => {
    const b = pts[(i + 1) % n];
    const chord = Math.hypot(b[0] - a[0], b[1] - a[1]);
    const u = { x: r6((b[0] - a[0]) / chord), y: r6((b[1] - a[1]) / chord) };
    const arc = sw.has(i) ? arcGeom(a, b, sw.get(i)) : null;
    const w = { id: ids[i], i, a: { x: a[0], y: a[1] }, b: { x: b[0], y: b[1] }, len: arc ? arc.arcLen : r6(chord), chord: r6(chord), arc,
      frame: { o: { x: a[0], y: a[1] }, u, n: { x: r6(-u.y), y: r6(u.x) }, ang: Math.atan2(u.y, u.x) } };
    w.angle = r6((Math.atan2(u.y, u.x) * 180) / Math.PI);
    w.t0 = arc ? arc.t0 : u; w.t1 = arc ? arc.t1 : u;
    return w;
  });
  out.forEach((w, i) => {
    const p = out[(i + n - 1) % n], q = out[(i + 1) % n];
    w.turnStart = r6(turnBetween(p.t1, w.t0));
    w.turnEnd = r6(turnBetween(w.t1, q.t0));
    w.convexStart = w.turnStart > 1e-6;   // a left turn into this wall: the room's corner
    w.convexEnd = w.turnEnd > 1e-6;
    w.nextId = q.id; w.prevId = p.id;
  });
  return out;
}

function pointInPoly(pts, x, y) {
  for (let i = 0; i < pts.length; i++) if (onSeg(pts[i], pts[(i + 1) % pts.length], x, y)) return true;   // on an edge
  let inside = false;
  for (let i = 0, j = pts.length - 1; i < pts.length; j = i++) {
    const [xi, yi] = pts[i], [xj, yj] = pts[j];
    if ((yi > y) !== (yj > y) && x < ((xj - xi) * (y - yi)) / (yj - yi) + xi) inside = !inside;
  }
  return inside;
}

/** Does a polygon (any angle) lie inside the room? Its corners and middle are in, no room corner is inside it, and no room edge crosses its edges. */
export function polyInRoom(room, poly, tol = 0.5) {
  const out = roomOutline(room);
  for (const [x, y] of poly) if (!pointInPoly(out, x, y) && distPointPoly(out, x, y) > tol) return false;
  const cx = poly.reduce((s, p) => s + p[0], 0) / poly.length, cy = poly.reduce((s, p) => s + p[1], 0) / poly.length;
  if (!pointInPoly(out, cx, cy)) return false;
  // a room corner poking into the polygon (further than tol from its edges)
  for (const [px, py] of out) if (pointInPoly(poly, px, py) && distPointPoly(poly, px, py) > tol) return false;
  return true;
}

function distPointSeg(px, py, a, b) {
  const dx = b[0] - a[0], dy = b[1] - a[1], L2 = dx * dx + dy * dy;
  const t = L2 ? Math.max(0, Math.min(1, ((px - a[0]) * dx + (py - a[1]) * dy) / L2)) : 0;
  return Math.hypot(px - (a[0] + t * dx), py - (a[1] + t * dy));
}

/** Distance from a convex polygon (or a rectangle [x0, y0, x1, y1]) to the nearest wall (0 when touching or crossing). */
export function distToWalls(room, shape) {
  const poly = shape.length === 4 && typeof shape[0] === 'number' ? [[shape[0], shape[1]], [shape[2], shape[1]], [shape[2], shape[3]], [shape[0], shape[3]]] : shape;
  const out = roomOutline(room);
  let best = Infinity;
  for (let i = 0; i < out.length; i++) {
    const a = out[i], b = out[(i + 1) % out.length];
    for (let j = 0; j < poly.length; j++) {
      const c = poly[j], d = poly[(j + 1) % poly.length];
      if (segsCross(a, b, c, d)) return 0;
      best = Math.min(best, distPointSeg(c[0], c[1], a, b), distPointSeg(a[0], a[1], c, d), distPointSeg(b[0], b[1], c, d));
    }
  }
  return best === Infinity ? 0 : best;
}

export function cleanOpenings(raw, room, unit = 'mm') {
  const W = walls(room);
  const k = unit === 'in' ? 1 / 25.4 : 1;
  const out = [];
  const seen = new Set();
  for (const o of (Array.isArray(raw) ? raw.slice(0, 40) : [])) {
    if (!o || typeof o !== 'object') continue;
    const wall = W.find((w) => w.id === o.wall);
    if (!wall) continue;
    const kind = o.kind === 'window' ? 'window' : 'door';
    const w = clamp(num(o.w, (kind === 'door' ? 900 : 1200) * k), 1, wall.chord);
    const at = clamp(num(o.at, 0), 0, Math.max(0, wall.chord - w));
    let id = txt(o.id, 12).replace(/[^A-Za-z0-9-]/g, '') || (kind === 'door' ? 'D' : 'W') + (out.length + 1);
    while (seen.has(id)) id += 'x';
    seen.add(id);
    const h = clamp(num(o.h, (kind === 'door' ? 2100 : 1200) * k), 1, room.h);
    const sill = kind === 'door' ? 0 : clamp(num(o.sill, 1000 * k), 0, Math.max(0, room.h - 1));
    out.push({ id, kind, wall: wall.id, at: r6(at), w: r6(w), h: r6(h), sill: r6(sill), swing: o.swing === 'out' ? 'out' : 'in', name: txt(o.name, 40) });
  }
  return out;
}

/** The strip of floor in front of an opening, in world plan coordinates: depth into the room, the opening's width along the wall. */
export function openingPoly(room, op, depth) {
  const wall = wallById(room, op.wall);
  if (!wall) return null;
  const f = wall.frame;
  const P = (s, o) => [r6(f.o.x + f.u.x * s + f.n.x * o), r6(f.o.y + f.u.y * s + f.n.y * o)];
  return [P(op.at, 0), P(op.at + op.w, 0), P(op.at + op.w, depth), P(op.at, depth)];
}

/** Parse "x,y" lines or "x,y x,y …" typed by a person into corner pairs. */
export function parsePoints(text) {
  const out = [];
  for (const m of String(text || '').matchAll(/(-?\d+(?:\.\d+)?)\s*[,;\s]\s*(-?\d+(?:\.\d+)?)/g)) out.push([Number(m[1]), Number(m[2])]);
  return out;
}

/** The corners of a right-angled outline from the lengths of its edges: start at (0, 0) going east, then turn left (L) or right (R) at each corner. "4000 L 2500 L 1500 R …". */
export function outlineFromTurns(lengths, turns) {
  const pts = [[0, 0]];
  let dir = [1, 0];
  for (let i = 0; i < lengths.length; i++) {
    const p = pts[pts.length - 1];
    pts.push([p[0] + dir[0] * lengths[i], p[1] + dir[1] * lengths[i]]);
    dir = turns[i] === 'R' ? [dir[1], -dir[0]] : [-dir[1], dir[0]];
  }
  pts.pop();
  return pts;
}

export function outlineFromSegments(segs) {
  if (!Array.isArray(segs) || segs.length < 2) return null;
  const pts = [[0, 0]], arcs = [];
  let heading = 0;
  for (let k = 0; k < segs.length; k++) {
    const sg = segs[k], p = pts[pts.length - 1];
    let next;
    if (sg.kind === 'arc') {
      const rr = num(sg.radius, NaN), sw = num(sg.sweep, NaN);
      if (!(rr > 0) || !(Math.abs(sw) >= 0.5 && Math.abs(sw) < 180)) return null;
      heading = sg.heading === null || sg.heading === undefined ? heading : num(sg.heading, heading);
      next = arcEnd(p, heading, rr, sw);
      arcs.push({ i: pts.length - 1, sweep: sw });
    } else {
      const len = num(sg.len, NaN);
      if (!(len > 0)) return null;
      heading = num(sg.angle, 0);
      next = edgeEnd(p, len, heading);
    }
    pts.push(next);
  }
  // the last point is the start again when the outline closes by itself
  const last = pts[pts.length - 1];
  if (Math.hypot(last[0], last[1]) < 1) pts.pop();
  return { pts, arcs: arcs.filter((a) => a.i < pts.length) };
}

export function cleanLoop(pts) {
  let p = (Array.isArray(pts) ? pts : []).map((q) => [Number(q[0]), Number(q[1])]).filter((q) => Number.isFinite(q[0]) && Number.isFinite(q[1]));
  if (p.length > 1 && Math.hypot(p[0][0] - p[p.length - 1][0], p[0][1] - p[p.length - 1][1]) < 1) p = p.slice(0, -1);
  // drop repeated points and points in a straight line
  let again = true;
  while (again && p.length > 3) {
    again = false;
    for (let i = 0; i < p.length; i++) {
      const a = p[(i + p.length - 1) % p.length], b = p[i], c = p[(i + 1) % p.length];
      const cross = (b[0] - a[0]) * (c[1] - b[1]) - (b[1] - a[1]) * (c[0] - b[0]);
      if (Math.hypot(b[0] - a[0], b[1] - a[1]) < 1 || Math.abs(cross) < 1e-3 * Math.max(1, Math.hypot(b[0] - a[0], b[1] - a[1]) * Math.hypot(c[0] - b[0], c[1] - b[1]))) { p.splice(i, 1); again = true; break; }
    }
  }
  if (p.length < 3 || Math.abs(area(p)) < 1) return null;
  return area(p) < 0 ? p.reverse() : p;
}

const k = u === 'in' ? 1 / 25.4 : 1;
const ox = Math.min(...loop.map((q) => q[0])), oy = Math.min(...loop.map((q) => q[1]));
const rel = loop.map((q) => [q[0] - ox, q[1] - oy]);
const rnd = (v) => (u === 'in' ? Math.round(v * k * 16) / 16 : Math.round(v * 10) / 10);
const pts = rel.map((q) => [rnd(q[0]), rnd(q[1])]);
const W = Math.max(...pts.map((q) => q[0])), D = Math.max(...pts.map((q) => q[1]));

const x = (Number(o.x) - ox) * k, y = (Number(o.y) - oy) * k, w = Number(o.w) * k;
if (!Number.isFinite(x) || !Number.isFinite(y) || !(w > 0)) { skipped.push(o); continue; }
let best = null;
for (const wall of wl) {
  if (wall.arc) continue;
  const dx = x - wall.a.x, dy = y - wall.a.y, s = dx * wall.frame.u.x + dy * wall.frame.u.y, off = Math.abs(-dx * wall.frame.u.y + dy * wall.frame.u.x);
  if (s < -w / 2 || s > wall.len + w / 2) continue;
  if (!best || off < best.off) best = { wall, s, off };
}
if (!best || best.off > MAX_OFF * k) { skipped.push(o); continue; }
const win = o.kind === 'window';
const id = (win ? 'W' : 'D') + (win ? ++nw : ++nd);
const at = Math.max(0, Math.min(best.wall.len - w, best.s - w / 2));

export function toModel(project, x, y) {
  const s = project.site || { ox: 0, oy: 0 };
  const k = project.unit === 'in' ? 25.4 : 1;
  return [s.ox + x * k, s.oy + y * k];
}