// suivi-propositions-re.jsx : vue « Suivi des propositions » (confirmations de lecture et réponses des clients à la proposition
// en ligne). Lecture seule : tables proposition_liens et proposition_evenements (lecture RLS de l'équipe, colonnes nommées,
// jamais de select *), aucune écriture Supabase, QuickBooks ni GHL.
//
//   <window.SuiviPropositionsRE onOpen={handleOpen} />   indicateurs, onglets, recherche, tableau, chronologie dépliable
//   window.SuiviPropositionsRE.COLS                       colonnes lues sur proposition_liens (fiche client comprise)
//
// Mise à jour en direct par Realtime (postgres_changes sur proposition_liens), avec relecture de repli toutes les 60 s.
// Formats et libellés réutilisés de proposition-lien-re.jsx (window.PropositionLienRE).

(function () {
  const { useState, useEffect, useMemo, useCallback, useRef } = React;
  const P = () => window.PropositionLienRE || {};
  const F = () => (window.PropositionLienRE && window.PropositionLienRE.format) || {};
  const sb = () => window.RAYCAST_SUPABASE;
  const JOUR_MS = 86400000;
  const COLS = "id,etat,langue,soumission_id,soumission_numero,qbo_estimate_id,qbo_doc_number,qbo_customer_id,client_key,client_nom,montant_ttc,envoye_le,expire_le,nb_revisions,revise_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,nb_decisions,suivi,suivi_detail,annule_le,created_at,updated_at";
  const COLS_LISTE = COLS.split(",");
  const COLS_EVT = "id,lien_id,type,quand,appareil,duree_s,nom_tape,montant_ttc,numero,motif,motif_detail,relance,decision_precedente";
  const ONGLETS = [
    ["toutes", "Toutes"],
    ["jamais", "Jamais ouvertes"],
    ["ouvertes", "Ouvertes sans réponse"],
    ["acceptees", "Acceptées"],
    ["refusees", "Refusées"],
    ["verifier", "À vérifier"],
  ];

  const norm = (s) => String(s == null ? "" : s).normalize("NFD").replace(/[̀-ͯ]/g, "").toLowerCase().trim();
  const t = (d) => { const x = d ? Date.parse(d) : NaN; return isFinite(x) ? x : null; };
  const aVerifier = (l) => l.suivi === "a_verifier" || l.suivi === "erreur";
  const expiree = (l) => { const x = t(l.expire_le); return x != null && x <= Date.now(); };
  const recence = (l) => t(l.envoye_le) || t(l.created_at) || 0;
  const montantAccepte = (l) => Number(l.decision_montant != null ? l.decision_montant : l.montant_ttc) || 0;
  const appareil = (a) => a === "mobile" ? "mobile" : a === "ordinateur" ? "ordinateur" : "";
  const garder = (o) => { const r = {}; for (const k of COLS_LISTE) if (o && Object.prototype.hasOwnProperty.call(o, k)) r[k] = o[k]; return r; };
  const quandLong = (d) => { const f = F(); return d && f.quand ? f.quand(d) : ""; };

  /** Filtres des onglets (un lien annulé ne compte ni comme « jamais ouverte » ni comme « sans réponse »). */
  const FILTRES = {
    toutes: () => true,
    jamais: (l) => !!l.envoye_le && !(l.nb_vues > 0) && !l.decision && l.etat !== "annulee",
    ouvertes: (l) => l.nb_vues > 0 && !l.decision && l.etat !== "annulee",
    acceptees: (l) => l.decision === "acceptee",
    refusees: (l) => l.decision === "refusee",
    verifier: aVerifier,
  };

  /** Indicateurs du haut : envoyées sur 30 jours, taux d'ouverture, en attente, acceptées (et montant), refusées, à vérifier. */
  function indicateurs(liens) {
    const maintenant = Date.now();
    const envoyees = liens.filter(l => l.envoye_le);
    const env30 = envoyees.filter(l => recence(l) >= maintenant - 30 * JOUR_MS);
    const ouvertes = envoyees.filter(l => l.nb_vues > 0);
    const attente = liens.filter(l => l.etat === "active" && l.envoye_le && !l.decision && !expiree(l));
    const acceptees = liens.filter(FILTRES.acceptees);
    return {
      envoyees30: env30.length,
      envoyees: envoyees.length,
      ouvertes: ouvertes.length,
      taux: envoyees.length ? Math.round((ouvertes.length / envoyees.length) * 100) : null,
      attente: attente.length,
      attenteOuvertes: attente.filter(l => l.nb_vues > 0).length,
      acceptees: acceptees.length,
      montantAccepte: acceptees.reduce((s, l) => s + montantAccepte(l), 0),
      refusees: liens.filter(FILTRES.refusees).length,
      verifier: liens.filter(aVerifier).length,
    };
  }

  /** « expire dans 5 jours », « expire demain », « expire aujourd'hui », « expirée », « lien annulé ». */
  function expiration(l) {
    if (l.etat === "annulee") return { texte: "Lien annulé", ton: "muet" };
    const x = t(l.expire_le);
    if (x == null) return { texte: "", ton: "muet" };
    const ton = l.decision ? "muet" : "";
    if (x <= Date.now()) return { texte: "Expirée", ton: l.decision ? "muet" : "expiree" };
    const j = Math.floor((x - Date.now()) / JOUR_MS);
    if (j <= 0) return { texte: "Expire aujourd'hui", ton: l.decision ? "muet" : "bientot" };
    if (j === 1) return { texte: "Expire demain", ton: l.decision ? "muet" : "bientot" };
    return { texte: `Expire dans ${j} jours`, ton: !l.decision && j <= 5 ? "bientot" : ton };
  }

  /** Suivi automatique (QuickBooks, Nurturing GHL) : texte du worker, ton selon l'état. */
  function Suivi({ lien }) {
    if (!lien.suivi && !lien.suivi_detail) return null;
    const alerte = aVerifier(lien);
    const telephone = /t[ée]l[ée]phone/i.test(lien.suivi_detail || "");
    if (alerte) return (
      <div className="sp-suivi sp-suivi-alerte" role="note">
        <b className="sp-suivi-titre">{telephone ? "À confirmer par téléphone" : "À vérifier"}</b>
        {lien.suivi_detail && <span>{lien.suivi_detail}</span>}
      </div>
    );
    const ton = lien.suivi === "fait" || lien.suivi === "deja" ? "ok" : "muet";
    return <div className={`sp-suivi sp-suivi-${ton}`}>{lien.suivi_detail || (lien.suivi === "desactive" ? "Suivi automatique désactivé." : "")}</div>;
  }

  /** Lecture : « Jamais ouverte » ou « Ouverte 3 fois », dernière vue (heure de Mascouche), appareil, temps total. */
  function Lecture({ lien }) {
    const f = F();
    if (!(lien.nb_vues > 0)) return <div className="sp-lecture"><b className="sp-jamais">Jamais ouverte</b>{!lien.envoye_le && <div className="sp-muet">Pas encore envoyée</div>}</div>;
    const app = [appareil(lien.derniere_vue_appareil), lien.nb_appareils > 1 ? `${lien.nb_appareils} appareils` : ""].filter(Boolean).join(", ");
    return (
      <div className="sp-lecture">
        <b>Ouverte {lien.nb_vues} fois</b>
        {lien.derniere_vue && <div>Dernière vue le {quandLong(lien.derniere_vue)}{app ? ` · ${app}` : ""}</div>}
        {lien.duree_totale_s > 0 && f.duree && <div className="sp-muet">Lecture {f.duree(lien.duree_totale_s)} au total</div>}
      </div>
    );
  }

  /** Réponse du client : acceptation (nom tapé, montant) ou refus (motif, délai de relance, précision). */
  function Reponse({ lien }) {
    const p = P(), f = F();
    if (lien.decision === "acceptee") return (
      <div className="sp-reponse">
        <div>Acceptée{lien.decision_nom ? ` par « ${lien.decision_nom} »` : ""}</div>
        <div className="sp-muet">{f.argent ? f.argent(montantAccepte(lien)) : ""} taxes incluses{lien.decision_le ? `, le ${quandLong(lien.decision_le)}` : ""}</div>
      </div>
    );
    if (lien.decision === "refusee") return (
      <div className="sp-reponse">
        <div><b>Motif :</b> {(p.MOTIFS || {})[lien.motif_refus] || "non précisé"}</div>
        {lien.relance && <div>Relance : {(p.RELANCES || {})[lien.relance] || lien.relance}</div>}
        {lien.motif_detail && <div className="sp-precision">« {lien.motif_detail} »</div>}
      </div>
    );
    return null;
  }

  /** Chronologie d'un lien : envoi, chaque vue (heure, appareil, durée), décisions, annulation, suivi. Bouton « Ouvrir la soumission ». */
  function Chronologie({ lien, evts, onOpen }) {
    const p = P(), f = F();
    const items = [];
    if (lien.envoye_le) items.push({ k: "envoi", quand: lien.envoye_le, ton: "envoi", texte: `Proposition envoyée${lien.langue === "en" ? " (anglais)" : ""}` });
    for (const e of (evts && evts.liste) || []) {
      if (e.type === "vue") {
        items.push({ k: e.id, quand: e.quand, ton: "vue", texte: `Vue${appareil(e.appareil) ? ` sur ${appareil(e.appareil)}` : ""}${e.duree_s > 0 && f.duree ? ` · lue ${f.duree(e.duree_s)}` : ""}` });
      } else if (e.type === "acceptation") {
        items.push({ k: e.id, quand: e.quand, ton: "acceptee", texte: `Acceptée${e.nom_tape ? ` par « ${e.nom_tape} »` : ""}${e.montant_ttc != null && f.argent ? ` · ${f.argent(e.montant_ttc)}` : ""}${e.numero ? ` · devis nº ${e.numero}` : ""}${e.decision_precedente ? ` (décision précédente : ${e.decision_precedente === "acceptee" ? "acceptée" : "refusée"})` : ""}` });
      } else if (e.type === "refus") {
        items.push({ k: e.id, quand: e.quand, ton: "refusee", texte: [`Refusée : ${(p.MOTIFS || {})[e.motif] || "motif non précisé"}`, e.relance && ((p.RELANCES || {})[e.relance] || e.relance), e.motif_detail && `« ${e.motif_detail} »`, e.decision_precedente && `décision précédente : ${e.decision_precedente === "acceptee" ? "acceptée" : "refusée"}`].filter(Boolean).join(" · ") });
      }
    }
    if (lien.revise_le && lien.nb_revisions > 0) items.push({ k: "revision", quand: lien.revise_le, ton: "envoi", texte: `Proposition révisée${lien.nb_revisions > 1 ? ` (${lien.nb_revisions} révisions)` : ""}` });
    if (lien.annule_le) items.push({ k: "annule", quand: lien.annule_le, ton: "annule", texte: "Lien annulé : le client ne peut plus l'ouvrir" });
    items.sort((a, b) => (t(a.quand) || 0) - (t(b.quand) || 0));
    return (
      <div className="sp-chrono">
        <div className="sp-chrono-tete">
          <b>Chronologie</b>
          {lien.soumission_id && onOpen && <button type="button" className="re-btn small primary" onClick={(e) => { e.stopPropagation(); onOpen(lien.soumission_id); }}>Ouvrir la soumission</button>}
        </div>
        {evts && evts.etat === "charge" && <p className="sp-muet">Chargement des événements…</p>}
        {evts && evts.etat === "erreur" && <p className="re-alert error">Événements illisibles : {evts.erreur}</p>}
        <ol className="sp-chrono-liste">
          {items.map(it => <li key={it.k} className={`sp-evt sp-evt-${it.ton}`}><time>{quandLong(it.quand)}</time><span>{it.texte}</span></li>)}
          {!items.length && evts && evts.etat === "ok" && <li className="sp-evt sp-muet"><span>Aucun événement pour ce lien.</span></li>}
        </ol>
        {lien.suivi_detail && <div className="sp-chrono-suivi"><Suivi lien={lien} /></div>}
      </div>
    );
  }

  /** Cellule du tableau : contenu dans un seul bloc pour la mise en carte sur mobile (libellé de colonne à gauche). */
  const Cellule = ({ label, className, children }) => <td data-label={label} className={className}><div className="sp-cellule">{children}</div></td>;

  function KPI({ label, value, sub, ton }) {
    return <div className={`re-kpi sp-kpi ${ton || ""}`}><div className="re-kpi-label">{label}</div><div className="re-kpi-value">{value}</div>{sub && <div className="re-kpi-sub">{sub}</div>}</div>;
  }

  function SuiviPropositionsRE({ onOpen }) {
    const [liens, setLiens] = useState(null);
    const [erreur, setErreur] = useState("");
    const [lu, setLu] = useState(null);
    const [direct, setDirect] = useState(false);
    const [onglet, setOnglet] = useState("toutes");
    const [recherche, setRecherche] = useState("");
    const [ouvert, setOuvert] = useState(null);
    const [evts, setEvts] = useState({});
    const ouvertRef = useRef(null);
    ouvertRef.current = ouvert;

    const chargerEvts = useCallback(async (id) => {
      if (!id || !sb()) return;
      setEvts(x => ({ ...x, [id]: { ...(x[id] || {}), etat: x[id] && x[id].liste ? "ok" : "charge" } }));
      const { data, error } = await sb().from("proposition_evenements").select(COLS_EVT).eq("lien_id", id).order("quand", { ascending: true }).limit(500);
      if (error) { console.warn("[suivi] événements illisibles", error.message); setEvts(x => ({ ...x, [id]: { etat: "erreur", erreur: error.message, liste: [] } })); return; }
      setEvts(x => ({ ...x, [id]: { etat: "ok", liste: data || [] } }));
    }, []);

    const charger = useCallback(async () => {
      if (!sb()) { setErreur("Connexion à la base indisponible."); setLiens([]); return; }
      const { data, error } = await sb().from("proposition_liens").select(COLS).neq("etat", "preparation").order("created_at", { ascending: false }).limit(1000);
      if (error) { console.warn("[suivi] propositions illisibles", error.message); setErreur(`Propositions illisibles pour le moment : ${error.message}`); setLiens(l => l || []); return; }
      setErreur("");
      setLiens((data || []).map(garder));
      setLu(new Date().toISOString());
      if (ouvertRef.current) chargerEvts(ouvertRef.current);
    }, [chargerEvts]);

    useEffect(() => { charger(); }, [charger]);
    // En direct : chaque vue, acceptation ou refus met la ligne à jour ; repli par relecture toutes les 60 s.
    useEffect(() => {
      if (!sb()) return;
      let ch = null;
      try {
        ch = sb().channel("sp-suivi-propositions").on("postgres_changes", { event: "*", schema: "public", table: "proposition_liens" }, (p) => {
          const n = p && p.new;
          if (!n || !n.id) return;
          const ligne = garder(n);
          setLiens(liste => {
            const l = liste || [];
            const i = l.findIndex(x => x.id === ligne.id);
            if (ligne.etat === "preparation") return i >= 0 ? l.filter(x => x.id !== ligne.id) : l;
            return i >= 0 ? l.map((x, j) => (j === i ? { ...x, ...ligne } : x)) : [ligne, ...l];
          });
          setLu(new Date().toISOString());
          if (ouvertRef.current === ligne.id) chargerEvts(ligne.id);
        }).subscribe((statut) => setDirect(statut === "SUBSCRIBED"));
      } catch (_) { ch = null; }
      const iv = setInterval(charger, 60000);
      const f = () => charger();
      window.addEventListener("rp-lien-maj", f);
      return () => { clearInterval(iv); window.removeEventListener("rp-lien-maj", f); try { if (ch) sb().removeChannel(ch); } catch (_) {} };
    }, [charger, chargerEvts]);

    const tries = useMemo(() => (liens || []).slice().sort((a, b) => recence(b) - recence(a)), [liens]);
    const k = useMemo(() => indicateurs(tries), [tries]);
    const comptes = useMemo(() => Object.fromEntries(ONGLETS.map(([id]) => [id, tries.filter(FILTRES[id]).length])), [tries]);
    const visibles = useMemo(() => {
      const q = norm(recherche);
      return tries.filter(FILTRES[onglet] || FILTRES.toutes).filter(l => !q || norm(`${l.client_nom || ""} ${l.qbo_doc_number || ""} ${l.soumission_numero || ""}`).includes(q));
    }, [tries, onglet, recherche]);

    const basculer = (id) => {
      const suivant = ouvert === id ? null : id;
      setOuvert(suivant);
      if (suivant) chargerEvts(suivant);
    };
    const f = F(), p = P();
    const Statut = p.Statut;
    const argent = f.argent || ((n) => String(n));

    return (
      <div className="re-app re-dash sp-suivi-vue">
        <div className="re-dash-head">
          <div>
            <h1>Suivi des propositions</h1>
            <p className="re-sub">Confirmations de lecture et réponses des clients à la proposition en ligne · heure de Mascouche</p>
          </div>
          <div className="re-dash-actions">
            <span className={`sp-direct${direct ? " on" : ""}`} title={direct ? "Mise à jour en direct" : "Relecture automatique chaque minute"}>{direct ? "En direct" : "Relecture chaque minute"}{lu && f.heure ? ` · lu à ${f.heure(lu)}` : ""}</span>
            <button type="button" className="re-btn" onClick={charger}>Rafraîchir</button>
          </div>
        </div>
        {erreur && <div className="re-alert error">{erreur}</div>}
        {liens === null ? <div className="re-panel re-loading">Chargement des propositions…</div> : (
          <>
            <div className="re-kpis-grid sp-kpis">
              <KPI label="Envoyées" value={k.envoyees30} sub={`30 derniers jours · ${k.envoyees} au total`} />
              <KPI label="Ouvertes" value={k.ouvertes} sub={k.taux == null ? "aucune proposition envoyée" : `${k.taux} % d'ouverture`} />
              <KPI label="En attente de réponse" value={k.attente} sub={`${k.attenteOuvertes} ouverte${k.attenteOuvertes > 1 ? "s" : ""}, ${k.attente - k.attenteOuvertes} jamais ouverte${k.attente - k.attenteOuvertes > 1 ? "s" : ""}`} />
              <KPI label="Acceptées" value={k.acceptees} sub={`${argent(k.montantAccepte)} acceptés`} ton="good" />
              <KPI label="Refusées" value={k.refusees} />
              <KPI label="À vérifier" value={k.verifier} sub={k.verifier ? "suivi à confirmer à la main" : "rien à vérifier"} ton={k.verifier ? "sp-rouge" : ""} />
            </div>

            <div className="sp-barre">
              <div className="sp-onglets" role="tablist" aria-label="Filtrer les propositions">
                {ONGLETS.map(([id, lib]) => (
                  <button key={id} type="button" role="tab" aria-selected={onglet === id} className={`sp-onglet${onglet === id ? " on" : ""}${id === "verifier" && comptes.verifier ? " alerte" : ""}`} onClick={() => setOnglet(id)}>
                    {lib} <span className="sp-compte">{comptes[id]}</span>
                  </button>
                ))}
              </div>
              <input className="re-search sp-recherche" type="search" placeholder="Rechercher un client ou un numéro" aria-label="Rechercher un client ou un numéro" value={recherche} onChange={(e) => setRecherche(e.target.value)} />
            </div>

            <div className="re-panel sp-panel">
              {!visibles.length ? (
                <p className="re-muted sp-vide">{tries.length ? "Aucune proposition ne correspond à ce filtre." : "Aucune proposition en ligne pour le moment."}</p>
              ) : (
                <table className="sp-table">
                  <thead>
                    <tr><th>Client</th><th className="droite">Montant</th><th>Envoyée</th><th>Lecture</th><th>Statut</th><th>Réponse et suivi</th><th>Expiration</th></tr>
                  </thead>
                  <tbody>
                    {visibles.map(l => {
                      const ex = expiration(l);
                      const estOuvert = ouvert === l.id;
                      return (
                        <React.Fragment key={l.id}>
                          <tr className={`sp-ligne${estOuvert ? " ouverte" : ""}${aVerifier(l) ? " a-verifier" : ""}`} tabIndex={0} aria-expanded={estOuvert} title="Afficher la chronologie" onClick={() => basculer(l.id)} onKeyDown={(e) => { if (e.key === "Enter" || e.key === " ") { e.preventDefault(); basculer(l.id); } }}>
                            <Cellule label="Client"><div className="sp-client">{(window.StatutsRE ? window.StatutsRE.nomPropre(l.client_nom) : l.client_nom) || "Client sans nom"}</div><div className="sp-muet">Devis nº {l.qbo_doc_number || "?"}{l.soumission_numero ? ` · ${l.soumission_numero}` : ""} <span className="sp-langue" title={l.langue === "en" ? "Proposition en anglais" : "Proposition en français"}>{l.langue === "en" ? "EN" : "FR"}</span></div></Cellule>
                            <Cellule label="Montant" className="droite sp-montant">{l.montant_ttc != null ? argent(l.montant_ttc) : ""}<div className="sp-muet">taxes incluses</div></Cellule>
                            <Cellule label="Envoyée">{l.envoye_le && f.jour ? <><div>{f.jour(l.envoye_le)}</div><div className="sp-muet">{f.heure(l.envoye_le)}</div></> : <span className="sp-muet">Non envoyée</span>}</Cellule>
                            <Cellule label="Lecture"><Lecture lien={l} /></Cellule>
                            <Cellule label="Statut">{Statut ? <Statut lien={l} compact /> : null}</Cellule>
                            <Cellule label="Réponse et suivi"><Reponse lien={l} /><Suivi lien={l} /></Cellule>
                            <Cellule label="Expiration"><span className={`sp-exp ${ex.ton}`}>{ex.texte}</span></Cellule>
                          </tr>
                          {estOuvert && <tr className="sp-detail"><td colSpan={7}><Chronologie lien={l} evts={evts[l.id]} onOpen={onOpen} /></td></tr>}
                        </React.Fragment>
                      );
                    })}
                  </tbody>
                </table>
              )}
            </div>
          </>
        )}
      </div>
    );
  }

  SuiviPropositionsRE.COLS = COLS;
  SuiviPropositionsRE.indicateurs = indicateurs;
  window.SuiviPropositionsRE = SuiviPropositionsRE;
})();
