Hardscape: paving, paths, walls, ramps and steps

// ---- line helpers ----
function walk(P) {
  const segs = [];
  let L = 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 (l > 1e-9) segs.push({ a: P[i], b: P[i + 1], l, s0: L }); L += l; }
  const at = (s) => { const g = segs.find((q) => s <= q.s0 + q.l + 1e-9) || segs[segs.length - 1]; const f = (s - g.s0) / g.l; return { x: g.a.x + f * (g.b.x - g.a.x), y: g.a.y + f * (g.b.y - g.a.y), ux: (g.b.x - g.a.x) / g.l, uy: (g.b.y - g.a.y) / g.l }; };
  return { segs, L, at };
}

function stations(w, step) {
  const out = [];
  for (let s = 0; s < w.L; s += step) out.push(s);
  out.push(w.L);
  for (const g of w.segs) if (g.s0 > 0) out.push(g.s0);
  return [...new Set(out.map((v) => Math.round(v * 1e6) / 1e6))].sort((a, b) => a - b);
}

// ---- paving ----
export function pavingSurface(p, surface) {
  const z0 = p.level ?? meanGround(surface, p.pts) ?? 0;
  const f = p.falls;
  if (f.mode === 'cross') return { corners: planeZ(p.pts, z0, { pct: f.pct, dir: f.dir }), drain: null, z0 };
  if (f.mode === 'drain' && f.drain) {
    // the drain is the low point at the paving's level; every corner rises from it at the fall
    const d = f.drain;
    return { corners: p.pts.map((q) => ({ x: q.x, y: q.y, z: z0 + (f.pct / 100) * Math.hypot(q.x - d.x, q.y - d.y) })), drain: { x: d.x, y: d.y, z: z0 }, z0 };
  }
  return { corners: p.pts.map((q) => ({ x: q.x, y: q.y, z: z0 })), drain: null, z0 };
}

// ---- paths ----
export function pathStrip(path, surface) {
  const w = walk(path.pts), out = { center: [], left: [], right: [], length: w.L, steepest: 0, steep: [] };
  if (!w.segs.length) return out;
  const step = Math.max(path.width / 2, w.L / 400);
  let prev = null;
  for (const s of stations(w, step)) {
    const q = w.at(s), z = ground(surface, q.x, q.y);
    if (z === null) continue;
    const nx = -q.uy, ny = q.ux, h = path.width / 2, dz = (path.crossfall / 100) * path.width;   // falls to the right side
    out.center.push({ x: q.x, y: q.y, z, s });
    out.left.push({ x: q.x + nx * h, y: q.y + ny * h, z: z + dz / 2 });
    out.right.push({ x: q.x - nx * h, y: q.y - ny * h, z: z - dz / 2 });
    if (prev) {
      const g = Math.abs(z - prev.z) / Math.max(1e-9, s - prev.s) * 100;
      if (g > out.steepest) out.steepest = g;
      if (g > path.maxGrade + 1e-9) out.steep.push({ s: prev.s, s1: s, grade: g });
    }
    prev = { z, s };
  }
  return out;
}

// ---- walls ----
export function wallLayout(wl, surface, units) {
  const D = hardDefaults(units), w = walk(wl.pts), out = { stations: [], maxHeight: 0, minHeight: Infinity, length: w.L, faceArea: 0, volume: 0, steps: 0, engineer: false, off: 0 };
  if (!w.segs.length) return out;
  const step = Math.max(units === 'm' ? 0.25 : 0.75, w.L / 400);
  let lastFoot = null;
  for (const s of stations(w, step)) {
    const q = w.at(s);
    let g = ground(surface, q.x, q.y);
    if (g === null) { out.off++; continue; }
    let top = wl.top ?? g + wl.height;
    if (wl.grade) {   // 0.8 LA.4: a wall that shapes the ground reads the surface it made: the top is the high side (or the typed top), the face the low side
      const off = wl.thickness / 2 + (units === 'm' ? 0.05 : 0.15), gl = ground(surface, q.x - q.uy * off, q.y + q.ux * off), gr = ground(surface, q.x + q.uy * off, q.y - q.ux * off);
      if (gl !== null && gr !== null) { top = wl.top ?? Math.max(gl, gr) + wl.coping.thickness; g = Math.min(gl, gr); }
    } else if (wl.retain && wl.top == null) {   // 0.8 LA.4: the top follows the high side of the ground, the face is what the low side shows
      const off = wl.thickness / 2 + (units === 'm' ? 0.05 : 0.15), gl = ground(surface, q.x - q.uy * off, q.y + q.ux * off), gr = ground(surface, q.x + q.uy * off, q.y - q.ux * off);
      if (gl !== null && gr !== null) { top = Math.max(gl, gr) + wl.coping.thickness; g = Math.min(gl, gr); }
    }
    const height = top - g;
    // the footing's top sits `depth` below the ground, stepped down in whole `step`s so it is level between steps
    const foot = Math.floor((g - wl.footing.depth) / wl.footing.step) * wl.footing.step;
    if (lastFoot !== null && Math.abs(foot - lastFoot) > 1e-9) out.steps++;
    lastFoot = foot;
    out.stations.push({ s, x: q.x, y: q.y, ux: q.ux, uy: q.uy, ground: g, top, height, footing: foot });
    out.maxHeight = Math.max(out.maxHeight, height);
    out.minHeight = Math.min(out.minHeight, height);
  }
  for (let i = 1; i < out.stations.length; i++) {
    const a = out.stations[i - 1], b = out.stations[i], ds = b.s - a.s;
    out.faceArea += ds * (Math.max(0, a.height) + Math.max(0, b.height)) / 2;
    out.volume += ds * wl.thickness * ((a.top - a.footing) + (b.top - b.footing)) / 2;
  }
  out.engineer = wl.wall === 'retaining' && out.maxHeight > D.wall.engineerFrom;
  if (!out.stations.length) out.minHeight = 0;
  return out;
}

// ---- ramps and steps ----
export function rampLayout(r, surface, units) {
  const D = hardDefaults(units), w = walk(r.pts);
  const a = r.pts[0], b = r.pts[r.pts.length - 1];
  const zs = r.zStart ?? ground(surface, a.x, a.y) ?? 0, ze = r.zEnd ?? ground(surface, b.x, b.y) ?? 0;
  const rise = Math.abs(ze - zs), runs = Math.max(1, Math.ceil(rise / r.landingEvery - 1e-9)), landings = runs - 1;
  const sloped = w.L - landings * r.landing;
  const grade = sloped > 0 ? (rise / sloped) * 100 : Infinity;
  const need = (rise / (r.maxGrade / 100)) + landings * r.landing;
  const checks = [
    { key: 'grade', ok: grade <= r.maxGrade + 1e-9, value: grade, limit: r.maxGrade },
    { key: 'width', ok: r.width >= D.ramp.widthMin - 1e-9, value: r.width, limit: D.ramp.widthMin },
  ];
  return { zs, ze, rise, length: w.L, grade, runs, landings, need, ok: checks.every((c) => c.ok), checks };
}

export function stepsLayout(st, surface, units) {
  const D = hardDefaults(units);
  const [a, b] = st.pts, L = Math.hypot(b.x - a.x, b.y - a.y);
  const zB = st.zBottom ?? ground(surface, a.x, a.y) ?? 0, zT = st.zTop ?? ground(surface, b.x, b.y) ?? 0;
  const H = zT - zB;
  if (!(H > 1e-6)) return { H, n: 0, riser: 0, going: 0, treads: 0, flights: 0, run: 0, length: L, fits: false, need: 0, checks: [{ key: 'height', ok: false, value: H }], treadLines: [], zB, zT };
  // as BimCraft's stairs (res-stair.js): n = ⌈H / riser max⌉ risers of H / n, n − 1 treads (the top level is the last step);
  // the going from the comfort rule 2R + G ≈ 630 mm, never under the minimum going
  const n = Math.ceil(H / st.riserMax - 1e-9), riser = H / n;
  const going = Math.max(st.goingMin, D.steps.comfort - 2 * riser);
  const flights = Math.ceil(n / st.maxRisers), landings = flights - 1, treads = n - 1;
  const run = treads * going + landings * (st.landing - going);
  const ux = (b.x - a.x) / (L || 1), uy = (b.y - a.y) / (L || 1), nx = -uy, ny = ux, hw = st.width / 2;
  const lines = [];
  let s = 0;
  for (let k = 1; k <= treads; k++) {   // the nosing of each tread, measured from the bottom step's front edge
    s += going;
    if (landings && k % st.maxRisers === 0 && k < treads) s += st.landing - going;
    lines.push([{ x: a.x + ux * s + nx * hw, y: a.y + uy * s + ny * hw }, { x: a.x + ux * s - nx * hw, y: a.y + uy * s - ny * hw }]);
  }
  const checks = [
    { key: 'riser', ok: riser <= st.riserMax + 1e-9, value: riser, limit: st.riserMax },
    { key: 'going', ok: going >= st.goingMin - 1e-9, value: going, limit: st.goingMin },
    { key: 'fits', ok: run <= L + 1e-9, value: run, limit: L },
  ];
  return { H, n, riser, going, treads, flights, landings, run, length: L, fits: run <= L + 1e-9, need: Math.max(0, run - L), checks, treadLines: lines, zB, zT, ux, uy };
}

/**
 * A retaining wall as a ground modifier (0.8 LA.4). The strip under the wall (its thickness wide) is rebuilt: the edge on the HIGH side (the side whose ground
 * is higher over the whole wall, so it never flips along it) is held at the ground there, station by station, so the wall's top follows the high side; a typed
 * `top` holds it at top minus the coping instead. The edge on the LOW side is held at `foot`, or at the ground there. The ground beyond the strip is not changed.
 */
export function wallPatch(h, surf, units) {
  const fail = (key) => ({ problems: [t(key)], region: null, points: [], breaklines: [], info: null });
  const w = walk(h.pts);
  if (!w.segs.length) return fail('ls.h.err.wallshort');
  const hw = h.thickness / 2, off = hw + (units === 'm' ? 0.05 : 0.15), rows = [];
  let offCount = 0;
  for (const s of stations(w, Math.max(units === 'm' ? 0.25 : 0.75, w.L / 400))) {
    const q = w.at(s), nx = -q.uy, ny = q.ux, gl = ground(surf, q.x + nx * off, q.y + ny * off), gr = ground(surf, q.x - nx * off, q.y - ny * off);
    if (gl === null || gr === null) { offCount++; continue; }
    rows.push({ q, nx, ny, gl, gr });
  }
  if (rows.length < 2) return fail('ls.g.err.off');
  const hiLeft = rows.reduce((v, r) => v + (r.gl - r.gr), 0) >= 0;
  const left = [], right = [];
  for (const r of rows) {
    const hi = h.top != null ? h.top - h.coping.thickness : hiLeft ? r.gl : r.gr, lo = h.foot != null ? h.foot : hiLeft ? r.gr : r.gl;
    left.push({ x: r.q.x + r.nx * hw, y: r.q.y + r.ny * hw, z: hiLeft ? hi : lo });
    right.push({ x: r.q.x - r.nx * hw, y: r.q.y - r.ny * hw, z: hiLeft ? lo : hi });
  }
  const region = [...left, ...right.slice().reverse()].map((q) => ({ x: q.x, y: q.y }));
  let a = 0;
  for (let i = 0; i < region.length; i++) { const p = region[i], q = region[(i + 1) % region.length]; a += p.x * q.y - q.x * p.y; }
  if (Math.abs(a) / 2 < 1e-9) return fail('ls.g.err.flat');
  const mean = (arr) => arr.reduce((v, q) => v + q.z, 0) / arr.length;
  return { problems: [], region, points: [], breaklines: [{ name: h.name + ' L', pts: left }, { name: h.name + ' R', pts: right }, { name: h.name + ' start', pts: [left[0], right[0]] }, { name: h.name + ' end', pts: [left.at(-1), right.at(-1)] }],
    info: { kind: 'wall', hiLeft, high: mean(hiLeft ? left : right), low: mean(hiLeft ? right : left), off: offCount } };
}

export function hardQuantities(ls, surface, 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 h of ls?.hardscape || []) {
    if (h.kind === 'paving') {
      const a = Math.abs(area(h.pts));
      out.push({ key: 'hard:' + h.id + ':area', name: t('ls.h.q.paving', { name: h.name }), unit: A, qty: r2(a) });
      h.layers.forEach((l, i) => out.push({ key: 'hard:' + h.id + ':layer' + i, name: t('ls.h.q.layer', { name: h.name, layer: l.name }), unit: V, qty: r2((a * l.thickness) / vPer) }));
    } else if (h.kind === 'path') { const st = pathStrip(h, surface); out.push({ key: 'hard:' + h.id + ':area', name: t('ls.h.q.path', { name: h.name }), unit: A, qty: r2(st.length * h.width) }); }
    else if (h.kind === 'wall') { const w = wallLayout(h, surface, units); out.push({ key: 'hard:' + h.id + ':face', name: t('ls.h.q.wallface', { name: h.name }), unit: A, qty: r2(w.faceArea) }, { key: 'hard:' + h.id + ':len', name: t('ls.h.q.walllen', { name: h.name }), unit: L, qty: r2(w.length) }); }
    else if (h.kind === 'kerb') out.push({ key: 'hard:' + h.id + ':len', name: t('ls.h.q.kerb', { name: h.name }), unit: L, qty: r2(walk(h.pts).L) });
    else if (h.kind === 'steps') { const s = stepsLayout(h, surface, units); out.push({ key: 'hard:' + h.id + ':risers', name: t('ls.h.q.steps', { name: h.name }), unit: 'EA', qty: s.n }); }   // i18n-ignore: a unit symbol
    else if (h.kind === 'ramp') { const r = rampLayout(h, surface, units); out.push({ key: 'hard:' + h.id + ':area', name: t('ls.h.q.ramp', { name: h.name }), unit: A, qty: r2(r.length * h.width) }); }
  }
  return out;
}