// solaire-studio-re.jsx — STUDIO SOLAIRE plein écran (vue React posée sur le moteur window.SolaireMoteur et le modèle
// vectoriel window.SolaireModele), fidèle à la maquette validée le 3 novembre 2026 :
//   bandeau (adresse, bilan, consommation du client, 2D / 3D, ensoleillement, mois), rail d'outils (sélectionner, panneaux,
//   remplir, obstacle, mesurer, annuler, rétablir), scène 2D (photo aérienne voilée hors du toit, modèle vectoriel : faces,
//   faîtes, arêtes, noues, égouts et rives, cotes, arbres, obstacles ; panneaux réalistes du moteur ; calque d'ensoleillement
//   avec encart temps réel ; flèche nord, échelle, légende, aide), vue 3D (window.Solaire3DRE), panneau droit (maison,
//   panneau, pans de toit, production) et « Appliquer à la soumission ».
// Sans moteur chargé, le studio tourne en mode démonstration (maison fictive, aucune donnée client) pour voir l'interface.
// Sans analyse Google déjà faite (toit absent), le studio géocode l'adresse du client et lance l'analyse lui-même.
// Exposé : window.SolaireStudioRE ({ state, setState, toit, onFermer, onApplique })  — plein écran dans un portail sur <body>
//          window.SolaireStudioBoutonRE ({ state, setState, toit })                  — bouton « Ouvrir le studio solaire » + studio
// Évènements window : « raycast:studio » (detail = { action, ... }) à chaque action notable ; « raycast:editeur » (detail = etat du
// moteur + batiment + image()) pour la vue 3D et la proposition, même contrat que l'éditeur.
// Clavier : V sélectionner · P panneaux · A remplir · O obstacle · M mesurer · T toit · S ensoleillement · R pivoter (sélection, sinon tous) ·
//           F recadrer · Suppr ou Retour arrière retirer · Flèches tasser de 2 cm (Maj : 10 cm) · Ctrl+Z / Ctrl+Y · molette zoom ·
//           espace, bouton du milieu ou Maj + glisser : déplacer la vue · Alt pendant une pose ou un glisser : sans aimantation · Échap.
// Pose libre (4 nov. 2026, demande de JF) : les panneaux ont une position continue (moteur peutPoserLibre, deplacer, pivoterPanneaux,
//   dupliquer). Outil Panneaux : clic = pose exacte (aimantée aux voisins), glisser = pose en continu, clic sur un panneau = retrait ;
//   glisser depuis la vignette du panneau (panneau droit) vers le toit = pose. Outil Sélectionner : clic = sélection, Maj + clic ou
//   rectangle = plusieurs, glisser = déplacement du groupe avec aperçu (vert accepté, rouge refusé), barre flottante Supprimer,
//   Dupliquer, Pivoter, clic droit = menu, double-clic sur un panneau = pivoter. Les panneaux qui ne tiennent plus (toit modifié,
//   marges) sont dessinés en rouge, jamais retirés d'office.
// Encart temps réel : au survol d'un pan, avec n'importe quel outil et sans calque ni panneau, le studio affiche kWh/kW à cet endroit,
//   accès solaire, production d'un panneau posé ici, pan, orientation et pente (lecture du flux déjà chargé, aucun recalcul).
// CONTRAT « Toit » (éditeur du modèle du toit, fichier solaire-toit-editeur-re.jsx d'un autre agent) : l'outil « Toit » du rail rend
//   window.SolaireToitEditeurRE({ modele, projection: { versPx(xm, ym) → { x, y } px du canevas 2D, versM(px, py) → { x, y } mètres du
//   repère du moteur (est, nord) }, onModele(nouveauModele) }) en superposition de la scène 2D (élément .re-studio-toit-ov, pleine
//   taille, évènements souris à lui). onModele remplace le modèle courant : moteur.appliquerModele(nouveau) (pans et zones posables
//   recalculés depuis nouveau.faces[].polygone_latlng et .pan, panneaux conservés et signalés en rouge s'ils sortent), vue 3D
//   rafraîchie (prop batiment), entrée dans l'historique annuler et rétablir. Sans module chargé : message « bientôt ».
// PHASE 2 (6 nov. 2026, GO de JF) : flux en deux étapes comme Aurora.
//   Étape 1 « Analyser la maison » : adresse et bâtiment retenus (précision du géocodage ; adresse approximative → JF clique sur le
//     bon toit, le bâtiment retenu est celui qui CONTIENT le point), bouton « Analyser la maison » = moteur de pans v2
//     (window.SolairePans : plans tirés du relief, contours, faîtes, arêtes, noues, égouts et rives typés, recalage sur Google et
//     écarts > 5° signalés, irradiance moyenne et production kWh/kW/an par pan, bornes de Mascouche). Correction à la main : outil Toit.
//   Étape 2 « Design » : palette de modules (LONGi 500 W par défaut, modèle et code), vrai glisser-déposer à la souris ou au doigt
//     (pointer events) : l'aperçu suit le curseur aux vraies dimensions, projeté dans le plan du pan survolé, vert si valide, rouge
//     sinon (raison affichée) ; relâché sur un pan valide = posé ; relâché ailleurs = le module retourne dans la liste (pose annulée).
//     Un module posé se reprend et se déplace de même ; relâché hors pan, il est retiré (retour dans la liste) ; relâché sur une
//     position refusée, il revient à sa place. Aimantation douce aux voisins et aux marges, Alt la coupe. Marges en cm (égout, faîte et
//     arêtes, rives, obstacles), globales et par pan, appliquées en direct (les modules qui ne tiennent plus passent en rouge).
//   3D : emplacement window.Solaire3DTilesRE (Google Photorealistic 3D Tiles, à venir) avec repli sur window.Solaire3DRE.
//     Contrat : <Solaire3DTilesRE lat lng panneaux modele orientation pans toit batiment cle onEchec /> ; Solaire3DTilesRE.disponible()
//     facultatif (false → repli) ; onEchec() appelé par le module s'il ne peut pas afficher (quota, erreur) → repli immédiat.
//     cle = clé navigateur « Raycast 3D » (Map Tiles) lue dans app_settings : window.RaycastDB.getAppSetting("google_3d").key, saisie
//     par un administrateur dans Paramètres, Intégrations (champ masqué). Jamais dans git ni dans Vercel. Sans clé : repli sur la 3D actuelle.
(function () {
  const { useState, useEffect, useRef, useMemo } = React;
  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 PENTE = (deg) => (deg == null ? "" : `${Math.round(Math.tan((Number(deg) || 0) * Math.PI / 180) * 12)}/12`);
  const ORI = { nord: "Nord", est: "Est", sud: "Sud", ouest: "Ouest", "nord-est": "Nord-est", "sud-est": "Sud-est", "sud-ouest": "Sud-ouest", "nord-ouest": "Nord-ouest" };
  const maintenant = () => new Date().toLocaleString("fr-CA", { timeZone: "America/Toronto", hour12: false }); // heure de Mascouche
  async function jwt() { try { const { data } = await window.RAYCAST_SUPABASE.auth.getSession(); return data && data.session ? data.session.access_token : null; } catch (e) { return null; } }
  const TARIF = 0.11142; // $/kWh Hydro-Québec, tarif D (1re tranche), pour l'économie an 1 affichée
  const MOIS = (window.SolaireMoteur && window.SolaireMoteur.MOIS) || ["janv.", "févr.", "mars", "avr.", "mai", "juin", "juil.", "août", "sept.", "oct.", "nov.", "déc."];
  const attendre = (ms) => new Promise(r => setTimeout(r, ms));
  // Arêtes typées : même palette que la maquette validée (écran en SVG, export en canevas)
  const LIGNES = { faite: { couleur: "#fde68a", largeur: 3.2 }, arete: { couleur: "#ffffff", largeur: 1.6 }, noue: { couleur: "#38bdf8", largeur: 1.8, tirets: "7 4" }, egout: { couleur: "#e2e8f0", largeur: 2.4 }, rive: { couleur: "#e2e8f0", largeur: 2.4 } };
  const MODELES_REPLI = { longi500: { id: "longi500", nom: "LONGi Hi-MO 7, 500 W (en stock)", watts: 500, w: 1.134, h: 1.961, qbo: "509" } };
  const CODES_MODELES = { longi500: "LR8-54HGBB-500M" }; // code fabricant affiché dans la palette
  const RENDEMENT = (window.SolaireMoteur && window.SolaireMoteur.RENDEMENT_AC) || 0.85;
  const PRECISION = { ROOFTOP: { txt: "toit exact", ok: true }, RANGE_INTERPOLATED: { txt: "interpolée sur la rue", ok: false }, GEOMETRIC_CENTER: { txt: "centre d'une zone", ok: false }, APPROXIMATE: { txt: "approximative", ok: false } };
  const SOURCES_POINT = { adresse: "adresse géocodée", fiche: "coordonnées de la fiche", google: "centre du bâtiment Google", clic: "clic sur le toit" };
  const MARGES_UI = [["egout", "Égout", "bas du pan, gouttière"], ["faite", "Faîte, arêtes", "haut du pan, arêtes et noues"], ["rive", "Rives", "côtés du pan"], ["obstacle", "Obstacles", "cheminées, évents"]];
  const AZ = (deg) => { const n = ["N", "NE", "E", "SE", "S", "SO", "O", "NO"]; return n[Math.round((((Number(deg) || 0) % 360) + 360) % 360 / 45) % 8]; };

  async function analyserToit(lat, lng, qualite) {
    const t = await jwt(); if (!t) throw new Error("Session expirée");
    const r = await fetch(`${WORKER_URL}/raycast/solaire/toit?lat=${lat}&lon=${lng}&qualite=${qualite || "MEDIUM"}`, { headers: { Authorization: "Bearer " + t } });
    const j = await r.json().catch(() => ({}));
    if (!r.ok) throw new Error(j.error || `HTTP ${r.status}`);
    return j;
  }
  /** Point de départ et précision : géocodage de l'adresse (précision Google : ROOFTOP, RANGE_INTERPOLATED, GEOMETRIC_CENTER, APPROXIMATE),
   *  sinon coordonnées de la fiche, sinon centre du bâtiment Google. Le géocodage est en cache 30 jours côté worker. */
  async function pointClient(client, toit) {
    const texte = client.address_full || [client.address_civic, client.address_street, client.address_city, client.address_postal].filter(Boolean).join(", ");
    if (texte && texte.length >= 5 && window.GeoRE && window.GeoRE.geocoder) {
      try { const g = await window.GeoRE.geocoder(texte); if (g && g.lat) return { lat: Number(g.lat), lng: Number(g.lng), precision: g.precision || null, source: "adresse", adresse: g.address_full || texte, geo: g }; } catch (e) { /* repli plus bas */ }
    }
    if (client.lat && client.lng) return { lat: Number(client.lat), lng: Number(client.lng), precision: client.precision || client.geo_precision || null, source: "fiche", adresse: texte };
    if (toit && toit.centre) return { lat: toit.centre.lat, lng: toit.centre.lng, precision: null, source: "google", adresse: texte };
    if (!texte || texte.length < 5) throw new Error("Entre d'abord l'adresse du client à l'étape Client (numéro, rue et ville suffisent).");
    throw new Error("Adresse introuvable par Google. Vérifie l'adresse à l'étape Client.");
  }
  const dansRaster = (rep, lat, lng, margePx) => { if (!rep) return false; const p = rep.pxDe(lat, lng); const m = margePx || 0; return p.x >= m && p.y >= m && p.x <= rep.w - m && p.y <= rep.h - m; };
  /** Petite courbe de 12 barres (flux ou production par mois). */
  function Mois12({ v, h, titre }) { if (!v || v.length !== 12) return null; const mx = Math.max(1, ...v); const H = h || 16; return <svg className="re-studio-mois12" viewBox={`0 0 48 ${H}`} width="48" height={H} aria-label={titre || "par mois"}><title>{titre || ""}</title>{v.map((x, i) => <rect key={i} x={i * 4} y={H - Math.max(1, x / mx * H)} width="3" height={Math.max(1, x / mx * H)} rx="0.5" />)}</svg>; }
  /** Noms des pans : orientation ; quand plusieurs pans partagent la même orientation, le plus grand garde le nom simple, les autres « (2e) », « (3e) ». */
  function nommerPans(pans) {
    const compte = {}; const noms = {};
    for (const x of pans.slice().sort((a, b) => (b.surface_m2 || 0) - (a.surface_m2 || 0))) { const o = (Number(x.pente_deg) || 0) < 10 ? "Plat" : (ORI[x.orientation] || x.orientation || "Pan"); /* toit plat : l'azimut de Google (souvent 0, « nord ») n'a pas de sens */ compte[o] = (compte[o] || 0) + 1; noms[x.index] = compte[o] === 1 ? o : `${o} (${compte[o]}e)`; }
    return noms;
  }
  const dansPoly = (pts, x, y) => { let inside = false; for (let i = 0, j = pts.length - 1; i < pts.length; j = i++) { const A = pts[i], B = pts[j]; if ((A.y > y) !== (B.y > y) && x < (B.x - A.x) * (y - A.y) / (B.y - A.y) + A.x) inside = !inside; } return inside; };
  const dateTexte = (d) => (d && typeof d === "object") ? [d.year, d.month, d.day].filter(Boolean).join("-") : (d || "");

  // ── Démonstration sans moteur : maison fictive à 4 pans, 16 panneaux (aucune donnée client) ──
  const DEMO = (() => {
    const faces = [
      { index: 0, pan: 1, nom: "Nord", orientation: "nord", pente_deg: 40, surface_m2: 44, acces_pct: 52, poly: [[0, 0], [11, 0], [6.5, 4.5], [4.5, 4.5]] },
      { index: 1, pan: 2, nom: "Est", orientation: "est", pente_deg: 40, surface_m2: 28, acces_pct: 79, poly: [[11, 0], [11, 9], [6.5, 4.5]] },
      { index: 2, pan: 3, nom: "Sud", orientation: "sud", pente_deg: 40, surface_m2: 44, acces_pct: 95, poly: [[0, 9], [4.5, 4.5], [6.5, 4.5], [11, 9]] },
      { index: 3, pan: 4, nom: "Ouest", orientation: "ouest", pente_deg: 40, surface_m2: 28, acces_pct: 73, poly: [[0, 0], [4.5, 4.5], [0, 9]] },
    ];
    const aretes = [{ t: "faite", a: [4.5, 4.5], b: [6.5, 4.5] }, { t: "arete", a: [0, 0], b: [4.5, 4.5] }, { t: "arete", a: [11, 0], b: [6.5, 4.5] }, { t: "arete", a: [0, 9], b: [4.5, 4.5] }, { t: "arete", a: [11, 9], b: [6.5, 4.5] }, { t: "egout", a: [0, 0], b: [11, 0] }, { t: "egout", a: [11, 0], b: [11, 9] }, { t: "egout", a: [11, 9], b: [0, 9] }, { t: "egout", a: [0, 9], b: [0, 0] }];
    const panneaux = []; const w = 1.134, h = 1.961 * Math.cos(40 * Math.PI / 180);
    [[2.0, 7.3, 6], [3.2, 5.8, 4]].forEach(([u0, v, n]) => { for (let i = 0; i < n; i++) panneaux.push({ pan: 2, kwh_an: 790, acces_pct: 95, coins: [[u0 + i * (w + .02), v], [u0 + i * (w + .02) + w, v], [u0 + i * (w + .02) + w, v + h], [u0 + i * (w + .02), v + h]] }); });
    [[9.3, 2.2, 4], [7.8, 3.4, 2]].forEach(([u, v0, n]) => { for (let i = 0; i < n; i++) panneaux.push({ pan: 1, kwh_an: 660, acces_pct: 79, coins: [[u, v0 + i * (w + .02)], [u + h, v0 + i * (w + .02)], [u + h, v0 + i * (w + .02) + w], [u, v0 + i * (w + .02) + w]] }); });
    return { faces, aretes, panneaux, mesures: { surface_toit_m2: 144, egout_m: 5.8, faite_m: 9.6, faces: 4 }, dims: [11, 9] };
  })();
  const ETAT_DEMO = { panneaux: DEMO.panneaux, pans: DEMO.faces.map(f => ({ index: f.index, orientation: f.orientation, pente_deg: f.pente_deg, surface_m2: f.surface_m2, acces_pct_pan: f.acces_pct, acces_pct_moyen: f.acces_pct, max: 9, nb_panneaux: DEMO.panneaux.filter(q => q.pan === f.index).length })), n: 16, kw: 8, kwh_an: 11535, rendement_kwh_kw: 1442, acces_pct_moyen: 92, modele: "longi500", orientation: "portrait", obstacles: [], faites: [], peut_annuler: false, peut_retablir: false };

  /** Bouton du rail d'outils : icône, libellé, infobulle avec raccourci ; `action` = bouton d'action (Remplir), sinon choix de l'outil. */
  function Outil({ id, outil, onPick, label, tip, kbd, action, children }) {
    return <button type="button" className={"re-studio-outil" + (outil === id ? " on" : "")} onClick={() => { if (action) action(); else onPick(id); }} aria-label={label}><svg viewBox="0 0 24 24">{children}</svg><small>{label}</small><span className="tip">{tip}{kbd ? <kbd>{kbd}</kbd> : null}</span></button>;
  }

  function SolaireStudioRE({ state, setState, toit: toitProp, onFermer, onApplique }) {
    const Moteur = window.SolaireMoteur || null;
    const s = (state && state.solaire) || {}; const p = (state && state.parcours) || {}; const de0 = s.design_editeur || {}; const client = (state && state.client) || {};
    const demo = !Moteur;
    const MODELES = Moteur ? Moteur.MODELES : MODELES_REPLI;
    const [toit, setToit] = useState(toitProp && toitProp.centre ? toitProp : null);
    const mRef = useRef(null); const geoRef = useRef(null); const journal = useRef([]);
    const noter = (action, detail) => { journal.current = [...journal.current.slice(-99), { t: maintenant(), action, detail: detail || null }]; try { window.dispatchEvent(new CustomEvent("raycast:studio", { detail: { action, ...(detail || {}) } })); } catch (e) { /* noop */ } };

    const [pret, setPret] = useState(false);
    const [msg, setMsg] = useState(demo ? { info: "Mode démonstration : moteur solaire non chargé, maison fictive." } : { loading: "Préparation du studio…" });
    const [toast, setToast] = useState(null);
    const [E, setE] = useState(() => demo ? ETAT_DEMO : { panneaux: [], pans: [], n: 0, kw: 0, kwh_an: 0, rendement_kwh_kw: 0, acces_pct_moyen: 0, modele: de0.modele || p.panneau || "longi500", orientation: de0.orientation || "portrait", obstacles: [], faites: [], marges: null, peut_annuler: false, peut_retablir: false });
    const [modele, setModele] = useState(null);              // modèle vectoriel (SolaireModele) ou null
    const [vueMode, setVueMode] = useState("2d");            // 2d | 3d
    const [vue3dMontee, setVue3dMontee] = useState(false);   // la vue 3D reste montée après sa première ouverture
    const [outil, setOutil] = useState("selectionner");      // selectionner | panneaux | obstacle | mesurer | toit
    const [soleil, setSoleil] = useState(false);
    const [mois, setMois] = useState(0);                     // 0 = annuel
    const [vue, setVue] = useState({ scale: 0, ox: 0, oy: 0 });
    const [dim, setDim] = useState({ W: 0, H: 0 });
    const [survol, setSurvol] = useState(null);              // { existant: i } | { fantome: { lat, lng } }
    const [panSurvol, setPanSurvol] = useState(null);
    const [curseur, setCurseur] = useState(null);            // encart ensoleillement sous le curseur
    const [panSel, setPanSel] = useState(null);
    const [selection, setSelection] = useState(new Set());   // panneaux sélectionnés (index)
    const [obstacleSel, setObstacleSel] = useState(null);    // obstacle manuel sélectionné (index)
    const [dessin, setDessin] = useState(null);              // obstacle (rect) ou mesure en cours
    const [mesure, setMesure] = useState(null);
    const [conso, setConso] = useState(String(Number(client.conso_kwh || s.conso_kwh || 0) || ""));
    const [streetView, setStreetView] = useState(null);
    const [apercu, setApercu] = useState(null);              // aperçu d'un déplacement de groupe (moteur.apercuDeplacement)
    const [menu, setMenu] = useState(null);                  // menu contextuel { x, y }
    const [etape, setEtape] = useState("maison");           // maison (analyse) | design (pose)
    const [point, setPoint] = useState(null);                // { lat, lng, precision, source, adresse } point retenu pour le bâtiment
    const [zone, setZone] = useState(null);                  // composante du masque qui contient le point
    const [choixToit, setChoixToit] = useState(false);      // mode « clique sur le bon toit »
    const [analyse, setAnalyse] = useState(null);            // résumé du moteur de pans v2 (comparaison, bâtiment, avertissements)
    const [dnd, setDnd] = useState(null);                    // glisser-déposer en cours : { x, y (écran), r (validation), sur, raison, kwh, nouveau }
    const [fantomeDom, setFantomeDom] = useState(null);      // vignette qui suit le doigt ou la souris hors scène { x, y, retour }
    const [tilesEchec, setTilesEchec] = useState(false);
    const [cle3d, setCle3d] = useState(null);                // clé Map Tiles (app_settings « google_3d »), lue seulement si le module 3D réaliste existe
    const dndRef = useRef(null); const paletteRef = useRef(null); const toitRef = useRef(null); const pointRef = useRef(null); toitRef.current = toit; pointRef.current = point;
    const canvasRef = useRef(null), sceneRef = useRef(null); const drag = useRef(null); const espace = useRef(false);
    const poseVignette = useRef(false); const dernierePose = useRef(0); const modeleInitial = useRef(null);
    const m = mRef.current;
    const segments = (toit && toit.segments) || [];
    const marges = (E && E.marges) || (m && m.marges && m.marges()) || (Moteur ? Moteur.MARGES : { egout: 0.15, faite: 0.1, rive: 0.15, bord: 0.15, arete: 0.1, obstacle: 0.3 });
    const K = useRef({}); K.current = { selection, obstacleSel, panSel, dessin, outil, soleil, m, pret, onFermer, mesure, menu, etape, choixToit };

    // ── Moteur : abonnement, analyse du toit au besoin, chargement des couches, modèle vectoriel ──
    const publier = (e) => { setE(e); const b = e.batiment || modeleInitial.current; if (b !== modele) setModele(b); const d = { ...e, batiment: b, image: () => exporterImageStudio() }; try { window.dispatchEvent(new CustomEvent("raycast:editeur", { detail: d })); } catch (x) { /* noop */ } };
    useEffect(() => { const mm = mRef.current; if (!mm || !pret) return; return mm.onChange(publier); }, [pret, modele]); // eslint-disable-line
    /** Étape 1 : analyse de la maison (moteur de pans v2 sur le bâtiment qui contient le point), puis zones de pose = faces du modèle. */
    const analyserMaison = async (opts) => {
      const mm = mRef.current; const T = (opts && opts.toit) || toitRef.current; const P = (opts && opts.point) || pointRef.current; if (!mm || !T) return null;
      const C = mm.couches && mm.couches(); if (!C || !C.dsm) { setToast({ info: "Relief Google absent à cette adresse : analyse impossible, pans de Google conservés." }); return null; }
      setMsg({ loading: "Analyse de la maison : plans du relief, contours, faîtes, arêtes, noues, égouts et rives…" }); await attendre(40);
      let md = null, res = null;
      try {
        if (window.SolairePans) {
          res = window.SolairePans.analyser({ rgb: C.rgb, dsm: C.dsm, masque: C.mask, flux: C.flux, fluxMois: C.fluxMois, repere: mm.repere(), segments: T.segments || [], point: P || T.centre });
          md = res.modele; mm.definirPans(res.segments);
        } else if (window.SolaireModele) { md = window.SolaireModele.construire({ rgb: C.rgb, dsm: C.dsm, masque: C.mask, flux: C.flux, repere: mm.repere(), segments: T.segments }); }
      } catch (e) { setMsg({}); setToast({ err: "Analyse impossible : " + (e && e.message || e) }); noter("analyse_echec", { erreur: String(e && e.message || e) }); return null; }
      if (!md || !md.faces || !md.faces.length) { setMsg({}); setToast({ err: "Analyse impossible : aucune face de toit." }); return null; }
      modeleInitial.current = md; let mdCourant = md;
      mm.appliquerModele(md, { historique: false });
      if (de0.modele_manuel && window.SolaireModele && window.SolaireModele.appliquerManuel && !(opts && opts.sansManuel)) { // toit corrigé à la main lors d'une ouverture précédente
        try { const mm2 = window.SolaireModele.appliquerManuel(md, de0.modele_manuel); if (mm2 && mm2.faces && mm2.faces.length) { mdCourant = mm2; mm.appliquerModele(mm2, { historique: false }); noter("modele_manuel_recharge", { faces: mm2.faces.length }); } } catch (e) { noter("modele_manuel_echec", { erreur: String(e && e.message || e) }); }
      }
      setModele(mdCourant);
      const resume = res ? { comparaison: res.comparaison, batiment: res.batiment, avertissements: res.avertissements, duree_ms: res.duree_ms, plans_dsm: res.plans_dsm, n: res.segments.length } : { comparaison: null, batiment: null, avertissements: [], n: md.faces.length };
      setAnalyse(resume); setMsg({});
      const cp = resume.comparaison;
      noter("analyse_maison", { pans: resume.n, apparies: cp && cp.apparies, google: cp && cp.pans_google, ecarts: cp && cp.ecarts_signales, ms: resume.duree_ms });
      if (!(opts && opts.silencieux)) setToast({ ok: `${resume.n} pans dessinés${cp ? ` · ${cp.apparies}/${cp.pans_google} recalés sur Google${cp.ecarts_signales ? ` · ${cp.ecarts_signales} écart${cp.ecarts_signales > 1 ? "s" : ""} de plus de 5° signalé${cp.ecarts_signales > 1 ? "s" : ""}` : ""}${cp.nouveaux ? ` · ${cp.nouveaux} pan${cp.nouveaux > 1 ? "s" : ""} que Google n'avait pas` : ""}` : ""}` });
      try { window.dispatchEvent(new CustomEvent("raycast:editeur", { detail: { ...mm.etat(), batiment: mdCourant } })); } catch (x) { /* noop */ }
      return resume;
    };
    /** Bâtiment visé : composante du masque qui contient le point (étape 1). */
    const majZone = (mm, P) => { if (!mm || !P || !window.SolairePans) { setZone(null); return null; } const C = mm.couches(); if (!C || !C.mask) return null; const z = window.SolairePans.composante(C.mask, mm.repere(), P, 3); const mpp = mm.repere().mParPx; const out = z.n ? { bin: z.bin, contient: z.contient, distance_m: z.distance_m, surface_m2: Math.round(z.n * mpp * mpp), bbox: z.bbox } : { bin: null, contient: false, distance_m: null, surface_m2: 0, bbox: null }; setZone(out); return out; };
    useEffect(() => {
      if (demo) return; let actif = true;
      (async () => {
        try {
          let T = toit;
          setMsg({ loading: "Localisation de l'adresse…" });
          let P = null; try { P = await pointClient(client, T); } catch (e) { if (!T) throw e; P = { lat: T.centre.lat, lng: T.centre.lng, precision: null, source: "google" }; }
          if (!actif) return;
          if (P.geo) { geoRef.current = P.geo; try { setState(st => ({ ...st, client: { ...((st && st.client) || {}), ...P.geo, address_full: P.geo.address_full } })); } catch (x) { /* fiche inchangée */ } }
          if (de0.point && isFinite(Number(de0.point.lat))) P = { ...P, lat: Number(de0.point.lat), lng: Number(de0.point.lng), source: de0.point.source || "clic" };
          delete P.geo; setPoint(P); pointRef.current = P;
          if (!T) {
            setMsg({ loading: "Analyse du toit par Google Solar…" });
            T = await analyserToit(P.lat, P.lng, "MEDIUM"); if (!actif) return;
            if (!T || !T.centre || !(T.segments || []).length) throw new Error("Google Solar ne couvre pas cette adresse : aucun pan de toit détecté. Colle une capture Aurora à l'étape Solaire, ou réessaie en basse qualité.");
            setToit(T); toitRef.current = T; noter("analyse_toit", { pans: T.segments.length, qualite: T.qualite_imagerie });
          }
          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: { egout: de0.marge_egout != null ? de0.marge_egout : (de0.marge_bord != null ? de0.marge_bord : Moteur.MARGES.egout), faite: de0.marge_faite != null ? de0.marge_faite : (de0.marge_arete != null ? de0.marge_arete : Moteur.MARGES.faite), rive: de0.marge_rive != null ? de0.marge_rive : (de0.marge_bord != null ? de0.marge_bord : Moteur.MARGES.rive), obstacle: de0.marge_obstacle != null ? de0.marge_obstacle : Moteur.MARGES.obstacle } });
          const mm = mRef.current;
          setMsg({ loading: "Chargement des couches Google (photo, relief, masque, ensoleillement annuel et mensuel)…" });
          // couches centrées sur le bâtiment de Google, ou sur le point quand Google a pris un bâtiment loin du point
          const R0 = 6371000, dCentre = Math.hypot((T.centre.lat - P.lat) * Math.PI / 180 * R0, (T.centre.lng - P.lng) * Math.PI / 180 * R0 * Math.cos(P.lat * Math.PI / 180));
          const centreCouches = dCentre > 25 ? P : T.centre;
          const r = await mm.chargerCouches(centreCouches.lat, centreCouches.lng, T);
          if (!actif) return;
          (de0.obstacles || []).forEach(ob => mm.ajouterObstacle(ob)); (de0.faites || []).forEach(f => mm.ajouterFaite(f));
          const z = majZone(mm, P);
          setPret(true); setVue({ scale: 0, ox: 0, oy: 0 });
          const besoinClic = !z || !z.contient || (P.precision && !(PRECISION[P.precision] || {}).ok);
          if ((de0.panneaux || []).length || de0.studio) { // design enregistré : analyse refaite puis retour direct au design
            const res = await analyserMaison({ toit: T, point: P, silencieux: true }); if (!actif) return;
            if (de0.marges_pans) Object.keys(de0.marges_pans).forEach(k => mm.setMargesPan(Number(k), de0.marges_pans[k], { historique: false }));
            (de0.panneaux || []).forEach(q => { if (mm.poserLibre) mm.poserLibre({ lat: q.lat, lng: q.lng }, { orientation: q.orientation, aimant: false, force: true }); else mm.poser({ lat: q.lat, lng: q.lng }); }); // positions libres rechargées telles quelles (en rouge si elles ne tiennent plus)
            if (res) { setEtape("design"); setOutil("selectionner"); }
          } else if (besoinClic) setChoixToit(true);
          setMsg({}); const e0 = mm.etat(); setE(e0);
          try { window.dispatchEvent(new CustomEvent("raycast:editeur", { detail: { ...e0, batiment: modeleInitial.current } })); } catch (x) { /* noop */ }
          setToast({ ok: `Couches chargées (${r.qualite || "qualité inconnue"}${r.date ? ", " + dateTexte(r.date) : ""}) · ${fmtNum(r.repere.mParPx * 100, 0)} cm par pixel${besoinClic && !(de0.panneaux || []).length ? " · clique sur le toit de la maison pour confirmer le bâtiment" : ""}` });
          noter("couches", { qualite: r.qualite, pans_google: (T.segments || []).length, precision: P.precision || null, point: P.source, dans_toit: !!(z && z.contient) });
        } catch (e) { if (actif) setMsg({ err: "Studio indisponible : " + (e && e.message || e) }); }
      })();
      return () => { actif = false; };
    }, []); // eslint-disable-line
    /** Clic de JF sur le bon toit : point retenu, bâtiment = composante qui le contient, buildingInsights refait à ce point (coût Google : 1 appel, en cache 30 jours). */
    const choisirToit = async (g) => {
      const mm = mRef.current; if (!mm) return; const P = { lat: g.lat, lng: g.lng, precision: point && point.precision, source: "clic", adresse: point && point.adresse };
      const z = majZone(mm, P); if (!z || !z.bin) { setToast({ info: "Aucun toit détecté ici : clique au milieu du toit de la maison." }); return; }
      setPoint(P); pointRef.current = P; setChoixToit(false); setAnalyse(null); setModele(null); modeleInitial.current = null; noter("choix_toit", { contient: z.contient, surface_m2: z.surface_m2 });
      try {
        const T2 = await analyserToit(P.lat, P.lng, "MEDIUM");
        if (T2 && T2.centre && (T2.segments || []).length) {
          setToit(T2); toitRef.current = T2;
          if (!dansRaster(mm.repere(), T2.centre.lat, T2.centre.lng, 60)) { setMsg({ loading: "Chargement des couches autour du toit choisi…" }); await mm.chargerCouches(P.lat, P.lng, T2); majZone(mm, P); setMsg({}); setVue({ scale: 0, ox: 0, oy: 0 }); }
          else mm.reinitialiserToit(T2);
        } else mm.reinitialiserToit({ ...(toitRef.current || {}), segments: [] });
      } catch (e) { noter("choix_toit_google_absent", { erreur: String(e && e.message || e) }); mm.reinitialiserToit({ ...(toitRef.current || {}), segments: [] }); }
      setToast({ ok: `Bâtiment retenu : celui qui contient ton clic (${fmtInt(z.surface_m2)} m² au sol). Lance « Analyser la maison ».` });
    };
    useEffect(() => { // photo Street View de la maison (clé navigateur des réglages, via GeoRE)
      let a = true; const lat = toit && toit.centre && toit.centre.lat, lng = toit && toit.centre && toit.centre.lng;
      if (!lat || !window.GeoRE || !window.GeoRE.streetViewUrl) return; window.GeoRE.streetViewUrl(lat, lng, "640x360").then(u => { if (a) setStreetView(u || null); }).catch(() => {});
      return () => { a = false; };
    }, [toit]);
    useEffect(() => { // clé navigateur Map Tiles : lue une fois, seulement quand window.Solaire3DTilesRE est chargé
      if (!window.Solaire3DTilesRE || !window.RaycastDB || !window.RaycastDB.getAppSetting) return; let a = true;
      window.RaycastDB.getAppSetting("google_3d").then(v => { if (a) setCle3d((v && v.key) || ""); }).catch(() => { if (a) setCle3d(""); });
      return () => { a = false; };
    }, []);
    useEffect(() => { if (!toast) return; const id = setTimeout(() => setToast(null), toast.err ? 8000 : 4500); return () => clearTimeout(id); }, [toast]);
    useEffect(() => { // taille de la scène (redimensionnement de la fenêtre)
      const el = sceneRef.current; if (!el) return;
      const mesurer = () => { const r = el.getBoundingClientRect(); setDim(d => (Math.round(r.width) === d.W && Math.round(r.height) === d.H) ? d : { W: Math.round(r.width), H: Math.round(r.height) }); };
      mesurer(); const ro = window.ResizeObserver ? new ResizeObserver(mesurer) : null; ro && ro.observe(el); window.addEventListener("resize", mesurer);
      return () => { ro && ro.disconnect(); window.removeEventListener("resize", mesurer); };
    }, []);
    useEffect(() => { document.body.classList.add("re-studio-ouvert"); return () => document.body.classList.remove("re-studio-ouvert"); }, []);
    useEffect(() => { if (selection.size && [...selection].some(i => i >= (E.panneaux || []).length)) setSelection(new Set()); if (obstacleSel != null && obstacleSel >= (E.obstacles || []).length) setObstacleSel(null); }, [E]); // eslint-disable-line

    // ── Géométrie d'écran : cadrage, échelle, modèle vectoriel en lat/lng puis en pixels ──
    const W = dim.W, H = dim.H;
    const roiZone = () => (zone && zone.bbox && !modele) ? { x0: zone.bbox.minx, y0: zone.bbox.miny, x1: zone.bbox.maxx + 1, y1: zone.bbox.maxy + 1 } : null;
    useEffect(() => { if (demo || !pret || vue.scale || !W || !m) return; setVue(m.vueCadree(W, H, roiZone() ? 5 : 3, roiZone())); }, [pret, vue.scale, W, H]); // eslint-disable-line
    const pxParM = useMemo(() => { if (!m || !pret || !vue.scale || !toit) return 0; const c = toit.centre; const a = m.geoVersEcran(vue, c.lat, c.lng), b = m.geoVersEcran(vue, c.lat, c.lng + 1 / (111320 * Math.cos(c.lat * Math.PI / 180))); return Math.hypot(b.x - a.x, b.y - a.y); }, [m, pret, vue, toit]);
    const MS = useMemo(() => { // modèle vectoriel en lat/lng (une fois par modèle)
      if (!modele || !m) return null; const rep = m.repere();
      const sommets = modele.sommets.map(q => rep.geoDe(q.x, q.y));
      const aretes = modele.aretes.map(a => ({ type: a.type, a: sommets[a.de], b: sommets[a.a], longueur_m: a.longueur_m, exterieur: !!a.mur && (a.faces || []).length <= 1 }));
      const faces = modele.faces.map(f => ({ index: f.index, pan: f.pan, ll: f.polygone_latlng, surface_m2: f.surface_m2, pente_deg: f.pente_deg }));
      const centre = rep.geoDe(modele.batiment.centre.px.x, modele.batiment.centre.px.y);
      const cotes = aretes.filter(a => a.exterieur && a.longueur_m >= 2.5).sort((x, y) => y.longueur_m - x.longueur_m).slice(0, 3);
      return { sommets, aretes, faces, centre, cotes, arbres: modele.arbres || [], obstacles: modele.obstacles_detectes || [] };
    }, [modele, m]);
    const OV = useMemo(() => { // modèle en pixels d'écran pour la vue courante
      if (!MS || !pret || !vue.scale || !m) return null;
      const P = (q) => m.geoVersEcran(vue, q.lat, q.lng); const C = P(MS.centre);
      const faces = MS.faces.map(f => { const pts = f.ll.map(P); const c = pts.reduce((t, q) => ({ x: t.x + q.x / pts.length, y: t.y + q.y / pts.length }), { x: 0, y: 0 }); return { ...f, pts, c }; });
      const aretes = MS.aretes.map(a => ({ type: a.type, A: P(a.a), B: P(a.b) }));
      const cotes = MS.cotes.map(c => { const A = P(c.a), B = P(c.b); const dx = B.x - A.x, dy = B.y - A.y, L = Math.hypot(dx, dy) || 1; let nx = -dy / L, ny = dx / L; const mx = (A.x + B.x) / 2, my = (A.y + B.y) / 2; if ((mx - C.x) * nx + (my - C.y) * ny < 0) { nx = -nx; ny = -ny; } const off = 16; let ang = Math.atan2(dy, dx) * 180 / Math.PI; if (ang > 90 || ang < -90) ang += 180; return { a: { x: A.x + nx * off, y: A.y + ny * off }, b: { x: B.x + nx * off, y: B.y + ny * off }, A, B, t: { x: mx + nx * (off + 9), y: my + ny * (off + 9) }, ang, texte: `${fmtNum(c.longueur_m, 1)} m` }; });
      const arbres = MS.arbres.map(t => ({ ...P(t), r: Math.max(2, (t.rayon_m || 2) * pxParM) }));
      const obstacles = MS.obstacles.map(o => ({ ...P(o), r: Math.max(4, (o.rayon_m || 0.3) * pxParM), rr: ((o.rayon_m || 0.3) + (marges.obstacle || 0.3)) * pxParM }));
      return { faces, aretes, cotes, arbres, obstacles, C };
    }, [MS, pret, vue, m, pxParM, marges.obstacle]);
    const echelle = useMemo(() => { if (!pxParM) return null; const L = [1, 2, 5, 10, 20, 50].find(l => l * pxParM >= 60) || 50; return { L, px: L * pxParM }; }, [pxParM]);

    // ── Scène 2D : rendu du canevas (photo, calque soleil, panneaux, tracés en cours) ──
    useEffect(() => {
      if (demo || !pret || !m) return; const cv = canvasRef.current; if (!cv || !vue.scale || !W) return;
      const dpr = window.devicePixelRatio || 1;
      if (cv.width !== Math.round(W * dpr) || cv.height !== Math.round(H * dpr)) { cv.width = Math.round(W * dpr); cv.height = Math.round(H * dpr); cv.style.width = W + "px"; cv.style.height = H + "px"; }
      const ctx = cv.getContext("2d"); ctx.setTransform(dpr, 0, 0, dpr, 0, 0); ctx.fillStyle = "#0b1220"; ctx.fillRect(0, 0, W, H);
      m.dessinerBase(ctx, vue);
      if (zone && zone.bin && (!OV || choixToit) && m.dessinerZone) m.dessinerZone(ctx, vue, zone.bin, choixToit ? [250, 204, 21] : [56, 189, 248]);
      if (soleil) m.dessinerCalqueSoleil(ctx, vue, mois);
      if (!OV && etape === "design") m.dessinerContours(ctx, vue, { marges: outil === "panneaux" }); // repli : contours du moteur tant que le modèle vectoriel n'est pas là
      if (OV && etape === "design" && m.vectoriel && m.vectoriel()) dessinerLignesMarge(ctx);
      m.dessinerPanneaux(ctx, vue, { survol: survol && survol.existant != null ? survol.existant : -1, selection, fantome: !dnd && outil === "panneaux" && etape === "design" && survol && survol.fantome ? survol.fantome : null, masquer: apercu ? new Set(apercu.panneaux.map(q => q.index)) : null, apercu });
      if (dnd && dnd.r && dnd.r.panneau && dnd.nouveau) { const pts = dnd.r.panneau.coins.map(c => m.geoVersEcran(vue, c.lat, c.lng)); m.dessinerPanneau(ctx, pts, dnd.r.ok ? "valide" : "interdit", dnd.r.panneau.orientation); }
      if (dessin && dessin.b && dessin.type === "selrect") { ctx.save(); ctx.setLineDash([5, 4]); ctx.lineWidth = 1.2; ctx.strokeStyle = "#22d3ee"; ctx.fillStyle = "rgba(34,211,238,.12)"; ctx.beginPath(); ctx.rect(Math.min(dessin.a.x, dessin.b.x), Math.min(dessin.a.y, dessin.b.y), Math.abs(dessin.b.x - dessin.a.x), Math.abs(dessin.b.y - dessin.a.y)); ctx.fill(); ctx.stroke(); ctx.restore(); }
      if (dessin && dessin.b && dessin.type !== "selrect") { ctx.save(); ctx.setLineDash([5, 4]); ctx.lineWidth = 1.5; ctx.strokeStyle = dessin.type === "mesure" ? "#facc15" : "#ef4444"; ctx.fillStyle = "rgba(239,68,68,.22)"; ctx.beginPath(); if (dessin.type === "mesure") { ctx.moveTo(dessin.a.x, dessin.a.y); ctx.lineTo(dessin.b.x, dessin.b.y); ctx.stroke(); } else { ctx.rect(Math.min(dessin.a.x, dessin.b.x), Math.min(dessin.a.y, dessin.b.y), Math.abs(dessin.b.x - dessin.a.x), Math.abs(dessin.b.y - dessin.a.y)); ctx.fill(); 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(); [mesure.a, mesure.b].forEach(q => { ctx.beginPath(); ctx.arc(q.x, q.y, 3.5, 0, Math.PI * 2); ctx.fillStyle = "#facc15"; ctx.fill(); }); const t = `${fmtNum(mesure.m, 2)} m`; ctx.font = "700 13px Inter, system-ui, sans-serif"; const tw = ctx.measureText(t).width + 14; const tx = (mesure.a.x + mesure.b.x) / 2, ty = (mesure.a.y + mesure.b.y) / 2; ctx.fillStyle = "rgba(15,23,42,.9)"; ctx.beginPath(); if (ctx.roundRect) ctx.roundRect(tx - tw / 2, ty - 26, tw, 20, 6); else ctx.rect(tx - tw / 2, ty - 26, tw, 20); ctx.fill(); ctx.fillStyle = "#facc15"; ctx.fillText(t, tx - tw / 2 + 7, ty - 11); ctx.restore(); }
    }, [E, vue, soleil, mois, survol, selection, dessin, mesure, outil, pret, OV, W, H, apercu, dnd, zone, choixToit, etape, modele]); // eslint-disable-line
    /** Lignes de marge (pointillés fins) à l'intérieur des faces : là où le bord d'un module peut venir au plus près. */
    const dessinerLignesMarge = (ctx) => {
      if (!modele || !m) return; const mg0 = m.marges(); ctx.save(); ctx.setLineDash([3, 4]); ctx.lineWidth = 1; ctx.strokeStyle = "rgba(255,255,255,.55)";
      const cle = (a, b) => a < b ? a + "," + b : b + "," + a; const parCle = new Map((modele.aretes || []).map(a => [cle(a.de, a.a), a.type])); const CATS = { egout: "egout", faite: "faite", arete: "faite", noue: "faite", rive: "rive" };
      for (const f of modele.faces) { if (f.pan < 0 || !f.sommets) continue; const mg = m.margesDe ? m.margesDe(f.pan) : mg0; const P = f.sommets.map(id => modele.sommets[id]); const n = P.length; let A2 = 0; for (let i = 0; i < n; i++) A2 += P[i].e * P[(i + 1) % n].n - P[(i + 1) % n].e * P[i].n; const ccw = A2 > 0; const g = f.plan ? { e: f.plan.B, n: f.plan.C } : { e: 0, n: 0 };
        const lignes = P.map((a, i) => { const b = P[(i + 1) % n]; const L = Math.hypot(b.e - a.e, b.n - a.n) || 1e-9; const u = { e: (b.e - a.e) / L, n: (b.n - a.n) / L }; const nr = ccw ? { e: -u.n, n: u.e } : { e: u.n, n: -u.e }; const t = CATS[parCle.get(cle(f.sommets[i], f.sommets[(i + 1) % n]))] || "rive"; const gn = g.e * nr.e + g.n * nr.n; const h = (mg[t] || 0) / Math.sqrt(1 + gn * gn); return { p: { e: a.e + nr.e * h, n: a.n + nr.n * h }, u }; });
        const pts = lignes.map((l, i) => { const k = lignes[(i + n - 1) % n]; const det = k.u.e * l.u.n - k.u.n * l.u.e; if (Math.abs(det) < 0.05) return l.p; const dx = l.p.e - k.p.e, dn = l.p.n - k.p.n; const t = (dx * l.u.n - dn * l.u.e) / det; return { e: k.p.e + t * k.u.e, n: k.p.n + t * k.u.n }; });
        let A3 = 0; for (let i = 0; i < n; i++) A3 += pts[i].e * pts[(i + 1) % n].n - pts[(i + 1) % n].e * pts[i].n; if (Math.sign(A3) !== Math.sign(A2) || Math.abs(A3) < 0.2) continue; // marge plus grande que le pan : pas de ligne
        const ecran = (q) => { const gq = m.geoDeMetres(q.e, q.n); return m.geoVersEcran(vue, gq.lat, gq.lng); };
        ctx.save(); ctx.beginPath(); P.forEach((q, i) => { const s2 = ecran(q); if (i) ctx.lineTo(s2.x, s2.y); else ctx.moveTo(s2.x, s2.y); }); ctx.closePath(); ctx.clip(); // jamais hors de la face
        ctx.beginPath(); pts.forEach((q, i) => { const s2 = ecran(q); if (i) ctx.lineTo(s2.x, s2.y); else ctx.moveTo(s2.x, s2.y); }); ctx.closePath(); ctx.stroke(); ctx.restore(); }
      ctx.restore();
    };

    // ── Pointeur (souris, doigt, stylet) : poser, glisser-déposer, retirer, survol, ensoleillement, sélection, obstacle, mesure, zoom ──
    const pos = (ev) => { const r = canvasRef.current.getBoundingClientRect(); return { x: ev.clientX - r.left, y: ev.clientY - r.top }; };
    const geo = (pt) => m.ecranVersGeo(vue, pt.x, pt.y);
    const obstaclesEcran = () => (E.obstacles || []).map(ob => ob.pts.map(q => m.geoVersEcran(vue, q.lat, q.lng)));
    const deltaM = (g0, g1) => { const a = m.metres(g0.lat, g0.lng), b = m.metres(g1.lat, g1.lng); return { de: b.e - a.e, dn: b.n - a.n }; };
    const surScene = (ev) => { const cv = canvasRef.current; if (!cv || vueMode !== "2d") return false; const r = cv.getBoundingClientRect(); return ev.clientX >= r.left && ev.clientX <= r.right && ev.clientY >= r.top && ev.clientY <= r.bottom; };
    const nomPan = (pan) => pan >= 0 ? `Pan ${pan + 1}${noms[pan] ? " · " + noms[pan] : ""}` : "";
    /** Estimation de production d'un module posé à un endroit (flux Google sous son centre × puissance × rendement). */
    const kwhIci = (g) => { const f = m.fluxAuPoint(g.lat, g.lng, 0); return f && f.flux ? Math.round(f.flux * (modeleCourant.watts || 500) / 1000 * RENDEMENT) : null; };
    // Glisser-déposer d'un NOUVEAU module depuis la palette : écouteurs posés sur window pendant le geste (souris ou doigt)
    const debutPalette = (ev, idModele) => {
      if (demo || !pret || !m || etape !== "design") return; if (ev.button != null && ev.button !== 0) return; ev.preventDefault(); ev.stopPropagation();
      if (idModele && idModele !== E.modele) { if ((E.panneaux || []).length) { setToast({ info: "Un seul modèle par design : choisis ce modèle avec « Utiliser » (les modules posés changent de modèle)." }); return; } m.setModele(idModele); noter("modele_panneau", { modele: idModele }); }
      const carte = ev.currentTarget.getBoundingClientRect(); dndRef.current = { type: "nouveau", id: ev.pointerId, carte: { x: carte.left + carte.width / 2, y: carte.top + carte.height / 2 }, r: null, alt: !!ev.altKey };
      setFantomeDom({ x: ev.clientX, y: ev.clientY, retour: false }); setMenu(null); setSelection(new Set()); noter("glisser_palette_debut");
    };
    const majNouveau = (ev) => {
      const d = dndRef.current; if (!d || d.type !== "nouveau") return;
      if (!surScene(ev)) { d.r = null; d.surScene = false; setDnd(null); setFantomeDom({ x: ev.clientX, y: ev.clientY, retour: false }); return; }
      const pt = pos(ev); const g = geo(pt); const r = m.peutPoserLibre(g, { aimant: !ev.altKey }); d.r = r; d.surScene = true;
      const c = r && r.panneau ? { lat: r.panneau.lat, lng: r.panneau.lng } : g;
      setDnd({ nouveau: true, x: pt.x, y: pt.y, r, ok: !!(r && r.ok), raison: r && !r.ok ? (r.raison || "position refusée") : "", pan: r ? r.pan : -1, kwh: r && r.ok ? kwhIci(c) : null, aimante: !!(r && r.aimante) });
      setFantomeDom(f => f ? { ...f, x: ev.clientX, y: ev.clientY, cache: true } : null);
    };
    const finNouveau = (ev, annule) => {
      const d = dndRef.current; if (!d || d.type !== "nouveau") return; dndRef.current = null; setDnd(null);
      if (!annule && ev && surScene(ev)) majNouveau(ev);
      const r = d.r;
      if (!annule && r && r.ok && r.panneau) { const q = m.poserLibre({ e: r.panneau.e, n: r.panneau.n }, { orientation: r.panneau.orientation, aimant: false }); if (q) { noter("poser", { pan: q.pan, libre: true, depuis: "palette" }); setFantomeDom(null); return; } }
      // relâché hors pan, position refusée ou hors toit : le module retourne dans la liste (animation), sans pose ni panneau rouge
      setFantomeDom({ x: d.carte.x, y: d.carte.y, retour: true }); setTimeout(() => setFantomeDom(null), 320);
      const raison = annule ? "geste annulé" : !d.surScene ? "relâché hors de la scène" : (r && r.raison) || "hors des pans dessinés";
      noter("pose_annulee", { raison }); setToast({ info: `Module revenu dans la liste : ${raison}.` });
    };
    useEffect(() => { // écouteurs globaux du glisser-déposer depuis la palette
      const mv = (ev) => { const d = dndRef.current; if (d && d.type === "nouveau") { if (d.id != null && ev.pointerId !== d.id) return; ev.preventDefault && ev.preventDefault(); majNouveau(ev); } };
      const up = (ev) => { const d = dndRef.current; if (d && d.type === "nouveau") { if (d.id != null && ev.pointerId !== d.id) return; finNouveau(ev, false); } };
      const cancel = (ev) => { const d = dndRef.current; if (d && d.type === "nouveau") finNouveau(ev, true); };
      window.addEventListener("pointermove", mv, { passive: false }); window.addEventListener("pointerup", up); window.addEventListener("pointercancel", cancel);
      return () => { window.removeEventListener("pointermove", mv); window.removeEventListener("pointerup", up); window.removeEventListener("pointercancel", cancel); };
    }); // réinscrits à chaque rendu : la vue et l'état courants sont dans la fermeture
    const onMove = (ev) => {
      if (demo || !pret || !vue.scale) return; if (dndRef.current && dndRef.current.type === "nouveau") return; const pt = pos(ev);
      if (drag.current && drag.current.type === "pan") { const d = drag.current; setVue({ ...vue, ox: d.ox + (pt.x - d.x), oy: d.oy + (pt.y - d.y) }); return; }
      const g = geo(pt);
      if (drag.current && drag.current.type === "deplacer") { // reprise d'un module posé : aperçu dans le plan du pan survolé (vert, rouge), flux recalculé au dépôt
        const d = drag.current; if (!d.bouge && Math.hypot(pt.x - d.pt0.x, pt.y - d.pt0.y) < 4) return; d.bouge = true;
        const ap = m.apercuDeplacement(d.indices, deltaM(d.g0, g), { aimant: !ev.altKey }); const panC = m.panAuPoint(g.lat, g.lng); d.apercu = ap; d.panCurseur = panC; setApercu(ap);
        setDnd({ nouveau: false, x: pt.x, y: pt.y, ok: ap.ok, raison: panC < 0 ? "hors des pans : relâche ici pour retirer le module" : (ap.ok ? "" : ap.raison || "position refusée"), pan: panC, horsPan: panC < 0, kwh: ap.ok && d.indices.length === 1 ? kwhIci(g) : null, n: d.indices.length });
        if (curseur) setCurseur(null); return;
      }
      if (drag.current && drag.current.type === "selrect") { if (Math.hypot(pt.x - drag.current.pt0.x, pt.y - drag.current.pt0.y) > 4) { drag.current.bouge = true; setDessin({ type: "selrect", a: drag.current.pt0, b: pt }); } return; }
      if (dessin) { setDessin({ ...dessin, b: pt }); return; }
      const pan = m.panAuPoint(g.lat, g.lng); if (pan !== panSurvol) setPanSurvol(pan >= 0 ? pan : null);
      const sous = m.indexPanneauSous(g.lat, g.lng);
      // Encart temps réel sur le toit, avec n'importe quel outil, sans calque ni panneau : lecture du flux déjà chargé
      if (pan >= 0 && outil !== "toit" && !choixToit && !(drag.current && drag.current.type === "poser")) { const f = m.fluxAuPoint(g.lat, g.lng, soleil ? mois : 0); setCurseur(f && f.flux ? { x: pt.x, y: pt.y, ...f, panneau: sous } : null); } else if (curseur) setCurseur(null);
      if (etape !== "design") { setSurvol(null); return; }
      if (outil === "panneaux") {
        if (sous >= 0) { setSurvol({ existant: sous }); return; }
        if (drag.current && drag.current.type === "poser" && pan >= 0) { const q = m.poserLibre(g, { aimant: !ev.altKey }); if (q) { drag.current.n++; dernierePose.current = Date.now(); } }
        setSurvol(pan >= 0 ? { fantome: { ...g, libre: true } } : null);
      } else setSurvol(sous >= 0 ? { existant: sous } : null);
    };
    const capturer = (ev) => { try { ev.currentTarget.setPointerCapture(ev.pointerId); } catch (e) { /* navigateur sans capture */ } };
    const onDown = (ev) => {
      if (demo || !pret || !vue.scale) return; const pt = pos(ev);
      if (ev.button === 1 || espace.current || (ev.shiftKey && outil !== "selectionner")) { drag.current = { type: "pan", x: pt.x, y: pt.y, ox: vue.ox, oy: vue.oy }; capturer(ev); ev.preventDefault(); return; }
      if (menu) setMenu(null);
      if (ev.button !== 0 || outil === "toit") return; const g = geo(pt);
      if (choixToit) { choisirToit(g); return; }
      if (outil === "mesurer") { setDessin({ type: "mesure", a: pt, b: pt }); setMesure(null); capturer(ev); return; }
      if (etape !== "design") { // étape 1 : clic = sélection du pan (tableau des pans)
        const pan = m.panAuPoint(g.lat, g.lng); setPanSel(pan >= 0 ? (panSel === pan ? null : pan) : null); return;
      }
      const sous = m.indexPanneauSous(g.lat, g.lng);
      if (sous >= 0 && (outil === "panneaux" || outil === "selectionner")) { // reprise d'un module posé : glisser = déplacer, clic sans bouger = action de l'outil
        let nn = selection;
        if (outil === "selectionner") { nn = ev.shiftKey ? new Set(selection) : (selection.has(sous) ? new Set(selection) : new Set()); if (ev.shiftKey && nn.has(sous)) nn.delete(sous); else nn.add(sous); setSelection(nn); setObstacleSel(null); setPanSel(E.panneaux[sous] ? E.panneaux[sous].pan : panSel); }
        const indices = nn.has(sous) ? [...nn] : [sous]; m.debutDeplacement(indices); drag.current = { type: "deplacer", indices, g0: g, pt0: pt, bouge: false, apercu: null, sous, outil }; capturer(ev); return;
      }
      if (outil === "panneaux") {
        const q = m.poserLibre(g, { aimant: !ev.altKey }); if (q) { noter("poser", { pan: q.pan, libre: true }); dernierePose.current = Date.now(); drag.current = { type: "poser", n: 1 }; capturer(ev); } else { const r = m.peutPoserLibre(g); if (r && !r.ok && r.raison) setToast({ info: r.code === "hors_pan" ? "Hors des pans dessinés." : `Pas de place ici : ${r.raison}.` }); } return;
      }
      if (outil === "selectionner") {
        const io = obstaclesEcran().findIndex(pts => dansPoly(pts, pt.x, pt.y));
        if (io >= 0) { setObstacleSel(io); setSelection(new Set()); return; }
        drag.current = { type: "selrect", pt0: pt, bouge: false, shift: ev.shiftKey }; capturer(ev); return;
      }
      if (outil === "obstacle") { setDessin({ type: "rect", a: pt, b: pt }); capturer(ev); return; }
    };
    const onUp = (ev) => {
      if (demo) return;
      if (drag.current && drag.current.type === "deplacer") {
        const d = drag.current; drag.current = null; m.finDeplacement(); setApercu(null); setDnd(null);
        if (!d.bouge) { if (d.outil === "panneaux") { if (Date.now() - dernierePose.current < 250) return; /* double-clic de pose : pas de retrait */ m.retirer(d.sous); noter("retirer", { pan: E.panneaux[d.sous] && E.panneaux[d.sous].pan }); setSurvol(null); setSelection(new Set()); } return; }
        const g = ev && canvasRef.current && surScene(ev) ? geo(pos(ev)) : null; const panC = g ? m.panAuPoint(g.lat, g.lng) : -1;
        if (panC < 0) { m.retirerPlusieurs(d.indices); setSelection(new Set()); noter("retirer_glisser", { n: d.indices.length }); setToast({ info: `${d.indices.length > 1 ? d.indices.length + " modules retirés" : "Module retiré"} : relâché hors des pans, ${d.indices.length > 1 ? "ils retournent" : "il retourne"} dans la liste.` }); return; }
        const ap = g ? m.apercuDeplacement(d.indices, deltaM(d.g0, g), { aimant: !(ev && ev.altKey) }) : d.apercu;
        if (ap && ap.ok) { const r = m.deplacer(d.indices, ap.delta, { aimant: false }); if (r.ok && !r.inchange) noter("deplacer", { n: d.indices.length, de: Math.round(r.delta.de * 100) / 100, dn: Math.round(r.delta.dn * 100) / 100 }); }
        else setToast({ info: `Position refusée (${(ap && ap.raison) || "chevauchement, marge ou obstacle"}) : ${d.indices.length > 1 ? "les modules reviennent" : "le module revient"} à sa place.` });
        return;
      }
      if (drag.current && drag.current.type === "selrect") {
        const d = drag.current; drag.current = null;
        if (d.bouge && dessin && dessin.b) { const x0 = Math.min(dessin.a.x, dessin.b.x), x1 = Math.max(dessin.a.x, dessin.b.x), y0 = Math.min(dessin.a.y, dessin.b.y), y1 = Math.max(dessin.a.y, dessin.b.y);
          const nn = d.shift ? new Set(selection) : new Set(); (E.panneaux || []).forEach((q, i) => { const c = m.geoVersEcran(vue, q.lat, q.lng); if (c.x >= x0 && c.x <= x1 && c.y >= y0 && c.y <= y1) nn.add(i); }); setSelection(nn); setObstacleSel(null); if (nn.size) noter("selection_rect", { n: nn.size }); setDessin(null); return; }
        const g = geo(d.pt0); const pan = m.panAuPoint(g.lat, g.lng); setSelection(new Set()); setObstacleSel(null); setPanSel(pan >= 0 ? (panSel === pan ? null : pan) : null); if (pan >= 0) noter("selection_pan", { pan }); setDessin(null); return;
      }
      if (drag.current) { if (drag.current.type === "poser" && drag.current.n > 1) noter("poser_glisser", { n: drag.current.n }); drag.current = null; }
      if (dessin && dessin.b) {
        const a = geo(dessin.a), b = geo(dessin.b);
        if (dessin.type === "rect") { if (Math.abs(dessin.b.x - dessin.a.x) > 4 && Math.abs(dessin.b.y - dessin.a.y) > 4) { const i = m.ajouterObstacle({ type: "rect", pts: [a, { lat: a.lat, lng: b.lng }, b, { lat: b.lat, lng: a.lng }], marge: marges.obstacle }); setSelection(new Set()); setObstacleSel(i); noter("obstacle", { marge: marges.obstacle }); setToast({ ok: "Obstacle ajouté : les panneaux gardent " + Math.round((marges.obstacle || 0) * 100) + " cm de recul. Suppr pour le retirer." }); } }
        if (dessin.type === "mesure") { const d = m.mesurer(a, b); if (d > 0.05) { setMesure({ a: dessin.a, b: dessin.b, m: d }); noter("mesure", { m: Math.round(d * 100) / 100 }); } }
        setDessin(null);
      }
    };
    const onCancel = () => { if (drag.current && drag.current.type === "deplacer") { m.finDeplacement(); setApercu(null); setDnd(null); if (drag.current.bouge) setToast({ info: "Déplacement annulé : les modules restent où ils étaient." }); } drag.current = null; setDessin(null); };
    const onWheel = (ev) => { if (demo || !vue.scale) return; ev.preventDefault(); const pt = pos(ev); const k = ev.deltaY < 0 ? 1.15 : 1 / 1.15; const sc = Math.max(0.4, Math.min(40, vue.scale * k)); setVue({ scale: sc, ox: pt.x - (pt.x - vue.ox) * (sc / vue.scale), oy: pt.y - (pt.y - vue.oy) * (sc / vue.scale) }); };
    // Molette : écouteur natif non passif (React pose onWheel en passif : preventDefault y était refusé, « Unable to preventDefault
    // inside passive event listener » à chaque cran, et la page pouvait défiler en zoomant). Le gestionnaire courant est lu dans une réf.
    const zone2dRef = useRef(null); const molette = useRef(onWheel); molette.current = onWheel;
    useEffect(() => { const el = zone2dRef.current; if (!el) return; const f = (ev) => molette.current(ev); el.addEventListener("wheel", f, { passive: false }); return () => el.removeEventListener("wheel", f); }, [pret]); // la zone 2D n'est montée qu'une fois le studio prêt
    const onLeave = () => { setSurvol(null); setCurseur(null); setPanSurvol(null); };
    const onDoubleClick = (ev) => { if (demo || !pret || !vue.scale || outil !== "selectionner" || etape !== "design") return; const g = geo(pos(ev)); const sous = m.indexPanneauSous(g.lat, g.lng); if (sous >= 0) pivoterSelection(new Set([sous])); };
    const onContextMenu = (ev) => { ev.preventDefault(); if (demo || !pret || !vue.scale || outil === "toit" || etape !== "design") return; const pt = pos(ev); const g = geo(pt); const sous = m.indexPanneauSous(g.lat, g.lng); if (sous < 0) { setMenu(null); return; } if (!selection.has(sous)) setSelection(new Set([sous])); setOutil("selectionner"); setMenu({ x: pt.x, y: pt.y }); };

    // ── Actions sur la sélection : supprimer, dupliquer, pivoter, tasser ──
    const supprimerSelection = (set) => { const sel = set || selection; if (!m || !sel.size) return; m.retirerPlusieurs([...sel]); setSelection(new Set()); setMenu(null); noter("retirer_selection", { n: sel.size }); };
    const dupliquerSelection = (set) => { const sel = set || selection; if (!m || !sel.size) return; const idx = m.dupliquer([...sel]); setMenu(null); if (idx.length) { setSelection(new Set(idx)); noter("dupliquer", { n: idx.length }); setToast({ ok: `${idx.length} panneau${idx.length > 1 ? "x" : ""} dupliqué${idx.length > 1 ? "s" : ""} à côté : glisse-les où tu veux.` }); } else setToast({ info: "Pas de place libre à côté pour dupliquer." }); };
    const pivoterSelection = (set) => { const sel = set || selection; if (!m || !sel.size) return; const r = m.pivoterPanneaux([...sel]); setMenu(null); if (!r.n) setToast({ info: "Pivot refusé : le panneau ne tiendrait plus (voisin, rive ou obstacle)." }); else { noter("pivoter_selection", { n: r.n }); if (!r.ok) setToast({ info: `${r.n} pivoté${r.n > 1 ? "s" : ""}, les autres ne tiendraient plus.` }); } };
    const tasserSelection = (de, dn) => { if (!m || !selection.size) return; const r = m.deplacer([...selection], { de, dn }, { aimant: false }); if (!r.ok) setToast({ info: r.raison === "hors du toit" ? "Refusé : un panneau sortirait du toit." : "Refusé : chevauchement, marge ou obstacle." }); else if (!r.inchange) noter("tasser", { n: selection.size, de, dn }); };

    // ── Actions : remplir, tout effacer, recadrer, pivoter ──
    const remplir = () => {
      if (demo || !pret || !m || etape !== "design") return;
      if (panSel != null) { const nb = m.remplirPan(panSel); noter("remplir", { pan: panSel, ajoutes: nb }); setToast(nb ? { ok: `${nb} panneau${nb > 1 ? "x" : ""} ajouté${nb > 1 ? "s" : ""} sur le pan ${panSel + 1}.` } : { info: "Aucune place libre sur ce pan avec les marges actuelles." }); return; }
      // Sans pan choisi : les meilleurs pans jusqu'à la cible du devis (nombre de panneaux) ; cible atteinte → tous les bons pans
      const cible = Math.max(1, Number(p.nb_panneaux) || 16); const manque = cible - n;
      const nb = m.remplirAuto(manque > 0 ? { n: manque, exclureNord: true } : { exclureNord: true });
      noter("remplir", { pan: null, cible, ajoutes: nb });
      setToast(nb ? { ok: `${nb} panneau${nb > 1 ? "x" : ""} ajouté${nb > 1 ? "s" : ""} sur les meilleurs pans${manque > 0 ? ` (cible du devis : ${cible})` : ` (cible de ${cible} déjà atteinte : tous les bons pans remplis)`} · nord et accès solaire sous 60 % exclus.` } : { info: "Aucune place libre sur les bons pans : vérifie les marges, ou choisis un pan à remplir." });
    };
    const toutEffacer = () => { if (demo || !m) return; m.toutEffacer(); setSelection(new Set()); noter("tout_effacer"); };
    const recadrer = () => { if (!m || !W) return; setVue(m.vueCadree(W, H, roiZone() ? 5 : 3, roiZone())); };
    const pivoter = () => { if (!m) return; m.setOrientation(m.orientation() === "portrait" ? "paysage" : "portrait"); noter("orientation", { orientation: m.orientation() }); };
    const remplirRef = useRef(remplir), pivoterRef = useRef(pivoter), recadrerRef = useRef(recadrer), noterRef = useRef(noter), selRef = useRef({}); remplirRef.current = remplir; pivoterRef.current = pivoter; recadrerRef.current = recadrer; noterRef.current = noter; selRef.current = { supprimerSelection, dupliquerSelection, pivoterSelection, tasserSelection, annulerDnd: () => finNouveau(null, true), annulerDeplacement: onCancel };
    useEffect(() => { // clavier (une seule inscription ; l'état courant est lu dans K)
      const kd = (ev) => {
        if (ev.target && /INPUT|TEXTAREA|SELECT/.test(ev.target.tagName)) return; const k = K.current; const key = ev.key.toLowerCase();
        if (ev.code === "Space") { espace.current = true; ev.preventDefault(); return; }
        if (ev.key === "Escape" && dndRef.current) { selRef.current.annulerDnd(); return; }
        if (ev.key === "Escape" && drag.current && drag.current.type === "deplacer") { selRef.current.annulerDeplacement(); return; }
        if (ev.key === "Escape" && k.choixToit) { setChoixToit(false); return; }
        if (ev.key === "Escape") { if (k.menu) setMenu(null); else if (k.dessin) setDessin(null); else if (k.mesure) setMesure(null); else if (k.selection.size || k.obstacleSel != null || k.panSel != null) { setSelection(new Set()); setObstacleSel(null); setPanSel(null); } else k.onFermer && k.onFermer(); return; }
        if (k.outil === "toit" && (/^Arrow/.test(ev.key) || key === "delete" || key === "backspace" || key === "r" || key === "d")) return; // touches de l'éditeur de toit
        if (/^Arrow/.test(ev.key) && k.selection.size && k.m) { ev.preventDefault(); const pas = ev.shiftKey ? 0.10 : 0.02; const de = ev.key === "ArrowLeft" ? -pas : ev.key === "ArrowRight" ? pas : 0, dn = ev.key === "ArrowUp" ? pas : ev.key === "ArrowDown" ? -pas : 0; selRef.current.tasserSelection(de, dn); return; }
        if ((ev.ctrlKey || ev.metaKey) && key === "z") { ev.preventDefault(); if (k.m) { if (ev.shiftKey) k.m.retablir(); else k.m.annuler(); } return; }
        if ((ev.ctrlKey || ev.metaKey) && key === "y") { ev.preventDefault(); k.m && k.m.retablir(); return; }
        if (ev.ctrlKey || ev.metaKey || ev.altKey) return;
        const enDesign = k.etape === "design";
        if (key === "v") setOutil("selectionner"); else if (key === "p" && enDesign) setOutil("panneaux"); else if (key === "o" && enDesign) setOutil("obstacle"); else if (key === "m") setOutil("mesurer"); else if (key === "t") setOutil("toit");
        else if (key === "a") remplirRef.current(); else if (key === "s") setSoleil(x => !x); else if (key === "r") { if (k.selection.size) selRef.current.pivoterSelection(); else pivoterRef.current(); } else if (key === "f") recadrerRef.current();
        else if (key === "d" && k.selection.size) { ev.preventDefault(); selRef.current.dupliquerSelection(); }
        else if (key === "delete" || key === "backspace") { ev.preventDefault(); if (!k.m) return; if (k.selection.size) selRef.current.supprimerSelection(); else if (k.obstacleSel != null) { k.m.retirerObstacle(k.obstacleSel); setObstacleSel(null); noterRef.current("retirer_obstacle"); } }
      };
      const ku = (ev) => { if (ev.code === "Space") espace.current = false; };
      window.addEventListener("keydown", kd); window.addEventListener("keyup", ku); return () => { window.removeEventListener("keydown", kd); window.removeEventListener("keyup", ku); };
    }, []); // eslint-disable-line

    // ── Export de l'image pour la proposition : photo, modèle vectoriel, panneaux, numéros des pans, échelle et flèche nord ──
    const exporterImageStudio = (largeur) => {
      const mm = mRef.current; if (!mm) return null; const Lg = largeur || 1600;
      try {
        if (!MS) return mm.exporterImage({ largeur: Lg });
        const rep = mm.repere(); const roi = mm.analyse().roi; const mg = 2 / rep.mParPx;
        const ga = rep.geoDe(roi.x0 - mg, roi.y0 - mg), gb = rep.geoDe(roi.x1 + mg, roi.y1 + mg);
        const v0 = { scale: 1, ox: 0, oy: 0 }; const a = mm.geoVersEcran(v0, ga.lat, ga.lng), b = mm.geoVersEcran(v0, gb.lat, gb.lng);
        const sc = Lg / Math.max(1, b.x - a.x); const Hh = Math.round(Math.max(1, b.y - a.y) * sc);
        const cv = document.createElement("canvas"); cv.width = Lg; cv.height = Hh; const ctx = cv.getContext("2d"); const v = { scale: sc, ox: -a.x * sc, oy: -a.y * sc };
        ctx.imageSmoothingEnabled = true; mm.dessinerBase(ctx, v);
        const k = Lg / 900; const P = (q) => mm.geoVersEcran(v, q.lat, q.lng);
        for (const ar of MS.aretes) { const st = LIGNES[ar.type] || LIGNES.rive; const A = P(ar.a), B = P(ar.b); ctx.save(); ctx.strokeStyle = st.couleur; ctx.lineWidth = st.largeur * k; ctx.lineCap = "round"; if (st.tirets) ctx.setLineDash(st.tirets.split(" ").map(x => Number(x) * k)); ctx.beginPath(); ctx.moveTo(A.x, A.y); ctx.lineTo(B.x, B.y); ctx.stroke(); ctx.restore(); }
        mm.dessinerPanneaux(ctx, v, { alertes: false });
        for (const f of MS.faces) { if (f.pan < 0) continue; const pts = f.ll.map(P); const c = pts.reduce((t, q) => ({ x: t.x + q.x / pts.length, y: t.y + q.y / pts.length }), { x: 0, y: 0 }); ctx.save(); ctx.beginPath(); ctx.arc(c.x, c.y, 11 * k, 0, Math.PI * 2); ctx.fillStyle = "#f59e0b"; ctx.fill(); ctx.lineWidth = 1.6 * k; ctx.strokeStyle = "#fff"; ctx.stroke(); ctx.fillStyle = "#1f1300"; ctx.font = `800 ${Math.round(11 * k)}px Inter, system-ui, sans-serif`; ctx.textAlign = "center"; ctx.textBaseline = "middle"; ctx.fillText(String(f.pan + 1), c.x, c.y + 0.5 * k); ctx.restore(); }
        mm.dessinerHabillage(ctx, Lg, Hh, v);
        return cv.toDataURL("image/jpeg", 0.88);
      } catch (e) { try { return mm.exporterImage({ largeur: Lg }); } catch (x) { return null; } }
    };
    const mParPxExport = () => { const mm = mRef.current; if (!mm || !pret) return null; try { const rep = mm.repere(); const roi = mm.analyse().roi; return ((roi.x1 - roi.x0) + 4 / rep.mParPx) * rep.mParPx / 1600; } catch (e) { return null; } };

    // ── Bilan ──
    const kwhAc = Math.round(E.kwh_an || 0), kw = E.kw || 0, n = (E.panneaux || []).length;
    const couverture = conso ? Math.min(999, Math.round(kwhAc / Number(conso) * 100)) : null;
    const noms = useMemo(() => nommerPans(E.pans || []), [E.pans]);
    const prodMois = useMemo(() => (m && pret && m.productionMensuelle && (E.panneaux || []).length) ? m.productionMensuelle() : null, [E.panneaux, pret, E.modele]); // eslint-disable-line
    const rendementDesign = kw ? Math.round(kwhAc / kw) : 0; const designHorsBornes = rendementDesign > 1350;
    const pans = (E.pans || []).map(x => ({ ...x, sg: segments.find(sg => sg.index === x.index) || {}, nom: noms[x.index] || (ORI[x.orientation] || x.orientation), acces: x.acces_pct_pan != null ? x.acces_pct_pan : (x.acces_pct_moyen || 0) }));
    const mesures = modele ? { surface_toit_m2: Math.round(modele.faces.reduce((t, f) => t + (f.surface_m2 || 0), 0)), egout_m: modele.hauteur_egout_m, faite_m: modele.hauteur_faite_m, faces: modele.faces.length }
      : demo ? DEMO.mesures : { surface_toit_m2: Math.round(segments.reduce((t, sg) => t + (Number(sg.surface_m2) || 0), 0)), egout_m: null, faite_m: null, faces: segments.length };
    const appliquer = () => {
      if (demo) { onFermer && onFermer(); return; }
      if (!pret || !n || !m) return;
      const image = exporterImageStudio(1600);
      const pans_toit = pans.filter(x => x.nb_panneaux > 0).sort((a, b) => b.nb_panneaux - a.nb_panneaux).map((x, k) => ({ nom: k === 0 ? "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: PENTE(x.pente_deg), nb_panneaux: x.nb_panneaux })).slice(0, 6);
      const kwhDc = Math.round(kwhAc / 0.96); // la soumission (calc-re) affiche production_google_kwh × 0,96 : on lui passe la production AC du studio / 0,96
      const pNext = { ...(window.ParcoursRE ? window.ParcoursRE.DEFAUT : {}), ...p, panneau: E.modele, nb_panneaux: n };
      const catNow = window.CatalogueRE && window.CatalogueRE._cache && window.CatalogueRE._cache();
      const lignes = catNow && window.ParcoursRE ? window.ParcoursRE.fusionner(state, window.ParcoursRE.composer(pNext, catNow)) : state.lignes;
      const consoN = conso ? Number(conso) : (client.conso_kwh || s.conso_kwh || null);
      noter("appliquer", { n, kw, kwh_ac: kwhAc, pans: pans_toit.length, conso: consoN });
      const design_editeur = { modele: E.modele, orientation: E.orientation, marge_bord: marges.bord, marge_arete: marges.arete, marge_obstacle: marges.obstacle, marge_egout: marges.egout, marge_faite: marges.faite, marge_rive: marges.rive, marges_pans: (m.margesPans && m.margesPans()) || {},
        point: point ? { lat: point.lat, lng: point.lng, source: point.source } : null, geo_precision: (point && point.precision) || null, rendement_ac: RENDEMENT, kwh_dc_flux: E.kwh_dc_an || null, production_mensuelle: prodMois || null,
        analyse: analyse ? { pans: analyse.n, comparaison: analyse.comparaison, batiment: analyse.batiment } : null,
        pans_v2: (E.pans || []).map(x => ({ index: x.index, nom: noms[x.index] || null, pente_deg: x.pente_deg, azimut_deg: x.azimut_deg, surface_m2: x.surface_m2, source: x.source || "google", flux_moyen: x.flux_moyen != null ? x.flux_moyen : null, rendement_kwh_kw: x.rendement_kwh_kw != null ? x.rendement_kwh_kw : null, alerte_google: !!x.alerte_google, alerte_irradiance: x.alerte_irradiance ? x.alerte_irradiance.niveau : null, nb_panneaux: x.nb_panneaux, kwh_an: x.kwh_an })), obstacles: E.obstacles, faites: E.faites, hourly_shade_ids: E.hourly_shade_ids || [], panneaux: m.panneauxBruts ? m.panneauxBruts() : (E.panneaux || []).map(q => ({ lat: q.lat, lng: q.lng, pan: q.pan })), n_invalides: E.n_invalides || 0,
        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: kwhAc, kw, acces_pct_moyen: E.acces_pct_moyen,
        modele_manuel: (modele && modele !== modeleInitial.current && window.SolaireModele && window.SolaireModele.serialiserManuel) ? (() => { try { return window.SolaireModele.serialiserManuel(modele); } catch (e) { return de0.modele_manuel || null; } })() : (de0.modele_manuel && modele === modeleInitial.current ? null : de0.modele_manuel || null), m_par_px: mParPxExport(), largeur_px: 1600, date_imagerie: E.date ? dateTexte(E.date) : (toit && toit.date_imagerie) || null, qualite_imagerie: E.qualite || (toit && toit.qualite_imagerie) || null, mesures, journal_studio: journal.current, studio: true, applique_le: maintenant() };
      setState({ ...state, parcours: pNext, lignes, client: { ...client, ...(geoRef.current || {}), conso_kwh: consoN },
        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, conso_kwh: consoN, design_editeur, aurora_image: image || s.aurora_image || null } });
      onApplique && onApplique({ n, kw, kwh_ac: kwhAc, acces: E.acces_pct_moyen, watts: E.watts || (MODELES[E.modele] || {}).watts || 500 });
      onFermer && onFermer();
    };

    // ── Rendu ──
    const choisirOutil = (id) => { setOutil(id); setDessin(null); setMenu(null); setChoixToit(false); };
    const lat = toit && toit.centre ? toit.centre.lat : null, lng = toit && toit.centre ? toit.centre.lng : null;
    const adresse = client.address_full || [client.address_civic, client.address_street, client.address_city].filter(Boolean).join(", ") || (demo ? "Maison de démonstration" : "Adresse du client");
    const qualiteTxt = (q) => q === "HIGH" ? "HD" : q === "MEDIUM" ? "moyenne" : q === "LOW" ? "basse" : "";
    const sousTitre = [client.name, toit ? `imagerie Google ${qualiteTxt(E.qualite || toit.qualite_imagerie)}${E.date || toit.date_imagerie ? " du " + dateTexte(E.date || toit.date_imagerie) : ""}`.replace(/\s+/g, " ") : null, pret && m ? `${fmtNum(m.repere().mParPx * 100, 0)} cm/px` : null].filter(Boolean).join(" · ");
    const modeleCourant = MODELES[E.modele] || MODELES.longi500 || Object.values(MODELES)[0];
    const bulle = (() => { if (!pret || !m || !vue.scale || selection.size !== 1 || apercu || dnd) return null; const i = [...selection][0]; const q = (E.panneaux || [])[i]; if (!q || !q.coins) return null; const pts = q.coins.map(c => m.geoVersEcran(vue, c.lat, c.lng)); return { x: Math.max(...pts.map(t => t.x)) + 10, y: Math.min(...pts.map(t => t.y)) - 4, i, q }; })();
    const barreSel = (() => { if (!pret || !m || !vue.scale || !selection.size || apercu || menu || dnd || outil !== "selectionner" || etape !== "design") return null; const pts = []; for (const i of selection) { const q = (E.panneaux || [])[i]; if (q && q.coins) q.coins.forEach(c => pts.push(m.geoVersEcran(vue, c.lat, c.lng))); } if (!pts.length) return null; return { x: (Math.min(...pts.map(t => t.x)) + Math.max(...pts.map(t => t.x))) / 2, y: Math.max(...pts.map(t => t.y)) + 10, n: selection.size }; })();
    const projectionToit = useMemo(() => (pret && m && vue.scale) ? { versPx: (xm, ym) => { const g = m.geoDeMetres(xm, ym); return m.geoVersEcran(vue, g.lat, g.lng); }, versM: (px, py) => { const g = m.ecranVersGeo(vue, px, py); const q = m.metres(g.lat, g.lng); return { e: q.e, n: q.n, x: q.e, y: q.n }; } } : null, [pret, m, vue]);
    const onModele = (nouveau) => { if (!m || !nouveau) return; const ok = m.appliquerModele(nouveau); if (ok) { setModele(nouveau); noter("modele_toit", { faces: (nouveau.faces || []).length }); const ni = m.panneauxInvalides().length; setToast(ni ? { info: `Toit mis à jour : ${ni} panneau${ni > 1 ? "x" : ""} en rouge ne tien${ni > 1 ? "nent" : "t"} plus, déplace-le${ni > 1 ? "s" : ""} ou retire-le${ni > 1 ? "s" : ""}.` } : { ok: "Toit mis à jour : pans et zones posables recalculés." }); } else setToast({ info: "Modèle du toit refusé : aucune face valide." }); };
    const obstaclesManuels = pret && m && vue.scale ? obstaclesEcran() : [];
    const faitesManuels = pret && m && vue.scale ? (E.faites || []).map(f => ({ A: m.geoVersEcran(vue, f.a.lat, f.a.lng), B: m.geoVersEcran(vue, f.b.lat, f.b.lng) })) : [];
    const aide = choixToit ? <><kbd>Clic</kbd> sur le toit de la maison du client : le bâtiment retenu est celui qui contient ce point · <kbd>Échap</kbd> annuler</>
      : etape !== "design" ? (outil === "toit" ? <>Corrige les faces et les arêtes du toit · puis « Passer au design »</> : outil === "mesurer" ? <>Glisser entre deux points pour mesurer en mètres</> : <><kbd>Clic</kbd> sur un pan : le voir dans le tableau · « Analyser la maison » dessine les pans · <kbd>T</kbd> corriger un pan à la main</>)
      : outil === "panneaux" ? <><kbd>Clic</kbd> poser ici (aimanté, <kbd>Alt</kbd> sans aimant) · <kbd>Glisser</kbd> poser en continu · <kbd>Glisser</kbd> un module : le déplacer, hors pan : le retirer</> : outil === "obstacle" ? <>Tracer un rectangle sur la cheminée, l'évent ou le puits de lumière · <kbd>Suppr</kbd> retire l'obstacle sélectionné</> : outil === "mesurer" ? <>Glisser entre deux points pour mesurer en mètres</> : outil === "toit" ? <>Corrige les faces et les arêtes du toit · les panneaux qui ne tiennent plus passent en rouge</> : <><kbd>Glisser</kbd> un module de la liste vers un pan · <kbd>Glisser</kbd> un module posé : le déplacer, hors pan : le retirer · <kbd>Maj</kbd> ou rectangle : plusieurs · <kbd>R</kbd> pivoter · <kbd>Suppr</kbd> retirer</>;
    const panDe = (i) => (E.pans || []).find(x => x.index === i) || segments.find(sg => sg.index === i) || {};
    const ptEcran = point && pret && m && vue.scale ? m.geoVersEcran(vue, point.lat, point.lng) : null;
    const prec = point && point.precision ? (PRECISION[point.precision] || { txt: point.precision, ok: false }) : null;
    const margesUI = (pan) => { const mg = pan != null && m && m.margesDe ? m.margesDe(pan) : marges; return mg; };
    const setMargeCm = (cat, cm, pan) => { if (!m) return; const v = Math.max(0, Math.min(300, Number(String(cm).replace(",", ".")) || 0)) / 100; if (pan != null) { m.setMargesPan(pan, { [cat]: v }); noter("marge_pan", { pan, [cat]: Math.round(v * 100) }); } else { m.setMarges({ [cat]: v }); noter("marge_" + cat, { cm: Math.round(v * 100) }); } };
    const passerDesign = () => { if (!modele) return; setEtape("design"); setOutil("selectionner"); setChoixToit(false); setPanSel(null); noter("etape_design"); };
    const Tiles = window.Solaire3DTilesRE; const tilesOk = !!Tiles && !tilesEchec && !!cle3d && (typeof Tiles.disponible !== "function" || Tiles.disponible());
    const badgeIrr = (x) => x.alerte_irradiance ? <span className={"re-studio-badge " + (x.alerte_irradiance.niveau === "hors_bornes" ? "rouge" : "orange")} title={x.alerte_irradiance.texte}>{x.alerte_irradiance.niveau === "hors_bornes" ? "hors bornes" : x.alerte_irradiance.niveau === "bas" ? "ombragé ?" : "à vérifier"}</span> : null;
    const badgeGoogle = (x) => x.alerte_google ? <span className="re-studio-badge orange" title={`Google : pente ${x.google_pan ? x.google_pan.pente_deg : "?"}°, azimut ${x.google_pan ? x.google_pan.azimut_deg : "?"}° ; relief : pente ${x.mesure ? x.mesure.pente_deg : "?"}°, azimut ${x.mesure ? x.mesure.azimut_deg : "?"}°`}>écart Google {Math.max(Math.abs((x.ecart && x.ecart.pente_deg) || 0), (x.ecart && x.ecart.azimut_deg) || 0)}°</span> : x.recale_google ? <span className="re-studio-badge gris" title={`Mesure du relief : pente ${x.mesure ? x.mesure.pente_deg : "?"}°, azimut ${x.mesure ? x.mesure.azimut_deg : "?"}° ; écart avec Google sous 5°, valeurs de Google retenues`}>recalé Google</span> : x.source === "dsm" ? <span className="re-studio-badge bleu" title="Pan trouvé dans le relief, absent des pans de Google">nouveau</span> : null;

    const studio = (
      <div className={"re-studio" + (soleil ? " sun" : "") + (vueMode === "3d" ? " m3d" : "") + (etape === "design" ? " etape-design" : " etape-maison") + (dnd ? " re-studio-dnd-actif" : "")} role="dialog" aria-label="Studio solaire">
        <div className="re-studio-top">
          <div className="re-studio-brand"><div className="logo">{window.EclairRaycom ? <window.EclairRaycom size={20} couleur="#fff" title="Raycom Électrique" /> : "R"}</div><div><b>Studio solaire</b><span>Raycast · Raycom Électrique</span></div></div>
          <div className="re-studio-adresse" title={adresse}><b>{adresse}</b><span>{sousTitre || (demo ? "démonstration, aucune donnée client" : "analyse en cours…")}</span></div>
          {!demo && <div className="re-studio-etapes" role="tablist" aria-label="Étapes du studio">
            <button type="button" role="tab" aria-selected={etape !== "design"} className={etape !== "design" ? "on" : ""} onClick={() => { setEtape("maison"); setOutil("selectionner"); }}><i>1</i>Analyser la maison</button>
            <span className="sep">›</span>
            <button type="button" role="tab" aria-selected={etape === "design"} className={etape === "design" ? "on" : ""} disabled={!modele} onClick={passerDesign} title={modele ? "" : "Analyse d'abord la maison"}><i>2</i>Design</button>
          </div>}
          <div className="re-studio-kpis">
            <div className={"hi" + (E.n_invalides ? " alerte" : "")} title={E.n_invalides ? `${E.n_invalides} panneau(x) en rouge ne tiennent plus : déplace-les ou retire-les` : ""}><b>{n}</b><span>panneaux{E.n_invalides ? ` · ${E.n_invalides} à revoir` : ""}</span></div>
            <div><b>{fmtNum(kw)} kW</b><span>puissance</span></div>
            <div className={designHorsBornes ? "alerte" : ""} title={designHorsBornes ? "Production au-dessus de ce qu'un toit donne à Mascouche : à vérifier" : `Production AC : flux Google × ${Math.round(RENDEMENT * 100)} % (pertes du système)`}><b>{fmtInt(kwhAc)}</b><span>kWh / an{designHorsBornes ? " · à vérifier" : ""}</span></div>
            <div className="sun"><b>{n && E.acces_pct_moyen != null ? Math.round(E.acces_pct_moyen) : "—"} %</b><span>accès solaire</span></div>
          </div>
          <div className="re-studio-conso">
            <div><label>Consommation</label><div className="in"><input value={conso ? fmtInt(conso) : ""} inputMode="numeric" onChange={e => setConso(e.target.value.replace(/\D/g, "").slice(0, 6))} placeholder="16 200" aria-label="Consommation annuelle du client en kWh" /><span>kWh / an</span></div></div>
            <div className="couv"><b>{couverture != null ? `${couverture} %` : "—"}</b><span>couverte</span></div>
          </div>
          <div className="spacer" />
          <div className="re-studio-seg"><button type="button" className={vueMode === "2d" ? "on" : ""} onClick={() => setVueMode("2d")}>2D</button><button type="button" className={vueMode === "3d" ? "on" : ""} onClick={() => { setVueMode("3d"); setVue3dMontee(true); noter("vue3d", { tuiles: tilesOk }); }} disabled={demo || !(window.Solaire3DRE || tilesOk) || !toit}>3D</button></div>
          <button type="button" className={"re-studio-tog" + (soleil ? " on" : "")} onClick={() => { setSoleil(x => !x); noter("ensoleillement", { on: !soleil }); }} title="Calque d'ensoleillement Google Solar (S)"><i />Ensoleillement</button>
          {soleil && E.flux_mensuel && <select className="re-studio-mois" value={mois} onChange={e => setMois(Number(e.target.value))} aria-label="Période du calque d'ensoleillement"><option value={0}>Annuel</option>{MOIS.map((mm, i) => <option key={mm} value={i + 1}>{mm}</option>)}</select>}
          <button type="button" className="re-studio-fermer" title="Fermer le studio (Échap)" onClick={() => onFermer && onFermer()}>✕</button>
        </div>

        <div className="re-studio-rail">
          <Outil id="selectionner" outil={outil} onPick={choisirOutil} label="Sélectionner" tip={etape === "design" ? "Sélectionner, déplacer un module (glisser), hors pan : retirer" : "Sélectionner un pan"} kbd="V"><path d="M4 4l7 16 2-7 7-2z" /></Outil>
          {etape !== "design" && !demo && <button type="button" className={"re-studio-outil" + (choixToit ? " on" : "")} onClick={() => { setChoixToit(x => !x); setOutil("selectionner"); }} aria-label="Choisir le toit"><svg viewBox="0 0 24 24"><path d="M12 21s-6-5.3-6-10a6 6 0 0 1 12 0c0 4.7-6 10-6 10z" /><circle cx="12" cy="11" r="2.2" /></svg><small>Choisir le toit</small><span className="tip">Clique sur le toit de la maison si l'adresse est approximative</span></button>}
          {etape === "design" && <Outil id="panneaux" outil={outil} onPick={choisirOutil} label="Panneaux" tip="Poser des panneaux : clic ou glisser sur le toit" kbd="P"><rect x="4" y="3" width="16" height="18" rx="1.5" /><path d="M4 9h16M4 15h16M12 3v18" /></Outil>}
          {etape === "design" && <Outil id="remplir" outil={outil} onPick={choisirOutil} label="Remplir" tip={panSel != null ? `Remplir le pan ${panSel + 1}` : "Remplir automatiquement les meilleurs pans"} kbd="A" action={remplir}><path d="M3 12l9-8 9 8M5 10v10h14V10" /><path d="M9 20v-6h6v6" /></Outil>}
          {etape === "design" && <Outil id="obstacle" outil={outil} onPick={choisirOutil} label="Obstacle" tip="Cheminée, évent, puits de lumière : tracer un rectangle" kbd="O"><rect x="6" y="9" width="12" height="11" rx="1" /><path d="M9 9V5h6v4" /></Outil>}
          <Outil id="mesurer" outil={outil} onPick={choisirOutil} label="Mesurer" tip="Mesurer en mètres : glisser entre deux points" kbd="M"><path d="M3 17L17 3l4 4L7 21z" /><path d="M8 12l2 2M11 9l2 2M14 6l2 2" /></Outil>
          <Outil id="toit" outil={outil} onPick={choisirOutil} label="Toit" tip="Corriger le modèle du toit : faces, faîtes, arêtes" kbd="T"><path d="M3 11l9-7 9 7" /><path d="M5 10v10h14V10" /><path d="M12 4v16M5 15h14" /></Outil>
          <div className="sep" />
          <button type="button" className="re-studio-outil fin" disabled={demo || !E.peut_annuler} onClick={() => m && m.annuler()} aria-label="Annuler"><svg viewBox="0 0 24 24"><path d="M9 14L4 9l5-5" /><path d="M4 9h11a5 5 0 0 1 0 10h-3" /></svg><small>Annuler</small><span className="tip">Annuler<kbd>Ctrl+Z</kbd></span></button>
          <button type="button" className="re-studio-outil" disabled={demo || !E.peut_retablir} onClick={() => m && m.retablir()} aria-label="Rétablir"><svg viewBox="0 0 24 24"><path d="M15 14l5-5-5-5" /><path d="M20 9H9a5 5 0 0 0 0 10h3" /></svg><small>Rétablir</small><span className="tip">Rétablir<kbd>Ctrl+Y</kbd></span></button>
        </div>

        <div className="re-studio-scene" ref={sceneRef}>
          {msg.loading && <div className="re-studio-msg"><i className="spin" />{msg.loading}</div>}
          {msg.err && <div className="re-studio-msg err">{msg.err}</div>}
          {msg.info && !toast && <div className="re-studio-toast info">{msg.info}</div>}
          {demo && vueMode === "2d" && <Demo2D soleil={soleil} panSel={panSel} setPanSel={setPanSel} />}
          {!demo && pret && (
            <div className={"re-studio-2d" + (vueMode === "2d" ? "" : " cache")} onPointerMove={onMove} onPointerDown={onDown} onPointerUp={onUp} onPointerCancel={onCancel} onPointerLeave={onLeave} ref={zone2dRef} onDoubleClick={onDoubleClick} onContextMenu={onContextMenu}>
              <canvas ref={canvasRef} className={"re-studio-canvas outil-" + outil + (choixToit ? " choix-toit" : "") + (apercu ? (apercu.ok ? " deplace" : " refuse") : "")} />
              {OV && W > 0 && (
                <svg className="re-studio-ov" width={W} height={H} viewBox={`0 0 ${W} ${H}`} aria-hidden="true">
                  <defs><pattern id="re-studio-hach" width="5" height="5" patternUnits="userSpaceOnUse" patternTransform="rotate(45)"><line x1="0" y1="0" x2="0" y2="5" stroke="rgba(255,255,255,.55)" strokeWidth="1" /></pattern></defs>
                  {!choixToit && <path className="voile" fillRule="evenodd" d={`M0 0H${W}V${H}H0Z ` + OV.faces.map(f => "M" + f.pts.map(q => `${q.x.toFixed(1)} ${q.y.toFixed(1)}`).join("L") + "Z").join(" ")} />}
                  <g className="faces">{OV.faces.map(f => { const pv = panDe(f.pan); const al = pv && (pv.alerte_google || (pv.alerte_irradiance && pv.alerte_irradiance.niveau === "hors_bornes")); return <polygon key={f.index} data-pan={f.pan} className={"face" + (f.pan < 0 ? " hors" : "") + (al && etape !== "design" ? " alerte" : "") + (panSel != null && f.pan === panSel ? " sel" : "") + (panSurvol != null && f.pan === panSurvol ? " hov" : "") + (dnd && dnd.pan === f.pan && f.pan >= 0 ? (dnd.ok ? " cible-ok" : " cible-ko") : "")} points={f.pts.map(q => `${q.x.toFixed(1)},${q.y.toFixed(1)}`).join(" ")} />; })}</g>
                  <g className="arbres">{OV.arbres.map((t, i) => <circle key={i} cx={t.x.toFixed(1)} cy={t.y.toFixed(1)} r={t.r.toFixed(1)} />)}</g>
                  <g className="aretes">{OV.aretes.map((a, i) => { const st = LIGNES[a.type] || LIGNES.rive; return <line key={i} className={a.type} x1={a.A.x.toFixed(1)} y1={a.A.y.toFixed(1)} x2={a.B.x.toFixed(1)} y2={a.B.y.toFixed(1)} stroke={st.couleur} strokeWidth={st.largeur} strokeDasharray={st.tirets} strokeLinecap="round" />; })}</g>
                  <g className="faites">{faitesManuels.map((f, i) => <line key={i} x1={f.A.x} y1={f.A.y} x2={f.B.x} y2={f.B.y} />)}</g>
                  <g className="obstacles">
                    {OV.obstacles.map((o, i) => <g key={"d" + i}><circle className="recul" cx={o.x.toFixed(1)} cy={o.y.toFixed(1)} r={o.rr.toFixed(1)} /><circle className="corps" cx={o.x.toFixed(1)} cy={o.y.toFixed(1)} r={o.r.toFixed(1)} /><circle className="hach" cx={o.x.toFixed(1)} cy={o.y.toFixed(1)} r={o.r.toFixed(1)} /></g>)}
                    {obstaclesManuels.map((pts, i) => <g key={"m" + i} className={obstacleSel === i ? "sel" : ""}><polygon className="corps" points={pts.map(q => `${q.x.toFixed(1)},${q.y.toFixed(1)}`).join(" ")} /><polygon className="hach" points={pts.map(q => `${q.x.toFixed(1)},${q.y.toFixed(1)}`).join(" ")} /></g>)}
                  </g>
                  <g className="cotes">{OV.cotes.map((c, i) => <g key={i}><line x1={c.a.x} y1={c.a.y} x2={c.b.x} y2={c.b.y} /><line x1={c.A.x} y1={c.A.y} x2={c.a.x} y2={c.a.y} /><line x1={c.B.x} y1={c.B.y} x2={c.b.x} y2={c.b.y} /><text transform={`translate(${c.t.x.toFixed(1)} ${c.t.y.toFixed(1)}) rotate(${c.ang.toFixed(1)})`}>{c.texte}</text></g>)}</g>
                  <g className="labs">{OV.faces.map(f => <g key={f.index} className={"lab" + (panSel != null && f.pan === panSel ? " sel" : "")} transform={`translate(${f.c.x.toFixed(1)} ${f.c.y.toFixed(1)})`}><circle r="10.5" /><text y="3.8">{f.pan >= 0 ? f.pan + 1 : "+"}</text></g>)}</g>
                </svg>
              )}
              {ptEcran && etape !== "design" && <div className={"re-studio-point" + (zone && zone.contient ? "" : " hors")} style={{ left: ptEcran.x, top: ptEcran.y }} title={`Point retenu : ${SOURCES_POINT[point.source] || point.source}`}><i /></div>}
              {choixToit && <div className="re-studio-choix"><b>Clique sur le toit de la maison du client</b><span>{prec && !prec.ok ? `Adresse ${prec.txt} : Google peut avoir pris le mauvais bâtiment.` : zone && !zone.contient ? "Le point de l'adresse ne tombe sur aucun toit." : "Le bâtiment retenu sera celui qui contient ton clic."}</span><button type="button" onClick={() => setChoixToit(false)}>Garder ce bâtiment</button></div>}
              {outil === "toit" && <div className="re-studio-toit-ov">{window.SolaireToitEditeurRE && projectionToit && modele ? <window.SolaireToitEditeurRE modele={modele} projection={projectionToit} onModele={onModele} modeleAuto={modeleInitial.current} largeur={W} hauteur={H} /> : <div className="re-studio-toit-bientot"><b>{modele ? "Éditeur du toit : bientôt" : "Analyse d'abord la maison"}</b><span>{modele ? "Les faces et les arêtes du toit se corrigeront ici. En attendant, les obstacles et les marges suffisent pour la pose." : "Le bouton « Analyser la maison » dessine les pans ; tu pourras ensuite les corriger ici."}</span></div>}</div>}
              {soleil && curseur && <div className="re-studio-pointeur" style={{ left: curseur.x, top: curseur.y }} />}
              {curseur && !dessin && !apercu && !dnd && (curseur.panneau >= 0 && E.panneaux[curseur.panneau]
                ? <div className="re-studio-curseur panneau" style={{ left: curseur.x + 20, top: curseur.y - 14 }}><b>{fmtInt(E.panneaux[curseur.panneau].kwh_an)} kWh / an</b><span>module {curseur.panneau + 1} · accès solaire {E.panneaux[curseur.panneau].acces_pct} %{E.panneaux[curseur.panneau].invalide ? " · ne tient plus ici" : ""}</span><span>{fmtInt(curseur.flux)} kWh / kW (flux Google) à cet endroit{curseur.pan >= 0 && noms[curseur.pan] ? ` · ${noms[curseur.pan].toLowerCase()}` : ""}{panDe(curseur.pan).pente_deg != null ? ` · ${PENTE(panDe(curseur.pan).pente_deg)}` : ""}</span></div>
                : <div className="re-studio-curseur" style={{ left: curseur.x + 20, top: curseur.y - 14 }}><b>{fmtInt(curseur.flux)} kWh / kW</b><span>flux Google, ombrage inclus · accès solaire {Math.round((curseur.acces || 0) * 100)} %</span><span>≈ {fmtInt(curseur.flux * (modeleCourant.watts || 500) / 1000 * RENDEMENT)} kWh / an AC pour un module de {modeleCourant.watts || 500} W posé ici</span>{curseur.pan >= 0 ? <span>pan {curseur.pan + 1}{noms[curseur.pan] ? ` · ${noms[curseur.pan].toLowerCase()}` : ""}{panDe(curseur.pan).pente_deg != null ? ` · ${PENTE(panDe(curseur.pan).pente_deg)}` : ""}{soleil && mois ? ` · ${MOIS[mois - 1]}` : ""}</span> : null}</div>)}
              {dnd && <div className={"re-studio-dnd-label " + (dnd.ok ? "ok" : "ko")} style={{ left: dnd.x + 18, top: dnd.y + 14 }}>{dnd.ok ? <><b>{nomPan(dnd.pan)}</b><span>{dnd.kwh != null ? `≈ ${fmtInt(dnd.kwh)} kWh / an` : ""}{dnd.aimante ? " · aimanté" : ""}{dnd.n > 1 ? ` · ${dnd.n} modules` : ""} · relâche pour {dnd.nouveau ? "poser" : "déplacer"}</span></> : <><b>{dnd.horsPan || (dnd.nouveau && dnd.pan < 0) ? (dnd.nouveau ? "Hors des pans" : "Hors des pans : retirer") : "Position refusée"}</b><span>{dnd.raison}{dnd.nouveau ? " · relâché ici, le module retourne dans la liste" : ""}</span></>}</div>}
              {bulle && !curseur && <div className="re-studio-bulle" style={{ left: bulle.x, top: bulle.y }}>Module {bulle.i + 1} · <b>{fmtInt(bulle.q.kwh_an)} kWh/an</b> · accès {bulle.q.acces_pct} % · pan {bulle.q.pan + 1}{bulle.q.invalide ? " · ne tient plus ici" : ""}</div>}
              {barreSel && <div className="re-studio-barre-sel" style={{ left: barreSel.x, top: barreSel.y }} onPointerDown={e => e.stopPropagation()}><span>{barreSel.n} panneau{barreSel.n > 1 ? "x" : ""}</span><button type="button" onClick={() => pivoterSelection()} title="Pivoter portrait ou paysage (R)">Pivoter</button><button type="button" onClick={() => dupliquerSelection()} title="Dupliquer à côté (D)">Dupliquer</button><button type="button" className="danger" onClick={() => supprimerSelection()} title="Supprimer (Suppr)">Supprimer</button></div>}
              {menu && <div className="re-studio-menu" style={{ left: menu.x, top: menu.y }} onPointerDown={e => e.stopPropagation()}><button type="button" onClick={() => pivoterSelection()}>Pivoter</button><button type="button" onClick={() => dupliquerSelection()}>Dupliquer</button><button type="button" className="danger" onClick={() => supprimerSelection()}>Supprimer</button></div>}
            </div>
          )}
          {!demo && vue3dMontee && toit && (tilesOk || window.Solaire3DRE) && <div className={"re-studio-3d" + (vueMode === "3d" ? "" : " cache")}>{tilesOk
            ? <Tiles lat={lat} lng={lng} panneaux={E.panneaux || []} modele={E.modele || "longi500"} orientation={E.orientation || "portrait"} pans={E.pans || segments} toit={toit} batiment={modele} cle={cle3d} onEchec={() => { setTilesEchec(true); noter("tuiles3d_echec"); }} />
            : <window.Solaire3DRE lat={lat} lng={lng} panneaux={E.panneaux || []} modele={E.modele || "longi500"} orientation={E.orientation || "portrait"} pans={(E.pans && E.pans.length ? E.pans : segments)} toit={toit} batiment={modele} />}</div>}
          {vueMode === "2d" && (pret || demo) && !soleil && <div className="re-studio-legende"><b>Modèle du toit</b><div><i className="f" />Faîte</div><div><i className="a" />Arête</div><div><i className="n" />Noue</div><div><i />Égout, rive</div><div><i className="t" />Arbre</div>{etape === "design" && <div><i className="m" />Marge</div>}</div>}
          {vueMode === "2d" && (pret || demo) && soleil && <div className="re-studio-legende soleil"><b>Ensoleillement {mois ? MOIS[mois - 1] : "annuel"}</b><div className="bar" /><div className="ends"><span>{pret && m ? `≤ ${fmtInt(m.fluxMax(mois) * 0.45)}` : "ombre"}</span><span>{pret && m ? `${fmtInt(m.fluxMax(mois) * 0.75)}` : ""}</span><span>{pret && m ? `${fmtInt(m.fluxMax(mois))} kWh/kW` : "plein soleil"}</span></div><div className="note">Google Solar, heure par heure sur l'année · ombrage des arbres, voisins et cheminées inclus{pret && m ? ` · max ${fmtInt(m.fluxMax(mois))} kWh/kW` : ""}</div></div>}
          {vueMode === "2d" && pret && !demo && <div className="re-studio-nord" title="Nord"><i />N</div>}
          {vueMode === "2d" && pret && echelle && <div className="re-studio-echelle">{echelle.L} m<i style={{ width: echelle.px }} /></div>}
          {vueMode === "2d" && pret && !demo && <button type="button" className="re-studio-recadrer" onClick={recadrer} title="Recadrer sur la maison (F)">⌖ Recadrer</button>}
          {vueMode === "2d" && (pret || demo) && <div className="re-studio-hint">{aide} · <kbd>Molette</kbd> zoom · <kbd>Espace</kbd> + glisser : déplacer</div>}
          {toast && toast.ok && <div className="re-studio-toast">{toast.ok}</div>}
          {toast && toast.info && <div className="re-studio-toast info">{toast.info}</div>}
          {toast && toast.err && <div className="re-studio-toast err">{toast.err}</div>}
        </div>

        <div className="re-studio-side">
          <section>
            <h4>Maison {client.client_id && window.RaycastNav && window.RaycastNav.ouvrirClient && <a href="#" onClick={e => { e.preventDefault(); noter("fiche_client", { id: client.client_id }); window.RaycastNav.ouvrirClient(client.client_id); onFermer && onFermer(); }}>Ouvrir la fiche client</a>}</h4>
            {etape !== "design" && <div className="re-studio-sv">{streetView ? <img src={streetView} alt="" /> : <svg width="34" height="34" viewBox="0 0 24 24" fill="none" stroke="currentColor" strokeWidth="1.6" strokeLinecap="round" strokeLinejoin="round"><path d="M3 10l9-7 9 7v10a1 1 0 0 1-1 1H4a1 1 0 0 1-1-1z" /><path d="M9 21v-7h6v7" /></svg>}<span>Street View · façade</span><em>{toit ? `Google · ${dateTexte(toit.date_imagerie || E.date).slice(0, 4) || ""}` : ""}</em></div>}
            <div className="re-studio-mesures">
              <div><b>{mesures.surface_toit_m2 ? `${fmtInt(mesures.surface_toit_m2)} m²` : "—"}</b><span>toit</span></div>
              <div><b>{mesures.egout_m != null ? `${fmtNum(mesures.egout_m)} m` : "—"}</b><span>égout</span></div>
              <div><b>{mesures.faite_m != null ? `${fmtNum(mesures.faite_m)} m` : "—"}</b><span>faîte</span></div>
              <div><b>{modele ? (E.pans || []).length : (mesures.faces || "—")}</b><span>pans</span></div>
            </div>
          </section>
          {etape !== "design" && !demo && <>
            <section className="re-studio-adr">
              <h4>Adresse et bâtiment retenus</h4>
              <div className="ligne"><span>Adresse</span><b title={point && point.adresse || adresse}>{(point && point.adresse) || adresse}</b></div>
              <div className="ligne"><span>Précision</span>{prec ? <b className={prec.ok ? "ok" : "warn"}>{prec.txt}{point.precision ? ` (${point.precision})` : ""}</b> : <b className="warn">inconnue</b>}</div>
              <div className="ligne"><span>Point</span><b>{point ? SOURCES_POINT[point.source] || point.source : "—"}</b></div>
              <div className="ligne"><span>Bâtiment</span>{zone && zone.bin ? <b className={zone.contient ? "ok" : "warn"}>{zone.contient ? "contient le point" : `toit le plus proche, à ${fmtNum(zone.distance_m, 1)} m`} · {fmtInt(zone.surface_m2)} m² au sol</b> : <b className="warn">aucun toit sous le point</b>}</div>
              {analyse && analyse.batiment && !analyse.batiment.google_meme_batiment && <div className="note warn">Google avait analysé un autre bâtiment : pans tirés du relief seulement.</div>}
              {analyse && analyse.batiment && analyse.batiment.zone_limitee && <div className="note">Maisons collées : analyse limitée au bâtiment de Google.</div>}
              <button type="button" className="re-studio-lien" onClick={() => { setChoixToit(true); setOutil("selectionner"); }}>{choixToit ? "Clique sur le toit…" : "Choisir un autre toit"}</button>
            </section>
            <section className="pans re-studio-pans-v2">
              <h4>Pans de toit {analyse && analyse.comparaison && <span className="re-studio-cmp" title="Comparaison avec les pans de Google (roofSegmentStats)">{analyse.comparaison.apparies}/{analyse.comparaison.pans_google} Google · {analyse.comparaison.ecarts_signales} écart{analyse.comparaison.ecarts_signales > 1 ? "s" : ""} &gt; 5°</span>}</h4>
              {!modele && <div className="re-studio-vide"><b>Les pans ne sont pas encore dessinés.</b><span>« Analyser la maison » lit le relief Google du bâtiment retenu : plans du toit, contours, faîtes, arêtes, noues, égouts et rives, pente, azimut, surface vraie et ensoleillement de chaque pan.</span></div>}
              {modele && <table className="re-studio-table"><thead><tr><th>Pan</th><th title="Surface vraie, inclinée">m²</th><th>Pente</th><th>Azim.</th><th title="Flux Google moyen sur le pan (kWh/kW/an, ombrage inclus) et production AC estimée">kWh/kW</th></tr></thead><tbody>
                {pans.map(x => <tr key={x.index} className={(panSel === x.index ? "sel" : "") + (panSurvol === x.index ? " hov" : "")} onClick={() => setPanSel(panSel === x.index ? null : x.index)} onMouseEnter={() => setPanSurvol(x.index)} onMouseLeave={() => setPanSurvol(null)}>
                  <td><span className="num">{x.index + 1}</span><b>{x.nom}</b>{badgeGoogle(x)}</td>
                  <td>{fmtNum(x.surface_m2, 0)}</td>
                  <td title={`${fmtNum(x.pente_deg, 1)}°`}>{PENTE(x.pente_deg)}<small>{Math.round(x.pente_deg || 0)}°</small></td>
                  <td>{x.pente_deg < 5 ? "plat" : `${AZ(x.azimut_deg)} ${Math.round(x.azimut_deg || 0)}°`}</td>
                  <td title={x.alerte_irradiance ? x.alerte_irradiance.texte : `Flux Google ${fmtInt(x.flux_moyen)} kWh/kW/an · production AC ≈ ${fmtInt(x.rendement_kwh_kw)} kWh/kW/an`}>{x.flux_moyen != null ? <><b className={x.alerte_irradiance && x.alerte_irradiance.niveau === "hors_bornes" ? "barre" : ""}>{fmtInt(x.rendement_kwh_kw)}</b><small>flux {fmtInt(x.flux_moyen)}</small></> : "—"}<Mois12 v={x.flux_mensuel} titre="Flux Google par mois (janvier à décembre)" />{badgeIrr(x)}</td>
                </tr>)}
              </tbody></table>}
              {analyse && (analyse.avertissements || []).length > 0 && <details className="re-studio-avert"><summary>{analyse.avertissements.length} remarque{analyse.avertissements.length > 1 ? "s" : ""} de l'analyse</summary>{analyse.avertissements.slice(0, 8).map((a, i) => <div key={i}>{a}</div>)}</details>}
              {modele && <div className="re-studio-note">kWh/kW : production AC estimée (flux Google × {Math.round(RENDEMENT * 100)} %). Attendu à Mascouche pour un pan sud bien incliné : 1 150 à 1 350.</div>}
            </section>
            <div className="actions">{!modele
              ? <button type="button" className="re-btn primary" disabled={!pret || choixToit} onClick={() => analyserMaison()}>Analyser la maison</button>
              : <><button type="button" className="re-btn" onClick={() => analyserMaison({ sansManuel: true })}>Refaire l'analyse</button><button type="button" className="re-btn primary" onClick={passerDesign}>Passer au design →</button></>}</div>
          </>}
          {(etape === "design" || demo) && <>
            <section className="re-studio-palette" ref={paletteRef}>
              <h4>Modules {E.modele === "longi500" && <span className="stock">en stock</span>}</h4>
              {Object.values(MODELES).map(md => { const actif = (E.modele || "longi500") === md.id; return (
                <div key={md.id} className={"re-studio-module" + (actif ? " actif" : "")} onPointerDown={e => actif ? debutPalette(e, md.id) : null} title={actif ? "Glisse ce module sur un pan dessiné" : ""} data-modele={md.id}>
                  <div className="img" /><div className="txt"><b>{String(md.nom || "").replace(/\s*\(en stock\)\s*$/, "")}</b><span>{CODES_MODELES[md.id] ? CODES_MODELES[md.id] + " · " : ""}{fmtNum(md.h * 1000, 0)} × {fmtNum(md.w * 1000, 0)} mm · {md.watts} W{md.qbo ? ` · code ${md.qbo}` : ""}</span></div>
                  {actif ? <span className="poignee" aria-hidden="true">⠿</span> : <button type="button" className="re-studio-lien" onPointerDown={e => e.stopPropagation()} onClick={() => { m && m.setModele(md.id); noter("modele_panneau", { modele: md.id }); }}>Utiliser</button>}
                </div>); })}
              <div className="row2">
                <label className="re-field"><span className="re-field-label">Orientation</span><select value={E.orientation || "portrait"} disabled={demo} onChange={e => { m && m.setOrientation(e.target.value); noter("orientation", { orientation: e.target.value }); }}><option value="portrait">Portrait</option><option value="paysage">Paysage</option></select></label>
                <div className="re-studio-astuce">Glisse le module sur un pan : vert = posable, rouge = refusé. Relâché ailleurs, il revient ici.</div>
              </div>
            </section>
            <section className="re-studio-marges">
              <h4>Marges (cm) {panSel != null && <span className="h4-actions"><span className="re-studio-cmp">pan {panSel + 1}</span></span>}</h4>
              <div className="grille">{MARGES_UI.map(([k, lib, tip]) => <label key={k} title={tip}><span>{lib}</span><input type="number" min="0" max="300" step="5" inputMode="numeric" value={Math.round(((marges[k]) || 0) * 100)} disabled={demo} onChange={e => setMargeCm(k, e.target.value, null)} aria-label={`Marge ${lib} en cm, tous les pans`} /></label>)}</div>
              {panSel != null && m && <div className="pan">
                <label className="propre"><input type="checkbox" checked={!!(m.margesPans && m.margesPans()[panSel])} onChange={e => { if (e.target.checked) m.setMargesPan(panSel, { egout: marges.egout, faite: marges.faite, rive: marges.rive }); else m.setMargesPan(panSel, null); noter("marges_pan_propres", { pan: panSel, on: e.target.checked }); }} />Marges propres au pan {panSel + 1}</label>
                {m.margesPans && m.margesPans()[panSel] && <div className="grille">{MARGES_UI.slice(0, 3).map(([k, lib]) => <label key={k}><span>{lib}</span><input type="number" min="0" max="300" step="5" value={Math.round((margesUI(panSel)[k] || 0) * 100)} onChange={e => setMargeCm(k, e.target.value, panSel)} aria-label={`Marge ${lib} en cm, pan ${panSel + 1}`} /></label>)}</div>}
              </div>}
            </section>
            <section className="pans">
              <h4>Pans de toit <span className="h4-actions">{n > 0 && !demo && <button type="button" className="re-studio-lien danger" onClick={toutEffacer} title="Retirer tous les panneaux">Vider</button>}<button type="button" className="re-studio-lien" disabled={demo || !pret} onClick={remplir}>{panSel != null ? `Remplir le pan ${panSel + 1}` : "Remplir auto"}</button></span></h4>
              {pans.map(x => (
                <div key={x.index} className={"re-studio-pan" + (x.nb_panneaux ? " on" : "") + (panSel === x.index ? " sel" : "") + (panSurvol === x.index ? " hov" : "")} onClick={() => { setPanSel(panSel === x.index ? null : x.index); setSelection(new Set()); setObstacleSel(null); }} onMouseEnter={() => setPanSurvol(x.index)} onMouseLeave={() => setPanSurvol(null)} title={`Pan ${x.index + 1} : ${x.nom}${x.pente_deg != null ? `, ${Math.round(x.pente_deg)}°` : ""}${x.rendement_kwh_kw != null ? `, ${x.rendement_kwh_kw} kWh/kW/an` : ""}`}>
                  <span className="num">{x.index + 1}</span>
                  <div className="info"><b>{x.nom}</b><span>{x.pente_deg != null ? PENTE(x.pente_deg) + " · " : ""}{fmtInt(x.surface_m2)} m²{x.nb_panneaux ? ` · ${fmtInt(x.kwh_an)} kWh/an` : ""}</span></div>
                  <div className="acces"><i style={{ width: `${Math.max(0, Math.min(100, Math.round(x.acces || 0)))}%` }} /><span>{Math.round(x.acces || 0)} %</span></div>
                  <b className="n">{x.nb_panneaux || 0}{x.max != null && <small title="Nombre maximal de panneaux sur ce pan">/{x.max}</small>}</b>
                </div>
              ))}
              {!pans.length && !demo && <div className="re-muted" style={{ fontSize: 12 }}>{msg.err ? "Aucun pan : l'analyse a échoué." : "Les pans apparaissent après l'analyse de la maison."}</div>}
            </section>
            <section>
              <h4>Production</h4>
              <div className="re-studio-prod">
                <div><b>{fmtInt(kwhAc)}</b><span>kWh / an AC</span></div>
                <div className={designHorsBornes ? "alerte" : ""}><b>{kw ? fmtInt(rendementDesign) : "—"}</b><span>kWh / kW{designHorsBornes ? " · à vérifier" : ""}</span></div>
                <div><b>{fmtInt(kwhAc * (Number(s.tarif_kwh) || TARIF))} $</b><span>économies an 1</span></div>
              </div>
              {prodMois && <div className="re-studio-prod-mois" title="Production AC par mois, flux mensuel Google sous chaque module">{prodMois.map((v, i) => <div key={i}><i style={{ height: `${Math.round(v / Math.max(1, ...prodMois) * 100)}%` }} /><span>{MOIS[i].slice(0, 1).toUpperCase()}</span></div>)}</div>}
              {couverture != null && <div className="re-studio-couv">Couvre <b>{couverture} %</b> de la consommation<div className="bar"><i style={{ width: `${Math.min(100, couverture)}%` }} /></div></div>}
            </section>
            <div className="actions">{!demo && <button type="button" className="re-btn" onClick={() => { setEtape("maison"); setOutil("selectionner"); }}>← Pans</button>}<button type="button" className="re-btn primary" disabled={!demo && (!pret || !n)} onClick={appliquer}>Appliquer à la soumission</button></div>
          </>}
        </div>
        {fantomeDom && <div className={"re-studio-fantome" + (fantomeDom.retour ? " retour" : "") + (fantomeDom.cache ? " cache" : "")} style={{ left: fantomeDom.x, top: fantomeDom.y }} aria-hidden="true"><div className="img" /></div>}
      </div>
    );
    return ReactDOM.createPortal(studio, document.body);
  }

  // ── Scène de démonstration (sans moteur) : modèle vectoriel fictif en SVG ──
  function Demo2D({ soleil, panSel, setPanSel }) {
    const K = 60, OX = 120, OY = 90; const pt = ([u, v]) => `${OX + u * K},${OY + v * K}`;
    const rampe = (t) => `hsl(${35 + 10 * t} 90% ${28 + 40 * t}%)`;
    const col = { faite: "#fde68a", arete: "#fff", noue: "#38bdf8", egout: "#e2e8f0", rive: "#e2e8f0" };
    return (
      <svg className="re-studio-demo" viewBox="0 0 900 720" preserveAspectRatio="xMidYMid meet">
        <rect width="900" height="720" fill="#2f3f2c" />
        {DEMO.faces.map(f => <polygon key={f.index} points={f.poly.map(pt).join(" ")} fill={soleil ? rampe(f.acces_pct / 100) : (panSel === f.index ? "rgba(56,189,248,.25)" : "rgba(120,110,100,.9)")} stroke="none" style={{ cursor: "pointer" }} onClick={() => setPanSel(panSel === f.index ? null : f.index)} />)}
        {DEMO.aretes.map((a, i) => <line key={i} x1={OX + a.a[0] * K} y1={OY + a.a[1] * K} x2={OX + a.b[0] * K} y2={OY + a.b[1] * K} stroke={col[a.t]} strokeWidth={a.t === "faite" ? 3.5 : a.t === "arete" ? 1.8 : 2.6} strokeDasharray={a.t === "noue" ? "7 4" : undefined} />)}
        {DEMO.panneaux.map((q, i) => <polygon key={i} points={q.coins.map(pt).join(" ")} fill="#0b2140" stroke="#dbe4ee" strokeWidth="1" />)}
        {DEMO.faces.map(f => { const c = f.poly.reduce((t, q) => [t[0] + q[0] / f.poly.length, t[1] + q[1] / f.poly.length], [0, 0]); return <g key={"l" + f.index} transform={`translate(${OX + c[0] * K} ${OY + c[1] * K})`}><circle r="11" fill="#f59e0b" stroke="#fff" strokeWidth="1.6" /><text y="4" textAnchor="middle" fontSize="11" fontWeight="800" fill="#1f1300">{f.index + 1}</text></g>; })}
        <text x="450" y="690" textAnchor="middle" fill="rgba(255,255,255,.75)" fontSize="13">Démonstration : maison fictive. Avec le moteur chargé, la vraie photo, le relief et l'ensoleillement Google s'affichent ici.</text>
      </svg>
    );
  }

  function SolaireStudioBoutonRE({ state, setState, toit, libelle }) {
    const [ouvert, setOuvert] = useState(false);
    const [ok, setOk] = useState(null);
    const de = state && state.solaire && state.solaire.design_editeur;
    return (
      <>
        <div className="re-studio-ouvrir">
          <button type="button" className="re-btn primary" onClick={() => { setOk(null); setOuvert(true); }} title="Studio solaire plein écran : photo, relief, modèle du toit, ensoleillement, panneaux à la souris, vue 3D">{libelle || (de && de.studio ? "Rouvrir le studio solaire" : "Ouvrir le studio solaire")}</button>
          <span className="re-muted">{toit ? "Toit analysé : la photo, le relief et l'ensoleillement Google se chargent à l'ouverture." : "L'adresse du client suffit : le studio analyse le toit à l'ouverture."}{de && de.studio && de.panneaux ? ` · design enregistré : ${de.panneaux.length} panneaux` : ""}</span>
        </div>
        {ok && <div className="re-alert ok span">{ok}</div>}
        {ouvert && <SolaireStudioRE state={state} setState={setState} toit={toit} onFermer={() => setOuvert(false)} onApplique={(r) => setOk(`Design appliqué : ${r.n} panneaux de ${r.watts} W (${fmtNum(r.kw)} kW), ≈ ${fmtInt(r.kwh_ac)} kWh/an AC, accès solaire moyen ${r.acces != null ? Math.round(r.acces) : "—"} %. Le devis a été recomposé.`)} />}
      </>
    );
  }
  window.SolaireStudioRE = SolaireStudioRE;
  window.SolaireStudioBoutonRE = SolaireStudioBoutonRE;
})();
