Bid packages and leveling

/** Our own cost of each item: the sum of its estimate rows (item, conditions, assembly parts), errors left out. */
function itemCosts(est) {
  const m = new Map();
  for (const r of est.rows) if (!r.error) m.set(r.itemId, (m.get(r.itemId) || 0) + r.total);
  return m;
}

export function bidPackages(state, est, { title = (k) => k } = {}) {
  const cost = itemCosts(est), qrow = new Map(est.rows.filter((r) => r.kind === 'item').map((r) => [r.itemId, r]));
  const sheets = new Map();
  for (const m of state.marks) { if (!sheets.has(m.item)) sheets.set(m.item, new Set()); sheets.get(m.item).add(m.sheet); }
  const by = new Map();
  for (const it of state.items) {
    const k = pkgOf(it);
    const p = by.get(k) || { key: k, title: title(k), items: [], sheets: new Set(), cost: 0 };
    const r = qrow.get(it.id);
    p.items.push({ itemId: it.id, name: it.name, csi: it.csi || '', qty: r && !r.error ? r.qty : null, unit: r?.unit || '', cost: cost.get(it.id) || 0, sheets: [...(sheets.get(it.id) || [])] });
    p.cost += cost.get(it.id) || 0;
    for (const s of sheets.get(it.id) || []) p.sheets.add(s);
    by.set(k, p);
  }
  return [...by.values()].sort((a, b) => (a.key || '99').localeCompare(b.key || '99')).map((p) => ({ ...p, sheets: [...p.sheets] }));
}

export function leveling(state, est, opts = {}) {
  const pk = new Map(bidPackages(state, est, opts).map((p) => [p.key, p]));
  const out = [];
  for (const [key, pkg] of pk) {
    const bids = (state.bids || []).filter((b) => b.pkg === key);
    if (!bids.length) continue;
    const inPkg = new Map(pkg.items.map((x) => [x.itemId, x]));
    const rows = bids.map((bid) => {
      const plugs = bid.excl.filter((id) => inPkg.has(id)).map((id) => ({ itemId: id, name: inPkg.get(id).name, cost: inPkg.get(id).cost }));
      const plug = plugs.reduce((n, x) => n + x.cost, 0), leveled = bid.amount + plug;
      return { bid, plugs, plug, leveled, diff: leveled - pkg.cost };
    });
    let low = null;
    for (const r of rows) if (!low || r.leveled < low.leveled) low = r;
    out.push({ pkg, ours: pkg.cost, bids: rows, low: low.bid.id });
  }
  return out;
}

/** A package's scope for a subcontractor: item, CSI number, quantity, unit, the sheets its marks are on. No prices. */
export function packageCsv(pkg, sheetLabel = (k) => k) {
  const lines = [[t('pkg.csv.title', { pkg: pkg.title })], ['item', 'csi', 'qty', 'unit', 'sheets'].map((k) => t('pkg.csv.' + k))];
  for (const x of pkg.items) lines.push([x.name, x.csi, x.qty === null ? '' : Math.round(x.qty * 10000) / 10000, x.unit, x.sheets.map(sheetLabel).join('; ')]);
  lines.push([], [t('pkg.csv.sheets'), pkg.sheets.map(sheetLabel).join('; ')]);
  return lines.map((l) => l.map(cell).join(',')).join('\r\n') + '\r\n';
}

/** The base bid with the chosen bids in it (see the header). Without awards, est itself. */
export function applyAwards(state, est) {
  const awards = cleanAwards(state.awards, state.bids);
  if (!awards.length) return est;
  const byPkg = new Map(awards.map((a) => [a.pkg, state.bids.find((b) => b.id === a.bid)]));
  const items = new Map(state.items.map((i) => [i.id, i]));
  const gone = new Set();                                     // items whose own pricing the bid replaced
  for (const it of state.items) {
    const b = byPkg.get(pkgOf(it));
    if (b && !b.excl.includes(it.id)) gone.add(it.id);
  }
  const rows = est.rows.map((r) => {
    if (r.error || !gone.has(r.itemId)) return r;
    const bidder = byPkg.get(pkgOf(items.get(r.itemId))).bidder;
    const { work, ...rest } = r;                              // our rates stay (the table shows them); only the extensions drop out
    return { ...rest, matExt: 0, labExt: 0, total: 0, awarded: bidder, ownTotal: r.total };
  });
  let sub = 0;
  for (const [pkg, b] of [...byPkg].sort((x, y) => (x[0] || '99').localeCompare(y[0] || '99'))) {
    sub += b.amount;
    rows.push({ kind: 'subcontract', itemId: null, pkg, bidId: b.id, bidder: b.bidder, name: b.bidder, unit: 'LS', qty: 1, qtyW: 1, waste: 0, mat: 0, lab: 0, matExt: 0, labExt: 0, subExt: b.amount, total: b.amount, type: 'sub', marks: 0 });
  }
  let mat = 0, lab = 0, errors = 0, hours = 0, workerHours = 0;
  for (const r of rows) {
    if (r.error) { errors++; continue; }
    mat += r.matExt; lab += r.labExt;
    if (r.work) { hours += r.work.hours; workerHours += r.work.workerHours; }
  }
  return { ...est, rows, matTotal: mat, labTotal: lab, subTotal: sub, total: mat + lab + sub, errors, incomplete: errors > 0 || est.unscaled > 0, hours, workerHours, days: hours / 8 };   // 8 = model.CREW_DAY (level.js can't import model.js: model imports it)
}