// solaire-toit-editeur-re.jsx — ÉDITEUR DE TOIT À LA MAIN (React), superposition SVG de la scène 2D du Studio solaire.
// Corrige le modèle vectoriel du bâtiment (window.SolaireModele) quand l'ajustement automatique n'est pas parfait :
//   · sommets du contour et des faîtes = poignées déplaçables (aimantation à 90° et 45° sur les axes du bâtiment et aux autres sommets ; Alt = libre)
//   · poignée au milieu d'une arête = translation parallèle de l'arête entière ; Maj + glisser une face = déplacement du pan entier
//   · double-clic sur une arête = nouveau sommet ; Suppr ou Retour arrière = sommet sélectionné retiré ; flèches = tasser de 5 cm (Maj : 25 cm)
//   · fiche flottante : hauteur d'un sommet, égout et faîte d'une face (mètres, pas de 5 cm), type d'une arête ; cotes en direct pendant le glisser
//   · « Réinitialiser au modèle automatique » (modèle d'origine conservé par SolaireModele.recalculer dans `auto`, ou prop modeleAuto)
// Chaque relâchement appelle onModele(nouveauModele) avec un modèle complet recalculé (SolaireModele.recalculer, insererSommet, supprimerSommet) :
// faces, arêtes typées, murs, pentes, surfaces, px et lat/lng. Le composant ne garde aucun état hors props, sauf le glisser en cours et la sélection.
//
// Exposé : window.SolaireToitEditeurRE ({ modele, projection: { versPx(e, n) → { x, y } (px du canevas 2D), versM(x, y) → { e, n } (m) },
//                                        onModele(modele), modeleAuto?, largeur?, hauteur?, lecture? })
// À monter dans un conteneur position: relative de la taille du canevas 2D ; le SVG couvre tout le conteneur (pointer-events sur ses éléments).
// Sérialisation pour la soumission : window.SolaireModele.serialiserManuel(modele) → design_editeur.modele_manuel ;
// rechargement : window.SolaireModele.appliquerManuel(modeleAuto, modele_manuel).
(function () {
  const { useState, useEffect, useRef, useMemo, useCallback } = React;
  const DEG = Math.PI / 180;
  const STYLE = { faite: { stroke: "#ffd166", width: 2.6 }, arete: { stroke: "#9ad0ff", width: 2, dash: "7 3" }, noue: { stroke: "#ff8ad8", width: 2, dash: "3 3" }, rive: { stroke: "#ffffff", width: 1.8 }, egout: { stroke: "#ffb347", width: 2.4 } };
  const TYPES = [["faite", "Faîte"], ["arete", "Arête"], ["noue", "Noue"], ["rive", "Rive"], ["egout", "Égout"]];
  const fmt = (v, d) => (Number(v) || 0).toLocaleString("fr-CA", { minimumFractionDigits: d == null ? 2 : d, maximumFractionDigits: d == null ? 2 : d });
  const arrondi5 = (v) => Math.round(v * 20) / 20;

  function SolaireToitEditeurRE({ modele, projection, onModele, modeleAuto, largeur, hauteur, lecture }) {
    const M = window.SolaireModele;
    const [sel, setSel] = useState(null);          // { type: "sommet" | "face" | "arete", id }
    const [hover, setHover] = useState(null);      // même forme
    const [drag, setDrag] = useState(null);        // { mode, ids, base: [{e,n}], depart: {e,n}, courant: [{e,n}], bouge }
    const [msg, setMsg] = useState(null);
    const [aimant, setAimant] = useState(true);    // aimantation (bouton de la barre) ; Alt pendant le glisser la coupe aussi
    const svgRef = useRef(null); const dragRef = useRef(null); dragRef.current = drag;
    const ok = modele && Array.isArray(modele.sommets) && Array.isArray(modele.faces) && projection && typeof projection.versPx === "function" && typeof projection.versM === "function";
    // positions courantes (mètres) : celles du glisser en cours, sinon celles du modèle
    const pos = useMemo(() => ok ? modele.sommets.map((s, i) => (drag && drag.courant[i]) ? drag.courant[i] : { e: s.e, n: s.n }) : [], [modele, drag, ok]);
    const px = useMemo(() => pos.map(p => projection.versPx(p.e, p.n)), [pos, projection]);
    const axe = ok && modele.batiment && isFinite(modele.batiment.axe_deg) ? modele.batiment.axe_deg * DEG : 0;
    const voisinsDe = useCallback((id) => { const out = []; for (const a of (modele.aretes || [])) { if (a.de === id) out.push(a.a); else if (a.a === id) out.push(a.de); } return out; }, [modele]);
    const facesIndex = useMemo(() => ok ? modele.faces.map((f, k) => k) : [], [modele, ok]);
    const mParPx = useMemo(() => { if (!ok) return 0.1; const a = projection.versM(0, 0), b = projection.versM(100, 0); return Math.hypot(b.e - a.e, b.n - a.n) / 100 || 0.1; }, [projection, ok]);

    useEffect(() => { if (!msg) return; const t = setTimeout(() => setMsg(null), 3500); return () => clearTimeout(t); }, [msg]);
    useEffect(() => { setSel(null); setDrag(null); }, [modele === null]); // eslint-disable-line

    /** Aimantation d'un sommet : rayons à 90° et 45° depuis ses voisins (axes du bâtiment), puis autres sommets proches. */
    const aimanter = (id, p, libre) => {
      if (libre) return p; const tol = 6 * DEG; let q = { e: p.e, n: p.n }; const rayons = [];
      for (const v of voisinsDe(id).slice(0, 2)) {
        const o = pos[v]; const d = Math.hypot(q.e - o.e, q.n - o.n); if (d < 0.3) continue; const ang = Math.atan2(q.n - o.n, q.e - o.e);
        let best = null, bd = Infinity; for (let k = 0; k < 8; k++) { const a = axe + k * Math.PI / 4; let dd = Math.abs(((ang - a) % (2 * Math.PI) + 3 * Math.PI) % (2 * Math.PI) - Math.PI); if (dd < bd) { bd = dd; best = a; } }
        if (bd <= tol) rayons.push({ o, u: [Math.cos(best), Math.sin(best)] });
      }
      if (rayons.length === 2) { const [r1, r2] = rayons; const det = r1.u[0] * r2.u[1] - r1.u[1] * r2.u[0]; if (Math.abs(det) > 0.2) { const dx = r2.o.e - r1.o.e, dy = r2.o.n - r1.o.n; const t = (dx * r2.u[1] - dy * r2.u[0]) / det; const c = { e: r1.o.e + t * r1.u[0], n: r1.o.n + t * r1.u[1] }; if (Math.hypot(c.e - q.e, c.n - q.n) < 0.6) return c; } }
      if (rayons.length >= 1) { const r = rayons[0]; const t = (q.e - r.o.e) * r.u[0] + (q.n - r.o.n) * r.u[1]; q = { e: r.o.e + t * r.u[0], n: r.o.n + t * r.u[1] }; }
      for (let i = 0; i < pos.length; i++) { if (i === id) continue; if (Math.hypot(pos[i].e - q.e, pos[i].n - q.n) < 0.25) return { e: pos[i].e, n: pos[i].n }; }
      return q;
    };
    const mDe = (ev) => { const r = svgRef.current.getBoundingClientRect(); return projection.versM(ev.clientX - r.left, ev.clientY - r.top); };
    const publier = (nouveau) => { if (nouveau && typeof onModele === "function") onModele(nouveau); };
    const recalc = (modifs) => { try { return M.recalculer(modele, modifs); } catch (e) { setMsg("Recalcul impossible : " + (e && e.message ? e.message : e)); return null; } };

    // ── glisser ──
    const debuter = (ev, mode, ids) => {
      if (lecture || !M) return; ev.preventDefault(); ev.stopPropagation(); try { ev.target.setPointerCapture && svgRef.current.setPointerCapture(ev.pointerId); } catch (e) { /* noop */ }
      const depart = mDe(ev); const base = pos.map(p => ({ e: p.e, n: p.n }));
      let normal = null; if (mode === "arete") { const A = base[ids[0]], B = base[ids[1]]; const L = Math.hypot(B.e - A.e, B.n - A.n) || 1e-9; normal = [-(B.n - A.n) / L, (B.e - A.e) / L]; }
      setDrag({ mode, ids, base, depart, courant: base.map(p => ({ e: p.e, n: p.n })), bouge: false, normal, pointerId: ev.pointerId });
    };
    const bouger = (ev) => {
      const d = dragRef.current; if (!d) return; const m = mDe(ev); const de = m.e - d.depart.e, dn = m.n - d.depart.n;
      const courant = d.base.map(p => ({ e: p.e, n: p.n }));
      if (d.mode === "sommet") { const id = d.ids[0]; courant[id] = aimanter(id, { e: d.base[id].e + de, n: d.base[id].n + dn }, ev.altKey || !aimant); }
      else if (d.mode === "arete") { const k = de * d.normal[0] + dn * d.normal[1]; for (const id of d.ids) courant[id] = { e: d.base[id].e + k * d.normal[0], n: d.base[id].n + k * d.normal[1] }; }
      else for (const id of d.ids) courant[id] = { e: d.base[id].e + de, n: d.base[id].n + dn };
      setDrag(Object.assign({}, d, { courant, bouge: d.bouge || Math.hypot(de, dn) > 0.02 }));
    };
    const finir = (ev) => {
      const d = dragRef.current; if (!d) return; setDrag(null);
      try { svgRef.current.releasePointerCapture && svgRef.current.releasePointerCapture(d.pointerId); } catch (e) { /* noop */ }
      if (!d.bouge) return;
      const sommets = modele.sommets.map((s, i) => ({ e: d.courant[i].e, n: d.courant[i].n, z: s.z }));
      publier(recalc({ sommets }));
    };

    // ── clavier : Suppr, Échap, flèches ──
    useEffect(() => {
      if (!ok || lecture) return;
      const onKey = (ev) => {
        const cible = ev.target; if (cible && /^(INPUT|SELECT|TEXTAREA)$/.test(cible.tagName)) return;
        if (ev.key === "Escape") { setSel(null); return; }
        if (!sel) return;
        if ((ev.key === "Delete" || ev.key === "Backspace") && sel.type === "sommet") { ev.preventDefault(); const r = M.supprimerSommet(modele, sel.id); if (!r) setMsg("Impossible : une face garderait moins de 3 sommets."); else { setSel(null); publier(r); } return; }
        const pas = (ev.shiftKey ? 0.25 : 0.05); const dir = { ArrowLeft: [-pas, 0], ArrowRight: [pas, 0], ArrowUp: [0, pas], ArrowDown: [0, -pas] }[ev.key];
        if (!dir) return; ev.preventDefault();
        const ids = sel.type === "sommet" ? [sel.id] : sel.type === "arete" ? [modele.aretes[sel.id].de, modele.aretes[sel.id].a] : modele.faces[sel.id].sommets;
        const sommets = modele.sommets.map((s, i) => ids.includes(i) ? { e: s.e + dir[0], n: s.n + dir[1], z: s.z } : { e: s.e, n: s.n, z: s.z });
        publier(recalc({ sommets }));
      };
      window.addEventListener("keydown", onKey); return () => window.removeEventListener("keydown", onKey);
    }, [ok, lecture, sel, modele]); // eslint-disable-line

    // ── fiche : hauteurs ──
    const fixerZ = (ids, z) => { if (!ids.length) { setMsg("Aucun sommet de ce type sur cette face."); return; } const sommets = modele.sommets.map((s, i) => { if (!ids.includes(i)) return { e: s.e, n: s.n, z: s.z }; const zFaces = {}; for (const k of s.faces) zFaces[k] = z; return { e: s.e, n: s.n, z, zFaces }; }); publier(recalc({ sommets })); };
    const typerArete = (idx, type) => { const aretes = modele.aretes.map((a, i) => ({ de: a.de, a: a.a, type: i === idx ? type : a.type, mur: i === idx ? (type === "egout" || type === "rive" ? a.faces.length <= 1 || a.mur : a.faces.length <= 1) : a.mur })); publier(recalc({ sommets: modele.sommets.map(s => ({ e: s.e, n: s.n, z: s.z })), aretes })); };
    const reinitialiser = () => { const a = modeleAuto || modele.auto; if (a) { setSel(null); publier(a); } };

    if (!ok) return null;
    const faces = modele.faces, aretes = modele.aretes || [];
    const selSommet = sel && sel.type === "sommet" ? sel.id : -1, selFace = sel && sel.type === "face" ? sel.id : -1, selArete = sel && sel.type === "arete" ? sel.id : -1;
    const bouges = drag ? new Set(drag.ids) : null;
    // cotes en direct : arêtes touchant un sommet déplacé
    const cotes = drag && drag.bouge ? aretes.filter(a => bouges.has(a.de) || bouges.has(a.a)).map(a => { const A = pos[a.de], B = pos[a.a]; const P = px[a.de], Q = px[a.a]; return { x: (P.x + Q.x) / 2, y: (P.y + Q.y) / 2, t: fmt(Math.hypot(B.e - A.e, B.n - A.n)) + " m" }; }) : [];
    // fiche flottante
    let carte = null;
    if (sel && !lecture) {
      if (sel.type === "sommet" && modele.sommets[sel.id]) { const s = modele.sommets[sel.id]; const p = px[sel.id];
        carte = { x: p.x + 14, y: p.y + 14, corps: (<div><b>Sommet {sel.id + 1}</b><span className="re-toit-sub">{s.faces.length} face{s.faces.length > 1 ? "s" : ""} · e {fmt(s.e, 1)} m · n {fmt(-s.n, 1)} m</span>
          <label>Hauteur <input type="number" step="0.05" min="0.5" max="30" defaultValue={arrondi5(s.z).toFixed(2)} key={sel.id + ":" + s.z} onKeyDown={e => { if (e.key === "Enter") { e.preventDefault(); fixerZ([sel.id], arrondi5(Number(e.currentTarget.value))); } }} onBlur={e => { const v = arrondi5(Number(e.target.value)); if (isFinite(v) && Math.abs(v - s.z) >= 0.01) fixerZ([sel.id], v); }} /> m</label>
          <div className="re-toit-boutons"><button type="button" onClick={() => { const r = M.supprimerSommet(modele, sel.id); if (!r) setMsg("Impossible : une face garderait moins de 3 sommets."); else { setSel(null); publier(r); } }}>Supprimer</button></div></div>) };
      } else if (sel.type === "face" && faces[sel.id]) { const f = faces[sel.id]; const c = f.polygone_2d.reduce((t, q) => ({ e: t.e + q.e / f.polygone_2d.length, n: t.n + q.n / f.polygone_2d.length }), { e: 0, n: 0 }); const p = projection.versPx(c.e, c.n);
        // égout = sommets les plus bas de la face (à 30 cm du minimum), faîte = les plus hauts (à 30 cm du maximum) : une face peut porter deux arêtes
        // typées « faîte » à des hauteurs différentes (faîte principal et faîte d'une aile), seul le plus haut est son faîte
        const zs = f.sommets_3d.map(q => q.z); const zEg = Math.min(...zs), zFa = Math.max(...zs);
        const egIds = f.sommets.filter((id, i) => zs[i] <= zEg + 0.3), faIds = f.sommets.filter((id, i) => zs[i] >= zFa - 0.3);
        carte = { x: p.x + 16, y: p.y - 10, corps: (<div><b>Pan {f.pan >= 0 ? f.pan + 1 : "+"}</b><span className="re-toit-sub">{fmt(f.surface_m2, 0)} m² · pente {fmt(f.pente_deg, 0)}° · azimut {f.azimut_deg}° · {f.sommets.length} sommets</span>
          <label>Égout <input type="number" step="0.05" min="0.5" max="30" key={"eg" + sel.id + ":" + zEg} defaultValue={zEg != null ? arrondi5(zEg).toFixed(2) : ""} onKeyDown={e => { if (e.key === "Enter") { e.preventDefault(); fixerZ(egIds, arrondi5(Number(e.currentTarget.value))); } }} onBlur={e => { const v = arrondi5(Number(e.target.value)); if (isFinite(v) && Math.abs(v - zEg) >= 0.01) fixerZ(egIds, v); }} /> m</label>
          <label>Faîte <input type="number" step="0.05" min="0.5" max="40" key={"fa" + sel.id + ":" + zFa} defaultValue={arrondi5(zFa).toFixed(2)} onKeyDown={e => { if (e.key === "Enter") { e.preventDefault(); fixerZ(faIds, arrondi5(Number(e.currentTarget.value))); } }} onBlur={e => { const v = arrondi5(Number(e.target.value)); if (isFinite(v) && Math.abs(v - zFa) >= 0.01) fixerZ(faIds, v); }} /> m</label>
          <span className="re-toit-sub">Maj + glisser le pan pour le déplacer en entier.</span></div>) };
      } else if (sel.type === "arete" && aretes[sel.id]) { const a = aretes[sel.id]; const P = px[a.de], Q = px[a.a];
        carte = { x: (P.x + Q.x) / 2 + 12, y: (P.y + Q.y) / 2 + 12, corps: (<div><b>Arête {fmt(a.longueur_m)} m</b><span className="re-toit-sub">{a.faces.length} face{a.faces.length > 1 ? "s" : ""}{a.mur ? " · mur" : ""}</span>
          <label>Type <select value={a.type} onChange={e => typerArete(sel.id, e.target.value)}>{TYPES.map(([v, l]) => <option key={v} value={v}>{l}</option>)}</select></label>
          <span className="re-toit-sub">Glisser la poignée du milieu pour déplacer l'arête parallèlement ; double-clic pour ajouter un sommet.</span></div>) };
      }
    }
    const auto = modeleAuto || modele.auto;
    return (
      <div className="re-toit-editeur" style={{ position: "absolute", left: 0, top: 0, width: largeur ? largeur + "px" : "100%", height: hauteur ? hauteur + "px" : "100%", pointerEvents: "none" }}>
        <svg ref={svgRef} className={"re-toit-svg" + (drag ? " drag" : "")} width="100%" height="100%" style={{ position: "absolute", left: 0, top: 0, overflow: "visible" }} onPointerMove={bouger} onPointerUp={finir} onPointerCancel={finir}>
          {faces.map((f, k) => <polygon key={"f" + k} className={"re-toit-face" + (selFace === k ? " sel" : "") + (hover && hover.type === "face" && hover.id === k ? " hov" : "")} points={f.sommets.map(id => px[id] ? px[id].x + "," + px[id].y : "").join(" ")}
            onPointerDown={ev => { if (ev.shiftKey) debuter(ev, "face", f.sommets.slice()); else { ev.stopPropagation(); setSel({ type: "face", id: k }); } }} onPointerEnter={() => setHover({ type: "face", id: k })} onPointerLeave={() => setHover(null)} />)}
          {aretes.map((a, i) => { const P = px[a.de], Q = px[a.a]; if (!P || !Q) return null; const st = STYLE[a.type] || STYLE.rive; const s = selArete === i; const h = hover && hover.type === "arete" && hover.id === i;
            return (<g key={"a" + i}><line x1={P.x} y1={P.y} x2={Q.x} y2={Q.y} stroke={st.stroke} strokeWidth={st.width + (s ? 1.6 : h ? 0.8 : 0)} strokeDasharray={st.dash || null} strokeLinecap="round" style={{ pointerEvents: "none", filter: s ? "drop-shadow(0 0 3px #3b82f6)" : null }} />
              <line x1={P.x} y1={P.y} x2={Q.x} y2={Q.y} stroke="transparent" strokeWidth="12" style={{ pointerEvents: lecture ? "none" : "stroke", cursor: "pointer" }} onPointerDown={ev => { ev.stopPropagation(); setSel({ type: "arete", id: i }); }} onPointerEnter={() => setHover({ type: "arete", id: i })} onPointerLeave={() => setHover(null)}
                onDoubleClick={ev => { ev.preventDefault(); ev.stopPropagation(); const m = mDe(ev); const r = M.insererSommet(modele, a.de, a.a, m.e, m.n); if (r) { setSel({ type: "sommet", id: r.sommets.length - 1 }); publier(r); } }} /></g>); })}
          {!lecture && aretes.map((a, i) => { const P = px[a.de], Q = px[a.a]; if (!P || !Q) return null; const vis = selArete === i || (hover && hover.type === "arete" && hover.id === i) || (hover && hover.type === "poignee" && hover.id === i); if (!vis) return null; const mx = (P.x + Q.x) / 2, my = (P.y + Q.y) / 2;
            return <rect key={"p" + i} className="re-toit-poignee" x={mx - 5} y={my - 5} width="10" height="10" transform={`rotate(${Math.atan2(Q.y - P.y, Q.x - P.x) / DEG} ${mx} ${my})`} style={{ pointerEvents: "all", cursor: "move" }} onPointerDown={ev => debuter(ev, "arete", [a.de, a.a])} onPointerEnter={() => setHover({ type: "poignee", id: i })} onPointerLeave={() => setHover(null)} />; })}
          {px.map((p, id) => p ? <circle key={"s" + id} className={"re-toit-sommet" + (selSommet === id ? " sel" : "") + (bouges && bouges.has(id) ? " bouge" : "")} cx={p.x} cy={p.y} r={selSommet === id ? 7 : 5.5} style={{ pointerEvents: lecture ? "none" : "all", cursor: lecture ? "default" : "grab" }}
            onPointerDown={ev => { setSel({ type: "sommet", id }); debuter(ev, "sommet", [id]); }} onPointerEnter={() => setHover({ type: "sommet", id })} onPointerLeave={() => setHover(null)} /> : null)}
          {cotes.map((c, i) => <g key={"c" + i} style={{ pointerEvents: "none" }}><rect x={c.x - 24} y={c.y - 9} width="48" height="18" rx="4" fill="rgba(11,27,43,0.85)" /><text x={c.x} y={c.y + 4} textAnchor="middle" fill="#fff" fontSize="11" fontWeight="700" fontFamily="sans-serif">{c.t}</text></g>)}
        </svg>
        {carte && <div className="re-toit-carte" style={{ position: "absolute", left: Math.max(4, carte.x), top: Math.max(4, carte.y), pointerEvents: "all" }} onPointerDown={ev => ev.stopPropagation()}>{carte.corps}</div>}
        {!lecture && <div className="re-toit-barre" style={{ pointerEvents: "all" }}>
          <span>{modele.manuel ? "Toit corrigé à la main" : "Toit automatique"} · {modele.sommets.length} sommets · {faces.length} pans · égout {fmt(modele.hauteur_egout_m, 2)} m · faîte {fmt(modele.hauteur_faite_m, 2)} m</span>
          <label className="re-toit-aimant"><input type="checkbox" checked={aimant} onChange={e => setAimant(e.target.checked)} /> Aimant 90° et 45°</label>
          {auto && modele.manuel && <button type="button" className="re-btn small" onClick={reinitialiser}>Réinitialiser au modèle automatique</button>}
          <span className="re-toit-aide">Glisser un sommet (Alt ou aimant décoché : libre) · poignée du milieu : déplacer l'arête · Maj + glisser un pan · double-clic : nouveau sommet · Suppr : retirer · flèches : tasser</span>
        </div>}
        {msg && <div className="re-toit-msg">{msg}</div>}
      </div>
    );
  }
  window.SolaireToitEditeurRE = SolaireToitEditeurRE;
})();
