// configurator-re.jsx — Configurateur « Soumission RE » : tuiles produits du catalogue QuickBooks.
//
// 5 étapes : Client → Système (presets + tuiles) → Solaire (capture Aurora + irradiance) → Options → Résumé.
// Le prix de référence vient de QuickBooks ; il reste modifiable ligne par ligne sur la soumission.
// Finaliser (création du devis QuickBooks + proposition) arrive en phase P3.

(function () {
  const { useState, useEffect, useMemo, useRef, useCallback } = React;
  // Éclair Raycom (défini par icons.jsx ou cloud/auth.jsx) ; repli local qui dessine la même silhouette quand ce module est chargé seul (tests, aperçus).
  const EclairRaycom = (p) => (window.EclairRaycom ? <window.EclairRaycom {...p} /> : <svg width={(p.size || 16) * 0.56} height={p.size || 16} viewBox="0 0 389 696" aria-hidden="true" className="rc-eclair" style={{ display: "inline-block", verticalAlign: "-0.15em", ...(p.style || {}) }}><polygon points="300,0 195,288 389,288 78,696 184,406 0,405" fill={p.couleur || "#0a6fc8"} /></svg>);
  const C = () => window.CALC_RE;
  const fmt = (n) => window.CALC_RE.fmtCAD(n);
  const fmt0 = (n) => window.CALC_RE.fmtCAD(n, 0);
  const fmtInt = (n) => window.CALC_RE.fmtInt(n);
  const fmtNum = (n) => window.CALC_RE.fmtNum(n);

  const STEPS = [
    { id: 1, label: "Client" },
    { id: 2, label: "Système" },
    { id: 3, label: "Solaire" },
    { id: 4, label: "Options" },
    { id: 5, label: "Résumé" }
  ];

  // ───────────────────────── helpers lignes ─────────────────────────
  // Une ligne composée par le parcours garde src:"parcours" quand on ajuste sa quantité ou son prix : à la prochaine
  // recomposition, le parcours fixe la quantité et le prix modifié est conservé. Marquée « manuel », elle s'additionnait
  // à la ligne recomposée (14 panneaux édités + 16 du design = 30).
  function setQty(state, setState, qbo_id, qty) {
    const lignes = (state.lignes || []).filter(l => l.qbo_id !== qbo_id);
    if (qty > 0) {
      const prev = (state.lignes || []).find(l => l.qbo_id === qbo_id);
      lignes.push({ qbo_id, qty, prix: prev ? prev.prix : null, src: prev && prev.src ? prev.src : "manuel" });
    }
    setState({ ...state, lignes });
  }
  const qtyOf = (state, qbo_id) => { const l = (state.lignes || []).find(x => x.qbo_id === qbo_id); return l ? Number(l.qty) || 0 : 0; };

  function applyPreset(state, setState, preset) {
    const lignes = (state.lignes || []).filter(l => !preset.lignes.some(p => p.qbo_id === l.qbo_id));
    for (const p of preset.lignes) lignes.push({ qbo_id: p.qbo_id, qty: Number(p.qty) || 1, prix: null, src: "manuel" });
    setState({ ...state, lignes, preset_id: preset.id });
  }

  // ───────────────────────── composants de base ─────────────────────────
  const Stepper = ({ step, setStep, solaireActif }) => (
    <div className="re-stepper">
      {STEPS.map(s => (
        <button key={s.id} className={`re-step ${step === s.id ? "active" : ""} ${s.id === 3 && !solaireActif ? "muted" : ""}`} onClick={() => setStep(s.id)}>
          <span className="re-step-num">{step === s.id ? <EclairRaycom size={11} couleur="#fff" title={"Étape " + s.id}/> : s.id}</span><span>{s.label}</span>
        </button>
      ))}
    </div>
  );

  const Field = ({ label, children, hint, span }) => (
    <label className={`re-field ${span ? "span" : ""}`}>
      <span className="re-field-label">{label}</span>
      {children}
      {hint && <span className="re-field-hint">{hint}</span>}
    </label>
  );

  const QtyStepper = ({ qty, onChange, step = 1 }) => (
    <div className="re-qty" onClick={e => e.stopPropagation()}>
      <button type="button" onClick={() => onChange(Math.max(0, qty - step))} aria-label="Moins">−</button>
      <input type="number" min="0" value={qty} onChange={e => onChange(Math.max(0, Number(e.target.value) || 0))} />
      <button type="button" onClick={() => onChange(qty + step)} aria-label="Plus">+</button>
    </div>
  );

  // Pictogrammes par famille (JF, 8 nov. 2026 : « pas de photos, c'est pas clair ») ; photo réelle quand l'article en a une (bornes).
  const PICTO = {
    entree: <><rect x="5" y="3" width="14" height="18" rx="2"/><path d="M9 7h6M9 11h6M9 15h3"/></>,
    travaux: <><path d="M14.7 6.3a4 4 0 0 0-5.4 5.4L3 18l3 3 6.3-6.3a4 4 0 0 0 5.4-5.4l-2.5 2.5-2.5-2.5z"/></>,
    frais: <><path d="M6 3h12v18l-3-2-3 2-3-2-3 2z"/><path d="M9 8h6M9 12h6"/></>,
    borne: <><rect x="6" y="3" width="9" height="18" rx="2"/><path d="M15 8h2a2 2 0 0 1 2 2v5a1.5 1.5 0 0 0 3 0V9l-2-2"/><path d="M10.5 8l-2 4h3l-2 4"/></>,
    materiel: <><path d="M3 7l9-4 9 4-9 4z"/><path d="M3 7v10l9 4 9-4V7"/><path d="M12 11v10"/></>,
    solaire: <><rect x="3" y="6" width="18" height="11" rx="1"/><path d="M3 11.5h18M9 6v11M15 6v11"/></>,
    defaut: <><path d="M13 2L4 14h7l-1 8 9-12h-7z"/></>
  };
  const Visuel = ({ a }) => {
    const img = a.image_url || (a.famille === "borne" && window.ParcoursRE && window.ParcoursRE.imageBorne ? window.ParcoursRE.imageBorne(a) : null);
    if (img) return <img className="re-tile-img" src={img} alt="" loading="lazy" />;
    return <div className={`re-tile-ph f-${a.famille}`} aria-hidden="true"><svg width="40" height="40" viewBox="0 0 24 24" fill="none" stroke="currentColor" strokeWidth="1.6" strokeLinecap="round" strokeLinejoin="round">{PICTO[a.famille] || PICTO.defaut}</svg><span>{a.famille_label || ""}</span></div>;
  };

  const Tile = ({ a, qty, onChange }) => (
    <div className={`re-tile ${qty > 0 ? "on" : ""}`} onClick={() => onChange(qty > 0 ? 0 : 1)} title={a.description || a.nom}>
      <Visuel a={a} />
      <div className="re-tile-body">
        <div className="re-tile-name">{a.nom}</div>
        <div className="re-tile-meta"><span className="re-tile-price">{a.prix ? fmt(a.prix) : "Montant manuel"}</span><span className="re-tile-fam">{a.famille_label}</span></div>
      </div>
      {qty > 0 ? <QtyStepper qty={qty} onChange={onChange} /> : <div className="re-tile-add">Ajouter</div>}
    </div>
  );

  /** Montant tapé avec un point OU une virgule : même résultat (JF, 8 nov. 2026). Espaces et « $ » ignorés ; le dernier
   *  séparateur est la décimale (« 1 234,56 », « 1234.56 », « 1.234,56 » → 1234,56). null si vide ou illisible. */
  function lireMontant(brut) {
    let t = String(brut == null ? "" : brut).replace(/[\s\u00a0\u202f$]/g, "");
    if (!t) return null;
    const neg = t.startsWith("-"); t = t.replace(/^[-+]/, "");
    const k = Math.max(t.lastIndexOf(","), t.lastIndexOf("."));
    const n = k >= 0 ? parseFloat(t.slice(0, k).replace(/[.,]/g, "") + "." + t.slice(k + 1).replace(/[.,]/g, "")) : parseFloat(t);
    return isFinite(n) ? Math.round((neg ? -n : n) * 100) / 100 : null;
  }
  window.RE_lireMontant = lireMontant;
  const affMontant = (v) => (v == null || v === "" ? "" : String(v).replace(".", ","));
  function PrixInput({ value, onChange, ...rest }) {
    const [t, setT] = useState(affMontant(value));
    const edite = useRef(false);
    useEffect(() => { if (!edite.current) setT(affMontant(value)); }, [value]);
    return <input {...rest} type="text" inputMode="decimal" value={t}
      onFocus={() => { edite.current = true; }}
      onBlur={() => { edite.current = false; const v = lireMontant(t); setT(affMontant(v)); }}
      onChange={e => { const s = e.target.value; setT(s); if (!s.trim()) onChange(null); else { const v = lireMontant(s); if (v != null) onChange(v); } }} />;
  }

  const Search = ({ value, onChange, placeholder }) => (
    <input className="re-search" type="search" value={value} onChange={e => onChange(e.target.value)} placeholder={placeholder || "Chercher un article (nom, catégorie, SKU)…"} />
  );

  const norm = (s) => (s || "").toString().normalize("NFD").replace(/[̀-ͯ]/g, "").toLowerCase();
  const matches = (a, q) => { const n = norm(q); return !n || norm(`${a.nom} ${a.categorie} ${a.sous_categorie || ""} ${a.sku || ""} ${a.description || ""}`).includes(n); };

  // Sources de lead : mêmes valeurs que les sources des contacts GHL (landing pages, mPower, organique, réseaux, Google, site).
  // mPower (Toronto) : seul distributeur canadien du Tesla Powerwall et de ses accessoires ; panneaux solaires Tesla attendus en 2027.
  const SOURCES = [
    { id: "landing-powerwall", label: "Landing Powerwall" },
    { id: "landing-solaire", label: "Landing solaire" },
    { id: "landing-borne", label: "Landing borne VÉ" },
    { id: "landing-sigenergy", label: "Landing Sigenergy" },
    { id: "landing-fox", label: "Landing Fox ESS" },
    { id: "landing-volthium", label: "Landing Volthium" },
    { id: "formulaire-site", label: "Formulaire du site web" },
    { id: "mpower", label: "mPower (référence du distributeur Tesla)" },
    { id: "reference", label: "Référence (organique)" },
    { id: "appel-direct", label: "Appel direct" },
    { id: "courriel", label: "Courriel" },
    { id: "facebook", label: "Facebook" },
    { id: "instagram", label: "Instagram" },
    { id: "google", label: "Google" },
    { id: "site-web", label: "Site web (direct)" },
    { id: "autre", label: "Autre" }
  ];
  const SOURCE_IDS = new Set(SOURCES.map(s => s.id));
  /** Source brute d'un lead (GHL : « Landing Powerwall », « courriel », « Aircall », « Facebook Ads »…) → id de SOURCES ; "" si vide.
   *  Mots-clés par ordre de priorité ; les mots courts (fb, ig, ev, vé, lp…) ne comptent que comme mot entier. */
  function normaliserSource(brut) {
    const t = (brut == null ? "" : String(brut)).trim();
    if (!t) return "";
    if (SOURCE_IDS.has(t)) return t;
    const n = norm(t), mots = n.split(/[^a-z0-9]+/).filter(Boolean);
    const a = (...cles) => cles.some(k => k.length <= 3 ? mots.includes(k) : n.includes(k));
    if (a("mpower")) return "mpower";
    if (a("aircall", "appel", "telephone", "phone", "call")) return "appel-direct";
    if (a("courriel", "email", "e-mail", "mail", "outlook")) return "courriel";
    if (a("facebook", "fb", "meta", "lead ad")) return "facebook";
    if (a("instagram", "ig")) return "instagram";
    if (a("google", "gads", "adwords", "gmb", "fiche", "maps")) return "google";
    if (a("reference", "referral", "parrain", "bouche")) return "reference";
    if (a("sigenergy", "sigen")) return "landing-sigenergy";
    if (a("fox", "foxess")) return "landing-fox";
    if (a("volthium", "luxpower")) return "landing-volthium";
    if (a("raycom-form", "formulaire du site", "form site")) return "formulaire-site";
    if (a("borne", "recharge", "chargeur", "ev", "ve")) return "landing-borne";
    if (a("solaire", "solar", "panneau")) return "landing-solaire";
    if (a("powerwall", "batterie", "tesla", "landing", "lp", "formulaire", "form")) return "landing-powerwall";
    if (a("site", "web", "www", "direct", "organique")) return "site-web";
    return "autre";
  }
  window.RE_normaliserSource = normaliserSource;
  /** Source d'un lead d'après la page du formulaire (JF, 8 nov. 2026 : « si ça vient d'une landing, c'est telle landing »). "" si inconnue. */
  function sourceDePage(url) {
    let h = ""; try { h = new URL(String(url || "")).hostname.toLowerCase(); } catch (e) { return ""; }
    const sd = h.split(".")[0];
    if (/^(powerwall\d*|batterie)$/.test(sd)) return "landing-powerwall";
    if (/^(solaire\d*|projet-solaire)$/.test(sd)) return "landing-solaire";
    if (sd === "recharge") return "landing-borne";
    if (sd === "sigenergy") return "landing-sigenergy";
    if (sd === "fox") return "landing-fox";
    if (sd === "volthium") return "landing-volthium";
    if (h === "raycom-form.pages.dev") return "formulaire-site";
    if (/(^|\.)raycomelectrique\.com$/.test(h)) return "site-web";
    return "";
  }
  window.RE_sourceDePage = sourceDePage;
  // Types de bâtiment et tarif Hydro-Québec qui s'applique normalement (Tarifs d'électricité HQ, 2026).
  const BATIMENTS = [
    { id: "residentiel_unifam", label: "Résidentiel · tarif D (ou Flex D)", hq: "D" },
    { id: "commercial", label: "Commercial · tarif G (moins de 65 kW) ou M (50 kW et plus)", hq: "G" },
    { id: "industriel", label: "Industriel · tarif M (moyenne puissance) ou L (5 MW et plus)", hq: "M" },
    { id: "multilog", label: "Multilogement · tarif DM (compteur commun) ou D par logement", hq: "DM" },
    { id: "agricole", label: "Agricole · tarif D (exploitation agricole)", hq: "D" },
    { id: "garage", label: "Garage ou bâtiment détaché · tarif D (usage domestique) ou G (commercial)", hq: "D" }
  ];
  window.RE_SOURCES = SOURCES; window.RE_BATIMENTS = BATIMENTS;

  // ───────────────────────── Étape 1 : client ─────────────────────────
  const telKey = (s) => (s || "").replace(/\D/g, "").slice(-10);
  function InsightsClient({ c, onSuggerer }) {
    const [ins, setIns] = useState(null);
    useEffect(() => {
      const keys = [telKey(c.phone), (c.email || "").trim().toLowerCase()].filter(Boolean);
      if (!keys.length || !window.RAYCAST_SUPABASE) { setIns(null); return; }
      let alive = true;
      // Une requête par téléphone ou courriel complet, pas une par touche frappée.
      const t = setTimeout(() => {
        let q;
        try { q = window.RAYCAST_SUPABASE.from("client_insights").select("*").in("client_key", keys).order("derniere_interaction", { ascending: false }).limit(1); } catch (_) { return; }
        Promise.resolve(q)
          .then(({ data }) => { if (alive) setIns(data && data[0] ? data[0] : null); })
          .catch(() => { if (alive) setIns(null); });
      }, 400);
      return () => { alive = false; clearTimeout(t); };
    }, [c.phone, c.email]);
    if (!ins) return null;
    const s = ins.suggestion || {};
    const libObj = { batterie: "batterie de secours", solaire: "solaire", solaire_batterie: "solaire + batterie", borne: "borne de recharge", travaux: "travaux électriques" }[s.objectif] || null;
    return (
      <div className="re-insight">
        <div className="re-insight-head"><b>Ce que le client a dit</b><span className="re-muted">{ins.nb_interactions} interaction{ins.nb_interactions > 1 ? "s" : ""}{ins.derniere_interaction ? ` · dernière le ${new Date(ins.derniere_interaction).toLocaleDateString("fr-CA")}` : ""}</span></div>
        <p>{ins.synthese || "Aucune synthèse disponible."}</p>
        {libObj && <div className="re-insight-sugg"><span>Suggestion : <b>{libObj}</b>{s.marque ? `, ${s.marque}` : ""}{s.nb ? `, ${s.nb} module${s.nb > 1 ? "s" : ""}` : ""}{s.secours ? `, secours ${s.secours}` : ""}{s.nb_panneaux ? `, ${s.nb_panneaux} panneaux` : ""}{s.budget ? ` · budget évoqué ${window.CALC_RE.fmtCAD(s.budget, 0)}` : ""}{ins.confiance != null ? ` · confiance ${Math.round(ins.confiance * 100)} %` : ""}</span><button className="re-btn small primary" onClick={() => onSuggerer(s)}>Suggérer le système</button></div>}
        {Array.isArray(s.objections) && s.objections.length > 0 && <div className="re-muted" style={{ fontSize: 12 }}>Objections : {s.objections.join(" · ")}</div>}
      </div>
    );
  }

  function StepClient({ state, setState, onNext }) {
    const c = state.client || {};
    const up = (patch) => setState({ ...state, client: { ...c, ...patch } });
    const [results, setResults] = useState([]);
    useEffect(() => {
      const q = (c.name || "").trim();
      if (q.length < 2 || c.client_id || !window.RaycastDB || !window.RaycastDB.listClients) { setResults([]); return; }
      let alive = true;
      const t = setTimeout(async () => {
        try { const d = await window.RaycastDB.listClients({ search: q, limit: 6 }); if (alive) setResults(d || []); }
        catch (_) { if (alive) setResults([]); }
      }, 250);
      return () => { alive = false; clearTimeout(t); };
    }, [c.name, c.client_id]);
    const pick = (cl) => { setResults([]); up({ client_id: cl.id, name: cl.name || "", phone: cl.phone || "", email: cl.email || "", address_full: cl.address_full || [cl.address_civic, cl.address_street, cl.address_city, cl.address_postal].filter(Boolean).join(", "), address_civic: cl.address_civic || "", address_street: cl.address_street || "", address_city: cl.address_city || "", address_postal: cl.address_postal || "", lat: cl.lat || null, lng: cl.lng || null, place_id: cl.place_id || null, source: cl.source || c.source }); };
    const ok = (c.name || "").trim().length >= 2;
    const adresseTexte = c.address_full || [c.address_civic, c.address_street, c.address_city, c.address_postal].filter(Boolean).join(", ");
    // Adresse choisie dans Google : champs décomposés + coordonnées, puis irradiance automatique (NASA POWER) si elle n'a pas été fixée à la main.
    const choisirAdresse = async (f) => {
      setState(st => ({ ...st, client: { ...(st.client || {}), ...f } }));
      if (f.lat && f.lng && window.GeoRE && !(state.solaire && state.solaire.irradiance_source === "manuel")) {
        try { const r = await window.GeoRE.irradiance(f.lat, f.lng); if (r && r.kwh_m2_an) setState(st => ({ ...st, solaire: { ...(st.solaire || {}), irradiance: r.kwh_m2_an, irradiance_source: "adresse", irradiance_mensuel: r.mensuel } })); }
        catch (e) { /* irradiance par défaut conservée */ }
      }
    };
    // Adresse déjà écrite (soumission rouverte, client importé, fiche) : Raycast la résout tout seul, comme si on avait choisi la suggestion Google,
    // sauf pendant la frappe (le menu Google fait alors le travail). État affiché à la place des deux vues en attendant.
    const [geoEtat, setGeoEtat] = useState(null);
    const resoluRef = useRef("");
    const resoudre = async (t) => {
      if (!window.GeoRE || !window.GeoRE.resoudreAdresse || resoluRef.current === t) return;
      resoluRef.current = t; setGeoEtat("recherche");
      try { const g = await window.GeoRE.resoudreAdresse(t, { ville: c.address_city || null }); await choisirAdresse(g); setGeoEtat(null); }
      catch (e) { setGeoEtat("introuvable"); }
    };
    useEffect(() => {
      const t = (adresseTexte || "").trim();
      if (c.lat || t.length < 8 || !/\d/.test(t)) { if (!c.lat) setGeoEtat(null); return; }
      const el = document.activeElement;
      if (el && el.closest && el.closest(".re-adresse")) return;
      const id = setTimeout(() => resoudre(t), 250);
      return () => clearTimeout(id);
    }, [adresseTexte, c.lat]); // eslint-disable-line
    // Source du lead : la chaîne brute venue de GHL (carte du pipeline, fiche client, client choisi) est gardée dans ghl_source
    // et ramenée à une valeur de la liste ; un choix fait à la main dans la liste n'est jamais écrasé.
    const sourceAppliquee = useRef(null);
    useEffect(() => {
      const src = (c.source || "").trim();
      if (src && !SOURCE_IDS.has(src)) { sourceAppliquee.current = c.source; up({ ghl_source: c.source, source: normaliserSource(src) }); }
      else if (!src && c.ghl_source && sourceAppliquee.current !== c.ghl_source) { sourceAppliquee.current = c.ghl_source; up({ source: normaliserSource(c.ghl_source) }); }
    }, [c.source, c.ghl_source]); // eslint-disable-line
    return (
      <div className="re-panel">
        <h2>Pour qui est cette soumission ?</h2>
        <p className="re-sub">Tape le nom : les clients déjà connus de Raycast remontent. Les champs vides sont acceptés, le devis QuickBooks les demandera au moment de finaliser.</p>
        <div className="re-grid2">
          <Field label="Nom complet" span>
            <div className="re-typeahead">
              <input value={c.name || ""} onChange={e => up({ name: e.target.value, client_id: null })} placeholder="Prénom Nom ou entreprise" autoFocus />
              {results.length > 0 && (
                <div className="re-typeahead-list">
                  {results.map(r => <div key={r.id} className="re-typeahead-item" onClick={() => pick(r)}><b>{r.name}</b><span>{[r.address_city, r.phone].filter(Boolean).join(" · ")}</span></div>)}
                </div>
              )}
            </div>
          </Field>
          <Field label="Téléphone"><input value={c.phone || ""} onChange={e => up({ phone: e.target.value })} placeholder="450 000-0000" /></Field>
          <Field label="Courriel"><input type="email" value={c.email || ""} onChange={e => up({ email: e.target.value })} placeholder="client@exemple.com" /></Field>
          <Field label="Adresse" span hint={c.lat ? `Coordonnées ${Number(c.lat).toFixed(5)}, ${Number(c.lng).toFixed(5)}${c.address_city ? " · " + c.address_city : ""}` : "Une seule ligne : Google Maps propose l'adresse, Raycast remplit ville, code postal, coordonnées, Street View et irradiance."}>
            {window.GeoRE
              ? <window.GeoRE.AdresseInput value={adresseTexte} onChange={(v) => up({ address_full: v, lat: null, lng: null, place_id: null })} onPick={choisirAdresse} onBlur={() => { const t = (c.address_full || "").trim(); if (c.lat || t.length < 8) return; resoluRef.current = ""; resoudre(t); }} />
              : <input value={adresseTexte} onChange={e => up({ address_full: e.target.value })} />}
          </Field>
          {c.lat && c.lng && window.GeoRE
            ? <div className="span"><window.GeoRE.VueAdresse lat={c.lat} lng={c.lng} compact /></div>
            : geoEtat && <div className="span re-vue-adresse compact re-vue-attente"><div className="re-vue-vide">{geoEtat === "recherche" ? "Google cherche la maison…" : "Adresse introuvable par Google : choisis une suggestion dans le champ"}</div><div className="re-vue-vide">Street View et vue satellite dès que l'adresse est reconnue</div></div>}
          <Field label="Type de bâtiment">
            <select value={state.building_type || "residentiel_unifam"} onChange={e => { const b = BATIMENTS.find(x => x.id === e.target.value); setState({ ...state, building_type: e.target.value, client: { ...c, hq_tariff: b ? b.hq : c.hq_tariff } }); }}>
              {BATIMENTS.map(b => <option key={b.id} value={b.id}>{b.label}</option>)}
            </select>
          </Field>
          {/* JF, 8 nov. 2026 : la source n'est plus choisie à la main ; elle vient du lead (page de la landing), de GHL (ex. « Empower »
              entré par Sandra = mPower) ou du courriel, et se corrige au besoin dans la fiche du client. */}
          <Field label="Source du lead" hint={c.ghl_source ? `Automatique · GHL : ${c.ghl_source}` : c.source ? "Automatique · page du formulaire ou fiche du client" : "Se remplit toute seule quand le client vient d'une landing, de GHL ou d'un courriel"}>
            <div className="re-source-auto">{(SOURCES.find(x => x.id === c.source) || {}).label || (c.source ? String(c.source) : "Inconnue pour l'instant")}</div>
          </Field>
        </div>
        <InsightsClient c={c} onSuggerer={(sg) => {
          if (!window.ParcoursRE) return;
          const p = { ...window.ParcoursRE.DEFAUT, ...(state.parcours || {}), objectif: sg.objectif, marque: sg.marque || "tesla", nb: sg.nb || 1, secours: sg.secours || "base", nb_panneaux: sg.nb_panneaux || 12 };
          const cat = window.CatalogueRE._cache();
          const lignes = cat ? window.ParcoursRE.fusionner(state, window.ParcoursRE.composer(p, cat)) : state.lignes;
          setState({ ...state, parcours: p, lignes, mode_systeme: "guide" });
          onNext();
        }} />
        <div className="re-actions"><span />
          <button className="re-btn primary" disabled={!ok} onClick={onNext}>Suivant : le système →</button>
        </div>
      </div>
    );
  }

  // ───────────────────────── Étape 2 : système (presets + tuiles) ─────────────────────────
  function StepSysteme({ state, setState, cat, onNext, onBack, onGuide }) {
    const [fam, setFam] = useState("tesla");
    const [q, setQ] = useState("");
    const familles = window.CatalogueRE.FAMILLES.filter(f => ["tesla", "batterie_mo", "solaire", "fox", "sigenergy", "lux", "borne", "subventions"].includes(f.id));
    const tuiles = useMemo(() => cat.articles.filter(a => q ? matches(a, q) : (a.tuile && a.famille === fam)), [cat, fam, q]);
    const presets = cat.presets;
    return (
      <div className="re-panel">
        <div className="re-panel-head">
          <div><h2>Catalogue complet</h2><p className="re-sub">Un preset coche les bonnes tuiles avec les bonnes quantités. Ajuste ensuite : chaque tuile a son compteur. Prix de référence QuickBooks, hors taxes.</p></div>
          <button className="re-btn small" onClick={onGuide}>← Parcours guidé</button>
        </div>
        <div className="re-presets">
          {presets.map(p => (
            <button key={p.id} className={`re-preset ${state.preset_id === p.id ? "on" : ""}`} onClick={() => applyPreset(state, setState, p)} title={p.description || ""}>
              <b>{p.nom}</b><span>{p.lignes.length} lignes</span>
            </button>
          ))}
          {presets.length === 0 && <span className="re-muted">Aucun preset actif.</span>}
        </div>
        <div className="re-toolbar">
          <div className="re-chips">
            {familles.map(f => <button key={f.id} className={`re-chip ${fam === f.id && !q ? "on" : ""}`} onClick={() => { setFam(f.id); setQ(""); }}>{f.label}</button>)}
          </div>
          <Search value={q} onChange={setQ} />
        </div>
        <div className="re-tiles">
          {tuiles.map(a => <Tile key={a.id} a={a} qty={qtyOf(state, a.id)} onChange={(n) => setQty(state, setState, a.id, n)} />)}
          {tuiles.length === 0 && <div className="re-muted">Rien ne correspond.</div>}
        </div>
        <div className="re-actions">
          <button className="re-btn" onClick={onBack}>← Client</button>
          <button className="re-btn primary" disabled={!(state.lignes || []).length} onClick={onNext}>Suivant →</button>
        </div>
      </div>
    );
  }

  // ───────────────────────── Charges à secourir en panne (étape Système, dès qu'il y a une batterie) ─────────────────────────
  // JF, 6 nov. 2026 : le vendeur coche les charges connues que le client veut garder ; l'autonomie se recalcule.
  // Sauvegardé dans la soumission : state.charges_secours = { choix: { id: quantité } } (une ancienne clé « saison » est ignorée).
  // JF, 6 nov. 2026 (2e passe) : une seule valeur par charge ; à gauche le kit de charges critiques de base, à droite les grosses charges.
  // Ne touche JAMAIS aux lignes : le prix reste identique (valeurs et calcul dans calc-re.jsx, CHARGES_SECOURS).
  const fmtKwh = (n) => (Number(n) || 0).toLocaleString("fr-CA", { minimumFractionDigits: 0, maximumFractionDigits: 1 });

  /** Avertissement « secours de base Tesla » : plus de charges cochées que de circuits possibles dans la Gateway 3.
   *  Utilise window.ParcoursRE.capaciteSecoursGateway(nbPowerwall) quand elle existe ; sinon, rien (aucune erreur). */
  function alerteGateway(state, calc, a) {
    try {
      const f = window.ParcoursRE && window.ParcoursRE.capaciteSecoursGateway;
      if (typeof f !== "function" || !a) return null;
      const L = calc.lignes.filter(l => l.qty > 0 && l.article);
      const nbPw = L.filter(l => l.article.est_batterie && /Tesla|Powerwall/i.test(l.nom) && !/expansion/i.test(l.nom)).reduce((s, l) => s + l.qty, 0);
      if (!nbPw) return null;
      const horsBase = L.some(l => /charges critiques|section de secours|backup partiel|embase de compteur combinée|Raccordement source de secours|maison complète/i.test(l.nom));
      if (horsBase || ((state.parcours || {}).secours && state.parcours.secours !== "base")) return null;
      const cap = f(nbPw, { nb_gateways: (state.parcours || {}).nb_gateways }) || {};
      const n120 = a.charges.filter(c => !c.v240).reduce((s, c) => s + c.qty, 0);
      const n240 = a.charges.filter(c => c.v240).reduce((s, c) => s + c.qty, 0);
      // Un circuit 240 V prend deux positions (bipolaire) ; un 120 V, une position.
      const positions = cap.positions_libres != null ? cap.positions_libres : cap.circuits_120_max;
      const trop = [];
      if (positions != null && n120 + 2 * n240 > positions) trop.push(`${n120 + 2 * n240} positions de disjoncteur pour ${positions} libres (${n120} circuit${n120 > 1 ? "s" : ""} 120 V et ${n240} en 240 V)`);
      else if (cap.circuits_240_max != null && n240 > cap.circuits_240_max) trop.push(`${n240} circuits 240 V pour ${cap.circuits_240_max} possibles`);
      if (!trop.length) return null;
      return `Secours de base Tesla : ${trop[0]} dans la Gateway 3 (${nbPw} Powerwall). Prévoir un panneau de charges critiques ou le secours de toute la maison, ou retirer des charges.`;
    } catch (e) { console.warn("[charges] capacité de la Gateway illisible :", e && e.message); return null; }
  }

  /** Powerwall 3 du devis (une batterie d'expansion ne compte pas : pas de disjoncteur dans la Gateway). */
  const nbPowerwallDe = (calc) => calc.lignes.filter(l => l.qty > 0 && l.article && l.article.est_batterie && /Tesla|Powerwall/i.test(l.nom) && !/expansion/i.test(l.nom)).reduce((s, l) => s + l.qty, 0);

  /** Circuits du kit de base coché, et s'il tient dans la Gateway 3 (Tesla) et dans un panneau de charges critiques de 60 A. */
  function texteKitBase(state, calc, a) {
    const R = window.CALC_RE;
    const base = a.charges.filter(c => c.base);
    if (!base.length) return "Aucune charge du kit de base cochée.";
    const k = R.circuitsDe(base);
    const quoi = `${k.circuits} circuit${k.circuits > 1 ? "s" : ""}${k.n240 ? ` (${k.n120} en 120 V, ${k.n240} en 240 V)` : ""}, ${k.positions} position${k.positions > 1 ? "s" : ""} de disjoncteur`;
    const morceaux = [];
    try {
      const f = window.ParcoursRE && window.ParcoursRE.capaciteSecoursGateway;
      const nbPw = nbPowerwallDe(calc);
      if (nbPw > 0 && typeof f === "function") {
        const cap = f(nbPw, { nb_gateways: (state.parcours || {}).nb_gateways }) || {};
        const libres = cap.positions_libres != null ? cap.positions_libres : cap.circuits_120_max;
        if (libres != null) morceaux.push(k.positions <= libres ? `tient dans la Gateway 3 (${libres} positions libres avec ${nbPw} Powerwall)` : `dépasse la Gateway 3 (${libres} positions libres avec ${nbPw} Powerwall)`);
      }
    } catch (e) { console.warn("[charges] capacité de la Gateway illisible :", e && e.message); }
    const p60 = R.PANNEAU_60A || { emplacements: 12 };
    morceaux.push(k.positions <= p60.emplacements ? `tient dans un panneau de 60 A (${p60.emplacements} emplacements)` : `dépasse un panneau de 60 A (${p60.emplacements} emplacements) : prévoir le panneau de 100 A`);
    return `Kit de base coché : ${quoi}. ${morceaux.join(" ; ").replace(/^./, m => m.toUpperCase())}.`;
  }

  // Icônes des charges (traits simples, 24 × 24, couleur du texte).
  const ICONE_CHARGE = {
    frigo: <><rect x="6" y="2.5" width="12" height="19" rx="2" /><path d="M6 10h12M9 6v2M9 13v3" /></>,
    flocon: <path d="M12 2.5v19M4 7l16 10M20 7 4 17M9.5 4 12 6.5 14.5 4M9.5 20l2.5-2.5 2.5 2.5" />,
    wifi: <><path d="M2.5 9a14 14 0 0 1 19 0M5.5 12.5a9.5 9.5 0 0 1 13 0M8.5 16a5 5 0 0 1 7 0" /><circle cx="12" cy="19.5" r="1" /></>,
    tele: <><rect x="2.5" y="4" width="19" height="13" rx="2" /><path d="M8 21h8M12 17v4" /></>,
    ampoule: <><path d="M9 18h6M10 21h4M12 3a6 6 0 0 0-3.5 10.9c.6.5 1 1.2 1 2.1h5c0-.9.4-1.6 1-2.1A6 6 0 0 0 12 3Z" /></>,
    prise: <><rect x="4" y="3" width="16" height="18" rx="3" /><path d="M9.5 8.5v3M14.5 8.5v3M12 15v1.5" /></>,
    pompe: <><path d="M12 3c3 4 5 6.6 5 9.5a5 5 0 0 1-10 0C7 9.6 9 7 12 3Z" /><path d="M10 13.5a2 2 0 0 0 2 2" /></>,
    coeur: <path d="M12 20s-7.5-4.6-7.5-10A4.3 4.3 0 0 1 12 7.4 4.3 4.3 0 0 1 19.5 10c0 5.4-7.5 10-7.5 10ZM7.5 12h2.5l1.2-2 1.6 4 1.2-2H17" />,
    eauchaude: <><rect x="6" y="3" width="12" height="18" rx="5" /><path d="M10 9c1-1 1 1 2 0s1 1 2 0M12 14v3" /></>,
    radiateur: <><rect x="3" y="7" width="18" height="11" rx="2" /><path d="M7 7v11M11 7v11M15 7v11M5 18v2M19 18v2" /></>,
    ventilo: <><circle cx="12" cy="12" r="9" /><circle cx="12" cy="12" r="1.5" /><path d="M12 10.5c0-3 1-5 3-5s1.5 4-3 5M13.5 12c3 0 5 1 5 3s-4 1.5-5-3M10.5 12.8c-1.5 2.6-3.4 3.8-5 2.8s.4-4.4 5-2.8" /></>,
    cuisiniere: <><rect x="4" y="3" width="16" height="18" rx="2" /><path d="M4 8h16M8 5.5h.01M12 5.5h.01M16 5.5h.01" /><rect x="7.5" y="11" width="9" height="7" rx="1" /></>,
    linge: <><rect x="4" y="2.5" width="16" height="19" rx="2" /><circle cx="12" cy="13" r="5" /><path d="M7.5 6h3" /></>,
    vaisselle: <><rect x="4" y="2.5" width="16" height="19" rx="2" /><path d="M4 7h16M8 4.8h4M8 12h8M8 16h8" /></>,
    micro: <><rect x="2.5" y="5" width="19" height="14" rx="2" /><rect x="5.5" y="8" width="10" height="8" rx="1" /><path d="M18.5 9v.01M18.5 12v.01" /></>,
    auto: <><path d="M5 16V11l2-5h10l2 5v5H5Z" /><path d="M5 11h14M5 16v2.5M19 16v2.5" /><circle cx="8.5" cy="13.5" r=".8" /><circle cx="15.5" cy="13.5" r=".8" /></>,
    vagues: <path d="M2.5 9c2 0 2-1.5 4-1.5s2 1.5 4 1.5 2-1.5 4-1.5 2 1.5 4 1.5 2-1.5 3-1.5M2.5 14c2 0 2-1.5 4-1.5s2 1.5 4 1.5 2-1.5 4-1.5 2 1.5 4 1.5 2-1.5 3-1.5M2.5 19c2 0 2-1.5 4-1.5s2 1.5 4 1.5 2-1.5 4-1.5 2 1.5 4 1.5 2-1.5 3-1.5" />,
    ordi: <><rect x="3" y="4" width="18" height="12" rx="1.5" /><path d="M2 20h20M9 16v4M15 16v4" /></>
  };
  const ICONE_DE = { refrigerateur: "frigo", congelateur: "flocon", internet: "wifi", tele: "tele", eclairage: "ampoule", comptoir: "prise",
    puisard: "pompe", puits: "pompe", medical: "coeur", chauffe_eau: "eauchaude", chauffage_maison: "radiateur", plinthes_piece: "radiateur",
    thermopompe: "ventilo", fournaise: "ventilo", cuisiniere: "cuisiniere", secheuse: "linge", laveuse: "linge", lave_vaisselle: "vaisselle",
    micro_ondes: "micro", borne_ve: "auto", piscine_spa: "vagues", prises: "prise", bureau: "ordi" };
  const IconeCharge = ({ id }) => (
    <svg className="re-charge-ico" viewBox="0 0 24 24" width="18" height="18" fill="none" stroke="currentColor" strokeWidth="1.7" strokeLinecap="round" strokeLinejoin="round" aria-hidden="true">{ICONE_CHARGE[ICONE_DE[id]] || ICONE_CHARGE.prise}</svg>
  );

  function ChargesSecours({ state, setState, calc }) {
    const R = window.CALC_RE;
    const a = calc.autonomie;
    if (!a || !R.CHARGES_SECOURS || !a.duree) return null;
    const cs = state.charges_secours || {};
    const choix = cs.choix && typeof cs.choix === "object" ? cs.choix : R.choixParDefaut();
    // Une ancienne valeur `saison` est laissée de côté : on n'écrit plus que les charges cochées.
    const ecrire = (patch) => setState({ ...state, charges_secours: { choix, ...patch } });
    const setQ = (id, q) => ecrire({ choix: { ...choix, [id]: Math.max(0, Math.min(20, q)) } });
    const r = a.duree;
    const alerteGw = alerteGateway(state, calc, a);
    const ligne = (c) => {
      const q = Math.max(0, Math.round(Number(choix[c.id]) || 0));
      return (
        <div key={c.id} className={`re-charge ${q > 0 ? "on" : ""}`} data-charge={c.id}>
          <label className="re-charge-nom">
            <input type="checkbox" checked={q > 0} onChange={e => setQ(c.id, e.target.checked ? 1 : 0)} />
            <IconeCharge id={c.id} />
            <span>{c.fr}{c.v240 && <em className="re-charge-240">240 V</em>}</span>
          </label>
          {c.quantite && q > 0 && <span className="re-charge-qty"><QtyStepper qty={q} onChange={(n) => setQ(c.id, n)} /><span className="re-muted">{c.id === "eclairage" ? "circuit" : "pièce"}{q > 1 ? "s" : ""}</span></span>}
          <span className="re-charge-val">{fmtKwh(c.kwh_jour * Math.max(q, 1))} kWh/j · {fmtKwh(c.pointe_kw * Math.max(q, 1))} kW</span>
        </div>
      );
    };
    return (
      <div className="re-panel re-charges" data-testid="charges-secours">
        <div className="re-panel-head">
          <div><h2>Charges à garder en panne</h2><p className="re-sub">Coche ce que le client veut alimenter pendant une panne. Ça change seulement l'estimation d'autonomie, jamais le prix.</p></div>
        </div>
        <div className="re-charges-res">
          <div className="re-charges-auto"><span>Autonomie estimée</span><b data-testid="autonomie-estimee">{r.libelle_fr}</b>{a.avec_solaire && <span className="re-muted">batterie seule : <span data-testid="autonomie-batterie-seule">{a.batterie_seule.libelle_fr}</span></span>}</div>
          <div className="re-charges-faits">
            <span>Charges cochées : <b>{fmtKwh(r.charge_kwh)} kWh/jour</b>{r.pertes_kwh > 0 ? <> · avec pertes et marge d'usage : <b>{fmtKwh(r.charge_reelle_kwh)} kWh/jour</b></> : null}</span>
            <span>Batteries : <b>{fmtKwh(a.kwh_utilisable)} kWh utilisables</b></span>
            {a.avec_solaire && <span>Solaire ({fmtKwh(a.kw_solaire)} kW) : <b>≈ {fmtKwh(r.solaire_kwh)} kWh/jour</b>, journée moyenne{a.source_solaire === "studio" ? " (production du studio solaire)" : ""}</span>}
            <span>Pointe : <b>{fmtKwh(a.pointe_kw)} kW</b> sur {fmtKwh(a.kw_continu)} kW en continu</span>
          </div>
        </div>
        {a.depasse_pointe && <div className="re-alert error" data-testid="alerte-pointe"><b>Puissance dépassée.</b> La pointe des charges cochées ({fmtKwh(a.pointe_kw)} kW) dépasse la puissance continue du système ({fmtKwh(a.kw_continu)} kW). Si tout démarre en même temps, le système coupe en surcharge : retirer une grosse charge, la délester, ou ajouter de la puissance (un Powerwall 3 de plus ajoute 11,5 kW).</div>}
        {alerteGw && <div className="re-alert" data-testid="alerte-gateway">{alerteGw}</div>}
        <div className="re-charges-btns">
          <button type="button" className="re-btn small" onClick={() => ecrire({ choix: R.choixParDefaut() })}>Kit de base seulement</button>
          <button type="button" className="re-btn small" onClick={() => ecrire({ choix: {} })}>Tout décocher</button>
        </div>
        <div className="re-charges-grille">
          <div className="re-charges-bloc re-charges-base" data-testid="kit-base">
            <div className="re-charges-titre">Kit de charges critiques de base</div>
            <p className="re-charges-aide">Petits circuits 120 V, pour la Gateway 3 ou un petit panneau de 60 A.</p>
            {R.CHARGES_SECOURS.filter(c => c.base && c.critique).map(ligne)}
            <div className="re-charges-sous">Selon la maison</div>
            {R.CHARGES_SECOURS.filter(c => c.base && !c.critique).map(ligne)}
            <p className="re-charges-circuits" data-testid="kit-circuits">{texteKitBase(state, calc, a)}</p>
          </div>
          <div className="re-charges-bloc" data-testid="grosses-charges">
            <div className="re-charges-titre">Grosses charges et autres circuits</div>
            <p className="re-charges-aide">À cocher seulement si le client les veut en panne : elles réduisent beaucoup l'autonomie.</p>
            {R.CHARGES_SECOURS.filter(c => !c.base).map(ligne)}
          </div>
        </div>
        <p className="re-field-hint">Estimation pour une batterie pleine au début de la panne, maison unifamiliale de 3 à 4 occupants, appareils récents typiques. Solaire : journée moyenne de panne à Mascouche (≈ 2,5 kWh par kW installé, moyenne annuelle moins une marge pour le mauvais temps) ; un jour sombre ou des panneaux enneigés produisent moins.</p>
      </div>
    );
  }

  /** Étape 2 : parcours guidé (cartes) par défaut, catalogue complet (tuiles) sur demande. */
  function StepSystemeOuParcours(props) {
    const [mode, setMode] = useState(props.state.mode_systeme || "guide");
    const setMode2 = (m) => { setMode(m); props.setState({ ...props.state, mode_systeme: m }); };
    // Charges à garder en panne : sous le système, seulement quand le devis contient une batterie.
    const charges = props.calc && props.calc.autonomie ? <ChargesSecours state={props.state} setState={props.setState} calc={props.calc} /> : null;
    if (mode === "catalogue" || !window.ParcoursRE) return <><StepSysteme {...props} onGuide={() => setMode2("guide")} />{charges}</>;
    const StepParcours = window.ParcoursRE.StepParcours;
    return <><StepParcours {...props} onCatalogue={() => setMode2("catalogue")} />{charges}</>;
  }

  // ───────────────────────── Étape 3 : solaire (capture Aurora) ─────────────────────────
  function lireImage(file, cb) {
    if (!file || (file.type && !/^image\//.test(file.type))) return;
    const img = new Image();
    const url = URL.createObjectURL(file);
    img.onload = () => {
      const max = 1600, k = Math.min(1, max / Math.max(img.width, img.height));
      const cv = document.createElement("canvas"); cv.width = Math.round(img.width * k); cv.height = Math.round(img.height * k);
      cv.getContext("2d").drawImage(img, 0, 0, cv.width, cv.height);
      URL.revokeObjectURL(url);
      cb(cv.toDataURL("image/jpeg", 0.85));
    };
    img.onerror = () => URL.revokeObjectURL(url);
    img.src = url;
  }

  const PANS = ["toit principal", "pan avant", "pan arrière", "pan gauche", "pan droit", "lucarne", "garage", "rallonge", "toit plat", "structure au sol", "cabanon"];
  const ORIENTATIONS = ["sud", "sud-est", "sud-ouest", "est", "ouest", "nord-est", "nord-ouest", "nord"];
  const MAX_PANS = 6;
  const PAN_VIDE = { nom: "", orientation: "", revetement: "", pente: "", nb_panneaux: "" };
  /** Pans de toit : liste (jusqu'à 6), chacun avec son revêtement, sa pente et son orientation ; reprise de l'ancien format (champs simples). */
  function pansDe(s) {
    if (Array.isArray(s.pans_toit) && s.pans_toit.length) return s.pans_toit;
    if (s.pans || s.orientation || s.revetement || s.pente) return [{ ...PAN_VIDE, nom: s.pans || "toit principal", orientation: s.orientation || "", revetement: s.revetement || "", pente: s.pente || "" }];
    return [{ ...PAN_VIDE, nom: "toit principal" }];
  }
  function PansToit({ s, up, totalPanneaux }) {
    const pans = pansDe(s);
    const set = (i, patch) => { const n = pans.map((p, j) => j === i ? { ...p, ...patch } : p); up({ pans_toit: n, pans: n.map(p => p.nom).filter(Boolean).join(", "), orientation: n.map(p => p.orientation).filter(Boolean).join(", "), revetement: n[0].revetement, pente: n[0].pente }); };
    const add = () => pans.length < MAX_PANS && up({ pans_toit: [...pans, { ...PAN_VIDE }] });
    const del = (i) => { const n = pans.filter((_, j) => j !== i); up({ pans_toit: n.length ? n : [{ ...PAN_VIDE, nom: "toit principal" }] }); };
    const repartis = pans.reduce((t, p) => t + (Number(p.nb_panneaux) || 0), 0);
    return (
      <div className="re-pans span">
        <div className="re-pans-head"><b>Pans de toit</b><span>{pans.length} / {MAX_PANS}{totalPanneaux ? ` · ${repartis} de ${totalPanneaux} panneaux répartis` : ""}</span>{pans.length < MAX_PANS && <button className="re-btn small" onClick={add}>+ Ajouter un pan</button>}</div>
        {pans.map((p, i) => (
          <div className="re-pan" key={i}>
            <select value={p.nom} onChange={e => set(i, { nom: e.target.value })}><option value="">pan…</option>{PANS.map(x => <option key={x} value={x}>{x}</option>)}</select>
            <select value={p.orientation} onChange={e => set(i, { orientation: e.target.value })}><option value="">orientation…</option>{ORIENTATIONS.map(x => <option key={x} value={x}>{x}</option>)}</select>
            <select value={p.revetement} onChange={e => set(i, { revetement: e.target.value })}><option value="">revêtement…</option>{REVETEMENTS.map(x => <option key={x} value={x}>{x}</option>)}</select>
            <select value={p.pente} onChange={e => set(i, { pente: e.target.value })}><option value="">pente…</option>{PENTES.map(x => <option key={x} value={x}>{x}</option>)}</select>
            <input type="number" min="0" placeholder="panneaux" value={p.nb_panneaux} onChange={e => set(i, { nb_panneaux: e.target.value })} title="Nombre de panneaux sur ce pan" />
            <button className="re-btn small ghost" onClick={() => del(i)} title="Retirer ce pan">×</button>
          </div>
        ))}
      </div>
    );
  }
  const REVETEMENTS = ["bardeaux d'asphalte", "tôle (acier)", "tôle à joints debout", "membrane (toit plat)", "élastomère", "bardeaux de cèdre", "ardoise ou tuiles", "autre"];
  const PENTES = ["faible (moins de 4/12)", "moyenne (4/12 à 8/12)", "forte (plus de 8/12)", "plat"];

  function StepSolaire({ state, setState, calc, onNext, onBack }) {
    const s = { ...C().DEFAUTS_SOLAIRE, ...(state.solaire || {}) };
    const up = (patch) => setState({ ...state, solaire: { ...s, ...patch } });
    const fileRef = useRef(null);
    useEffect(() => {
      const onPaste = (e) => {
        const item = Array.from(e.clipboardData && e.clipboardData.items || []).find(i => i.type.startsWith("image/"));
        if (item) { e.preventDefault(); lireImage(item.getAsFile(), (d) => up({ aurora_image: d })); }
      };
      document.addEventListener("paste", onPaste);
      return () => document.removeEventListener("paste", onPaste);
    });
    const solaire = calc.kw > 0;
    // Nombre de panneaux : celui du parcours quand il compose le solaire, sinon ce qui est réellement sur la soumission (preset, tuiles).
    const pSol = state.parcours || {};
    const parcoursSolaire = pSol.objectif === "solaire" || pSol.objectif === "solaire_batterie";
    const nbAffiche = parcoursSolaire ? (Number(pSol.nb_panneaux) || 0) : calc.panneaux;
    const fixerPanneaux = (n) => {
      const catNow = window.CatalogueRE && window.CatalogueRE._cache && window.CatalogueRE._cache();
      if (!catNow || !window.ParcoursRE || !window.ParcoursRE.appliquerPanneaux) return;
      const r = window.ParcoursRE.appliquerPanneaux(state, catNow, { nb_panneaux: n });
      setState({ ...state, parcours: r.parcours, lignes: r.lignes, solaire: { ...s, production_source: s.production_source === "google" ? "manuel" : s.production_source } });
    };
    return (
      <div className="re-panel">
        <h2>Données solaires</h2>
        {!solaire && <div className="re-alert">Aucun panneau sur cette soumission : cette étape est facultative. Ajoute des panneaux à l'étape Système si le projet comprend du solaire.</div>}
        <p className="re-sub">Analyse automatique du toit (Google Solar) ou capture d'écran Aurora collée ici (Ctrl+V ou ⌘V), puis les données du toit.</p>
        <div className="re-grid2">
          {window.SolaireDesignRE && <window.SolaireDesignRE state={state} setState={setState} />}
          {window.SolaireStudioBoutonRE && <div className="span"><window.SolaireStudioBoutonRE state={state} setState={setState} toit={s.design_google || null} /></div>}
          <div className="re-dropzone span" onClick={() => fileRef.current && fileRef.current.click()}>
            {s.aurora_image ? <img src={s.aurora_image} alt="Capture Aurora" /> : <div className="re-dropzone-empty"><b>Coller la capture Aurora ici</b><span>Ctrl+V, ou clique pour choisir un fichier</span></div>}
            <input ref={fileRef} type="file" accept="image/*" style={{ display: "none" }} onChange={e => e.target.files[0] && lireImage(e.target.files[0], (d) => up({ aurora_image: d }))} />
            {s.aurora_image && <button className="re-btn small" onClick={(e) => { e.stopPropagation(); up({ aurora_image: null }); }}>Retirer</button>}
          </div>
          <Field label="Irradiance (kWh/m²/an)" hint={s.irradiance_source === "adresse" ? "Calculée automatiquement pour l'adresse du client (NASA POWER). Remplace-la par la valeur Aurora au besoin." : s.irradiance_source === "manuel" ? "Valeur saisie à la main (Aurora)." : "Valeur par défaut Québec ; choisis l'adresse à l'étape Client pour la calculer automatiquement."}>
            <div className="re-inline">
              <input type="number" value={s.irradiance} onChange={e => up({ irradiance: e.target.value, irradiance_source: "manuel" })} />
              {state.client && state.client.lat && window.GeoRE && <button className="re-btn small" title="Recalculer pour l'adresse" onClick={async () => { try { const r = await window.GeoRE.irradiance(state.client.lat, state.client.lng); if (r && r.kwh_m2_an) up({ irradiance: r.kwh_m2_an, irradiance_source: "adresse", irradiance_mensuel: r.mensuel }); } catch (e) { alert("Irradiance indisponible pour cette adresse."); } }}>↻ adresse</button>}
            </div>
          </Field>
          <Field label="Accès solaire (%)"><input type="number" min="0" max="100" value={s.acces_pct} onChange={e => up({ acces_pct: e.target.value })} /></Field>
          <Field label="Nombre de panneaux" hint="Rempli par l'analyse du toit ci-dessus, ou saisi ici. Le devis se recompose (panneaux, structure, pose, arrêt rapide ou optimiseurs).">
            <input type="number" min="0" max="80" value={nbAffiche} onChange={e => fixerPanneaux(Math.max(0, Math.min(80, Number(e.target.value) || 0)))} />
          </Field>
          <PansToit s={s} up={up} totalPanneaux={calc.panneaux} />
          <Field label="Tarif Hydro-Québec ($/kWh)"><input type="number" step="0.00001" value={s.tarif_kwh} onChange={e => up({ tarif_kwh: e.target.value })} /></Field>
          <Field label="Ratio de performance"><input type="number" step="0.01" value={s.ratio_perf} onChange={e => up({ ratio_perf: e.target.value })} /></Field>
        </div>
        {solaire && (
          <div className="re-kpis">
            <div><b>{fmtNum(calc.kw)} kW</b><span>{calc.panneaux} panneaux</span></div>
            <div><b>{fmtInt(calc.production)} kWh/an</b><span>production estimée</span></div>
            <div><b>{fmt0(calc.economiesAn1)}</b><span>économies an 1</span></div>
            <div><b>{calc.retourAns ? `≈ ${fmtNum(calc.retourAns)} ans` : "—"}</b><span>retour après LogisVert</span></div>
          </div>
        )}
        <div className="re-actions">
          <button className="re-btn" onClick={onBack}>← Système</button>
          <button className="re-btn primary" onClick={onNext}>Suivant : Options →</button>
        </div>
      </div>
    );
  }

  // ───────────────────────── Étape 4 : options ─────────────────────────
  // Articles réellement facturés et soumissionnés (worker /raycast/stats-articles), hors équipements du parcours.
  const FAMILLES_PARCOURS = new Set(["tesla", "fox", "sigenergy", "lux", "solaire", "batterie_mo", "subventions"]);
  let statsCache = null, statsInflight = null;
  // Un seul appel par session, et seul un succès est gardé en cache (un échec passager se réessaie à la prochaine visite de l'étape).
  async function chargerStats() {
    if (statsCache) return statsCache;
    if (statsInflight) return statsInflight;
    statsInflight = (async () => {
      try {
        const { data } = await window.RAYCAST_SUPABASE.auth.getSession();
        const token = data && data.session ? data.session.access_token : null;
        if (!token) return { articles: [] };
        const r = await fetch(`${window.CatalogueRE.WORKER_URL}/raycast/stats-articles`, { headers: { Authorization: `Bearer ${token}` } });
        if (!r.ok) return { articles: [] };
        statsCache = await r.json();
        return statsCache;
      } catch (_) { return { articles: [] }; }
      finally { statsInflight = null; }
    })();
    return statsInflight;
  }

  function StepOptions({ state, setState, cat, onNext, onBack }) {
    // JF, 8 nov. 2026 (« trop agressant, trop de choses ») : 8 suggestions claires, ce qui est déjà ajouté en haut,
    // le reste du catalogue caché derrière « Voir tout le catalogue » (familles et recherche).
    const [tout, setTout] = useState(false);
    const [fam, setFam] = useState("entree");
    const [q, setQ] = useState("");
    const [stats, setStats] = useState(statsCache);
    useEffect(() => { let alive = true; chargerStats().then(s => { if (alive) setStats(s); }); return () => { alive = false; }; }, []);
    const familles = window.CatalogueRE.FAMILLES.filter(f => ["entree", "travaux", "frais", "borne", "materiel"].includes(f.id));
    const suggestions = useMemo(() => {
      const compte = new Map(((stats && stats.articles) || []).map(a => [a.qbo_id, a.devis_90j + a.factures_90j * 2 + Math.round(a.devis_365j / 4)]));
      return cat.articles.filter(a => !FAMILLES_PARCOURS.has(a.famille) && compte.get(a.id) > 0 && a.prix > 0 && !/^Capping de tôle/i.test(a.nom || "")).sort((x, y) => compte.get(y.id) - compte.get(x.id)).slice(0, 8);
    }, [cat, stats]);
    // Capping de tôle au pied, une couleur par article (noir, brun, gris, blanc ; créés le 8 nov. 2026) : toujours proposé ici
    const cappings = cat.articles.filter(a => /^RE-CAPPING-/i.test(a.sku || "") || /^Capping de tôle/i.test(a.nom || ""));
    const ajoutes = (state.lignes || []).filter(l => l.qty > 0 && l.src === "manuel").map(l => ({ l, a: cat.byId && cat.byId.get(l.qbo_id) })).filter(x => x.a && !FAMILLES_PARCOURS.has(x.a.famille));
    const liste = q ? cat.articles.filter(a => matches(a, q)).slice(0, 60) : cat.articles.filter(a => a.famille === fam);
    return (
      <div className="re-panel re-options">
        <h2>Options et extras</h2>
        <p className="re-sub">Rien d'obligatoire ici : ajoute seulement ce que le projet demande.</p>
        {ajoutes.length > 0 && (
          <div className="re-options-ajoutes">
            <div className="re-options-titre">Déjà ajouté</div>
            <div className="re-options-puces">{ajoutes.map(({ l, a }) => <span key={a.id} className="re-option-puce">{l.qty > 1 ? `${l.qty} × ` : ""}{a.nom}<button type="button" aria-label={`Retirer ${a.nom}`} onClick={() => setQty(state, setState, a.id, 0)}>×</button></span>)}</div>
          </div>
        )}
        {cappings.length > 0 && (<>
          <div className="re-options-titre">Capping de tôle (cache-fil, au pied)</div>
          <div className="re-tiles re-options-grille">
            {cappings.map(a => <Tile key={a.id} a={a} qty={qtyOf(state, a.id)} onChange={(n) => setQty(state, setState, a.id, n)} />)}
          </div>
        </>)}
        <div className="re-options-titre">Les plus demandés</div>
        <div className="re-tiles re-options-grille">
          {suggestions.map(a => <Tile key={a.id} a={a} qty={qtyOf(state, a.id)} onChange={(n) => setQty(state, setState, a.id, n)} />)}
          {!suggestions.length && <div className="re-muted">{!stats ? "Chargement…" : "Aucune suggestion pour l'instant : utilise le catalogue."}</div>}
        </div>
        {!tout ? (
          <button type="button" className="re-btn re-options-tout" onClick={() => setTout(true)}>Voir tout le catalogue (entrée électrique, travaux, frais, bornes, matériel)</button>
        ) : (
          <div className="re-options-catalogue">
            <div className="re-toolbar">
              <div className="re-chips">{familles.map(f => <button key={f.id} className={`re-chip ${fam === f.id && !q ? "on" : ""}`} onClick={() => { setFam(f.id); setQ(""); }}>{f.label}</button>)}</div>
              <Search value={q} onChange={setQ} />
            </div>
            <div className="re-tiles compact">
              {liste.map(a => <Tile key={a.id} a={a} qty={qtyOf(state, a.id)} onChange={(n) => setQty(state, setState, a.id, n)} />)}
              {!liste.length && <div className="re-muted">Rien ne correspond.</div>}
            </div>
            <button type="button" className="re-link" onClick={() => { setTout(false); setQ(""); }}>Masquer le catalogue</button>
          </div>
        )}
        <div className="re-actions">
          <button className="re-btn" onClick={onBack}>← Retour</button>
          <button className="re-btn primary re-suivant" onClick={onNext}>Suivant : Résumé →</button>
        </div>
      </div>
    );
  }

  /** Résumé : ajouter un article du catalogue (par ex. pour remplacer une ligne retirée ; JF, 8 nov. 2026). */
  function AjoutArticle({ state, setState, cat }) {
    const [q, setQ] = useState("");
    const res = q.trim().length >= 2 ? cat.articles.filter(a => matches(a, q)).slice(0, 8) : [];
    return (
      <div className="re-ajout-article">
        <div className="re-options-titre">Ajouter un article du catalogue</div>
        <Search value={q} onChange={setQ} placeholder="Chercher un article à ajouter (nom, SKU)…" />
        {res.length > 0 && (
          <ul className="re-ajout-liste">
            {res.map(a => { const n = qtyOf(state, a.id); return (
              <li key={a.id}>
                <span className="re-ajout-nom">{a.nom}<small>{a.famille_label}{a.sku ? ` · ${a.sku}` : ""}</small></span>
                <span className="re-ajout-prix">{a.prix ? fmt(a.prix) : "Montant manuel"}</span>
                <button type="button" className="re-btn small primary" onClick={() => { setQty(state, setState, a.id, n + 1); setQ(""); }}>{n > 0 ? `Ajouter (${n} déjà)` : "Ajouter"}</button>
              </li>); })}
          </ul>
        )}
        {q.trim().length >= 2 && !res.length && <p className="re-muted">Aucun article ne correspond.</p>}
      </div>
    );
  }

  // ───────────────────────── Étape 5 : résumé ─────────────────────────
  function StepResume({ state, setState, calc, cat, onBack, onEnvoyer, envoiPossible, onReviser, busy }) {
    const sub = state.subventions || {};
    const upSub = (patch) => setState({ ...state, subventions: { ...sub, ...patch } });
    const upLigne = (qbo_id, patch) => setState({ ...state, lignes: (state.lignes || []).map(l => l.qbo_id === qbo_id ? { ...l, ...patch, src: l.src || "manuel" } : l) });
    const plans = window.CALC_RE.PLANS;
    const fin = calc.financement || {};
    return (
      <div className="re-panel">
        <h2>Résumé de la soumission</h2>
        <p className="re-sub">Quantités et prix unitaires restent modifiables ici. Les prix du catalogue ne bougent pas ; un prix changé ne vaut que pour cette soumission.</p>
        {calc.groupes.map(g => (
          <div key={g.id} className="re-group">
            <div className="re-group-head"><span>{g.label}</span><b>{fmt(g.ht)}</b></div>
            <table className="re-table">
              <tbody>
                {g.lignes.map(l => (
                  <tr key={l.qbo_id}>
                    <td className="nom"><div>{l.nom}</div>{l.description && <div className="desc">{l.description}</div>}</td>
                    <td className="qty"><input type="number" min="0" value={l.qty} onChange={e => upLigne(l.qbo_id, { qty: Number(e.target.value) || 0 })} /></td>
                    <td className="prix"><PrixInput value={l.prix} onChange={v => upLigne(l.qbo_id, { prix: v })} aria-label={`Prix unitaire de ${l.nom}`} /></td>
                    <td className="montant">{fmt(l.montant)}</td>
                    <td className="del"><button onClick={() => setQty(state, setState, l.qbo_id, 0)} title="Supprimer cette ligne" aria-label={`Supprimer ${l.nom}`}>×</button></td>
                  </tr>
                ))}
              </tbody>
            </table>
          </div>
        ))}
        <AjoutArticle state={state} setState={setState} cat={cat} />
        <div className="re-grid2">
          <Field label="Subventions" span>
            <div className="re-checks">
              <label><input type="checkbox" checked={sub.logisvert_admissible !== false} onChange={e => upSub({ logisvert_admissible: e.target.checked })} /> LogisVert (solaire résidentiel) : {fmt0(calc.logisvert)}</label>
              <label><input type="checkbox" checked={sub.renoclimat_admissible !== false} onChange={e => upSub({ renoclimat_admissible: e.target.checked })} /> Rénoclimat (batterie fixe ≥ 5 kWh, résidence principale) : {fmt0(calc.renoclimat)}</label>
            </div>
          </Field>
          <Field label="Autre subvention ($)"><input type="number" value={sub.autres || ""} onChange={e => upSub({ autres: e.target.value })} /></Field>
          <Field label="Libellé"><input value={sub.autres_libelle || ""} onChange={e => upSub({ autres_libelle: e.target.value })} placeholder="Écorecharge, promotion…" /></Field>
          <Field label="Financement mis de l'avant" hint={fin.monthly ? `${fmt(fin.monthly)}/mois${fin.promo_free_months ? ` après ${fin.promo_free_months} mois à 0 $` : ""}${fin.mois ? ` · ${fin.mois} mois` : ""}${fin.taux ? ` · ${(fin.taux).toLocaleString("fr-CA", { minimumFractionDigits: 2 })} %` : ""}` : "Comptant"}>
            <select value={(state.client || {}).financing_plan_id || "fit_promo_3m"} onChange={e => setState({ ...state, client: { ...state.client, financing_plan_id: e.target.value } })}>
              {plans.map(p => <option key={p.id} value={p.id}>{p.label}</option>)}
            </select>
          </Field>
          <Field label="Frais Financeit à la charge de Raycom (interne, jamais au client)" hint="Frais de programme sur le montant financé, selon la fiche de taux du 31 oct. 2026. Aucuns frais de dossier pour le client.">
            <div className="re-checks">
              {(fin.options || []).length
                ? fin.options.map(o => <span key={o.id}>{o.court} : <b>{fmt(o.monthly)}/mois</b> · frais Raycom <b>{fmt(o.frais_marchand)}</b>{o.frais_pct ? ` (${o.frais_pct.toLocaleString("fr-CA", { minimumFractionDigits: 2 })} %)` : ""}</span>)
                : <span className="re-muted">Financeit s'applique à partir de 1 000 $ taxes incluses : comptant seulement.</span>}
            </div>
          </Field>
          <Field label="Note au client (apparaît sur le devis)" span><textarea rows="3" value={state.notes_client || ""} onChange={e => setState({ ...state, notes_client: e.target.value })} placeholder="Dépôt de 1 000 $ à la signature, remboursé si Hydro-Québec refuse… Soumission valide 30 jours." /></Field>
          <Field label="Notes internes (jamais envoyées)" span><textarea rows="2" value={state.notes_internes || ""} onChange={e => setState({ ...state, notes_internes: e.target.value })} /></Field>
        </div>
        {window.PropositionRE && <LangueProposition state={state} setState={setState} />}
        <div className="re-actions">
          <button className="re-btn" onClick={onBack}>← Options</button>
          <div className="re-actions-right">
            {window.PropositionRE && <button className="re-btn" onClick={() => window.PropositionRE.ouvrir(state, calc)}>Aperçu de la proposition</button>}
            {window.SchemaBoutonRE && <window.SchemaBoutonRE state={state} setState={setState} />}
            {/* JF, 8 nov. 2026 : plus de « Sauvegarder » (enregistrement automatique) ni de « Finaliser dans QuickBooks » :
                « Envoyer au client » fait tout (devis QuickBooks, proposition, courriel à relire dans Outlook). */}
            {state.qbo_estimate_id && <button className="re-btn" disabled={busy || !calc.pret || !onReviser} title="Régénère la proposition (dans la langue choisie) et la joint au MÊME devis QuickBooks : aucun nouveau devis, rien n'est envoyé" onClick={() => onReviser(calc)}>Mettre à jour la proposition</button>}
            {onEnvoyer && <button className="re-btn primary" disabled={busy || !calc.pret || !envoiPossible} title={envoiPossible ? "Crée le devis QuickBooks (une seule fois) et prépare le courriel au client dans Outlook ; tu le relis et cliques Envoyer" : "Ajoute le courriel du client pour lui envoyer la proposition"} onClick={onEnvoyer}>Envoyer au client</button>}
          </div>
        </div>
      </div>
    );
  }

  // ───────────────────────── Langue de la proposition (Français | English) ─────────────────────────
  // Enregistrée dans la soumission : state.client.langue_proposition, « fr » ou « en ». Par défaut, la langue de la fiche
  // client si elle en a une, sinon le français (règle dans PropositionRE.langue). Aperçu, PDF et finalisation la suivent.
  function LangueProposition({ state, setState }) {
    const langue = window.PropositionRE.langue ? window.PropositionRE.langue(state) : "fr";
    const choisir = (l) => setState({ ...state, client: { ...(state.client || {}), langue_proposition: l } });
    return (
      <div className="re-langue-prop">
        <span className="re-langue-prop-label">Langue de la proposition</span>
        <div className="re-langue-prop-seg" role="radiogroup" aria-label="Langue de la proposition">
          {[["fr", "Français"], ["en", "English"]].map(([id, nom]) => (
            <button key={id} type="button" role="radio" aria-checked={langue === id} className={langue === id ? "on" : ""} onClick={() => choisir(id)}>{nom}</button>
          ))}
        </div>
      </div>
    );
  }

  // ───────────────────────── Panneau latéral (toujours visible) ─────────────────────────
  function ResumePanel({ calc, state }) {
    const f = calc.financement || {};
    return (
      <aside className="re-side">
        <div className="re-side-card">
          <div className="re-side-title">{state.quote_id || "Nouvelle soumission"}</div>
          <div className="re-side-row"><span>{calc.lignes.length} ligne{calc.lignes.length > 1 ? "s" : ""} · sous-total</span><b>{fmt(calc.ht)}</b></div>
          <div className="re-side-row muted"><span>TPS + TVQ</span><span>{fmt(calc.taxes)}</span></div>
          <div className="re-side-row total"><span>Total taxes incluses</span><b>{fmt(calc.ttc)}</b></div>
          {calc.subventions > 0 && <>
            {calc.logisvert > 0 && <div className="re-side-row green"><span>LogisVert estimé</span><span>− {fmt0(calc.logisvert)}</span></div>}
            {calc.renoclimat > 0 && <div className="re-side-row green"><span>Rénoclimat estimé</span><span>− {fmt0(calc.renoclimat)}</span></div>}
            {calc.autres > 0 && <div className="re-side-row green"><span>{(state.subventions || {}).autres_libelle || "Autre subvention"}</span><span>− {fmt0(calc.autres)}</span></div>}
            <div className="re-side-row net"><span>Investissement net</span><b>{fmt(calc.net)}</b></div>
          </>}
          {f.monthly > 0 && <div className="re-side-row muted"><span>FinanceIT</span><span>{f.promo_free_months ? `0 $ × ${f.promo_free_months} mois, puis ` : ""}{fmt(f.monthly)}/mois</span></div>}
        </div>
        {(calc.kw > 0 || calc.kwh > 0) && (
          <div className="re-side-card">
            {calc.kw > 0 && <div className="re-side-row"><span>Solaire</span><b>{fmtNum(calc.kw)} kW · {calc.panneaux} panneaux</b></div>}
            {calc.kw > 0 && <div className="re-side-row muted"><span>Production</span><span>≈ {fmtInt(calc.production)} kWh/an</span></div>}
            {calc.kwh > 0 && <div className="re-side-row"><span>Stockage</span><b>{fmtNum(calc.kwh)} kWh</b></div>}
            {calc.autonomie && calc.autonomie.duree && <div className="re-side-row muted" data-testid="side-autonomie"><span>Autonomie en panne</span><span>{calc.autonomie.duree.libelle_fr}</span></div>}
            {calc.autonomie && calc.autonomie.depasse_pointe && <div className="re-side-row" style={{ color: "#991b1b" }}><span>Pointe des charges</span><span>{fmtNum(calc.autonomie.pointe_kw)} kW &gt; {fmtNum(calc.autonomie.kw_continu)} kW</span></div>}
          </div>
        )}
      </aside>
    );
  }

  // ───────────────────────── racine ─────────────────────────
  // Étape où l'on était, par soumission, le temps de la session : revenir sur la soumission en cours ramène à la même étape
  // (avec l'enregistrement automatique, elle a un numéro dès le début : on ne saute plus au Résumé ; JF, 8 nov. 2026).
  const ETAPES = new Map();
  function ConfiguratorRE({ state, setState, onEnvoyer, envoiPossible, onReviser, busy }) {
    const { cat, loading, rafraichit, error, reload } = window.CatalogueRE.useCatalogue();
    const nomCli = ((state.client || {}).name || "").trim();
    const cleEtape = state.quote_id ? "n:" + state.quote_id : (nomCli ? "c:" + nomCli : null); // soumission vierge : toujours l'étape 1
    const [step, setStep] = useState(() => (cleEtape && ETAPES.get(cleEtape)) || (state.quote_id ? 5 : 1));
    useEffect(() => { if (cleEtape) ETAPES.set(cleEtape, step); }, [cleEtape, step]);
    const calc = useMemo(() => C().compute(state, cat), [state, cat]);
    useEffect(() => { try { window.scrollTo({ top: 0, behavior: "smooth" }); } catch (_) {} }, [step]);

    if (error && !cat) return <div className="re-panel"><div className="re-alert error"><b>Catalogue indisponible.</b> {error}</div><button className="re-btn" onClick={() => reload({ force: true })}>Réessayer</button></div>;
    if (loading || !cat) return <div className="re-panel re-loading">Chargement du catalogue QuickBooks…</div>;

    const go = (n) => setStep(Math.min(5, Math.max(1, n)));
    const props = { state, setState, cat, calc };
    return (
      <div className="re-app">
        <div className="re-head">
          <Stepper step={step} setStep={go} solaireActif={calc.kw > 0} />
          <div className="re-sync" title={`Catalogue QuickBooks synchronisé ${cat.synced_at || ""}`}>
            {cat.articles.length} articles RE · {rafraichit ? <span className="re-muted">relecture QuickBooks…</span> : <button className="re-link" onClick={() => reload({ refresh: true })}>relire QuickBooks</button>}
          </div>
        </div>
        <div className="re-main">
          <div className="re-content">
            {step === 1 && <StepClient {...props} onNext={() => go(2)} />}
            {step === 2 && <StepSystemeOuParcours {...props} onBack={() => go(1)} onNext={() => go(calc.kw > 0 ? 3 : 4)} />}
            {step === 3 && <StepSolaire {...props} onBack={() => go(2)} onNext={() => go(4)} />}
            {step === 4 && <StepOptions {...props} onBack={() => go(calc.kw > 0 ? 3 : 2)} onNext={() => go(5)} />}
            {step === 5 && <StepResume {...props} onBack={() => go(4)} onEnvoyer={onEnvoyer} envoiPossible={envoiPossible} onReviser={onReviser} busy={busy} />}
          </div>
          <ResumePanel calc={calc} state={state} />
        </div>
      </div>
    );
  }

  window.ConfiguratorRE = ConfiguratorRE;
})();
