// messagerie-re.jsx — Messagerie Raycast, phase 2 (écriture) : un vrai CRM.
// Colonne de gauche : conversations (GHL + contacts avec courriels ou SMS Aircall), pastille de canal, non lus, filtres, recherche.
// Centre : fil unifié d'un contact (SMS et courriels GHL, SMS Aircall, courriels Microsoft 365, appels Aircall), bulles par direction.
// Bas : composeur avec choix du canal (Courriel avec la signature de l'utilisateur connecté, SMS GHL, SMS Aircall).
// Contrat relais (JWT, voir cloud/proxy.jsx) :
//   GET  /raycast/proxy?worker=ghl&path=/conversations/fil&contact_id=&email=&phone= → { ok, messages[], contact, canaux_disponibles }
//   POST /raycast/proxy { worker: "ghl", path: "/conversations/envoyer", body: { contact_id, canal, texte, html?, sujet?, de?, aircall_number_id?, en_reponse_a? } }
//        → { ok, canal, id, quand } ou { ok: false, erreur }
//   Repli : si le fil unifié n'est pas encore servi par le relais, le fil GHL seul (/conversations/messages) est affiché, envoi désactivé.
// Temps réel (JF, 5 nov. 2026 : « un SMS, je texte et ça rentre ») : Supabase Realtime sur public.interactions (INSERT et UPDATE,
//   filtre client_key = téléphone 10 chiffres et courriel du contact ouvert ; un seul canal par conversation) : la bulle s'ajoute
//   tout de suite, la colonne de gauche aussi, puis le fil complet est relu en arrière-plan. Canal « liste » (INSERT entrants) pour
//   les autres conversations. Secours : fil relu toutes les 5 s (onglet visible), liste toutes les 30 s, après un envoi à 1 s puis 4 s.
// Props : profile (name, phone, email_signature), user (email), contactInitial ({ ghl_contact_id?, courriel?, telephone?, nom }, depuis la fiche client).
// Exposé : window.MessagerieRE
(function () {
  const { useState, useEffect, useMemo, useRef, useCallback } = React;
  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 LOC = "Ey6SB5epk8GFGgL5BfhX";
  const SMS_MAX = 1600;
  const CANAUX_GHL = { TYPE_PHONE: "sms", TYPE_SMS: "sms", TYPE_EMAIL: "courriel", TYPE_WHATSAPP: "chat", TYPE_FB_MESSENGER: "chat", TYPE_FACEBOOK: "chat", TYPE_INSTAGRAM: "chat", TYPE_GMB: "chat", TYPE_WEBCHAT: "chat", TYPE_LIVE_CHAT: "chat", TYPE_CALL: "appel", TYPE_REVIEW: "chat" };
  const LIBELLES = { sms: "SMS", courriel: "Courriel", chat: "Chat", appel: "Appel", ghl_sms: "SMS GHL", ghl_email: "Courriel GHL", ghl_chat: "Chat", aircall_sms: "SMS Aircall", aircall: "SMS Aircall" };
  const FILTRES = [["tous", "Tous"], ["sms", "SMS"], ["courriel", "Courriels"], ["chat", "Chat"], ["appel", "Appels"]];
  // Catégorie d'un type GHL (liste de gauche) ou d'un canal du fil unifié
  const categorie = (t) => { const k = String(t || ""); if (CANAUX_GHL[k]) return CANAUX_GHL[k]; if (/sms/i.test(k)) return "sms"; if (/email|courriel/i.test(k)) return "courriel"; if (/call|appel/i.test(k)) return "appel"; return "chat"; };
  const libelleCanal = (c) => LIBELLES[c] || LIBELLES[categorie(c)] || "Message";
  const parseDate = (v) => { if (v == null || v === "") return null; const s = String(v).trim(); const d = new Date(typeof v === "number" || /^\d{12,}$/.test(s) ? Number(v) : s); return isNaN(d) ? null : d; };
  const jourTZ = (d) => d.toLocaleDateString("fr-CA", { timeZone: TZ });
  const quand = (v) => { const d = parseDate(v); if (!d) return ""; const meme = jourTZ(d) === jourTZ(new Date()); return d.toLocaleString("fr-CA", meme ? { timeZone: TZ, hour: "2-digit", minute: "2-digit" } : { timeZone: TZ, day: "numeric", month: "short", hour: "2-digit", minute: "2-digit" }); };
  const quandLong = (v) => { const d = parseDate(v); return d ? d.toLocaleString("fr-CA", { timeZone: TZ, weekday: "long", day: "numeric", month: "long", year: "numeric", hour: "2-digit", minute: "2-digit" }) : ""; };
  const ts = (v) => { const d = parseDate(v); return d ? d.getTime() : 0; };
  const nettoie = (s) => String(s || "").replace(/<style[\s\S]*?<\/style>/gi, " ").replace(/<script[\s\S]*?<\/script>/gi, " ").replace(/<br\s*\/?>/gi, "\n").replace(/<\/p>/gi, "\n").replace(/<[^>]+>/g, " ").replace(/&nbsp;/g, " ").replace(/&amp;/g, "&").replace(/&lt;/g, "<").replace(/&gt;/g, ">").replace(/[ \t]+/g, " ").replace(/\n\s*\n+/g, "\n").trim();
  // HTML d'un courriel, assaini : plus de scripts, de styles, d'événements ni de formulaires ; liens en nouvel onglet.
  const assainir = (html) => String(html || "").replace(/<(script|style|iframe|object|embed|form)[^>]*>[\s\S]*?<\/\1\s*>/gi, "").replace(/<\/?(script|style|iframe|object|embed|form|link|meta)[^>]*>/gi, "").replace(/\son\w+\s*=\s*("[^"]*"|'[^']*'|[^\s>]+)/gi, "").replace(/javascript:/gi, "").replace(/<a\s/gi, '<a target="_blank" rel="noopener" ');
  const echappe = (s) => String(s || "").replace(/[&<>"]/g, c => ({ "&": "&amp;", "<": "&lt;", ">": "&gt;", '"': "&quot;" }[c]));
  const tel10 = (p) => String(p || "").replace(/\D/g, "").slice(-10);
  const nomDe = (c) => (c && (c.fullName || c.contactName || c.nom)) || "Sans nom";
  const extraire = (r) => { const m = r && r.messages; if (Array.isArray(m)) return m; if (m && Array.isArray(m.messages)) return m.messages; return []; };
  const CACHE_MS = 60000;
  let cacheConvs = null; // { at, convs }
  const FIL_MS = 5000, LISTE_MS = 30000, GARDE_DIRECT_MS = 120000;
  const ongletVisible = () => typeof document === "undefined" || document.visibilityState !== "hidden";
  const normTexte = (t) => String(t || "").replace(/\s+/g, " ").trim().toLowerCase().slice(0, 200);
  // « [2026-11-05 10:00] Client (SMS GHL) : texte » ou « [...] Raycom (x, courriel) [Re : Sujet] : texte » → « texte »
  const sansPrefixe = (t) => String(t || "").replace(/^\[[^\]]*\][^\[:]*(\[[^\]]*\])?\s*:\s*/, "").trim();
  const statutDe = (brut) => { const s = String(brut || "").toLowerCase().trim(); if (!s) return ""; if (/read|opened|seen|\blu\b/.test(s)) return "lu"; if (/deliver|livr/.test(s)) return "livré"; if (/fail|undeliver|error|bounce|rejected|échec|echec/.test(s)) return "échec"; if (/pending|queued|scheduled|sending|attente/.test(s)) return "en attente"; if (/sent|envoy|ok|success|completed/.test(s)) return "envoyé"; return s.slice(0, 30); };
  /** Interaction Supabase reçue par Realtime → message du fil (mêmes id que le fil unifié du worker). */
  function messageDeInteraction(i) {
    if (!i || !i.source_id) return null;
    const b = i.brut || {}; const c = String(b.canal || ""); const sid = String(i.source_id);
    let canal;
    if (i.source === "aircall") canal = /sms/i.test(c) ? "aircall_sms" : "appel";
    else if (i.source === "ghl") canal = /courriel|email/i.test(c) ? "ghl_email" : "ghl_sms";
    else if (i.source === "email") canal = "courriel";
    else return null;
    const sortant = i.direction === "sortant";
    let texte = canal === "appel" ? (String(i.resume || "").trim() || "Appel " + (sortant ? "sortant" : "entrant")) : sansPrefixe(i.transcript || i.resume);
    if (!texte) return null;
    const id = i.source === "ghl" && /^ghl:/.test(sid) ? sid.slice(4) : canal === "appel" ? "appel:" + sid : sid;
    return { id, canal, direction: sortant ? "sortant" : "entrant", quand: i.started_at || new Date().toISOString(), sujet: b.sujet || "", texte, pieces_jointes: [], statut: statutDe(b.status) || (sortant ? "envoyé" : ""), auteur: sortant ? (b.auteur || b.user || undefined) : undefined, source_id: sid, direct: true, recu: Date.now() };
  }
  /** Même message ? (id, ou même famille de canal, même direction, même texte à moins de 2 min) */
  const memeMessage = (a, b) => !!(a && b && ((a.id && a.id === b.id) || (a.source_id && a.source_id === b.source_id) || (categorie(a.canal) === categorie(b.canal) && a.direction === b.direction && normTexte(a.texte) === normTexte(b.texte) && Math.abs(ts(a.quand) - ts(b.quand)) < 120000)));
  /** Fil relu du serveur + messages locaux encore utiles : envois en cours ou en échec, messages reçus en direct ou envoyés d'ici
   *  depuis moins de 2 min que le serveur ne montre pas encore (cache, délai de GHL). */
  function fusionLocale(serveur, anciens) {
    const garde = (anciens || []).filter(m => (m.erreur || m.enCours || ((m.direct || m.local) && Date.now() - (m.recu || 0) < GARDE_DIRECT_MS)) && !serveur.some(x => memeMessage(x, m)));
    return garde.length ? [...serveur, ...garde].sort((a, b) => ts(a.quand) - ts(b.quand)) : serveur;
  }

  /** Signature de l'utilisateur connecté : profil (signature courriel, nom, téléphone) ou signature Raycom par défaut. */
  function signatureDe(profile, user) {
    const p = profile || {}; const courriel = (user && user.email) || p.email || "";
    const brute = String(p.email_signature || "").trim();
    if (brute) return { texte: nettoie(brute) || brute, html: /<[a-z][\s\S]*>/i.test(brute) ? assainir(brute) : echappe(brute).replace(/\n/g, "<br>") };
    const lignes = [p.name || courriel || "Raycom Électrique", "Raycom Électrique inc.", p.phone ? `Tél. : ${p.phone}` : "Tél. : 450 474-8470", courriel, "www.raycomelectrique.com"].filter(Boolean);
    return { texte: lignes.join("\n"), html: lignes.map(echappe).join("<br>") };
  }
  const htmlCourriel = (texte, sig) => `<div style="font-family:Arial,Helvetica,sans-serif;font-size:14px;line-height:1.5;color:#1e293b"><div style="white-space:pre-wrap">${echappe(texte)}</div><br><div class="signature" style="color:#334155">${sig.html}</div></div>`;
  // Normalisation du fil GHL seul (repli quand le relais ne sert pas encore /conversations/fil)
  const normaliserGhl = (msgs) => msgs.filter(m => m && !/ACTIVITY/.test(String(m.messageType || m.type || ""))).map(m => {
    const cat = categorie(m.messageType || m.type);
    return { id: m.id, canal: cat === "courriel" ? "ghl_email" : cat === "sms" ? "ghl_sms" : cat === "appel" ? "appel" : "ghl_chat", direction: m.direction === "inbound" ? "entrant" : "sortant", quand: m.dateAdded, sujet: m.subject || "", texte: nettoie(m.body), html: null, pieces_jointes: (Array.isArray(m.attachments) ? m.attachments : []).map((u, i) => (typeof u === "string" ? { nom: `pièce jointe ${i + 1}`, url: u } : u)), statut: m.status || "", source_id: m.id };
  });
  const entreeDe = (c) => ({ cle: c.id, convId: c.id, contactId: c.contactId || "", courriel: c.email || "", telephone: c.phone || "", nom: nomDe(c), derniere: c.lastMessageDate, type: c.lastMessageType || c.type, apercu: nettoie(c.lastMessageBody), nonLus: Number(c.unreadCount) || 0 });

  /** Un message du fil unifié. */
  function initialesDe(nom) { const mots = String(nom || "").trim().split(/\s+/).filter(Boolean); if (!mots.length) return ""; if (mots.length === 1) return mots[0].split("-").map(x => x[0]).join("").slice(0, 2).toUpperCase(); return (mots[0][0] + mots[mots.length - 1][0]).toUpperCase(); }
  function Bulle({m, ouvert, onToggle, nomClient }) {
    const client = m.direction === "entrant";
    const cat = categorie(m.canal);
    const courriel = cat === "courriel";
    const pj = Array.isArray(m.pieces_jointes) ? m.pieces_jointes : [];
    const texte = m.texte || "";
    const long = courriel && texte.length > 280;
    return (
      <div className={"re-bulle " + (client ? "client" : "raycom") + (m.enCours ? " encours" : "") + (m.erreur ? " erreur" : "") + (cat === "appel" ? " appel" : "")}>
        {courriel && <div className="re-bulle-sujet">{m.sujet ? nettoie(m.sujet) : "(sans sujet)"}</div>}
        {cat === "appel" ? <div className="re-bulle-texte">📞 {texte || "Appel"}</div>
          : ouvert && m.html ? <div className="re-bulle-html" dangerouslySetInnerHTML={{ __html: assainir(m.html) }} />
          : <div className="re-bulle-texte">{long && !ouvert ? texte.slice(0, 280) + "…" : texte}</div>}
        {courriel && (long || m.html) && <button type="button" className="re-link re-bulle-plus" onClick={onToggle}>{ouvert ? "Réduire" : "Afficher le courriel complet"}</button>}
        {pj.length > 0 && <div className="re-bulle-pj">{pj.map((u, i) => <a key={i} href={(u && u.url) || "#"} target="_blank" rel="noopener">{(u && u.nom) || `pièce jointe ${i + 1}`}</a>)}</div>}
        <div className="re-bulle-meta" title={quandLong(m.quand)}>
          {client
            ? <><span className="re-msg-avatar client" title={nomClient || "Client"}>{initialesDe(nomClient) || "C"}</span>{nomClient || "Client"}</>
            : <><span className="re-msg-avatar" title={m.auteur || "Raycom"}>{m.auteur_initiales || initialesDe(m.auteur) || <EclairRaycom size={10} />}</span>{m.auteur || "Raycom"}</>} · {libelleCanal(m.canal)}{courriel && m.de && !client ? ` · ${m.de}` : ""} · {quand(m.quand)}
          {client
            ? (m.statut === "lu" ? <span className="re-msg-statut lu" title="Lu par toi"> · lu</span> : null)
            : m.enCours ? <span className="re-msg-statut"> · ⏳ envoi en cours…</span>
            : m.erreur ? <span className="re-msg-statut echec"> · ✗ échec : {m.erreur}</span>
            : m.statut === "lu" ? <span className="re-msg-statut lu" title="Lu par le client"> · ✓✓ lu</span>
            : m.statut === "livré" ? <span className="re-msg-statut livre" title="Livré au client"> · ✓✓ livré</span>
            : m.statut === "échec" ? <span className="re-msg-statut echec" title="Non livré"> · ✗ non livré</span>
            : m.statut === "en attente" ? <span className="re-msg-statut" title="En attente chez le fournisseur"> · ⏳ en attente</span>
            : m.statut ? <span className="re-msg-statut" title="Envoyé"> · ✓ {m.statut}</span> : null}
        </div>
      </div>
    );
  }

  function MessagerieRE({ profile, user, contactInitial }) {
    const [convs, setConvs] = useState(() => (cacheConvs && Date.now() - cacheConvs.at < CACHE_MS) ? cacheConvs.convs : null);
    const [etat, setEtat] = useState({ loading: !convs });
    const [extras, setExtras] = useState([]);        // contacts ouverts sans conversation GHL (fiche client, courriels seuls)
    const [sel, setSel] = useState(null);           // clé de la conversation choisie
    const [fil, setFil] = useState({});             // clé → { loading, err, messages, contact, canaux, repli }
    const [q, setQ] = useState("");
    const [filtre, setFiltre] = useState("tous");
    const [ouverts, setOuverts] = useState({});     // courriels dépliés
    const [mobileFil, setMobileFil] = useState(false);
    const [canal, setCanal] = useState("ghl_sms");
    const [texte, setTexte] = useState("");
    const [sujet, setSujet] = useState("");
    const [de, setDe] = useState("");
    const [numAircall, setNumAircall] = useState("");
    const [envoi, setEnvoi] = useState({});          // { loading, err, ok }
    const [voirSignature, setVoirSignature] = useState(false);
    const [direct, setDirect] = useState(null);      // null : temps réel indisponible ; true : en direct ; false : reconnexion
    const filRef = useRef(null);
    const monte = useRef(true);
    const enVol = useRef({});                         // rechargements de fond en cours, par conversation
    const selRef = useRef(null); selRef.current = sel;
    const filEtat = useRef(fil); filEtat.current = fil;
    useEffect(() => { monte.current = true; return () => { monte.current = false; }; }, []);
    const sig = useMemo(() => signatureDe(profile, user), [profile, user]);

    const chargerListe = async (refresh, fond) => {
      if (!refresh && cacheConvs && Date.now() - cacheConvs.at < CACHE_MS) { setConvs(cacheConvs.convs); setEtat({}); return; }
      if (!fond) setEtat({ loading: true });
      try {
        if (!window.RaycastProxy) throw new Error("relais indisponible");
        const r = await window.RaycastProxy.fetch("ghl", "/conversations", { limit: 50 }, { refresh: !!refresh });
        const liste = (Array.isArray(r && r.conversations) ? r.conversations : []).filter(c => c && c.id);
        cacheConvs = { at: Date.now(), convs: liste };
        if (monte.current) { setConvs(liste); setEtat({}); }
      } catch (e) { if (monte.current && !fond) setEtat({ err: String(e.message || e) }); }
    };
    useEffect(() => { chargerListe(false); }, []); // eslint-disable-line

    /** Charge le fil unifié d'une entrée (conversation GHL ou contact seul). fond = rechargement silencieux (minuterie, temps réel,
     *  après un envoi) : pas de « Chargement… », pas de changement de sélection, fil gardé si la relecture échoue. */
    const ouvrir = useCallback(async (item, refresh, fond) => {
      const cle = item.cle;
      if (!fond) { setSel(cle); setMobileFil(true); setEnvoi({}); }
      const courant = filEtat.current[cle];
      if (!fond && !refresh && courant && !courant.err && !courant.loading) return;
      if (fond) { if (enVol.current[cle] || !courant || courant.loading) return; enVol.current[cle] = true; }
      else setFil(f => ({ ...f, [cle]: { ...(f[cle] || {}), loading: true, err: null } }));
      try {
        if (!window.RaycastProxy) throw new Error("relais indisponible");
        let data = null, repli = false;
        try {
          const r = await window.RaycastProxy.fetch("ghl", "/conversations/fil", { contact_id: item.contactId || "", email: item.courriel || "", phone: item.telephone || "" }, { refresh: !!refresh });
          if (r && r.ok !== false && Array.isArray(r.messages)) data = r;
          else throw new Error((r && (r.erreur || r.error)) || "fil indisponible");
        } catch (e) {
          // Relais pas encore à jour (chemin non permis, 400, 404) ou fil unifié en panne : fil GHL seul, lecture seule, si la conversation GHL existe.
          if (!item.convId) throw e;
          repli = true;
        }
        if (!data && item.convId) {
          const r = await window.RaycastProxy.fetch("ghl", "/conversations/messages", { conversation_id: item.convId, limit: 100 }, { refresh: !!refresh });
          const f = (Array.isArray(r && r.fils) ? r.fils : [])[0] || {};
          data = { messages: normaliserGhl(extraire(f)), contact: { id: item.contactId, nom: item.nom, telephone: item.telephone, courriel: item.courriel }, canaux_disponibles: null };
        }
        const messages = (data.messages || []).slice().sort((a, b) => ts(a.quand) - ts(b.quand));
        if (monte.current) setFil(x => ({ ...x, [cle]: { messages: fusionLocale(messages, x[cle] && x[cle].messages), contact: data.contact || {}, canaux: data.canaux_disponibles || null, repli } }));
      } catch (e) {
        if (monte.current) setFil(x => (fond && x[cle] && x[cle].messages ? x : { ...x, [cle]: { err: "Fil indisponible (" + String(e.message || e) + ")" } }));
      } finally { if (fond) enVol.current[cle] = false; }
    }, []);

    // Contact demandé depuis la fiche client : conversation GHL existante, sinon entrée ajoutée en tête de liste ; ouvert dans les deux cas.
    useEffect(() => {
      if (!contactInitial || convs === null) return;
      const ci = contactInitial;
      const t = tel10(ci.telephone), em = String(ci.courriel || "").toLowerCase();
      const existante = convs.find(c => (ci.ghl_contact_id && c.contactId === ci.ghl_contact_id) || (em && String(c.email || "").toLowerCase() === em) || (t.length === 10 && tel10(c.phone) === t));
      if (existante) { ouvrir(entreeDe(existante), false); return; }
      const e = { cle: "c:" + (ci.ghl_contact_id || em || t || ci.nom || "contact"), contactId: ci.ghl_contact_id || "", courriel: ci.courriel || "", telephone: ci.telephone || "", nom: ci.nom || "Contact", extra: true, derniere: null, type: "" };
      setExtras(x => (x.some(y => y.cle === e.cle) ? x : [e, ...x]));
      ouvrir(e, false);
    }, [contactInitial, convs === null]); // eslint-disable-line

    // Défilement : en bas à l'ouverture, et à l'arrivée d'un message si on était déjà en bas (les relectures de fond ne font pas sauter le fil).
    // Ouverture d'une conversation (JF, 6 nov. 2026 : « toujours m'amener au bas ») : on descend tout en bas à l'ouverture ET à
    // l'arrivée des premiers messages (ils se chargent après l'ouverture), puis encore après le rendu des images et des pièces jointes.
    const defil = useRef({ sel: null, n: 0 });
    useEffect(() => {
      const el = filRef.current; const n = sel && fil[sel] && fil[sel].messages ? fil[sel].messages.length : 0; const d = defil.current;
      const ouverture = d.sel !== sel || (d.n === 0 && n > 0);
      const enBas = () => { const e = filRef.current; if (e) e.scrollTop = e.scrollHeight; };
      if (el && (ouverture || (n > d.n && el.scrollHeight - el.scrollTop - el.clientHeight < 400))) {
        enBas();
        if (ouverture && n > 0) { requestAnimationFrame(enBas); const t1 = setTimeout(enBas, 250), t2 = setTimeout(enBas, 900); defil.current = { sel, n }; return () => { clearTimeout(t1); clearTimeout(t2); }; }
      }
      defil.current = { sel, n };
    }, [sel, fil]);
    const entrees = useMemo(() => [...extras, ...(convs || []).map(entreeDe)], [convs, extras]);
    const visibles = useMemo(() => {
      const s = q.trim().toLowerCase();
      return entrees.filter(c => (filtre === "tous" || c.extra || categorie(c.type) === filtre) && (!s || `${c.nom} ${c.apercu || ""} ${c.courriel || ""}`.toLowerCase().includes(s)));
    }, [entrees, q, filtre]);
    const item = sel ? entrees.find(c => c.cle === sel) : null;
    const itemRef = useRef(null); itemRef.current = item;
    // Secours du temps réel : fil ouvert relu toutes les 5 s (cache du worker de 5 s), liste toutes les 30 s, sauf onglet caché.
    useEffect(() => {
      if (!item) return;
      const t1 = setInterval(() => { if (ongletVisible() && monte.current && itemRef.current) ouvrir(itemRef.current, false, true); }, FIL_MS);
      return () => clearInterval(t1);
    }, [item && item.cle]); // eslint-disable-line
    useEffect(() => {
      const t2 = setInterval(() => { if (ongletVisible() && monte.current) chargerListe(true, true); }, LISTE_MS);
      return () => clearInterval(t2);
    }, []); // eslint-disable-line
    const f = sel ? fil[sel] : null;
    const contact = (f && f.contact) || {};

    /** Message reçu en direct : ajouté au fil (ou fusionné : statut, texte d'un appel résumé, écho d'un envoi fait d'ici). */
    const integrerDirect = (cle, m) => setFil(x => {
      const cur = x[cle]; if (!cur || !cur.messages) return x;
      const i = cur.messages.findIndex(y => memeMessage(y, m));
      if (i >= 0) {
        const y = cur.messages[i];
        const fusion = { ...y, statut: m.statut || y.statut, texte: m.canal === "appel" ? m.texte : y.texte };
        return { ...x, [cle]: { ...cur, messages: cur.messages.map((z, k) => (k === i ? fusion : z)) } };
      }
      return { ...x, [cle]: { ...cur, messages: [...cur.messages, m].sort((a, b) => ts(a.quand) - ts(b.quand)) } };
    });
    /** Colonne de gauche à jour sans attendre : dernier message, heure, non lu (si l'onglet est caché ou la conversation fermée). */
    const majListe = (correspond, m, ouverte) => {
      const type = categorie(m.canal) === "courriel" ? "TYPE_EMAIL" : categorie(m.canal) === "appel" ? "TYPE_CALL" : "TYPE_SMS";
      const nonLu = m.direction === "entrant" && (!ouverte || !ongletVisible());
      let trouve = false;
      setExtras(xs => xs.map(e => (correspond(e) ? (trouve = true, { ...e, derniere: m.quand, apercu: m.texte }) : e)));
      setConvs(cs => {
        if (!cs) return cs;
        const i = cs.findIndex(c => correspond(entreeDe(c)));
        if (i < 0) return cs;
        trouve = true;
        const n = { ...cs[i], lastMessageBody: m.texte, lastMessageDate: m.quand, lastMessageType: type, unreadCount: nonLu ? (Number(cs[i].unreadCount) || 0) + 1 : (ouverte ? 0 : cs[i].unreadCount) };
        const out = [n, ...cs.slice(0, i), ...cs.slice(i + 1)];
        cacheConvs = { at: Date.now(), convs: out };
        return out;
      });
      return () => trouve;
    };
    // Clés temps réel du contact ouvert : téléphone 10 chiffres et courriel (client_key de public.interactions).
    const clesDirect = useMemo(() => {
      if (!item) return [];
      const t = tel10(contact.telephone || item.telephone); const e = String(contact.courriel || item.courriel || "").trim().toLowerCase();
      return [t.length === 10 ? t : "", /@/.test(e) ? e : ""].filter(Boolean);
    }, [item && item.cle, item && item.telephone, item && item.courriel, contact.telephone, contact.courriel]); // eslint-disable-line
    const clesDirectTxt = clesDirect.join("|");
    // Un seul canal Realtime par conversation ouverte ; désabonnement au changement de conversation et au démontage.
    useEffect(() => {
      const sb = window.RAYCAST_SUPABASE;
      if (!item || !clesDirect.length || !sb || typeof sb.channel !== "function") { setDirect(null); return; }
      const it = item; const cle = it.cle; let actif = true; let relire = null;
      setDirect(false);
      const ch = sb.channel("raycast-fil-" + String(cle).replace(/[^\w-]/g, "_") + "-" + Date.now().toString(36));
      const recevoir = (payload) => {
        if (!actif || !monte.current) return;
        const m = messageDeInteraction(payload && payload.new);
        if (!m) return;
        const maj = payload.eventType === "UPDATE";
        integrerDirect(cle, m);
        if (!maj) majListe(e => e.cle === cle, m, true);
        clearTimeout(relire);
        relire = setTimeout(() => { if (actif && monte.current) ouvrir(it, true, true); }, 400);
      };
      clesDirect.forEach(k => ["INSERT", "UPDATE"].forEach(ev => ch.on("postgres_changes", { event: ev, schema: "public", table: "interactions", filter: "client_key=eq." + k }, recevoir)));
      ch.subscribe((statut) => { if (actif && monte.current) setDirect(statut === "SUBSCRIBED"); });
      return () => { actif = false; clearTimeout(relire); try { sb.removeChannel(ch); } catch (e) { try { ch.unsubscribe(); } catch (e2) { /* noop */ } } };
    }, [item && item.cle, clesDirectTxt]); // eslint-disable-line
    // Canal « liste » : messages entrants des autres conversations (aperçu, heure, non lu) ; contact inconnu de la liste → relecture.
    useEffect(() => {
      const sb = window.RAYCAST_SUPABASE;
      if (!sb || typeof sb.channel !== "function") return;
      let actif = true; let relire = null;
      const ch = sb.channel("raycast-liste-" + Date.now().toString(36));
      ch.on("postgres_changes", { event: "INSERT", schema: "public", table: "interactions", filter: "direction=eq.entrant" }, (payload) => {
        if (!actif || !monte.current) return;
        const row = payload && payload.new; const m = messageDeInteraction(row); if (!m) return;
        const k = String(row.client_key || "").toLowerCase();
        const correspond = (e) => !!((row.ghl_contact_id && e.contactId === row.ghl_contact_id) || (k && (tel10(e.telephone) === k || String(e.courriel || "").toLowerCase() === k)));
        const it = itemRef.current;
        if (it && it.cle === selRef.current && correspond(it)) return; // le canal de la conversation ouverte s'en charge
        const aTrouve = majListe(correspond, m, false);
        clearTimeout(relire);
        relire = setTimeout(() => { if (actif && monte.current && !aTrouve()) chargerListe(true, true); }, 800);
      });
      ch.subscribe();
      return () => { actif = false; clearTimeout(relire); try { sb.removeChannel(ch); } catch (e) { /* noop */ } };
    }, []); // eslint-disable-line
    const canaux = f ? f.canaux : null;
    const messagesVisibles = useMemo(() => (f && f.messages ? f.messages.filter(m => filtre === "tous" || categorie(m.canal) === filtre) : []), [f, filtre]);

    // Canaux du composeur : disponibilité et raison quand un canal est grisé
    const choixCanaux = useMemo(() => {
      const tel = contact.telephone || (item && item.telephone); const mail = contact.courriel || (item && item.courriel);
      const sansFil = !canaux ? "fil unifié indisponible" : "";
      return [
        { id: "courriel", libelle: "Courriel", dispo: !!(canaux && Array.isArray(canaux.courriel) && canaux.courriel.length && mail), raison: !mail ? "contact sans courriel" : sansFil || (!(canaux.courriel || []).length ? "aucune boîte permise pour ton compte" : "") },
        { id: "ghl_sms", libelle: "SMS GHL", dispo: !!(canaux && canaux.ghl_sms && tel), raison: !tel ? "contact sans téléphone" : sansFil || (!canaux.ghl_sms ? "SMS GHL non disponible pour ce contact" : "") },
        { id: "aircall_sms", libelle: "SMS Aircall", dispo: !!(canaux && Array.isArray(canaux.aircall_sms) && canaux.aircall_sms.length && tel), raison: !tel ? "contact sans téléphone" : sansFil || (!(canaux.aircall_sms || []).length ? "aucun numéro Aircall avec SMS" : "") },
      ];
    }, [canaux, contact, item]);
    // Canal par défaut : on répond par le canal du dernier message du client (courriel → courriel, SMS → SMS), sinon le premier disponible ;
    // boîte d'envoi = celle de l'utilisateur connecté.
    const canalDuFil = useMemo(() => {
      const dernier = f && f.messages ? [...f.messages].reverse().find(m => m.direction === "entrant" && ["sms", "courriel"].includes(categorie(m.canal))) : null;
      if (!dernier) return null;
      return categorie(dernier.canal) === "courriel" ? "courriel" : (dernier.canal === "aircall_sms" ? "aircall_sms" : "ghl_sms");
    }, [f && f.messages]); // eslint-disable-line
    const filCharge = !!(f && f.messages && !f.loading);
    useEffect(() => { if (filCharge && canalDuFil && choixCanaux.find(c => c.id === canalDuFil && c.dispo)) setCanal(canalDuFil); }, [sel, filCharge]); // eslint-disable-line
    useEffect(() => {
      if (!choixCanaux.find(c => c.id === canal && c.dispo)) { const premier = choixCanaux.find(c => c.dispo); if (premier) setCanal(premier.id); }
      if (canaux && Array.isArray(canaux.courriel) && canaux.courriel.length && !canaux.courriel.includes(de)) {
        const mienne = (user && user.email && canaux.courriel.find(b => String(b).toLowerCase() === String(user.email).toLowerCase())) || canaux.courriel[0];
        setDe(mienne);
      }
      if (canaux && Array.isArray(canaux.aircall_sms) && canaux.aircall_sms.length && !canaux.aircall_sms.some(n => String(n.number_id) === String(numAircall))) setNumAircall(String(canaux.aircall_sms[0].number_id));
    }, [choixCanaux, canaux]); // eslint-disable-line
    // Sujet prérempli « Re : … » quand on répond au dernier courriel du fil
    const dernierCourriel = useMemo(() => (f && f.messages ? [...f.messages].reverse().find(m => categorie(m.canal) === "courriel" && !m.enCours) : null), [f]);
    useEffect(() => { if (canal === "courriel" && !sujet && dernierCourriel && dernierCourriel.sujet) setSujet((/^re\s*:/i.test(dernierCourriel.sujet) ? "" : "Re : ") + nettoie(dernierCourriel.sujet)); }, [canal, dernierCourriel]); // eslint-disable-line
    useEffect(() => { setTexte(""); setSujet(""); setEnvoi({}); }, [sel]);

    const estSms = canal !== "courriel";
    const longueur = texte.length;
    const canalDispo = choixCanaux.some(c => c.id === canal && c.dispo);
    const peutEnvoyer = texte.trim().length > 0 && (!estSms || longueur <= SMS_MAX) && (canal !== "courriel" || sujet.trim().length > 0) && !envoi.loading && canalDispo;

    const envoyer = async () => {
      if (!peutEnvoyer || !item) return;
      const t = texte.trim();
      const corps = { contact_id: contact.id || item.contactId || "", canal, texte: canal === "courriel" ? `${t}\n\n${sig.texte}` : t };
      if (canal === "courriel") { corps.html = htmlCourriel(t, sig); corps.sujet = sujet.trim(); corps.de = de; if (dernierCourriel && dernierCourriel.source_id && dernierCourriel.direction === "entrant") corps.en_reponse_a = dernierCourriel.source_id; }
      if (canal === "aircall_sms") corps.aircall_number_id = numAircall;
      const cle = sel;
      const provisoire = { id: "tmp-" + Date.now(), canal, direction: "sortant", quand: new Date().toISOString(), sujet: corps.sujet || "", texte: t, auteur: (profile && profile.name) || (user && user.email) || "Raycom", auteur_initiales: (profile && (profile.initials || initialesDe(profile.name))) || "", enCours: true, local: true, recu: Date.now(), de };
      setFil(x => ({ ...x, [cle]: { ...x[cle], messages: [...((x[cle] && x[cle].messages) || []), provisoire] } }));
      setEnvoi({ loading: true });
      try {
        if (!window.RaycastProxy || !window.RaycastProxy.post) throw new Error("relais sans envoi (cloud/proxy.jsx à jour ?)");
        const r = await window.RaycastProxy.post("ghl", "/conversations/envoyer", corps);
        if (!r || r.ok === false) throw new Error((r && (r.erreur || r.error)) || "envoi refusé");
        if (!monte.current) return;
        setFil(x => ({ ...x, [cle]: { ...x[cle], messages: (x[cle].messages || []).map(m => (m.id === provisoire.id ? { ...m, id: r.id || m.id, quand: r.quand || m.quand, enCours: false, statut: m.statut && m.statut !== "envoyé" ? m.statut : "envoyé", recu: Date.now() } : m)) } }));
        setEnvoi({ ok: `Envoyé par ${libelleCanal(canal)} à ${quand(r.quand || provisoire.quand)}.` });
        setTexte(""); if (canal === "courriel") setSujet("");
        [1000, 4000].forEach(d => setTimeout(() => { if (monte.current) ouvrir(item, true, true); }, d));
      } catch (e) {
        if (!monte.current) return;
        const msg = String(e.message || e);
        setFil(x => ({ ...x, [cle]: { ...x[cle], messages: (x[cle].messages || []).map(m => (m.id === provisoire.id ? { ...m, enCours: false, erreur: msg } : m)) } }));
        setEnvoi({ err: msg, texte: t, sujet: corps.sujet || "" });
      }
    };
    const retirerEchecs = () => setFil(x => ({ ...x, [sel]: { ...x[sel], messages: (x[sel].messages || []).filter(m => !m.erreur) } }));
    const reessayer = () => { retirerEchecs(); if (envoi.texte) setTexte(envoi.texte); if (envoi.sujet) setSujet(envoi.sujet); setEnvoi({}); };
    const surTouche = (e) => { if ((e.ctrlKey || e.metaKey) && e.key === "Enter") { e.preventDefault(); envoyer(); } };

    return (
      <div className={"re-app re-msg" + (mobileFil ? " fil-ouvert" : "")}>
        <div className="re-dash-head">
          <div><h1>Conversations</h1><p className="re-sub">Toutes les conversations : SMS et courriels GHL, SMS Aircall, courriels Microsoft 365, appels. Tu réponds d'ici, ça part dans le bon outil.</p></div>
          <div className="re-dash-actions"><button className="re-btn" onClick={() => { chargerListe(true); if (item) ouvrir(item, true); }} disabled={!!etat.loading}>↻ Rafraîchir</button></div>
        </div>
        {etat.err && <div className="re-alert error">Conversations indisponibles ({etat.err}). <button className="re-link" onClick={() => chargerListe(true)}>Réessayer</button></div>}
        <div className="re-msg-corps">
          <div className="re-msg-liste">
            <input placeholder="Rechercher un nom, un courriel, un message…" value={q} onChange={e => setQ(e.target.value)} aria-label="Rechercher" />
            <div className="re-msg-filtres">{FILTRES.map(([id, lib]) => <button key={id} type="button" className={"re-btn small" + (filtre === id ? " primary" : "")} onClick={() => setFiltre(id)}>{lib}</button>)}</div>
            {convs === null && !etat.err && <div className="re-muted" style={{ padding: 10 }}>Chargement des conversations…</div>}
            {visibles.map(c => (
              <div key={c.cle} className={"re-msg-item" + (c.cle === sel ? " on" : "") + (c.nonLus > 0 ? " nonlu" : "")} onClick={() => ouvrir(c, false)} onDoubleClick={() => { if (window.RaycastNav && window.RaycastNav.ouvrirClient) window.RaycastNav.ouvrirClient({ ghl_contact_id: c.contactId || c.ghl_contact_id || c.contact_id || null, courriel: c.courriel || c.email || null, telephone: c.telephone || c.phone || null }); }} title="Double-clic : ouvrir la fiche client">
                <div className="re-msg-item-haut"><b>{c.nom}</b><span>{c.derniere ? quand(c.derniere) : ""}</span></div>
                <div className="re-msg-item-bas"><span className={"re-msg-canal " + (c.extra ? "contact" : categorie(c.type))}>{c.extra ? "Contact" : LIBELLES[categorie(c.type)]}</span><span className="re-msg-apercu">{c.apercu ? c.apercu.slice(0, 90) : (c.extra ? [c.courriel, c.telephone].filter(Boolean).join(" · ") || "Nouveau fil" : "…")}</span>{c.nonLus > 0 && <span className="re-msg-nonlu">{c.nonLus}</span>}</div>
              </div>
            ))}
            {convs && !entrees.length && <div className="re-vide">Aucune conversation.</div>}
            {convs && entrees.length > 0 && !visibles.length && <div className="re-vide">Rien ne correspond. <button type="button" className="re-link" onClick={() => { setQ(""); setFiltre("tous"); }}>Effacer les filtres</button></div>}
          </div>
          <div className="re-msg-fil">
            {!item && <div className="re-msg-vide">Choisis une conversation, ou ouvre une fiche client et clique « Écrire ».</div>}
            {item && (
              <>
                <div className="re-msg-fil-head">
                  <div className="re-msg-fil-titre"><button type="button" className="re-btn small re-msg-retour" onClick={() => setMobileFil(false)}>← Liste</button><b>{contact.nom || item.nom}</b><span className="re-muted">{[contact.telephone || item.telephone, contact.courriel || item.courriel].filter(Boolean).join(" · ")}</span>{direct !== null && <span className={"re-msg-direct" + (direct ? " on" : "")} role="status" title={direct ? "Les nouveaux messages de ce contact apparaissent dès leur arrivée" : "Connexion temps réel perdue : reconnexion en cours (le fil se relit quand même toutes les 5 s)"}>{direct ? "en direct" : "reconnexion…"}</span>}</div>
                  <span className="re-muted">{(contact.id || item.contactId) && <a href={`https://app.gohighlevel.com/v2/location/${LOC}/contacts/detail/${contact.id || item.contactId}`} target="_blank" rel="noopener">ouvrir dans GHL</a>}</span>
                </div>
                <div className="re-msg-bulles" ref={filRef}>
                  {f && f.loading && <div className="re-muted">Chargement du fil…</div>}
                  {f && f.err && <div className="re-alert error">{f.err} <button type="button" className="re-link" onClick={() => ouvrir(item, true)}>Réessayer</button></div>}
                  {f && f.repli && <div className="re-msg-note">Fil GHL seul : le fil unifié (courriels Microsoft 365, SMS Aircall) et l'envoi arrivent quand le relais est à jour.</div>}
                  {f && f.messages && !f.messages.length && <div className="re-vide">Aucun message avec ce contact pour l'instant. Écris le premier.</div>}
                  {f && f.messages && f.messages.length > 0 && !messagesVisibles.length && <div className="re-vide">Aucun message de ce type dans ce fil.</div>}
                  {messagesVisibles.map((m, idx) => <Bulle nomClient={item && item.nom} key={m.id || idx} m={m} ouvert={!!ouverts[m.id || idx]} onToggle={() => setOuverts(o => ({ ...o, [m.id || idx]: !o[m.id || idx] }))} />)}
                </div>
                <div className="re-msg-composeur">
                  <div className="re-msg-canaux" role="radiogroup" aria-label="Canal d'envoi">
                    {choixCanaux.map(c => <button key={c.id} type="button" className={"re-btn small re-msg-canal-btn" + (canal === c.id ? " primary" : "") + (c.dispo ? "" : " off")} disabled={!c.dispo} title={c.dispo ? `Envoyer par ${c.libelle}` : `${c.libelle} indisponible : ${c.raison}`} onClick={() => setCanal(c.id)}>{c.libelle}{!c.dispo && <span className="re-msg-raison"> · {c.raison}</span>}</button>)}
                    {canal === "aircall_sms" && canaux && Array.isArray(canaux.aircall_sms) && canaux.aircall_sms.length > 1 && (
                      <select value={numAircall} onChange={e => setNumAircall(e.target.value)} aria-label="Numéro Aircall">{canaux.aircall_sms.map(n => <option key={n.number_id} value={n.number_id}>{n.libelle || n.numero_masque || n.number_id}</option>)}</select>
                    )}
                  </div>
                  {canal === "courriel" && (
                    <div className="re-msg-courriel-champs">
                      <label>De<select value={de} onChange={e => setDe(e.target.value)} aria-label="Boîte d'envoi">{((canaux && canaux.courriel) || []).map(b => <option key={b} value={b}>{b}</option>)}</select></label>
                      <label className="grand">Sujet<input value={sujet} onChange={e => setSujet(e.target.value)} placeholder="Sujet du courriel" aria-label="Sujet" /></label>
                    </div>
                  )}
                  <textarea value={texte} onChange={e => setTexte(e.target.value)} onKeyDown={surTouche} rows={canal === "courriel" ? 5 : 3} placeholder={canal === "courriel" ? "Écris ton courriel ; ta signature s'ajoute automatiquement en dessous." : "Écris ton texto (Ctrl+Entrée pour envoyer)"} disabled={!canalDispo} aria-label="Message" />
                  {canal === "courriel" && (
                    <div className="re-msg-signature">
                      <button type="button" className="re-link" onClick={() => setVoirSignature(v => !v)}>{voirSignature ? "Masquer la signature" : "Voir la signature qui sera ajoutée"}</button>
                      {voirSignature && <pre className="re-msg-signature-apercu">{sig.texte}</pre>}
                    </div>
                  )}
                  <div className="re-msg-envoi-ligne">
                    <span className={"re-msg-compteur" + (estSms && longueur > SMS_MAX ? " depasse" : "")}>{estSms ? `${longueur} / ${SMS_MAX} caractères${longueur > 160 ? ` · ${Math.ceil(longueur / 153)} SMS` : ""}` : `${longueur} caractères`}</span>
                    {envoi.err && <span className="re-msg-etat erreur">{envoi.err} <button type="button" className="re-link" onClick={reessayer}>Réessayer</button> <button type="button" className="re-link" onClick={() => { retirerEchecs(); setEnvoi({}); }}>Retirer</button></span>}
                    {envoi.ok && <span className="re-msg-etat ok">{envoi.ok}</span>}
                    <button type="button" className="re-btn primary" onClick={envoyer} disabled={!peutEnvoyer}>{envoi.loading ? "Envoi…" : `Envoyer par ${libelleCanal(canal)}`}</button>
                  </div>
                </div>
              </>
            )}
          </div>
        </div>
      </div>
    );
  }
  window.MessagerieRE = MessagerieRE;
})();
