Duct runs, fittings and schedule

/** A move / rotate / scale / mirror (matrix [a, b, c, d, e, f]) baked into the run: points move, sizes stay, drawn widths follow a scale. */
export function transformDuct(d, m) {
  const out = structuredClone(d);
  out.pts = d.pts.map(([x, y]) => [m[0] * x + m[2] * y + m[4], m[1] * x + m[3] * y + m[5]]);
  const sc = Math.sqrt(Math.abs(m[0] * m[3] - m[1] * m[2]));
  if (sc > 1e-12 && Math.abs(sc - 1) > 1e-12) { out.k = d.k / sc; out.z = d.z * sc; }
  out.links = { taps: [], s: null, e: null };   // worked out again from where everything is now
  return out;
}

/** Plan width and height of a section in drawing units. */
export const planW = (d, s) => s.w / d.k;

/**
 * Work out branches: a run's end on another run's centreline (not at its ends) is a branch there. runs = [{ id, data }].
 * → Map id → { taps, s, e } (drawing units; `at` along the main's segment, `cut` = how far the branch stops short of the
 * main's centreline: half the main's width over the sine of the angle between them).
 */
export function linkRuns(runs) {
  const out = new Map(runs.map((r) => [r.id, { taps: [], s: null, e: null }]));
  for (const B of runs) {
    const bs = segsOf(B.data.pts);
    if (!bs.length) continue;
    for (const end of ['s', 'e']) {
      const seg = end === 's' ? bs[0] : bs[bs.length - 1];
      const p = end === 's' ? seg.a : seg.b;
      const into = end === 's' ? seg.t : { x: -seg.t.x, y: -seg.t.y };   // pointing from the joint into the branch
      const tol = 1e-7 * Math.max(1, Math.abs(p.x), Math.abs(p.y));
      for (const A of runs) {
        if (A === B) continue;
        const near = nearestOnPath(A.data.pts, p);
        const total = pathLength(A.data.pts);
        if (!near || near.dist > tol || near.s <= tol || near.s >= total - tol) continue;
        const ga = segsOf(A.data.pts)[near.seg];
        const cr = ga.t.x * into.y - ga.t.y * into.x, sin = Math.abs(cr);
        if (sin < 0.2) continue;   // running along the main, not off it
        const ms = A.data.segs[near.seg], bsec = B.data.segs[end === 's' ? 0 : B.data.segs.length - 1];
        const ang = Math.round((Math.asin(Math.min(1, sin)) * 180) / Math.PI * 10) / 10;
        const kind = bsec.s !== 'rect' ? 'takeoff' : Math.abs(90 - ang) <= 15 ? 'tee' : 'lateral';
        out.get(B.id)[end] = { on: A.id, cut: planW(A.data, ms) / 2 / sin, ang, kind, main: { s: ms.s, w: ms.w, h: ms.h } };
        out.get(A.id).taps.push({ seg: near.seg, at: near.at, w: planW(B.data, bsec) / sin, side: cr > 0 ? 1 : -1, by: B.id });
        break;
      }
    }
  }
  for (const l of out.values()) l.taps.sort((a, b) => a.seg - b.seg || a.at - b.at);
  return out;
}

/**
 * The run's fittings and straight pieces (drawing units). Elbows sit on turns (radius: centreline radius r × the width,
 * tangent length R·tan(θ/2); mitred: W/2·tan(θ/2)); a size change makes a transition just downstream of the corner (after
 * its elbow), as long as its sides need to slope no more than TRANSITION_DEG; a branch end is cut back to the main's side
 * and gets a collar. → { segs, pieces [{seg, s0, s1}], elbows, transitions, taps, problems }
 */
export function layoutDuct(d) {
  const G = segsOf(d.pts), n = G.length;
  const trimS = new Array(n).fill(0), trimE = new Array(n).fill(0);
  const elbows = [], transitions = [], problems = [];
  const minT = MIN_TRANSITION[d.u] / d.k, tanA = Math.tan((TRANSITION_DEG * Math.PI) / 180);
  for (let i = 1; i < n; i++) {
    const A = G[i - 1], B = G[i], sa = d.segs[i - 1], sb = d.segs[i];
    const turn = turnOf(A.t, B.t), theta = Math.abs(turn);
    if (theta > (179 * Math.PI) / 180) { problems.push({ kind: 'hairpin', at: i }); continue; }
    if (theta > Math.PI / 180) {
      const W = planW(d, sa);
      const mitred = d.elbow === 'mitred';
      const R = mitred ? 0 : d.r * W;
      const T = mitred ? (W / 2) * Math.tan(theta / 2) : R * Math.tan(theta / 2);
      trimE[i - 1] += T; trimS[i] += T;
      elbows.push({ at: i, V: A.b, tin: A.t, tout: B.t, theta, side: turn >= 0 ? 1 : -1, R, T, sec: sa, mitred, len: mitred ? 2 * T : R * theta });
    }
    if (!same(sa, sb)) {
      const dW = Math.abs(sa.w - sb.w) / 2, dH = Math.abs(sa.h - sb.h);   // flat bottom: the top takes the whole height change
      const L = Math.max(Math.max(dW, dH) / tanA / d.k, minT);
      transitions.push({ seg: i, s: trimS[i], len: L, from: sa, to: sb });
      trimS[i] += L;
    }
  }
  const taps = [];
  for (const end of ['s', 'e']) {
    const l = d.links?.[end];
    if (!l || !n) continue;
    const i = end === 's' ? 0 : n - 1, sec = d.segs[i];
    const c = COLLAR[d.u] / d.k;
    if (end === 's') trimS[0] = Math.max(trimS[0], l.cut); else trimE[n - 1] = Math.max(trimE[n - 1], l.cut);
    taps.push({ end, seg: i, cut: l.cut, collar: c, sec, kind: l.kind, ang: l.ang, main: l.main || null });
  }
  const pieces = G.map((g, i) => {
    const s0 = trimS[i], s1 = g.len - trimE[i];
    if (s1 < s0 - 1e-9) problems.push({ kind: 'short', at: i });
    return { seg: i, s0, s1: Math.max(s0, s1) };
  });
  return { segs: G, pieces, elbows, transitions, taps, problems };
}

/** Length in drawing units → feet or metres; area of a perimeter (size units) over a length (drawing units) → ft² or m². */
const lenOut = (d, du) => (d.u === 'in' ? (du * d.k) / 12 : (du * d.k) / 1000);

const areaOut = (d, perim, du) => (d.u === 'in' ? (perim * du * d.k) / 144 : (perim * du * d.k) / 1e6);

const deg = Math.round((e.theta * 180) / Math.PI);
const p = section(e.sec.s, e.sec.w, e.sec.h).perimeter;
const name = e.mitred ? t('fit.elbow.mitred', { deg, size: sizeText(e.sec) })
  : t(e.sec.s === 'rect' ? 'fit.elbow.rect' : 'fit.elbow.round', { deg, size: sizeText(e.sec), r: fmtNum(d.r, 2) });
out.push({ kind: 'elbow', name, area: areaOut(d, p, e.len), sec: e.sec, x: e.V.x, y: e.V.y, deg });

const a = tr.from, b = tr.to, Ls = tr.len * d.k;   // size units
let area;
if (a.s === 'rect' && b.s === 'rect') {
  // four flat trapezoids (flat bottom, centred on plan): bottom (wa+wb)/2·L, top the same over its slope,
  // the two sides (ha+hb)/2 over the slope of the side wall
  const bot = ((a.w + b.w) / 2) * Ls, top = ((a.w + b.w) / 2) * Math.hypot(Ls, a.h - b.h);
  const sides = 2 * ((a.h + b.h) / 2) * Math.hypot(Ls, (a.w - b.w) / 2);
  area = bot + top + sides;
} else {
  // average perimeter × slant length: exact for a concentric round reducer (π (r1 + r2) s), close for the others
  const pa = section(a.s, a.w, a.h).perimeter, pb = section(b.s, b.w, b.h).perimeter;
  area = ((pa + pb) / 2) * Math.hypot(Ls, (Math.max(a.w, a.h) - Math.max(b.w, b.h)) / 2);
}
area = d.u === 'in' ? area / 144 : area / 1e6;

/** The straight pieces of one run: { sec, len (ft/m), area (ft²/m²), pts [[a], [b]] (drawing coordinates) }. */
export function straightsOf(d) {
  const L = layoutDuct(d);
  return L.pieces.filter((p) => p.s1 - p.s0 > 1e-9).map((p) => {
    const g = L.segs[p.seg], sec = d.segs[p.seg], du = p.s1 - p.s0;
    const a = at(g, p.s0), b = at(g, p.s1);
    return { sec, len: lenOut(d, du), area: areaOut(d, section(sec.s, sec.w, sec.h).perimeter, du), pts: [[a.x, a.y], [b.x, b.y]] };
  });
}

totals: { len: dl.reduce((s, r) => s + r.len, 0), area: dl.reduce((s, r) => s + r.area, 0) + fl.reduce((s, r) => s + r.area, 0), fittings: fl.reduce((s, r) => s + r.n, 0) },

/** A run with its sizes and airflows in the other unit system (in ↔ mm; cfm ↔ L/s), its geometry unchanged. */
export function convertRun(d, u) {
  if (d.u === u) return d;
  const f = u === 'mm' ? 25.4 : 1 / 25.4, fq = u === 'mm' ? 0.47194745 : 1 / 0.47194745;
  return { ...d, u, k: d.k * f, segs: d.segs.map((s) => ({ ...s, w: s.w * f, h: s.h * f, ...(s.q ? { q: s.q * fq } : {}) })) };
}

/** "24x12", "24 × 12", "Ø14", "14" → { w, h } in size units (round: w = h). null when it does not read. */
export function parseSize(text, shape) {
  const s = String(text ?? '').trim().replace(/^(ø|Ø|d|dia\.?)\s*/i, '');
  if (shape === 'round') { const d = Number(s); return Number.isFinite(d) && d > 0 ? { w: d, h: d } : null; }
  const m = /^(\d+(?:\.\d+)?)\s*[x×*]\s*(\d+(?:\.\d+)?)$/i.exec(s);
  if (!m) return null;
  const w = Number(m[1]), h = Number(m[2]);
  if (!(w > 0 && h > 0) || (shape === 'oval' && w < h)) return null;
  return { w, h };
}

/** A point inside a run's outline, pulled onto its centreline (to start or end a branch there). → { x, y, run } | null */
function onRun(doc, p, except = null) {
  let best = null;
  for (const r of runsIn(doc)) {
    if (except && r.data.id === except) continue;
    const n = nearestOnPath(r.data.pts, p);
    if (!n) continue;
    const W = planW(r.data, r.data.segs[n.seg]);
    if (n.dist <= W / 2 + 1e-9 && (!best || n.dist < best.dist)) best = { x: n.x, y: n.y, dist: n.dist, run: r };
  }
  return best;
}

// ---------------------------------------------------------------------------------------------- DUCTSCHED and tables
function tableRows(doc) {
  const runs = runsIn(doc).map((r) => r.data);
  if (!runs.length) return null;
  const S = schedule(runs), U = units(S.u);
  const rows = [[t('col.item'), t('col.qty'), t('col.area', { unit: U.area })]];
  for (const r of S.ducts) rows.push([r.name, fmtNum(r.len, 1) + ' ' + U.len, fmtNum(r.area, 1)]);
  for (const f of S.fittings) rows.push([f.name, String(f.n), fmtNum(f.area, 1)]);
  rows.push([t('row.total'), t('row.total.v', { len: fmtNum(S.totals.len, 1), lu: U.len, n: S.totals.fittings }), fmtNum(S.totals.area, 1)]);
  return { S, rows };
}

// ---------------------------------------------------------------------------------------------- files
function scheduleCsv(doc) {
  const runs = runsIn(doc).map((r) => r.data);
  if (!runs.length) throw new Error(t('err.noducts'));
  const S = schedule(runs), U = units(S.u);
  const rows = [[t('csv.ducts')], [t('col.item'), t('col.shape'), t('col.size', { unit: U.size }), t('col.mat'), t('col.len', { unit: U.len }), t('col.perimeter', { unit: U.size }), t('col.area', { unit: U.area })]];
  for (const r of S.ducts) rows.push([r.name, t('shape.' + r.sec.s), sizeText(r.sec), t('mat.' + r.mat), +r.len.toFixed(3), +r.perimeter.toFixed(3), +r.area.toFixed(3)]);
  rows.push([], [t('csv.fittings')], [t('col.item'), t('col.count'), t('col.areaeach', { unit: U.area }), t('col.area', { unit: U.area })]);
  for (const f of S.fittings) rows.push([f.name, f.n, +f.areaEach.toFixed(3), +f.area.toFixed(3)]);
  rows.push([], [t('csv.sections')], [t('col.tag'), t('col.system'), t('col.section'), t('col.size', { unit: U.size }), t('col.len', { unit: U.len }), t('col.q', { unit: U.q }), t('col.v', { unit: U.v }), t('col.rate', { unit: U.rate })]);
  for (const s of S.sections) rows.push([s.tag, t('sys.' + s.sys), s.seg + 1, sizeText(s.sec), +s.len.toFixed(3), s.q ?? '', s.V === null ? '' : +s.V.toFixed(u2(S.u)), s.rate === null ? '' : +s.rate.toFixed(4)]);
  rows.push([], [t('row.total'), '', '', '', +S.totals.len.toFixed(3), '', +S.totals.area.toFixed(3)]);
  return csv(rows);
}