/*!
 * Tectum
 * Copyright © 2026 Machiel Heinen.
 * Alle rechten voorbehouden. Gebruik uitsluitend met schriftelijke toestemming.
 * Zie LICENTIE.md.
 */
// Deuren en ramen tellen als wand. Wanduiteinden tellen END_TOL langer, zodat een kiertje bij
// een getekende binnenwand de ruimte niet laat doorlopen.

window.RoomModel = (() => {
  const EPS = 0.5;
  const END_TOL = 15;
  const MIN_AREA_MM2 = 0.05e6;
  const FACE_OFF = 2;
  const CEIL_STEP = 300;
  const CEIL_MIN = 1800, CEIL_MAX = 4500;

  const TYPES = {
    woonkamer: { label: 'Woonkamer', color: '#e6c36a' },
    keuken: { label: 'Keuken', color: '#f0a05a', floor: 'tegel_grijs' },
    woonkeuken: { label: 'Woonkeuken', color: '#e9b35f' },
    slaapkamer: { label: 'Slaapkamer', color: '#8fb3e8' },
    badkamer: { label: 'Badkamer', color: '#5fc9c0', floor: 'tegel_antraciet', fibo: { decor: 'wit_tegel', height: null }, ceiling: 2600 },
    toilet: { label: 'Toilet', color: '#7cc7e3', floor: 'tegel_antraciet', fibo: { decor: 'wit_tegel', height: 1200 }, ceiling: 2600 },
    hal: { label: 'Hal / entree', color: '#c9bfae' },
    berging: { label: 'Berging', color: '#a99a86' },
    techniek: { label: 'Techniek', color: '#9a9aa6' },
    wasruimte: { label: 'Wasruimte', color: '#9fd3a4', floor: 'tegel_grijs' },
    werkkamer: { label: 'Werkkamer', color: '#c3a6e0' },
    overig: { label: 'Overig', color: '#b8b8b8' }
  };

  const FIBO = {
    wit_tegel: { label: 'Wit, tegel 300×600', color: '#f1f0ec', jointColor: '#cfcdc6', tile: { w: 600, h: 300, joint: 3 } },
    grijs_tegel: { label: 'Lichtgrijs, tegel 300×600', color: '#c9c8c3', jointColor: '#a3a29d', tile: { w: 600, h: 300, joint: 3 } },
    antraciet_tegel: { label: 'Antraciet, tegel 300×600', color: '#55575a', jointColor: '#3a3b3d', tile: { w: 600, h: 300, joint: 3 } },
    wit_metro: { label: 'Wit, metrotegel 100×200', color: '#f3f2ee', jointColor: '#c8c6be', tile: { w: 200, h: 100, joint: 2 } },
    beton: { label: 'Betonlook (naadloos)', color: '#a6a39c' }
  };

  const isHex = (v) => /^#[0-9a-f]{6}$/i.test(v || '');

  function applyType(room, type) {
    const T = TYPES[type] || TYPES.overig;
    room.type = TYPES[type] ? type : 'overig';
    room.floor = T.floor || null;
    room.fibo = T.fibo ? Object.assign({}, T.fibo) : null;
    room.ceiling = T.ceiling || null;
    room.paint = null;
    return room;
  }

  function create(state, rect, x, z, type) {
    const id = (state.rooms || []).reduce((m, r) => Math.max(m, r.id || 0), 0) + 1;
    return applyType({ id, unitId: rect.id, x: Math.round(x - rect.x0), z: Math.round(z - rect.z0), name: '' }, type);
  }

  function normalizeRoom(r, i) {
    return {
      id: r.id > 0 ? r.id : i + 1,
      unitId: String(r.unitId || 'A'), x: Number(r.x) || 0, z: Number(r.z) || 0,
      type: TYPES[r.type] ? r.type : 'overig',
      name: typeof r.name === 'string' ? r.name : '',
      floor: r.floor && FloorModel.FINISHES[r.floor] ? r.floor : null,
      paint: isHex(r.paint) ? r.paint : null,
      fibo: r.fibo && FIBO[r.fibo.decor] ? { decor: r.fibo.decor, height: r.fibo.height > 0 ? Math.round(r.fibo.height) : null } : null,
      ceiling: r.ceiling > 0 ? Math.max(CEIL_MIN, Math.min(CEIL_MAX, Math.round(r.ceiling))) : null
    };
  }
  function normalize(list, unitIds) {
    return (Array.isArray(list) ? list : []).map(normalizeRoom).filter(r => !unitIds || unitIds.includes(r.unitId));
  }

  const q = (v) => Math.round(v * 10) / 10;
  function bsearch(arr, v) {
    if (!arr.length || v < arr[0] || v > arr[arr.length - 1]) return -1;
    let lo = 0, hi = arr.length - 1;
    while (hi - lo > 1) { const m = (lo + hi) >> 1; if (arr[m] <= v) lo = m; else hi = m; }
    return lo;
  }

  function buildGrid(pieces, rects) {
    const blockers = [];
    pieces.forEach(p => {
      if (p.place.baseY) return; // opbouw boven een lager dak staat niet op de vloer
      const pl = p.place, alongX = Math.abs(Math.sin(pl.rotY)) < 0.5;
      const hw = pl.width / 2, ht = pl.thickness / 2;
      const r = alongX ? [pl.cx - hw, pl.cx + hw, pl.cz - ht, pl.cz + ht] : [pl.cx - ht, pl.cx + ht, pl.cz - hw, pl.cz + hw];
      const ext = alongX ? [r[0] - END_TOL, r[1] + END_TOL, r[2], r[3]] : [r[0], r[1], r[2] - END_TOL, r[3] + END_TOL];
      blockers.push({ piece: p, r: r.map(q), ext: ext.map(q), alongX });
    });
    const sx = new Set(), sz = new Set();
    const addR = (r) => { sx.add(r[0]); sx.add(r[1]); sz.add(r[2]); sz.add(r[3]); };
    const unitR = rects.map(r => [r.x0, r.x1, r.z0, r.z1].map(q));
    unitR.forEach(addR);
    blockers.forEach(b => { addR(b.r); addR(b.ext); });
    const xs = [...sx].sort((a, b) => a - b), zs = [...sz].sort((a, b) => a - b);
    const nx = Math.max(0, xs.length - 1), nz = Math.max(0, zs.length - 1);
    const ix = new Map(xs.map((v, i) => [v, i])), iz = new Map(zs.map((v, i) => [v, i]));
    const unitOf = new Int16Array(nx * nz).fill(-1);
    const block = new Int32Array(nx * nz).fill(-1);
    const mark = (arr, r, val, onlyEmpty) => {
      const i0 = ix.get(r[0]), i1 = ix.get(r[1]), j0 = iz.get(r[2]), j1 = iz.get(r[3]);
      for (let j = j0; j < j1; j++) for (let i = i0; i < i1; i++) {
        const k = j * nx + i;
        if (!onlyEmpty || arr[k] < 0) arr[k] = val;
      }
    };
    unitR.forEach((r, i) => mark(unitOf, r, i, true));
    blockers.forEach((b, i) => mark(block, b.r, i, true));
    blockers.forEach((b, i) => mark(block, b.ext, i, true));
    return { xs, zs, nx, nz, unitOf, block, blockers };
  }

  function fill(g, rects) {
    const { xs, zs, nx, nz, unitOf, block } = g;
    const region = new Int32Array(nx * nz).fill(-1);
    const regions = [];
    for (let k0 = 0; k0 < nx * nz; k0++) {
      if (unitOf[k0] < 0 || block[k0] >= 0 || region[k0] >= 0) continue;
      const idx = regions.length, cells = [], units = new Set();
      let area = 0, mx = 0, mz = 0;
      const stack = [k0];
      region[k0] = idx;
      while (stack.length) {
        const k = stack.pop(), i = k % nx, j = (k - i) / nx;
        const w = xs[i + 1] - xs[i], d = zs[j + 1] - zs[j], a = w * d;
        cells.push(k);
        units.add(rects[unitOf[k]].id);
        area += a; mx += a * (xs[i] + w / 2); mz += a * (zs[j] + d / 2);
        const nb = [i > 0 ? k - 1 : -1, i < nx - 1 ? k + 1 : -1, j > 0 ? k - nx : -1, j < nz - 1 ? k + nx : -1];
        nb.forEach(m => {
          if (m < 0 || region[m] >= 0 || unitOf[m] < 0 || block[m] >= 0) return;
          region[m] = idx;
          stack.push(m);
        });
      }
      regions.push({ idx, cells, units: [...units], area, cx: mx / area, cz: mz / area });
    }
    return { region, regions };
  }

  function outline(g, region, reg) {
    const { xs, zs, nx, nz, block } = g;
    const inReg = (k) => region[k] === reg.idx;
    const rows = new Map();
    reg.cells.forEach(k => { const i = k % nx, j = (k - i) / nx; (rows.get(j) || rows.set(j, []).get(j)).push(i); });
    let open = [];
    const rects = [];
    [...rows.keys()].sort((a, b) => a - b).forEach(j => {
      const is = rows.get(j).sort((a, b) => a - b), runs = [];
      is.forEach(i => { const last = runs[runs.length - 1]; if (last && last[1] === i) last[1] = i + 1; else runs.push([i, i + 1]); });
      const next = [];
      runs.forEach(([a, b]) => {
        const r = open.find(o => o.a === a && o.b === b && o.j1 === j);
        if (r) { r.j1 = j + 1; next.push(r); } else { const n = { a, b, j0: j, j1: j + 1 }; rects.push(n); next.push(n); }
      });
      open = next;
    });
    const out = rects.map(r => ({ x0: xs[r.a], x1: xs[r.b], z0: zs[r.j0], z1: zs[r.j1] }));
    const raw = [];
    reg.cells.forEach(k => {
      const i = k % nx, j = (k - i) / nx;
      const side = (m, axis, v, s0, s1, n) => {
        if (m >= 0 && inReg(m)) return;
        raw.push({ axis, v, s0, s1, n, owner: m >= 0 ? block[m] : -1 });
      };
      side(i < nx - 1 ? k + 1 : -1, 'x', xs[i + 1], zs[j], zs[j + 1], { x: -1, z: 0 });
      side(i > 0 ? k - 1 : -1, 'x', xs[i], zs[j], zs[j + 1], { x: 1, z: 0 });
      side(j < nz - 1 ? k + nx : -1, 'z', zs[j + 1], xs[i], xs[i + 1], { x: 0, z: -1 });
      side(j > 0 ? k - nx : -1, 'z', zs[j], xs[i], xs[i + 1], { x: 0, z: 1 });
    });
    const groups = new Map();
    raw.forEach(e => { const key = `${e.axis}|${e.v}|${e.n.x}|${e.n.z}|${e.owner}`; (groups.get(key) || groups.set(key, []).get(key)).push(e); });
    const edges = [];
    groups.forEach(list => {
      list.sort((a, b) => a.s0 - b.s0);
      list.forEach(e => {
        const last = edges[edges.length - 1];
        if (last && last.key === list && Math.abs(last.s1 - e.s0) < EPS) last.s1 = e.s1;
        else edges.push(Object.assign({ key: list }, e));
      });
    });
    edges.forEach(e => delete e.key);
    return { rects: out, edges };
  }

  function labelPoint(g, region, reg, rects) {
    const i = bsearch(g.xs, reg.cx), j = bsearch(g.zs, reg.cz);
    if (i >= 0 && j >= 0 && i < g.nx && j < g.nz && region[j * g.nx + i] === reg.idx) return { x: reg.cx, z: reg.cz };
    const big = rects.reduce((b, r) => (r.x1 - r.x0) * (r.z1 - r.z0) > (b.x1 - b.x0) * (b.z1 - b.z0) ? r : b, rects[0]);
    return { x: (big.x0 + big.x1) / 2, z: (big.z0 + big.z1) / 2 };
  }

  function bandOnSide(p, e, lo, H) {
    const pl = p.place, cfg = p.config, W = cfg.wallWidth, tl = WallModel.topLine(cfg);
    const c = Math.cos(pl.rotY), sn = Math.sin(pl.rotY);
    const toS = (lx) => e.axis === 'z' ? pl.cx + lx * c : pl.cz - lx * sn;
    const toLx = (s) => e.axis === 'z' ? (s - pl.cx) / c : -(s - pl.cz) / sn;
    const la = Math.max(-W / 2, Math.min(toLx(e.s0), toLx(e.s1))), lb = Math.min(W / 2, Math.max(toLx(e.s0), toLx(e.s1)));
    if (lb - la < 1) return { quads: [], area: 0 };
    const hiAt = (lx) => Math.min(tl.at(lx), H);
    // Schoorsteen met binnenkant 'zoals de wanden': de afwerking van de ruimte loopt eroverheen.
    const ops = (cfg.openings || []).filter(op => !(op.chimney && op.chimney.inside === 'wand')).map(op => ({ x0: -W / 2 + op.x, x1: -W / 2 + op.x + op.w, y0: op.y, top: (lx) => WallModel.openingTopAt(op, lx + W / 2) }));
    const bs = new Set([la, lb]);
    tl.pts.forEach(pt => bs.add(pt.x));
    for (let i = 0; i < tl.pts.length - 1; i++) {
      const a = tl.pts[i], b = tl.pts[i + 1];
      if (isFinite(H) && (a.y - H) * (b.y - H) < 0) bs.add(a.x + (H - a.y) / (b.y - a.y) * (b.x - a.x));
    }
    ops.forEach(o => {
      bs.add(o.x0); bs.add(o.x1);
      const t0 = o.top(o.x0), t1 = o.top(o.x1);
      [lo, H].forEach(L => { if (isFinite(L) && (t0 - L) * (t1 - L) < 0) bs.add(o.x0 + (L - t0) / (t1 - t0) * (o.x1 - o.x0)); });
    });
    const xsB = [...bs].filter(x => x >= la - 0.01 && x <= lb + 0.01).sort((a, b) => a - b);
    const quads = [];
    let area = 0;
    for (let k = 0; k < xsB.length - 1; k++) {
      const a = xsB[k], b = xsB[k + 1];
      if (b - a < 1) continue;
      const m = (a + b) / 2;
      if (hiAt(m) <= lo + 1) continue;
      let bot = () => lo;
      const ivs = [];
      ops.filter(o => o.x0 <= m && o.x1 >= m).sort((u, v) => u.y0 - v.y0).forEach(o => {
        const bf = bot;
        ivs.push([bf, () => o.y0]);
        bot = (x) => Math.max(bf(x), o.top(x));
      });
      ivs.push([bot, hiAt]);
      ivs.forEach(([bf, tf]) => {
        const at = (x) => { const y0 = Math.max(lo, bf(x)), y1 = Math.min(hiAt(x), tf(x)); return [y0, Math.max(y0, y1)]; };
        const [a0, a1] = at(a), [b0, b1] = at(b);
        if (a1 - a0 < 0.5 && b1 - b0 < 0.5) return;
        quads.push([[toS(a), a0], [toS(b), b0], [toS(b), b1], [toS(a), a1]]);
        area += (b - a) * ((a1 - a0) + (b1 - b0)) / 2;
      });
    }
    return { quads, area };
  }
  function bandOnEnd(p, e, lo, H) {
    const tl = WallModel.topLine(p.config), W = p.config.wallWidth;
    const top = Math.min(H, Math.min(tl.at(-W / 2), tl.at(W / 2)));
    if (top - lo < 1) return { quads: [], area: 0 };
    return { quads: [[[e.s0, lo], [e.s1, lo], [e.s1, top], [e.s0, top]]], area: (e.s1 - e.s0) * (top - lo) };
  }

  function compute(roomStates, units, pieces) {
    const rects = units.map(u => u.rect);
    const g = buildGrid(pieces, rects);
    const { region, regions } = fill(g, rects);
    const cellAt = (x, z) => {
      const i = bsearch(g.xs, x), j = bsearch(g.zs, z);
      return i < 0 || j < 0 || i >= g.nx || j >= g.nz ? -1 : j * g.nx + i;
    };
    const valid = (r) => r && r.area >= MIN_AREA_MM2;
    const regionAt = (x, z) => { const k = cellAt(x, z); return k >= 0 && region[k] >= 0 && valid(regions[region[k]]) ? regions[region[k]] : null; };
    // Zaadpunt in een wand (wand verschoven): het dichtstbijzijnde gebied binnen 400 mm.
    const seedRegion = (x, z) => {
      const r0 = regionAt(x, z);
      if (r0) return r0;
      for (let d = 50; d <= 400; d += 50) {
        for (let a = 0; a < 8; a++) {
          const r = regionAt(x + d * Math.cos(a * Math.PI / 4), z + d * Math.sin(a * Math.PI / 4));
          if (r) return r;
        }
      }
      return null;
    };

    const owner = new Map();
    const lost = [];
    (roomStates || []).forEach(rs => {
      const u = units.find(x => x.id === rs.unitId);
      const reg = u ? seedRegion(u.rect.x0 + rs.x, u.rect.z0 + rs.z) : null;
      if (!reg) lost.push({ id: rs.id, state: rs, reason: u ? 'Geen afgesloten gebied op deze plek' : `Unit ${rs.unitId} bestaat niet` });
      else if (owner.has(reg.idx)) lost.push({ id: rs.id, state: rs, reason: `Valt samen met een andere ruimte (wand weg?)` });
      else owner.set(reg.idx, rs);
    });

    const pieceIdx = new Map(g.blockers.map((b, i) => [i, b]));
    const unitAt = (x, z) => units.find(u => x >= u.rect.x0 - EPS && x <= u.rect.x1 + EPS && z >= u.rect.z0 - EPS && z <= u.rect.z1 + EPS);
    const sameType = {};
    owner.forEach(rs => { sameType[rs.type] = (sameType[rs.type] || 0) + 1; });
    const seenType = {};

    const rooms = [], free = [];
    regions.filter(valid).forEach(reg => {
      const { rects: rr, edges } = outline(g, region, reg);
      const lp = labelPoint(g, region, reg, rr);
      const u0 = units.find(u => u.id === reg.units[0]);
      const floorTop = u0 ? u0.layout.floorTop : 0;
      const base = { key: reg.idx, areaM2: reg.area / 1e6, rects: rr, edges, label: lp, units: reg.units, floorTop };
      const rs = owner.get(reg.idx);
      if (!rs) { free.push(base); return; }
      const T = TYPES[rs.type] || TYPES.overig;
      seenType[rs.type] = (seenType[rs.type] || 0) + 1;
      const name = rs.name || (sameType[rs.type] > 1 ? `${T.label} ${seenType[rs.type]}` : T.label);
      const share = {};
      rr.forEach(r => { const u = unitAt((r.x0 + r.x1) / 2, (r.z0 + r.z1) / 2); if (u) share[u.id] = (share[u.id] || 0) + (r.x1 - r.x0) * (r.z1 - r.z0); });
      const unitId = Object.keys(share).sort((a, b) => share[b] - share[a])[0] || reg.units[0];

      const ceilQuads = [];
      let ceilMM2 = 0;
      if (rs.ceiling) {
        const yAbs = floorTop + rs.ceiling;
        rr.forEach(r => {
          const nX = Math.max(1, Math.ceil((r.x1 - r.x0) / CEIL_STEP)), nZ = Math.max(1, Math.ceil((r.z1 - r.z0) / CEIL_STEP));
          for (let a = 0; a < nX; a++) for (let b = 0; b < nZ; b++) {
            const x0 = r.x0 + (r.x1 - r.x0) * a / nX, x1 = r.x0 + (r.x1 - r.x0) * (a + 1) / nX;
            const z0 = r.z0 + (r.z1 - r.z0) * b / nZ, z1 = r.z0 + (r.z1 - r.z0) * (b + 1) / nZ;
            const u = unitAt((x0 + x1) / 2, (z0 + z1) / 2);
            if (!u) continue;
            const ok = [[x0 + 1, z0 + 1], [x1 - 1, z0 + 1], [x1 - 1, z1 - 1], [x0 + 1, z1 - 1]].every(([x, z]) => u.roof.ceilingAt(x, z) > yAbs + 10);
            if (!ok) continue;
            ceilQuads.push({ x0, x1, z0, z1, y: yAbs });
            ceilMM2 += (x1 - x0) * (z1 - z0);
          }
        });
      }

      const H = rs.ceiling && ceilQuads.length ? rs.ceiling : Infinity;
      const fiboH = rs.fibo ? (rs.fibo.height ? Math.min(rs.fibo.height, H) : H) : 0;
      const faces = [];
      let fiboMM2 = 0, paintMM2 = 0;
      edges.forEach(e => {
        const b = pieceIdx.get(e.owner);
        if (!b) return;
        const side = b.alongX === (e.axis === 'z');
        const band = (lo, hi) => side ? bandOnSide(b.piece, e, lo, hi) : bandOnEnd(b.piece, e, lo, hi);
        const world = ([s, y]) => e.axis === 'z'
          ? { x: s, y: b.piece.place.floorTop + y, z: e.v + e.n.z * FACE_OFF, u: s }
          : { x: e.v + e.n.x * FACE_OFF, y: b.piece.place.floorTop + y, z: s, u: s };
        if (rs.fibo) {
          const r = band(0, fiboH);
          fiboMM2 += r.area;
          r.quads.forEach(qd => faces.push({ kind: 'fibo', pts: qd.map(world) }));
        }
        if (rs.paint && (!rs.fibo || fiboH < H)) {
          const r = band(rs.fibo ? fiboH : 0, H);
          paintMM2 += r.area;
          r.quads.forEach(qd => faces.push({ kind: 'paint', pts: qd.map(world) }));
        }
      });

      rooms.push(Object.assign(base, {
        id: rs.id, state: rs, type: rs.type, typeLabel: T.label, name, color: T.color, unitId,
        floor: rs.floor, paint: rs.paint, fibo: rs.fibo, ceiling: rs.ceiling,
        ceilingActive: ceilQuads.length > 0, ceilQuads, ceilM2: ceilMM2 / 1e6,
        faces, fiboM2: fiboMM2 / 1e6, paintM2: paintMM2 / 1e6
      }));
    });

    const roomAt = (x, z) => { const reg = regionAt(x, z); return reg ? rooms.find(r => r.key === reg.idx) || null : null; };
    const freeAt = (x, z) => { const reg = regionAt(x, z); return reg ? free.find(r => r.key === reg.idx) || null : null; };
    return { rooms, free, lost, roomAt, freeAt, regionAt };
  }

  function lowerSpots(result, spots) {
    (spots || []).forEach(sp => {
      const r = result.roomAt(sp.x, sp.z);
      if (r && r.ceilingActive && sp.floorY + r.ceiling < sp.y) sp.y = sp.floorY + r.ceiling;
    });
  }

  const matCache = {};
  const offset = (m) => Object.assign(m, { polygonOffset: true, polygonOffsetFactor: -1, polygonOffsetUnits: -2, side: THREE.DoubleSide });
  function fiboMaterial(decor) {
    const key = 'fibo:' + decor;
    if (matCache[key]) return matCache[key];
    const f = FIBO[decor] || FIBO.wit_tegel;
    const tex = f.tile && FloorModel.tileTexture ? FloorModel.tileTexture(f.tile, f.color, f.jointColor) : null;
    return (matCache[key] = offset(new THREE.MeshStandardMaterial(tex ? { map: tex, roughness: 0.3 } : { color: f.color, roughness: 0.5 })));
  }
  function paintMaterial(hex) {
    const key = 'paint:' + hex;
    return matCache[key] || (matCache[key] = offset(new THREE.MeshStandardMaterial({ color: hex, roughness: 0.9 })));
  }
  // Kopie van de vloerafwerking, zodat hij boven de woningvloer wint.
  function floorMaterial(key) {
    const f = FloorModel.FINISHES[key] || FloorModel.FINISHES.geen;
    const base = FloorModel.finishMaterial(key);
    const ck = 'floor:' + key;
    if (!matCache[ck]) matCache[ck] = offset(base ? base.clone() : new THREE.MeshStandardMaterial({ color: f.color, roughness: 0.75 }));
    const m = matCache[ck];
    if (base && base.map && m.map !== base.map) { m.map = base.map; m.color.copy(base.color); m.needsUpdate = true; }
    return m;
  }
  let ceilMat = null;
  const ceilingMaterial = () => ceilMat || (ceilMat = new THREE.MeshStandardMaterial({ color: 0xf4f3ef, roughness: 0.95, side: THREE.DoubleSide }));

  function quadGeometry(quads, uvOf) {
    const pos = [], uv = [];
    quads.forEach(qd => [0, 1, 2, 0, 2, 3].forEach(i => {
      const p = qd[i];
      pos.push(p.x * 0.001, p.y * 0.001, p.z * 0.001);
      const t = uvOf(p);
      uv.push(t[0], t[1]);
    }));
    const geo = new THREE.BufferGeometry();
    geo.setAttribute('position', new THREE.Float32BufferAttribute(pos, 3));
    geo.setAttribute('uv', new THREE.Float32BufferAttribute(uv, 2));
    geo.computeVertexNormals();
    return geo;
  }

  function build3D(result, opts) {
    const o = opts || {};
    const group = new THREE.Group(), ceilings = new THREE.Group();
    group.add(ceilings);
    group.userData.ceilings = ceilings;
    result.rooms.forEach(r => {
      if (r.floor) {
        const y = r.floorTop + FACE_OFF;
        const quads = r.rects.map(c => [{ x: c.x0, z: c.z0 }, { x: c.x1, z: c.z0 }, { x: c.x1, z: c.z1 }, { x: c.x0, z: c.z1 }].map(p => Object.assign(p, { y })));
        const m = new THREE.Mesh(quadGeometry(quads, p => [p.x * 0.001, p.z * 0.001]), floorMaterial(r.floor));
        m.receiveShadow = true;
        group.add(m);
      }
      const byKind = { fibo: [], paint: [] };
      r.faces.forEach(f => byKind[f.kind].push(f.pts));
      if (byKind.fibo.length) group.add(new THREE.Mesh(quadGeometry(byKind.fibo, p => [p.u * 0.001, p.y * 0.001]), fiboMaterial(r.fibo.decor)));
      if (byKind.paint.length) group.add(new THREE.Mesh(quadGeometry(byKind.paint, p => [p.u * 0.001, p.y * 0.001]), paintMaterial(r.paint)));
      if (r.ceilQuads.length) {
        const quads = r.ceilQuads.map(c => [{ x: c.x0, z: c.z0 }, { x: c.x1, z: c.z0 }, { x: c.x1, z: c.z1 }, { x: c.x0, z: c.z1 }].map(p => Object.assign(p, { y: c.y })));
        ceilings.add(new THREE.Mesh(quadGeometry(quads, p => [p.x * 0.001, p.z * 0.001]), ceilingMaterial()));
      }
    });
    ceilings.visible = o.ceilings !== false;
    return group;
  }

  function floorLabel(r) { return r.floor ? (FloorModel.FINISHES[r.floor] || {}).label || r.floor : 'Woning'; }
  function wallLabel(r) {
    const parts = [];
    if (r.fibo) parts.push(`FIBO ${(FIBO[r.fibo.decor] || {}).label.toLowerCase()}${r.fibo.height ? ` tot ${r.fibo.height} mm` : ''}`);
    if (r.paint) parts.push(`verf ${r.paint}`);
    return parts.join(', ') || 'Woning';
  }
  function ceilingLabel(r) { return r.ceiling ? (r.ceilingActive ? `vals plafond ${r.ceiling}` : `${r.ceiling} (dak lager)`) : 'volgt dak'; }

  return {
    TYPES, FIBO, CEIL_MIN, CEIL_MAX, applyType, create, normalize, compute, lowerSpots, build3D,
    floorLabel, wallLabel, ceilingLabel
  };
})();