Planting: bed and hedge fills, planted areas and their quantities

const FT_M = 1200 / 3937;                 // a US survey foot in metres (CivilCraft's feet)
export const unitM = (units) => (units === 'm' ? 1 : FT_M);

// ---- geometry ----
function area(pts) { let a = 0; for (let i = 0, j = pts.length - 1; i < pts.length; j = i++) a += (pts[j].x + pts[i].x) * (pts[j].y - pts[i].y); return Math.abs(a) / 2; }

/** Whole counts from percentages that add up to exactly n (largest remainder). */
export function shares(mix, n) {
  const tot = mix.reduce((a, m) => a + m.pct, 0) || 1;
  const raw = mix.map((m) => (m.pct / tot) * n), out = raw.map(Math.floor);
  let left = n - out.reduce((a, b) => a + b, 0);
  const order = raw.map((r, i) => [r - Math.floor(r), i]).sort((a, b) => b[0] - a[0] || a[1] - b[1]);
  for (let k = 0; left > 0; k = (k + 1) % order.length, left--) out[order[k][1]]++;
  return out;
}

/** The spacing the plant list gives (m): the current list, or `edition`'s where a species changed since. */
export function listSpacingM(it, index, edition = PLANT_LIST) {
  const old = edition < PLANT_LIST ? LIST_CHANGES[edition] || {} : {};
  const of = (key) => { if (old[key] != null) return old[key]; const sp = index.get(key); return sp ? spacingOf(sp, it.pattern) : null; };   // LA.6: a density gives the spacing for the bed's pattern
  if (!it.mix) return of(it.key) ?? 0.4;
  let w = 0, s = 0;
  for (const m of it.mix) { const v = of(m.key); if (v != null) { w += m.pct; s += m.pct * v; } }
  return w > 0 && s > 0 ? s / w : 0.5;
}

/** `keep(x, y)` (0.8 LA.5): a place the fill may use (a planted area clipped around paving); species shares are counted after it. */
export function bedFill(bed, index, units, keep = null) {
  const um = unitM(units), sM = bedSpacingM(bed, index), s = sM / um;
  const pts = bed.pts, A = area(pts);
  const out = [];
  let capped = false;
  if (s > 0 && pts.length >= 3) {
    const a = (bed.angle * Math.PI) / 180, ca = Math.cos(a), sa = Math.sin(a);
    // the bed in the grid's frame (rotated by −angle about its first point)
    const o = pts[0];
    const loc = pts.map((p) => ({ x: (p.x - o.x) * ca + (p.y - o.y) * sa, y: -(p.x - o.x) * sa + (p.y - o.y) * ca }));
    let x0 = Infinity, y0 = Infinity, x1 = -Infinity, y1 = -Infinity;
    for (const p of loc) { x0 = Math.min(x0, p.x); y0 = Math.min(y0, p.y); x1 = Math.max(x1, p.x); y1 = Math.max(y1, p.y); }
    const tri = bed.pattern !== 'square', dy = tri ? (s * Math.sqrt(3)) / 2 : s, edge = s / 2 - 1e-9;
    let row = 0;
    for (let y = y0 + s / 2; y <= y1 && !capped; y += dy, row++) {
      const shift = tri && row % 2 ? s / 2 : 0;
      for (let x = x0 + s / 2 + shift; x <= x1; x += s) {
        if (!inside(x, y, loc) || edgeDist(x, y, loc) < edge) continue;
        const wx = o.x + x * ca - y * sa, wy = o.y + x * sa + y * ca;
        if (keep && !keep(wx, wy, s)) continue;
        if (out.length >= MAX_FILL) { capped = true; break; }
        out.push({ x: wx, y: wy });
      }
    }
    if (!out.length) {   // a bed smaller than one spacing still gets one plant, in its middle when that is inside
      const cx = pts.reduce((v, p) => v + p.x, 0) / pts.length, cy = pts.reduce((v, p) => v + p.y, 0) / pts.length;
      if (inside(cx, cy, pts) && (!keep || keep(cx, cy, 0))) out.push({ x: cx, y: cy });
    }
  }
  // species by share, at places in a seeded random order (the same bed always fills the same way)
  const n = out.length, counts = {}, cnt = shares(bed.mix, n), order = out.map((_, i) => i), r = rng(bed.seed);
  for (let i = n - 1; i > 0; i--) { const j = Math.floor(r() * (i + 1)); [order[i], order[j]] = [order[j], order[i]]; }
  let k = 0;
  bed.mix.forEach((m, mi) => { for (let c = 0; c < cnt[mi]; c++) { const q = out[order[k++]]; q.key = m.key; q.mi = mi; } counts[m.key] = (counts[m.key] || 0) + cnt[mi]; });
  return { pts: out, counts, mixCounts: cnt, spacing: s, area: A, capped };
}

export function hedgeFill(hedge, index, units) {
  const sp = index.get(hedge.key), um = unitM(units);
  const s = usedSpacingM(hedge, index) / um, gap = hedge.rowGap / um;   // 0.7.1: its own, as saved, else the list's
  const P = hedge.pts, out = [];
  let length = 0, capped = false;
  for (let i = 0; i + 1 < P.length; i++) length += Math.hypot(P[i + 1].x - P[i].x, P[i + 1].y - P[i].y);
  if (!(s > 0) || length <= 0) return { pts: out, length, spacing: s, capped };
  const along = (d) => {   // point and unit direction at distance d along the line
    let acc = 0;
    for (let i = 0; i + 1 < P.length; i++) {
      const L = Math.hypot(P[i + 1].x - P[i].x, P[i + 1].y - P[i].y);
      if (d <= acc + L || i === P.length - 2) { const f = L ? (d - acc) / L : 0, ux = L ? (P[i + 1].x - P[i].x) / L : 1, uy = L ? (P[i + 1].y - P[i].y) / L : 0; return { x: P[i].x + f * (P[i + 1].x - P[i].x), y: P[i].y + f * (P[i + 1].y - P[i].y), ux, uy }; }
      acc += L;
    }
    return null;
  };
  // one row centred along the line (the ends get the same margin); a second row sits beside it, between the first row's plants
  const n = Math.min(MAX_FILL, Math.max(1, Math.floor(length / s + 1e-9) + 1)), start = (length - (n - 1) * s) / 2;
  if (n === MAX_FILL) capped = true;
  const rows = hedge.rows === 2 ? [[-gap / 2, 0, n], [gap / 2, s / 2, Math.min(n - 1, MAX_FILL - n)]] : [[0, 0, n]];
  for (const [off, shift, count] of rows) {
    for (let k = 0; k < count; k++) {
      const q = along(start + shift + k * s);
      out.push({ x: q.x - q.uy * off, y: q.y + q.ux * off, key: hedge.key });
    }
  }
  return { pts: out, length, spacing: s, capped };
}

/** An open line offset sideways (left = +), mitred. */
export function offsetLine(pts, d) {
  const n = pts.length, out = [];
  const nrm = (a, b) => { const L = Math.hypot(b.x - a.x, b.y - a.y) || 1; return { x: -(b.y - a.y) / L, y: (b.x - a.x) / L }; };
  for (let i = 0; i < n; i++) {
    const n0 = i > 0 ? nrm(pts[i - 1], pts[i]) : null, n1 = i < n - 1 ? nrm(pts[i], pts[i + 1]) : null;
    let m = n0 && n1 ? { x: n0.x + n1.x, y: n0.y + n1.y } : n0 || n1;
    const L = Math.hypot(m.x, m.y) || 1;
    m = { x: m.x / L, y: m.y / L };
    const cos = n0 && n1 ? Math.max(0.25, m.x * n1.x + m.y * n1.y) : 1;
    out.push({ x: pts[i].x + (m.x * d) / cos, y: pts[i].y + (m.y * d) / cos });
  }
  return out;
}

/** Labelled typical build-ups (a designer sets the real ones), in project units. */
export function areaDefaults(kind, units) {
  const m = units === 'm', L = (mv) => (m ? mv : Math.round((mv / 0.3048) * 100) / 100);
  const d = { lawn: [0.15, 0, ''], bed: [0.3, 0.075, 'steel'], meadow: [0.1, 0, ''], groundcover: [0.2, 0.05, ''] }[kind] || [0.3, 0.075, ''];
  return { topsoil: L(d[0]), mulch: L(d[1]), membrane: false, edging: d[2] };
}

export function areaFill(a, ls, index, units, region = areaRegion(a, ls)) {
  if (!a.mix.length) return { pts: [], counts: {}, mixCounts: [], spacing: 0, area: region.area, capped: false };
  // a place is kept when it is in what is left and at least half a spacing from a cut edge (the outline's margin is bedFill's own)
  return bedFill(asBed(a), index, units, (x, y, s) => region.inside(x, y) && (!region.cutLength || cutDist(region, x, y) >= s / 2 - 1e-9));
}

export function areaQuantities(a, ls, index, units) {
  const region = areaRegion(a, ls), fill = areaFill(a, ls, index, units, region), b = a.buildup;
  return { area: region.area, perimeter: region.perimeter, edging: b.edging ? region.outlineLength : 0, topsoil: region.area * b.topsoil, mulch: region.area * b.mulch,
    membrane: b.membrane ? region.area : 0, plants: fill.pts.length, mixCounts: fill.mixCounts || [], counts: fill.counts, clipped: region.cutLength > 0, region, fill };
}

export function areaQuantityItems(ls, index, units) {
  const m = units === 'm', A = m ? 'm²' : 'SF', L = m ? 'm' : 'LF', V = m ? 'm³' : 'CY', vPer = m ? 1 : 27, r2 = (v) => Math.round(v * 100) / 100;   // i18n-ignore: TakeoffCraft's unit symbols
  const out = [];
  for (const a of ls?.areas || []) {
    const q = areaQuantities(a, ls, index, units), k = 'area:' + a.id;
    out.push({ key: k + ':area', name: t('ls.a.q.area', { name: a.name }), unit: A, qty: r2(q.area) });
    if (q.topsoil) out.push({ key: k + ':topsoil', name: t('ls.a.q.topsoil', { name: a.name }), unit: V, qty: r2(q.topsoil / vPer) });
    if (q.mulch) out.push({ key: k + ':mulch', name: t('ls.a.q.mulch', { name: a.name }), unit: V, qty: r2(q.mulch / vPer) });
    if (q.membrane) out.push({ key: k + ':membrane', name: t('ls.a.q.membrane', { name: a.name }), unit: A, qty: r2(q.membrane) });
    if (q.edging) out.push({ key: k + ':edging', name: t('ls.a.q.edging', { name: a.name, kind: t('ls.a.e.' + a.buildup.edging) }), unit: L, qty: r2(q.edging) });
  }
  return out;
}