Cabinet run layout and countertops

/** The islands as runs of their own: the front row faces the island's left, a back row (if it has items) faces the other way from the far end. */
export function islandRuns(p) {
  const out = [];
  for (const isl of p.islands || []) {
    const a = (isl.rot * Math.PI) / 180;
    const u = { x: r6(Math.cos(a)), y: r6(Math.sin(a)) }, n = { x: r6(-u.y), y: r6(u.x) };
    const o = { x: isl.x, y: isl.y };
    const mk = (id, items, frame, attach, ep) => ({
      run: { id, name: isl.name, wall: null, island: isl.id, from: 0, to: isl.len, autoFiller: isl.autoFiller, endPanels: ep, base: items, upper: [], attach, seat: isl.seat, kind: isl.kind },
      wall: null, frame, len: isl.len, rows: {}, closedStart: attach.start, closedEnd: attach.end, island: isl,
    });
    out.push(mk(isl.id, isl.base, { o, u, n, ang: a }, isl.attach, isl.endPanels));
    if (isl.back.length) {
      const o2 = { x: r6(o.x + u.x * isl.len), y: r6(o.y + u.y * isl.len) };
      out.push(mk(isl.id + 'b', isl.back, { o: o2, u: { x: -u.x, y: -u.y }, n: { x: -n.x, y: -n.y }, ang: a + Math.PI }, { start: isl.attach.end, end: isl.attach.start }, { start: isl.endPanels.end, end: isl.endPanels.start }));
    }
  }
  return out;
}

const tol = 0.01;
const maxFiller = conv(75, unit);

const arcTilt = (L, row, which) => {
  const g = L.wallInfo && L.wallInfo.arc;
  if (!g || !g.bay || L.island) return 0;
  const cells = L.rows[row].cells, c = which === 'start' ? cells[0] : cells[cells.length - 1];
  if (!c || (c.tpl && c.tpl.curved) || !(c.w < 2 * g.r)) return 0;
  const d = c.kind === 'cab' ? (depthOf ? depthOf(c) : c.cab.d) : L.rows[row].depth || 0;
  return d * Math.sin(Math.atan2(c.w / 2, Math.sqrt(Math.max(0, g.r * g.r - (c.w * c.w) / 4))));
};

const fits = (cell, tau, other, own) => {
  if (own.arc || (other && other.arc)) return 'arc';
  if (Math.abs(tau - 90) < 0.01) return null;
  if (cell.turn !== 'diag') return 'angle';
  const dg = diagAt(tau, cell.w, cell.cab.d);
  return dg.valid ? null : 'size';
};

const later = ib > ia;
const dOther = later ? a.depth : b.depth;
const flat = square ? dOther : cornerBlock(tau, dOther);
const bend = (L, q) => (L.wallInfo.arc && !L.island ? (q * q) / (2 * L.wallInfo.arc.r) : 0);   // the curve leaves the tangent line by s^2 / 2r over a stretch s
const stop = flat + arcTilt(A, row, 'end') + arcTilt(B, row, 'start') + bend(A, flat);
if (later) b.blocked.start = Math.max(b.blocked.start, stop); else a.blocked.end = Math.max(a.blocked.end, stop);
if (!square || stop > dOther + 1e-6) {

const wc = wedgeCorner(tau, dOther);
if (wc && wc.leg1 > 1 && wc.leg2 > 1) {
  const Pc = A.wallInfo.b;
  const uA = A.wallInfo.t1, nA = { x: -uA.y, y: uA.x }, uB = B.wallInfo.t0, nB = { x: -uB.y, y: uB.x };
  const tri = later
    ? [[Pc.x, Pc.y], [Pc.x + uB.x * wc.leg1, Pc.y + uB.y * wc.leg1], [Pc.x + nA.x * dOther, Pc.y + nA.y * dOther]]
    : [[Pc.x, Pc.y], [Pc.x - uA.x * wc.leg1, Pc.y - uA.y * wc.leg1], [Pc.x + nB.x * dOther, Pc.y + nB.y * dOther]];
  const hostRun = later ? A : B;
  const hc = hostRun.rows[row].cells.filter((x) => x.kind === 'cab').pop();
  wedges.push({ row, from: A.run.id, to: B.run.id, tau: r6(tau), depth: dOther, leg1: wc.leg1, leg2: wc.leg2, area: wc.area, tri, hostCab: hc || null });

let used = sumW(L, row, ordered) + (tail ? R.frontT : 0);
let rest = rw.end - rw.start - used;
if (cells.length && L.run.autoFiller && rest > tol && rest <= maxFiller) {
  let wf = rest;
  if (L.wallInfo && L.wallInfo.arc && !L.island) {   // on a curve a filler also adds the wedge on either side of it: take the widest one that still fits the span
    const span = rw.end - rw.start - (tail ? R.frontT : 0);
    const fits = (v) => sumW(L, row, [...ordered, { kind: 'filler', w: v, depth: 0 }]) <= span + tol;
    if (!fits(wf)) { let lo = 0, hi = wf; for (let k = 0; k < 30; k++) { const mid = (lo + hi) / 2; if (fits(mid)) lo = mid; else hi = mid; } wf = lo; }
  }
  if (wf < tol) wf = 0;
  const f = wf > 0 ? { kind: 'filler', w: r6(wf), auto: true, row, height: fillerHeight(ordered, R), depth: 0 } : null;
  if (!f) { /* no room for a filler on this curve */ } else {
  if (rw.cornerEnd) ordered.splice(ordered.length - 1, 0, f); else ordered.push(f);   // beside a corner cabinet the filler goes before it
  used += f.w; rest = r6(rest - f.w);
  }
}

let x = rw.start;
for (const c of ordered) {
  if (c === rw.cornerEnd) x = Math.max(x, rw.end - c.w);   // the corner cabinet sits IN the corner, whatever is left over is before it
  c.x = r6(x); x += c.w;

if (clashes(0)) {
  let lo = 0, hi = conv(600, unit);
  if (!clashes(hi)) { for (let k = 0; k < 40; k++) { const mid = (lo + hi) / 2; if (clashes(mid)) lo = mid; else hi = mid; } shift = hi; }
}
if (shift > 0) { st = stepArc(g, items, { from: rw.start + shift, to: rw.end }); rw.arcShift = r6(shift); }

cs.push({ run: L.run.id, wall: L.wall, x0: r6(x0 - ov(ends.start)), x1: r6(x1 + ov(ends.end)), y0: r6(-seat), depth, cabs: seg.length, ids: seg.map((c) => c.no), ends, length: r6(x1 - x0 + ov(ends.start) + ov(ends.end)), width: r6(depth + p.counter.front + seat) });

const back = run.flatMap((c) => [c.arcCorners.bl, c.arcCorners.br]);
const fr = run.map((c) => { const d = c.kind === 'cab' ? (depthOf ? depthOf(c) : c.cab.d) : (L.rows.base.depth || 0); const n = c.pf.n, u = c.pf.u; return [ { x: c.pf.o.x + n.x * (d + f), y: c.pf.o.y + n.y * (d + f) }, { x: c.pf.o.x + u.x * c.w + n.x * (d + f), y: c.pf.o.y + u.y * c.w + n.y * (d + f) } ]; });
const poly = [...back, ...fr.slice().reverse().flatMap(([l, r]) => [r, l])].map((q) => [r6(q.x), r6(q.y)]);
const area = Math.abs(poly.reduce((q, pt, k) => { const nx = poly[(k + 1) % poly.length]; return q + pt[0] * nx[1] - nx[0] * pt[1]; }, 0)) / 2;
const xs = poly.map((q) => q[0]), ys = poly.map((q) => q[1]);
cs.push({ run: L.run.id, wall: L.wall, world: true, poly, x0: Math.min(...xs), x1: Math.max(...xs), y0: Math.min(...ys), y1: Math.max(...ys), depth, cabs: seg.length, ids: seg.map((c) => c.no), ends, length: r6(run.reduce((q, c) => q + c.w, 0)), width: r6(depth + f), area: r6(area) });

const d = depthOf ? depthOf(c) : c.cab.d, f = p.counter.front, w = c.cab.w, a = w - d;
let pts = c.turn === 'l' ? [[0, 0], [w, 0], [w, w], [a - f, w], [a - f, d + f], [0, d + f]] : [[0, 0], [w, 0], [w, w], [a - f * Math.SQRT2, w], [0, d + f * Math.SQRT2]];
if (c.turn === 'diag' && c.tau && Math.abs(c.tau - 90) >= 0.01) {   // at another angle: the outline of diagAt with its front pushed out by the overhang
  const dg = diagAt(c.tau, w, d), dx = dg.FB[0] - dg.FA[0], dy = dg.FB[1] - dg.FA[1], ln = Math.hypot(dx, dy) || 1, nx = dy / ln, ny = -dx / ln;   // the front's normal away from the corner
  const sgn = (nx * (dg.Q[0] - dg.FA[0]) + ny * (dg.Q[1] - dg.FA[1])) > 0 ? -1 : 1;
  pts = [[0, 0], dg.P1, dg.P2, [dg.FB[0] + sgn * nx * f, dg.FB[1] + sgn * ny * f], [dg.FA[0] + sgn * nx * f, dg.FA[1] + sgn * ny * f]];
}
if (c.corner === 'start') pts = pts.map(([x, y]) => [w - x, y]).reverse();
pts = pts.map(([x, y]) => [r6(c.x + x), r6(y)]);
const area = Math.abs(pts.reduce((q, pt, i) => { const n = pts[(i + 1) % pts.length]; return q + pt[0] * n[1] - n[0] * pt[1]; }, 0)) / 2;
const xs = pts.map((q) => q[0]), ys = pts.map((q) => q[1]), side = Math.sqrt(area);
cs.push({ run: L.run.id, wall: L.wall, corner: c.turn, cab: c.no, poly: pts, x0: Math.min(...xs), x1: Math.max(...xs), y0: Math.min(...ys), y1: Math.max(...ys), depth: d, cabs: 1, ids: [c.no], ends: { start: 'wall', end: 'wall' }, length: r6(side), width: r6(side), area: r6(area) });

  const a = L.wallInfo.a, u = L.wallInfo.frame.u, qs = Object.values(c.arcCorners).map((q) => (q.x - a.x) * u.x + (q.y - a.y) * u.y);
  c.ext = [r6(Math.min(...qs)), r6(Math.max(...qs))];
} else c.ext = [c.x, r6(c.x + c.w)];

function panelHeight(cell, R) {
  if (!cell || cell.kind !== 'cab') return 0;
  const kick = cell.cab.type === 'wall' || R.kick === 'none' ? 0 : R.kickH;
  return r6(cell.cab.h - kick);
}

export const toWorld = (frame, s, o) => ({ x: r6(frame.o.x + frame.u.x * s + frame.n.x * o), y: r6(frame.o.y + frame.u.y * s + frame.n.y * o) });

export function footprints(build) {
  const { layout, R, F, project } = build;
  const out = [];
  const byNo = new Map(build.cells.map((c) => [c.no, c]));
  for (const L of layout.runs) for (const row of ['base', 'upper']) for (const c of L.rows[row].cells) {
    if (c.kind === 'gap' || c.kind === 'filler') continue;
    let local;
    let z0 = 0, z1 = 0;
    if (c.kind === 'endpanel') { const sx = c.pf ? 0 : c.x; local = [[[sx, 0], [sx + c.w, 0], [sx + c.w, c.depth], [sx, c.depth]]]; z1 = c.height; }
    else {
      const b = byNo.get(c.no);
      const sx = c.pf ? 0 : c.x;
      if (c.curved) local = null;
      else if (b && b.corner) local = b.corner.footprint.map((poly) => poly.map(([x, y]) => [sx + x, y]));
      else {
        const depth = c.cab.d;   // the carcass (and frame): doors stand a few mm proud at a corner, which is what a filler is for
        local = [[[sx, 0], [sx + c.w, 0], [sx + c.w, depth], [sx, depth]]];
      }
      z0 = c.cab.elev || 0; z1 = z0 + c.cab.h;
    }
    const fr = c.pf || L.frame;
    const pieces = local ? local.map((poly) => poly.map(([s, o]) => { const p = toWorld(fr, s, o); return [p.x, p.y]; })) : c.curved.slices;   // a curved-front cabinet: its ring sector in convex slices
    const xs = pieces.flat().map((p) => p[0]), ys = pieces.flat().map((p) => p[1]);
    out.push({ no: c.no, run: L.run.id, island: L.island ? L.island.id : null, row, kind: c.kind, cell: c, pieces, bbox: [Math.min(...xs), Math.min(...ys), Math.max(...xs), Math.max(...ys)], z0, z1 });
  }
  void F; void project;
  return out;
}

/** Penetration depth of two convex polygons (separating axis test); 0 when they only touch or are apart. */
export function overlap(A, B) {
  let best = Infinity;
  for (const poly of [A, B]) {
    for (let i = 0; i < poly.length; i++) {
      const p = poly[i], q = poly[(i + 1) % poly.length];
      const nx = q[1] - p[1], ny = p[0] - q[0], len = Math.hypot(nx, ny);
      if (len < 1e-9) continue;
      const proj = (P) => { let lo = Infinity, hi = -Infinity; for (const [x, y] of P) { const v = (x * nx + y * ny) / len; if (v < lo) lo = v; if (v > hi) hi = v; } return [lo, hi]; };
      const [a0, a1] = proj(A), [b0, b1] = proj(B);
      const o = Math.min(a1, b1) - Math.max(a0, b0);
      if (o <= 1e-6) return 0;
      if (o < best) best = o;
    }
  }
  return Number.isFinite(best) ? best : 0;
}

export function rectGap([ax0, ay0, ax1, ay1], [bx0, by0, bx1, by1]) {
  const dx = Math.max(bx0 - ax1, ax0 - bx1, 0), dy = Math.max(by0 - ay1, ay0 - by1, 0);
  return Math.hypot(dx, dy);
}

/** Distance between two sets of convex polygons (0 when they touch or overlap). */
export function polyGap(setA, setB) {
  const segDist = (p, 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, ((p[0] - a[0]) * dx + (p[1] - a[1]) * dy) / L2)) : 0; return Math.hypot(p[0] - a[0] - t * dx, p[1] - a[1] - t * dy); };
  let best = Infinity;
  for (const A of setA) for (const B of setB) {
    if (overlap(A, B) > 0) return 0;
    for (const [P, Q] of [[A, B], [B, A]]) for (const p of P) for (let i = 0; i < Q.length; i++) best = Math.min(best, segDist(p, Q[i], Q[(i + 1) % Q.length]));
  }
  return best === Infinity ? 0 : best;
}