<!-- Portail Bestlife — Location, Maintenance, Gestion, Propriétaire
     Page WordPress : https://lesgestionsbestlife.com/portail/
     Seule la clé publique (« publishable ») de Supabase est dans la page; les données sont protégées par les règles d'accès (RLS). -->
<link rel="stylesheet" href="https://fonts.googleapis.com/css2?family=Heebo:wght@700;900&family=Poppins:wght@500;600;700&family=Open+Sans:wght@400;600;700&display=swap">
<div id="bl-app">
<style>
#bl-app{--bg:#f3f5f5;--card:#fff;--s2:#eef2f2;--txt:#333;--mut:#666;--line:#d6dddd;--pri:#c4704f;--pri-soft:#f6e4dc;--sage:#aabcbf;--sage-ink:#3d3d3d;
  --ok:#037f4c;--ok-soft:#e1f2e8;--warn:#a86a00;--warn-soft:#fff3d6;--bad:#bb3354;--bad-soft:#f9e1e7;--blue:#2f6fb3;--blue-soft:#e3edf8;
  --fh:"Heebo","Helvetica Neue",Arial,sans-serif;--fu:"Poppins","Helvetica Neue",Arial,sans-serif;--fb:"Open Sans",system-ui,-apple-system,"Segoe UI",Arial,sans-serif;
  font-family:var(--fb);color:var(--txt);background:var(--bg);line-height:1.5;font-size:15px;max-width:1180px;margin:0 auto;border-radius:6px;overflow:hidden}
#bl-app *{box-sizing:border-box}
#bl-app .bl-top{background:#fff;border-top:6px solid var(--sage);border-bottom:1px solid var(--line);padding:10px 16px;display:flex;align-items:center;gap:14px;flex-wrap:wrap}
#bl-app .bl-top img{height:46px;width:auto;display:block}
#bl-app .bl-titre{font-family:var(--fh);font-weight:900;text-transform:uppercase;letter-spacing:.06em;font-size:1.05rem}
#bl-app .bl-titre span{color:var(--pri);font-weight:700}
#bl-app .bl-esp{display:flex;gap:6px;flex-wrap:wrap;margin-left:auto}
#bl-app .bl-esp button{font-family:var(--fu);font-weight:600;font-size:.82rem;text-transform:uppercase;letter-spacing:.04em;border:2px solid var(--line);background:#fff;color:var(--txt);border-radius:999px;padding:6px 14px;cursor:pointer}
#bl-app .bl-esp button.on{background:var(--pri);border-color:var(--pri);color:#fff}
#bl-app .bl-user{font-size:.82rem;color:var(--mut);white-space:nowrap}
#bl-app .bl-user a{color:var(--pri)}
#bl-root{padding:16px}
#bl-app h1,#bl-app h2,#bl-app h3{font-family:var(--fh);margin:0;text-wrap:balance}
#bl-app h2{font-size:1.35rem;text-transform:uppercase;letter-spacing:.02em;margin-bottom:12px}
#bl-app h3{font-size:1.02rem;margin:16px 0 8px}
#bl-app .tabs{display:flex;gap:2px;overflow-x:auto;border-bottom:1px solid var(--line);margin:-16px -16px 16px;padding:0 12px;background:#fff;scrollbar-width:none}
#bl-app .tabs button{flex:0 0 auto;font-family:var(--fu);font-weight:600;font-size:.84rem;text-transform:uppercase;letter-spacing:.03em;background:none;border:0;border-bottom:3px solid transparent;color:var(--mut);padding:11px 12px 9px;cursor:pointer}
#bl-app .tabs button.on{color:var(--txt);border-bottom-color:var(--pri)}
#bl-app .card{background:var(--card);border:1px solid var(--line);border-radius:6px;padding:14px;margin-bottom:10px;box-shadow:0 1px 2px rgba(30,30,30,.05),0 4px 14px rgba(30,30,30,.05);position:relative}
#bl-app .bar{border-left:5px solid var(--bc,var(--line))}
#bl-app .grid{display:grid;grid-template-columns:repeat(auto-fill,minmax(250px,1fr));gap:14px}
#bl-app .click{cursor:pointer}#bl-app .click:hover{border-color:var(--mut)}
#bl-app .mut{color:var(--mut);font-size:13px}
#bl-app .small{font-size:13px}
#bl-app .num{font-variant-numeric:tabular-nums}
#bl-app .badge{display:inline-block;font-family:var(--fu);font-size:11.5px;font-weight:600;padding:3px 10px;border-radius:4px;white-space:nowrap;background:var(--s2);color:var(--txt)}
#bl-app .b-ok{background:var(--ok-soft);color:var(--ok)}#bl-app .b-warn{background:var(--warn-soft);color:var(--warn)}#bl-app .b-bad{background:var(--bad-soft);color:var(--bad)}
#bl-app .b-blue{background:var(--blue-soft);color:var(--blue)}#bl-app .b-pri{background:var(--pri-soft);color:var(--pri)}#bl-app .b-dark{background:#3a3a3a;color:#fff}
#bl-app label{display:block;font-family:var(--fu);font-size:12px;font-weight:600;color:var(--mut);text-transform:uppercase;letter-spacing:.04em;margin:10px 0 4px}
#bl-app input,#bl-app select,#bl-app textarea{width:100%;padding:10px 12px;border:1px solid var(--line);border-radius:6px;font:inherit;font-size:15px;background:#fff;color:var(--txt);min-width:0}
#bl-app textarea{min-height:80px}
#bl-app input[type=checkbox]{width:auto}
#bl-app .row{display:grid;grid-template-columns:1fr 1fr;gap:12px}
#bl-app .btn{display:inline-flex;align-items:center;justify-content:center;gap:6px;font-family:var(--fu);font-weight:600;font-size:.84rem;text-transform:uppercase;letter-spacing:.04em;background:var(--pri);color:#fff;border:1px solid var(--pri);padding:9px 16px;border-radius:6px;cursor:pointer;min-height:42px;text-decoration:none}
#bl-app .btn.sec{background:#fff;color:var(--txt);border-color:var(--line)}
#bl-app .btn.small{min-height:34px;padding:5px 11px;font-size:.76rem}
#bl-app .btn.danger{background:#fff;color:var(--bad);border-color:var(--bad)}
#bl-app .btn.ok{background:var(--ok);border-color:var(--ok)}
#bl-app .btn[disabled]{opacity:.5;cursor:not-allowed}
#bl-app .btns{display:flex;gap:8px;flex-wrap:wrap;margin-top:12px}
#bl-app .chips{display:flex;gap:6px;flex-wrap:wrap;margin-bottom:12px}
#bl-app .chip{font-family:var(--fu);font-size:.82rem;border:1px solid var(--line);background:#fff;border-radius:999px;padding:6px 13px;cursor:pointer;color:var(--txt)}
#bl-app .chip.on{background:var(--txt);border-color:var(--txt);color:#fff}
#bl-app .kv{display:grid;grid-template-columns:210px 1fr;gap:5px 14px;font-size:14px}
#bl-app .kv>div:nth-child(odd){color:var(--mut)}
#bl-app .code{font-family:ui-monospace,Consolas,monospace;font-size:20px;font-weight:700;background:#fff7d6;border:1px dashed #e0c25a;padding:4px 12px;border-radius:6px;display:inline-block;letter-spacing:.06em}
#bl-app .msg{padding:10px 12px;border-radius:6px;margin:8px 0;font-size:14px}
#bl-app .msg.err{background:var(--bad-soft);color:var(--bad)}#bl-app .msg.ok{background:var(--ok-soft);color:var(--ok)}#bl-app .msg.info{background:var(--s2);color:var(--txt)}
#bl-app .ov{position:fixed;inset:0;background:rgba(10,18,16,.5);display:flex;align-items:flex-start;justify-content:center;padding:24px 10px;overflow:auto;z-index:99999}
#bl-app .modal{background:var(--bg);border-radius:8px;max-width:820px;width:100%;padding:18px;border-top:6px solid var(--sage)}
#bl-app table{width:100%;border-collapse:collapse;font-size:14px}
#bl-app td,#bl-app th{border-bottom:1px solid var(--line);padding:8px 8px;text-align:left;vertical-align:top}
#bl-app th{font-family:var(--fu);font-size:11.5px;text-transform:uppercase;letter-spacing:.04em;color:var(--mut);font-weight:600}
#bl-app td.n,#bl-app th.n{text-align:right;white-space:nowrap}
#bl-app .tbl{overflow-x:auto;background:#fff;border:1px solid var(--line);border-radius:6px}
/* Fiches logement façon site web */
#bl-app .lg{padding:0;overflow:hidden;display:flex;flex-direction:column}
#bl-app .lg .ph{aspect-ratio:4/3;background:var(--s2) center/cover no-repeat;display:flex;align-items:flex-end;justify-content:flex-start;padding:8px}
#bl-app .lg .ph.vide{display:grid;place-items:center;color:var(--mut);font-size:13px}
#bl-app .lg .in{padding:12px 14px;border-top:4px solid var(--pri)}
#bl-app .lg .ad{font-family:var(--fh);font-weight:700;font-size:1.08rem;line-height:1.25}
#bl-app .lg .px{color:var(--pri);font-weight:700;font-size:1.05rem;margin-top:2px}
#bl-app .gal{display:grid;grid-template-columns:repeat(auto-fill,minmax(130px,1fr));gap:8px}
#bl-app .gal a,#bl-app .gal span{display:block;aspect-ratio:4/3;border-radius:6px;overflow:hidden;background:var(--s2)}
#bl-app .gal img{width:100%;height:100%;object-fit:cover;display:block}
#bl-app .hero{width:100%;max-height:340px;object-fit:cover;border-radius:6px;display:block;margin-bottom:10px}
/* Ma journée */
#bl-app .vis{display:grid;grid-template-columns:78px 1fr;gap:12px}
#bl-app .heure{font-family:var(--fh);font-weight:900;font-size:1.5rem;line-height:1.1}
#bl-app .tel{font-family:var(--fu);font-weight:700;font-size:1.05rem;color:var(--pri);text-decoration:none;white-space:nowrap}
#bl-app .cles{margin-top:10px;padding:12px;border:2px dashed var(--pri);border-radius:6px;background:#fff}
#bl-app .stat{background:#fff;border:1px solid var(--line);border-radius:6px;padding:10px 12px}
#bl-app .stat b{display:block;font-family:var(--fh);font-size:1.55rem;line-height:1.1}
#bl-app .stat span{font-family:var(--fu);font-size:11px;color:var(--mut);text-transform:uppercase;letter-spacing:.05em}
#bl-app .stats{display:grid;grid-template-columns:repeat(auto-fill,minmax(150px,1fr));gap:10px;margin-bottom:16px}
#bl-app .hb{display:flex;align-items:center;gap:8px;font-size:13px;margin:3px 0}
#bl-app .hb .l{width:92px;flex:0 0 auto;color:var(--mut)}
#bl-app .hb .b{height:14px;background:var(--pri);border-radius:3px;min-width:2px}
#bl-app .score{font-family:var(--fh);font-weight:900;font-size:1.25rem;color:var(--pri)}
#bl-app .alerte{border-left:5px solid var(--bad);background:var(--bad-soft);padding:8px 10px;border-radius:4px;margin:6px 0;font-size:14px}
#bl-app .piste{border-left:5px solid var(--ok);background:var(--ok-soft);padding:8px 10px;border-radius:4px;margin:6px 0;font-size:14px}
#bl-app .bientot{text-align:center;padding:40px 16px;color:var(--mut)}
@media (max-width:640px){#bl-app .row{grid-template-columns:1fr}#bl-app .kv{grid-template-columns:1fr}#bl-app .kv>div:nth-child(odd){margin-top:6px}
  #bl-app .bl-top img{height:36px}#bl-app .bl-esp{margin-left:0;width:100%}#bl-app .vis{grid-template-columns:62px 1fr}#bl-app .heure{font-size:1.25rem}
  #bl-app .ov{padding:0}#bl-app .modal{border-radius:0;min-height:100%}}
/* ===== Lisibilité et facilité : textes plus gros, pas de majuscules partout, gros boutons, tout visible ===== */
body.page-id-8489 .entry-title,body.page-id-8489 .main_title{display:none}
#bl-app{font-size:17px;line-height:1.55;--mut:#4f5656;--line:#c9d2d2}
#bl-app h2{text-transform:none;letter-spacing:0;font-size:1.5rem}
#bl-app h3{font-size:1.15rem}
#bl-app .mut,#bl-app .small{font-size:15px}
#bl-app .bl-titre{font-size:1.1rem}
#bl-app .bl-user{font-size:15px;white-space:normal}
#bl-app .bl-user a{font-weight:700}
#bl-app .bl-esp{display:grid;grid-template-columns:repeat(auto-fill,minmax(150px,1fr));gap:8px;width:100%;margin-left:0}
#bl-app .bl-esp button{text-transform:none;letter-spacing:0;font-size:1.02rem;border-radius:12px;padding:12px 10px;min-height:54px}
#bl-app .tabs{display:grid;grid-template-columns:repeat(auto-fill,minmax(170px,1fr));gap:8px;overflow:visible;border-bottom:0;padding:12px;background:#fff;margin:-16px -16px 16px}
#bl-app .tabs button{text-transform:none;letter-spacing:0;font-size:1rem;font-weight:700;color:#2f3434;background:#fff;border:2px solid var(--line);border-radius:12px;padding:12px 10px;min-height:56px;line-height:1.25}
#bl-app .tabs button.on{background:var(--pri);border-color:var(--pri);color:#fff}
#bl-app label{text-transform:none;letter-spacing:0;font-size:1rem;color:#2f3434;font-weight:700}
#bl-app input,#bl-app select,#bl-app textarea{font-size:17px;padding:12px 14px;min-height:50px;border-width:2px}
#bl-app input[type=checkbox],#bl-app input[type=radio]{min-height:0;width:24px;height:24px}
#bl-app input:focus,#bl-app select:focus,#bl-app textarea:focus,#bl-app button:focus-visible{outline:3px solid var(--pri);outline-offset:1px}
#bl-app .btn{text-transform:none;letter-spacing:0;font-size:1rem;min-height:50px;padding:10px 18px;border-radius:10px}
#bl-app .btn.small{min-height:44px;font-size:.95rem;padding:8px 14px}
#bl-app .chip{font-size:1rem;padding:10px 16px;min-height:46px}
#bl-app .badge{font-size:13.5px;padding:4px 10px}
#bl-app .stat span,#bl-app th{text-transform:none;letter-spacing:0;font-size:13.5px}
#bl-app .msg{font-size:16px}
#bl-app .kv{font-size:16px}
#bl-app table{font-size:15.5px}
@media (max-width:640px){#bl-app .tabs,#bl-app .bl-esp{grid-template-columns:1fr 1fr}#bl-app .tabs button{font-size:.98rem}}
#bl-app .b-reno{background:#ece4f7;color:#6a3fa0}
#bl-app .lg .ph .badge{font-size:14px;padding:6px 12px;box-shadow:0 1px 4px rgba(0,0,0,.25)}
#bl-app .lg .ph.vide{flex-direction:column;gap:8px}
#bl-app .px-vieux{text-decoration:line-through;color:var(--mut);font-weight:600}
#bl-app .px-rabais{color:var(--bad);font-weight:800;font-size:1.2em}
#bl-app .incls{display:flex;flex-wrap:wrap;gap:6px;margin:8px 0}
#bl-app .incl{background:var(--s2);border-radius:999px;padding:4px 10px;font-size:14px;white-space:nowrap}
#bl-app .cp{border:1px solid var(--line);background:#fff;border-radius:8px;padding:3px 8px;font-size:13px;cursor:pointer;margin-left:4px}
#bl-app .cp.ok{background:var(--ok-soft);border-color:var(--ok);color:var(--ok)}
#bl-app mark.loin{background:#ffe066;color:#5a4700;padding:2px 6px;border-radius:4px;font-weight:700}
#bl-app select.st-sel{width:auto;min-height:40px;padding:6px 10px;font-weight:700;border-radius:999px;border:2px solid var(--sc,#999);color:var(--sc,#333);background:#fff;font-size:15px}
#bl-app .appel{border-left:4px solid var(--line);padding:6px 10px;margin:6px 0;background:var(--s2);border-radius:0 6px 6px 0;font-size:15px}
#bl-app .grp-titre{display:flex;align-items:center;gap:10px;margin:18px 0 8px}
#bl-app .retard{color:var(--bad);font-weight:800}
</style>
<div class="bl-top"><a href="https://lesgestionsbestlife.com"><img src="https://lesgestionsbestlife.com/wp-content/uploads/2021/10/Logo-2.png" alt="Les Gestions Bestlife"></a>
  <div class="bl-titre">Portail <span>Bestlife</span></div><nav class="bl-esp" id="bl-esp"></nav><div class="bl-user" id="bl-user"></div></div>
<div id="bl-root">Chargement…</div>
</div>
<style>
#mnt{
  --bg:#f3f5f5; --surface:#ffffff; --surface-2:#eef2f2; --ink:#333333; --muted:#666666; --line:#d6dddd;
  --accent:#c4704f; --accent-ink:#ffffff; --accent-soft:#f6e4dc; --brand:#d08770; --sage:#aabcbf; --sage-ink:#3d3d3d;
  --urgent:#bb3354; --urgent-soft:#f9e1e7; --ok-soft:#e1f2e8;
  --shadow:0 1px 2px rgba(30,30,30,.05),0 4px 14px rgba(30,30,30,.06);
  --f-head:"Heebo","Helvetica Neue",Arial,sans-serif;
  --f-ui:"Poppins","Helvetica Neue",Arial,sans-serif;
  --f-body:"Open Sans",system-ui,-apple-system,"Segoe UI",Arial,sans-serif;
  --r:6px;
}#mnt *{box-sizing:border-box}#mnt{background:var(--bg);color:var(--ink);font-family:var(--f-body);font-size:15.5px;line-height:1.5;margin:0}#mnt-nope{content:"";position:fixed;inset:0 0 auto;height:env(safe-area-inset-top,0px);z-index:30;background:var(--sage)}#mnt h1,#mnt h2,#mnt h3{font-family:var(--f-head);text-wrap:balance;margin:0}#mnt .view-head h2,#mnt .sheet-head h2,#mnt .bill-head h3,#mnt .empty h3{text-transform:uppercase;letter-spacing:.02em}#mnt .btn,#mnt .chip,#mnt nav.tabs a,#mnt .field label,#mnt .stat span,#mnt .pill,#mnt .statusbar button,#mnt th{font-family:var(--f-ui)}#mnt .btn{text-transform:uppercase;letter-spacing:.04em;font-size:.88rem}#mnt .grp{display:flex;align-items:center;gap:10px;margin:18px 0 8px}#mnt .grp:first-child{margin-top:0}#mnt button,#mnt input,#mnt select,#mnt textarea{font:inherit;color:inherit}#mnt .num{font-variant-numeric:tabular-nums}#mnt :focus-visible{outline:2px solid var(--accent);outline-offset:2px}#mnt header.top{position:sticky;top:env(safe-area-inset-top,0px);z-index:20;background:var(--surface);border-top:6px solid var(--sage);border-bottom:1px solid var(--line)}#mnt .top-inner{max-width:980px;margin:0 auto;padding-block:10px 0;padding-left:max(16px,env(safe-area-inset-left,0px));padding-right:max(16px,env(safe-area-inset-right,0px))}#mnt .brand{display:flex;align-items:baseline;justify-content:space-between;gap:12px;flex-wrap:wrap}#mnt .brand h1{font-size:1.15rem;font-weight:900;text-transform:uppercase;letter-spacing:.06em}#mnt .brand h1 span{color:var(--brand);font-weight:700}#mnt .who{font-size:.85rem;color:var(--muted)}#mnt nav.tabs{display:flex;gap:4px;overflow-x:auto;margin-top:8px;scrollbar-width:none}#mnt nav.tabs a{flex:0 0 auto;font-weight:600;font-size:.85rem;text-transform:uppercase;letter-spacing:.04em;text-decoration:none;color:var(--muted);padding:8px 12px 10px;border-bottom:3px solid transparent;white-space:nowrap}#mnt nav.tabs a[aria-current="page"]{color:var(--ink);border-bottom-color:var(--brand)}#mnt nav.tabs a .badge{display:inline-block;min-width:20px;padding:0 6px;margin-left:6px;border-radius:10px;background:var(--accent-soft);color:var(--accent);font-size:.8rem;text-align:center}#mnt main{max-width:980px;margin:0 auto;padding-block:18px 96px;padding-left:max(16px,env(safe-area-inset-left,0px));padding-right:max(16px,env(safe-area-inset-right,0px))}#mnt .banner{padding:10px 14px;border-radius:var(--r);background:var(--surface-2);border:1px solid var(--line);color:var(--muted);font-size:.92rem;margin-bottom:14px}#mnt .banner.warn{background:var(--urgent-soft);border-color:transparent;color:var(--ink)}#mnt .view-head{display:flex;justify-content:space-between;align-items:flex-end;gap:12px;flex-wrap:wrap;margin-bottom:14px}#mnt .view-head h2{font-size:1.6rem;font-weight:700}#mnt .view-head p{margin:2px 0 0;color:var(--muted);font-size:.95rem}#mnt .stats{display:grid;grid-template-columns:repeat(5,minmax(0,1fr));gap:10px;margin-bottom:18px}#mnt .stat{background:var(--surface);border:1px solid var(--line);border-radius:var(--r);padding:10px 12px}#mnt .stat b{display:block;font-family:var(--f-head);font-size:1.6rem;line-height:1.1}#mnt .stat span{font-size:.8rem;color:var(--muted);text-transform:uppercase;letter-spacing:.05em}@media (max-width:760px){#mnt .stats{grid-template-columns:repeat(3,minmax(0,1fr))}}@media (max-width:460px){#mnt .stats{grid-template-columns:repeat(2,minmax(0,1fr))}}#mnt .filters{display:flex;gap:8px;flex-wrap:wrap;margin-bottom:12px}#mnt .filters input,#mnt .filters select{padding:8px 10px;border:1px solid var(--line);border-radius:8px;background:var(--surface);min-width:0}#mnt .filters input{flex:1 1 200px}#mnt .chips{display:flex;gap:6px;flex-wrap:wrap}#mnt .chip{border:1px solid var(--line);background:var(--surface);border-radius:999px;padding:5px 12px;font-size:.88rem;cursor:pointer}#mnt .chip[aria-pressed="true"]{background:var(--ink);color:var(--bg);border-color:var(--ink)}#mnt .list{display:grid;gap:10px}#mnt .card{background:var(--surface);border:1px solid var(--line);border-radius:var(--r);box-shadow:var(--shadow);padding:12px 14px 12px 16px;position:relative;cursor:pointer;display:grid;gap:6px;min-width:0}#mnt .card::before{content:"";position:absolute;left:0;top:10px;bottom:10px;width:4px;border-radius:0 4px 4px 0;background:var(--sc,var(--line))}#mnt .card:hover{border-color:var(--muted)}#mnt .card .row1{display:flex;justify-content:space-between;gap:10px;align-items:flex-start}#mnt .card .addr{font-family:var(--f-head);font-weight:600;font-size:1.12rem;line-height:1.2;min-width:0;overflow-wrap:anywhere}#mnt .card .desc{color:var(--ink);font-size:.95rem;overflow-wrap:anywhere;display:-webkit-box;-webkit-line-clamp:2;-webkit-box-orient:vertical;overflow:hidden}#mnt .card .meta{display:flex;gap:10px;flex-wrap:wrap;color:var(--muted);font-size:.85rem}#mnt .pill{display:inline-flex;align-items:center;gap:5px;font-size:.74rem;font-weight:600;padding:3px 10px;border-radius:4px;white-space:nowrap;background:var(--sc,var(--muted));color:var(--si,#fff)}#mnt .pill.urgent{background:var(--urgent-soft);color:var(--urgent);border-color:transparent}#mnt .timer-live{color:var(--accent);font-weight:700}#mnt .empty{text-align:center;padding:36px 16px;color:var(--muted);background:var(--surface);border:1px dashed var(--line);border-radius:var(--r)}#mnt .empty h3{color:var(--ink);font-size:1.2rem;margin-bottom:6px}#mnt .btn{display:inline-flex;align-items:center;justify-content:center;gap:6px;border:1px solid var(--line);background:var(--surface);border-radius:8px;padding:9px 14px;font-weight:600;cursor:pointer;min-height:42px}#mnt .btn:hover{border-color:var(--muted)}#mnt .btn.primary{background:var(--accent);color:var(--accent-ink);border-color:var(--accent)}#mnt .btn.big{min-height:52px;font-size:1.05rem;padding:12px 18px}#mnt .btn.danger{color:var(--urgent)}#mnt .btn[disabled]{opacity:.5;cursor:not-allowed}#mnt .btns{display:flex;gap:8px;flex-wrap:wrap}#mnt form.grid,#mnt .fgrid{display:grid;grid-template-columns:repeat(2,minmax(0,1fr));gap:12px}#mnt .field{display:grid;gap:4px;min-width:0}#mnt .field.full{grid-column:1/-1}#mnt .field label{font-size:.8rem;font-weight:600;color:var(--muted);text-transform:uppercase;letter-spacing:.05em}#mnt .field input,#mnt .field select,#mnt .field textarea{width:100%;padding:10px 12px;border:1px solid var(--line);border-radius:8px;background:var(--surface);min-width:0}#mnt .field textarea{min-height:90px;resize:vertical}@media (max-width:560px){#mnt form.grid,#mnt .fgrid{grid-template-columns:minmax(0,1fr)}}#mnt .panel{background:var(--surface);border:1px solid var(--line);border-radius:var(--r);padding:16px}#mnt .sheet-back{position:fixed;inset:0;background:rgba(10,18,16,.45);z-index:40}#mnt .sheet{position:fixed;z-index:41;top:0;right:0;bottom:0;width:min(560px,100%);background:var(--bg);overflow-y:auto;box-shadow:-8px 0 30px rgba(0,0,0,.2);
  padding-top:calc(env(safe-area-inset-top,0px) + 12px);padding-bottom:calc(env(safe-area-inset-bottom,0px) + 24px);padding-right:max(16px,env(safe-area-inset-right,0px));padding-left:16px}#mnt .sheet-head{display:flex;justify-content:space-between;gap:10px;align-items:flex-start;margin-bottom:10px}#mnt .sheet-head h2{font-size:1.4rem;overflow-wrap:anywhere}#mnt .close{border:0;background:var(--surface);border-radius:8px;width:40px;height:40px;font-size:1.3rem;cursor:pointer;flex:0 0 auto}#mnt .sec{margin-top:16px}#mnt .sec h3{font-size:1.05rem;font-weight:700;margin-bottom:8px;display:flex;justify-content:space-between;align-items:center;gap:8px}#mnt .lines{display:grid;gap:6px}#mnt .line{display:flex;justify-content:space-between;gap:10px;background:var(--surface);border:1px solid var(--line);border-radius:8px;padding:8px 10px;font-size:.93rem}#mnt .line .l{min-width:0;overflow-wrap:anywhere}#mnt .line .r{white-space:nowrap;display:flex;gap:8px;align-items:center}#mnt .x{border:0;background:none;color:var(--muted);cursor:pointer;font-size:1.1rem;padding:0 4px}#mnt .inline{display:flex;gap:6px;flex-wrap:wrap;margin-top:8px}#mnt .inline input{flex:1 1 120px;min-width:0;padding:9px 10px;border:1px solid var(--line);border-radius:8px;background:var(--surface)}#mnt .chrono{display:flex;align-items:center;justify-content:space-between;gap:12px;background:var(--accent-soft);border-radius:var(--r);padding:12px 14px}#mnt .chrono b{font-family:var(--f-head);font-size:1.8rem}#mnt .photos{display:grid;grid-template-columns:repeat(auto-fill,minmax(90px,1fr));gap:8px}#mnt .photos a{display:block;aspect-ratio:1;border-radius:8px;overflow:hidden;background:var(--surface-2);max-width:100%}#mnt .photos img{width:100%;height:100%;object-fit:cover;display:block}#mnt .statusbar{display:flex;gap:6px;flex-wrap:wrap}#mnt .statusbar{display:grid!important;grid-template-columns:repeat(auto-fill,minmax(150px,1fr))}#mnt .statusbar button{border:3px solid transparent;background:var(--sc);color:var(--si,#fff);border-radius:4px;padding:8px 10px;font-size:.82rem;font-weight:600;cursor:pointer;opacity:.55}#mnt .statusbar button[aria-pressed="true"]{opacity:1;border-color:var(--ink)}#mnt .statusbar button:hover{opacity:.9}#mnt .confirm{margin-top:8px;padding:10px;border-radius:8px;background:var(--urgent-soft);display:flex;gap:8px;align-items:center;flex-wrap:wrap;font-size:.9rem}#mnt .bill{background:var(--surface);border:1px solid var(--line);border-radius:var(--r);margin-bottom:12px;overflow:hidden}#mnt .bill-head{display:flex;justify-content:space-between;align-items:center;gap:10px;flex-wrap:wrap;padding:12px 14px;border-bottom:1px solid var(--line);background:var(--surface-2)}#mnt .bill-head h3{font-size:1.15rem}#mnt .bill-total{font-family:var(--f-head);font-size:1.3rem;font-weight:700}#mnt .tbl-wrap{overflow-x:auto}#mnt table{width:100%;border-collapse:collapse;font-size:.92rem}#mnt th,#mnt td{text-align:left;padding:8px 12px;border-bottom:1px solid var(--line);vertical-align:top}#mnt th{font-size:.75rem;text-transform:uppercase;letter-spacing:.05em;color:var(--muted);font-weight:600}#mnt td.n,#mnt th.n{text-align:right;white-space:nowrap}#mnt .bill-foot{display:flex;gap:8px;flex-wrap:wrap;padding:10px 14px;align-items:center}#mnt .bill-foot input{padding:8px 10px;border:1px solid var(--line);border-radius:8px;background:var(--surface);min-width:0;flex:1 1 140px}#mnt .clock{display:flex;align-items:center;justify-content:space-between;gap:14px;flex-wrap:wrap;background:var(--surface);border:1px solid var(--line);border-left:6px solid var(--sage);border-radius:var(--r);padding:16px 18px;margin-bottom:10px}#mnt .clock b{font-family:var(--f-head);font-weight:900;font-size:2.4rem;line-height:1.1}#mnt .clock.running{border-left-color:var(--brand);background:var(--accent-soft)}#mnt .clock.done{border-left-color:#00a862}#mnt .step{padding:14px 0;border-bottom:1px solid var(--line)}#mnt .step:first-child{padding-top:0}#mnt .step h3{font-size:1.05rem;display:flex;align-items:center;gap:10px;margin-bottom:10px}#mnt .stepn{display:inline-grid;place-items:center;width:26px;height:26px;border-radius:50%;background:var(--sage);color:var(--sage-ink);font-family:var(--f-ui);font-size:.85rem;flex:0 0 auto}#mnt .opts{display:grid;grid-template-columns:repeat(auto-fill,minmax(190px,1fr));gap:6px}#mnt .opt{display:flex;gap:8px;align-items:center;padding:8px 10px;border:1px solid var(--line);border-radius:6px;background:var(--surface);cursor:pointer;font-size:.93rem}#mnt .opt input{width:18px;height:18px;accent-color:var(--brand)}#mnt input.qte{width:70px;padding:6px 8px;border:1px solid var(--line);border-radius:6px;background:var(--surface)}#mnt .tags{display:flex;gap:6px;flex-wrap:wrap;align-items:center}#mnt .tag-rep{background:var(--accent-soft);color:var(--accent);border-color:transparent}#mnt .tag{font-size:.78rem;font-weight:600;padding:2px 9px;border-radius:999px;background:var(--surface-2);border:1px solid var(--line)}#mnt .av{font-family:var(--f-ui);font-size:.74rem;font-weight:600;padding:3px 10px;border-radius:4px;background:var(--sage);color:var(--sage-ink);text-transform:uppercase;letter-spacing:.03em}#mnt .av-en_cours{background:#0f7c8c;color:#fff}#mnt .av-en_attente{background:#f2b705;color:#2b2200}#mnt .av-termine{background:#037f4c;color:#fff}#mnt .av-termine_facturer{background:#8cc21f;color:#1d2a00}#mnt h2.sub{font-size:1.2rem;text-transform:uppercase;letter-spacing:.02em;margin:26px 0 10px;padding-top:16px;border-top:2px solid var(--line)}#mnt .finish{margin-top:10px;padding:12px;border:2px solid var(--brand);border-radius:var(--r);background:var(--surface)}#mnt .solution{margin-top:10px;padding:10px 12px;border-left:4px solid #037f4c;background:var(--ok-soft);border-radius:4px;font-size:.93rem}#mnt .revs{display:grid;gap:8px;margin-top:6px;font-size:.88rem}#mnt .revs>div{padding:8px 10px;border-left:3px solid var(--brand);background:var(--surface-2);border-radius:4px}#mnt .linkbtn{border:0;background:none;color:var(--accent);font-size:.82rem;cursor:pointer;padding:0;text-decoration:underline}#mnt .immq{width:100%;padding:10px 12px;border:1px solid var(--line);border-radius:6px 6px 0 0;background:var(--surface-2);border-bottom:0}#mnt .immq+select{border-radius:0 0 6px 6px!important}#mnt .plage{display:flex;flex-wrap:wrap;align-items:flex-end;gap:10px}#mnt .plage .field{flex:0 1 150px}#mnt .plage input[type=time],#mnt .plage input[type=date]{font-size:1.15rem;font-variant-numeric:tabular-nums}#mnt .plage-sep{font-size:1.4rem;padding-bottom:10px;color:var(--muted)}#mnt .plage-total{display:grid;margin-left:auto;text-align:right}#mnt .plage-total b{font-family:var(--f-head);font-weight:900;font-size:1.6rem}#mnt .flag{display:inline-block;font-family:var(--f-ui);font-size:.7rem;font-weight:700;padding:2px 8px;border-radius:4px;margin-left:4px;letter-spacing:.03em;vertical-align:1px}#mnt .flag-urg{background:#d0273e;color:#fff}#mnt .flag-hors{background:#6b3fa0;color:#fff}#mnt .line-urg{border-left:5px solid #d0273e;background:#fdecef}#mnt .line-hors{border-left:5px solid #6b3fa0;background:#f3ecfa}#mnt .txt-urg{color:#d0273e;font-weight:700}#mnt .txt-hors{color:#6b3fa0;font-weight:700}#mnt .row-hors td{background:#f3ecfa}#mnt .stat-urg{border-color:#d0273e;border-left:5px solid #d0273e}#mnt .stat-urg b{color:#d0273e}#mnt .stat-hors{border-color:#6b3fa0;border-left:5px solid #6b3fa0}#mnt .stat-hors b{color:#6b3fa0}#mnt .card-urg{border-color:#d0273e;background:#fff6f7}#mnt .microw{display:flex;align-items:center;gap:10px;flex-wrap:wrap;margin:2px 0 4px}#mnt .mic{font-family:var(--f-ui);font-weight:600;font-size:.88rem;border:2px solid var(--brand);color:var(--brand);background:var(--surface);border-radius:999px;padding:8px 16px;cursor:pointer;min-height:42px}#mnt .mic.on{background:var(--brand);color:#fff;animation:pulse 1.4s ease-in-out infinite}@keyframes pulse{50%{box-shadow:0 0 0 6px rgba(208,135,112,.25)}}@media (prefers-reduced-motion:reduce){#mnt .mic.on{animation:none}}#mnt .mic-live{font-size:.88rem;color:var(--muted);font-style:italic;min-width:0;overflow-wrap:anywhere}#mnt .mic-hint{font-size:.8rem;color:var(--muted)}#mnt .toast{position:fixed;left:50%;transform:translateX(-50%);bottom:calc(env(safe-area-inset-bottom,0px) + 18px);background:var(--ink);color:var(--bg);padding:10px 16px;border-radius:8px;z-index:60;font-weight:600;max-width:calc(100% - 32px)}#mnt .who::before{content:"Connecté : "}#mnt .e-desc{display:block;margin-top:2px}@media (max-width:640px){#mnt{font-size:16px}#mnt header.top{border-top-width:4px}#mnt .top-inner{padding-top:8px}#mnt .brand{flex-wrap:nowrap;align-items:center}#mnt .brand h1{font-size:1rem;letter-spacing:.04em;white-space:nowrap;min-width:0;overflow:hidden;text-overflow:ellipsis}#mnt .brand .h-long{display:none}#mnt .who{font-size:.8rem;white-space:nowrap;flex:0 0 auto}#mnt .who::before{content:""}#mnt nav.tabs{margin-top:4px;gap:0}#mnt nav.tabs a{padding:10px 10px 10px;font-size:.8rem;letter-spacing:.02em}#mnt main{padding-top:14px}#mnt .view-head{margin-bottom:10px}#mnt .view-head h2{font-size:1.35rem}#mnt .view-head p{font-size:.88rem}#mnt .sec h3{flex-direction:column;align-items:flex-start;gap:2px;font-size:1.1rem}#mnt .line-e{flex-direction:column;align-items:stretch;gap:8px;padding:12px}#mnt .line-e .l{font-size:1rem;line-height:1.45}#mnt .line-e .r{white-space:normal;flex-wrap:wrap;justify-content:flex-start;gap:10px;border-top:1px solid var(--line);padding-top:8px}#mnt .line-e .r b{font-size:1.15rem;margin-right:auto}#mnt .line-e .r>.muted{order:-1;width:100%}#mnt .line .x{min-width:44px;min-height:44px;font-size:1.35rem;border:1px solid var(--line);border-radius:8px;background:var(--surface)}#mnt .linkbtn{font-size:.9rem;padding:4px 0}#mnt .clock{padding:14px}#mnt .clock b{font-size:2.1rem}#mnt .clock .btns,#mnt .clock>.btn{width:100%}#mnt .clock .btns .btn,#mnt .clock>.btn{flex:1 1 100%}#mnt .plage .field{flex:1 1 calc(50% - 20px)}#mnt .plage-sep{display:none}#mnt .plage-total{margin-left:0;text-align:left;flex:1 1 100%}#mnt .btns .btn.big{flex:1 1 100%}#mnt .opts{grid-template-columns:1fr 1fr}#mnt .opt{padding:10px}#mnt .chip{padding:8px 14px;font-size:.92rem}#mnt .statusbar{grid-template-columns:1fr 1fr}#mnt .statusbar button{padding:10px 8px;min-height:44px}#mnt .field input,#mnt .field select,#mnt .field textarea{font-size:16px;padding:12px}#mnt .inline input{font-size:16px;padding:11px 10px}#mnt .card .addr{font-size:1.05rem}#mnt .sheet{padding-left:14px;padding-right:14px}#mnt th,#mnt td{padding:8px 8px}#mnt td:first-child{white-space:nowrap}#mnt .sheet-head h2{font-size:1.15rem;text-transform:none;letter-spacing:0;line-height:1.3}#mnt .brand h1{font-size:.95rem}#mnt .toast{bottom:calc(env(safe-area-inset-bottom,0px) + 12px)}}#mnt .muted{color:var(--muted)}#mnt .flagx{font-family:var(--f-ui);font-size:.72rem;font-weight:700;padding:2px 9px;border-radius:4px;letter-spacing:.02em}#mnt .f-eau{background:#1f6fb2;color:#fff}#mnt .f-appr{background:#3f3d8f;color:#fff}#mnt .f-refus{background:#333;color:#fff}#mnt .f-ret{background:#d0273e;color:#fff}#mnt a.alert-bar{display:block;text-decoration:none;font-weight:600}#mnt .al-item{display:grid;gap:6px;margin-bottom:12px}#mnt .al-item .btns .btn{min-height:40px}#mnt .appr-box{margin-top:12px;padding:12px;border:2px solid #3f3d8f;border-radius:var(--r);background:var(--surface)}#mnt .small{font-size:.85rem}#mnt .apercu{display:flex;align-items:center;gap:6px;font-family:var(--f-ui);font-size:.8rem;color:var(--muted)}#mnt .apercu select{padding:4px 8px;border:1px solid var(--line);border-radius:6px;background:var(--surface);font-size:.85rem;max-width:180px}#mnt .apercu-bar{display:flex;align-items:center;justify-content:space-between;gap:10px;flex-wrap:wrap;background:#2f5d8a;color:#fff;border-color:transparent}#mnt .apercu-bar .btn{min-height:36px;padding:6px 12px}@media (max-width:640px){#mnt .apercu span{display:none}#mnt .apercu select{max-width:130px}}@media (prefers-reduced-motion:no-preference){#mnt .sheet{animation:slide .18s ease-out}@keyframes slide{from{transform:translateX(24px);opacity:.6}to{transform:none;opacity:1}}}
/* ===== Lisibilité et facilité (utilisateurs moins à l'aise avec la technologie) ===== */
#mnt{font-size:17px;line-height:1.55;--muted:#4f5656}
#mnt .view-head h2,#mnt .sheet-head h2,#mnt .bill-head h3,#mnt .empty h3,#mnt h2.sub{text-transform:none;letter-spacing:0}
#mnt .view-head h2{font-size:1.55rem}
#mnt .view-head p{font-size:1rem;color:#3f4545}
#mnt .btn{text-transform:none;letter-spacing:0;font-size:1rem;min-height:50px;padding:10px 18px;border-radius:10px}
#mnt .btn.primary{font-weight:700}
#mnt .chip{font-size:1rem;padding:10px 16px;min-height:46px}
#mnt .chip[aria-pressed="true"]{outline:3px solid var(--brand);outline-offset:1px}
#mnt .field label{text-transform:none;letter-spacing:0;font-size:1rem;color:#2f3434;font-weight:700}
#mnt .field input,#mnt .field select,#mnt .field textarea{font-size:17px;padding:13px 14px;min-height:50px;border-width:2px}
#mnt .field input:focus,#mnt .field select:focus,#mnt .field textarea:focus{outline:3px solid var(--brand);outline-offset:1px}
#mnt .step h3{font-size:1.15rem}
#mnt .stepn{width:32px;height:32px;font-size:1rem}
#mnt .small{font-size:.95rem}
#mnt .mic{min-height:46px;font-size:1rem;padding:8px 14px}
/* Onglets : tous visibles d'un coup (plus besoin de glisser de côté) */
#mnt nav.tabs{display:grid;grid-template-columns:repeat(auto-fill,minmax(160px,1fr));gap:8px;overflow:visible;margin-top:10px}
#mnt nav.tabs a{display:flex;align-items:center;justify-content:center;gap:6px;text-align:center;white-space:normal;text-transform:none;letter-spacing:0;font-size:1rem;font-weight:700;color:#2f3434;background:#fff;border:2px solid var(--line);border-radius:12px;padding:12px 10px;min-height:56px}
#mnt nav.tabs a[aria-current="page"]{background:var(--brand);border-color:var(--brand);color:#fff}
#mnt nav.tabs a[aria-current="page"] .badge{background:#fff}
#mnt nav.tabs a.tab-urg{border-color:#bb3354;color:#bb3354}
#mnt nav.tabs a.tab-urg[aria-current="page"]{background:#bb3354;color:#fff}
#mnt nav.tabs a[hidden]{display:none}
#mnt nav.tabs a{display:block;padding:14px 8px}
#mnt nav.tabs .badge[hidden]{display:none!important}
@media (max-width:640px){#mnt nav.tabs{grid-template-columns:1fr 1fr}}

/* ===== Urgences ===== */
#mnt .u-big{min-height:58px;font-size:1.08rem;padding:12px 22px}
#mnt .u-back{min-height:50px}
#mnt .u-danger{background:#fbe3e8;border:2px solid #bb3354;border-radius:12px;padding:14px 16px;margin:0 0 16px;font-size:1.02rem;color:#3a1d25}
#mnt .u-tel{display:flex;flex-wrap:wrap;gap:10px;margin-top:10px}
#mnt .u-tel .btn{flex:1 1 150px;flex-direction:column;line-height:1.2;text-decoration:none}
#mnt .u-tel a.btn{color:#2f3434;background:#fff;opacity:1}
#mnt .u-tel a.btn.u-911{color:#fff;background:#bb3354}
#mnt .u-tel .btn small{font-weight:600;font-size:.85rem}
#mnt .u-911{background:#bb3354;border-color:#bb3354;color:#fff;font-size:1.25rem}
#mnt .u-head h2{font-size:1.5rem;margin:0}
#mnt .u-head p{margin:4px 0 8px;color:#3f4545}
#mnt .u-list{display:grid;gap:10px}
#mnt .u-card{display:grid;gap:4px;text-align:left;width:100%;background:#fff;border:2px solid var(--line);border-left:8px solid #8aa;border-radius:12px;padding:14px 16px;cursor:pointer;font:inherit;color:inherit}
#mnt .u-card.u-open{border-left-color:#bb3354}
#mnt .u-card-t{font-weight:800;font-size:1.12rem}
#mnt .u-card-m{color:#4f5656;font-size:.95rem}
#mnt .u-chips .chip{flex:1 1 200px;text-align:left}
#mnt .u-photos{display:grid;grid-template-columns:repeat(auto-fill,minmax(110px,1fr));gap:8px;margin-top:10px}
#mnt .u-ph{display:block;aspect-ratio:1;border-radius:10px;overflow:hidden;background:#eef2f2}
#mnt .u-ph img{width:100%;height:100%;object-fit:cover;display:block}
#mnt .u-ia{background:#f2f6ff;border:2px solid #b9cbee;border-radius:12px;padding:14px 16px;margin:14px 0}
#mnt .u-chat{display:grid;gap:10px;margin:10px 0}
#mnt .u-msg{padding:12px 14px;border-radius:12px;font-size:1.02rem;line-height:1.55;max-width:100%;overflow-wrap:anywhere}
#mnt .u-msg .u-who{display:block;font-weight:800;font-size:.85rem;margin-bottom:4px;color:#4f5656}
#mnt .u-moi{background:#fff;border:2px solid var(--line);margin-left:12%}
#mnt .u-ia-msg{background:#fff;border:2px solid #b9cbee;margin-right:6%}
#mnt .u-wait{font-weight:700;color:#2f6fb3;animation:upulse 1.4s ease-in-out infinite}
@keyframes upulse{50%{opacity:.45}}
#mnt .u-gsec{background:#fff;border:2px solid var(--line);border-radius:12px;padding:12px 14px;margin:10px 0}
#mnt .u-gsec>b{display:block;font-size:1.05rem;margin-bottom:6px}
#mnt .u-gitem{display:flex;gap:12px;align-items:flex-start;padding:8px 0;font-size:1.02rem;cursor:pointer;border-top:1px solid #eef2f2}
#mnt .u-gitem:first-of-type{border-top:0}
#mnt .u-gitem input{width:28px;height:28px;flex:0 0 28px;margin:0;accent-color:#037f4c}
#mnt .u-gitem input:checked+span{color:#4f5656;text-decoration:line-through}
#mnt .u-ia-off{font-size:1rem}
/* ===== Paye ===== */
#mnt .grid2{display:grid;grid-template-columns:1fr 1fr;gap:10px}
@media (max-width:640px){#mnt .grid2{grid-template-columns:1fr}}
#mnt .p-banque{display:flex;justify-content:space-between;align-items:center;gap:10px;background:#e1f2e8;border:2px solid #9ccfb2;border-radius:12px;padding:14px 16px;margin:12px 0;font-size:1.05rem}
#mnt .p-banque b{font-size:1.6rem}
#mnt .p-btns{display:flex;flex-wrap:wrap;gap:10px;margin-top:8px}
#mnt .p-btn{flex:1 1 220px;justify-content:flex-start;text-align:left;background:#fff}
#mnt .p-form{background:#fff8ef;border:2px solid #e8c9a8;border-radius:12px;padding:14px 16px;margin:14px 0}
#mnt .p-form h3{margin-top:0}
#mnt .p-total{font-size:1.1rem}
#mnt .p-card{gap:6px}
#mnt .p-plus{color:#037f4c;font-weight:700}
#mnt .p-moins{color:#bb3354;font-weight:700}
#mnt .p-calc{background:#fff;border:2px solid var(--line);border-radius:12px;padding:14px 16px}
#mnt .p-sous{margin:12px 0}
#mnt .p-res .line{display:flex;justify-content:space-between;gap:10px;padding:8px 0;border-bottom:1px solid #eef2f2}
#mnt .p-res .p-grand{font-size:1.15rem;background:#f6e4dc;padding:10px;border-radius:8px}
#mnt .p-ajust{margin-top:12px}
#mnt .p-ajust summary{cursor:pointer;font-weight:700;padding:8px 0}
#mnt .u-rapport{background:#e1f2e8;border:2px solid #9ccfb2;border-radius:12px;padding:12px 14px;margin-top:10px}
#mnt .u-rapport p{margin:6px 0}
#mnt header.top{position:relative;top:auto}#mnt .brand h1{display:none}#mnt .brand{justify-content:flex-end}#mnt main{padding-bottom:40px}#mnt .sheet{z-index:100001}#mnt .sheet-back{z-index:100000}#mnt .toast{z-index:100002}#mnt{max-width:1180px;margin:0 auto}
</style>
<div id="mnt" hidden>
<header class="top">
  <div class="top-inner">
    <div class="brand"><h1><span class="h-long">Les Gestions </span>Bestlife <span>· Maintenance</span></h1><div style="display:flex;align-items:center;gap:10px;flex-wrap:wrap"><label class="apercu" id="apercu-wrap" hidden><span>Voir comme</span><select id="apercu" aria-label="Voir l'application comme"></select></label><div class="who" id="mnt-who"></div></div></div>
    <nav class="tabs" aria-label="Sections">
      <a href="#alertes" data-v="alertes" hidden>🔔 À approuver <span class="badge num" id="b-al" hidden></span></a>
      <a href="#temps" data-v="temps">⏱️ Feuille de temps <span class="badge num" id="b-temps" hidden>●</span></a>
      <a href="#urgences" data-v="urgences" class="tab-urg">🚨 Urgences <span class="badge num" id="b-urg" hidden></span></a>
      <a href="#travaux" data-v="travaux">🔧 Mes travaux <span class="badge num" id="b-travaux" hidden></span></a>
      <a href="#billets" data-v="billets">📋 Tous les billets</a>
      <a href="#resume" data-v="resume">📊 Résumé des heures</a>
      <a href="#paye" data-v="paye">💵 Paye</a>
      <a href="#facturation" data-v="facturation" hidden>💵 Facturation <span class="badge num" id="b-fact" hidden></span></a>
      <a href="#nouveau" data-v="nouveau">➕ Nouveau billet</a>
    </nav>
  </div>
</header>
<main id="mnt-main"><div class="empty"><h3>Chargement des billets…</h3></div></main>
<div id="sheet-root"></div>
<div id="mnt-toast" class="toast" hidden role="status"></div>

</div>




.
window.BLMaintStart = (CTX) => {
/* Couleurs : rouge = urgent, bleu = nouveau, mauve pâle = pas pressé, sarcelle = en cours, jaune = en attente, gris/indigo = transféré, verts = terminé */
const STATUTS = [
  {k:"priorite",       l:"01 - Priorité",              c:"#c62839", i:"#fff"},
  {k:"a_traiter",      l:"01 - À traiter",             c:"#2f6fb3", i:"#fff"},
  {k:"quand_possible", l:"02 - À faire quand on peut", c:"#b9a2e3", i:"#2a1a4a"},
  {k:"gypse",          l:"Gypse et plâtre",            c:"#8a6446", i:"#fff"},
  {k:"en_cours",       l:"En cours",                   c:"#0f7c8c", i:"#fff"},
  {k:"en_attente",     l:"En attente",                 c:"#f2b705", i:"#2b2200"},
  {k:"envoye_nic",     l:"Envoyé à Nic",               c:"#6c757d", i:"#fff"},
  {k:"pour_will",      l:"Pour Will",                  c:"#3f3d8f", i:"#fff"},
  {k:"ferme_facturer", l:"Fermé et à facturer",        c:"#8cc21f", i:"#1d2a00"},
  {k:"regle_ferme",    l:"Réglé et fermé",             c:"#037f4c", i:"#fff"},
  {k:"ferme_refuse",   l:"Fermé / refusé",             c:"#3a3a3a", i:"#fff"},
];
const ST = Object.fromEntries(STATUTS.map(s=>[s.k,s]));
const FERMES = ["ferme_facturer","regle_ferme","ferme_refuse"];
const AV = [{k:"en_cours",l:"En cours"},{k:"en_attente",l:"En attente"},{k:"termine",l:"Terminée"},{k:"termine_facturer",l:"Terminée et à facturer"}];
const AVL = Object.fromEntries(AV.map(a=>[a.k,a.l]));
const FIN_LABEL = {termine:"Terminée", termine_facturer:"Terminée et à facturer", regle_ferme:"Réglé et fermé"};
const JEAN = ["priorite","a_traiter","quand_possible","gypse","en_cours"];
const CATS = ["Plomberie","Électricité","Chauffage","Électroménager","Portes et serrures","Fenêtres","Peinture / réparation murale","Plancher","Extérieur / déneigement","Nettoyage","Vermine","Autre"];
const PRIOS = [{k:"urgente",l:"Urgente"},{k:"normale",l:"Normale"},{k:"basse",l:"Basse"}];
const PRANK = {urgente:0,normale:1,basse:2};
const money = new Intl.NumberFormat("fr-CA",{style:"currency",currency:"CAD"});
const $ = (s,el=document)=>el.querySelector(s);
const esc = s => String(s ?? "").replace(/[&<>"']/g,c=>({"&":"&amp;","<":"&lt;",">":"&gt;",'"':"&quot;","'":"&#39;"}[c]));
const todayISO = () => { const d=new Date(); d.setMinutes(d.getMinutes()-d.getTimezoneOffset()); return d.toISOString().slice(0,10); };
const fmtDate = iso => iso ? new Date(iso.length===10? iso+"T12:00:00": iso).toLocaleDateString("fr-CA",{day:"numeric",month:"short"}) : "";
const fmtH = min => { const h=Math.floor(min/60), m=Math.round(min%60); return h? `${h} h ${String(m).padStart(2,"0")}` : `${m} min`; };
const rid = () => Math.random().toString(36).slice(2,10);
const code = t => "M-" + (t.creeLe||"").slice(2,10).replace(/-/g,"") + "-" + t.id.slice(0,3).toUpperCase();
const ZONES = [{k:"logement",l:"Logement"},{k:"corridor",l:"Corridor"},{k:"exterieur",l:"Extérieur de l'immeuble"},{k:"complet",l:"Immeuble au complet"}];
const BUREAU = ["Préparation au bureau","Rencontre d'équipe","Ménage du bureau"];
const GESTION = ["Gestion des courriels des locataires","Supervision de la maintenance","Rencontre client","Rencontre de direction","Rencontre/dîner avec les employés","Supervision des chantiers"];
const AUTRE = "__autre";
const EAU_RE = /\b(eaux?|fuites?|fuit|coule|coulent|couler|coulait|inond\w*|refoul\w*|debord\w*|infiltr\w*|goutt\w*|mouill\w*|humidite|degat d.eau|chauffe-eau|dalle)\b/;
const estEau = txt => EAU_RE.test(norm(txt));
const APPROB_RE = /east[\s-]*angus|magog|\bmurray\b/;
const besoinApprob = imm => { const n=norm(imm); return APPROB_RE.test(n) || (/\bprincipale\b/.test(n) && /\brich(e)?mond\b/.test(n)); };
const approbId = () => S.config.approbateur || ((S.config.gestionnaires||[]).length===1 ? S.config.gestionnaires[0] : null);
const estApprobateur = () => !!S.me && S.me===approbId();
/* Répartition des demandes (dispatch) : personnes au choix, liées à un compte dans Réglages */
const EQUIPE = [{k:"jean",l:"Jean",note:"maintenancelesgestionsbestlife@gmail.com"},{k:"jgr",l:"Jean-Guy & Robert"},{k:"etienne",l:"Étienne"},{k:"william",l:"William"}];
const EQL = Object.fromEntries(EQUIPE.map(p=>[p.k,p.l]));
const compteDe = k => (S.config.comptes||{})[k] || (k==="william" ? approbId() : null);
const repartiMoi = t => !!S.me && (t.repartiA||[]).some(k=>compteDe(k)===S.me);
const peutRepartir = () => !S.readOnly && (S.canAdmin || estApprobateur());
const repTags = t => (t.repartiA||[]).map(k=>`<span class="tag tag-rep">→ ${esc(EQL[k]||k)}${compteDe(k)===S.me?" (moi)":""}</span>`).join("");
const voitAlertes = () => estApprobateur() || S.canAdmin;
const attenteApprob = t => t.approbation==="requise";
const RAPPEL_MS = 2*864e5;
const prioDepuis = t => t.prioriteLe || t.creeLe;
const traitee = t => !actif(t) || ["termine","termine_facturer"].includes(t.avancement);
const enRetard = t => t.statut==="priorite" && !traitee(t) && !!prioDepuis(t) && Date.now()-Date.parse(prioDepuis(t)) >= RAPPEL_MS;
const joursDepuis = t => Math.floor((Date.now()-Date.parse(prioDepuis(t)))/864e5);
const eauNonVue = t => t.eau && actif(t) && !(t.eauVuPar||[]).includes(approbId());
function alertes(){ return {approb:S.tickets.filter(t=>attenteApprob(t)&&actif(t)), eau:S.tickets.filter(eauNonVue), retard:S.tickets.filter(enRetard)}; }
function flagsHTML(t){
  const f=[];
  if(t.eau) f.push(`<span class="flagx f-eau">💧 Problème d'eau</span>`);
  if(attenteApprob(t)) f.push(`<span class="flagx f-appr">En attente de l'approbation de William</span>`);
  if(t.approbation==="refusee") f.push(`<span class="flagx f-refus">Refusée par William</span>`);
  if(enRetard(t)) f.push(`<span class="flagx f-ret">⏰ Priorité non réglée depuis ${joursDepuis(t)} jours</span>`);
  return f.length?`<div class="tags">${f.join("")}</div>`:"";
}
const paieOk = id => !!id && id!==S.me && !(S.config.gestionnaires||[]).includes(id); // la paie à 28 $/h ne s'applique qu'aux employés de maintenance
const isGest = () => S.canAdmin || (S.config.gestionnaires||[]).includes(S.me);
const voitEntree = e => e.lieuType!=="gestion" || isGest();
const zoneLabel = e => e.zone==="logement" ? `app. ${e.logement||"?"}` : ((ZONES.find(z=>z.k===e.zone)||{}).l||"");
const lieuLabel = e => e.lieuType==="bureau" ? `Bureau · ${e.activite}` : e.lieuType==="gestion" ? `Gestion · ${e.activite}` : `${adrAff(e.immeuble)} · ${zoneLabel(e)}`;
const firstLine = s => String(s||"").split("\n")[0];

const S = { tWho:"", tDiscard:false, dict:null, micOn:false, micTarget:null, micPartial:"", res:{du:"",au:"",qui:""}, immQ:{}, finNote:"", revs:{}, revSubs:{}, showRev:null, db:null, user:null, assets:null, downloads:null, me:null, canAdmin:false, readOnly:false,
  tickets:[], temps:[], loaded:false, slow:false, error:null,
  tForm:{type:"immeuble",immeuble:"",zone:"logement",logement:"",activite:BUREAU[0],desc:"",urgence:"",outils:[],outilAutre:"",stock:"",mats:[],matArt:"",matQte:"",min:"",date:"",manuel:false}, tConfirm:null,
  config:{ tauxHoraire:null, majorationMateriel:0, immeubles:[], gestionnaires:[], approbateur:null, comptes:{} },
  view:"travaux", openId:null, filt:{q:"",statut:"actifs",immeuble:"",rep:""}, factFilter:"", names:{}, confirm:null };

/* Aperçu (administration) : voir l'application comme un autre profil, en lecture seulement */
function setApercu(id){
  if(!S.vraiAdmin) return;
  if(!id || id===S.vraiMe){ S.apercu=null; S.me=S.vraiMe; S.canAdmin=true; S.readOnly=S.vraiRO; }
  else { S.apercu=id; S.me=id; S.canAdmin=false; S.readOnly=true; }
  S.openId=null; S.confirm=null; S.tWho=""; S.res.qui=""; resetTForm();
  const w=$("#mnt-who"); if(w) w.textContent = S.apercu ? (S.names[id]||"…") : (S.myName||"");
  if(S.apercu && S.view==="facturation") location.hash="#temps"; else render();
  toast(S.apercu?`Aperçu : ${S.names[id]||"ce profil"}`:"Retour à ton compte");
}
function renderApercu(){
  const wrap=$("#apercu-wrap"), sel=$("#apercu"); if(!wrap||!sel) return;
  wrap.hidden = !S.vraiAdmin; if(!S.vraiAdmin || document.activeElement===sel) return;
  const ppl=Object.keys(S.names).filter(id=>id!==S.vraiMe && S.names[id]).sort((a,b)=>S.names[a].localeCompare(S.names[b],"fr"));
  sel.innerHTML=`<option value="">Moi (administration)</option>`+ppl.map(id=>`<option value="${esc(id)}" ${id===S.apercu?"selected":""}>${esc(S.names[id])}</option>`).join("");
}
let toastT; function toast(msg){ const t=$("#mnt-toast"); t.textContent=msg; t.hidden=false; clearTimeout(toastT); toastT=setTimeout(()=>t.hidden=true, Math.max(2600, msg.length*55)); }

/* ---------- calculs ---------- */
const majOf = () => 0; /* pas de majoration sur le matériel : facturé au prix coûtant */
const linkedTemps = t => S.temps.filter(e=>e.ticketId===t.id && !e.enCours && !e.aRemplir);
const minutesOf = t => (t.heures||[]).reduce((a,h)=>a+(+h.minutes||0),0) + linkedTemps(t).reduce((a,e)=>a+(+e.minutes||0),0);
const matOf = t => (t.materiel||[]).reduce((a,m)=>a+(+m.montant||0),0);
/* Facturation à l'heure : chaque ligne est arrondie à l'heure supérieure. Le coût de revient garde le temps exact. */
const hArr = h => h > 0 ? Math.ceil(h - 1e-9) : 0;
const coutH = h => h * (+S.config.tauxPaie || 0);
function costOf(t){
  const taux = +S.config.tauxHoraire || 0, maj = majOf(t.immeuble)/100;
  const heures = minutesOf(t)/60, hFact = hArr(heures);
  const mo = hFact*taux, mat = matOf(t), majo = mat*maj;
  return {heures, hFact, mo, mat, majo, total:mo+mat+majo, cout:coutH(heures)};
}
const actif = t => !FERMES.includes(t.statut);
const sOf = t => ST[t.statut] || ST.a_traiter;
const sortTickets = (a,b) => (a.datePrevue||"9").localeCompare(b.datePrevue||"9") || (a.creeLe||"").localeCompare(b.creeLe||"");
function grouped(list, order){
  return order.map(k=>[k, list.filter(t=>sOf(t).k===k).sort(sortTickets)]).filter(([,ts])=>ts.length)
    .map(([k,ts])=>`<h3 class="grp"><span class="pill" style="--sc:${ST[k].c};--si:${ST[k].i}">${ST[k].l}</span><span class="muted small num">${ts.length}</span></h3><div class="list">${ts.map(card).join("")}</div>`).join("");
}

/* ---------- Urgences : fiche détaillée + assistant IA (fonction Supabase « urgence-ia ») ---------- */
Object.assign(S, { urgences:[], urgOpen:null, urgEd:{}, urgBusy:"", urgQ:"", urgIA:null });
const U_TYPES = ["💧 Eau / fuite","🚽 Refoulement d'égout","⚡ Électricité","🔥 Chauffage","⛽ Odeur de gaz","🚒 Feu / fumée","🏚 Plafond / mur / structure","🔑 Serrure / porte / accès","🧊 Électroménager","Autre"];
const U_ETATS = [{k:"non_stabilisee",l:"🔴 Pas encore sous contrôle"},{k:"stabilisee",l:"🟡 Sous contrôle (temporaire)"},{k:"reglee",l:"🟢 Réglée pour de bon"}];
const U_CHAMPS = [
  {k:"constat", l:"Ce que tu as vu sur place", ph:"Ex. : eau qui coule du plafond de la salle de bain, tache de 1 m, plancher mouillé…"},
  {k:"cause", l:"La cause (d'où ça vient)", ph:"Ex. : joint de la toilette du logement du dessus qui fuit"},
  {k:"actions", l:"Ce que tu as fait", ph:"Ex. : fermé l'eau, épongé, changé le joint de cire…"},
  {k:"aFaire", l:"Ce qu'il reste à faire", ph:"Ex. : réparer le gypse dans 1 semaine, faire venir un plombier…"},
  {k:"materiel", l:"Matériel utilisé ou à acheter", ph:"Ex. : 1 joint de cire, 2 boulons de toilette"},
];
/* Guide sans IA : quoi faire, dans l'ordre, selon le genre d'urgence (cases à cocher enregistrées dans la fiche) */
const U_SEC = ["🛟 Sécurité d'abord","🧯 Arrêter les dégâts","🔎 Trouver la cause","📷 Photos à prendre","📌 Ensuite"];
const U_GUIDE = {
  "eau":[["Si l'eau touche des prises, des lumières ou le panneau électrique : coupe le disjoncteur de cette zone, seulement si tu as les pieds au sec."],
    ["Ferme la valve la plus proche (sous l'évier, derrière la toilette, à l'entrée du chauffe-eau).","Si ça coule encore : ferme l'entrée d'eau du logement ou de l'immeuble.","Éponge, mets des seaux, protège les meubles et les biens du locataire."],
    ["D'où vient l'eau exactement? (tuyau, raccord, toilette, bain, douche, chauffe-eau, toit, fenêtre)","Est-ce que ça coule seulement quand on utilise un appareil (douche, laveuse, toilette)?","Va voir le logement du dessus et celui du dessous.","Depuis quand? Est-ce déjà arrivé à cet endroit?"],
    ["La source de la fuite, de près.","Les dégâts : plafond, mur, plancher (vue d'ensemble).","La valve fermée.","Les logements voisins touchés."],
    ["Vérifie l'humidité dans les murs et sous le plancher (risque de moisissure).","Note les pièces à acheter et ce qu'il reste à réparer."]],
  "egout":[["L'eau d'égout est contaminée : gants et bottes, ne touche pas avec les mains.","Éloigne les locataires et les enfants de l'eau."],
    ["Demande à tous les logements de ne plus utiliser l'eau (toilettes, laveuse, lave-vaisselle) pour le moment.","Vérifie s'il y a un clapet antiretour et s'il est fermé."],
    ["Par où l'eau sort-elle? (drain de plancher, toilette ou douche du sous-sol)","Un seul logement ou plusieurs?","Grosse pluie ou fonte de neige en ce moment? (égout de la ville)","Le drain principal a-t-il été nettoyé récemment?"],
    ["Le drain ou l'endroit où l'eau sort.","La hauteur de l'eau.","Le clapet antiretour.","Les dommages (murs, planchers, biens)."],
    ["Désinfecter. Le gypse et les tapis touchés doivent souvent être jetés.","Si la ville est en cause : appeler la Ville. Sinon : plombier pour déboucher ou passer la caméra dans le drain."]],
  "elec":[["Ne touche à rien de mouillé ou de brûlé.","Odeur de brûlé ou fumée : fais sortir tout le monde et appelle le 911.","Fil tombé dehors : reste à 10 mètres et appelle Hydro-Québec."],
    ["Coupe le disjoncteur du circuit touché, si le panneau est au sec."],
    ["Panne dans un seul logement, tout l'immeuble ou le quartier? (regarde chez les voisins)","Le disjoncteur a-t-il sauté? Saute-t-il encore quand on le remet?","Quel appareil était branché au moment du problème?","Une prise ou un interrupteur est-il chaud, noirci ou grésille-t-il?"],
    ["Le panneau électrique (disjoncteurs).","La prise, l'interrupteur ou le fil en cause.","L'appareil branché."],
    ["Changer à l'identique une prise ou un interrupteur, courant coupé : correct.","Pour le reste (filage, panneau) : il faut un maître électricien."]],
  "chauf":[["Grand froid : vérifie que les locataires sont en sécurité (personnes âgées, bébés).","Chaufferette d'appoint : loin des rideaux et des meubles.","Attention au gel des tuyaux."],
    ["Si un seul logement : fournis une chaufferette en attendant la réparation."],
    ["Un seul logement ou tout l'immeuble?","Le thermostat : bien réglé? piles? affichage?","Le disjoncteur des plinthes ou de la fournaise a-t-il sauté?","La fournaise ou la chaudière affiche-t-elle un code ou un voyant?","Une seule pièce froide ou toutes?"],
    ["Le thermostat.","Le panneau électrique.","La fournaise : l'étiquette (marque, modèle) et le code d'erreur."],
    ["Note la marque et le modèle pour commander la pièce.","Fournaise au gaz ou au mazout : technicien qualifié."]],
  "gaz":[["N'allume pas de lumière ni d'interrupteur, pas de téléphone à l'intérieur, aucune flamme.","Fais sortir tout le monde et laisse la porte ouverte.","Une fois dehors : appelle Énergir (1 800 361-8003) et le 911."],
    ["Ferme la valve d'entrée de gaz seulement si c'est facile et sans danger."],
    ["Seul un technicien qualifié travaille sur le gaz. Note où l'odeur est la plus forte et quels appareils sont au gaz."],
    ["Seulement quand Énergir ou les pompiers disent que c'est sécuritaire."],
    ["Avise la gestionnaire tout de suite."]],
  "feu":[["Fais évacuer et appelle le 911.","N'éteins un petit feu que si c'est sans danger (extincteur)."],
    ["Laisse travailler les pompiers."],
    ["Où le feu a-t-il commencé? (cuisinière, appareil, prise, cigarette…)"],
    ["Seulement quand les pompiers le permettent : les dégâts, l'endroit où ça a commencé."],
    ["Avise la gestionnaire tout de suite.","Vérifie les détecteurs de fumée de l'immeuble."]],
  "struct":[["Éloigne tout le monde de la zone."],
    ["Plafond gonflé par l'eau : perce un petit trou au centre avec un seau dessous, seulement si c'est sécuritaire.","Arrête la source d'eau s'il y en a une."],
    ["Infiltration d'eau? Poids de la neige sur le toit? Fissure nouvelle qui grandit?"],
    ["Vue d'ensemble, puis de près (fissure, gonflement, tache)."],
    ["Fissure qui grandit ou plancher qui bouge : avise la gestionnaire tout de suite."]],
  "serrure":[["Vérifie que la personne est bien locataire (nom sur le bail) avant d'ouvrir."],
    ["Porte forcée ou vol : le locataire appelle la police. Sécurise la porte en attendant."],
    ["Clé perdue, serrure brisée ou porte forcée?","Clé volée : il faut changer le barillet."],
    ["La serrure, la porte et le cadre."],
    ["Note si une nouvelle clé doit être faite ou remise."]],
  "appareil":[["Débranche l'appareil ou coupe son disjoncteur avant d'y toucher.","Fuite d'eau : ferme la valve de l'appareil."],
    ["Vide l'eau, protège le plancher."],
    ["Marque, modèle et numéro de série (étiquette).","Y a-t-il un code d'erreur?","Disjoncteur ou prise en cause?","Âge de l'appareil, garantie?"],
    ["L'étiquette de l'appareil.","Le code d'erreur.","Le problème (fuite, pièce brisée)."],
    ["Note la pièce à commander ou si l'appareil doit être remplacé."]],
  "autre":[["Y a-t-il un danger pour quelqu'un? Si oui, éloigne les gens et appelle au besoin."],
    ["Empêche que ça empire (couper l'eau, le courant, protéger les biens)."],
    ["Qu'est-ce qui s'est passé, où, depuis quand? Est-ce déjà arrivé?"],
    ["Vue d'ensemble, puis de près."],
    ["Note ce qui reste à faire."]]
};
const uCleType = t => { const s=String(t||""); return s.includes("Eau")?"eau":s.includes("gout")?"egout":s.includes("lectricit")?"elec":s.includes("Chauffage")?"chauf":s.includes("gaz")?"gaz":s.includes("Feu")?"feu":s.includes("Plafond")?"struct":s.includes("Serrure")?"serrure":s.includes("lectrom")?"appareil":"autre"; };
function uGuide(u, ro){
  const t=uVal(u,"type"); if(!t) return `<p class="muted">Choisis d'abord le genre d'urgence : la liste de ce qu'il faut faire apparaîtra ici.</p>`;
  const k=uCleType(t), fait=u.guide||[];
  return U_GUIDE[k].map((items,s)=>`<div class="u-gsec"><b>${U_SEC[s]}</b>${items.map((txt,i)=>{ const id=k+"|"+s+"|"+i; return `<label class="u-gitem"><input type="checkbox" data-ug="${id}" ${fait.includes(id)?"checked":""} ${ro?"disabled":""}><span>${esc(txt)}</span></label>`; }).join("")}</div>`).join("");
}
async function uPing(){
  if(S.urgIA!==null) return; S.urgIA="?";
  try{ const {data,error}=await CTX.sb.functions.invoke("urgence-ia",{body:{mode:"ping"}}); S.urgIA=!error && !!(data&&data.ok); }catch(e){ S.urgIA=false; }
  render();
}
const uDoc = id =>S.urgences.find(u=>u.id===id);
const uVal = (u,k) => { const e=S.urgEd[u.id]; return e && e[k]!==undefined ? e[k] : (u[k] ?? ""); };
const uOuverte = u => u.etat!=="reglee";
const uEtat = u => (U_ETATS.find(e=>e.k===u.etat)||{l:"⚪ État à indiquer"}).l;
function urgBadge(){ const b=$("#b-urg"); if(!b) return; const n=S.urgences.filter(uOuverte).length; b.hidden=!n; b.textContent=n; }
function uTexte(t){ return esc(t).replace(/\*\*(.+?)\*\*/g,"<b>$1</b>").replace(/\n/g,"<br>"); }
function uCtx(u){ return { lieu:u.lieu||"", date:u.date||"", type:uVal(u,"type"), description:uVal(u,"description"), constat:uVal(u,"constat"), cause:uVal(u,"cause"), actions:uVal(u,"actions"), etat:uEtat(u), aFaire:uVal(u,"aFaire"), materiel:uVal(u,"materiel"), noteTemps:u.noteTemps||"" }; }

async function uSave(id, patch){
  try{ await S.db.collection("urgences").doc(id).update({...patch, modifieLe:new Date().toISOString()});
    const u=uDoc(id); if(u) Object.assign(u,patch);
    const e=S.urgEd[id]; if(e) Object.keys(patch).forEach(k=>{ if(e[k]===patch[k]) delete e[k]; });
  }catch(err){ handleWriteErr(err); }
}
const uTimers={};
function uSaveLater(id,k){ clearTimeout(uTimers[id+k]); uTimers[id+k]=setTimeout(()=>{ const e=S.urgEd[id]; if(e && e[k]!==undefined) uSave(id,{[k]:e[k]}); },1200); }

async function ouvrirUrgenceDepuisTemps(tempsId, p){
  let u = S.urgences.find(x=>x.tempsId===tempsId);
  if(!u){
    const data={ tempsId, ticketId:p.ticketId||null, immeuble:p.immeuble||"", zone:p.zone||"", logement:p.logement||"", lieu:lieuLabel(p), date:todayISO(),
      par:S.me||null, creeLe:new Date().toISOString(), description:p.description||"", noteTemps:p.description||"", type:"", etat:"", photos:[], conversation:[] };
    try{ const r=await S.db.collection("urgences").add(data); u={id:r.id,...data}; S.urgences=[u,...S.urgences]; }
    catch(err){ handleWriteErr(err); render(); return; }
  }
  S.urgOpen=u.id;
  toast("🚨 C'était une urgence : remplis maintenant la fiche d'urgence.");
  if(location.hash==="#urgences") setView(); else location.hash="#urgences";
}

function viewUrgences(){
  const u = S.urgOpen && uDoc(S.urgOpen);
  if(u) return viewUrgence(u);
  const list=[...S.urgences].sort((a,b)=>(uOuverte(b)-uOuverte(a)) || String(b.creeLe||"").localeCompare(String(a.creeLe||"")));
  const carte = x => `<button type="button" class="u-card ${uOuverte(x)?"u-open":""}" data-uopen="${esc(x.id)}">
      <span class="u-card-t">${esc(x.type||"Urgence")}</span>
      <span class="u-card-l">📍 ${esc(x.lieu||"Lieu à préciser")}</span>
      <span class="u-card-m">${esc(fmtDate(x.date||x.creeLe))} · ${esc(S.names[x.par]||"")} · ${esc(uEtat(x))}</span></button>`;
  return `<div class="view-head"><div><h2>🚨 Urgences</h2><p>Une fiche par urgence. Elle te guide pour sécuriser, trouver la cause, régler le problème et tout noter.</p></div></div>
    <p><button class="btn primary u-big" id="u-new" type="button">➕ Nouvelle urgence</button></p>
    ${list.length ? `<div class="u-list">${list.map(carte).join("")}</div>` : emptyBox("Aucune urgence","Quand tu indiques « Oui, une urgence » dans ta feuille de temps, la fiche s'ouvre ici toute seule.")}`;
}

function viewUrgence(u){
  const ro = S.readOnly;
  const conv = u.conversation||[];
  const chips = (k,opts) => `<div class="chips u-chips">${opts.map(o=>{ const v=typeof o==="string"?o:o.k, l=typeof o==="string"?o:o.l; return `<button type="button" class="chip" data-uchip="${k}" data-v="${esc(v)}" aria-pressed="${uVal(u,k)===v}" ${ro?"disabled":""}>${esc(l)}</button>`; }).join("")}</div>`;
  const champ = c => `<div class="field full"><label for="u-${c.k}">${c.l}</label><textarea id="u-${c.k}" data-ufield="${c.k}" rows="3" placeholder="${esc(c.ph)}" ${ro?"readonly":""}>${esc(uVal(u,c.k))}</textarea>${mic("u-"+c.k)}</div>`;
  const photos = (u.photos||[]).map(p=>`<a href="#" data-phhref="${esc(p)}" class="u-ph"><img data-ph="${esc(p)}" alt="Photo de l'urgence"></a>`).join("");
  const r = u.rapport;
  uPing();
  let n=0; const N=()=>++n;
  return `<p><button class="btn u-back" id="u-back" type="button">← Retour à la liste des urgences</button></p>
  <div class="u-danger"><b>⚠️ Danger immédiat?</b> Odeur de gaz, feu, fumée, fils électriques près de l'eau, plafond qui s'écroule : fais sortir tout le monde et appelle.
    <div class="u-tel"><a class="btn u-911" href="tel:911">📞 911</a><a class="btn" href="tel:18003618003">⛽ Gaz Énergir<br><small>1 800 361-8003</small></a><a class="btn" href="tel:18007902424">⚡ Hydro-Québec<br><small>1 800 790-2424</small></a></div></div>
  <div class="u-head"><h2>${esc(u.type||"Urgence")}</h2><p>📍 ${esc(u.lieu||"Lieu à préciser")} · ${esc(fmtDate(u.date||u.creeLe))}${u.par?` · ${esc(S.names[u.par]||"")}`:""}</p></div>

  ${u.tempsId?"":`<div class="step"><h3><span class="stepn">${N()}</span> Où?</h3><div class="field full"><label for="u-lieu">Adresse de l'immeuble et numéro du logement</label><input id="u-lieu" data-ufield="lieu" list="u-imm-list" value="${esc(uVal(u,"lieu"))}" placeholder="Ex. : 1355 Choquette, app. 3" ${ro?"readonly":""}><datalist id="u-imm-list">${(S.config.immeubles||[]).map(i=>`<option value="${esc(i.adresse)}">`).join("")}</datalist></div></div>`}
  <div class="step"><h3><span class="stepn">${N()}</span> Quel genre d'urgence?</h3>${chips("type",U_TYPES)}</div>

  <div class="step u-guide"><h3><span class="stepn">${N()}</span> 📋 Quoi faire, dans l'ordre</h3><p class="muted">Coche au fur et à mesure. C'est noté dans la fiche.</p>${uGuide(u,ro)}</div>

  <div class="step"><h3><span class="stepn">${N()}</span> Décris ce qui se passe</h3>
    <div class="field full"><label for="u-description">En tes mots, comme si tu parlais au téléphone</label><textarea id="u-description" data-ufield="description" rows="4" placeholder="Ex. : la locataire du 3 dit que l'eau coule du plafond depuis ce matin…" ${ro?"readonly":""}>${esc(uVal(u,"description"))}</textarea>${mic("u-description")}</div></div>

  <div class="step"><h3><span class="stepn">${N()}</span> Prends des photos</h3>
    <p class="muted">Prends la source du problème de près, puis une vue d'ensemble.</p>
    ${ro?"":`<div class="u-tel"><label class="btn u-big">📷 Prendre une photo<input type="file" accept="image/*" capture="environment" data-uphoto hidden></label><label class="btn u-big">🖼 Choisir des photos<input type="file" accept="image/*" multiple data-uphoto hidden></label></div>`}
    ${S.urgBusy==="photo"?`<p class="u-wait">Envoi de la photo…</p>`:""}
    ${photos?`<div class="u-photos">${photos}</div>`:""}</div>

  ${S.urgIA!==true ? (S.urgIA===false ? `<div class="u-ia u-ia-off">🤖 <b>Assistant IA : bientôt disponible.</b> En attendant, suis le guide ci-dessus et remplis la fiche au complet.</div>` : "") : `
  <div class="step u-ia"><h3><span class="stepn">${N()}</span> 🤖 Assistant d'urgence</h3>
    <p class="muted">Il te guide étape par étape : sécurité, arrêter les dégâts, trouver la cause et la régler. Réponds à ses questions ici.</p>
    <div class="u-chat">${conv.map(m=>`<div class="u-msg ${m.role==="user"?"u-moi":"u-ia-msg"}"><span class="u-who">${m.role==="user"?"Toi":"Assistant"}</span>${uTexte(m.content)}</div>`).join("")}
    ${S.urgBusy==="chat"?`<div class="u-msg u-ia-msg u-wait">L'assistant réfléchit… (environ 30 secondes)</div>`:""}</div>
    ${ro?"":(conv.length
      ? `<div class="field full"><label for="u-q">Ta réponse ou ta question</label><textarea id="u-q" rows="3" placeholder="Écris ou dicte ta réponse…">${esc(S.urgQ)}</textarea>${mic("u-q")}</div>
         <p><button class="btn primary u-big" id="u-send" type="button" ${S.urgBusy?"disabled":""}>Envoyer à l'assistant ➜</button></p>`
      : `<p><button class="btn primary u-big" id="u-start" type="button" ${S.urgBusy?"disabled":""}>▶ Démarrer l'assistant</button></p>`)}
  </div>`}

  <div class="step"><h3><span class="stepn">${N()}</span> Ce qu'il faut retenir</h3>
    ${U_CHAMPS.map(champ).join("")}
    ${ro||S.urgIA!==true?"":`<p><button class="btn u-big" id="u-rapport" type="button" ${S.urgBusy?"disabled":""}>📝 Remplir ces cases avec l'assistant</button></p>`}
    ${S.urgBusy==="rapport"?`<p class="u-wait">L'assistant rédige le rapport…</p>`:""}
    ${r?`<div class="u-rapport"><b>Résumé pour la gestion</b><p>${uTexte(r.resume||"")}</p>${r.risques?`<p><b>Risques à surveiller :</b> ${uTexte(r.risques)}</p>`:""}${r.locataires_touches?`<p><b>Locataires touchés :</b> ${uTexte(r.locataires_touches)}</p>`:""}${r.infos_manquantes?`<p><b>Il manque encore :</b> ${uTexte(r.infos_manquantes)}</p>`:""}</div>`:""}
  </div>

  <div class="step"><h3><span class="stepn">${N()}</span> Où en est l'urgence?</h3>${chips("etat",U_ETATS)}</div>
  ${ro?"":`<p><button class="btn primary u-big" id="u-fin" type="button">✅ Enregistrer et revenir à la liste</button></p>`}`;
}

async function uAppel(u, mode, question){
  const conv=[...(u.conversation||[])];
  if(question) conv.push({role:"user", content:question, quand:new Date().toISOString()});
  S.urgBusy=mode; if(question){ u.conversation=conv; S.urgQ=""; } render();
  try{
    const {data,error} = await CTX.sb.functions.invoke("urgence-ia",{ body:{ mode, urgence:uCtx(u), conversation:conv.map(({role,content})=>({role,content})), photos:(u.photos||[]).slice(-6) } });
    let msg=null;
    if(error){ try{ msg=(await error.context.json()).erreur; }catch(e){} throw new Error(msg||"L'assistant ne répond pas. Vérifie ta connexion et réessaie."); }
    if(data && data.erreur) throw new Error(data.erreur);
    if(mode==="rapport"){
      const r=data.rapport||{}, patch={rapport:r, rapportLe:new Date().toISOString()};
      const map={constat:r.constat, cause:r.cause_probable, actions:r.actions_faites, aFaire:r.travaux_a_faire, materiel:r.materiel_requis};
      Object.entries(map).forEach(([k,v])=>{ if(v && !String(uVal(u,k)).trim()) patch[k]=v; });
      if(!uVal(u,"etat") && r.etat) patch.etat=r.etat;
      if(!uVal(u,"type") && r.type_urgence){ const t=U_TYPES.find(x=>x.toLowerCase().includes(String(r.type_urgence).toLowerCase().split(" ")[0])); patch.type=t||r.type_urgence; }
      await uSave(u.id, patch); toast("Rapport rédigé. Vérifie et corrige au besoin.");
    } else {
      conv.push({role:"assistant", content:data.reponse||"", quand:new Date().toISOString()});
      u.conversation=conv; await uSave(u.id,{conversation:conv});
    }
  }catch(e){ if(question){ S.urgQ=question; u.conversation=conv.slice(0,-1); } toast(e.message||"L'assistant ne répond pas."); }
  S.urgBusy=""; render();
  const fin=document.querySelector(".u-chat .u-msg:last-child"); if(mode==="chat" && fin) fin.scrollIntoView({behavior:"smooth",block:"start"});
}

function bindUrgences(){
  const on=(sel,ev,fn)=>{ const el=$(sel); if(el) el.addEventListener(ev,fn); };
  document.querySelectorAll("[data-uopen]").forEach(b=>b.addEventListener("click",()=>{ S.urgOpen=b.dataset.uopen; render(); window.scrollTo(0,0); }));
  on("#u-new","click",async()=>{
    const data={ tempsId:null, ticketId:null, immeuble:"", lieu:"", date:todayISO(), par:S.me||null, creeLe:new Date().toISOString(), description:"", type:"", etat:"", photos:[], conversation:[] };
    try{ const r=await S.db.collection("urgences").add(data); S.urgences=[{id:r.id,...data},...S.urgences]; S.urgOpen=r.id; render(); window.scrollTo(0,0); }catch(e){ handleWriteErr(e); }
  });
  const u = S.urgOpen && uDoc(S.urgOpen); if(!u) return;
  on("#u-back","click",()=>{ S.urgOpen=null; render(); window.scrollTo(0,0); });
  on("#u-fin","click",async()=>{ const e=S.urgEd[u.id]||{}; if(Object.keys(e).length) await uSave(u.id,{...e}); S.urgOpen=null; toast(u.etat?"Urgence enregistrée":"Urgence enregistrée. N'oublie pas d'indiquer où elle en est."); render(); window.scrollTo(0,0); });
  document.querySelectorAll("[data-ufield]").forEach(t=>t.addEventListener("input",()=>{ const k=t.dataset.ufield; (S.urgEd[u.id] ||= {})[k]=t.value; uSaveLater(u.id,k); }));
  document.querySelectorAll("[data-uchip]").forEach(b=>b.addEventListener("click",()=>{ const k=b.dataset.uchip, v=b.dataset.v; uSave(u.id,{[k]:v}).then(render); u[k]=v; render(); }));
  document.querySelectorAll("[data-ug]").forEach(c=>c.addEventListener("change",()=>{ const id=c.dataset.ug, g=new Set(u.guide||[]); c.checked?g.add(id):g.delete(id); u.guide=[...g]; uSave(u.id,{guide:u.guide}); }));
  on("#u-q","input",e=>{ S.urgQ=e.target.value; });
  on("#u-start","click",()=>uAppel(u,"chat",""));
  on("#u-send","click",()=>{ const q=S.urgQ.trim(); if(!q){ toast("Écris ou dicte ta réponse d'abord."); const t=$("#u-q"); if(t) t.focus(); return; } uAppel(u,"chat",q); });
  on("#u-rapport","click",()=>uAppel(u,"rapport",""));
  document.querySelectorAll("[data-uphoto]").forEach(inp=>inp.addEventListener("change",async()=>{
    const files=[...inp.files]; if(!files.length) return;
    S.urgBusy="photo"; render();
    const ajout=[];
    for(const f of files){ try{ const r=await S.assets.upload(f); ajout.push(r.id); }catch(e){ toast(e&&e.code==="too_large"?"Photo trop lourde (20 Mo maximum).":"Une photo n'a pas pu être envoyée."); } }
    S.urgBusy="";
    if(ajout.length){ await uSave(u.id,{photos:[...(u.photos||[]),...ajout]}); toast(ajout.length>1?`${ajout.length} photos ajoutées`:"Photo ajoutée"); }
    render();
  }));
}
/* ---------- Paye : spécifications des employés + calcul de la paye (administration) ---------- */
Object.assign(S, { pspecs:[], banque:[], payes:[], pForm:null, pAdm:{qui:"",du:"",au:""}, pBusy:"", pExcl:{} });
const P_KM = 0.50;            // $ par kilomètre
const P_DINER = 30;           // minutes de dîner payées par jour travaillé
const P_SEMAINE = 40*60;      // au-delà : en banque
const P_TYPES = {km:"🚗 Auto personnelle", banque:"🏦 Heures prises en banque", malade:"🤒 Maladie", facture:"🧾 Facture payée de ma poche"};
const hD = m => (Math.round((+m||0)/6)/10).toLocaleString("fr-CA",{minimumFractionDigits:1})+" h";
const addDays = (iso,n) => { const d=new Date(iso+"T12:00:00"); d.setDate(d.getDate()+n); return isoLocal(d); };
const lundiDe = iso => { const d=new Date(iso+"T12:00:00"); d.setDate(d.getDate()-((d.getDay()+6)%7)); return isoLocal(d); };
function feriesPaye(y){ // jours fériés de la CNESST (Vendredi saint retenu; report au lundi si la Fête nationale ou la Fête du Canada tombe un dimanche)
  const f={...feries(y)};
  [[5,24,"Fête nationale"],[6,1,"Fête du Canada"]].forEach(([m,j,nom])=>{ const d=new Date(y,m,j); if(d.getDay()===0){ delete f[isoLocal(d)]; d.setDate(d.getDate()+1); f[isoLocal(d)]=nom+" (reportée au lundi)"; } });
  return f;
}
function minutesParJour(emp){ const m={}; resumeEntries().filter(e=>e.par===emp).forEach(e=>{ if(e.date) m[e.date]=(m[e.date]||0)+(+e.minutes||0); }); return m; }
function semaine(emp, lundi, mj, du, au, ferMap){ // du/au : limite aux jours de la période (sinon semaine complète)
  // ferMap : indemnités des jours fériés, comptées comme du travail pour le seuil de 40 h (LNT, CNESST)
  let trav=0, jours=0, fer=0;
  for(let i=0;i<7;i++){ const d=addDays(lundi,i); if(du && (d<du || d>au)) continue; const m=mj[d]||0; trav+=m; if(m>0) jours++; if(ferMap && ferMap[d]) fer+=ferMap[d]; }
  const diner=jours*P_DINER, total=trav+diner+fer;
  return {lundi, dimanche:addDays(lundi,6), trav, jours, diner, fer, total, payees:Math.min(total,P_SEMAINE), surplus:Math.max(0,total-P_SEMAINE)};
}
function indemnite(emp, iso, mj){ // 1/20 des heures payées (sans le surplus) des 4 semaines complètes avant la semaine du congé
  const l=lundiDe(iso); let s=0; for(let k=1;k<=4;k++) s+=semaine(emp, addDays(l,-7*k), mj).payees; return Math.round(s/20);
}
const soldeBanque = emp => S.banque.filter(b=>b.employe===emp).reduce((a,b)=>a+(+b.minutes||0),0);
const specsDe = emp => S.pspecs.filter(s=>s.par===emp);
function maladiePayeeDefaut(sp){ // 2 jours payés par année civile (CNESST)
  const an=String(sp.date||"").slice(0,4);
  const avant=S.pspecs.filter(x=>x.type==="malade" && x.par===sp.par && String(x.date||"").slice(0,4)===an && (x.date<sp.date || (x.date===sp.date && x.id<sp.id)) && x.payee!==false);
  return avant.length<2;
}
function calcPaye(emp, du, au){
  const mj=minutesParJour(emp), semaines=[];
  const feriesL=[]; for(let d=du; d<=au; d=addDays(d,1)){ const f=feriesPaye(+d.slice(0,4))[d]; if(f) feriesL.push({date:d, nom:f, minutes:indemnite(emp,d,mj), exclu:!!S.pExcl[emp+d]}); }
  const ferMap={}; feriesL.filter(f=>!f.exclu).forEach(f=>{ ferMap[f.date]=f.minutes; });
  for(let l=lundiDe(du); l<=au; l=addDays(l,7)) semaines.push(semaine(emp,l,mj,du,au,ferMap));
  const sp=specsDe(emp);
  const malades=sp.filter(s=>s.type==="malade" && s.date>=du && s.date<=au).map(s=>{ const payee = s.payee!==undefined ? !!s.payee : maladiePayeeDefaut(s); return {...s, payeeCalc:payee, minutesInd: payee?indemnite(emp,s.date,mj):0}; });
  const retraits=sp.filter(s=>s.type==="banque" && !s.payeId && s.date<=au);
  const kms=sp.filter(s=>s.type==="km" && !s.payeId && s.date<=au);
  const factures=sp.filter(s=>s.type==="facture" && !s.payeLe);
  const t={ trav:0, diner:0, payees:0, surplus:0 }; semaines.forEach(w=>{ t.trav+=w.trav; t.diner+=w.diner; t.payees+=w.payees; t.surplus+=w.surplus; });
  const fer=feriesL.filter(f=>!f.exclu).reduce((a,f)=>a+f.minutes,0), mal=malades.reduce((a,m)=>a+m.minutesInd,0), ret=retraits.reduce((a,r)=>a+(+r.minutes||0),0);
  const solde=soldeBanque(emp);
  return { emp, du, au, semaines, feriesL, malades, retraits, kms, factures, t, fer, mal, ret,
    aPayer: t.payees+mal+ret, kmTotal: kms.reduce((a,k)=>a+(+k.montant||0),0), factTotal: factures.reduce((a,f)=>a+(+f.montant||0),0),
    solde, soldeApres: solde+t.surplus-ret };
}
const payeChevauche = (emp,du,au) => S.payes.find(p=>p.employe===emp && !(p.au<du || p.du>au));

/* ----- distance (OpenStreetMap) ----- */
async function geocode(adr){
  const q = /qu[ée]bec|\bqc\b/i.test(adr) ? adr : adr+", Québec, Canada";
  const r = await fetch("https://nominatim.openstreetmap.org/search?format=json&limit=1&countrycodes=ca&q="+encodeURIComponent(q));
  const j = await r.json(); if(!j.length) throw new Error("Adresse introuvable : "+adr); return {lat:+j[0].lat, lon:+j[0].lon, nom:j[0].display_name};
}
async function distanceKm(a,b){
  const [p,q]=[await geocode(a), await geocode(b)];
  const r=await fetch(`https://router.project-osrm.org/route/v1/driving/${p.lon},${p.lat};${q.lon},${q.lat}?overview=false`);
  const j=await r.json(); if(!j.routes||!j.routes.length) throw new Error("Trajet introuvable");
  return Math.round(j.routes[0].distance/100)/10;
}

/* ----- vues ----- */
function viewPaye(){
  const adm=S.canAdmin;
  const emp = adm ? (S.pAdm.qui || compteDe("jean") || "") : S.me;
  const solde=soldeBanque(emp), hist=S.banque.filter(b=>b.employe===emp).sort((a,b)=>String(b.date).localeCompare(String(a.date)));
  const gens=[...new Set([...resumeEntries().map(e=>e.par), ...S.pspecs.map(s=>s.par), compteDe("jean")].filter(Boolean))].filter(id=>id!==S.me || !adm);
  const f=S.pForm;
  const btn=(k,l)=>`<button type="button" class="btn u-big p-btn" data-pnew="${k}">${l}</button>`;
  return `<div class="view-head"><div><h2>💵 Spécifications pour la paye</h2><p>${adm?"Calcul de la paye, banque d'heures et déclarations des employés.":"Indique ici ton auto, tes heures en banque, une maladie ou une facture payée de ta poche."}</p></div></div>
  ${adm?`<div class="field"><label for="p-qui">Employé</label><select id="p-qui">${gens.map(id=>`<option value="${esc(id)}" ${id===emp?"selected":""}>${esc(S.names[id]||id)}</option>`).join("")}</select></div>`:""}
  <div class="p-banque"><span>🏦 Heures en banque${adm?` de ${esc(S.names[emp]||"")}`:""}</span><b class="num">${hD(solde)}</b></div>
  ${adm?payeAdmin(emp):""}
  ${adm?"":`<div class="sec"><h3>Que veux-tu déclarer?</h3><div class="p-btns">${btn("km",P_TYPES.km)}${btn("banque",P_TYPES.banque)}${btn("malade",P_TYPES.malade)}${btn("facture",P_TYPES.facture)}</div></div>`}
  ${f?formPaye(f, solde):""}
  <div class="sec"><h3>${adm?"Déclarations de l'employé":"Mes déclarations"}</h3>${listeSpecs(emp)}</div>
  <div class="sec"><h3>Historique de la banque d'heures</h3>${hist.length?`<div class="tbl-wrap panel" style="padding:0"><table><thead><tr><th>Date</th><th>Raison</th><th class="n">Heures</th></tr></thead><tbody>${hist.map(b=>`<tr><td>${esc(fmtDate(b.date))}</td><td>${esc(b.raison||"")}</td><td class="n num ${(+b.minutes)<0?"p-moins":"p-plus"}">${(+b.minutes)>0?"+":""}${hD(b.minutes)}</td></tr>`).join("")}</tbody></table></div>`:`<p class="muted">Aucun mouvement pour l'instant. Les heures au-delà de 40 h par semaine (temps + dîners) s'ajoutent ici quand la paye est confirmée.</p>`}
  ${adm?`<details class="p-ajust"><summary>Ajuster la banque à la main (solde de départ, correction)</summary><div class="grid2"><div class="field"><label for="pa-h">Heures (+ pour ajouter, - pour retirer)</label><input id="pa-h" type="number" step="0.25"></div><div class="field"><label for="pa-d">Date</label><input id="pa-d" type="date" value="${todayISO()}"></div><div class="field full"><label for="pa-r">Raison</label><input id="pa-r" placeholder="Ex. : solde de départ au 16 novembre"></div></div><p><button class="btn" id="pa-ok" type="button">Enregistrer l'ajustement</button></p></details>`:""}</div>`;
}

function formPaye(f, solde){
  const v=k=>esc(f[k]??"");
  const champ=(id,l,html)=>`<div class="field full"><label for="${id}">${l}</label>${html}</div>`;
  let corps="";
  if(f.type==="km") corps = champ("pf-date","Date du trajet",`<input id="pf-date" data-pf="date" type="date" value="${v("date")}">`)
    + champ("pf-dep","Départ (adresse)",`<input id="pf-dep" data-pf="depart" list="pf-adr" value="${v("depart")}" placeholder="Ex. : 1355 rue Choquette, Sherbrooke">`)
    + champ("pf-arr","Arrivée (adresse)",`<input id="pf-arr" data-pf="arrivee" list="pf-adr" value="${v("arrivee")}" placeholder="Ex. : Rona, 4300 boul. Bourque, Sherbrooke">`)
    + `<datalist id="pf-adr">${(S.config.immeubles||[]).map(i=>`<option value="${esc(i.adresse)}">`).join("")}</datalist>`
    + `<label class="u-gitem"><input type="checkbox" id="pf-ar" ${f.allerRetour?"checked":""}><span>Aller-retour (compter 2 fois)</span></label>`
    + champ("pf-pourquoi","Pourquoi?",`<input id="pf-pourquoi" data-pf="note" value="${v("note")}" placeholder="Ex. : acheter un chauffe-eau">`)
    + `<p><button type="button" class="btn" id="pf-calc" ${S.pBusy?"disabled":""}>📏 Calculer la distance</button></p>${S.pBusy==="km"?`<p class="u-wait">Calcul du trajet…</p>`:""}`
    + champ("pf-km","Kilomètres (calculés, tu peux corriger)",`<input id="pf-km" data-pf="km" type="number" step="0.1" min="0" value="${v("km")}">`)
    + `<p class="p-total">À rembourser : <b class="num">${money.format((+f.km||0)*(f.allerRetour?2:1)*P_KM)}</b> <span class="muted">(${P_KM.toFixed(2).replace(".",",")} $ du km)</span></p>`;
  if(f.type==="banque") corps = `<p class="muted">Tu as <b>${hD(solde)}</b> en banque.</p>`
    + champ("pf-date","Pour quelle journée?",`<input id="pf-date" data-pf="date" type="date" value="${v("date")}">`)
    + champ("pf-h","Combien d'heures veux-tu prendre?",`<input id="pf-h" data-pf="heures" type="number" step="0.25" min="0.25" value="${v("heures")}">`)
    + champ("pf-note","Note (facultatif)",`<input id="pf-note" data-pf="note" value="${v("note")}">`);
  if(f.type==="malade") corps = champ("pf-date","Quelle journée as-tu été malade?",`<input id="pf-date" data-pf="date" type="date" value="${v("date")}">`)
    + champ("pf-note","Note (facultatif)",`<input id="pf-note" data-pf="note" value="${v("note")}" placeholder="Ex. : grippe">`)
    + `<p class="muted small">La loi prévoit 2 journées de maladie payées par année. L'administration confirme si la journée est payée.</p>`;
  if(f.type==="facture") corps = champ("pf-date","Date de la facture",`<input id="pf-date" data-pf="date" type="date" value="${v("date")}">`)
    + champ("pf-mt","Montant payé ($, taxes incluses)",`<input id="pf-mt" data-pf="montant" type="number" step="0.01" min="0" value="${v("montant")}">`)
    + champ("pf-four","Magasin ou fournisseur",`<input id="pf-four" data-pf="fournisseur" value="${v("fournisseur")}" placeholder="Ex. : Canadian Tire">`)
    + champ("pf-note","Pour quoi faire? (immeuble, réparation)",`<input id="pf-note" data-pf="note" value="${v("note")}">`)
    + `<div class="u-tel"><label class="btn u-big">📷 Photo de la facture<input type="file" accept="image/*" capture="environment" data-pfphoto hidden></label><label class="btn u-big">🖼 Choisir une photo<input type="file" accept="image/*" multiple data-pfphoto hidden></label></div>`
    + (S.pBusy==="photo"?`<p class="u-wait">Envoi de la photo…</p>`:"")
    + ((f.photos||[]).length?`<div class="u-photos">${f.photos.map(p=>`<a href="#" data-phhref="${esc(p)}" class="u-ph"><img data-ph="${esc(p)}" alt="Facture"></a>`).join("")}</div>`:"")
    + `<p class="muted small">La facture sera envoyée par courriel à la comptabilité, qui te remboursera par virement Interac.</p>`;
  return `<div class="p-form"><h3>${P_TYPES[f.type]}</h3>${corps}
    <div class="p-btns"><button type="button" class="btn primary u-big" id="pf-ok" ${S.pBusy?"disabled":""}>✅ Envoyer</button><button type="button" class="btn" id="pf-annule">Annuler</button></div></div>`;
}

function listeSpecs(emp){
  const l=specsDe(emp).sort((a,b)=>String(b.date).localeCompare(String(a.date))).slice(0,60);
  if(!l.length) return `<p class="muted">Rien pour l'instant.</p>`;
  const adm=S.canAdmin;
  return `<div class="u-list">${l.map(s=>{
    let det="", etat="";
    if(s.type==="km"){ det=`${esc(s.depart)} → ${esc(s.arrivee)}${s.allerRetour?" (aller-retour)":""} · ${String(s.kmTotal??s.km).replace(".",",")} km · <b>${money.format(+s.montant||0)}</b>${s.note?` · ${esc(s.note)}`:""}`; etat=s.payeId?"✅ Payé avec la paye":"⏳ Sera payé à la prochaine paye"; }
    if(s.type==="banque"){ det=`${hD(s.minutes)}${s.note?` · ${esc(s.note)}`:""}`; etat=s.payeId?"✅ Payé avec la paye":"⏳ Demande reçue"; }
    if(s.type==="malade"){ det=esc(s.note||""); const p = s.payee!==undefined ? s.payee : maladiePayeeDefaut(s); etat=(s.payeId?"✅ Traité":"⏳ À traiter")+(p?" · journée payée":" · non payée"); }
    if(s.type==="facture"){ det=`<b>${money.format(+s.montant||0)}</b> · ${esc(s.fournisseur||"")}${s.note?` · ${esc(s.note)}`:""}${(s.photos||[]).length?` · <a href="#" data-phhref="${esc(s.photos[0])}">voir la facture</a>`:""}`; etat=s.payeLe?`✅ Remboursée le ${fmtDate(s.payeLe)} (Interac)`:(s.envoyeLe?"📧 Envoyée à la comptabilité":"⏳ À envoyer"); }
    const actions = (adm && s.type==="facture" && !s.payeLe ? `<button type="button" class="btn" data-pfpaye="${esc(s.id)}">💵 Marquer payée (Interac)</button>` : "")
      + (adm && s.type==="facture" && !s.envoyeLe ? `<button type="button" class="btn" data-pfenv="${esc(s.id)}">📧 Envoyer à la comptabilité</button>` : "")
      + (adm && s.type==="malade" && !s.payeId ? `<button type="button" class="btn" data-pfmal="${esc(s.id)}">${(s.payee!==undefined?s.payee:maladiePayeeDefaut(s))?"Rendre non payée":"Rendre payée"}</button>` : "")
      + (!s.payeId && !s.payeLe && (adm || s.par===S.me) ? `<button type="button" class="btn danger" data-pfdel="${esc(s.id)}">Retirer</button>` : "");
    return `<div class="u-card p-card"><span class="u-card-t">${P_TYPES[s.type]||s.type} · ${esc(fmtDate(s.date))}</span><span>${det}</span><span class="u-card-m">${etat}</span>${actions?`<div class="p-btns">${actions}</div>`:""}</div>`; }).join("")}</div>`;
}

function payeAdmin(emp){
  const A=S.pAdm; if(!A.du){ const l=lundiDe(todayISO()); A.du=addDays(l,-14); A.au=addDays(l,-1); }
  if(!emp) return "";
  const c=calcPaye(emp, A.du, A.au), dej=payeChevauche(emp, A.du, A.au), taux=+S.config.tauxPaie||0;
  const ligne=(l,v,cls="")=>`<div class="line ${cls}"><span>${l}</span><span class="num">${v}</span></div>`;
  return `<div class="sec p-calc"><h3>🧮 Calcul de la paye</h3>
    <div class="grid2"><div class="field"><label for="p-du">Du</label><input id="p-du" type="date" value="${esc(A.du)}"></div><div class="field"><label for="p-au">Au</label><input id="p-au" type="date" value="${esc(A.au)}"></div></div>
    <div class="chips"><button type="button" class="chip" data-pper="2">2 dernières semaines</button><button type="button" class="chip" data-pper="1">Semaine dernière</button><button type="button" class="chip" data-pper="0">Cette semaine</button></div>
    <div class="tbl-wrap panel" style="padding:0"><table><thead><tr><th>Semaine</th><th class="n">Travail</th><th class="n">Dîners</th><th class="n">Fériés</th><th class="n">Total</th><th class="n">Payé</th><th class="n">En banque</th></tr></thead><tbody>
      ${c.semaines.map(w=>`<tr><td>${esc(fmtDate(w.lundi))} au ${esc(fmtDate(w.dimanche))}<br><span class="muted small">${w.jours} jour${w.jours>1?"s":""} travaillé${w.jours>1?"s":""}</span></td><td class="n num">${hD(w.trav)}</td><td class="n num">${hD(w.diner)}</td><td class="n num">${w.fer?hD(w.fer):"—"}</td><td class="n num">${hD(w.total)}</td><td class="n num"><b>${hD(w.payees)}</b></td><td class="n num">${w.surplus?"+"+hD(w.surplus):"—"}</td></tr>`).join("")}
    </tbody></table></div>
    ${c.feriesL.length?`<div class="p-sous"><b>Jours fériés (CNESST)</b>${c.feriesL.map(f=>`<label class="u-gitem"><input type="checkbox" data-pfer="${esc(f.date)}" ${f.exclu?"":"checked"}><span>${esc(f.nom)} · ${esc(fmtDate(f.date))} : <b>${hD(f.minutes)}</b> <span class="muted small">(1/20 des 4 semaines précédentes)</span></span></label>`).join("")}</div>`:""}
    <div class="lines p-res">
      ${ligne(c.fer?"Travail + dîners + fériés (max. 40 h/sem.)":"Heures travaillées + dîners (max. 40 h/sem.)", hD(c.t.payees))}
      ${c.fer?ligne("dont jours fériés (comptés dans les 40 h, CNESST)", hD(c.fer), "muted"):""}
      ${c.malades.length?ligne(`Maladie (${c.malades.filter(m=>m.payeeCalc).length} jour(s) payé(s) sur ${c.malades.length})`, hD(c.mal)):""}
      ${c.retraits.length?ligne(`Heures prises dans la banque (${c.retraits.length} demande${c.retraits.length>1?"s":""})`, hD(c.ret)):""}
      ${ligne("<b>Heures à payer</b>", `<b>${hD(c.aPayer)}</b>`, "p-grand")}
      ${taux?ligne(`Salaire (${money.format(taux)}/h)`, `<b>${money.format(c.aPayer/60*taux)}</b>`):""}
      ${c.kms.length?ligne(`Kilométrage (${c.kms.length} trajet${c.kms.length>1?"s":""})`, `<b>${money.format(c.kmTotal)}</b>`):""}
      ${c.factures.length?ligne(`Factures à rembourser par Interac (${c.factures.length})`, money.format(c.factTotal)):""}
      ${ligne("Banque : avant → après cette paye", `${hD(c.solde)} → <b>${hD(c.soldeApres)}</b>`)}
    </div>
    ${c.soldeApres<0?`<p class="banner warn">Attention : il prend plus d'heures qu'il en a en banque.</p>`:""}
    ${dej?`<p class="banner">✅ Paye déjà confirmée pour le ${esc(fmtDate(dej.du))} au ${esc(fmtDate(dej.au))} (le ${esc(fmtDate(dej.confirmeLe))}). <button type="button" class="btn danger" data-pannule="${esc(dej.id)}">Annuler cette paye</button></p>`
      :`<p><button type="button" class="btn primary u-big" id="p-conf" ${S.pBusy?"disabled":""}>✅ Confirmer cette paye et mettre à jour la banque</button></p><p class="muted small">Confirmer ajoute les surplus en banque, retire les heures demandées et marque le kilométrage comme payé.</p>`}
  </div>`;
}

/* ----- actions ----- */
async function pAjout(coll, data){ return S.db.collection(coll).add(data); }
async function envoyerFacture(id){
  const {data,error}=await CTX.sb.functions.invoke("facture-courriel",{body:{id}});
  if(error || (data&&data.erreur)){ let m=data&&data.erreur; if(error){ try{ m=(await error.context.json()).erreur; }catch(e){} } throw new Error(m||"Le courriel n'a pas pu partir."); }
}
function bindPaye(){
  const on=(sel,ev,fn)=>{ const el=$(sel); if(el) el.addEventListener(ev,fn); };
  const all=(sel,fn)=>document.querySelectorAll(sel).forEach(fn);
  on("#p-qui","change",e=>{ S.pAdm.qui=e.target.value; S.pForm=null; render(); });
  on("#p-du","change",e=>{ S.pAdm.du=e.target.value; render(); });
  on("#p-au","change",e=>{ S.pAdm.au=e.target.value; render(); });
  all("[data-pper]",b=>b.addEventListener("click",()=>{ const n=+b.dataset.pper, l=lundiDe(todayISO()); if(n===0){ S.pAdm.du=l; S.pAdm.au=addDays(l,6); } else { S.pAdm.du=addDays(l,-7*n); S.pAdm.au=addDays(l,-1); } render(); }));
  all("[data-pfer]",c=>c.addEventListener("change",()=>{ const emp=S.pAdm.qui||compteDe("jean"); S.pExcl[emp+c.dataset.pfer]=!c.checked; render(); }));
  all("[data-pnew]",b=>b.addEventListener("click",()=>{ S.pForm={type:b.dataset.pnew, date:todayISO(), photos:[]}; render(); const f=$(".p-form"); if(f) f.scrollIntoView({behavior:"smooth"}); }));
  on("#pf-annule","click",()=>{ S.pForm=null; render(); });
  all("[data-pf]",i=>i.addEventListener("input",()=>{ S.pForm[i.dataset.pf]=i.value; if(i.dataset.pf==="km"){ const t=$(".p-total b"); if(t) t.textContent=money.format((+i.value||0)*(S.pForm.allerRetour?2:1)*P_KM); } }));
  on("#pf-ar","change",e=>{ S.pForm.allerRetour=e.target.checked; render(); });
  on("#pf-calc","click",async()=>{ const f=S.pForm; if(!f.depart||!f.arrivee){ toast("Écris l'adresse de départ et d'arrivée."); return; }
    S.pBusy="km"; render(); try{ f.km=await distanceKm(f.depart,f.arrivee); toast(`Trajet : ${String(f.km).replace(".",",")} km`); }catch(e){ toast((e.message||"Calcul impossible")+". Écris les kilomètres à la main."); } S.pBusy=""; render(); });
  all("[data-pfphoto]",inp=>inp.addEventListener("change",async()=>{ const files=[...inp.files]; if(!files.length) return; S.pBusy="photo"; render();
    for(const fl of files){ try{ const r=await S.assets.upload(fl); S.pForm.photos=[...(S.pForm.photos||[]),r.id]; }catch(e){ toast("La photo n'a pas pu être envoyée."); } } S.pBusy=""; render(); }));
  on("#pf-ok","click",async()=>{
    const f=S.pForm, base={type:f.type, date:f.date||todayISO(), par:S.me, creeLe:new Date().toISOString(), note:(f.note||"").trim()};
    let d;
    if(f.type==="km"){ const km=+f.km; if(!f.depart||!f.arrivee||!(km>0)){ toast("Il faut le départ, l'arrivée et les kilomètres."); return; } const tot=Math.round(km*(f.allerRetour?2:1)*10)/10; d={...base, depart:f.depart.trim(), arrivee:f.arrivee.trim(), allerRetour:!!f.allerRetour, km, kmTotal:tot, montant:Math.round(tot*P_KM*100)/100}; }
    if(f.type==="banque"){ const h=+f.heures; if(!(h>0)){ toast("Indique combien d'heures."); return; } d={...base, minutes:Math.round(h*60)}; }
    if(f.type==="malade") d={...base};
    if(f.type==="facture"){ const m=+f.montant; if(!(m>0)){ toast("Indique le montant de la facture."); return; } if(!(f.photos||[]).length){ toast("Ajoute la photo de la facture."); return; } d={...base, montant:Math.round(m*100)/100, fournisseur:(f.fournisseur||"").trim(), photos:f.photos}; }
    S.pBusy="envoi"; render();
    try{ const r=await pAjout("paye_specs", d); S.pspecs=[{id:r.id,...d},...S.pspecs];
      if(d.type==="facture"){ try{ await envoyerFacture(r.id); toast("Facture envoyée à la comptabilité ✅"); }catch(e){ toast("Facture enregistrée, mais le courriel n'est pas parti : "+e.message); } }
      else toast("C'est noté ✅");
      S.pForm=null;
    }catch(e){ handleWriteErr(e); }
    S.pBusy=""; render(); window.scrollTo(0,0);
  });
  all("[data-pfdel]",b=>b.addEventListener("click",async()=>{ if(!confirm("Retirer cette déclaration?")) return; try{ await S.db.collection("paye_specs").doc(b.dataset.pfdel).delete(); S.pspecs=S.pspecs.filter(s=>s.id!==b.dataset.pfdel); render(); }catch(e){ handleWriteErr(e); } }));
  all("[data-pfpaye]",b=>b.addEventListener("click",async()=>{ if(!confirm("Confirmer que cette facture a été remboursée par Interac?")) return; try{ await S.db.collection("paye_specs").doc(b.dataset.pfpaye).update({payeLe:new Date().toISOString(), payePar:S.me}); toast("Facture marquée payée"); }catch(e){ handleWriteErr(e); } }));
  all("[data-pfenv]",b=>b.addEventListener("click",async()=>{ try{ await envoyerFacture(b.dataset.pfenv); toast("Facture envoyée à la comptabilité ✅"); }catch(e){ toast(e.message); } }));
  all("[data-pfmal]",b=>b.addEventListener("click",async()=>{ const s=S.pspecs.find(x=>x.id===b.dataset.pfmal); if(!s) return; const p=s.payee!==undefined?s.payee:maladiePayeeDefaut(s); try{ await S.db.collection("paye_specs").doc(s.id).update({payee:!p}); s.payee=!p; render(); }catch(e){ handleWriteErr(e); } }));
  on("#pa-ok","click",async()=>{ const emp=S.pAdm.qui||compteDe("jean"), h=+($("#pa-h").value||0), r=$("#pa-r").value.trim(); if(!h||!r){ toast("Indique les heures et la raison."); return; }
    try{ await pAjout("banque",{employe:emp, date:$("#pa-d").value||todayISO(), minutes:Math.round(h*60), raison:"Ajustement : "+r, par:S.me, creeLe:new Date().toISOString()}); toast("Banque ajustée"); }catch(e){ handleWriteErr(e); } });
  on("#p-conf","click",async()=>{
    const emp=S.pAdm.qui||compteDe("jean"), A=S.pAdm, c=calcPaye(emp,A.du,A.au);
    if(!confirm(`Confirmer la paye de ${S.names[emp]||""} du ${fmtDate(A.du)} au ${fmtDate(A.au)} : ${hD(c.aPayer)} à payer?`)) return;
    S.pBusy="conf"; render();
    try{
      const now=new Date().toISOString();
      const p=await pAjout("payes",{employe:emp, du:A.du, au:A.au, confirmeLe:now, par:S.me, heuresAPayer:c.aPayer, travail:c.t.trav, diners:c.t.diner, surplus:c.t.surplus, feries:c.fer, maladie:c.mal, retraits:c.ret, km:c.kmTotal, semaines:c.semaines});
      for(const w of c.semaines) if(w.surplus>0) await pAjout("banque",{employe:emp, date:(w.dimanche<A.au?w.dimanche:A.au), minutes:w.surplus, raison:`Surplus de la semaine du ${fmtDate(w.lundi)} (${hD(w.total)} avec les dîners)`, payeId:p.id, par:S.me, creeLe:now});
      for(const r of c.retraits){ await pAjout("banque",{employe:emp, date:r.date, minutes:-(+r.minutes||0), raison:`Heures prises le ${fmtDate(r.date)}${r.note?` (${r.note})`:""}`, payeId:p.id, par:S.me, creeLe:now}); await S.db.collection("paye_specs").doc(r.id).update({payeId:p.id}); }
      for(const k of c.kms) await S.db.collection("paye_specs").doc(k.id).update({payeId:p.id});
      for(const m of c.malades) if(!m.payeId) await S.db.collection("paye_specs").doc(m.id).update({payeId:p.id, payee:m.payeeCalc});
      toast("Paye confirmée ✅");
    }catch(e){ handleWriteErr(e); }
    S.pBusy=""; render();
  });
  all("[data-pannule]",b=>b.addEventListener("click",async()=>{
    if(!confirm("Annuler cette paye? Les mouvements de banque qu'elle a créés seront retirés.")) return;
    const id=b.dataset.pannule;
    try{
      for(const x of S.banque.filter(x=>x.payeId===id)) await S.db.collection("banque").doc(x.id).delete();
      for(const s of S.pspecs.filter(s=>s.payeId===id)) await S.db.collection("paye_specs").doc(s.id).update({payeId:null});
      await S.db.collection("payes").doc(id).delete(); toast("Paye annulée");
    }catch(e){ handleWriteErr(e); }
  }));
}
/* ---------- rendu ---------- */
function setView(){
  const h = (location.hash||"").slice(1);
  S.view = ["travaux","temps","resume","billets","facturation","nouveau","alertes","urgences","paye"].includes(h) ? h : "temps";
  document.querySelectorAll("nav.tabs a").forEach(a=>a.setAttribute("aria-current", a.dataset.v===S.view?"page":"false"));
  render();
}
function render(){
  const m = $("#mnt-main");
  const nTrav = S.tickets.filter(t=>(((t.assignes||[]).includes(S.me)||repartiMoi(t)) && actif(t) && !["termine","termine_facturer"].includes(t.avancement)) || (JEAN.includes(sOf(t).k) && !(t.assignes||[]).length && !(t.repartiA||[]).length && !attenteApprob(t))).length, nFact = factGroups().reduce((a,[,it])=>a+it.length,0);
  const bt=$("#b-travaux"), bf=$("#b-fact");
  bt.hidden=!nTrav; bt.textContent=nTrav; bf.hidden=!nFact; bf.textContent=nFact;
  urgBadge(); $("#b-temps").hidden = !S.temps.some(e=>e.enCours && e.par===S.me);
  const AL=alertes(), nAl=AL.approb.length+AL.eau.length+AL.retard.length, ta=document.querySelector('nav.tabs a[data-v="alertes"]'), ba=$("#b-al");
  ta.hidden=!voitAlertes(); ba.hidden=!nAl; ba.textContent=nAl;
  // Ne pas effacer un formulaire en cours de saisie quand des données arrivent
  if (S.view==="nouveau" && $("#f-new")) { renderSheet(); return; }
  const ae=document.activeElement, focusId=ae&&ae.id&&m.contains(ae)?ae.id:null, selS=ae&&ae.selectionStart, selE=ae&&ae.selectionEnd;
  let banner = "";
  if (!S.db) banner = `<div class="banner warn">La base partagée n'est pas disponible dans cette vue. Ouvre l'application dans claude.ai, connectée à ton compte, pour voir et modifier les billets.</div>`;
  else if (S.error) banner = `<div class="banner warn">${esc(S.error)}</div>`;
  else if (S.slow && !S.loaded) banner = `<div class="banner">Les billets prennent du temps à arriver. Vérifie ta connexion; la page se mettra à jour toute seule.</div>`;
  if (voitAlertes() && nAl && S.view!=="alertes") banner += `<a class="banner warn alert-bar" href="#alertes">🔔 ${[AL.approb.length?`${AL.approb.length} demande${AL.approb.length>1?"s":""} à approuver`:"", AL.eau.length?`${AL.eau.length} problème${AL.eau.length>1?"s":""} d'eau à voir`:"", AL.retard.length?`${AL.retard.length} priorité${AL.retard.length>1?"s":""} non réglée${AL.retard.length>1?"s":""} après 2 jours`:""].filter(Boolean).join(" · ")} →</a>`;
  if (S.apercu) banner = `<div class="banner apercu-bar"><span>👁 Tu vois l'application comme <b>${esc(S.names[S.apercu]||"ce profil")}</b>. Lecture seulement : rien ne peut être modifié.</span><button class="btn" id="apercu-off">Revenir à mon compte</button></div>` + banner;
  const tf=document.querySelector('nav.tabs a[data-v="facturation"]'); if(tf) tf.hidden=!S.canAdmin;
  renderApercu();
  if (S.readOnly && !S.apercu) banner += `<div class="banner">Tu as un accès en lecture seulement. Demande à Pénélope de te donner l'accès « Peut modifier » pour modifier les billets.</div>`;
  if (S.view==="nouveau") m.innerHTML = banner + viewNouveau();
  else if (S.view==="billets") m.innerHTML = banner + viewBillets();
  else if (S.view==="facturation") m.innerHTML = banner + (S.canAdmin ? viewFacturation() : emptyBox("Section réservée à l'administration","La facturation est visible seulement pour l'administration."));
  else if (S.view==="urgences") m.innerHTML = banner + viewUrgences();
  else if (S.view==="paye") m.innerHTML = banner + viewPaye();
  else if (S.view==="temps") m.innerHTML = banner + viewTemps();
  else if (S.view==="resume") m.innerHTML = banner + viewResume();
  else if (S.view==="alertes") m.innerHTML = banner + (voitAlertes() ? viewAlertes() : emptyBox("Section réservée","Cette section est réservée à William et à l'administration."));
  else m.innerHTML = banner + viewTravaux();
  bindView();
  if (focusId){ const el=document.getElementById(focusId); if(el){ el.focus(); try{ if(selS!=null) el.setSelectionRange(selS,selE); }catch{} } }
  renderSheet();
  resolveNames();
}

function pill(t){
  const s = sOf(t);
  return `<span class="pill" style="--sc:${s.c};--si:${s.i}">${s.l}</span>`;
}
const uniteLabel = u => !u ? "" : (ZONES.find(z=>z.k===u) ? ZONES.find(z=>z.k===u).l : `app. ${u}`);
function card(t){
  const s = sOf(t), min = minutesOf(t);
  const rt = S.temps.find(e=>e.enCours && e.ticketId===t.id), since = t.chrono ? t.chrono.debut : rt && rt.debut;
  const live = since ? `<span class="timer-live" data-since="${esc(since)}">● ${fmtH((Date.now()-Date.parse(since))/60000)}</span>` : "";
  return `<article class="card ${s.k==="priorite"?"card-urg":""}" style="--sc:${s.c}" data-open="${esc(t.id)}" tabindex="0">
    <div class="row1"><div class="addr">${esc(adrAff(t.immeuble)||"Adresse à préciser")}${t.unite?` <span class="muted">· ${esc(uniteLabel(t.unite))}</span>`:""}</div><div>${pill(t)}</div></div>
    <div class="desc">${esc(t.description)}</div>
    ${flagsHTML(t)}
    ${(t.assignes||[]).length||(t.repartiA||[]).length||t.avancement?`<div class="tags">${t.avancement?`<span class="av av-${esc(t.avancement)}">${esc(AVL[t.avancement]||"")}</span>`:""}${repTags(t)}${(t.assignes||[]).map(id=>`<span class="tag">${esc(S.names[id]||"…")}${id===S.me?" (moi)":""}</span>`).join("")}</div>`:""}
    <div class="meta"><span>${esc(t.categorie||"")}</span>${t.datePrevue?`<span>Prévu ${fmtDate(t.datePrevue)}</span>`:""}${min?`<span class="num">${fmtH(min)}</span>`:""}${matOf(t)?`<span class="num">${money.format(matOf(t))} matériel</span>`:""}${live}<span class="muted small">${code(t)}</span></div>
  </article>`;
}
function emptyBox(title, text, cta){ return `<div class="empty"><h3>${title}</h3><p>${text}</p>${cta?`<p><a class="btn primary" href="#nouveau">${cta}</a></p>`:""}</div>`; }

function viewTravaux(){
  const recent = t => !t.termineLe || (Date.now()-Date.parse(t.termineLe)) < 14*864e5;
  const mine = S.tickets.filter(t=>((t.assignes||[]).includes(S.me)||repartiMoi(t)) && !["regle_ferme","ferme_refuse"].includes(t.statut) && recent(t));
  const libres = S.tickets.filter(t=>JEAN.includes(sOf(t).k) && !(t.assignes||[]).length && !(t.repartiA||[]).length && !attenteApprob(t));
  const enCours = S.tickets.filter(t=>t.chrono || S.temps.some(e=>e.enCours && e.ticketId===t.id));
  const secs = AV.map(a=>[a, mine.filter(t=>(t.avancement||"en_cours")===a.k).sort(sortTickets)]).filter(([,ts])=>ts.length);
  return `<div class="view-head"><div><h2>Mes travaux</h2><p>Les demandes qui te sont envoyées ou où tu es identifié, classées par avancement. Plus bas : les demandes que personne n'a encore prises. Touche une demande pour t'identifier dessus.</p></div></div>
  ${enCours.length?`<div class="banner"><b>Chrono en marche :</b> ${enCours.map(t=>esc(adrAff(t.immeuble))).join(", ")}</div>`:""}
  ${!S.loaded && S.db ? "" : `
    ${secs.length ? secs.map(([a,ts])=>`<h3 class="grp"><span class="av av-${a.k}">${a.l}</span><span class="muted small num">${ts.length}</span></h3><div class="list">${ts.map(card).join("")}</div>`).join("") : `<div class="empty"><h3>Aucune demande à ton nom</h3><p>Ouvre une demande ci-dessous et touche « Je m'en occupe ».</p></div>`}
    <h2 class="sub">À prendre</h2>
    ${libres.length ? grouped(libres, JEAN) : `<p class="muted">Aucune demande en attente d'être prise.</p>`}`}`;
}

function viewAlertes(){
  const A=alertes(), w=estApprobateur(), nmW=S.names[approbId()]||"William";
  const item=(t,btns)=>`<div class="al-item">${card(t)}${btns?`<div class="btns">${btns}</div>`:""}</div>`;
  const apprBtns=t=> w&&!S.readOnly ? `<button class="btn primary" data-appr="${esc(t.id)}">Approuver</button><button class="btn danger" data-refus="${esc(t.id)}">Refuser</button>` : `<span class="muted small">En attente de ${esc(nmW)}</span>`;
  const vuBtn=t=> w&&!S.readOnly ? `<button class="btn" data-vu="${esc(t.id)}">Vu, je suis au courant</button>` : `<span class="muted small">${esc(nmW)} ne l'a pas encore vu</span>`;
  return `<div class="view-head"><div><h2>À approuver et alertes</h2><p>Les demandes d'East Angus, de Magog, de la rue Murray et de la rue Principale à Richmond attendent l'approbation de William avant que Jean puisse les prendre. Les problèmes d'eau sont mis en priorité et signalés ici. Une priorité qui n'est pas réglée après 2 jours revient en rappel chaque jour.</p></div></div>
  ${!approbId() ? `<div class="banner warn">William n'est pas encore choisi comme approbateur. ${S.canAdmin?"Choisis-le dans Facturation › Réglages.":""}</div>`:""}
  <h2 class="sub" style="margin-top:0;border-top:0;padding-top:0">Demandes à approuver <span class="muted small num">${A.approb.length}</span></h2>
  ${A.approb.length ? A.approb.sort(sortTickets).map(t=>item(t,apprBtns(t))).join("") : `<p class="muted">Aucune demande à approuver.</p>`}
  <h2 class="sub">Problèmes d'eau à voir <span class="muted small num">${A.eau.length}</span></h2>
  ${A.eau.length ? A.eau.sort(sortTickets).map(t=>item(t,vuBtn(t))).join("") : `<p class="muted">Aucun nouveau problème d'eau.</p>`}
  <h2 class="sub">Rappels : priorités non réglées après 2 jours <span class="muted small num">${A.retard.length}</span></h2>
  ${A.retard.length ? A.retard.sort((a,b)=>prioDepuis(a).localeCompare(prioDepuis(b))).map(t=>item(t,"")).join("") : `<p class="muted">Aucune priorité en retard.</p>`}`;
}

function viewBillets(){
  const now = new Date(), ym = `${now.getFullYear()}-${String(now.getMonth()+1).padStart(2,"0")}`;
  const minMois = resumeEntries().filter(e=>(e.date||"").startsWith(ym) && (S.canAdmin || e.par===S.me)).reduce((a,e)=>a+(+e.minutes||0),0);
  const cnt = k => S.tickets.filter(t=>t.statut===k).length;
  const f = S.filt, q = f.q.trim().toLowerCase();
  let list = S.tickets.filter(t => {
    if (f.statut==="actifs" && !actif(t)) return false;
    if (f.statut==="fermes" && actif(t)) return false;
    if (f.statut==="afermer" && !(actif(t) && t.avancement==="termine")) return false;
    if (f.immeuble && t.immeuble!==f.immeuble) return false;
    if (f.rep==="aucun" ? (t.repartiA||[]).length : f.rep && !(t.repartiA||[]).includes(f.rep)) return false;
    if (q && !`${t.immeuble} ${adrAff(t.immeuble)} ${t.unite} ${t.description} ${t.demandeur} ${t.categorie} ${code(t)}`.toLowerCase().includes(q)) return false;
    return true;
  });
  const imms = [...new Set(S.tickets.map(t=>t.immeuble).filter(Boolean))].sort(adrCmp);
  const chip = (k,l)=>`<button class="chip" data-st="${k}" aria-pressed="${f.statut===k}">${l}</button>`;
  return `<div class="view-head"><div><h2>Tous les billets</h2><p>Les demandes de service classées par catégorie, comme dans Monday.</p></div><a class="btn primary" href="#nouveau">+ Nouveau billet</a></div>
  <div class="stats">
    <div class="stat"><b class="num">${cnt("priorite")}</b><span>Priorité</span></div>
    <div class="stat"><b class="num">${cnt("a_traiter")}</b><span>À traiter</span></div>
    <div class="stat"><b class="num">${cnt("en_cours")}</b><span>En cours</span></div>
    <div class="stat"><b class="num">${cnt("en_attente")+cnt("envoye_nic")+cnt("pour_will")}</b><span>En attente / transférés</span></div>
    <div class="stat"><b class="num">${(minMois/60).toFixed(1).replace(".",",")} h</b><span>Heures ce mois</span></div>
  </div>
  <div class="filters"><input id="f-q" type="search" placeholder="Rechercher une adresse, un locataire, un mot…" value="${esc(f.q)}">
    <select id="f-imm"><option value="">Tous les immeubles</option>${imms.map(i=>`<option value="${esc(i)}" ${i===f.immeuble?"selected":""}>${esc(adrAff(i))}</option>`).join("")}</select>
    <select id="f-rep"><option value="">Toutes les personnes</option>${EQUIPE.map(p=>`<option value="${p.k}" ${f.rep===p.k?"selected":""}>Envoyées à ${esc(p.l)}</option>`).join("")}<option value="aucun" ${f.rep==="aucun"?"selected":""}>Pas encore envoyées</option></select></div>
  <div class="chips" style="margin-bottom:14px">${chip("actifs","Ouverts")}${S.canAdmin?chip("afermer","Terminées à fermer"):""}${chip("fermes","Fermés")}${chip("tous","Tous")}</div>
  ${list.length ? grouped(list, STATUTS.map(s=>s.k)) : (S.tickets.length ? emptyBox("Aucun billet pour ces filtres","Essaie un autre statut ou efface la recherche.") : emptyBox("Aucun billet pour l'instant","Crée le premier billet à partir d'une demande de réparation reçue.","Créer un billet"))}`;
}

/* ---------- Feuille de temps (remplace Clockify) ---------- */
const OUTILS = ["Machine à l'ozone","Sécheur commercial","Laveuse à pression","Fish"];
const MATS_RAPIDES = ["Plâtre","Luminaire","Peinture 5 gallons","Silicone / calfeutrant","Serrure de boîte aux lettres","Pêne dormant","Plancher"];
const unitsOf = adr => ((S.config.immeubles||[]).find(i=>i.adresse===adr)||{}).unites || [];
function weekStart(){ const d=new Date(); const day=(d.getDay()+6)%7; d.setDate(d.getDate()-day); d.setHours(0,0,0,0); d.setMinutes(d.getMinutes()-d.getTimezoneOffset()); return d.toISOString().slice(0,10); }
const hhmm = iso => { if(!iso) return ""; const d=new Date(iso); return `${String(d.getHours()).padStart(2,"0")}:${String(d.getMinutes()).padStart(2,"0")}`; };
const fmtHeure = iso => iso ? new Date(iso).toLocaleTimeString("fr-CA",{hour:"2-digit",minute:"2-digit"}) : "";
function plage(f){ // retourne {debut, fin, minutes} ou un message d'erreur
  if(!f.date || !f.deb || !f.fin) return {err:"Entre la date, l'heure de début et l'heure de fin."};
  const d=new Date(`${f.date}T${f.deb}:00`); let e=new Date(`${f.date}T${f.fin}:00`), lend=false;
  if(e.getTime()===d.getTime()) return {err:"L'heure de début et l'heure de fin sont pareilles."};
  if(e<d){ e=new Date(`${f.date}T${f.fin}:00`); e.setDate(e.getDate()+1); lend=true; } // travail de nuit : fin le lendemain
  const minutes=Math.round((e-d)/60000);
  if(minutes>16*60) return {err:"Plus de 16 heures : vérifie l'heure de début et de fin."};
  return {debut:d.toISOString(), fin:e.toISOString(), minutes, lend};
}
/* ---------- Dictée vocale ---------- */
/* Dictée de secours : reconnaissance vocale du navigateur (téléphone, Safari…) */
function makeWebDict(){
  const SR = window.SpeechRecognition || window.webkitSpeechRecognition;
  if(!SR) return null;
  const h={}; let rec=null;
  return {
    web:true,
    onFinal(f){h.final=f;}, onPartial(f){h.partial=f;}, onState(f){h.state=f;},
    start(){ return new Promise((res,rej)=>{
      let started=false, err=null;
      try{ rec=new SR(); }catch(e){ rej({code:"unavailable"}); return; }
      rec.lang="fr-CA"; rec.interimResults=true; rec.continuous=false; rec.maxAlternatives=1;
      rec.onstart=()=>{ started=true; h.state&&h.state({state:"listening"}); res(); };
      rec.onresult=ev=>{ let interim=""; for(let i=ev.resultIndex;i<ev.results.length;i++){ const r=ev.results[i]; if(r.isFinal) h.final&&h.final({text:r[0].transcript}); else interim+=r[0].transcript; } h.partial&&h.partial({text:interim}); };
      rec.onerror=e=>{ err=e.error; if(!started) rej({code:(e.error==="not-allowed"||e.error==="service-not-allowed")?"web_blocked":"unavailable"}); };
      rec.onend=()=>{ rec=null; h.state&&h.state({state:"idle",reason: !started?"stopped":(err&&err!=="no-speech"&&err!=="aborted"?"upstream_error":"stopped")}); };
      try{ rec.start(); }catch(e){ rej({code:"unavailable"}); }
    }); },
    stop(){ try{ rec&&rec.stop(); }catch(e){} return Promise.resolve(); }
  };
}
const MIC_AIDE = "La dictée n'est pas permise dans cette fenêtre. Ouvre l'application dans Chrome (ou l'application Claude sur ordinateur), ou utilise la dictée du clavier : sur Samsung, touche ⚙️ ou les 3 points au-dessus du clavier puis 🎤 « Saisie vocale ».";
function mic(target){
  if(!S.dict) return `<button type="button" class="mic" data-mic="${target}" aria-pressed="false">🎤 Dicter</button>`;
  const on = S.micOn && S.micTarget===target;
  return `<button type="button" class="mic ${on?"on":""}" data-mic="${target}" aria-pressed="${on}">${on?"■ Arrêter la dictée":"🎤 Dicter"}</button><span class="mic-live" data-live="${target}">${on&&S.micPartial?esc(S.micPartial):""}</span>`;
}
function setupDictation(d){
  d.onFinal(({text})=>{ const el=document.getElementById(S.micTarget); if(!el) return; const add = el.value.trim() ? text : text.replace(/^\s+/,""); el.value = el.value.replace(/\s+$/,"") + (el.value.trim()&&!/^\s/.test(add)?" ":"") + add; el.dispatchEvent(new Event("input",{bubbles:true})); });
  d.onPartial(({text})=>{ S.micPartial=text; const l=document.querySelector(`[data-live="${S.micTarget}"]`); if(l) l.textContent=text; });
  d.onState(({state,reason})=>{
    S.micOn = state!=="idle";
    if(state==="idle"){ S.micPartial=""; if(reason==="not_granted") toast("La dictée est bloquée. Autorise le micro dans les permissions de l'application."); else if(reason==="unavailable"){ switchToWebDict(); return; } else if(reason==="upstream_error") toast("La dictée a eu un problème. Réessaie."); }
    document.querySelectorAll("[data-mic]").forEach(b=>{ const on=S.micOn && b.dataset.mic===S.micTarget; b.classList.toggle("on",on); b.setAttribute("aria-pressed",on); b.textContent = on?"■ Arrêter la dictée":"🎤 Dicter"; });
    if(state==="idle") document.querySelectorAll("[data-live]").forEach(l=>l.textContent="");
  });
}
function switchToWebDict(){
  const w = (S.dict && S.dict.web) ? null : makeWebDict();
  S.dict = w; if(w) setupDictation(w);
  render();
}
function bindMics(root=document){
  root.querySelectorAll("[data-mic]").forEach(b=>b.addEventListener("click",()=>{
    if(!S.dict){ toast(MIC_AIDE); const el=document.getElementById(b.dataset.mic); if(el) el.focus(); return; }
    const target=b.dataset.mic;
    if(S.micOn && S.micTarget===target){ S.dict.stop(); return; }
    if(S.micOn){ S.dict.stop(); }
    S.micTarget=target;
    const d=S.dict;
    d.start().catch(e=>{
      const c=e&&e.code;
      if(c==="not_granted") toast("Tu as refusé la dictée. Tu peux la permettre dans les permissions de l'application.");
      else if(c==="web_blocked"){ S.dict=null; render(); toast(MIC_AIDE); }
      else if(c==="unavailable"){ if(d.web){ S.dict=null; render(); toast(MIC_AIDE); } else switchToWebDict(); }
      else if(c!=="stopped"&&c!=="dismissed") toast("La dictée n'a pas pu démarrer.");
    });
  }));
}
function resetTForm(){ Object.assign(S.tForm,{pendingId:null,deb:"",fin:"",editId:null,ticketId:null,type:"immeuble",immeuble:"",zone:"logement",logement:"",activite:BUREAU[0],activiteAutre:"",desc:"",urgence:"",outils:[],outilAutre:"",stock:"",mats:[],matArt:"",matQte:"",min:"",date:"",manuel:false}); }
const entryDetails = e => [
  e.urgence===true?"Urgence":"",
  (e.outils||[]).length?`Outils : ${e.outils.join(", ")}`:"",
  (e.materiauxStock||[]).length?`Stock : ${e.materiauxStock.map(m=>m.quantite?`${m.quantite} × ${m.article}`:m.article).join(", ")}`:""
].filter(Boolean).join(" · ");

function formDetails(mode){
  const f=S.tForm, units=unitsOf(f.immeuble), ro=S.readOnly||!S.db;
  const chk=(name,list,val)=>`<label class="opt"><input type="checkbox" data-${name}="${esc(val)}" ${list.includes(val)?"checked":""}> ${esc(val)}</label>`;
  let n=1; const N=()=>n++;
  const open = S.tickets.filter(t=>actif(t) || t.id===f.ticketId);
  const aMoi = t => (t.assignes||[]).includes(S.me) || repartiMoi(t);
  const mineFirst = [...open].sort((a,b)=>aMoi(b) - aMoi(a) || adrCmp(a.immeuble||"",b.immeuble||""));
  const tk = S.tickets.find(t=>t.id===f.ticketId);
  const timeStep=()=>`<div class="step"><h3><span class="stepn">${N()}</span> ${mode==="chrono"?"Heures travaillées (ajuste au besoin)":"Début et fin du travail"}</h3>
    <div class="plage">
      <div class="field"><label for="t-deb">Début</label><input id="t-deb" type="time" step="60" value="${esc(f.deb)}"></div>
      <span class="plage-sep" aria-hidden="true">–</span>
      <div class="field"><label for="t-fin">Fin</label><input id="t-fin" type="time" step="60" value="${esc(f.fin)}"></div>
      <div class="field"><label for="t-date">Date</label><input id="t-date" type="date" value="${esc(f.date||todayISO())}"></div>
      <div class="plage-total"><span class="small muted">Durée</span><b class="num" id="t-dur">${(()=>{ const p=plage({...f,date:f.date||todayISO()}); return p.err?"—":fmtH(p.minutes)+(p.lend?" (fin le lendemain)":""); })()}</b></div>
    </div></div>`;
  return `
  ${mode==="manuel"?timeStep():""}
  <div class="step"><h3><span class="stepn">${N()}</span> Pour quelle demande de service?</h3>
    <div class="field"><label for="t-ticket">Demande de service</label><select id="t-ticket">
      <option value="">Aucune — autre travail (choisir l'immeuble plus bas)</option>
      ${mineFirst.map(t=>`<option value="${esc(t.id)}" ${t.id===f.ticketId?"selected":""}>${aMoi(t)?"★ ":""}${esc(adrAff(t.immeuble))}${t.unite?` · ${esc(uniteLabel(t.unite))}`:""} — ${esc(firstLine(t.description).slice(0,60))}</option>`).join("")}
    </select></div>
    ${tk?`<div class="solution" style="border-left-color:var(--brand);background:var(--accent-soft)"><b>${esc(adrAff(tk.immeuble))}${tk.unite?` · ${esc(uniteLabel(tk.unite))}`:""}</b><br>${esc(firstLine(tk.description))}<br><span class="small muted">Ce temps sera ajouté à cette demande et facturé avec elle.</span></div>`:`<p class="muted small">★ = demandes qui te sont envoyées ou où tu es identifié.</p>`}</div>

  <div class="step"><h3><span class="stepn">${N()}</span> Qu'as-tu fait?</h3>
    <div class="field"><label for="t-desc">Description du travail</label><textarea id="t-desc" placeholder="ex. Réparé le trou dans le mur de la chambre et peinturé">${esc(f.desc)}</textarea></div></div>

  ${tk?"":`<div class="step"><h3><span class="stepn">${N()}</span> Où?</h3>
    <div class="chips" style="margin-bottom:10px"><button class="chip" type="button" data-ttype="immeuble" aria-pressed="${f.type==="immeuble"}">Sur un immeuble</button><button class="chip" type="button" data-ttype="bureau" aria-pressed="${f.type==="bureau"}">Au bureau</button>${isGest()?`<button class="chip" type="button" data-ttype="gestion" aria-pressed="${f.type==="gestion"}">Gestion</button>`:""}</div>
    <div class="fgrid">
    ${f.type==="immeuble"?`
      <div class="field full"><label for="t-imm">Immeuble concerné</label>${immPicker("t-imm",f.immeuble)}</div>
      <div class="field"><label for="t-zone">Endroit</label><select id="t-zone">${ZONES.map(z=>`<option value="${z.k}" ${z.k===f.zone?"selected":""}>${z.l}</option>`).join("")}</select></div>
      ${f.zone==="logement"?`<div class="field"><label for="t-log">Appartement</label>${units.length?`<select id="t-log"><option value="">Choisir…</option>${units.map(u=>`<option ${u===f.logement?"selected":""}>${esc(u)}</option>`).join("")}</select>`:`<input id="t-log" value="${esc(f.logement)}" placeholder="No d'appartement">`}</div>`:`<div class="field"></div>`}
    `:`
      <div class="field full"><label for="t-act">${f.type==="gestion"?"Tâche de gestion":"Activité"}</label><select id="t-act">${(f.type==="gestion"?GESTION:BUREAU).map(b=>`<option ${b===f.activite?"selected":""}>${b}</option>`).join("")}${f.type==="gestion"?`<option value="${AUTRE}" ${f.activite===AUTRE?"selected":""}>Autre tâche (préciser)</option>`:""}</select></div>
      ${f.type==="gestion"&&f.activite===AUTRE?`<div class="field full"><label for="t-act-autre">Quelle tâche?</label><input id="t-act-autre" value="${esc(f.activiteAutre||"")}" placeholder="ex. Appel avec l'assureur"></div>`:""}
    `}</div></div>`}

  ${f.type==="immeuble"?`
  <div class="step"><h3><span class="stepn">${N()}</span> Était-ce une urgence?</h3>
    <div class="chips"><button class="chip" type="button" data-urg="oui" aria-pressed="${f.urgence==="oui"}">Oui, une urgence</button><button class="chip" type="button" data-urg="non" aria-pressed="${f.urgence==="non"}">Non</button></div></div>

  <div class="step"><h3><span class="stepn">${N()}</span> As-tu utilisé des outils spéciaux?</h3>
    <div class="opts">${OUTILS.map(o=>chk("outil",f.outils,o)).join("")}${f.outils.filter(o=>!OUTILS.includes(o)).map(o=>chk("outil",f.outils,o)).join("")}</div>
    <div class="inline"><input id="t-outil" value="${esc(f.outilAutre)}" placeholder="Autre outil (écris-le)"><button class="btn" type="button" id="t-outil-add">Ajouter</button></div></div>

  <div class="step"><h3><span class="stepn">${N()}</span> As-tu pris des matériaux déjà en stock?</h3>
    <div class="chips" style="margin-bottom:8px"><button class="chip" type="button" data-stock="oui" aria-pressed="${f.stock==="oui"}">Oui</button><button class="chip" type="button" data-stock="non" aria-pressed="${f.stock==="non"}">Non</button></div>
    ${f.stock==="oui"?`
      <div class="chips" style="margin-bottom:8px">${MATS_RAPIDES.map(m=>`<button class="chip" type="button" data-matq="${esc(m)}">+ ${esc(m)}</button>`).join("")}</div>
      <div class="lines">${f.mats.map((m,i)=>`<div class="line"><span class="l">${esc(m.article)}</span><span class="r"><input class="qte" data-matqte="${i}" value="${esc(m.quantite)}" placeholder="Qté" aria-label="Quantité de ${esc(m.article)}"><button class="x" type="button" data-matdel="${i}" aria-label="Retirer">×</button></span></div>`).join("") || `<p class="muted small">Touche un article ci-dessus ou écris-le plus bas.</p>`}</div>
      <div class="inline"><input id="t-mat" value="${esc(f.matArt)}" placeholder="Autre matériau (ex. 2 x 4 de 8 pi)"><input id="t-matq" value="${esc(f.matQte)}" placeholder="Quantité" style="flex:0 1 110px"><button class="btn" type="button" id="t-mat-add">Ajouter</button></div>`:""}
  </div>`:""}

  ${mode==="chrono"?timeStep():""}

  <div class="btns" style="margin-top:14px"><button class="btn primary big" id="t-save" ${ro?"disabled":""}>${S.tForm.editId?"Enregistrer la modification":mode==="manuel"?"Enregistrer ce temps":"Enregistrer la feuille de temps"}</button>${mode==="manuel"?`<button class="btn big" id="t-cancel-man">Annuler</button>`:""}${mode==="chrono"&&!ro?(S.tDiscard?`</div><div class="confirm" style="margin-top:10px"><span>Supprimer ce temps sans l'enregistrer? Il ne sera pas compté.</span><button class="btn danger" id="t-discard2">Oui, annuler ce temps</button><button class="btn" id="t-discard-no">Non, le garder</button>`:`<button class="btn big danger" id="t-discard">Annuler ce temps</button>`):""}</div>`;
}

function allRevs(){ return Object.values(S.revs).flat().sort((a,b)=>(b.quand||"").localeCompare(a.quand||"")); }
function revList(tempsId){
  const rs=allRevs().filter(r=>r.tempsId===tempsId);
  return `<div class="revs">${rs.map(r=>`<div><span class="muted small num">${new Date(r.quand).toLocaleString("fr-CA",{day:"numeric",month:"short",hour:"2-digit",minute:"2-digit"})} · ${esc(S.names[r.par]||"…")}</span><br>${esc(diffText(r.avant,r.apres))}</div>`).join("")||`<div class="muted small">Historique pas encore chargé.</div>`}</div>`;
}
function viewTemps(){
  const f=S.tForm, ro=S.readOnly||!S.db;
  const run=S.temps.find(e=>e.enCours && e.par===S.me);
  const pending=S.temps.filter(e=>!e.enCours && e.aRemplir && e.par===S.me).sort((a,b)=>(a.creeLe||"").localeCompare(b.creeLe||""))[0];
  const ws=weekStart();
  const semaineTous=S.temps.filter(e=>!e.enCours && !e.aRemplir && (e.date||"")>=ws && voitEntree(e) && (S.canAdmin || e.par===S.me));
  const genst=[...new Set(semaineTous.map(e=>e.par).filter(Boolean))];
  if(S.tWho && !genst.includes(S.tWho)) S.tWho="";
  const semaine=semaineTous.filter(e=>!S.canAdmin || !S.tWho || e.par===S.tWho).sort((a,b)=>(b.date||"").localeCompare(a.date||"")||(b.creeLe||"").localeCompare(a.creeLe||""));
  const tot=semaine.reduce((a,e)=>a+(+e.minutes||0),0), totBur=semaine.filter(e=>e.lieuType==="bureau").reduce((a,e)=>a+(+e.minutes||0),0), totGes=semaine.filter(e=>e.lieuType==="gestion").reduce((a,e)=>a+(+e.minutes||0),0);
  const days={}; semaine.forEach(e=>(days[e.date] ||= []).push(e));
  const nm=id=>esc(S.names[id]||"");
  let top;
  if (!run && pending && S.tForm.pendingId!==pending.id){ Object.assign(S.tForm,{pendingId:pending.id, deb:hhmm(pending.debut), fin:hhmm(pending.fin), date:pending.date||todayISO()});
    const tk=pending.ticketId && S.tickets.find(t=>t.id===pending.ticketId);
    if(tk){ const z=ZONES.find(z=>z.k===tk.unite); Object.assign(S.tForm,{ticketId:tk.id, type:"immeuble", immeuble:tk.immeuble||"", zone:z&&z.k!=="logement"?z.k:"logement", logement:z&&z.k!=="logement"?"":(tk.unite||""), urgence:S.tForm.urgence||(tk.statut==="priorite"?"oui":"")}); } }
  if (run) top = `<div class="clock running"><div><div class="small">Chrono en marche depuis ${new Date(run.debut).toLocaleTimeString("fr-CA",{hour:"2-digit",minute:"2-digit"})}</div><b class="num" data-since="${esc(run.debut)}" data-plain="1">${fmtH((Date.now()-Date.parse(run.debut))/60000)}</b></div><div class="btns"><button class="btn primary big" id="t-stop" ${ro?"disabled":""}>Arrêter le chrono</button>${ro?"":(S.tDiscard?`<button class="btn big danger" id="t-discard2">Oui, annuler ce chrono</button><button class="btn big" id="t-discard-no">Non</button>`:`<button class="btn big danger" id="t-discard">Annuler le chrono</button>`)}</div></div>
    <p class="muted small">Le chrono continue de tourner même si tu fermes l'application. Quand tu l'arrêtes, on te demande ce que tu as fait.</p>`;
  else if (pending) top = `<div class="clock done"><div><div class="small">Chrono arrêté · ${fmtDate(pending.date)} · ${fmtHeure(pending.debut)} – ${fmtHeure(pending.fin)} · à compléter</div><b class="num">${fmtH(+pending.minutes||0)}</b></div></div>
    <div class="panel">${formDetails("chrono")}</div>`;
  else if (f.manuel) top = `<div class="panel"><p class="muted small" style="margin-top:0">${f.editId?"<b>Modification d'une entrée.</b> L'administration garde l'historique des changements.":"Pour du temps fait sans chrono."}</p>${formDetails("manuel")}</div>`;
  else top = `<div class="clock"><div><div class="small">Prêt à commencer</div><b class="num">0 min</b></div><button class="btn primary big" id="t-start" ${ro?"disabled":""}>Démarrer le chrono</button></div>
    <p><button class="btn" id="t-manuel" ${ro?"disabled":""}>Entrer du temps sans chrono</button></p>`;
  const revs = S.canAdmin ? allRevs().slice(0,15) : [];
  const revSec = S.canAdmin ? `<div class="sec panel"><h3>Historique des révisions <span class="muted small">visible par l'administration seulement</span></h3>
    ${revs.length ? `<div class="revs">${revs.map(r=>`<div><span class="muted small num">${new Date(r.quand).toLocaleString("fr-CA",{day:"numeric",month:"short",hour:"2-digit",minute:"2-digit"})} · ${esc(S.names[r.par]||"…")} · ${r.action==="suppression"?"Suppression":r.action==="chrono annulé"?"Chrono annulé":"Modification"} de l'entrée du ${fmtDate(r.avant&&r.avant.date)} (${esc(r.avant?r.avant.lieu:"")})</span><br>${esc(diffText(r.avant,r.apres))}</div>`).join("")}</div>` : `<p class="muted small">Aucune modification d'horaire pour l'instant.</p>`}</div>` : "";
  return `<div class="view-head"><div><h2>Feuille de temps</h2><p>1. Démarre le chrono en commençant. 2. Arrête-le quand tu as fini. 3. Indique ce que tu as fait, l'immeuble et l'appartement, si c'était une urgence, les outils spéciaux et les matériaux pris en stock.</p></div></div>
  ${top}
  <div class="sec"><h3>Cette semaine <span class="num small muted">${fmtH(tot)} au total · ${fmtH(totBur)} au bureau${totGes?` · ${fmtH(totGes)} en gestion`:""}${S.canAdmin&&S.config.tauxPaie&&paieOk(S.tWho)?` · paie ${money.format(tot/60*S.config.tauxPaie)}`:""}</span></h3>
  ${S.canAdmin&&genst.length>1?`<div class="chips" style="margin-bottom:8px"><button class="chip" data-twho="" aria-pressed="${!S.tWho}">Tout le monde</button>${genst.map(id=>`<button class="chip" data-twho="${esc(id)}" aria-pressed="${S.tWho===id}">${esc(S.names[id]||"…")}</button>`).join("")}</div>`:""}
  ${semaine.length? Object.entries(days).map(([d,es])=>`<p class="small muted" style="margin:12px 0 6px">${new Date(d+"T12:00:00").toLocaleDateString("fr-CA",{weekday:"long",day:"numeric",month:"long"})} · <span class="num">${fmtH(es.reduce((a,e)=>a+(+e.minutes||0),0))}</span></p><div class="lines">${es.map(e=>`<div class="line line-e ${e.urgence===true?"line-urg":flags(e).hors?"line-hors":""}"><span class="l"><b>${esc(lieuLabel(e))}</b>${e.ticketId&&S.tickets.find(t=>t.id===e.ticketId)?` <button class="linkbtn" data-open="${esc(e.ticketId)}">Demande : ${esc(firstLine(S.tickets.find(t=>t.id===e.ticketId).description).slice(0,40))}</button>`:""}${e.description?`<span class="e-desc">${esc(e.description)}</span>`:""}${flagBadges(e)}${entryDetails(e)?`<br><span class="muted small">${esc(entryDetails(e))}</span>`:""}${nm(e.par)?` <span class="muted small">(${nm(e.par)})</span>`:""}${e.facture&&S.canAdmin?` <span class="pill" style="--sc:#037f4c">Facturé</span>`:""}${e.chronoOriginal&&S.canAdmin?` <span class="muted small">· chrono ajusté (original ${fmtHeure(e.chronoOriginal.debut)} – ${fmtHeure(e.chronoOriginal.fin)})</span>`:""}${e.nbRevisions&&S.canAdmin?` <button class="linkbtn" data-showrev="${esc(e.id)}">Modifiée ${e.nbRevisions} fois — voir l'historique</button>`:""}${S.showRev===e.id?revList(e.id):""}</span><span class="r num">${e.debut&&e.fin?`<span class="muted">${fmtHeure(e.debut)} – ${fmtHeure(e.fin)}</span>`:""}<b>${fmtH(+e.minutes||0)}</b>${!ro && !e.facture && (e.par===S.me||S.canAdmin)?`<button class="x" data-tedit="${esc(e.id)}" aria-label="Modifier" title="Modifier">✎</button>`:""}${!ro && !e.facture && (e.par===S.me||S.canAdmin)?(S.tConfirm===e.id?` <button class="btn danger" data-tdel2="${esc(e.id)}" style="min-height:32px;padding:4px 10px">Retirer</button>`:`<button class="x" data-tdel="${esc(e.id)}" aria-label="Retirer">×</button>`):""}</span></div>`).join("")}</div>`).join("") : `<div class="empty"><h3>Aucun temps cette semaine</h3><p>Démarre le chrono en arrivant à un immeuble ou au bureau.</p></div>`}
  </div>${revSec}`;
}

const snapEntry = e => ({lieu:lieuLabel(e), heures:e.debut&&e.fin?`${fmtHeure(e.debut)} – ${fmtHeure(e.fin)}`:"", minutes:+e.minutes||0, date:e.date||"", description:e.description||"", urgence:!!e.urgence, outils:e.outils||[], materiauxStock:e.materiauxStock||[]});
function diffText(a,b){
  const out=[];
  if(!b) return a&&a.heures ? `Temps non enregistré : ${a.heures} (${fmtH(a.minutes)})` : "Entrée supprimée";
  if((a.heures||"")!==(b.heures||"")) out.push(`Heures : ${a.heures||"—"} → ${b.heures||"—"}`);
  if(a.minutes!==b.minutes) out.push(`Durée : ${fmtH(a.minutes)} → ${fmtH(b.minutes)}`);
  if(a.date!==b.date) out.push(`Date : ${fmtDate(a.date)} → ${fmtDate(b.date)}`);
  if(a.lieu!==b.lieu) out.push(`Lieu : ${a.lieu} → ${b.lieu}`);
  if(a.description!==b.description) out.push(`Description : « ${a.description} » → « ${b.description} »`);
  if(a.urgence!==b.urgence) out.push(`Urgence : ${a.urgence?"oui":"non"} → ${b.urgence?"oui":"non"}`);
  if(JSON.stringify(a.outils)!==JSON.stringify(b.outils)) out.push(`Outils : ${a.outils.join(", ")||"aucun"} → ${b.outils.join(", ")||"aucun"}`);
  const ms=m=>m.map(x=>x.quantite?`${x.quantite} × ${x.article}`:x.article).join(", ")||"aucun";
  if(ms(a.materiauxStock)!==ms(b.materiauxStock)) out.push(`Matériaux : ${ms(a.materiauxStock)} → ${ms(b.materiauxStock)}`);
  return out.join(" · ") || "Aucun changement";
}
async function logRevision(e, apres, action){
  if(!S.me || !S.db) return;
  try{ await S.db.collection(`revisions/${S.me}/log`).add({tempsId:e.id, action, quand:new Date().toISOString(), par:S.me, auteurEntree:e.par||null, avant:snapEntry(e), apres:apres?snapEntry(apres):null}); }
  catch(err){ /* la modification reste enregistrée même si le journal échoue */ }
}
function tPayload(){
  const f=S.tForm;
  if(!f.desc.trim()){ toast("Écris ce que tu as fait."); return null; }
  if(f.type==="gestion" && f.activite===AUTRE && !String(f.activiteAutre||"").trim()){ toast("Précise la tâche de gestion."); return null; }
  if(f.type==="bureau"||f.type==="gestion") return {ticketId:null, lieuType:f.type, activite:f.type==="gestion"&&f.activite===AUTRE?String(f.activiteAutre).trim():f.activite, description:f.desc.trim(), urgence:false, outils:[], materiauxStock:[]};
  if(!f.immeuble){ toast("Choisis l'immeuble concerné."); return null; }
  if(f.zone==="logement" && !String(f.logement).trim()){ if(f.ticketId){ f.zone="complet"; } else { toast("Choisis l'appartement, ou un autre endroit (corridor, extérieur…)."); return null; } }
  if(!f.urgence){ toast("Indique si c'était une urgence."); return null; }
  if(!f.stock){ toast("Indique si tu as pris des matériaux en stock."); return null; }
  return {ticketId:f.ticketId||null, lieuType:"immeuble", immeuble:f.immeuble, zone:f.zone, logement:f.zone==="logement"?String(f.logement).trim():"",
    description:f.desc.trim(), urgence:f.urgence==="oui", outils:[...f.outils],
    materiauxStock: f.stock==="oui" ? f.mats.filter(m=>m.article).map(m=>({article:m.article, quantite:String(m.quantite||"").trim()})) : []};
}
function bindTemps(){
  const f=S.tForm;
  const on=(sel,ev,fn)=>{ const el=$(sel); if(el) el.addEventListener(ev,fn); };
  const all=(sel,fn)=>document.querySelectorAll(sel).forEach(fn);
  all("[data-ttype]",b=>b.addEventListener("click",()=>{ const t=b.dataset.ttype; if(t!==f.type){ if(t==="gestion") f.activite=GESTION[0]; else if(t==="bureau") f.activite=BUREAU[0]; } f.type=t; render(); }));
  all("[data-urg]",b=>b.addEventListener("click",()=>{ f.urgence=b.dataset.urg; render(); }));
  all("[data-stock]",b=>b.addEventListener("click",()=>{ f.stock=b.dataset.stock; render(); }));
  all("[data-outil]",c=>c.addEventListener("change",()=>{ const v=c.dataset.outil; f.outils = c.checked ? [...new Set([...f.outils,v])] : f.outils.filter(o=>o!==v); }));
  all("[data-matq]",b=>b.addEventListener("click",()=>{ f.mats.push({article:b.dataset.matq, quantite:""}); render(); }));
  all("[data-matqte]",i=>i.addEventListener("input",()=>{ f.mats[+i.dataset.matqte].quantite=i.value; }));
  all("[data-matdel]",b=>b.addEventListener("click",()=>{ f.mats.splice(+b.dataset.matdel,1); render(); }));
  on("#t-outil","input",e=>{ f.outilAutre=e.target.value; });
  on("#t-outil-add","click",()=>{ const v=f.outilAutre.trim(); if(!v) return; f.outils=[...new Set([...f.outils,v])]; f.outilAutre=""; render(); });
  on("#t-mat","input",e=>{ f.matArt=e.target.value; });
  on("#t-matq","input",e=>{ f.matQte=e.target.value; });
  on("#t-mat-add","click",()=>{ const v=f.matArt.trim(); if(!v) return; f.mats.push({article:v, quantite:f.matQte.trim()}); f.matArt=""; f.matQte=""; render(); });
  on("#t-desc","input",e=>{ f.desc=e.target.value; });
  on("#t-ticket","change",e=>{
    f.ticketId=e.target.value||null;
    const t=S.tickets.find(x=>x.id===f.ticketId);
    if(t){ f.type="immeuble"; f.immeuble=t.immeuble||""; const z=ZONES.find(z=>z.k===t.unite);
      if(z && z.k!=="logement"){ f.zone=z.k; f.logement=""; } else { f.zone="logement"; f.logement=t.unite||""; }
      if(!f.urgence && t.statut==="priorite") f.urgence="oui"; }
    render();
  });
  on("#t-imm","change",e=>{ f.immeuble=e.target.value; f.logement=""; render(); });
  on("#t-zone","change",e=>{ f.zone=e.target.value; render(); });
  on("#t-log","input",e=>{ f.logement=e.target.value; });
  on("#t-log","change",e=>{ f.logement=e.target.value; });
  on("#t-act","change",e=>{ const was=f.activite; f.activite=e.target.value; if((was===AUTRE)!==(f.activite===AUTRE)){ render(); const a=$("#t-act-autre"); if(a) a.focus(); } });
  on("#t-act-autre","input",e=>{ f.activiteAutre=e.target.value; });
  const upDur=()=>{ const p=plage({...f,date:f.date||todayISO()}); const el=$("#t-dur"); if(el) el.textContent=p.err?"—":fmtH(p.minutes)+(p.lend?" (fin le lendemain)":""); };
  on("#t-deb","input",e=>{ f.deb=e.target.value; upDur(); });
  on("#t-fin","input",e=>{ f.fin=e.target.value; upDur(); });
  on("#t-date","change",e=>{ f.date=e.target.value; upDur(); });
  on("#t-discard","click",()=>{ S.tDiscard=true; render(); });
  on("#t-discard-no","click",()=>{ S.tDiscard=false; render(); });
  on("#t-discard2","click",async()=>{
    const e=S.temps.find(x=>x.enCours && x.par===S.me) || S.temps.filter(x=>!x.enCours && x.aRemplir && x.par===S.me).sort((a,b)=>(a.creeLe||"").localeCompare(b.creeLe||""))[0];
    S.tDiscard=false; if(!e){ render(); return; }
    const snap = e.enCours ? {...e, fin:new Date().toISOString(), minutes:Math.max(1,Math.round((Date.now()-Date.parse(e.debut))/60000))} : e;
    try{ await logRevision(snap, null, "chrono annulé"); await S.db.collection("temps").doc(e.id).delete(); resetTForm(); toast("Temps annulé, rien n'a été enregistré"); render(); }
    catch(err){ handleWriteErr(err); }
  });
  on("#t-manuel","click",()=>{ resetTForm(); f.manuel=true; render(); });
  on("#t-cancel-man","click",()=>{ resetTForm(); render(); });
  const col=()=>S.db.collection("temps");
  on("#t-start","click",async()=>{
    if(!S.db) return;
    try{ await col().add({date:todayISO(), debut:new Date().toISOString(), enCours:true, minutes:0, par:S.me||null, creeLe:new Date().toISOString(), facture:false}); resetTForm(); toast("Chrono démarré"); }
    catch(e){ handleWriteErr(e); }
  });
  on("#t-stop","click",async()=>{
    const run=S.temps.find(e=>e.enCours && e.par===S.me); if(!run) return;
    const min=Math.max(1,Math.round((Date.now()-Date.parse(run.debut))/60000));
    try{ await col().doc(run.id).update({enCours:false, aRemplir:true, minutes:min, fin:new Date().toISOString()}); toast(`${fmtH(min)} · dis-nous ce que tu as fait`); }
    catch(e){ handleWriteErr(e); }
  });
  on("#t-save","click",async()=>{
    const p=tPayload(); if(!p||!S.db) return;
    const pending=S.temps.filter(e=>!e.enCours && e.aRemplir && e.par===S.me).sort((a,b)=>(a.creeLe||"").localeCompare(b.creeLe||""))[0];
    let savedId=null;
    try{
      if(f.editId){
        const old=S.temps.find(x=>x.id===f.editId); if(!old){ toast("Cette entrée n'existe plus."); resetTForm(); render(); return; }
        const memes = f.deb===hhmm(old.debut) && f.fin===hhmm(old.fin) && (f.date||old.date)===old.date;
        const pl = memes && old.debut && old.fin ? {debut:old.debut, fin:old.fin, minutes:old.minutes} : plage({...f,date:f.date||old.date}); if(pl.err){ toast(pl.err); return; }
        const upd={...p, minutes:pl.minutes, debut:pl.debut, fin:pl.fin, date:f.date||old.date, modifieLe:new Date().toISOString(), nbRevisions:(+old.nbRevisions||0)+1};
        if(p.lieuType!=="immeuble"){ upd.immeuble=""; upd.zone=""; upd.logement=""; } else { upd.activite=""; }
        if(JSON.stringify(snapEntry(old))===JSON.stringify(snapEntry({...old,...upd})) && (old.ticketId||null)===(upd.ticketId||null)){ resetTForm(); toast("Aucun changement"); render(); return; }
        await col().doc(old.id).update(upd); savedId=old.id;
        await logRevision(old, {...old,...upd}, "modification");
      }
      else if(pending && !f.manuel){
        const ajuste = hhmm(pending.debut)!==f.deb || hhmm(pending.fin)!==f.fin || (f.date||pending.date)!==pending.date;
        const pl = ajuste ? plage({...f,date:f.date||pending.date}) : {debut:pending.debut, fin:pending.fin, minutes:Math.max(1,+pending.minutes||1)}; if(pl.err){ toast(pl.err); return; }
        savedId=pending.id; await col().doc(pending.id).update({...p, aRemplir:false, debut:pl.debut, fin:pl.fin, minutes:pl.minutes, date:f.date||pending.date,
          ...(ajuste ? {chronoOriginal:{debut:pending.debut, fin:pending.fin, minutes:pending.minutes}} : {})});
      }
      else {
        const pl=plage({...f,date:f.date||todayISO()}); if(pl.err){ toast(pl.err); return; }
        savedId=(await col().add({...p, date:f.date||todayISO(), debut:pl.debut, fin:pl.fin, enCours:false, aRemplir:false, minutes:pl.minutes, par:S.me||null, creeLe:new Date().toISOString(), facture:false})).id;
      }
      resetTForm(); toast("Feuille de temps enregistrée"); if(p.urgence && savedId){ await ouvrirUrgenceDepuisTemps(savedId, p); return; } render();
    } catch(e){ handleWriteErr(e); }
  });
  all("[data-tdel]",b=>b.addEventListener("click",()=>{ S.tConfirm=b.dataset.tdel; render(); }));
  all("[data-tdel2]",b=>b.addEventListener("click",async()=>{ const old=S.temps.find(x=>x.id===b.dataset.tdel2); try{ if(old) await logRevision(old,null,"suppression"); await col().doc(b.dataset.tdel2).delete(); S.tConfirm=null; toast("Temps retiré"); }catch(e){ handleWriteErr(e); } }));
  all("[data-twho]",b=>b.addEventListener("click",()=>{ S.tWho=b.dataset.twho; render(); }));
  all("[data-showrev]",b=>b.addEventListener("click",()=>{ S.showRev = S.showRev===b.dataset.showrev ? null : b.dataset.showrev; render(); }));
  all("[data-tedit]",b=>b.addEventListener("click",()=>{
    const e=S.temps.find(x=>x.id===b.dataset.tedit); if(!e) return;
    resetTForm();
    Object.assign(f,{editId:e.id, ticketId:e.ticketId||null, manuel:true, type:e.lieuType==="bureau"||e.lieuType==="gestion"?e.lieuType:"immeuble", immeuble:e.immeuble||"", zone:e.zone||"logement", logement:e.logement||"", activite:e.lieuType==="gestion"&&e.activite&&!GESTION.includes(e.activite)?AUTRE:(e.activite||BUREAU[0]), activiteAutre:e.lieuType==="gestion"&&e.activite&&!GESTION.includes(e.activite)?e.activite:"",
      desc:e.description||"", urgence:e.urgence===true?"oui":e.urgence===false?"non":"", outils:[...(e.outils||[])], stock:(e.materiauxStock||[]).length?"oui":"non", mats:(e.materiauxStock||[]).map(m=>({...m})), min:String(e.minutes||""), date:e.date||"", deb:hhmm(e.debut), fin:hhmm(e.fin)});
    render(); window.scrollTo({top:0,behavior:"smooth"});
  }));
}

const norm = x => String(x||"").normalize("NFD").replace(/[\u0300-\u036f]/g,"").toLowerCase();
/* Adresses : « 1234 rue de la Montagne, Magog » s'affiche « Montagne 1234, Magog » (type de voie et article retirés) */
const ADR_TYPE = /^(rue|av\.?|avenue|chem\.?|chemin|boul\.?|bd\.?|boulevard|place|pl\.?|mont[ée]e|rang|route|rte\.?|croissant|cr\.?|impasse|promenade|prom\.?|terrasse|all[ée]e|c[ôo]te|carr[ée]|square|parc|circle|cercle|street|st\.?)\s+/i;
const ADR_ART = /^(de la\s+|de l['’]\s*|des\s+|du\s+|de\s+|d['’]\s*|la\s+|le\s+|les\s+|l['’]\s*)/i;
function adrParts(adr){
  let s = String(adr||"").trim().replace(/^(\d+[A-Za-z]?(?:\s*[-–\/]\s*\d+[A-Za-z]?)*)\s*,\s*/,"$1 ");
  const i = s.indexOf(","), first = (i<0?s:s.slice(0,i)).trim(), rest = i<0?"":s.slice(i+1).trim();
  const m = first.match(/^(\d+[A-Za-z]?(?:\s*[-–\/]\s*\d+[A-Za-z]?)*)[\s,]+(.+)$/);
  const num = m ? m[1].replace(/\s+/g,"") : "", reste = m ? m[2] : first;
  const rue = reste.replace(ADR_TYPE,"").replace(ADR_ART,"").trim() || reste;
  return {num, rue: rue.charAt(0).toUpperCase()+rue.slice(1), rest};
}
const adrAff = adr => { if(!adr) return adr; const p=adrParts(adr); if(!p.num) return String(adr); return `${p.rue} ${p.num}${p.rest?`, ${p.rest}`:""}`; };
const streetKey = adr => norm(adrParts(adr).rue);
const adrCmp = (a,b) => streetKey(a).localeCompare(streetKey(b),"fr",{numeric:true}) || String(adrParts(a).num).localeCompare(String(adrParts(b).num),"fr",{numeric:true}) || String(a||"").localeCompare(String(b||""),"fr",{numeric:true});
const immSorted = () => [...(S.config.immeubles||[])].sort((a,b)=>adrCmp(a.adresse,b.adresse));
/* ---------- Résumé des heures ---------- */
function paques(y){ const a=y%19,b=Math.floor(y/100),c=y%100,d=Math.floor(b/4),e=b%4,f=Math.floor((b+8)/25),g=Math.floor((b-f+1)/3),h=(19*a+b-d-g+15)%30,i=Math.floor(c/4),k=c%4,l=(32+2*e+2*i-h-k)%7,m=Math.floor((a+11*h+22*l)/451),mo=Math.floor((h+l-7*m+114)/31),da=((h+l-7*m+114)%31)+1; return new Date(y,mo-1,da); }
const isoLocal = d => `${d.getFullYear()}-${String(d.getMonth()+1).padStart(2,"0")}-${String(d.getDate()).padStart(2,"0")}`;
const _fer={};
function feries(y){ // jours fériés du Québec
  if(_fer[y]) return _fer[y];
  const nthMon=(mo,n)=>{ const d=new Date(y,mo,1); while(d.getDay()!==1) d.setDate(d.getDate()+1); d.setDate(d.getDate()+7*(n-1)); return d; };
  const p=paques(y), vs=new Date(p); vs.setDate(p.getDate()-2);
  const patriotes=new Date(y,4,24); while(patriotes.getDay()!==1) patriotes.setDate(patriotes.getDate()-1);
  const list=[[new Date(y,0,1),"Jour de l'An"],[vs,"Vendredi saint"],[patriotes,"Journée nationale des patriotes"],[new Date(y,5,24),"Fête nationale"],[new Date(y,6,1),"Fête du Canada"],[nthMon(8,1),"Fête du Travail"],[nthMon(9,2),"Action de grâce"],[new Date(y,11,25),"Noël"]];
  return _fer[y]=Object.fromEntries(list.map(([d,n])=>[isoLocal(d),n]));
}
const ferie = d => feries(d.getFullYear())[isoLocal(d)] || null;
/* minutes hors des heures de bureau (avant 7 h, après 17 h, fin de semaine, jours fériés) */
function horsMinutes(debutISO, finISO, dateISO, minutes){
  if(!debutISO || !finISO){ const d=new Date((dateISO||todayISO())+"T12:00:00"); return (d.getDay()%6===0 || ferie(d)) ? (+minutes||0) : 0; }
  let a=new Date(debutISO), b=new Date(finISO), out=0;
  while(a<b){
    const dayEnd=new Date(a); dayEnd.setHours(24,0,0,0);
    const segEnd = b<dayEnd ? b : dayEnd;
    const off = a.getDay()%6===0 || ferie(a);
    if(off) out += (segEnd-a)/60000;
    else {
      const o=new Date(a); o.setHours(7,0,0,0); const c=new Date(a); c.setHours(17,0,0,0);
      const ov=(x1,x2,y1,y2)=>Math.max(0,(Math.min(x2,y2)-Math.max(x1,y1))/60000);
      out += ov(a,segEnd,new Date(a).setHours(0,0,0,0),o) + ov(a,segEnd,c,dayEnd);
    }
    a=segEnd;
  }
  return Math.round(out);
}
function horsRaison(e){
  const d = e.debut ? new Date(e.debut) : new Date((e.date||todayISO())+"T12:00:00");
  const f = ferie(d); if(f) return f;
  if(d.getDay()===0) return "Dimanche"; if(d.getDay()===6) return "Samedi";
  if(e.debut && new Date(e.debut).getHours()<7) return "Avant 7 h";
  return "Après 17 h";
}
const flags = e => { const h=horsMinutes(e.debut,e.fin,e.date,e.minutes); return {urg:e.urgence===true, hors:h}; };
function flagBadges(e){
  const {urg,hors}=flags(e);
  return (urg?` <span class="flag flag-urg">URGENCE</span>`:"") + (hors?` <span class="flag flag-hors" title="Hors des heures de bureau">${esc(horsRaison(e))} · ${fmtH(hors)}</span>`:"");
}
const stockTxt = arr => (arr||[]).map(m=>m.quantite?`${m.quantite} × ${m.article}`:m.article).join(", ");
const qteNum = q => { const n=parseFloat(String(q||"").replace(",",".")); return isNaN(n)?1:n; };
function stockLignes(du, au, qui){
  return S.temps.filter(e=>!e.enCours && !e.aRemplir && (e.date||"")>=du && (e.date||"")<=au && (!qui || e.par===qui) && (e.materiauxStock||[]).length)
    .flatMap(e=>e.materiauxStock.map(m=>({article:m.article, quantite:m.quantite||"", date:e.date, immeuble:e.lieuType==="immeuble"?e.immeuble:"Bureau", lieu:lieuLabel(e), par:e.par, ticketId:e.ticketId||null})))
    .sort((a,b)=>(a.date||"").localeCompare(b.date||""));
}
function stockSection(R){
  const ls=stockLignes(R.du,R.au,R.qui); if(!ls.length) return `<div class="sec"><h3>Matériaux pris en stock</h3><p class="muted small">Aucun matériau pris en stock dans cette période.</p></div>`;
  const tot={}; ls.forEach(l=>{ const k=l.article; (tot[k] ||= {q:0,n:0}); tot[k].q+=qteNum(l.quantite); tot[k].n++; });
  const parImm={}; ls.forEach(l=>(parImm[l.immeuble] ||= []).push(l));
  return `<div class="sec"><h3>Matériaux pris en stock <button class="btn" id="r-stock-csv" style="min-height:36px">CSV inventaire</button></h3>
    <div class="tbl-wrap panel" style="padding:0;margin-bottom:10px"><table><thead><tr><th>Article</th><th class="n">Quantité</th><th class="n">Nb de fois</th></tr></thead><tbody>
    ${Object.entries(tot).sort((a,b)=>a[0].localeCompare(b[0],"fr")).map(([a,v])=>`<tr><td>${esc(a)}</td><td class="n num">${String(Math.round(v.q*100)/100).replace(".",",")}</td><td class="n num">${v.n}</td></tr>`).join("")}
    </tbody></table></div>
    <div class="lines">${Object.entries(parImm).sort((a,b)=>adrCmp(a[0],b[0])).map(([imm,arr])=>`<div class="line line-e"><span class="l"><b>${esc(adrAff(imm))}</b>${arr.map(l=>`<span class="e-desc small">${fmtDate(l.date)} · ${esc(l.quantite?`${l.quantite} × ${l.article}`:l.article)} <span class="muted">(${esc(l.lieu.replace(adrAff(imm)+" · ",""))}${S.names[l.par]?` · ${esc(S.names[l.par])}`:""})</span></span>`).join("")}</span></div>`).join("")}</div>
    <p class="muted small">Quantité : les quantités non chiffrées comptent pour 1.</p></div>`;
}
function resumeEntries(){
  // feuille de temps + heures notées directement sur les billets
  const a = S.temps.filter(e=>!e.enCours && !e.aRemplir && voitEntree(e)).map(e=>({...e, src:"temps"}));
  const b = [];
  S.tickets.forEach(t=>(t.heures||[]).forEach(h=>b.push({id:h.id, src:"billet", ticketId:t.id, date:h.date, minutes:+h.minutes||0, par:h.par, lieuType:"immeuble", immeuble:t.immeuble, zone:ZONES.find(z=>z.k===t.unite)?t.unite:"logement", logement:ZONES.find(z=>z.k===t.unite)?"":t.unite, description:(h.note&&h.note!=="Chrono"?h.note+" — ":"")+firstLine(t.description), urgence:t.statut==="priorite"})));
  return [...a,...b];
}
function rangePreset(k){
  const now=new Date(); const d0=new Date(now); d0.setHours(0,0,0,0);
  const mon=new Date(d0); mon.setDate(d0.getDate()-((d0.getDay()+6)%7));
  if(k==="semaine") return [isoLocal(mon), isoLocal(d0)];
  if(k==="semprec"){ const a=new Date(mon); a.setDate(mon.getDate()-7); const b=new Date(mon); b.setDate(mon.getDate()-1); return [isoLocal(a),isoLocal(b)]; }
  if(k==="2sem"){ const a=new Date(mon); a.setDate(mon.getDate()-7); return [isoLocal(a), isoLocal(d0)]; }
  if(k==="mois") return [isoLocal(new Date(now.getFullYear(),now.getMonth(),1)), isoLocal(d0)];
  if(k==="moisprec") return [isoLocal(new Date(now.getFullYear(),now.getMonth()-1,1)), isoLocal(new Date(now.getFullYear(),now.getMonth(),0))];
  return [isoLocal(mon), isoLocal(d0)];
}
function viewResume(){
  const R=S.res; if(!R.du){ [R.du,R.au]=rangePreset("semaine"); }
  const people=[...new Set(resumeEntries().map(e=>e.par).filter(Boolean))];
  const who = S.canAdmin ? R.qui : S.me;
  const list = resumeEntries().filter(e=>(e.date||"")>=R.du && (e.date||"")<=R.au && (!who || e.par===who))
    .sort((a,b)=>(a.date||"").localeCompare(b.date||"") || (a.debut||"").localeCompare(b.debut||""));
  const sum=f=>list.filter(f).reduce((a,e)=>a+(+e.minutes||0),0);
  const tot=sum(()=>true), imm=sum(e=>e.lieuType==="immeuble"), bur=sum(e=>e.lieuType==="bureau"||e.lieuType==="gestion"), urg=sum(e=>e.urgence===true);
  const hors=list.reduce((a,e)=>a+flags(e).hors,0);
  const days={}; list.forEach(e=>{ const d=days[e.date] ||= {min:0,hors:0,urg:0,n:0}; d.min+=+e.minutes||0; d.hors+=flags(e).hors; d.urg+=e.urgence===true?(+e.minutes||0):0; d.n++; });
  const byImm={}; list.filter(e=>e.lieuType==="immeuble").forEach(e=>{ byImm[e.immeuble]=(byImm[e.immeuble]||0)+(+e.minutes||0); });
  const preset=(k,l)=>`<button class="chip" data-preset="${k}">${l}</button>`;
  const h2=m=>(m/60).toFixed(2).replace(".",",")+" h";
  return `<div class="view-head"><div><h2>Résumé des heures</h2><p>Choisis une période pour voir le temps travaillé. En rouge : les urgences. En violet : le travail hors des heures de bureau (avant 7 h, après 17 h, fin de semaine et jours fériés).</p></div>${list.length?`<button class="btn" id="r-csv">Télécharger en CSV</button>`:""}</div>
  <div class="panel" style="margin-bottom:14px">
    <div class="plage">
      <div class="field"><label for="r-du">Du</label><input id="r-du" type="date" value="${esc(R.du)}"></div>
      <span class="plage-sep" aria-hidden="true">–</span>
      <div class="field"><label for="r-au">Au</label><input id="r-au" type="date" value="${esc(R.au)}"></div>
      ${S.canAdmin?`<div class="field" style="flex:1 1 180px"><label for="r-qui">Employé</label><select id="r-qui"><option value="">Tout le monde</option>${people.map(p=>`<option value="${esc(p)}" ${p===R.qui?"selected":""}>${esc(S.names[p]||"…")}</option>`).join("")}</select></div>`:""}
    </div>
    <div class="chips" style="margin-top:10px">${preset("semaine","Cette semaine")}${preset("semprec","Semaine dernière")}${preset("2sem","2 dernières semaines")}${preset("mois","Ce mois")}${preset("moisprec","Mois dernier")}</div>
  </div>
  <div class="stats">
    <div class="stat"><b class="num">${h2(tot)}</b><span>Total</span></div>
    <div class="stat"><b class="num">${h2(imm)}</b><span>Sur les immeubles</span></div>
    <div class="stat"><b class="num">${h2(bur)}</b><span>${isGest()?"Bureau / gestion":"Au bureau"}</span></div>
    <div class="stat stat-urg"><b class="num">${h2(urg)}</b><span>Urgences</span></div>
    <div class="stat stat-hors"><b class="num">${h2(hors)}</b><span>Hors heures</span></div>
  </div>
  ${S.canAdmin&&(S.config.tauxPaie||S.config.tauxHoraire)?`<p class="small muted" style="margin-top:-6px">${S.config.tauxPaie?(paieOk(R.qui)?`Paie : <b class="num">${money.format(tot/60*S.config.tauxPaie)}</b> (${money.format(S.config.tauxPaie)}/h)`:`Choisis l'employé de maintenance pour voir sa paie`):""}${S.config.tauxHoraire?` · Facturable sur les immeubles : <b class="num">${money.format(imm/60*S.config.tauxHoraire)}</b>`:""} <span>· visible par l'administration seulement</span></p>`:""}
  ${list.length?`
  <div class="sec"><h3>Par jour</h3><div class="tbl-wrap panel" style="padding:0"><table><thead><tr><th>Jour</th><th class="n">Heures</th><th class="n">Urgences</th><th class="n">Hors heures</th></tr></thead><tbody>
    ${Object.entries(days).map(([d,v])=>{ const dd=new Date(d+"T12:00:00"); const off=dd.getDay()%6===0||ferie(dd); return `<tr class="${off?"row-hors":""}"><td>${dd.toLocaleDateString("fr-CA",{weekday:"short",day:"numeric",month:"short"})}${ferie(dd)?` <span class="flag flag-hors">${esc(ferie(dd))}</span>`:""}</td><td class="n num">${fmtH(v.min)}</td><td class="n num">${v.urg?`<span class="txt-urg">${fmtH(v.urg)}</span>`:"—"}</td><td class="n num">${v.hors?`<span class="txt-hors">${fmtH(v.hors)}</span>`:"—"}</td></tr>`; }).join("")}
    <tr><td><b>Total</b></td><td class="n num"><b>${fmtH(tot)}</b></td><td class="n num"><b>${urg?fmtH(urg):"—"}</b></td><td class="n num"><b>${hors?fmtH(hors):"—"}</b></td></tr>
  </tbody></table></div></div>
  ${Object.keys(byImm).length?`<div class="sec"><h3>Par immeuble</h3><div class="lines">${Object.entries(byImm).sort((a,b)=>adrCmp(a[0],b[0])).map(([i,m])=>`<div class="line"><span class="l">${esc(adrAff(i))}</span><span class="r num">${fmtH(m)}</span></div>`).join("")}</div></div>`:""}
  ${S.canAdmin?stockSection(R):""}
  <div class="sec"><h3>Détail des entrées</h3><div class="lines">${list.map(e=>{ const fl=flags(e); return `<div class="line line-e ${fl.urg?"line-urg":fl.hors?"line-hors":""}"><span class="l"><span class="muted small">${fmtDate(e.date)}${e.debut&&e.fin?` · ${fmtHeure(e.debut)} – ${fmtHeure(e.fin)}`:""}${S.canAdmin&&!R.qui&&e.par?` · ${esc(S.names[e.par]||"…")}`:""}</span><br><b>${esc(lieuLabel(e))}</b>${e.description?`<span class="e-desc">${esc(e.description)}</span>`:""}${flagBadges(e)}</span><span class="r num"><b>${fmtH(+e.minutes||0)}</b></span></div>`; }).join("")}</div></div>
  `:`<div class="empty"><h3>Aucune heure dans cette période</h3><p>Choisis d'autres dates.</p></div>`}`;
}
function bindResume(){
  const R=S.res;
  const on=(sel,ev,fn)=>{ const el=$(sel); if(el) el.addEventListener(ev,fn); };
  on("#r-du","change",e=>{ R.du=e.target.value; if(R.au && R.du>R.au) R.au=R.du; render(); });
  on("#r-au","change",e=>{ R.au=e.target.value; if(R.du && R.au<R.du) R.du=R.au; render(); });
  on("#r-qui","change",e=>{ R.qui=e.target.value; render(); });
  document.querySelectorAll("[data-preset]").forEach(b=>b.addEventListener("click",()=>{ [R.du,R.au]=rangePreset(b.dataset.preset); render(); }));
  on("#r-stock-csv","click",async()=>{
    const rows=[["Date","Immeuble","Endroit","Article","Quantité","Employé"]];
    stockLignes(R.du,R.au,R.qui).forEach(l=>rows.push([l.date,adrAff(l.immeuble),l.lieu,l.article,l.quantite,S.names[l.par]||""]));
    const csv="\ufeff"+rows.map(r=>r.map(v=>`"${String(v??"").replace(/"/g,'""')}"`).join(",")).join("\r\n");
    if(!S.downloads){ toast("Le téléchargement n'est pas offert dans cette vue."); return; }
    try{ await S.downloads.save({filename:`inventaire-utilise-${R.du}-au-${R.au}.csv`, data:csv}); }catch(e){ if(!(e&&e.code==="declined")) toast("Le téléchargement n'a pas fonctionné."); }
  });
  on("#r-csv","click",async()=>{
    const who = S.canAdmin ? R.qui : S.me;
    const list = resumeEntries().filter(e=>(e.date||"")>=R.du && (e.date||"")<=R.au && (!who || e.par===who)).sort((a,b)=>(a.date||"").localeCompare(b.date||""));
    const rows=[["Date","Début","Fin","Employé","Lieu","Description","Heures","Urgence","Heures hors bureau","Raison hors heures"]];
    list.forEach(e=>{ const fl=flags(e); rows.push([e.date,fmtHeure(e.debut),fmtHeure(e.fin),S.names[e.par]||"",lieuLabel(e),e.description||"",((+e.minutes||0)/60).toFixed(2),fl.urg?"Oui":"Non",(fl.hors/60).toFixed(2),fl.hors?horsRaison(e):""]); });
    const csv="﻿"+rows.map(r=>r.map(v=>`"${String(v??"").replace(/"/g,'""').replace(/\n/g," ")}"`).join(",")).join("\r\n");
    if(!S.downloads){ toast("Le téléchargement n'est pas offert dans cette vue."); return; }
    try{ await S.downloads.save({filename:`heures-${R.du}-au-${R.au}.csv`, data:csv}); }catch(e){ if(!(e&&e.code==="declined")) toast("Le téléchargement n'a pas fonctionné."); }
  });
}

function immOptions(sel, q){
  const all = immSorted().map(i=>i.adresse), nq = norm(q||"").trim();
  const list = nq ? all.filter(a=>(norm(a).includes(nq) || norm(adrAff(a)).includes(nq)) || a===sel) : all;
  return `<option value="">${nq ? (list.length?`${list.length} résultat${list.length>1?"s":""}…`:"Aucun immeuble trouvé") : "Choisir un immeuble…"}</option>` + list.map(a=>`<option value="${esc(a)}" ${a===sel?"selected":""}>${esc(adrAff(a))}</option>`).join("") + (sel && !all.includes(sel)?`<option value="${esc(sel)}" selected>${esc(adrAff(sel))}</option>`:"");
}
function immPicker(id, sel){
  return `<input type="search" class="immq" id="${id}-q" data-for="${id}" value="${esc(S.immQ[id]||"")}" placeholder="🔍 Rechercher : nom de rue ou numéro" autocomplete="off"><select id="${id}">${immOptions(sel, S.immQ[id])}</select>`;
}
function bindImmSearch(){
  document.querySelectorAll(".immq").forEach(inp=>inp.addEventListener("input",()=>{
    const id=inp.dataset.for, sel=document.getElementById(id); S.immQ[id]=inp.value;
    sel.innerHTML = immOptions(sel.value, inp.value);
    const opts=[...sel.options].filter(o=>o.value);
    if(opts.length===1 && sel.value!==opts[0].value){ sel.value=opts[0].value; sel.dispatchEvent(new Event("change")); }
  }));
}
function viewNouveau(){
  return `<div class="view-head"><div><h2>Nouveau billet</h2><p>Pour une demande créée directement dans l'application. Elle est inscrite au nom de la personne connectée.</p></div></div>
  <div class="banner small">Formulaire des locataires : <span style="user-select:all">forms.monday.com/forms/74e3c2f4d06b7485be89d034b1533554</span> · <a href="https://forms.monday.com/forms/74e3c2f4d06b7485be89d034b1533554?r=use1" target="_blank" rel="noopener">Ouvrir</a></div>
  <form class="grid panel" id="f-new">
    <div class="field"><label for="n-imm">Immeuble</label>${immPicker("n-imm","")}</div>
    <div class="field"><label for="n-unite">Logement ou endroit</label><select id="n-unite"><option value="">Choisis d'abord l'immeuble</option></select></div>
    <div class="field full"><label>Demandé par</label><div class="small" style="padding:6px 0"><b id="n-dem-nom">${esc(S.myName||"Ton compte")}</b> <span class="muted">(la personne connectée)</span></div></div>
    <div class="field full"><label for="n-titre">Courte description</label><input id="n-titre" required placeholder="ex. Robinet de cuisine qui coule"></div>
    <div class="field full"><label for="n-desc">Description détaillée</label><textarea id="n-desc" placeholder="Ce que le locataire a écrit dans le formulaire, ou ce que tu as constaté"></textarea></div>
    <div class="field full" id="n-hint" aria-live="polite"></div>
    ${peutRepartir()?`<div class="field full"><label>Envoyer à</label><div class="opts">${EQUIPE.map(p=>`<label class="opt"><input type="checkbox" data-nrep="${p.k}"> ${esc(p.l)}</label>`).join("")}</div></div>`:""}
    <div class="field"><label for="n-statut">Catégorie</label><select id="n-statut">${STATUTS.filter(s=>!FERMES.includes(s.k)).map(s=>`<option value="${s.k}" ${s.k==="a_traiter"?"selected":""}>${s.l}</option>`).join("")}</select></div>
    <div class="field"><label for="n-date">Date prévue</label><input id="n-date" type="date"></div>
    <div class="field"><label for="n-fact">Facturable au propriétaire</label><select id="n-fact"><option value="1">Oui</option><option value="0">Non</option></select></div>
    <div class="field"><label for="n-auth">Autorisation d'entrer</label><select id="n-auth"><option value="oui">Oui</option><option value="non">Non, prendre rendez-vous</option><option value="">Inconnue</option></select></div>
    <div class="field"><label for="n-acces">Accès / consignes</label><input id="n-acces" placeholder="ex. Boîte à clé, chien dans le logement"></div>
    ${S.assets?`<div class="field full"><label for="n-photos">Photos de la demande (optionnel)</label><input id="n-photos" type="file" accept="image/*" multiple></div>`:""}
    <div class="field full btns"><button class="btn primary big" type="submit" ${S.db&&!S.readOnly?"":"disabled"}>Créer le billet</button><a class="btn big" href="#billets">Annuler</a></div>
  </form>`;
}

/* Lignes à facturer : billets terminés + temps entré directement sur un immeuble */
function factGroups(){
  const g = {}, taux = +S.config.tauxHoraire || 0;
  S.tickets.filter(t=>t.statut==="ferme_facturer").forEach(t=>{
    const c=costOf(t);
    const stk=stockTxt(linkedTemps(t).flatMap(e=>e.materiauxStock||[]));
    (g[t.immeuble||"Sans adresse"] ||= []).push({kind:"t", id:t.id, date:t.termineLe, label:(t.unite?`${uniteLabel(t.unite)} · `:"")+firstLine(t.description)+(stk?` (pris en stock : ${stk})`:""), code:code(t), cat:t.categorie||"", unite:t.unite||"", ...c});
  });
  S.temps.filter(e=>e.lieuType==="immeuble" && !e.enCours && !e.aRemplir && !e.facture && !(e.ticketId && S.tickets.some(t=>t.id===e.ticketId)) && e.facturable!==false && e.immeuble).forEach(e=>{
    const h=(+e.minutes||0)/60, hFact=hArr(h), mo=hFact*taux;
    (g[e.immeuble] ||= []).push({kind:"e", id:e.id, date:e.date, label:`${e.urgence?"URGENCE · ":""}Temps · ${zoneLabel(e)}${e.description?` — ${e.description}`:""}${(e.outils||[]).length?` (outils : ${e.outils.join(", ")})`:""}${(e.materiauxStock||[]).length?` (pris en stock : ${stockTxt(e.materiauxStock)})`:""}`, code:"", cat:"Temps", unite:e.zone==="logement"?(e.logement||""):"", heures:h, hFact, mo, mat:0, majo:0, total:mo, cout:coutH(h)});
  });
  Object.values(g).forEach(arr=>arr.sort((a,b)=>(a.date||"").localeCompare(b.date||"")));
  return Object.entries(g).sort((a,b)=>adrCmp(a[0],b[0]));
}
function viewFacturation(){
  const groups = factGroups();
  const taux = S.config.tauxHoraire;
  const grand = groups.reduce((a,[,it])=>a+it.reduce((x,i)=>x+i.total,0),0);
  const recent = S.tickets.filter(t=>t.statut==="regle_ferme" && t.factureLe).sort((a,b)=>(b.factureLe||"").localeCompare(a.factureLe||"")).slice(0,8);
  return `<div class="view-head"><div><h2>Facturation</h2><p>Les billets terminés et le temps entré sur les immeubles, regroupés par immeuble, prêts à entrer dans QuickBooks.</p></div>
    <div class="btns">${groups.length?`<button class="btn" id="csv">Télécharger en CSV</button>`:""}</div></div>
  ${taux ? "" : `<div class="banner warn">Le taux horaire n'est pas encore défini, alors la main-d'œuvre est calculée à 0 $. ${S.canAdmin?"Entre-le plus bas, dans Réglages.":"Pénélope peut l'entrer dans Réglages."}</div>`}
  ${groups.length ? `<p class="muted small">Total à facturer : <b class="num">${money.format(grand)}</b> · ${groups.length} immeuble${groups.length>1?"s":""}${S.config.tauxPaie?` · coût de revient de la main-d'œuvre (temps exact) : <b class="num">${money.format(groups.reduce((a,[,it])=>a+it.reduce((x,i)=>x+i.cout,0),0))}</b>`:""}</p>
  <p class="muted small" style="margin-top:-4px">On facture à l'heure : chaque intervention est arrondie à l'heure supérieure (ex. 1 h 10 = 2 h). Le coût de revient garde le temps exact.</p>` + groups.map(([imm,items])=>{
      const tot = items.reduce((a,i)=>a+i.total,0);
      return `<section class="bill"><div class="bill-head"><h3>${esc(adrAff(imm))}</h3><div class="bill-total num">${money.format(tot)}</div></div>
      <div class="tbl-wrap"><table><thead><tr><th>Date</th><th>Travail</th><th class="n">Heures réelles</th><th class="n">Heures arrondies</th><th class="n">Main-d'œuvre</th><th class="n">Matériel</th><th class="n">Total</th></tr></thead><tbody>
      ${items.map(i=>`<tr ${i.kind==="t"?`data-open="${esc(i.id)}" style="cursor:pointer"`:""}><td class="num">${fmtDate(i.date)}</td><td>${esc(i.label)}</td><td class="n num">${i.heures.toFixed(2).replace(".",",")}</td><td class="n num"><b>${i.hFact}</b></td><td class="n num">${money.format(i.mo)}</td><td class="n num">${money.format(i.mat+i.majo)}</td><td class="n num"><b>${money.format(i.total)}</b></td></tr>`).join("")}
      </tbody></table></div>
      ${(()=>{ const hr=items.reduce((a,i)=>a+i.heures,0), hf=items.reduce((a,i)=>a+i.hFact,0), ct=items.reduce((a,i)=>a+i.cout,0), mo=items.reduce((a,i)=>a+i.mo,0);
        return `<p class="small muted" style="margin:0;padding:10px 14px 0">Temps réel : <b class="num">${hr.toFixed(2).replace(".",",")} h</b> · facturé : <b class="num">${hf} h</b>${S.config.tauxPaie?` · coût de revient (temps exact × ${money.format(S.config.tauxPaie)}/h) : <b class="num">${money.format(ct)}</b> · marge sur la main-d'œuvre : <b class="num">${money.format(mo-ct)}</b>`:` · entre le taux payé dans Réglages pour voir le coût de revient`}</p>`; })()}
      <div class="bill-foot"><button class="btn" data-copy="${esc(imm)}">Copier le résumé</button><input placeholder="No de facture QuickBooks (optionnel)" data-ref="${esc(imm)}"><button class="btn primary" data-billed="${esc(imm)}" ${S.readOnly?"disabled":""}>Marquer facturé</button></div></section>`;
    }).join("") : emptyBox("Rien à facturer pour le moment","Les billets « Fermé et à facturer » et le temps entré sur un immeuble apparaissent ici, regroupés par immeuble.")}
  ${recent.length?`<div class="sec"><h3>Facturés récemment</h3><div class="lines">${recent.map(t=>`<div class="line" data-open="${esc(t.id)}" style="cursor:pointer"><span class="l">${esc(adrAff(t.immeuble))} · ${esc(t.description)}</span><span class="r num">${fmtDate(t.factureLe)}${t.refFacture?` · ${esc(t.refFacture)}`:""}</span></div>`).join("")}</div></div>`:""}
  <div class="sec panel"><h3>Réglages</h3>
    <div class="fgrid">
      <div class="field"><label for="c-taux">Taux facturé pour Jean ($/h)</label><input id="c-taux" type="number" min="0" step="0.5" value="${taux??""}" ${S.canAdmin?"":"disabled"}></div>
      <div class="field"><label for="c-paie">Taux payé à Jean ($/h, paie)</label><input id="c-paie" type="number" min="0" step="0.5" value="${S.config.tauxPaie??""}" ${S.canAdmin?"":"disabled"}></div>
      <div class="field full"><label>Gestionnaires (voient les tâches de gestion)</label>${(()=>{ const ppl=Object.keys(S.names).filter(id=>id!==S.me && S.names[id]); return ppl.length?`<div class="opts">${ppl.map(id=>`<label class="opt"><input type="checkbox" data-gest="${esc(id)}" ${(S.config.gestionnaires||[]).includes(id)?"checked":""}> ${esc(S.names[id])}</label>`).join("")}</div><p class="muted small" style="margin:4px 0 0">Les personnes cochées voient le choix « Gestion » dans la feuille de temps et les heures de gestion. Les autres (ex. l'homme de maintenance) ne les voient pas.</p>`:`<p class="muted small">Les personnes apparaîtront ici après avoir ouvert l'application et entré du temps.</p>`; })()}</div>
      <div class="field full"><label for="c-appr">William : approbation (East Angus, Magog, rue Murray, rue Principale à Richmond) et alertes d'eau</label><select id="c-appr" ${S.canAdmin?"":"disabled"}><option value="">Choisir…</option>${Object.keys(S.names).filter(id=>id!==S.me&&S.names[id]).map(id=>`<option value="${esc(id)}" ${id===S.config.approbateur?"selected":""}>${esc(S.names[id])}</option>`).join("")}</select></div>
      <div class="field full"><label>Comptes de l'équipe (pour l'envoi des demandes)</label>
        <div class="fgrid">${EQUIPE.map(p=>{ const ppl=Object.keys(S.names).filter(id=>S.names[id]), cur=(S.config.comptes||{})[p.k]||""; return `<div class="field"><label for="c-cpt-${p.k}">${esc(p.l)}${p.note?` <span style="text-transform:none;letter-spacing:0">(${esc(p.note)})</span>`:""}</label><select id="c-cpt-${p.k}" data-cpt="${p.k}" ${S.canAdmin?"":"disabled"}><option value="">${p.k==="william"?"Comme l'approbateur":"Pas de compte"}</option>${ppl.map(id=>`<option value="${esc(id)}" ${id===cur?"selected":""}>${esc(S.names[id])}</option>`).join("")}${cur&&!ppl.includes(cur)?`<option value="${esc(cur)}" selected>Compte lié</option>`:""}</select></div>`; }).join("")}</div>
        <p class="muted small" style="margin:4px 0 0">Choisis le compte du portail de chaque personne pour que les demandes qui lui sont envoyées apparaissent dans ses « Mes travaux ». Une personne apparaît dans la liste après avoir ouvert l'application une fois.</p></div>
      <div class="field full"><label>Immeubles et logements</label><p class="muted small">La liste vient directement de la base de donnÃ©es (immeubles et logements de Supabase).</p></div>
    </div>
    ${S.canAdmin?`<div class="btns" style="margin-top:10px"><button class="btn primary" id="c-save">Enregistrer les réglages</button></div>`:`<p class="muted small">Seuls les éditeurs de l'application peuvent changer ces réglages.</p>`}
  </div>`;
}

/* ---------- feuille de détail ---------- */
function renderSheet(){
  const root = $("#sheet-root");
  const t = S.tickets.find(x=>x.id===S.openId);
  if (!t){ root.innerHTML=""; return; }
  const c = costOf(t), ro = S.readOnly;
  const nm = id => esc(S.names[id] || "");
  const running = t.chrono ? (Date.now()-Date.parse(t.chrono.debut))/60000 : 0;
  root.innerHTML = `<div class="sheet-back" data-close></div>
  <aside class="sheet" role="dialog" aria-modal="true" aria-label="Billet ${esc(code(t))}">
    <div class="sheet-head"><div><div class="muted small">${esc(code(t))} · créé ${fmtDate(t.creeLe)}${t.creePar&&nm(t.creePar)?` par ${nm(t.creePar)}`:""}</div><h2>${esc(adrAff(t.immeuble))}${t.unite?` · ${esc(uniteLabel(t.unite))}`:""}</h2><div style="margin-top:4px">${pill(t)}</div></div><button class="close" data-close aria-label="Fermer">×</button></div>

    <div class="panel"><div style="white-space:pre-wrap">${esc(t.description)}</div>
      <div class="meta muted small" style="display:flex;gap:12px;flex-wrap:wrap;margin-top:8px">${t.categorie?`<span>${esc(t.categorie)}</span>`:""}${t.demandeur?`<span>Demandé par ${esc(t.demandeur)}</span>`:""}${t.contact?`<span>${esc(t.contact)}</span>`:""}${t.datePrevue?`<span>Prévu ${fmtDate(t.datePrevue)}</span>`:""}</div>
      ${t.autorisation?`<div class="small" style="margin-top:6px"><b>Autorisation d'entrer :</b> ${t.autorisation==="oui"?"Oui":"Non, prendre rendez-vous"}</div>`:""}
      ${t.acces?`<div class="small" style="margin-top:4px"><b>Accès :</b> ${esc(t.acces)}</div>`:""}
    </div>

    <div class="sec"><h3>Envoyée à</h3>
      ${peutRepartir()?`<div class="chips">${EQUIPE.map(p=>`<button class="chip" data-rep="${p.k}" aria-pressed="${(t.repartiA||[]).includes(p.k)}">${esc(p.l)}</button>`).join("")}</div><p class="muted small" style="margin:6px 0 0">Touche un nom pour envoyer la demande (ou la retirer). Elle apparaît dans « Mes travaux » de la personne.</p>`
        :`<div class="tags">${repTags(t)||`<span class="muted small">Pas encore envoyée.</span>`}</div>`}
    </div>

    <div class="sec"><h3>Qui s'en occupe</h3>
      <div class="tags">${(t.assignes||[]).map(id=>`<span class="tag">${nm(id)||"…"}${id===S.me?" (moi)":""}</span>`).join("") || `<span class="muted small">Personne pour l'instant.</span>`}</div>
      ${attenteApprob(t)?`<div class="appr-box"><b>En attente de l'approbation de William.</b> Jean pourra prendre la demande une fois qu'elle sera approuvée.${estApprobateur()&&!ro?`<div class="btns" style="margin-top:8px"><button class="btn primary" data-appr="${esc(t.id)}">Approuver</button><button class="btn danger" data-refus="${esc(t.id)}">Refuser</button></div>`:""}</div>`:""}
      ${t.eau&&estApprobateur()&&!(t.eauVuPar||[]).includes(S.me)&&actif(t)&&!ro?`<div class="btns" style="margin-top:8px"><button class="btn" data-vu="${esc(t.id)}">💧 Vu, je suis au courant</button></div>`:""}
      ${ro||!S.me||(attenteApprob(t)&&!estApprobateur())?"":(t.assignes||[]).includes(S.me)?`<button class="btn" data-act="untag" style="margin-top:8px">Me retirer</button>`:`<button class="btn primary" data-act="tag" style="margin-top:8px">Je m'en occupe</button>`}</div>

    <div class="sec"><h3>Avancement</h3>
      <div class="chips">${AV.map(a=>`<button class="chip" data-av="${a.k}" aria-pressed="${t.avancement===a.k}" ${ro?"disabled":""}>${a.l}</button>`).join("")}</div>
      ${S.confirm && FIN_LABEL[S.confirm] ? `<div class="finish">
        <div class="field"><label for="note-fin">Comment as-tu réglé le problème? (obligatoire)</label><div class="microw">${mic("note-fin")}</div><textarea id="note-fin" placeholder="ex. Remplacé la cartouche du robinet, vérifié qu'il n'y a plus de fuite sous l'évier">${esc(S.finNote||t.noteFin||"")}</textarea></div>
        <div class="small" style="font-weight:600;margin:8px 0 4px">Photos du travail terminé</div>
        <div class="photos">${(t.photosApres||[]).map(p=>`<a href="#" data-phhref="${esc(p)}" target="_blank" rel="noopener"><img data-ph="${esc(p)}" alt="Photo après réparation" loading="lazy"></a>`).join("")}</div>
        ${S.assets?`<label class="btn" style="margin-top:8px">Ajouter des photos<input type="file" data-photofield="photosApres" accept="image/*" multiple hidden></label>`:""}
        <div class="btns" style="margin-top:10px"><button class="btn primary" data-act="finish">Confirmer « ${FIN_LABEL[S.confirm]} »</button><button class="btn" data-act="cancel">Annuler</button></div></div>` : ""}
      ${t.noteFin?`<div class="solution"><b>Solution :</b> ${esc(t.noteFin)}${t.terminePar&&nm(t.terminePar)?` <span class="muted small">— ${nm(t.terminePar)}, ${fmtDate(t.termineLe)}</span>`:""}</div>`:""}</div>

    ${actif(t) ? (()=>{ const rt=S.temps.find(e=>e.enCours && e.ticketId===t.id);
      if(t.chrono) return `<div class="sec"><div class="chrono"><div><div class="small muted">Chrono en marche</div><b class="num" id="chrono-val">${fmtH(running)}</b></div><button class="btn primary big" data-act="stop" ${ro?"disabled":""}>Arrêter</button></div></div>`;
      if(rt) return `<div class="sec"><div class="chrono"><div><div class="small muted">Chrono en marche${rt.par&&rt.par!==S.me&&nm(rt.par)?` · ${nm(rt.par)}`:""}</div><b class="num" data-since="${esc(rt.debut)}" data-plain="1">${fmtH((Date.now()-Date.parse(rt.debut))/60000)}</b></div>${rt.par===S.me&&!ro?`<button class="btn primary big" data-act="stopT">Arrêter</button>`:""}</div></div>`;
      return `<div class="sec"><div class="chrono"><div><div class="small muted">Temps sur ce billet</div><b class="num">${fmtH(minutesOf(t))}</b></div><button class="btn primary big" data-act="start" ${ro?"disabled":""}>Démarrer le chrono</button></div></div>`; })() : ""}

    <div class="sec"><h3>Catégorie</h3><div class="statusbar">${STATUTS.map(s=>{ const lock=!S.canAdmin && (s.k==="regle_ferme"||s.k==="ferme_refuse"); return `<button style="--sc:${s.c};--si:${s.i}" data-status="${s.k}" aria-pressed="${sOf(t).k===s.k}" ${ro||lock?"disabled":""} ${lock?'title="Réservé à l\'administration"':""}>${s.l}</button>`; }).join("")}</div>
      ${!S.canAdmin?`<p class="muted small">Seule l'administration peut classer une demande « Réglé et fermé » ou « Fermé / refusé ».</p>`:""}</div>

    <div class="sec"><h3>Heures <span class="num small muted">${fmtH(minutesOf(t))}</span></h3>
      <div class="lines">${linkedTemps(t).map(e=>`<div class="line"><span class="l">${fmtDate(e.date)} · Feuille de temps${e.description?` — ${esc(e.description)}`:""}${entryDetails(e)?`<br><span class="muted small">${esc(entryDetails(e))}</span>`:""}${e.par&&nm(e.par)?` <span class="muted small">(${nm(e.par)})</span>`:""}</span><span class="r num">${fmtH(+e.minutes||0)}</span></div>`).join("")}${(t.heures||[]).map(h=>`<div class="line"><span class="l">${fmtDate(h.date)}${h.note?` · ${esc(h.note)}`:""}${h.par&&nm(h.par)?` <span class="muted small">(${nm(h.par)})</span>`:""}</span><span class="r num">${fmtH(+h.minutes)}${ro?"":`<button class="x" data-delh="${esc(h.id)}" aria-label="Retirer">×</button>`}</span></div>`).join("") || (linkedTemps(t).length?"":`<p class="muted small">Aucune heure notée.</p>`)}</div>
      ${ro?"":`<div class="inline"><input id="h-min" type="number" min="5" step="5" placeholder="Minutes (ex. 45)"><input id="h-date" type="date" value="${todayISO()}"><input id="h-note" placeholder="Note (optionnelle)"><button class="btn" data-act="addh">Ajouter</button></div>`}</div>

    <div class="sec"><h3>Matériel et achats <span class="num small muted">${money.format(matOf(t))}</span></h3>
      <div class="lines">${(t.materiel||[]).map(x=>`<div class="line"><span class="l">${esc(x.desc)}${x.fournisseur?` <span class="muted small">· ${esc(x.fournisseur)}</span>`:""}</span><span class="r num">${money.format(+x.montant)}${ro?"":`<button class="x" data-delm="${esc(x.id)}" aria-label="Retirer">×</button>`}</span></div>`).join("") || `<p class="muted small">Aucun achat noté.</p>`}</div>
      ${ro?"":`<div class="inline"><input id="m-desc" placeholder="Article (ex. cartouche Moen)"><input id="m-four" placeholder="Fournisseur"><input id="m-mt" type="number" min="0" step="0.01" placeholder="Montant $ avant taxes"><button class="btn" data-act="addm">Ajouter</button></div>`}</div>

    <div class="sec"><h3>Photos après réparation</h3>
      <div class="photos">${(t.photosApres||[]).map(p=>`<a href="#" data-phhref="${esc(p)}" target="_blank" rel="noopener"><img data-ph="${esc(p)}" alt="Photo après réparation" loading="lazy"></a>`).join("")}</div>
      ${S.assets && !ro ? `<label class="btn" style="margin-top:8px">Ajouter des photos<input type="file" data-photofield="photosApres" accept="image/*" multiple hidden></label>` : (t.photosApres||[]).length?"":`<p class="muted small">Aucune photo.</p>`}</div>

    <div class="sec"><h3>Photos de la demande</h3>
      <div class="photos">${(t.photos||[]).map(p=>`<a href="#" data-phhref="${esc(p)}" target="_blank" rel="noopener"><img data-ph="${esc(p)}" alt="Photo du travail" loading="lazy" onerror="this.replaceWith(Object.assign(document.createElement('span'),{textContent:'Photo indisponible',className:'small muted'}))"></a>`).join("")}</div>
      ${S.assets && !ro ? `<label class="btn" style="margin-top:8px">Ajouter des photos<input type="file" data-photofield="photos" accept="image/*" multiple hidden></label>` : (t.photos||[]).length?"":`<p class="muted small">${S.assets?"Aucune photo.":"L'ajout de photos n'est pas offert dans cette vue."}</p>`}</div>

    ${!S.canAdmin ? `<div class="sec"><label class="small" style="display:flex;gap:8px;align-items:center"><input type="checkbox" id="t-fact" ${t.facturable!==false?"checked":""} ${ro?"disabled":""}> Facturable au propriétaire</label></div>` : `<div class="sec panel"><h3>Facturation</h3>
      <div class="lines small"><div class="line"><span>Main-d'œuvre (${c.hFact} h arrondie${c.hFact>1?"s":""} × ${money.format(+S.config.tauxHoraire||0)} · temps réel ${c.heures.toFixed(2).replace(".",",")} h)</span><span class="num">${money.format(c.mo)}</span></div>${S.config.tauxPaie?`<div class="line muted"><span>Coût de revient (temps exact × ${money.format(S.config.tauxPaie)}/h)</span><span class="num">${money.format(c.cout)}</span></div>`:""}
      <div class="line"><span>Matériel</span><span class="num">${money.format(c.mat+c.majo)}</span></div>
      <div class="line"><b>Total avant taxes</b><b class="num">${money.format(c.total)}</b></div></div>
      <div class="inline"><label class="small" style="display:flex;gap:8px;align-items:center"><input type="checkbox" id="t-fact" ${t.facturable!==false?"checked":""} ${ro?"disabled":""}> Facturable au propriétaire</label></div>
      ${t.factureLe?`<p class="small">Facturé le ${fmtDate(t.factureLe)}${t.refFacture?` · facture ${esc(t.refFacture)}`:""}</p>`:""}
    </div>`}

    ${ro||!S.canAdmin?"":`<div class="sec">${S.confirm==="delete"?`<div class="confirm"><span>Supprimer ce billet pour de bon? Ses heures et son matériel seront perdus.</span><button class="btn danger" data-act="del2">Oui, supprimer</button><button class="btn" data-act="cancel">Annuler</button></div>`:`<button class="btn danger" data-act="del1">Supprimer le billet</button>`}</div>`}
  </aside>`;
  bindSheet(t);
  bindMics(root);
}

/* ---------- écritures ---------- */
async function save(t, patch, okMsg){
  if (!S.db || S.readOnly) return;
  if (patch.statut==="priorite" && t.statut!=="priorite") patch.prioriteLe=new Date().toISOString();
  try { await S.db.collection("tickets").doc(t.id).update(patch); if (okMsg) toast(okMsg); }
  catch(e){ handleWriteErr(e); }
}
function handleWriteErr(e){
  if (e && e.code==="invalid_argument" && S.canWrite===null){ S.readOnly=true; render(); toast("Modification refusée : accès en lecture seulement."); return; }
  if (e && e.code==="quota_exceeded"){ toast("La base est pleine. Supprime d'anciens billets facturés."); return; }
  toast("L'enregistrement n'a pas fonctionné. Réessaie dans un instant.");
}

function bindView(){
  document.querySelectorAll("[data-open]").forEach(el=>{
    el.addEventListener("click",()=>{ S.openId=el.dataset.open; S.confirm=null; renderSheet(); });
    el.addEventListener("keydown",e=>{ if(e.key==="Enter"){ S.openId=el.dataset.open; S.confirm=null; renderSheet(); }});
  });
  const q=$("#f-q"); if(q) q.addEventListener("input",()=>{ S.filt.q=q.value; const pos=q.selectionStart; render(); const nq=$("#f-q"); nq.focus(); nq.setSelectionRange(pos,pos); });
  const fi=$("#f-imm"); if(fi) fi.addEventListener("change",()=>{ S.filt.immeuble=fi.value; render(); });
  const ao=$("#apercu-off"); if(ao) ao.addEventListener("click",()=>setApercu(null));
  const fr=$("#f-rep"); if(fr) fr.addEventListener("change",()=>{ S.filt.rep=fr.value; render(); });
  document.querySelectorAll("[data-st]").forEach(b=>b.addEventListener("click",()=>{ S.filt.statut=b.dataset.st; render(); }));

  const ni=$("#n-imm"); if(ni) ni.addEventListener("change",()=>{
    const us=unitsOf(ni.value);
    $("#n-unite").innerHTML = ni.value ? `<option value="">Choisir…</option>`+us.map(u=>`<option value="${esc(u)}">App. ${esc(u)}</option>`).join("")+ZONES.filter(z=>z.k!=="logement").map(z=>`<option value="${z.k}">${z.l}</option>`).join("") : `<option value="">Choisis d'abord l'immeuble</option>`;
  });
  const hint=()=>{ const h=$("#n-hint"); if(!h) return; const eau=estEau($("#n-titre").value+" "+$("#n-desc").value), ap=besoinApprob($("#n-imm").value);
    if(eau){ const st=$("#n-statut"); if(st) st.value="priorite"; }
    h.innerHTML=[eau?`<div class="banner warn" style="margin:0">💧 Problème d'eau détecté : le billet sera mis en <b>Priorité</b> et William sera avisé.</div>`:"", ap?`<div class="banner" style="margin:0">Cet immeuble demande l'approbation de William avant que Jean puisse prendre la demande.</div>`:""].join(""); };
  ["#n-titre","#n-desc"].forEach(sel=>{ const el=$(sel); if(el) el.addEventListener("input",hint); });
  if(ni) ni.addEventListener("change",hint);
  const fn=$("#f-new"); if(fn) fn.addEventListener("submit", async e=>{
    e.preventDefault(); if(!S.db||S.readOnly) return;
    const imm=$("#n-imm").value, titre=$("#n-titre").value.trim(), detail=$("#n-desc").value.trim();
    const desc = detail ? `${titre}\n${detail}` : titre;
    if(!imm||!titre){ toast("Choisis l'immeuble et décris le problème."); return; }
    const btn=fn.querySelector("button[type=submit]"); btn.disabled=true;
    const doc = { immeuble:imm, unite:$("#n-unite").value, demandeur:S.myName||"", contact:"",
      description:desc, categorie:"", datePrevue:$("#n-date").value||"",
      facturable:$("#n-fact").value==="1", acces:$("#n-acces").value.trim(), autorisation:$("#n-auth").value, statut:$("#n-statut").value,
      creeLe:new Date().toISOString(), creePar:S.me||null, heures:[], materiel:[], photos:[], chrono:null,
      repartiA:[...document.querySelectorAll("[data-nrep]:checked")].map(c=>c.dataset.nrep) };
    if(doc.repartiA.length){ doc.repartiLe=new Date().toISOString(); doc.repartiPar=S.me||null; }
    if(estEau(desc)){ doc.eau=true; doc.statut="priorite"; doc.eauVuPar=[]; }
    if(doc.statut==="priorite") doc.prioriteLe=doc.creeLe;
    if(besoinApprob(imm)) doc.approbation="requise";
    const pf=$("#n-photos"), files=pf?[...pf.files]:[];
    if(files.length && S.assets){ toast(`Envoi de ${files.length} photo${files.length>1?"s":""}…`); for(const f of files){ try{ const r=await S.assets.upload(f); doc.photos.push(r.id); }catch(err){ toast("Une photo n'a pas pu être envoyée."); } } }
    try{ const ref = await S.db.collection("tickets").add(doc); toast(["Billet créé", doc.eau?"problème d'eau : mis en priorité, William est avisé":"", doc.approbation?"en attente de l'approbation de William":""].filter(Boolean).join(" · ")); location.hash="#billets"; S.openId=ref.id; }
    catch(err){ btn.disabled=false; handleWriteErr(err); }
  });

  const tk=id=>S.tickets.find(x=>x.id===id);
  document.querySelectorAll("[data-appr]").forEach(b=>b.addEventListener("click",()=>{ const t=tk(b.dataset.appr); if(t) save(t,{approbation:"approuvee",approbationPar:S.me,approbationLe:new Date().toISOString()},"Demande approuvée : Jean peut la prendre"); }));
  document.querySelectorAll("[data-refus]").forEach(b=>b.addEventListener("click",()=>{ const t=tk(b.dataset.refus); if(t) save(t,{approbation:"refusee",approbationPar:S.me,approbationLe:new Date().toISOString(),statut:"ferme_refuse"},"Demande refusée"); }));
  document.querySelectorAll("[data-vu]").forEach(b=>b.addEventListener("click",()=>{ const t=tk(b.dataset.vu); if(t) save(t,{eauVuPar:[...new Set([...(t.eauVuPar||[]),S.me])]},"Noté comme vu"); }));
  const ap=$("#c-appr"); if(ap) ap.addEventListener("change",async()=>{ try{ await S.db.doc("config/general").update({approbateur:ap.value||null}); S.config.approbateur=ap.value||null; toast(ap.value?`${S.names[ap.value]||"Cette personne"} approuve et reçoit les alertes`:"Approbateur retiré"); render(); }catch(e){ toast("L'enregistrement n'a pas fonctionné."); } });
  document.querySelectorAll("[data-cpt]").forEach(sel=>sel.addEventListener("change",async()=>{
    const next={...(S.config.comptes||{})}; if(sel.value) next[sel.dataset.cpt]=sel.value; else delete next[sel.dataset.cpt];
    try{ await S.db.doc("config/general").update({comptes:next}); S.config.comptes=next; toast(`Compte de ${EQL[sel.dataset.cpt]} enregistré`); render(); }catch(e){ toast("L'enregistrement n'a pas fonctionné."); }
  }));
  const csv=$("#csv"); if(csv) csv.addEventListener("click", exportCSV);
  document.querySelectorAll("[data-copy]").forEach(b=>b.addEventListener("click",()=>copySummary(b.dataset.copy)));
  document.querySelectorAll("[data-billed]").forEach(b=>b.addEventListener("click", async ()=>{
    const imm=b.dataset.billed; const ref=(document.querySelector(`[data-ref="${CSS.escape(imm)}"]`)||{}).value||"";
    const items=factGroups().find(([i])=>i===imm)?.[1]||[]; b.disabled=true;
    const now=new Date().toISOString(), r=ref.trim();
    for (const i of items){
      if(i.kind==="t"){ const t=S.tickets.find(x=>x.id===i.id); if(t){ await save(t,{statut:"regle_ferme",factureLe:now,refFacture:r}); for(const e of linkedTemps(t)){ try{ await S.db.collection("temps").doc(e.id).update({facture:true,factureLe:now,refFacture:r}); }catch(err){} } } }
      else { try{ await S.db.collection("temps").doc(i.id).update({facture:true,factureLe:now,refFacture:r}); }catch(e){ handleWriteErr(e); } }
    }
    toast(`${items.length} ligne${items.length>1?"s":""} marquée${items.length>1?"s":""} facturée${items.length>1?"s":""}`);
  }));
  document.querySelectorAll("[data-gest]").forEach(c=>c.addEventListener("change",async()=>{
    const id=c.dataset.gest, cur=S.config.gestionnaires||[];
    const next = c.checked ? [...new Set([...cur,id])] : cur.filter(x=>x!==id);
    try{ await S.db.doc("config/general").update({gestionnaires:next}); S.config.gestionnaires=next; toast(c.checked?`${S.names[id]||"Cette personne"} voit maintenant les tâches de gestion`:"Accès aux tâches de gestion retiré"); }
    catch(e){ c.checked=!c.checked; toast("L'enregistrement n'a pas fonctionné."); }
  }));
  const cs=$("#c-save"); if(cs) cs.addEventListener("click", async ()=>{
    const taux=parseFloat($("#c-taux").value), paie=parseFloat($("#c-paie").value);
    const imms=null;
    try{
      await S.db.doc("config/general").set({gestionnaires:S.config.gestionnaires||[], approbateur:S.config.approbateur||null, comptes:S.config.comptes||{}});
      await S.db.doc("admin/tarifs").set({tauxHoraire:isNaN(taux)?null:taux, tauxPaie:isNaN(paie)?null:paie, majorationMateriel:0, majExceptions:{}});
      toast("Réglages enregistrés");
    } catch(e){ toast(e&&e.code==="invalid_argument"?"Seule l'administration peut changer les réglages.":"L'enregistrement n'a pas fonctionné."); }
  });
  if (S.view==="temps") bindTemps();
  if (S.view==="urgences") bindUrgences();
  if (S.view==="paye") bindPaye();
  if (S.view==="resume") bindResume();
  bindImmSearch();
  bindMics($("#mnt-main"));
}

function bindSheet(t){
  const root=$("#sheet-root");
  root.querySelectorAll("[data-close]").forEach(b=>b.addEventListener("click",()=>{ S.openId=null; S.confirm=null; renderSheet(); }));
  root.querySelectorAll("[data-status]").forEach(b=>b.addEventListener("click",()=>{
    const k=b.dataset.status; if(k===t.statut) return;
    if((k==="regle_ferme"||k==="ferme_refuse") && !S.canAdmin){ toast("Réservé à l'administration."); return; }
    if(k==="ferme_facturer"){ S.confirm="termine_facturer"; S.finNote=""; renderSheet(); return; }
    if(k==="regle_ferme"){ S.confirm="regle_ferme"; S.finNote=""; renderSheet(); return; }
    save(t,{statut:k},`Catégorie : ${ST[k].l}`);
  }));
  root.querySelectorAll("[data-av]").forEach(b=>b.addEventListener("click",()=>{
    const k=b.dataset.av; if(k===t.avancement) return;
    if(k==="termine"||k==="termine_facturer"){ S.confirm=k; S.finNote=""; renderSheet(); return; }
    const patch={avancement:k}; if(S.me && !(t.assignes||[]).includes(S.me)) patch.assignes=[...(t.assignes||[]),S.me];
    if(t.statut==="ferme_facturer") patch.statut="en_cours";
    save(t,patch,`Avancement : ${AVL[k]}`);
  }));
  const nf=$("#note-fin"); if(nf) nf.addEventListener("input",()=>{ S.finNote=nf.value; });
  document.querySelectorAll("[data-rep]").forEach(b=>b.addEventListener("click",()=>{
    if(!peutRepartir()) return; const k=b.dataset.rep, cur=t.repartiA||[], on=cur.includes(k);
    const next = on ? cur.filter(x=>x!==k) : [...cur,k];
    save(t,{repartiA:next, repartiLe:new Date().toISOString(), repartiPar:S.me||null}, on?`Retirée de ${EQL[k]}`:`Envoyée à ${EQL[k]}`);
  }));
  const act = async (a)=>{
    if((a==="tag"||a==="start") && attenteApprob(t) && !estApprobateur()){ toast("Cette demande doit d'abord être approuvée par William."); return; }
    if(a==="tag"){ await save(t,{assignes:[...new Set([...(t.assignes||[]),S.me])], avancement:t.avancement||"en_cours"},"Tu es identifié sur cette demande"); return; }
    if(a==="untag"){ await save(t,{assignes:(t.assignes||[]).filter(x=>x!==S.me)},"Retiré de la demande"); return; }
    if(a==="start"){
      if(S.temps.some(e=>e.enCours && e.par===S.me)){ toast("Un chrono est déjà en marche. Arrête-le d'abord."); S.openId=null; location.hash="#temps"; return; }
      if(S.temps.some(e=>!e.enCours && e.aRemplir && e.par===S.me)){ toast("Complète d'abord le temps déjà arrêté."); S.openId=null; location.hash="#temps"; return; }
      try{
        await S.db.collection("temps").add({date:todayISO(), debut:new Date().toISOString(), enCours:true, minutes:0, par:S.me||null, creeLe:new Date().toISOString(), facture:false, ticketId:t.id});
        const patch={}; if(["a_traiter","quand_possible"].includes(t.statut)) patch.statut="en_cours";
        if(S.me && !(t.assignes||[]).includes(S.me)){ patch.assignes=[...(t.assignes||[]),S.me]; patch.avancement=t.avancement||"en_cours"; }
        if(Object.keys(patch).length) await save(t,patch);
        toast("Chrono démarré — il apparaît aussi dans la feuille de temps");
      }catch(e){ handleWriteErr(e); }
      return;
    }
    if(a==="stopT"){
      const rt=S.temps.find(e=>e.enCours && e.ticketId===t.id && e.par===S.me); if(!rt) return;
      const min=Math.max(1,Math.round((Date.now()-Date.parse(rt.debut))/60000));
      try{ await S.db.collection("temps").doc(rt.id).update({enCours:false, aRemplir:true, minutes:min, fin:new Date().toISOString()}); resetTForm(); S.openId=null; location.hash="#temps"; toast(`${fmtH(min)} · dis-nous ce que tu as fait`); }
      catch(e){ handleWriteErr(e); }
      return;
    }
    if(a==="stop" && t.chrono){
      const min=Math.max(1,Math.round((Date.now()-Date.parse(t.chrono.debut))/60000));
      await save(t,{chrono:null, heures:[...(t.heures||[]),{id:rid(),date:todayISO(),minutes:min,note:"Chrono",par:t.chrono.par||S.me||null}]},`${fmtH(min)} ajoutées`);
    }
    if(a==="finish"){
      const note=(($("#note-fin")||{}).value||"").trim();
      if(!note){ toast("Explique comment tu as réglé le problème."); $("#note-fin")&&$("#note-fin").focus(); return; }
      const k=S.confirm;
      if(k==="regle_ferme" && !S.canAdmin){ toast("Réservé à l'administration."); return; }
      const patch={noteFin:note, termineLe:new Date().toISOString(), terminePar:S.me||null};
      if(k==="termine") patch.avancement="termine";
      if(k==="termine_facturer"){ patch.avancement="termine_facturer"; patch.statut = t.facturable===false ? t.statut : "ferme_facturer"; }
      if(k==="regle_ferme"){ patch.statut="regle_ferme"; patch.avancement=t.avancement==="termine_facturer"?"termine_facturer":"termine"; }
      if(S.me && !(t.assignes||[]).includes(S.me) && k!=="regle_ferme") patch.assignes=[...(t.assignes||[]),S.me];
      if(t.chrono){ const min=Math.max(1,Math.round((Date.now()-Date.parse(t.chrono.debut))/60000)); patch.chrono=null; patch.heures=[...(t.heures||[]),{id:rid(),date:todayISO(),minutes:min,note:"Chrono",par:t.chrono.par||S.me||null}]; }
      S.confirm=null; S.finNote=""; await save(t,patch, FIN_LABEL[k]);
    }
    if(a==="cancel"){ S.confirm=null; S.finNote=""; renderSheet(); }
    if(a==="addh"){
      const min=parseInt($("#h-min").value,10); if(!(min>0)){ toast("Entre un nombre de minutes."); return; }
      await save(t,{heures:[...(t.heures||[]),{id:rid(),date:$("#h-date").value||todayISO(),minutes:min,note:$("#h-note").value.trim(),par:S.me||null}]},"Heures ajoutées");
    }
    if(a==="addm"){
      const d=$("#m-desc").value.trim(), mt=parseFloat($("#m-mt").value);
      if(!d||isNaN(mt)){ toast("Entre l'article et son montant."); return; }
      await save(t,{materiel:[...(t.materiel||[]),{id:rid(),desc:d,fournisseur:$("#m-four").value.trim(),montant:Math.round(mt*100)/100,par:S.me||null}]},"Matériel ajouté");
    }
    if(a==="del1"){ S.confirm="delete"; renderSheet(); }
    if(a==="del2"){ try{ await S.db.collection("tickets").doc(t.id).delete(); S.openId=null; S.confirm=null; toast("Billet supprimé"); }catch(e){ handleWriteErr(e); } }
  };
  root.querySelectorAll("[data-act]").forEach(b=>b.addEventListener("click",()=>act(b.dataset.act)));
  root.querySelectorAll("[data-delh]").forEach(b=>b.addEventListener("click",()=>save(t,{heures:(t.heures||[]).filter(h=>h.id!==b.dataset.delh)},"Heures retirées")));
  root.querySelectorAll("[data-delm]").forEach(b=>b.addEventListener("click",()=>save(t,{materiel:(t.materiel||[]).filter(m=>m.id!==b.dataset.delm)},"Matériel retiré")));
  const tf=$("#t-fact"); if(tf) tf.addEventListener("change",()=>save(t,{facturable:tf.checked}, tf.checked?"Marqué facturable":"Marqué non facturable"));
  root.querySelectorAll("[data-photofield]").forEach(pf=>pf.addEventListener("change", async ()=>{
    const field=pf.dataset.photofield, files=[...pf.files]; if(!files.length) return; toast(`Envoi de ${files.length} photo${files.length>1?"s":""}…`);
    const ids=[];
    for(const f of files){ try{ const r=await S.assets.upload(f); ids.push(r.id); }catch(e){ toast(e&&e.code==="too_large"?"Photo trop lourde (20 Mo max).":e&&e.code==="unsupported_type"?"Format de photo non accepté.":"Une photo n'a pas pu être envoyée."); } }
    if(ids.length){ const cur=S.tickets.find(x=>x.id===t.id)||t; await save(cur,{[field]:[...(cur[field]||[]),...ids]},`${ids.length} photo${ids.length>1?"s":""} ajoutée${ids.length>1?"s":""}`); }
  }));
  const esc1=e=>{ if(e.key==="Escape"){ S.openId=null; S.confirm=null; renderSheet(); document.removeEventListener("keydown",esc1);} };
  document.addEventListener("keydown",esc1,{once:true});
}

/* ---------- exports ---------- */
function summaryText(imm){
  const items=factGroups().find(([i])=>i===imm)?.[1]||[];
  const lines=items.map(i=>`- ${fmtDate(i.date)} : ${i.label.replace(/\s+/g," ")} — ${i.hFact} h, main-d'œuvre ${money.format(i.mo)}, matériel ${money.format(i.mat+i.majo)} = ${money.format(i.total)}`);
  const tot=items.reduce((a,i)=>a+i.total,0);
  return `Maintenance — ${adrAff(imm)}\n${lines.join("\n")}\nTotal avant taxes : ${money.format(tot)}`;
}
async function copySummary(imm){
  const txt=summaryText(imm);
  try{ await navigator.clipboard.writeText(txt); toast("Résumé copié"); }
  catch{ const ta=document.createElement("textarea"); ta.value=txt; ta.style.cssText="width:100%;min-height:140px;margin-top:8px"; const host=document.querySelector(`[data-copy="${CSS.escape(imm)}"]`).closest(".bill"); host.appendChild(ta); ta.select(); toast("Sélectionne le texte et copie-le"); }
}
async function exportCSV(){
  const rows=[["Immeuble","Logement","Date","Travail","Type","Heures réelles","Heures arrondies","Taux horaire","Main-d'oeuvre","Matériel","Total avant taxes","Code"]];
  factGroups().forEach(([imm,items])=>items.forEach(i=>rows.push([adrAff(imm),i.unite,(i.date||"").slice(0,10),i.label,i.cat,i.heures.toFixed(2),i.hFact,S.config.tauxHoraire??"",i.mo.toFixed(2),i.mat.toFixed(2),i.total.toFixed(2),i.code])));
  const csv="﻿"+rows.map(r=>r.map(v=>`"${String(v).replace(/"/g,'""').replace(/\n/g," ")}"`).join(",")).join("\r\n");
  if(!S.downloads){ toast("Le téléchargement n'est pas offert dans cette vue."); return; }
  try{ await S.downloads.save({filename:`maintenance-a-facturer-${todayISO()}.csv`, data:csv}); }
  catch(e){ if(!(e&&e.code==="declined")) toast("Le téléchargement n'a pas fonctionné."); }
}

/* ---------- noms ---------- */
async function resolveNames(){
  if(!S.user) return;
  const ids=new Set(); S.tickets.forEach(t=>{ if(t.creePar) ids.add(t.creePar); if(t.terminePar) ids.add(t.terminePar); (t.assignes||[]).forEach(x=>ids.add(x)); (t.heures||[]).forEach(h=>h.par&&ids.add(h.par)); });
  if(S.me) ids.add(S.me);
  allRevs().forEach(r=>r.par&&ids.add(r.par));
  S.temps.forEach(e=>e.par&&ids.add(e.par));
  if(!ids.size) return;
  const ps=await S.user.profiles([...ids]); let changed=false;
  for(const id of ids){ const n=ps[id]?.name||""; if(S.names[id]!==n){ S.names[id]=n; changed=true; } }
  if(changed) render();
}

/* ---------- démarrage ---------- */
window.addEventListener("hashchange",()=>{ S.openId=null; setView(); });
setInterval(()=>{ document.querySelectorAll("[data-since]").forEach(el=>{ el.textContent=(el.dataset.plain?"":"● ")+fmtH((Date.now()-Date.parse(el.dataset.since))/60000); });
  const cv=$("#chrono-val"); const t=S.tickets.find(x=>x.id===S.openId); if(cv&&t&&t.chrono) cv.textContent=fmtH((Date.now()-Date.parse(t.chrono.debut))/60000); }, 15000);
setView();

(async()=>{
  /* ---------- Démarrage dans le portail : base Supabase au lieu de la base de l'artéfact ---------- */
  const sb = CTX.sb;
  const uid = () => (window.crypto && crypto.randomUUID) ? crypto.randomUUID() : (Date.now().toString(36) + Math.random().toString(36).slice(2));
  const subs = {}, docSubs = {}, minuteurs = {};
  async function lire(coll){
    if(coll==="tickets"){ const {data,error}=await sb.from("billets").select("id,donnees").not("donnees","is",null).limit(5000); if(error) throw error; return data.map(r=>({id:r.id,data:r.donnees})); }
    const {data,error}=await sb.from("maint_docs").select("id,data").eq("collection",coll).limit(5000); if(error) throw error; return data.map(r=>({id:r.id,data:r.data}));
  }
  const instantane = rows => ({docs:rows.map(r=>({id:r.id,data:()=>r.data})), metadata:{fromCache:false}});
  function rafraichir(coll){
    clearTimeout(minuteurs[coll]);
    minuteurs[coll]=setTimeout(async()=>{
      try{
        const rows=await lire(coll);
        (subs[coll]||[]).forEach(s=>s.cb(instantane(rows)));
        Object.keys(docSubs).forEach(k=>{ const i=k.lastIndexOf("/"); if(k.slice(0,i)!==coll) return; const r=rows.find(x=>x.id===k.slice(i+1)); docSubs[k].forEach(cb=>cb({exists:!!r, data:()=>r?r.data:undefined})); });
      }catch(e){ (subs[coll]||[]).forEach(s=>s.err&&s.err(e)); }
    },120);
  }
  function docRef(coll,id){ return {
    id,
    async update(patch){ const {error}=await sb.rpc("maint_fusion",{p_coll:coll,p_id:String(id),p_patch:patch}); if(error) throw error; rafraichir(coll); },
    async set(data){ const r = coll==="tickets" ? await sb.from("billets").update({donnees:data}).eq("id",id) : await sb.from("maint_docs").upsert({collection:coll,id:String(id),data,modifie_le:new Date().toISOString()}); if(r.error) throw r.error; rafraichir(coll); },
    async delete(){ const r = coll==="tickets" ? await sb.from("billets").delete().eq("id",id) : await sb.from("maint_docs").delete().eq("collection",coll).eq("id",String(id)); if(r.error) throw r.error; rafraichir(coll); },
    onSnapshot(cb){ (docSubs[coll+"/"+id] ||= []).push(cb); rafraichir(coll); return ()=>{}; }
  }; }
  const db = {
    collection(coll){ return {
      doc:id=>docRef(coll,id),
      async add(data){
        if(coll==="tickets"){ const {data:r,error}=await sb.from("billets").insert({donnees:data}).select("id").single(); if(error) throw error; rafraichir(coll); return {id:r.id}; }
        const id=uid(); const {error}=await sb.from("maint_docs").insert({collection:coll,id,data}); if(error) throw error; rafraichir(coll); return {id};
      },
      onSnapshot(cb,err){ (subs[coll] ||= []).push({cb,err}); rafraichir(coll); return ()=>{}; }
    }; },
    doc(path){ const i=path.lastIndexOf("/"); return docRef(path.slice(0,i), path.slice(i+1)); }
  };
  try{
    sb.channel("maintenance-"+uid())
      .on("postgres_changes",{event:"*",schema:"public",table:"billets"},()=>rafraichir("tickets"))
      .on("postgres_changes",{event:"*",schema:"public",table:"maint_docs"},p=>{ const c=(p.new&&p.new.collection)||(p.old&&p.old.collection); if(c) rafraichir(c); else Object.keys(subs).forEach(rafraichir); })
      .subscribe();
  }catch(e){}
  setInterval(()=>{ const m=document.getElementById("mnt"); if(m && !m.hidden) Object.keys(subs).forEach(rafraichir); }, 60000);
  window.BLMaintRefresh = () => { Object.keys(subs).forEach(rafraichir); setView(); };

  const user = { async profiles(ids){
    const ok=ids.filter(x=>/^[0-9a-f-]{36}$/i.test(x)), out={};
    if(ok.length){ const {data}=await sb.from("profils").select("id,nom,courriel").in("id",ok); (data||[]).forEach(p=>{ out[p.id]={name:p.nom||p.courriel||""}; }); }
    ids.filter(x=>!out[x]).forEach(x=>{ out[x]={name:S.names[x]||""}; });
    return out;
  } };
  const assets = { async upload(file){
    if(file.size>20*1024*1024) throw {code:"too_large"};
    if(!/^image\//.test(file.type||"image/")) throw {code:"unsupported_type"};
    const ext=((file.name||"").split(".").pop()||"jpg").toLowerCase().replace(/[^a-z0-9]/g,"")||"jpg";
    const path=`maintenance/${uid()}.${ext}`;
    const {error}=await sb.storage.from("photos").upload(path,file,{contentType:file.type||"image/jpeg"});
    if(error) throw {code:"failed",message:error.message};
    return {id:path};
  } };
  const downloads = { async save({filename,data}){
    const a=document.createElement("a"); a.href=URL.createObjectURL(new Blob([data],{type:"text/csv;charset=utf-8"})); a.download=filename;
    document.body.appendChild(a); a.click(); setTimeout(()=>{ URL.revokeObjectURL(a.href); a.remove(); },1500);
  } };

  /* Photos : URL signées (privées) du stockage Supabase */
  let urls={}, enAttente=false;
  setInterval(()=>{ urls={}; }, 50*60000);
  async function resoudrePhotos(){
    enAttente=false;
    const els=[...document.querySelectorAll('#mnt img[data-ph]:not([src]), #mnt a[data-phhref][href="#"]')];
    const chemins=[...new Set(els.map(e=>e.dataset.ph||e.dataset.phhref))].filter(p=>p&&!urls[p]);
    const valides=chemins.filter(p=>!/^[0-9a-f]{32}$/.test(p));
    if(valides.length){ const {data}=await sb.storage.from("photos").createSignedUrls(valides,3600); (data||[]).forEach(d=>{ if(d.signedUrl) urls[d.path]=d.signedUrl; }); }
    chemins.filter(p=>!urls[p]).forEach(p=>{ urls[p]="__x"; });
    document.querySelectorAll('#mnt img[data-ph]:not([src])').forEach(img=>{ const u=urls[img.dataset.ph]; if(!u) return; if(u==="__x"){ const a=img.closest("a"); (a||img).replaceWith(Object.assign(document.createElement("span"),{textContent:"Photo indisponible",className:"small muted"})); } else img.src=u; });
    document.querySelectorAll('#mnt a[data-phhref][href="#"]').forEach(a=>{ const u=urls[a.dataset.phhref]; if(u&&u!=="__x"){ a.href=u; a.target="_blank"; } });
  }
  new MutationObserver(()=>{ if(!enAttente){ enAttente=true; setTimeout(resoudrePhotos,60); } }).observe(document.getElementById("mnt"),{childList:true,subtree:true});

  S.db=db; S.user=user; S.assets=assets; S.downloads=downloads; S.dict=makeWebDict();
  if(S.dict) setupDictation(S.dict);
  S.me=CTX.user.id; S.canAdmin=!!CTX.isAdmin; S.myName=CTX.nom||"";
  $("#mnt-who").textContent=S.myName;
  const dn=$("#n-dem-nom"); if(dn && S.myName) dn.textContent=S.myName;
  S.canWrite=true; S.vraiMe=S.me; S.vraiAdmin=S.canAdmin; S.vraiRO=S.readOnly;
  const ap=$("#apercu"); if(ap) ap.addEventListener("change",()=>setApercu(ap.value||null));

  const [{data:ppl},{data:imms}] = await Promise.all([
    sb.from("profils").select("id,nom,courriel"),
    sb.from("maint_immeubles").select("adresse,unites")
  ]);
  (ppl||[]).forEach(p=>{ S.names[p.id]=p.nom||p.courriel||""; });
  S.config.immeubles=(imms||[]).map(i=>({adresse:i.adresse, unites:i.unites||[]}));

  const timer=setTimeout(()=>{ S.slow=true; render(); },10000);
  db.collection("tickets").onSnapshot(snap=>{
    S.tickets=snap.docs.map(d=>({id:d.id,...d.data()}));
    S.loaded=true; S.slow=false; clearTimeout(timer);
    render();
  }, err=>{ clearTimeout(timer); S.loaded=true; S.error="Les billets ne peuvent pas être chargés pour le moment."; render(); });
  const subRevs=()=>{ if(!S.canAdmin) return; const ids=new Set(S.temps.map(e=>e.par).filter(Boolean)); if(S.me) ids.add(S.me);
    ids.forEach(u=>{ if(S.revSubs[u]) return; S.revSubs[u]=db.collection(`revisions/${u}/log`).onSnapshot(sn=>{ S.revs[u]=sn.docs.map(d=>({id:d.id,...d.data()})); if(S.view==="temps") render(); }, ()=>{}); }); };
  [["paye_specs","pspecs"],["banque","banque"],["payes","payes"]].forEach(([c,k])=>db.collection(c).onSnapshot(snap=>{ S[k]=snap.docs.map(d=>({id:d.id,...d.data()})); if(S.view==="paye") render(); }, ()=>{}));
  db.collection("urgences").onSnapshot(snap=>{ S.urgences=snap.docs.map(d=>({id:d.id,...d.data()})); render(); }, ()=>{});
  db.collection("temps").onSnapshot(snap=>{ S.temps=snap.docs.map(d=>({id:d.id,...d.data()})); subRevs(); render(); }, ()=>{});
  db.doc("config/general").onSnapshot(snap=>{
    if(snap.exists){ const d=snap.data(); S.config.gestionnaires=d.gestionnaires||[]; S.config.approbateur=d.approbateur||null; S.config.comptes=d.comptes||{}; }
    render();
  });
  if(S.canAdmin) db.doc("admin/tarifs").onSnapshot(snap=>{
    if(snap.exists){ const d=snap.data(); S.config.tauxHoraire=d.tauxHoraire??null; S.config.majorationMateriel=d.majorationMateriel??0; S.config.tauxPaie=d.tauxPaie??null; S.config.majExceptions=d.majExceptions||{}; }
    render();
  });
  const tf=document.querySelector('#mnt nav.tabs a[data-v="facturation"]'); if(tf) tf.hidden=!S.canAdmin;
})();
};
.
(function () {
  const SUPABASE_URL = 'https://phneerdsktucfysodjwq.supabase.co';
  const SUPABASE_CLE_PUBLIQUE = 'sb_publishable_Q-OqrYOK5RAow85ZuilpOA_U7_QrvJl';
  const DUREE_VISITE_MIN = 30;
  const root = document.getElementById('bl-root');
  if (SUPABASE_CLE_PUBLIQUE.startsWith('COLLE_ICI')) { root.innerHTML = '<div class="msg err">Clé publique Supabase manquante dans la page.</div>'; return; }
  const sb = supabase.createClient(SUPABASE_URL, SUPABASE_CLE_PUBLIQUE);

  const S = { user: null, roles: [], esp: null, tab: 'journee', annonces: [], filtre: 'actifs', q: '', jour: null, noms: {}, produits: null, statsPer: '90' };
  const STATUTS_ANNONCE = { affiche: ['Affiché / dispo', 'b-ok'], prise_photos: ['Prise de photos', 'b-blue'], en_attente: ['En attente', 'b-warn'], en_renovation: ['En rénovation', 'b-reno'], en_enquete: ['En enquête', 'b-pri'], loue: ['Loué', 'b-dark'], retire: ['Retiré', 'b-bad'] };
  const ORDRE_ANNONCE = ['affiche', 'prise_photos', 'en_attente', 'en_renovation', 'en_enquete', 'loue', 'retire'];
  const STATUTS_VISITE = { demandee: ['Demandée', 'b-warn'], planifiee: ['Planifiée', 'b-blue'], confirmee: ['Confirmée', 'b-ok'], faite: ['Faite', 'b-dark'], absent: ['Absent', 'b-bad'], annulee: ['Annulée', 'b-bad'] };
  // Étapes identiques au tableau Monday « Je veux appliquer »
  const STATUTS_DEMANDE = { nouvelle: ['À traiter', 'b-blue', '#2f6fb3'], formulaire_envoye: ['Formulaire envoyé', 'b-warn', '#e08a00'], formulaire_expire: ['Formulaire expiré', 'b-bad', '#a0522d'],
    enquete_envoyee: ['Enquête démarrée', 'b-warn', '#f2b705'], brouillon_bail: ['Brouillon de bail à créer', 'b-pri', '#c4704f'], bail_a_envoyer: ['Bail à envoyer', 'b-pri', '#d9822b'],
    bail_envoye: ['Bail envoyé', 'b-ok', '#3a9d6a'], transfert_candidature: ['Transfert de candidature à faire', 'b-blue', '#6a5acd'], en_attente: ['En attente', 'b-warn', '#b8a000'],
    louee: ['Loué', 'b-dark', '#3a3a3a'], refusee: ['Respecte pas les critères', 'b-bad', '#bb3354'], perdue: ['Perdu', 'b-bad', '#8a8a8a'] };
  const ANCIENS_DEMANDE = { enquete_payee: 'Enquête démarrée', approuvee: 'Bail à envoyer' };
  const DEM_FINIES = ['louee', 'refusee', 'perdue', 'formulaire_expire'];
  const PAIEMENTS = ['Non', 'Oui (60$)', 'Oui (120$)', 'Oui (180$)', 'Oui (240$)', 'Non applicable'];
  // Statuts de suivi des demandes de visite (identiques au tableau Monday « Planifier une visite »)
  const SUIVI_VISITE = [['À CONTACTER', '#2f6fb3'], ['Contacté 1x', '#e08a00'], ['Contacté 2x', '#e08a00'], ['Contacté 3x', '#d9822b'], ['Contacté 4x', '#d9822b'], ['Dernière tentative de contact', '#bb3354'],
    ['À rappler en soirée', '#6a5acd'], ['En attente de son retour', '#b8a000'], ['À relancer visite intéressante', '#c4704f'], ['Visite planifiée', '#037f4c'],
    ['Déjà trouvé ailleur', '#8a8a8a'], ['Plus intéressé', '#8a8a8a'], ['Candidat non intéressant', '#8a8a8a'], ['Contact pas bon', '#8a8a8a'], ['Perdu après 5 relances', '#8a8a8a']];
  const SUIVI_FINIS = ['Déjà trouvé ailleur', 'Plus intéressé', 'Candidat non intéressant', 'Contact pas bon', 'Perdu après 5 relances', 'Visite planifiée'];
  const couleurSuivi = (s) => (SUIVI_VISITE.find(x => x[0] === s) || [s, '#2f6fb3'])[1];
  const STATUTS_ATTENTE = { actif: ['Actif', 'b-ok'], contacte: ['Contacté', 'b-blue'], loge: ['Logé', 'b-dark'], perdu: ['Perdu', 'b-bad'] };
  const APPEL = { confirme: ['Confirmé de vive voix', 'b-ok'], message_laisse: ['Message laissé sur la boîte vocale', 'b-warn'], impossible: ['Impossible de laisser un message : 2e appel à faire', 'b-bad'] };
  const ACTIFS = ['en_attente', 'prise_photos', 'en_renovation', 'affiche', 'en_enquete'];

  const esc = (v) => (v == null ? '' : String(v)).replace(/[&<>"']/g, c => ({ '&': '&amp;', '<': '&lt;', '>': '&gt;', '"': '&quot;', "'": '&#39;' }[c]));
  const badge = (s, map) => { const x = map[s] || [s, '']; return `<span class="badge ${x[1]}">${esc(x[0])}</span>`; };
  const norm = (s) => String(s || '').normalize('NFD').replace(/[̀-ͯ]/g, '').toLowerCase();
  const TYPES = /^(rue|av\.?|avenue|chem\.?|chemin|boul\.?|boulevard|place|mont[ée]e|rang|route|croissant|impasse|terrasse|all[ée]e|c[ôo]te)\s+/i;
  const ARTS = /^(de la\s+|de l['’]\s*|des\s+|du\s+|de\s+|d['’]\s*|la\s+|le\s+|les\s+|l['’]\s*)/i;
  const rueCle = (r) => { const s = String(r || '').trim().replace(TYPES, '').replace(ARTS, '').trim(); return s.charAt(0).toUpperCase() + s.slice(1); };
  const libelle = (a) => a ? `${rueCle(a.rue)} ${a.numero || ''}`.trim() : '';
  const adresseComplete = (a) => a ? `${a.numero || ''} ${a.rue || ''}`.trim() + (a.immeubles && a.immeubles.ville ? ', ' + a.immeubles.ville : '') : '';
  const triAnn = (x, y) => norm(rueCle(x.rue)).localeCompare(norm(rueCle(y.rue)), 'fr', { numeric: true }) || String(x.numero || '').localeCompare(String(y.numero || ''), 'fr', { numeric: true });
  const fmtDate = (d) => d ? new Date(d + (String(d).length === 10 ? 'T12:00:00' : '')).toLocaleDateString('fr-CA', { day: 'numeric', month: 'long', year: 'numeric' }) : '';
  const fmtCourt = (d) => d ? new Date(d + (String(d).length === 10 ? 'T12:00:00' : '')).toLocaleDateString('fr-CA', { day: 'numeric', month: 'short' }) : '';
  const fmtDT = (d) => d ? new Date(d).toLocaleString('fr-CA', { weekday: 'short', day: 'numeric', month: 'short', hour: '2-digit', minute: '2-digit' }) : '';
  const fmtH = (d) => d ? new Date(d).toLocaleTimeString('fr-CA', { hour: '2-digit', minute: '2-digit' }) : '';
  const isoJour = (d) => { const x = new Date(d); x.setMinutes(x.getMinutes() - x.getTimezoneOffset()); return x.toISOString().slice(0, 10); };
  // Prix : le prix demandé par le propriétaire est la référence; le prix affiché plus bas = rabais
  const dollars = (n) => `${Number(n).toLocaleString('fr-CA')} $`;
  const rabais = (a) => (a.prix_proprio && a.prix_affiche && Number(a.prix_affiche) < Number(a.prix_proprio)) ? Number(a.prix_proprio) - Number(a.prix_affiche) : 0;
  const prix = (a) => rabais(a) ? `${dollars(a.prix_affiche)} / mois (rabais de ${dollars(rabais(a))})` : (a.prix_proprio ? `${dollars(a.prix_proprio)} / mois` : (a.prix_affiche ? `${dollars(a.prix_affiche)} / mois` : 'Prix à venir'));
  const prixHTML = (a) => rabais(a) ? `<span class="px-vieux">${esc(dollars(a.prix_proprio))}</span> <span class="px-rabais">${esc(dollars(a.prix_affiche))} / mois</span> <span class="badge b-bad">🔻 Rabais ${esc(dollars(rabais(a)))}</span>` : esc(prix(a));
  // Petites icônes pour les inclusions
  const ICONES = [[/ethernet|internet|wi-?fi|fibre/, '🌐'], [/stationnement|parking/, '🚗'], [/laveuse|secheuse|lessive/, '🧺'], [/chauff/, '🔥'], [/eau chaude/, '🚿'], [/electricit/, '⚡'],
    [/refrig|frigo|frigid/, '🧊'], [/cuisiniere|poele|four/, '🍳'], [/lave-vaisselle|lave vaisselle/, '🍽️'], [/clim|thermopompe/, '❄️'], [/rangement|casier|cabanon/, '📦'], [/balcon|cour|terrasse|patio/, '🌳'], [/meubl/, '🛋️'], [/deneig/, '❄️'], [/eau\b|eau froide/, '💧']];
  const inclusionsHTML = (a) => [a.inclusions, a.inclusions_autres].filter(Boolean).join(',').split(/[,;\n]+/).map(s => s.trim()).filter(Boolean)
    .map(s => { const n = norm(s); const ic = (ICONES.find(([re]) => re.test(n)) || [, '✔️'])[1]; return `<span class="incl">${ic} ${esc(s)}</span>`; }).join('');
  // Téléphone : 819-555-1234
  const fmtTel = (t) => { const d = String(t || '').replace(/\D/g, ''); if (d.length === 10) return `${d.slice(0, 3)}-${d.slice(3, 6)}-${d.slice(6)}`; if (d.length === 11 && d[0] === '1') return `1-${d.slice(1, 4)}-${d.slice(4, 7)}-${d.slice(7)}`; return String(t || ''); };
  const copier = (txt) => txt ? `<button type="button" class="cp" data-cp="${esc(txt)}" title="Copier">📋 Copier</button>` : '';
  const courrielHTML = (c) => c ? `<span class="mut">${esc(c)}</span> ${copier(c)}` : '';
  // Heure tapée : « 14 », « 14h », « 14h30 », « 1430 », « 2:30 » (après-midi si 1 à 6)
  const lireHeure = (s) => { const t = String(s || '').trim().toLowerCase().replace(/\s/g, ''); let m = t.match(/^(\d{1,2})(?:[h:]?(\d{2}))?h?$/); if (!m) { m = t.match(/^(\d{1,2})(\d{2})$/); } if (!m) return null; let h = +m[1], mi = +(m[2] || 0); if (h >= 1 && h <= 6) h += 12; if (h > 23 || mi > 59) return null; return `${String(h).padStart(2, '0')}:${String(mi).padStart(2, '0')}`; };
  // Date d'aménagement trop loin (plus de 2 mois) : surlignée
  const loin = (txt) => { const d = dateVoulue(txt); if (!d) return false; const l = new Date(); l.setMonth(l.getMonth() + 2); return d > l; };
  const amenagementHTML = (txt) => txt ? (loin(txt) ? `<mark class="loin">📅 Aménagement : ${esc(txt)} (plus de 2 mois)</mark>` : `📅 Aménagement : ${esc(txt)}`) : '';
  const isAdmin = () => S.roles.includes('admin');
  const msg = (el, txt, ok) => { el.innerHTML = `<div class="msg ${ok ? 'ok' : 'err'}">${esc(txt)}</div>`; };
  const val = (f, n) => { const e = f.elements[n]; if (!e) return null; const v = String(e.value).trim(); return v === '' ? null : v; };
  const telLien = (t) => t ? `<a class="tel" href="tel:${esc(String(t).replace(/[^\d+]/g, ''))}">📞 ${esc(fmtTel(t))}</a>` : '';
  const carte = (adr) => `https://www.google.com/maps/search/?api=1&query=${encodeURIComponent(adr + ', QC')}`;

  function modal(html) {
    const ov = document.createElement('div'); ov.className = 'ov';
    ov.innerHTML = `<div class="modal">${html}</div>`;
    ov.addEventListener('click', e => { if (e.target === ov) ov.remove(); });
    document.getElementById('bl-app').appendChild(ov);
    return ov;
  }
  const urlsSignees = {};
  async function signer(paths) {
    const manque = [...new Set(paths.filter(p => p && !urlsSignees[p]))];
    if (manque.length) { const { data } = await sb.storage.from('photos').createSignedUrls(manque, 3600); (data || []).forEach(d => { if (d.signedUrl) urlsSignees[d.path] = d.signedUrl; }); }
    return paths.map(p => urlsSignees[p]).filter(Boolean);
  }

  // ---------- Photos et annonces du site web (WooCommerce) ----------
  async function produits() {
    if (S.produits) return S.produits;
    S.produits = [];
    try { for (let p = 1; p <= 10; p++) { const lot = await (await fetch(`/wp-json/wc/store/v1/products?per_page=100&page=${p}`)).json(); if (!Array.isArray(lot) || !lot.length) break; S.produits.push(...lot); if (lot.length < 100) break; } } catch { /* site injoignable */ }
    return S.produits;
  }
  function produitDe(a) {
    const civ = (String(a.numero || '').match(/\d+/) || [''])[0];
    const app = (String(a.numero || '').match(/(?:app\.?|apt\.?|#|ch\.?|,|-)\s*([0-9]+)/i) || [])[1];
    const mots = norm(a.rue).split(/[^a-z0-9]+/).filter(m => m.length > 1 && !['rue', 'avenue', 'boulevard', 'chemin', 'nord', 'sud', 'est', 'ouest', 'de', 'des', 'du', 'la', 'le', 'les', 'sous', 'sol'].includes(m));
    if (a.lien_annonce) { const sans = (u) => String(u || '').replace(/\/+$/, ''); const p = (S.produits || []).find(x => sans(x.permalink) === sans(a.lien_annonce)); if (p) return p; }
    let best = null, bs = 0;
    for (const p of S.produits || []) {
      const n = ' ' + norm(String(p.name || '').replace(/&#8211;/g, ' ')).replace(/[^a-z0-9]+/g, ' ') + ' ';
      if (!civ || !n.includes(` ${civ} `)) continue;
      if (!mots.length || !mots.some(m => n.includes(` ${m}`))) continue;
      let s = 1 + mots.filter(m => n.includes(m)).length * 2;
      if (app && n.includes(` ${app} `)) s += 3;
      if (s > bs) { bs = s; best = p; }
    }
    return bs >= 3 ? best : null;
  }
  const photoPrincipale = (a) => { const p = produitDe(a); return p && p.images && p.images[0] ? (p.images[0].thumbnail || p.images[0].src) : null; };
  const lienAnnonce = (a) => a.lien_annonce || (produitDe(a) || {}).permalink || '';

  // ---------- Connexion ----------
  function ecranConnexion(erreur) {
    document.getElementById('bl-esp').innerHTML = ''; document.getElementById('bl-user').innerHTML = '';
    montrerLocation();
    root.innerHTML = `<div class="card" style="max-width:440px;margin:30px auto"><h2>Connexion</h2>
      <form id="f-login"><label>Courriel</label><input name="email" type="email" required autocomplete="username">
      <label>Mot de passe</label><input name="pwd" type="password" required autocomplete="current-password">
      <div class="btns"><button class="btn">Se connecter</button><button type="button" class="btn sec" id="oubli">Mot de passe oublié</button></div></form>
      <div id="m"></div></div>`;
    const m = root.querySelector('#m'); if (erreur) msg(m, erreur);
    root.querySelector('#f-login').onsubmit = async (e) => {
      e.preventDefault();
      const { error } = await sb.auth.signInWithPassword({ email: val(e.target, 'email'), password: e.target.elements.pwd.value });
      if (error) msg(m, 'Connexion refusée : vérifiez le courriel et le mot de passe.');
    };
    root.querySelector('#oubli').onclick = async () => {
      const email = val(root.querySelector('#f-login'), 'email');
      if (!email) return msg(m, 'Entrez votre courriel d\'abord.');
      const { error } = await sb.auth.resetPasswordForEmail(email, { redirectTo: location.href.split('#')[0] });
      error ? msg(m, error.message) : msg(m, 'Un courriel de réinitialisation a été envoyé.', true);
    };
  }
  function ecranMotDePasse() {
    root.innerHTML = `<div class="card" style="max-width:440px;margin:30px auto"><h2>Choisissez votre mot de passe</h2>
      <form id="f-pwd"><label>Nouveau mot de passe (10 caractères minimum)</label><input name="pwd" type="password" minlength="10" required autocomplete="new-password">
      <div class="btns"><button class="btn">Enregistrer</button></div></form><div id="m"></div></div>`;
    root.querySelector('#f-pwd').onsubmit = async (e) => {
      e.preventDefault();
      const { error } = await sb.auth.updateUser({ password: e.target.elements.pwd.value });
      if (error) return msg(root.querySelector('#m'), error.message);
      history.replaceState(null, '', location.href.split('#')[0]);
      demarrer();
    };
  }

  // ---------- Espaces (selon le rôle) ----------
  const ESPACES = [
    ['location', '🏠 Location', r => r.includes('admin') || r.includes('agent')],
    ['maintenance', '🔧 Maintenance', r => r.includes('admin') || r.includes('maintenance')],
    ['gestion', '📊 Gestion', r => r.includes('admin')],
    ['proprietaire', '👤 Propriétaire', r => r.includes('admin') || r.includes('proprietaire')],
  ];
  async function demarrer() {
    const { data: { user } } = await sb.auth.getUser();
    if (!user) return ecranConnexion();
    S.user = user;
    const { data: roles } = await sb.from('roles_utilisateurs').select('role').eq('utilisateur_id', user.id);
    S.roles = (roles || []).map(r => r.role);
    const { data: moi } = await sb.from('profils').select('nom').eq('id', user.id).maybeSingle();
    S.monNom = (moi && moi.nom) || user.email;
    document.getElementById('bl-user').innerHTML = `${esc(S.monNom)} · <a href="#" id="out">Se déconnecter</a>`;
    document.getElementById('out').onclick = (e) => { e.preventDefault(); sb.auth.signOut(); };
    S.espaces = ESPACES.filter(([, , ok]) => ok(S.roles));
    if (!S.espaces.length) { root.innerHTML = '<div class="msg err">Votre compte n\'a pas encore d\'accès. Contactez l\'administration.</div>'; return; }
    let pref = null; try { pref = localStorage.getItem('bl-espace'); } catch {}
    if (/^#(temps|travaux|billets|resume|facturation|nouveau|alertes|urgences|paye)$/.test(location.hash)) pref = 'maintenance';
    choisirEspace(S.espaces.some(e => e[0] === pref) ? pref : S.espaces[0][0]);
  }
  function choisirEspace(k) {
    S.esp = k; try { localStorage.setItem('bl-espace', k); } catch {}
    const nav = document.getElementById('bl-esp');
    nav.innerHTML = S.espaces.length > 1 ? S.espaces.map(([id, l]) => `<button data-esp="${id}" class="${id === k ? 'on' : ''}">${l}</button>`).join('') : '';
    nav.querySelectorAll('[data-esp]').forEach(b => b.onclick = () => choisirEspace(b.dataset.esp));
    if (k === 'maintenance') return montrerMaintenance();
    montrerLocation();
    if (k === 'location') return coquille();
    root.innerHTML = `<div class="card bientot"><h2>${k === 'gestion' ? 'Gestion' : 'Propriétaire'}</h2><p>Cette section est en préparation. Elle apparaîtra ici quand elle sera prête.</p></div>`;
  }
  function montrerLocation() { const m = document.getElementById('mnt'); if (m) m.hidden = true; root.hidden = false; }
  function montrerMaintenance() {
    const m = document.getElementById('mnt');
    root.hidden = true; root.innerHTML = '';
    if (!m || !window.BLMaintStart) { root.hidden = false; root.innerHTML = '<div class="msg err">Le module de maintenance n\'est pas chargé.</div>'; return; }
    m.hidden = false;
    if (!S.maintLance) { S.maintLance = true; window.BLMaintStart({ sb, user: S.user, isAdmin: isAdmin(), nom: S.monNom }); }
    else if (window.BLMaintRefresh) window.BLMaintRefresh();
  }

  // ---------- Location ----------
  function coquille() {
    const tabs = [['journee', '📅 Ma journée'], ['suivi', '🔔 Suivi'], ['dvisites', '📞 Demandes de visite'], ['visites', '🗓️ Planifier une visite'], ['logements', '🏠 Logements à louer'], ['avenir', '🔜 Logements à venir'], ['demandes', '📄 Demandes de location'], ['attente', '⏳ Liste d\'attente'], ['pancartes', '🪧 Pancartes']];
    if (isAdmin()) tabs.push(['stats', '📈 Statistiques'], ['ajout', '➕ Ajouter un logement']);
    if (!tabs.some(t => t[0] === S.tab)) S.tab = 'journee';
    root.innerHTML = `<div class="tabs">${tabs.map(([k, l]) => `<button data-t="${k}" class="${S.tab === k ? 'on' : ''}">${l}</button>`).join('')}</div><div id="vue"></div>`;
    root.querySelectorAll('.tabs button').forEach(b => b.onclick = () => { S.tab = b.dataset.t; if (b.dataset.t === 'visites') { S.demandePre = null; S.annoncePre = null; } coquille(); });
    ({ journee: vueJournee, suivi: vueSuivi, dvisites: vueDemandesVisite, logements: vueLogements, avenir: vueAVenir, visites: vueVisites, pancartes: vuePancartes, demandes: vueDemandes, attente: vueAttente, stats: vueStats, ajout: () => { const e = S.edition; S.edition = null; vueAjout(e); } })[S.tab]();
  }
  const vue = () => root.querySelector('#vue');

  async function chargerAnnonces() {
    const [{ data, error }] = await Promise.all([
      sb.from('annonces').select('*, immeubles(id, numero, rue, ville)'),
      produits()
    ]);
    if (error) throw error; S.annonces = (data || []).sort(triAnn); return S.annonces;
  }
  async function chargerNoms() {
    if (!isAdmin() || Object.keys(S.noms).length) return;
    const { data } = await sb.from('profils').select('id, nom, courriel');
    (data || []).forEach(p => { S.noms[p.id] = p.nom || p.courriel; });
  }

  // ----- Panneau des clés (boîte à clés + code du logement) -----
  async function panneauCles(a, el) {
    el.innerHTML = '<div class="mut">Chargement des clés…</div>';
    const [{ data: boites }, { data: codes }] = await Promise.all([
      a.immeuble_id ? sb.from('boites_a_cles').select('id, emplacement, cles_contenues, photos').eq('immeuble_id', a.immeuble_id) : Promise.resolve({ data: [] }),
      sb.from('annonce_codes').select('annonce_id').eq('annonce_id', a.id)
    ]);
    const aCode = (codes || []).length > 0;
    const photos = await signer((boites || []).flatMap(b => b.photos || []));
    el.innerHTML = `<div class="cles">
      <div class="small"><b>Clé du logement :</b> ${esc(a.acces_cles || '—')}${a.lieu_boite_cles ? ' — ' + esc(a.lieu_boite_cles) : ''}</div>
      ${(boites || []).map(b => `<div style="margin-top:10px"><b>Boîte à clés :</b> ${esc(b.emplacement || 'Emplacement non précisé')}${b.cles_contenues ? ` <span class="mut">(${esc(b.cles_contenues)})</span>` : ''}
        <div class="btns" style="margin-top:6px"><button class="btn small" data-vc="${b.id}">🔑 Afficher le code de la boîte</button></div><div data-code="${b.id}"></div>
        ${(b.photos || []).length ? `<div class="gal" style="margin-top:8px">${(b.photos || []).map(p => urlsSignees[p] ? `<a href="${esc(urlsSignees[p])}" target="_blank" rel="noopener"><img src="${esc(urlsSignees[p])}" alt="Emplacement de la boîte à clés" loading="lazy"></a>` : '').join('')}</div>` : '<div class="mut">Aucune photo de la boîte.</div>'}</div>`).join('') || '<div class="mut" style="margin-top:8px">Aucune boîte à clés enregistrée pour cet immeuble.</div>'}
      ${aCode ? `<div style="margin-top:10px"><button class="btn small sec" id="vca">Code propre au logement</button><div id="code-log"></div></div>` : ''}
    </div>`;
    el.querySelectorAll('[data-vc]').forEach(btn => btn.onclick = async () => {
      const { data, error } = await sb.rpc('voir_code', { p_boite: btn.dataset.vc });
      el.querySelector(`[data-code="${btn.dataset.vc}"]`).innerHTML = error ? `<div class="msg err">${esc(error.message)}</div>` : `<div style="margin-top:6px"><span class="code">${esc(data || 'aucun code')}</span></div>`;
      btn.remove();
    });
    const vca = el.querySelector('#vca');
    if (vca) vca.onclick = async () => {
      const { data, error } = await sb.rpc('voir_code_annonce', { p_annonce: a.id });
      el.querySelector('#code-log').innerHTML = error ? `<div class="msg err">${esc(error.message)}</div>` : `<div style="margin-top:6px"><span class="code">${esc(data || 'aucun code')}</span></div>`;
      vca.remove();
    };
  }

  // ----- Ma journée -----
  async function vueJournee() {
    if (!S.jour) S.jour = isoJour(new Date());
    vue().innerHTML = '<div class="mut">Chargement…</div>';
    if (!S.annonces.length) await chargerAnnonces();
    await chargerNoms();
    const d0 = new Date(S.jour + 'T00:00:00'), d1 = new Date(d0); d1.setDate(d1.getDate() + 1);
    let q = sb.from('visites').select('*').gte('debut', d0.toISOString()).lt('debut', d1.toISOString()).order('debut');
    if (!isAdmin()) q = q.eq('agent_id', S.user.id);
    const { data: visites, error } = await q;
    const parId = Object.fromEntries(S.annonces.map(a => [a.id, a]));
    const locs = {};
    await Promise.all([...new Set((visites || []).map(v => v.annonce_id).filter(Boolean))].map(async id => { const { data } = await sb.rpc('locataires_annonce', { p_annonce: id }); locs[id] = data || []; }));
    const decale = (n) => { const d = new Date(S.jour + 'T12:00:00'); d.setDate(d.getDate() + n); S.jour = isoJour(d); vueJournee(); };
    const titre = new Date(S.jour + 'T12:00:00').toLocaleDateString('fr-CA', { weekday: 'long', day: 'numeric', month: 'long' });
    const actives = (visites || []).filter(v => !['annulee'].includes(v.statut));
    vue().innerHTML = `<div style="display:flex;align-items:center;gap:8px;flex-wrap:wrap;margin-bottom:12px">
        <h2 style="margin:0;flex:1 1 auto">${S.jour === isoJour(new Date()) ? 'Ma journée' : 'Journée'} · ${esc(titre)}</h2>
        <button class="btn small sec" id="j-prec">‹ Veille</button><input type="date" id="j-date" value="${S.jour}" style="width:auto"><button class="btn small sec" id="j-suiv">Lendemain ›</button></div>
      ${isAdmin() ? '<p class="mut" style="margin-top:-6px">Vous voyez les visites de toute l\'équipe.</p>' : ''}
      ${error ? `<div class="msg err">${esc(error.message)}</div>` : ''}
      <p class="mut">${actives.length} visite${actives.length > 1 ? 's' : ''} prévue${actives.length > 1 ? 's' : ''}.</p>
      ${(visites || []).map(v => {
        const a = parId[v.annonce_id] || null; const l = locs[v.annonce_id] || [];
        const conf = v.confirmee_le ? `<span class="badge b-ok">✓ Confirmée par courriel ${esc(fmtH(v.confirmee_le) ? 'le ' + fmtCourt(v.confirmee_le) : '')}</span>` : v.statut === 'annulee' ? '<span class="badge b-bad">Annulée</span>' : v.invitation_envoyee_le ? '<span class="badge b-warn">Pas encore confirmée</span>' : '<span class="badge b-warn">Invitation en cours d\'envoi</span>';
        return `<div class="card bar" style="--bc:${v.confirmee_le ? '#037f4c' : v.statut === 'annulee' || v.statut === 'absent' ? '#bb3354' : '#f2b705'}"><div class="vis">
          <div><div class="heure num">${esc(fmtH(v.debut))}</div><div class="mut">${v.fin ? Math.round((new Date(v.fin) - new Date(v.debut)) / 60000) + ' min' : ''}</div></div>
          <div><div style="display:flex;justify-content:space-between;gap:8px;flex-wrap:wrap"><b style="font-family:var(--fh);font-size:1.08rem">${esc(a ? libelle(a) : 'Logement à préciser')}</b>${badge(v.statut, STATUTS_VISITE)}</div>
            ${a ? `<div class="mut">${esc(a.grandeur || '')} · <a href="${esc(carte(adresseComplete(a)))}" target="_blank" rel="noopener">Itinéraire</a></div>` : ''}
            ${isAdmin() && v.agent_id ? `<div class="mut">Agent : ${esc(S.noms[v.agent_id] || '…')}</div>` : ''}
            <div style="margin-top:8px"><b>${esc(v.prospect_nom)}</b> ${telLien(v.prospect_telephone)}<div class="mut">${esc(v.prospect_courriel || '')}</div></div>
            <div style="margin-top:6px">${conf}</div>
            ${l.length ? `<div class="card" style="margin:10px 0 0;background:var(--s2)"><b>Logement habité :</b> ${l.map(x => `${esc(x.nom)} ${telLien(x.telephone)}`).join(' · ')}
              <div class="mut">${v.locataire_avis_envoye_le ? `Avis de visite envoyé par courriel le ${esc(fmtCourt(v.locataire_avis_envoye_le))}` : 'Avis de visite au locataire en cours d\'envoi'}</div>
              <div style="margin-top:6px">${v.appel_locataire_statut ? badge(v.appel_locataire_statut, APPEL) : '<span class="badge b-warn">Appel au locataire à faire</span>'}</div>
              <div class="btns" style="margin-top:6px">${Object.entries(APPEL).map(([k, [lab]]) => `<button class="btn small ${v.appel_locataire_statut === k ? '' : 'sec'}" data-appel="${k}" data-v="${v.id}">${esc(k === 'impossible' ? 'Impossible de laisser un message' : lab)}</button>`).join('')}</div></div>` : ''}
            <div class="btns">${a ? `<button class="btn small" data-cles="${v.id}" data-a="${a.id}">🔑 Code de la boîte à clés</button>` : ''}
              ${['faite', 'absent', 'annulee'].map(s => `<button class="btn small sec" data-st="${s}" data-v="${v.id}">${esc(STATUTS_VISITE[s][0])}</button>`).join('')}</div>
            <div data-pc="${v.id}"></div></div></div></div>`;
      }).join('') || `<div class="card bientot"><h3>Aucune visite ce jour-là</h3><p><button class="btn" id="j-plan">Planifier une visite</button></p></div>`}`;
    vue().querySelector('#j-prec').onclick = () => decale(-1);
    vue().querySelector('#j-suiv').onclick = () => decale(1);
    vue().querySelector('#j-date').onchange = (e) => { if (e.target.value) { S.jour = e.target.value; vueJournee(); } };
    const jp = vue().querySelector('#j-plan'); if (jp) jp.onclick = () => { S.tab = 'visites'; coquille(); };
    vue().querySelectorAll('[data-cles]').forEach(b => b.onclick = () => { const el = vue().querySelector(`[data-pc="${b.dataset.cles}"]`); if (el.innerHTML) { el.innerHTML = ''; return; } panneauCles(parId[b.dataset.a], el); });
    vue().querySelectorAll('[data-st]').forEach(b => b.onclick = async () => { await sb.from('visites').update({ statut: b.dataset.st }).eq('id', b.dataset.v); vueJournee(); });
    vue().querySelectorAll('[data-appel]').forEach(b => b.onclick = async () => {
      const { error } = await sb.from('visites').update({ appel_locataire_statut: b.dataset.appel, appel_locataire_le: new Date().toISOString(), rappel_appel_envoye_le: null }).eq('id', b.dataset.v);
      if (error) alert(error.message); vueJournee();
    });
  }

  // ----- Logements à louer -----
  async function vueLogements() {
    vue().innerHTML = '<div class="mut">Chargement…</div>';
    await chargerAnnonces();
    const q = norm(S.q);
    const liste = S.annonces.filter(a => (S.filtre === 'tous' || (S.filtre === 'actifs' ? ACTIFS.includes(a.statut) : a.statut === S.filtre)) && (!q || norm(libelle(a) + ' ' + a.rue + ' ' + a.numero + ' ' + (a.grandeur || '')).includes(q)));
    const carteLg = (a) => { const ph = photoPrincipale(a); return `<div class="card lg click" data-id="${a.id}">
        <div class="ph ${ph ? '' : 'vide'}" ${ph ? `style="background-image:url('${esc(ph)}')"` : ''}>${badge(a.statut, STATUTS_ANNONCE)}${ph ? '' : '<span>Pas encore de photo sur le site</span>'}</div>
        <div class="in"><div class="ad">${esc(libelle(a))}</div><div class="px">${esc(a.grandeur || '')}${a.grandeur ? ' · ' : ''}${prixHTML(a)}</div>
        <div class="mut">Disponible : ${esc(fmtDate(a.disponibilite) || '—')}</div>${(a.inclusions || a.inclusions_autres) ? `<div class="incls">${inclusionsHTML(a)}</div>` : ''}</div></div>`; };
    const groupes = ORDRE_ANNONCE.map(st => [st, liste.filter(a => a.statut === st)]).filter(([, l]) => l.length);
    vue().innerHTML = `<div class="chips">${[['actifs', 'À louer'], ['affiche', 'Affichés / dispo'], ['en_enquete', 'En enquête'], ['loue', 'Loués'], ['tous', 'Tous']].map(([k, l]) => `<button class="chip ${S.filtre === k ? 'on' : ''}" data-f="${k}">${l}</button>`).join('')}</div>
      <input id="lg-q" type="search" placeholder="🔍 Rechercher : nom de rue, numéro, grandeur…" value="${esc(S.q)}" style="margin-bottom:14px">
      ${groupes.map(([st, l]) => `<h3 class="grp-titre">${badge(st, STATUTS_ANNONCE)} <span class="mut">${l.length}</span></h3><div class="grid">${l.map(carteLg).join('')}</div>`).join('') || '<div class="mut">Aucun logement.</div>'}`;
    vue().querySelectorAll('[data-f]').forEach(b => b.onclick = () => { S.filtre = b.dataset.f; vueLogements(); });
    const qi = vue().querySelector('#lg-q'); qi.oninput = () => { S.q = qi.value; clearTimeout(S.tq); S.tq = setTimeout(() => { vueLogements().then(() => { const n = vue().querySelector('#lg-q'); n.focus(); n.setSelectionRange(n.value.length, n.value.length); }); }, 250); };
    vue().querySelectorAll('[data-id]').forEach(c => c.onclick = () => ficheAnnonce(S.annonces.find(a => a.id === c.dataset.id)));
  }

  async function ficheAnnonce(a) {
    const imm = a.immeubles, p = produitDe(a), lien = lienAnnonce(a);
    const imgs = (p && p.images) || [];
    const [{ data: panc }, { data: locs }] = await Promise.all([
      sb.from('pancartes').select('*').eq('annonce_id', a.id).is('retiree_le', null),
      sb.rpc('locataires_annonce', { p_annonce: a.id })
    ]);
    const lignes = [
      ['Adresse', adresseComplete(a)], ['Disponibilité', fmtDate(a.disponibilite)], ['Grandeur', a.grandeur],
      ['Prix demandé par le propriétaire', a.prix_proprio ? dollars(a.prix_proprio) : ''], ['Prix affiché avec rabais', rabais(a) ? `${dollars(a.prix_affiche)} (rabais de ${dollars(rabais(a))})` : ''],
      ['Superficie (pi²)', a.pieds_carres], ['Étage', a.etage], ['Marches', a.marches], ['Animaux', a.animaux], ['Dépôt pour chien', a.depot_chien],
      ['Stationnements inclus', a.nb_stationnements], ['Emplacement stationnement', a.emplacement_stationnement], ['Stationnement supplémentaire', a.stationnement_supplementaire],
      ['Électros possibles', a.electro_possible], ['Surplus électros', a.surplus_electro], ['Frais inclusions extra', a.frais_inclusions_extra],
      ['Habité', a.habite == null ? '' : (a.habite ? 'Oui' : 'Non')], ['Départ du locataire actuel', fmtDate(a.depart_locataire)], ['Qui contacter pour visiter', a.coordonnees_contact],
      ['Critères de sélection', a.criteres_selection], ['Candidat sans crédit', a.accepte_sans_credit], ['Locataires OMH', a.accepte_omh],
      ['Autres infos', a.autres_infos], ['Commentaires', a.commentaires]
    ].filter(([, v]) => v != null && v !== '');
    const ov = modal(`<div style="display:flex;justify-content:space-between;gap:8px;align-items:flex-start"><div><h2 style="margin-bottom:2px">${esc(libelle(a))}</h2><div style="color:var(--pri);font-weight:700;font-size:1.1rem">${esc(a.grandeur || '')} · ${prixHTML(a)}</div></div><div>${badge(a.statut, STATUTS_ANNONCE)}</div></div>
      ${(a.inclusions || a.inclusions_autres) ? `<h3>Inclusions</h3><div class="incls">${inclusionsHTML(a)}</div>` : ''}
      <h3>Photos</h3>
      ${imgs.length ? `<img class="hero" src="${esc(imgs[0].src)}" alt="${esc(libelle(a))}">${imgs.length > 1 ? `<div class="gal">${imgs.slice(1).map(i => `<a href="${esc(i.src)}" target="_blank" rel="noopener"><img src="${esc(i.thumbnail || i.src)}" alt="" loading="lazy"></a>`).join('')}</div>` : ''}` : '<div class="mut">Aucune photo trouvée sur le site pour ce logement.</div>'}
      ${lien ? `<div class="btns"><a class="btn sec" href="${esc(lien)}" target="_blank" rel="noopener">Voir l'annonce et toutes les photos sur le site ↗</a></div>` : ''}
      <h3>Pour y aller : accès et clés</h3><div id="pc"></div>
      ${(locs || []).length ? `<h3>Locataire en place</h3>${locs.map(l => `<div>${esc(l.nom)} ${telLien(l.telephone)} <span class="mut">${esc(l.courriel || '')}</span></div>`).join('')}<p class="mut">Un avis de visite lui est envoyé automatiquement par courriel. Appelez-le aussi pour confirmer 24 h à l'avance.</p>` : ''}
      <h3>🪧 Pancartes</h3><div>${(panc || []).length ? panc.map(x => `<div style="display:flex;justify-content:space-between;gap:8px;align-items:center;padding:4px 0">${x.nombre} × ${esc(x.emplacement)} <span class="mut">(depuis le ${esc(fmtDate(x.posee_le))})</span><button class="btn small sec" data-pret="${x.id}">Marquer retirée</button></div>`).join('') : '<span class="mut">Aucune pancarte posée.</span>'}</div>
      <div class="btns"><button class="btn small sec" id="pa-add">➕ Il y a une pancarte sur ce logement</button></div>
      <h3>Détails</h3><div class="kv">${lignes.map(([k, v]) => `<div>${esc(k)}</div><div>${esc(v)}</div>`).join('')}</div>
      ${/^oui/i.test(a.accepte_omh || '') ? grilleOMH(a.grandeur, a.prix_proprio || a.prix_affiche) : ''}
      ${isAdmin() ? `<div class="btns"><button class="btn" id="ad-modif">✏️ Modifier toutes les informations</button></div>${manquants(a).length ? `<div class="msg err">À compléter : ${esc(manquants(a).join(', '))}</div>` : ''}` : ''}
      ${isAdmin() ? `<h3>Administration</h3><div class="row"><div><label>Lien vers l'annonce (si différent)</label><input id="ad-lien" value="${esc(a.lien_annonce || '')}" placeholder="${esc((p || {}).permalink || 'https://lesgestionsbestlife.com/produit/…')}"></div>
        <div><label>Logement de la base (pour aviser le locataire)</label><select id="ad-log"><option value="">— Choisir —</option></select></div></div><div class="btns"><button class="btn small sec" id="ad-save">Enregistrer</button></div>` : ''}
      <h3>Changer le statut</h3><div class="row"><select id="st">${Object.entries(STATUTS_ANNONCE).map(([k, [l]]) => `<option value="${k}" ${k === a.statut ? 'selected' : ''}>${l}</option>`).join('')}</select><button class="btn" id="save-st">Enregistrer le statut</button></div>
      <div id="m"></div>
      <div class="btns"><button class="btn" id="planif">Planifier une visite</button><button class="btn sec" id="ferme">Fermer</button></div>`);
    const m = ov.querySelector('#m');
    panneauCles(a, ov.querySelector('#pc'));
    ov.querySelector('#ferme').onclick = () => ov.remove();
    ov.querySelector('#planif').onclick = () => { ov.remove(); S.tab = 'visites'; S.demandePre = null; S.annoncePre = a.id; coquille(); };
    const adm = ov.querySelector('#ad-modif'); if (adm) adm.onclick = () => { ov.remove(); S.edition = a; S.tab = 'ajout'; coquille(); };
    ov.querySelector('#pa-add').onclick = async () => { ov.remove(); await questionPancartes(a); ficheAnnonce(a); };
    ov.querySelectorAll('[data-pret]').forEach(b => b.onclick = async () => { await sb.from('pancartes').update({ retiree_le: new Date().toISOString().slice(0, 10), retiree_par: S.user.id }).eq('id', b.dataset.pret); ov.remove(); ficheAnnonce(a); });
    if (isAdmin()) {
      const sel = ov.querySelector('#ad-log');
      if (a.immeuble_id) sb.from('logements').select('id, numero').eq('immeuble_id', a.immeuble_id).order('numero').then(({ data }) => {
        sel.innerHTML += (data || []).map(l => `<option value="${l.id}" ${l.id === a.logement_id ? 'selected' : ''}>App. ${esc(l.numero)}</option>`).join('');
      });
      ov.querySelector('#ad-save').onclick = async () => {
        const { error } = await sb.from('annonces').update({ lien_annonce: ov.querySelector('#ad-lien').value.trim() || null, logement_id: sel.value || null }).eq('id', a.id);
        error ? msg(m, error.message) : msg(m, 'Enregistré.', true);
      };
    }
    ov.querySelector('#save-st').onclick = async () => {
      const nouveau = ov.querySelector('#st').value;
      if (nouveau === a.statut) return;
      if (nouveau === 'affiche') { const ok = await questionPancartes(a); if (!ok) return; }
      if (nouveau === 'loue' && (panc || []).length) { const ok = await questionRetrait(a, panc); if (!ok) return; }
      const { error } = await sb.from('annonces').update({ statut: nouveau }).eq('id', a.id);
      if (error) return msg(m, error.message);
      ov.remove(); vueLogements();
    };
  }

  function questionPancartes(a) {
    return new Promise(resolve => {
      const ov = modal(`<h2>Pancartes « À louer » — ${esc(libelle(a))}</h2>
        <p>Combien de pancartes avez-vous posées sur l'immeuble, et où ?</p>
        <form id="fp"><div class="row"><div><label>Nombre de pancartes</label><input name="n" type="number" min="0" value="1" required></div>
        <div><label>Emplacement(s)</label><input name="e" placeholder="ex. gazon avant, fenêtre de l'app 6"></div></div>
        <div class="btns"><button class="btn">Enregistrer et afficher</button><button type="button" class="btn sec" id="ann">Annuler</button></div></form><div id="m"></div>`);
      ov.querySelector('#ann').onclick = () => { ov.remove(); resolve(false); };
      ov.querySelector('#fp').onsubmit = async (e) => {
        e.preventDefault();
        const n = parseInt(e.target.elements.n.value, 10);
        if (n > 0) {
          const emp = val(e.target, 'e');
          if (!emp) return msg(ov.querySelector('#m'), 'Indiquez où les pancartes ont été posées.');
          const { error } = await sb.from('pancartes').insert({ annonce_id: a.id, immeuble_id: a.immeuble_id, adresse: a.immeuble_id ? null : `${a.numero} ${a.rue}`, nombre: n, emplacement: emp });
          if (error) return msg(ov.querySelector('#m'), error.message);
        }
        ov.remove(); resolve(true);
      };
    });
  }
  function questionRetrait(a, panc) {
    return new Promise(resolve => {
      const total = panc.reduce((s, p) => s + p.nombre, 0);
      const ov = modal(`<h2>Logement loué — ${esc(libelle(a))}</h2>
        <p>Il y a <strong>${total} pancarte(s)</strong> enregistrée(s) pour ce logement : ${panc.map(p => esc(p.emplacement)).join(', ')}.</p>
        <p>Avez-vous retiré les pancartes ?</p>
        <div class="btns"><button class="btn" id="oui">Oui, retirées</button><button class="btn sec" id="non">Pas encore</button><button class="btn sec" id="ann">Annuler</button></div>`);
      ov.querySelector('#oui').onclick = async () => {
        await sb.from('pancartes').update({ retiree_le: new Date().toISOString().slice(0, 10), retiree_par: S.user.id }).in('id', panc.map(p => p.id));
        ov.remove(); resolve(true);
      };
      ov.querySelector('#non').onclick = () => { ov.remove(); resolve(true); };
      ov.querySelector('#ann').onclick = () => { ov.remove(); resolve(false); };
    });
  }

  // ----- Planifier / visites -----
  function lienGoogle(v, a) {
    const f = (d) => new Date(d).toISOString().replace(/[-:]/g, '').replace(/\.\d{3}/, '');
    const p = new URLSearchParams({ action: 'TEMPLATE', text: `Visite — ${libelle(a)} — ${v.prospect_nom}`, dates: `${f(v.debut)}/${f(v.fin)}`,
      details: `Visite du logement ${adresseComplete(a)}.\nProspect : ${v.prospect_nom}, ${v.prospect_telephone || ''}, ${v.prospect_courriel || ''}\n\nLes Gestions Bestlife`, location: adresseComplete(a) + ', QC' });
    return 'https://calendar.google.com/calendar/render?' + p.toString();
  }
  const HEURES = (() => { const h = []; for (let m = 7 * 60; m <= 21 * 60; m += 15) h.push(`${String(Math.floor(m / 60)).padStart(2, '0')}:${String(m % 60).padStart(2, '0')}`); return h; })();
  const optionsLogements = (liste, sel) => `<option value="">— Choisir un logement (${liste.length}) —</option>` + liste.map(a => `<option value="${a.id}" ${sel === a.id ? 'selected' : ''}>${esc(libelle(a))} · ${esc(a.grandeur || '')} · ${esc(STATUTS_ANNONCE[a.statut][0])}</option>`).join('');

  async function vueVisites() {
    vue().innerHTML = '<div class="mut">Chargement…</div>';
    await chargerAnnonces(); await chargerNoms();
    const actives = S.annonces.filter(a => ACTIFS.includes(a.statut));
    const depuis = new Date(); depuis.setDate(depuis.getDate() - 7);
    let q = sb.from('visites').select('*').gte('debut', depuis.toISOString()).order('debut');
    if (!isAdmin()) q = q.eq('agent_id', S.user.id);
    const [{ data: visites, error }, { data: demandes }] = await Promise.all([q, sb.from('visites').select('*').eq('statut', 'demandee').is('debut', null).order('cree_le')]);
    const parId = Object.fromEntries(S.annonces.map(a => [a.id, a]));
    const pre = S.demandePre ? (demandes || []).find(d => d.id === S.demandePre) : null;
    const aTraiter = (demandes || []).filter(d => !SUIVI_FINIS.includes(d.suivi_statut)).length;
    vue().innerHTML = `
      ${aTraiter && !pre ? `<div class="msg info">📞 ${aTraiter} demande${aTraiter > 1 ? 's' : ''} de visite à traiter. <a href="#" id="v-vers-dem"><b>Voir l'onglet « Demandes de visite » →</b></a></div>` : ''}
      <div class="card"><h2>${pre ? 'Planifier la demande de ' + esc(pre.prospect_nom) : 'Planifier une visite'}</h2>
      <form id="fv">
        <label>Logement</label><input type="search" id="v-q" placeholder="🔍 Rechercher : nom de rue ou numéro" autocomplete="off" style="border-radius:6px 6px 0 0;background:var(--s2)">
        <select name="annonce" id="v-sel" required style="border-radius:0 0 6px 6px;border-top:0">${optionsLogements(actives, S.annoncePre || (pre && pre.annonce_id))}</select>
        <div id="v-loc"></div>
        <div class="row"><div><label>Nom du prospect</label><input name="nom" required value="${esc(pre ? pre.prospect_nom : '')}"></div><div><label>Téléphone</label><input name="tel" type="tel" required value="${esc(pre ? pre.prospect_telephone : '')}"></div></div>
        <label>Courriel</label><input name="courriel" type="email" required value="${esc(pre ? pre.prospect_courriel : '')}">
        <div class="row"><div><label>Date de la visite</label><input name="date" type="date" required min="${isoJour(new Date())}" value="${isoJour(new Date())}"></div>
          <div><label>Heure (visite de ${DUREE_VISITE_MIN} minutes) — tapez-la, ex. 14h30</label><input name="heure" required list="v-heures" placeholder="ex. 14h30" autocomplete="off" inputmode="numeric"><datalist id="v-heures">${HEURES.map(h => `<option value="${h}">`).join('')}</datalist></div></div>
        <label>Notes (optionnel)</label><textarea name="notes">${esc(pre ? (pre.specifications || '') : '')}</textarea>
        <div class="btns"><button class="btn">Enregistrer la visite</button>${pre ? '<button type="button" class="btn sec" id="v-annule">Annuler</button>' : ''}</div>
      </form><div id="m"></div></div>
      <div class="card"><h2>Visites ${isAdmin() ? 'de toute l\'équipe' : 'à mon nom'}</h2>${error ? `<div class="msg err">${esc(error.message)}</div>` : ''}
      <div class="tbl"><table><thead><tr><th>Quand</th><th>Logement</th><th>Prospect</th>${isAdmin() ? '<th>Agent</th>' : ''}<th>Statut</th><th></th></tr></thead><tbody>
      ${(visites || []).map(v => { const a = parId[v.annonce_id] || {}; return `<tr><td class="num">${esc(fmtDT(v.debut))}</td><td>${esc(libelle(a))}</td>
        <td>${esc(v.prospect_nom)}<div class="mut">${esc(fmtTel(v.prospect_telephone))}</div></td>${isAdmin() ? `<td>${esc(S.noms[v.agent_id] || '')}</td>` : ''}
        <td>${badge(v.statut, STATUTS_VISITE)}${v.confirmee_le ? '<div class="mut">✓ confirmée</div>' : ''}</td>
        <td><select data-v="${v.id}" class="stv" style="min-width:120px">${Object.entries(STATUTS_VISITE).map(([k, [l]]) => `<option value="${k}" ${k === v.statut ? 'selected' : ''}>${l}</option>`).join('')}</select>
        <a class="mut" target="_blank" rel="noopener" href="${esc(lienGoogle(v, a))}">Google Agenda</a></td></tr>`; }).join('') || `<tr><td colspan="6" class="mut">Aucune visite.</td></tr>`}
      </tbody></table></div></div>`;
    S.annoncePre = null;
    const f = vue().querySelector('#fv'), sel = vue().querySelector('#v-sel'), vq = vue().querySelector('#v-q');
    const majLoc = async () => {
      const el = vue().querySelector('#v-loc'); el.innerHTML = '';
      if (!sel.value) return;
      const { data } = await sb.rpc('locataires_annonce', { p_annonce: sel.value });
      if ((data || []).length) el.innerHTML = `<div class="msg info"><b>Logement habité.</b> Le locataire recevra un avis par courriel; appelez-le aussi : ${data.map(l => `${esc(l.nom)} ${telLien(l.telephone)}`).join(' · ')}</div>`;
    };
    sel.onchange = majLoc; majLoc();
    vq.oninput = () => {
      const n = norm(vq.value).trim(), cur = sel.value;
      const liste = n ? actives.filter(a => norm(libelle(a) + ' ' + a.numero + ' ' + a.rue).includes(n)) : actives;
      sel.innerHTML = optionsLogements(liste, cur);
      if (liste.length === 1) { sel.value = liste[0].id; majLoc(); }
    };
    const vd = vue().querySelector('#v-vers-dem'); if (vd) vd.onclick = (e) => { e.preventDefault(); S.tab = 'dvisites'; coquille(); };
    const va = vue().querySelector('#v-annule'); if (va) va.onclick = () => { S.demandePre = null; S.tab = 'dvisites'; coquille(); };
    const hIn = f.elements.heure; hIn.onblur = () => { const h = lireHeure(hIn.value); if (h) hIn.value = h; };
    vue().querySelectorAll('.stv').forEach(s => s.onchange = async () => { await sb.from('visites').update({ statut: s.value }).eq('id', s.dataset.v); vueVisites(); });
    f.onsubmit = async (e) => {
      e.preventDefault(); const m = vue().querySelector('#m');
      const hh = lireHeure(f.elements.heure.value);
      if (!hh) return msg(m, 'Écrivez l\'heure, par exemple 14h30 ou 9h.');
      if (hh < '07:00' || hh > '21:00') return msg(m, 'Les visites se font entre 7 h et 21 h.');
      const debut = new Date(`${f.elements.date.value}T${hh}:00`);
      if (isNaN(debut)) return msg(m, 'Choisissez la date et l\'heure.');
      if (debut < new Date()) return msg(m, 'Cette heure est déjà passée.');
      const fin = new Date(debut.getTime() + DUREE_VISITE_MIN * 60000);
      const v = { annonce_id: sel.value, agent_id: S.user.id, prospect_nom: val(f, 'nom'), prospect_telephone: val(f, 'tel'), prospect_courriel: (val(f, 'courriel') || '').toLowerCase(),
        specifications: val(f, 'notes'), debut: debut.toISOString(), fin: fin.toISOString(), statut: 'planifiee', ...(pre ? { suivi_statut: 'Visite planifiée' } : {}) };
      const r = pre ? await sb.from('visites').update(v).eq('id', pre.id) : await sb.from('visites').insert(v);
      if (r.error) return msg(m, r.error.message);
      S.demandePre = null;
      const a = parId[v.annonce_id];
      m.innerHTML = `<div class="msg ok">Visite enregistrée pour le ${esc(fmtDT(v.debut))}. ${esc(v.prospect_nom)} recevra l'invitation et les rappels par courriel d'ici quelques minutes.</div>
        <a class="btn sec" target="_blank" rel="noopener" href="${esc(lienGoogle(v, a))}">Ajouter à mon Google Agenda</a>`;
      f.reset(); vq.value = ''; sel.innerHTML = optionsLogements(actives, '');
      setTimeout(() => { if (S.tab === 'visites') vueVisites(); }, 20000);
    };
  }

  // ----- Demandes de visite (formulaire du site / Monday) : statuts, appels et notes -----
  async function vueDemandesVisite() {
    vue().innerHTML = '<div class="mut">Chargement…</div>';
    if (!S.annonces.length) await chargerAnnonces();
    const [{ data: dem, error }, { data: appels }] = await Promise.all([
      sb.from('visites').select('*').is('debut', null).order('cree_le', { ascending: false }).limit(400),
      sb.from('visite_appels').select('*').order('quand', { ascending: false })
    ]);
    const parId = Object.fromEntries(S.annonces.map(a => [a.id, a]));
    const appelsDe = (id) => (appels || []).filter(x => x.visite_id === id);
    const st = (d) => d.suivi_statut || 'À CONTACTER';
    const filtre = S.filtreDV || 'atraiter';
    const liste = (dem || []).filter(d => filtre === 'toutes' || (filtre === 'atraiter' ? !SUIVI_FINIS.includes(st(d)) : st(d) === filtre));
    const compte = (k) => (dem || []).filter(d => st(d) === k).length;
    vue().innerHTML = `<h2>📞 Demandes de visite</h2><p class="mut">Les demandes reçues par le formulaire du site. Notez chaque appel : la note est obligatoire, l'agent, la date et l'heure sont ajoutés automatiquement.</p>
      ${error ? `<div class="msg err">${esc(error.message)}</div>` : ''}
      <div class="chips"><button class="chip ${filtre === 'atraiter' ? 'on' : ''}" data-fdv="atraiter">À traiter (${(dem || []).filter(d => !SUIVI_FINIS.includes(st(d))).length})</button>${SUIVI_VISITE.filter(([k]) => compte(k)).map(([k, c]) => `<button class="chip ${filtre === k ? 'on' : ''}" data-fdv="${esc(k)}" style="border-left:5px solid ${c}">${esc(k)} (${compte(k)})</button>`).join('')}<button class="chip ${filtre === 'toutes' ? 'on' : ''}" data-fdv="toutes">Toutes</button></div>
      ${liste.map(d => { const ap = appelsDe(d.id), a = parId[d.annonce_id]; const suivant = `Contacté ${Math.min(ap.length + 1, 4)}x`;
        return `<div class="card bar" style="--bc:${couleurSuivi(st(d))}">
          <div style="display:flex;justify-content:space-between;gap:8px;flex-wrap:wrap;align-items:flex-start"><div><b style="font-family:var(--fh);font-size:1.1rem">${esc(d.prospect_nom)}</b> <span class="mut">reçue le ${esc(fmtDate(d.cree_le))}</span>
            <div>${telLien(d.prospect_telephone)} ${courrielHTML(d.prospect_courriel)}</div></div>
            <select class="st-sel" data-sv="${d.id}" style="--sc:${couleurSuivi(st(d))}">${SUIVI_VISITE.map(([k]) => `<option ${k === st(d) ? 'selected' : ''}>${esc(k)}</option>`).join('')}${SUIVI_VISITE.some(([k]) => k === st(d)) ? '' : `<option selected>${esc(st(d))}</option>`}</select></div>
          <div style="margin-top:6px">🏠 <b>${esc(a ? libelle(a) : 'Logement non précisé')}</b>${a ? ` · ${esc(a.grandeur || '')} · ${badge(a.statut, STATUTS_ANNONCE)}` : ''}</div>
          <div class="mut">${d.horaires_preferes ? '🕒 Disponibilités : ' + esc(d.horaires_preferes) + ' · ' : ''}${d.moyen_contact ? 'Préfère : ' + esc(d.moyen_contact) : ''}</div>
          ${d.date_amenagement ? `<div style="margin-top:4px">${amenagementHTML(d.date_amenagement)}${d.liste_attente_courriel_le ? ` <span class="badge b-blue">📧 Invité à la liste d'attente le ${esc(fmtCourt(d.liste_attente_courriel_le))}</span>` : ''}</div>` : ''}
          ${d.specifications ? `<div class="mut" style="margin-top:4px">${esc(d.specifications)}</div>` : ''}
          <div style="margin-top:8px"><b>Appels (${ap.length})</b>${ap.map(x => `<div class="appel">📞 <b>${esc(x.agent_nom || S.noms[x.agent_id] || 'Agent')}</b> · ${esc(fmtDT(x.quand))}${x.resultat ? ` · <b>${esc(x.resultat)}</b>` : ''}<div>${esc(x.note)}</div></div>`).join('') || '<div class="mut">Aucun appel noté.</div>'}</div>
          <details style="margin-top:8px"><summary class="btn small sec" style="display:inline-flex">➕ Noter un appel</summary>
            <div class="row" style="margin-top:8px"><div><label>Résultat</label><select data-ar="${d.id}">${SUIVI_VISITE.map(([k]) => `<option ${k === suivant ? 'selected' : ''}>${esc(k)}</option>`).join('')}</select></div>
              <div><label>Note de l'appel (obligatoire)</label><textarea data-an="${d.id}" placeholder="Ex. : message laissé, rappeler après 17 h"></textarea></div></div>
            <div class="btns"><button class="btn small" data-asave="${d.id}">Enregistrer l'appel</button></div></details>
          <div class="btns"><button class="btn" data-plan2="${d.id}">🗓️ Planifier la visite</button></div></div>`; }).join('') || '<div class="mut">Aucune demande.</div>'}`;
    vue().querySelectorAll('[data-fdv]').forEach(b => b.onclick = () => { S.filtreDV = b.dataset.fdv; vueDemandesVisite(); });
    vue().querySelectorAll('[data-sv]').forEach(s => s.onchange = async () => { const { error } = await sb.rpc('maj_suivi_visite', { p_visite: s.dataset.sv, p_statut: s.value }); if (error) alert(error.message); vueDemandesVisite(); });
    vue().querySelectorAll('[data-asave]').forEach(b => b.onclick = async () => {
      const id = b.dataset.asave, note = vue().querySelector(`[data-an="${id}"]`).value.trim(), res = vue().querySelector(`[data-ar="${id}"]`).value;
      if (!note) { alert('La note de l\'appel est obligatoire.'); return; }
      const { error } = await sb.from('visite_appels').insert({ visite_id: id, agent_id: S.user.id, agent_nom: S.monNom, resultat: res, note });
      if (error) { alert(error.message); return; }
      await sb.rpc('maj_suivi_visite', { p_visite: id, p_statut: res }); vueDemandesVisite();
    });
    vue().querySelectorAll('[data-plan2]').forEach(b => b.onclick = () => { S.demandePre = b.dataset.plan2; S.annoncePre = null; S.tab = 'visites'; coquille(); });
  }

  // ----- Suivi : ce qui attend une action, avec le temps écoulé -----
  const ecoule = (iso) => { const h = Math.floor((Date.now() - new Date(iso).getTime()) / 3600000); return h < 24 ? `${h} h` : `${Math.floor(h / 24)} j ${h % 24} h`; };
  async function vueSuivi() {
    vue().innerHTML = '<div class="mut">Chargement…</div>';
    const [{ data: dems }, { data: dv }, { data: appels }] = await Promise.all([
      sb.from('demandes_location').select('*, demande_personnes(nom, telephone, courriel, role)').order('statut_change_le'),
      sb.from('visites').select('*').is('debut', null).order('cree_le'),
      sb.from('visite_appels').select('visite_id, quand').order('quand', { ascending: false })
    ]);
    const actives = (dems || []).filter(d => !DEM_FINIES.includes(d.statut));
    const h48 = (d) => ['formulaire_envoye', 'enquete_envoyee'].includes(d.statut) && d.statut_change_le && Date.now() - new Date(d.statut_change_le).getTime() >= 48 * 3600000;
    const dernier = (id, cree) => { const a = (appels || []).find(x => x.visite_id === id); return a ? a.quand : cree; };
    const aRappeler = (dv || []).filter(d => !SUIVI_FINIS.includes(d.suivi_statut || 'À CONTACTER') && Date.now() - new Date(dernier(d.id, d.cree_le)).getTime() >= 24 * 3600000);
    const nom = (d) => ((d.demande_personnes || []).find(p => p.role === 'principal') || (d.demande_personnes || [])[0] || {}).nom || '';
    vue().innerHTML = `<h2>🔔 Suivi</h2>
      <div class="card"><h3 style="margin-top:0">📄 Demandes de location en cours (${actives.length})</h3><p class="mut">Une enquête prend de 24 à 48 h. Après 48 h, un rappel s'affiche ici et un courriel est envoyé à location@.</p>
        ${actives.map(d => { const s = STATUTS_DEMANDE[d.statut] || [ANCIENS_DEMANDE[d.statut] || d.statut, '', '#999']; return `<div class="appel" style="border-left-color:${s[2]}"><b>${esc(d.adresse_souhaitee || 'Logement non précisé')}</b> · ${esc(nom(d))}
          <div><span class="badge ${s[1]}">${esc(s[0])}</span> depuis <b>${esc(d.statut_change_le ? ecoule(d.statut_change_le) : '—')}</b>${h48(d) ? ' <span class="retard">⏰ 48 h dépassées : vérifier le résultat de l\'enquête</span>' : ''}</div></div>`; }).join('') || '<div class="mut">Rien en cours.</div>'}</div>
      <div class="card"><h3 style="margin-top:0">📞 Demandes de visite à rappeler (${aRappeler.length})</h3><p class="mut">Aucune nouvelle depuis plus de 24 h.</p>
        ${aRappeler.map(d => `<div class="appel" style="border-left-color:${couleurSuivi(d.suivi_statut || 'À CONTACTER')}"><b>${esc(d.prospect_nom)}</b> ${telLien(d.prospect_telephone)} · ${esc(d.suivi_statut || 'À CONTACTER')} · dernier contact il y a <b>${esc(ecoule(dernier(d.id, d.cree_le)))}</b></div>`).join('') || '<div class="mut">Tout est à jour.</div>'}
        ${aRappeler.length ? '<div class="btns"><button class="btn small" id="s-dv">Ouvrir les demandes de visite</button></div>' : ''}</div>`;
    const b = vue().querySelector('#s-dv'); if (b) b.onclick = () => { S.tab = 'dvisites'; coquille(); };
  }

  // ----- Pancartes -----
  async function vuePancartes() {
    const [{ data: resume }, { data: liste }] = await Promise.all([
      sb.from('pancartes_actives').select('*').order('adresse'),
      sb.from('pancartes').select('*, annonces(numero, rue), immeubles(numero, rue)').is('retiree_le', null).order('posee_le')
    ]);
    const total = (resume || []).reduce((s, r) => s + Number(r.nombre), 0);
    vue().innerHTML = `<div class="card"><h2>${total} pancarte(s) posée(s)</h2>
      <div class="tbl"><table><thead><tr><th>Adresse</th><th class="n">Nombre</th><th>Emplacements</th><th>Depuis</th></tr></thead><tbody>
      ${(resume || []).map(r => `<tr><td>${esc(r.adresse)}</td><td class="n">${esc(r.nombre)}</td><td>${esc(r.emplacements)}</td><td>${esc(fmtDate(r.depuis))}</td></tr>`).join('') || '<tr><td colspan="4" class="mut">Aucune pancarte posée.</td></tr>'}
      </tbody></table></div></div>
      <div class="card"><h2>Détail</h2><div class="tbl"><table><tbody>${(liste || []).map(p => `<tr><td>${esc(p.annonces ? libelle(p.annonces) : (p.immeubles ? libelle(p.immeubles) : p.adresse))}</td>
        <td>${p.nombre} × ${esc(p.emplacement)}${p.notes ? `<div class="mut">${esc(p.notes)}</div>` : ''}</td><td><button class="btn small sec" data-r="${p.id}">Marquer retirée</button></td></tr>`).join('') || '<tr><td class="mut">Rien à afficher.</td></tr>'}</tbody></table></div></div>`;
    vue().querySelectorAll('[data-r]').forEach(b => b.onclick = async () => { await sb.from('pancartes').update({ retiree_le: new Date().toISOString().slice(0, 10), retiree_par: S.user.id }).eq('id', b.dataset.r); vuePancartes(); });
  }

  // ----- Demandes de location -----
  async function vueDemandes() {
    vue().innerHTML = '<div class="mut">Chargement…</div>';
    if (!S.annonces.length) await chargerAnnonces();
    const { data, error } = await sb.from('demandes_location').select('*, demande_personnes(*)').order('cree_le', { ascending: false });
    const filtre = S.filtreDem || 'actives';
    const liste = (data || []).filter(d => filtre === 'toutes' || (filtre === 'actives' ? !DEM_FINIES.includes(d.statut) : d.statut === filtre));
    const compte = k => (data || []).filter(d => d.statut === k).length;
    const parId = Object.fromEntries(S.annonces.map(a => [a.id, a]));
    const optsLog = (sel) => `<option value="">— Aucun logement lié —</option>` + S.annonces.filter(a => a.statut !== 'retire' || a.id === sel).map(a => `<option value="${a.id}" ${a.id === sel ? 'selected' : ''}>${esc(libelle(a))} · ${esc(STATUTS_ANNONCE[a.statut] ? STATUTS_ANNONCE[a.statut][0] : a.statut)}</option>`).join('');
    vue().innerHTML = `<h2>Demandes de location</h2>${error ? `<div class="msg err">${esc(error.message)}</div>` : ''}
      <div class="chips"><button class="chip ${filtre === 'actives' ? 'on' : ''}" data-fd="actives">En cours</button>${Object.entries(STATUTS_DEMANDE).filter(([k]) => compte(k)).map(([k, [l, , c]]) => `<button class="chip ${filtre === k ? 'on' : ''}" data-fd="${k}" style="border-left:5px solid ${c}">${l} (${compte(k)})</button>`).join('')}<button class="chip ${filtre === 'toutes' ? 'on' : ''}" data-fd="toutes">Toutes</button></div>
      ${liste.map(d => {
        const pers = d.demande_personnes || [], garants = pers.filter(p => p.role === 'garant'), bail = pers.filter(p => p.role !== 'garant');
        const st = STATUTS_DEMANDE[d.statut] || [ANCIENS_DEMANDE[d.statut] || d.statut, '', '#999'];
        const paye = /^oui/i.test(d.paiement_enquete || '') || !!d.enquete_recue_le;
        const paie = d.paiement_enquete || (d.enquete_recue_le ? 'Oui (60$)' : 'Non');
        return `<div class="card bar" style="--bc:${st[2]}">
          <div style="display:flex;justify-content:space-between;gap:8px;flex-wrap:wrap;align-items:flex-start"><div><b style="font-family:var(--fh);font-size:1.08rem">${esc(d.adresse_souhaitee || 'Logement non précisé')}</b>
            <div class="mut">Reçue le ${esc(fmtDate(d.cree_le))}${d.date_amenagement ? ' · aménagement : ' + esc(d.date_amenagement) : ''}${d.nb_habitants ? ' · ' + d.nb_habitants + ' habitant(s)' : ''}${d.nb_stationnements ? ' · ' + d.nb_stationnements + ' stationnement(s)' : ''}</div></div>
            <select class="st-sel" data-d="${d.id}" style="--sc:${st[2]}">${Object.entries(STATUTS_DEMANDE).map(([k, [l]]) => `<option value="${k}" ${k === d.statut ? 'selected' : ''}>${l}</option>`).join('')}${STATUTS_DEMANDE[d.statut] ? '' : `<option selected value="${esc(d.statut)}">${esc(st[0])}</option>`}</select></div>
          <div style="display:flex;gap:8px;flex-wrap:wrap;margin-top:8px;align-items:center">
            <span class="badge b-blue">👥 ${bail.length} personne${bail.length > 1 ? 's' : ''} sur le bail</span>
            <span class="badge ${garants.length ? 'b-pri' : ''}">${garants.length ? '🤝 Avec endosseur (' + garants.length + ')' : 'Sans endosseur'}</span>
            ${isAdmin() ? `<label style="margin:0;display:flex;gap:6px;align-items:center;font-weight:600">💵 Paiement enquête <select class="st-sel" data-pay="${d.id}" style="--sc:${paye ? 'var(--ok)' : 'var(--bad)'}">${PAIEMENTS.concat(PAIEMENTS.includes(paie) ? [] : [paie]).map(o => `<option ${o === paie ? 'selected' : ''}>${esc(o)}</option>`).join('')}</select></label>`
              : `<span class="badge ${paye ? 'b-ok' : 'b-bad'}">💵 Paiement enquête : ${esc(paie)}</span>`}
            ${d.formulaire_courriel_envoye_le ? `<span class="badge b-warn">📧 Courriel « formulaire » envoyé le ${esc(fmtCourt(d.formulaire_courriel_envoye_le))}</span>` : ''}</div>
          <div style="margin-top:8px;display:flex;gap:8px;align-items:center;flex-wrap:wrap"><b>🏠 Logement lié :</b> <select data-dl="${d.id}" style="width:auto;max-width:100%">${optsLog(d.annonce_id)}</select>${d.annonce_id && parId[d.annonce_id] ? badge(parId[d.annonce_id].statut, STATUTS_ANNONCE) : ''}</div>
          <div style="margin-top:10px">${pers.map(p => `<div style="padding:4px 0;border-top:1px solid var(--line)"><b>${esc(p.nom)}</b> <span class="mut">(${esc(p.role === 'principal' ? 'demandeur principal' : p.role === 'garant' ? 'endosseur' : 'colocataire')})</span> ${telLien(p.telephone)} ${courrielHTML(p.courriel)}</div>`).join('')}</div>
          ${d.specification ? `<div class="mut" style="margin-top:6px">${esc(d.specification)}</div>` : ''}
        </div>`; }).join('') || '<div class="mut">Aucune demande.</div>'}`;
    vue().querySelectorAll('[data-fd]').forEach(b => b.onclick = () => { S.filtreDem = b.dataset.fd; vueDemandes(); });
    vue().querySelectorAll('[data-d]').forEach(s => s.onchange = async () => {
      if (s.value === 'formulaire_envoye' && !confirm('Le courriel « Formulaire envoyé » partira à toutes les personnes de cette demande. Continuer ?')) { vueDemandes(); return; }
      const { error } = await sb.from('demandes_location').update({ statut: s.value }).eq('id', s.dataset.d);
      if (error) alert(error.message);
      else if (s.value === 'formulaire_envoye') { try { await fetch(SUPABASE_URL + '/functions/v1/visites'); } catch {} alert('Courriel envoyé aux personnes de la demande (depuis location@lesgestionsbestlife.com).'); }
      S.annonces = []; vueDemandes();
    });
    vue().querySelectorAll('[data-pay]').forEach(s => s.onchange = async () => {
      const oui = /^oui/i.test(s.value);
      const { error } = await sb.from('demandes_location').update({ paiement_enquete: s.value, enquete_recue_le: oui ? new Date().toISOString() : null, enquete_recue_par: oui ? S.user.id : null }).eq('id', s.dataset.pay);
      if (error) alert(error.message); vueDemandes();
    });
    vue().querySelectorAll('[data-dl]').forEach(s => s.onchange = async () => {
      const { error } = await sb.from('demandes_location').update({ annonce_id: s.value || null }).eq('id', s.dataset.dl);
      if (error) alert(error.message); S.annonces = []; vueDemandes();
    });
  }
  // ----- Liste d'attente + jumelage -----
  const MOIS = ['janv', 'fev', 'mars', 'avr', 'mai', 'juin', 'juil', 'aout', 'sept', 'oct', 'nov', 'dec'];
  function dateVoulue(txt) {
    const t = norm(txt); if (!t) return null;
    const iso = t.match(/(\d{4})-(\d{2})-(\d{2})/); if (iso) return new Date(+iso[1], +iso[2] - 1, +iso[3]);
    const i = MOIS.findIndex(m => t.includes(m)); if (i < 0) return null;
    const y = (t.match(/20\d\d/) || [])[0]; const now = new Date();
    let d = new Date(y ? +y : now.getFullYear(), i, 1); if (!y && d < new Date(now.getFullYear(), now.getMonth() - 1, 1)) d.setFullYear(d.getFullYear() + 1);
    return d;
  }
  function jumelage(p, annonces) {
    const voulu = norm(p.grandeur), budget = Math.max(0, ...((String(p.budget || '').match(/\d[\d\s]*/g) || []).map(x => parseInt(x.replace(/\s/g, ''), 10)).filter(n => n > 200)));
    const quand = dateVoulue(p.date_demenagement), spec = norm((p.specifications || '') + ' ' + (p.notes || ''));
    return annonces.filter(a => ['affiche', 'prise_photos', 'en_attente', 'en_renovation'].includes(a.statut)).map(a => {
      let s = 0; const r = [], c = [];
      const g = norm(a.grandeur);
      if (g && voulu && voulu.includes(g)) { s += 40; r.push(`grandeur recherchée (${a.grandeur})`); } else if (g && voulu) { const n1 = parseFloat(g), n2 = parseFloat(voulu); if (!isNaN(n1) && !isNaN(n2) && Math.abs(n1 - n2) <= 1) { s += 15; r.push('grandeur voisine'); } else c.push(`grandeur ${a.grandeur}`); } else s += 10;
      const px = Number(a.prix_affiche || a.prix_proprio || 0);
      if (px && budget) { if (px <= budget) { s += 30; r.push(`dans le budget (${px} $ ≤ ${budget} $)`); } else if (px <= budget * 1.1) { s += 12; r.push(`légèrement au-dessus du budget (${px} $)`); } else { s -= 20; c.push(`au-dessus du budget (${px} $)`); } }
      // Date : le logement doit être libre au bon moment (pas plus de 15 jours après, pas plus d'un mois avant la date voulue), sinon il n'est pas proposé
      if (quand && a.disponibilite) { const dispo = new Date(a.disponibilite + 'T12:00:00'); const ecart = (dispo - quand) / 864e5; if (ecart > 15 || ecart < -31) return null; s += 25; r.push(`libre le ${fmtCourt(a.disponibilite)}, au bon moment`); }
      else if (quand && !a.disponibilite) { s -= 10; c.push('date de disponibilité inconnue'); }
      else if (!quand) { s -= 5; c.push('date de déménagement non précisée'); }
      if (/(chien|chat|animal|animaux)/.test(spec)) { if (/non|aucun|interdit/.test(norm(a.animaux))) { s -= 30; c.push('animaux non acceptés'); } else if (a.animaux) { s += 10; r.push('animaux : ' + a.animaux); } }
      if (/stationnement|auto|voiture/.test(spec) && Number(a.nb_stationnements) > 0) { s += 8; r.push('stationnement inclus'); }
      const motsRue = norm(a.rue).split(/[^a-z0-9]+/).filter(m => m.length > 3);
      if (motsRue.some(m => spec.includes(m))) { s += 10; r.push('secteur mentionné'); }
      return { a, s: Math.max(0, Math.min(100, s)), r, c };
    }).filter(x => x && x.s >= 55).sort((x, y) => y.s - x.s);
  }
  async function vueAttente() {
    if (!S.annonces.length) await chargerAnnonces();
    const { data, error } = await sb.from('liste_attente').select('*').order('statut').order('cree_le', { ascending: false });
    vue().innerHTML = `<h2>Liste d'attente</h2><p class="mut">Touchez une personne pour voir tout ce qu'elle a rempli et les logements qui lui correspondent (jumelage intelligent).</p>${error ? `<div class="msg err">${esc(error.message)}</div>` : ''}
      ${(data || []).map(p => { const j = jumelage(p, S.annonces); return `<div class="card click bar" style="--bc:${p.statut === 'actif' ? '#037f4c' : '#aabcbf'}" data-p="${p.id}">
        <div style="display:flex;justify-content:space-between;gap:8px;flex-wrap:wrap"><div><b style="font-family:var(--fh);font-size:1.05rem">${esc(p.nom)}</b> <span class="mut">inscrit le ${esc(fmtDate(p.cree_le))}</span>
          <div>${esc(p.grandeur || '—')} · budget ${esc(p.budget || '—')} · déménagement : ${esc(p.date_demenagement || '—')}</div></div>
          <div style="text-align:right">${p.statut_libelle ? `<span class="badge ${STATUTS_ATTENTE[p.statut] ? STATUTS_ATTENTE[p.statut][1] : ''}">${esc(p.statut_libelle)}</span>` : badge(p.statut, STATUTS_ATTENTE)}${p.statut === 'actif' && j.length ? `<div style="margin-top:6px"><span class="badge b-pri">✨ ${j.length} logement${j.length > 1 ? 's' : ''} possible${j.length > 1 ? 's' : ''}</span></div>` : ''}</div></div></div>`; }).join('') || '<div class="mut">Personne en attente.</div>'}`;
    vue().querySelectorAll('[data-p]').forEach(c => c.onclick = () => ficheAttente((data || []).find(x => x.id === c.dataset.p)));
  }
  function ficheAttente(p) {
    const j = jumelage(p, S.annonces);
    const champs = [['Nom', p.nom], ['Téléphone', p.telephone], ['Courriel', p.courriel], ['Grandeur recherchée', p.grandeur], ['Date de déménagement', p.date_demenagement], ['Budget', p.budget],
      ['Spécifications', p.specifications], ['Aviser dès qu\'un logement correspond', p.notifier == null ? '' : (p.notifier ? 'Oui' : 'Non')], ['Inscrit le', fmtDate(p.cree_le)], ['Notes internes', p.notes]].filter(([, v]) => v != null && v !== '');
    const ov = modal(`<div style="display:flex;justify-content:space-between;gap:8px"><h2>${esc(p.nom)}</h2>${badge(p.statut, STATUTS_ATTENTE)}</div>
      <div>${telLien(p.telephone)} ${p.courriel ? `<a href="mailto:${esc(p.courriel)}">${esc(p.courriel)}</a> ${copier(p.courriel)}` : ''}</div>
      <h3>Ce que la personne a rempli</h3><div class="kv">${champs.map(([k, v]) => `<div>${esc(k)}</div><div>${esc(v)}</div>`).join('')}</div>
      <h3>✨ Jumelage intelligent avec les logements alloués</h3>
      ${j.length ? j.slice(0, 5).map(x => `<div class="card" style="display:flex;gap:12px;align-items:flex-start"><div class="score num">${x.s}%</div><div style="flex:1"><b>${esc(libelle(x.a))}</b> · ${esc(x.a.grandeur || '')} · ${esc(prix(x.a))}
        <div class="small" style="color:var(--ok)">${x.r.map(esc).join(' · ')}</div>${x.c.length ? `<div class="small" style="color:var(--bad)">${x.c.map(esc).join(' · ')}</div>` : ''}
        <div class="btns" style="margin-top:6px"><button class="btn small" data-plan="${x.a.id}">Planifier une visite</button>${lienAnnonce(x.a) ? `<a class="btn small sec" href="${esc(lienAnnonce(x.a))}" target="_blank" rel="noopener">Annonce ↗</a>` : ''}</div></div></div>`).join('') : '<div class="mut">Aucun logement alloué ne correspond pour le moment.</div>'}
      <h3>Suivi</h3><div class="row"><select id="sta">${Object.entries(STATUTS_ATTENTE).map(([k, [l]]) => `<option value="${k}" ${k === p.statut ? 'selected' : ''}>${l}</option>`).join('')}</select><input id="nts" placeholder="Note interne" value="${esc(p.notes || '')}"></div>
      <div id="m"></div><div class="btns"><button class="btn" id="sv">Enregistrer</button><button class="btn sec" id="fe">Fermer</button></div>`);
    ov.querySelector('#fe').onclick = () => ov.remove();
    ov.querySelector('#sv').onclick = async () => { const { error } = await sb.from('liste_attente').update({ statut: ov.querySelector('#sta').value, notes: ov.querySelector('#nts').value || null }).eq('id', p.id); if (error) return msg(ov.querySelector('#m'), error.message); ov.remove(); vueAttente(); };
    ov.querySelectorAll('[data-plan]').forEach(b => b.onclick = async () => {
      ov.remove(); S.tab = 'visites'; S.annoncePre = b.dataset.plan; coquille();
      setTimeout(() => { const f = vue().querySelector('#fv'); if (f) { f.elements.nom.value = p.nom || ''; f.elements.tel.value = p.telephone || ''; f.elements.courriel.value = p.courriel || ''; } }, 700);
    });
  }

  // ----- Statistiques (administration) -----
  async function vueStats() {
    vue().innerHTML = '<div class="mut">Calcul des statistiques…</div>';
    await chargerAnnonces(); S.noms = {}; await chargerNoms();
    const jours = S.statsPer === 'tout' ? null : Number(S.statsPer);
    const depuis = jours ? new Date(Date.now() - jours * 864e5) : null;
    let qv = sb.from('visites').select('*'); if (depuis) qv = qv.gte('cree_le', depuis.toISOString());
    let qd = sb.from('demandes_location').select('id, annonce_id, visite_id, statut, cree_le, enquete_recue_le, enquete_montant'); if (depuis) qd = qd.gte('cree_le', depuis.toISOString());
    const [{ data: V }, { data: D }] = await Promise.all([qv, qd]);
    const vis = V || [], dem = D || [];
    const pct = (a, b) => b ? Math.round(a / b * 100) + ' %' : '—';
    const n = (arr, f) => arr.filter(f).length;
    const planif = vis.filter(v => v.debut), faites = n(vis, v => v.statut === 'faite'), abs = n(vis, v => v.statut === 'absent'), ann = n(vis, v => v.statut === 'annulee'), conf = n(planif, v => v.confirmee_le);
    const loues = S.annonces.filter(a => a.loue_le && (!depuis || new Date(a.loue_le) >= depuis));
    const delais = loues.filter(a => a.affiche_le).map(a => (new Date(a.loue_le) - new Date(a.affiche_le)) / 864e5);
    const delai = delais.length ? Math.round(delais.reduce((s, x) => s + x, 0) / delais.length) + ' j' : '—';
    const paye = dem.filter(d => d.enquete_recue_le).reduce((s, d) => s + Number(d.enquete_montant || 60), 0);
    // Par logement
    const parLog = S.annonces.map(a => {
      const v = vis.filter(x => x.annonce_id === a.id), d = dem.filter(x => x.annonce_id === a.id);
      const f = n(v, x => x.statut === 'faite'), ab = n(v, x => x.statut === 'absent'), an = n(v, x => x.statut === 'annulee');
      const jAff = a.affiche_le ? Math.round(((a.loue_le ? new Date(a.loue_le) : new Date()) - new Date(a.affiche_le)) / 864e5) : null;
      const sig = [];
      if (f >= 5 && !d.length) sig.push(['bad', `${f} visites faites sans aucune demande : revoir le prix, les photos ou la présentation.`]);
      if (a.statut === 'affiche' && !v.length && jAff != null && jAff > 14) sig.push(['bad', `Affiché depuis ${jAff} jours sans visite : visibilité de l'annonce à revoir.`]);
      if (v.length >= 4 && (ab + an) / v.length > 0.4) sig.push(['bad', `${pct(ab + an, v.length)} d'absences ou d'annulations : confirmer davantage la veille.`]);
      if (d.length && f && d.length / f >= 0.5) sig.push(['ok', 'Bon taux de conversion des visites en demandes.']);
      return { a, tot: v.length, f, ab, an, d: d.length, jAff, sig };
    }).filter(x => x.tot || ACTIFS.includes(x.a.statut) || x.a.loue_le).sort((x, y) => y.tot - x.tot || triAnn(x.a, y.a));
    // Par agent
    const agents = [...new Set(vis.map(v => v.agent_id).filter(Boolean))];
    const parAgent = agents.map(id => {
      const v = vis.filter(x => x.agent_id === id), p = v.filter(x => x.debut), ids = new Set(v.map(x => x.id));
      const d = dem.filter(x => x.visite_id && ids.has(x.visite_id));
      const f = n(v, x => x.statut === 'faite');
      const louesA = S.annonces.filter(a => a.statut === 'loue' && v.some(x => x.annonce_id === a.id && x.statut === 'faite')).length;
      return { id, tot: v.length, f, ab: n(v, x => x.statut === 'absent'), an: n(v, x => x.statut === 'annulee'), conf: pct(n(p, x => x.confirmee_le), p.length), d: d.length, conv: pct(d.length, f), louesA };
    }).sort((x, y) => y.f - x.f);
    // Jours et heures
    const JS = ['Dim.', 'Lun.', 'Mar.', 'Mer.', 'Jeu.', 'Ven.', 'Sam.'];
    const parJour = JS.map((l, i) => [l, n(planif, v => new Date(v.debut).getDay() === i)]);
    const parHeure = []; for (let h = 7; h <= 21; h++) parHeure.push([`${h} h`, n(planif, v => new Date(v.debut).getHours() === h)]);
    const absHeure = parHeure.map(([l], i) => { const h = i + 7; const t = planif.filter(v => new Date(v.debut).getHours() === h); return [l, t.length ? n(t, v => v.statut === 'absent') / t.length : 0, t.length]; }).filter(x => x[2] >= 3).sort((x, y) => y[1] - x[1])[0];
    const sources = {}; vis.forEach(v => { if (v.source_annonce) sources[v.source_annonce] = (sources[v.source_annonce] || 0) + 1; });
    const barres = (rows) => { const mx = Math.max(1, ...rows.map(r => r[1])); return rows.map(([l, x]) => `<div class="hb"><span class="l">${esc(l)}</span><span class="b" style="width:${Math.round(x / mx * 70)}%"></span><span class="num">${x}</span></div>`).join(''); };
    const pistes = [];
    const meilleurJour = [...parJour].sort((x, y) => y[1] - x[1])[0];
    if (planif.length >= 5) pistes.push(`Jour le plus achalandé : ${meilleurJour[0]} (${meilleurJour[1]} visites). Concentrer les plages de visites ce jour-là.`);
    if (planif.length >= 5) pistes.push(`Taux de confirmation par courriel : ${pct(conf, planif.length)}. Les visites non confirmées la veille méritent un appel.`);
    if (absHeure && absHeure[1] > 0.25) pistes.push(`Les visites de ${absHeure[0]} ont ${Math.round(absHeure[1] * 100)} % d'absences : éviter cette plage ou rappeler 1 h avant.`);
    vue().innerHTML = `<div style="display:flex;justify-content:space-between;align-items:center;gap:8px;flex-wrap:wrap"><h2 style="margin:0">Statistiques de location</h2>
      <div class="chips" style="margin:0">${[['30', '30 jours'], ['90', '90 jours'], ['365', '12 mois'], ['tout', 'Tout']].map(([k, l]) => `<button class="chip ${S.statsPer === k ? 'on' : ''}" data-per="${k}">${l}</button>`).join('')}</div></div>
      <div class="stats" style="margin-top:12px">
        <div class="stat"><b class="num">${planif.length}</b><span>Visites planifiées</span></div>
        <div class="stat"><b class="num">${faites}</b><span>Visites faites</span></div>
        <div class="stat"><b class="num">${pct(abs, planif.length)}</b><span>Absences (${abs})</span></div>
        <div class="stat"><b class="num">${pct(ann, planif.length)}</b><span>Annulations (${ann})</span></div>
        <div class="stat"><b class="num">${pct(conf, planif.length)}</b><span>Confirmées par courriel</span></div>
        <div class="stat"><b class="num">${dem.length}</b><span>Demandes de location</span></div>
        <div class="stat"><b class="num">${pct(dem.length, faites)}</b><span>Visites → demandes</span></div>
        <div class="stat"><b class="num">${loues.length}</b><span>Logements loués</span></div>
        <div class="stat"><b class="num">${delai}</b><span>Délai moyen de location</span></div>
        <div class="stat"><b class="num">${paye.toLocaleString('fr-CA')} $</b><span>Enquêtes encaissées</span></div>
      </div>
      ${pistes.length ? `<div class="card"><h3 style="margin-top:0">Pistes d'optimisation</h3>${pistes.map(p => `<div class="piste">${esc(p)}</div>`).join('')}</div>` : ''}
      <div class="card"><h3 style="margin-top:0">Par logement</h3><div class="tbl"><table><thead><tr><th>Logement</th><th>Statut</th><th class="n">Visites</th><th class="n">Faites</th><th class="n">Absences</th><th class="n">Annulées</th><th class="n">Demandes</th><th class="n">Jours affiché</th></tr></thead><tbody>
        ${parLog.map(x => `<tr><td><b>${esc(libelle(x.a))}</b>${x.sig.map(([k, t]) => `<div class="${k === 'bad' ? 'alerte' : 'piste'}" style="margin:4px 0 0;padding:4px 8px;font-size:12.5px">${esc(t)}</div>`).join('')}</td><td>${badge(x.a.statut, STATUTS_ANNONCE)}</td>
          <td class="n num">${x.tot}</td><td class="n num">${x.f}</td><td class="n num">${x.ab}</td><td class="n num">${x.an}</td><td class="n num">${x.d}</td><td class="n num">${x.jAff ?? '—'}</td></tr>`).join('') || '<tr><td colspan="8" class="mut">Pas encore de données.</td></tr>'}
      </tbody></table></div></div>
      <div class="card"><h3 style="margin-top:0">Performance des agents</h3><div class="tbl"><table><thead><tr><th>Agent</th><th class="n">Visites</th><th class="n">Faites</th><th class="n">Absences</th><th class="n">Annulations</th><th class="n">Confirmées</th><th class="n">Demandes générées</th><th class="n">Visite → demande</th><th class="n">Logements loués</th></tr></thead><tbody>
        ${parAgent.map(x => `<tr><td><b>${esc(S.noms[x.id] || 'Agent')}</b></td><td class="n num">${x.tot}</td><td class="n num">${x.f}</td><td class="n num">${x.ab}</td><td class="n num">${x.an}</td><td class="n num">${x.conf}</td><td class="n num">${x.d}</td><td class="n num">${x.conv}</td><td class="n num">${x.louesA}</td></tr>`).join('') || '<tr><td colspan="9" class="mut">Pas encore de visites planifiées par un agent.</td></tr>'}
      </tbody></table></div></div>
      <div class="row"><div class="card"><h3 style="margin-top:0">Visites par jour de la semaine</h3>${barres(parJour)}</div><div class="card"><h3 style="margin-top:0">Visites par heure</h3>${barres(parHeure.filter(x => x[1]) .length ? parHeure.filter(x => x[1]) : parHeure.slice(0, 1))}</div></div>
      ${Object.keys(sources).length ? `<div class="card"><h3 style="margin-top:0">D'où viennent les prospects</h3>${barres(Object.entries(sources).sort((x, y) => y[1] - x[1]))}</div>` : ''}`;
    vue().querySelectorAll('[data-per]').forEach(b => b.onclick = () => { S.statsPer = b.dataset.per; vueStats(); });
  }

  // ----- Formulaire « Logement alloué » (interne) -----
  // ----- Choix identiques au formulaire Monday « Information sur le logement à louer » -----
  const CHOIX = {
    inclusions: ['Aucune inclusion', 'Chauffé', 'Éclairé', 'Eau chaude', 'Internet', 'Stationnement', 'Frigidaire et four', 'Laveuse et sécheuse', 'Lave-vaisselle', 'Micro Onde', 'Entrée laveuse/sécheuse', 'Entrée lave-vaisselle', 'Buanderie dans l\'immeuble', 'Balayeuse centrale', 'Échangeur d\'air', 'Plancher chauffant', 'Thermopompe', 'Espace de rangement (Locker)', 'Balcon/terrasse', 'Accès à la cours', 'base de lit', 'table'],
    criteres: ['Aucun dossier au TAL (Tribunal administratif du logement)', 'Aucun dossier criminel', 'Cote de crédit en haut de 500', 'Cote de crédit en haut de 600', 'Le coût du logement représente moins de 30% du revenu du locataire', 'Aucun critère spécifique, selon le bon jugement de l\'agent de location'],
    sansCredit: ['Non', 'Oui', 'Oui sous condition de dépôt volontaire (Ex : 1 mois de loyer)'],
    etage: ['Rez-de-chaussée', '2e étage', '3e étage', '4e étage', 'Sous-sol'], marches: ['Non aucune', 'Oui quelques unes (2-7)', 'Oui beaucoup (+8)'],
    animaux: ['Aucun', 'Chat', 'Petit chien (-30 livres)', 'Gros chien (+30 livres)', 'Limite de 1 animal seulement'], depotChien: ['Oui', 'Non', '50$/mois en +'],
    electro: ['Oui', 'Non', 'Électro déjà inclus'], surplusElectro: ['25$/mois/électro/bail de 2 ans', '50$/mois/électro/bail de 2 ans', '75$/mois/électro'],
    grandeur: ['Chambre', 'Loft/Studio', '2 1/2', '3 1/2', '4 1/2', '5 1/2', '6 1/2', '7 1/2'], stationnements: ['Aucun', '1', '2', '3', '4']
  };
  // ----- OMH : loyer maximal estimé (Programme de supplément au loyer, SHQ) -----
  // Loyer médian du marché et taux d'inoccupation : SCHL, Sherbrooke (RMR), octobre 2025. Plafond selon l'inoccupation :
  // 120 % si 3,0 % et plus, 150 % sous 2,0 %, 130 % / 140 % entre les deux (paliers intermédiaires à confirmer avec l'OMH de Sherbrooke).
  const OMH = { studio: { l: 'Studio (Chambre, Loft, 2 1/2)', lmm: 700, inocc: 1.8 }, ch1: { l: '1 chambre (3 1/2)', lmm: 850, inocc: 3.0 }, ch2: { l: '2 chambres (4 1/2)', lmm: 997, inocc: 3.0 }, ch3: { l: '3 chambres et + (5 1/2 et +)', lmm: 1350, inocc: 2.0 } };
  const omhPct = (i) => i >= 3 ? 120 : i >= 2.5 ? 130 : i >= 2 ? 140 : 150;
  const omhType = (g) => { const s = String(g || ''); const n = parseFloat(s.replace(',', '.')); if (/chambre|loft|studio/i.test(s) || n <= 2.5) return 'studio'; if (n <= 3.5) return 'ch1'; if (n <= 4.5) return 'ch2'; return 'ch3'; };
  const omhMax = (g) => { const t = OMH[omhType(g)]; return Math.round(t.lmm * omhPct(t.inocc) / 100); };
  function grilleOMH(g, prixDemande) {
    const k = g ? omhType(g) : null, max = g ? omhMax(g) : null, p = Number(prixDemande) || 0;
    return `<div class="card" style="background:var(--s2)"><b>🏛️ Grille OMH — loyer maximal estimé (supplément au loyer)</b>
      <div class="tbl" style="margin-top:6px"><table><thead><tr><th>Type</th><th class="n">Loyer médian</th><th class="n">Inoccupation</th><th class="n">Plafond</th><th class="n">Loyer max. OMH</th></tr></thead><tbody>
      ${Object.entries(OMH).map(([t, o]) => `<tr ${t === k ? 'style="background:#fff3d6;font-weight:700"' : ''}><td>${esc(o.l)}</td><td class="n">${dollars(o.lmm)}</td><td class="n">${String(o.inocc).replace('.', ',')} %</td><td class="n">${omhPct(o.inocc)} %</td><td class="n">${dollars(Math.round(o.lmm * omhPct(o.inocc) / 100))}</td></tr>`).join('')}</tbody></table></div>
      ${max ? `<p style="margin:8px 0 0"><b>Prix OMH suggéré pour ce logement : ${dollars(p ? Math.min(p, max) : max)} / mois</b>${p ? (p <= max ? ` <span class="badge b-ok">Le prix demandé (${dollars(p)}) entre dans la grille</span>` : ` <span class="badge b-bad">Le prix demandé (${dollars(p)}) dépasse de ${dollars(p - max)}</span>`) : ''}</p>` : '<p class="mut" style="margin:8px 0 0">Choisissez la grandeur pour voir le prix suggéré.</p>'}
      <p class="mut small" style="margin:6px 0 0">Le locataire OMH paie environ 25 % de son revenu; l'OMH paie la différence jusqu'au loyer reconnu. Données : SCHL (loyer médian et inoccupation, Sherbrooke, oct. 2025) et cadre du Programme de supplément au loyer de la SHQ. Estimation à confirmer avec l'OMH de Sherbrooke avant d'accepter.</p></div>`;
  }
  const cases = (nom, opts, sel = []) => `<div class="chips">${opts.map(o => `<label class="chip" style="display:inline-flex;gap:6px;align-items:center;cursor:pointer"><input type="checkbox" name="${nom}" value="${esc(o)}" ${sel.includes(o) ? 'checked' : ''} style="width:20px;height:20px;min-height:0">${esc(o)}</label>`).join('')}</div>`;
  const radios = (nom, opts, sel) => `<div class="chips">${opts.map(o => `<label class="chip" style="display:inline-flex;gap:6px;align-items:center;cursor:pointer"><input type="radio" name="${nom}" value="${esc(o)}" ${sel === o ? 'checked' : ''} style="width:20px;height:20px;min-height:0">${esc(o)}</label>`).join('')}</div>`;
  const choix = (nom, opts, vide = '—') => `<select name="${nom}"><option value="">${vide}</option>${opts.map(o => `<option>${esc(o)}</option>`).join('')}</select>`;

  // Informations importantes manquantes dans une fiche logement (vu par l'administration)
  const manquants = (a) => [[!a.disponibilite, 'date de disponibilité'], [!a.grandeur, 'grandeur'], [!a.prix_proprio, 'prix demandé par le propriétaire'], [!a.inclusions && !a.inclusions_autres, 'inclusions'],
    [!a.etage, 'étage'], [!a.animaux, 'animaux'], [!a.criteres_selection, 'critères de sélection'], [!a.accepte_sans_credit, 'candidat sans crédit'], [!a.accepte_omh, 'OMH'],
    [a.habite == null, 'habité ou non'], [a.habite && !a.depart_locataire, 'départ du locataire'], [!a.logement_id && !!a.immeuble_id, 'logement de la base (pour aviser le locataire)']].filter(([m]) => m).map(([, l]) => l);
  // ----- Logements à venir : en attente, prise de photos, en rénovation -----
  async function vueAVenir() {
    vue().innerHTML = '<div class="mut">Chargement…</div>';
    await chargerAnnonces();
    const st = ['en_renovation', 'en_attente', 'prise_photos'];
    const liste = S.annonces.filter(a => st.includes(a.statut)).sort((x, y) => String(x.disponibilite || '9999').localeCompare(String(y.disponibilite || '9999')) || triAnn(x, y));
    const ligne = (k, v) => v != null && v !== '' ? `<div><span class="mut">${esc(k)} :</span> ${esc(v)}</div>` : '';
    vue().innerHTML = `<h2>🔜 Logements à venir</h2><p class="mut">Les logements qui seront bientôt à louer (en attente, en rénovation ou en prise de photos), du plus tôt disponible au plus tard. Touchez un logement pour sa fiche complète.</p>
      ${liste.map(a => { const ph = photoPrincipale(a); return `<div class="card bar click" data-id="${a.id}" style="--bc:${a.statut === 'prise_photos' ? '#2f6fb3' : a.statut === 'en_renovation' ? '#6a3fa0' : '#e08a00'}">
        <div style="display:flex;gap:12px;align-items:flex-start;flex-wrap:wrap">
          ${ph ? `<img src="${esc(ph)}" alt="" style="width:120px;height:90px;object-fit:cover;border-radius:8px">` : ''}
          <div style="flex:1;min-width:220px"><div style="display:flex;justify-content:space-between;gap:8px;flex-wrap:wrap"><b style="font-family:var(--fh);font-size:1.1rem">${esc(libelle(a))}</b>${badge(a.statut, STATUTS_ANNONCE)}</div>
            <div style="color:var(--pri);font-weight:700">${esc(a.grandeur || '')}${a.grandeur ? ' · ' : ''}${prixHTML(a)}</div>
            <div><b>📅 Disponible : ${esc(fmtDate(a.disponibilite) || 'date à confirmer')}</b></div>
            ${(a.inclusions || a.inclusions_autres) ? `<div class="incls">${inclusionsHTML(a)}</div>` : ''}
            ${ligne('Étage', a.etage)}${ligne('Superficie', a.pieds_carres ? a.pieds_carres + ' pi²' : '')}${ligne('Stationnements', a.nb_stationnements)}${ligne('Animaux', a.animaux)}
            ${a.habite ? ligne('Habité — départ du locataire', fmtDate(a.depart_locataire) || 'à confirmer') : ''}
            ${ligne('Critères', a.criteres_selection)}${ligne('Sans dossier de crédit', a.accepte_sans_credit)}${ligne('OMH accepté', a.accepte_omh)}
            ${ligne('Notes', [a.commentaires, a.autres_infos].filter(Boolean).join(' · '))}
            ${isAdmin() && manquants(a).length ? `<div class="msg err" style="margin-top:8px">⚠️ À compléter : ${esc(manquants(a).join(', '))} <button class="btn small" data-comp="${a.id}">✏️ Compléter</button></div>` : ''}</div></div></div>`; }).join('') || '<div class="mut">Aucun logement à venir pour le moment.</div>'}`;
    vue().querySelectorAll('[data-comp]').forEach(b => b.onclick = (e) => { e.stopPropagation(); S.edition = S.annonces.find(a => a.id === b.dataset.comp); S.tab = 'ajout'; coquille(); });
    vue().querySelectorAll('[data-id]').forEach(c => c.onclick = () => ficheAnnonce(S.annonces.find(a => a.id === c.dataset.id)));
  }

  // ----- Ajouter un logement (administration seulement) -----
  async function vueAjout(ed) {
    if (!isAdmin()) { vue().innerHTML = '<div class="msg err">Section réservée à l\'administration.</div>'; return; }
    const { data: imms } = await sb.from('immeubles').select('id, numero, rue, ville');
    const liste = (imms || []).sort(triAnn);
    vue().innerHTML = `<div class="card"><h2>${ed ? '✏️ Modifier : ' + esc(libelle(ed)) : '➕ Ajouter un logement à louer'}</h2>${ed ? '<p class="mut">Les modifications sont visibles tout de suite par les agents. Réservé à l\'administration.</p>' : ''}
      <form id="fa">
        <h3>1. Le logement</h3>
        <label>Immeuble</label><select name="imm"><option value="">— Nouvel immeuble / adresse non listée —</option>${liste.map(i => `<option value="${i.id}">${esc(libelle(i) + ', ' + (i.ville || ''))}</option>`).join('')}</select>
        <div id="fa-log"></div>
        <div class="row"><div><label>Rue</label><input name="rue" required></div><div><label>No civique et appartement</label><input name="numero" required placeholder="ex. 1940 app 6"></div></div>
        <div class="row"><div><label>Grandeur</label>${choix('grandeur', CHOIX.grandeur)}</div><div><label>Disponible à partir du</label><input name="dispo" type="date"></div></div>
        <div class="row"><div><label>Prix demandé par le propriétaire ($/mois)</label><input name="pp" type="number" min="0" required></div><div><label>Superficie (pi²)</label><input name="pi2" type="number" min="0"></div></div>
        ${ed ? '<div class="row"><div><label>Prix affiché avec rabais ($/mois, laisser vide si aucun rabais)</label><input name="pa" type="number" min="0"></div><div></div></div>' : '<p class="mut small">Le prix affiché (rabais) se change ensuite avec « Modifier » dans la fiche du logement.</p>'}
        <div class="row"><div><label>Étage</label>${choix('etage', CHOIX.etage)}</div><div><label>Marches</label>${choix('marches', CHOIX.marches)}</div></div>
        <h3>2. Inclusions</h3>${cases('incl', CHOIX.inclusions)}<label>Autres inclusions</label><input name="incl2">
        <div class="row"><div><label>Stationnements inclus</label>${choix('stat', CHOIX.stationnements)}</div><div><label>Électros possibles ?</label>${choix('electro', CHOIX.electro)}</div></div>
        <div class="row"><div><label>Surplus pour électros</label>${choix('surplus', CHOIX.surplusElectro)}</div><div><label>Dépôt pour chien ?</label>${choix('depot', CHOIX.depotChien)}</div></div>
        <label>Animaux acceptés</label>${cases('animaux', CHOIX.animaux)}
        <h3>3. Le locataire actuel</h3>
        <label>Le logement est-il habité ?</label>${radios('habite', ['Oui', 'Non'], '')}
        <div id="fa-loc"></div>
        <h3>4. Clés</h3><div id="fa-cles" class="mut">Choisissez l'immeuble : les boîtes à clés enregistrées s'afficheront ici.</div>
        <label>Code d'accès propre au logement (s'il y en a un)${ed ? ' — laisser vide pour garder le code actuel' : ''}</label><input name="code" autocomplete="off">
        <h3>5. Critères de sélection des candidats</h3>${cases('crit', CHOIX.criteres)}
        <label>Candidat sans dossier de crédit (nouveaux arrivants, jeunes, étudiants…) ?</label>${radios('sanscredit', CHOIX.sansCredit, '')}
        <label>Locataires sous l'OMH acceptés ?</label>${radios('omh', ['Non', 'Oui'], '')}
        <div id="fa-omh"></div>
        <label>Autres informations pertinentes</label><textarea name="autres"></textarea>
        <div class="btns"><button class="btn">${ed ? 'Enregistrer les modifications' : 'Enregistrer le logement'}</button>${ed ? '<button type="button" class="btn sec" id="fa-ann">Annuler</button>' : ''}</div>
      </form><div id="m"></div></div>`;
    const f = vue().querySelector('#fa');
    const fa = vue().querySelector('#fa-ann'); if (fa) fa.onclick = () => { S.tab = 'logements'; coquille(); };
    const coches = (n) => [...f.querySelectorAll(`input[name="${n}"]:checked`)].map(x => x.value);
    const radio = (n) => (f.querySelector(`input[name="${n}"]:checked`) || {}).value || null;
    let locs = [], logs = [];
    const majOMH = () => { vue().querySelector('#fa-omh').innerHTML = radio('omh') === 'Oui' ? grilleOMH(f.elements.grandeur.value, f.elements.pp.value) : ''; };
    const majLoc = async () => {
      const el = vue().querySelector('#fa-loc'), logId = f.elements.logement ? f.elements.logement.value : '';
      if (radio('habite') !== 'Oui') { el.innerHTML = ''; return; }
      if (!logId) { el.innerHTML = `<div class="msg info">Choisissez l'immeuble et le logement : je vais chercher le locataire dans la base de données.</div><div class="row"><div><label>Départ du locataire actuel</label><input name="depart" type="date" value="${esc((ed && ed.depart_locataire) || '')}"></div><div><label>Qui contacter pour visiter</label><input name="contact" value="${esc((ed && ed.coordonnees_contact) || '')}"></div></div>`; return; }
      const { data } = await sb.from('locataires').select('nom, telephone, courriel, debut_bail, fin_bail').eq('logement_id', logId).order('fin_bail', { ascending: false });
      locs = data || [];
      const fin = locs.length ? locs[0].fin_bail : '';
      el.innerHTML = `${locs.length ? `<div class="card" style="background:var(--s2)"><b>👤 Locataire(s) trouvé(s) dans la base</b>${locs.map(l => `<div style="padding:6px 0;border-top:1px solid var(--line)"><b>${esc(l.nom)}</b> ${telLien(l.telephone)} ${courrielHTML(l.courriel)}<div class="mut">Bail du ${esc(fmtDate(l.debut_bail))} au <b>${esc(fmtDate(l.fin_bail))}</b></div></div>`).join('')}</div>` : '<div class="msg info">Aucun locataire trouvé dans la base pour ce logement.</div>'}
        <div class="row"><div><label>Départ du locataire actuel</label><input name="depart" type="date" value="${esc((ed && ed.depart_locataire) || fin || '')}"></div><div><label>Qui contacter pour visiter</label><input name="contact" value="${esc((ed && ed.coordonnees_contact) || (locs.length ? [locs[0].nom, fmtTel(locs[0].telephone)].filter(Boolean).join(', ') : ''))}"></div></div>
        ${fin ? `<p class="mut small">Fin du bail selon la base de données : ${esc(fmtDate(fin))}.</p>` : ''}
        <label style="display:flex;gap:10px;align-items:center;font-weight:700"><input type="checkbox" name="confirme" ${ed && ed.depart_confirme ? 'checked' : ''} style="width:24px;height:24px;min-height:0"> J'ai confirmé avec le gestionnaire que c'est bien la date de départ entendue</label>`;
    };
    f.elements.imm.onchange = async () => {
      const i = liste.find(x => x.id === f.elements.imm.value);
      const zl = vue().querySelector('#fa-log'), zc = vue().querySelector('#fa-cles');
      if (!i) { zl.innerHTML = ''; zc.innerHTML = '<span class="mut">Adresse non listée : aucune boîte à clés enregistrée.</span>'; majLoc(); return; }
      f.elements.rue.value = i.rue || '';
      const [{ data: lg }, { data: bx }] = await Promise.all([sb.from('logements').select('id, numero, grandeur, inclusions').eq('immeuble_id', i.id).order('numero'), sb.from('boites_a_cles').select('emplacement, cles_contenues').eq('immeuble_id', i.id)]);
      logs = lg || [];
      zl.innerHTML = `<label>Logement</label><select name="logement"><option value="">— Choisir l'appartement —</option>${logs.map(l => `<option value="${l.id}">App. ${esc(l.numero)}${l.grandeur ? ' · ' + esc(l.grandeur) : ''}</option>`).join('')}</select>`;
      zc.innerHTML = (bx || []).length ? `<div class="card" style="background:var(--s2)">🔑 ${(bx || []).map(b => `<div><b>${esc(b.emplacement || 'Boîte à clés')}</b>${b.cles_contenues ? ` <span class="mut">(${esc(b.cles_contenues)})</span>` : ''}</div>`).join('')}<div class="mut small">Le code se consulte dans le portail au moment de la visite.</div></div>` : '<div class="msg info">Aucune boîte à clés enregistrée pour cet immeuble.</div>';
      f.elements.logement.onchange = () => {
        const l = logs.find(x => x.id === f.elements.logement.value);
        if (l) { f.elements.numero.value = `${i.numero} app ${l.numero}`; if (l.grandeur && CHOIX.grandeur.includes(l.grandeur)) f.elements.grandeur.value = l.grandeur; majOMH(); }
        majLoc();
      };
      if (!f.elements.numero.value) f.elements.numero.value = i.numero + ' app ';
      majLoc();
    };
    f.querySelectorAll('input[name="habite"]').forEach(r => r.onchange = majLoc);
    f.querySelectorAll('input[name="omh"]').forEach(r => r.onchange = majOMH);
    f.elements.grandeur.onchange = majOMH; f.elements.pp.oninput = majOMH;
    if (ed) { // préremplir avec les informations actuelles du logement
      const mets = (n, v) => { if (f.elements[n] && v != null) f.elements[n].value = v; };
      const coche = (n, vals) => f.querySelectorAll(`input[name="${n}"]`).forEach(c => { c.checked = vals.some(v => norm(v) === norm(c.value)); });
      const liste2 = (s, sep) => String(s || '').split(sep).map(x => x.trim()).filter(Boolean);
      mets('rue', ed.rue); mets('numero', ed.numero); mets('dispo', ed.disponibilite); mets('pp', ed.prix_proprio); mets('pa', ed.prix_affiche); mets('pi2', ed.pieds_carres);
      ['grandeur', 'etage', 'marches', 'electro', 'surplus', 'depot'].forEach(n => { const v = { grandeur: ed.grandeur, etage: ed.etage, marches: ed.marches, electro: ed.electro_possible, surplus: ed.surplus_electro, depot: ed.depot_chien }[n]; if (v && f.elements[n]) { if (![...f.elements[n].options].some(o => o.value === v)) f.elements[n].add(new Option(v, v)); f.elements[n].value = v; } });
      if (ed.nb_stationnements != null) mets('stat', ed.nb_stationnements === 0 ? 'Aucun' : String(ed.nb_stationnements));
      const incl = liste2(ed.inclusions, /[,;\n]+/); coche('incl', incl); mets('incl2', [ed.inclusions_autres, ...incl.filter(x => !CHOIX.inclusions.some(c => norm(c) === norm(x)))].filter(Boolean).join(', '));
      coche('animaux', liste2(ed.animaux, /[,;\n]+/)); coche('crit', liste2(ed.criteres_selection, /[;\n]+|,(?![^(]*\))/));
      const radioSet = (n, v) => f.querySelectorAll(`input[name="${n}"]`).forEach(r => { r.checked = !!v && norm(r.value) === norm(v); });
      radioSet('habite', ed.habite == null ? null : (ed.habite ? 'Oui' : 'Non')); radioSet('sanscredit', ed.accepte_sans_credit); radioSet('omh', ed.accepte_omh);
      mets('autres', [ed.autres_infos].filter(Boolean).join('\n'));
      if (ed.immeuble_id && liste.some(i => i.id === ed.immeuble_id)) { f.elements.imm.value = ed.immeuble_id; await f.elements.imm.onchange(); f.elements.rue.value = ed.rue || ''; f.elements.numero.value = ed.numero || ''; if (ed.logement_id && f.elements.logement) { f.elements.logement.value = ed.logement_id; } }
      await majLoc(); majOMH();
    }
    f.onsubmit = async (e) => {
      e.preventDefault(); const m = vue().querySelector('#m');
      const num = (k) => { const v = val(f, k); return v == null ? null : Number(v); };
      const hab = radio('habite');
      const stat = val(f, 'stat');
      const a = { immeuble_id: val(f, 'imm'), logement_id: f.elements.logement ? (f.elements.logement.value || null) : null, rue: val(f, 'rue'), numero: val(f, 'numero'), disponibilite: val(f, 'dispo'), grandeur: val(f, 'grandeur'),
        prix_proprio: num('pp'), inclusions: coches('incl').join(', ') || null, inclusions_autres: val(f, 'incl2'), pieds_carres: num('pi2'), etage: val(f, 'etage'), marches: val(f, 'marches'),
        animaux: coches('animaux').join(', ') || null, depot_chien: val(f, 'depot'), electro_possible: val(f, 'electro'), surplus_electro: val(f, 'surplus'),
        nb_stationnements: stat == null ? null : (stat === 'Aucun' ? 0 : Number(stat)), habite: hab ? hab === 'Oui' : null,
        depart_locataire: f.elements.depart ? (f.elements.depart.value || null) : null, coordonnees_contact: f.elements.contact ? (f.elements.contact.value.trim() || null) : null,
        depart_confirme: f.elements.confirme ? f.elements.confirme.checked : null,
        criteres_selection: coches('crit').join('; ') || null, accepte_sans_credit: radio('sanscredit'), accepte_omh: radio('omh'), autres_infos: val(f, 'autres'), soumis_par: S.user.email, statut: 'en_attente' };
      if (hab === 'Oui' && f.elements.confirme && !f.elements.confirme.checked && !confirm('La date de départ n\'est pas encore confirmée avec le gestionnaire. Enregistrer quand même ?')) return;
      if (ed) { delete a.statut; delete a.soumis_par; a.prix_affiche = num('pa'); }
      const { data, error } = ed ? await sb.from('annonces').update(a).eq('id', ed.id).select('id').single() : await sb.from('annonces').insert(a).select('id').single();
      if (error) return msg(m, error.message);
      const code = val(f, 'code');
      if (code) { if (ed) await sb.from('annonce_codes').delete().eq('annonce_id', data.id); const r = await sb.from('annonce_codes').insert({ annonce_id: data.id, code }); if (r.error) return msg(m, 'Logement enregistré, mais le code n\'a pas pu l\'être : ' + r.error.message); }
      S.annonces = [];
      if (ed) { alert('Modifications enregistrées.'); S.tab = 'logements'; coquille(); return; }
      msg(m, 'Logement enregistré avec le statut « En attente ».', true); vueAjout();
    };
  }
  // Bouton « Copier » (courriels) partout dans le portail
  document.getElementById('bl-app').addEventListener('click', async (e) => {
    const b = e.target.closest('[data-cp]'); if (!b) return; e.preventDefault(); e.stopPropagation();
    try { await navigator.clipboard.writeText(b.dataset.cp); } catch { const t = document.createElement('textarea'); t.value = b.dataset.cp; document.body.appendChild(t); t.select(); document.execCommand('copy'); t.remove(); }
    b.classList.add('ok'); b.textContent = '✓ Copié'; setTimeout(() => { b.classList.remove('ok'); b.textContent = '📋 Copier'; }, 1800);
  }, true);

  // ---------- Démarrage ----------
  const h = location.hash;
  sb.auth.onAuthStateChange((evt) => {
    if (evt === 'PASSWORD_RECOVERY') ecranMotDePasse();
    else if (evt === 'SIGNED_OUT') { S.user = null; S.maintLance = false; ecranConnexion(); }
    else if (evt === 'SIGNED_IN' && !/type=(invite|recovery)/.test(h) && !S.user) demarrer();
  });
  if (/type=(invite|recovery)/.test(h)) setTimeout(ecranMotDePasse, 300); else demarrer();
})();
