Numbers in the frame analysis report

function fmt(v, d) {
  if (!Number.isFinite(v)) return '';
  const s = (Math.abs(v) < 0.5 * 10 ** -d ? 0 : v).toFixed(d);
  return s === '-0' || /^-0\.0*$/.test(s) ? s.slice(1) : s;
}

export const KN = (v) => fmt(v / 1000, 2);

export function reportData(model, sol, { n = 40 } = {}) {
  const prep = sol.prep;
  const secs = new Map(model.sections.map((s) => [s.id, s]));
  const sets = [];
  for (const [key, R] of Object.entries(sol.results)) {
    const reactions = [];
    model.supports.forEach((s) => {
      const k = prep.idx.get(s.node);
      reactions.push({ node: s.node, R: Array.from(R.reactions.subarray(6 * k, 6 * k + 6)) });
    });
    let maxDisp = { value: 0, node: null };
    model.nodes.forEach((nd, k) => {
      const d = Math.hypot(R.u[6 * k], R.u[6 * k + 1], R.u[6 * k + 2]);
      if (d > maxDisp.value) maxDisp = { value: d, node: nd.id };
    });
    const members = model.members.map((m, k) => ({ id: m.id, ref: m.from?.ref || '', L: prep.mem[k].ax.L, section: secs.get(m.section)?.name || m.section, ext: memberExtremes(prep, R, k, n) }));
    sets.push({ key, name: R.name, kind: R.kind, R, reactions, sum: { applied: R.applied, reacted: R.reacted }, members, maxDisp });
  }
  // envelope: for each member and action the largest magnitude over every set, with its sign and the set it came from
  const envelope = model.members.map((m, k) => {
    const row = { id: m.id, ref: m.from?.ref || '' };
    for (const a of ['N', 'Vy', 'Vz', 'T', 'My', 'Mz']) {
      let best = { v: 0, set: '' };
      for (const s of sets) { const v = signedMax(s.members[k].ext[a]); if (Math.abs(v) > Math.abs(best.v)) best = { v, set: s.name }; }
      row[a] = best;
    }
    let d = { v: 0, set: '', ratio: Infinity };
    for (const s of sets) { const e = s.members[k].ext.defl; if (e.value > d.v) d = { v: e.value, set: s.name, ratio: e.ratio }; }
    row.defl = d;
    return row;
  });
  return { sets, envelope, counts: { nodes: model.nodes.length, members: model.members.length, supports: model.supports.length, cases: model.cases.length, combos: model.combos.length, dofs: sol.dofs }, warnings: sol.warnings || [] };
}

const ratio = (r) => (Number.isFinite(r) && r < 1e7 ? 'L/' + Math.round(r) : '');

function fmtF(v, unit) {
  if (!Number.isFinite(v)) return '';
  if (unit === 'N') return (Math.round(v / 10) / 100).toFixed(2) + ' kN';
  if (unit === 'N·mm') return (Math.round(v / 1e4) / 100).toFixed(2) + ' kN·m';
  return (Math.round(v * 1000) / 1000).toFixed(3);
}

const pc = (v) => (v === null || !Number.isFinite(v) ? '' : (Math.round(v * 1000) / 10).toFixed(1) + ' %');

const f2 = (v, d = 2) => (Number.isFinite(v) ? (Math.round(v * 10 ** d) / 10 ** d).toFixed(d) : '');

export function problemsOf({ rc, drift, drawn = (id) => id, label = () => '', t }) {
  const out = [];
  const src = { name: 'detailcraft.frame' };
  const seen = new Set();
  if (rc?.ok) for (const m of rc.members) {
    const id = drawn(m.id);
    if (m.status === 'fail') {
      const key = 'rc.fail|' + id;
      if (seen.has(key)) continue;
      seen.add(key);
      out.push({ id: 'rc.fail:' + id, code: 'rc.fail', severity: 'warning', source: src, about: [{ kind: 'member', id, label: label(id) }],
        msg: { key: 'frame.rc.prob.fail', vars: { util: Math.round(m.util * 1000) / 10, check: m.check.id, clause: m.check.clause } },
        text: t('frame.rc.prob.fail', { util: f2(m.util * 100, 1), check: t('frame.rc.check.' + m.check.id), clause: m.check.clause }),
        req: { op: '<=', value: 1, unit: 'ratio' }, found: { value: Math.round(m.util * 1e4) / 1e4, unit: 'ratio' } });
    } else if (m.status === 'partial') {
      const key = 'rc.partial|' + id;
      if (seen.has(key)) continue;
      seen.add(key);
      out.push({ id: 'rc.partial:' + id, code: 'rc.partial', severity: 'note', source: src, about: [{ kind: 'member', id, label: label(id) }],
        msg: { key: 'frame.rc.prob.partial', vars: { why: m.partial[0] } }, text: t('frame.rc.prob.partial', { why: t('frame.rc.why.' + m.partial[0]) }) });
    }
  }
  for (const d of drift || []) {
    if (d.ratio <= 1) continue;
    out.push({ id: 'drift:' + d.set + ':' + d.id, code: 'seismic.drift', severity: 'warning', source: src, about: [],
      msg: { key: 'frame.eq.prob.drift', vars: { floor: d.name, ratio: Math.round(d.ratio * 1000) / 10 } },
      text: t('frame.eq.prob.drift', { floor: d.name, set: d.setName, design: f2(d.design, 1), allowed: f2(d.allowed, 1), ratio: f2(d.ratio * 100, 1) }),
      req: { op: '<=', value: Math.round(d.allowed * 100) / 100, unit: 'mm' }, found: { value: Math.round(d.design * 100) / 100, unit: 'mm' } });
  }
  return out;
}

export function plateTables(model, sol, key, t) {
  const R = sol?.results?.[key], pl = sol?.prep?.shell?.pl;
  if (!R || !pl?.length) return [];
  const groups = new Map();
  model.plates.forEach((p, k) => { const g = p.from?.ref || p.id.split('.p')[0]; if (!groups.has(g)) groups.set(g, []); groups.get(g).push(k); });
  const kNm = (v) => (v / 1e3).toFixed(2), kN = (v) => (v / 1e3).toFixed(2);
  const rows = [];
  for (const [g, list] of groups) {
    let w = 0, mx = [0, 0], my = [0, 0], mxy = 0, q = 0;
    for (const k of list) {
      const c = plateCentre(sol.prep, R, k);
      mx = [Math.max(mx[0], c[3]), Math.min(mx[1], c[3])]; my = [Math.max(my[0], c[4]), Math.min(my[1], c[4])];
      mxy = Math.max(mxy, Math.abs(c[5])); q = Math.max(q, Math.hypot(c[6], c[7]));
      for (const nd of pl[k].nodes) w = Math.max(w, Math.hypot(R.u[6 * nd], R.u[6 * nd + 1], R.u[6 * nd + 2]));
    }
    rows.push([g, String(list.length), (model.plates[list[0]].t).toFixed(0), w.toFixed(2), kNm(mx[0]), kNm(mx[1]), kNm(my[0]), kNm(my[1]), kNm(mxy), kN(q)]);
  }
  /* i18n-ignore-start: column heads that are symbols / units */
  return [{ title: t('frame.pl.title'), head: [t('frame.pl.element'), t('frame.pl.n'), 't (mm)', 'w (mm)', 'Mx+ (kN·m/m)', 'Mx− (kN·m/m)', 'My+ (kN·m/m)', 'My− (kN·m/m)', '|Mxy| (kN·m/m)', 'Q (kN/m)'], numeric: [1, 2, 3, 4, 5, 6, 7, 8, 9], rows },
    { title: t('frame.pl.about'), head: [t('frame.rep.item'), t('frame.rep.value')], numeric: [], rows: [[t('frame.pl.method'), t('frame.pl.method-text')], [t('frame.pl.limits'), t('frame.pl.limits-text')]] }];
  /* i18n-ignore-end */
}

/** Failed slab checks as shared problems (rule 29). `t(key, vars)` words them; ids do not depend on the language. */
export function slabProblems(res, { t = (k) => k, name = 'slab' } = {}) {
  if (!res?.ok) return [];
  const out = [], fmt = (v) => String(Math.round(v * 10) / 10);
  for (const r of res.rows) if (r.ratio > 1 + 1e-9) {
    out.push({ id: 'concrete.slab:' + r.key, code: 'concrete.slab-flexure', severity: 'error', about: [], source: { kind: 'engine', name: 'detailcraft.frame' }, clause: r.clause,
      msg: { key: 'frame.slab.prob.flexure', vars: { layer: r.layer, need: fmt(r.need), prov: fmt(r.prov), bar: r.bar, s: r.s, plate: r.plate, set: r.set } },
      text: t('frame.slab.prob.flexure', { layer: r.layer, need: fmt(r.need), prov: fmt(r.prov), bar: r.bar, s: r.s, plate: r.plate, set: r.set }),
      req: { op: '<=', value: Math.round(r.prov * 10) / 10, unit: 'mm²/m' }, found: { value: Math.round(r.need * 10) / 10, unit: 'mm²/m' } });
  }
  for (const c of res.checks) if (c.ratio > 1 + 1e-9) {
    out.push({ id: 'concrete.slab:' + c.id, code: 'concrete.slab-shear', severity: 'error', about: [], source: { kind: 'engine', name: 'detailcraft.frame' }, clause: c.clause,
      msg: { key: 'frame.slab.prob.shear', vars: { Vu: fmt(c.demand / 1000), phiVc: fmt(c.capacity / 1000), plate: c.plate, set: c.set } },
      text: t('frame.slab.prob.shear', { Vu: fmt(c.demand / 1000), phiVc: fmt(c.capacity / 1000), plate: c.plate, set: c.set }),
      req: { op: '<=', value: Math.round(c.capacity / 100) / 10, unit: 'kN/m' }, found: { value: Math.round(c.demand / 100) / 10, unit: 'kN/m' } });
  }
  return out;
}