Installation loads and cable lengths

/** Metres per drawing unit (doc.meta.units, the DXF $INSUNITS names; unitless = millimetres, as CadCraft's 3D reads it). */
export const UNIT_M = { '': 0.001, inches: 0.0254, feet: 0.3048, millimeters: 0.001, centimeters: 0.01, meters: 1, yards: 0.9144 };

const num = (v) => { const n = parseFloat(String(v ?? '').replace(',', '.')); return Number.isFinite(n) ? n : NaN; };

/** Library items placed by CadCraft (CC-ELEC-* attributes) as loads: watts or null. */
export function libraryLoad(attrs) {
  const kw = num(attrs['CC-ELEC-KW']);
  if (kw > 0) return kw * 1000;
  const amps = num(attrs['CC-ELEC-AMPS']), volts = num(attrs['CC-ELEC-VOLTS']);
  if (amps > 0 && volts > 0) { const ph = num(attrs['CC-ELEC-PHASE']); return amps * volts * (ph === 3 ? Math.sqrt(3) : 1); }
  const hp = num(attrs['CC-ELEC-HP']);
  if (hp > 0) return hp * 746;
  return null;
}

for (const l of loads) if (l.circuit) { const c = get(l.circuit); c.loads.push(l); c.watts += l.watts; }
for (const c of circuits.values()) {
  c.board = boards.find((b) => b.tag && b.tag === c.boardTag) || (boards.length === 1 ? boards[0] : null);
  if (!c.def && c.board) c.voltage = c.board.voltage;
  c.amps = currentOf(c);

/** Current drawn by a circuit (A): single phase W / (V·pf); three phase ("3P", "L1L2L3") W / (√3·V·pf). */
export function currentOf(c) {
  const three = /^(3P|L1L2L3|3)$/i.test(c.phase);
  const v = c.voltage || 230;
  return c.watts / ((three ? Math.sqrt(3) : 1) * v * (c.pf || 1));
}

/** The trip current (mA) a circuit's RCD text names ("30 mA", "RCD1 0.03 A" is not read: write mA), or null. */
export function rcdMilliamps(text) {
  const m = /(\d+(?:[.,]\d+)?)\s*mA\b/i.exec(String(text || ''));
  return m ? parseFloat(m[1].replace(',', '.')) : null;
}

/** The route network of one space: nodes and edges, routes split where an end lands on another route. */
export function routeGraph(routes, { tol = 1e-6 } = {}) {
  const nodes = [], edges = [];
  const nodeAt = (p) => {
    for (const n of nodes) if (Math.hypot(n.x - p.x, n.y - p.y) <= tol) return n.i;
    nodes.push({ i: nodes.length, x: p.x, y: p.y, adj: [] });
    return nodes.length - 1;
  };
  // segments, with the extra points that land on them (other routes' ends)
  const segs = [];
  for (const r of routes) for (let i = 0; i + 1 < r.pts.length; i++) segs.push({ a: r.pts[i], b: r.pts[i + 1], cuts: [] });
  const ends = routes.flatMap((r) => [r.pts[0], r.pts[r.pts.length - 1]]);
  for (const s of segs) for (const p of ends) { const q = segDist2(p, s.a, s.b); if (q.d2 <= Math.max(tol, 1e-9) ** 2 && q.u > 1e-9 && q.u < 1 - 1e-9) s.cuts.push(q.u); }
  for (const s of segs) {
    const us = [0, ...[...new Set(s.cuts)].sort((x, y) => x - y), 1];
    for (let k = 0; k + 1 < us.length; k++) {
      const p = { x: s.a.x + (s.b.x - s.a.x) * us[k], y: s.a.y + (s.b.y - s.a.y) * us[k] }, q = { x: s.a.x + (s.b.x - s.a.x) * us[k + 1], y: s.a.y + (s.b.y - s.a.y) * us[k + 1] };
      const i = nodeAt(p), j = nodeAt(q), len = Math.hypot(q.x - p.x, q.y - p.y);
      if (i === j || len <= 0) continue;
      const e = { i, j, len, k: edges.length };
      edges.push(e);
      nodes[i].adj.push(e); nodes[j].adj.push(e);
    }
  }
  return { nodes, edges };
}

/** Attach a point to the graph: the nearest point on an edge within reach → a new node (the edge split). → node index or -1. */
export function attach(g, p, reach) {
  let best = null;
  for (const e of g.edges) {
    if (e.dead) continue;
    const a = g.nodes[e.i], b = g.nodes[e.j];
    const q = segDist2(p, a, b);
    if (q.d2 <= reach * reach && (!best || q.d2 < best.q.d2)) best = { e, q };
  }
  if (!best) return -1;
  const { e, q } = best;
  const drop = Math.sqrt(q.d2);
  let mid;
  if (q.u <= 1e-9) mid = e.i;
  else if (q.u >= 1 - 1e-9) mid = e.j;
  else {
    mid = g.nodes.length;
    g.nodes.push({ i: mid, x: q.q.x, y: q.q.y, adj: [] });
    e.dead = true;
    const a = { i: e.i, j: mid, len: e.len * q.u, k: g.edges.length }, b = { i: mid, j: e.j, len: e.len * (1 - q.u), k: g.edges.length + 1 };
    g.edges.push(a, b);
    g.nodes[e.i].adj = g.nodes[e.i].adj.filter((x) => x !== e).concat(a);
    g.nodes[e.j].adj = g.nodes[e.j].adj.filter((x) => x !== e).concat(b);
    g.nodes[mid].adj.push(a, b);
  }
  // the drop from the point to the route
  const n = g.nodes.length;
  g.nodes.push({ i: n, x: p.x, y: p.y, adj: [] });
  const d = { i: n, j: mid, len: drop, k: g.edges.length, drop: true };
  g.edges.push(d);
  g.nodes[n].adj.push(d); g.nodes[mid].adj.push(d);
  return n;
}

/** Shortest paths from one node (Dijkstra). → {dist[], via[] (edge index)}. */
export function shortest(g, from) {
  const dist = new Array(g.nodes.length).fill(Infinity), via = new Array(g.nodes.length).fill(-1), done = new Array(g.nodes.length).fill(false);
  dist[from] = 0;
  for (;;) {
    let u = -1;
    for (let i = 0; i < dist.length; i++) if (!done[i] && dist[i] < Infinity && (u < 0 || dist[i] < dist[u])) u = i;
    if (u < 0) break;
    done[u] = true;
    for (const e of g.nodes[u].adj) {
      if (e.dead) continue;
      const v = e.i === u ? e.j : e.i;
      if (dist[u] + e.len < dist[v]) { dist[v] = dist[u] + e.len; via[v] = e.k; }
    }
  }
  return { dist, via };
}

/**
 * Cable length of every circuit, in metres. opts: reach (drawing units; default 0.5 m), atDevice / atBoard (metres added
 * at each device and at the board; defaults 0.5 and 1). → Map circuit name → {metres, routed (bool), unreached [load],
 * reason ('no-board' | 'no-route' | '')}.
 */
export function cableLengths(doc, model, inst, { reach, atDevice = 0.5, atBoard = 1 } = {}) {
  const mpu = mPerUnit(doc.meta.units);
  reach = reach ?? 0.5 / mpu;
  const out = new Map();
  for (const c of inst.circuits.values()) {
    if (!c.loads.length) { out.set(c.name, { metres: 0, routed: false, unreached: [], reason: '' }); continue; }
    if (!c.board) { out.set(c.name, { metres: 0, routed: false, unreached: c.loads, reason: 'no-board' }); continue; }
    const sp = c.board.space;
    const g = routeGraph(model.routes.filter((r) => r.space.key === sp.key));   // by key: inst may come from another scan of the drawing
    const start = attach(g, c.board.at, reach);
    if (start < 0) { out.set(c.name, { metres: 0, routed: false, unreached: c.loads, reason: 'no-route' }); continue; }
    const targets = c.loads.map((l) => ({ l, n: l.space.key === sp.key ? attach(g, l.at, reach) : -1 }));
    const { dist, via } = shortest(g, start);
    const used = new Set(), unreached = [];
    for (const { l, n } of targets) {
      if (n < 0 || dist[n] === Infinity) { unreached.push(l); continue; }
      for (let v = n; v !== start;) { const e = g.edges[via[v]]; used.add(e.k); v = e.i === v ? e.j : e.i; }
    }
    let len = 0;
    for (const k of used) len += g.edges[k].len;
    const reached = targets.length - unreached.length;
    const metres = reached ? len * mpu + reached * atDevice + atBoard : 0;
    out.set(c.name, { metres, routed: reached > 0, unreached, reason: unreached.length ? 'no-route' : '' });
  }
  return out;
}