Erection plan: picks, crane loads and times

/** A chart row list cleaned: numbers only, sorted by radius, a capacity that does not rise with radius. */
export function cleanChart(rows) {
  const out = [];
  for (const r of Array.isArray(rows) ? rows : []) {
    const radius = Number(r?.radius), kg = Number(r?.kg);
    if (Number.isFinite(radius) && Number.isFinite(kg) && radius > 0 && radius <= 500 && kg >= 0 && kg <= 5e6) out.push({ radius, kg });
  }
  out.sort((a, b) => a.radius - b.radius);
  for (let i = 1; i < out.length; i++) if (out[i].kg > out[i - 1].kg) out[i] = { radius: out[i].radius, kg: out[i - 1].kg };
  return out.slice(0, 200);
}

export function capacityAt(chart, radiusM) {
  if (!chart?.length || !(radiusM >= 0)) return 0;
  if (radiusM > chart[chart.length - 1].radius + 1e-9) return 0;
  for (const row of chart) if (radiusM <= row.radius + 1e-9) return row.kg;   // the first row at or beyond the radius
  return 0;
}

const weight = parts.reduce((t, q) => t + q.weight, 0);
// the centre of gravity of the assembly: weight-weighted centres of its parts (bolts and welds add to the rigging percentage, not here)
const cg = [0, 1, 2].map((i) => parts.reduce((t, q, k) => t + q.weight * (bx[k].a[i] + bx[k].b[i]) / 2, 0) / (weight || 1));

const tierOf = (k) => {
  if (k.type === 'column') return Math.max(0, levels.filter((z) => z <= k.lo[2] + tol).length - 1);
  return Math.max(0, levels.filter((z) => z < k.cg[2] - tol).length - 1);
};

const load0 = k.weight * (1 + setup.riggingPct / 100);
const checks = cranes.map((c) => {
  const ld = laydownFor(c);
  const rPick = dist2(c.at, ld) / 1000, rSet = dist2(c.at, setAt) / 1000;
  const radius = Math.max(rPick, rSet);
  const cap = capacityAt(c.chart, radius);
  const load = load0 + c.deductKg;
  const hookNeed = k.hi[2] + setup.headroom + setup.clearance;
  return { crane: c, rPick, rSet, radius, cap, load, util: cap > 0 ? load / cap : Infinity, hookNeed, hookOk: !c.hookHeight || hookNeed <= c.hookHeight, reach: radius <= c.chart[c.chart.length - 1].radius + 1e-9, ld };
});

const travel = (Math.hypot(pick.ld[0] - setAt[0], pick.ld[1] - setAt[1], 0) + Math.max(0, k.hi[2] - 0)) / 1000;   // a straight lift and carry, metres
const minutes = c.hookMin + travel / c.speed + c.setMin + c.releaseMin;
const ready = Math.max(0, ...[...deps.get(k.id)].map((d) => finish.get(d) ?? 0));
const start = Math.max(free.get(c.id), ready);
const end = start + minutes;

const status = !pick.reach || pick.cap <= 0 ? 'out' : pick.util > 1 ? 'over' : pick.util > setup.limit ? 'high' : !pick.hookOk ? 'hook' : 'ok';

function summaryOf(list, nCranes) {
  const heavy = list.reduce((a, p) => (!a || p.weight > a.weight ? p : a), null);
  const tight = list.reduce((a, p) => (!a || p.util > a.util ? p : a), null);
  return {
    picks: list.length, cranes: nCranes, minutes: list.reduce((t, p) => Math.max(t, p.end), 0), totalKg: list.reduce((t, p) => t + p.weight, 0),
    heaviest: heavy ? { id: heavy.id, mark: heavy.mark, kg: heavy.weight } : null, tightest: tight && Number.isFinite(tight.util) ? { id: tight.id, mark: tight.mark, util: tight.util } : null,
    over: list.filter((p) => p.status === 'over' || p.status === 'out' || p.status === 'hook').length, high: list.filter((p) => p.status === 'high').length,
  };
}

const vars = { mark: labelOf(p.id), kg: Math.round(p.weight), load: Math.round(p.load), r: r1(p.radius), cap: Math.round(p.capacity), pct: Math.round(p.util * 100), limit: Math.round(pl.setup.limit * 100), hook: Math.round(p.hookNeed / 10) / 100 };

/** What the movie player draws: the phases' picks in order with their routes, the boxes, the cranes (plain JSON, mm, z up). */
export function movieData(pl, { title = '' } = {}) {
  const members = [];
  for (const p of pl.picks) {
    for (const b of p.boxes || []) members.push({ pick: p.n, type: b.type, a: b.a.map(Math.round), b: b.b.map(Math.round), u: b.u, v: b.v, w: Math.round(b.w), d: Math.round(b.d), voff: Math.round(b.voff) });
  }
  return {
    format: 'cadcraft-erection', version: 1, title,
    cranes: pl.cranes.map((c) => ({ id: c.id, name: c.name, at: c.at, hookHeight: c.hookHeight, chart: c.chart })),
    picks: pl.picks.map((p) => ({
      n: p.n, mark: p.mark, type: p.type, profile: p.profile, phase: p.phase, kg: Math.round(p.weight), crane: p.crane, from: p.pickAt.map(Math.round), to: p.setAt.map(Math.round),
      top: Math.round(p.top), radius: r1(p.radius), cap: Math.round(p.capacity), pct: Number.isFinite(p.util) ? Math.round(p.util * 100) : null, status: p.status,
      t0: Math.round(p.start * 100) / 100, t1: Math.round(p.end * 100) / 100, h: r2(p.hookMin), tr: r2(p.travelMin), cg: p.cg.map(Math.round),
    })),
    members, minutes: pl.summary.minutes,
  };
}