Priced estimate

function priced(r) {
  const qtyW = withWaste(r.qty, r.waste);
  const matExt = extendCents(qtyW, r.mat);
  if (r.crew) {                                            // T18: labor from the crew's hours; `lab` shows the rate it comes to
    const work = crewWork(r.crew, qtyW);
    return { ...r, lab: work.rate, qtyW, matExt, labExt: work.labExt, total: matExt + work.labExt, work };
  }
  const labExt = extendCents(qtyW, r.lab);
  return { ...r, qtyW, matExt, labExt, total: matExt + labExt };
}

/** Hours and labor of a crew on a quantity (with waste). */
export function crewWork(crew, qtyW) {
  const hours = qtyW / crew.prod, workerHours = hours * crew.size;
  return { hours, workerHours, days: hours / CREW_DAY, labExt: Math.round(roundTo(workerHours * crew.wage / 100, 0)), rate: Math.round(crew.size * crew.wage / crew.prod) };
}

/**
 * The priced estimate: a row per item and per component, extended in cents.
 *   qty → qty × (1 + waste) → × material rate, × labor rate (each rounded to the cent) → total
 * A component whose formula fails gets `error` and no amounts; the estimate is then `incomplete`.
 */
export function estimate(state, q = quantities(state)) {
  const rows = [];
  let mat = 0, lab = 0, errors = 0, unscaled = 0, hours = 0, workerHours = 0;
  for (const it of state.items) {
    const t = q.get(it.id);
    const vars = itemVars(it, t);
    const qty = itemQty(it, t);
    const row = priced({ kind: 'item', itemId: it.id, name: it.name, unit: UNITS[it.unit].label, qty, waste: it.waste, mat: it.mat, lab: it.lab, type: it.type, ...(it.crew ? { crew: it.crew } : {}) });
    if (row.work) { hours += row.work.hours; workerHours += row.work.workerHours; }
    row.unscaled = t.unscaled;
    row.marks = t.marks - Object.values(t.conds || {}).reduce((n, c) => n + c.marks, 0);
    if (t.backoutSqft > 0) row.backout = { value: sqftTo(t.backoutSqft, it.unit), unit: UNITS[it.unit].label };
    if (it.type === 'linear' && it.heightFt > 0) row.wallArea = { value: vars.A, unit: areaUnitOf(it.unit) };
    if (it.type === 'area') row.perimeter = { value: vars.P, unit: lengthUnitOf(it.unit) === 'm' ? 'm' : 'LF' };
    if (it.type === 'fixed' && it.origin) row.origin = it.origin;
    unscaled += t.unscaled;
    rows.push(row);
    mat += row.matExt; lab += row.labExt;
    for (const c of it.conds || []) {                      // T8: each second condition priced on its own row
      const cr = priced({ kind: 'condition', itemId: it.id, cond: c.kind, name: it.name, unit: UNITS[c.unit].label, qty: condQty(c, t.conds?.[c.kind]), waste: c.waste, mat: c.mat, lab: c.lab, type: c.kind });
      cr.marks = t.conds?.[c.kind]?.marks || 0;
      rows.push(cr);
      mat += cr.matExt; lab += cr.labExt;
    }
    for (const c of it.components) {
      const p = parse(c.formula, VARS[it.type]);
      let cr;
      if (!p.ok) cr = { kind: 'component', itemId: it.id, compId: c.id, name: c.name, unit: c.unit, error: p.error, waste: c.waste, mat: c.mat, lab: c.lab };
      else {
        try { cr = priced({ kind: 'component', itemId: it.id, compId: c.id, name: c.name, unit: c.unit, qty: evaluate(p.ast, vars), waste: c.waste, mat: c.mat, lab: c.lab }); }
        catch (err) { cr = { kind: 'component', itemId: it.id, compId: c.id, name: c.name, unit: c.unit, error: err.message, waste: c.waste, mat: c.mat, lab: c.lab }; }
      }
      cr.formula = c.formula;
      if (cr.error) errors++;
      else { mat += cr.matExt; lab += cr.labExt; }
      rows.push(cr);
    }
  }
  return { rows, matTotal: mat, labTotal: lab, total: mat + lab, errors, unscaled, incomplete: errors > 0 || unscaled > 0, hours, workerHours, days: hours / CREW_DAY };
}

/**
 * The estimate of each bid area (T12): [{ area: {id, name} | null (marks in no bid area), est }], in the
 * bid areas' order, then "no bid area" — only areas that hold marks, and "no bid area" only when the takeoff has areas
 * or such marks. Assembly formulas run on each area's own totals. The rows of all areas add up to the job when no
 * formula rounds (ceil/round per area can make the parts differ from the whole, as on a real bid).
 */
export function areaEstimates(state) {
  const out = [];
  const used = new Set(state.marks.map((m) => m.area || null));
  for (const it of state.items) if (it.type === 'fixed' && it.qty > 0) used.add(it.area || null);   // typed quantities (TK.5+) too
  for (const a of state.areas || []) if (used.has(a.id)) out.push({ area: a, est: estimate(state, quantities(state, { area: a.id })) });
  if (used.has(null) && (state.areas || []).length) out.push({ area: null, est: estimate(state, quantities(state, { area: null })) });
  return out;
}

/**
 * The alternates (T17), in bid area order: [{ area, alt, est, amount }]. `amount` (cents) is what taking the alternate does
 * to the base bid: + the add's cost, − the deduct's cost. Only items with marks in the area count (and their assemblies):
 * an item's assembly is not priced in an alternate it has no marks in.
 */
export function alternates(state) {
  const out = [];
  for (const a of state.areas || []) {
    if (!a.alt) continue;
    const est = estimate(state, quantities(state, { area: a.id }));
    const live = new Set(est.rows.filter((r) => (r.kind === 'item' || r.kind === 'condition') && (r.marks > 0 || (r.type === 'fixed' && r.qty > 0))).map((r) => r.itemId));
    const rows = est.rows.filter((r) => live.has(r.itemId));
    const total = rows.reduce((n, r) => n + (r.error ? 0 : r.total), 0);
    out.push({ area: a, alt: a.alt, est: { ...est, rows, total, matTotal: rows.reduce((n, r) => n + (r.error ? 0 : r.matExt), 0), labTotal: rows.reduce((n, r) => n + (r.error ? 0 : r.labExt), 0) }, amount: a.alt === 'add' ? total : -total });
  }
  return out;
}