/*!
 * Tectum
 * Copyright © 2026 Machiel Heinen.
 * Alle rechten voorbehouden. Gebruik uitsluitend met schriftelijke toestemming.
 * Zie LICENTIE.md.
 */
// ============================================================
// lighting/lighting-model.js — LightingModel: ENIGE bron van de
// buitenverlichting van een woning. Geen DOM.
//
// Woning-breed (settings.lighting): type, lichtrichting en alle afstanden.
//   mode: 'geen' | 'spots' (boeideel-spots, alleen waar boeidelen zijn) |
//         'gevel' (gevellampen), direction: 'both' | 'down' | 'up'.
//
// Gevellampen worden per GEVEL verdeeld, niet per wand: wandstukken in
// hetzelfde gevelvlak die op elkaar aansluiten (ook over een naad tussen
// units) vormen samen één gevel van hoek tot hoek. De balklogica per wand
// blijft ongewijzigd; alleen de lampen lopen uniform door.
// Op lamphoogte (standaard 1950 mm) worden openingen incl. raamwerk
// (koningsstijl/dorpels) van de gevel afgetrokken. Op elk vrij stuk van
// minstens minWallWidth (2000 mm) komen lampen: de eerste en laatste op
// endOffset (300 mm) van het uiteinde (hoek of opening), daartussen
// verdeeld met min/max h.o.h. (zelfde verdeling als stijlen). Smallere vrije
// stukken krijgen geen lampen. Gevellampen en boeideel-spots sluiten elkaar
// uit: bij 'gevel' komen er nooit spots.
// Per wand(zijde) blijft een harde override mogelijk
// (unit.lighting.walls[side]): 'auto' (standaard), 'openingen' (lampen op
// openingOffset = 500 mm naast elke opening, bijv. slaapkamers) of 'geen'.
//
// Plain script, geladen na core/geometry.js en roof-model.js.
// ============================================================

window.LightingModel = (() => {
  const DEFAULT_SETTINGS = {
    mode: 'spots',        // 'geen' | 'spots' | 'gevel'
    direction: 'both',    // gevellampen: 'both' | 'down' | 'up'
    lampHeight: 1950,     // mm boven vloer
    lampMin: 1500,        // mm h.o.h. gevellampen
    lampMax: 3000,
    minWallWidth: 2000,   // kleinste vrije gevelbreedte voor gevellampen
    endOffset: 300,       // eerste/laatste lamp vanaf hoek/uiteinde
    openingOffset: 500    // override: lampen zoveel naast elke opening
  };
  const MODES = { geen: 'Geen', spots: 'Boeideel-spots', gevel: 'Gevellampen' };
  const DIRECTIONS = { both: 'Boven én onder', down: 'Alleen onder', up: 'Alleen boven' };
  const WALL_OVERRIDES = { auto: 'Automatisch', openingen: 'Naast openingen (override)', geen: 'Geen lampen' };

  // Per unit alleen nog de override per wandzijde.
  function createDefaultUnitLighting() {
    return { walls: {} };
  }

  function normalizeSettings(settings) {
    return Object.assign({}, DEFAULT_SETTINGS, settings || {});
  }

  // Spots op een lijnstuk A -> B: op beide uiteinden + daartussen verdeeld.
  function spotsBetween(A, B, min, max, out) {
    const len = Math.hypot(B.x - A.x, B.z - A.z);
    out.push({ x: A.x, z: A.z }, { x: B.x, z: B.z });
    if (len < 1) return;
    calculateSegmentPositions(len, min, max).forEach(p => out.push({ x: A.x + (B.x - A.x) * p / len, z: A.z + (B.z - A.z) * p / len }));
  }

  // Lampen die dichter dan `min` bij elkaar staan worden samengevoegd tot één
  // lamp in het midden, tot alle onderlinge afstanden >= min zijn.
  function enforceMinSpacing(positions, min) {
    let pts = positions.slice().sort((a, b) => a - b);
    let changed = true;
    while (changed && pts.length > 1) {
      changed = false;
      for (let i = 0; i < pts.length - 1; i++) {
        if (pts[i + 1] - pts[i] < min - 0.5) {
          pts.splice(i, 2, (pts[i] + pts[i + 1]) / 2);
          changed = true;
          break;
        }
      }
    }
    return pts;
  }

  // Aftrekken van intervallen: [lo, hi] min blocked -> vrije intervallen.
  function freeIntervals(lo, hi, blocked) {
    const free = [];
    let cursor = lo;
    blocked.slice().sort((p, q) => p[0] - q[0]).forEach(([a, b]) => {
      if (a > cursor) free.push([cursor, Math.min(a, hi)]);
      cursor = Math.max(cursor, b);
    });
    if (cursor < hi) free.push([cursor, hi]);
    return free.filter(([a, b]) => b - a > 1);
  }

  // Alles voor de hele woning. units = HouseModel-parts.units (met
  // walls[].pieces[].config/place), stateUnits = state.units (overrides per
  // wand), edge = RoofModel.computeEdge-resultaat (edge.spots wordt hier
  // gevuld). Zet per wandstuk p.lamps = [{ u, y }] (voor editor/PDF).
  // Geeft { lamps: [{ x, y, z, normal, direction, element, u, yLocal }] }.
  function compute(settings, roofSettings, units, stateUnits, edge) {
    const s = normalizeSettings(settings);
    const overrides = {};
    stateUnits.forEach(u => { overrides[u.id] = (u.lighting && u.lighting.walls) || {}; });

    // 1. Buiten-wandstukken als lijnstukken in hun gevelvlak (wereld-mm).
    const segs = [];
    units.forEach(u => u.walls.forEach(w => w.pieces.forEach(p => {
      p.lamps = [];
      const W = p.place.width;
      // Lampen hangen op de afgewerkte gevel: wandvlak + kruislat + bekleding.
      const T = p.place.thickness + 2 * WallModel.claddingOffset(p.buitenMateriaal);
      const normal = { x: p.place.normal.x, z: p.place.normal.y }; // place.normal is {x, y} (plattegrond)
      const axis = Math.abs(normal.z) > 0.5 ? 'x' : 'z';
      const perp = axis === 'x' ? 'z' : 'x';
      const q0 = UnitModel.localToWorld(p.place, -W / 2, T / 2), q1 = UnitModel.localToWorld(p.place, W / 2, T / 2);
      segs.push({
        piece: p, normal, axis, perp, line: q0[perp],
        sAt0: q0[axis], sAtW: q1[axis], s0: Math.min(q0[axis], q1[axis]), s1: Math.max(q0[axis], q1[axis]),
        override: overrides[u.id][w.side] || 'auto'
      });
    })));
    const uToS = (sg, u) => sg.sAt0 + (sg.sAtW - sg.sAt0) * (u / sg.piece.place.width);
    const sToU = (sg, v) => (v - sg.sAt0) / (sg.sAtW - sg.sAt0) * sg.piece.place.width;

    // 2. Gevels: zelfde normaal + zelfde gevelvlak + aansluitend.
    const runs = groupFacadeRuns(segs); // core/geometry.js

    // 3. Lampen per gevel.
    const lamps = [];
    const H = s.lampHeight;
    const addLamp = (run, v) => {
      const sg = run.segs.find(x => v >= x.s0 - 0.5 && v <= x.s1 + 0.5);
      if (!sg) return;
      const u = sToU(sg, v);
      const pt = run.axis === 'x' ? { x: v, z: run.line } : { x: run.line, z: v };
      sg.piece.lamps.push({ u, y: H });
      lamps.push({ x: pt.x, z: pt.z, y: sg.piece.place.floorTop + H, normal: run.normal, direction: s.direction, element: sg.piece.element, u, yLocal: H });
    };
    if (s.mode === 'gevel') {
      runs.forEach(run => {
        const blocked = [];
        const pos = []; // lampposities langs deze gevel (wereld-mm)
        run.segs.forEach(sg => {
          const cfg = sg.piece.config, sW = cfg.studWidth;
          const low = Math.min(cfg.wallHeightLeft, cfg.wallHeightRight) < H + 100;
          if (sg.override === 'geen' || low) { blocked.push([sg.s0, sg.s1]); return; }
          if (sg.override === 'openingen') {
            // Harde override: lampen naast elke opening, dit stuk doet verder niet mee.
            blocked.push([sg.s0, sg.s1]);
            cfg.openings.forEach(op => [op.x - s.openingOffset, op.x + op.w + s.openingOffset]
              .filter(u => u >= 0 && u <= cfg.wallWidth).forEach(u => pos.push(uToS(sg, u))));
            return;
          }
          cfg.openings.filter(op => op.y - sW <= H && op.y + op.h + sW >= H).forEach(op => {
            const a = uToS(sg, op.x - sW), b = uToS(sg, op.x + op.w + sW);
            blocked.push([Math.min(a, b), Math.max(a, b)]);
          });
        });
        freeIntervals(run.s0, run.s1, blocked).forEach(([a, b]) => {
          if (b - a < s.minWallWidth) return; // te smal: geen lampen
          const first = a + s.endOffset, last = b - s.endOffset;
          pos.push(first);
          calculateSegmentPositions(last - first, s.lampMin, s.lampMax).forEach(p => pos.push(first + p));
          pos.push(last);
        });
        // Min. h.o.h. geldt over ALLE lampen van de gevel samen (ook bij
        // afstand hoek/opening, overrides en de grens tussen wanden).
        enforceMinSpacing(pos, s.lampMin).forEach(v => addLamp(run, v));
      });
      units.forEach(u => u.walls.forEach(w => w.pieces.forEach(p => p.lamps.sort((a, b) => a.u - b.u))));
    }

    // 4. Boeideel-spots per dakrand-ribbe (alleen bij type 'spots').
    if (edge) {
      const spots = [];
      if (s.mode === 'spots') {
        const rs = RoofModel.normalizeSettings(roofSettings);
        edge.segments.filter(sg => sg.fascia).forEach(sg => spotsBetween(sg.spotA, sg.spotB, rs.spotMin, rs.spotMax, spots));
      }
      edge.spots = spots.filter((p, i) => spots.findIndex(q => Math.hypot(q.x - p.x, q.z - p.z) < 5) === i);
    }
    return { lamps };
  }

  function createMaterials() {
    return {
      housingMaterial: new THREE.MeshStandardMaterial({ color: 0x2b2f33, roughness: 0.5, metalness: 0.3 }),
      glowMaterial: new THREE.MeshStandardMaterial({ color: 0xfff4d0, emissive: 0xffe2a0, emissiveIntensity: 1 }),
      beamMaterial: new THREE.MeshBasicMaterial({ color: 0xffe9a8, transparent: true, opacity: 0.16, depthWrite: false, side: THREE.DoubleSide })
    };
  }

  // 3D: behuizing op het gevelvlak + lichtbundel(s) omhoog/omlaag.
  function build3D(lamps, materials) {
    const toM = 0.001;
    const group = new THREE.Group();
    const w = 0.08, h = 0.16, d = 0.07, beamH = 0.7, beamR = 0.22;
    lamps.forEach(l => {
      const cx = l.x * toM + l.normal.x * d / 2, cz = l.z * toM + l.normal.z * d / 2, cy = l.y * toM;
      const alongX = Math.abs(l.normal.z) > 0.5;
      const box = new THREE.Mesh(new THREE.BoxGeometry(alongX ? w : d, h, alongX ? d : w), materials.housingMaterial);
      box.position.set(cx, cy, cz);
      group.add(box);
      const addGlow = (sign) => {
        const g = new THREE.Mesh(new THREE.BoxGeometry(alongX ? w * 0.8 : d * 0.8, 0.006, alongX ? d * 0.8 : w * 0.8), materials.glowMaterial);
        g.position.set(cx, cy + sign * h / 2, cz);
        group.add(g);
        const cone = new THREE.Mesh(new THREE.ConeGeometry(beamR, beamH, 20, 1, true), materials.beamMaterial);
        cone.userData.beam = true; // verborgen in de volle render (dan schijnt echt licht)
        if (sign > 0) cone.rotation.x = Math.PI; // punt bij de lamp, breed naar boven
        cone.position.set(cx, cy + sign * (h / 2 + beamH / 2), cz);
        group.add(cone);
      };
      if (l.direction !== 'up') addGlow(-1);
      if (l.direction !== 'down') addGlow(1);
    });
    return group;
  }

  // Volle render: elke gevellamp (per lichtrichting) en elke boeideel-spot
  // wordt een echte SpotLight. Gevellampen staan net buiten het gevelvlak en
  // schijnen langs de gevel omhoog/omlaag; spots schijnen recht naar beneden.
  // spots = [{ x, z }] (mm), spotY = hoogte onderkant boeideel (mm).
  function buildLights3D(lamps, spots, spotY) {
    const toM = 0.001;
    const group = new THREE.Group();
    const add = (x, y, z, dirY, intensity, angle, distance) => {
      const light = new THREE.SpotLight(0xffd9a0, intensity, distance, angle, 0.6, 1.5);
      light.position.set(x, y, z);
      light.target.position.set(x, y + dirY * 2, z);
      group.add(light);
      group.add(light.target);
    };
    lamps.forEach(l => {
      const x = l.x * toM + l.normal.x * 0.12, z = l.z * toM + l.normal.z * 0.12, y = l.y * toM;
      if (l.direction !== 'up') add(x, y - 0.09, z, -1, 3, 0.55, 4.5);
      if (l.direction !== 'down') add(x, y + 0.09, z, 1, 3, 0.55, 4.5);
    });
    (spots || []).forEach(p => add(p.x * toM, spotY * toM - 0.02, p.z * toM, -1, 2.5, 0.6, 5.5));
    return group;
  }

  return { DEFAULT_SETTINGS, MODES, DIRECTIONS, WALL_OVERRIDES, createDefaultUnitLighting, normalizeSettings, compute, createMaterials, build3D, buildLights3D };
})();