// analyses-re.jsx : section ANALYSES de RAYCAST (JF, 7 nov. 2026 : « moins de choses, mais les plus importantes, avec des graphiques
// professionnels, navigables, clairs, faciles à interpréter, rien de superflu »).
//
//   window.TableauDeBordRE  { profile, onOpen(id), onNew(), onNewFor(prefill) }  la santé de l'entreprise en 10 secondes :
//                           12 indicateurs en 4 groupes (Leads, Ventes, Pipeline et encaissement, Marketing), chacun cliquable
//                           vers sa liste, « À faire aujourd'hui », ventes 12 mois contre l'an passé, constats qui sautent aux yeux.
//   window.AnalyticsRE      { profile, onOpen }  deux onglets : « Leads et marketing » (pages et variantes, canaux, coût par lead,
//                           entonnoir lead → devis → accepté → facturé) et « Ventes » (12 mois contre l'an passé, familles, produits).
//   window.AnalysesRE       fonctions pures (fenêtres, ventes, rapprochement des leads, familles) pour les tests.
//
// Même logique de comparaison partout : la période choisie (par défaut le dernier mois complet) est comparée à la période d'avant
// ET à la même période l'an passé, en $ (ou en nombre, ou en points) et en %. Une comparaison que la source ne couvre pas est
// marquée « n/d » avec sa raison (jamais estimée).
//
// Sources, toutes en lecture seule :
//   QuickBooks : worker GET /raycast/pipeline (devis et factures des 365 derniers jours) et GET /raycast/ventes-produits
//                (24 mois de totaux et d'articles par mois) ; liste unifiée des clients (window.ClientsCache, sinon /raycast/clients).
//   Supabase   : SELECT sur submissions (leads web : page_url, fbclid, gclid, score) et proposition_liens (consultations).
//   Meta       : relais GET /raycast/proxy?worker=meta&path=/ads/campaigns&days=N (dépense ; une fenêtre passée = différence de deux fenêtres).
// Aucune écriture nulle part. Graphiques en SVG maison mesurés à la largeur réelle (pas de bibliothèque).

(function () {
  const { useState, useEffect, useMemo, useRef, useCallback } = React;
  const TZ = "America/Toronto";

  // ════════════════════════════ Formats ════════════════════════════
  const nbFr = (n, d = 0) => (Number(n) || 0).toLocaleString("fr-CA", { minimumFractionDigits: d, maximumFractionDigits: d });
  const fmtCAD = (n, d = 2) => (window.CALC_RE && window.CALC_RE.fmtCAD) ? window.CALC_RE.fmtCAD(n, d) : (Number(n) || 0).toLocaleString("fr-CA", { style: "currency", currency: "CAD", minimumFractionDigits: d, maximumFractionDigits: d });
  /** Montant court des tuiles et des axes : « 629 k$ », « 22,8 k$ », « 1,2 M$ », « 850 $ ». */
  const fmtK = (n) => {
    const v = Number(n) || 0, a = Math.abs(v);
    if (a >= 1e6) return `${(v / 1e6).toLocaleString("fr-CA", { maximumFractionDigits: 1 })} M$`;
    if (a >= 1000) return `${(v / 1000).toLocaleString("fr-CA", { maximumFractionDigits: a >= 100000 ? 0 : 1 })} k$`;
    return `${Math.round(v).toLocaleString("fr-CA")} $`;
  };
  const pct = (n, d = 0) => `${nbFr(n, d)} %`;
  const MOIS = ["janvier", "février", "mars", "avril", "mai", "juin", "juillet", "août", "septembre", "octobre", "novembre", "décembre"];
  const MOIS_C = ["janv.", "févr.", "mars", "avr.", "mai", "juin", "juil.", "août", "sept.", "oct.", "nov.", "déc."];
  const majuscule = (s) => s ? s.charAt(0).toUpperCase() + s.slice(1) : s;

  // ════════════════════════════ Dates (jours locaux de Mascouche, chaînes AAAA-MM-JJ) ════════════════════════════
  const FMT_JOUR = new Intl.DateTimeFormat("en-CA", { timeZone: TZ, year: "numeric", month: "2-digit", day: "2-digit" });
  const jourDe = (v) => { if (v == null || v === "") return null; const s = String(v); if (/^\d{4}-\d{2}-\d{2}$/.test(s)) return s; const d = new Date(s); return isNaN(d) ? null : FMT_JOUR.format(d); };
  const aujourdhui = () => FMT_JOUR.format(new Date());
  const addJ = (s, n) => { const d = new Date(s + "T12:00:00Z"); d.setUTCDate(d.getUTCDate() + n); return d.toISOString().slice(0, 10); };
  const addM = (s, n) => { let y = Number(s.slice(0, 4)), m = Number(s.slice(5, 7)) + n; while (m > 12) { m -= 12; y++; } while (m < 1) { m += 12; y--; } return `${y}-${String(m).padStart(2, "0")}-01`; };
  const debutMois = (s) => s.slice(0, 7) + "-01";
  const anMoins = (s) => { const y = Number(s.slice(0, 4)) - 1, md = s.slice(5); return md === "02-29" ? `${y}-02-28` : `${y}-${md}`; };
  const ecartJ = (a, b) => Math.round((Date.parse(b + "T12:00:00Z") - Date.parse(a + "T12:00:00Z")) / 86400000);
  const libMois = (s) => `${MOIS[Number(s.slice(5, 7)) - 1]} ${s.slice(0, 4)}`;
  const libMoisC = (s) => `${MOIS_C[Number(s.slice(5, 7)) - 1]} ${s.slice(2, 4)}`;
  const libJour = (s) => s ? `${Number(s.slice(8, 10))} ${MOIS_C[Number(s.slice(5, 7)) - 1]} ${s.slice(0, 4)}` : "";
  const libJourCourt = (s) => s ? `${Number(s.slice(8, 10))} ${MOIS_C[Number(s.slice(5, 7)) - 1]}` : "";

  /** Fenêtres [a, b) de la période choisie, de la période d'avant et de la même période l'an passé (null quand c'est la même). */
  const PERIODES = [["mois", "Mois dernier"], ["30", "30 jours"], ["3m", "3 mois"], ["12m", "12 mois"], ["annee", "Année"]];
  function fenetres(p, auj) {
    const m0 = debutMois(auj), demain = addJ(auj, 1);
    if (p === "30") { const a = addJ(auj, -29); return { p, mensuel: false, cur: { a, b: demain, lib: `30 derniers jours (${libJourCourt(a)} au ${libJourCourt(auj)})` }, prev: { a: addJ(a, -30), b: a, lib: "30 jours d'avant", de: "aux 30 jours d'avant" }, ly: { a: anMoins(a), b: anMoins(demain), lib: "mêmes dates l'an passé", de: "aux mêmes dates l'an passé" } }; }
    if (p === "3m") { const a = addM(m0, -3); return { p, mensuel: true, cur: { a, b: m0, lib: `${majuscule(libMois(a).split(" ")[0])} à ${libMois(addM(m0, -1))}` }, prev: { a: addM(a, -3), b: a, lib: "3 mois d'avant", de: "aux 3 mois d'avant" }, ly: { a: addM(a, -12), b: addM(m0, -12), lib: "mêmes mois l'an passé", de: "aux mêmes mois l'an passé" } }; }
    if (p === "12m") { const a = addM(m0, -12); return { p, mensuel: true, cur: { a, b: m0, lib: `12 derniers mois complets (${libMoisC(a)} à ${libMoisC(addM(m0, -1))})` }, prev: { a: addM(a, -12), b: a, lib: "12 mois d'avant", de: "aux 12 mois d'avant (l'an passé)" }, ly: null }; }
    if (p === "annee") { const a = auj.slice(0, 4) + "-01-01"; return { p, mensuel: true, cur: { a, b: demain, lib: `Depuis le 1er janvier ${auj.slice(0, 4)}` }, prev: { a: anMoins(a), b: anMoins(demain), lib: "même période l'an passé", de: "à la même période l'an passé" }, ly: null }; }
    const a = addM(m0, -1);
    return { p: "mois", mensuel: true, cur: { a, b: m0, lib: majuscule(libMois(a)) }, prev: { a: addM(a, -1), b: a, lib: libMois(addM(a, -1)) }, ly: { a: addM(a, -12), b: addM(m0, -12), lib: libMois(addM(a, -12)) } };
  }
  const dans = (j, w) => !!j && j >= w.a && j < w.b;

  // ════════════════════════════ Leads : page, système, canal, qualification ════════════════════════════
  const tel10 = (s) => { const d = String(s || "").replace(/\D/g, ""); return d.length >= 10 ? d.slice(-10) : ""; };
  const mel = (s) => { const x = String(s || "").trim().toLowerCase(); return x.includes("@") ? x : ""; };
  const SEUIL_QUALIFIE = 75; // score GHL v3 « chaud » (3 boules de feu), même seuil que statuts-re.jsx et lead-scoring.ts
  const hoteDe = (u) => { try { return new URL(String(u)).hostname.toLowerCase(); } catch (e) { return ""; } };
  const estTest = (l) => /test/i.test(String(l.source || "")) || /^(127\.|localhost|0\.0\.0\.0)/.test(hoteDe(l.page_url)) || /^test$/i.test(String(l.utm_source || ""));
  /** Page de pub (variante) : « powerwall1. », « solaire. », « recharge. », « Formulaire web » ; sinon la source. */
  function pageDe(l) {
    const h = hoteDe(l.page_url);
    if (/raycomelectrique\.com$/.test(h)) { const sous = h.replace(/\.?raycomelectrique\.com$/, ""); return sous && sous !== "www" ? sous + "." : "raycomelectrique.com"; }
    if (/raycom-form/.test(h)) return "Formulaire web";
    if (h) return h;
    const s = String(l.source || "");
    if (/formulaire/i.test(s)) return "Formulaire web";
    return s || "Source inconnue";
  }
  const PROJETS = { batterie: "Batterie", solaire: "Solaire", solaire_batterie: "Solaire + batterie", borne: "Borne VÉ" };
  /** Système visé : celui de la page de pub (powerwall… → Batterie Tesla), sinon le type de projet du formulaire. */
  function systemeDe(page, projet) {
    const p = String(page || "").toLowerCase();
    if (/^powerwall/.test(p)) return "Batterie Tesla";
    if (/^sigen/.test(p)) return "Sigenergy";
    if (/^fox/.test(p)) return "Fox ESS";
    if (/^(volthium|lux)/.test(p)) return "Volthium / Lux";
    if (/^solaire/.test(p)) return "Solaire";
    if (/^(recharge|borne)/.test(p)) return "Borne VÉ";
    return PROJETS[projet] ? `${PROJETS[projet]} (formulaire)` : "Autre";
  }
  const CANAUX = [{ k: "meta", label: "Meta (Facebook, Instagram)", cl: "s1" }, { k: "google", label: "Google Ads", cl: "s2" }, { k: "autre", label: "Organique, direct, formulaire", cl: "s3" }];
  function canalDe(l) {
    const u = String(l.utm_source || "").toLowerCase();
    if (l.fbclid || /^(facebook|fb|meta|ig|instagram)$/.test(u)) return "meta";
    if (l.gclid || /^(google|adwords|gads)$/.test(u)) return "google";
    return "autre";
  }
  /** Canal au sens du compteur des pages de pub (lp-stats.js) : comme canalDe, mais « organique » (aucun utm ni clic publicitaire) et
   *  « autre » (un utm qui n'est ni Meta ni Google) séparés. */
  function canalLpDe(l) {
    const c = canalDe(l); if (c !== "autre") return c;
    return String(l.utm_source || "").trim() ? "autre" : "organique";
  }

  // ════════════════════════════ Articles QuickBooks : famille de vente, produit ════════════════════════════
  const FAMILLES = [["batteries", "Batteries et secours"], ["solaire", "Solaire"], ["bornes", "Bornes de recharge"], ["electricite", "Électricité générale et autres"]];
  const LIB_FAMILLE = Object.fromEntries(FAMILLES);
  function familleDe(nom) {
    const n = String(nom || "");
    if (/projoy|rapid shutdown|\brsd\b/i.test(n)) return "solaire";
    if (/borne|wall connector|wallbox|flo home|\bdcc\b|dcc-|contrôleur de charge|prise ve|nema 14-50|recharge/i.test(n)) return "bornes";
    if (/powerwall|gateway|tesla|expansion|\bmci\b|remote meter|fox|sigen|lux ?power|volthium|eq ?4000|batterie|backup|secours|forfait #/i.test(n)) return "batteries";
    if (/solaire|photovolta|pose solaire|racking|bom et structure|longi|thornova/i.test(n)) return "solaire";
    return "electricite";
  }
  // Produit (matériel vendu) : les anciens et les nouveaux articles QuickBooks d'un même produit comptent ensemble ; la main-d'œuvre,
  // l'installation, les forfaits, le petit matériel et la ligne générique « Ventes » ne sont pas des produits.
  const PAS_PRODUIT = /main[- ]d|install|pose\b|forfait|raccord|branchement|déplacement|taux|travaux|matériel électrique|^ventes|total|harness|harnais|kit de mât|quincaillerie|\bfil\b|câble|cable|conduit|disjoncteur|boîte|connecteur|clip|coupling|\bvis\b|mise à la terre|slider|filage|câblage|upgrade|remplacement|panneau secondaire|panneau 200|panneau à disj|embase|charges critiques|interrupteur|spot|plafonnier|chauffage|prise gfci|sectionneur|contreplaque|nmd|commercial/i;
  const PRODUITS = [
    ["expansion", "Expansion Powerwall 3", /(expansion|extension).*(powerwall|pw3)|powerwall.*(expansion|extension)/i],
    ["onduleur_tesla", "Onduleur Tesla Powerwall 3", /onduleur.*tesla|tesla.*(onduleur|inverter)/i],
    ["powerwall", "Powerwall 3", /powerwall\s*3/i],
    ["gateway", "Gateway 3 Tesla", /gateway/i],
    ["panneaux", "Panneaux solaires", /panneau (solaire|photovolta)|panneau.*(longi|thornova)|^panneau thornova/i],
    ["structure", "Structure de montage solaire", /bom et structure|racking/i],
    ["fox_bat", "Batterie Fox ESS EQ4000", /fox.*eq ?4000|eq ?4000/i],
    ["fox_ond", "Onduleur Fox ESS", /fox.*(h1|h3|hybrid|onduleur)/i],
    ["sigenergy", "Sigenergy", /sigen/i],
    ["lux", "Lux Power / Volthium", /lux ?power|volthium/i],
    ["bornes", "Bornes de recharge (matériel)", /wall connector|wallbox|flo home|borne wallbox|^borne\b/i],
    ["dcc", "Contrôleur de charge DCC", /\bdcc\b|dcc-|contrôleur de charge/i],
    ["remote", "Remote Meter Kit Tesla", /remote meter/i],
    ["mci", "MCI Tesla", /\bmci\b|mid-circuit/i],
    ["rsd", "Arrêt rapide solaire (RSD)", /projoy|rapid shutdown|\brsd\b/i],
  ];
  function produitDe(nom) {
    const n = String(nom || "").replace(/\s*\(supprimé\)\s*$/i, "");
    const court = n.includes(":") ? n.slice(n.lastIndexOf(":") + 1).trim() : n.trim();
    if (/^(onduleur.*tesla|tesla.*onduleur)/i.test(court)) return { k: "onduleur_tesla", label: "Onduleur Tesla Powerwall 3" };
    if (PAS_PRODUIT.test(court)) return null;
    for (const [k, label, rx] of PRODUITS) if (rx.test(court)) return { k, label };
    return court ? { k: "a:" + court.toLowerCase(), label: court } : null;
  }

  // ════════════════════════════ Chargement des sources (cache partagé, 2 min) ════════════════════════════
  const CACHE_MS = 2 * 60000;
  let cacheSrc = null;      // { at, promesse }
  const cacheMeta = {};     // days → { at, promesse }
  async function jwt() { try { const sb = window.RAYCAST_SUPABASE; if (!sb) return null; const { data } = await sb.auth.getSession(); return data && data.session ? data.session.access_token : null; } catch (e) { return null; } }
  const urlWorker = () => (window.CatalogueRE && window.CatalogueRE.WORKER_URL) || window.RAYCAST_WORKER_URL || "https://raycom-ghl-qbo-worker.proud-leaf-b313.workers.dev";
  async function worker(path) {
    const t = await jwt(); if (!t) throw new Error("session expirée, reconnecte-toi");
    const r = await fetch(urlWorker() + path, { headers: { Authorization: `Bearer ${t}` } });
    const j = await r.json().catch(() => ({})); if (!r.ok) throw new Error(j.error || `HTTP ${r.status}`); return j;
  }
  const texte = (e) => (e && e.message) ? e.message : String(e);
  const COLS_LEADS = "id,created_at,status,source,project_type,lead_score,client_name,lead_email,lead_phone,ghl_contact_id,page_url:data->>page_url,fbclid:data->>fbclid,gclid:data->>gclid,utm_source:data->utm->>source,client_phone:data->client->>phone,client_email:data->client->>email";
  const COLS_LIENS = "id,etat,soumission_id,soumission_numero,qbo_doc_number,qbo_customer_id,client_key,client_nom,montant_ttc,envoye_le,nb_vues,derniere_vue,decision,decision_le";
  /** Leads web (toute ligne de submissions qui a une source : un lead converti en soumission garde sa source), par pages de 1000. */
  async function lireLeads() {
    const sb = window.RAYCAST_SUPABASE; if (!sb) throw new Error("Supabase indisponible");
    const out = [];
    for (let i = 0; i < 20; i++) {
      const { data, error } = await sb.from("submissions").select(COLS_LEADS).not("source", "is", null).order("created_at", { ascending: false }).range(i * 1000, i * 1000 + 999);
      if (error) throw new Error(error.message || "lecture des leads refusée");
      out.push(...(data || [])); if (!data || data.length < 1000) break;
    }
    return out;
  }
  async function lireLiens() {
    const sb = window.RAYCAST_SUPABASE; if (!sb) return [];
    const { data, error } = await sb.from("proposition_liens").select(COLS_LIENS).neq("etat", "preparation").order("created_at", { ascending: false }).limit(1000);
    if (error) throw new Error(error.message || "lecture des propositions refusée");
    return data || [];
  }
  /** Liste unifiée des clients : celle que la coquille précharge à la connexion (un seul appel), sinon le worker. */
  async function lireClients() {
    const C = window.ClientsCache;
    if (C && C.precharger) {
      const e = C.etat ? C.etat() : null;
      // Liste déjà en mémoire : on la consulte par recherche (téléphone, courriel) au lieu de la relire, aucun nouvel appel au worker
      if (e && e.charge && !e.enCours && C.filtrer) return { parRecherche: C.filtrer };
      const c = await C.precharger(); if (c && Array.isArray(c.rows)) return c.rows;
    }
    const w = await worker("/raycast/clients"); return Array.isArray(w.clients) ? w.clients : [];
  }
  function charger(force) {
    if (!force && cacheSrc && Date.now() - cacheSrc.at < CACHE_MS) return cacheSrc.promesse;
    const promesse = (async () => {
      const noms = ["pipe", "ventes", "leads", "clients", "liens"];
      const r = await Promise.allSettled([worker("/raycast/pipeline"), worker("/raycast/ventes-produits"), lireLeads(), lireClients(), lireLiens()]);
      const src = { erreurs: {}, charge_le: Date.now() };
      r.forEach((x, i) => { if (x.status === "fulfilled") src[noms[i]] = x.value; else { src[noms[i]] = null; src.erreurs[noms[i]] = texte(x.reason); } });
      return src;
    })();
    cacheSrc = { at: Date.now(), promesse };
    promesse.catch(() => { if (cacheSrc && cacheSrc.promesse === promesse) cacheSrc = null; });
    return promesse;
  }
  /** Dépense Meta des N derniers jours (somme des campagnes) par le relais ; null si le relais ne répond pas. */
  function metaJours(n) {
    if (n <= 0) return Promise.resolve(0);
    const c = cacheMeta[n]; if (c && Date.now() - c.at < 10 * 60000) return c.promesse;
    const promesse = (window.RaycastProxy ? window.RaycastProxy.fetch("meta", "/ads/campaigns", { days: n }) : Promise.reject(new Error("relais absent")))
      .then(j => { const cs = Array.isArray(j && j.campaigns) ? j.campaigns : null; if (!cs) throw new Error("réponse Meta illisible"); return cs.reduce((s, x) => s + (Number(x && x.spend) || 0), 0); });
    cacheMeta[n] = { at: Date.now(), promesse };
    promesse.catch(() => { delete cacheMeta[n]; });
    return promesse;
  }
  /** Dépense Meta d'une fenêtre [a, b) = dépense des jours depuis a moins celle des jours depuis b (fenêtres glissantes du relais). */
  async function metaFenetre(w, auj) {
    const demain = addJ(auj, 1), na = ecartJ(w.a, demain), nb = Math.max(0, ecartJ(w.b, demain));
    if (na > 400) return null; // le relais Meta n'est pas interrogé au-delà de 400 jours
    const [sa, sbv] = await Promise.all([metaJours(na), metaJours(nb)]);
    return Math.max(0, sa - sbv);
  }

  // ════════════════════════════ Modèle : rapprochements et calculs purs ════════════════════════════
  const ACCEPTE = (d) => /accept|closed/i.test(String(d.statut || ""));
  function construire(src, auj) {
    const pipe = src.pipe, ventes = src.ventes;
    const docs = (pipe && Array.isArray(pipe.docs) ? pipe.docs : []).map(d => ({ ...d, date: jourDe(d.date), ht: Number(d.ht) || 0, solde: Number(d.solde) || 0, client: d.client || "Client sans nom", client_id: d.client_id != null ? String(d.client_id) : "", numero: d.numero || "" })).filter(d => d.date);
    const pipeSync = pipe && pipe.synced_at ? jourDe(pipe.synced_at) : null;
    const pipeDebut = pipeSync ? addJ(pipeSync, -365) : null;
    const pipeFin = pipeSync ? addJ(pipeSync, 1) : null;
    const parClient = new Map();
    for (const d of docs) { if (!d.client_id) continue; if (!parClient.has(d.client_id)) parClient.set(d.client_id, []); parClient.get(d.client_id).push(d); }
    for (const l of parClient.values()) l.sort((a, b) => a.date.localeCompare(b.date));
    // Mois QuickBooks (ventes-produits) : total HT, nombre de factures et articles par mois
    const mois = new Map();
    for (const m of (ventes && Array.isArray(ventes.mois) ? ventes.mois : [])) if (m && /^\d{4}-\d{2}$/.test(String(m.mois))) mois.set(String(m.mois), { total_ht: Number(m.total_ht) || 0, factures: Number(m.factures) || 0, par_article: m.par_article && typeof m.par_article === "object" ? m.par_article : {} });
    // Index des clients (téléphone, courriel, clés apprises) → fiche unifiée (qbo_id)
    const idx = new Map();
    const clesClient = (c) => [tel10(c.telephone), mel(c.courriel), ...(Array.isArray(c.cles) ? c.cles.map(k => tel10(k) || mel(k)) : [])];
    for (const c of (Array.isArray(src.clients) ? src.clients : [])) for (const k of clesClient(c)) if (k && !idx.has(k)) idx.set(k, c);
    const recherche = src.clients && typeof src.clients.parRecherche === "function" ? src.clients.parRecherche : null;
    const clientDe = (k) => {
      if (!k) return null;
      if (idx.has(k)) return idx.get(k);
      if (!recherche) return null;
      let r = null; try { const f = recherche(k); r = (f && Array.isArray(f.lignes) ? f.lignes : []).find(c => clesClient(c).includes(k)) || null; } catch (e) { r = null; }
      idx.set(k, r); return r;
    };
    // Leads : tests exclus, page, canal, système, rapprochement avec le client QuickBooks et ses devis et factures après le lead
    const leads = [];
    for (const l of (Array.isArray(src.leads) ? src.leads : [])) {
      if (!l || estTest(l)) continue;
      const jour = jourDe(l.created_at); if (!jour) continue;
      const tel = tel10(l.lead_phone || l.client_phone), courriel = mel(l.lead_email || l.client_email);
      const page = pageDe(l), canal = canalDe(l), systeme = systemeDe(page, l.project_type);
      const client = clientDe(tel) || clientDe(courriel) || null;
      const qbo = client && client.sources && client.sources.qbo_id ? String(client.sources.qbo_id) : "";
      const apres = qbo ? (parClient.get(qbo) || []).filter(d => d.date >= addJ(jour, -1)) : [];
      const devis = apres.filter(d => d.type === "devis"), factures = apres.filter(d => d.type === "facture");
      const score = l.lead_score == null || l.lead_score === "" ? null : Number(l.lead_score);
      const statut = String(l.status || "lead");
      leads.push({
        id: l.id, jour, created_at: l.created_at, nom: l.client_name || "", statut, page, canal, canalLp: canalLpDe(l), source: String(l.source || ""), systeme, projet: l.project_type || "", score, qualifie: score != null && score >= SEUIL_QUALIFIE,
        tel, courriel, personne: tel || courriel || "id:" + l.id, client, qbo, cle: client ? client.cle : null,
        // Étapes emboîtées : une facture vaut une acceptation, une acceptation vaut un devis (une vente facturée sans devis compte partout)
        devis: devis[0] || null, nbDevis: devis.length, facture: factures[0] || null,
        accepte: devis.some(ACCEPTE) || statut === "accepte" || !!factures[0],
        soumis: !!devis[0] || !!factures[0] || /^(envoye|accepte|refuse)$/.test(statut), traite: statut !== "lead" || !!devis[0] || !!factures[0],
      });
    }
    leads.sort((a, b) => String(b.created_at).localeCompare(String(a.created_at)));
    const leadsDebut = leads.length ? leads.reduce((m, l) => l.jour < m ? l.jour : m, leads[0].jour) : null;
    return { auj, docs, pipeSync, pipeDebut, pipeFin, synced_at: pipe && pipe.synced_at, ventesSync: ventes && ventes.synced_at, mois, leads, leadsDebut, liens: Array.isArray(src.liens) ? src.liens : [], paniers: ventes && ventes.paniers, erreurs: src.erreurs || {}, sources: { pipe: !!pipe, ventes: !!ventes, leads: Array.isArray(src.leads), clients: Array.isArray(src.clients) || !!recherche, liens: Array.isArray(src.liens) } };
  }
  const pipeCouvre = (M, a, b) => !!M.pipeDebut && a >= M.pipeDebut && b <= M.pipeFin;
  const sommePipe = (M, type, a, b) => M.docs.filter(d => d.type === type && d.date >= a && d.date < b).reduce((s, d) => s + d.ht, 0);
  /** Ventes facturées HT sur [a, b) : mois QuickBooks complets, factures du jour quand le mois est partiel ; null si rien ne couvre. */
  function ventesEntre(M, a, b) {
    if (!(a < b)) return 0;
    let tot = 0;
    for (let m = debutMois(a); m < b; m = addM(m, 1)) {
      const mf = addM(m, 1), x = a > m ? a : m, y = b < mf ? b : mf, mens = M.mois.get(m.slice(0, 7));
      const encours = mf > M.auj && y >= addJ(M.auj, 1); // mois en cours couvert jusqu'à aujourd'hui
      if (x === m && (y === mf || encours) && mens) { tot += mens.total_ht; continue; }
      if (pipeCouvre(M, x, y)) { tot += sommePipe(M, "facture", x, y); continue; }
      // Mois partiel hors de la fenêtre des factures : total du mois moins la partie couverte par les factures du jour
      if (mens && (x === m || pipeCouvre(M, m, x)) && (y === mf || pipeCouvre(M, y, mf))) { tot += mens.total_ht - (x > m ? sommePipe(M, "facture", m, x) : 0) - (y < mf ? sommePipe(M, "facture", y, mf) : 0); continue; }
      return null;
    }
    return tot;
  }
  /** Articles vendus sur une fenêtre alignée sur des mois (mois complets, ou mois en cours jusqu'à aujourd'hui) ; null sinon. */
  function articlesEntre(M, w) {
    if (w.a !== debutMois(w.a)) return null;
    const out = []; const finCourante = addJ(M.auj, 1);
    for (let m = w.a; m < w.b; m = addM(m, 1)) {
      const mf = addM(m, 1); if (mf > w.b && !(w.b === finCourante && m === debutMois(M.auj))) return null;
      const x = M.mois.get(m.slice(0, 7)); if (!x) return null;
      for (const [id, art] of Object.entries(x.par_article)) out.push({ id, nom: String(art && art.nom || ""), qty: Number(art && art.qty) || 0, montant: Number(art && art.montant) || 0, mois: m.slice(0, 7) });
    }
    return out;
  }
  function mixFamilles(arts) {
    const f = Object.fromEntries(FAMILLES.map(([k]) => [k, 0]));
    for (const a of arts) f[familleDe(a.nom)] += a.montant;
    return f;
  }
  function topProduits(arts) {
    const p = new Map();
    for (const a of arts) { const x = produitDe(a.nom); if (!x) continue; const c = p.get(x.k) || { k: x.k, label: x.label, qty: 0, montant: 0 }; c.qty += a.qty; c.montant += a.montant; p.set(x.k, c); }
    return [...p.values()].filter(x => x.montant > 0).sort((a, b) => b.montant - a.montant);
  }
  /** Leads de la fenêtre, une ligne par personne (téléphone, sinon courriel) : la première demande de la période compte. */
  function personnes(leads) {
    const vu = new Map();
    for (const l of [...leads].sort((a, b) => a.jour.localeCompare(b.jour))) if (!vu.has(l.personne)) vu.set(l.personne, l);
    return [...vu.values()];
  }
  const mediane = (xs) => { if (!xs.length) return null; const s = [...xs].sort((a, b) => a - b), m = Math.floor(s.length / 2); return s.length % 2 ? s[m] : (s[m - 1] + s[m]) / 2; };

  // ─── Calcul d'un indicateur sur une fenêtre : { v } ou { v: null, raison } (jamais estimé) ───
  const leadsCouvre = (M, w) => !!M.leadsDebut && w.a >= M.leadsDebut;
  const raisonLeads = (M) => M.leadsDebut ? `leads web enregistrés dans RAYCAST depuis le ${libJour(M.leadsDebut)}` : "aucun lead lu dans Supabase";
  const raisonPipe = (M) => M.pipeDebut ? `devis et factures QuickBooks relus sur 365 jours (depuis le ${libJour(M.pipeDebut)})` : "devis et factures QuickBooks indisponibles";
  function leadsDe(M, w) { return M.leads.filter(l => dans(l.jour, w)); }
  /** Partie de la fenêtre couverte par les devis et factures QuickBooks relus au jour près (null : rien de couvert). */
  const pipeEff = (M, w) => { if (!M.pipeDebut || !M.sources.pipe) return null; const a = w.a > M.pipeDebut ? w.a : M.pipeDebut, b = w.b < M.pipeFin ? w.b : M.pipeFin; if (a >= b) return null; return { a, b, partiel: a > w.a, depuis: a > w.a ? a : null }; };
  const avecPipe = (M, e, r) => e.partiel ? { ...r, partiel: true, depuis: e.depuis, raison: raisonPipe(M) } : r;
  /** Début réel d'une fenêtre de leads (premier lead enregistré si la fenêtre commence avant). */
  const debutLeads = (M, w) => M.leadsDebut && M.leadsDebut > w.a ? M.leadsDebut : w.a;
  const avecLeads = (M, w, r) => leadsCouvre(M, w) ? r : { ...r, partiel: true, depuis: M.leadsDebut, raison: raisonLeads(M) };
  const conversionCouverte = (M, w) => M.sources.leads && M.sources.pipe && M.sources.clients && pipeCouvre(M, addJ(debutLeads(M, w), -1), w.b < M.pipeFin ? w.b : M.pipeFin);
  const IND = {
    leads: (M, w) => { if (!M.sources.leads) return { v: null, raison: "leads Supabase indisponibles" }; return avecLeads(M, w, { v: leadsDe(M, w).length }); },
    qualifies: (M, w) => { if (!M.sources.leads) return { v: null, raison: "leads Supabase indisponibles" }; const L = leadsDe(M, w).filter(l => l.score != null); if (!L.length) return { v: null, raison: "aucun lead noté sur la période" }; return avecLeads(M, w, { v: L.filter(l => l.qualifie).length / L.length * 100, n: L.length }); },
    tauxDevis: (M, w) => { if (!M.sources.leads || !M.sources.pipe || !M.sources.clients) return { v: null, raison: "leads, clients ou devis QuickBooks indisponibles" }; if (!conversionCouverte(M, w)) return { v: null, raison: raisonPipe(M) }; const P = personnes(leadsDe(M, w)); if (!P.length) return { v: null, raison: "aucun lead sur la période" }; return avecLeads(M, w, { v: P.filter(l => l.soumis).length / P.length * 100, n: P.length }); },
    delai: (M, w) => { if (!M.sources.leads || !M.sources.pipe || !M.sources.clients) return { v: null, raison: "leads, clients ou devis QuickBooks indisponibles" }; if (!conversionCouverte(M, w)) return { v: null, raison: raisonPipe(M) }; const d = personnes(leadsDe(M, w)).filter(l => l.devis).map(l => ecartJ(l.jour, l.devis.date)).filter(x => x >= 0); if (!d.length) return { v: null, raison: "aucun lead devenu devis sur la période" }; return avecLeads(M, w, { v: mediane(d), n: d.length }); },
    ventes: (M, w) => { const v = (M.sources.ventes || M.sources.pipe) ? ventesEntre(M, w.a, w.b) : null; return v == null ? { v: null, raison: M.sources.ventes ? "factures QuickBooks disponibles depuis décembre 2024 (mois) et sur 365 jours (au jour près)" : "ventes QuickBooks indisponibles" } : { v }; },
    panier: (M, w) => { const e = pipeEff(M, w); if (!e) return { v: null, raison: raisonPipe(M) }; const F = M.docs.filter(d => d.type === "facture" && dans(d.date, e)); const cl = new Set(F.map(d => d.client_id || d.client)); return cl.size ? avecPipe(M, e, { v: F.reduce((s, d) => s + d.ht, 0) / cl.size, n: cl.size }) : { v: null, raison: "aucune facture sur la période" }; },
    devis: (M, w) => { const e = pipeEff(M, w); if (!e) return { v: null, raison: raisonPipe(M) }; const D = M.docs.filter(d => d.type === "devis" && dans(d.date, e)); return avecPipe(M, e, { v: D.reduce((s, d) => s + d.ht, 0), n: D.length }); },
    acceptation: (M, w) => { const e = pipeEff(M, w); if (!e) return { v: null, raison: raisonPipe(M) }; const D = M.docs.filter(d => d.type === "devis" && dans(d.date, e)); return D.length ? avecPipe(M, e, { v: D.filter(ACCEPTE).length / D.length * 100, n: D.length }) : { v: null, raison: "aucun devis sur la période" }; },
    leadsMeta: (M, w) => { if (!M.sources.leads) return { v: null, raison: "leads Supabase indisponibles" }; return avecLeads(M, w, { v: leadsDe(M, w).filter(l => l.canal === "meta").length }); },
  };
  // Instantanés (pas d'historique : aucune comparaison possible)
  function pipelineOuvert(M) { const lim = addJ(M.auj, -60); return M.docs.filter(d => d.type === "devis" && /pending/i.test(String(d.statut || "")) && d.date >= lim); }
  function soldes(M) { return M.docs.filter(d => d.type === "facture" && d.solde > 0.005).sort((a, b) => b.solde - a.solde); }

  // ════════════════════════════ Composants graphiques ════════════════════════════
  /** Largeur réelle du conteneur (le SVG est dessiné en pixels : le texte ne rapetisse jamais sur mobile). */
  function useLargeur(defaut) {
    const ref = useRef(null); const [w, setW] = useState(defaut || 600);
    useEffect(() => {
      const el = ref.current; if (!el) return;
      const maj = () => { const x = Math.floor(el.getBoundingClientRect().width); if (x > 0) setW(x); };
      maj();
      if (typeof ResizeObserver === "undefined") { window.addEventListener("resize", maj); return () => window.removeEventListener("resize", maj); }
      const ro = new ResizeObserver(maj); ro.observe(el); return () => ro.disconnect();
    }, []);
    return [ref, w];
  }
  /** Graduations « rondes » de 0 à au moins max. */
  function graduations(max, n = 4) {
    if (!(max > 0)) return [0, 1];
    const brut = max / n, p = Math.pow(10, Math.floor(Math.log10(brut))), f = brut / p;
    const pas = (f <= 1 ? 1 : f <= 2 ? 2 : f <= 2.5 ? 2.5 : f <= 5 ? 5 : 10) * p;
    const out = []; for (let v = 0; v <= max + pas * 0.001; v += pas) out.push(Math.round(v * 1000) / 1000);
    if (out[out.length - 1] < max) out.push(out[out.length - 1] + pas);
    return out;
  }
  function Bulle({ pos, largeur, children }) {
    if (!pos) return null;
    const gauche = Math.max(0, Math.min(pos.x + 14, largeur - 230));
    const droite = pos.x + 14 > largeur - 230;
    return <div className="an-bulle" role="status" style={droite ? { left: Math.max(0, pos.x - 244), top: pos.y } : { left: gauche, top: pos.y }}>{children}</div>;
  }
  const LigneBulle = ({ cl, v, lib, ligne }) => <div className="an-bulle-r"><i className={"an-cle " + cl + (ligne ? " ligne" : "")} /><b>{v}</b><span>{lib}</span></div>;
  /** Barre verticale à bout arrondi (4 px), carrée sur la ligne de base. */
  const cheminColonne = (x, y, w, h, r) => { if (h <= 0) return ""; const rr = Math.min(r, h, w / 2); return `M${x},${y + h}V${y + rr}Q${x},${y} ${x + rr},${y}H${x + w - rr}Q${x + w},${y} ${x + w},${y + rr}V${y + h}Z`; };

  /** Courbes (tendance) : viseur vertical qui suit le pointeur, une bulle pour toutes les séries, clic → onClic(clé). */
  function Courbes({ x, libX, libLong, series, fmt, fmtAxe, hauteur = 220, onClic, note, titre }) {
    const [ref, W] = useLargeur(600);
    const [i, setI] = useState(null);
    const g = 44, d = 14, h = 14, bas = 26, pw = Math.max(40, W - g - d), ph = hauteur - h - bas;
    const max = Math.max(1, ...series.flatMap(s => s.v.filter(v => v != null)));
    const ticks = graduations(max, 4), top = ticks[ticks.length - 1] || 1;
    const X = (k) => g + (x.length > 1 ? (k * pw) / (x.length - 1) : pw / 2), Y = (v) => h + ph - (v / top) * ph;
    const pas = Math.max(1, Math.ceil((x.length * 52) / pw));
    const chemin = (v) => { let s = ""; v.forEach((y, k) => { if (y == null) return; s += (s && v[k - 1] != null ? "L" : "M") + X(k).toFixed(1) + "," + Y(y).toFixed(1); }); return s; };
    const choisir = (ev) => { const svg = ev.currentTarget.ownerSVGElement || ev.currentTarget; const r = svg.getBoundingClientRect(); const px = ev.clientX - r.left; const k = Math.round(((px - g) / pw) * (x.length - 1)); setI(Math.max(0, Math.min(x.length - 1, k))); };
    const clavier = (ev) => { if (ev.key === "ArrowRight") { setI(k => Math.min(x.length - 1, k == null ? 0 : k + 1)); ev.preventDefault(); } else if (ev.key === "ArrowLeft") { setI(k => Math.max(0, k == null ? x.length - 1 : k - 1)); ev.preventDefault(); } else if ((ev.key === "Enter" || ev.key === " ") && i != null && onClic) { onClic(x[i]); ev.preventDefault(); } };
    const der = series[0] && series[0].v; let kDer = der ? der.length - 1 : -1; while (kDer >= 0 && der[kDer] == null) kDer--;
    return (
      <div className="an-graph" ref={ref}>
        <svg width={W} height={hauteur} role="img" aria-label={titre || "Courbes"} tabIndex={0} onKeyDown={clavier} onBlur={() => setI(null)}>
          {ticks.map(t => <g key={t}><line x1={g} x2={g + pw} y1={Y(t)} y2={Y(t)} className={t === 0 ? "an-axe-l" : "an-grid-l"} /><text x={g - 8} y={Y(t) + 4} textAnchor="end" className="an-axe-t">{fmtAxe ? fmtAxe(t) : nbFr(t)}</text></g>)}
          {x.map((k, j) => (j % pas === 0 || j === x.length - 1) && (j === x.length - 1 || x.length - 1 - j >= pas) ? <text key={k} x={X(j)} y={hauteur - 8} textAnchor="middle" className="an-axe-t">{libX(k)}</text> : null)}
          {i != null && <line x1={X(i)} x2={X(i)} y1={h} y2={h + ph} className="an-viseur" />}
          {series.slice().reverse().map(s => <path key={s.k} d={chemin(s.v)} className={"an-trait " + s.cl} />)}
          {series.map(s => s.v.map((v, k) => v != null && (k === i || (s === series[0] && k === kDer && i == null)) ? <circle key={s.k + k} cx={X(k)} cy={Y(v)} r="4.5" className={"an-pt " + s.cl} /> : null))}
          {kDer >= 0 && i == null && der[kDer] != null && <text x={Math.min(X(kDer), g + pw)} y={Math.max(11, Y(der[kDer]) - 10)} textAnchor="end" className="an-val-t">{fmt(der[kDer])}</text>}
          <rect x={g - 6} y={h} width={pw + 12} height={ph + 6} fill="transparent" style={{ cursor: onClic ? "pointer" : "crosshair" }} onPointerMove={choisir} onPointerDown={choisir} onPointerLeave={() => setI(null)} onClick={() => { if (onClic && i != null) onClic(x[i]); }} />
        </svg>
        {i != null && <Bulle pos={{ x: X(i), y: 4 }} largeur={W}>
          <div className="an-bulle-t">{libLong ? libLong(x[i]) : x[i]}</div>
          {series.map(s => <LigneBulle key={s.k} cl={s.cl} ligne v={s.v[i] == null ? "n/d" : fmt(s.v[i])} lib={s.libPoint ? s.libPoint(x[i]) : s.label} />)}
          {note && note(i) && <div className="an-bulle-note">{note(i)}</div>}
          {onClic && <div className="an-bulle-note">Clic : voir les factures</div>}
        </Bulle>}
      </div>
    );
  }

  /** Colonnes empilées (une catégorie par mois) : 2 px de surface entre les segments, bout arrondi en haut, bulle par colonne. */
  function Colonnes({ x, libX, libLong, series, valeurs, fmt, hauteur = 220, onClic, choisi, titre }) {
    const [ref, W] = useLargeur(600);
    const [i, setI] = useState(null);
    const g = 34, d = 8, h = 16, bas = 26, pw = Math.max(40, W - g - d), ph = hauteur - h - bas;
    const tot = valeurs.map(v => v.reduce((s, y) => s + (y || 0), 0));
    const ticks = graduations(Math.max(1, ...tot), 4), top = ticks[ticks.length - 1] || 1;
    const bande = pw / Math.max(1, x.length), bw = Math.min(24, Math.max(6, bande * 0.56));
    const Y = (v) => h + ph - (v / top) * ph;
    const pas = Math.max(1, Math.ceil((x.length * 44) / pw));
    return (
      <div className="an-graph" ref={ref}>
        <svg width={W} height={hauteur} role="img" aria-label={titre || "Colonnes"}>
          {ticks.map(t => <g key={t}><line x1={g} x2={g + pw} y1={Y(t)} y2={Y(t)} className={t === 0 ? "an-axe-l" : "an-grid-l"} /><text x={g - 7} y={Y(t) + 4} textAnchor="end" className="an-axe-t">{nbFr(t)}</text></g>)}
          {x.map((k, j) => {
            const cx = g + bande * j + bande / 2, x0 = cx - bw / 2; let y = h + ph; const segs = [];
            const vis = series.map((s, si) => ({ s, v: valeurs[j][si] || 0 })).filter(z => z.v > 0);
            vis.forEach((z, zi) => { const hh = (z.v / top) * ph; const haut = zi === vis.length - 1; const y0 = y - hh; const gap = zi > 0 ? 2 : 0; segs.push(haut ? <path key={z.s.k} d={cheminColonne(x0, y0, bw, Math.max(0, hh - gap), 4)} className={"an-mark " + z.s.cl} /> : <rect key={z.s.k} x={x0} y={y0} width={bw} height={Math.max(0, hh - gap)} className={"an-mark " + z.s.cl} />); y = y0; });
            return (
              <g key={k} className={"an-col" + (choisi === k ? " on" : "")} tabIndex={0} role="button" aria-label={`${libLong ? libLong(k) : k} : ${tot[j]}`}
                onPointerEnter={() => setI(j)} onPointerLeave={() => setI(null)} onFocus={() => setI(j)} onBlur={() => setI(null)}
                onClick={() => onClic && onClic(k)} onKeyDown={(ev) => { if ((ev.key === "Enter" || ev.key === " ") && onClic) { onClic(k); ev.preventDefault(); } }}>
                <rect x={g + bande * j} y={h} width={bande} height={ph} fill="transparent" />
                {segs}
                {(j === x.length - 1 || j === i) && tot[j] > 0 && <text x={cx} y={Math.max(11, y - 6)} textAnchor="middle" className="an-val-t">{nbFr(tot[j])}</text>}
                {(j % pas === 0 || j === x.length - 1) && (j === x.length - 1 || x.length - 1 - j >= pas) && <text x={cx} y={hauteur - 8} textAnchor="middle" className="an-axe-t">{libX(k)}</text>}
              </g>
            );
          })}
        </svg>
        {i != null && <Bulle pos={{ x: g + bande * i + bande / 2, y: 2 }} largeur={W}>
          <div className="an-bulle-t">{libLong ? libLong(x[i]) : x[i]}</div>
          {series.map((s, si) => <LigneBulle key={s.k} cl={s.cl} v={fmt(valeurs[i][si] || 0)} lib={s.label} />)}
          <div className="an-bulle-note">Total : {fmt(tot[i])}{onClic ? " · clic : voir la liste" : ""}</div>
        </Bulle>}
      </div>
    );
  }

  /** Barres horizontales classées (une seule teinte), valeur au bout, bulle au survol, clic → onClic(clé). */
  function Barres({ lignes, fmt, onClic, choisi, ctx, detail }) {
    const [i, setI] = useState(null);
    const [ref, W] = useLargeur(500);
    if (!lignes.length) return <p className="an-vide">Aucune donnée pour la période.</p>;
    const max = Math.max(1, ...lignes.map(l => l.v || 0));
    return (
      <div className="an-graph" ref={ref}>
        <div className="an-barres">
          {lignes.map((l, j) => (
            <button key={l.k} type="button" className="an-barre" aria-pressed={choisi === l.k} onClick={() => onClic && onClic(l.k)} onPointerEnter={() => setI(j)} onPointerLeave={() => setI(null)} onFocus={() => setI(j)} onBlur={() => setI(null)}>
              <span className="an-barre-lib">{l.label}{l.sous && <small>{l.sous}</small>}</span>
              <span className="an-barre-piste"><span className={"an-barre-plein" + (ctx ? " ctx" : "")} style={{ width: `calc(${Math.max(0.6, ((l.v || 0) / max) * 100)}% - ${((l.v || 0) / max) * 96}px)` }} /><span className="an-barre-v">{fmt(l.v || 0)}{l.suffixe && <span>{l.suffixe}</span>}</span></span>
            </button>
          ))}
        </div>
        {i != null && detail && <Bulle pos={{ x: Math.min(W - 10, W * 0.5), y: 6 + i * 34 }} largeur={W}>{detail(lignes[i])}</Bulle>}
      </div>
    );
  }

  // ════════════════════════════ Pièces d'interface ════════════════════════════
  /** Écart entre deux valeurs : « ▲ 156,3 k$ (+141 %) » ; points pour un taux. */
  function ecart(v, r, genre) {
    if (v == null || r == null) return null;
    const dv = v - r, signe = dv > 0 ? "▲" : dv < 0 ? "▼" : "=";
    if (genre === "taux") return { txt: `${signe} ${nbFr(Math.abs(dv), 0)} pt${Math.abs(dv) >= 2 ? "s" : ""}`, dv };
    const absTxt = genre === "argent" ? fmtK(Math.abs(dv)) : nbFr(Math.abs(dv), 0);
    const pc = r ? ` (${dv >= 0 ? "+" : "−"}${nbFr(Math.abs(dv / r) * 100, 0)} %)` : (v ? " (nouveau)" : "");
    return { txt: `${signe} ${absTxt}${pc}`, dv };
  }
  function Delta({ cur, ref_, genre, sens, lib }) {
    if (!ref_ || (cur && cur.attente) || ref_.attente) return null;
    if (cur == null || cur.v == null || ref_.v == null || ref_.partiel || cur.partiel) {
      const raison = (ref_ && ref_.raison) || (cur && cur.raison) || "donnée absente";
      return <span className="an-delta" data-sens="nd" title={`Comparaison impossible : ${raison}.`}>n/d <span>vs {lib}</span></span>;
    }
    const e = ecart(cur.v, ref_.v, genre); if (!e) return null;
    const s = e.dv === 0 || !sens ? "neutre" : (e.dv > 0) === (sens > 0) ? "bon" : "mauvais";
    return <span className="an-delta" data-sens={s}>{e.txt} <span>vs {lib}</span></span>;
  }
  /** Tuile d'indicateur : libellé, valeur, deux écarts (période d'avant, an passé), source ; cliquable vers sa liste. */
  function Tuile({ def, F, M, actif, onClic }) {
    const cur = def.calc(M, F.cur), prev = F.prev ? def.calc(M, F.prev) : null, ly = F.ly ? def.calc(M, F.ly) : null;
    const val = cur.attente ? "…" : cur.v == null ? "n/d" : def.fmt(cur.v);
    const titre = `${def.label} : ${cur.v == null ? "non disponible (" + (cur.raison || "donnée absente") + ")" : def.fmtLong ? def.fmtLong(cur.v) : val}. Source : ${def.source}${def.calcul ? ". Calcul : " + def.calcul : ""}${cur.partiel ? `. Attention : ${cur.raison}` : ""}.`;
    return (
      <button type="button" className="an-tuile" data-ind={def.k} aria-pressed={!!actif} title={titre} onClick={onClic}>
        <span className="an-tuile-lib">{def.label}</span>
        <span className="an-tuile-val">{val}{def.unite && cur.v != null && <small>{def.unite(cur)}</small>}</span>
        {def.sous && cur.v != null && <span className="an-tuile-sub">{def.sous(cur, M, F)}</span>}
        {cur.partiel && cur.v != null && cur.depuis && <span className="an-tuile-sub">depuis le {libJour(cur.depuis)}</span>}
        {def.instantane ? <span className="an-delta" data-sens="nd" title="Instantané : QuickBooks ne garde pas l'historique de ce montant, aucune comparaison possible.">instantané, aujourd'hui</span> : <>
          <Delta cur={cur} ref_={prev} genre={def.genre} sens={def.sens} lib={F.prev.lib} />
          {F.ly && <Delta cur={cur} ref_={ly} genre={def.genre} sens={def.sens} lib={F.ly.lib} />}
        </>}
        <span className="an-src">{def.sourceCourte}</span>
      </button>
    );
  }
  function SelecteurPeriode({ periode, setPeriode, F }) {
    return (
      <div className="an-filtres">
        <div className="an-seg" role="group" aria-label="Période">
          {PERIODES.map(([k, l]) => <button key={k} type="button" aria-pressed={periode === k} onClick={() => setPeriode(k)}>{l}</button>)}
        </div>
        <span className="an-periode-lib">{F.cur.lib}, comparé {F.prev.de || "à " + F.prev.lib}{F.ly ? ` et ${F.ly.de || "à " + F.ly.lib}` : ""}</span>
      </div>
    );
  }
  // Période partagée entre le tableau de bord et Analytics (même session) ; mémorisée dans le navigateur si possible.
  let periodeMemo = (() => { try { return localStorage.getItem("raycast_analyses_periode") || "mois"; } catch (e) { return "mois"; } })();
  function usePeriode() {
    const [p, setP] = useState(PERIODES.some(([k]) => k === periodeMemo) ? periodeMemo : "mois");
    const changer = useCallback((k) => { periodeMemo = k; try { localStorage.setItem("raycast_analyses_periode", k); } catch (e) { /* navigation privée */ } setP(k); }, []);
    return [p, changer];
  }
  function useDonnees() {
    const [src, setSrc] = useState(null);
    const [charge, setCharge] = useState(false);
    const [version, setVersion] = useState(0);
    useEffect(() => {
      let vivant = true;
      charger(version > 0).then(s => { if (vivant) { setSrc(s); setCharge(true); } }).catch(e => { if (vivant) { setSrc({ erreurs: { tout: texte(e) } }); setCharge(true); } });
      return () => { vivant = false; };
    }, [version]);
    const M = useMemo(() => src ? construire(src, aujourdhui()) : null, [src]);
    return { M, charge, rafraichir: () => setVersion(v => v + 1) };
  }
  /** Dépense Meta des fenêtres de la période (null : relais indisponible). curClip : la période courante ramenée au premier lead
   *  enregistré dans RAYCAST, pour un coût par lead qui ne divise pas une dépense par des leads jamais enregistrés. */
  function useMeta(F, actif, debutLeads) {
    const [m, setM] = useState({});
    const clip = debutLeads && debutLeads > F.cur.a && debutLeads < F.cur.b ? { a: debutLeads, b: F.cur.b } : null;
    const cle = F.cur.a + F.cur.b + (F.prev ? F.prev.a : "") + (F.ly ? F.ly.a : "") + (clip ? clip.a : "");
    useEffect(() => {
      if (!actif) return;
      let vivant = true; const auj = aujourdhui();
      const lire = (w) => w ? metaFenetre(w, auj).then(v => v == null ? { v: null, raison: "fenêtre trop ancienne pour le relais Meta" } : { v }, e => ({ v: null, raison: "relais Meta indisponible (" + texte(e) + ")" })) : Promise.resolve(null);
      Promise.all([lire(F.cur), lire(F.prev), lire(F.ly), lire(clip)]).then(([c, p, l, cc]) => { if (vivant) setM({ cle, cur: c, prev: p, ly: l, curClip: cc ? { ...cc, depuis: clip.a } : null }); });
      return () => { vivant = false; };
    }, [cle, actif]); // eslint-disable-line
    return m.cle === cle ? m : { cle, attente: true };
  }
  const MSG_ERREURS = { pipe: "devis et factures QuickBooks", ventes: "ventes par mois QuickBooks", leads: "leads Supabase", clients: "liste des clients", liens: "propositions en ligne", tout: "données" };
  function Erreurs({ M }) {
    const e = M ? M.erreurs : {}; const k = Object.keys(e || {});
    if (!k.length) return null;
    return <div className="an-erreur" role="alert">Données indisponibles pour le moment : {k.map(x => `${MSG_ERREURS[x] || x} (${e[x]})`).join(", ")}. Les indicateurs qui en dépendent affichent « n/d ».</div>;
  }
  const ouvrirClient = (l) => { const N = window.RaycastNav; if (!N || !N.ouvrirClient) return; if (l.qbo) N.ouvrirClient({ qbo_id: l.qbo, cle: l.cle || undefined }); else if (l.cle) N.ouvrirClient({ cle: l.cle }); else if (l.tel || l.courriel) N.ouvrirClient({ cle: l.tel || l.courriel }); };
  const ouvrirClientQbo = (d) => { const N = window.RaycastNav; if (N && N.ouvrirClient && d.client_id) N.ouvrirClient({ qbo_id: d.client_id }); };
  const nomPropre = (s) => (window.StatutsRE && window.StatutsRE.nomPropre) ? window.StatutsRE.nomPropre(s) : s;
  function etatLead(l) {
    if (l.facture) return { ton: "vert", txt: "Facturé" };
    if (l.accepte) return { ton: "vert", txt: "Accepté" };
    if (l.devis) return { ton: "bleu", txt: `Devis ${l.devis.numero || ""}`.trim() };
    if (l.statut === "refuse") return { ton: "rouge", txt: "Refusé" };
    if (l.statut !== "lead") return { ton: "bleu", txt: "Soumission RAYCAST" };
    const j = ecartJ(l.jour, aujourdhui());
    return j <= 2 ? { ton: "jaune", txt: "Nouveau" } : { ton: "orange", txt: `Sans suite, ${j} j` };
  }
  const CANAL_COURT = { meta: "Meta", google: "Google Ads", autre: "Organique ou direct" };
  /** Liste filtrée d'une sélection (indicateur, barre, mois, page) : lignes cliquables vers la fiche client ou la soumission. */
  function Detail({ sel, onFermer, onOpen }) {
    const ref = useRef(null);
    useEffect(() => { if (sel && ref.current && ref.current.scrollIntoView) ref.current.scrollIntoView({ block: "nearest", behavior: "smooth" }); }, [sel && sel.titre]);
    if (!sel) return null;
    const lignes = sel.lignes || [];
    return (
      <section className="an-panneau an-detail large" ref={ref} aria-label={sel.titre} style={{ marginBottom: 14 }}>
        <div className="an-panneau-tete">
          <div><h2>{sel.titre} <span className="an-compte">{lignes.length}</span></h2>{sel.sous && <p>{sel.sous}</p>}</div>
          <div className="an-actions">{sel.lien && <button type="button" className="an-lien" onClick={sel.lien.fn}>{sel.lien.txt}</button>}<button type="button" className="an-btn" onClick={onFermer}>Fermer</button></div>
        </div>
        {!lignes.length ? <p className="an-vide">{sel.vide || "Rien sur la période."}</p> : (
          <ul className="an-liste">
            {lignes.slice(0, 300).map(r => (
              <li key={r.k}><button type="button" className="an-item" onClick={() => r.ouvrir && r.ouvrir(onOpen)} title={r.titre || ""}>
                <span className="an-item-corps"><span className="an-item-t" style={{ display: "block" }}>{r.t}</span><span className="an-item-s" style={{ display: "block" }}>{r.s}</span></span>
                <span className="an-item-v">{r.v}{r.pill && <span className="an-pill" data-ton={r.pill.ton}>{r.pill.txt}</span>}</span>
              </button></li>
            ))}
          </ul>
        )}
        {lignes.length > 300 && <p className="an-vide">300 premières lignes affichées sur {lignes.length}.</p>}
      </section>
    );
  }
  const ligneLead = (l) => ({ k: "l" + l.id, t: nomPropre(l.nom) || "Sans nom", s: `${libJour(l.jour)} · ${l.page} · ${CANAL_COURT[l.canal]}${l.score != null ? ` · score ${l.score}` : ""}`, v: "", pill: etatLead(l),
    titre: l.qbo || l.cle ? "Ouvrir la fiche client" : "Ouvrir le lead", ouvrir: (onOpen) => { if ((l.qbo || l.cle) && window.RaycastNav && window.RaycastNav.ouvrirClient) ouvrirClient(l); else if (onOpen) onOpen(l.id); } });
  const ligneDoc = (d) => ({ k: d.type + d.id, t: nomPropre(d.client), s: `${d.type === "devis" ? "Devis" : "Facture"} ${d.numero} · ${libJour(d.date)}${d.type === "facture" && d.solde > 0 ? ` · solde ${fmtCAD(d.solde)}` : ""}`, v: fmtCAD(d.ht),
    pill: d.type === "devis" ? (ACCEPTE(d) ? { ton: "vert", txt: "Accepté" } : /reject/i.test(d.statut) ? { ton: "rouge", txt: "Refusé" } : ecartJ(d.date, aujourdhui()) >= 7 ? { ton: "orange", txt: `En attente, ${ecartJ(d.date, aujourdhui())} j` } : { ton: "bleu", txt: "En attente" }) : (d.solde > 0 ? { ton: ecartJ(d.date, aujourdhui()) > 45 ? "orange" : "bleu", txt: ecartJ(d.date, aujourdhui()) > 45 ? `Solde dû, ${ecartJ(d.date, aujourdhui())} j` : "Solde dû" } : { ton: "vert", txt: "Payée" }),
    titre: "Ouvrir la fiche client", ouvrir: () => ouvrirClientQbo(d) });
  const allerAnalytics = (onglet) => { window.__analyticsOnglet = onglet; if (window.RaycastNav && window.RaycastNav.allerA) window.RaycastNav.allerA("analytics"); };

  // ─── Constats : ce qui doit sauter aux yeux (calculés, jamais écrits à la main) ───
  function constats(M, F, meta) {
    const out = [];
    const L = M.leads;
    if (L.length) {
      const metaL = L.filter(l => l.canal === "meta");
      if (metaL.length >= 10) {
        const dernier = metaL.reduce((m, l) => l.jour > m ? l.jour : m, metaL[0].jour), j = ecartJ(dernier, M.auj);
        if (j >= 14) {
          const debut = metaL.reduce((m, l) => l.jour < m ? l.jour : m, metaL[0].jour), moisActifs = Math.max(1, ecartJ(debut, dernier) / 30.44);
          const parMois = metaL.length / moisActifs;
          const pages = {}; for (const l of metaL) pages[l.page] = (pages[l.page] || 0) + 1; const top = Object.entries(pages).sort((a, b) => b[1] - a[1])[0];
          out.push({ k: "meta", ton: "rouge", txt: <>Aucun lead Meta depuis le <b>{libJour(dernier)}</b> ({j} jours). Avant l'arrêt : <b>{nbFr(parMois, 0)} leads Meta par mois</b> ({nbFr(metaL.length)} au total{top ? (top[1] === metaL.length ? <>, tous sur {top[0]}</> : <>, dont {nbFr(top[1])} sur {top[0]}</>) : null}){meta && meta.cur && meta.cur.v === 0 ? <>, et 0 $ dépensé sur la période</> : null}.</>, onglet: "leads" });
        }
      }
      const W = leadsDe(M, F.cur); const parPage = {};
      for (const l of W) { const p = parPage[l.page] || (parPage[l.page] = { n: 0, q: 0, s: 0, ns: 0 }); p.n++; if (l.qualifie) p.q++; if (l.score != null) { p.s += l.score; p.ns++; } }
      const faible = Object.entries(parPage).filter(([, p]) => p.n >= 10 && p.q === 0).sort((a, b) => b[1].n - a[1].n)[0];
      if (faible) out.push({ k: "faible", ton: "orange", txt: <><b>{faible[0]}</b> : {nbFr(faible[1].n)} leads sur la période, aucun qualifié (score moyen {nbFr(faible[1].s / Math.max(1, faible[1].ns), 0)}, seuil {SEUIL_QUALIFIE}).</>, onglet: "leads" });
    }
    return out;
  }
  function Constats({ liste, onVoir }) {
    if (!liste.length) return null;
    return <div className="an-constats">{liste.map(c => <div key={c.k} className="an-constat" data-ton={c.ton} data-constat={c.k}><span className="an-constat-ico" aria-hidden="true">!</span><span>{c.txt}{onVoir && <button type="button" className="an-lien" onClick={() => onVoir(c)}>Voir le détail</button>}</span></div>)}</div>;
  }

  // ════════════════════════════ Définitions des 12 indicateurs (4 groupes) ════════════════════════════
  const leadsSel = (M, F, filtre, titre, sous) => ({ titre, sous, lignes: leadsDe(M, F.cur).filter(filtre).map(ligneLead) });
  function definitions(meta) {
    const metaCalc = (k) => (M, w, F) => { const m = meta || {}; const x = w === F.cur ? m.cur : w === F.prev ? m.prev : w === F.ly ? m.ly : null; if (m.attente) return { v: null, attente: true, raison: "chargement de la dépense Meta" }; if (!x) return { v: null, raison: "relais Meta indisponible" }; if (x.v == null) return x; if (k === "depense") return { v: x.v };
      const n = IND.leadsMeta(M, w); if (n.v == null) return { v: null, raison: n.raison || "leads indisponibles" };
      if (n.partiel) { if (w !== F.cur || !m.curClip || m.curClip.v == null) return { v: null, raison: n.raison }; return n.v ? { v: m.curClip.v / n.v, n: n.v, partiel: true, depuis: m.curClip.depuis, raison: `dépense Meta comptée depuis le ${libJour(m.curClip.depuis)}, premier lead enregistré` } : { v: null, raison: "aucun lead Meta sur la période" }; }
      return n.v ? { v: x.v / n.v, n: n.v } : { v: null, raison: "aucun lead Meta sur la période" }; };
    return [
      { groupe: "Leads", items: [
        { k: "leads", label: "Leads reçus", calc: IND.leads, fmt: (v) => nbFr(v), sens: +1, genre: "nombre", source: "Supabase, table submissions (leads web : landings et formulaire), tests exclus", sourceCourte: "Supabase",
          sous: (c, M, F) => { const L = leadsDe(M, F.cur); return `${nbFr(personnes(L).length)} personnes`; }, clic: (M, F) => leadsSel(M, F, () => true, "Leads reçus", F.cur.lib) },
        { k: "qualifies", label: "Part qualifiée", calc: IND.qualifies, fmt: (v) => pct(v), sens: +1, genre: "taux", source: `Supabase, score GHL v3 à l'arrivée du lead ; qualifié = ${SEUIL_QUALIFIE} et plus (chaud ou brûlant, 3 boules de feu)`, sourceCourte: "Supabase, score GHL",
          sous: (c) => `${nbFr(Math.round(c.v * c.n / 100))} sur ${nbFr(c.n)} leads`, clic: (M, F) => leadsSel(M, F, l => l.qualifie, "Leads qualifiés", `Score ${SEUIL_QUALIFIE} et plus, ${F.cur.lib}`) },
        { k: "tauxDevis", label: "Leads devenus devis", calc: IND.tauxDevis, fmt: (v) => pct(v), sens: +1, genre: "taux", source: "Supabase (leads) rapprochés par téléphone ou courriel de la liste unifiée des clients, puis devis QuickBooks émis après le lead", sourceCourte: "Supabase + QuickBooks",
          calcul: "personnes uniques de la période qui ont reçu un devis QuickBooks (ou une soumission RAYCAST) après leur demande", sous: (c) => `${nbFr(Math.round(c.v * c.n / 100))} sur ${nbFr(c.n)} personnes`,
          clic: (M, F) => ({ titre: "Leads et suite donnée", sous: `Une ligne par personne, ${F.cur.lib}`, lignes: personnes(leadsDe(M, F.cur)).sort((a, b) => Number(b.soumis) - Number(a.soumis) || b.jour.localeCompare(a.jour)).map(ligneLead) }) },
      ] },
      { groupe: "Ventes", items: [
        { k: "ventes", label: "Ventes facturées", calc: IND.ventes, fmt: fmtK, fmtLong: (v) => fmtCAD(v), sens: +1, genre: "argent", source: "QuickBooks, factures HT (worker /raycast/ventes-produits par mois, /raycast/pipeline au jour près)", sourceCourte: "QuickBooks",
          clic: (M, F) => ({ titre: "Factures de la période", sous: pipeCouvre(M, F.cur.a, F.cur.b > M.pipeFin ? M.pipeFin : F.cur.b) ? F.cur.lib : `${F.cur.lib} : seules les factures des 365 derniers jours sont listées`, lignes: M.docs.filter(d => d.type === "facture" && dans(d.date, F.cur)).sort((a, b) => b.ht - a.ht).map(ligneDoc) }) },
        { k: "panier", label: "Panier moyen par client", calc: IND.panier, fmt: fmtK, fmtLong: (v) => fmtCAD(v), sens: +1, genre: "argent", source: "QuickBooks, factures HT de la période divisées par le nombre de clients facturés (acompte et finale d'un même client comptent ensemble)", sourceCourte: "QuickBooks",
          sous: (c) => `${nbFr(c.n)} client${c.n > 1 ? "s" : ""} facturé${c.n > 1 ? "s" : ""}`, clic: (M, F) => {
            const par = new Map(); for (const d of M.docs.filter(x => x.type === "facture" && dans(x.date, F.cur))) { const k = d.client_id || d.client; const c = par.get(k) || { ...d, ht: 0, n: 0 }; c.ht += d.ht; c.n++; par.set(k, c); }
            return { titre: "Clients facturés", sous: F.cur.lib, lignes: [...par.values()].sort((a, b) => b.ht - a.ht).map(c => ({ k: "c" + c.client_id, t: nomPropre(c.client), s: `${c.n} facture${c.n > 1 ? "s" : ""}`, v: fmtCAD(c.ht), ouvrir: () => ouvrirClientQbo(c) })) }; } },
        { k: "devis", label: "Soumissions émises", calc: IND.devis, fmt: fmtK, fmtLong: (v) => fmtCAD(v), sens: +1, genre: "argent", source: "QuickBooks, devis émis HT (worker /raycast/pipeline)", sourceCourte: "QuickBooks",
          sous: (c) => `${nbFr(c.n)} devis`, clic: (M, F) => ({ titre: "Devis émis", sous: F.cur.lib, lignes: M.docs.filter(d => d.type === "devis" && dans(d.date, F.cur)).sort((a, b) => b.date.localeCompare(a.date)).map(ligneDoc) }) },
      ] },
      { groupe: "Pipeline et encaissement", items: [
        { k: "pipeline", label: "Pipeline ouvert", instantane: true, calc: (M) => M.sources.pipe ? { v: pipelineOuvert(M).reduce((s, d) => s + d.ht, 0), n: pipelineOuvert(M).length } : { v: null, raison: "devis QuickBooks indisponibles" }, fmt: fmtK, fmtLong: (v) => fmtCAD(v), source: "QuickBooks, devis en attente (Pending) de moins de 60 jours, HT", sourceCourte: "QuickBooks",
          sous: (c) => `${nbFr(c.n)} devis en attente`, clic: (M) => ({ titre: "Pipeline ouvert", sous: "Devis en attente de moins de 60 jours, les plus gros d'abord", lignes: pipelineOuvert(M).sort((a, b) => b.ht - a.ht).map(ligneDoc) }) },
        { k: "acceptation", label: "Taux d'acceptation", calc: IND.acceptation, fmt: (v) => pct(v), sens: +1, genre: "taux", source: "QuickBooks, devis émis sur la période et acceptés depuis (Accepted ou Closed)", sourceCourte: "QuickBooks",
          sous: (c) => `${nbFr(Math.round(c.v * c.n / 100))} sur ${nbFr(c.n)} devis`, clic: (M, F) => ({ titre: "Devis de la période et leur statut", sous: F.cur.lib, lignes: M.docs.filter(d => d.type === "devis" && dans(d.date, F.cur)).sort((a, b) => Number(ACCEPTE(b)) - Number(ACCEPTE(a)) || b.ht - a.ht).map(ligneDoc) }) },
        { k: "solde", label: "Solde à encaisser", admin: true, instantane: true, calc: (M) => M.sources.pipe ? { v: soldes(M).reduce((s, d) => s + d.solde, 0), n: soldes(M).length } : { v: null, raison: "factures QuickBooks indisponibles" }, fmt: fmtK, fmtLong: (v) => fmtCAD(v), source: "QuickBooks, soldes dus des factures des 365 derniers jours", sourceCourte: "QuickBooks",
          sous: (c, M) => { const vieux = soldes(M).filter(d => ecartJ(d.date, M.auj) > 45).reduce((s, d) => s + d.solde, 0); return `${nbFr(c.n)} facture${c.n > 1 ? "s" : ""}${vieux ? ` · ${fmtK(vieux)} après 45 j` : ""}`; },
          clic: (M) => ({ titre: "Soldes à encaisser", sous: "Factures avec solde dû, les plus gros d'abord", lignes: soldes(M).map(d => ({ ...ligneDoc(d), v: fmtCAD(d.solde) })) }) },
      ] },
      { groupe: "Marketing (Meta)", items: [
        { k: "depenseMeta", label: "Dépense Meta", calc: metaCalc("depense"), fmt: fmtK, fmtLong: (v) => fmtCAD(v), sens: 0, genre: "argent", source: "Meta Ads, toutes les campagnes, par le relais RAYCAST (une période passée = différence de deux fenêtres glissantes)", sourceCourte: "Meta",
          clic: (M, F) => leadsSel(M, F, l => l.canal === "meta", "Leads Meta de la période", "Leads avec un identifiant de clic Meta (fbclid) ou une source utm Facebook"), lienAnalytics: "leads" },
        { k: "cplMeta", label: "Coût par lead Meta", calc: metaCalc("cpl"), fmt: (v) => fmtCAD(v, 2), sens: -1, genre: "argent", source: "Dépense Meta de la période divisée par les leads Meta reçus dans RAYCAST (fbclid ou utm Facebook)", sourceCourte: "Meta + Supabase",
          sous: (c) => `${nbFr(c.n)} leads Meta`, clic: (M, F) => leadsSel(M, F, l => l.canal === "meta", "Leads Meta de la période", F.cur.lib), lienAnalytics: "leads" },
        { k: "leadsMeta", label: "Leads Meta", calc: IND.leadsMeta, fmt: (v) => nbFr(v), sens: +1, genre: "nombre", source: "Supabase, leads avec un identifiant de clic Meta (fbclid) ou une source utm Facebook ou Instagram", sourceCourte: "Supabase",
          sous: (c, M, F) => { const n = leadsDe(M, F.cur).length; return n ? `${pct(c.v / n * 100)} des leads` : ""; }, clic: (M, F) => leadsSel(M, F, l => l.canal === "meta", "Leads Meta de la période", F.cur.lib), lienAnalytics: "leads" },
      ] },
    ];
  }
  function GrilleIndicateurs({ M, F, defs, sel, setSel, admin }) {
    return (
      <div className="an-groupes re-kpis-grid">
        {defs.map(g => {
          const items = g.items.filter(d => admin || !d.admin);
          return (
            <section key={g.groupe} className="an-groupe" aria-label={g.groupe}>
              <h2>{g.groupe}</h2>
              <div className="an-tuiles">
                {items.map(d => {
                  const calc = (MM, w) => d.calc(MM, w, F);
                  return <Tuile key={d.k} def={{ ...d, calc }} F={F} M={M} actif={sel && sel.k === d.k} onClic={() => {
                    if (sel && sel.k === d.k) return setSel(null);
                    const s = d.clic(M, F); setSel({ ...s, k: d.k, lien: d.lienAnalytics ? { txt: "Ouvrir l'analytics des leads", fn: () => allerAnalytics(d.lienAnalytics) } : null });
                  }} />;
                })}
              </div>
            </section>
          );
        })}
      </div>
    );
  }

  // ════════════════════════════ Ventes 12 mois contre l'an passé ════════════════════════════
  function serieVentes(M) {
    const m0 = debutMois(M.auj); const x = []; for (let k = 11; k >= 0; k--) x.push(addM(m0, -k));
    const cur = x.map(m => { const v = ventesEntre(M, m, m === m0 ? addJ(M.auj, 1) : addM(m, 1)); return v; });
    const prev = x.map(m => { const a = addM(m, -12); const b = m === m0 ? anMoins(addJ(M.auj, 1)) : addM(a, 1); return ventesEntre(M, a, b); });
    return { x, cur, prev };
  }
  function PanneauVentes12({ M, onMois, compact }) {
    const s = useMemo(() => serieVentes(M), [M]);
    const totC = s.cur.slice(0, 11).reduce((t, v) => t + (v || 0), 0), totP = s.prev.slice(0, 11).every(v => v != null) ? s.prev.slice(0, 11).reduce((t, v) => t + (v || 0), 0) : null;
    const e = totP != null ? ecart(totC, totP, "argent") : null;
    return (
      <section className="an-panneau" aria-label="Ventes facturées par mois">
        <div className="an-panneau-tete">
          <div><h2>Ventes facturées par mois</h2><p>12 derniers mois (le mois en cours jusqu'à aujourd'hui) contre les mêmes mois l'an passé, HT · QuickBooks</p></div>
          {e && <span className="an-delta" data-sens={e.dv >= 0 ? "bon" : "mauvais"} title={`11 mois complets : ${fmtCAD(totC)} contre ${fmtCAD(totP)} l'an passé`}>{e.txt} <span>sur 11 mois complets</span></span>}
        </div>
        <div className="an-legende"><span><i className="an-cle ligne s1" />12 derniers mois</span><span><i className="an-cle ligne ctx" />Mêmes mois l'an passé</span></div>
        <Courbes titre="Ventes facturées par mois" x={s.x} libX={(m) => MOIS_C[Number(m.slice(5, 7)) - 1]} libLong={(m) => majuscule(libMois(m)) + (m === debutMois(M.auj) ? ` (jusqu'au ${libJourCourt(M.auj)})` : "")} hauteur={compact ? 200 : 240} fmt={fmtK} fmtAxe={fmtK}
          series={[{ k: "cur", label: "", cl: "s1", v: s.cur, libPoint: (m) => libMois(m) }, { k: "prev", label: "", cl: "ctx", v: s.prev, libPoint: (m) => libMois(addM(m, -12)) }]}
          note={(i) => { const e2 = ecart(s.cur[i], s.prev[i], "argent"); return e2 ? `Écart : ${e2.txt}` : "Écart : n/d (mois de l'an passé non couvert)"; }}
          onClic={onMois} />
        <details className="an-table"><summary>Voir le tableau</summary>
          <table><thead><tr><th>Mois</th><th className="n">Ventes HT</th><th className="n">An passé</th><th className="n">Écart</th></tr></thead>
            <tbody>{s.x.map((m, i) => { const e2 = ecart(s.cur[i], s.prev[i], "argent"); return <tr key={m}><td>{majuscule(libMois(m))}</td><td className="n">{s.cur[i] == null ? "n/d" : fmtCAD(s.cur[i])}</td><td className="n">{s.prev[i] == null ? "n/d" : fmtCAD(s.prev[i])}</td><td className="n">{e2 ? e2.txt : "n/d"}</td></tr>; })}</tbody></table>
        </details>
      </section>
    );
  }
  const selFacturesMois = (M, m) => { const b = addM(m, 1); const L = M.docs.filter(d => d.type === "facture" && d.date >= m && d.date < b).sort((a, b2) => b2.ht - a.ht); const couvert = pipeCouvre(M, m, b > M.pipeFin ? M.pipeFin : b); return { k: "mois" + m, titre: `Factures de ${libMois(m)}`, sous: couvert ? "Les plus grosses d'abord, HT" : "Ce mois dépasse les 365 jours relus au jour près : le total vient du cumul mensuel QuickBooks, la liste peut être incomplète", lignes: L.map(ligneDoc), vide: "Aucune facture listée pour ce mois." }; };

  // ════════════════════════════ À faire aujourd'hui ════════════════════════════
  function AFaire({ M, admin, onOpen }) {
    const auj = M.auj;
    const relances = M.docs.filter(d => d.type === "devis" && /pending/i.test(String(d.statut || "")) && ecartJ(d.date, auj) >= 7 && ecartJ(d.date, auj) <= 60).sort((a, b) => b.ht - a.ht);
    const vues = M.liens.filter(l => l && l.etat === "active" && Number(l.nb_vues) > 0 && !l.decision && l.derniere_vue && ecartJ(jourDe(l.derniere_vue), auj) >= 2).sort((a, b) => String(a.derniere_vue).localeCompare(String(b.derniere_vue)));
    const nonTraites = M.leads.filter(l => !l.traite && ecartJ(l.jour, auj) <= 14).sort((a, b) => (b.score || 0) - (a.score || 0) || b.jour.localeCompare(a.jour));
    const retards = admin ? soldes(M).filter(d => ecartJ(d.date, auj) > 45) : [];
    const blocs = [
      { k: "relances", titre: "Relances en retard", sous: "Devis en attente depuis 7 à 60 jours, les plus gros d'abord · QuickBooks", n: relances.length, lignes: relances.slice(0, 5).map(d => ({ ...ligneDoc(d), pill: { ton: "orange", txt: `${ecartJ(d.date, auj)} j` } })), vide: "Aucune relance en retard." },
      { k: "vues", titre: "Propositions consultées sans réponse", sous: "Ouvertes par le client il y a 2 jours ou plus · propositions en ligne", n: vues.length, lignes: vues.slice(0, 5).map(l => ({ k: "p" + l.id, t: nomPropre(l.client_nom) || "Client", s: `Proposition ${l.soumission_numero || l.qbo_doc_number || ""} · vue ${nbFr(l.nb_vues)} fois, dernière le ${libJour(jourDe(l.derniere_vue))}`, v: l.montant_ttc ? fmtCAD(l.montant_ttc) : "", pill: { ton: "orange", txt: `${ecartJ(jourDe(l.derniere_vue), auj)} j` }, ouvrir: (o) => { if (l.soumission_id && o) o(l.soumission_id); } })), vide: "Aucune proposition consultée en attente." },
      { k: "leads", titre: "Leads non traités", sous: "Reçus depuis 14 jours, sans devis ni soumission, les mieux notés d'abord · Supabase", n: nonTraites.length, lignes: nonTraites.slice(0, 5).map(l => ({ ...ligneLead(l), ouvrir: (o) => { if (o) o(l.id); }, titre: "Ouvrir le lead (créer la soumission)" })), vide: "Tous les leads récents ont une suite." },
    ];
    if (admin) blocs.push({ k: "retards", titre: "Factures en retard", sous: "Solde dû depuis plus de 45 jours · QuickBooks", n: retards.length, lignes: retards.slice(0, 5).map(d => ({ ...ligneDoc(d), v: fmtCAD(d.solde) })), vide: "Aucune facture en retard." });
    return (
      <section className="an-panneau large" aria-label="À faire aujourd'hui" style={{ marginBottom: 14 }}>
        <div className="an-panneau-tete"><div><h2>À faire aujourd'hui</h2><p>{libJour(auj)}, heure de Mascouche</p></div></div>
        <div className={"an-afaire" + (blocs.length === 4 ? " quatre" : "")}>
          {blocs.map(b => (
            <div key={b.k} data-afaire={b.k}>
              <h3 style={{ fontSize: 13.5, margin: "0 0 2px" }}>{b.titre}<span className="an-compte">{b.n}</span></h3>
              <p className="an-item-s" style={{ margin: "0 0 6px", whiteSpace: "normal" }}>{b.sous}</p>
              {!b.lignes.length ? <p className="an-vide">{b.vide}</p> : <ul className="an-liste">{b.lignes.map(r => <li key={r.k}><button type="button" className="an-item" onClick={() => r.ouvrir && r.ouvrir(onOpen)} title={r.titre || ""}><span className="an-item-corps"><span className="an-item-t" style={{ display: "block" }}>{r.t}</span><span className="an-item-s" style={{ display: "block" }}>{r.s}</span></span><span className="an-item-v">{r.v}{r.pill && <span className="an-pill" data-ton={r.pill.ton}>{r.pill.txt}</span>}</span></button></li>)}</ul>}
            </div>
          ))}
        </div>
      </section>
    );
  }

  // ════════════════════════════ Tableau de bord ════════════════════════════
  function TableauDeBordRE({ profile, onOpen, onNew, onNewFor }) {
    const [periode, setPeriode] = usePeriode();
    const { M, charge } = useDonnees();
    const [sel, setSel] = useState(null);
    const auj = aujourdhui();
    const F = useMemo(() => fenetres(periode, auj), [periode, auj]);
    const meta = useMeta(F, charge, M && M.leadsDebut);
    useEffect(() => { setSel(null); }, [periode]);
    const admin = !profile || profile.role === "admin";
    const prenom = (profile && profile.name || "").split(" ")[0];
    const heure = parseInt(new Intl.DateTimeFormat("fr-CA", { timeZone: TZ, hour: "numeric", hourCycle: "h23" }).format(new Date()), 10) || 0;
    const salut = heure < 12 ? "Bon matin" : heure < 18 ? "Bon après-midi" : "Bonsoir";
    const defs = useMemo(() => definitions(meta), [meta]);
    const defsVues = admin ? defs : defs.filter(g => g.groupe !== "Ventes");
    return (
      <div className="an-root re-app re-dash" data-vue="tableau-de-bord">
        <div className="an-tete">
          <div><h1>{salut}{prenom ? `, ${prenom}` : ""}</h1><p>{new Date().toLocaleDateString("fr-CA", { timeZone: TZ, weekday: "long", day: "numeric", month: "long", year: "numeric" })}{M && M.synced_at ? ` · QuickBooks synchronisé à ${new Date(M.synced_at).toLocaleTimeString("fr-CA", { timeZone: TZ, hour: "2-digit", minute: "2-digit" })}` : ""}</p></div>
          <div className="an-actions">{onNew && <button type="button" className="an-btn primaire" onClick={onNew}>Nouvelle soumission</button>}</div>
        </div>
        <SelecteurPeriode periode={periode} setPeriode={setPeriode} F={F} />
        {!charge || !M ? <div className="an-panneau an-attente">Chargement des indicateurs…</div> : (
          <>
            <Erreurs M={M} />
            <Constats liste={constats(M, F, meta)} onVoir={(c) => allerAnalytics(c.onglet)} />
            <GrilleIndicateurs M={M} F={F} defs={defsVues} sel={sel} setSel={setSel} admin={admin} />
            <Detail sel={sel} onFermer={() => setSel(null)} onOpen={onOpen} />
            <AFaire M={M} admin={admin} onOpen={onOpen} />
            <div className="an-grille auto">
              {admin && <PanneauVentes12 M={M} compact onMois={(m) => setSel(selFacturesMois(M, m))} />}
              <PanneauLeadsMois M={M} onMois={(m) => setSel(selLeadsMois(M, m))} />
            </div>
            {window.TachesRE ? <div className="re-panel re-panel-taches" style={{ marginTop: 14 }}><window.TachesRE compact profile={profile} onNewFor={onNewFor} /></div> : null}
          </>
        )}
      </div>
    );
  }

  // ════════════════════════════ Leads par mois et par canal ════════════════════════════
  function serieLeadsMois(M, nMax = 12) {
    if (!M.leadsDebut) return { x: [], valeurs: [] };
    const m0 = debutMois(M.auj); let a = debutMois(M.leadsDebut); if (addM(m0, -(nMax - 1)) > a) a = addM(m0, -(nMax - 1));
    const x = []; for (let m = a; m <= m0; m = addM(m, 1)) x.push(m);
    const valeurs = x.map(m => { const b = addM(m, 1); const L = M.leads.filter(l => l.jour >= m && l.jour < b); return CANAUX.map(c => L.filter(l => l.canal === c.k).length); });
    return { x, valeurs };
  }
  const selLeadsMois = (M, m, canal) => { const b = addM(m, 1); return { k: "lm" + m + (canal || ""), titre: `Leads de ${libMois(m)}${canal ? " · " + CANAL_COURT[canal] : ""}`, sous: m === debutMois(M.auj) ? `Jusqu'au ${libJour(M.auj)}` : "", lignes: M.leads.filter(l => l.jour >= m && l.jour < b && (!canal || l.canal === canal)).map(ligneLead) }; };
  function PanneauLeadsMois({ M, onMois }) {
    const s = useMemo(() => serieLeadsMois(M), [M]);
    return (
      <section className="an-panneau" aria-label="Leads par mois et par canal">
        <div className="an-panneau-tete"><div><h2>Leads par mois et par canal</h2><p>Leads web reçus (le mois en cours jusqu'à aujourd'hui) · Supabase, canal d'après fbclid, gclid et utm</p></div></div>
        <div className="an-legende">{CANAUX.map(c => <span key={c.k}><i className={"an-cle " + c.cl} />{c.label}</span>)}</div>
        {!s.x.length ? <p className="an-vide">Aucun lead enregistré.</p> : <Colonnes titre="Leads par mois et par canal" x={s.x} libX={(m) => MOIS_C[Number(m.slice(5, 7)) - 1]} libLong={(m) => majuscule(libMois(m))} series={CANAUX} valeurs={s.valeurs} fmt={(v) => nbFr(v)} onClic={onMois} />}
        <details className="an-table"><summary>Voir le tableau</summary>
          <table><thead><tr><th>Mois</th>{CANAUX.map(c => <th key={c.k} className="n">{CANAL_COURT[c.k]}</th>)}<th className="n">Total</th></tr></thead>
            <tbody>{s.x.map((m, i) => <tr key={m}><td>{majuscule(libMois(m))}</td>{s.valeurs[i].map((v, j) => <td key={j} className="n">{nbFr(v)}</td>)}<td className="n">{nbFr(s.valeurs[i].reduce((t, v) => t + v, 0))}</td></tr>)}</tbody></table>
        </details>
      </section>
    );
  }

  // ════════════════════════════ Analytics : leads et marketing ════════════════════════════
  function agregats(L) {
    const P = personnes(L), notes = L.filter(l => l.score != null);
    const delais = P.filter(l => l.devis).map(l => ecartJ(l.jour, l.devis.date)).filter(d => d >= 0);
    return { n: L.length, personnes: P.length, score: notes.length ? notes.reduce((s, l) => s + l.score, 0) / notes.length : null, qualif: notes.length ? notes.filter(l => l.qualifie).length / notes.length * 100 : null,
      meta: L.filter(l => l.canal === "meta").length, devis: P.filter(l => l.soumis).length, acceptes: P.filter(l => l.accepte).length, factures: P.filter(l => l.facture).length, delai: mediane(delais), dernier: L.reduce((m, l) => !m || l.jour > m ? l.jour : m, null) };
  }
  const GROUPAGES = [["page", "Par page de pub"], ["systeme", "Par système"], ["canal", "Par canal"]];
  function ComparaisonPages({ M, F, metaCur, sel, setSel }) {
    const [par, setPar] = useState("page");
    const L = leadsDe(M, F.cur);
    const dep = metaCur && metaCur.v != null ? metaCur.v : null;
    const metaPages = new Set(L.filter(l => l.canal === "meta").map(l => l.page));
    const total = agregats(L);
    const cles = par === "canal" ? CANAUX.map(c => c.k) : [...new Set(L.map(l => par === "page" ? l.page : l.systeme))];
    const lignes = cles.map(k => { const sous = L.filter(l => (par === "page" ? l.page : par === "systeme" ? l.systeme : l.canal) === k); const a = agregats(sous); return { k, label: par === "canal" ? CANAL_COURT[k] : k, sysPage: /^Formulaire/.test(k) ? "Formulaire web (tous les systèmes)" : systemeDe(k, null), ...a, L: sous }; }).filter(r => r.n > 0);
    // Coût par lead d'une page : seulement si tous les leads Meta de la période sont arrivés sur cette page (la dépense n'est pas ventilée par page).
    const cplDe = (r) => {
      if (dep == null) return { v: null, t: metaCur && metaCur.raison ? "dépense Meta indisponible : " + metaCur.raison : "dépense Meta indisponible" };
      if (par === "canal") return r.k === "meta" && r.meta ? { v: dep / r.meta, t: "Dépense Meta de la période ÷ leads Meta" } : { v: null, t: r.k === "google" ? "dépense Google Ads non relayée par période" : "pas de dépense publicitaire suivie" };
      if (!r.meta) return { v: null, t: "aucun lead Meta" };
      if (metaPages.size === 1) return { v: dep / r.meta, t: "Toute la dépense Meta de la période ÷ leads Meta de cette page (seule page qui en a reçu)" };
      return { v: null, t: "dépense Meta non ventilée par page (plusieurs pages reçoivent des leads Meta)" };
    };
    const max = Math.max(1, ...lignes.map(r => r.n));
    const ordre = (a, b) => b.n - a.n;
    const groupes = par === "page" ? [...new Set(lignes.map(r => r.sysPage))].map(s => ({ s, rows: lignes.filter(r => r.sysPage === s).sort(ordre) })).sort((a, b) => b.rows.reduce((t, r) => t + r.n, 0) - a.rows.reduce((t, r) => t + r.n, 0)) : [{ s: null, rows: lignes.sort(ordre) }];
    const choisir = (r) => setSel(sel && sel.k === "pg" + par + r.k ? null : { k: "pg" + par + r.k, titre: `Leads · ${r.label}`, sous: F.cur.lib, lignes: r.L.map(ligneLead) });
    return (
      <section className="an-panneau large" aria-label="Pages de pub et variantes">
        <div className="an-panneau-tete">
          <div><h2>Pages de pub et variantes</h2><p>Même période pour toutes les lignes : {F.cur.lib}. Qualifié = score {SEUIL_QUALIFIE} et plus. Clic sur une ligne : ses leads.</p></div>
          <div className="an-seg" role="group" aria-label="Regrouper">{GROUPAGES.map(([k, l]) => <button key={k} type="button" aria-pressed={par === k} onClick={() => setPar(k)}>{l}</button>)}</div>
        </div>
        {!lignes.length ? <p className="an-vide">Aucun lead sur la période.</p> : (
          <table className="an-comp">
            <thead><tr><th>{par === "page" ? "Page" : par === "systeme" ? "Système" : "Canal"}</th><th>Leads</th><th>Score moyen</th><th>Qualifiés</th><th>Coût par lead</th><th>Devenus devis</th><th>Dernier lead</th></tr></thead>
            <tbody>
              {groupes.map(gp => [
                gp.s ? <tr key={"s" + gp.s} className="sys"><td colSpan={7}>{gp.s}</td></tr> : null,
                ...gp.rows.map(r => { const c = cplDe(r); return (
                  <tr key={r.k} className="ligne" tabIndex={0} aria-selected={!!sel && sel.k === "pg" + par + r.k} onClick={() => choisir(r)} onKeyDown={(e) => { if (e.key === "Enter" || e.key === " ") { choisir(r); e.preventDefault(); } }} data-page={r.k}>
                    <td className="page">{r.label}</td>
                    <td data-lib="Leads" title={`${nbFr(r.n)} leads, ${nbFr(r.personnes)} personnes`}><span className="mini" style={{ width: Math.max(3, (r.n / max) * 70) }} />{nbFr(r.n)}</td>
                    <td data-lib="Score moyen">{r.score == null ? "n/d" : nbFr(r.score, 0)}</td>
                    <td data-lib="Qualifiés" className={r.qualif === 0 ? "faible" : ""}>{r.qualif == null ? "n/d" : pct(r.qualif)}</td>
                    <td data-lib="Coût par lead" title={c.t} className={c.v == null ? "faible" : ""}>{c.v == null ? "n/d" : fmtCAD(c.v, 2)}</td>
                    <td data-lib="Devenus devis" title={`${nbFr(r.devis)} personnes sur ${nbFr(r.personnes)} ont reçu un devis QuickBooks ou une soumission RAYCAST`}>{r.personnes ? pct(r.devis / r.personnes * 100) : "n/d"}</td>
                    <td data-lib="Dernier lead">{r.dernier ? libJourCourt(r.dernier) : ""}</td>
                  </tr>); }),
              ])}
              <tr className="ligne" style={{ fontWeight: 700 }} onClick={() => setSel({ k: "pgtout", titre: "Tous les leads", sous: F.cur.lib, lignes: L.map(ligneLead) })}>
                <td className="page">Total</td><td data-lib="Leads">{nbFr(total.n)}</td><td data-lib="Score moyen">{total.score == null ? "n/d" : nbFr(total.score, 0)}</td><td data-lib="Qualifiés">{total.qualif == null ? "n/d" : pct(total.qualif)}</td>
                <td data-lib="Coût par lead">{dep != null && total.meta ? fmtCAD(dep / total.meta, 2) : "n/d"}<span className="faible" style={{ fontWeight: 500 }}>{dep != null && total.meta ? " (Meta)" : ""}</span></td>
                <td data-lib="Devenus devis">{total.personnes ? pct(total.devis / total.personnes * 100) : "n/d"}</td><td data-lib="Dernier lead">{total.dernier ? libJourCourt(total.dernier) : ""}</td>
              </tr>
            </tbody>
          </table>
        )}
      </section>
    );
  }
  function Entonnoir({ M, F, sel, setSel }) {
    const P = personnes(leadsDe(M, F.cur));
    const couvert = conversionCouverte(M, F.cur);
    const etapes = [
      { k: "e1", label: "Leads (personnes)", L: P },
      { k: "e2", label: "Devis ou soumission", L: P.filter(l => l.soumis) },
      { k: "e3", label: "Acceptés", L: P.filter(l => l.accepte) },
      { k: "e4", label: "Facturés", L: P.filter(l => l.facture) },
    ];
    const a = agregats(leadsDe(M, F.cur));
    return (
      <section className="an-panneau" aria-label="Entonnoir lead, devis, accepté, facturé">
        <div className="an-panneau-tete"><div><h2>Entonnoir</h2><p>Personnes dont le lead est arrivé dans la période{debutLeads(M, F.cur) > F.cur.a ? ` (leads enregistrés depuis le ${libJour(M.leadsDebut)})` : ""}, et ce qui a suivi à ce jour · Supabase + QuickBooks</p></div></div>
        {!couvert ? <p className="an-nd"><b>Non disponible pour cette période</b> : {raisonPipe(M)}.</p> : !P.length ? <p className="an-vide">Aucun lead sur la période.</p> : <>
          <Barres lignes={etapes.map((e, i) => ({ k: e.k, label: e.label, v: e.L.length, sous: i === 0 ? "100 %" : `${pct(e.L.length / Math.max(1, etapes[i - 1].L.length) * 100)} de l'étape d'avant`, total: pct(e.L.length / P.length * 100) }))} fmt={(v) => nbFr(v)} choisi={sel && sel.k}
            onClic={(k) => { const e = etapes.find(x => x.k === k); setSel(sel && sel.k === k ? null : { k, titre: `Entonnoir · ${e.label}`, sous: F.cur.lib, lignes: e.L.map(ligneLead) }); }}
            detail={(l) => <><div className="an-bulle-t">{l.label}</div><div className="an-bulle-r"><b>{nbFr(l.v)}</b><span>personnes</span></div><div className="an-bulle-note">{l.sous}{l.total ? `, ${l.total} des leads` : ""}</div></>} />
          <dl className="an-kv" style={{ marginTop: 12 }}>
            <dt>Délai médian entre le lead et le devis</dt><dd>{a.delai == null ? "n/d" : `${nbFr(a.delai, 0)} jour${a.delai >= 2 ? "s" : ""}`}<span>QuickBooks</span></dd>
            <dt title="Les appels et messages ne sont journalisés dans RAYCAST que depuis le 1er novembre 2026">Délai de première réponse</dt><dd title="Historique des appels et messages (table interactions) depuis le 1er novembre 2026 seulement : trop court pour une moyenne fiable">n/d<span>historique trop court</span></dd>
          </dl>
        </>}
      </section>
    );
  }
  function LeadsMarketing({ M, F, meta, sel, setSel }) {
    const defs = definitions(meta);
    const pick = (k) => { for (const g of defs) for (const d of g.items) if (d.k === k) return d; return null; };
    const extra = [
      { k: "score", label: "Score moyen", calc: (MM, w) => { const L = leadsDe(MM, w).filter(l => l.score != null); if (!L.length) return { v: null, raison: "aucun lead noté" }; return avecLeads(MM, w, { v: L.reduce((s, l) => s + l.score, 0) / L.length }); }, fmt: (v) => nbFr(v, 0), sens: +1, genre: "nombre", source: "Supabase, score GHL v3 à l'arrivée du lead (0 à 100)", sourceCourte: "Supabase, score GHL", clic: (MM, FF) => leadsSel(MM, FF, l => l.score != null, "Leads notés", FF.cur.lib) },
    ];
    extra.push({ k: "delai", label: "Délai lead → devis", calc: IND.delai, fmt: (v) => `${nbFr(v, 0)} j`, sens: -1, genre: "nombre", source: "Supabase (date du lead) et QuickBooks (date du premier devis après le lead), médiane en jours", sourceCourte: "Supabase + QuickBooks", sous: (c) => `médiane sur ${nbFr(c.n)} personnes`,
      clic: (MM, FF) => ({ titre: "Leads devenus devis", sous: `Délai entre la demande et le premier devis, ${FF.cur.lib}`, lignes: personnes(leadsDe(MM, FF.cur)).filter(l => l.devis).sort((a, b) => ecartJ(b.jour, b.devis.date) - ecartJ(a.jour, a.devis.date)).map(l => ({ ...ligneLead(l), v: `${ecartJ(l.jour, l.devis.date)} j` })) }) });
    const nonTraites = (MM) => MM.leads.filter(l => !l.traite && ecartJ(l.jour, MM.auj) <= 14);
    extra.push({ k: "nonTraites", label: "Leads non traités", instantane: true, calc: (MM) => MM.sources.leads ? { v: nonTraites(MM).length } : { v: null, raison: "leads Supabase indisponibles" }, fmt: (v) => nbFr(v), source: "Supabase, leads des 14 derniers jours sans devis QuickBooks ni soumission RAYCAST", sourceCourte: "Supabase + QuickBooks", sous: () => "reçus depuis 14 jours, sans suite",
      clic: (MM) => ({ titre: "Leads non traités", sous: "Reçus depuis 14 jours, sans devis ni soumission, les mieux notés d'abord", lignes: nonTraites(MM).sort((a, b) => (b.score || 0) - (a.score || 0)).map(ligneLead) }) });
    const tuiles = [pick("leads"), extra[0], pick("qualifies"), pick("tauxDevis"), extra[1], extra[2], pick("depenseMeta"), pick("cplMeta"), pick("leadsMeta")].filter(Boolean);
    return (
      <>
        <Constats liste={constats(M, F, meta)} />
        <div className="an-groupes trois re-kpis-grid">
          {[["Volume et qualité", tuiles.slice(0, 3)], ["Conversion", tuiles.slice(3, 6)], ["Coût Meta", tuiles.slice(6)]].map(([g, items]) => (
            <section key={g} className="an-groupe" aria-label={g}><h2>{g}</h2><div className="an-tuiles">
              {items.map(d => <Tuile key={d.k} def={{ ...d, calc: (MM, w) => d.calc(MM, w, F) }} F={F} M={M} actif={sel && sel.k === d.k} onClic={() => setSel(sel && sel.k === d.k ? null : { ...d.clic(M, F), k: d.k })} />)}
            </div></section>
          ))}
        </div>
        <Detail sel={sel} onFermer={() => setSel(null)} onOpen={null} />
        <h2 className="an-titre-section" style={{ fontSize: 16, margin: "4px 0 10px" }}>Leads Meta et pages de pub : comparer les variantes</h2>
        <div className="an-grille un"><ComparaisonPages M={M} F={F} metaCur={meta && (meta.curClip || meta.cur)} sel={sel} setSel={setSel} /></div>
        <div className="an-grille un"><PagesPub M={M} F={F} metaCur={meta && (meta.curClip || meta.cur)} /></div>
        <div className="an-grille auto trois-max">
          <PanneauLeadsMois M={M} onMois={(m) => setSel(selLeadsMois(M, m))} />
          <Entonnoir M={M} F={F} sel={sel} setSel={setSel} />
        <section className="an-panneau" aria-label="Données non disponibles">
          <div className="an-panneau-tete"><div><h2>Non disponible pour le moment</h2><p>Rien n'est estimé : ces mesures reviennent quand leur source est rebranchée.</p></div></div>
          <dl className="an-kv">
            <dt>Trafic du site et conversions (Google Analytics 4)</dt><dd>n/d<span>accès Supermetrics expiré</span></dd>
            <dt>Coût par lead Google Ads</dt><dd>n/d<span>dépense non relayée par période</span></dd>
            <dt>Marge brute par vente</dt><dd>n/d<span>coût des articles non lu</span></dd>
            <dt>Leads GHL, Aircall et téléphone (hors formulaires)</dt><dd>n/d<span>pas de date de création relayée</span></dd>
          </dl>
        </section>
        </div>
      </>
    );
  }

  // ════════════════════════════ Pages de pub : compteur des pages (Supabase lp_stats_jour) ════════════════════════════
  // Compteurs agrégés par jour écrits par le worker GHL (POST /lp/evt) depuis assets/lp-stats.js des pages, seulement après
  // « Accepter » sur le bandeau de témoins : visites, défilement, blocs vus, étapes du formulaire, envoi, clics. Aucune donnée
  // personnelle. Lien avec RAYCAST : les leads (submissions) dont la source est la variante de la page.
  const LP_ETAPES = [
    ["visite", "Visites"], ["vu_formulaire", "Ont vu le formulaire"], ["form_debut", "Ont commencé le formulaire"],
    ["q_proprietaire", "Propriétaire ?"], ["q_chauffage", "Chauffage"], ["q_facture", "Facture d'Hydro-Québec"], ["q_delai", "Délai du projet"],
    ["coordonnees", "Coordonnées remplies"], ["envoi_ok", "Formulaire envoyé"],
  ];
  const LP_DEFIL = [["defil_25", "25 %"], ["defil_50", "50 %"], ["defil_75", "75 %"], ["defil_100", "Bas de page"]];
  const LP_CLICS = [["vu_subventions", "Ont vu le bloc subventions"], ["clic_reserver", "Clic « Réserver un appel »"], ["clic_tel", "Clic téléphone"], ["clic_sms", "Clic texto"], ["envoi_echec", "Échecs d'envoi du formulaire"]];
  const LP_CANAUX = [["tous", "Tous les canaux"], ["meta", "Meta"], ["google", "Google"], ["organique", "Organique"], ["autre", "Autre"]];
  const LP_ANGLES = { defaut: "Par défaut", panne: "Panne", facture: "Facture", subvention: "Subvention", generatrice: "Génératrice", ve: "Véhicule électrique" };
  // Sources reprises par d'autres pages (powerwall2. à 4. gardent landing-powerwall-v2) : le lead doit aussi venir du même sous-domaine
  const LP_PARTAGEES = new Set(["landing-powerwall-v2", "landing-solaire-v1"]);
  const CLARITY_URL = "https://clarity.microsoft.com/projects/view/wvm6u5crpy/dashboard";
  /** Table absente (migration pas encore appliquée) : PostgREST répond PGRST205 (ou 42P01 selon la version). */
  const lpAbsente = (e) => { const c = String((e && e.code) || ""), m = String((e && e.message) || ""); return c === "PGRST205" || c === "42P01" || (/lp_stats_jour/.test(m) && /does not exist|could not find|schema cache/i.test(m)); };
  const cacheLp = {};
  function lireStatsLp(a, b, force) {
    const cle = a + "|" + b, c = cacheLp[cle];
    if (!force && c && Date.now() - c.at < CACHE_MS) return c.promesse;
    const promesse = (async () => {
      const sb = window.RAYCAST_SUPABASE; if (!sb) return { etat: "erreur", raison: "Supabase indisponible" };
      const out = [];
      for (let i = 0; i < 60; i++) {
        const { data, error } = await sb.from("lp_stats_jour").select("jour,page,variante,canal,angle,evenement,n").gte("jour", a).lt("jour", b)
          .order("jour", { ascending: true }).order("page").order("variante").order("canal").order("angle").order("evenement").range(i * 1000, i * 1000 + 999);
        if (error) return lpAbsente(error) ? { etat: "absente" } : { etat: "erreur", raison: error.message || "lecture refusée" };
        out.push(...(data || [])); if (!data || data.length < 1000) break;
      }
      return { etat: "ok", lignes: out };
    })().catch(e => ({ etat: "erreur", raison: texte(e) }));
    cacheLp[cle] = { at: Date.now(), promesse };
    promesse.then(r => { if (r.etat !== "ok" && cacheLp[cle] && cacheLp[cle].promesse === promesse) delete cacheLp[cle]; });
    return promesse;
  }
  function useStatsLp(F, M) {
    const [r, setR] = useState({ etat: "attente" });
    const cle = F.cur.a + "|" + F.cur.b;
    useEffect(() => { let vivant = true; setR({ etat: "attente" }); lireStatsLp(F.cur.a, F.cur.b).then(x => { if (vivant) setR({ ...x, cle }); }); return () => { vivant = false; }; }, [cle, M]); // M change au « Rafraîchir »
    return r;
  }
  /** Somme des compteurs par page et variante, filtrés par canal et angle. */
  function agregerLp(lignes, canal, angle) {
    const m = new Map();
    for (const r of lignes || []) {
      if (canal !== "tous" && r.canal !== canal) continue;
      if (angle !== "tous" && r.angle !== angle) continue;
      const k = r.page + "|" + r.variante;
      if (!m.has(k)) m.set(k, { k, page: r.page, variante: r.variante, ev: {} });
      const x = m.get(k); x.ev[r.evenement] = (x.ev[r.evenement] || 0) + (Number(r.n) || 0);
    }
    return [...m.values()].sort((a, b) => (b.ev.visite || 0) - (a.ev.visite || 0));
  }
  /** Entonnoir d'une page : étapes présentes (une étape à 0 suivie d'une étape comptée n'existe pas sur la page, ex. pas de
   *  questions de qualification), taux de passage à chaque étape, et l'étape où ça décroche le plus (au moins 5 personnes avant). */
  function entonnoirLp(ev) {
    const tout = LP_ETAPES.map(([k, lib]) => ({ k, lib, n: ev[k] || 0 }));
    tout.forEach((x, i) => { x.absente = i > 0 && x.n === 0 && tout.slice(i + 1).some(y => y.n > 0); });
    const etapes = tout.filter(x => !x.absente);
    let pire = null;
    etapes.forEach((x, i) => {
      if (!i) { x.passage = null; return; }
      const avant = etapes[i - 1].n;
      x.passage = avant ? Math.min(1, x.n / avant) : null;
      if (avant >= 5 && x.passage != null && x.passage < 1 && (!pire || x.passage < pire.passage)) pire = x;
    });
    return { etapes, absentes: tout.filter(x => x.absente), pire, visites: ev.visite || 0 };
  }
  const libPage = (p) => p + ".";
  function leadsDeLp(M, F, ligne, canal) {
    return leadsDe(M, F.cur).filter(l => l.source === ligne.variante && (!LP_PARTAGEES.has(ligne.variante) || l.page === libPage(ligne.page)) && (canal === "tous" || l.canalLp === canal));
  }
  const tauxLp = (n, d) => d ? n / d * 100 : null;
  const fmtTaux = (v) => v == null ? "n/d" : pct(v, v > 0 && v < 10 ? 1 : 0);

  function EntonnoirPage({ ligne, M, F, canal, angle }) {
    const E = entonnoirLp(ligne.ev);
    const L = leadsDeLp(M, F, ligne, canal), P = personnes(L), notes = L.filter(l => l.score != null);
    const couvert = conversionCouverte(M, F.cur);
    const hote = `${ligne.page}.raycomelectrique.com`;
    const v = E.visites;
    return (
      <div className="an-lp-detail" data-lp-detail={ligne.k}>
        <div className="an-panneau-tete">
          <div><h3>{libPage(ligne.page)} · entonnoir</h3><p>{ligne.variante} · {F.cur.lib}{canal !== "tous" ? ` · ${LP_CANAUX.find(c => c[0] === canal)[1]}` : ""}{angle !== "tous" ? ` · angle ${LP_ANGLES[angle] || angle}` : ""}. Barre : part des visites ; à droite : passage depuis l'étape d'avant.</p></div>
          <a className="an-btn" href={CLARITY_URL} target="_blank" rel="noopener noreferrer" title={`Ouvre le projet Clarity wvm6u5crpy. Filtre à poser dans Clarity : URL visitée contient ${hote}`}>Voir dans Clarity ↗</a>
        </div>
        {v < 30 && <p className="an-nd" style={{ marginBottom: 10 }}><b>Échantillon faible</b> : {nbFr(v)} visite{v >= 2 ? "s" : ""} comptée{v >= 2 ? "s" : ""}, les taux bougent beaucoup d'une visite à l'autre.</p>}
        <div className="an-lp-etapes" role="list" aria-label="Entonnoir de la page">
          {E.etapes.map((x, i) => {
            const part = v ? Math.min(1, x.n / v) : 0, pire = E.pire && E.pire.k === x.k;
            return (
              <div key={x.k} role="listitem" className={"an-lp-etape" + (pire ? " decroche" : "")} data-etape={x.k} title={`${x.lib} : ${nbFr(x.n)} (${fmtTaux(tauxLp(x.n, v))} des visites)${x.passage != null ? `, ${fmtTaux(x.passage * 100)} de l'étape d'avant` : ""}`}>
                <span className="an-lp-lib">{x.lib}{pire && <small>Décroche le plus ici</small>}</span>
                <span className="an-lp-piste"><span className="an-lp-plein" style={{ width: `${Math.max(0.8, part * 100)}%` }} /></span>
                <span className="an-lp-n">{nbFr(x.n)}<small>{i ? fmtTaux(tauxLp(x.n, v)) : "100 %"}</small></span>
                <span className="an-lp-pass">{i === 0 ? "" : x.passage == null ? "n/d" : `${pire ? "−" + nbFr((1 - x.passage) * 100, 0) + " %" : fmtTaux(x.passage * 100)}`}</span>
              </div>
            );
          })}
        </div>
        {E.pire && <p className="an-lp-note" data-pire={E.pire.k}>Plus gros décrochage : <b>{E.etapes[E.etapes.indexOf(E.pire) - 1].lib.toLowerCase()} → {E.pire.lib.toLowerCase()}</b>, {nbFr((1 - E.pire.passage) * 100, 0)} % s'arrêtent là.</p>}
        {E.absentes.length > 0 && <p className="an-lp-note faible">Pas sur cette page : {E.absentes.map(x => x.lib.toLowerCase()).join(", ")}.</p>}
        <div className="an-lp-cols">
          <section aria-label="Défilement et clics">
            <h4>Défilement et clics</h4>
            <dl className="an-kv">
              {LP_DEFIL.map(([k, l]) => <React.Fragment key={k}><dt>{k === "defil_100" ? "Ont défilé jusqu'en bas" : `Ont défilé ${l} de la page`}</dt><dd data-ev={k}>{fmtTaux(tauxLp(ligne.ev[k] || 0, v))}<span>{nbFr(ligne.ev[k] || 0)}</span></dd></React.Fragment>)}
              {LP_CLICS.map(([k, l]) => <React.Fragment key={k}><dt>{l}</dt><dd data-ev={k}>{nbFr(ligne.ev[k] || 0)}<span>{fmtTaux(tauxLp(ligne.ev[k] || 0, v))}</span></dd></React.Fragment>)}
            </dl>
          </section>
          <section aria-label="Après le formulaire">
            <h4>Après le formulaire (RAYCAST)</h4>
            <dl className="an-kv">
              <dt>Leads reçus{angle !== "tous" ? " (tous angles)" : ""}</dt><dd data-suite="leads">{nbFr(L.length)}<span>{nbFr(P.length)} personnes</span></dd>
              <dt>Qualifiés (score {SEUIL_QUALIFIE} et plus)</dt><dd data-suite="qualifies">{notes.length ? pct(notes.filter(l => l.qualifie).length / notes.length * 100) : "n/d"}<span>{nbFr(notes.filter(l => l.qualifie).length)} sur {nbFr(notes.length)}</span></dd>
              {[["soumis", "Devis ou soumission"], ["accepte", "Acceptés"], ["facture", "Vendus (facturés)"]].map(([k, l]) => <React.Fragment key={k}><dt>{l}</dt><dd data-suite={k} title={couvert ? "" : raisonPipe(M)}>{couvert ? nbFr(P.filter(x => x[k]).length) : "n/d"}<span>{couvert && P.length ? pct(P.filter(x => x[k]).length / P.length * 100) : ""}</span></dd></React.Fragment>)}
            </dl>
            {angle !== "tous" && <p className="an-lp-note faible">L'angle de la pub n'est pas enregistré avec le lead : les leads sont ceux de la page et du canal, tous angles confondus.</p>}
          </section>
        </div>
      </div>
    );
  }

  function PagesPub({ M, F, metaCur }) {
    const S = useStatsLp(F, M);
    const [canal, setCanal] = useState("tous");
    const [angle, setAngle] = useState("tous");
    const [choisi, setChoisi] = useState(null);
    const lignes = useMemo(() => S.etat === "ok" ? agregerLp(S.lignes, canal, angle) : [], [S, canal, angle]);
    const angles = useMemo(() => S.etat === "ok" ? [...new Set(S.lignes.map(r => r.angle))].sort() : [], [S]);
    const dep = metaCur && metaCur.v != null ? metaCur.v : null;
    const pagesMeta = new Set(leadsDe(M, F.cur).filter(l => l.canal === "meta").map(l => l.source + "|" + l.page));
    const cpl = (r, L) => {
      if (canal !== "tous" && canal !== "meta") return { v: null, t: "dépense suivie pour Meta seulement" };
      if (dep == null) return { v: null, t: "dépense Meta indisponible" };
      const lm = L.filter(l => l.canal === "meta").length;
      if (!lm) return { v: null, t: "aucun lead Meta" };
      if (pagesMeta.size === 1) return { v: dep / lm, t: "Toute la dépense Meta de la période ÷ leads Meta de cette page (seule page qui en a reçu)" };
      return { v: null, t: "dépense Meta non ventilée par page (plusieurs pages reçoivent des leads Meta)" };
    };
    const sel = lignes.find(r => r.k === choisi) || null;
    const corps = S.etat === "attente" ? <p className="an-vide">Chargement du compteur…</p>
      : S.etat === "absente" ? <p className="an-nd" data-lp="absent"><b>Compteur pas encore activé</b> : la table lp_stats_jour n'existe pas encore dans Supabase. Les visites et l'entonnoir de chaque page apparaîtront ici dès que le compteur sera mis en ligne.</p>
      : S.etat === "erreur" ? <p className="an-nd" data-lp="erreur"><b>Compteur indisponible pour le moment</b> : {S.raison}.</p>
      : !lignes.length ? <p className="an-vide" data-lp="vide">Aucune visite comptée sur la période{canal !== "tous" || angle !== "tous" ? " avec ces filtres" : ""}.</p>
      : (
        <table className="an-comp an-lp-comp">
          <thead><tr><th>Page</th><th>Visites</th><th>Formulaire vu</th><th>Commencé</th><th>Envoyé</th><th>Leads</th><th>Qualifiés</th><th>Coût par lead</th></tr></thead>
          <tbody>
            {lignes.map(r => {
              const v = r.ev.visite || 0, L = leadsDeLp(M, F, r, canal), notes = L.filter(l => l.score != null), c = cpl(r, L);
              const choisir = () => setChoisi(choisi === r.k ? null : r.k);
              return (
                <tr key={r.k} className="ligne" tabIndex={0} data-lp-page={r.page} aria-selected={choisi === r.k} onClick={choisir} onKeyDown={(e) => { if (e.key === "Enter" || e.key === " ") { choisir(); e.preventDefault(); } }}>
                  <td className="page">{libPage(r.page)}<small className="an-lp-var">{r.variante}</small></td>
                  <td data-lib="Visites">{nbFr(v)}</td>
                  <td data-lib="Formulaire vu" title={`${nbFr(r.ev.vu_formulaire || 0)} visites`}>{fmtTaux(tauxLp(r.ev.vu_formulaire || 0, v))}</td>
                  <td data-lib="Commencé" title={`${nbFr(r.ev.form_debut || 0)} visites`}>{fmtTaux(tauxLp(r.ev.form_debut || 0, v))}</td>
                  <td data-lib="Envoyé" title={`${nbFr(r.ev.envoi_ok || 0)} formulaires envoyés`}><b>{fmtTaux(tauxLp(r.ev.envoi_ok || 0, v))}</b></td>
                  <td data-lib="Leads" title="Leads RAYCAST (submissions) de cette source sur la période">{nbFr(L.length)}</td>
                  <td data-lib="Qualifiés" className={notes.length ? "" : "faible"}>{notes.length ? pct(notes.filter(l => l.qualifie).length / notes.length * 100) : "n/d"}</td>
                  <td data-lib="Coût par lead" title={c.t} className={c.v == null ? "faible" : ""}>{c.v == null ? "n/d" : fmtCAD(c.v, 2)}</td>
                </tr>
              );
            })}
          </tbody>
        </table>
      );
    return (
      <section className="an-panneau large an-lp" aria-label="Pages de pub">
        <div className="an-panneau-tete">
          <div><h2>Pages de pub</h2><p>De la visite au lead, par page et variante · {F.cur.lib} · compteur des pages (après consentement aux témoins, sans donnée personnelle) et leads RAYCAST. Clic sur une page : son entonnoir.</p></div>
        </div>
        {S.etat === "ok" && <div className="an-filtres an-lp-filtres">
          <div className="an-seg" role="group" aria-label="Canal">{LP_CANAUX.map(([k, l]) => <button key={k} type="button" aria-pressed={canal === k} onClick={() => setCanal(k)}>{l}</button>)}</div>
          {angles.length > 0 && <div className="an-seg" role="group" aria-label="Angle de pub">{[["tous", "Tous les angles"], ...angles.map(a => [a, LP_ANGLES[a] || a])].map(([k, l]) => <button key={k} type="button" aria-pressed={angle === k} onClick={() => setAngle(k)}>{l}</button>)}</div>}
        </div>}
        {corps}
        {sel && <EntonnoirPage ligne={sel} M={M} F={F} canal={canal} angle={angle} />}
      </section>
    );
  }

  // ════════════════════════════ Analytics : ventes ════════════════════════════
  function VentesAnalyse({ M, F, sel, setSel }) {
    const defs = definitions({});
    const pick = (k) => { for (const g of defs) for (const d of g.items) if (d.k === k) return d; return null; };
    const factures = { k: "nbFactures", label: "Factures émises", calc: (MM, w) => { if (!MM.sources.pipe) return { v: null, raison: "factures QuickBooks indisponibles" }; if (!pipeCouvre(MM, w.a, w.b > MM.pipeFin ? MM.pipeFin : w.b)) { if (w.a === debutMois(w.a)) { let n = 0; for (let m = w.a; m < w.b; m = addM(m, 1)) { const x = MM.mois.get(m.slice(0, 7)); if (!x) return { v: null, raison: raisonPipe(MM) }; n += x.factures; } return { v: n }; } return { v: null, raison: raisonPipe(MM) }; } return { v: MM.docs.filter(d => d.type === "facture" && dans(d.date, w)).length }; }, fmt: (v) => nbFr(v), sens: +1, genre: "nombre", source: "QuickBooks, nombre de factures (acomptes et finales)", sourceCourte: "QuickBooks", clic: (MM, FF) => pick("ventes").clic(MM, FF) };
    const tuiles = [pick("ventes"), pick("panier"), factures, pick("devis")];
    const arts = useMemo(() => articlesEntre(M, F.cur), [M, F]);
    const artsPrev = useMemo(() => articlesEntre(M, F.prev), [M, F]);
    const mix = arts ? mixFamilles(arts) : null, mixPrev = artsPrev ? mixFamilles(artsPrev) : null;
    const totMix = mix ? Object.values(mix).reduce((s, v) => s + v, 0) : 0;
    const top = arts ? topProduits(arts).slice(0, 8) : null;
    const pa = M.paniers && M.paniers.types ? Object.entries(M.paniers.types).filter(([, t]) => t && Number(t.clients) > 0).sort((a, b) => (Number(b[1].montant_ht) || 0) - (Number(a[1].montant_ht) || 0)) : [];
    const TYPES = { tesla_sans_solaire: "Tesla sans solaire", tesla_avec_solaire: "Tesla avec solaire", solaire_sans_tesla: "Solaire sans Tesla", bornes_seules: "Bornes seules", autres: "Autres travaux" };
    const raisonMois = F.p === "30" ? "les articles vendus sont cumulés par mois complet dans QuickBooks : choisis Mois dernier, 3 mois, 12 mois ou Année" : "mois non couverts par les 24 mois d'articles QuickBooks";
    const Ancien = window.DashboardREAncien;
    return (
      <>
        <div className="an-groupes un re-kpis-grid">
          {[["Ventes et facturation", tuiles]].map(([g, items]) => (
            <section key={g} className="an-groupe" aria-label={g}><h2>{g}</h2><div className="an-tuiles rangee">
              {items.map(d => <Tuile key={d.k} def={{ ...d, calc: (MM, w) => d.calc(MM, w, F) }} F={F} M={M} actif={sel && sel.k === d.k} onClic={() => setSel(sel && sel.k === d.k ? null : { ...d.clic(M, F), k: d.k })} />)}
            </div></section>
          ))}
        </div>
        <Detail sel={sel} onFermer={() => setSel(null)} onOpen={null} />
        <div className="an-grille auto trois-max">
          <PanneauVentes12 M={M} onMois={(m) => setSel(selFacturesMois(M, m))} />
          <section className="an-panneau" aria-label="Mix par famille">
            <div className="an-panneau-tete"><div><h2>Mix par famille</h2><p>{F.cur.lib}, montants HT des lignes de facture · QuickBooks. Clic : les produits de la famille.</p></div></div>
            {!mix ? <p className="an-nd"><b>Non disponible</b> : {raisonMois}.</p> : !totMix ? <p className="an-vide">Aucune vente sur la période.</p> :
              <Barres lignes={FAMILLES.map(([k, l]) => { const e = mixPrev ? ecart(mix[k], mixPrev[k], "argent") : null; return { k, label: l, v: mix[k], sous: `${pct(mix[k] / totMix * 100)} des ventes${e ? ` · ${e.txt} vs ${F.prev.lib}` : ""}` }; }).sort((a, b) => b.v - a.v)} fmt={fmtK} choisi={sel && sel.k}
                onClic={(k) => { const L = topProduits(arts.filter(a => familleDe(a.nom) === k)); const autres = arts.filter(a => familleDe(a.nom) === k && !produitDe(a.nom)).reduce((s, a) => s + a.montant, 0); setSel(sel && sel.k === k ? null : { k, titre: `${LIB_FAMILLE[k]} · produits et services`, sous: F.cur.lib, lignes: [...L.map(p => ({ k: p.k, t: p.label, s: `${nbFr(p.qty)} vendu${p.qty >= 2 ? "s" : ""}`, v: fmtCAD(p.montant) })), ...(autres ? [{ k: "autres", t: "Main-d'œuvre, installation et matériel", s: "lignes de service de la famille", v: fmtCAD(autres) }] : [])] }); }}
                detail={(l) => <><div className="an-bulle-t">{l.label}</div><div className="an-bulle-r"><b>{fmtCAD(l.v)}</b><span>HT</span></div><div className="an-bulle-note">{l.sous}</div></>} />}
          </section>
          <section className="an-panneau" aria-label="Produits les plus vendus">
            <div className="an-panneau-tete"><div><h2>Produits les plus vendus</h2><p>{F.cur.lib}, matériel seulement (main-d'œuvre et petit matériel exclus), HT · QuickBooks</p></div></div>
            {!top ? <p className="an-nd"><b>Non disponible</b> : {raisonMois}.</p> :
              <Barres lignes={top.map(p => ({ k: p.k, label: p.label, v: p.montant, suffixe: `${nbFr(p.qty)} u.` }))} fmt={fmtK} detail={(l) => <><div className="an-bulle-t">{l.label}</div><div className="an-bulle-r"><b>{fmtCAD(l.v)}</b><span>HT, {l.suffixe}</span></div></>} />}
          </section>
        </div>
        <div className="an-grille auto">
          <section className="an-panneau" aria-label="Panier moyen par type de client">
            <div className="an-panneau-tete"><div><h2>Panier moyen par type de client</h2><p>Depuis {M.paniers ? "janvier 2023" : "le début"}, par client facturé (acompte et finale ensemble), HT · QuickBooks</p></div></div>
            {!pa.length ? <p className="an-nd"><b>Non disponible</b> : panier par type pas encore calculé par le worker.</p> : (
              <dl className="an-kv">{pa.map(([k, t]) => <React.Fragment key={k}><dt>{TYPES[k] || k}<span className="an-item-s" style={{ display: "block" }}>{nbFr(t.clients)} clients · médiane {fmtK(t.median)}</span></dt><dd>{fmtCAD(t.moyen, 0)}<span>{nbFr(t.part_pct, 0)} % du chiffre</span></dd></React.Fragment>)}</dl>
            )}
          </section>
          <section className="an-panneau" aria-label="Marge">
            <div className="an-panneau-tete"><div><h2>Marge</h2><p>Ventes moins coût du matériel</p></div></div>
            <p className="an-nd"><b>Non disponible</b> : aucune route du worker ne lit le coût d'achat des articles. Route à ajouter (lecture seule) : GET /raycast/marge, rapport ProfitAndLoss QuickBooks par mois (revenus, coût des produits vendus, marge brute), mis en cache KV comme /raycast/ventes-produits.</p>
          </section>
        </div>
        {Ancien && Ancien.SitesPowerhub && <details className="an-panneau an-repli" style={{ marginTop: 14 }}><summary>Parc Tesla installé (Powerhub)</summary><div style={{ marginTop: 10 }}><Ancien.SitesPowerhub v={null} /></div></details>}
      </>
    );
  }

  function AnalyticsRE({ profile, onOpen }) {
    const [periode, setPeriode] = usePeriode();
    const [onglet, setOnglet] = useState(() => { const o = window.__analyticsOnglet; window.__analyticsOnglet = null; return o === "ventes" ? "ventes" : "leads"; });
    const { M, charge, rafraichir } = useDonnees();
    const [sel, setSel] = useState(null);
    const auj = aujourdhui();
    const F = useMemo(() => fenetres(periode, auj), [periode, auj]);
    const meta = useMeta(F, charge, M && M.leadsDebut);
    useEffect(() => { setSel(null); }, [periode, onglet]);
    const admin = !profile || profile.role === "admin";
    return (
      <div className="an-root" data-vue="analytics">
        <div className="an-tete">
          <div><h1>Analytics</h1><p>Leads, marketing et ventes : ce qui rapporte, ce qui coûte, ce qui bloque</p></div>
          <div className="an-actions"><button type="button" className="an-btn" onClick={() => { for (const k of Object.keys(cacheLp)) delete cacheLp[k]; rafraichir(); }}>Rafraîchir</button></div>
        </div>
        <div className="an-onglets" role="tablist" aria-label="Analytics">
          <button type="button" role="tab" aria-selected={onglet === "leads"} onClick={() => setOnglet("leads")}>Leads et marketing</button>
          {admin && <button type="button" role="tab" aria-selected={onglet === "ventes"} onClick={() => setOnglet("ventes")}>Ventes</button>}
        </div>
        <SelecteurPeriode periode={periode} setPeriode={setPeriode} F={F} />
        {!charge || !M ? <div className="an-panneau an-attente">Chargement…</div> : (
          <>
            <Erreurs M={M} />
            {onglet === "ventes" && admin ? <VentesAnalyse M={M} F={F} sel={sel} setSel={setSel} /> : <LeadsMarketing M={M} F={F} meta={meta} sel={sel} setSel={setSel} />}
          </>
        )}
      </div>
    );
  }

  window.AnalysesRE = { agregerLp, entonnoirLp, lpAbsente, canalLpDe, lireStatsLp, fenetres, ventesEntre, articlesEntre, mixFamilles, topProduits, familleDe, produitDe, pageDe, systemeDe, canalDe, estTest, construire, personnes, agregats, constats, serieVentes, serieLeadsMois, IND, charger, metaFenetre, SEUIL_QUALIFIE, _vider: () => { cacheSrc = null; for (const k of Object.keys(cacheMeta)) delete cacheMeta[k]; for (const k of Object.keys(cacheLp)) delete cacheLp[k]; } };
  window.TableauDeBordRE = TableauDeBordRE;
  window.AnalyticsRE = AnalyticsRE;
  // La coquille (app.jsx) affiche window.DashboardRE pour « Tableau de bord » et window.Analytics2026 pour « Analytics » :
  // ce module, chargé après les anciens, prend leur place sans toucher app.jsx. L'ancien tableau de bord reste joignable
  // (window.DashboardREAncien) pour ses blocs Powerhub, repliés dans l'onglet Ventes.
  if (window.DashboardRE && window.DashboardRE !== TableauDeBordRE) window.DashboardREAncien = window.DashboardRE;
  window.DashboardRE = TableauDeBordRE;
  window.Analytics2026 = AnalyticsRE;
})();
