Factory layout checks

export function corners(it) {
  const a = (it.rot * Math.PI) / 180, c = Math.cos(a), s = Math.sin(a), hx = it.w / 2, hy = it.d / 2;
  return [[-hx, -hy], [hx, -hy], [hx, hy], [-hx, hy]].map(([x, y]) => [it.x + x * c - y * s, it.y + x * s + y * c]);
}

/** The strips beside each side that must stay free: front = +Y, back = −Y, left = −X, right = +X (before turning). */
export function accessZones(it) {
  const a = (it.rot * Math.PI) / 180, c = Math.cos(a), s = Math.sin(a), hx = it.w / 2, hy = it.d / 2;
  const T = ([x, y]) => [it.x + x * c - y * s, it.y + x * s + y * c];
  const strip = (x0, y0, x1, y1) => [[x0, y0], [x1, y0], [x1, y1], [x0, y1]].map(T);
  return [
    { side: 'front', clear: it.clear.front, corners: strip(-hx, hy, hx, hy + it.clear.front) },
    { side: 'back', clear: it.clear.back, corners: strip(-hx, -hy - it.clear.back, hx, -hy) },
    { side: 'left', clear: it.clear.left, corners: strip(-hx - it.clear.left, -hy, -hx, hy) },
    { side: 'right', clear: it.clear.right, corners: strip(hx, -hy, hx + it.clear.right, hy) },
  ].filter((z) => z.clear > 0);
}

/** Do two convex polygons overlap by more than a sliver (touching edges do not count)? */
export function overlaps(A, B, tol = 1) {
  for (const P of [A, B]) for (const [p, q] of edges(P)) {
    const ax = [-(q[1] - p[1]), q[0] - p[0]], l = Math.hypot(...ax) || 1, n = [ax[0] / l, ax[1] / l];
    const [a0, a1] = project(A, n), [b0, b1] = project(B, n);
    if (a1 <= b0 + tol || b1 <= a0 + tol) return false;
  }
  return true;
}

const segDist = (p, a, b) => { const dx = b[0] - a[0], dy = b[1] - a[1], L2 = dx * dx + dy * dy, 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)); };

/** The least distance between two convex polygons that do not overlap. */
export function gap(A, B) {
  let best = Infinity;
  for (const p of A) for (const [a, b] of edges(B)) best = Math.min(best, segDist(p, a, b));
  for (const p of B) for (const [a, b] of edges(A)) best = Math.min(best, segDist(p, a, b));
  return best;
}

if (it.weight > 0 && floorLoad > 0) {
  const load = it.weight / (area(P) / 1e6);
  if (load > floorLoad) out.push({ code: 'floor-load', level: 'warning', items: [it.id], vars: { name: it.tag || it.name || it.id, load: Math.round(load), limit: floorLoad }, at: [it.x, it.y] });
}

/** Equipment from equip.js (unplaced): its box in plan is the footprint, turned about the place's point like the equipment is. */
export function itemFromEquipment(eq, place = {}) {
  if (!eq?.bbox) return null;
  const w = eq.bbox.max[0] - eq.bbox.min[0], d = eq.bbox.max[1] - eq.bbox.min[1];
  const cx = (eq.bbox.max[0] + eq.bbox.min[0]) / 2, cy = (eq.bbox.max[1] + eq.bbox.min[1]) / 2;
  const a = ((place.rot || 0) * Math.PI) / 180, c = Math.cos(a), s = Math.sin(a);
  return layoutItem({ id: place.id ?? '', name: place.name ?? eq.type, tag: place.tag, w, d, h: eq.bbox.max[2] - eq.bbox.min[2], weight: place.weight, x: (place.x || 0) + cx * c - cy * s, y: (place.y || 0) + cx * s + cy * c, rot: place.rot || 0, clear: place.clear });
}

export function flowLength(items, sequence) {
  const by = new Map((items || []).map(layoutItem).filter(Boolean).map((i) => [i.id, i]));
  let n = 0;
  for (let k = 1; k < sequence.length; k++) { const a = by.get(sequence[k - 1]), b = by.get(sequence[k]); if (a && b) n += Math.abs(a.x - b.x) + Math.abs(a.y - b.y); }
  return n;
}