Costs on the schedule

export const UNITS = Object.freeze({ m3: ['volume', 1], m2: ['area', 1], m: ['length', 1], kg: ['mass', 1], item: ['count', 1], cy: ['volume', 0.764554858], cf: ['volume', 0.0283168466], sf: ['area', 0.09290304], lf: ['length', 0.3048] });

const cents = (d) => Math.round(d * 100);

const money = (c) => Math.round(c) / 100;

// ------------------------------------------------------------------------------------------------ pricing the model
function qtyFor(row, part) {
  const [kind, k] = UNITS[row.unit];
  let q;
  if (kind === 'mass') q = Number.isFinite(part.mass) ? part.mass : Number.isFinite(part.volume) ? part.volume * row.density : NaN;
  else if (kind === 'count') q = Number.isFinite(part.count) ? part.count : 1;
  else q = part[kind];
  return Number.isFinite(q) ? { qty: q / k, kind } : { qty: NaN, kind };
}

export function priceItems(items, rows) {
  const lines = [], unpriced = [], byId = new Map();
  for (const it of items) {
    for (const part of it.parts || []) {
      const row = matchRow(rows, { material: part.material, name: it.name, cls: it.cls });
      if (!row) { unpriced.push({ id: it.id, guid: it.guid, name: it.name, cls: it.cls, material: part.material || '', why: 'noprice' }); continue; }
      const q = qtyFor(row, part);
      if (!(q.qty >= 0)) { unpriced.push({ id: it.id, guid: it.guid, name: it.name, cls: it.cls, material: part.material || '', why: 'noqty', need: q.kind }); continue; }
      const matC = cents(q.qty * (1 + row.waste) * row.mat), labC = cents(q.qty * row.lab);
      const cost = money(matC + labC);
      lines.push({ id: it.id, guid: it.guid, name: it.name, cls: it.cls, storey: it.storey || '', price: row.id, qty: q.qty, unit: row.unit, mat: money(matC), lab: money(labC), cost });
      byId.set(it.id, (byId.get(it.id) || 0) + matC + labC);
    }
  }
  let total = 0;
  for (const [k, c] of byId) { byId.set(k, c / 100); total += c; }
  return { lines, byId, unpriced, total: money(total) };
}

/** Each matched task's cost: the cost of its elements, an element in n tasks counted 1/n in each. `byKey` Map(key → dollars) with key = keyBase + id. */
export function taskCosts(matched, byKey) {
  const n = new Map();
  for (const t of matched) for (const k of t.keys || []) n.set(k, (n.get(k) || 0) + 1);
  const tasks = [];
  const inTask = new Set();
  for (const t of matched) {
    let c = 0;
    for (const k of t.keys || []) { const v = byKey.get(k); if (v) { c += cents(v) / n.get(k); inTask.add(k); } }
    tasks.push({ name: t.name, stage: t.stage || '', package: t.package || '', start: t.start, finish: t.finish, keys: t.keys || [], cents: Math.round(c), cost: money(Math.round(c)) });
  }
  let un = 0;
  for (const [k, v] of byKey) if (!inTask.has(k)) un += cents(v);
  return { tasks, scheduled: money(tasks.reduce((s, t) => s + t.cents, 0)), unscheduled: money(un) };
}

// ------------------------------------------------------------------------------------------------ spreading over days
const weightsFor = (D, profile) => {
  if (D <= 1) return [1];
  return Array.from({ length: D }, (_, i) => (profile === 'front' ? D - i : profile === 'back' ? i + 1 : profile === 'bell' ? Math.sin(Math.PI * (i + 0.5) / D) : 1));
};

/** A task's cents over Start..Finish (inclusive days): whole cents by the largest-remainder rule, so the days add up to the task exactly. */
export function spread(task, profile = 'even') {
  const D = task.finish - task.start + 1, w = weightsFor(D, PROFILES.includes(profile) ? profile : 'even'), W = w.reduce((s, x) => s + x, 0);
  const raw = w.map((x) => task.cents * x / W), base = raw.map(Math.floor);
  let left = task.cents - base.reduce((s, x) => s + x, 0);
  raw.map((x, i) => [x - Math.floor(x), i]).sort((a, b) => b[0] - a[0] || a[1] - b[1]).forEach(([, i]) => { if (left > 0) { base[i]++; left--; } });
  return base.map((c, i) => ({ day: task.start + i, cents: c }));
}

export function cashFlow(tasks, { profile = 'even', per = 'day' } = {}) {
  const days = new Map();
  for (const t of tasks) for (const s of spread(t, profile)) days.set(s.day, (days.get(s.day) || 0) + s.cents);
  if (!days.size) return { points: [], total: 0, first: null, last: null };
  const first = Math.min(...days.keys()), last = Math.max(...days.keys());
  const key = (d) => (per === 'week' ? monday(d) : per === 'month' ? monthOf(d) : d);
  const groups = new Map();
  for (let d = first; d <= last; d++) {
    const k = key(d), g = groups.get(k) || { from: d, to: d, c: 0 };
    g.to = d; g.c += days.get(d) || 0; groups.set(k, g);
  }
  let cum = 0;
  const points = [...groups.values()].map((g) => { cum += g.c; return { label: per === 'month' ? monthOf(g.from) : dayText(per === 'week' ? monday(g.from) : g.from), from: g.from, to: g.to, cost: money(g.c), cum: money(cum) }; });
  return { points, total: money(cum), first, last };
}

/** On `day`: what the schedule plans to have spent, what is built (tasks finished), running (tasks in progress), the rest; and earned value when the person types progress. */
export function valueAt(tasks, day, { profile = 'even', progress = null } = {}) {
  let planned = 0, built = 0, running = 0, remaining = 0, earned = 0;
  for (const t of tasks) {
    for (const s of spread(t, profile)) if (s.day <= day) planned += s.cents;
    if (day > t.finish) built += t.cents; else if (day >= t.start) running += t.cents; else remaining += t.cents;
    if (progress) earned += t.cents * Math.max(0, Math.min(1, Number(progress[t.name]) || 0));
  }
  return { planned: money(planned), built: money(built), running: money(running), remaining: money(remaining), ...(progress ? { earned: money(Math.round(earned)) } : {}) };
}

export function calcCost5d(items, rows, matched, { keyBase = 0, profile = 'even', per = 'week' } = {}) {
  const priced = priceItems(items, rows);
  const byKey = new Map([...priced.byId].map(([id, c]) => [keyBase + id, c]));
  const tc = taskCosts(matched, byKey);
  const flow = cashFlow(tc.tasks, { profile, per });
  return { ...priced, ...tc, flow, groups: byGroup(tc.tasks), profile, per, grand: money(cents(tc.scheduled) + cents(tc.unscheduled)) };
}

/**
 * TakeoffCraft's own rates → price rows. Reads a takeoff project (`{ format: 'takeoffcraft-project', items }`) or its `items` object: each item with a
 * material or labour rate (integers in ten-thousandths of a dollar; waste in ten-thousandths of one) becomes a row whose keyword is the item's name.
 * Those names rarely match a model's materials: edit the keywords (the mapping) before pricing. linear → lf, area → sf, count → item (TakeoffCraft's feet).
 */
export function fromTakeoff(json) {
  const src = typeof json === 'string' ? (() => { try { return JSON.parse(json); } catch { return null; } })() : json;
  const items = src && typeof src === 'object' ? (src.items && typeof src.items === 'object' ? src.items : src) : null;
  if (!items || Array.isArray(items)) return { rows: [], skipped: [{ name: '', code: 'format' }] };
  const rows = [], skipped = [], seen = new Set();
  for (const [key, it] of Object.entries(items).slice(0, LIMIT.rows)) {
    const name = String(it?.name ?? key);
    const unit = { linear: 'lf', area: 'sf', count: 'item', fixed: 'item' }[it?.type];
    const mat = Number(it?.mat) / 10000, lab = Number(it?.lab) / 10000, waste = (Number(it?.waste) || 0) / 10000;
    if (!unit || !(mat > 0 || lab > 0)) { skipped.push({ name, code: 'norate' }); continue; }
    let id = slug(name), n = 2;
    while (seen.has(id)) id = slug(name) + '-' + n++;
    const c = cleanPriceRow({ id, match: [name], unit, mat: mat || 0, lab: lab || 0, waste, source: 'TakeoffCraft rates' });
    if (!c.row) { skipped.push({ name, code: c.errors[0] }); continue; }
    seen.add(id); rows.push(c.row);
  }
  return { rows, skipped };
}

export function costCsv(res, currency = '') {
  const lines = ['stage,package,task,start,finish,cost' + (cleanCurrency(currency) ? ' (' + cleanCurrency(currency) + ')' : '')];
  for (const t of res.tasks) lines.push([cell(t.stage), cell(t.package), cell(t.name), dayText(t.start), dayText(t.finish), t.cost.toFixed(2)].join(','));
  lines.push(['', '', 'scheduled', '', '', res.scheduled.toFixed(2)].join(','), ['', '', 'not in any task', '', '', res.unscheduled.toFixed(2)].join(','), '', 'period,cost,cumulative');
  for (const p of res.flow.points) lines.push([p.label, p.cost.toFixed(2), p.cum.toFixed(2)].join(','));
  return lines.join('\r\n') + '\r\n';
}