Building mass areas, levels and base earthwork

export function signedArea(pts) { let a = 0; for (let i = 0; i < pts.length; i++) { const p = pts[i], q = pts[(i + 1) % pts.length]; a += p.x * q.y - q.x * p.y; } return a / 2; }

export const massArea = (m) => Math.abs(signedArea(m.pts));
export const massGfa = (m) => massArea(m) * m.floors;
export const massHeight = (m) => m.floors * m.floorHeight;

export function centroid(pts) {
  const A = signedArea(pts);
  if (Math.abs(A) < 1e-12) return { x: pts.reduce((s, p) => s + p.x, 0) / pts.length, y: pts.reduce((s, p) => s + p.y, 0) / pts.length };
  let cx = 0, cy = 0;
  for (let i = 0; i < pts.length; i++) { const p = pts[i], q = pts[(i + 1) % pts.length], k = p.x * q.y - q.x * p.y; cx += (p.x + q.x) * k; cy += (p.y + q.y) * k; }
  return { x: cx / (6 * A), y: cy / (6 * A) };
}

/** Ground heights under the footprint: a grid of `cells` × `cells` over its bounds (cells inside it) plus its corners.
 *  elevAt(x, y) → z | null. Each sample carries the area it stands for (dA), so volumes are sums. */
export function groundUnder(m, elevAt, { cells = 40 } = {}) {
  const P = m.pts;
  let x0 = Infinity, y0 = Infinity, x1 = -Infinity, y1 = -Infinity;
  for (const p of P) { 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 nx = cells, ny = cells, dx = (x1 - x0) / nx, dy = (y1 - y0) / ny;
  const samples = [];
  let missing = 0;
  for (let j = 0; j < ny; j++) for (let i = 0; i < nx; i++) {
    const x = x0 + (i + 0.5) * dx, y = y0 + (j + 0.5) * dy;
    if (!pointInPoly(x, y, P)) continue;
    const z = elevAt(x, y);
    if (fin(z)) samples.push({ x, y, z }); else missing++;
  }
  // the cells cover the footprint to within a cell's width; scale their area to the exact footprint area
  const A = massArea(m), n = samples.length + missing;
  const cellArea = n ? A / n : 0;
  for (const s of samples) s.dA = cellArea;
  let min = Infinity, max = -Infinity, sum = 0, w = 0;
  const corners = P.map((p) => ({ x: p.x, y: p.y, z: elevAt(p.x, p.y) })).filter((c) => fin(c.z));
  for (const s of samples) { min = Math.min(min, s.z); max = Math.max(max, s.z); sum += s.z; w++; }
  for (const c of corners) { min = Math.min(min, c.z); max = Math.max(max, c.z); }
  if (!w) return corners.length ? { min, max, mean: corners.reduce((s, c) => s + c.z, 0) / corners.length, n: corners.length, missing: P.length - corners.length, cellArea, samples: [] } : null;
  return { min, max, mean: sum / w, n: w, missing, cellArea, samples };
}

export function baseLevel(m, ground) {
  if (!ground) return 0;
  return m.base === 'podium' ? ground.max : m.base === 'cut' ? ground.min : ground.mean;
}

export function baseVolumes(m, ground, z0) {
  let fill = 0, cut = 0;
  for (const s of ground?.samples || []) { if (s.z < z0) fill += (z0 - s.z) * s.dA; else cut += (s.z - z0) * s.dA; }
  return { fill, cut };
}

export function levels(m, z0) {
  return Array.from({ length: m.floors }, (_, i) => ({ n: i + 1, name: t('ms.level', { n: i + 1 }), z: z0 + i * m.floorHeight, top: z0 + (i + 1) * m.floorHeight, h: m.floorHeight }));
}

/** Push/pull: the floor count whose height is nearest to H (at least one floor). */
export function setHeight(m, H) { return Math.max(1, Math.min(MAX_FLOORS, Math.round(H / m.floorHeight))); }

/** Ear clipping of a simple polygon, any winding; triangles as indices into pts, counter-clockwise. */
export function triangulate(pts) {
  const n = pts.length;
  const idx = pts.map((_, i) => i);
  if (signedArea(pts) < 0) idx.reverse();
  const out = [];
  const cross = (a, b, c) => (pts[b].x - pts[a].x) * (pts[c].y - pts[a].y) - (pts[b].y - pts[a].y) * (pts[c].x - pts[a].x);
  const inTri = (p, a, b, c) => cross(a, b, p) >= -1e-12 && cross(b, c, p) >= -1e-12 && cross(c, a, p) >= -1e-12;
  let guard = 0;
  while (idx.length > 3 && guard++ < n * n) {
    let clipped = false;
    for (let k = 0; k < idx.length; k++) {
      const a = idx[(k + idx.length - 1) % idx.length], b = idx[k], c = idx[(k + 1) % idx.length];
      if (cross(a, b, c) <= 1e-12) continue;   // reflex or flat
      let ear = true;
      for (const p of idx) { if (p === a || p === b || p === c) continue; if (inTri(p, a, b, c)) { ear = false; break; } }
      if (!ear) continue;
      out.push(a, b, c); idx.splice(k, 1); clipped = true; break;
    }
    if (!clipped) { // a degenerate sliver: drop the flattest corner so the loop always ends
      let best = 0, bv = Infinity;
      for (let k = 0; k < idx.length; k++) { const v = Math.abs(cross(idx[(k + idx.length - 1) % idx.length], idx[k], idx[(k + 1) % idx.length])); if (v < bv) { bv = v; best = k; } }
      idx.splice(best, 1);
    }
  }
  if (idx.length === 3 && cross(idx[0], idx[1], idx[2]) > 1e-12) out.push(idx[0], idx[1], idx[2]);
  return out;
}