Pad daylight lines and the graded surface

/**
 * One slope line: from p0 (at design elevation z) outward along (ux, uy), up at `rate`/cut where the
 * ground is above z, down at `rate`/fill where it is below, to where it meets the surface.
 * → { x0, y0, x, y, z, d, kind: 'cut'|'fill'|'flat'|'off' }   ('off': left the surface first)
 */
export function castSlope(surface, p0, ux, uy, z, cut, fill, { rate = 1, step = 0.25, far = 1e4 } = {}) {
  const z0 = surface.elevationAt(p0.x, p0.y, 1e-6);
  if (z0 === null) return { x0: p0.x, y0: p0.y, x: p0.x, y: p0.y, z, d: 0, kind: 'off' };
  if (Math.abs(z0 - z) < 1e-9) return { x0: p0.x, y0: p0.y, x: p0.x, y: p0.y, z, d: 0, kind: 'flat' };
  const kind = z0 > z ? 'cut' : 'fill';
  const g = kind === 'cut' ? rate / cut : -rate / fill;   // design rise per unit outward
  const f = (d) => { const e = surface.elevationAt(p0.x + ux * d, p0.y + uy * d, 1e-6); return e === null ? null : z + g * d - e; };
  // f(0) has the sign of (design − ground); march until it changes, then bisect
  const s0 = Math.sign(f(0));
  let a = 0, b = step, fb = f(b);
  while (fb !== null && Math.sign(fb) === s0 && b < far) { a = b; b += step; fb = f(b); }
  if (fb === null || b >= far) return { x0: p0.x, y0: p0.y, x: p0.x + ux * a, y: p0.y + uy * a, z: z + g * a, d: a, kind: 'off' };
  for (let it = 0; it < 60 && b - a > 1e-7; it++) { const m = (a + b) / 2, fm = f(m); if (fm !== null && Math.sign(fm) === s0) a = m; else b = m; }
  const d = (a + b) / 2;
  return { x0: p0.x, y0: p0.y, x: p0.x + ux * d, y: p0.y + uy * d, z: z + g * d, d, kind };
}

const edgeN = (i) => { const a = poly[i], b = poly[(i + 1) % n], L = Math.hypot(b.x - a.x, b.y - a.y); return { x: (b.y - a.y) / L, y: -(b.x - a.x) / L, L }; };   // outward (right of a counter-clockwise edge)
for (let i = 0; i < n; i++) {
  const v = poly[i], nIn = edgeN((i - 1 + n) % n), nOut = edgeN(i);
  const sIn = sideOf((i - 1 + n) % n), sOut = sideOf(i);   // 0.7.1 71.22
  const turn = Math.atan2(nIn.x * nOut.y - nIn.y * nOut.x, nIn.x * nOut.x + nIn.y * nOut.y);   // > 0 at a convex corner
  if (sIn.wall && sOut.wall && Math.abs(turn) > 1e-9) {   // two walls: a mitre
    const bx = nIn.x + nOut.x, by = nIn.y + nOut.y, L = Math.hypot(bx, by);
    rays.push(wall(v, bx / L, by / L, wallT / Math.max(0.25, Math.cos(Math.abs(turn) / 2)), zv(v), sOut.k));
  } else if (turn > 1e-9) {
    // a wall's end: its own ray, then the slope's fan round the corner (without the ray along the wall)
    const a0 = Math.atan2(nIn.y, nIn.x), k = Math.max(1, Math.ceil(turn / fanStep));
    if (sIn.wall) rays.push(wall(v, nIn.x, nIn.y, wallT, zv(v), sIn.k));
    for (let j = sIn.wall ? 1 : 0; j <= (sOut.wall ? k - 1 : k); j++) { const a = a0 + (turn * j) / k; rays.push(cast(v, Math.cos(a), Math.sin(a), 1, zv(v), j * 2 <= k ? (sIn.wall ? sOut : sIn) : (sOut.wall ? sIn : sOut))); }
    if (sOut.wall) rays.push(wall(v, nOut.x, nOut.y, wallT, zv(v), sOut.k));
  } else if (turn < -1e-9) {
    const bx = nIn.x + nOut.x, by = nIn.y + nOut.y, L = Math.hypot(bx, by);
    rays.push(cast(v, bx / L, by / L, Math.cos(Math.abs(turn) / 2), zv(v), sIn.wall ? sOut : sIn));
    concave.push({ i, v, bx: bx / L, by: by / L });
  } else rays.push(sOut.wall || sIn.wall ? wall(v, nOut.x, nOut.y, wallT, zv(v), sOut.wall ? sOut.k : sIn.k) : cast(v, nOut.x, nOut.y, 1, zv(v), sOut));   // in line: a wall runs to the corner
  // along the edge
  const b = poly[(i + 1) % n], m = Math.max(1, Math.ceil(nOut.L / sp));
  for (let j = 1; j < m; j++) {
    const t = j / m, p = { x: v.x + (b.x - v.x) * t, y: v.y + (b.y - v.y) * t }, ze = zv(v) + (zv(b) - zv(v)) * t;
    const r = sOut.wall ? wall(p, nOut.x, nOut.y, wallT, ze, sOut.k) : cast(p, nOut.x, nOut.y, 1, ze, sOut);
    r.edge = i; rays.push(r);
  }
}

for (const c of concave) {
  const side = (x, y) => c.bx * (y - c.v.y) - c.by * (x - c.v.x);
  for (let k = rays.length - 1; k >= 0; k--) {
    const r = rays[k];
    if (r.edge !== c.i && r.edge !== (c.i - 1 + n) % n) continue;
    const s0 = side(r.x0, r.y0), s1 = side(r.x, r.y);
    if ((s0 > 1e-9 && s1 < -1e-9) || (s0 < -1e-9 && s1 > 1e-9)) rays.splice(k, 1);
  }
}

function padPatch(surf, pad) {
  const dl = daylightPad(surf, pad, pad.options || {});
  if (dl.problems.length || !dl.rays.length) return { problems: dl.problems.length ? dl.problems : [t('grade.none')], region: null, points: [], breaklines: [], info: dl };
  const region = dl.daylight, padZ = Number(pad.z), bl = [], zv = (p) => (Number.isFinite(p.z) ? p.z : padZ);
  bl.push({ name: t('grade.bl.edge', { name: pad.name || t('scene.pad.default') }), pts: [...dl.poly, dl.poly[0]].map((p) => ({ x: p.x, y: p.y, z: zv(p) })) });
  bl.push({ name: t('grade.bl.daylight', { name: pad.name || t('scene.pad.default') }), pts: [...region, region[0]].map((p) => ({ x: p.x, y: p.y, z: p.z })) });
  for (const r of dl.rays) if (r.d > 1e-6) bl.push({ name: 'slope', pts: [{ x: r.x0, y: r.y0, z: r.z0 ?? padZ }, { x: r.x, y: r.y, z: r.z }] });
  return { problems: [], region, points: [], breaklines: bl, info: dl };
}

/**
 * The base surface with every item graded in, in order (a later item grades against the result of the
 * earlier ones). An item is a pad ({ pts, z, cut, fill, name }) or anything with
 * `patch(surface) → { problems, region, points, breaklines, info }` (a corridor). The item's region
 * (its daylight polygon) replaces the base there: base points inside it and base breaklines touching it
 * are dropped, the item's own points and breaklines go in, and the lot is triangulated again by
 * `build(input)` (buildSurface, passed in so this module stays independent).
 * → { surface (null when nothing could be graded), report: { notes, errors, items: [{name, problems}] },
 *     regions (null for a failed item), items (each daylightPad result or patch info) }
 */
export function gradedSurface(base, basePoints, baseBreaklines, items, build) {
  const regions = [], report = { notes: [], errors: [], items: [] }, infos = [];
  let surf = base, points = basePoints.slice(), breaklines = baseBreaklines.slice(), any = false;
  for (const item of items) {
    const pt = item.patch ? item.patch(surf) : padPatch(surf, item);
    report.items.push({ name: item.name, problems: pt.problems });
    infos.push(pt.info);
    if (pt.problems.length || !pt.region || pt.region.length < 3) { regions.push(null); continue; }
    const region = pt.region;
    regions.push(region);
    // inside the region or on its edge (a ground point on the edge would pin the new surface to the old ground)
    const inside = (p) => pointInPoly(p.x, p.y, region) || nearPoly(p, region, 1e-6);
    points = points.filter((p) => !inside(p));
    breaklines = breaklines.filter((b) => b.pts.every((p) => !inside(p)) && !crossesPoly(b.pts, region));
    points.push(...pt.points);
    breaklines.push(...pt.breaklines);
    const built = build({ points, breaklines, boundary: null });
    if (!built.surface) { report.errors.push(...built.report.errors); return { surface: null, report, regions, items: infos }; }
    surf = built.surface; any = true;
    report.notes.push(...built.report.notes);
  }
  return { surface: any ? surf : null, report, regions, items: infos };
}

function properCross(a, b, c, d) {
  const o = (p, q, r) => (q.x - p.x) * (r.y - p.y) - (q.y - p.y) * (r.x - p.x);
  const d1 = o(a, b, c), d2 = o(a, b, d), d3 = o(c, d, a), d4 = o(c, d, b);
  return ((d1 > 1e-12 && d2 < -1e-12) || (d1 < -1e-12 && d2 > 1e-12)) && ((d3 > 1e-12 && d4 < -1e-12) || (d3 < -1e-12 && d4 > 1e-12));
}

function nearPoly(p, poly, tol) {
  for (let i = 0; i < poly.length; i++) {
    const a = poly[i], b = poly[(i + 1) % poly.length], dx = b.x - a.x, dy = b.y - a.y, L = dx * dx + dy * dy;
    const t = L ? Math.max(0, Math.min(1, ((p.x - a.x) * dx + (p.y - a.y) * dy) / L)) : 0;
    if (Math.hypot(p.x - a.x - dx * t, p.y - a.y - dy * t) <= tol) return true;
  }
  return false;
}