Hours of direct sun on the ground and on walls

export function sunSamples({ date, utcOffset, lat, lon, stepMin = 15 }) {
  const m = /^(\d{4})-(\d{2})-(\d{2})$/.exec(String(date));
  if (!m) throw new Error('bad_date');
  const day0 = Date.UTC(+m[1], +m[2] - 1, +m[3]);
  const n = Math.round(1440 / stepMin), dirs = [], alt = [], az = [];
  for (let k = 0; k < n; k++) {
    const minute = (k + 0.5) * stepMin;   // the middle of each step
    const p = sunPosition(new Date(day0 + (minute - utcOffset * 60) * 60000), lat, lon);
    if (p.altitude > 0) { const v = sunVector(p); dirs.push(v[0], v[1], v[2]); alt.push(p.altitude); az.push(p.azimuth); }
  }
  return { dirs: Float64Array.from(dirs), alt, az, hours: stepMin / 60, day: (dirs.length / 3) * (stepMin / 60) };
}

/** Does the ray from (px, py, pz) toward direction s pass through the prism? */
function hitsPrism(px, py, pz, sx, sy, sz, P) {
  if (sz <= 1e-9) return false;
  let lo = Math.max((P.zlo - pz) / sz, 1e-9), hi = (P.zhi - pz) / sz;
  if (hi <= lo) return false;
  const h2 = sx * sx + sy * sy;
  if (h2 < 1e-18) {   // the sun overhead: the ray is a vertical line
    if (px < P.x0 || px > P.x1 || py < P.y0 || py > P.y1) return false;
    return inPoly(px, py, P);
  }
  for (const [p, s, a, b] of [[px, sx, P.x0, P.x1], [py, sy, P.y0, P.y1]]) {   // the box of the footprint, as a slab on each axis
    if (Math.abs(s) < 1e-12) { if (p < a || p > b) return false; continue; }
    let t1 = (a - p) / s, t2 = (b - p) / s;
    if (t1 > t2) { const q = t1; t1 = t2; t2 = q; }
    if (t1 > lo) lo = t1;
    if (t2 < hi) hi = t2;
    if (hi <= lo) return false;
  }
  // where the sun's line (the whole line) crosses the footprint's edges, as t along it; inside between every other pair
  const L = Math.sqrt(h2), ux = sx / L, uy = sy / L, n = P.n;
  const ts = [];
  for (let i = 0; i < n; i++) {
    const j = i + 1 === n ? 0 : i + 1;
    const da = ux * (P.ys[i] - py) - uy * (P.xs[i] - px), db = ux * (P.ys[j] - py) - uy * (P.xs[j] - px);
    if ((da > 0) === (db > 0)) continue;
    const f = da / (da - db), qx = P.xs[i] + (P.xs[j] - P.xs[i]) * f - px, qy = P.ys[i] + (P.ys[j] - P.ys[i]) * f - py;
    ts.push((qx * ux + qy * uy) / L);   // t in units of the ray parameter (sx, sy have length L)
  }
  if (ts.length < 2) return false;
  ts.sort((a, b) => a - b);
  for (let k = 0; k + 1 < ts.length; k += 2) if (ts[k] < hi && ts[k + 1] > lo && Math.min(ts[k + 1], hi) - Math.max(ts[k], lo) > 1e-9) return true;
  return false;
}

function litLocal(world, px, py, pz, sx, sy, sz) {
  if (sz <= 1e-9) return false;
  for (const P of world.prisms) if (hitsPrism(px, py, pz, sx, sy, sz, P)) return false;
  const T = world.terrain;
  if (T && pz < world.zmax) {   // march over the ground, a cell at a time, until the ray is above the highest ground
    const h = Math.hypot(sx, sy);
    if (h > 1e-9) {
      const ds = T.cell, rise = (sz / h) * ds, dx = (sx / h) * ds, dy = (sy / h) * ds, kmax = Math.min(600, Math.ceil((world.zmax - pz) / rise));
      let x = px, y = py, zz = pz;
      for (let k = 1; k <= kmax; k++) {
        x += dx; y += dy; zz += rise;
        const g = sampleRaster(T, x, y);
        if (g > zz + 1e-3) return false;
      }
    }
  }
  return true;
}

const facadeOut = facades.map((F) => {
  const floors = Array.from({ length: world.prisms.find((P) => P.id === F.mass).floors }, () => ({ s: 0, n: 0 }));
  for (const p of F.pts) { p.hours /= nd; floors[p.floor].s += p.hours; floors[p.floor].n++; }
  const fl = floors.map((q) => (q.n ? q.s / q.n : 0));
  return { mass: F.mass, name: F.name, edge: F.edge, normal: F.normal, length: F.length, floors: fl, mean: fl.reduce((s, v) => s + v, 0) / fl.length,
    points: F.pts.map((p) => ({ x: p.x + origin.x, y: p.y + origin.y, z: p.z, floor: p.floor, hours: p.hours })) };
});

export function facadeCsv(r) {
  const rows = [['mass', 'wall', 'facing_deg', 'floor', 'sun_hours_per_day']];
  for (const f of r.facades) f.floors.forEach((h, k) => rows.push([f.name, f.edge + 1, Math.round(((90 - (f.normal * 180) / Math.PI) % 360 + 360) % 360), k + 1, h.toFixed(2)]));
  return rows.map((row) => row.map(csvCell).join(',')).join('\n') + '\n';
}