Reinforcing bars and the bending schedule

export const BARS = new Map(A615.map(([n, d, w, a]) => [n, Object.freeze({
  name: n, num: Number(n.slice(1)), db: d * 25.4, mass: w * 1.48816394, area: a * 645.16,
  bendD: (Number(n.slice(1)) <= 8 ? 6 : 8) * d * 25.4,       // ACI 318-19 Table 25.3.1
  pub: { d, w, a }, set: 'astm', markPre: n.slice(1), metric: '#' + Math.round(d * 25.4),
})]));

const area = Math.PI * d * d / 4;
BARS.set('H' + d, Object.freeze({ name: 'H' + d, num: d, db: d, mass: area * 7850 * 1e-6, area, bendD: 2 * r, r, P, set: 'bs', markPre: 'H' + d, metric: 'H' + d }));

/** n bars evenly over a width w (bar centers), spacing no more than s. */
export function layout(w, s) {
  const n = Math.max(2, Math.ceil(w / s - 1e-9) + 1);
  return { n, spacing: w / (n - 1) };
}

/** Out-to-out length of a standard 90° hook leg: ACI 318-19 Table 25.3.1 D/2 + db + 12·db; BS 8666 the end projection P. */
export function hookLeg(b) { return b.set === 'bs' ? b.P : b.bendD / 2 + b.db + 12 * b.db; }

/** Centerline cut length of a shape with out-to-out dims. */
export function cutLength(shape, dims, b) {
  const k = b.bendD / 2 + b.db, rc = b.bendD / 2 + b.db / 2;
  if (shape === 'S') return dims.A;
  if (b.set === 'bs') {                                         // BS 8666:2020 shape codes 11 and 21
    if (shape === 'L') return dims.A + dims.B - 0.5 * b.r - b.db;
    if (shape === 'U') return dims.A + dims.B + dims.C - b.r - 2 * b.db;
  }
  if (shape === 'L') return dims.A + dims.B - 2 * k + Math.PI / 2 * rc;
  if (shape === 'U') return dims.A + dims.B + dims.C - 4 * k + Math.PI * rc;
  throw new Error(t('rebar.err.shape', { shape }));
}

/**
 * Centerline of a bar in its own plane: s along A, t toward the bends' side. Returns
 * [{ k:'L', a:[s,t], b:[s,t] } | { k:'A', a, m, b, c:[s,t], r }] from one end to the other.
 * U: legs up at both ends; L: the hook leg at the s = A end (main leg along s).
 */
export function centerline2d(shape, dims, b) {
  const h = b.db / 2, rc = b.bendD / 2 + h, A = dims.A;
  const arc = (c, a0, a1) => ({ k: 'A', c, r: rc, a: [c[0] + rc * Math.cos(a0), c[1] + rc * Math.sin(a0)], m: [c[0] + rc * Math.cos((a0 + a1) / 2), c[1] + rc * Math.sin((a0 + a1) / 2)], b: [c[0] + rc * Math.cos(a1), c[1] + rc * Math.sin(a1)] });
  if (shape === 'S') return [{ k: 'L', a: [0, h], b: [A, h] }];
  const segs = [];
  if (shape === 'U') {
    const c1 = [h + rc, h + rc];
    segs.push({ k: 'L', a: [h, dims.B - 0], b: [h, h + rc] });
    segs.push(arc(c1, Math.PI, 1.5 * Math.PI));
    segs.push({ k: 'L', a: [h + rc, h], b: [A - h - rc, h] });
  } else segs.push({ k: 'L', a: [0, h], b: [A - h - rc, h] });
  const c2 = [A - h - rc, h + rc];
  segs.push(arc(c2, 1.5 * Math.PI, 2 * Math.PI));
  const legEnd = shape === 'U' ? dims.C : dims.B;
  segs.push({ k: 'L', a: [A - h, h + rc], b: [A - h, legEnd] });
  return segs;
}

export function centerlineLength(segs) {
  let s = 0;
  for (const g of segs) s += g.k === 'L' ? Math.hypot(g.b[0] - g.a[0], g.b[1] - g.a[1]) : g.r * Math.PI / 2;
  return s;
}

// bottom layer: bars along local X (outermost), then bars along local Y on top of them
const layer = (b, along, across, runLen, acrossLen, s, zBottom, role) => {
  const A = runLen - 2 * c;
  const hooks = f.mat.hooks;
  const room = f.H - 2 * c - (zBottom - (bottom + c));
  const B = hooks ? Math.min(hookLeg(b), room) : 0;
  const shape = hooks ? 'U' : 'S';
  const dims = hooks ? { A, B, C: B } : { A };
  const lay = layout(acrossLen - 2 * c - b.db, s);
  const sets = [];
  for (let i = 0; i < lay.n; i++) {
    const off = -acrossLen / 2 + c + b.db / 2 + i * lay.spacing;
    const o = along === 'x' ? P(-runLen / 2 + c, off, zBottom) : P(off, -runLen / 2 + c, zBottom);
    sets.push({ origin: o, sDir: along === 'x' ? ex : ey, tDir: ez });
  }
  out.push({ role, bar: b.name, shape, dims, count: lay.n, spacing: lay.spacing, length: cutLength(shape, dims, b), sets });
};

const z0 = bottom + c + bx.db + by.db;                 // sitting on the mat
const A = f.top + s.projection - z0;                  // out-to-out, vertical
const shape = s.hook ? 'L' : 'S';
const dims = s.hook ? { A, B: hookLeg(b) } : { A };
const sets = [];
for (let i = 0; i < s.nx; i++) for (let j = 0; j < s.ny; j++) {
  const lx = (i - (s.nx - 1) / 2) * s.sx, ly = (j - (s.ny - 1) / 2) * s.sy;
  // hook points outward, along local X (or Y when the bar is further out that way)
  let hd = Math.abs(lx) >= Math.abs(ly) ? (lx >= 0 ? ex : ex.map((v) => -v)) : (ly >= 0 ? ey : ey.map((v) => -v));
  if (Math.abs(lx) < 1e-9 && Math.abs(ly) < 1e-9) hd = ex;
  // L shape: main leg along s (here: down from the top), hook at s = A turning toward t = hook direction.
  // The bar's centerline is drawn from its top (s = 0) down to the bend; the bar axis sits at (lx, ly).
  const top = P(lx, ly, z0 + A);
  sets.push({ origin: [top[0] - hd[0] * b.db / 2, top[1] - hd[1] * b.db / 2, top[2]], sDir: [0, 0, -1], tDir: hd });

const minClear = (b) => (b.set === 'bs' ? Math.max(20, b.db) : Math.max(25.4, b.db));   // ACI 318-19 25.2.1; EN 1992-1-1 8.2 (aggregate not checked)
const lx = layout(f.B - 2 * c - bx.db, f.mat.sX), ly = layout(f.L - 2 * c - by.db, f.mat.sY);
if (lx.spacing - bx.db < minClear(bx) - 1e-6) out.push({ text: t('rebar.warn.clear', { bar: f.mat.barX, spacing: r1(lx.spacing), min: r1(minClear(bx)) }) });
if (ly.spacing - by.db < minClear(by) - 1e-6) out.push({ text: t('rebar.warn.clear', { bar: f.mat.barY, spacing: r1(ly.spacing), min: r1(minClear(by)) }) });

/** Concrete volume (m³). */
export const footingVolume = (f) => f.L * f.B * f.H * 1e-9;

/**
 * Bar marks across all footings: identical bars (size, shape, dims to the mm) share a mark "<size>F<n>".
 * Returns { rows (bending schedule), byFooting: Map(footingId → [{ group, mark }]) }.
 */
export function bendingSchedule(footings) {
  const marks = new Map();
  const rows = [];
  const byFooting = new Map();
  const counters = new Map();
  for (const f of footings) {
    const list = [];
    for (const g of footingBars(f)) {
      const b = BARS.get(g.bar);
      const key = [g.bar, g.shape, ...['A', 'B', 'C'].map((k) => g.dims[k] === undefined ? '' : Math.round(g.dims[k]))].join('|');
      let row = marks.get(key);
      if (!row) {
        const n = (counters.get(b.markPre) || 0) + 1;
        counters.set(b.markPre, n);
        row = { mark: b.markPre + 'F' + n, bar: g.bar, shape: g.shape, dims: { ...g.dims }, count: 0, length: g.length, mass: b.mass, roles: new Set() };
        marks.set(key, row);
        rows.push(row);
      }
      row.count += g.count;
      row.roles.add(g.role);
      list.push({ group: g, mark: row.mark });
    }
    byFooting.set(f.id, list);
  }
  for (const r of rows) {
    r.totalLength = r.length * r.count;
    r.unitWeight = r.mass * r.length / 1000;
    r.totalWeight = r.unitWeight * r.count;
    r.roles = [...r.roles];
  }
  return { rows, byFooting };
}

/** Bending schedule as CSV rows (header first). */
export function scheduleTable(rows, { codes = 'dc', naming = 'imperial' } = {}) {
  const mm = (v) => v === undefined ? '' : String(Math.round(v));
  const head = ['mark', 'size', 'shape', 'a', 'b', 'c', 'count', 'cut', 'total-length', 'kg-m', 'weight-each', 'total-weight', 'used-for'].map((k) => t('rebar.col.' + k));
  const body = rows.map((r) => { const d = scheduleDims(r.shape, r.dims, codes); return [r.mark, barLabel(r.bar, naming), shapeCode(r.shape, codes), mm(d.A), mm(d.B), mm(d.C), String(r.count), mm(r.length),
    (r.totalLength / 1000).toFixed(2), r.mass.toFixed(3), r.unitWeight.toFixed(2), r.totalWeight.toFixed(1), r.roles.join('; ')]; });
  const total = rows.reduce((s, r) => s + r.totalWeight, 0);
  body.push([t('rebar.total'), '', '', '', '', '', String(rows.reduce((s, r) => s + r.count, 0)), '', (rows.reduce((s, r) => s + r.totalLength, 0) / 1000).toFixed(2), '', '', total.toFixed(1), '']);
  return [head, ...body];
}