// calc-re.jsx — Moteur de calcul des soumissions RE (lignes du catalogue QuickBooks).
//
//   window.CALC_RE.compute(state, cat) → calc
//   state.lignes = [{ qbo_id, qty, prix }]  (prix = prix unitaire HT, modifiable sur la soumission)
//   state.solaire = { irradiance, acces_pct, ratio_perf, tarif_kwh, indexation_pct, degradation_pct, pans, orientation, aurora_image }
//   state.subventions = { renoclimat_admissible, logisvert_admissible, autres }
//
// Formules identiques aux propositions Claude Design d'octobre 2026 :
//   production = kW × irradiance × accès × 0,80 ; LogisVert = min(kW × 1 000 $, 40 % du HT solaire) ;
//   Rénoclimat = 4 000 $ batterie fixe ≥ 5 kWh + 1 000 $ raccordement de secours ; taxes 14,975 %.

(function () {
  const TPS = 0.05, TVQ = 0.09975;
  const r2 = (x) => Math.round((Number(x) || 0) * 100) / 100;

  const DEFAUTS_SOLAIRE = { irradiance: 1311, acces_pct: 100, ratio_perf: 0.80, tarif_kwh: 0.11142, indexation_pct: 4, degradation_pct: 0.4, pans: "", orientation: "", aurora_image: null };
  const DEFAUTS_SUBV = { renoclimat_admissible: true, logisvert_admissible: true, autres: 0, autres_libelle: "" };

  function buildInitialStateRE() {
    return {
      data_version: "re",
      project_type: "batterie",
      building_type: "residentiel_unifam",
      created_at: new Date().toISOString().slice(0, 10),
      quote_id: null,
      client: {
        client_id: null, name: "", phone: "", email: "",
        address_civic: "", address_apt: "", address_street: "", address_city: "", address_postal: "", address_province: "QC",
        source: "reference", region_id: "mascouche", financing_plan_id: "fit_promo_3m", hq_tariff: "D"
      },
      lignes: [],
      solaire: { ...DEFAUTS_SOLAIRE },
      subventions: { ...DEFAUTS_SUBV },
      notes_client: "",
      notes_internes: ""
    };
  }

  function groupeDe(a) {
    if (!a) return "autres";
    // Les lignes d'information (subventions) ne sont jamais des lignes de prix, même quand leur nom parle de borne.
    if (a.famille === "subventions" || /^Info subvention/i.test(a.nom || "")) return "info";
    if (a.famille === "solaire") return "solaire";
    if (a.famille === "entree") return "entree";
    if (a.famille === "borne" || /Wall Connector|Borne/i.test(a.nom)) return "borne";
    if (["tesla", "fox", "sigenergy", "lux", "batterie_mo"].includes(a.famille)) return "stockage";
    return "autres";
  }

  const GROUPES = [
    { id: "stockage", label: "Stockage d'énergie" },
    { id: "solaire",  label: "Système photovoltaïque" },
    { id: "entree",   label: "Entrée électrique et panneau" },
    { id: "borne",    label: "Recharge de véhicule" },
    { id: "autres",   label: "Travaux, matériel et frais" },
    { id: "info",     label: "Information" }
  ];

  // ─── Financeit, fiche « Home Improvement » en vigueur le 31 octobre 2026 ───
  // Crédit standard 13,99 %, sans frais marchand ; facteurs mensuels par tranche et amortissement.
  // Promotions : frais de programme (% du montant financé) payés par Raycom. Aucuns frais de dossier pour le client (JF, 5 nov. 2026).
  const FINANCEIT = {
    standard: { taux: 13.99, tranches: [
      { min: 1000, max: 9999.99, amort: [{ mois: 144, facteur: 0.01458, fee: 0 }, { mois: 180, facteur: 0.01351, fee: 0 }] },
      { min: 10000, max: 100000, amort: [{ mois: 144, facteur: 0.01436, fee: 2.14 }, { mois: 180, facteur: 0.01331, fee: 1.98 }, { mois: 240, facteur: 0.01243, fee: 1.85 }] } ] },
    frais_client_pct: 0, frais_client_max: 0, expire_promo: "2027-01-01"
  };
  const PLANS = [
    { id: "comptant", label: "Comptant", court: "Comptant" },
    { id: "fit_promo_3m", label: "Financeit · 0 $ et 0 % pendant 3 mois, puis crédit standard", court: "0 $ · 0 % · 3 mois", promo: true, differe_mois: 3, frais_pct: 3.49, puis: "standard" },
    { id: "fit_48m_999", label: "Financeit · 48 mois à 9,99 %", court: "48 mois · 9,99 %", taux: 9.99, mois: 48, frais_pct: 10.99 },
    { id: "fit_standard", label: "Financeit · crédit standard 13,99 %, jusqu'à 20 ans", court: "Standard · 13,99 %", standard: true, frais_pct: 0 }
  ];
  function mensualiteStandard(P) {
    const tr = FINANCEIT.standard.tranches.find(t => P >= t.min && P <= t.max) || FINANCEIT.standard.tranches[1];
    const a = tr.amort[tr.amort.length - 1];   // amortissement le plus long disponible
    return { monthly: r2(P * a.facteur + a.fee), mois: a.mois, taux: FINANCEIT.standard.taux };
  }
  function mensualiteAmortie(P, tauxPct, mois) {
    const r = tauxPct / 100 / 12; if (!mois) return 0;
    return r2(r === 0 ? P / mois : P * (r / (1 - Math.pow(1 + r, -mois))));
  }
  function calcPlan(plan, ttc) {
    const P = r2(ttc);
    const fraisClient = r2(Math.min(P * FINANCEIT.frais_client_pct / 100, FINANCEIT.frais_client_max));
    if (!plan || plan.id === "comptant" || P < 1000) return { id: "comptant", label: "Comptant", court: "Comptant", monthly: 0, frais_marchand: 0, frais_client: 0 };
    if (plan.standard) { const m = mensualiteStandard(P); return { ...plan, ...m, frais_marchand: 0, frais_client: fraisClient }; }
    if (plan.promo) { const m = mensualiteStandard(P); return { ...plan, ...m, monthly: m.monthly, frais_marchand: r2(P * plan.frais_pct / 100), frais_client: fraisClient }; }
    return { ...plan, monthly: mensualiteAmortie(P, plan.taux, plan.mois), frais_marchand: r2(P * plan.frais_pct / 100), frais_client: fraisClient };
  }
  function calcFinancement(ttc, planId) {
    // Sous 1 000 $ taxes incluses, Financeit ne s'applique pas : aucune option (sinon trois « Comptant » identiques).
    const options = r2(ttc) < 1000 ? [] : PLANS.filter(p => p.id !== "comptant").map(p => calcPlan(p, ttc));
    const choisi = calcPlan(PLANS.find(p => p.id === (planId || "fit_promo_3m")) || PLANS[1], ttc);
    return { ...choisi, options, promo_free_months: choisi.differe_mois || 0, after_plan: choisi.puis ? { apr: FINANCEIT.standard.taux, months: choisi.mois } : null };
  }

  // ═════════════════════ Autonomie en panne : charges connues (JF, 6 nov. 2026) ═════════════════════
  // Le vendeur coche les charges que le client veut garder pendant une panne ; l'autonomie se calcule sur l'énergie
  // utilisable des batteries du devis, la consommation quotidienne des charges cochées et, s'il y a des panneaux, la
  // production solaire d'une journée moyenne de panne. Rien ici ne touche aux lignes, aux quantités ni aux totaux : le prix
  // ne bouge JAMAIS quand on coche (prouvé par tests/test-autonomie-re.js).
  //
  // JF, 6 nov. 2026 (2e passe) : une seule valeur par charge, plus de saison. Le preset devient le « Kit de charges critiques
  // de base », vraiment de base, pour entrer dans la Gateway 3 ou dans un petit panneau de 60 A : réfrigérateur, congélateur,
  // internet et routeur Wi-Fi, un circuit de prise pour la télé, un circuit d'éclairage DEL, une prise de comptoir de cuisine.
  // Les pompes (puisard, puits) et l'appareil médical sont dans le même bloc, décochés (pas tous les clients en ont). Les
  // grosses charges (chauffe-eau, chauffage, cuisinière, sécheuse, borne VE…) se cochent à part.
  //
  // CHARGES_SECOURS est le seul objet à ajuster. Par charge :
  //   id           clé stable, sauvegardée dans la soumission (state.charges_secours.choix) : ne pas la renommer ;
  //   fr, en       libellé complet (configurateur) ; court_fr, court_en : libellé court (liste de la proposition) ;
  //   kwh_jour     kWh par jour de panne pour UNE unité, appareil récent typique (ni le pire ni le meilleur cas) ;
  //   pointe_kw    puissance de pointe en kW (démarrage du moteur ou résistance au maximum), pour UNE unité ;
  //   v240         true si l'appareil est en 240 V (circuit bipolaire, 2 positions de disjoncteur) ;
  //   base         true = bloc « Kit de base » (petits circuits, Gateway 3 ou panneau de 60 A) ; sinon « Grosses charges » ;
  //   critique     true = coché par défaut (preset « Kit de charges critiques de base ») ;
  //   quantite     true = compteur (circuits, pièces) au lieu d'une simple case ; chaque unité est un circuit.
  // Les kWh comptent le fonctionnement réel (cycles du compresseur, thermostat), jamais la puissance × 24 h. Maison
  // unifamiliale québécoise, 3 à 4 occupants. Une valeur `saison` encore sauvegardée dans une ancienne soumission est ignorée.
  //
  // Sources (lues le 6 nov. 2026 par recherche web ; les hôtes n'étaient pas joignables directement depuis la session) :
  //   [HQ-app]  Hydro-Québec, « Appareils efficaces », tableau de consommation unitaire par année de modèle (kWh/an, modèles
  //             2018 : réfrigérateur 466,8 ; congélateur 321,6 ; sécheuse 597,0 ; cuisinière 548,7),
  //             https://www.hydroquebec.com/residential/energy-wise/tips/appliances/products.html
  //   [HQ-app2] Hydro-Québec, « Consommation des appareils électriques » (la fabrication de glaçons ajoute 15 à 20 % au
  //             réfrigérateur ; les appareils en veille font 5 à 20 % de la facture),
  //             https://www.hydroquebec.com/residential/customer-space/electricity-use/electricity-consumption-devices.html
  //   [HQ-rep]  Hydro-Québec, « Répartition de la consommation d'un ménage » (maison chauffée à l'électricité : chauffage 54 %,
  //             eau chaude 20 %, électroménagers et électronique 18 %),
  //             https://www.hydroquebec.com/residential/customer-space/electricity-use/electricity-consumption-by-use.html
  //   [HQ-mai]  Hydro-Québec, « Consommation selon les caractéristiques de l'habitation » (maison unifamiliale sans piscine ni
  //             climatisation ≈ 22 000 kWh/an), https://www.hydroquebec.com/residential/customer-space/electricity-use/tools/electricity-use.html
  //   [HQ-calc] Hydro-Québec, outils de calcul de la consommation (puissance × heures d'utilisation ÷ 1 000),
  //             https://www.hydroquebec.com/residential/customer-space/electricity-use/tools/
  //   [RNCan-fr] Ressources naturelles Canada, « Consommation d'énergie des réfrigérateurs » (AHAM 2020 : moyenne des modèles
  //             expédiés en baisse de 25 % depuis 2000, de 638,8 kWh/an), https://oee.rncan-nrcan.gc.ca/publications/statistics/aham/2020/refrigerators.cfm
  //   [RNCan-lav] RNCan, « Consommation d'énergie des laveuses » (moyenne 2019 : 134,3 kWh/an),
  //             https://oee.nrcan.gc.ca/publications/statistics/aham/2019/washers.cfm
  //   [RNCan-lv] RNCan, Règlement sur l'efficacité énergétique, lave-vaisselle (critère ENERGY STAR v6 : 270 kWh/an au plus,
  //             format standard), https://natural-resources.canada.ca/energy-efficiency/energy-efficiency-regulations/dishwashers-0
  //   [SCHL]    SCHL, Centre canadien des technologies résidentielles, ventilateur de fournaise à moteur ECM (≈ 2,4 kWh/jour en
  //             marche continue, contre ≈ 9,3 pour un moteur PSC), https://publications.gc.ca/collections/collection_2014/schl-cmhc/NH18-22-105-101-eng.pdf
  //   [fab]     plaques signalétiques et fiches de fabricants d'appareils courants (puissance de marche et de démarrage) :
  //             estimation Raycom, sans fiche unique, notée comme telle sur la ligne.
  const CHARGES_SECOURS = [
    // ── Kit de charges critiques de base (coché par défaut) : ≈ 4,6 kWh/jour, pointe ≈ 3,4 kW, 6 circuits 120 V ──
    // Réfrigérateur 18 à 22 pi³ récent : 466,8 kWh/an [HQ-app] ≈ 1,28 kWh/jour, +≈ 10 % en usage réel (ouvertures, machine à
    // glaçons : +15 à 20 % selon [HQ-app2]) ≈ 1,4. Pointe : démarrage du compresseur, 4 à 6 fois les ≈ 150 W de marche [fab].
    { id: "refrigerateur", fr: "Réfrigérateur", en: "Refrigerator", court_fr: "réfrigérateur", court_en: "refrigerator", kwh_jour: 1.4, pointe_kw: 0.8, v240: false, base: true, critique: true },
    // Congélateur : 321,6 kWh/an [HQ-app] ≈ 0,9 kWh/jour. Pointe : démarrage du compresseur [fab].
    { id: "congelateur", fr: "Congélateur", en: "Freezer", court_fr: "congélateur", court_en: "freezer", kwh_jour: 0.9, pointe_kw: 0.6, v240: false, base: true, critique: true },
    // Modem et routeur Wi-Fi (ou borne maillée) : 15 à 20 W en continu [fab] ≈ 0,4 kWh/jour.
    { id: "internet", fr: "Internet et routeur Wi-Fi", en: "Internet and Wi-Fi router", court_fr: "internet", court_en: "internet", kwh_jour: 0.4, pointe_kw: 0.05, v240: false, base: true, critique: true },
    // Un circuit de prise pour la télé : télé DEL 55 po ≈ 80 W pendant 5 h (0,4 kWh) [HQ-calc], décodeur et barre de son
    // ≈ 15 W en continu, veille comprise (0,36 kWh) [HQ-app2] ≈ 0,8 kWh/jour.
    { id: "tele", fr: "Prise de la télévision (1 circuit)", en: "TV outlet (1 circuit)", court_fr: "télé", court_en: "TV", kwh_jour: 0.8, pointe_kw: 0.3, v240: false, base: true, critique: true },
    // Un circuit d'éclairage DEL : ≈ 10 ampoules de 9 W allumées ≈ 6 h [HQ-calc] ≈ 0,5 kWh/jour par circuit.
    { id: "eclairage", fr: "Éclairage DEL, par circuit", en: "LED lighting, per circuit", court_fr: "éclairage", court_en: "lighting", kwh_jour: 0.5, pointe_kw: 0.1, v240: false, base: true, critique: true, quantite: true },
    // Une prise de comptoir de cuisine : cafetière (≈ 0,2 kWh), bouilloire 1 500 W ≈ 10 min (0,25), grille-pain, chargeurs
    // [HQ-calc] ≈ 0,6 kWh/jour. Pointe : bouilloire et cafetière ensemble ≈ 1,5 kW (circuit de 15 A).
    { id: "comptoir", fr: "Prise de comptoir de la cuisine", en: "Kitchen counter outlet", court_fr: "prise de comptoir", court_en: "counter outlet", kwh_jour: 0.6, pointe_kw: 1.5, v240: false, base: true, critique: true },
    // Pompe de puisard (submersible) 1/3 à 1/2 HP, ≈ 600 W en marche : ≈ 1 h de marche cumulée par jour de pluie ou de fonte
    // ≈ 0,6 kWh/jour [fab]. Pointe : démarrage ≈ 3 fois la marche ≈ 2 kW. Décochée : pas toutes les maisons en ont.
    { id: "puisard", fr: "Pompe de puisard", en: "Sump pump", court_fr: "pompe de puisard", court_en: "sump pump", kwh_jour: 0.6, pointe_kw: 2.0, v240: false, base: true },
    // Pompe de puits submersible 3/4 HP, 240 V, ≈ 1,1 kW en marche : ≈ 1 000 L d'eau par jour pour la maison, ≈ 1 h de marche
    // ≈ 1,2 kWh/jour [fab]. Pointe : démarrage ≈ 4 kW. Décochée : seulement les maisons sur puits.
    { id: "puits", fr: "Pompe de puits submersible", en: "Submersible well pump", court_fr: "pompe de puits", court_en: "well pump", kwh_jour: 1.2, pointe_kw: 4.0, v240: true, base: true },
    // Appareil médical (CPAP avec humidificateur) : 40 à 60 W, 8 h par nuit [fab] ≈ 0,4 kWh/jour.
    { id: "medical", fr: "Appareil médical (CPAP)", en: "Medical device (CPAP)", court_fr: "appareil médical (CPAP)", court_en: "medical device (CPAP)", kwh_jour: 0.4, pointe_kw: 0.1, v240: false, base: true },

    // ── Grosses charges et autres circuits (décochés par défaut) ──
    // Chauffe-eau électrique 40 à 60 gal : eau chaude ≈ 20 % [HQ-rep] des ≈ 22 000 kWh/an d'une maison [HQ-mai] ≈ 4 000 à
    // 4 400 kWh/an ≈ 11 kWh/jour pour 3 à 4 occupants. Pointe : élément de 4 500 W (3 000 à 3 800 W sur bien des modèles).
    { id: "chauffe_eau", fr: "Chauffe-eau électrique", en: "Electric water heater", court_fr: "chauffe-eau", court_en: "water heater", kwh_jour: 11, pointe_kw: 4.5, v240: true },
    // Chauffage électrique de toute la maison : chauffage ≈ 54 % [HQ-rep] de ≈ 22 000 kWh/an [HQ-mai] ≈ 11 900 kWh sur une
    // saison de chauffage d'≈ 200 jours ≈ 60 kWh/jour en moyenne (≈ 80 et plus un jour de janvier). Pointe ≈ 15 kW (60 A à 240 V).
    { id: "chauffage_maison", fr: "Chauffage électrique, toute la maison", en: "Electric heating, whole house", court_fr: "chauffage de toute la maison", court_en: "whole-house heating", kwh_jour: 60, pointe_kw: 15, v240: true },
    // Plinthes électriques d'UNE pièce (≈ 1 500 W) : ≈ 60 kWh/jour de chauffage ÷ ≈ 8 pièces chauffées ≈ 7 kWh/jour
    // (thermostat en marche ≈ 20 % du temps en moyenne de saison).
    { id: "plinthes_piece", fr: "Plinthes électriques, par pièce", en: "Electric baseboards, per room", court_fr: "plinthes", court_en: "baseboards", kwh_jour: 7, pointe_kw: 1.5, v240: true, quantite: true },
    // Thermopompe centrale ou climatiseur ≈ 3 tonnes : en chauffage, ≈ 60 kWh/jour de chaleur ÷ rendement saisonnier ≈ 3
    // ≈ 20 kWh/jour (en climatisation l'été ≈ 10). Pointe : compresseur ≈ 5 kW (un démarreur progressif aide beaucoup) [fab].
    { id: "thermopompe", fr: "Thermopompe ou climatisation", en: "Heat pump or air conditioning", court_fr: "thermopompe ou climatisation", court_en: "heat pump or A/C", kwh_jour: 20, pointe_kw: 5.0, v240: true },
    // Ventilateur de fournaise (gaz, mazout, bois ou granules : la fournaise chauffe sans éléments électriques) : moteur ECM
    // ≈ 2,4 kWh/jour en continu [SCHL], plus le tirage et l'allumage ≈ 2,5 kWh/jour en saison de chauffage. Les éléments
    // d'une fournaise électrique ne sont PAS compris : cocher « Chauffage électrique, toute la maison ».
    { id: "fournaise", fr: "Ventilateur de fournaise", en: "Furnace blower", court_fr: "ventilateur de fournaise", court_en: "furnace blower", kwh_jour: 2.5, pointe_kw: 0.8, v240: false },
    // Cuisinière et four (240 V) : 548,7 kWh/an [HQ-app] ≈ 1,5 kWh/jour. Pointe ≈ 6 kW (four et deux ronds) [fab].
    { id: "cuisiniere", fr: "Cuisinière et four", en: "Range and oven", court_fr: "cuisinière et four", court_en: "range and oven", kwh_jour: 1.5, pointe_kw: 6.0, v240: true },
    // Sécheuse électrique 240 V : 597 kWh/an [HQ-app] ≈ 1,6 kWh/jour (≈ 2,5 kWh par brassée). Pointe ≈ 5,5 kW (élément et moteur).
    { id: "secheuse", fr: "Sécheuse", en: "Dryer", court_fr: "sécheuse", court_en: "dryer", kwh_jour: 1.6, pointe_kw: 5.5, v240: true },
    // Laveuse : 134,3 kWh/an [RNCan-lav] ≈ 0,4 kWh/jour (eau chaude non comprise : voir chauffe-eau). Pointe : moteur ≈ 1 kW.
    { id: "laveuse", fr: "Laveuse", en: "Washer", court_fr: "laveuse", court_en: "washer", kwh_jour: 0.4, pointe_kw: 1.0, v240: false },
    // Lave-vaisselle standard ENERGY STAR : 270 kWh/an au plus [RNCan-lv] ≈ 0,7 kWh/jour. Pointe : élément et pompe ≈ 1,5 kW.
    { id: "lave_vaisselle", fr: "Lave-vaisselle", en: "Dishwasher", court_fr: "lave-vaisselle", court_en: "dishwasher", kwh_jour: 0.7, pointe_kw: 1.5, v240: false },
    // Micro-ondes 1 000 à 1 200 W (≈ 1,5 kW absorbés) : ≈ 15 min par jour [HQ-calc] ≈ 0,3 kWh/jour.
    { id: "micro_ondes", fr: "Micro-ondes", en: "Microwave", court_fr: "micro-ondes", court_en: "microwave", kwh_jour: 0.3, pointe_kw: 1.5, v240: false },
    // Borne de recharge VE réglée à 32 A (7,7 kW) : ≈ 40 km par jour (≈ 15 000 km/an) à ≈ 20 kWh/100 km, pertes de recharge
    // comprises ≈ 8 kWh/jour [fab].
    { id: "borne_ve", fr: "Borne de recharge VE", en: "EV charger", court_fr: "borne VE", court_en: "EV charger", kwh_jour: 8, pointe_kw: 7.7, v240: true },
    // Piscine et spa : pompe de filtration ≈ 1 kW pendant ≈ 6 h et maintien en température du spa ≈ 4 kWh ≈ 10 kWh/jour [fab].
    // Pointe : élément du spa de 5,5 kW.
    { id: "piscine_spa", fr: "Piscine et spa", en: "Pool and spa", court_fr: "piscine et spa", court_en: "pool and spa", kwh_jour: 10, pointe_kw: 5.5, v240: true },
    // Autres prises du salon et des chambres : lampes d'appoint, chargeurs, petits appareils et veille [HQ-app2] ≈ 1 kWh/jour.
    { id: "prises", fr: "Autres prises du salon et des chambres", en: "Other living room and bedroom outlets", court_fr: "autres prises", court_en: "other outlets", kwh_jour: 1.0, pointe_kw: 1.5, v240: false },
    // Bureau à domicile : ordinateur, deux écrans, imprimante, ≈ 125 W pendant 8 h [HQ-calc] ≈ 1 kWh/jour.
    { id: "bureau", fr: "Bureau à domicile", en: "Home office", court_fr: "bureau à domicile", court_en: "home office", kwh_jour: 1.0, pointe_kw: 0.6, v240: false }
  ];

  // Énergie utilisable des batteries, en fraction de la capacité inscrite dans le nom QuickBooks.
  //   Tesla : 13,5 kWh est déjà l'énergie utilisable en courant alternatif (fiche technique du Powerwall 3) → 1,0.
  //   Autres : capacité nominale des modules × profondeur de décharge × rendement de l'onduleur (≈ 95 %) :
  //     Fox ESS EQ4000 / CM4000 : profondeur 90 % → ≈ 0,86 ; Sigenergy BAT 6.0 / 9.0 : profondeur ≈ 97 % → ≈ 0,92 ;
  //     Volthium LiFePO4 sur Lux Power : arrêt de l'onduleur réglé à ≈ 10 % → 0,90 × 0,94 ≈ 0,85.
  const ENERGIE_UTILISABLE = { tesla: 1.0, fox: 0.86, sigenergy: 0.92, lux: 0.85 };
  // Puissance continue en mode secours.
  //   Tesla : 11,5 kW par Powerwall 3 (une batterie d'expansion ajoute de l'énergie, pas de puissance).
  //   Fox ESS, Sigenergy, Lux Power : puissance de l'onduleur lue dans son nom QuickBooks (« 11,4 kW », « 11,5 kW », « 12K »,
  //   « 10K »), limitée par la décharge des batteries quand elle est connue (Volthium 100 Ah : 1 C ≈ 5,1 kW par module).
  const PUISSANCE_PW3_KW = 11.5;
  const DECHARGE_KW_PAR_KWH = { lux: 1.0 };
  // Production solaire d'une journée moyenne de panne à Mascouche, kWh par kW installé et par jour : une seule valeur.
  //   Moyenne annuelle : ≈ 1 185 kWh/kW/an à Montréal (RNCan, CanmetÉNERGIE, « Cartes d'ensoleillement et du potentiel
  //   d'énergie solaire photovoltaïque du Canada », https://ressources-naturelles.canada.ca/source-energie/energies-renouvelables/cartes-ensoleillement-potentiel-energie-solaire-photovoltaique-canada
  //   et https://ressources-naturelles.canada.ca/sites/nrcan/files/canmetenergy/files/pdf/PV_potential_summary_report_FR.pdf,
  //   lus le 6 nov. 2026) ÷ 365 ≈ 3,2 kWh/kW par jour.
  //   Marge prudente de ≈ 25 % : une panne arrive souvent par mauvais temps (verglas, orage, tempête), et la neige retire une
  //   bonne part de la production de décembre à février. Retenu : 2,5 kWh/kW par jour, soit ≈ une journée moyenne de
  //   printemps ou d'automne un peu couverte. 8 kW → ≈ 20 kWh/jour.
  // Quand le studio solaire a mesuré le toit (production Google), on prend sa production annuelle, mise à l'échelle :
  // production du jour = production annuelle × 2,5 ÷ 1 185 (même marge, ombrage et orientation du vrai toit compris).
  const SOLAIRE_MASCOUCHE = { kwh_par_kw_jour: 2.5, annuel_ref: 1185 };
  // Part de la consommation du jour qui tombe la nuit, sans soleil : la batterie doit la porter seule. Le solaire ne rend
  // l'autonomie « illimitée par beau temps » que si la production moyenne couvre la journée ET que la batterie tient la nuit.
  // ≈ 12 h sans soleil : réfrigérateur, congélateur et internet tournent 24 h ; l'éclairage et la télé surtout le soir → 0,6.
  const PART_NUIT = 0.6;
  // Au-delà de 7 jours, on affiche « plusieurs jours » plutôt qu'un chiffre faussement précis (le kit de base sur 2 Powerwall 3
  // donne ≈ 3,5 jours avec les pertes : on le montre, pour que le client voie le double de 1 Powerwall).
  const JOURS_PLUSIEURS = 7;
  // Pertes et marge réelles (JF, 7 nov. 2026 : « ajouter les pertes, mais 2 jours sur un Powerwall, c'est pas exagéré ? »).
  //   veille_kwh_jour : onduleur, passerelle et électronique de la batterie restent allumés toute la panne, ≈ 40 W en
  //                     continu ≈ 1 kWh/jour par système, même sans aucune charge.
  //   conversion      : ≈ 10 % perdus entre la batterie (courant continu) et les prises (courant alternatif).
  //   marge_usage     : en vraie panne, la famille branche plus que le kit (chargeurs, micro-ondes, portes du frigo plus
  //                     souvent ouvertes, ventilateur) : + 15 %.
  //   Charge réelle du jour = charges cochées × 1,15 × 1,10 + 1 kWh. Kit de base 4,6 kWh → ≈ 6,8 kWh/jour.
  //   L'autonomie est ensuite arrondie VERS LE BAS à la demi-journée : on ne promet jamais plus que ce qu'on calcule.
  //   1 Powerwall 3 (13,5 kWh) avec le kit de base : 13,5 ÷ 6,8 ≈ 1,98 → « ≈ 1,5 jour ».
  const PERTES = { veille_kwh_jour: 1.0, conversion: 0.10, marge_usage: 0.15 };
  const chargeReelle = (c) => c > 0 ? Math.round((c * (1 + PERTES.marge_usage) * (1 + PERTES.conversion) + PERTES.veille_kwh_jour) * 100) / 100 : 0;
  // Petit panneau de charges critiques de 60 A (article 586) : 12 emplacements de 1 po sans disjoncteurs jumelés (modèle
  // courant Siemens, Eaton ou Square D, à confirmer selon le panneau posé) ; 60 A × 240 V × 80 % ≈ 11,5 kW en continu.
  const PANNEAU_60A = { emplacements: 12, kw_continu: 11.5 };

  /** Preset « Kit de charges critiques de base » : une unité de chaque charge cochée par défaut. */
  function choixParDefaut() {
    const o = {}; for (const c of CHARGES_SECOURS) if (c.critique) o[c.id] = 1; return o;
  }
  /** Charges cochées de la soumission : state.charges_secours.choix = { id: quantité } ; preset de base s'il est absent.
   *  Toute autre clé (ancienne `saison`, id inconnu) est ignorée. */
  function chargesChoisies(state) {
    const cs = (state && state.charges_secours) || {};
    const choix = cs.choix && typeof cs.choix === "object" ? cs.choix : choixParDefaut();
    const out = [];
    for (const c of CHARGES_SECOURS) { const q = Math.max(0, Math.round(Number(choix[c.id]) || 0)); if (q > 0) out.push({ ...c, qty: c.quantite ? q : 1 }); }
    return out;
  }
  /** Circuits d'une liste de charges (avec qty) : un 120 V prend une position de disjoncteur, un 240 V en prend deux. */
  function circuitsDe(charges) {
    const n120 = (charges || []).filter(c => !c.v240).reduce((s, c) => s + (c.qty || 1), 0);
    const n240 = (charges || []).filter(c => c.v240).reduce((s, c) => s + (c.qty || 1), 0);
    return { n120, n240, circuits: n120 + n240, positions: n120 + 2 * n240 };
  }
  const kwOnduleur = (a) => {
    if (a.kw) return Number(a.kw);
    const m = (a.nom || "").match(/(\d+(?:[.,]\d+)?)\s*K\b/);
    return m ? parseFloat(m[1].replace(",", ".")) : 0;
  };
  function familleBatterie(a) {
    if (a.famille === "tesla" || /Tesla|Powerwall/i.test(a.nom)) return "tesla";
    if (a.famille === "fox" || /Fox/i.test(a.nom)) return "fox";
    if (a.famille === "sigenergy" || /Sigenergy/i.test(a.nom)) return "sigenergy";
    return "lux";
  }

  /** Énergie utilisable (kWh) et puissance continue en secours (kW), lues sur les lignes du devis (tous modules et expansions). */
  function stockageDe(lignes) {
    let kwhNom = 0, kwhUtil = 0, nbPw3 = 0, kwOnd = 0, decharge = null;
    for (const l of lignes) {
      const a = l.article; if (!a || !(l.qty > 0)) continue;
      if (a.est_batterie && a.kwh) {
        const f = familleBatterie(a);
        kwhNom += l.qty * a.kwh;
        kwhUtil += l.qty * a.kwh * ENERGIE_UTILISABLE[f];
        if (f === "tesla" && !/expansion/i.test(a.nom)) nbPw3 += l.qty;
        if (DECHARGE_KW_PAR_KWH[f]) decharge = (decharge || 0) + l.qty * a.kwh * DECHARGE_KW_PAR_KWH[f];
      } else if (/^Onduleur/i.test(a.nom) && !/Tesla/i.test(a.nom)) {
        kwOnd += l.qty * kwOnduleur(a);
      }
    }
    const kw = nbPw3 * PUISSANCE_PW3_KW + (decharge != null ? Math.min(kwOnd, decharge) : kwOnd);
    return { kwh_nominal: r2(kwhNom), kwh_utilisable: r2(kwhUtil), kw_continu: r2(kw), nb_powerwall: nbPw3 };
  }

  /** Durée lisible : « ≈ 14 h », « ≈ 1 jour », « ≈ 1,5 jour », « ≈ 2,5 jours » ; en anglais « ≈ 1.5 days ». */
  function libelleDuree(r, langue) {
    const en = langue === "en";
    if (r.vide) return en ? "no load selected" : "aucune charge cochée";
    if (r.illimitee) return en ? "unlimited in good weather" : "illimitée par beau temps";
    if (r.plusieurs) return en ? "several days" : "plusieurs jours";
    // Arrondi vers le bas (prudent) : 1,98 jour s'affiche « ≈ 1,5 jour », 23,6 h « ≈ 23 h ».
    const h = Math.floor(r.jours * 24);
    if (h < 24) return `≈ ${Math.max(1, h)} h`;
    const j = Math.max(1, Math.floor(r.jours * 2) / 2);
    const txt = j.toLocaleString(en ? "en-CA" : "fr-CA");
    return en ? `≈ ${txt} day${j === 1 ? "" : "s"}` : `≈ ${txt} jour${j >= 2 ? "s" : ""}`;
  }

  /**
   * Autonomie en panne, une seule valeur (journée moyenne de panne).
   *   o = { kwh_utilisable, kw_continu, charges: [charge + qty], kw_solaire, production_an, production_mesuree }
   *   Sans solaire : jours = énergie utilisable ÷ charge du jour.
   *   Avec solaire : jours = énergie ÷ (charge − production du jour) ; « illimitée par beau temps » si la production couvre
   *   la journée et que la batterie porte la nuit ; « plusieurs jours » au-delà de 7 jours.
   *   → { …, duree: { charge_kwh, solaire_kwh, jours, illimitee, plusieurs, vide, libelle_fr, libelle_en }, batterie_seule: {…} }
   */
  function calcAutonomie(o) {
    const E = Number(o.kwh_utilisable) || 0;
    if (E <= 0) return null;
    const charges = o.charges || [];
    const kwSol = Number(o.kw_solaire) || 0;
    const prodAn = Number(o.production_an) || 0;
    const mesuree = !!o.production_mesuree && prodAn > 0 && kwSol > 0;
    const kwCont = Number(o.kw_continu) || 0;
    const pointe = r2(charges.reduce((s, c) => s + c.qty * c.pointe_kw, 0));
    const C = r2(charges.reduce((t, c) => t + c.qty * c.kwh_jour, 0));
    const Creel = chargeReelle(C);   // charges cochées + marge d'usage + conversion + veille du système
    const S = SOLAIRE_MASCOUCHE;
    const prodJour = kwSol > 0 ? r2(mesuree ? prodAn * S.kwh_par_kw_jour / S.annuel_ref : kwSol * S.kwh_par_kw_jour) : 0;
    const duree = (P) => {
      const r = { charge_kwh: C, charge_reelle_kwh: Creel, pertes_kwh: r2(Creel - C), solaire_kwh: P, jours: null, illimitee: false, plusieurs: false, vide: C <= 0 };
      if (!r.vide) {
        if (P > 0 && P >= Creel && E >= Creel * PART_NUIT) r.illimitee = true;
        else {
          // Production qui couvre la journée mais batterie trop petite pour la nuit : on ne compte pas le solaire (prudent).
          r.jours = Math.round(E / (P < Creel ? Creel - P : Creel) * 100) / 100;
          r.plusieurs = r.jours > JOURS_PLUSIEURS;
        }
      }
      r.libelle_fr = libelleDuree(r, "fr"); r.libelle_en = libelleDuree(r, "en");
      return r;
    };
    return {
      kwh_utilisable: r2(E), kw_continu: r2(kwCont), pointe_kw: pointe, depasse_pointe: kwCont > 0 && pointe > kwCont,
      charges: charges.map(c => ({ id: c.id, fr: c.fr, en: c.en, court_fr: c.court_fr, court_en: c.court_en, qty: c.qty, kwh_jour: c.kwh_jour, pointe_kw: c.pointe_kw, v240: !!c.v240, base: !!c.base, critique: !!c.critique })),
      circuits: circuitsDe(charges),
      avec_solaire: kwSol > 0, kw_solaire: r2(kwSol), source_solaire: kwSol > 0 ? (mesuree ? "studio" : "rendement") : null,
      duree: duree(prodJour),
      // Même calcul sans le solaire (comparaison « batterie seule » de la proposition).
      batterie_seule: duree(0)
    };
  }

  function compute(state0, cat) {
    const state = state0 || {};
    const byId = cat && cat.byId ? cat.byId : new Map();
    const sol = { ...DEFAUTS_SOLAIRE, ...(state.solaire || {}) };
    const sub = { ...DEFAUTS_SUBV, ...(state.subventions || {}) };

    const lignes = (state.lignes || []).map(l => {
      const a = byId.get(l.qbo_id);
      const qty = Number(l.qty) || 0;
      const prix = l.prix != null && l.prix !== "" ? Number(l.prix) : (a ? a.prix : 0);
      // nom_marque : installation au nom de la marque du système (parcours-re.jsx, JF 8 nov. 2026) ; même article et même prix
      const marque = l.nom_marque ? String(l.nom_marque).replace(/^Installation (onduleur|batterie) /, "").replace(/, par module$/, "") : "";
      return { ...l, article: a, nom: l.nom_marque || (a ? a.nom : `Article ${l.qbo_id}`), description: a ? (marque && a.description ? `${marque} : ${a.description}` : a.description) : "", qty, prix, montant: r2(qty * prix), groupe: groupeDe(a) };
    });

    // Projet avec panneaux : l'onduleur hybride, son installation et les dispositifs d'arrêt rapide ou
    // d'optimisation (MCI Tesla, ProJoy RSD et son branchement, Tigo) font partie du volet solaire (et du coût admissible
    // LogisVert), pas du stockage ni des travaux ; sinon un projet solaire Fox affichait un volet « Stockage » de 0 kWh.
    // JF, 4 nov. 2026 : ProJoy (et son branchement), MCI Tesla, Tigo font partie du BOS solaire dans tous les cas, avec ou sans batterie.
    // JF, 5 nov. 2026 : norme des propositions, avec ou sans batterie, dès qu'il y a des panneaux, l'onduleur hybride et son
    // installation font partie du volet solaire (coût admissible LogisVert), comme dans la proposition client.
    const aPanneaux = lignes.some(l => l.article && l.article.est_panneau && l.qty > 0);
    for (const l of lignes) {
      if (aPanneaux && l.groupe === "stockage" && /^(Onduleur|Installation onduleur)/i.test(l.nom)) l.groupe = "solaire";
      else if ((l.groupe === "stockage" || l.groupe === "autres") && /Arrêt rapide|RSD|ProJoy|\bMCI\b|Optimiseur|Tigo/i.test(l.nom)) l.groupe = "solaire";
    }
    const parGroupe = {};
    for (const g of GROUPES) parGroupe[g.id] = { ...g, lignes: [], ht: 0 };
    for (const l of lignes) { parGroupe[l.groupe].lignes.push(l); parGroupe[l.groupe].ht = r2(parGroupe[l.groupe].ht + l.montant); }

    const ht = r2(lignes.reduce((s, l) => s + l.montant, 0));
    const tps = r2(ht * TPS), tvq = r2(ht * TVQ);
    const ttc = r2(ht + tps + tvq);

    // Puissance solaire et stockage, lues sur les lignes
    const kw = r2(lignes.filter(l => l.article && l.article.est_panneau && l.article.watts).reduce((s, l) => s + l.qty * l.article.watts / 1000, 0));
    const panneaux = lignes.filter(l => l.article && l.article.est_panneau).reduce((s, l) => s + l.qty, 0);
    const kwh = r2(lignes.filter(l => l.article && l.article.est_batterie && l.article.kwh).reduce((s, l) => s + l.qty * l.article.kwh, 0));
    // Raccordement à une source de secours (Rénoclimat +1 000 $) : passerelle de transfert, panneau de charges
    // critiques, embase combinée ou ligne de raccordement explicite.
    const aRaccordement = lignes.some(l => l.qty > 0 && l.article && (l.article.est_raccordement_secours || /Gateway|Passerelle|LoadHub|Hub G2|charges critiques|embase de compteur combinée/i.test(l.nom)));

    // LogisVert : 1 000 $/kW, plafond 40 % du coût admissible (lignes solaires), 40 kW max
    const htSolaire = parGroupe.solaire.ht;
    const logisvert = (sub.logisvert_admissible && kw > 0) ? Math.round(Math.min(Math.min(kw, 40) * 1000, htSolaire * 0.40)) : 0;
    // Rénoclimat : batterie fixe ≥ 5 kWh → 4 000 $ ; raccordement de secours → 1 000 $
    const renoBatterie = (sub.renoclimat_admissible && kwh >= 5) ? 4000 : 0;
    const renoRaccord = (sub.renoclimat_admissible && kwh >= 5 && aRaccordement) ? 1000 : 0;
    const renoclimat = renoBatterie + renoRaccord;
    const autres = Number(sub.autres) || 0;
    const subventions = logisvert + renoclimat + autres;
    const net = r2(ttc - subventions);

    // Production et économies (solaire)
    const acces = Math.min(Math.max(Number(sol.acces_pct) || 0, 0), 100) / 100;
    // Production : mesure Google Solar (kWh DC/an du design, ramenée en AC à 96 %) si un design a été appliqué, sinon formule irradiance.
    const prodGoogle = Number(sol.production_google_kwh) || 0;
    const production = kw > 0 ? (prodGoogle > 0 && sol.production_source === "google" ? Math.round(prodGoogle * 0.96) : Math.round(kw * (Number(sol.irradiance) || 0) * acces * (Number(sol.ratio_perf) || 0.8))) : 0;
    const tarif = Number(sol.tarif_kwh) || 0;
    const economiesAn1 = Math.round(production * tarif);
    const solaireTtc = r2(htSolaire * (1 + TPS + TVQ));
    const coutNetSolaire = r2(solaireTtc - logisvert);
    let cumul = 0, seuil = null; const courbe = [];
    for (let an = 1; an <= 25; an++) {
      const prod = production * Math.pow(1 - (Number(sol.degradation_pct) || 0) / 100, an - 1);
      const prix = tarif * Math.pow(1 + (Number(sol.indexation_pct) || 0) / 100, an - 1);
      cumul += prod * prix;
      courbe.push({ an, cumul: Math.round(cumul) });
      if (seuil === null && cumul >= coutNetSolaire && coutNetSolaire > 0) seuil = an;
    }
    const retourAns = economiesAn1 > 0 ? r2(coutNetSolaire / economiesAn1) : null;

    // Financement Financeit (fiche de taux Home Improvement du 31 oct. 2026). Les frais de programme sont
    // à la charge de Raycom : calculés pour le vendeur, JAMAIS montrés au client.
    const financement = calcFinancement(ttc, (state.client || {}).financing_plan_id);

    // Autonomie en panne (JF, 6 nov. 2026) : énergie utilisable des batteries ÷ charges cochées, solaire d'une journée moyenne en plus.
    // Calcul à part des lignes : aucune ligne, quantité ni total ne dépend des charges cochées.
    const stockage = stockageDe(lignes);
    const autonomie = kwh > 0 ? calcAutonomie({
      kwh_utilisable: stockage.kwh_utilisable, kw_continu: stockage.kw_continu, charges: chargesChoisies(state),
      kw_solaire: kw, production_an: production, production_mesuree: sol.production_source === "google" && prodGoogle > 0
    }) : null;

    return {
      lignes, groupes: GROUPES.map(g => parGroupe[g.id]).filter(g => g.lignes.length),
      ht, tps, tvq, ttc, taxes: r2(tps + tvq),
      kw, panneaux, kwh, aRaccordement,
      logisvert, renoclimat, renoBatterie, renoRaccord, autres, subventions, net,
      htSolaire, solaireTtc, coutNetSolaire, production, economiesAn1, retourAns, seuil, courbe, cumul25: Math.round(cumul),
      financement, autonomie,
      pret: lignes.length > 0 && !!(state.client && state.client.name),
      // Fiabilité du calcul (soumission 2026-0019 sauvegardée à 0 $, 6 nov. 2026) : sans catalogue chargé, une ligne sans prix
      // saisi vaut 0 $ et ses kW ou kWh sont inconnus. La sauvegarde n'écrit alors ni prix ni puissance (cloud/db.jsx).
      catalogue_charge: byId.size > 0,
      lignes_actives: lignes.filter(l => l.qty > 0).length,
      lignes_sans_prix: lignes.filter(l => l.qty > 0 && !l.article && !(l.prix > 0)).length,
      lignes_sans_article: lignes.filter(l => l.qty > 0 && !l.article).length
    };
  }

  const fmtCAD = (n, d = 2) => (Number(n) || 0).toLocaleString("fr-CA", { style: "currency", currency: "CAD", minimumFractionDigits: d, maximumFractionDigits: d });
  const fmtInt = (n) => Math.round(Number(n) || 0).toLocaleString("fr-CA");
  const fmtNum = (n, d = 1) => (Number(n) || 0).toLocaleString("fr-CA", { minimumFractionDigits: 0, maximumFractionDigits: d });

  window.CALC_RE = { compute, buildInitialStateRE, GROUPES, groupeDe, fmtCAD, fmtInt, fmtNum, TPS, TVQ, DEFAUTS_SOLAIRE, PLANS, FINANCEIT, calcFinancement,
    CHARGES_SECOURS, ENERGIE_UTILISABLE, PUISSANCE_PW3_KW, SOLAIRE_MASCOUCHE, PART_NUIT, PANNEAU_60A, PERTES, chargeReelle, choixParDefaut, chargesChoisies, circuitsDe, stockageDe, calcAutonomie, libelleDuree };
})();
