Electrical devices: positions, loads and circuit amps

/** The nearest wall face within `reach` of p: the device's spot on it and the way it faces (into the room). */
export function wallSpot(walls, p, reach = 600) {
  let best = null;
  for (const w of walls) {
    const d = [w.b[0] - w.a[0], w.b[1] - w.a[1]], L = Math.hypot(...d);
    if (L < 1) continue;
    const u = [d[0] / L, d[1] / L], n = [-u[1], u[0]];
    const s = Math.max(0, Math.min(L, (p[0] - w.a[0]) * u[0] + (p[1] - w.a[1]) * u[1]));
    const off = (p[0] - w.a[0]) * n[0] + (p[1] - w.a[1]) * n[1];
    const side = off >= 0 ? 1 : -1, dist = Math.abs(Math.abs(off) - w.t / 2);
    const along = (p[0] - w.a[0]) * u[0] + (p[1] - w.a[1]) * u[1];
    if (along < -w.t || along > L + w.t || dist > reach) continue;
    if (!best || dist < best.dist) best = { wall: w.guid, side, offset: s, dist, at: spotOn(w, s, side), angle: Math.atan2(n[1] * side, n[0] * side) };
  }
  return best;
}

function spotOn(w, s, side) {
  const d = [w.b[0] - w.a[0], w.b[1] - w.a[1]], L = Math.hypot(...d) || 1, u = [d[0] / L, d[1] / L], n = [-u[1], u[0]];
  return [w.a[0] + u[0] * s + n[0] * side * w.t / 2, w.a[1] + u[1] * s + n[1] * side * w.t / 2];
}

// ------------------------------------------------------------------------------------------------------------ writing
function writeDevice(w, d, walls) {
  const D = DEVICES[d.kind];
  let at = d.at, ang = d.angle;
  const wall = d.wall ? walls.find((x) => x.guid === d.wall) : null;
  if (wall) { const L = Math.hypot(wall.b[0] - wall.a[0], wall.b[1] - wall.a[1]); const s = Math.min(Math.max(0, d.offset), L); at = spotOn(wall, s, d.side); const n = [-(wall.b[1] - wall.a[1]) / L, (wall.b[0] - wall.a[0]) / L]; ang = Math.atan2(n[1] * d.side, n[0] * d.side); }
  // local axes: x along the wall (the device's right), y out into the room; the placement turns +x to (sin, −cos)·…
  const deg = (ang * 180) / Math.PI - 90;
  const l = w.api.GetLine(w.mid, d.id, false);
  w.movePlacement(l.ObjectPlacement.value, at[0], at[1], 0, deg);
  const b = D.body;
  const solid = D.mount === 'wall' ? w.box(-b.w / 2, 0, d.height - b.h / 2, b.w / 2, b.d, d.height + b.h / 2) : w.box(-b.w / 2, -b.d / 2, d.height - b.h, b.w / 2, b.d / 2, d.height);
  const color = isBoard(d.kind) ? [0.55, 0.57, 0.6] : isLight(d.kind) ? [0.98, 0.95, 0.75] : [0.95, 0.95, 0.93];
  w.styleItem(solid, w.surfaceStyle(tr(isBoard(d.kind) ? 'res.style.panel' : 'res.style.device'), color, 0));
  w.setShape(d.id, [w.rep('body', 'Body', 'SweptSolid', [solid])]);
  w.upsertPset(d.id, ELEC_PSET, [['X', 'IFCLENGTHMEASURE', round(w.u(at[0]))], ['Y', 'IFCLENGTHMEASURE', round(w.u(at[1]))], ['Angle', 'IFCREAL', round((ang * 180) / Math.PI, 4)]]);
  return { at, angle: ang };
}

/** The ceiling of a level: its walls' usual height, else the level's height less 300 (a floor's depth). */
function ceilingOf(w, storey) {
  const ws = readWalls(w, storey);
  if (ws.length) { const hs = ws.map((x) => x.height).sort((a, b) => a - b); return hs[Math.floor(hs.length / 2)]; }
  const lv = readLevels(w).find((l) => l.id === storey);
  return Math.max(2000, (lv?.height || 2700) - 300);
}

/** Volts for the circuit schedule's amps: 120 / 240 in a feet-and-inches model, 230 / 400 in a metric one. */
export const voltsOf = (kind, units) => (kind === 'socket.3ph' ? (isMetric(units) ? 400 : 240) : /^(cooker|heater|evcharger)$/.test(kind) ? (isMetric(units) ? 230 : 240) : (isMetric(units) ? 230 : 120));

export function circuitSchedule(devs, { units = 'ftin', t = tr } = {}) {
  const map = new Map();
  for (const d of devs) {
    if (isBoard(d.kind)) continue;
    const c = d.circuit || '';
    if (!map.has(c)) map.set(c, { circuit: c, n: 0, watts: 0, volts: 0, kinds: new Map() });
    const r = map.get(c);
    r.n++; r.watts += d.load || 0; r.volts = Math.max(r.volts, voltsOf(d.kind, units));
    r.kinds.set(d.kind, (r.kinds.get(d.kind) || 0) + 1);
  }
  const list = [...map.values()].sort((a, b) => (a.circuit === '') - (b.circuit === '') || cmpTag(a.circuit, b.circuit));
  const rows = list.map((r) => [r.circuit || t('res.el.nocircuit'), String(r.n), [...r.kinds].map(([k, n]) => n + ' × ' + t('res.el.kind.' + k)).join(', '), String(Math.round(r.watts)), (r.watts / r.volts).toFixed(1), String(r.volts)]);   // i18n-ignore: a count
  const watts = list.reduce((s, r) => s + r.watts, 0);
  return { head: [t('res.el.sch.circuit'), t('res.el.sch.count'), t('res.el.sch.devices'), t('res.el.sch.load'), t('res.el.sch.amps'), t('res.el.sch.volts')], rows, total: [t('model.sch.total'), String(list.reduce((s, r) => s + r.n, 0)), '', String(Math.round(watts)), '', ''] };
}

// ------------------------------------------------------------------------------------------------------------ schedules
export function deviceSchedule(devs, levels, { fmtLen = (mm) => String(Math.round(mm)), t = tr } = {}) {
  const byGuid = new Map(devs.map((d) => [d.guid, d]));
  const rows = devs.map((d) => [d.tag, t('res.el.kind.' + d.kind), levels.find((l) => l.id === d.storey)?.name || '', d.circuit, d.load ? String(Math.round(d.load)) : '', fmtLen(d.height), d.controls.map((g) => byGuid.get(g)?.tag).filter(Boolean).join(', ')]);
  const watts = devs.reduce((s, d) => s + (d.load || 0), 0);
  return { head: [t('res.el.sch.tag'), t('res.el.sch.device'), t('res.el.sch.level'), t('res.el.sch.circuit'), t('res.el.sch.load'), t('res.el.sch.height'), t('res.el.sch.controls')], rows, total: [t('model.sch.total'), String(devs.length), '', '', String(Math.round(watts)), '', ''] };
}