// proposition-lien-re.jsx : suivi de la proposition client en ligne (lien /p/<jeton> servi par le worker raycom-ghl-qbo-worker).
//
//   window.PropositionLienRE.libelle(lien)                     → { texte, ton } : « Envoyée », « Vue 3 fois, dernière vue le … »,
//                                                                « Acceptée le … », « Refusée : Budget »
//   <window.PropositionLienRE.Statut lien={…} />               pastille de statut (liste des Soumissions)
//   window.PropositionLienRE.useLiens(ids)                     liens des soumissions visibles (Supabase, lecture RLS équipe)
//   <window.PropositionLienRE.Panneau soumissionId lienId docNumber revisions />
//                                                              statut détaillé, « Copier le lien client », « Aperçu client »,
//                                                              « Annuler le lien client » (créateur de la soumission ou admin)
//   window.PropositionLienRE.format                            jour, heure, quand, argent, duree (« 4 min 20 s »), ilYa (« il y a 2 h »)
//   <window.PropositionLienRE.Notifications onOpen />          avis en direct (Realtime, sinon relecture aux 90 s) quand un client
//                                                              accepte ou refuse, et quand un suivi passe « à vérifier »
//                                                              (ex. refus définitif à confirmer par téléphone)
//   <window.PropositionLienRE.EnvoiModale resume onPreparer onFermer />
//                                                              « Envoyer au client » : vraie modale, « Tapez ENVOYER pour
//                                                              confirmer » (majuscules exactes), puis brouillon Outlook ouvert dans
//                                                              un nouvel onglet (repli mailto:) ; rien n'est envoyé par Raycast
//   window.PropositionLienRE.courrielPrepare(state)            « Courriel préparé le 6 nov. » (statut, jamais « envoyé ») ou null
// Lecture seule : les écritures sont faites par le worker (rôle service). Le jeton n'est jamais en base en clair : le lien
// à copier est demandé au worker (JWT Supabase), qui le déchiffre.

(function () {
  const { useState, useEffect, useRef, useCallback } = React;
  const TZ = "America/Toronto";
  const COLS = "id,soumission_id,qbo_doc_number,etat,langue,envoye_le,expire_le,nb_vues,nb_appareils,premiere_vue,derniere_vue,derniere_vue_appareil,duree_totale_s,decision,decision_le,decision_nom,decision_montant,motif_refus,motif_detail,relance,infolettre_consentement_le,suivi,suivi_detail,nb_revisions,revise_le,annule_le,created_at";
  const MOTIFS = { budget: "Budget", autre_entreprise: "Signé avec une autre entreprise", annule: "Projet annulé ou reporté", delai: "Délai trop long", attendre: "Je préfère attendre (subventions, saison)", autre: "Autre" };
  const RELANCES = { "1": "relancer dans 1 mois", "3": "relancer dans 3 mois", "6": "relancer dans 6 mois", "12": "relancer dans 12 mois", infolettre: "infolettre mensuelle seulement (consentement)" };
  const LANGUES = { fr: "français", en: "anglais" };
  const sb = () => window.RAYCAST_SUPABASE;
  const workerUrl = () => (window.CatalogueRE && window.CatalogueRE.WORKER_URL) || window.RAYCAST_WORKER_URL || "https://raycom-ghl-qbo-worker.proud-leaf-b313.workers.dev";

  const jour = (d) => new Date(d).toLocaleDateString("fr-CA", { timeZone: TZ, day: "numeric", month: "short" });
  const heure = (d) => new Date(d).toLocaleTimeString("fr-CA", { timeZone: TZ, hour: "2-digit", minute: "2-digit" }).replace(":", " h ").replace(/\s?h\s?/, " h ");
  const quand = (d) => d ? `${jour(d)} à ${heure(d)}` : "";
  const argent = (n) => (Number(n) || 0).toLocaleString("fr-CA", { minimumFractionDigits: 2, maximumFractionDigits: 2 }) + " $";
  /** « 45 s », « 4 min 20 s », « 1 h 05 min » (temps de lecture). */
  const duree = (s) => {
    s = Math.max(0, Math.round(Number(s) || 0));
    if (s < 60) return `${s} s`;
    if (s < 3600) { const m = Math.floor(s / 60), r = s % 60; return r ? `${m} min ${r} s` : `${m} min`; }
    const h = Math.floor(s / 3600), m = Math.round((s % 3600) / 60);
    return m ? `${h} h ${String(m).padStart(2, "0")} min` : `${h} h`;
  };
  /** Temps écoulé depuis un horodatage : « à l'instant », « il y a 12 min », « il y a 2 h », « il y a 3 j », puis « le 5 nov. ». */
  const ilYa = (d) => {
    const t = d ? Date.parse(d) : NaN;
    if (!isFinite(t)) return "";
    const s = Math.max(0, (Date.now() - t) / 1000);
    if (s < 60) return "à l'instant";
    if (s < 3600) return `il y a ${Math.floor(s / 60)} min`;
    if (s < 86400) return `il y a ${Math.floor(s / 3600)} h`;
    if (s < 7 * 86400) return `il y a ${Math.floor(s / 86400)} j`;
    return `le ${jour(d)}`;
  };

  function libelle(l) {
    if (!l) return null;
    if (l.etat === "annulee") return { texte: "Lien annulé", ton: "gris" };
    if (l.decision === "acceptee") return { texte: `Acceptée le ${quand(l.decision_le)}`, ton: "vert" };
    if (l.decision === "refusee") return { texte: `Refusée : ${MOTIFS[l.motif_refus] || "motif non précisé"}`, ton: "rouge" };
    const expiree = l.expire_le && Date.parse(l.expire_le) <= Date.now();
    // Couleurs de la palette unique (statuts-re.jsx) : expirée rouge ; vue ou envoyée bleu, puis orange (à relancer) après 3 jours sans réponse
    if (expiree) return { texte: l.nb_vues > 0 ? `Expirée sans réponse (vue ${l.nb_vues} fois)` : "Expirée sans réponse", ton: "rouge" };
    const aRelancer = (d) => { const t = d ? Date.parse(d) : NaN; return isFinite(t) && Date.now() - t >= 3 * 86400000; };
    if (l.nb_vues > 0) return { texte: `Vue ${l.nb_vues} fois, dernière vue le ${quand(l.derniere_vue)}`, ton: aRelancer(l.derniere_vue) ? "orange" : "bleu" };
    if (l.envoye_le) return { texte: "Envoyée", ton: aRelancer(l.envoye_le) ? "orange" : "bleu-pale" };
    return { texte: l.etat === "active" ? "Lien prêt, devis non envoyé" : "Lien en préparation", ton: "gris" };
  }

  function Statut({ lien, compact }) {
    const l = libelle(lien);
    if (!l) return null;
    return <span className={`rp-statut rp-ton-${l.ton}${compact ? " rp-compact" : ""}`} title={lien.suivi === "erreur" || lien.suivi === "a_verifier" ? `À vérifier : ${lien.suivi_detail || ""}` : l.texte}>
      {l.texte}{(lien.suivi === "erreur" || lien.suivi === "a_verifier") && <b className="rp-alerte" aria-label="À vérifier"> !</b>}
    </span>;
  }

  /** Liens des soumissions données (le plus récent par soumission), rafraîchis en direct. */
  function useLiens(ids) {
    const [parSoumission, setPar] = useState({});
    const cle = (ids || []).filter(Boolean).slice().sort().join(",");
    const charger = useCallback(async () => {
      const liste = cle ? cle.split(",") : [];
      if (!liste.length || !sb()) { setPar({}); return; }
      const out = {};
      for (let i = 0; i < liste.length; i += 150) {
        const { data, error } = await sb().from("proposition_liens").select(COLS).in("soumission_id", liste.slice(i, i + 150)).neq("etat", "preparation").order("created_at", { ascending: true });
        if (error) { console.warn("[proposition] liens illisibles (migration appliquée ?)", error.message); return; }
        for (const l of data || []) if (l.etat !== "annulee" || !out[l.soumission_id]) out[l.soumission_id] = l;
      }
      setPar(out);
    }, [cle]);
    useEffect(() => { charger(); }, [charger]);
    useEffect(() => {
      const f = () => charger();
      window.addEventListener("rp-lien-maj", f);
      return () => window.removeEventListener("rp-lien-maj", f);
    }, [charger]);
    return parSoumission;
  }

  async function jetonSession() {
    const { data } = await sb().auth.getSession();
    const t = data && data.session && data.session.access_token;
    if (!t) throw new Error("Session expirée, reconnecte-toi.");
    return t;
  }
  async function lienClient(id) {
    const r = await fetch(`${workerUrl()}/raycast/proposition/lien?id=${encodeURIComponent(id)}`, { headers: { Authorization: `Bearer ${await jetonSession()}` } });
    const j = await r.json().catch(() => ({}));
    if (!r.ok) throw new Error(j.error || `Le worker a répondu HTTP ${r.status}`);
    return j;
  }
  /** Annule le lien client (worker : JWT, créateur de la soumission ou administrateur). La page publique devient introuvable. */
  async function annulerLien(id) {
    const r = await fetch(`${workerUrl()}/raycast/proposition/annuler`, { method: "POST", headers: { Authorization: `Bearer ${await jetonSession()}`, "Content-Type": "application/json" }, body: JSON.stringify({ id }) });
    const j = await r.json().catch(() => ({}));
    if (!r.ok) throw new Error(j.error || `Le worker a répondu HTTP ${r.status}`);
    return j;
  }
  async function copier(texte) {
    try { await navigator.clipboard.writeText(texte); return true; }
    catch (_) {
      const t = document.createElement("textarea"); t.value = texte; t.setAttribute("readonly", ""); t.style.position = "fixed"; t.style.opacity = "0";
      document.body.appendChild(t); t.select(); let ok = false; try { ok = document.execCommand("copy"); } catch (_) { ok = false; } t.remove(); return ok;
    }
  }

  /** Statut détaillé d'une soumission finalisée, avec « Copier le lien client » et l'historique des révisions. */
  function Panneau({ soumissionId, lienId, docNumber, revisions, courriel }) {
    const [lien, setLien] = useState(null);
    const [msg, setMsg] = useState("");
    const [occupe, setOccupe] = useState(false);
    const charger = useCallback(async () => {
      if (!sb() || (!lienId && !soumissionId)) return;
      let q = sb().from("proposition_liens").select(COLS);
      q = lienId ? q.eq("id", lienId) : q.eq("soumission_id", soumissionId).eq("etat", "active").order("created_at", { ascending: false }).limit(1);
      const { data, error } = await q;
      if (!error) setLien((data || [])[0] || null);
    }, [lienId, soumissionId]);
    useEffect(() => { charger(); }, [charger]);
    useEffect(() => {
      if (!sb() || !sb().channel || !lien) return;
      const ch = sb().channel(`rp-lien-${lien.id}`).on("postgres_changes", { event: "UPDATE", schema: "public", table: "proposition_liens", filter: `id=eq.${lien.id}` }, (p) => { if (p && p.new) setLien((x) => ({ ...(x || {}), ...p.new })); }).subscribe();
      const iv = setInterval(charger, 120000);
      const f = () => charger(); window.addEventListener("rp-lien-maj", f);
      return () => { try { sb().removeChannel(ch); } catch (_) {} clearInterval(iv); window.removeEventListener("rp-lien-maj", f); };
    }, [lien && lien.id, charger]);

    const action = async (genre) => {
      if (!lien) return;
      setOccupe(true); setMsg("");
      try {
        const j = await lienClient(lien.id);
        if (genre === "copier") setMsg((await copier(j.url)) ? "Lien client copié." : `Copie impossible, voici le lien : ${j.url}`);
        else window.open(j.url_apercu, "_blank", "noopener");
      } catch (e) { setMsg(e.message || String(e)); }
      finally { setOccupe(false); }
    };

    const annuler = async () => {
      if (!lien || lien.etat !== "active") return;
      if (!confirm(`Annuler le lien client de la proposition${lien.qbo_doc_number ? ` nº ${lien.qbo_doc_number}` : ""} ?\n\nLe client ne pourra plus consulter la proposition ni y répondre en ligne : le lien affichera « Lien introuvable ». Le devis QuickBooks n'est pas modifié. Pour redonner un lien au client, révise la proposition.`)) return;
      setOccupe(true); setMsg("");
      try {
        await annulerLien(lien.id);
        setLien((x) => ({ ...(x || {}), etat: "annulee", annule_le: new Date().toISOString() }));
        setMsg("Lien client annulé.");
        window.dispatchEvent(new CustomEvent("rp-lien-maj", { detail: { id: lien.id } }));
      } catch (e) { setMsg(e.message || String(e)); }
      finally { setOccupe(false); }
    };

    const revs = Array.isArray(revisions) ? revisions : [];
    if (!lien) return <div className="rp-panneau"><div className="rp-panneau-titre">Proposition en ligne{docNumber ? ` · devis nº ${docNumber}` : ""}</div><div className="rp-muet">Aucun lien client pour cette soumission (finalisée avant la mise en service, ou lien non créé).</div>{revs.length > 0 && <Historique revisions={revs} />}</div>;
    const l = libelle(lien);
    // Courriel préparé (brouillon Outlook ou mailto) et pas encore de vue ni de décision : on le dit, sans jamais écrire « envoyée »
    const prepare = courriel && courriel.le && !lien.envoye_le && !(lien.nb_vues > 0) && !lien.decision && lien.etat === "active";
    return (
      <div className="rp-panneau" aria-live="polite">
        <div className="rp-panneau-tete">
          <div className="rp-panneau-titre">Proposition en ligne{docNumber ? ` · devis nº ${docNumber}` : ""}</div>
          {prepare ? <span className="rp-statut rp-ton-bleu-pale" title="Brouillon préparé : l'envoi se fait dans Outlook. Les vues du lien confirment la lecture.">Courriel préparé le {jour(courriel.le)}</span> : <Statut lien={lien} />}
        </div>
        <ul className="rp-details">
          {courriel && courriel.le && <li>Courriel préparé le {quand(courriel.le)}{courriel.mode === "mailto" ? " (logiciel de courriel)" : courriel.boite ? ` (brouillon Outlook, boîte ${courriel.boite})` : " (brouillon Outlook)"} : l'envoi se fait dans Outlook.{courriel.mode !== "mailto" && courriel.brochure && courriel.brochure.produit ? (courriel.brochure.jointe ? " Brochure jointe." : " Brochure à joindre à la main.") : ""} Les vues du lien en ligne confirment la consultation.</li>}
          {lien.envoye_le && <li>Envoyée le {quand(lien.envoye_le)}</li>}
          {lien.nb_vues > 0 && <li>{[`Vue ${lien.nb_vues} fois sur ${lien.nb_appareils || 1} appareil${(lien.nb_appareils || 1) > 1 ? "s" : ""}`, lien.premiere_vue && `première vue le ${quand(lien.premiere_vue)}`, lien.derniere_vue && `dernière le ${quand(lien.derniere_vue)} sur ${lien.derniere_vue_appareil === "mobile" ? "mobile" : "ordinateur"}`, lien.duree_totale_s > 0 && `temps total ≈ ${duree(lien.duree_totale_s)}`].filter(Boolean).join(" · ")}</li>}
          {lien.decision === "acceptee" && <li>Acceptée par « {lien.decision_nom} » ({argent(lien.decision_montant)} taxes incluses). Confirmation en ligne, pas une signature certifiée.</li>}
          {lien.decision === "refusee" && <li>Motif : {MOTIFS[lien.motif_refus] || "?"}{lien.relance ? ` · ${RELANCES[lien.relance]}` : ""}{lien.motif_detail ? ` · « ${lien.motif_detail} »` : ""}</li>}
          {lien.infolettre_consentement_le && <li>Consentement à l'infolettre mensuelle donné le {quand(lien.infolettre_consentement_le)}</li>}
          {lien.suivi_detail && <li className={lien.suivi === "erreur" || lien.suivi === "a_verifier" ? "rp-a-verifier" : ""}>Suivi : {lien.suivi_detail}</li>}
          {lien.etat === "annulee" && <li className="rp-muet">Lien annulé{lien.annule_le ? ` le ${quand(lien.annule_le)}` : ""} : le client ne peut plus l'ouvrir.</li>}
          <li className="rp-muet">Langue {LANGUES[lien.langue] || "français"} · valide jusqu'au {jour(lien.expire_le)}</li>
        </ul>
        <div className="rp-panneau-actions">
          <button type="button" className="re-btn" disabled={occupe || lien.etat !== "active"} onClick={() => action("copier")}>Copier le lien client</button>
          <button type="button" className="re-btn" disabled={occupe || lien.etat !== "active"} onClick={() => action("apercu")} title="Ouvre la page client sans compter de vue (boutons désactivés)">Aperçu client</button>
          <button type="button" className="re-btn rp-annuler" disabled={occupe || lien.etat !== "active"} onClick={annuler} title="Le client ne pourra plus ouvrir la proposition en ligne (le devis QuickBooks n'est pas modifié)">Annuler le lien client</button>
        </div>
        {msg && <div className="rp-msg" role="status">{msg}</div>}
        <Historique revisions={revs} />
      </div>
    );
  }
  function Historique({ revisions }) {
    if (!revisions || !revisions.length) return null;
    return <ul className="rp-historique">{revisions.slice().reverse().map((r, i) => <li key={i}>Proposition révisée le {quand(r.le)} ({LANGUES[r.langue] || r.langue})</li>)}</ul>;
  }

  /** Avis en direct quand un client accepte ou refuse (toutes les soumissions de l'équipe). */
  function Notifications({ onOpen }) {
    const [avis, setAvis] = useState([]);
    const vus = useRef(new Set());
    const depuis = useRef(new Date().toISOString());
    const ajouter = useCallback((l) => {
      if (!l || !l.decision || !l.decision_le || Date.parse(l.decision_le) < Date.parse(depuis.current)) return;
      // Un suivi « à vérifier » (ex. refus définitif à confirmer par téléphone) donne un deuxième avis, distinct de la décision
      const aVerifier = l.suivi === "a_verifier" && l.suivi_detail;
      const k = `${l.id}:${l.decision_le}${aVerifier ? ":v" : ""}`;
      if (vus.current.has(k)) return;
      vus.current.add(k);
      const texte = aVerifier
        ? `Proposition nº ${l.qbo_doc_number || "?"} à vérifier : ${l.suivi_detail}`
        : l.decision === "acceptee"
          ? `Proposition nº ${l.qbo_doc_number || "?"} acceptée par ${l.decision_nom || "le client"} (${argent(l.decision_montant)}).`
          : `Proposition nº ${l.qbo_doc_number || "?"} refusée : ${MOTIFS[l.motif_refus] || "motif non précisé"}.`;
      setAvis((a) => [...a.slice(-3), { k, texte, ton: aVerifier ? "orange" : l.decision === "acceptee" ? "vert" : "rouge", soumission_id: l.soumission_id }]);
      window.dispatchEvent(new CustomEvent("rp-lien-maj", { detail: { id: l.id } }));
    }, []);
    useEffect(() => {
      if (!sb()) return;
      let ch = null;
      try { ch = sb().channel("rp-decisions").on("postgres_changes", { event: "UPDATE", schema: "public", table: "proposition_liens" }, (p) => ajouter(p && p.new)).subscribe(); } catch (_) { ch = null; }
      const relire = async () => {
        const { data, error } = await sb().from("proposition_liens").select(COLS).gt("decision_le", depuis.current).order("decision_le", { ascending: true }).limit(20);
        if (!error) (data || []).forEach(ajouter);
      };
      const iv = setInterval(relire, 90000);
      return () => { clearInterval(iv); try { if (ch) sb().removeChannel(ch); } catch (_) {} };
    }, [ajouter]);
    if (!avis.length) return null;
    return (
      <div className="rp-avis-pile" role="status" aria-live="polite">
        {avis.map((a) => (
          <div key={a.k} className={`rp-avis rp-ton-${a.ton}`}>
            <span>{a.texte}</span>
            <div className="rp-avis-actions">
              {a.soumission_id && onOpen && <button type="button" onClick={() => { onOpen(a.soumission_id); setAvis((x) => x.filter((y) => y.k !== a.k)); }}>Ouvrir</button>}
              <button type="button" aria-label="Fermer" onClick={() => setAvis((x) => x.filter((y) => y.k !== a.k))}>×</button>
            </div>
          </div>
        ))}
      </div>
    );
  }

  /** Statut « Courriel préparé le 6 nov. » d'une soumission (state.courriel_prepare), ou null. Jamais « envoyé » : l'envoi se fait dans Outlook. */
  function courrielPrepare(state) {
    const c = state && state.courriel_prepare;
    return c && c.le && isFinite(Date.parse(c.le)) ? { texte: `Courriel préparé le ${jour(c.le)}`, titre: `Courriel préparé le ${quand(c.le)} : brouillon à envoyer depuis Outlook`, le: c.le } : null;
  }
  const MOT = "ENVOYER";
  /** Pièce jointe du brouillon, en clair pour l'utilisateur (brochure du produit choisie par le worker selon le système et la langue). */
  const PRODUITS = { powerwall: "Tesla Powerwall 3", sigenergy: "Sigenergy", fox: "Fox ESS", "lux-volthium": "Lux Power et Volthium" };
  function brochureTexte(b) {
    if (!b || !PRODUITS[b.produit]) return { ok: true, texte: "Sans pièce jointe : aucune brochure pour ce type de projet, le lien de la proposition suffit." };
    const nom = `brochure ${PRODUITS[b.produit]} (${LANGUES[b.langue] || "français"})`;
    if (b.jointe) return { ok: true, texte: `Pièce jointe : ${nom}.` };
    const pourquoi = { introuvable: "brochure introuvable", trop_lourde: "brochure trop lourde pour Outlook (plus de 2,5 Mo)", invalide: "brochure invalide" }[b.statut] || "brochure non jointe (erreur)";
    return { ok: false, texte: `${pourquoi.charAt(0).toUpperCase() + pourquoi.slice(1)}, à joindre à la main : ${nom}.` };
  }
  const mailtoDe = (r) => `mailto:${encodeURIComponent(r.a || "")}?subject=${encodeURIComponent(r.sujet || "")}&body=${encodeURIComponent(r.texte || "")}`;

  /**
   * « Envoyer au client » : résumé, « Tapez ENVOYER pour confirmer » (bouton désactivé tant que le texte n'est pas exactement
   * ENVOYER), puis onPreparer(etape) (devis QuickBooks garanti, brouillon Outlook par le worker). Le brouillon s'ouvre dans un
   * nouvel onglet, ouvert dès le clic pour éviter le bloqueur de fenêtres ; repli mailto: si Outlook est indisponible.
   * resume : { client, courriel, numero, devis, ttc, langue } ; onPreparer renvoie la réponse du worker ({ web_link } ou { repli }).
   */
  function EnvoiModale({ resume, onPreparer, onFermer }) {
    const [texte, setTexte] = useState("");
    const [phase, setPhase] = useState("confirmer"); // confirmer | travail | pret | repli | erreur
    const [etapes, setEtapes] = useState([]);
    const [res, setRes] = useState(null);
    const [erreur, setErreur] = useState("");
    const champ = useRef(null);
    const r = resume || {};
    const exact = texte === MOT;
    const occupe = phase === "travail";
    useEffect(() => { if (champ.current) champ.current.focus(); }, []);
    useEffect(() => {
      const f = (e) => { if (e.key === "Escape" && !occupe) onFermer(); };
      window.addEventListener("keydown", f);
      return () => window.removeEventListener("keydown", f);
    }, [occupe, onFermer]);

    const confirmer = async (e) => {
      if (e) e.preventDefault();
      if (!exact || phase !== "confirmer") return;
      // Onglet ouvert pendant le clic (sinon le navigateur bloque l'ouverture qui suit l'attente du worker)
      let onglet = null;
      try {
        onglet = window.open("", "_blank");
        if (onglet) { onglet.document.title = "Préparation du courriel"; onglet.document.body.innerHTML = '<p style="font:16px system-ui,sans-serif;padding:24px;color:#0C2340">Préparation du brouillon Outlook…</p>'; }
      } catch (_) { onglet = null; }
      const fermerOnglet = () => { try { if (onglet && !onglet.closed) onglet.close(); } catch (_) {} };
      setPhase("travail"); setEtapes([]); setErreur("");
      try {
        const j = await onPreparer((m) => setEtapes((x) => [...x, m]));
        if (j && j.web_link) {
          setRes(j); setPhase("pret");
          if (onglet && !onglet.closed) { try { onglet.opener = null; } catch (_) {} onglet.location.href = j.web_link; }
          else window.open(j.web_link, "_blank", "noopener");
        } else if (j && j.repli) {
          fermerOnglet();
          const m = mailtoDe(j.repli);
          setRes({ ...j, mailto: m }); setPhase("repli");
          try { const a = document.createElement("a"); a.href = m; a.rel = "noopener"; document.body.appendChild(a); a.click(); a.remove(); } catch (_) {}
        } else throw new Error("Réponse inattendue du worker");
      } catch (err) {
        fermerOnglet();
        setErreur((err && err.message) || String(err)); setPhase("erreur");
      }
    };

    const ligne = (k, v) => <div className="rp-envoi-ligne"><span>{k}</span><b>{v}</b></div>;
    return (
      <div className="re-modal-fond rp-envoi-fond" onClick={() => { if (!occupe) onFermer(); }}>
        <div className="re-modal rp-envoi" role="dialog" aria-modal="true" aria-labelledby="rp-envoi-titre" onClick={(e) => e.stopPropagation()}>
          <div className="re-modal-tete"><h3 id="rp-envoi-titre">Envoyer au client</h3>
            {!occupe && <button type="button" className="rp-envoi-x" aria-label="Fermer" onClick={onFermer}>×</button>}</div>
          <div className="rp-envoi-resume">
            {ligne("Client", r.client || "?")}
            {ligne("Courriel", r.courriel || "?")}
            {ligne("Soumission", `${r.numero || "brouillon"}${r.devis ? ` · devis QuickBooks nº ${r.devis}` : ""}`)}
            {ligne("Total", `${r.ttc || "?"} taxes incluses`)}
            {ligne("Langue", LANGUES[r.langue] || "français")}
          </div>
          {phase === "confirmer" && (
            <form onSubmit={confirmer}>
              <p className="rp-envoi-texte">Raycast prépare un courriel personnalisé selon le système du client, avec le lien de sa proposition et la brochure du produit en pièce jointe, dans ta boîte Outlook avec ta signature. Le courriel ne contient aucun prix : le client les voit dans sa proposition en ligne. Tu le relis, puis tu cliques Envoyer dans Outlook : rien ne part sans toi.
                {r.devis ? "" : " Le devis QuickBooks est d'abord créé, sans envoi par QuickBooks."}</p>
              <label className="rp-envoi-champ">
                <span>Tapez ENVOYER pour confirmer</span>
                <input ref={champ} value={texte} onChange={(e) => setTexte(e.target.value)} autoComplete="off" autoCorrect="off" spellCheck={false} autoCapitalize="characters" inputMode="text" aria-describedby="rp-envoi-aide" />
              </label>
              <div id="rp-envoi-aide" className="rp-envoi-aide" aria-live="polite">{texte && !exact ? (texte.trim().toUpperCase() === MOT ? "En majuscules, sans espace : ENVOYER" : "Tapez exactement ENVOYER") : ""}</div>
              <div className="re-modal-pied">
                <button type="button" className="re-btn" onClick={onFermer}>Annuler</button>
                <button type="submit" className="re-btn primary" disabled={!exact}>Préparer le courriel</button>
              </div>
            </form>
          )}
          {phase === "travail" && (
            <div className="rp-envoi-travail" role="status" aria-live="polite">
              <span className="rp-envoi-roue" aria-hidden="true" />
              <ul>{(etapes.length ? etapes : ["Préparation…"]).map((m, i) => <li key={i}>{m}</li>)}</ul>
            </div>
          )}
          {phase === "pret" && res && (
            <div className="rp-envoi-ok" role="status">
              <p><b>Brouillon prêt dans Outlook</b>{res.boite ? ` (boîte ${res.boite})` : ""}.{res.deja ? " Il avait déjà été préparé il y a moins d'une minute : c'est le même." : ""}</p>
              {res.boite_repli && <p className="rp-envoi-avis" role="note">Ta boîte n'est pas dans la liste des boîtes autorisées : le brouillon est dans {res.boite}. Vérifie la signature avant d'envoyer.</p>}
              {(() => { const b = brochureTexte(res.brochure); return <p className={b.ok ? "rp-muet rp-envoi-pj" : "rp-envoi-avis rp-envoi-pj"} data-testid="envoi-brochure">{b.texte}</p>; })()}
              <p>Il s'ouvre dans un nouvel onglet. Relis-le, puis clique <b>Envoyer</b> dans Outlook. Rien n'a été envoyé au client pour l'instant.</p>
              <p className="rp-muet">Les vues du lien en ligne confirmeront la consultation.</p>
              <div className="re-modal-pied">
                <a className="re-btn" href={res.web_link} target="_blank" rel="noopener noreferrer">Ouvrir le brouillon dans Outlook</a>
                <button type="button" className="re-btn primary" onClick={onFermer}>Fermer</button>
              </div>
            </div>
          )}
          {phase === "repli" && res && (
            <div className="rp-envoi-repli" role="alert">
              {res.code === "permission_outlook"
                ? <p><b>Permission Outlook manquante : Mail.ReadWrite à accorder par l'administrateur.</b> En attendant, ton logiciel de courriel s'ouvre avec un message court et le lien de la proposition (sans brochure ni signature) : relis-le, puis envoie-le.</p>
                : <><p><b>Outlook n'a pas pu préparer le brouillon.</b> Ton logiciel de courriel s'ouvre avec un message court et le lien de la proposition (sans brochure) : relis-le, puis envoie-le.</p>
                  <p className="rp-muet">{res.error || ""}</p></>}
              <div className="re-modal-pied">
                <a className="re-btn" href={res.mailto}>Ouvrir mon logiciel de courriel</a>
                <button type="button" className="re-btn primary" onClick={onFermer}>Fermer</button>
              </div>
            </div>
          )}
          {phase === "erreur" && (
            <div className="rp-envoi-erreur" role="alert">
              <p><b>Rien n'a été préparé.</b> {erreur}</p>
              <div className="re-modal-pied">
                <button type="button" className="re-btn" onClick={onFermer}>Fermer</button>
                <button type="button" className="re-btn primary" onClick={() => { setTexte(""); setPhase("confirmer"); }}>Réessayer</button>
              </div>
            </div>
          )}
        </div>
      </div>
    );
  }

  // Formats et libellés partagés avec le Suivi des propositions (suivi-propositions-re.jsx) et la fiche client (clients-re.jsx)
  const format = { jour, heure, quand, argent, duree, ilYa };
  window.PropositionLienRE = { libelle, Statut, useLiens, Panneau, Notifications, EnvoiModale, courrielPrepare, lienClient, annulerLien, format, MOTIFS, RELANCES, LANGUES, TZ };
})();
