Interior elevations and their dimensions

function middle(poly) {
  // the middle of the room's box (the cut runs through it): robust for L-shaped rooms too
  let x0 = Infinity, y0 = Infinity, x1 = -Infinity, y1 = -Infinity;
  for (const p of poly) { x0 = Math.min(x0, p[0]); y0 = Math.min(y0, p[1]); x1 = Math.max(x1, p[0]); y1 = Math.max(y1, p[1]); }
  return [(x0 + x1) / 2, (y0 + y1) / 2];
}

/** One wall of a room, seen from inside it. room = { poly (plan, the room's inside outline), name }. */
export function interiorView(elements, room, side, { height = 2438.4, past = 50, res = 1400 } = {}) {
  const dir = LOOK[side], right = [dir[1], -dir[0]];
  if (!dir || !room?.poly?.length) return { lines: [], cuts: [], bounds: null, n: 0 };
  const xs = room.poly.map((p) => dot(p, right)), ds = room.poly.map((p) => dot(p, dir));
  const o = middle(room.poly), d0 = dot(o, dir), d1 = Math.max(...ds) + past;
  const x0 = Math.min(...xs), x1 = Math.max(...xs);
  // wall to wall and floor to ceiling, with room for the cut walls, the floor and the ceiling round it
  const box = { x0: x0 - 400, x1: x1 + 400, y0: -350, y1: height + 350 };
  const v = projectView(elements, { dir, cut: { o }, far: d1 - d0, box, res });
  return { ...v, side, dir, d0, d1, frame: { x0, x1, y0: 0, y1: height }, ground: true, room: room.name || '' };
}

/** The notes a view carries (see the header). Never throws on what it can't place: it leaves that note out. */
export function viewNotes(view, ctx = {}) {
  const out = [], b = view?.bounds;
  if (!b) return out;
  const fmt = ctx.fmt || ((mm) => String(Math.round(mm)));
  const dir = ctx.dir || view.dir, right = [dir[1], -dir[0]];
  const X = (p) => dot(p, right);
  const base = ctx.base || 0;
  if (ctx.kind === 'interior') {
    const f = view.frame;
    if (f && f.x1 - f.x0 > 1) out.push({ t: 'dim', a: [f.x0, f.y0], b: [f.x1, f.y0], off: -8, text: fmt(f.x1 - f.x0) });
    if (f && f.y1 - f.y0 > 1) out.push({ t: 'dim', a: [f.x0, f.y0], b: [f.x0, f.y1], off: 8, text: fmt(f.y1 - f.y0) });
    const inRange = (p, past = 1) => { const d = dot(p, dir); return d >= (ctx.d0 ?? view.d0) - 1 && d <= (ctx.d1 ?? view.d1) + past; };
    for (const o of ctx.openings || []) {
      // a door or window in the wall it looks at (its centre line lies inside that wall: up to a wall's thickness past its face)
      if (!o.mark || !inRange(o.at, 400) || (o.face && dot(o.face, dir) > -0.5 && dot(o.face, dir) < 0.5)) continue;
      const x = X(o.at);
      if (x < f.x0 - 1 || x > f.x1 + 1) continue;
      out.push({ t: 'tag', x, y: (o.z0 + o.z1) / 2, s: o.mark, shape: o.kind === 'door' ? 'box' : 'hex' });
    }
    for (const it of ctx.items || []) {
      if (!it.tag || !inRange(it.at)) continue;
      const x = X(it.at);
      if (x < f.x0 - 1 || x > f.x1 + 1) continue;
      out.push({ t: 'tag', x, y: Math.max(150, (it.z || 0) + (it.h || 900) / 2), s: String(it.tag), shape: 'circle' });
    }
    return out;
  }
  // elevations and sections: the levels that fall in the view
  const lv = (ctx.levels || []).map((l) => ({ ...l, y: l.elevation - base })).filter((l) => l.y >= b.y0 - 1 && l.y <= b.y1 + 600).sort((p, q) => p.y - q.y);
  const xr = b.x1 + 600;
  for (const l of lv) out.push({ t: 'level', y: l.y, x0: b.x0 - 300, x1: xr, name: l.name, text: fmt(l.elevation) });
  for (let i = 0; i + 1 < lv.length; i++) if (lv[i + 1].y - lv[i].y > 1) out.push({ t: 'dim', a: [b.x0, lv[i].y], b: [b.x0, lv[i + 1].y], off: 12, text: fmt(lv[i + 1].y - lv[i].y) });
  if (ctx.kind === 'elevation') {
    // the building's width (its walls, not the ground round it), under the ground line
    const w = ctx.width || (view.content || b);
    if (w.x1 - w.x0 > 1) out.push({ t: 'dim', a: [w.x0, b.y0], b: [w.x1, b.y0], off: -10, text: fmt(w.x1 - w.x0) });
    for (const o of ctx.openings || []) {
      // tags only on the walls that face the viewer (an elevation shows those)
      if (!o.mark || !o.face || dot(o.face, dir) > -0.7) continue;
      out.push({ t: 'tag', x: X(o.at), y: (o.z0 + o.z1) / 2, s: o.mark, shape: o.kind === 'door' ? 'box' : 'hex' });
    }
  }
  return out;
}

/** The plan facts viewNotes needs about doors and windows, from model-ops.js snapshotModel openings and their walls. */
export function openingFacts(openings, walls, geom) {
  const out = [];
  for (const o of openings || []) {
    const w = (walls || []).find((x) => x.id === o.wall);
    if (!w) continue;
    const g = geom(w), s = o.offset + o.width / 2, at = g.at(s, 0), n = g.normal(s);
    const ext = w.extSide === 'right' ? -1 : 1;   // the wall's outside: its left (+n) or its right
    out.push({ mark: o.mark, kind: o.kind, at, z0: o.sill, z1: o.sill + o.height, face: [n[0] * ext, n[1] * ext], storey: w.storey, wall: w.guid, base: w.baseOffset || 0 });
  }
  return out;
}

const sc = scaleFor(W, H, [cw - 40, ch - 30], units);
const k = 1 / sc.ratio;
const placed = [];
shown.forEach((v, i) => {
  const col = i % 2, row = Math.floor(i / 2);
  const x = m + col * cw, y = m + strip + (1 - row) * ch;   // first row on top
  const b = v.view.bounds, ox = x + 22 + (cw - 40 - (b.x1 - b.x0) * k) / 2 - b.x0 * k, oy = y + 16 + (ch - 30 - (b.y1 - b.y0) * k) / 2 - b.y0 * k;
  const P = (q) => [ox + q[0] * k, oy + q[1] * k];

/** Where a drag puts the item: { x, y, rot }. */
function dragTo(d, p, e) {
  const it = d.item;
  if (d.kind === 'rot') {
    const a = Math.atan2(p[1] - it.y, p[0] - it.x) / D2R, step = e?.shiftKey ? 1 : 15;
    return { x: it.x, y: it.y, rot: Math.round(a / step) * step };
  }
  const want = [it.x + p[0] - d.from[0], it.y + p[1] - d.from[1]];
  const s = A.snapFrom(want, e, [it.x, it.y]);
  return { x: s.p[0], y: s.p[1], rot: it.rot, snap: s };
}

const height = levels[i + 1] ? levels[i + 1].elevation - lv.elevation : lv.height;
const w = writer();
const facts = openingFacts(data.openings.filter((o) => o.storey === lv.id), data.walls, wallGeom);
const pl = w.placements(), its = placedItems(w, lv.id).map((p) => { const r = pl.find((x) => x.id === p.id); return { tag: p.itemNumber, at: [p.x, p.y], z: p.z, h: Number(r?.equipment?.Height || 0) * w.unitMm || 900 }; });