// solaire-editeur-re.jsx — VUE MINCE (React) de l'éditeur de panneaux, posée sur le MOTEUR window.SolaireMoteur (solaire-moteur-re.js).
// Toute la géométrie, la pose, le remplissage, l'ensoleillement, l'export et le dessin des panneaux vivent dans le moteur ;
// ici seulement : état d'interface, souris et clavier, barre d'outils, liste des pans, bandeau et « Appliquer à la soumission ».
// Exposé : window.SolaireEditeurRE ({ state, setState, toit }) ; SolaireEditeurRE.etat() ; SolaireEditeurRE.moteur() ;
// événement window « raycast:editeur » (detail = etat()) à chaque changement.
(function () {
  const { useState, useEffect, useRef } = React;
  const Moteur = window.SolaireMoteur;
  if (!Moteur) { console.warn("[solaire-editeur] moteur absent (solaire-moteur-re.js non chargé) : éditeur de panneaux désactivé."); return; }
  const WORKER_URL = window.RAYCAST_WORKER_URL || "https://raycom-ghl-qbo-worker.proud-leaf-b313.workers.dev";
  const fmtInt = (n) => Math.round(Number(n) || 0).toLocaleString("fr-CA");
  const fmtNum = (n, d) => (Number(n) || 0).toLocaleString("fr-CA", { maximumFractionDigits: d == null ? 1 : d });
  const MODELES = Moteur.MODELES, MOIS = Moteur.MOIS;
  async function jwt() { const { data } = await window.RAYCAST_SUPABASE.auth.getSession(); return data && data.session ? data.session.access_token : null; }
  const dernierEtat = { current: null };
  let instance = null;

  function SolaireEditeurRE({ state, setState, toit }) {
    const s = state.solaire || {}; const p = state.parcours || {}; const de0 = s.design_editeur || {};
    const mRef = useRef(null);
    if (!mRef.current) {
      mRef.current = Moteur.creer({ workerUrl: WORKER_URL, jwt, GeoTIFF: window.GeoTIFF, document, modele: de0.modele || p.panneau || "longi500", orientation: de0.orientation || "portrait",
        marges: { bord: de0.marge_bord != null ? de0.marge_bord : Moteur.MARGES.bord, arete: de0.marge_arete != null ? de0.marge_arete : Moteur.MARGES.arete, obstacle: de0.marge_obstacle != null ? de0.marge_obstacle : Moteur.MARGES.obstacle } });
      instance = mRef.current;
    }
    const m = mRef.current;
    const [pret, setPret] = useState(false);
    const [msg, setMsg] = useState({});
    const [E, setE] = useState(() => m.etat());          // instantané du moteur (panneaux, pans, bilan)
    const [outil, setOutil] = useState("poser");          // poser | obstacle | polygone | faite | mesure
    const [soleil, setSoleil] = useState(false);
    const [mois, setMois] = useState(0);                  // 0 = annuel, 1..12
    const [vue, setVue] = useState({ scale: 0, ox: 0, oy: 0 }); // scale 0 = à cadrer
    const [survol, setSurvol] = useState(null);           // { existant: i } | { fantome: { lat, lng } }
    const [curseur, setCurseur] = useState(null);         // encart ensoleillement
    const [selection, setSelection] = useState(new Set());
    const [dessin, setDessin] = useState(null);           // tracé en cours (rect, poly, faite, mesure, select)
    const [mesure, setMesure] = useState(null);
    const [nAuto, setNAuto] = useState(p.nb_panneaux || 16);
    const canvasRef = useRef(null), wrapRef = useRef(null); const drag = useRef(null); const espace = useRef(false);
    const segments = (toit && toit.segments) || [];
    const marges = E.marges || m.marges();

    const publier = (e) => { setE(e); dernierEtat.current = { ...e, image: () => m.exporterImage() }; try { window.dispatchEvent(new CustomEvent("raycast:editeur", { detail: dernierEtat.current })); } catch (x) { /* noop */ } };
    useEffect(() => m.onChange(publier), []); // eslint-disable-line

    const charger = async () => {
      if (!toit || !toit.centre) return;
      setMsg({ loading: "Chargement des couches Google (image, relief, masque, ensoleillement)…" }); setPret(false);
      try {
        const r = await m.chargerCouches(toit.centre.lat, toit.centre.lng, toit);
        (de0.obstacles || []).forEach(ob => m.ajouterObstacle(ob)); (de0.faites || []).forEach(f => m.ajouterFaite(f)); (de0.panneaux || []).forEach(q => m.poser({ lat: q.lat, lng: q.lng }));
        const d = r.date; const dateTxt = d && typeof d === "object" ? [d.year, d.month, d.day].filter(Boolean).join("-") : (d || "");
        setVue({ scale: 0, ox: 0, oy: 0 }); setPret(true); publier(m.etat());
        setMsg({ ok: `Couches chargées (${r.qualite || "qualité inconnue"}${dateTxt ? ", " + dateTxt : ""}) : ${segments.length} pans, ${fmtNum(r.repere.mParPx * 100, 0)} cm par pixel.` });
      } catch (e) { setMsg({ err: "Couches indisponibles : " + (e.message || e) }); }
    };

    const hauteurScene = () => Math.round(Math.max(420, Math.min(window.innerHeight * 0.7, 900)));
    useEffect(() => { // cadrage initial sur le bâtiment
      if (!pret || vue.scale) return; const wrap = wrapRef.current; if (!wrap || !wrap.clientWidth) return;
      setVue(m.vueCadree(wrap.clientWidth, hauteurScene(), 3));
    }, [pret, vue.scale]); // eslint-disable-line

    useEffect(() => { // rendu : tout vient du moteur, la vue ajoute seulement le tracé en cours
      const cv = canvasRef.current; if (!cv || !pret || !vue.scale) return;
      const wrap = wrapRef.current; const Wc = wrap ? wrap.clientWidth : cv.clientWidth, Hc = hauteurScene(); const dpr = window.devicePixelRatio || 1;
      if (cv.width !== Math.round(Wc * dpr) || cv.height !== Math.round(Hc * dpr)) { cv.width = Math.round(Wc * dpr); cv.height = Math.round(Hc * dpr); cv.style.width = Wc + "px"; cv.style.height = Hc + "px"; }
      const ctx = cv.getContext("2d"); ctx.setTransform(dpr, 0, 0, dpr, 0, 0); ctx.fillStyle = "#0b1b2b"; ctx.fillRect(0, 0, Wc, Hc);
      m.dessinerBase(ctx, vue);
      if (soleil) m.dessinerCalqueSoleil(ctx, vue, mois);
      m.dessinerContours(ctx, vue, { marges: outil === "poser" });
      m.dessinerPanneaux(ctx, vue, { survol: survol && survol.existant != null ? survol.existant : -1, selection, fantome: outil === "poser" && survol && survol.fantome ? survol.fantome : null });
      if (dessin) {
        ctx.save(); ctx.setLineDash([5, 4]); ctx.lineWidth = 1.5;
        if (dessin.type === "rect" || dessin.type === "select") { ctx.strokeStyle = dessin.type === "select" ? "#22d3ee" : "#ef4444"; ctx.fillStyle = dessin.type === "select" ? "rgba(34,211,238,.12)" : "rgba(239,68,68,.25)"; const x = Math.min(dessin.a.x, dessin.b.x), y = Math.min(dessin.a.y, dessin.b.y), w = Math.abs(dessin.b.x - dessin.a.x), h = Math.abs(dessin.b.y - dessin.a.y); ctx.fillRect(x, y, w, h); ctx.strokeRect(x, y, w, h); }
        if (dessin.type === "poly") { ctx.strokeStyle = "#ef4444"; ctx.beginPath(); dessin.pts.forEach((q, k) => k ? ctx.lineTo(q.x, q.y) : ctx.moveTo(q.x, q.y)); if (dessin.b) ctx.lineTo(dessin.b.x, dessin.b.y); ctx.stroke(); dessin.pts.forEach(q => { ctx.beginPath(); ctx.arc(q.x, q.y, 3, 0, Math.PI * 2); ctx.fillStyle = "#ef4444"; ctx.fill(); }); }
        if ((dessin.type === "faite" || dessin.type === "mesure") && dessin.b) { ctx.strokeStyle = dessin.type === "faite" ? "#ffffff" : "#facc15"; ctx.beginPath(); ctx.moveTo(dessin.a.x, dessin.a.y); ctx.lineTo(dessin.b.x, dessin.b.y); ctx.stroke(); }
        ctx.restore();
      }
      if (mesure) { ctx.save(); ctx.strokeStyle = "#facc15"; ctx.lineWidth = 2; ctx.beginPath(); ctx.moveTo(mesure.a.x, mesure.a.y); ctx.lineTo(mesure.b.x, mesure.b.y); ctx.stroke(); const tx = (mesure.a.x + mesure.b.x) / 2, ty = (mesure.a.y + mesure.b.y) / 2; const t = `${fmtNum(mesure.m, 2)} m`; ctx.font = "bold 12px system-ui"; const w = ctx.measureText(t).width + 10; ctx.fillStyle = "rgba(11,27,43,.85)"; ctx.fillRect(tx - w / 2, ty - 18, w, 18); ctx.fillStyle = "#facc15"; ctx.fillText(t, tx - w / 2 + 5, ty - 5); ctx.restore(); }
      m.dessinerHabillage(ctx, Wc, Hc, vue);
    }, [pret, vue, E, soleil, mois, outil, survol, selection, dessin, mesure]); // eslint-disable-line

    const posSouris = (ev) => { const r = canvasRef.current.getBoundingClientRect(); const x = ev.clientX - r.left, y = ev.clientY - r.top; const g = m.ecranVersGeo(vue, x, y); return { x, y, lat: g.lat, lng: g.lng, pan: m.panAuPoint(g.lat, g.lng) }; };
    const onDown = (ev) => {
      if (!pret) return;
      if (ev.button === 1 || espace.current) { drag.current = { pan: true, x: ev.clientX, y: ev.clientY, ox: vue.ox, oy: vue.oy }; ev.preventDefault(); return; }
      if (ev.button !== 0) return;
      const ps = posSouris(ev);
      if (outil === "mesure") { if (!dessin) setDessin({ type: "mesure", a: ps, b: ps }); else { setMesure({ a: dessin.a, b: ps, m: m.mesurer(dessin.a, ps) }); setDessin(null); } return; }
      if (outil === "faite") { if (!dessin) setDessin({ type: "faite", a: ps, b: ps }); else { m.ajouterFaite({ a: dessin.a, b: ps }); setDessin(null); } return; }
      if (outil === "obstacle") { setDessin({ type: "rect", a: ps, b: ps }); return; }
      if (outil === "polygone") { if (!dessin) setDessin({ type: "poly", pts: [ps], b: ps }); else if (ev.detail >= 2 && dessin.pts.length >= 3) { m.ajouterObstacle({ type: "poly", pts: dessin.pts }); setDessin(null); } else setDessin({ ...dessin, pts: [...dessin.pts, ps] }); return; }
      if (ev.ctrlKey || ev.metaKey) { drag.current = { select: true, a: ps, b: ps }; setDessin({ type: "select", a: ps, b: ps }); return; }
      const idx = m.indexPanneauSous(ps.lat, ps.lng);
      if (idx >= 0) { if (ev.shiftKey) setSelection(prev => { const n = new Set(prev); n.has(idx) ? n.delete(idx) : n.add(idx); return n; }); else { m.retirer(idx); setSelection(new Set()); } return; }
      m.poser(ps); drag.current = { peindre: true };
    };
    const onMove = (ev) => {
      if (!pret) return;
      if (drag.current && drag.current.pan) { setVue(v => ({ ...v, ox: drag.current.ox + ev.clientX - drag.current.x, oy: drag.current.oy + ev.clientY - drag.current.y })); return; }
      const ps = posSouris(ev);
      if (drag.current && drag.current.select) { drag.current.b = ps; setDessin({ type: "select", a: drag.current.a, b: ps }); return; }
      if (dessin) setDessin({ ...dessin, b: ps });
      const f = m.fluxAuPoint(ps.lat, ps.lng, mois); const sous = m.indexPanneauSous(ps.lat, ps.lng);
      setCurseur(f ? { x: ev.clientX, y: ev.clientY, flux: f.flux, acces: f.acces, irradiance: f.irradiance_estimee != null ? f.irradiance_estimee : f.flux, pan: segments.find(x => x.index === f.pan) || null, panneau: sous } : null);
      if (sous >= 0) setSurvol({ existant: sous });
      else if (outil === "poser" && ps.pan >= 0) setSurvol({ fantome: { lat: ps.lat, lng: ps.lng } });
      else setSurvol(null);
      if (drag.current && drag.current.peindre && ps.pan >= 0) m.poser(ps);
    };
    const onUp = () => {
      if (drag.current && drag.current.select) { const a = drag.current.a, b = drag.current.b; const sel = new Set(); E.panneaux.forEach((q, i) => { const sp = m.geoVersEcran(vue, q.lat, q.lng); if (sp.x >= Math.min(a.x, b.x) && sp.x <= Math.max(a.x, b.x) && sp.y >= Math.min(a.y, b.y) && sp.y <= Math.max(a.y, b.y)) sel.add(i); }); setSelection(sel); setDessin(null); }
      if (dessin && dessin.type === "rect") { const a = dessin.a, b = dessin.b; if (m.mesurer(a, { lat: b.lat, lng: a.lng }) > 0.1 && m.mesurer(a, { lat: a.lat, lng: b.lng }) > 0.1) { const c = [[a.x, a.y], [b.x, a.y], [b.x, b.y], [a.x, b.y]].map(([x, y]) => m.ecranVersGeo(vue, x, y)); m.ajouterObstacle({ type: "rect", pts: c }); } setDessin(null); }
      drag.current = null;
    };
    const onWheel = (ev) => { ev.preventDefault(); const r = canvasRef.current.getBoundingClientRect(); const mx = ev.clientX - r.left, my = ev.clientY - r.top; const f = ev.deltaY < 0 ? 1.15 : 1 / 1.15; setVue(v => { const sc = Math.min(16, Math.max(0.2, v.scale * f)); return { scale: sc, ox: mx - (mx - v.ox) * (sc / v.scale), oy: my - (my - v.oy) * (sc / v.scale) }; }); };
    // Molette : écouteur natif non passif (React 17+ pose onWheel en passif : preventDefault y est refusé, la page défilait en zoomant).
    useEffect(() => {
      const cv = canvasRef.current; if (!cv) return;
      cv.addEventListener("wheel", onWheel, { passive: false });
      return () => cv.removeEventListener("wheel", onWheel);
    }, [pret]); // eslint-disable-line
    useEffect(() => {
      const kd = (e) => {
        if (e.target && /input|select|textarea/i.test(e.target.tagName)) return;
        if (e.code === "Space") { espace.current = true; e.preventDefault(); }
        if ((e.key === "Delete" || e.key === "Backspace") && selection.size) { m.retirerPlusieurs([...selection]); setSelection(new Set()); }
        if (e.key === "r" || e.key === "R") m.setOrientation(m.orientation() === "portrait" ? "paysage" : "portrait");
        if ((e.ctrlKey || e.metaKey) && e.key.toLowerCase() === "z") { e.preventDefault(); e.shiftKey ? m.retablir() : m.annuler(); }
        if ((e.ctrlKey || e.metaKey) && e.key.toLowerCase() === "y") { e.preventDefault(); m.retablir(); }
        if (e.key === "Escape") { setDessin(null); setOutil("poser"); setMesure(null); setSelection(new Set()); }
      };
      const ku = (e) => { if (e.code === "Space") espace.current = false; };
      window.addEventListener("keydown", kd); window.addEventListener("keyup", ku);
      return () => { window.removeEventListener("keydown", kd); window.removeEventListener("keyup", ku); };
    }, [selection]); // eslint-disable-line

    const appliquer = () => {
      if (!pret || !E.n) return;
      const premier = segments[0] ? segments[0].index : 0;
      const pans_toit = E.pans.filter(x => x.nb_panneaux > 0).map(x => ({ nom: x.index === premier ? "toit principal" : `pan ${x.index + 1}`, orientation: x.orientation, revetement: s.revetement || (s.pans_toit && s.pans_toit[0] && s.pans_toit[0].revetement) || "", pente: (segments.find(sg => sg.index === x.index) || {}).pente || "", nb_panneaux: x.nb_panneaux })).slice(0, 6);
      const image = m.exporterImage(); const kwhDc = Math.round(E.kwh_an / 0.96);
      // Recomposition du devis par le parcours (passage en mode solaire si la soumission vient du catalogue), modèle de l'éditeur.
      const PR = window.ParcoursRE || {};
      const catNow = window.CatalogueRE && window.CatalogueRE._cache ? window.CatalogueRE._cache() : null;
      const r = catNow && PR.appliquerPanneaux ? PR.appliquerPanneaux(state, catNow, { nb_panneaux: E.n, panneau: E.modele }) : { parcours: { ...(PR.DEFAUT || {}), ...p, panneau: E.modele, nb_panneaux: E.n }, lignes: state.lignes };
      const d = E.date; const dateTxt = d && typeof d === "object" ? [d.year, d.month, d.day].filter(Boolean).join("-") : (d || (toit && toit.date_imagerie) || null);
      // Même forme que le studio (pans avec accès solaire, date d'imagerie) : la proposition s'en sert pour le tableau des pans.
      const design_editeur = { modele: E.modele, orientation: E.orientation, marge_bord: marges.bord, marge_arete: marges.arete, marge_obstacle: marges.obstacle, obstacles: E.obstacles, faites: E.faites, hourly_shade_ids: E.hourly_shade_ids || [],
        panneaux: E.panneaux.map(q => ({ lat: q.lat, lng: q.lng, pan: q.pan })), pans: E.pans.map(x => ({ index: x.index, nb_panneaux: x.nb_panneaux, acces_pct_moyen: x.acces_pct_moyen, acces_pct_pan: x.acces_pct_pan, kwh_an: x.kwh_an })),
        kwh_an_ac: E.kwh_an, kw: E.kw, acces_pct_moyen: E.acces_pct_moyen, date_imagerie: dateTxt, qualite_imagerie: E.qualite || (toit && toit.qualite_imagerie) || null };
      setState({ ...state, parcours: r.parcours, lignes: r.lignes, solaire: { ...s, pans_toit, pans: pans_toit.map(x => x.nom).join(", "), orientation: pans_toit.map(x => x.orientation).join(", "), pente: pans_toit[0] ? pans_toit[0].pente : s.pente, acces_pct: E.acces_pct_moyen, production_google_kwh: kwhDc, production_source: "google", design_google: toit,
        design_editeur, aurora_image: image || s.aurora_image || null } });
      setMsg({ ok: `Design appliqué : ${E.n} panneaux de ${E.watts} W (${fmtNum(E.kw)} kW), ≈ ${fmtInt(E.kwh_an)} kWh/an AC, accès solaire moyen ${E.acces_pct_moyen} %.` });
    };
    const gMax = E.pans.reduce((t, x) => t + (x.max || 0), 0);
    const viderTout = (fn, n) => { for (let i = n - 1; i >= 0; i--) fn(i); };

    return (
      <div className="re-editeur">
        <div className="re-editeur-head">
          <div><b>Éditeur de panneaux</b> <span className="re-muted">· vraie grandeur sur l'image satellite, pans et faîtes détectés, ensoleillement réel</span></div>
          {!pret ? <button className="re-btn primary small" disabled={!!msg.loading} onClick={charger}>{msg.loading || "Ouvrir l'éditeur"}</button> : <button className="re-btn small" onClick={charger}>↻ Recharger les couches</button>}
        </div>
        {msg.err && <div className="re-err">{msg.err}</div>}
        {msg.ok && <div className="re-ok">{msg.ok}</div>}
        {pret && (
          <div className="re-editeur-corps">
            <div className="re-editeur-outils">
              <label className="re-field"><span className="re-field-label">Panneau</span>
                <select value={E.modele} onChange={e => m.setModele(e.target.value)}>{Object.entries(MODELES).map(([k, x]) => <option key={k} value={k}>{x.nom} · {x.w} × {x.h} m</option>)}</select>
              </label>
              <div className="re-mode"><button className={E.orientation === "portrait" ? "on" : ""} onClick={() => m.setOrientation("portrait")}>Portrait</button><button className={E.orientation === "paysage" ? "on" : ""} onClick={() => m.setOrientation("paysage")}>Paysage</button></div>
              <div className="re-editeur-barre">
                {[["poser", "Panneaux"], ["obstacle", "Obstacle"], ["polygone", "Polygone"], ["faite", "Faîte"], ["mesure", "Mesurer"]].map(([k, t]) => <button key={k} className={"re-btn small" + (outil === k ? " on" : "")} onClick={() => { setOutil(k); setDessin(null); setMesure(null); }}>{t}</button>)}
                <button className={"re-btn small re-soleil" + (soleil ? " on" : "")} title="Carte d'ensoleillement" onClick={() => setSoleil(v => !v)}>☀</button>
              </div>
              {soleil && E.flux_mensuel && <label className="re-field"><span className="re-field-label">Période</span><select value={mois} onChange={e => setMois(Number(e.target.value))}><option value={0}>Annuel</option>{MOIS.map((x, i) => <option key={x} value={i + 1}>{x}</option>)}</select></label>}
              <div className="re-editeur-marges">
                <label>Rives, faîtes<input type="number" step="0.05" min="0" max="1.5" value={marges.bord} onChange={e => m.setMarges({ bord: Number(e.target.value) || 0 })} /></label>
                <label>Arêtes<input type="number" step="0.05" min="0" max="1.5" value={marges.arete} onChange={e => m.setMarges({ arete: Number(e.target.value) || 0 })} /></label>
                <label>Obstacles<input type="number" step="0.05" min="0" max="1.5" value={marges.obstacle} onChange={e => m.setMarges({ obstacle: Number(e.target.value) || 0 })} /></label>
              </div>
              <div className="re-editeur-barre">
                <input type="number" min="1" max="300" value={nAuto} onChange={e => setNAuto(Math.max(1, Number(e.target.value) || 1))} style={{ width: 64 }} title="Nombre de panneaux visé" />
                <button className="re-btn small primary" onClick={() => m.remplirAuto({ n: nAuto })} title="Meilleurs pans d'abord : nord et accès solaire sous 60 % exclus">⚡ Auto {nAuto}</button>
                <button className="re-btn small ghost" onClick={() => m.toutEffacer()} disabled={!E.n}>Tout effacer</button>
              </div>
              <div className="re-editeur-pans">
                {E.pans.map(x => <div key={x.index} className="re-editeur-pan"><span className="re-design-num">{x.index + 1}</span><span className="re-design-desc">{x.orientation} · {x.pente_deg}° · max {x.max}{x.google ? ` (Google ${x.google})` : ""} · accès {x.acces_pct_pan} %</span><b>{x.nb_panneaux}</b><button className="re-btn small" disabled={!x.max} onClick={() => m.remplirPan(x.index)}>Remplir</button></div>)}
              </div>
              <div className="re-editeur-barre">
                <button className="re-btn small ghost" onClick={() => m.annuler()} disabled={!E.peut_annuler} title="Ctrl+Z">↶ Annuler</button><button className="re-btn small ghost" onClick={() => m.retablir()} disabled={!E.peut_retablir} title="Ctrl+Y">↷ Rétablir</button>
                {E.obstacles.length > 0 && <button className="re-btn small ghost" onClick={() => viderTout(m.retirerObstacle, E.obstacles.length)}>Obstacles ({E.obstacles.length}) ✕</button>}
                {E.faites.length > 0 && <button className="re-btn small ghost" onClick={() => viderTout(m.retirerFaite, E.faites.length)}>Faîtes ({E.faites.length}) ✕</button>}
              </div>
              <div className="re-muted" style={{ fontSize: 11.5 }}>Clic : poser · clic sur un panneau : retirer · glisser : peindre · Maj+clic ou Ctrl+glisser : sélectionner · Suppr · R : pivoter · molette : zoom · espace+glisser : déplacer · Échap</div>
            </div>
            <div className="re-editeur-scene" ref={wrapRef}>
              <canvas ref={canvasRef} className={"re-editeur-canvas outil-" + outil} onMouseDown={onDown} onMouseMove={onMove} onMouseUp={onUp} onMouseLeave={() => { onUp(); setSurvol(null); setCurseur(null); }} onContextMenu={e => e.preventDefault()} />
              {soleil && <div className="re-soleil-legende"><span>Ombre</span><i /><span>Plein soleil</span><small>{mois ? MOIS[mois - 1] : "annuel"} · max {fmtInt(m.fluxMax(mois))} kWh/kW</small></div>}
              {curseur && (
                <div className="re-soleil-encart" style={{ left: 0, top: 0, transform: `translate(${Math.min(curseur.x + 16, window.innerWidth - 240)}px, ${curseur.y + 16}px)`, position: "fixed" }}>
                  {curseur.panneau >= 0 && E.panneaux[curseur.panneau] ? <div className="re-enc-titre">Panneau {curseur.panneau + 1} : <b>{fmtInt(E.panneaux[curseur.panneau].kwh_an)} kWh/an</b> · accès {E.panneaux[curseur.panneau].acces_pct} %</div> : null}
                  <div>Ensoleillement <b>{fmtInt(curseur.flux)}</b> kWh/kW/{mois ? "mois" : "an"}</div>
                  <div>Accès solaire <b>{Math.round(curseur.acces * 100)} %</b></div>
                  <div>Irradiance estimée <b>{fmtInt(curseur.irradiance)}</b> kWh/m²/{mois ? "mois" : "an"}</div>
                  {curseur.pan && <div className="re-muted">Pan {curseur.pan.index + 1} · {curseur.pan.orientation} · {curseur.pan.pente_deg}°</div>}
                </div>
              )}
              <div className="re-editeur-bandeau">
                <div><b>{E.n}</b><span>panneaux (max {gMax})</span></div>
                <div><b>{fmtNum(E.kw)} kW</b><span>puissance</span></div>
                <div><b>{fmtInt(E.kwh_an)} kWh</b><span>production AC / an</span></div>
                <div><b>{E.n ? fmtInt(E.rendement_kwh_kw) : "—"}</b><span>kWh par kW</span></div>
                <div><b>{E.n ? E.acces_pct_moyen + " %" : "—"}</b><span>accès solaire moyen</span></div>
                <button className="re-btn primary" disabled={!E.n} onClick={appliquer}>Appliquer à la soumission</button>
              </div>
            </div>
          </div>
        )}
      </div>
    );
  }
  SolaireEditeurRE.etat = () => dernierEtat.current;
  SolaireEditeurRE.moteur = () => instance;
  window.SolaireEditeurRE = SolaireEditeurRE;
})();
