// clients-re.jsx — Page Clients v1.2 : UN seul répertoire pour tous les contacts (QuickBooks, RAYCAST, GHL, Aircall),
// dédoublonné côté worker (/raycast/clients : téléphone 10 chiffres puis courriel). Fiche client : coordonnées,
// Street View, « Chez nous » (système acheté d'après les factures QuickBooks), soumissions RAYCAST, devis et factures,
// « Ce que le client a dit » (analyses IA des appels et conversations), dossier (photos et pièces jointes reçues).
// Aperçu (6 nov. 2026) : en haut, carte « Fiche » (adresse complète, téléphone, courriel, source, étape GHL, projet, système,
// consommation, n° client HQ masqué, dernier contact, prochaine étape ; un fait inconnu = une ligne grise « à obtenir ») et
// « En bref » de 3 phrases au plus ; le détail (résumé complet, reprise, chronologie, ce que le client a dit) est replié dans
// « Détails et conversations », fermé par défaut.
//
//   window.ClientsRE  → composant React { onNewFor(client), onOpenSubmission(id), clientInitial }
//   clientInitial (facultatif) : { supabase_id } ou { cle } ou { ghl_contact_id } ou { qbo_id }. Dès que la liste unifiée
//   est chargée, la fiche du contact visé s'ouvre d'elle-même (une seule fois par valeur de la prop ; une nouvelle valeur
//   la rouvre). La coquille passe cette prop par window.RaycastNav.ouvrirClient(id).

(function () {
  const { useState, useEffect, useMemo, useRef } = React;
  // Éclair Raycom (défini par icons.jsx ou cloud/auth.jsx) ; repli local qui dessine la même silhouette quand ce module est chargé seul (tests, aperçus).
  const EclairRaycom = (p) => (window.EclairRaycom ? <window.EclairRaycom {...p} /> : <svg width={(p.size || 16) * 0.56} height={p.size || 16} viewBox="0 0 389 696" aria-hidden="true" className="rc-eclair" style={{ display: "inline-block", verticalAlign: "-0.15em", ...(p.style || {}) }}><polygon points="300,0 195,288 389,288 78,696 184,406 0,405" fill={p.couleur || "#0a6fc8"} /></svg>);
  const TZ = "America/Toronto";
  const fmt = (n) => window.CALC_RE.fmtCAD(n);
  const fmt0 = (n) => window.CALC_RE.fmtCAD(n, 0);
  const DATE_SEULE = /^\d{4}-\d{2}-\d{2}$/;
  /** Date robuste : « 2026-06-10 » (QuickBooks) est lue à midi pour ne pas reculer d'un jour ; horodatages ISO ou en millisecondes acceptés. */
  const parseDate = (d) => {
    if (d == null || d === "") return null;
    if (d instanceof Date) return isNaN(d) ? null : d;
    const s = String(d).trim();
    const x = DATE_SEULE.test(s) ? new Date(s + "T12:00:00") : new Date(/^\d{12,}$/.test(s) ? Number(s) : s);
    return isNaN(x) ? null : x;
  };
  const dateFR = (d) => { const s = String(d || "").trim(); if (DATE_SEULE.test(s)) return s; const x = parseDate(d); return x ? x.toLocaleDateString("fr-CA", { timeZone: TZ }) : "—"; };
  const dateHeure = (d) => { const x = parseDate(d); return x ? x.toLocaleString("fr-CA", { timeZone: TZ, dateStyle: "medium", timeStyle: "short" }) : "—"; };
  const norm = (s) => (s || "").toString().normalize("NFD").replace(/[̀-ͯ]/g, "").toLowerCase();
  const tel = (s) => (s == null ? "" : String(s)).replace(/\D/g, "").slice(-10);
  const telFmt = (s) => { const t = tel(s); return t.length === 10 ? `${t.slice(0, 3)} ${t.slice(3, 6)}-${t.slice(6)}` : (s == null ? "" : String(s)); };
  const texte = (e) => (e && e.message) ? e.message : String(e);
  const pluriel = (n, un, des) => `${n} ${n > 1 ? des : un}`;

  // Jeton de session toujours frais (JF, 5 nov. 2026 : « Unauthorized » quand l'onglet était resté ouvert longtemps) :
  // renouvelé s'il expire dans moins de 2 minutes, ou de force après un refus 401 du worker.
  async function jwt(forcer) {
    const sb = window.RAYCAST_SUPABASE;
    let { data } = await sb.auth.getSession();
    let s = data && data.session;
    if (s && (forcer || (s.expires_at && s.expires_at * 1000 - Date.now() < 120000))) {
      try { const r = await sb.auth.refreshSession(); if (r && r.data && r.data.session) s = r.data.session; } catch (e) { /* on garde le jeton actuel */ }
    }
    return s ? s.access_token : null;
  }
  async function worker(path) {
    let t = await jwt(); if (!t) throw new Error("Session expirée, reconnecte-toi");
    let r = await fetch(`${window.CatalogueRE.WORKER_URL}${path}`, { headers: { Authorization: `Bearer ${t}` } });
    if (r.status === 401) { t = await jwt(true); if (t) r = await fetch(`${window.CatalogueRE.WORKER_URL}${path}`, { headers: { Authorization: `Bearer ${t}` } }); }
    const j = await r.json().catch(() => ({}));
    if (!r.ok) throw new Error(j.error || `HTTP ${r.status}`);
    return j;
  }

  async function workerPost(path, body, multipart) {
    let t = await jwt(); if (!t) throw new Error("Session expirée, reconnecte-toi");
    const envoyer = (jeton) => fetch(`${window.CatalogueRE.WORKER_URL}${path}`, { method: "POST", headers: multipart ? { Authorization: `Bearer ${jeton}` } : { Authorization: `Bearer ${jeton}`, "Content-Type": "application/json" }, body: multipart ? body : JSON.stringify(body) });
    let r = await envoyer(t);
    if (r.status === 401) { t = await jwt(true); if (t) r = await envoyer(t); }
    const j = await r.json().catch(() => ({}));
    if (!r.ok) throw new Error(j.error || `HTTP ${r.status}`);
    return j;
  }
  // Clé client (même règle que le worker, src/cles.ts) : téléphone à 10 chiffres, poste retiré (« 450 555-1234 poste 22 » donnait
  // une clé fausse et un dossier vide), sinon courriel en minuscules.
  const cleTel = (s) => { const x = s == null ? "" : String(s).trim(); if (!x || x.includes("@")) return ""; const d = x.replace(/\s*(?:poste|postes|extension|ext\.?|x|#|:)\s*\d{1,6}\s*$/i, "").replace(/\D/g, ""); return d.length >= 10 ? d.slice(-10) : ""; };
  const cleDe = (v) => { const s = v == null ? "" : String(v).trim().toLowerCase(); return cleTel(s) || (/^[^\s@]+@[^\s@]+\.[a-z]{2,}$/.test(s) ? s : ""); };
  // Clés apprises à la reprise de l'historique (autre téléphone ou courriel du même contact), gardées pour la session.
  const clesApprises = new Map();
  /** Toutes les clés du dossier : téléphone et courriel affichés, clés de la fiche unifiée (c.cles : autres téléphones et courriels
   *  fusionnés par le worker) et clés apprises à la reprise ; 6 au plus, la première est la clé principale. */
  const clesDe = (c) => { const out = []; for (const v of [c.telephone, c.courriel, ...(Array.isArray(c.cles) ? c.cles : []), ...(clesApprises.get(c.cle) || [])]) { const k = cleDe(v); if (k && !out.includes(k)) out.push(k); } return out.slice(0, 6); };
  const EVT_DOSSIER = "raycast-dossier-maj";

  /** Index de recherche calculé une seule fois par contact (nom, entreprise, courriel, ville, adresse, code postal, sans accents ni casse ;
   *  téléphone ramené à 10 chiffres) : 5 000 lignes se filtrent à chaque frappe sans refaire la normalisation. */
  const indexer = (c) => ({ ...c, sources: c.sources || {}, _q: norm(`${c.nom || ""} ${c.entreprise || ""} ${c.courriel || ""} ${c.ville || ""} ${c.adresse || ""} ${c.code_postal || ""} ${c.address_full || ""}`), _t: tel(c.telephone) });
  /** Tolère l'ancien format du worker (liste QuickBooks seule) tant que la version unifiée n'est pas déployée. */
  const normaliser = (c) => indexer(c.sources ? c : { ...c, cle: c.cle || `qbo:${c.id}`, sources: { qbo_id: c.id || null, supabase_id: null, ghl_contact_id: null, aircall: false, ghl_conversations: false }, derniere_interaction: c.derniere_interaction || null, nb_devis: 0, nb_factures: 0, total_facture_ht: 0, solde: Number(c.solde || 0) });
  /** Fiche minimale bâtie depuis la table clients (RAYCAST) quand le contact demandé n'est pas dans la liste unifiée. */
  // La table clients n'a pas de colonne « entreprise » : elle est gardée en première ligne des notes (« Entreprise : … »).
  const PREFIXE_ENTREPRISE = "Entreprise : ";
  const separerNotes = (notes) => {
    const s = notes == null ? "" : String(notes);
    const m = s.match(/^Entreprise : ([^\r\n]*)(\r?\n|$)/);
    return m ? { entreprise: m[1].trim(), notes: s.slice(m[0].length) } : { entreprise: "", notes: s };
  };
  const joindreNotes = (entreprise, notes) => [String(entreprise || "").trim() ? PREFIXE_ENTREPRISE + String(entreprise).trim() : "", String(notes || "").trim()].filter(Boolean).join("\n");
  const depuisSupabase = (c) => indexer({ cle: `sup:${c.id}`, nom: c.name || "", entreprise: separerNotes(c.notes).entreprise || null, source: c.source || null, courriel: c.email || null, telephone: c.phone || null, adresse: [c.address_civic, c.address_street].filter(Boolean).join(" ") || null, ville: c.address_city || null, code_postal: c.address_postal || null, address_full: c.address_full || null, lat: c.lat || null, lng: c.lng || null, solde: 0, derniere_interaction: null, nb_devis: 0, nb_factures: 0, total_facture_ht: 0, sources: { qbo_id: null, supabase_id: c.id, ghl_contact_id: null, aircall: false, ghl_conversations: false } });
  const meme = (a, b) => a != null && a !== "" && b != null && String(a) === String(b);
  /** Retrouve le contact visé par clientInitial (clé unifiée, id RAYCAST, contact GHL, client QuickBooks ou téléphone/courriel). */
  const trouver = (rows, ci) => {
    if (!ci || !rows) return null;
    const s = (r) => r.sources || {};
    return rows.find(r => meme(ci.cle, r.cle))
      || rows.find(r => meme(ci.supabase_id, s(r).supabase_id))
      || rows.find(r => meme(ci.ghl_contact_id, s(r).ghl_contact_id))
      || rows.find(r => meme(ci.qbo_id, s(r).qbo_id))
      || (ci.cle ? rows.find(r => clesDe(r).includes(String(ci.cle).trim().toLowerCase())) : null)
      || null;
  };

  // ─── Liste unifiée gardée en mémoire pour toute la session ───
  // Préchargée au démarrage de l'application (window.ClientsRE.precharger, appelé par app.jsx après connexion et MFA) :
  // la vue Clients s'ouvre tout de suite. « Rafraîchir » relit la liste du worker (KV, instantané), fusionne les clients
  // Raycast créés ou modifiés depuis (table clients, updated_at) et demande au worker de reconstruire la liste en arrière-plan.
  let cacheListe = null;        // { rows, synced, charge_le, utilisateur }
  let chargementEnCours = null; // promesse partagée : précharge et vue ne lancent jamais deux chargements
  let majEnCours = false;
  let derniereErreur = null;
  let suiviTimer = null;
  const SUIVI_MS = 45000;       // relecture incrémentale (?depuis=) après une reconstruction demandée au worker
  const abonnes = new Set();
  const notifier = () => abonnes.forEach(f => { try { f(); } catch (e) { /* vue démontée */ } });
  // Fiches créées ou enregistrées dans Raycast depuis cette vue : le worker ne les connaît qu'après sa reconstruction.
  // Elles restent dans la liste (ou gardent leur supabase_id) tant que la liste unifiée ne les a pas fusionnées.
  let ajoutsLocaux = [];
  const fusionnerLocaux = (liste) => {
    ajoutsLocaux = ajoutsLocaux.filter(x => !liste.some(r => meme(r.sources && r.sources.supabase_id, x.sources.supabase_id)));
    if (!ajoutsLocaux.length) return liste;
    const out = liste.map(r => { const x = ajoutsLocaux.find(a => a.cle === r.cle); return x ? indexer({ ...r, sources: { ...(r.sources || {}), supabase_id: x.sources.supabase_id } }) : r; });
    return [...ajoutsLocaux.filter(a => !liste.some(r => r.cle === a.cle)), ...out];
  };
  const memoriserLocal = (r) => { ajoutsLocaux = [r, ...ajoutsLocaux.filter(x => !meme(x.sources.supabase_id, r.sources.supabase_id))]; };
  const mailNorm = (s) => (s == null ? "" : String(s)).trim().toLowerCase();
  /** Clients Raycast (table clients) créés ou modifiés depuis une date : lecture directe Supabase, une panne ne bloque rien. */
  async function clientsRaycastDepuis(iso) {
    try {
      if (!window.RAYCAST_SUPABASE || !window.RAYCAST_SUPABASE.from) return [];
      const { data, error } = await window.RAYCAST_SUPABASE.from("clients").select("*").gt("updated_at", iso).order("updated_at", { ascending: false }).limit(500);
      return error || !Array.isArray(data) ? [] : data;
    } catch (e) { return []; }
  }
  /** Fusionne des lignes de la table clients dans la liste : même fiche (supabase_id) mise à jour, sinon même téléphone ou courriel
   *  (le contact QuickBooks ou GHL gagne sa fiche Raycast, ses champs vides sont complétés), sinon nouvelle ligne en tête. */
  function fusionnerRaycast(liste, lignes) {
    if (!lignes || !lignes.length) return liste;
    const out = liste.slice();
    const parSid = new Map(), parTel = new Map(), parMail = new Map();
    out.forEach((r, i) => { const sid = r.sources && r.sources.supabase_id; if (sid) parSid.set(String(sid), i); if (r._t && r._t.length === 10 && !parTel.has(r._t)) parTel.set(r._t, i); const m = mailNorm(r.courriel); if (m && !parMail.has(m)) parMail.set(m, i); });
    const nouveaux = [];
    for (const s of lignes) {
      const b = depuisSupabase(s);
      const t = tel(s.phone), m = mailNorm(s.email);
      let i = parSid.get(String(s.id));
      const memeFiche = i != null;
      if (i == null && t.length === 10) i = parTel.get(t);
      if (i == null && m) i = parMail.get(m);
      if (i == null) { if (!nouveaux.some(x => meme(x.sources.supabase_id, s.id))) { nouveaux.push(b); memoriserLocal(b); } continue; }
      const r = out[i];
      const champs = ["nom", "entreprise", "courriel", "telephone", "adresse", "ville", "code_postal", "address_full", "lat", "lng"];
      const maj = {}; for (const k of champs) { if (memeFiche ? (b[k] != null && b[k] !== "") : (r[k] == null || r[k] === "")) maj[k] = b[k]; }
      out[i] = indexer({ ...r, ...maj, source: r.source || b.source || null, sources: { ...(r.sources || {}), supabase_id: s.id } });
    }
    return nouveaux.length ? [...nouveaux, ...out] : out;
  }
  /** Réponse incrémentale (?depuis=) : chaque contact remplace la ligne de même clé ou de même fiche Raycast. */
  function fusionnerDelta(liste, delta) {
    if (!delta.length) return liste;
    const cles = new Set(delta.map(d => d.cle)), sids = new Set(delta.map(d => d.sources && d.sources.supabase_id).filter(Boolean).map(String));
    return [...delta, ...liste.filter(r => !cles.has(r.cle) && !(r.sources && r.sources.supabase_id && sids.has(String(r.sources.supabase_id))))];
  }
  const avantMarge = (iso, ms) => { const t = iso ? Date.parse(iso) : NaN; return new Date((isNaN(t) ? Date.now() : t) - ms).toISOString(); };
  /** Charge la liste unifiée (KV du worker, instantané) puis les clients Raycast modifiés depuis sa construction.
   *  reconstruire : demande aussi au worker de reconstruire en arrière-plan (?refresh=1, limite de débit : repli sur la simple lecture). */
  function chargerListe(o) {
    const opts = o || {};
    if (chargementEnCours) return chargementEnCours;
    majEnCours = true; notifier();
    chargementEnCours = (async () => {
      try {
        let w = null;
        if (opts.reconstruire) { try { w = await worker("/raycast/clients?refresh=1"); } catch (e) { w = null; } }
        if (!w) w = await worker("/raycast/clients");
        let liste = fusionnerLocaux((Array.isArray(w.clients) ? w.clients : []).map(normaliser));
        // Marge de 5 minutes : la reconstruction lit Supabase au début et peut durer jusqu'à 30 secondes.
        const depuis = avantMarge(cacheListe && cacheListe.synced && w.synced_at && cacheListe.synced < w.synced_at ? cacheListe.synced : w.synced_at, 5 * 60000);
        liste = fusionnerRaycast(liste, await clientsRaycastDepuis(depuis));
        cacheListe = { rows: liste, synced: w.synced_at || null, charge_le: Date.now(), utilisateur: opts.utilisateur !== undefined ? opts.utilisateur : (cacheListe ? cacheListe.utilisateur : null) };
        derniereErreur = null;
        if (w.reconstruction) planifierSuivi(w.synced_at, 0);
        return cacheListe;
      } catch (e) { derniereErreur = "Liste des clients indisponible : " + texte(e); return cacheListe; }
      finally { majEnCours = false; chargementEnCours = null; notifier(); }
    })();
    return chargementEnCours;
  }
  /** Après une reconstruction demandée : relit seulement les contacts modifiés (?depuis=) dès que le worker a fini (3 essais). */
  function planifierSuivi(syncAvant, essai) {
    clearTimeout(suiviTimer);
    if (essai >= 3) return;
    suiviTimer = setTimeout(async () => {
      try {
        const w = await worker(`/raycast/clients?depuis=${encodeURIComponent(avantMarge(syncAvant, 5 * 60000))}`);
        if (!cacheListe || !w.synced_at || (syncAvant && w.synced_at <= syncAvant)) return planifierSuivi(syncAvant, essai + 1);
        const delta = (Array.isArray(w.clients) ? w.clients : []).map(normaliser);
        cacheListe = { ...cacheListe, rows: fusionnerLocaux(fusionnerDelta(cacheListe.rows, delta)), synced: w.synced_at, charge_le: Date.now() };
        notifier();
      } catch (e) { /* prochain Rafraîchir */ }
    }, SUIVI_MS);
  }
  /** Précharge (démarrage de l'application, donc à chaque connexion) : relit la liste en arrière-plan ; la liste déjà en mémoire reste
   *  affichée pendant ce temps. Un autre compte sur le même navigateur repart d'une liste vide. */
  function precharger(o) {
    const u = (o && o.utilisateur) || null;
    if (cacheListe && cacheListe.utilisateur && u && cacheListe.utilisateur !== u) { cacheListe = null; ajoutsLocaux = []; derniereErreur = null; clearTimeout(suiviTimer); }
    return chargerListe({ utilisateur: u || (cacheListe ? cacheListe.utilisateur : null) });
  }
  const rafraichir = () => chargerListe({ reconstruire: true });
  const placerDansCache = (r) => { cacheListe = cacheListe ? { ...cacheListe, rows: remplacerLigne(cacheListe.rows, r) } : { rows: [r], synced: null, charge_le: Date.now(), utilisateur: null }; notifier(); };

  // ─── Recherche instantanée : mots (sans accents ni casse) et chiffres (téléphone 10 chiffres ou numéro civique) ───
  const LIMITE_AFFICHAGE = 200;
  const PREMIER_LOT = 40;       // lignes rendues à la frappe même ; les suivantes (jusqu'à 200) à l'image suivante
  const preparerRecherche = (q) => {
    const brut = String(q || "").trim();
    if (!brut) return null;
    // Requête faite seulement de chiffres et de séparateurs (450 555-1234, (450) 555 1234) : un seul bloc de chiffres.
    if (/^[\d\s().+-]+$/.test(brut)) { const d = brut.replace(/\D/g, ""); return d ? { mots: [], chiffres: [d] } : null; }
    const mots = [], chiffres = [];
    for (const m of norm(brut).split(/\s+/).filter(Boolean)) { if (/^[\d().+-]+$/.test(m) && /\d/.test(m)) chiffres.push(m.replace(/\D/g, "")); else mots.push(m); }
    return { mots, chiffres };
  };
  /** Une ligne correspond si chaque mot est dans l'index et chaque bloc de chiffres dans le téléphone ou l'index (numéro civique, code postal). */
  const correspond = (r, rq) => {
    const q = r._q || "", t = r._t || "";
    for (const m of rq.mots) if (q.indexOf(m) < 0) return false;
    for (const d of rq.chiffres) if (t.indexOf(d) < 0 && q.indexOf(d) < 0) return false;
    return true;
  };
  /** Filtre local : les 200 premières lignes et le nombre total de correspondances. */
  function filtrerClients(rows, q, test) {
    const t0 = (window.performance && performance.now) ? performance.now() : Date.now();
    const rq = preparerRecherche(q);
    const lignes = []; let n = 0;
    for (const r of rows || []) {
      if (test && !test(r)) continue;
      if (rq && !correspond(r, rq)) continue;
      n++; if (lignes.length < LIMITE_AFFICHAGE) lignes.push(r);
    }
    const ms = ((window.performance && performance.now) ? performance.now() : Date.now()) - t0;
    if (window.ClientsCache) window.ClientsCache.dernierFiltreMs = ms;
    return { lignes, n, rq };
  }
  /** Plages [début, fin[ du texte original qui correspondent à la recherche (mots normalisés, chiffres en ignorant les séparateurs). */
  function plages(texteOrig, rq) {
    const s = texteOrig == null ? "" : String(texteOrig);
    if (!s || !rq) return [];
    const out = [];
    if (rq.mots.length) {
      let n = ""; const carte = [];
      for (let i = 0; i < s.length; i++) { const c = norm(s[i]); for (let k = 0; k < c.length; k++) { n += c[k]; carte.push(i); } }
      for (const m of rq.mots) { let p = n.indexOf(m); while (p >= 0) { out.push([carte[p], carte[p + m.length - 1] + 1]); p = n.indexOf(m, p + m.length); } }
    }
    if (rq.chiffres.length) {
      let d = ""; const carte = [];
      for (let i = 0; i < s.length; i++) if (s[i] >= "0" && s[i] <= "9") { d += s[i]; carte.push(i); }
      for (const c of rq.chiffres) { let p = d.indexOf(c); while (p >= 0) { out.push([carte[p], carte[p + c.length - 1] + 1]); p = d.indexOf(c, p + c.length); } }
    }
    out.sort((a, b) => a[0] - b[0]);
    const fus = [];
    for (const x of out) { const der = fus[fus.length - 1]; if (der && x[0] <= der[1]) der[1] = Math.max(der[1], x[1]); else fus.push([x[0], x[1]]); }
    return fus;
  }
  /** Texte avec la partie trouvée mise en évidence. */
  function Surligne({ texte: t, rq }) {
    const s = t == null ? "" : String(t);
    const p = plages(s, rq);
    if (!p.length) return s;
    const morceaux = []; let i = 0;
    p.forEach(([a, b], k) => { if (a > i) morceaux.push(s.slice(i, a)); morceaux.push(<mark key={k} className="rc-trouve">{s.slice(a, b)}</mark>); i = b; });
    if (i < s.length) morceaux.push(s.slice(i));
    return <>{morceaux}</>;
  }
  const ilYa = (ms) => { const m = Math.floor(Math.max(0, Date.now() - ms) / 60000); return m < 1 ? "à l'instant" : m < 60 ? `il y a ${m} min` : `il y a ${Math.floor(m / 60)} h${m % 60 ? " " + String(m % 60).padStart(2, "0") : ""}`; };
  const remplacerLigne = (liste, r) => { const l = liste || []; const i = l.findIndex(x => x.cle === r.cle); return i >= 0 ? l.map((x, j) => (j === i ? r : x)) : [r, ...l]; };

  // ─── Création et modification d'un client : table clients de Raycast seulement ───
  // QuickBooks et GHL ne sont jamais touchés ici : le client est créé dans QuickBooks au moment de finaliser le devis.
  async function utilisateurId() {
    try { const { data } = await window.RAYCAST_SUPABASE.auth.getUser(); return data && data.user ? data.user.id : null; } catch (e) { return null; }
  }
  const baseClients = () => { if (!window.RaycastDB || !window.RaycastDB.createClient || !window.RaycastDB.updateClient) throw new Error("base Raycast indisponible, recharge la page"); return window.RaycastDB; };
  const clientDB = {
    creer: async (champs) => baseClients().createClient(champs, await utilisateurId()),
    modifier: async (id, champs) => baseClients().updateClient(id, champs),
    lire: async (id) => (window.RaycastDB && window.RaycastDB.getClient ? window.RaycastDB.getClient(id) : null),
    /** Doublons déjà dans la table clients (même téléphone ou courriel) ; une panne de lecture ne bloque pas la création. */
    doublons: async (phone, email) => { try { return window.RaycastDB && window.RaycastDB.findClientsByContact ? (await window.RaycastDB.findClientsByContact({ phone, email })) || [] : []; } catch (e) { return []; } },
  };
  /** 10 chiffres (un « 1 » de tête est accepté), sinon "". */
  const telDix = (s) => { let d = String(s == null ? "" : s).replace(/\D/g, ""); if (d.length === 11 && d[0] === "1") d = d.slice(1); return d.length === 10 ? d : ""; };
  const COURRIEL_OK = /^[^\s@]+@[^\s@.]+(\.[^\s@.]+)*\.[a-z]{2,}$/i;
  /** Source du lead d'un contact importé (QuickBooks, GHL, Aircall) ramenée à un id de RE_SOURCES quand c'est possible. */
  const sourceLead = (r) => { const brut = String(r.source || r.ghl_source || "").trim(); return brut && window.RE_normaliserSource ? window.RE_normaliserSource(brut) : brut; };
  const champsAdresse = (g) => ({ address_full: g.address_full || "", address_civic: g.address_civic || "", address_street: g.address_street || "", address_city: g.address_city || "", address_postal: g.address_postal || "", address_province: g.address_province || "QC", lat: g.lat == null ? null : g.lat, lng: g.lng == null ? null : g.lng, place_id: g.place_id || null });
  const ADRESSE_VIDE = { address_civic: "", address_street: "", address_city: "", address_postal: "", lat: null, lng: null, place_id: null };
  const FORM_VIDE = { name: "", entreprise: "", phone: "", email: "", address_full: "", address_civic: "", address_apt: "", address_street: "", address_city: "", address_postal: "", address_province: "QC", lat: null, lng: null, place_id: null, source: "", notes: "" };
  const avecDelai = (p, ms) => Promise.race([p, new Promise((_, non) => setTimeout(() => non(new Error("délai dépassé")), ms))]);
  function validerClient(f) {
    const e = {};
    if (!String(f.name || "").trim()) e.name = "Le nom complet est requis.";
    const t = String(f.phone || "").trim(), c = String(f.email || "").trim();
    if (!t && !c) e.contact = "Entre au moins un téléphone ou un courriel.";
    if (t && !telDix(t)) e.phone = "Le téléphone doit avoir 10 chiffres (ex. 450 555-1234).";
    if (c && !COURRIEL_OK.test(c)) e.email = "Courriel invalide (ex. nom@exemple.com).";
    return e;
  }
  /** Pré-remplissage d'une création depuis la recherche tapée : un courriel, un numéro ou un nom. */
  const depuisRecherche = (q) => { const t = String(q || "").trim(); if (!t) return {}; if (/@/.test(t)) return { email: t }; if (!/[a-z]/i.test(t) && t.replace(/\D/g, "").length >= 7) return { phone: t }; return { name: t }; };

  /** Formulaire Nouveau client / Modifier le client (fenêtre par-dessus la liste ou la fiche). */
  function FormClient({ mode, initial, rows, onClose, onSaved, onOuvrir }) {
    const creation = mode === "creer";
    const [f, setF] = useState(() => ({ ...FORM_VIDE, ...(initial || {}) }));
    const [erreurs, setErreurs] = useState({});
    const [doublons, setDoublons] = useState(null);
    const [occupe, setOccupe] = useState(false);
    const [etat, setEtat] = useState("");
    const occupeRef = useRef(false);
    const up = (p) => { setF(x => ({ ...x, ...p })); setDoublons(null); };
    useEffect(() => {
      const k = (e) => { if (e.key === "Escape" && !occupeRef.current) onClose(); };
      window.addEventListener("keydown", k);
      return () => window.removeEventListener("keydown", k);
    }, []); // eslint-disable-line
    const sources = Array.isArray(window.RE_SOURCES) ? window.RE_SOURCES : [];
    const options = f.source && !sources.some(x => x.id === f.source) ? [...sources, { id: f.source, label: `${f.source} (valeur actuelle)` }] : sources;
    const enregistrer = async (forcer) => {
      if (occupeRef.current) return;
      const e = validerClient(f);
      setErreurs(e);
      if (Object.keys(e).length) { setEtat(""); return; }
      occupeRef.current = true; setOccupe(true); setEtat("");
      try {
        let champs = { ...f };
        // Adresse tapée sans choisir de suggestion : Google la complète (ville, code postal, coordonnées) ; sinon le texte est gardé tel quel.
        const adr = String(f.address_full || "").trim();
        if (adr && !f.lat && adr.length >= 6 && /\d/.test(adr) && window.GeoRE && window.GeoRE.resoudreAdresse) {
          setEtat("Google vérifie l'adresse…");
          try { const g = await avecDelai(window.GeoRE.resoudreAdresse(adr, { ville: f.address_city || null }), 8000); if (g && g.lat) { champs = { ...champs, ...champsAdresse(g) }; setF(x => ({ ...x, ...champsAdresse(g) })); } } catch (err) { /* adresse gardée en texte */ }
          setEtat("");
        }
        if (creation && !forcer) {
          const t = telDix(f.phone), c = String(f.email || "").trim().toLowerCase();
          const dansListe = (rows || []).filter(r => (t && r._t === t) || (c && String(r.courriel || "").trim().toLowerCase() === c));
          const enBase = (await clientDB.doublons(f.phone, f.email)).filter(x => !dansListe.some(r => meme(r.sources && r.sources.supabase_id, x.id))).map(depuisSupabase);
          const tous = [...dansListe, ...enBase].slice(0, 5);
          if (tous.length) { setDoublons(tous); return; }
        }
        const payload = {
          name: champs.name, phone: champs.phone, email: champs.email,
          address_full: champs.address_full, address_civic: champs.address_civic, address_apt: champs.address_apt, address_street: champs.address_street,
          address_city: champs.address_city, address_postal: champs.address_postal, address_province: champs.address_province || "QC",
          lat: champs.lat, lng: champs.lng, place_id: champs.place_id, source: champs.source, notes: joindreNotes(champs.entreprise, champs.notes),
        };
        const ligne = creation ? await clientDB.creer(payload) : await clientDB.modifier(initial.id, payload);
        occupeRef.current = false;
        onSaved(ligne);
        return;
      } catch (err) { setEtat("Enregistrement impossible : " + texte(err)); }
      occupeRef.current = false; setOccupe(false);
    };
    // occupe reste vrai pendant la vérification des doublons ; on le relâche quand la liste des doublons s'affiche
    useEffect(() => { if (doublons) { occupeRef.current = false; setOccupe(false); } }, [doublons]);
    const champ = (k, label, props, extra) => (
      <div className={"re-field" + (props && props.span ? " span" : "")}>
        <label className="re-field-label" htmlFor={"rc-client-" + k}>{label}</label>
        <input id={"rc-client-" + k} name={k} value={f[k] || ""} onChange={ev => up({ [k]: ev.target.value })} aria-invalid={erreurs[k] ? "true" : undefined} {...((props && props.input) || {})} />
        {erreurs[k] ? <span className="re-field-erreur">{erreurs[k]}</span> : extra}
      </div>
    );
    return (
      <div className="re-modal-fond" onMouseDown={ev => { if (ev.target === ev.currentTarget && !occupeRef.current) onClose(); }}>
        <div className="re-modal re-client-form" role="dialog" aria-modal="true" aria-labelledby="rc-client-titre">
          <div className="re-modal-tete">
            <h3 id="rc-client-titre">{creation ? "Nouveau client" : "Modifier la fiche"}</h3>
            <button type="button" className="re-btn small ghost" onClick={onClose} disabled={occupe}>Fermer</button>
          </div>
          <p className="re-client-form-aide">{creation ? "Enregistré dans Raycast seulement. Le client sera créé dans QuickBooks au moment du devis." : "Enregistré dans Raycast. GHL et QuickBooks ne sont pas modifiés pour l'instant : la synchronisation vers GHL viendra avec ton GO."}</p>
          <form onSubmit={ev => { ev.preventDefault(); enregistrer(false); }} noValidate>
            <div className="re-grid2">
              {champ("name", "Nom complet *", { span: true, input: { placeholder: "Prénom Nom", autoFocus: true, autoComplete: "off" } })}
              {champ("entreprise", "Entreprise (facultatif)", { span: true, input: { placeholder: "Nom de l'entreprise, s'il y a lieu", autoComplete: "off" } })}
              {champ("phone", "Téléphone", { input: { type: "tel", placeholder: "450 555-1234", autoComplete: "off" } })}
              {champ("email", "Courriel", { input: { type: "email", placeholder: "client@exemple.com", autoComplete: "off" } })}
              {erreurs.contact && <div className="span re-field-erreur re-client-form-contact">{erreurs.contact}</div>}
              <div className="re-field span">
                <span className="re-field-label">Adresse</span>
                {window.GeoRE && window.GeoRE.AdresseInput
                  ? <window.GeoRE.AdresseInput value={f.address_full} onChange={v => up({ address_full: v, ...ADRESSE_VIDE })} onPick={g => g && up(champsAdresse(g))} placeholder="Tape l'adresse et choisis la suggestion Google" />
                  : <input value={f.address_full || ""} onChange={ev => up({ address_full: ev.target.value, ...ADRESSE_VIDE })} placeholder="Adresse complète" />}
                <span className="re-field-hint">{f.lat
                  ? `Adresse reconnue : ${[f.address_city, f.address_postal, f.address_province].filter(Boolean).join(" · ")}${f.lat && f.lng ? ` · ${Number(f.lat).toFixed(5)}, ${Number(f.lng).toFixed(5)}` : ""}`
                  : "Ville, code postal, province et coordonnées se remplissent avec la suggestion Google (ou à l'enregistrement)."}</span>
              </div>
              <div className="re-field span">
                <label className="re-field-label" htmlFor="rc-client-source">Source du lead</label>
                <select id="rc-client-source" name="source" value={f.source || ""} onChange={ev => up({ source: ev.target.value })}>
                  <option value="">Choisir…</option>
                  {options.map(o => <option key={o.id} value={o.id}>{o.label}</option>)}
                </select>
              </div>
              <div className="re-field span">
                <label className="re-field-label" htmlFor="rc-client-notes">Notes</label>
                <textarea id="rc-client-notes" name="notes" rows={3} value={f.notes || ""} onChange={ev => up({ notes: ev.target.value })} placeholder="Besoin, disponibilités, référé par…" />
              </div>
            </div>
            {doublons && (
              <div className="re-alert re-client-doublon" role="alert">
                <b>Ce client existe déjà</b>
                <span> : même téléphone ou même courriel.</span>
                <ul>{doublons.map((d, i) => <li key={d.cle || i}><button type="button" className="re-link" onClick={() => onOuvrir(d)}>Ouvrir la fiche de {d.nom || "Sans nom"}</button><span className="re-muted"> · {[d.ville, d.courriel, telFmt(d.telephone)].filter(Boolean).join(" · ") || "aucune coordonnée"}</span></li>)}</ul>
                <button type="button" className="re-btn small" disabled={occupe} onClick={() => enregistrer(true)}>Créer quand même</button>
              </div>
            )}
            {etat && <div className={"re-etat re-client-form-etat" + (/impossible/.test(etat) ? " erreur" : "")}>{etat}</div>}
            <div className="re-modal-pied">
              <button type="button" className="re-btn" onClick={onClose} disabled={occupe}>Annuler</button>
              <button type="submit" className="re-btn primary" disabled={occupe}>{occupe ? "Un instant…" : creation ? "Créer le client" : "Enregistrer"}</button>
            </div>
          </form>
        </div>
      </div>
    );
  }

  const SOURCES = [
    { k: "qbo", test: (c) => c.sources && c.sources.qbo_id, label: "QuickBooks", cls: "qbo" },
    { k: "sup", test: (c) => c.sources && c.sources.supabase_id, label: "RAYCAST", cls: "sup" },
    { k: "ghl", test: (c) => c.sources && (c.sources.ghl_contact_id || c.sources.ghl_conversations), label: "GHL", cls: "ghl" },
    { k: "aircall", test: (c) => c.sources && c.sources.aircall, label: "Aircall", cls: "aircall" },
  ];
  function Badges({ c }) {
    return <span className="re-src-badges">{SOURCES.filter(s => s.test(c)).map(s => <span key={s.k} className={"re-src " + s.cls}>{s.k === "sup" && <EclairRaycom size={9} couleur="currentColor" style={{ marginRight: 4 }}/>}{s.label}</span>)}</span>;
  }

  /** Achats QuickBooks du client (/raycast/achats : factures avec lignes et résumé du système acheté), lus une fois par fiche et
   *  partagés par « Chez nous » et l'aperçu (Projet, Système). undefined : chargement ; null : pas client QuickBooks ; { error } : panne. */
  function useAchats(qboId) {
    const [a, setA] = useState(qboId ? undefined : null);
    useEffect(() => { let alive = true; if (!qboId) { setA(null); return; } setA(undefined); worker(`/raycast/achats?customer_id=${encodeURIComponent(qboId)}`).then(d => alive && setA(d || { error: true })).catch(() => alive && setA({ error: true })); return () => { alive = false; }; }, [qboId]);
    return a;
  }
  // Factures QuickBooks d'un client : un seul compte et un seul total pour toute la fiche (En bref, Projet, Chez nous).
  //  - /raycast/achats lit les 100 factures les plus récentes (lignes d'articles) : complet jusqu'à 100, tronqué au-delà ;
  //  - la fiche unifiée (r.nb_factures, r.total_facture_ht) compte toutes les factures, mais son « total_facture_ht » est en fait
  //    taxes incluses (la requête groupée du worker ne reçoit pas TxnTaxDetail : il égale la somme des TotalAmt).
  // Règle : les achats quand ils sont complets (somme des totaux taxes incluses, exacte) ; sinon le compte et le total de la fiche
  // unifiée, et « les 100 dernières factures » est dit partout où un chiffre vient des achats (système, plus ancienne facture).
  const LIMITE_ACHATS = 100;
  function facturesClient(r, a) {
    const res = a && a.resume && Number(a.resume.nb_factures) > 0 ? a.resume : null;
    const nUnif = Number(r && r.nb_factures) || 0, nLues = res ? Number(res.nb_factures) : 0;
    if (!res && !nUnif) return null;
    const tronque = !!res && nLues >= LIMITE_ACHATS && nUnif > nLues;
    const ttcLues = res && Array.isArray(a.factures) && a.factures.length ? a.factures.reduce((s, f) => s + (Number(f.total_ttc) || 0), 0) : 0;
    const n = tronque ? nUnif : (nLues || nUnif);
    const total = !tronque && ttcLues ? ttcLues : (Number(r && r.total_facture_ht) || ttcLues);
    return { n, total, tronque, nLues, premiere: !tronque && res ? res.premiere_facture : null, plusAncienneLue: res ? res.premiere_facture : null, derniere: res ? res.derniere_facture : null };
  }
  /** Résumé « Chez nous » : système acheté, montants, dates (mêmes chiffres que l'aperçu : facturesClient). */
  function ChezNous({ a, c }) {
    const r = a && a.resume;
    const fc = c ? facturesClient(c, a) : null;
    const systeme = r ? [
      r.nb_powerwall ? `${r.nb_powerwall} Powerwall 3` : null, r.expansion ? `${r.expansion} extension` : null, r.gateway ? `${r.gateway} passerelle Gateway 3` : null,
      r.onduleur_tesla ? `${r.onduleur_tesla} onduleur Tesla` : null, r.remote_meter ? "Remote Meter" : null,
      r.fox_aio ? `${r.fox_aio} Fox ESS AIO` : null, r.sigenergy_ctrl ? `${r.sigenergy_ctrl} Sigenergy Energy Controller` : null, r.lux_lxp ? `${r.lux_lxp} Lux Power LXP` : null,
      r.panneaux && r.panneaux.nb ? `${pluriel(r.panneaux.nb, "panneau solaire", "panneaux solaires")} (${window.CALC_RE.fmtNum(r.panneaux.kw)} kW)` : null,
      ...(Array.isArray(r.bornes) ? r.bornes : []).map(b => `${b.qty > 1 ? b.qty + " × " : ""}${b.nom || "borne"}`),
    ].filter(Boolean) : [];
    return (
      <div className="re-group re-chez-nous">
        <div className="re-group-head"><span>Chez nous</span><b>{a === undefined ? "…" : r && r.nb_factures ? pluriel(fc ? fc.n : r.nb_factures, "facture", "factures") : "aucun achat"}</b></div>
        {a === null && <p className="re-muted">Pas encore client QuickBooks : aucun achat facturé.</p>}
        {a && a.error && <p className="re-muted">Factures indisponibles pour le moment.</p>}
        {r && !r.nb_factures && <p className="re-muted">Client QuickBooks sans facture : aucun achat pour l'instant.</p>}
        {r && r.nb_factures > 0 && (
          <div className="re-chez-nous-grid">
            <div className="re-chez-nous-sys">
              <span className="re-field-label">Système installé</span>
              {systeme.length ? <ul>{systeme.map((x, i) => <li key={i}>{x}</li>)}</ul> : <p className="re-muted">Travaux électriques et autres articles, sans système d'énergie.</p>}
              {fc && fc.tronque && <p className="re-muted re-chez-nous-tronque">D'après les {fc.nLues} dernières factures sur {fc.n}.</p>}
            </div>
            <div className="re-kpis compact">
              <div><b>{fmt0(fc ? fc.total : r.total_ht)}</b><span>facturé, taxes incluses</span></div>
              <div><b>{dateFR(r.premiere_facture)}</b><span>{fc && fc.tronque ? `plus ancienne des ${fc.nLues} dernières` : "première facture"}</span></div>
              <div><b>{dateFR(r.derniere_facture)}</b><span>dernière facture</span></div>
            </div>
          </div>
        )}
      </div>
    );
  }

  /** « Système Tesla en service » : sites Powerwall extraits du Tesla Powerhub (table sites_tesla).
   *  1) un site dont client_id = fiche RAYCAST du client est son site (un client peut en avoir deux) ;
   *  2) sinon, suggestion par adresse : même numéro civique et même ville (sans accents ni casse), ou même code postal et numéro civique ;
   *  3) sinon, petit lien pour relier un site à la main. Le nom de client venant de Powerhub n'est jamais affiché. */
  const sitesTeslaDB = {
    lister: async () => {
      if (window.RaycastDB && window.RaycastDB.listSitesTesla) return window.RaycastDB.listSitesTesla();
      if (!window.RAYCAST_SUPABASE) return [];
      const { data, error } = await window.RAYCAST_SUPABASE.from("sites_tesla").select("*").order("date_installation", { ascending: false });
      if (error) throw error;
      return Array.isArray(data) ? data : [];
    },
    relier: async (siteId, clientId) => {
      if (window.RaycastDB && window.RaycastDB.linkSiteTesla) return window.RaycastDB.linkSiteTesla(siteId, clientId);
      const { data, error } = await window.RAYCAST_SUPABASE.from("sites_tesla").update({ client_id: clientId, updated_at: new Date().toISOString() }).eq("site_id", siteId).select("site_id");
      if (error) throw error;
      if (!data || !data.length) throw new Error("écriture refusée par la base");
      return data[0];
    },
  };
  const civique = (a) => { const m = String(a || "").trim().match(/^(\d+)/); return m ? m[1] : ""; };
  const postal = (p) => norm(p).replace(/[^a-z0-9]/g, "");
  const num = (n, d = 0) => (Number(n) || 0).toLocaleString("fr-CA", { minimumFractionDigits: 0, maximumFractionDigits: d });
  const kwh = (v) => (v == null || v === "" ? "n. d." : `${num(v)} kWh`);
  /** Le site correspond-il à l'adresse de la fiche ? Il faut un numéro civique des deux côtés : une ville seule ne suffit pas. */
  const siteCorrespond = (s, r) => {
    const cs = civique(s.adresse); if (!cs) return false;
    const cr = civique(r.adresse) || civique(r.address_full); if (!cr || cr !== cs) return false;
    const vs = norm(s.ville).trim(), vr = norm(r.ville).trim();
    if (vs && (vr ? vr === vs : norm(r.address_full).includes(vs))) return true;
    const ps = postal(s.code_postal), pr = postal(r.code_postal) || postal(r.address_full).slice(-6);
    return !!(ps && pr && ps === pr);
  };
  const MODES_BATTERIE = { self_powered: "Autoconsommation (Self-Powered)", time_based_control: "Selon les tarifs (Time-Based Control)", backup: "Secours seulement", autonomous: "Autonome" };
  const EXPORTS = { pv_only: "Solaire seulement", battery_ok: "Tout (solaire et batterie)", never: "Jamais", none: "Jamais" };
  const libelleMode = (m) => (m ? MODES_BATTERIE[String(m).toLowerCase()] || String(m) : "mode inconnu");
  const libelleExport = (x) => (x ? EXPORTS[String(x).toLowerCase()] || String(x) : "inconnu");
  const configSite = (s) => [
    Number(s.powerwall_qte) > 0 ? `${num(s.powerwall_qte)} Powerwall 3` : null,
    s.extension_batterie ? "extension de batterie" : null,
    Number(s.capacite_kwh) > 0 ? `${num(s.capacite_kwh, 1)} kWh` : null,
    Number(s.puissance_kw) > 0 ? `${num(s.puissance_kw, 1)} kW` : null,
    s.passerelle || null,
    Number(s.wall_connectors) > 0 ? `${num(s.wall_connectors)} Wall Connector${Number(s.wall_connectors) > 1 ? "s" : ""}` : null,
  ].filter(Boolean);
  const adresseSite = (s) => [s.adresse, s.ville].filter(Boolean).join(", ") || `Site ${s.site_id}`;
  function SiteTesla({ s }) {
    const cat = String(s.categorie || "");
    const config = configSite(s);
    return (
      <div className={"re-tesla-site" + (cat === "Site vide" ? " vide" : cat === "Powershare Gateway seul" ? " powershare" : "")}>
        <div className="re-tesla-tete">
          <div><b>{adresseSite(s)}</b><span className="re-muted"> · {s.date_installation ? `installé le ${dateFR(s.date_installation)}` : "date d'installation inconnue"}</span></div>
          {s.lien_powerhub && <a className="re-link" href={s.lien_powerhub} target="_blank" rel="noopener">Ouvrir dans Powerhub</a>}
        </div>
        {cat === "Site vide" && <div className="re-alert re-tesla-avis">Site vide dans Powerhub : aucun Powerwall ni passerelle enregistré pour l'instant. Vérifie le commissionnement.</div>}
        {cat === "Powershare Gateway seul" && <div className="re-alert re-tesla-avis">Powershare Gateway seule, sans Powerwall : le secours vient du véhicule, il n'y a pas de batterie fixe.</div>}
        <dl className="re-tesla-fiche">
          <dt>Configuration</dt><dd>{config.length ? config.join(" · ") : "Aucun équipement enregistré"}</dd>
          <dt>Solaire</dt><dd>{s.solaire_mesure ? "Solaire mesuré par la passerelle" : "Batterie seule, aucun solaire mesuré"}</dd>
          <dt>Mode</dt><dd>{libelleMode(s.mode_batterie)} · export au réseau : {libelleExport(s.export_reseau)}</dd>
          <dt>Réserve de secours</dt><dd>{s.reserve_backup_pct == null || s.reserve_backup_pct === "" ? "n. d." : `${num(s.reserve_backup_pct)} %`}{s.firmware ? <span className="re-muted"> · micrologiciel {s.firmware}</span> : null}</dd>
        </dl>
        <div className="re-tesla-energie">
          <span className="re-field-label">Énergie des 30 derniers jours</span>
          <div className="re-kpis compact re-tesla-kpis">
            <div><b>{kwh(s.conso_30j_kwh)}</b><span>consommation</span></div>
            <div><b>{kwh(s.solaire_30j_kwh)}</b><span>solaire</span></div>
            <div><b>{kwh(s.decharge_30j_kwh)}</b><span>décharge</span></div>
            <div><b>{kwh(s.import_30j_kwh)}</b><span>import</span></div>
            <div><b>{kwh(s.export_30j_kwh)}</b><span>export</span></div>
          </div>
          <span className="re-muted re-tesla-extraction">{s.extraction_le ? `Extraction Powerhub du ${dateHeure(s.extraction_le)}, heure de Mascouche` : "Date d'extraction inconnue"}</span>
        </div>
        {s.notes && <p className="re-tesla-notes">{String(s.notes)}</p>}
      </div>
    );
  }
  function SystemeTesla({ r }) {
    const sid = (r.sources && r.sources.supabase_id) || null;
    const [sites, setSites] = useState(null);     // null : chargement ; [] : rien
    const [erreur, setErreur] = useState(false);
    const [liste, setListe] = useState(false);     // recherche manuelle ouverte
    const [q, setQ] = useState("");
    const [occupe, setOccupe] = useState(null);    // site_id en cours de liaison
    const [etat, setEtat] = useState("");
    useEffect(() => {
      let alive = true;
      setSites(null); setErreur(false); setListe(false); setQ(""); setEtat("");
      sitesTeslaDB.lister().then(l => { if (alive) setSites(Array.isArray(l) ? l : []); }).catch(() => { if (alive) { setSites([]); setErreur(true); } });
      return () => { alive = false; };
    }, [r.cle]);
    const tous = sites || [];
    const relies = sid ? tous.filter(s => meme(s.client_id, sid)) : [];
    const libres = tous.filter(s => s.client_id == null || s.client_id === "");
    const suggestions = libres.filter(s => siteCorrespond(s, r)); // même avec un site déjà relié : un client peut avoir deux systèmes à la même adresse
    const n = norm(q).trim();
    const candidats = n ? libres.filter(s => norm(`${s.ville || ""} ${s.adresse || ""} ${s.code_postal || ""} ${s.date_installation || ""}`).includes(n)) : libres;
    const relier = async (s) => {
      if (!sid || occupe) return;
      setOccupe(s.site_id); setEtat("");
      try {
        await sitesTeslaDB.relier(s.site_id, sid);
        setSites(l => (l || []).map(x => x.site_id === s.site_id ? { ...x, client_id: sid } : x));
        setListe(false); setQ(""); setEtat("Site relié à cette fiche.");
      } catch (e) { setEtat("Impossible de relier le site : " + texte(e)); }
      finally { setOccupe(null); }
    };
    // JF, 8 nov. 2026 : section affichée seulement s'il y a un système Tesla relié ou un site Tesla probable ; sinon, rien.
    if (!relies.length && !suggestions.length && !etat) return null;
    const sansFiche = <span className="re-muted">Crée d'abord la fiche Raycast de ce client (bouton « Créer la fiche Raycast » en haut de la fiche), puis reviens relier le site.</span>;
    return (
      <div className="re-group re-tesla">
        <div className="re-group-head"><span>Système Tesla en service</span><b>{sites === null ? "…" : relies.length ? pluriel(relies.length, "site Powerhub", "sites Powerhub") : "aucun site relié"}</b></div>
        {erreur && <p className="re-muted">Sites Tesla indisponibles pour le moment.</p>}
        {relies.map(s => <SiteTesla key={s.site_id} s={s} />)}
        {suggestions.map(s => (
          <div key={s.site_id} className="re-tesla-suggestion">
            <div><b>Site Tesla probable</b><span className="re-muted"> · {adresseSite(s)} · {s.date_installation ? `installé le ${dateFR(s.date_installation)}` : "date inconnue"} · {configSite(s).join(" · ") || String(s.categorie || "site")}</span></div>
            {sid ? <button className="re-btn small primary" disabled={!!occupe} onClick={() => relier(s)}>{occupe === s.site_id ? "Un instant…" : "Relier à cette fiche"}</button> : sansFiche}
          </div>
        ))}
        {etat && <div className="re-etat re-tesla-etat">{etat}</div>}
        {sites && libres.length > 0 && !liste && <button className="re-link re-tesla-relier" onClick={() => setListe(true)}>{relies.length ? "Relier un autre site Tesla" : "Relier un site Tesla"}</button>}
        {liste && (
          <div className="re-tesla-liste">
            <div className="re-inline"><input className="re-search" placeholder="Ville, adresse ou date (aaaa-mm)" value={q} onChange={e => setQ(e.target.value)} autoFocus /><button className="re-btn small ghost" onClick={() => { setListe(false); setQ(""); }}>Fermer</button></div>
            {!sid && <p>{sansFiche}</p>}
            <table className="re-table re-tesla-table"><tbody>
              {candidats.slice(0, 30).map(s => <tr key={s.site_id}><td className="nom"><div>{adresseSite(s)}</div><div className="desc">{s.date_installation ? dateFR(s.date_installation) : "date inconnue"} · {configSite(s).join(" · ") || String(s.categorie || "site")}</div></td><td className="montant"><button className="re-btn small" disabled={!sid || !!occupe} onClick={() => relier(s)}>{occupe === s.site_id ? "…" : "Relier"}</button></td></tr>)}
              {!candidats.length && <tr><td className="nom re-muted">Aucun site libre ne correspond.</td></tr>}
            </tbody></table>
            {candidats.length > 30 && <p className="re-muted">30 premiers affichés, précise la recherche.</p>}
          </div>
        )}
      </div>
    );
  }

  /** Résumé du dossier (client_insights.resume, bâti par l'IA du worker à partir de toutes les interactions : appels, SMS, courriels,
   *  rencontres Pocket). Lisible d'un coup d'œil : En bref, petites cartes, listes, chronologie ; « Mettre à jour le résumé » le refait à la demande. */
  const estNM = (v) => v == null || String(v).trim() === "" || norm(String(v)).trim() === "non mentionne";
  const CANAL_RD = { "Appel": "aircall", "SMS": "ghl", "Courriel": "email", "Rencontre Pocket": "pocket", "Clavardage": "chat", "Note": "manuel", "Proposition": "manuel" };
  const dateCourte = (d) => { const x = parseDate(d); return x ? x.toLocaleString("fr-CA", { timeZone: TZ, day: "numeric", month: "short", year: "numeric", hour: "2-digit", minute: "2-digit" }) : "date inconnue"; };
  const lireResume = (v) => { if (!v) return null; if (typeof v === "string") { try { v = JSON.parse(v); } catch (e) { return null; } } return v && typeof v === "object" && v.en_bref ? v : null; };
  const listeRD = (v) => (Array.isArray(v) ? v : []).filter(x => x && !estNM(typeof x === "object" ? x.action : x));
  function CarteRD({ titre, valeur, details }) {
    // details : [[libellé, valeur]] ; seules les valeurs mentionnées s'affichent
    if (details) {
      const vus = details.filter(([, v]) => !estNM(v));
      return <div className="rd-mini"><div className="rd-mini-titre">{titre}</div><dl>{vus.map(([l, v]) => <React.Fragment key={l}><dt>{l}</dt><dd>{String(v)}</dd></React.Fragment>)}</dl></div>;
    }
    return <div className="rd-mini"><div className="rd-mini-titre">{titre}</div><p>{String(valeur)}</p></div>;
  }
  // Cartes toujours visibles (demande de JF, 6 nov. 2026) : consommation, Hydro-Québec, système (statut vérifié), données techniques,
  // résumé des échanges, visites. Un résumé de l'ancienne forme (sans ces clés) affiche les cartes vides, sans erreur.
  const VIDE_RD = "Non mentionné dans les échanges";
  const STATUT_RD = { "installé": ["Installé", "installe"], "vendu, à installer": ["Vendu, à installer", "a-installer"], "soumission envoyée": ["Soumission envoyée", "soumission"], "en discussion": ["En discussion", "discussion"], "inconnu": ["Statut inconnu", "inconnu"] };
  const objRD = (v) => (v && typeof v === "object" && !Array.isArray(v) ? v : {});
  /** Numéros Hydro-Québec masqués par défaut (Loi 25) : toute suite de 5 chiffres ou plus devient « •••• 1234 ». */
  const masqueHQ = (v) => String(v).replace(/\d[\d\s.-]{3,}\d/g, (x) => { const d = x.replace(/\D/g, ""); return d.length >= 5 ? `•••• ${d.slice(-4)}` : x; });
  function CarteCle({ titre, details, className, action, children }) {
    const vus = (details || []).filter(([, v]) => !estNM(v));
    const contenu = children || (vus.length ? <dl>{vus.map(([l, v]) => <React.Fragment key={l}><dt>{l}</dt><dd>{String(v)}</dd></React.Fragment>)}</dl> : null);
    return (
      <div className={"rd-mini rd-cle" + (className ? " " + className : "")}>
        <div className="rd-mini-tete"><div className="rd-mini-titre">{titre}</div>{action || null}</div>
        {contenu || <p className="rd-nm">{VIDE_RD}</p>}
      </div>
    );
  }
  function CarteHQ({ hq }) {
    const [voir, setVoir] = useState(false);
    const h = objRD(hq);
    const champs = [["N° de client", h.numero_client], ["Contrat ou compte", h.numero_contrat_ou_compte], ["N° de compteur", h.numero_compteur], ["Raccordement", h.demande_raccordement], ["Autres références", h.autres_references]].filter(([, v]) => !estNM(v));
    const aMasquer = champs.some(([, v]) => masqueHQ(v) !== String(v));
    const action = aMasquer ? <button type="button" className="rd-afficher" aria-pressed={voir} onClick={() => setVoir(x => !x)}>{voir ? "Masquer" : "Afficher"}</button> : null;
    return (
      <CarteCle titre="Hydro-Québec" className="rd-hq" action={action}>
        {champs.length ? <>
          <dl>{champs.map(([l, v]) => <React.Fragment key={l}><dt>{l}</dt><dd className="rd-masque">{voir ? String(v) : masqueHQ(v)}</dd></React.Fragment>)}</dl>
          <div className="rd-hq-note">Renseignements personnels : ne pas copier hors de RAYCAST.</div>
        </> : null}
      </CarteCle>
    );
  }
  function CarteSysteme({ sy }) {
    if (!sy) return <CarteCle titre="Système" className="rd-systeme" />;
    const st = STATUT_RD[sy.statut] || STATUT_RD["inconnu"];
    const comps = (Array.isArray(sy.composantes) ? sy.composantes : []).filter(x => x && (!estNM(x.modele) || !estNM(x.type)));
    const date = estNM(sy.date_installation) ? "" : String(sy.date_installation);
    return (
      <CarteCle titre="Système" className="rd-systeme">
        <div className="rd-statut-ligne">
          <span className={"rd-statut " + st[1]}>{st[0]}</span>
          {sy.verifie ? <span className="rd-verifie">Vérifié dans les données</span> : <span className="rd-ia">Selon les échanges</span>}
        </div>
        {date && <div className="rd-sys-date">{sy.statut === "installé" ? "Installé le " : "Installation : "}{date}</div>}
        {comps.length > 0 && (
          <ul className="rd-composantes">{comps.map((x, i) => {
            const meta = [estNM(x.type) ? "" : x.type, estNM(x.puissance_ou_capacite) ? "" : x.puissance_ou_capacite, estNM(x.numero_serie) ? "" : `n° de série ${x.numero_serie}`].filter(Boolean);
            return <li key={i}><b>{estNM(x.quantite) ? "" : `${x.quantite} × `}{estNM(x.modele) ? String(x.type) : String(x.modele)}</b>{meta.length > 0 && <span className="rd-meta">{meta.map(String).join(" · ")}</span>}</li>;
          })}</ul>
        )}
        {!estNM(sy.source_du_statut) && <div className="rd-source">Source : {String(sy.source_du_statut)}</div>}
      </CarteCle>
    );
  }
  function CartesCles({ R, cle }) {
    const co = objRD(R.consommation), sy = R.systeme && typeof R.systeme === "object" ? R.systeme : null, dt = objRD(sy && sy.donnees_techniques);
    const visites = (Array.isArray(R.visites) ? R.visites : []).filter(v => v && !(estNM(v.constats) && estNM(v.suite) && estNM(v.mesures_photos)));
    return (
      <div className="rd-essentiels">
        <CarteSysteme sy={sy} />
        <CarteCle titre="Données techniques" details={[["Solaire", dt.kw_pv], ["Batterie", dt.kwh_batterie], ["Onduleur", dt.onduleur], ["Entrée et panneau", dt.entree_panneau], ["Passerelle", dt.passerelle], ["Arrêt rapide", dt.arret_rapide], ["Bornes", dt.bornes]]} />
        <CarteCle titre="Consommation" details={[["Annuelle", co.kwh_annuels], ["Facture", co.facture_mensuelle_ou_annuelle], ["Tarif HQ", co.tarif_hq], ["Chauffage", co.chauffage], ["Gros consommateurs", co.gros_consommateurs], ["Période ou source", co.periode_ou_source], ["Mesure Powerwall", co.mesure_passerelle_30j]]} />
        <CarteHQ key={cle} hq={R.hydro_quebec} />
        <CarteCle titre="Résumé des échanges" className="rd-large rd-echanges">{estNM(R.resume_transcriptions) ? null : <p>{String(R.resume_transcriptions)}</p>}</CarteCle>
        <CarteCle titre={visites.length ? <>Visites <b>{visites.length}</b></> : "Visites"} className="rd-large rd-visites">
          {visites.length ? <ol>{visites.map((v, i) => {
            const meta = [["Présents", v.qui], ["Mesures et photos", v.mesures_photos], ["Suite", v.suite]].filter(([, x]) => !estNM(x));
            return (
              <li key={i}>
                <div className="rd-visite-tete"><span className={"re-src " + (CANAL_RD[v.canal] || "pocket")}>{v.canal === "Rencontre Pocket" || !v.canal ? "Rencontre" : String(v.canal)}</span><time>{dateCourte(v.date)}</time>{!estNM(v.date_mentionnee) && <span className="rd-meta">visite du {String(v.date_mentionnee)}</span>}</div>
                {!estNM(v.constats) && <div className="rd-visite-texte">{String(v.constats)}</div>}
                {meta.length > 0 && <div className="rd-visite-meta">{meta.map(([l, x]) => <span key={l}><b>{l} :</b> {String(x)}</span>)}</div>}
              </li>
            );
          })}</ol> : null}
        </CarteCle>
      </div>
    );
  }
  /** Données du résumé du dossier (client_insights.resume), partagées par l'aperçu de la fiche et le détail :
   *  lecture, création automatique une fois par fiche ouverte (JF, 5 nov. 2026), « Mettre à jour le résumé », relecture après une reprise. */
  function useResumeDossier(c) {
    const [ins, setIns] = useState(undefined);          // undefined : chargement ; null : aucune ligne client_insights
    const [aDesInteractions, setADesInteractions] = useState(false);
    const [etat, setEtat] = useState({ occupe: false, erreur: "" });
    const [version, setVersion] = useState(0);
    const keys = clesDe(c);
    // Après une reprise de l'historique : résumé fourni par le worker, sinon relecture
    useEffect(() => {
      const f = (e) => { const d = (e && e.detail) || {}; if (d.cle !== c.cle) return; if (d.resume && lireResume(d.resume)) setIns(x => ({ ...(x || {}), client_key: d.client_key || (x && x.client_key) || keys[0], resume: d.resume, resume_le: d.resume_le, synthese: d.resume.en_bref, nb_interactions: d.nb_interactions != null ? d.nb_interactions : (x && x.nb_interactions) })); else setVersion(v => v + 1); };
      window.addEventListener(EVT_DOSSIER, f); return () => window.removeEventListener(EVT_DOSSIER, f);
    }, [c.cle]); // eslint-disable-line
    useEffect(() => {
      let alive = true;
      if (version === 0) { setIns(undefined); setEtat({ occupe: false, erreur: "" }); }
      setADesInteractions(false);
      if (!keys.length || !window.RAYCAST_SUPABASE) { setIns(null); return; }
      (async () => {
        try {
          const { data } = await window.RAYCAST_SUPABASE.from("client_insights").select("client_key,resume,resume_le,synthese,nb_interactions,derniere_interaction").in("client_key", keys);
          const lignes = Array.isArray(data) ? data : [];
          // Ligne qui porte un résumé (le plus récent), sinon la première : sa clé devient la clé principale de la mise à jour.
          // Plusieurs clés (téléphone, courriel) : le résumé qui a lu le plus d'interactions, puis le plus récent.
          const avec = lignes.filter(x => lireResume(x.resume)).sort((a, b) => (Number(b.nb_interactions) || 0) - (Number(a.nb_interactions) || 0) || String(b.resume_le || "").localeCompare(String(a.resume_le || "")));
          if (alive) setIns(avec[0] || lignes[0] || null);
          const { data: it } = await window.RAYCAST_SUPABASE.from("interactions").select("id").in("client_key", keys).limit(1);
          if (alive) setADesInteractions(Array.isArray(it) && it.length > 0);
        } catch (e) { if (alive) setIns(null); }
      })();
      return () => { alive = false; };
    }, [c.cle, version]); // eslint-disable-line
    const R = ins ? lireResume(ins.resume) : null;
    const lancer = async () => {
      if (etat.occupe) return;
      const principale = ins && ins.client_key ? ins.client_key : keys[0];
      const cles = [principale, ...keys.filter(k => k !== principale)].filter(Boolean).slice(0, 6);
      if (!cles.length) { setEtat({ occupe: false, erreur: "Aucun téléphone ni courriel sur cette fiche : impossible de retrouver les interactions." }); return; }
      setEtat({ occupe: true, erreur: "" });
      try {
        const j = await workerPost(`/raycast/intel/resumer?client_key=${encodeURIComponent(cles.join(","))}`, {});
        if (!lireResume(j.resume)) throw new Error("réponse sans résumé");
        setIns(x => ({ ...(x || {}), client_key: j.client_key || principale, resume: j.resume, resume_le: j.resume_le, synthese: j.resume.en_bref, nb_interactions: j.nb_interactions != null ? j.nb_interactions : (x && x.nb_interactions) }));
        setEtat({ occupe: false, erreur: "" });
      } catch (e) {
        const m = texte(e);
        const lisible = /aucune interaction/i.test(m) ? "Aucun appel, SMS, courriel ni rencontre trouvé pour ce client : rien à résumer pour l'instant."
          : /limite atteinte/i.test(m) ? m
          : /failed to fetch|networkerror|load failed/i.test(m) ? "Le serveur ne répond pas. Vérifie ta connexion et réessaie."
          : "Le résumé n'a pas pu être fait : " + m;
        setEtat({ occupe: false, erreur: lisible });
      }
    };
    // Pas encore de résumé mais des interactions : création automatique une seule fois par fiche ouverte (JF, 5 nov. 2026).
    const autoLance = useRef("");
    useEffect(() => {
      if (ins === undefined || R || !aDesInteractions || etat.occupe || etat.erreur) return;
      const k = keys.join(","); if (!k || autoLance.current === k) return;
      autoLance.current = k; lancer();
    }, [ins, aDesInteractions]); // eslint-disable-line
    return { ins, R, aDesInteractions, etat, lancer, keys };
  }

  /** Détail du résumé du dossier (section « Détails et conversations », fermée par défaut) : cartes, listes, points à vérifier,
   *  chronologie. L'« En bref » est dans l'aperçu de la fiche (ApercuFiche), pas répété ici. */
  function ResumeDossier({ c, rs }) {
    const [toutChrono, setToutChrono] = useState(false);
    useEffect(() => { setToutChrono(false); }, [c.cle]);
    const { ins, R, aDesInteractions, etat, lancer, keys } = rs;
    if (ins === undefined) return null;
    if (!R && !ins && !aDesInteractions) return null;   // client sans aucune interaction : rien à résumer, la fiche reste sobre
    const bouton = (lib) => (
      <button className="re-btn small rd-bouton" onClick={lancer} disabled={etat.occupe} aria-busy={etat.occupe}>
        {etat.occupe ? <><span className="rd-spin" aria-hidden="true" />{R ? "Mise à jour…" : "Création…"}</> : lib}
      </button>
    );
    if (!R) {
      return (
        <section className="rd-carte rd-vide" aria-label="Résumé du dossier">
          <div className="rd-tete"><div><h3 className="rd-titre"><EclairRaycom size={15} /> Résumé du dossier</h3><div className="rd-maj">Pas encore de résumé{ins && ins.nb_interactions ? ` · ${pluriel(ins.nb_interactions, "interaction", "interactions")}` : ""}</div></div>{bouton("Créer le résumé")}</div>
          <p className="rd-vide-texte">L'IA lit tous les appels, SMS, courriels et rencontres de ce client et en fait un résumé clair : ce qu'il veut, sa maison, le système discuté, le budget, les prochaines étapes.</p>
          {etat.erreur && <div className="re-alert error rd-erreur" role="alert">{etat.erreur}</div>}
          <CartesCles R={{}} cle={c.cle || keys.join(",")} />
        </section>
      );
    }
    const m = R.maison || {}, s = R.systeme_discute || {};
    const cartes = [
      ["Demande", { valeur: R.demande }, estNM(R.demande)],
      ["Maison", { details: [["Type", m.type], ["Entrée électrique", m.entree_electrique], ["Panneau", m.panneau], ["Toit", m.toit], ["Particularités", m.particularites]] }, [m.type, m.entree_electrique, m.panneau, m.toit, m.particularites].every(estNM)],
      ["Système discuté", { details: [["Produits", s.produits], ["Quantités", s.quantites], ["Options", s.options], ["Secours", s.secours], ["Solaire", s.solaire], ["Bornes", s.bornes]] }, [s.produits, s.quantites, s.options, s.secours, s.solaire, s.bornes].every(estNM)],
      ["Budget et financement", { valeur: R.budget_financement }, estNM(R.budget_financement)],
      ["Échéancier", { valeur: R.echeancier }, estNM(R.echeancier)],
      ["Décideurs", { valeur: R.decideurs }, estNM(R.decideurs)],
    ];
    const etapes = listeRD(R.prochaines_etapes), promis = listeRD(R.engagements_raycom), objections = listeRD(R.objections_inquietudes), verifier = listeRD(R.points_a_verifier);
    const listes = [["Objections et inquiétudes", objections, "rd-objections"], ["Ce que Raycom a promis", promis, "rd-promis"]];
    const absents = [...cartes.filter(x => x[2]).map(x => x[0]), ...(etapes.length ? [] : ["Prochaines étapes"]), ...listes.filter(x => !x[1].length).map(x => x[0])];
    const chrono = (Array.isArray(R.chronologie) ? R.chronologie : []).filter(x => x && x.resume);
    const VISIBLES = 6;
    const chronoVue = toutChrono ? chrono : chrono.slice(-VISIBLES);
    return (
      <section className="rd-carte" aria-label="Résumé du dossier">
        <div className="rd-tete">
          <div><h3 className="rd-titre"><EclairRaycom size={15} /> Résumé du dossier</h3><div className="rd-maj">Mis à jour le {dateHeure(ins.resume_le || R.derniere_mise_a_jour)}{ins.nb_interactions || R.nb_interactions ? ` · ${pluriel(ins.nb_interactions || R.nb_interactions, "interaction", "interactions")}` : ""}</div></div>
          {bouton("Mettre à jour le résumé")}
        </div>
        {etat.erreur && <div className="re-alert error rd-erreur" role="alert">{etat.erreur}</div>}
        {etapes.length > 0 && (
          <div className="rd-etapes"><div className="rd-liste-titre">Prochaines étapes</div>
            <ol>{etapes.map((p, i) => { const o = typeof p === "object" ? p : { action: p }; const meta = [o.qui, o.quand].filter(v => !estNM(v)); return <li key={i}><span className="rd-action">{String(o.action)}</span>{meta.length > 0 && <span className="rd-qui">{meta.map(String).join(" · ")}</span>}</li>; })}</ol>
          </div>
        )}
        <CartesCles R={R} cle={c.cle || keys.join(",")} />
        <div className="rd-grille">{cartes.filter(x => !x[2]).map(([t, p]) => <CarteRD key={t} titre={t} {...p} />)}</div>
        {(listes.some(x => x[1].length) || verifier.length > 0) && (
          <div className="rd-listes">
            {listes.filter(x => x[1].length).map(([t, l, cls]) => <div key={t} className={"rd-liste " + cls}><div className="rd-liste-titre">{t}</div><ul>{l.map((x, i) => <li key={i}>{String(x)}</li>)}</ul></div>)}
            {verifier.length > 0 && <div className="rd-liste rd-verifier"><div className="rd-liste-titre">À vérifier</div><ul>{verifier.map((x, i) => <li key={i}>{String(x)}</li>)}</ul></div>}
          </div>
        )}
        {absents.length > 0 && <div className="rd-absents"><span>Pas encore mentionné :</span>{absents.map(a => <span key={a} className="rd-absent">{a}</span>)}</div>}
        {chrono.length > 0 && (
          <div className="rd-chrono">
            <div className="rd-liste-titre">Chronologie <b>{chrono.length}</b></div>
            {chrono.length > VISIBLES && <button className="rd-lien" onClick={() => setToutChrono(v => !v)}>{toutChrono ? "Voir seulement les plus récentes" : `Voir les ${chrono.length - VISIBLES} plus anciennes`}</button>}
            <ol>{chronoVue.map((x, i) => <li key={i}><span className={"re-src " + (CANAL_RD[x.canal] || "autre")}>{x.canal === "Rencontre Pocket" ? "Rencontre" : String(x.canal || "Message")}</span><time>{dateCourte(x.date)}</time><span className="rd-chrono-texte">{String(x.resume)}</span></li>)}</ol>
          </div>
        )}
      </section>
    );
  }

  // ─── Aperçu de la fiche (JF, 6 nov. 2026 : « une fiche client se doit d'être complète, claire et toujours bien remplie ;
  //     pas trop de blabla, les choses clés avec un simple résumé ; pour creuser, on ira dans les conversations ») ───
  // Carte « Fiche » : un fait par ligne ; un fait inconnu reste visible, en gris, « à obtenir » avec l'action à faire.
  // Sources : fiche unifiée du worker (QuickBooks, RAYCAST, GHL, soumissions, schéma, dossier), résumé IA du dossier, opportunités GHL.

  /** Étape GHL du contact (pipeline et colonne) par le relais sécurisé : opportunité ouverte la plus récente, sinon la dernière. Mémoire de session. */
  const etapesSession = new Map();   // ghl_contact_id → { at, val }
  function useEtapeGhl(r) {
    const id = (r.sources && r.sources.ghl_contact_id) || "";
    const [val, setVal] = useState(null);
    useEffect(() => {
      let alive = true;
      if (!id) { setVal({ etat: "sans_contact" }); return; }
      const m = etapesSession.get(id);
      if (m && Date.now() - m.at < 5 * 60000) { setVal(m.val); return; }
      if (!window.RaycastProxy || !window.RaycastProxy.fetch) { setVal({ etat: "indisponible" }); return; }
      setVal({ etat: "chargement" });
      (async () => {
        let v;
        try {
          const [o, p] = await Promise.all([window.RaycastProxy.fetch("ghl", "/opportunities", { contact_id: id }), window.RaycastProxy.fetch("ghl", "/pipelines", {}).catch(() => null)]);
          const opps = (Array.isArray(o && o.opportunities) ? o.opportunities : []).filter(x => x && (!x.contactId || x.contactId === id) && (!x.contact || !x.contact.id || x.contact.id === id));
          const date = (x) => Date.parse(x.lastStageChangeAt || x.lastStatusChangeAt || x.updatedAt || x.dateUpdated || x.createdAt || "") || 0;
          const ouvertes = opps.filter(x => String(x.status || "open") === "open").sort((a, b) => date(b) - date(a));
          const choisie = ouvertes[0] || opps.slice().sort((a, b) => date(b) - date(a))[0];
          if (!choisie) v = { etat: "aucune" };
          else {
            const pipes = Array.isArray(p && p.pipelines) ? p.pipelines : [];
            const pipe = pipes.find(x => x && x.id === choisie.pipelineId);
            const col = pipe && Array.isArray(pipe.stages) ? pipe.stages.find(s => s && s.id === choisie.pipelineStageId) : null;
            const STATUT = { won: "gagnée", lost: "perdue", abandoned: "abandonnée" };
            v = { etat: "ok", texte: [pipe ? pipe.name : "Pipeline inconnu", col ? col.name : "colonne inconnue"].join(" · ") + (STATUT[choisie.status] ? ` (${STATUT[choisie.status]})` : ""), autres: ouvertes.length > 1 ? ouvertes.length - 1 : 0, quand: date(choisie) || null };
          }
        } catch (e) { v = { etat: "indisponible" }; }
        if (v.etat !== "indisponible") etapesSession.set(id, { at: Date.now(), val: v });
        if (alive) setVal(v);
      })();
      return () => { alive = false; };
    }, [id]);
    return val || { etat: "chargement" };
  }

  const PROJETS = { batterie: "Batterie", solaire: "Solaire", solaire_batterie: "Solaire et batterie", borne: "Borne de recharge", travaux: "Travaux électriques", service: "Entrée électrique" };
  const court = (v, n) => { const s = String(v == null ? "" : v).replace(/\s+/g, " ").trim(); return s.length > n ? s.slice(0, n - 1).trimEnd() + "…" : s; };
  /** Comme court(), mais coupe entre deux mots et retire les parenthèses : « Calculer le nombre de panneaux… » plutôt que « (cible environ 8… ». */
  const courtMots = (v, n) => { const s = String(v == null ? "" : v).replace(/\s*\([^)]*\)/g, "").replace(/\s+/g, " ").trim(); if (s.length <= n) return s; const c = s.slice(0, n - 1); const i = c.lastIndexOf(" "); return (i > n * 0.5 ? c.slice(0, i) : c).replace(/[\s,;:.]+$/, "") + "…"; };
  const masqueQuatre = (v) => { const s = String(v || "").trim(); const m = s.match(/^…(\w{4})$/); return m ? `•••• ${m[1]}` : masqueHQ(s); };
  /** En bref : 3 phrases au plus. */
  const troisPhrases = (t) => { const p = String(t || "").replace(/\s+/g, " ").trim().match(/[^.!?]+[.!?]+(\s|$)|[^.!?]+$/g) || []; return p.slice(0, 3).join("").trim(); };
  const ilYaJours = (d) => { const j = joursDepuis(d); return j == null ? "" : j <= 0 ? "aujourd'hui" : j === 1 ? "hier" : `il y a ${j} jours`; };
  /** Jours entiers écoulés depuis une date (heure de Mascouche, jour civil) ; null si la date est illisible. */
  const jourCivil = (d) => { const x = parseDate(d); return x ? x.toLocaleDateString("en-CA", { timeZone: TZ }) : ""; };
  const joursDepuis = (d, maintenant) => { const a = jourCivil(d), b = jourCivil(maintenant || new Date()); if (!a || !b) return null; return Math.round((Date.parse(b + "T12:00:00Z") - Date.parse(a + "T12:00:00Z")) / 86400000); };

  // ─── Noms de personnes (JF, 6 nov. 2026 : « jean tremblay » doit s'afficher « Jean Tremblay ») ───
  // Seuls les noms écrits tout en minuscules (ou tout en majuscules, hors sigles et sociétés) sont corrigés : un nom déjà écrit
  // en casse mixte (« ABC (Services Exemple) », « McDonald ») reste tel quel. La longueur du texte ne change jamais
  // (la recherche surligne les mêmes positions). Particules en minuscules sauf en tête : de, du, des, la, le, van, von…
  const PARTICULES = new Set(["de", "du", "des", "la", "le", "les", "van", "von", "der", "den", "da", "di", "dos", "das", "et", "y", "of", "e"]);
  const MARQUES_SOCIETE = /\b(inc|lt[ée]e|ltd|enr|s\.?e\.?n\.?c|cie|corp|llc|soci[ée]t[ée]|groupe|services?|solar|solaire|construction|[ée]lectrique|gestion|immeubles?|holdings?)\b/i;
  const LETTRE = "A-Za-zÀ-ÖØ-öø-ÿ";
  const RE_MOT = new RegExp(`[${LETTRE}]+(?:['’][${LETTRE}]+)?`, "g");
  const cap = (m) => m.charAt(0).toUpperCase() + m.slice(1);
  function nomPropre(s) {
    const t = s == null ? "" : String(s);
    const lettres = t.replace(new RegExp(`[^${LETTRE}]`, "g"), "");
    if (!lettres) return t;
    const toutMin = lettres === lettres.toLowerCase(), toutMaj = lettres === lettres.toUpperCase();
    if (!toutMin && !toutMaj) return t;
    if (toutMaj && (lettres.length <= 4 || /\d/.test(t) || MARQUES_SOCIETE.test(t))) return t;   // sigle ou nom de société
    let premier = true;
    return t.toLowerCase().replace(RE_MOT, (mot) => {
      const tete = premier; premier = false;
      const ap = mot.match(/^([dlo])['’](.+)$/);
      if (ap) return ap[1].toUpperCase() + mot.charAt(1) + cap(ap[2]);              // D'Amours, L'Heureux, O'Brien
      if (!tete && PARTICULES.has(mot)) return mot;                                  // Pierre de la Rue
      if (/^mc[a-zà-ÿ]{2,}$/.test(mot)) return "Mc" + cap(mot.slice(2));             // McDonald
      return cap(mot);
    });
  }

  // ─── Source du lead : libellé humain, la clé brute reste dans la bulle d'aide ───
  const SOURCES_LIBELLES = [
    [/^landing[-_ ]?powerwall/i, "Page web Powerwall"], [/^landing[-_ ]?solaire/i, "Page web solaire"], [/^landing[-_ ]?borne/i, "Page web borne VÉ"],
    [/^quickbooks$/i, "QuickBooks"], [/^aircall$/i, "Aircall (appel)"], [/^(ghl|lead[-_ ]?ghl|ghl[-_ ]?lead|gohighlevel|highlevel)$/i, "Lead GHL"],
    [/^m-?power$/i, "mPower (distributeur Tesla)"], [/^tesla$/i, "Tesla"], [/^r[ée]f[ée]rence/i, "Référence"], [/^pay[ée]e$/i, "Publicité payée"],
    [/^appel[-_ ]direct$/i, "Appel direct"], [/^site[-_ ]web$/i, "Site web"], [/^service[-_ ]booking$/i, "Réservation de service"],
    [/^formulaire de raycom [ée]nergie/i, "Formulaire Raycom Énergie"], [/^formulaire[-_ ]raycom[-_ ]services$/i, "Formulaire Raycom Services"],
    [/^formulaire (web|site)/i, "Formulaire web"], [/assistant web/i, "Assistant web"], [/^consultation t[ée]l[ée]phonique$/i, "Consultation téléphonique"],
    [/^facebook$/i, "Facebook"], [/^instagram$/i, "Instagram"], [/^google$/i, "Google"], [/^courriel$/i, "Courriel"], [/^organique$/i, "Organique"], [/^autre$/i, "Autre"],
  ];
  /** « landing-powerwall-v2 » → « Page web Powerwall » ; repli : tirets en espaces, suffixe de version retiré, première lettre en majuscule. */
  function libelleSource(brut) {
    const t = String(brut == null ? "" : brut).replace(/\s+/g, " ").trim();
    if (!t) return "";
    for (const [re, lib] of SOURCES_LIBELLES) if (re.test(t)) return lib;
    const s = t.replace(/[—–]/g, ",").replace(/[-_]+/g, " ").replace(/\s+v\d+$/i, "").replace(/\s+/g, " ").trim();
    return s.charAt(0).toUpperCase() + s.slice(1);
  }

  // ─── Équipement d'une soumission RAYCAST (lignes du catalogue, id QuickBooks) en une ligne courte ───
  const EQUIP = {
    "478": { nom: "Powerwall 3", ordre: 2, pw: true }, "479": { nom: "extension Powerwall 3", ordre: 3 }, "480": { nom: "passerelle Gateway 3", ordre: 6 },
    "525": { nom: "Fox ESS AIO 11,4 kW", ordre: 4 }, "526": { nom: "Fox ESS AIO 9,6 kW", ordre: 4 }, "491": { nom: "onduleur Fox ESS H1 11,4 kW", ordre: 5 }, "527": { nom: "onduleur Fox ESS H1 9,6 kW", ordre: 5 },
    "492": { nom: "batterie Fox EQ4000", ordre: 3 }, "528": { nom: "batterie Fox CM4000", ordre: 3 }, "529": { nom: "batterie Fox CS4000", ordre: 3 },
    "495": { nom: "Sigenergy Energy Controller", ordre: 4 }, "496": { nom: "batterie Sigenergy 9 kWh", ordre: 3 }, "497": { nom: "batterie Sigenergy 6 kWh", ordre: 3 },
    "502": { nom: "onduleur Lux Power 12K", ordre: 5 }, "585": { nom: "onduleur Lux Power 10K", ordre: 5 }, "501": { nom: "onduleur Lux Power SNA 12K", ordre: 5 }, "500": { nom: "onduleur Lux Power SNA 6K", ordre: 5 },
    "504": { nom: "batterie Volthium 5,1 kWh", ordre: 3 }, "541": { nom: "batterie Volthium 10,2 kWh", ordre: 3 }, "506": { nom: "batterie Volthium 16,1 kWh", ordre: 3 },
  };
  const PANNEAUX_KW = { "509": 0.5, "582": 0.62, "583": 0.625 };
  const BORNES = new Set(["522", "523", "540", "539", "538", "356", "384", "35", "435", "471"]);
  const SECOURS = { base: "secours de base", partiel: "secours partiel", complet: "maison complète", critique: "charges critiques" };
  /** Lignes [{ qbo_id, qty }] → « Solaire 15 kW (30 panneaux), 1 Powerwall 3, passerelle Gateway 3 » ; "" si aucun équipement connu. */
  function equipementDe(lignes) {
    const L = Array.isArray(lignes) ? lignes : [];
    const q = {}; let nbPan = 0, kw = 0, bornes = 0;
    for (const l of L) {
      const id = String(l && l.qbo_id != null ? l.qbo_id : ""), n = Number(l && l.qty) || 0; if (!id || n <= 0) continue;
      if (PANNEAUX_KW[id]) { nbPan += n; kw += n * PANNEAUX_KW[id]; } else if (BORNES.has(id)) bornes += n; else if (EQUIP[id]) q[id] = (q[id] || 0) + n;
    }
    const morceaux = [];
    if (nbPan) morceaux.push({ o: 1, t: `solaire ${num(Math.round(kw * 100) / 100, 2)} kW (${pluriel(nbPan, "panneau", "panneaux")})` });
    for (const [id, n] of Object.entries(q)) { const e = EQUIP[id]; morceaux.push({ o: e.ordre, t: e.pw ? `${num(n)} ${e.nom}` : n > 1 ? `${num(n)} × ${e.nom}` : e.nom }); }
    if (bornes) morceaux.push({ o: 7, t: bornes > 1 ? `${num(bornes)} bornes de recharge` : "borne de recharge" });
    const t = morceaux.sort((a, b) => a.o - b.o).map(x => x.t).join(", ");
    return t ? cap(t) : "";
  }
  /** Système facturé d'après le résumé des factures QuickBooks (/raycast/achats). */
  function equipementFacture(res) {
    if (!res) return "";
    const m = [
      res.panneaux && res.panneaux.nb ? `${pluriel(res.panneaux.nb, "panneau solaire", "panneaux solaires")} (${num(res.panneaux.kw, 2)} kW)` : null,
      res.nb_powerwall ? `${num(res.nb_powerwall)} Powerwall 3` : null, res.expansion ? `${num(res.expansion)} extension${res.expansion > 1 ? "s" : ""} Powerwall` : null,
      res.fox_aio ? `${num(res.fox_aio)} Fox ESS AIO` : null, res.sigenergy_ctrl ? `${num(res.sigenergy_ctrl)} Sigenergy` : null, res.lux_lxp ? `${num(res.lux_lxp)} Lux Power LXP` : null,
      res.gateway ? "passerelle Gateway 3" : null, Array.isArray(res.bornes) && res.bornes.length ? "borne de recharge" : null,
    ].filter(Boolean);
    return m.length ? cap(m.join(", ")) : "";
  }
  /** Projet d'après la source du lead (dernier recours, présenté comme un intérêt). */
  const PROJET_SOURCE = [[/powerwall|m-?power|tesla/i, "Batterie Powerwall"], [/solaire|solar/i, "Solaire"], [/borne/i, "Borne de recharge"]];
  // Dates écrites par l'IA (« 28 octobre 2026, 14 h 30 », « 2026-11-06, entre 10h30 et midi ») : première date complète du texte, sinon null.
  const MOIS = { janvier: 1, fevrier: 2, mars: 3, avril: 4, mai: 5, juin: 6, juillet: 7, aout: 8, septembre: 9, octobre: 10, novembre: 11, decembre: 12 };
  function dateDansTexte(t) {
    const s = norm(t);
    if (/suivant|apres|avant le|prochain|semaine/.test(s)) return null;   // échéance relative : jamais jugée en retard
    let m = s.match(/(\d{4})-(\d{2})-(\d{2})/);
    if (m) return `${m[1]}-${m[2]}-${m[3]}`;
    m = s.match(/(\d{1,2})(?:er)?\s+(janvier|fevrier|mars|avril|mai|juin|juillet|aout|septembre|octobre|novembre|decembre)\s+(\d{4})/);
    return m ? `${m[3]}-${String(MOIS[m[2]]).padStart(2, "0")}-${m[1].padStart(2, "0")}` : null;
  }

  /** Adresse de la maison, UNE seule source pour la carte « Fiche », la ligne « Maison » et Street View (fonction pure, testée).
   *  Ordre retenu par JF (6 nov. 2026) : Raycast, puis GHL, puis QuickBooks. address_full vient de la fiche Raycast (vérifiée par
   *  Google quand elle a des coordonnées) ; sinon la rue fusionnée par le worker (adresse_source : GHL, QuickBooks…) ; sinon l'adresse
   *  dite dans un échange. Une autre adresse différente connue ailleurs est gardée pour la bulle d'aide. */
  function adresseFiche(r, R) {
    const rue = String(r.adresse || "").trim();
    // Province : celle de la fiche, sinon déduite du code postal québécois (G, H, J : règle fixe de Postes Canada)
    const province = r.province || (/^[GHJ]\d[A-Z]\s?\d[A-Z]\d$/i.test(String(r.code_postal || "").trim()) ? "QC" : "");
    const fin = [province, r.code_postal].filter(Boolean).join(" ");
    const composee = rue ? [rue, r.ville, fin].filter(Boolean).join(", ") : "";
    const full = r.address_full && /\d/.test(r.address_full) ? String(r.address_full).trim() : "";
    const dite = R && R.adresse_mentionnee && R.adresse_mentionnee.adresse ? R.adresse_mentionnee : null;
    const differente = (a, b) => a && b && norm(a).replace(/[^a-z0-9]/g, "") !== norm(b).replace(/[^a-z0-9]/g, "");
    if (full) return { texte: full, source: r.lat ? "RAYCAST, vérifiée par Google" : "RAYCAST", autre: differente(composee, full) ? `${r.adresse_source || "autre source"} : ${composee}` : "", complete: true };
    if (composee) return { texte: composee, source: r.adresse_source || "", autre: "", complete: true };
    if (dite) return { texte: dite.adresse, source: `dite dans un échange (${dite.source})`, autre: "", complete: true };
    const partiel = [r.ville, fin].filter(Boolean).join(", ");
    return { texte: partiel, source: "", autre: "", complete: false, manque: partiel ? "rue à obtenir" : "à obtenir, demander l'adresse de la maison" };
  }

  /** Faits clés de la fiche (fonction pure, testée) : [{ cle, libelle, valeur, source, manque, detail }] ; manque = action à faire quand
   *  le fait est inconnu (affichée en bulle d'aide, la ligne dit seulement « à obtenir »).
   *  ctx (facultatif) : { liens, achats, fiche } : liens de proposition par soumission, résumé des factures QuickBooks, fiche Raycast éditée. */
  function faitsFiche(r, R, etape, subs, ctx) {
    const cx = ctx || {};
    const fx = cx.fiche && cx.fiche.champs && typeof cx.fiche.champs === "object" ? cx.fiche.champs : {};   // fiche Raycast : priorité
    const en = (r && r.energie && typeof r.energie === "object") ? r.energie : {};
    const co = objRD(R && R.consommation), hq = objRD(R && R.hydro_quebec), sy = R && R.systeme && typeof R.systeme === "object" ? R.systeme : null, sd = objRD(R && R.systeme_discute);
    const F = [];
    const fait = (cle, libelle, valeur, source, manque, detail) => F.push({ cle, libelle, valeur: valeur ? String(valeur) : "", source: source || "", manque: valeur ? "" : manque, detail: detail || "" });
    // Texte de l'IA trop vague pour la fiche (« Soumission 13,5 kWh, détails non mentionnés ») : on passe aux données
    const vague = (v) => estNM(v) || /non mentionn|non pr[ée]cis|pas pr[ée]cis|inconnu/i.test(String(v));
    const deFiche = (k) => (fx[k] != null && String(fx[k]).trim() !== "" ? String(fx[k]).trim() : "");
    // Adresse complète (même source que Street View : adresseFiche)
    const ad = deFiche("adresse") ? { texte: [deFiche("adresse"), deFiche("ville"), [deFiche("province"), deFiche("code_postal")].filter(Boolean).join(" ")].filter(Boolean).join(", "), source: "fiche RAYCAST", complete: true } : adresseFiche(r, R);
    if (ad.complete) fait("adresse", "Adresse", ad.texte, ad.source, "", ad.autre);
    else F.push({ cle: "adresse", libelle: "Adresse", valeur: ad.texte, source: "", manque: ad.manque, detail: "" });
    fait("telephone", "Téléphone", deFiche("telephone") ? telFmt(deFiche("telephone")) : r.telephone ? telFmt(r.telephone) : "", "", "à obtenir");
    fait("courriel", "Courriel", deFiche("courriel") || r.courriel || "", "", "à obtenir");
    const srcBrute = deFiche("source") || r.source || r.ghl_source || "";
    fait("source", "Source", libelleSource(srcBrute), "", "à obtenir, demander comment il nous a connus", srcBrute && libelleSource(srcBrute) !== srcBrute ? `Valeur enregistrée : ${srcBrute}` : "");
    const et = etape || {};
    if (et.etat === "ok") fait("etape", "Étape GHL", et.texte + (et.autres ? ` (+${et.autres} autre${et.autres > 1 ? "s" : ""})` : ""), "GHL");
    else fait("etape", "Étape GHL", et.etat === "chargement" ? "…" : "", "", et.etat === "sans_contact" ? "à obtenir, aucun contact GHL relié" : et.etat === "aucune" ? "à obtenir, aucune opportunité GHL" : "à vérifier dans GHL");
    // Soumission de référence : la plus récente qui n'est ni refusée ni archivée (sinon la plus récente)
    const S = (subs || []).filter(Boolean);
    const liensDe = (s) => (cx.liens && cx.liens[s.id]) || [];
    const sub = S.find(s => s.status !== "refuse" && s.status !== "archive" && (s.project_type || equipementDe(s.lignes))) || S.find(x => x.project_type) || null;
    const res = cx.achats && cx.achats.resume && Number(cx.achats.resume.nb_factures) > 0 ? cx.achats.resume : null;
    const facture = res ? equipementFacture(res) : "";
    const srcFactures = res ? `factures QuickBooks${res.derniere_facture ? `, dernière le ${dateJour(res.derniere_facture)}` : ""}` : "";
    // Projet : fiche Raycast, résumé IA (projet_court), produits discutés, soumission RAYCAST, factures, puis l'intérêt d'après la source
    let projet = "", srcProjet = "";
    const secoursDe = (s) => { const p = s && s.parcours && typeof s.parcours === "object" ? s.parcours : {}; return /batterie/.test(String(s.project_type || p.objectif || "")) && SECOURS[p.secours] ? SECOURS[p.secours] : ""; };
    if (deFiche("projet")) { projet = court(deFiche("projet"), 90); srcProjet = "fiche RAYCAST"; }
    else if (R && !vague(R.projet_court)) { projet = court(R.projet_court, 70); srcProjet = "échanges"; }
    else if (!vague(sd.produits)) {
      const q = String(sd.quantites || "").trim(), prod = String(sd.produits).split(/[.;]\s/)[0].trim();
      const sec = !estNM(sd.secours) ? String(sd.secours).split(/[(,.:]/)[0].trim().toLowerCase() : "";
      projet = courtMots([/^\d+$/.test(q) ? `${q} × ${prod}` : prod, /^(secours\s+)?(partiel|complet|total|de base|maison compl|charges critiques)/.test(sec) ? `secours ${sec.replace(/^secours\s+/, "")}` : ""].filter(Boolean).join(", "), 70); srcProjet = "échanges";
    }
    else if (sub && sub.project_type) { projet = [PROJETS[sub.project_type] || cap(String(sub.project_type)), secoursDe(sub)].filter(Boolean).join(", "); srcProjet = `soumission RAYCAST${sub.number ? ` nº ${sub.number}` : ""}`; }
    else if (facture) { projet = res.nb_powerwall || res.fox_aio || res.sigenergy_ctrl || res.lux_lxp ? (res.panneaux && res.panneaux.nb ? "Batterie et solaire" : "Batterie") : res.panneaux && res.panneaux.nb ? "Solaire" : "Borne de recharge"; srcProjet = srcFactures; }
    else if (res) { const fc = facturesClient(r, cx.achats); projet = "Travaux électriques"; srcProjet = `factures QuickBooks, ${pluriel(fc.n, "facture", "factures")}${fc.premiere ? ` depuis ${String(fc.premiere).slice(0, 4)}` : ""}`; }
    else { const p = PROJET_SOURCE.find(([re]) => re.test(srcBrute)); if (p) { projet = `${p[1]} (intérêt)`; srcProjet = `d'après la source : ${libelleSource(srcBrute)}`; } }
    fait("projet", "Projet", projet, srcProjet, "à obtenir, préciser le besoin avec le client");
    // Système : fiche Raycast, équipement facturé (QuickBooks), équipement de la soumission RAYCAST avec son statut, sinon le statut dit dans les échanges
    let sys = "", srcSys = "";
    const st = sy && STATUT_RD[sy.statut] && sy.statut !== "inconnu" ? STATUT_RD[sy.statut][0] : "";
    const eqSub = sub ? equipementDe(sub.lignes) : "";
    if (deFiche("systeme")) { sys = court(deFiche("systeme"), 90); srcSys = "fiche RAYCAST"; }
    else if (facture) { sys = `Facturé : ${facture}`; srcSys = srcFactures; }
    else if (eqSub) {
      const stS = statutSoumission(sub, lienPrincipal(liensDe(sub)));
      const verbe = stS.cle === "acceptee" ? "Accepté" : stS.cle === "refusee" ? "Refusé" : stS.cle === "brouillon" ? "En préparation" : "Proposé";
      sys = `${verbe} : ${eqSub}`; srcSys = `soumission RAYCAST${sub.number ? ` nº ${sub.number}` : ""}, ${stS.texte}`;
    } else if (sub && sub.status !== "refuse") {
      const stS = statutSoumission(sub, lienPrincipal(liensDe(sub)));
      sys = cap(stS.texte); srcSys = `soumission RAYCAST${sub.number ? ` nº ${sub.number}` : ""}`;
    } else if (st) {
      const dateInst = !estNM(sy.date_installation) ? String(sy.date_installation).replace(/\s*\(.*\)\s*$/, "") : "";
      sys = st + (dateInst && /install/i.test(st) ? `, ${dateInst}` : ""); srcSys = sy.verifie ? "vérifié dans les données" : "selon les échanges";
    } else if (res) { sys = "Aucun système d'énergie"; srcSys = `${srcFactures} (travaux électriques)`; }
    fait("systeme", "Système", sys, srcSys, "à obtenir, installé ou non à confirmer");
    // Consommation : kWh par an, tarif, chauffage ; chaque morceau inconnu est nommé
    const deIA = (v) => (estNM(v) ? "" : court(v, 70));
    // kWh dits dans les échanges : seulement le chiffre et l'unité (« 51 540 kWh par année »), le détail reste dans le résumé
    const kwhIA = (v) => { if (estNM(v)) return ""; const m = String(v).match(/(\d[\d\s\u00a0\u202f.,]*)\s*kWh(\s*(?:par|\/)\s*(?:an|année))?/i); return m ? `${m[1].trim()} kWh${m[2] ? " par année" : ""}` : court(v, 50); };
    const kwhFiche = deFiche("conso_kwh_an") ? `${deFiche("conso_kwh_an").replace(/\s*kWh.*$/i, "")} kWh par année` : "";
    const kwh = kwhFiche || kwhIA(co.kwh_annuels) || (en.kwh_an && en.kwh_an.v) || (en.conso_dollars && `${en.conso_dollars.v} (en dollars)`) || deIA(co.mesure_passerelle_30j);
    const tarif = deFiche("tarif_hq") || deIA(co.tarif_hq) || (en.tarif && en.tarif.v) || "";
    const chauf = deFiche("chauffage") || deIA(co.chauffage) || (en.chauffage && en.chauffage.v) || "";
    const srcConso = [kwhFiche || deFiche("tarif_hq") || deFiche("chauffage") ? "fiche RAYCAST" : "", !kwhFiche && !kwhIA(co.kwh_annuels) && en.kwh_an ? en.kwh_an.src : !kwhFiche && !kwhIA(co.kwh_annuels) && en.conso_dollars ? en.conso_dollars.src : "", !deFiche("tarif_hq") && !deIA(co.tarif_hq) && en.tarif ? en.tarif.src : "", !deFiche("chauffage") && !deIA(co.chauffage) && en.chauffage ? en.chauffage.src : ""].filter(Boolean);
    const morceaux = [kwh, tarif ? `tarif ${tarif.replace(/^tarif\s+/i, "")}` : "", chauf ? `chauffage ${chauf.replace(/^chauffage\s+/i, "").replace(/^./, x => x.toLowerCase())}` : ""].filter(Boolean);
    const manquants = [kwh ? "" : "kWh", tarif ? "" : "tarif", chauf ? "" : "chauffage"].filter(Boolean);
    const factureHQ = en.facture_hq ? ` (facture ${en.facture_hq.v})` : "";
    F.push({ cle: "consommation", libelle: "Consommation", valeur: morceaux.join(" · "), source: [...new Set(srcConso)].join(" ; ") || (morceaux.length ? "échanges" : ""), manque: !morceaux.length ? (en.facture_hq ? `à obtenir, lire la facture Hydro-Québec${factureHQ}` : "à obtenir, demander la facture Hydro-Québec") : manquants.length ? `${manquants.join(", ")} à obtenir` : "", detail: "" });
    // N° de client Hydro-Québec : 4 derniers chiffres seulement, comme ailleurs
    const hqIA = !estNM(hq.numero_client) ? masqueHQ(hq.numero_client) : "";
    const hqFiche = en.hq_client ? masqueQuatre(en.hq_client.v) : "";
    fait("hq", "N° client HQ", hqIA || hqFiche, hqIA ? "échanges" : hqFiche ? en.hq_client.src : "", en.facture_hq ? `à obtenir, sur la facture Hydro-Québec${factureHQ}` : "à obtenir, sur la facture Hydro-Québec");
    return F;
  }

  /** Devis QuickBooks resté « Pending » alors qu'une facture du même montant a suivi : il est facturé, pas en attente. */
  const devisFacture = (d, factures) => (factures || []).some(f => f && Math.abs((Number(f.total_ttc) || 0) - (Number(d.total_ttc) || 0)) < 0.01 && String(f.date || "") >= String(d.date || ""));
  const devisEnAttente = (devis, factures, lies) => (devis || []).filter(d => d && d.statut === "Pending" && !lies.has(String(d.id)) && !devisFacture(d, factures)).sort((a, b) => String(b.date || "").localeCompare(String(a.date || "")))[0];
  /** Prochaine étape (fonction pure, testée) : fiche Raycast, sinon la première étape du résumé IA, sinon une étape déduite des données
   *  (proposition consultée ou envoyée sans réponse, solde dû, devis QuickBooks en attente, soumission en préparation).
   *  { texte, source, retard, jours } ou null. retard : la date est passée (étape écrite) ou le délai normal est dépassé (étape déduite). */
  function prochaineEtape(R, ctx, subs, maintenant) {
    const cx = ctx || {}, now = maintenant || new Date();
    const fx = cx.fiche && cx.fiche.champs && typeof cx.fiche.champs === "object" ? cx.fiche.champs : {};
    if (fx.prochaine_etape && String(fx.prochaine_etape).trim()) {
      const q = fx.prochaine_etape_le || ""; const j = q ? joursDepuis(q, now) : null;
      return { texte: [court(fx.prochaine_etape, 90), q ? dateJour(q) : ""].filter(Boolean).join(", "), source: "fiche RAYCAST", retard: j != null && j > 0, jours: j };
    }
    const etapes = listeRD(R && R.prochaines_etapes);
    if (etapes.length) {
      const pe = typeof etapes[0] === "object" ? etapes[0] : { action: etapes[0] };
      const quand = !estNM(pe.quand) ? String(pe.quand) : "";
      const d = quand ? dateDansTexte(quand) : null; const j = d ? joursDepuis(d, now) : null;
      return { texte: [courtMots(pe.action, 90), quand.replace(/^[A-ZÀ-Ý](?=[a-zà-ÿ])/, x => x.toLowerCase())].filter(Boolean).join(", "), source: "", retard: j != null && j > 0, jours: j };
    }
    const cands = [];
    const S = (subs || []).filter(s => s && s.status !== "archive");
    const s = S[0];
    if (s) {
      const l = lienPrincipal((cx.liens && cx.liens[s.id]) || []), st = statutSoumission(s, l), n = s.number ? `nº ${s.number}` : "";
      if (st.cle === "consultee") { const vu = (l && (l.derniere_vue || l.envoye_le || l.created_at)) || s.updated_at; const j = joursDepuis(vu, now); cands.push({ p: 1, texte: `Relancer : proposition ${n} consultée le ${dateJour(vu)}, sans réponse`, source: "déduite de la proposition en ligne", retard: j != null && j >= 3, jours: j }); }
      else if (st.cle === "envoyee" || st.cle === "courriel") { const env = (l && l.envoye_le) || s.courriel_prepare || s.finalized_at || s.created_at; const j = joursDepuis(env, now); cands.push({ p: 1, texte: `Relancer : proposition ${n} envoyée le ${dateJour(env)}${l && !(Number(l.nb_vues) > 0) ? ", pas encore ouverte" : ""}`, source: "déduite de la soumission", retard: j != null && j >= 3, jours: j }); }
      else if (st.cle === "finalisee") { const f = s.finalized_at || s.created_at; const j = joursDepuis(f, now); cands.push({ p: 1, texte: `Envoyer la proposition ${n} (finalisée le ${dateJour(f)})`, source: "déduite de la soumission", retard: j != null && j >= 2, jours: j }); }
      else if (st.cle === "brouillon") { const f = s.updated_at || s.created_at; const j = joursDepuis(f, now); cands.push({ p: 4, texte: `Finaliser la soumission ${n}`.trim(), source: "déduite de la soumission", retard: j != null && j >= 3, jours: j }); }
      else if (st.cle === "acceptee") { const f = (l && l.decision_le) || s.updated_at; cands.push({ p: 5, texte: `Planifier l'installation (proposition ${n} acceptée le ${dateJour(f)})`, source: "déduite de la proposition", retard: false, jours: null }); }
    }
    const fac = (cx.factures || []).filter(f => Number(f.solde) > 0);
    if (fac.length) {
      const total = fac.reduce((a, f) => a + Number(f.solde), 0);
      const echue = fac.filter(f => f.echeance && joursDepuis(f.echeance, now) > 0).sort((a, b) => String(a.echeance).localeCompare(String(b.echeance)))[0];
      const ref = echue || fac.slice().sort((a, b) => String(b.date || "").localeCompare(String(a.date || "")))[0];
      cands.push({ p: 2, texte: `Suivre le solde de ${fmt(total)}${fac.length === 1 && ref.numero ? ` (facture nº ${ref.numero}${ref.echeance ? `, échéance le ${dateJour(ref.echeance)}` : ""})` : ` (${pluriel(fac.length, "facture", "factures")})`}`, source: "déduite des factures QuickBooks", retard: !!echue, jours: echue ? joursDepuis(echue.echeance, now) : null });
    }
    const lies = new Set(S.map(x => x.qbo_estimate_id).filter(Boolean).map(String));
    const dv = devisEnAttente(cx.devis, cx.factures, lies);
    if (dv) { const j = joursDepuis(dv.date, now); cands.push({ p: 3, texte: `Relancer le devis nº ${dv.numero || "?"} (${fmt(dv.total_ttc)}), en attente depuis le ${dateJour(dv.date)}`, source: "déduite des devis QuickBooks", retard: j != null && j >= 7, jours: j }); }
    cands.sort((a, b) => a.p - b.p);
    if (!cands.length) return null;
    const { p, ...c } = cands[0];
    return c;
  }

  /** Phrases entières tant qu'elles tiennent dans n caractères ; une première phrase trop longue est coupée entre deux mots. */
  const tronquer = (t, n) => {
    const s = String(t || "").trim(); if (s.length <= n) return s;
    const ph = s.match(/[^.!?]+[.!?]+(\s|$)|[^.!?]+$/g) || [s]; let out = "";
    for (const p of ph) { if ((out + p).trim().length > n) break; out += p; }
    if (out.trim()) return out.trim();
    const coupe = s.slice(0, n - 1); const i = coupe.lastIndexOf(" "); return (i > n * 0.6 ? coupe.slice(0, i) : coupe).replace(/[\s,;:.]+$/, "") + "…";
  };
  const BREF_MAX = 320;
  /** En bref (fonction pure, testée) : 3 phrases au plus. Le résumé IA du dossier d'abord (client_insights.resume.en_bref, sinon la
   *  synthèse), tronqué proprement ; sinon un résumé factuel bâti avec ce qui est déjà chargé : ce que le client veut, où il en est
   *  (soumission, devis, solde) et le dernier contact. { texte, source, ia } ou null quand rien n'est connu. */
  function resumeBref(r, R, ins, ctx, subs, faits, dernier) {
    const cx = ctx || {};
    if (R && !estNM(R.en_bref)) return { texte: tronquer(troisPhrases(R.en_bref), BREF_MAX), source: `Résumé IA${ins && ins.resume_le ? ` du ${dateJour(ins.resume_le)}` : ""}`, ia: true };
    if (ins && !estNM(ins.synthese)) return { texte: tronquer(troisPhrases(ins.synthese), BREF_MAX), source: `Synthèse IA${ins.derniere_interaction ? ` du ${dateJour(ins.derniere_interaction)}` : ""}`, ia: true };
    const P = [];
    const pj = (faits || []).find(f => f.cle === "projet");
    const res = cx.achats && cx.achats.resume && Number(cx.achats.resume.nb_factures) > 0 ? cx.achats.resume : null;
    const fc = facturesClient(r, cx.achats);
    const nbF = fc ? fc.n : 0, totF = fc ? fc.total : 0;
    if (pj && pj.valeur && !/^Travaux électriques$/.test(pj.valeur)) P.push(`Projet : ${pj.valeur.charAt(0).toLowerCase() + pj.valeur.slice(1)}.`);
    else if (nbF) P.push(`Client QuickBooks${fc.premiere ? ` depuis ${String(fc.premiere).slice(0, 4)}` : ""} : ${pluriel(nbF, "facture", "factures")}${totF ? `, ${fmt0(totF)} facturés taxes incluses` : ""}.`);
    const etat = [];
    const S = (subs || []).filter(s => s && s.status !== "archive"), s = S[0];
    if (s) {
      const l = lienPrincipal((cx.liens && cx.liens[s.id]) || []), st = statutSoumission(s, l);
      const quoi = `soumission ${s.number ? `nº ${s.number} ` : ""}${s.price_total != null && s.price_total !== "" ? `de ${fmt(s.price_total)} ` : ""}`.trim();
      const vu = l && (l.derniere_vue || l.envoye_le);
      const detail = st.cle === "consultee" ? `proposition consultée${vu ? ` le ${dateJour(vu)}` : ""}, sans réponse`
        : st.cle === "acceptee" ? `acceptée${l && l.decision_le ? ` le ${dateJour(l.decision_le)}` : ""}`
        : st.cle === "refusee" ? "refusée"
        : st.cle === "brouillon" ? "en préparation"
        : st.cle === "envoyee" || st.cle === "courriel" ? `envoyée${l && l.envoye_le ? ` le ${dateJour(l.envoye_le)}` : ""}${l && !(Number(l.nb_vues) > 0) ? ", pas encore ouverte" : ""}`
        : "finalisée, pas encore envoyée";
      etat.push(`${quoi} : ${detail}`);
    }
    const lies = new Set(S.map(x => x.qbo_estimate_id).filter(Boolean).map(String));
    const dv = devisEnAttente(cx.devis, cx.factures, lies);
    if (dv) etat.push(`devis nº ${dv.numero || "?"} de ${fmt(dv.total_ttc)} en attente depuis le ${dateJour(dv.date)}`);
    const solde = (cx.factures || []).reduce((a, f) => a + (Number(f.solde) > 0 ? Number(f.solde) : 0), 0) || (Number(r.solde) > 0 ? Number(r.solde) : 0);
    if (solde > 0) etat.push(`solde dû de ${fmt(solde)}`);
    // Rien d'ouvert, mais des factures et un projet nommé : où en est le client, en une phrase
    if (!etat.length && nbF && P.length && /^Projet/.test(P[0])) etat.push(`${pluriel(nbF, "facture", "factures")}${totF ? ` (${fmt0(totF)} taxes incluses)` : ""}, tout est payé`);
    if (etat.length) P.push(cap(etat.slice(0, 2).join(" ; ")) + ".");
    if (dernier) P.push(`Dernier contact le ${dateJour(dernier)}.`);
    if (!P.length) return null;
    return { texte: P.slice(0, 3).join(" "), source: "D'après les soumissions, devis et factures", ia: false };
  }

  /** Résumé IA dépassé par les données (fonction pure, testée) : le dernier statut connu de la soumission la plus récente est plus
   *  récent que le résumé (« Depuis : … »), ou le résumé parle d'un brouillon alors que la proposition est partie (« À jour : … »).
   *  Retourne { etiquette, texte } ou null. Le texte de l'IA n'est jamais modifié. */
  function miseAJourBref(b, ins, ctx, subs) {
    if (!b || !b.ia) return null;
    const s = (subs || []).filter(x => x && x.status !== "archive")[0]; if (!s) return null;
    const l = lienPrincipal((ctx && ctx.liens && ctx.liens[s.id]) || []), st = statutSoumission(s, l);
    const quand = st.cle === "consultee" ? l && l.derniere_vue : st.cle === "acceptee" || st.cle === "refusee" ? (l && l.decision_le) || s.updated_at
      : st.cle === "envoyee" || st.cle === "courriel" ? (l && l.envoye_le) || s.courriel_prepare || s.finalized_at : st.cle === "finalisee" ? s.finalized_at : null;
    if (!quand || st.cle === "brouillon") return null;
    const texte = `soumission ${s.number ? `nº ${s.number} ` : ""}: ${st.texte} le ${dateJour(quand)}.`;
    const resumeLe = ins && (ins.resume_le || ins.derniere_interaction);
    if (resumeLe && (parseDate(quand) || 0) > (parseDate(resumeLe) || 0)) return { etiquette: "Depuis", texte };
    if (/brouillon/i.test(b.texte)) return { etiquette: "À jour", texte };
    return null;
  }

  /** « à obtenir … » : la ligne dit seulement « à obtenir », le détail (quoi faire) est dans la bulle d'aide. */
  const courtManque = (m) => (/^à obtenir(\s|,|$)/.test(m) || /(^|\s)à obtenir$/.test(m) ? "à obtenir" : m);
  const Pastille2 = ({ ton, children, titre }) => <span className="re-colonne-pastille" data-ton={ton} title={titre}>{children}</span>;

  function ApercuFiche({ r, rs, subs, etape, ctx, modifierFiche }) {
    const { ins, R, aDesInteractions, etat } = rs;
    const F = faitsFiche(r, R, etape, subs, ctx);
    // Dernier contact : la fiche unifiée ou le résumé, la plus récente ; canal de la dernière entrée de la chronologie si elle est du même jour
    const dates = [r.derniere_interaction, ins && ins.derniere_interaction].filter(Boolean).sort((a, b) => (parseDate(b) || 0) - (parseDate(a) || 0));
    const dernier = dates[0] || null;
    const chrono = R && Array.isArray(R.chronologie) ? R.chronologie.filter(x => x && x.date) : [];
    const derniereEntree = chrono[chrono.length - 1];
    const memeJour = derniereEntree && dernier && dateFR(derniereEntree.date) === dateFR(dernier);
    F.push({ cle: "dernier", libelle: "Dernier contact", valeur: dernier ? `${DATE_SEULE.test(String(dernier).trim()) ? dateJour(dernier) : dateCourte(dernier)}${memeJour && derniereEntree.canal ? `, ${derniereEntree.canal === "Rencontre Pocket" ? "rencontre" : String(derniereEntree.canal).toLowerCase() === "sms" ? "SMS" : String(derniereEntree.canal).toLowerCase()}` : ""} (${ilYaJours(dernier)})` : "", source: "", manque: dernier ? "" : "aucun échange au dossier", detail: "" });
    const pe = prochaineEtape(R, ctx, subs);
    F.push({ cle: "prochaine", libelle: "Prochaine étape", valeur: pe ? pe.texte : "", source: pe ? pe.source : "", manque: pe ? "" : "à définir", detail: "", retard: !!(pe && pe.retard), jours: pe ? pe.jours : null });
    const b = resumeBref(r, R, ins, ctx, subs, F, dernier);
    const maj = miseAJourBref(b, ins, ctx, subs);
    const brefAttente = !b && (etat.occupe ? "Résumé en préparation…" : ins === undefined ? "…" : aDesInteractions || ins ? "Résumé à venir : ouvre « Détails et conversations » pour le créer." : "Aucun échange au dossier pour l'instant.");
    const manquants = F.filter(f => f.manque && !f.valeur);
    const sync = ctx && ctx.fiche && ctx.fiche.sync_ghl;
    return (
      <section className="fa-apercu" aria-label="Aperçu du client">
        <div className="fa-carte">
          <div className="fa-tete">
            <h3 className="fa-titre">Fiche</h3>
            {manquants.length > 0 && <span className="fa-compte" title={manquants.map(f => `${f.libelle} : ${f.manque}`).join("\n")}>{pluriel(manquants.length, "fait à obtenir", "faits à obtenir")}</span>}
            {sync === "a_synchroniser" && <Pastille2 ton="orange" titre={(ctx.fiche.sync_ghl_erreur ? `Dernière erreur : ${ctx.fiche.sync_ghl_erreur}. ` : "") + "La fiche est enregistrée dans Raycast ; elle sera renvoyée à GHL."}>GHL à synchroniser</Pastille2>}
            {modifierFiche && <button type="button" className="re-btn small fa-modifier" disabled={!!modifierFiche.desactive} onClick={modifierFiche.action} title={modifierFiche.titre}>Modifier la fiche</button>}
          </div>
          <dl className="fa-faits">
            {F.map(f => (
              <div key={f.cle} className={"fa-fait" + (!f.valeur ? " fa-manque" : f.manque ? " fa-partiel" : "")} data-fait={f.cle}>
                <dt>{f.libelle}</dt>
                <dd>
                  {f.valeur && <span className="fa-val" title={!f.source && f.detail ? f.detail : undefined}>{f.valeur}</span>}
                  {f.retard && <> <Pastille2 ton="orange" titre={f.jours != null ? `${pluriel(f.jours, "jour", "jours")} de retard` : undefined}>en retard</Pastille2></>}
                  {f.manque && <span className="fa-aobtenir" title={courtManque(f.manque) !== f.manque ? f.manque : undefined}>{f.valeur ? " · " : ""}{courtManque(f.manque)}</span>}
                  {f.valeur && f.source && <span className="fa-src" title={f.detail || undefined}>{f.source}</span>}
                </dd>
              </div>
            ))}
          </dl>
        </div>
        <div className={"fa-bref" + (b ? "" : " fa-bref-attente")}><span className="fa-etiquette">En bref</span><p>{b ? b.texte : brefAttente}</p>{maj && <span className="fa-bref-maj"><b>{maj.etiquette} :</b> {maj.texte}</span>}{b && <span className="fa-bref-src">{b.source}{b.ia ? " · le détail est dans « Détails et conversations »" : ""}</span>}</div>
      </section>
    );
  }

  /** Reprise de l'historique (JF, 6 nov. 2026 : « dans GHL il a un gros dossier, mais dans Raycast le dossier est vide ») :
   *  à l'ouverture d'une fiche jamais reprise, le worker va chercher les conversations et les notes GHL et les appels Aircall du client
   *  (POST /raycast/intel/reprise, une fois par fiche et par session) ; le bouton « Reprendre l'historique » force une relecture
   *  complète (rien n'est doublé). Pocket n'est pas repris. Après la reprise, le résumé du dossier et « Ce que le client a dit »
   *  se mettent à jour (événement raycast-dossier-maj). */
  const repriseSession = new Map();   // c.cle → { le } : une seule reprise automatique par fiche et par session
  const SIX_HEURES = 6 * 3600000;
  function RepriseHistorique({ c }) {
    const keys = clesDe(c);
    const vide = { occupe: false, message: "", erreur: "", marque: null };
    const [etat, setEtat] = useState(vide);
    const seq = useRef(0);
    const lancer = async (force, auto) => {
      if (!keys.length) return;
      const id = ++seq.current;
      repriseSession.set(c.cle, { le: Date.now() });
      setEtat(e => ({ ...e, occupe: true, message: "", erreur: "" }));
      try {
        const ghl = (c.sources && c.sources.ghl_contact_id) || "";
        const j = await workerPost(`/raycast/intel/reprise?client_key=${encodeURIComponent(keys.join(","))}${ghl ? `&ghl_contact_id=${encodeURIComponent(ghl)}` : ""}${force ? "&force=1" : ""}${auto ? "&auto=1" : ""}`, {});
        if (id !== seq.current) return;
        if (Array.isArray(j.cles) && j.cles.length) clesApprises.set(c.cle, j.cles.slice(0, 6));
        const n = Number(j.total_ajoutes) || 0;
        const message = j.deja ? "" : (n > 0 ? pluriel(n, "échange ajouté", "échanges ajoutés") : "Aucun nouvel échange : le dossier était déjà à jour") + (j.complet === false ? " · la suite viendra à la prochaine reprise" : "");
        setEtat({ occupe: false, message, erreur: "", marque: j.marque || null });
        if (!j.deja && (n > 0 || j.resume)) window.dispatchEvent(new CustomEvent(EVT_DOSSIER, { detail: { cle: c.cle, resume: j.resume || null, resume_le: j.resume_le || null, nb_interactions: j.nb_interactions != null ? j.nb_interactions : null, client_key: keys[0] } }));
      } catch (e) {
        if (id !== seq.current) return;
        const m = texte(e);
        const lisible = /limite atteinte/i.test(m) ? m : /déjà en cours/i.test(m) ? "Une reprise est déjà en cours pour ce client, réessaie dans une minute." : /failed to fetch|networkerror|load failed/i.test(m) ? "Le serveur ne répond pas. Vérifie ta connexion et réessaie." : "Reprise impossible : " + m;
        setEtat({ ...vide, erreur: auto ? "" : lisible });   // reprise automatique : un échec reste discret, le bouton reste là
      }
    };
    useEffect(() => {
      seq.current++; setEtat(vide);
      if (!keys.length || repriseSession.has(c.cle)) return;
      const id = seq.current;
      (async () => {
        try {
          const j = await worker(`/raycast/intel/reprise/etat?client_key=${encodeURIComponent(keys.join(","))}`);
          if (id !== seq.current) return;
          const m = j && j.marque;
          // Déjà reprise (ou essayée il y a moins de 6 h) : rien à faire ; sinon reprise automatique, une fois par session
          if (j.complet || (m && m.le && Date.now() - Date.parse(m.le) < SIX_HEURES)) { repriseSession.set(c.cle, { le: Date.now() }); setEtat({ ...vide, marque: m || null }); return; }
          lancer(false, true);
        } catch (e) { /* worker sans la reprise ou injoignable : le bouton reste disponible */ }
      })();
      return () => { seq.current++; };
    }, [c.cle]); // eslint-disable-line
    if (!keys.length) return null;
    const statut = etat.occupe ? <><span className="rd-spin" aria-hidden="true" /> Reprise en cours…</>
      : etat.message ? etat.message
      : etat.marque && etat.marque.le ? `Historique GHL et Aircall repris le ${dateHeure(etat.marque.le)}`
      : "Historique GHL et Aircall";
    return (
      <div className="rh-reprise" aria-live="polite">
        <span className={"rh-texte" + (etat.message ? " rh-fait" : "")}>{statut}</span>
        <button className="re-btn small rh-bouton" onClick={() => lancer(true, false)} disabled={etat.occupe} aria-busy={etat.occupe} title="Va chercher les conversations et les notes GHL et les appels Aircall de ce client (rien n'est doublé), puis met le résumé à jour">Reprendre l'historique</button>
        {etat.erreur && <div className="re-alert error rh-erreur" role="alert">{etat.erreur}</div>}
      </div>
    );
  }

  /** Analyses IA des appels et conversations (client_insights + interactions récentes). Sources valides : aircall, pocket, email, ghl, manuel. */
  const SRC_INTER = { aircall: ["Appel", "aircall"], pocket: ["Rencontre", "pocket"], email: ["Courriel", "email"], ghl: ["GHL", "ghl"], manuel: ["Note", "manuel"] };
  // Canal GHL lisible (brut.canal : « sms » du webhook et de la reprise, « SMS » de la collecte, « note », « chat », « appel »)
  const CANAL_GHL = { sms: "SMS", courriel: "Courriel", email: "Courriel", chat: "Clavardage", appel: "Appel", note: "Note" };
  function CeQueLeClientADit({ c }) {
    const [ins, setIns] = useState(null);
    const [inter, setInter] = useState([]);
    const [version, setVersion] = useState(0);
    useEffect(() => { const f = (e) => { if (e && e.detail && e.detail.cle === c.cle) setVersion(v => v + 1); }; window.addEventListener(EVT_DOSSIER, f); return () => window.removeEventListener(EVT_DOSSIER, f); }, [c.cle]);
    useEffect(() => {
      let alive = true;
      setIns(null); setInter([]);
      const keys = clesDe(c);
      if (!keys.length || !window.RAYCAST_SUPABASE) return;
      (async () => {
        try {
          const { data } = await window.RAYCAST_SUPABASE.from("client_insights").select("*").in("client_key", keys).order("derniere_interaction", { ascending: false }).limit(1);
          if (alive) setIns(data && data[0] ? data[0] : null);
          const { data: it } = await window.RAYCAST_SUPABASE.from("interactions").select("id,source,direction,started_at,resume,analyse_ia,brut").in("client_key", keys).order("started_at", { ascending: false }).limit(8);
          if (alive) setInter(Array.isArray(it) ? it : []);
        } catch (e) { /* tables d'intelligence indisponibles : la fiche reste utilisable */ }
      })();
      return () => { alive = false; };
    }, [c.cle, version]); // eslint-disable-line
    if (!ins && !inter.length) return null;
    const sg = ins && ins.suggestion && typeof ins.suggestion === "object" ? ins.suggestion : null;
    return (
      <div className="re-group">
        <div className="re-group-head"><span>Ce que le client a dit</span><b>{pluriel(inter.length, "interaction", "interactions")}</b></div>
        {ins && <div className="re-insight"><p>{ins.synthese}</p>{sg && sg.objectif && <div className="re-chips">{[sg.objectif, sg.marque, sg.secours ? `secours ${sg.secours}` : null, sg.nb_panneaux ? `${sg.nb_panneaux} panneaux` : null, sg.bornes ? "borne" : null].filter(Boolean).map((x, i) => <span key={i} className="re-chip on">{String(x)}</span>)}{sg.prochaine_etape && <span className="re-chip">→ {String(sg.prochaine_etape)}</span>}</div>}</div>}
        <ul className="re-timeline">
          {inter.map((i, idx) => {
            const a = (i.analyse_ia && typeof i.analyse_ia === "object") ? i.analyse_ia : {}; const b = (i.brut && typeof i.brut === "object") ? i.brut : {};
            const src = SRC_INTER[i.source] || [i.source || "Message", "autre"];
            const libelle = i.source === "ghl" && b.canal ? (CANAL_GHL[String(b.canal).toLowerCase()] || String(b.canal)) : src[0];
            return <li key={i.id || idx}><span className={"re-src " + src[1]}>{libelle}</span><span className="re-muted">{dateHeure(i.started_at)}{i.direction ? ` · ${i.direction}` : ""}{b.sentiment ? ` · ${String(b.sentiment).toLowerCase()}` : ""}</span><div>{a.resume || i.resume || (a.ignore ? "Message court, non analysé." : "Analyse en attente.")}</div>{Array.isArray(b.actions) && b.actions.length > 0 && <div className="re-muted">À faire : {b.actions.map(String).join(" · ")}</div>}</li>;
          })}
        </ul>
      </div>
    );
  }

  /** Dossier : tout ce que le client nous a envoyé (courriels, SMS et messages GHL, QuickBooks, dépôts manuels), bucket privé, URL signées. */
  const SRC_FICHIER = { email: ["Courriel", "email"], ghl: ["SMS / GHL", "ghl"], quickbooks: ["QuickBooks", "qbo"], manuel: ["Ajouté", "manuel"] };
  function Dossier({ c }) {
    const [files, setFiles] = useState(null);
    const [filtre, setFiltre] = useState("tous");
    const [etat, setEtat] = useState("");
    const [occupe, setOccupe] = useState(false);
    const [glisse, setGlisse] = useState(false);
    const inputRef = useRef(null);
    const seq = useRef(0); // une réponse tardive d'un autre client n'écrase jamais le dossier affiché
    const keys = clesDe(c);
    const charger = async () => {
      const id = ++seq.current;
      if (!keys.length) { setFiles([]); return; }
      try { const j = await worker(`/raycast/dossier?keys=${encodeURIComponent(keys.join(","))}`); if (id === seq.current) setFiles(Array.isArray(j.fichiers) ? j.fichiers : []); return; }
      catch (e) { /* repli : lecture directe, URL signées par le navigateur */ }
      try {
        const { data, error } = await window.RAYCAST_SUPABASE.from("client_files").select("*").in("client_key", keys).order("recu_le", { ascending: false }).limit(120);
        if (error) throw error;
        const rows = data || [];
        const signed = await Promise.all(rows.map(async f => { try { const { data: s } = await window.RAYCAST_SUPABASE.storage.from("dossiers-clients").createSignedUrl(f.chemin, 3600); return { ...f, url: s && s.signedUrl, image: /^image\//.test(f.type || "") }; } catch (e) { return f; } }));
        if (id === seq.current) setFiles(signed);
      } catch (e) { if (id === seq.current) { setFiles([]); setEtat("Dossier indisponible pour le moment, réessaie dans quelques minutes."); } }
    };
    useEffect(() => { setFiles(null); setEtat(""); setFiltre("tous"); charger().then(() => importerAuto()); return () => { seq.current++; }; }, [c.cle]); // eslint-disable-line
    // JF, 8 nov. 2026 : plus de bouton « Importer tout le dossier ». À l'ouverture de la fiche, Raycast va chercher tout seul,
    // en arrière-plan, les photos et PDF déjà reçus (GHL, courriels, QuickBooks), au plus une fois par jour et par client ;
    // les nouveaux (texto, courriel) arrivent aussi d'eux-mêmes par la collecte automatique des workers.
    const importerAuto = async () => {
      if (!keys.length) return;
      const marque = "raycast:dossier:auto:" + keys[0];
      try { const t = Number(localStorage.getItem(marque) || 0); if (t && Date.now() - t < 24 * 3600 * 1000) return; localStorage.setItem(marque, String(Date.now())); } catch (e) { /* stockage local indisponible : on importe */ }
      const id = seq.current;
      try {
        const j = await workerPost("/raycast/dossier/importer", { client_key: keys[0], email: (c.courriel || "").toString().trim().toLowerCase(), telephone: c.telephone == null ? "" : String(c.telephone), ghl_contact_id: (c.sources && c.sources.ghl_contact_id) || "", qbo_customer_id: (c.sources && c.sources.qbo_id) || "" });
        const total = Number(j && j.total) || 0;
        if (total > 0 && id === seq.current) { setEtat(`${pluriel(total, "nouveau fichier retrouvé", "nouveaux fichiers retrouvés")} (texto, courriel ou QuickBooks).`); await charger(); }
      } catch (e) { try { localStorage.removeItem(marque); } catch (_) { /* */ } } // réessai à la prochaine ouverture, sans message
    };
    const deposer = async (liste) => {
      if (occupe) return;
      if (!keys.length) { setEtat("Ajoute d'abord un téléphone ou un courriel à ce client pour classer ses fichiers."); return; }
      const fichiers = Array.from(liste || []).filter(f => /^(image\/|application\/pdf)/.test(f.type)).slice(0, 10);
      if (!fichiers.length) { setEtat("Images et PDF seulement."); return; }
      setOccupe(true); setEtat(`Dépôt de ${pluriel(fichiers.length, "fichier", "fichiers")}…`);
      let n = 0; const erreurs = [];
      for (const f of fichiers) {
        const fd = new FormData(); fd.append("client_key", keys[0]); fd.append("fichier", f, f.name);
        try { await workerPost("/raycast/dossier/fichier", fd, true); n++; } catch (e) { erreurs.push(`${f.name} (${texte(e)})`); }
      }
      setEtat(`${pluriel(n, "fichier ajouté", "fichiers ajoutés")}.${erreurs.length ? ` Refusés : ${erreurs.join(" ; ")}` : ""}`);
      setOccupe(false);
      await charger();
    };
    const vis = (files || []).filter(f => filtre === "tous" || f.source === filtre);
    const sources = Array.from(new Set((files || []).map(f => f.source).filter(Boolean)));
    return (
      <div className={"re-group re-dossier2" + (glisse ? " glisse" : "")} onDragOver={e => { e.preventDefault(); setGlisse(true); }} onDragLeave={() => setGlisse(false)} onDrop={e => { e.preventDefault(); setGlisse(false); deposer(e.dataTransfer.files); }}>
        <div className="re-group-head"><span>Dossier</span><b>{files ? pluriel(files.length, "fichier", "fichiers") : "…"}</b></div>
        {sources.length > 1 && (
          <div className="re-dossier2-barre">
            <div className="re-dossier2-filtres">
              <button className={filtre === "tous" ? "on" : ""} onClick={() => setFiltre("tous")}>Tout</button>
              {sources.map(k => <button key={k} className={filtre === k ? "on" : ""} onClick={() => setFiltre(k)}>{(SRC_FICHIER[k] || [k])[0]}</button>)}
            </div>
          </div>
        )}
        {keys.length > 0 ? (
          <button type="button" className={"re-depot" + (glisse ? " actif" : "")} disabled={occupe} onClick={() => inputRef.current && inputRef.current.click()} aria-label="Ajouter des fichiers au dossier du client">
            <svg width="28" height="28" viewBox="0 0 24 24" fill="none" stroke="currentColor" strokeWidth="1.8" strokeLinecap="round" strokeLinejoin="round" aria-hidden="true"><path d="M12 16V4"/><path d="M7 9l5-5 5 5"/><path d="M4 16v3a1 1 0 0 0 1 1h14a1 1 0 0 0 1-1v-3"/></svg>
            <span className="re-depot-titre">{occupe ? "Dépôt en cours…" : "Glisse tes PDF ou photos ici"}</span>
            <span className="re-depot-sous">ou clique pour les choisir · PDF, JPG, PNG · 8 Mo max par fichier</span>
          </button>
        ) : <p className="re-muted">Aucun téléphone ni courriel sur cette fiche : le dossier ne peut pas être rattaché à ce client.</p>}
        <input ref={inputRef} type="file" multiple accept="image/*,application/pdf" style={{ display: "none" }} onChange={e => { deposer(e.target.files); e.target.value = ""; }} />
        {etat && <div className="re-etat" style={{ margin: "8px 0" }}>{etat}</div>}
        {files && !files.length && keys.length > 0 && <p className="re-muted re-depot-note">Les photos et PDF reçus par texto ou par courriel s'ajoutent ici automatiquement.</p>}
        {files && files.length > 0 && !vis.length && <p className="re-muted">Aucun fichier de cette source.</p>}
        {vis.length > 0 && (
          <div className="re-dossier2-grille">
            {vis.map((f, idx) => (
              <a key={f.id || f.chemin || idx} className="re-vignette" href={f.url || "#"} target="_blank" rel="noopener" title={`${f.nom || "fichier"} · ${dateHeure(f.recu_le)}`}>
                {f.image && f.url ? <img src={f.url} alt={f.nom || ""} loading="lazy" /> : <div className="re-vignette-doc"><span>{/pdf/i.test(f.type || f.nom || "") ? "PDF" : "DOC"}</span></div>}
                <span className={"re-vignette-src " + ((SRC_FICHIER[f.source] || ["", "autre"])[1])}>{(SRC_FICHIER[f.source] || [f.source || "Autre"])[0]}</span>
                <b>{f.nom || "fichier"}</b><small>{dateFR(f.recu_le)}</small>
              </a>
            ))}
          </div>
        )}
      </div>
    );
  }

  /** Propositions en ligne du client (proposition_liens : id QuickBooks de la fiche, ou une de ses clés téléphone et courriel).
   *  Lecture seule, colonnes nommées ; le bloc n'apparaît que s'il y a au moins un lien. Un clic ouvre la soumission. */
  function PropositionsClient({ r, onOpenSubmission, clavier }) {
    const [liens, setLiens] = useState([]);
    const qboId = r.sources && r.sources.qbo_id ? String(r.sources.qbo_id) : "";
    const cles = clesDe(r);
    const cleCles = cles.join(",");
    useEffect(() => {
      let alive = true;
      setLiens([]);
      const sb = window.RAYCAST_SUPABASE;
      const COLS = window.SuiviPropositionsRE && window.SuiviPropositionsRE.COLS;
      if (!sb || !COLS || (!qboId && !cles.length)) return;
      const lire = (q) => q.neq("etat", "preparation").order("created_at", { ascending: false }).limit(50).then(({ data, error }) => { if (error) { console.warn("[clients] propositions en ligne illisibles", error.message); return []; } return data || []; });
      Promise.all([qboId ? lire(sb.from("proposition_liens").select(COLS).eq("qbo_customer_id", qboId)) : Promise.resolve([]), cles.length ? lire(sb.from("proposition_liens").select(COLS).in("client_key", cles)) : Promise.resolve([])])
        .then(([a, b]) => {
          if (!alive) return;
          const vus = new Map();
          for (const l of [...a, ...b]) vus.set(l.id, l);
          const date = (l) => Date.parse(l.envoye_le || l.created_at || "") || 0;
          setLiens([...vus.values()].sort((x, y) => date(y) - date(x)));
        });
      return () => { alive = false; };
    }, [qboId, cleCles]); // eslint-disable-line
    const PL = window.PropositionLienRE;
    if (!liens.length || !PL) return null;
    const f = PL.format || {};
    const decision = (l) => l.decision === "acceptee" ? `Acceptée${l.decision_nom ? ` par « ${l.decision_nom} »` : ""}${l.decision_le ? ` le ${f.quand(l.decision_le)}` : ""}`
      : l.decision === "refusee" ? `Refusée : ${(PL.MOTIFS || {})[l.motif_refus] || "motif non précisé"}${l.relance ? `, ${(PL.RELANCES || {})[l.relance] || l.relance}` : ""}`
      : "Aucune réponse";
    return (
      <div className="re-group sp-fiche"><div className="re-group-head"><span>Propositions en ligne</span><b>{liens.length}</b></div>
        <table className="re-table"><tbody>
          {liens.map(l => {
            const ouvrir = () => { if (l.soumission_id) onOpenSubmission(l.soumission_id); };
            return (
              <tr key={l.id} className="sp-fiche-ligne" style={{ cursor: l.soumission_id ? "pointer" : "default" }} tabIndex={0} title={l.soumission_id ? "Ouvrir la soumission" : "Soumission introuvable"} onClick={ouvrir} onKeyDown={clavier(ouvrir)}>
                <td className="nom">
                  <div>Devis nº {l.qbo_doc_number || "?"} <PL.Statut lien={l} compact /></div>
                  <div className="desc">{l.nb_vues > 0 ? `Ouverte ${l.nb_vues} fois, dernière vue le ${f.quand(l.derniere_vue)}` : "Jamais ouverte"} · {decision(l)}</div>
                </td>
                <td className="montant">{l.montant_ttc != null ? f.argent(l.montant_ttc) : ""}</td>
              </tr>
            );
          })}
        </tbody></table>
      </div>
    );
  }

  // ─── Colonne de droite de la fiche : soumissions Raycast, devis et factures QuickBooks (JF, 6 nov. 2026 : « quand je rouvre une
  //     fiche client, je vois pas automatiquement les soumissions qui ont été émises ») ───
  // Lecture seule. Soumissions : table submissions (droits RLS existants, lecture équipe), trouvées par toutes les clés du client :
  // fiche Raycast (client_id), courriel et téléphone copiés dans la soumission, id QuickBooks, liens de proposition en ligne
  // (proposition_liens : qbo_customer_id ou client_key) et devis QuickBooks du client (qbo_estimate_id). Les leads (formulaires web)
  // ne sont pas des soumissions émises : ils restent dans le pipeline. Devis et factures : route /raycast/devis du worker, et leur
  // PDF par la même route (le worker vérifie que le document appartient au client).
  const COLONNE_MAX = 5;
  const COLS_SOUMISSION = "id,number,status,project_type,client_id,client_name,price_total,qbo_estimate_id,qbo_doc_number,pdf_url,finalized_at,created_at,updated_at,courriel:data->client->>email,telephone:data->client->>phone,qbo_client:data->client->>qbo_customer_id,courriel_prepare:data->courriel_prepare->>le,revisions:data->proposition_revisions,lignes:data->lignes,parcours:data->parcours";
  const COLS_LIEN_COLONNE = "id,etat,soumission_id,qbo_estimate_id,qbo_doc_number,qbo_customer_id,client_key,montant_ttc,envoye_le,expire_le,nb_vues,premiere_vue,derniere_vue,decision,decision_le,motif_refus,annule_le,created_at";
  /** « 6 nov. 2026 » à l'heure de Mascouche ; une date QuickBooks seule (« 2026-10-20 ») reste le même jour. */
  const dateJour = (d) => { const s = String(d == null ? "" : d).trim(); const x = DATE_SEULE.test(s) ? new Date(s + "T12:00:00Z") : parseDate(d); return x && !isNaN(x) ? x.toLocaleDateString("fr-CA", { timeZone: TZ, day: "numeric", month: "short", year: "numeric" }) : ""; };
  const valeurOr = (v) => '"' + String(v).replace(/[\\"]/g, "\\$&") + '"';
  // Téléphone écrit de toutes les façons (« +15145551234 », « (514) 555-1234 ») : motif 514%555%1234, vérifié ensuite exactement.
  const motifTel = (k) => `%${k.slice(0, 3)}%${k.slice(3, 6)}%${k.slice(6)}`;
  const tri = (x) => Date.parse(x.created_at || "") || 0;
  /** Soumission bien à ce client (fonction pure, testée) : les requêtes larges (courriel, téléphone) sont revérifiées exactement ici. */
  function soumissionDuClient(s, ctx) {
    if (!s || !s.id || s.status === "lead") return false;
    const cles = ctx.cles || [];
    const c1 = cleDe(s.courriel), c2 = cleTel(s.telephone);
    return !!((ctx.sid && s.client_id === ctx.sid) || (c1 && cles.includes(c1)) || (c2 && cles.includes(c2)) || (ctx.qbo && s.qbo_client != null && String(s.qbo_client) === String(ctx.qbo))
      || (ctx.idsLiens && ctx.idsLiens.has(s.id)) || (s.qbo_estimate_id && (ctx.devisIds || []).includes(String(s.qbo_estimate_id))));
  }
  /** Lien de proposition qui donne le statut : une décision d'abord, sinon le lien actif le plus récent, sinon le plus récent. */
  const lienActif = (l) => !!l && l.etat === "active" && !l.annule_le && (!l.expire_le || Date.parse(l.expire_le) > Date.now());
  const lienPrincipal = (liens) => { const L = (liens || []).slice().sort((a, b) => (Date.parse(b.created_at || "") || 0) - (Date.parse(a.created_at || "") || 0)); return L.find(l => l.decision) || L.find(lienActif) || L[0] || null; };
  /** Statut affiché d'une soumission (fonction pure, testée) : décision du client, proposition consultée, courriel préparé, finalisée, brouillon.
   *  Tons de la palette unique (statuts-re.jsx) ; la relance (orange) et l'expiration (rouge) s'ajoutent par window.StatutsRE.statutSoumission. */
  function statutSoumission(s, lien) {
    if (s.status === "accepte" || (lien && lien.decision === "acceptee")) return { cle: "acceptee", texte: "acceptée", ton: "vert" };
    if (s.status === "refuse" || (lien && lien.decision === "refusee")) return { cle: "refusee", texte: "refusée", ton: "rouge" };
    if (lien && Number(lien.nb_vues) > 0) return { cle: "consultee", texte: "proposition consultée", ton: "bleu" };
    // Envoi réel constaté (worker : brouillon Outlook parti, JF 8 nov. 2026) avant « courriel préparé »
    if (s.status === "envoye" || (lien && lien.envoye_le)) return { cle: "envoyee", texte: "envoyée", ton: "bleu" };
    if (s.courriel_prepare) return { cle: "courriel", texte: "courriel préparé", ton: "bleu" };
    if (s.status === "archive") return { cle: "archivee", texte: "archivée", ton: "gris" };
    if (s.finalized_at || s.qbo_estimate_id) return { cle: "finalisee", texte: "finalisée", ton: "jaune" };
    return { cle: "brouillon", texte: "brouillon", ton: "jaune" };
  }
  const STATUT_DEVIS = { Pending: ["en attente", "orange"], Accepted: ["accepté", "vert"], Closed: ["fermé", "gris"], Converted: ["fermé", "gris"], Rejected: ["refusé", "rouge"] };
  const statutDevis = (d) => { const s = STATUT_DEVIS[d && d.statut]; return s ? { texte: s[0], ton: s[1] } : { texte: d && d.statut ? String(d.statut).toLowerCase() : "statut inconnu", ton: "gris" }; };
  /** PDF archivé de la proposition : la dernière révision, sinon celui de la finalisation (bucket propositions). */
  // ─── État en ligne de chaque soumission de la colonne (JF, 8 nov. 2026 : « je veux voir si elles sont en attente ou consultées.
  //     La consultation, c'est bien important que je sois bien au courant. ») ───
  // Pastille toujours visible : Brouillon (gris), Envoyée, en attente (bleu), Consultée (violet, point animé : aucune réponse encore),
  // Acceptée (vert), Refusée (rouge), Expirée (gris foncé). Base : statutSoumission ci-dessus (décision, vues du lien, courriel
  // préparé, status de la soumission) ; un lien envoyé compte comme envoyé ; expiration comme le Suivi des propositions (expire_le
  // passé sans décision). Dates et heures de Montréal, en français (« 8 nov. à 14 h 32 »).
  const ETATS_LIGNE = { brouillon: "Brouillon", envoyee: "Envoyée, en attente", consultee: "Consultée", acceptee: "Acceptée", refusee: "Refusée", expiree: "Expirée", archivee: "Archivée" };
  const anneeMtl = (x) => x.toLocaleDateString("fr-CA", { timeZone: TZ, year: "numeric" });
  /** « 8 nov. » (année ajoutée si ce n'est pas l'année courante), à l'heure de Montréal. */
  const jourMtl = (d) => { const x = parseDate(d); if (!x) return ""; const j = x.toLocaleDateString("fr-CA", { timeZone: TZ, day: "numeric", month: "short" }); return anneeMtl(x) === anneeMtl(new Date()) ? j : `${j} ${anneeMtl(x)}`; };
  /** « 14 h 32 », « 9 h 05 » à l'heure de Montréal. */
  const heureMtl = (d) => { const x = parseDate(d); if (!x) return ""; const p = new Intl.DateTimeFormat("fr-CA", { timeZone: TZ, hour: "numeric", minute: "2-digit", hourCycle: "h23" }).formatToParts(x); const v = (t) => (p.find(q => q.type === t) || {}).value || ""; return `${Number(v("hour"))} h ${v("minute")}`; };
  const quandMtl = (d) => parseDate(d) ? `${jourMtl(d)} à ${heureMtl(d)}` : "";
  /** Temps écoulé : « moins d'une heure », « 5 h », « 1 jour », « 3 jours ». */
  const depuisMtl = (d, n) => { const t = parseDate(d); if (!t) return ""; const h = Math.max(0, ((n || Date.now()) - t.getTime()) / 3600000); if (h < 1) return "moins d'une heure"; if (h < 24) return `${Math.floor(h)} h`; const j = Math.floor(h / 24); return j === 1 ? "1 jour" : `${j} jours`; };
  /** État affiché d'une soumission (fonction pure, testée) : { cle, libelle, detail, alerte }. */
  function etatLigne(s, lien, maintenant) {
    const n = maintenant || Date.now(), l = lien || null, st = statutSoumission(s || {}, l);
    const vues = l ? Number(l.nb_vues) || 0 : 0;
    const lecture = !l ? "consultation non suivie (sans lien en ligne)" : vues > 0 ? `consultée ${vues} fois` : "jamais ouverte";
    const res = (cle, detail, alerte) => ({ cle, libelle: ETATS_LIGNE[cle], detail: detail || "", alerte: alerte || "" });
    if (st.cle === "acceptee") { const le = (l && l.decision === "acceptee" && l.decision_le) || s.updated_at; return res("acceptee", le ? `Acceptée le ${quandMtl(le)}` : ""); }
    if (st.cle === "refusee") { const le = (l && l.decision === "refusee" && l.decision_le) || s.updated_at; const motif = l && l.motif_refus ? ((window.PropositionLienRE && window.PropositionLienRE.MOTIFS) || {})[l.motif_refus] : ""; return res("refusee", [le ? `Refusée le ${quandMtl(le)}` : "", motif].filter(Boolean).join(" · ")); }
    const expire = l && !l.decision && l.etat !== "annulee" && l.expire_le && Date.parse(l.expire_le) <= n;
    if (expire) return res("expiree", `Expirée le ${jourMtl(l.expire_le)} sans réponse · ${lecture}`);
    if (st.cle === "consultee") {
      const premiere = l.premiere_vue || l.derniere_vue;
      const detail = premiere ? `Consultée le ${quandMtl(premiere)}${vues > 1 ? ` · ${vues} consultations${l.derniere_vue && l.derniere_vue !== premiere ? `, dernière le ${quandMtl(l.derniere_vue)}` : ""}` : ""}` : `${vues} consultation${vues > 1 ? "s" : ""}`;
      return res("consultee", detail, premiere ? `Consultée, sans réponse depuis ${depuisMtl(premiere, n)}` : "Consultée, sans réponse");
    }
    const envoyeLien = l && l.etat !== "annulee" && l.envoye_le;
    if (st.cle === "envoyee" || st.cle === "courriel" || envoyeLien) {
      const le = envoyeLien ? l.envoye_le : st.cle === "courriel" ? s.courriel_prepare : null;
      const quoi = !envoyeLien && st.cle === "courriel" ? "Courriel préparé" : "Envoyée";
      return res("envoyee", `${le ? `${quoi} le ${quandMtl(le)}` : quoi} · ${lecture}`);
    }
    if (st.cle === "archivee") return res("archivee", "Soumission archivée");
    return res("brouillon", st.cle === "finalisee" ? "Finalisée, pas encore envoyée" : "Pas encore envoyée");
  }
  const EtatEnLigne = ({ etat }) => <span className="re-colonne-etat" data-etat={etat.cle} title={[etat.libelle, etat.detail].filter(Boolean).join(" : ")}>{etat.libelle}</span>;
  const pdfArchive = (s) => { const revs = Array.isArray(s.revisions) ? s.revisions.filter(x => x && x.pdf_url) : []; return (revs.length ? revs[revs.length - 1].pdf_url : null) || s.pdf_url || null; };

  /** Lecture d'une requête Supabase sans jamais lever : { ok, lignes } ou { ok: false, erreur }. */
  const lireSb = (fabrique) => Promise.resolve().then(fabrique).then(({ data, error }) => { if (error) throw new Error(error.message || String(error)); return { ok: true, lignes: Array.isArray(data) ? data : [] }; }).catch(e => ({ ok: false, erreur: texte(e) }));

  /** Soumission d'un lien de proposition (fonction pure, testée) : soumission_id, sinon le même devis QuickBooks (qbo_estimate_id,
   *  puis qbo_doc_number). vues : Map id → soumission du client. */
  function rattacherLien(l, vues) {
    if (!l) return null;
    if (l.soumission_id && vues.has(l.soumission_id)) return l.soumission_id;
    if (l.soumission_id) return null; // lien d'une autre soumission
    const S = [...vues.values()];
    const parDevis = l.qbo_estimate_id && S.find(s => s.qbo_estimate_id && String(s.qbo_estimate_id) === String(l.qbo_estimate_id));
    if (parDevis) return parDevis.id;
    const parNumero = l.qbo_doc_number && S.find(s => s.qbo_doc_number && String(s.qbo_doc_number) === String(l.qbo_doc_number));
    return parNumero ? parNumero.id : null;
  }

  async function lireSoumissionsClient({ sid, cles, qbo, devisIds }) {
    const sb = window.RAYCAST_SUPABASE;
    if (!sb) throw new Error("base Raycast non connectée");
    const tels = cles.filter(k => /^\d{10}$/.test(k)), mails = cles.filter(k => k.includes("@"));
    const base = () => sb.from("submissions").select(COLS_SOUMISSION).neq("status", "lead").order("created_at", { ascending: false }).limit(100);
    const conds = [...mails.map(m => `data->client->>email.ilike.${valeurOr(m)}`), ...tels.map(t => `data->client->>phone.ilike.${valeurOr(motifTel(t))}`), ...(qbo ? [`data->client->>qbo_customer_id.eq.${valeurOr(qbo)}`] : [])];
    const [rFiche, rCles, rLq, rLc, rDevis] = await Promise.all([
      sid ? lireSb(() => base().eq("client_id", sid)) : null,
      conds.length ? lireSb(() => base().or(conds.join(","))) : null,
      qbo ? lireSb(() => sb.from("proposition_liens").select(COLS_LIEN_COLONNE).eq("qbo_customer_id", String(qbo)).limit(50)) : null,
      cles.length ? lireSb(() => sb.from("proposition_liens").select(COLS_LIEN_COLONNE).in("client_key", cles).limit(50)) : null,
      devisIds.length ? lireSb(() => base().in("qbo_estimate_id", devisIds)) : null,
    ]);
    // Toutes les lectures de la table submissions en échec : erreur affichée (jamais « Aucune soumission » par erreur)
    const lectures = [rFiche, rCles, rDevis].filter(Boolean);
    if (lectures.length && lectures.every(x => !x.ok)) throw new Error(lectures[0].erreur);
    const liens = new Map();
    for (const r of [rLq, rLc]) if (r && r.ok) for (const l of r.lignes) if (l && l.id) liens.set(l.id, l);
    const idsLiens = new Set([...liens.values()].map(l => l.soumission_id).filter(Boolean));
    const ctx = { sid, cles, qbo, idsLiens, devisIds };
    const vues = new Map();
    for (const r of [rFiche, rCles, rDevis]) if (r && r.ok) for (const s of r.lignes) if (soumissionDuClient(s, ctx)) vues.set(s.id, s);
    // Soumissions connues seulement par un lien de proposition, puis liens des soumissions trouvées (statut vu, accepté, refusé)
    const manquantes = [...idsLiens].filter(id => !vues.has(id));
    if (manquantes.length) { const r = await lireSb(() => base().in("id", manquantes.slice(0, 50))); if (r.ok) for (const s of r.lignes) if (soumissionDuClient(s, ctx)) vues.set(s.id, s); }
    const sansLien = [...vues.keys()].filter(id => ![...liens.values()].some(l => l.soumission_id === id));
    // Liens par soumission_id, sinon par devis QuickBooks (qbo_estimate_id) pour un lien créé sans soumission rattachée
    const devisSansLien = sansLien.map(id => vues.get(id).qbo_estimate_id).filter(Boolean).map(String);
    const [rSid, rEst] = await Promise.all([
      sansLien.length ? lireSb(() => sb.from("proposition_liens").select(COLS_LIEN_COLONNE).in("soumission_id", sansLien.slice(0, 50)).limit(100)) : null,
      devisSansLien.length ? lireSb(() => sb.from("proposition_liens").select(COLS_LIEN_COLONNE).in("qbo_estimate_id", devisSansLien.slice(0, 50)).limit(100)) : null,
    ]);
    for (const r of [rSid, rEst]) if (r && r.ok) for (const l of r.lignes) if (l && l.id) liens.set(l.id, l);
    const parSoumission = {};
    for (const l of liens.values()) { const sid = rattacherLien(l, vues); if (sid) (parSoumission[sid] = parSoumission[sid] || []).push(l); }
    return { lignes: [...vues.values()].sort((a, b) => tri(b) - tri(a)), liens: parSoumission };
  }

  /** Soumissions Raycast du client, chargées dès l'ouverture de la fiche ; relues sans effacer la liste quand les devis QuickBooks arrivent. */
  function useSoumissionsClient(r, devisIds) {
    const [st, setSt] = useState({ etat: "chargement", lignes: [], liens: {}, erreur: "" });
    const sid = (r.sources && r.sources.supabase_id) || null;
    const qbo = (r.sources && r.sources.qbo_id) || null;
    const cles = clesDe(r);
    const cleCles = cles.join(","), cleDevis = devisIds.join(",");
    const deja = useRef(null);
    useEffect(() => { setSt({ etat: "chargement", lignes: [], liens: {}, erreur: "" }); deja.current = null; }, [r.cle]);
    useEffect(() => {
      let alive = true;
      const silencieux = deja.current === r.cle; // 2e lecture (devis QuickBooks arrivés) : la liste reste affichée
      if (!sid && !cles.length && !qbo) { setSt({ etat: "ok", lignes: [], liens: {}, erreur: "" }); deja.current = r.cle; return; }
      lireSoumissionsClient({ sid, cles, qbo, devisIds })
        .then(res => { if (!alive) return; deja.current = r.cle; setSt({ etat: "ok", lignes: res.lignes, liens: res.liens, erreur: "" }); })
        .catch(e => { if (!alive) return; deja.current = r.cle; if (!silencieux) setSt({ etat: "erreur", lignes: [], liens: {}, erreur: "Soumissions indisponibles : " + texte(e) }); });
      return () => { alive = false; };
    }, [r.cle, sid, qbo, cleCles, cleDevis]); // eslint-disable-line
    return st;
  }

  const Pastille = ({ ton, children }) => <span className={"re-colonne-pastille"} data-ton={ton}>{children}</span>;

  function ListeColonne({ id, titre, etat, erreur, lignes, vide, rendre, totalConnu }) {
    const [tout, setTout] = useState(false);
    const vis = tout ? lignes : lignes.slice(0, COLONNE_MAX);
    return (
      <section className="re-colonne-bloc" data-liste={id} aria-busy={etat === "chargement"}>
        <h3 className="re-colonne-titre"><span>{titre}</span>{etat === "ok" && <b>{lignes.length}</b>}</h3>
        {etat === "chargement" && <p className="re-colonne-vide">Chargement…</p>}
        {etat === "erreur" && <p className="re-colonne-erreur" role="alert">{erreur}</p>}
        {etat === "ok" && !lignes.length && <p className="re-colonne-vide">{vide}</p>}
        {etat === "ok" && lignes.length > 0 && <ul className="re-colonne-liste">{vis.map(rendre)}</ul>}
        {etat === "ok" && lignes.length > COLONNE_MAX && <button type="button" className="re-colonne-tout" onClick={() => setTout(v => !v)}>{tout ? "Voir moins" : `Voir tout (${lignes.length})`}</button>}
        {etat === "ok" && totalConnu > lignes.length && lignes.length > 0 && <p className="re-colonne-tronque">{lignes.length} plus récentes sur {totalConnu} (les plus anciennes sont dans QuickBooks)</p>}
      </section>
    );
  }

  /** Colonne de droite (en dessous sur téléphone) : Nouvelle soumission, Soumissions Raycast, Devis QuickBooks, Factures QuickBooks. */
  function ColonneClient({ soum, qbo, onNouvelle, onModifier, onVoir, ouvrirPdf, nbFactures }) {
    const devis = (qbo.devis || []).slice().sort((a, b) => String(b.date || "").localeCompare(String(a.date || "")) || (Number(b.numero) || 0) - (Number(a.numero) || 0));
    const factures = (qbo.factures || []).slice().sort((a, b) => String(b.date || "").localeCompare(String(a.date || "")) || (Number(b.numero) || 0) - (Number(a.numero) || 0));
    return (
      <aside className="re-colonne" aria-label="Soumissions, devis et factures du client">
        <button type="button" className="re-btn primary re-colonne-nouvelle" onClick={onNouvelle}>Nouvelle soumission</button>
        <ListeColonne id="soumissions" titre="Soumissions Raycast" etat={soum.etat} erreur={soum.erreur} lignes={soum.lignes} vide="Aucune soumission"
          rendre={(s) => { const lp = lienPrincipal(soum.liens[s.id]), st = statutSoumission(s, lp), et = etatLigne(s, lp); return (
            <li key={s.id} className="re-colonne-ligne" data-soumission={s.id} data-statut={st.cle} data-etat={et.cle}>
              <button type="button" className="re-colonne-doc" title="Ouvrir la soumission" onClick={() => onModifier(s)}>
                <span className="re-colonne-haut"><b>{s.number ? `nº ${s.number}` : "Sans numéro"}</b><span className="re-colonne-montant">{s.price_total != null && s.price_total !== "" ? fmt(s.price_total) : "montant à calculer"}</span></span>
                <span className="re-colonne-bas"><span>{dateJour(s.created_at)}</span><EtatEnLigne etat={et} /></span>
                {et.detail && <span className="re-colonne-detail">{et.detail}</span>}
                {et.alerte && <span className="re-colonne-alerte">{et.alerte}</span>}
              </button>
              <div className="re-colonne-actions"><button type="button" className="re-btn small" onClick={() => onModifier(s)}>Modifier</button><button type="button" className="re-btn small" title="Proposition : PDF archivé, sinon aperçu de la proposition en ligne, sinon aperçu calculé" onClick={() => onVoir(s, lienPrincipal(soum.liens[s.id]))}>Voir</button></div>
            </li>); }} />
        <ListeColonne id="devis" titre="Devis QuickBooks" etat={qbo.etat} erreur={qbo.erreur} lignes={devis} vide="Aucun devis"
          rendre={(d, i) => { const st = statutDevis(d); return (
            <li key={d.id || d.numero || i} className="re-colonne-ligne"><button type="button" className="re-colonne-doc" title="Ouvrir le PDF du devis" onClick={() => ouvrirPdf("estimate", d.id, `Devis ${d.numero || ""}`)}>
              <span className="re-colonne-haut"><b>Devis nº {d.numero || "?"}</b><span className="re-colonne-montant">{fmt(d.total_ttc)}</span></span>
              <span className="re-colonne-bas"><span>{dateJour(d.date)}</span><Pastille ton={st.ton}>{st.texte}</Pastille></span>
            </button></li>); }} />
        <ListeColonne id="factures" titre="Factures QuickBooks" etat={qbo.etat} erreur={qbo.erreur} lignes={factures} vide="Aucune facture" totalConnu={nbFactures}
          rendre={(f, i) => { const solde = Number(f.solde) || 0; return (
            <li key={f.id || f.numero || i} className="re-colonne-ligne"><button type="button" className="re-colonne-doc" title="Ouvrir le PDF de la facture" onClick={() => ouvrirPdf("invoice", f.id, `Facture ${f.numero || ""}`)}>
              <span className="re-colonne-haut"><b>Facture nº {f.numero || "?"}</b><span className="re-colonne-montant">{fmt(f.total_ttc)}</span></span>
              <span className="re-colonne-bas"><span>{dateJour(f.date)}</span>{solde > 0 ? <Pastille ton="orange">solde {fmt(solde)}</Pastille> : <Pastille ton="vert">payée</Pastille>}</span>
            </button></li>); }} />
      </aside>
    );
  }

  // ─── « Modifier la fiche » (JF, 6 nov. 2026 : « C'est un ou l'autre. Si la fiche est modifiée dans Raycast, elle devient modifiée
  //     dans GHL… un jour, GHL va débarquer. ») ───
  // Conception retenue : table Supabase fiches_clients versionnée (historique complet, cloud/fiches_clients.sql), écriture par le
  // worker seulement (route POST /raycast/fiche à venir) : Raycast d'abord, puis GHL par un adaptateur à liste blanche de champs ;
  // un échec GHL laisse la fiche « à synchroniser » (relance par le worker). Lecture : Raycast, puis GHL, puis QuickBooks.
  // DÉSACTIVÉ tant que la table et la route n'existent pas (GO de JF) : le formulaire s'ouvre, l'enregistrement est bloqué.
  // window.RAYCAST_FICHE_EDITION = true l'active (tests seulement pour l'instant).
  const editionFicheActive = () => window.RAYCAST_FICHE_EDITION === true;
  /** Champs de la fiche (liste blanche, la même que le worker et la contrainte SQL) ; ghl : champ GHL écrit par l'adaptateur. */
  const CHAMPS_FICHE = [
    { k: "nom", lib: "Nom complet", ghl: "firstName + lastName", span: true },
    { k: "telephone", lib: "Téléphone", ghl: "phone", type: "tel" },
    { k: "courriel", lib: "Courriel", ghl: "email", type: "email" },
    { k: "adresse", lib: "Adresse (numéro et rue)", ghl: "address1", span: true },
    { k: "ville", lib: "Ville", ghl: "city" },
    { k: "code_postal", lib: "Code postal", ghl: "postalCode" },
    { k: "province", lib: "Province", ghl: "state" },
    { k: "source", lib: "Source du lead", ghl: "source", liste: true },
    { k: "projet", lib: "Projet", span: true },
    { k: "systeme", lib: "Système", span: true },
    { k: "conso_kwh_an", lib: "Consommation (kWh par année)", ghl: "champ « Consommation HQ annuelle (kWh) »", type: "number" },
    { k: "tarif_hq", lib: "Tarif Hydro-Québec", ghl: "champ « Tarif Hydro-Québec »" },
    { k: "chauffage", lib: "Chauffage", ghl: "champ « Mode de chauffage »" },
    { k: "prochaine_etape", lib: "Prochaine étape", span: true },
    { k: "prochaine_etape_le", lib: "Date de la prochaine étape", type: "date" },
  ];
  const CLES_FICHE = new Set(CHAMPS_FICHE.map(c => c.k));
  /** « 1815 Chem. A, Mascouche, QC J7K 0P2 » → { adresse, ville, province, code_postal } (adresse vérifiée par Google). */
  function decouperAdresse(t) {
    const p = String(t || "").split(",").map(x => x.trim()).filter(Boolean);
    if (p.length && /^(canada|ca)$/i.test(p[p.length - 1])) p.pop();
    const fin = p.length >= 3 ? p[p.length - 1].match(/^([A-Z]{2})\s+([A-Z]\d[A-Z]\s?\d[A-Z]\d)$/i) : null;
    return fin ? { adresse: p.slice(0, -2).join(", "), ville: p[p.length - 2], province: fin[1].toUpperCase(), code_postal: fin[2].toUpperCase() } : { adresse: p.join(", "), ville: "", province: "", code_postal: "" };
  }
  /** Valeurs de départ du formulaire : ce que la fiche affiche (fiche Raycast, puis GHL, puis QuickBooks), nom avec majuscules ;
   *  l'adresse est celle de la carte « Fiche » (même source que Street View). */
  function initialFiche(r, F, fx, pe, R) {
    const v = (k) => { const f = F.find(x => x.cle === k); return f && f.valeur ? f.valeur : ""; };
    const champs = fx || {};
    const kwh = (v("consommation").match(/^([\d\s  ]+)\s*kWh/) || [])[1];
    const ad = adresseFiche(r, R);
    const morceaux = ad.complete && /^(RAYCAST|dite)/.test(ad.source) ? decouperAdresse(ad.texte) : { adresse: r.adresse || "", ville: r.ville || "", code_postal: r.code_postal || "", province: r.province || "" };
    return {
      nom: champs.nom || nomPropre(r.nom || ""), telephone: champs.telephone || (r.telephone == null ? "" : telFmt(r.telephone)), courriel: champs.courriel || r.courriel || "",
      adresse: champs.adresse || morceaux.adresse || "", ville: champs.ville || morceaux.ville || r.ville || "", code_postal: champs.code_postal || morceaux.code_postal || "", province: champs.province || morceaux.province || r.province || "QC",
      source: champs.source || r.source || r.ghl_source || "", projet: champs.projet || v("projet"), systeme: champs.systeme || v("systeme"),
      conso_kwh_an: champs.conso_kwh_an || (kwh ? kwh.replace(/\D/g, "") : ""), tarif_hq: champs.tarif_hq || "", chauffage: champs.chauffage || "",
      // étape écrite (fiche ou résumé IA) seulement : une étape déduite se recalcule toute seule
      prochaine_etape: champs.prochaine_etape || (pe && pe.texte && !pe.source ? pe.texte : ""), prochaine_etape_le: champs.prochaine_etape_le || "",
    };
  }
  function validerFiche(f) {
    const e = {};
    if (!String(f.nom || "").trim()) e.nom = "Le nom est requis.";
    if (String(f.telephone || "").trim() && !telDix(f.telephone)) e.telephone = "Le téléphone doit avoir 10 chiffres.";
    if (String(f.courriel || "").trim() && !COURRIEL_OK.test(String(f.courriel).trim())) e.courriel = "Courriel invalide.";
    if (String(f.conso_kwh_an || "").trim() && !/^\d{1,7}$/.test(String(f.conso_kwh_an).replace(/\s/g, ""))) e.conso_kwh_an = "Un nombre de kWh, sans unité.";
    if (String(f.code_postal || "").trim() && !/^[A-Z]\d[A-Z]\s?\d[A-Z]\d$/i.test(String(f.code_postal).trim())) e.code_postal = "Code postal canadien (ex. J7K 0K8).";
    return e;
  }
  /** Changements seulement (liste blanche) : { cle: nouvelle valeur } ; une valeur vidée devient null. */
  function diffFiche(avant, apres) {
    const d = {};
    for (const k of CLES_FICHE) { const a = String(avant[k] == null ? "" : avant[k]).trim(), b = String(apres[k] == null ? "" : apres[k]).trim(); if (a !== b) d[k] = b === "" ? null : b; }
    return d;
  }
  /** Fiche Raycast (fiches_clients) : lecture seulement quand l'édition est activée (la table n'existe pas encore). */
  async function lireFicheRaycast(cle) {
    if (!editionFicheActive() || !window.RAYCAST_SUPABASE || !cle) return null;
    const r = await lireSb(() => window.RAYCAST_SUPABASE.from("fiches_clients").select("cle,version,champs,sync_ghl,sync_ghl_erreur,sync_ghl_le,maj_le").eq("cle", cle).limit(1));
    return r.ok && r.lignes[0] ? r.lignes[0] : null;
  }
  /** Envoi au worker (POST /raycast/fiche) : { cle, version_attendue, champs, ghl_contact_id, qbo_id, supabase_id }. Le worker écrit la
   *  version dans fiches_clients puis pousse les champs GHL de la liste blanche ; réponse { fiche, sync_ghl, erreur_ghl }. */
  async function enregistrerFicheClient(r, version, champs) {
    if (!editionFicheActive()) throw new Error("enregistrement pas encore activé");
    const s = r.sources || {};
    return workerPost("/raycast/fiche", { cle: r.cle, version_attendue: version || 0, champs, ghl_contact_id: s.ghl_contact_id || null, qbo_id: s.qbo_id || null, supabase_id: s.supabase_id || null });
  }

  function FormFiche({ r, F, pe, R, fiche, onClose, onSaved }) {
    const depart = useMemo(() => initialFiche(r, F, fiche && fiche.champs, pe, R), []); // eslint-disable-line
    const [f, setF] = useState(depart);
    const [erreurs, setErreurs] = useState({});
    const [etat, setEtat] = useState({ occupe: false, message: "", erreur: "" });
    const actif = editionFicheActive();
    useEffect(() => { const k = (e) => { if (e.key === "Escape" && !etat.occupe) onClose(); }; window.addEventListener("keydown", k); return () => window.removeEventListener("keydown", k); }, [etat.occupe]); // eslint-disable-line
    const sources = Array.isArray(window.RE_SOURCES) ? window.RE_SOURCES : [];
    const options = f.source && !sources.some(x => x.id === f.source) ? [{ id: f.source, label: `${libelleSource(f.source)} (valeur actuelle)` }, ...sources] : sources;
    const changes = diffFiche(depart, f);
    const nbChanges = Object.keys(changes).length;
    const versGhl = Object.keys(changes).filter(k => (CHAMPS_FICHE.find(c => c.k === k) || {}).ghl);
    const enregistrer = async () => {
      const e = validerFiche(f); setErreurs(e);
      if (Object.keys(e).length || !nbChanges || etat.occupe) return;
      if (!actif) { setEtat({ occupe: false, message: "", erreur: "Bientôt disponible : rien n'a été enregistré." }); return; }
      setEtat({ occupe: true, message: "", erreur: "" });
      try {
        const j = await enregistrerFicheClient(r, fiche && fiche.version, changes);
        onSaved(j);
      } catch (err) {
        const m = texte(err);
        setEtat({ occupe: false, message: "", erreur: /conflit|version/i.test(m) ? "Quelqu'un a modifié cette fiche entre-temps : ferme et rouvre la fiche, puis recommence." : "Enregistrement impossible : " + m });
      }
    };
    return (
      <div className="re-modal-fond" onMouseDown={ev => { if (ev.target === ev.currentTarget && !etat.occupe) onClose(); }}>
        <div className="re-modal re-client-form fa-form" role="dialog" aria-modal="true" aria-labelledby="fa-form-titre">
          <div className="re-modal-tete">
            <h3 id="fa-form-titre">Modifier la fiche</h3>
            <button type="button" className="re-btn small ghost" onClick={onClose} disabled={etat.occupe}>Fermer</button>
          </div>
          {actif
            ? <p className="re-client-form-aide">Enregistré dans Raycast, puis envoyé à GHL pour les champs marqués GHL. Si GHL ne répond pas, la fiche reste « à synchroniser » et sera renvoyée.</p>
            : <div className="re-alert fa-form-bientot" role="note"><b>Bientôt disponible.</b> L'enregistrement vers Raycast et GHL attend ton GO (table « fiches_clients » et route du serveur). Tu peux préparer les changements ; rien n'est écrit pour l'instant.</div>}
          <form onSubmit={ev => { ev.preventDefault(); enregistrer(); }} noValidate>
            <div className="re-grid2">
              {CHAMPS_FICHE.map(c => (
                <div key={c.k} className={"re-field" + (c.span ? " span" : "")} data-champ={c.k}>
                  <label className="re-field-label" htmlFor={"fa-f-" + c.k}>{c.lib}<span className={"fa-form-dest" + (c.ghl ? " ghl" : "")} title={c.ghl ? `Envoyé à GHL : ${c.ghl}` : "Gardé dans Raycast seulement (aucun champ GHL)"}>{c.ghl ? "Raycast et GHL" : "Raycast"}</span></label>
                  {c.liste
                    ? <select id={"fa-f-" + c.k} value={f[c.k] || ""} onChange={ev => setF(x => ({ ...x, [c.k]: ev.target.value }))}><option value="">Choisir…</option>{options.map(o => <option key={o.id} value={o.id}>{o.label}</option>)}</select>
                    : <input id={"fa-f-" + c.k} type={c.type === "date" ? "date" : c.type === "email" ? "email" : c.type === "tel" ? "tel" : "text"} inputMode={c.type === "number" ? "numeric" : undefined} value={f[c.k] || ""} onChange={ev => setF(x => ({ ...x, [c.k]: ev.target.value }))} aria-invalid={erreurs[c.k] ? "true" : undefined} autoComplete="off" />}
                  {erreurs[c.k] && <span className="re-field-erreur">{erreurs[c.k]}</span>}
                </div>
              ))}
            </div>
            <div className="re-etat fa-form-resume" aria-live="polite">{nbChanges ? `${pluriel(nbChanges, "changement", "changements")}${versGhl.length ? `, dont ${versGhl.length} vers GHL` : ", Raycast seulement"}` : "Aucun changement"}</div>
            {etat.erreur && <div className="re-alert error" role="alert">{etat.erreur}</div>}
            <div className="re-modal-pied">
              <button type="button" className="re-btn" onClick={onClose} disabled={etat.occupe}>Annuler</button>
              <button type="submit" className="re-btn primary" disabled={etat.occupe || !nbChanges || !actif} title={actif ? undefined : "Bientôt disponible : l'enregistrement attend le GO de JF"}>{etat.occupe ? "Un instant…" : "Enregistrer"}</button>
            </div>
          </form>
        </div>
      </div>
    );
  }

  function Fiche({ r, onNewFor, onOpenSubmission, onBack, onModifier, onEnregistrer, message }) {
    const qboId = r.sources && r.sources.qbo_id;
    // Devis et factures QuickBooks : { etat: chargement | ok | erreur } ; une fiche sans client QuickBooks n'en a pas (listes vides)
    const [qbo, setQbo] = useState(() => qboId ? { etat: "chargement" } : { etat: "ok", devis: [], factures: [] });
    const [enreg, setEnreg] = useState({ occupe: false, erreur: "" }); // « Enregistrer dans Raycast » (fiche QuickBooks ou GHL seule)
    const sidFiche = (r.sources && r.sources.supabase_id) || null;
    const enregistrer = async () => {
      if (enreg.occupe || !onEnregistrer) return;
      setEnreg({ occupe: true, erreur: "" });
      try { await onEnregistrer(r); } catch (e) { setEnreg({ occupe: false, erreur: "Enregistrement dans Raycast impossible : " + texte(e) }); }
    };
    // Aperçu de la fiche : résumé du dossier (partagé avec le détail) et étape GHL ; détails et conversations fermés par défaut
    const rs = useResumeDossier(r);
    const etape = useEtapeGhl(r);
    const [details, setDetails] = useState(false);
    useEffect(() => { setDetails(false); }, [r.cle]);
    // Aperçu instantané d'un devis ou d'une facture QuickBooks (PDF), sans quitter la fiche (JF, 5 nov. 2026)
    const [apercu, setApercu] = useState(null);
    useEffect(() => () => { if (apercu && apercu.url && apercu.blob) URL.revokeObjectURL(apercu.url); }, [apercu]);
    const ouvrirPdf = async (type, doc, titre) => {
      if (!qboId || !doc) return;
      setApercu({ titre, occupe: true, attente: "Chargement du PDF QuickBooks…" });
      try {
        const chemin = `${window.CatalogueRE.WORKER_URL}/raycast/devis?customer_id=${encodeURIComponent(qboId)}&pdf=${type}&doc=${encodeURIComponent(doc)}`;
        let t = await jwt(); if (!t) throw new Error("Session expirée, reconnecte-toi");
        let r = await fetch(chemin, { headers: { Authorization: `Bearer ${t}` } });
        if (r.status === 401) { t = await jwt(true); if (t) r = await fetch(chemin, { headers: { Authorization: `Bearer ${t}` } }); }
        if (!r.ok) { const j = await r.json().catch(() => ({})); throw new Error(j.error || `HTTP ${r.status}`); }
        if (!/pdf/i.test(r.headers.get("Content-Type") || "")) throw new Error("aperçu PDF pas encore activé sur le serveur");
        const url = URL.createObjectURL(await r.blob());
        setApercu({ titre, url, blob: true });
      } catch (e) { setApercu({ titre, erreur: texte(e) }); }
    };
    const clavier = (fn) => (e) => { if (e.key === "Enter" || e.key === " ") { e.preventDefault(); fn(); } };
    // Devis et factures QuickBooks et soumissions Raycast se chargent chacun de leur côté, dès l'ouverture : si l'un échoue, les autres s'affichent.
    useEffect(() => {
      let alive = true;
      if (!qboId) { setQbo({ etat: "ok", devis: [], factures: [] }); return; }
      setQbo({ etat: "chargement" });
      worker(`/raycast/devis?customer_id=${encodeURIComponent(qboId)}`)
        .then(d => { if (alive) setQbo({ etat: "ok", devis: Array.isArray(d && d.devis) ? d.devis : [], factures: Array.isArray(d && d.factures) ? d.factures : [] }); })
        .catch(e => { if (alive) setQbo({ etat: "erreur", erreur: "Devis et factures QuickBooks indisponibles : " + texte(e) }); });
      return () => { alive = false; };
    }, [r.cle]); // eslint-disable-line
    const devisIds = qbo.etat === "ok" ? (qbo.devis || []).map(d => d && d.id != null ? String(d.id) : "").filter(Boolean) : [];
    const soum = useSoumissionsClient(r, devisIds);
    const subs = soum.lignes;
    const achats = useAchats(qboId);
    // Fiche Raycast éditée (fiches_clients) : lue seulement quand « Modifier la fiche » est activé ; priorité sur GHL et QuickBooks
    const [ficheRx, setFicheRx] = useState(null);
    const [formFiche, setFormFiche] = useState(false);
    const [msgFiche, setMsgFiche] = useState("");
    useEffect(() => { let alive = true; setFicheRx(null); setFormFiche(false); setMsgFiche(""); lireFicheRaycast(r.cle).then(x => { if (alive) setFicheRx(x); }).catch(() => {}); return () => { alive = false; }; }, [r.cle]);
    const ctx = { liens: soum.liens, achats: achats && !achats.error ? achats : null, devis: qbo.etat === "ok" ? qbo.devis : [], factures: qbo.etat === "ok" ? qbo.factures : [], fiche: ficheRx };
    const nomAffiche = nomPropre((ficheRx && ficheRx.champs && ficheRx.champs.nom) || r.nom || "") || "Sans nom";
    const ficheEnregistree = (j) => {
      setFormFiche(false);
      if (j && j.fiche) setFicheRx(j.fiche);
      setMsgFiche(j && j.sync_ghl === "a_synchroniser" ? `Fiche enregistrée dans Raycast. GHL n'a pas répondu${j.erreur_ghl ? ` (${j.erreur_ghl})` : ""} : la fiche est « à synchroniser » et sera renvoyée.` : j && j.sync_ghl === "sans_ghl" ? "Fiche enregistrée dans Raycast (aucun contact GHL relié)." : "Fiche enregistrée dans Raycast et GHL.");
    };
    // « Voir » une soumission : le PDF archivé de la proposition, sinon l'aperçu de la proposition en ligne active (ne compte pas
    // comme une vue du client), sinon l'aperçu de la proposition calculé depuis la soumission. Rien n'est écrit.
    const voirSoumission = async (s, lien) => {
      const titre = `Proposition ${s.number ? "nº " + s.number : ""}`.trim();
      const pdf = pdfArchive(s);
      if (pdf) {
        setApercu({ titre, occupe: true, attente: "Chargement de la proposition archivée…" });
        try {
          const { data, error } = await window.RAYCAST_SUPABASE.storage.from("propositions").createSignedUrl(pdf, 600);
          if (error || !data || !data.signedUrl) throw new Error((error && error.message) || "PDF archivé introuvable");
          setApercu({ titre, url: data.signedUrl });
        } catch (e) { setApercu({ titre, erreur: texte(e) }); }
        return;
      }
      // Fenêtre ouverte tout de suite (au clic), remplie ensuite : sinon le navigateur bloque la fenêtre surgissante.
      const w = window.open("", "_blank");
      const echec = (e) => { try { if (w) w.close(); } catch (_) {} setApercu({ titre, erreur: texte(e) }); };
      try {
        const PL = window.PropositionLienRE;
        if (lienActif(lien) && PL && PL.lienClient) {
          const j = await PL.lienClient(lien.id);
          if (!j || !(j.url_apercu || j.url)) throw new Error("lien de la proposition introuvable");
          if (w) { w.opener = null; w.location.href = j.url_apercu || j.url; } else window.open(j.url_apercu || j.url, "_blank", "noopener");
          return;
        }
        if (!window.RaycastDB || !window.RaycastDB.getSubmission || !window.PropositionRE || !window.CALC_RE) throw new Error("aperçu de la proposition indisponible ici");
        const row = await window.RaycastDB.getSubmission(s.id);
        const st = row && row.data;
        if (!st || st.data_version !== "re") throw new Error("aperçu indisponible pour cette ancienne soumission : ouvre-la avec « Modifier »");
        let cat = window.CatalogueRE && window.CatalogueRE._cache ? window.CatalogueRE._cache() : null;
        if ((!cat || !cat.byId || !cat.byId.size) && window.CatalogueRE && window.CatalogueRE.load) cat = await window.CatalogueRE.load();
        const html = window.PropositionRE.html({ ...st, quote_id: row.number || st.quote_id }, window.CALC_RE.compute(st, cat));
        if (!w) throw new Error("le navigateur a bloqué la fenêtre de l'aperçu");
        const base = `<base href="${location.origin}${location.pathname.replace(/[^/]*$/, "")}">`;
        w.opener = null; w.document.open(); w.document.write(html.replace("<head>", "<head>" + base)); w.document.close();
      } catch (e) { echec(e); }
    };
    // Maison et Street View : la MÊME adresse que la carte « Fiche » (adresseFiche : Raycast, puis GHL, puis QuickBooks, puis dite dans un échange)
    const adF = adresseFiche(r, rs.R);
    const adresse = adF.complete ? adF.texte : "";
    const adresseDite = /^dite dans/.test(adF.source || "");
    // Maison : coordonnées connues, sinon géocodage automatique de l'adresse (mémorisé dans la fiche RAYCAST si elle existe)
    const [geo, setGeo] = useState({ lat: r.lat || null, lng: r.lng || null, adresse: r.address_full || null, etat: r.lat ? "ok" : "recherche" });
    const [corriger, setCorriger] = useState(false);
    const [adrSaisie, setAdrSaisie] = useState("");
    const memoriser = async (g, texte) => {
      const sid = r.sources && r.sources.supabase_id;
      if (adresseDite) return;   // une adresse dite dans un échange n'est jamais écrite dans la fiche sans confirmation
      if (sid && window.RAYCAST_SUPABASE) { try { await window.RAYCAST_SUPABASE.from("clients").update({ lat: g.lat, lng: g.lng, address_full: g.address_full || texte, address_city: g.address_city || r.ville || null, address_postal: g.address_postal || r.code_postal || null, place_id: g.place_id || null }).eq("id", sid); } catch (e) { /* facultatif */ } }
    };
    useEffect(() => {
      let alive = true;
      setGeo({ lat: r.lat || null, lng: r.lng || null, adresse: r.address_full || null, etat: r.lat ? "ok" : "recherche" });
      if (r.lat && r.lng) return;
      // Google complète l'adresse dès l'ouverture, par le même chemin que le menu déroulant (Places), avec la ville connue en renfort.
      // Il faut au moins un numéro civique : une ville seule donnerait la maison de quelqu'un d'autre.
      const texte = adresse && adresse.length >= 6 && /\d/.test(adresse) ? adresse : "";
      if (!window.GeoRE || !window.GeoRE.resoudreAdresse) { setGeo(g => ({ ...g, etat: "sans_carte" })); return; }
      if (!texte) { setGeo(g => ({ ...g, etat: "absente" })); return; }
      (async () => {
        try {
          const g = await window.GeoRE.resoudreAdresse(texte, { ville: r.ville || null });
          if (!alive) return;
          if (!g || !g.lat) { setGeo(x => ({ ...x, etat: "introuvable" })); return; }
          setGeo({ lat: g.lat, lng: g.lng, adresse: g.address_full || texte, etat: "ok" });
          await memoriser(g, texte);
        } catch (e) { if (alive) setGeo(x => ({ ...x, etat: "introuvable" })); }
      })();
      return () => { alive = false; };
    }, [r.cle, adresse]); // eslint-disable-line   (l'adresse dite dans un échange arrive avec le résumé)
    const choisirAdresse = async (g) => { if (!g || !g.lat) return; setGeo({ lat: g.lat, lng: g.lng, adresse: g.address_full || "", etat: "ok" }); setCorriger(false); await memoriser(g, g.address_full || ""); };
    // Source du lead : exposée par le worker sur les clients unifiés (source RAYCAST, sinon contact GHL, sinon Aircall) ; vide tant qu'elle n'existe pas.
    const prefill = { name: nomPropre(r.nom || ""), email: r.courriel || "", phone: r.telephone == null ? "" : String(r.telephone), address_full: geo.adresse || adresse, address_civic: "", address_street: r.adresse || "", address_city: r.ville || "", address_postal: r.code_postal || "", lat: geo.lat, lng: geo.lng, client_id: r.sources && r.sources.supabase_id || null, qbo_customer_id: qboId || null, ghl_contact_id: r.sources && r.sources.ghl_contact_id || null, source: r.source || r.ghl_source || "" };
    return (
      <div className="re-panel re-fiche">
        <div className="re-panel-head">
          <div><h2>{nomAffiche}</h2><FeuxClient r={r} />{((r.entreprise && r.entreprise !== r.nom) || r.telephone) && <p className="re-sub">{[r.entreprise && r.entreprise !== r.nom ? nomPropre(r.entreprise) : "", telFmt(r.telephone)].filter(Boolean).join(" · ")}</p>}<Badges c={r} />{Number(r.solde) > 0 && <span className="re-chip" style={{ marginLeft: 8, background: "#fee2e2", color: "#991b1b", borderColor: "#fecaca" }}>Solde dû {fmt(r.solde)}</span>}</div>
          <div className="re-actions-right">
            <button className="re-btn" onClick={onBack}>← Clients</button>
            {/* Modifier : un seul bouton, « Modifier la fiche » dans la carte Fiche. Ici seulement la création de la fiche Raycast d'un
                contact QuickBooks ou GHL qui n'en a pas encore (rien n'est modifié dans QuickBooks ni GHL). */}
            {!sidFiche && <button className="re-btn" disabled={enreg.occupe} title="Crée la fiche Raycast de ce contact avec les coordonnées connues ; QuickBooks et GHL ne sont pas modifiés. Ensuite, « Modifier la fiche » devient possible." onClick={enregistrer}>{enreg.occupe ? "Un instant…" : "Créer la fiche Raycast"}</button>}
            {window.SchemaBoutonFicheRE && <window.SchemaBoutonFicheRE prefill={prefill} />}
            <button className="re-btn" title={(r.courriel || r.telephone) ? "Courriel ou texto depuis la messagerie" : "Aucun courriel ni téléphone sur cette fiche"} disabled={!(r.courriel || r.telephone) || !(window.RaycastNav && window.RaycastNav.ouvrirMessagerie)} onClick={() => window.RaycastNav.ouvrirMessagerie({ ghl_contact_id: (r.sources && r.sources.ghl_contact_id) || null, courriel: r.courriel || "", telephone: r.telephone || "", nom: r.nom || "" })}>Écrire</button>
          </div>
        </div>
        {message && <div className="re-alert ok re-fiche-message">{message}</div>}
        {enreg.erreur && <div className="re-alert error">{enreg.erreur}</div>}
        {msgFiche && <div className={"re-alert re-fiche-message" + (/synchroniser/.test(msgFiche) ? "" : " ok")}>{msgFiche}</div>}
        <div className="re-fiche-corps">
        <div className="re-fiche-haut"><ApercuFiche r={r} rs={rs} subs={subs} etape={etape} ctx={ctx} modifierFiche={editionFicheActive()
          ? { action: () => setFormFiche(true), titre: "Modifier les faits de la fiche : Raycast, puis GHL" }
          : sidFiche ? { action: () => onModifier && onModifier(r), titre: "Modifier la fiche Raycast (nom, coordonnées, adresse, source, notes). GHL sera mis à jour quand la synchronisation sera activée." }
          : { desactive: true, titre: "Crée d'abord la fiche Raycast (bouton « Créer la fiche Raycast » en haut)" }} /></div>
        <ColonneClient key={r.cle} soum={soum} qbo={qbo} onNouvelle={() => onNewFor(prefill)} onModifier={(s) => onOpenSubmission(s.id)} onVoir={voirSoumission} ouvrirPdf={ouvrirPdf} nbFactures={Number(r.nb_factures) || 0} />
        <div className="re-fiche-reste">
        {/* Tout le détail reste là, replié : résumé complet, points à vérifier, objections, chronologie, reprise de l'historique, ce que le client a dit */}
        <details className="fa-details" open={details} onToggle={(e) => setDetails(e.currentTarget.open)}>
          <summary><span className="fa-details-titre">Détails et conversations</span><span className="fa-details-aide">résumé complet, échanges, chronologie</span></summary>
          <div className="fa-details-corps">
            <RepriseHistorique c={r} />
            <ResumeDossier c={r} rs={rs} />
            <CeQueLeClientADit c={r} />
          </div>
        </details>
        <div className="re-maison">
          {geo.lat && geo.lng && window.GeoRE
            ? <window.GeoRE.VueAdresse lat={geo.lat} lng={geo.lng} />
            : <div className="re-vue-adresse re-vue-attente"><div className="re-vue-vide">{geo.etat === "recherche" ? "Google cherche la maison…" : geo.etat === "introuvable" ? "Adresse introuvable par Google : clique « Corriger l'adresse » et choisis la suggestion" : geo.etat === "sans_carte" || (geo.lat && !window.GeoRE) ? "Carte Google non chargée sur cette page : Street View et vue satellite indisponibles" : "Aucune adresse complète sur cette fiche : clique « Entrer l'adresse »"}</div><div className="re-vue-vide">Street View et vue satellite s'affichent dès que l'adresse est reconnue</div></div>}
          <div className="re-maison-ligne">
            <b>Maison</b><span>{geo.adresse || adresse || "adresse à obtenir"}</span>
            {geo.lat && <a href={`https://www.google.com/maps/search/?api=1&query=${geo.lat},${geo.lng}`} target="_blank" rel="noopener">Google Maps</a>}
            {geo.lat && <a href={`https://www.google.com/maps/@?api=1&map_action=pano&viewpoint=${geo.lat},${geo.lng}`} target="_blank" rel="noopener">Street View</a>}
            <button className="re-btn small ghost" onClick={() => setCorriger(v => !v)}>{corriger ? "Annuler" : (geo.lat ? "Corriger l'adresse" : "Entrer l'adresse")}</button>
          </div>
          {corriger && window.GeoRE && <div className="re-maison-corriger"><window.GeoRE.AdresseInput value={adrSaisie} onChange={setAdrSaisie} onPick={choisirAdresse} placeholder="Tape la bonne adresse et choisis la suggestion Google" /></div>}
        </div>
        <div className="re-fiche-grid">
          <div>
            <ChezNous a={achats} c={r} />
            <SystemeTesla r={r} />
            <PropositionsClient r={r} onOpenSubmission={onOpenSubmission} clavier={clavier} />
          </div>
          <div>
            <Dossier c={r} />
          </div>
        </div>
        </div>
        </div>
        {formFiche && <FormFiche r={r} F={faitsFiche(r, rs.R, etape, subs, ctx)} pe={prochaineEtape(rs.R, ctx, subs)} R={rs.R} fiche={ficheRx} onClose={() => setFormFiche(false)} onSaved={ficheEnregistree} />}
        {apercu && (
          <div role="dialog" aria-modal="true" aria-label={apercu.titre} onClick={() => setApercu(null)} onKeyDown={(e) => { if (e.key === "Escape") setApercu(null); }}
            style={{ position: "fixed", inset: 0, background: "rgba(12,35,64,.55)", zIndex: 1000, display: "flex", alignItems: "center", justifyContent: "center", padding: 16 }}>
            <div onClick={(e) => e.stopPropagation()} style={{ background: "var(--r26-card, #fff)", borderRadius: 12, width: "min(980px, 100%)", height: "min(92vh, 1200px)", display: "flex", flexDirection: "column", overflow: "hidden", boxShadow: "0 20px 60px rgba(0,0,0,.35)" }}>
              <div style={{ display: "flex", alignItems: "center", gap: 10, padding: "10px 14px", borderBottom: "1px solid var(--r26-line, #e2e8f0)" }}>
                <b style={{ flex: 1 }}>{apercu.titre}</b>
                {apercu.url && <a className="re-btn small" href={apercu.url} target="_blank" rel="noopener noreferrer">Nouvel onglet</a>}
                <button className="re-btn small" autoFocus onClick={() => setApercu(null)}>Fermer</button>
              </div>
              {apercu.occupe && <div style={{ padding: 24 }} className="re-muted">{apercu.attente || "Chargement…"}</div>}
              {apercu.erreur && <div className="re-alert error" role="alert" style={{ margin: 16 }}>Impossible d'ouvrir le document : {apercu.erreur}</div>}
              {apercu.url && <iframe title={apercu.titre} src={apercu.url} style={{ flex: 1, border: 0, width: "100%" }} />}
            </div>
          </div>
        )}
      </div>
    );
  }

  /** Ligne de la liste : partie trouvée mise en évidence ; l'adresse s'affiche quand c'est elle qui correspond. */
  /** Boules de feu du lead d'un contact (cache des leads, leads-re.jsx), ou rien. */
  function FeuxClient({ r }) {
    const S = window.StatutsRE, L = window.LeadsRE;
    if (!S || !S.Feux || !L || !L.scoreContact) return null;
    const sc = L.scoreContact({ ghl_contact_id: r.sources && r.sources.ghl_contact_id, courriel: r.courriel, telephone: r.telephone });
    return sc ? <span className="re-client-feux"><S.Feux r={sc} taille={12} /></span> : null;
  }
  function LigneClient({ r, rq, onOuvrir }) {
    const adr = r.address_full || [r.adresse, r.ville, r.code_postal].filter(Boolean).join(", ");
    const visibles = norm(`${r.nom || ""} ${r.entreprise || ""} ${r.ville || ""} ${r.courriel || ""}`);
    const parAdresse = rq && adr && rq.mots.some(m => visibles.indexOf(m) < 0 && norm(adr).indexOf(m) >= 0) || (rq && adr && rq.chiffres.some(d => (r._t || "").indexOf(d) < 0 && norm(adr).indexOf(d) >= 0));
    const desc = [r.ville, r.courriel, telFmt(r.telephone), parAdresse ? adr : null].filter(Boolean);
    return (
      <tr style={{ cursor: "pointer" }} onClick={() => onOuvrir(r)}>
        <td className="nom"><div><Surligne texte={nomPropre(r.nom) || "Sans nom"} rq={rq} /><FeuxClient r={r} />{r.entreprise ? <span className="re-muted"> · <Surligne texte={r.entreprise} rq={rq} /></span> : null}</div><div className="desc">{desc.map((x, i) => <React.Fragment key={i}>{i ? " · " : ""}<Surligne texte={x} rq={rq} /></React.Fragment>)}</div></td>
        <td className="re-col-src"><Badges c={r} /></td>
        <td className="re-col-maj">{r.derniere_interaction ? <span title="Dernière interaction">{dateFR(r.derniere_interaction)}</span> : null}</td>
        <td className="montant">{Number(r.total_facture_ht) > 0 ? fmt0(r.total_facture_ht) : Number(r.solde) > 0 ? fmt(r.solde) : ""}</td>
      </tr>
    );
  }
  const LigneClientMemo = React.memo(LigneClient);

  function ClientsRE({ onNewFor, onOpenSubmission, clientInitial }) {
    const [cache, setCache] = useState(() => cacheListe);   // liste du cache module (partagée par toute la session)
    const [enMaj, setEnMaj] = useState(() => majEnCours);
    const [err, setErr] = useState(() => (cacheListe ? null : derniereErreur));
    const [, setTic] = useState(0);                           // « il y a n min » avance tout seul
    const leadsV = (window.LeadsRE && window.LeadsRE.useVersion) ? window.LeadsRE.useVersion() : 0;   // boules de feu quand les leads arrivent
    const [avis, setAvis] = useState(null);       // message doux (client demandé introuvable, etc.)
    const [q, setQ] = useState("");
    const [sel, setSel] = useState(null);
    const [filtre, setFiltre] = useState("tous");
    const [remote, setRemote] = useState(null);   // { q, rows } : complément serveur quand la recherche locale trouve moins de 3 contacts
    const [plafond, setPlafond] = useState(PREMIER_LOT); // rendu progressif : 40 lignes tout de suite, 200 à l'image suivante
    const [form, setForm] = useState(null);       // { mode: "creer" | "modifier", initial } : formulaire client ouvert
    const [message, setMessage] = useState(null); // confirmation affichée sur la fiche (création, modification)
    const monte = useRef(true);
    const timer = useRef(null);
    const seqRemote = useRef(0);                  // une réponse serveur tardive n'écrase pas une recherche plus récente (ou effacée)
    const dejaOuvert = useRef(null);              // dernière valeur de clientInitial traitée
    const rows = cache ? cache.rows : null;
    useEffect(() => {
      monte.current = true;
      const suivre = () => { if (!monte.current) return; setCache(cacheListe); setEnMaj(majEnCours); setErr(derniereErreur); };
      abonnes.add(suivre);
      if (!cacheListe && !chargementEnCours) chargerListe(); else suivre();
      const tic = setInterval(() => setTic(x => x + 1), 30000);
      return () => { monte.current = false; abonnes.delete(suivre); clearInterval(tic); clearTimeout(timer.current); seqRemote.current++; };
    }, []);
    const src = filtre === "tous" ? null : SOURCES.find(s => s.k === filtre);
    // Recherche locale à chaque frappe sur l'index précalculé (aucun appel réseau).
    const local = useMemo(() => filtrerClients(rows, q, src && src.test), [rows, q, filtre]); // eslint-disable-line
    // Complément serveur : seulement si moins de 3 résultats locaux après 400 ms sans frappe ; il s'ajoute, il ne remplace jamais.
    useEffect(() => {
      clearTimeout(timer.current);
      const s = q.trim(); const id = ++seqRemote.current;
      if (s.length < 3 || !rows || local.n >= 3) return;
      timer.current = setTimeout(() => worker(`/raycast/clients?q=${encodeURIComponent(s)}`).then(w => { if (id === seqRemote.current && monte.current) setRemote({ q: s, rows: (Array.isArray(w.clients) ? w.clients : []).map(normaliser) }); }).catch(() => {}), 400);
      return () => clearTimeout(timer.current);
    }, [q, local.n, !!rows]); // eslint-disable-line
    const vis = useMemo(() => {
      if (!remote || remote.q !== q.trim() || !remote.rows.length) return local.lignes;
      const deja = new Set(local.lignes.map(r => r.cle));
      const extra = remote.rows.filter(r => !deja.has(r.cle) && (!src || src.test(r)));
      return extra.length ? [...local.lignes, ...extra].slice(0, LIMITE_AFFICHAGE) : local.lignes;
    }, [local, remote, q]); // eslint-disable-line
    // Rendu progressif : à chaque frappe, les 40 premières lignes s'affichent tout de suite, les autres à l'image suivante.
    useEffect(() => {
      if (plafond >= vis.length) return;
      const id = requestAnimationFrame(() => { if (monte.current) setPlafond(LIMITE_AFFICHAGE); });
      return () => cancelAnimationFrame(id);
    }, [vis, plafond]);
    const changerRecherche = (v) => { setPlafond(PREMIER_LOT); setQ(v); };
    const ouvrirRef = useRef(null);
    const ouvrirStable = useRef((r) => ouvrirRef.current(r)).current; // les lignes mémorisées ne se redessinent pas pour un nouveau rappel
    const nTrouves = vis.length > local.lignes.length ? local.n + (vis.length - local.lignes.length) : local.n;
    // Ouverture automatique (clientInitial) : dès que la liste est là, une seule fois par valeur de la prop ; repli sur la table clients pour un id RAYCAST.
    useEffect(() => {
      if (!clientInitial || !rows || dejaOuvert.current === clientInitial) return;
      dejaOuvert.current = clientInitial;
      const ci = typeof clientInitial === "string" ? { supabase_id: clientInitial, cle: clientInitial } : clientInitial;
      const c = trouver(rows, ci);
      if (c) { setAvis(null); setSel(c); return; }
      let alive = true;
      (async () => {
        try {
          if (ci.supabase_id && window.RaycastDB && window.RaycastDB.getClient) {
            const d = await window.RaycastDB.getClient(ci.supabase_id);
            if (!alive) return;
            if (d) { setAvis(null); setSel(depuisSupabase(d)); return; }
          }
        } catch (e) { /* repli ci-dessous */ }
        if (alive) { setSel(null); setAvis("Ce client n'est pas dans le répertoire : cherche-le ci-dessous ou clique « Rafraîchir » pour relire la liste."); }
      })();
      return () => { alive = false; };
    }, [rows, clientInitial]);
    // ─── Création, modification, « Enregistrer dans Raycast » : la liste est mise à jour localement, sans attendre le worker ───
    const placerLigne = (r) => placerDansCache(r);
    const ouvrir = (r) => { setMessage(null); setAvis(null); setSel(r); };
    ouvrirRef.current = ouvrir;
    /** Le worker reconstruit la liste unifiée en arrière-plan (fusion par téléphone ou courriel) ; la fiche ouverte n'attend pas. */
    const reconstruireEnFond = (sid) => {
      rafraichir().then(c => {
        const u = ((c && c.rows) || []).find(x => meme(x.sources && x.sources.supabase_id, sid));
        if (u && monte.current) setSel(s => (s && meme(s.sources && s.sources.supabase_id, sid) ? { ...u, _v: s._v || 0 } : s));
      }).catch(() => {});
    };
    const apresCreation = (ligne) => {
      const r = { ...depuisSupabase(ligne), _v: 0 };
      memoriserLocal(r); placerLigne(r); setForm(null); ouvrir(r);
      setMessage("Client créé dans Raycast. Il sera créé dans QuickBooks au moment du devis.");
      reconstruireEnFond(ligne.id);
    };
    const apresModification = (ligne) => {
      const s = sel; if (!s) { setForm(null); return; }
      const b = depuisSupabase(ligne);
      const r = indexer({ ...s, nom: b.nom, entreprise: b.entreprise, courriel: b.courriel, telephone: b.telephone, adresse: b.adresse, ville: b.ville, code_postal: b.code_postal, address_full: b.address_full, lat: b.lat, lng: b.lng, source: b.source || s.source || null, _v: (s._v || 0) + 1 });
      if (ajoutsLocaux.some(x => meme(x.sources.supabase_id, ligne.id))) memoriserLocal(r);
      placerLigne(r); setForm(null); setSel(r); setMessage("Fiche mise à jour dans Raycast.");
    };
    const ouvrirModification = async (r) => {
      const sid = r.sources && r.sources.supabase_id; if (!sid) return;
      let c = null; try { c = await clientDB.lire(sid); } catch (e) { /* repli sur la fiche affichée */ }
      const b = c || {}; const n = separerNotes(b.notes);
      setForm({ mode: "modifier", initial: {
        id: sid, name: b.name || r.nom || "", entreprise: n.entreprise || r.entreprise || "", phone: b.phone || (r.telephone == null ? "" : String(r.telephone)), email: b.email || r.courriel || "",
        address_full: b.address_full || r.address_full || [r.adresse, r.ville, r.code_postal].filter(Boolean).join(", "), address_civic: b.address_civic || "", address_apt: b.address_apt || "", address_street: b.address_street || (c ? "" : r.adresse || ""),
        address_city: b.address_city || r.ville || "", address_postal: b.address_postal || r.code_postal || "", address_province: b.address_province || "QC",
        lat: b.lat != null ? b.lat : (r.lat || null), lng: b.lng != null ? b.lng : (r.lng || null), place_id: b.place_id || null, source: b.source || sourceLead(r) || "", notes: n.notes || "",
      } });
    };
    /** Fiche QuickBooks ou GHL seule : crée la fiche Raycast avec les champs connus (ou relie celle qui a déjà le même téléphone ou courriel). */
    const enregistrerDansRaycast = async (r) => {
      const t = r.telephone == null ? "" : String(r.telephone);
      const existante = (await clientDB.doublons(t, r.courriel || ""))[0] || null;
      const ligne = existante || await clientDB.creer({
        name: r.nom || "Sans nom", phone: t, email: r.courriel || "",
        address_full: r.address_full || (r.adresse ? [r.adresse, r.ville, r.code_postal].filter(Boolean).join(", ") : ""), address_street: r.adresse || "", address_city: r.ville || "", address_postal: r.code_postal || "",
        lat: r.lat || null, lng: r.lng || null, source: sourceLead(r), notes: joindreNotes(r.entreprise, ""),
      });
      const n = indexer({ ...r, sources: { ...(r.sources || {}), supabase_id: ligne.id }, _v: (r._v || 0) + 1 });
      memoriserLocal(n); placerLigne(n); setSel(n);
      setMessage(existante ? "Fiche Raycast existante reliée (même téléphone ou courriel) : tu peux maintenant la modifier." : "Client enregistré dans Raycast : tu peux maintenant modifier sa fiche. Il sera créé dans QuickBooks au moment du devis.");
      reconstruireEnFond(ligne.id);
    };
    const modal = form && <FormClient mode={form.mode} initial={form.initial} rows={rows} onClose={() => setForm(null)} onSaved={form.mode === "creer" ? apresCreation : apresModification} onOuvrir={(d) => { setForm(null); ouvrir(d); }} />;
    if (sel) return <div className="re-app"><Fiche key={`${sel.cle}:${sel._v || 0}`} r={sel} onNewFor={onNewFor} onOpenSubmission={onOpenSubmission} onBack={() => { setSel(null); setMessage(null); }} onModifier={ouvrirModification} onEnregistrer={enregistrerDansRaycast} message={message} />{modal}</div>;
    const filtresActifs = q.trim().length > 0 || filtre !== "tous";
    const ouvrirPremier = (e) => { if (e.key === "Enter" && vis.length) { e.preventDefault(); ouvrir(vis[0]); } };
    const etat = !rows
      ? (err ? "Liste des clients indisponible" : "Chargement des clients…")
      : `${rows.length.toLocaleString("fr-CA")} ${rows.length > 1 ? "clients" : "client"} · ${enMaj ? "mise à jour…" : `à jour ${ilYa(cache.charge_le)}`}`;
    const aideRafraichir = "Relit la liste des clients (QuickBooks, GHL, Aircall et Raycast) et ajoute tout de suite les clients créés ou modifiés dans Raycast pendant la session. La liste complète est aussi reconstruite par le serveur en arrière-plan.";
    const aideEtat = cache && cache.synced ? `Liste complète reconstruite par le serveur le ${dateHeure(cache.synced)} ; clients Raycast lus en direct.` : undefined;
    return (
      <div className="re-app">
        <div className="re-panel">
          <div className="re-panel-head">
            <div><h2>Clients</h2><p className="re-sub rc-clients-etat" aria-live="polite"><span title={aideEtat}>{etat}</span>{(rows || err) ? <> · <button className="re-link" disabled={enMaj} title={aideRafraichir} onClick={() => rafraichir()}>Rafraîchir</button></> : null}</p></div>
            <div className="re-actions-right">
              <button className="re-btn" onClick={() => setForm({ mode: "creer", initial: depuisRecherche(q) })}>Nouveau client</button>
              <button className="re-btn primary" onClick={() => onNewFor(null)}>Nouvelle soumission</button>
            </div>
          </div>
          {err && <div className="re-alert error">{err}</div>}
          {avis && <div className="re-alert">{avis}</div>}
          <div className="re-clients-bar">
            <input className="re-search" placeholder="Nom, entreprise, téléphone, courriel, ville, adresse…" value={q} onChange={e => changerRecherche(e.target.value)} onKeyDown={ouvrirPremier} autoFocus aria-label="Rechercher un client (Entrée ouvre le premier résultat)" />
            <div className="re-chips">
              {[{ k: "tous", label: "Tous" }, ...SOURCES.map(s => ({ k: s.k, label: s.label }))].map(f => <button key={f.k} className={"re-chip" + (filtre === f.k ? " on" : "")} onClick={() => { setPlafond(PREMIER_LOT); setFiltre(f.k); }}>{f.label}</button>)}
            </div>
          </div>
          {rows && filtresActifs && <p className="re-muted rc-clients-compteur">{nTrouves > vis.length ? `${vis.length} premiers sur ${nTrouves.toLocaleString("fr-CA")} résultats, précise la recherche` : pluriel(nTrouves, "résultat", "résultats")}{vis.length ? " · Entrée ouvre le premier" : ""}</p>}
          <table className="re-table re-clients">
            <tbody>
              {vis.slice(0, plafond).map((r, idx) => <LigneClientMemo key={r.cle || idx} r={r} rq={local.rq} onOuvrir={ouvrirStable} leadsV={leadsV} />)}
              {rows && !vis.length && <tr><td className="nom re-muted" colSpan="4">{filtresActifs ? <>Aucun client ne correspond. <button className="re-link" onClick={() => { setQ(""); setFiltre("tous"); }}>Effacer la recherche et les filtres</button></> : (err ? "Liste indisponible pour le moment." : "Aucun client dans le répertoire pour l'instant.")}</td></tr>}
            </tbody>
          </table>
          {!filtresActifs && rows && rows.length > vis.length && <p className="re-muted" style={{ marginTop: 8 }}>{vis.length} premiers affichés, précise la recherche.</p>}
        </div>
        {modal}
      </div>
    );
  }

  // Fonctions partagées avec les autres listes (Leads, Soumissions, Pipelines) : une seule mise en majuscules, un seul statut
  if (window.StatutsRE && window.StatutsRE.enregistrer) window.StatutsRE.enregistrer({ nomPropre, libelleSource, statutSoumission, statutDevis });
  ClientsRE.precharger = precharger;
  ClientsRE.faitsFiche = faitsFiche;   // faits clés de l'aperçu (tests)
  ClientsRE.fiche = { nomPropre, libelleSource, equipementDe, equipementFacture, adresseFiche, prochaineEtape, resumeBref, miseAJourBref, facturesClient, dateDansTexte, diffFiche, validerFiche, decouperAdresse, CHAMPS_FICHE: CHAMPS_FICHE.map(c => c.k), editionFicheActive };   // haut de la fiche (tests)
  ClientsRE.colonne = { statutSoumission, soumissionDuClient, statutDevis, dateJour, lienPrincipal, etatLigne, rattacherLien, quandMtl };   // colonne de droite de la fiche (tests)
  ClientsRE.rafraichir = rafraichir;
  window.ClientsRE = ClientsRE;
  // Accès direct au cache (la coquille ou un test peut envelopper window.ClientsRE) : précharge, rafraîchissement, mesure du filtre.
  window.ClientsCache = { precharger, rafraichir, filtrer: (q, rows) => filtrerClients(rows || (cacheListe ? cacheListe.rows : []), q), etat: () => ({ charge: !!cacheListe, lignes: cacheListe ? cacheListe.rows.length : 0, enCours: majEnCours, charge_le: cacheListe ? cacheListe.charge_le : null, synced: cacheListe ? cacheListe.synced : null }), dernierFiltreMs: null };
})();
