#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
Back-office local de votre-fiche-google.fr  —  python3 admin.py
Ouvre http://127.0.0.1:8080  (interface d'administration)  et  http://127.0.0.1:8081  (aperçu du site généré).
Aucune dépendance : Python 3.8+ (Pillow optionnel pour convertir les images en WebP).
Tout reste sur votre ordinateur ; le bouton « Publier » envoie dist/ sur votre hébergement en FTP.
"""
import os, sys, re, io, json, html, shutil, zipfile, datetime, threading, webbrowser, unicodedata, ftplib, traceback
from http.server import HTTPServer, BaseHTTPRequestHandler, SimpleHTTPRequestHandler
from urllib.parse import urlparse, parse_qs, unquote, quote
from email.parser import BytesParser
from email.policy import default as email_policy

ROOT = os.path.dirname(os.path.abspath(__file__))
sys.path.insert(0, ROOT)
import build as B   # notre générateur

PAGES = os.path.join(ROOT, "pages"); ASSETS = os.path.join(ROOT, "assets"); IMG = os.path.join(ASSETS, "img")
DIST = os.path.join(ROOT, "dist"); TRASH = os.path.join(ROOT, "_corbeille")
ADMIN_PORT, PREVIEW_PORT = 8080, 8081
VERSION = "1.41"   # affiché en bas de la barre latérale et sur l'écran de connexion — vérifie que la mise à jour est bien active
ONLINE = os.environ.get("VFG_ONLINE") == "1"          # back-office hébergé (Passenger/o2switch) : aperçu via /apercu, publication par copie, cookies Secure
PREVIEW_BASE = "/apercu" if ONLINE else "http://127.0.0.1:" + str(PREVIEW_PORT)
LOG = []
USERS_PATH = os.path.join(ROOT, "users.json")
SESS_PATH = os.path.join(ROOT, "sessions.json"); SESS_TTL = 30 * 86400   # connexion conservée 30 jours (cookie durable + session serveur)
def load_sessions():
    try: return json.load(open(SESS_PATH, encoding="utf-8"))
    except Exception: return {}
def save_sessions(sess):
    now = int(__import__("time").time())
    sess = {t: v for t, v in sess.items() if v.get("t", 0) > now - SESS_TTL}
    try:
        json.dump(sess, open(SESS_PATH, "w", encoding="utf-8"))
        os.chmod(SESS_PATH, 0o600)
    except Exception: pass
    return sess
SESSIONS = load_sessions()   # token -> {"e": email, "t": horodatage}
import hashlib, secrets, http.cookies

def load_users():
    try: return json.load(open(USERS_PATH, encoding="utf-8"))
    except Exception: return []
def save_users(u): json.dump(u, open(USERS_PATH, "w", encoding="utf-8"), ensure_ascii=False, indent=1)
def hash_pw(pw, salt=None):
    salt = salt or secrets.token_hex(16)
    return salt, hashlib.pbkdf2_hmac("sha256", pw.encode("utf-8"), bytes.fromhex(salt), 200_000).hex()
def check_pw(user, pw): return secrets.compare_digest(hash_pw(pw, user["salt"])[1], user["hash"])
def find_user(email): return next((u for u in load_users() if u["email"].lower() == (email or "").lower()), None)
def upsert_user(email, pw, role, name=""):
    users = load_users(); salt, h = hash_pw(pw); u = find_user(email)
    if u:
        for x in users:
            if x["email"].lower() == email.lower():
                x.update({"salt": salt, "hash": h, "role": role})
                if name: x["name"] = name.strip()
    else: users.append({"email": email.strip(), "role": role, "salt": salt, "hash": h, "created": datetime.date.today().isoformat(), **({"name": name.strip()} if name else {})})
    save_users(users)

def display_name(u):
    """Nom lisible du compte : champ « name », sinon déduit de l'e-mail (jean-marc.d → Jean-Marc D)."""
    n = (u or {}).get("name", "").strip()
    if n: return n
    local = ((u or {}).get("email") or "").split("@")[0]
    return " ".join(w.capitalize() for w in re.split(r"[._\-]+", local) if w) or "Compte"
CURRENT_USER = {}
ROLES = {"admin": "Administrateur (tout)",
         "seo": "SEO (contenu + référencement + redirections + traductions + publication)",
         "client": "Client (pages, articles, médias + « Publier en ligne »)",
         "editeur": "Client (ancien nom « Éditeur »)"}
# Trois niveaux : admin (tout) · seo (contenu + référencement + publication) · client (contenu + publier en ligne).
# Un chemin absent de PERMS est ouvert à tous les comptes connectés. "editeur" (historique) = client.
_AS = ("admin", "seo")
PERMS = {
    "/settings": _AS,            # GET réservé admin (redirigé), POST seo limité aux clefs SEO
    "/users": ("admin",), "/user-del": ("admin",),
    "/delete": ("admin",),
    "/menu": ("admin",), "/popup": ("admin",), "/layout-save": ("admin",), "/navbar-save": ("admin",), "/layout-translate": ("admin",),
    "/test-mail": ("admin",), "/export": ("admin",),
    "/seo": _AS,
    "/redirects": _AS, "/redirect-add": _AS, "/redirect-del": _AS, "/redirect-import": _AS, "/redirect-code": _AS, "/redirect-export": _AS,
    "/theme-add": _AS, "/theme-del": _AS,
    "/translations": _AS, "/translate": _AS, "/translate-all": _AS, "/translate-batch": _AS, "/trans-slug": _AS, "/blocks-sync": _AS, "/blocks-sync-all": _AS,
    "/articles-import": _AS, "/alt-ia": _AS, "/optimize": _AS,
}
def role_of(u):
    r = (u or {}).get("role", "admin")
    return "client" if r == "editeur" else r
def allowed(path, role):
    base = path.split("?")[0]
    need = PERMS.get(base)
    return True if need is None else role in need


# ---------- Anti force brute (verrouillage 15 min après 5 échecs) ----------
LOCK_PATH = os.path.join(ROOT, ".login_attempts.json")
def _locks():
    try: return json.load(open(LOCK_PATH, encoding="utf-8"))
    except Exception: return {}
def login_locked(email):
    import time as _t
    v = _locks().get((email or "").lower())
    return bool(v and v.get("n", 0) >= 5 and v.get("t", 0) > _t.time() - 900)
def login_fail(email):
    import time as _t
    d = _locks(); k = (email or "").lower(); v = d.get(k, {"n": 0})
    if v.get("t", 0) < _t.time() - 900: v = {"n": 0}
    v["n"] = v.get("n", 0) + 1; v["t"] = int(_t.time()); d[k] = v
    try: json.dump(d, open(LOCK_PATH, "w", encoding="utf-8"))
    except Exception: pass
def login_clear(email):
    d = _locks(); d.pop((email or "").lower(), None)
    try: json.dump(d, open(LOCK_PATH, "w", encoding="utf-8"))
    except Exception: pass

def reset_token_for(email):
    """Crée un jeton « mot de passe oublié » (30 min) stocké haché dans users.json."""
    users = load_users(); tok = secrets.token_urlsafe(24)
    import time as _t
    for u in users:
        if u["email"].lower() == (email or "").lower():
            u["reset"] = {"h": hashlib.sha256(tok.encode()).hexdigest(), "t": int(_t.time()) + 1800}
            save_users(users); return tok
    return None
def reset_consume(email, tok):
    users = load_users()
    import time as _t
    for u in users:
        if u["email"].lower() == (email or "").lower():
            r = u.get("reset") or {}
            if r.get("t", 0) >= int(_t.time()) and secrets.compare_digest(r.get("h", ""), hashlib.sha256((tok or "").encode()).hexdigest()):
                u.pop("reset", None); save_users(users); return True
    return False
def send_reset_mail(email, url):
    """Envoie le lien de réinitialisation via sendmail (hébergement) — en local, l'affiche dans le journal."""
    subject = "Réinitialisation du mot de passe — back-office"
    text = f"Bonjour,\n\nPour choisir un nouveau mot de passe du back-office, ouvrez ce lien (valable 30 minutes) :\n{url}\n\nSi vous n'êtes pas à l'origine de cette demande, ignorez ce message."
    frm = B.CONFIG.get("FORM_FROM") or ("noreply@" + B.CONFIG.get("SITE_URL", "//site").split("//")[-1].strip("/"))
    if not ONLINE:
        log(f"🔑 Lien de réinitialisation pour {email} : {url}"); return True
    try:
        import subprocess, base64
        msg = (f"To: {email}\r\nFrom: {frm}\r\nSubject: =?UTF-8?B?" + base64.b64encode(subject.encode()).decode() + "?=\r\n"
               f"MIME-Version: 1.0\r\nContent-Type: text/plain; charset=UTF-8\r\n\r\n{text}")
        pr = subprocess.run(["/usr/sbin/sendmail", "-t", "-oi", f"-f{frm}"], input=msg.encode("utf-8"), timeout=20)
        return pr.returncode == 0
    except Exception as e:
        log(f"✘ Envoi du mail de réinitialisation impossible : {e}"); return False

JOURNAL_PATH = os.path.join(ROOT, "journal.log")
def log(msg):
    LOG.insert(0, f"{datetime.datetime.now():%H:%M:%S} — {msg}"); del LOG[30:]
    try:
        who = (CURRENT_USER or {}).get("email") or "système"
    except Exception:
        who = "système"
    try:
        with open(JOURNAL_PATH, "a", encoding="utf-8") as f:
            f.write(f"{datetime.datetime.now():%Y-%m-%d %H:%M:%S}\t{who}\t{msg}\n")
    except Exception: pass
def journal_read(month):
    """Entrées [date, compte, action] du mois YYYY-MM, plus récentes d'abord."""
    out = []
    try:
        for line in open(JOURNAL_PATH, encoding="utf-8"):
            if line.startswith(month):
                p = line.rstrip("\n").split("\t", 2)
                if len(p) == 3: out.append(p)
    except Exception: pass
    return out[::-1]
def journal_months():
    ms = set()
    try:
        for line in open(JOURNAL_PATH, encoding="utf-8"):
            if len(line) >= 7: ms.add(line[:7])
    except Exception: pass
    return sorted(ms, reverse=True)
def esc(s): return html.escape(str(s or ""), quote=True)
def slugify(s):
    s = unicodedata.normalize("NFKD", s).encode("ascii", "ignore").decode(); s = re.sub(r"[^a-zA-Z0-9]+", "-", s).strip("-").lower()
    return s or "page"
def rel(p): return os.path.relpath(p, PAGES).replace(os.sep, "/")
def safe_join(base, *parts):
    p = os.path.abspath(os.path.join(base, *parts))
    if not p.startswith(os.path.abspath(base)): raise ValueError("chemin interdit")
    return p

# ------------------------------------------------------------------ front-matter
def read_page(relpath):
    meta, body = B.parse(safe_join(PAGES, relpath)); return meta, body
def write_page(relpath, meta, body):
    path = safe_join(PAGES, relpath); os.makedirs(os.path.dirname(path), exist_ok=True)
    fm = "\n".join(f"{k}: {v}" for k, v in meta.items() if str(v).strip() != "")
    open(path, "w", encoding="utf-8").write(f"---\n{fm}\n---\n{body.strip()}\n")
def list_pages():
    out = []
    for dp, dn, fns in os.walk(PAGES):
        for fn in sorted(fns):
            if fn.endswith(".html"):
                r = rel(os.path.join(dp, fn)); meta, _ = read_page(r)
                out.append({"file": r, "url": B.url_from_path(r), "title": meta.get("title", r), "type": meta.get("type", "page"), "draft": meta.get("draft", "false") == "true"})
    return sorted(out, key=lambda p: p["url"])
def group(url):
    if url == "/": return "Accueil"
    seg = url.strip("/").split("/")[0]
    if seg and (seg == B.BLOG_BASE or any(seg == sl for sl, _ in B.GUIDE_THEMES)): return "Guide (blog)"
    return {"offre": "Offre", "metiers": "Métiers", "guide": "Guide (blog)", "audit-gratuit": "Conversion", "contact": "Conversion", "resultats": "Preuve", "faq": "Réassurance", "a-propos": "Agence", "agence-fiche-google-bordeaux": "Agence", "mentions-legales": "Légal", "confidentialite": "Légal", "cgv": "Légal"}.get(seg, "Autres")

# ------------------------------------------------------------------ Markdown minimal → HTML
def md_to_html(md):
    lines = md.replace("\r\n", "\n").split("\n"); out = []; para = []; lst = None
    def inline(t):
        t = esc(t)
        t = re.sub(r"\*\*(.+?)\*\*", r"<strong>\1</strong>", t); t = re.sub(r"(?<!\*)\*(?!\*)(.+?)\*", r"<em>\1</em>", t)
        t = re.sub(r"\[(.+?)\]\((.+?)\)", r'<a href="\2">\1</a>', t); t = re.sub(r"`(.+?)`", r"<code>\1</code>", t)
        return t
    def flush():
        nonlocal para, lst
        if para: out.append("<p>" + inline(" ".join(para)) + "</p>"); para = []
        if lst: out.append(f"</{lst}>"); lst = None
    for ln in lines:
        s = ln.rstrip()
        if not s.strip(): flush(); continue
        m = re.match(r"^(#{2,4})\s+(.*)", s)
        if m:
            flush(); lvl = len(m.group(1)); txt = m.group(2).strip(); hid = slugify(txt)[:60]
            out.append(f'<h{lvl} id="{hid}">{inline(txt)}</h{lvl}>'); continue
        m = re.match(r"^[-*]\s+(.*)", s)
        if m:
            if para: out.append("<p>" + inline(" ".join(para)) + "</p>"); para = []
            if lst != "ul":
                if lst: out.append(f"</{lst}>")
                out.append("<ul>"); lst = "ul"
            out.append(f"<li>{inline(m.group(1))}</li>"); continue
        m = re.match(r"^\d+[.)]\s+(.*)", s)
        if m:
            if para: out.append("<p>" + inline(" ".join(para)) + "</p>"); para = []
            if lst != "ol":
                if lst: out.append(f"</{lst}>")
                out.append("<ol>"); lst = "ol"
            out.append(f"<li>{inline(m.group(1))}</li>"); continue
        if s.startswith(">"): flush(); out.append(f'<div class="callout"><p>{inline(s.lstrip("> "))}</p></div>'); continue
        if s.strip().startswith("<"): flush(); out.append(s); continue   # HTML brut autorisé
        para.append(s.strip())
    flush(); return "\n".join(out)

# ------------------------------------------------------------------ gabarits
ARTICLE_TPL = """<div class="hero-img"><img src="{image}" alt="{title_esc}" width="1200" height="675" loading="eager"><div class="hero-img-title"><div class="container">{{{{BREADCRUMB}}}}</div></div></div>
<div class="container">
  <div class="article-head">
    <div class="article-meta"><span><svg viewBox="0 0 24 24"><circle cx="12" cy="12" r="9"/><path d="M12 7v5l3 2"/></svg>{{{{READING}}}} min de lecture</span><span><svg viewBox="0 0 24 24"><rect x="3" y="5" width="18" height="16" rx="2"/><path d="M3 10h18M8 3v4M16 3v4"/></svg>{{{{DATE_FR}}}}</span></div>
    <h1>{title_esc}</h1><p class="sub">{subtitle_esc}</p>
  </div>
  <div class="article-layout">
    <aside class="sidebar">
      <div class="sidebar-box"><h4>Sommaire</h4><ul class="toc">{toc}</ul>
        <h4 class="mt-2">Partager l'article</h4><div class="share"><a href="https://www.linkedin.com/sharing/share-offsite/?url={share}" target="_blank" rel="noopener" aria-label="LinkedIn"><svg viewBox="0 0 24 24"><path d="M4.98 3.5C4.98 4.88 3.87 6 2.5 6S0 4.88 0 3.5 1.12 1 2.5 1s2.48 1.12 2.48 2.5zM.5 8h4V24h-4V8zm7.5 0h3.8v2.2h.1c.5-1 1.8-2.2 3.8-2.2 4 0 4.8 2.6 4.8 6V24h-4v-8.5c0-2 0-4.6-2.8-4.6s-3.2 2.2-3.2 4.5V24H8V8z"/></svg></a><a href="https://www.facebook.com/sharer/sharer.php?u={share}" target="_blank" rel="noopener" aria-label="Facebook"><svg viewBox="0 0 24 24"><path d="M22 12a10 10 0 1 0-11.6 9.9v-7H7.9V12h2.5V9.8c0-2.5 1.5-3.9 3.8-3.9 1.1 0 2.2.2 2.2.2v2.5h-1.3c-1.2 0-1.6.8-1.6 1.6V12h2.8l-.4 2.9h-2.3v7A10 10 0 0 0 22 12z"/></svg></a></div>
      </div>
      <div class="sidebar-box blue"><h4>L'auteur</h4><div class="author"><img src="/assets/img/jean-marc-laplace.png" alt="Jean-Marc Laplace"><div><b>Jean-Marc Laplace</b><span>Co-dirigeant Beecom' · expert fiche Google</span></div></div></div>
      <div class="sidebar-box dark"><h4>Audit gratuit</h4><p>Votre fiche est-elle dans le top 3 ? On vous le dit sous 48 h, gratuitement.</p><a class="btn btn-primary btn-sm" href="/audit-gratuit/" style="width:100%">Demander mon audit</a></div>
    </aside>
    <article class="prose">
{body}
      <div class="cta-inline"><p>Votre fiche mérite un diagnostic.<small>Audit gratuit sous 48 h, sans engagement.</small></p><a class="btn btn-primary" href="/audit-gratuit/">Demander mon audit</a></div>
    </article>
  </div>
  <section class="section related"><h2>À lire aussi</h2><div class="grid grid-3">{{{{ARTICLE_CARDS:{theme}:fill3}}}}</div></section>
</div>"""

PAGE_TPL = """<section class="hero hero-light hero-simple">
  <div class="container-narrow center">
    {{{{BREADCRUMB}}}}
    <h1>{title_esc}</h1>
    <p class="lead" style="margin:1.2rem auto 0">{subtitle_esc}</p>
  </div>
</section>
<section class="section"><div class="container-narrow prose">
{body}
</div></section>
<section class="section"><div class="container"><div class="cta-band"><div><span class="sec-label">Et maintenant ?</span><h2>Votre fiche mérite mieux qu'une page oubliée.</h2><p>Audit gratuit sous 48 h, sans engagement.</p></div><div class="actions"><a class="btn btn-primary btn-lg" href="/audit-gratuit/">Audit gratuit de ma fiche</a></div></div></div></section>"""

SNIPPETS = {
 "Titre de section (H2)": '<h2 id="mon-titre">Mon titre</h2>',
 "Sous-titre (H3)": '<h3>Mon sous-titre</h3>',
 "Paragraphe": '<p>Votre texte…</p>',
 "Liste à puces": '<ul><li>Point 1</li><li>Point 2</li></ul>',
 "Encadré « Bon à savoir »": '<div class="callout"><p><b>Bon à savoir :</b> …</p></div>',
 "Encadré bleu": '<div class="callout blue"><p>…</p></div>',
 "L'essentiel à retenir": '<div class="essential" id="essentiel"><h2>L\'essentiel à retenir</h2><ul><li>…</li><li>…</li></ul></div>',
 "Image": '<img src="/assets/img/uploads/NOM.webp" alt="Description de l\'image" loading="lazy">',
 "2 images côte à côte": '<div class="img-2"><img src="/assets/img/uploads/A.webp" alt=""><img src="/assets/img/uploads/B.webp" alt=""></div>',
 "Bouton audit": '<p><a class="btn btn-primary" href="/audit-gratuit/">Audit gratuit de ma fiche</a></p>',
 "CTA encart": '<div class="cta-inline"><p>Titre accrocheur.<small>Sous-texte.</small></p><a class="btn btn-primary" href="/audit-gratuit/">Demander mon audit</a></div>',
 "Question FAQ": '<div class="faq"><details><summary>Question ?</summary><div class="answer"><p>Réponse.</p></div></details></div>',
 "Tableau": '<table><thead><tr><th>Colonne 1</th><th>Colonne 2</th></tr></thead><tbody><tr><td>…</td><td>…</td></tr></tbody></table>',
 "Lien": '<a href="/offre/">texte du lien</a>',
 "Vidéo YouTube": '<div style="aspect-ratio:16/9"><iframe width="100%" height="100%" src="https://www.youtube.com/embed/ID_VIDEO" title="Vidéo" loading="lazy" allowfullscreen style="border:0;border-radius:20px"></iframe></div>',
}

# ------------------------------------------------------------------ UI
CSS = """
:root{--navy:#010720;--navy2:#0b1a33;--pink:#d82474;--blue:#1a73e8;--ink:#222;--line:#ebebeb;--soft:#f7f7f8;--grey:#717171;--sb:230px}
*{box-sizing:border-box}body{margin:0;font-family:Poppins,system-ui,-apple-system,Segoe UI,Roboto,sans-serif;background:var(--soft);color:var(--ink);font-size:14.5px;line-height:1.55;font-weight:400}
b,strong{font-weight:600}h1,h2,h3,h4{font-weight:500;letter-spacing:-.01em;color:var(--navy)}
a{color:var(--blue);text-decoration:none}a:hover{text-decoration:underline}
.sidebar{position:fixed;top:0;left:0;bottom:0;width:var(--sb);background:var(--navy);color:#c5cfdb;display:flex;flex-direction:column;z-index:10}
.sidebar .brand{padding:1.1rem 1.2rem;border-bottom:1px solid rgba(255,255,255,.08);display:flex;align-items:center;gap:.6rem}
.sidebar .brand img{height:auto;width:100%;max-width:190px}
.sidebar .brand small{display:block;font-size:.7rem;color:#8fa0b4;letter-spacing:2px;text-transform:uppercase}
.sidebar nav{padding:.6rem 0;flex:1;overflow:auto}
.sidebar .sec{font-size:.68rem;letter-spacing:1.2px;text-transform:uppercase;color:#6d7f94;padding:1rem 1.2rem .3rem;font-weight:500}
.sidebar a{display:flex;align-items:center;gap:.7rem;color:#c5cfdb;padding:.55rem 1.2rem;font-size:.89rem;font-weight:400;border-left:3px solid transparent}
.sidebar a:hover{background:rgba(255,255,255,.06);color:#fff;text-decoration:none}
.sidebar a.on{background:rgba(255,255,255,.08);color:#fff;border-left-color:var(--pink)}
.sidebar a .i{width:20px;text-align:center;opacity:.9}
.sidebar .foot{padding:1rem 1.2rem;border-top:1px solid rgba(255,255,255,.08);font-size:.75rem;color:#8fa0b4}
.topbar{position:sticky;top:0;z-index:5;margin-left:var(--sb);background:#fff;border-bottom:1px solid var(--line);padding:.6rem 1.6rem;display:flex;align-items:center;gap:.8rem}
.topbar h1{font-size:1.12rem;margin:0;flex:1;color:var(--navy);font-weight:500}
main{margin-left:var(--sb);max-width:1240px;padding:1.9rem 2rem 3.5rem}
h2{font-size:1rem;margin:1.8rem 0 .7rem;color:var(--navy);font-weight:500}\nmain>h1{display:none}
.card{background:#fff;border:1px solid var(--line);border-radius:14px;padding:1.5rem 1.7rem;margin-bottom:1.2rem;box-shadow:0 1px 2px rgba(0,0,0,.03)}
.btn{display:inline-block;background:linear-gradient(42deg,#d82474,#f54839);color:#fff;border:0;border-radius:10px;padding:.58rem 1.2rem;font-weight:500;cursor:pointer;font-family:inherit;font-size:.87rem;text-decoration:none!important;line-height:1.3;transition:filter .15s}.btn:hover{filter:brightness(1.05)}
.btn.sec{background:#fff;color:var(--ink);border:1px solid #c7c7c7;font-weight:500}.btn.sec:hover{border-color:var(--ink)}.btn.blue{background:var(--blue)}.btn.sm{padding:.32rem .75rem;font-size:.78rem}.btn.danger{background:#b3134f}
.btn:disabled{opacity:.45;cursor:not-allowed}
table{width:100%;border-collapse:collapse;font-size:.88rem}th,td{text-align:left;padding:.6rem .6rem;border-bottom:1px solid var(--line);vertical-align:top}th{color:var(--grey);font-weight:500;font-size:.78rem;text-transform:none;letter-spacing:0}
tr:hover td{background:#fafbfc}
label{display:block;font-weight:500;font-size:.84rem;margin:1rem 0 .35rem;color:var(--ink)}input[type=text],input[type=url],input[type=password],input[type=number],select,textarea{width:100%;font:inherit;padding:.6rem .8rem;border:1px solid #d9d9d9;border-radius:10px;background:#fff}
input:focus,select:focus,textarea:focus{outline:0;border-color:var(--ink);box-shadow:0 0 0 3px rgba(34,34,34,.08)}
textarea{min-height:140px}textarea.code{font-family:ui-monospace,SFMono-Regular,Menlo,Consolas,monospace;font-size:13px;min-height:520px;line-height:1.5;tab-size:2}
.row{display:grid;grid-template-columns:1fr 1fr;gap:1rem}.row3{display:grid;grid-template-columns:1fr 1fr 1fr;gap:1rem}
.help{font-size:.78rem;color:var(--grey);margin:.25rem 0 0;font-weight:400}.msg{background:#e6f4ea;color:#1e7e34;padding:.7rem 1rem;border-radius:10px;margin-bottom:1rem;border-left:4px solid #34A853}.err{background:#fde8ef;color:#b3134f;border-left-color:#d82474}
.tag{display:inline-block;font-size:.7rem;padding:.14rem .55rem;border-radius:100px;background:#f0f4ff;color:var(--blue);font-weight:500}
.tag.d{background:#fff3cd;color:#8a6d00}
.snips{display:flex;flex-wrap:wrap;gap:.35rem;margin:.6rem 0}.snips button{font:inherit;font-size:.76rem;padding:.28rem .6rem;border-radius:100px;border:1px solid var(--line);background:#fff;cursor:pointer}.snips button:hover{border-color:var(--blue);color:var(--blue)}
.imgs{display:grid;grid-template-columns:repeat(auto-fill,minmax(160px,1fr));gap:.8rem}.imgs div{background:#fff;border:1px solid var(--line);border-radius:10px;padding:.5rem;font-size:.72rem;word-break:break-all}.imgs img{width:100%;height:100px;object-fit:cover;border-radius:6px;background:#eee}
.actions{display:flex;gap:.6rem;flex-wrap:wrap;align-items:center}
.sec-card{margin-bottom:1.2rem}.sec-card.dragover{outline:2px dashed var(--blue);outline-offset:3px}
.sec-tools{display:flex;gap:.35rem;align-items:center;margin-left:auto;font-size:.75rem}.sec-tools .drag{cursor:grab;color:var(--grey);font-size:1.05rem;padding:0 .25rem}.sec-tools .mv{background:none;border:1px solid var(--line);border-radius:6px;cursor:pointer;font-size:.7rem;padding:.1rem .35rem}.sec-tools .tool{border:1px solid var(--line);border-radius:100px;padding:.15rem .55rem;color:var(--grey);font-weight:500}.sec-tools .tool:hover{color:var(--blue);border-color:var(--blue);text-decoration:none}.sec-tools .tool.danger{color:#c62828;border-color:#f1c9c9}
.sec-card>h2 .sec-title{margin-right:.4rem}.sec-card>h2 .chev{margin-left:.6rem}
.opts{border:1px dashed #cfd6df;border-radius:10px;padding:.55rem .9rem;margin-bottom:.9rem;background:#fbfcfd}.opts summary{cursor:pointer;font-size:.82rem;font-weight:500;color:var(--grey)}
.palette{display:flex;flex-wrap:wrap;gap:.5rem;align-items:center}.palette .sw{display:flex;flex-direction:column;align-items:center;gap:.15rem;cursor:pointer;margin:0}.palette .sw input{display:none}.palette .sw span{width:34px;height:34px;border-radius:9px;border:1.5px solid var(--line);display:block}.palette .sw small{font-size:.62rem;color:var(--grey)}.palette .sw input:checked+span{box-shadow:0 0 0 3px #cfe0fb;border-color:var(--blue)}.sec-card>h2{margin:0 0 .2rem;font-size:1rem;font-weight:500;display:flex;align-items:center;gap:.6rem;cursor:pointer}.sec-card>h2 .chev{font-size:.8rem;color:var(--grey);transition:.2s}.sec-card.closed>h2 .chev{transform:rotate(-90deg)}.sec-card.closed .sec-body{display:none}.sec-body{margin-top:.6rem}
.fgrid{display:grid;grid-template-columns:1fr 1fr;gap:0 1.5rem}.fgrid .full{grid-column:1/-1}@media(max-width:1100px){.fgrid{grid-template-columns:1fr}}
.rep{border:1px dashed #cfd6df;border-radius:12px;padding:.6rem .9rem .9rem;margin:.6rem 0;background:#fbfcfd}.rep-head{display:flex;align-items:center;gap:.6rem;font-size:.8rem;color:var(--grey);font-weight:500}.rep-head .del{margin-left:auto;font-size:.75rem;color:#c62828;background:none;border:1px solid #f1c9c9;border-radius:100px;padding:.15rem .6rem;cursor:pointer}.rep-head .mv{background:none;border:1px solid var(--line);border-radius:6px;cursor:pointer;font-size:.75rem;padding:.1rem .4rem}
.ico-pick{display:flex;flex-wrap:wrap;gap:.35rem}.ico-pick label{margin:0;cursor:pointer}.ico-pick input{display:none}.ico-pick span{display:flex;width:36px;height:36px;border-radius:9px;border:1.5px solid var(--line);align-items:center;justify-content:center;background:#fff}.ico-pick svg{width:18px;height:18px;stroke:#1a73e8;fill:none;stroke-width:1.9;stroke-linecap:round;stroke-linejoin:round}.ico-pick input:checked+span{border-color:#1a73e8;background:#e8f0fe;box-shadow:0 0 0 2px #e8f0fe}
.imgf{display:flex;gap:.9rem;align-items:flex-start}.imgf img{width:120px;height:90px;object-fit:contain;background:repeating-conic-gradient(#eee 0 25%,#fff 0 50%) 0 0/16px 16px;border:1px solid var(--line);border-radius:8px}.imgf .size{font-size:.76rem;color:var(--grey);margin-top:.3rem}.imgf .size b{color:var(--navy)}
.sizes td:first-child{white-space:nowrap;font-weight:500}
.sticky-actions{position:sticky;bottom:0;background:#fff;border-top:1px solid var(--line);padding:.8rem 0;margin-top:1rem;z-index:5}
pre{background:#0b1a33;color:#c5cfdb;padding:1rem;border-radius:10px;font-size:.78rem;overflow:auto;max-height:260px}
.kpi{display:flex;gap:1rem;flex-wrap:wrap;margin-bottom:1rem}.kpi div{background:#fff;border:1px solid var(--line);border-radius:12px;padding:.8rem 1.1rem;min-width:150px;font-size:.8rem;color:var(--grey)}.kpi b{display:block;font-size:1.4rem;color:var(--ink);font-weight:600}
.dd{position:relative;display:inline-block}.dd>summary{list-style:none;cursor:pointer;display:inline-flex;align-items:center;gap:.45rem}
.dd>summary::-webkit-details-marker{display:none}
.dd .dd-m{position:absolute;top:calc(100% + 6px);left:0;background:#fff;border:1px solid var(--line);border-radius:12px;box-shadow:0 8px 28px rgba(0,0,0,.1);min-width:200px;padding:.4rem;z-index:40}
.dd .dd-m.dd-r{left:auto;right:0}
.dd .dd-m a{display:block;padding:.5rem .7rem;border-radius:8px;color:var(--ink);font-size:.86rem;text-decoration:none}
.dd .dd-m a:hover{background:#f5f5f5;text-decoration:none}
.btn.navy{background:var(--navy);color:#fff}.btn.navy:hover{filter:brightness(1.4)}
.acct>summary{font-size:.85rem;color:var(--ink);padding:.3rem .6rem .3rem .35rem;border-radius:100px;border:1px solid var(--line);background:#fff}
.acct>summary:hover{border-color:#c7c7c7}
.acct .ava{display:inline-flex;align-items:center;justify-content:center;width:28px;height:28px;border-radius:50%;background:var(--navy);color:#fff;font-size:.72rem;font-weight:600;letter-spacing:.5px}
.acct .acct-n{font-weight:500}.acct .chev-s{font-size:.62rem;color:var(--grey)}
.acct-head{padding:.5rem .7rem .55rem;border-bottom:1px solid var(--line);margin-bottom:.3rem}.acct-head b{display:block;font-weight:600;font-size:.88rem}.acct-head small{color:var(--grey);font-size:.74rem}
.hgrid{display:flex;gap:1.6rem;align-items:center;flex-wrap:wrap}
.hring{position:relative;width:118px;height:118px;flex:none}
.hring svg{transform:rotate(-90deg)}
.hring .pct{position:absolute;inset:0;display:flex;flex-direction:column;align-items:center;justify-content:center}
.hring .pct b{font-size:1.5rem;font-weight:600;color:var(--navy);line-height:1}.hring .pct span{font-size:.7rem;color:var(--grey);margin-top:.2rem}
.hitems{display:grid;grid-template-columns:1fr 1fr;gap:.55rem;flex:1;min-width:300px}
.hit{display:flex;gap:.6rem;align-items:center;padding:.6rem .8rem;border-radius:12px;font-size:.84rem;background:#f2f8f4;color:#14532d}
.hit.ko{background:#fbf3f4;color:#8e2040}
.hit .hi{flex:none;width:22px;height:22px;border-radius:50%;display:inline-flex;align-items:center;justify-content:center;background:#fff;font-size:.72rem}
.hit a{color:inherit;text-decoration:underline}
@media(max-width:900px){.hitems{grid-template-columns:1fr}}
.acct .i svg,.sidebar .i svg,.dd .i svg{width:16px;height:16px;vertical-align:-3px}
.sidebar a .i{display:inline-flex;width:20px;justify-content:center;opacity:.85}
.jrnl{font-size:.84rem}.jrnl td{padding:.42rem .6rem}.jrnl .t{white-space:nowrap;color:var(--grey);font-size:.78rem}.jrnl .u{white-space:nowrap;color:var(--grey);font-size:.78rem}
.sante li{list-style:none;padding:.3rem 0;display:flex;gap:.6rem;align-items:baseline}.sante{margin:0;padding:0}.sante .ok{color:#1e7e34}.sante .ko{color:#b3134f}
@media (max-width:900px){:root{--sb:0px}.sidebar{display:none}}
"""
_SV = lambda d: f'<svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.8" stroke-linecap="round" stroke-linejoin="round">{d}</svg>'
ICONS = {
    "home": _SV('<path d="M3 10.5 12 3l9 7.5"/><path d="M5 9.5V21h14V9.5"/>'),
    "pages": _SV('<path d="M14 3H6a1 1 0 0 0-1 1v16a1 1 0 0 0 1 1h12a1 1 0 0 0 1-1V8z"/><path d="M14 3v5h5"/><path d="M9 13h6M9 17h6"/>'),
    "plus": _SV('<path d="M12 5v14M5 12h14"/>'),
    "library": _SV('<rect x="3" y="3" width="8" height="8" rx="1.5"/><rect x="13" y="3" width="8" height="8" rx="1.5"/><rect x="3" y="13" width="8" height="8" rx="1.5"/><rect x="13" y="13" width="8" height="8" rx="1.5"/>'),
    "article": _SV('<path d="M12 20h9"/><path d="M16.5 3.5a2.1 2.1 0 0 1 3 3L7 19l-4 1 1-4z"/>'),
    "image": _SV('<rect x="3" y="4" width="18" height="16" rx="2"/><circle cx="9" cy="10" r="1.6"/><path d="m21 16-4.5-4.5L7 21"/>'),
    "menu": _SV('<path d="M4 6h16M4 12h16M4 18h16"/>'),
    "popup": _SV('<rect x="4" y="5" width="16" height="12" rx="2"/><path d="M8 21h8"/>'),
    "globe": _SV('<circle cx="12" cy="12" r="9"/><path d="M3 12h18M12 3a14 14 0 0 1 0 18M12 3a14 14 0 0 0 0 18"/>'),
    "search": _SV('<circle cx="11" cy="11" r="7"/><path d="m21 21-4.3-4.3"/>'),
    "redirect": _SV('<path d="M4 17h9a5 5 0 0 0 5-5V6"/><path d="m14 10 4-4 4 4" transform="translate(-4,0)"/>'),
    "settings": _SV('<path d="M4 7h10M18 7h2M4 17h2M10 17h10"/><circle cx="16" cy="7" r="2.2"/><circle cx="8" cy="17" r="2.2"/>'),
    "users": _SV('<circle cx="9" cy="8" r="3.2"/><path d="M3.5 20a5.5 5.5 0 0 1 11 0"/><path d="M16 11a3 3 0 1 0-2-5.2"/><path d="M15.5 14.5a5.5 5.5 0 0 1 5 5.5"/>'),
    "help": _SV('<circle cx="12" cy="12" r="9"/><path d="M9.5 9a2.5 2.5 0 1 1 3.8 2.1c-.8.5-1.3 1-1.3 1.9"/><circle cx="12" cy="17" r=".4"/>'),
    "account": _SV('<circle cx="12" cy="8" r="3.4"/><path d="M5 20a7 7 0 0 1 14 0"/>'),
    "eye": _SV('<path d="M2 12s3.5-6 10-6 10 6 10 6-3.5 6-10 6-10-6-10-6z"/><circle cx="12" cy="12" r="2.6"/>'),
    "download": _SV('<path d="M12 4v11"/><path d="m7 11 5 5 5-5"/><path d="M5 20h14"/>'),
}
def _ic(n): return ICONS.get(n, n)

def layout(title, body, active="", user=None):
    groups = [
        ("", [("/", _ic("home"), "Tableau de bord")]),
        ("Contenu", [("/pages", _ic("pages"), "Toutes les pages"), ("/new-page", _ic("plus"), "Ajouter une page"), ("/library", _ic("library"), "Bibliothèque"), ("/articles", _ic("article"), "Articles"), ("/new-article", _ic("plus"), "Ajouter un article"), ("/images", _ic("image"), "Médias")]),
        ("Site", [("/menu", _ic("menu"), "Menu & pied de page"), ("/popup", _ic("popup"), "Pop-up"), ("/translations", _ic("globe"), "Traductions"), ("/seo", _ic("search"), "SEO"), ("/redirects", _ic("redirect"), "Redirections"), ("/settings", _ic("settings"), "Réglages")]),
        ("Compte", [("/profile", _ic("account"), "Mon compte"), ("/users", _ic("users"), "Utilisateurs"), ("/help", _ic("help"), "Aide")]),
    ]
    user = user or CURRENT_USER
    role = role_of(user)
    groups = [(sec, [it for it in items if allowed(it[0], role)]) for sec, items in groups]
    groups = [(sec, items) for sec, items in groups if items]
    nav = ""
    for sec, items in groups:
        if sec: nav += f'<div class="sec">{sec}</div>'
        nav += "".join(f'<a href="{u}" class="{"on" if u == active else ""}"><span class="i">{i}</span>{t}</a>' for u, i, t in items)
    if role in ("admin", "seo"):
        pub_btn = ('<form method="post" action="/publish" style="margin:0" onsubmit="return confirm(\'Publier sur la PRÉPROD ?\')"><input type="hidden" name="target" value="preprod"><button class="btn sm sec" title="Régénère en mode préprod (noindex + mot de passe) puis envoie le site par FTP sur la préprod">Publier en préprod</button></form>'
                   '<form method="post" action="/publish" style="margin:0" onsubmit="return confirm(\'ATTENTION : publier en PRODUCTION (site public, indexable par Google). Continuer ?\')"><input type="hidden" name="target" value="prod"><button class="btn sm" title="Régénère en mode production puis envoie le site par FTP sur le domaine public">Publier en prod</button></form>')
    else:   # client : un seul bouton, simple — régénère et met en ligne
        pub_btn = ('<form method="post" action="/publish" style="margin:0" onsubmit="return confirm(\'Mettre vos modifications EN LIGNE sur le site public ?\')"><input type="hidden" name="target" value="prod"><button class="btn sm" title="Régénère le site avec vos modifications puis le met en ligne">Publier en ligne</button></form>')
    return f"""<!DOCTYPE html><html lang="fr"><head><meta charset="utf-8"><title>{esc(title)} — Back-office</title><meta name="viewport" content="width=device-width,initial-scale=1"><style>{CSS}</style></head>
<body>
<aside class="sidebar"><div class="brand">{(lambda _l: f'<img src="{_l}" alt="">' if _l else f'<b style="color:#fff;font-size:.95rem">{esc(B.SITE_NAME)}</b>')(bo_logo(True))}<span></span></div><nav>{nav}<div class="sec">Aperçu & publication</div><a href="{PREVIEW_BASE}/" target="_blank"><span class="i">{_ic("eye")}</span>Voir le site (aperçu)</a><a href="/export"><span class="i">{_ic("download")}</span>Télécharger le zip</a></nav><div class="foot">Un service de l'agence Beecom' · moteur v{VERSION}<br>Rien n'est en ligne tant que vous ne publiez pas.</div></aside>
<div class="topbar"><h1>{esc(title)}</h1>
<details class="dd"><summary class="btn sm navy">＋ Créer</summary><div class="dd-m">
<a href="/new-page">Une page</a><a href="/new-article">Un article</a><a href="/images">Déposer une image</a></div></details>
<form method="post" action="/build" style="margin:0"><button class="btn sm sec" title="Reconstruit le site (dossier dist/) à partir de vos modifications pour le voir dans l’aperçu local — rien n’est mis en ligne">Régénérer le site</button></form>{pub_btn}
<details class="dd acct"><summary><span class="ava">{esc("".join(w[0].upper() for w in display_name(user).split()[:2]))}</span><span class="acct-n">{esc(display_name(user))}</span><span class="chev-s">▾</span></summary><div class="dd-m dd-r">
<div class="acct-head"><b>{esc(display_name(user))}</b><small>{esc((user or {}).get("email",""))}</small></div>
<a href="/profile">Mon compte</a><a href="/logout">Se déconnecter</a></div></details></div>
<main>{body}</main></body></html>"""


# ---------- Traductions (type WPML : slugs traduits, détection des champs modifiés) ----------
def _tr_mod():
    import translate as T
    return T

def tr_units_for(rel):
    """(bname, units, has_blocks) — unités traduisibles d'une page."""
    T = _tr_mod()
    meta, body = read_page(rel)
    bd = B.load_blocks(rel)
    units = T.page_units(meta, bd) + (T.body_extra_units(body) if bd else [T.body_unit(body)])
    return B.blocks_key(rel), units, bool(bd)

def tr_slug_auto(rel, lang):
    """Propose un slug traduit : dernier segment de l'URL FR, mots traduits puis re-slugifiés."""
    T = _tr_mod()
    path = B.url_from_path(rel).strip("/")
    if not path: return ""
    try:
        segs = path.split("/")
        words = [s.replace("-", " ") for s in segs]
        got = T.call_provider(words, lang, B.CONFIG)
        return "/".join(slugify(g) for g in got)
    except Exception:
        return path

def page_translations(msg=""):
    others = [(c.strip(), l.strip()) for c, l in B.LANGS if c.strip() != B.DEFAULT_LANG]
    if not others:
        body = f"""{msg}<h1>Traductions</h1>
<div class="card"><p>Le site est monolingue pour l'instant. Pour activer la traduction :</p>
<p>1. <a href="/settings#set-langs">Réglages › Langues & traduction</a> : renseignez les langues (ex. <code>fr:Français,en:English</code>) et la clé <b>DeepL</b> (compte gratuit sur <a href="https://www.deepl.com/pro-api" target="_blank">deepl.com/pro-api</a> — nouvelles clés : 1 million de caractères offerts au total, largement assez pour plusieurs sites complets ; le compteur exact s'affiche ici une fois la clé renseignée).</p>
<p>2. Revenez ici : chaque page se traduit en un clic, avec des <b>URLs traduites</b> (ex. <code>/en/sectors/campsites/</code>), les balises hreflang, le sitemap et le sélecteur de langue dans le menu — le français reste servi à la racine.</p>
<p>3. Quand vous modifiez un texte français, la page passe « à mettre à jour » : seuls les champs modifiés sont retraduits.</p></div>"""
        return layout("Traductions", body, "/translations")
    T = _tr_mod()
    key_ok = bool((B.CONFIG.get("DEEPL_KEY") or "").strip()) if (B.CONFIG.get("TRANSLATE_PROVIDER") or "deepl") == "deepl" else bool((B.CONFIG.get("ANTHROPIC_KEY") or "").strip())
    warn = "" if key_ok else '<div class="msg err">Aucune clé API renseignée : la traduction automatique échouera. <a href="/settings#set-langs">Réglages › Langues & traduction</a>.</div>'
    # quota DeepL réel + état de la bascule Claude
    if (B.CONFIG.get("TRANSLATE_PROVIDER") or "deepl") == "deepl" and (B.CONFIG.get("DEEPL_KEY") or "").strip():
        u = T.deepl_usage(B.CONFIG)
        if u:
            used, lim = u; pct = (used * 100 // lim) if lim else 0
            fb = ("bascule automatique sur Claude activée ✔" if (B.CONFIG.get("ANTHROPIC_KEY") or "").strip()
                  else "pas de clé Anthropic : renseignez-en une dans les Réglages pour une bascule automatique quand le quota sera épuisé")
            bar_color = "#c5221f" if pct >= 90 else ("#e37400" if pct >= 70 else "#137333")
            warn += (f'<div class="card" style="padding:.8rem 1rem;margin-bottom:.8rem"><b>Quota DeepL :</b> {used:,} / {lim:,} caractères utilisés ({pct} %)'.replace(",", " ")
                     + f'<span style="display:inline-block;width:140px;height:8px;background:#e6eaef;border-radius:4px;margin:0 .6rem;vertical-align:middle"><span style="display:block;width:{min(pct,100)}%;height:8px;background:{bar_color};border-radius:4px"></span></span>'
                     + f'<span class="help">{fb}</span></div>')
    pages = list_pages()
    out = f"{msg}{warn}<h1>Traductions</h1><p class=\"help\">Le français reste à la racine (/). Chaque langue est publiée sous /&lt;code&gt;/ avec des <b>slugs traduits</b> (modifiables ci-dessous), les balises hreflang et le sélecteur de langue. « À mettre à jour » = des textes français ont changé depuis la traduction ; seuls ces champs seront retraduits. Après traduction : <b>Régénérer</b> puis publier. Relecture fine possible dans les fichiers <code>translations/</code>.</p>"
    out += ('<div class="actions" style="margin:.4rem 0 1.1rem"><a class="btn sm sec" href="/blocks-sync-all" onclick="return confirm(\'Relire le HTML de toutes les pages et détecter les nouveaux éléments traduisibles ?\')">↻ Resynchroniser les blocs de toutes les pages</a>'
            '<span class="help">À faire après une mise à jour du moteur, puis « Tout traduire ».</span></div>')
    for lang, label in others:
        # menu (site natif : blocks/_menu.json) ou habillage (site importé : layout/header+footer)
        menu_p = os.path.join(B.BLOCKS_DIR, "_menu.json")
        if os.path.exists(menu_p):
            mu = T.page_units({}, json.load(open(menu_p, encoding="utf-8")))
            mtr = T.load("_menu", lang); t_, m_, s_ = T.status(mu, mtr)
            mstat = "—"
            if mu: mstat = ("<span class=tag style='background:#e6f4ea;color:#137333'>à jour</span>" if (m_ == 0 and s_ == 0) else (f"<span class=tag d>à mettre à jour ({s_ + m_})</span>" if m_ < t_ else "<span class=tag style='background:#fce8e6;color:#c5221f'>non traduit</span>"))
            rows = f'<tr><td><b>☰ Menu & pied de page</b></td><td>—</td><td>{mstat}</td><td><form method="post" action="/translate" style="margin:0"><input type="hidden" name="name" value="_menu"><input type="hidden" name="lang" value="{lang}"><button class="btn sm sec">Traduire</button></form></td></tr>'
        elif os.path.isdir(LAYOUT):
            has_l = os.path.exists(os.path.join(LAYOUT, f"header.{lang}.html"))
            lstat = "<span class=tag style='background:#e6f4ea;color:#137333'>traduit</span>" if has_l else "<span class=tag style='background:#fce8e6;color:#c5221f'>non traduit</span>"
            rows = (f'<tr><td><b>☰ En-tête & pied de page (habillage)</b><br><span class="help">menu, boutons, colonnes du footer — relisible dans « Menu & pied de page »</span></td><td>—</td><td>{lstat}</td>'
                    f'<td><form method="post" action="/layout-translate" style="margin:0"><input type="hidden" name="lang" value="{lang}"><input type="hidden" name="back" value="/translations"><button class="btn sm sec">{"Retraduire" if has_l else "Traduire"}</button></form></td></tr>')
        else:
            rows = ""
        for p in pages:
            if p.get("draft"): continue
            rel = p["file"]; bname, units, hb = tr_units_for(rel)
            tr = T.load(bname, lang); t, m, st = T.status(units, tr)
            if m == 0 and st == 0 and t > 0: stat = "<span class=tag style='background:#e6f4ea;color:#137333'>à jour</span>"
            elif m >= t: stat = "<span class=tag style='background:#fce8e6;color:#c5221f'>non traduite</span>"
            else: stat = f"<span class=tag d>à mettre à jour ({m + st})</span>"
            cur_path = tr.get("path") if tr.get("path") is not None else ""
            slug_in = (f'<form method="post" action="/trans-slug" style="margin:0;display:flex;gap:.3rem"><input type="hidden" name="name" value="{esc(bname)}"><input type="hidden" name="lang" value="{lang}">'
                       f'<input type="text" name="path" value="{esc(cur_path)}" placeholder="{esc(B.url_from_path(rel).strip("/") or "(accueil)")}" style="font-size:.78rem;padding:.3rem .5rem;width:230px">'
                       f'<button class="btn sm sec" title="Enregistrer le slug">✓</button></form>') if t else "—"
            btn = f'<form method="post" action="/translate" style="margin:0"><input type="hidden" name="name" value="{esc(bname)}"><input type="hidden" name="lang" value="{lang}"><input type="hidden" name="rel" value="{esc(rel)}"><button class="btn sm sec">{"Mettre à jour" if m < t else "Traduire"}</button></form>'
            title = re.sub(r"\s*\|\s*.*$", "", p["title"])
            dest = (" → <code style=&quot;font-size:.72rem;color:var(--blue)&quot;>/" + lang + "/" + esc(cur_path) + ("/" if cur_path else "") + "</code>") if (m == 0 and t > 0) else ""
            dest = dest.replace("&quot;", chr(34))
            art_tag = " <span class=tag>article</span>" if p["type"] == "article" else ""
            rows += f'<tr><td>{esc(title)}{art_tag}<br><code style="font-size:.72rem">{esc(p["url"])}</code>{dest}</td><td>{slug_in}</td><td>{stat}</td><td>{btn}</td></tr>'
        out += f"""<div class="card"><h2 style="margin-top:0">{esc(label)} ({lang.upper()}) — publié sous /{lang}/</h2>
<div class="actions" style="margin-bottom:.8rem"><form method="post" action="/translate-all" style="margin:0" onsubmit="this.querySelector('button').textContent='Traduction en cours — ne quittez pas cette page…'"><input type="hidden" name="lang" value="{lang}"><button class="btn">Tout traduire / tout mettre à jour</button></form><span class="help">Par lots automatiques (la page s&#39;enchaîne toute seule) : <b>ne fermez pas l&#39;onglet</b>. En cas d&#39;interruption, rien n&#39;est perdu — recliquez, la traduction reprend où elle en était.</span></div>
<table><tr><th>Page</th><th>Slug traduit (URL /{lang}/…)</th><th>Statut</th><th></th></tr>{rows}</table></div>"""
    return layout("Traductions", out, "/translations")

def do_translate(name, lang, rel=None):
    """Traduit une page (ou le menu). Retourne un message."""
    T = _tr_mod()
    if name == "_menu":
        menu = json.load(open(os.path.join(B.BLOCKS_DIR, "_menu.json"), encoding="utf-8"))
        units = T.page_units({}, menu)
    else:
        rel = rel or (name.replace("__", "/") + ".html")
        bname, units, hb = tr_units_for(rel); name = bname
    tr = T.load(name, lang)
    n, kept = T.translate_units(units, tr, lang, B.CONFIG)
    if name != "_menu" and tr.get("path") is None and rel:
        tr["path"] = tr_slug_auto(rel, lang)
    T.save(name, lang, tr)
    return f"{n} champ(s) traduit(s), {kept} déjà à jour."

def seo_alerts():
    """Alertes SEO rapides : title/description manquants ou hors gabarit, H1 absent ou multiple."""
    al = []
    for p in list_pages():
        if p["draft"]: continue
        meta, body = read_page(p["file"])
        t, d = meta.get("title", ""), meta.get("description", "")
        if not t.strip(): al.append((p["file"], "titre SEO manquant"))
        elif len(t) > 65: al.append((p["file"], f"titre SEO trop long ({len(t)}/65)"))
        if not d.strip(): al.append((p["file"], "méta description manquante"))
        elif len(d) > 160: al.append((p["file"], f"méta description trop longue ({len(d)}/160)"))
    # H1 : vérifié sur le site généré (les blocs y sont résolus)
    if os.path.exists(os.path.join(DIST, "index.html")):
        by_url = {pg["url"]: pg["file"] for pg in list_pages()}
        for dp, dn, fns in os.walk(DIST):
            dn[:] = [x for x in dn if x not in ("assets", "api") and not x.startswith("_")]
            for fn in fns:
                if fn != "index.html": continue
                rp = os.path.relpath(dp, DIST).replace(os.sep, "/")
                url = "/" if rp == "." else "/" + rp + "/"
                src = by_url.get(url)
                if not src or src == "404.html": continue
                n = len(re.findall(r"<h1\b", open(os.path.join(dp, fn), encoding="utf-8", errors="replace").read(), re.I))
                if n == 0: al.append((src, "aucune balise H1"))
                elif n > 1: al.append((src, f"{n} balises H1"))
    return al

def broken_links():
    """Liens internes cassés dans le site généré (dist/) : [(page, lien)]."""
    if not os.path.exists(os.path.join(DIST, "index.html")): return None
    out = []
    for dp, dn, fns in os.walk(DIST):
        for fn in fns:
            if not fn.endswith(".html"): continue
            page = os.path.relpath(os.path.join(dp, fn), DIST).replace(os.sep, "/")
            htm = open(os.path.join(dp, fn), encoding="utf-8", errors="replace").read()
            for href in set(re.findall(r'href="(/[^"#?]*)"', htm)):
                tgt = href.lstrip("/")
                if not tgt: continue
                cand = [os.path.join(DIST, tgt.rstrip("/"), "index.html"), os.path.join(DIST, tgt)]
                if tgt.endswith("/"): cand = [os.path.join(DIST, tgt, "index.html")]
                if not any(os.path.exists(c) for c in cand):
                    out.append(("/" + re.sub(r"index\.html$", "", page), href))
    return sorted(set(out))[:40]

def matomo_fetch(period_key):
    """Résumé Matomo via l'API de reporting. (libellé, {métriques}, top_pages, erreur)."""
    cfg = B.CONFIG
    url, sid, tok = cfg.get("MATOMO_URL", "").rstrip("/"), cfg.get("MATOMO_SITE_ID", ""), cfg.get("MATOMO_TOKEN", "")
    if not (url and sid and tok): return None
    today = datetime.date.today()
    periods = {
        "today": ("Aujourd'hui", "day", "today"),
        "7d": ("7 derniers jours", "range", "last7"),
        "30d": ("30 derniers jours", "range", "last30"),
        "month": ("Mois en cours", "month", "today"),
        "lastmonth": ("Mois dernier", "month", (today.replace(day=1) - datetime.timedelta(days=1)).strftime("%Y-%m-01")),
        "year": ("Année en cours", "year", "today"),
    }
    lab, per, date = periods.get(period_key, periods["month"])
    from urllib.parse import urlencode
    from urllib.request import urlopen
    def call(method, extra=""):
        q = urlencode({"module": "API", "method": method, "idSite": sid, "period": per, "date": date, "format": "JSON", "token_auth": tok}) + extra
        return json.loads(urlopen(f"{url}/index.php?{q}", timeout=6).read().decode("utf-8", "replace"))
    try:
        v = call("VisitsSummary.get")
        if isinstance(v, dict) and v.get("result") == "error": return (lab, None, None, v.get("message", "erreur Matomo"))
        top = call("Actions.getPageUrls", "&flat=1&filter_limit=5&filter_sort_column=nb_hits")
        if not isinstance(top, list): top = []
        return (lab, v, top, None)
    except Exception as e:
        return (lab, None, None, str(e))

def page_dashboard(msg="", q=None):
    q = q or {}
    pages = list_pages(); arts = [p for p in pages if p["type"] == "article"]
    dist_ok = os.path.exists(os.path.join(DIST, "index.html"))
    mtime = datetime.datetime.fromtimestamp(os.path.getmtime(os.path.join(DIST, "index.html"))).strftime("%d/%m %H:%M") if dist_ok else "jamais"
    cfg = B.CONFIG
    form_ok = (cfg.get("FORM_MODE") == "php" and cfg.get("FORM_TO")) or (cfg.get("WEB3FORMS_KEY") and not cfg["WEB3FORMS_KEY"].startswith("VOTRE_CLE"))
    ftp_ok = bool(cfg["FTP_HOST"] and cfg["FTP_USER"]) or cfg.get("PUBLISH_MODE") == "copy"
    al = seo_alerts(); bl = broken_links()
    period = q.get("sp", "month"); mt = matomo_fetch(period)
    lic = "" if B.LICENCE_OK else f'<div class="msg err">🔐 <b>Licence Beecom</b> — {esc(B.LICENCE_MSG)} La publication en production est bloquée tant que la licence n\'est pas en place.</div>'
    # --- compteurs sobres ---
    nb_bl = "—" if bl is None else len(bl)
    kpi = (f'<div class="kpi"><div><b>{len(pages) - len(arts)}</b>pages</div><div><b>{len(arts)}</b>articles</div>'
           f'<div><b>{len(al)}</b>alerte(s) SEO</div><div><b>{nb_bl}</b>lien(s) cassé(s)</div></div>')
    # --- alertes SEO + liens cassés ---
    arows = "".join(f'<tr><td><code style="font-size:.76rem">{esc(f)}</code></td><td>{esc(wmsg)}</td><td><a class="btn sm sec" href="/edit?f={esc(f)}#seo">Corriger</a></td></tr>' for f, wmsg in al[:25])
    amore = f'<p class="help">… et {len(al) - 25} autre(s) — vue complète dans l\'onglet <a href="/seo">SEO</a>.</p>' if len(al) > 25 else ""
    seo_card = (f'<div class="card"><h2 style="margin-top:0">Alertes SEO</h2>' +
                (f'<table>{arows}</table>{amore}' if al else '<p class="help">Aucune alerte : titres, descriptions et H1 sont en ordre. ✔</p>') + '</div>')
    if bl is None:
        bl_inner = '<p class="help">Régénérez le site pour lancer la vérification.</p>'
    elif bl:
        bl_inner = '<table>' + "".join(f'<tr><td><code style="font-size:.76rem">{esc(pg)}</code></td><td>→ <code style="font-size:.76rem">{esc(h)}</code></td></tr>' for pg, h in bl[:25]) + '</table>'
    else:
        bl_inner = '<p class="help">Aucun lien interne cassé dans le site généré. ✔</p>'
    links_card = f'<div class="card"><h2 style="margin-top:0">Liens internes</h2>{bl_inner}</div>'
    # --- santé du site : tous les essentiels d'une mise en ligne, d'un coup d'œil ---
    # indexation : accueil en noindex ou robots.txt de prod bloquant = site invisible sur Google
    try: home_noidx = read_page("index.html")[0].get("noindex", "false").lower() == "true"
    except Exception: home_noidx = False
    robots_block = bool(re.search(r"^\s*Disallow:\s*/\s*$", cfg.get("ROBOTS_TXT", ""), re.M))
    https_ok = cfg.get("SITE_URL", "").startswith("https://")
    idx_ok = not home_noidx and not robots_block and https_ok
    idx_ko = ("Accueil en noindex — à décocher avant la mise en ligne !" if home_noidx
              else ("robots.txt de production bloque tout Google — <a href=\"/seo\">SEO</a>" if robots_block
                    else "L'URL publique n'est pas en https — <a href=\"/settings#set-ftp\">Réglages</a>"))
    # favicon : réglage dédié, fichier du moteur, ou balise présente dans l'habillage importé
    fav_ok = bool(cfg.get("FAVICON", "").strip()) or os.path.exists(os.path.join(ASSETS, "img", "favicon.svg")) or os.path.exists(os.path.join(ROOT, "favicon.ico"))
    if not fav_ok:
        try: fav_ok = bool(re.search(r'rel="(?:shortcut )?icon"', open(os.path.join(LAYOUT, "head.html"), encoding="utf-8").read()))
        except Exception: pass
    # cookies / consentement
    cmp_ok = bool(cfg.get("CMP_SCRIPT", "").strip())
    # pages légales (RGPD)
    urls_all = " ".join(p["url"] for p in pages)
    legal_ok = ("mention" in urls_all or "legal" in urls_all) and ("confidentialite" in urls_all or "privacy" in urls_all or "donnees" in urls_all)
    # image de partage par défaut
    og_ok = B.asset_exists(cfg.get("DEFAULT_OG", "/assets/img/og-default.jpg"))
    # textes alternatifs des images
    try: nb_alt = len(collect_missing_alts())
    except Exception: nb_alt = 0
    checks = [
        (idx_ok, "Indexation Google prête (https, pas de blocage)", idx_ko),
        (bool(form_ok), "Formulaires configurés", 'Formulaires à configurer — <a href="/settings#set-forms">Réglages</a>'),
        (bool(ftp_ok), "Publication prête", 'Publication à configurer — <a href="/settings#set-ftp">Réglages</a>'),
        (bool(B.LICENCE_OK), "Licence Beecom valide", "Licence absente ou invalide"),
        (bool(dist_ok), "Site généré et à jour", "Site jamais généré — cliquez « Régénérer »"),
        (not al, "SEO : titres, descriptions, H1 en ordre", f'SEO : {len(al)} point(s) à corriger — <a href="/seo">voir</a>'),
        (bl is not None and not bl, "Aucun lien interne cassé", ("Liens vérifiés après régénération" if bl is None else f"{len(bl)} lien(s) cassé(s)")),
        (fav_ok, "Favicon en place", 'Favicon manquant — <a href="/settings#set-coord">Réglages › Coordonnées</a>'),
        (mt is not None and mt[3] is None and mt[1] is not None, "Statistiques Matomo connectées",
         ('Matomo injoignable : ' + esc(str(mt[3]))[:60] if (mt is not None and mt[3]) else 'Statistiques non connectées — <a href="/settings#set-stats">Réglages › Statistiques</a>')),
        (cmp_ok, "Bandeau cookies (consentement) actif", 'Bandeau cookies absent — <a href="/settings#set-cmp">Réglages › Cookies</a> (requis si GA4/pixels)'),
        (legal_ok, "Pages légales présentes (mentions, confidentialité)", "Pages légales incomplètes (mentions légales + confidentialité)"),
        (og_ok, "Image de partage par défaut en place", "Image de partage par défaut absente (aperçus réseaux sociaux)"),
        (nb_alt == 0, "Toutes les images ont un texte alternatif", f'{nb_alt} texte(s) alternatif(s) manquant(s) — <a href="/images">Médias</a>'),
    ]
    n_ok = sum(1 for ok, _, _ in checks if ok); score = round(100 * n_ok / len(checks))
    verdict = "Excellent" if score == 100 else ("Bien" if score >= 80 else ("Correct" if score >= 60 else "À améliorer"))
    ring_c = "#1e8e3e" if score >= 80 else ("#e37400" if score >= 60 else "#c5221f")
    circ = 2 * 3.14159 * 52
    ring = (f'<div class="hring"><svg width="118" height="118" viewBox="0 0 118 118">'
            f'<circle cx="59" cy="59" r="52" fill="none" stroke="#eef0f3" stroke-width="9"/>'
            f'<circle cx="59" cy="59" r="52" fill="none" stroke="{ring_c}" stroke-width="9" stroke-linecap="round" stroke-dasharray="{circ * score / 100:.0f} {circ:.0f}"/></svg>'
            f'<div class="pct"><b>{score}%</b><span>{verdict}</span></div></div>')
    hits = "".join(f'<div class="hit{"" if ok else " ko"}"><span class="hi">{"✔" if ok else "！"}</span><span>{oktxt if ok else kotxt}</span></div>' for ok, oktxt, kotxt in checks)
    mailtest = ('<div class="actions" style="margin-top:1rem"><form method="post" action="/test-mail" style="margin:0"><button class="btn sm sec">✉ Envoyer un e-mail de test</button></form>'
                '<span class="help">Vérifie en conditions réelles que les e-mails du formulaire partent (SMTP des Réglages, envoyé à l\'adresse de réception).</span></div>') if role_of(CURRENT_USER) == "admin" else ""
    sante = f'<div class="card"><h2 style="margin-top:0">Santé du site</h2><div class="hgrid">{ring}<div class="hitems">{hits}</div></div>{mailtest}</div>'
    # --- statistiques Matomo ---
    if mt is None:
        stats_card = ('<div class="card"><h2 style="margin-top:0">Statistiques (Matomo)</h2>'
                      '<p class="help">Renseignez l\'URL Matomo, l\'ID du site et le <b>jeton API</b> dans <a href="/settings#set-stats">Réglages › Statistiques</a> pour afficher ici les visites (période au choix, mois en cours par défaut).</p></div>')
    else:
        lab, v, top, err = mt
        sel = "".join(f'<option value="{k}" {"selected" if k == period else ""}>{t}</option>' for k, t in
                      [("today", "Aujourd\'hui"), ("7d", "7 derniers jours"), ("30d", "30 derniers jours"), ("month", "Mois en cours"), ("lastmonth", "Mois dernier"), ("year", "Année en cours")])
        selform = f'<form method="get" action="/" style="margin-left:auto"><select name="sp" onchange="this.form.submit()" style="width:auto;padding:.3rem .5rem;font-size:.82rem">{sel}</select></form>'
        if err or not isinstance(v, dict):
            inner = f'<p class="help">Impossible de joindre Matomo : {esc(str(err or v))}</p>'
        else:
            mins = int(v.get("avg_time_on_site") or 0)
            inner = (f'<div class="kpi" style="margin-bottom:.6rem"><div><b>{v.get("nb_visits", 0)}</b>visites</div><div><b>{v.get("nb_uniq_visitors", "—")}</b>visiteurs</div>'
                     f'<div><b>{v.get("nb_actions", 0)}</b>pages vues</div><div><b>{mins // 60} min {mins % 60:02d}</b>temps moyen</div><div><b>{v.get("bounce_rate", "—")}</b>rebond</div></div>')
            if top:
                inner += '<table><tr><th>Pages les plus vues</th><th style="width:90px">Vues</th></tr>' + "".join(
                    f'<tr><td><code style="font-size:.76rem">{esc(t.get("label", ""))}</code></td><td>{t.get("nb_hits", t.get("nb_visits", ""))}</td></tr>' for t in top[:5]) + '</table>'
        stats_card = f'<div class="card"><h2 style="margin-top:0;display:flex;align-items:center">Statistiques — {esc(lab)}{selform}</h2>{inner}</div>'
    # --- journal (persistant, par compte, mois par mois) ---
    months = journal_months() or [datetime.date.today().strftime("%Y-%m")]
    jm = q.get("jm", months[0])
    rows = journal_read(jm)
    msel = "".join(f'<option value="{m}" {"selected" if m == jm else ""}>{m[5:]}/{m[:4]}</option>' for m in months)
    jform = f'<form method="get" action="/" style="margin-left:auto"><input type="hidden" name="sp" value="{esc(period)}"><select name="jm" onchange="this.form.submit()" style="width:auto;padding:.3rem .5rem;font-size:.82rem">{msel}</select></form>'
    if rows:
        jrows = "".join(f'<tr><td class="t">{esc(d[11:16])} · {esc(d[8:10])}/{esc(d[5:7])}</td><td class="u">{esc(u.split("@")[0])}</td><td>{esc(a)}</td></tr>' for d, u, a in rows[:80])
        jtbl = f'<table class="jrnl">{jrows}</table>' + (f'<p class="help">{len(rows)} action(s) ce mois-ci (80 affichées).</p>' if len(rows) > 80 else "")
    else:
        jtbl = '<table class="jrnl">' + "".join(f'<tr><td>{esc(l)}</td></tr>' for l in LOG[:15]) + '</table>' if LOG else '<p class="help">Aucune action ce mois-ci.</p>'
    journal_card = f'<div class="card"><h2 style="margin-top:0;display:flex;align-items:center;gap:.8rem">Journal de bord<span class="help" style="font-weight:400">dernière génération : {mtime}</span>{jform}</h2>{jtbl}</div>'
    body = f"""{msg}{lic}<h1>Tableau de bord</h1>{kpi}{stats_card}{sante}{seo_card}{links_card}{journal_card}"""
    return layout("Tableau de bord", body, "/")

def page_articles(msg=""):
    arts = [p for p in list_pages() if p["type"] == "article"]
    rows = ""
    for p in sorted(arts, key=lambda a: a["url"]):
        t = re.sub(r"\s*\|\s*votre-fiche-google\.fr\s*$", "", p["title"])
        rows += f'<tr><td><a href="/edit?f={esc(p["file"])}"><b>{esc(t)}</b></a>{" <span class=tag d>brouillon</span>" if p["draft"] else ""}</td><td><code>{esc(p["url"])}</code></td><td><a href="{PREVIEW_BASE}{p["url"]}" target="_blank">aperçu ↗</a></td><td><a class="btn sm sec" href="/edit?f={esc(p["file"])}">Éditer</a></td></tr>'
    counts = {}
    for p in arts:
        f = p["file"]
        if B.BLOG_PREFIX and f.startswith(B.BLOG_PREFIX): f = f[len(B.BLOG_PREFIX):]
        seg = f.split("/")
        if len(seg) == 2: counts[seg[0]] = counts.get(seg[0], 0) + 1
    trows = ""
    for sl, lab in B.GUIDE_THEMES:
        n = counts.get(sl, 0)
        act = (f'<form method="post" action="/theme-del" style="display:inline" onsubmit="return confirm(\'Supprimer la catégorie « {esc(lab)} » et sa page hub ?\')">'
               f'<input type="hidden" name="slug" value="{esc(sl)}"><button class="btn sm sec">Supprimer</button></form>') if n == 0 else '<span class="help">contient des articles</span>'
        hub = f"/{B.BLOG_PREFIX}{sl}/"
        trows += f'<tr><td><b>{esc(lab)}</b></td><td><code>{esc(hub)}</code> <a href="{PREVIEW_BASE}{hub}" target="_blank">↗</a></td><td>{n}</td><td>{act}</td></tr>'
    body = f"""{msg}<h1>Articles du guide <a class="btn sm" href="/new-article" style="margin-left:1rem">＋ Écrire un article</a></h1>
<p class="help">Un article = des champs structurés : <b>Contenu</b> (éditeur visuel, code source affichable), <b>FAQ</b> (questions/réponses, données structurées FAQPage automatiques), <b>Sources</b> (une par ligne). Les listes du guide, des pages thème et des « À lire aussi » se mettent à jour automatiquement à la régénération.</p>
<div class="card"><table>{rows or "<tr><td>Aucun article.</td></tr>"}</table></div>
<h2 style="margin-top:2rem">Catégories du guide</h2>
<p class="help">Chaque catégorie a sa page « hub » (<code>/{esc(B.BLOG_PREFIX)}&lt;adresse&gt;/</code>) qui liste automatiquement ses articles — les articles vivent à <code>/{esc(B.BLOG_PREFIX)}&lt;catégorie&gt;/&lt;article&gt;/</code>. Une catégorie ne peut être supprimée que si elle ne contient aucun article.</p>
<div class="card"><table><tr><th>Catégorie</th><th>Adresse</th><th>Articles</th><th></th></tr>{trows}</table>
<form method="post" action="/theme-add" style="display:flex;gap:.6rem;align-items:center;margin-top:1rem;flex-wrap:wrap">
<input type="text" name="label" placeholder="Nom de la nouvelle catégorie (ex. Réseaux sociaux)" required style="flex:1;min-width:220px">
<button class="btn sm">＋ Ajouter la catégorie</button></form>
<p class="help">La page hub est créée avec ses blocs (sur-titre, titre, accroche, appel à l'action) — personnalisez-la ensuite depuis « Pages ».</p></div>
<div class="card sec-card closed"><h2 onclick="this.parentElement.classList.toggle('closed')">📥 Import d'articles en masse<span class="chev">▼</span></h2><div class="sec-body">
<p class="help">Déposez d'un coup les livraisons <code>articles-pour-bo/</code> : les fichiers <b>.md</b> (un par article) et leurs covers (<code>cover-&lt;slug&gt;.webp</code>), ou directement le dossier en <b>.zip</b>. Chaque article est créé comme s'il avait été saisi dans le formulaire : champs structurés (contenu, essentiel, FAQ → données FAQPage, sources), catégorie, cover, hub et sitemap à jour.</p>
<form method="post" action="/articles-import" enctype="multipart/form-data">
<label>Fichiers (.md + images, ou un .zip)</label><input type="file" name="lots" multiple required accept=".md,.markdown,.zip,.webp,.jpg,.jpeg,.png">
<label style="font-weight:400;display:flex;gap:.5rem;align-items:center;margin:.6rem 0"><input type="checkbox" name="autocat" value="1" checked> Créer automatiquement les catégories manquantes (avec leur page hub)</label>
<div class="actions"><button class="btn">Importer les articles</button><span class="help">Un article dont l'adresse existe déjà est ignoré (compte rendu après import).</span></div></form>
<details style="margin-top:.8rem"><summary class="help" style="cursor:pointer">Format attendu des .md (rappel)</summary>
<pre style="max-height:230px">---
titre: Mon titre d'article
sous-titre: Une phrase d'accroche.
description: Méta description 140-160 caractères.
slug: mon-titre-d-article
categorie: conseils
couverture: cover-mon-titre-d-article.webp
---
Contenu de l'article en Markdown (## sous-titres, **gras**, listes…).

## L'essentiel à retenir
- Une puce par ligne.

## FAQ
Question ? | Réponse.

## Sources
- Une source par ligne.</pre>
<p class="help">Clefs optionnelles : titre-seo, date (AAAA-MM-JJ), extrait, brouillon: oui. Tolérant aux accents et alias (catégorie/categorie, cover/couverture…). Sans « couverture », le fichier <code>cover-&lt;slug&gt;.*</code> joint est utilisé.</p></details>
</div></div>"""
    return layout("Articles", body, "/articles")

def page_pages(msg=""):
    pages = [p for p in list_pages() if p["type"] != "article"]; groups = {}
    for p in pages: groups.setdefault(group(p["url"]), []).append(p)
    order = ["Accueil", "Conversion", "Offre", "Métiers", "Guide (blog)", "Preuve", "Réassurance", "Agence", "Légal", "Autres"]
    rows = ""
    for g in order:
        if g not in groups: continue
        rows += f'<tr><th colspan="4" style="background:#f7f8fa;padding-top:1rem">{g}</th></tr>'
        for p in groups[g]:
            t = re.sub(r"\s*\|\s*votre-fiche-google\.fr\s*$", "", p["title"])
            rows += f'<tr><td><a href="/edit?f={esc(p["file"])}"><b>{esc(t)}</b></a>{" <span class=tag>article</span>" if p["type"]=="article" else ""}{" <span class=tag d>brouillon</span>" if p["draft"] else ""}</td><td><code>{esc(p["url"])}</code></td><td><a href="{PREVIEW_BASE}{p["url"]}" target="_blank">aperçu ↗</a></td><td><a class="btn sm sec" href="/edit?f={esc(p["file"])}">Éditer</a></td></tr>'
    return layout("Pages", f"{msg}<h1>Toutes les pages</h1><p class='help'>Chaque page s'ouvre avec ses <b>blocs</b> (titres, textes, images, boutons — section par section). Les articles du guide sont dans « Articles ».</p><div class='card'><table>{rows}</table></div>", "/pages")

def image_options(selected=""):
    opts = ['<option value="">— choisir une image existante —</option>']
    for dp, dn, fns in os.walk(IMG):
        dn[:] = [d for d in dn if d != "_v"]   # variantes auto (perf) : internes
        for fn in sorted(fns):
            if fn.lower().endswith((".webp", ".jpg", ".jpeg", ".png")):
                p = "/assets/" + os.path.relpath(os.path.join(dp, fn), ASSETS).replace(os.sep, "/")
                opts.append(f'<option value="{esc(p)}" {"selected" if p==selected else ""}>{esc(p)}</option>')
    return "".join(opts)


# ---------- Blocs configurables (style ACF) ----------
BLOCKS = os.path.join(ROOT, "blocks")
def blocks_list():
    out = []
    if not os.path.isdir(BLOCKS): return out
    for fn in sorted(os.listdir(BLOCKS)):
        if fn.endswith(".json"):
            d = json.load(open(os.path.join(BLOCKS, fn), encoding="utf-8"))
            out.append({"name": fn[:-5], "label": d.get("label", fn[:-5]), "page": d.get("page", ""), "n": len(d.get("sections", []))})
    return out
def load_blocks(name):
    return json.load(open(safe_join(BLOCKS, name + ".json"), encoding="utf-8"))
def save_blocks(name, data):
    json.dump(data, open(safe_join(BLOCKS, name + ".json"), "w", encoding="utf-8"), ensure_ascii=False, indent=1)

def img_url(p): return f"{PREVIEW_BASE}{p}" if p else ""
def field_input(name, f, value, compact=False):
    t = f.get("type", "text"); v = value if value is not None else ""
    help_ = f'<p class="help" style="margin:.2rem 0 0">{esc(f["help"])}</p>' if f.get("help") else ""
    if t in ("text", "url"):
        inner = f'<input type="text" name="{name}" value="{esc(v)}">'
        if t == "url" and name.startswith("f__"):
            tid = f.get("tid") or ""
            chk = "checked" if f.get("track") else ""
            inner += f'<label style="font-weight:400;font-size:.8rem;display:flex;gap:.4rem;align-items:center;margin:.35rem 0 0"><input type="checkbox" name="{name}__track" value="1" {chk}> Tracker ce bouton/lien</label>'
            if f.get("track") and tid:
                inner += f'<p class="help" style="margin:.15rem 0 0">ID de suivi : <code>#{esc(tid)}</code> — un événement (CTA · {esc(tid)}) part automatiquement vers Matomo et/ou GA4 à chaque clic, si configurés dans Réglages › Statistiques.</p>'
    elif t == "richtext":
        tid = re.sub(r"\W", "_", name)
        inner = (f'<div class="rtxbar" data-rtx="{tid}">'
                 '<button type="button" data-cmd="bold" title="Gras"><b>G</b></button>'
                 '<button type="button" data-cmd="italic" title="Italique"><i>I</i></button>'
                 '<button type="button" data-blk="h2">H2</button><button type="button" data-blk="h3">H3</button><button type="button" data-blk="p">¶</button>'
                 '<button type="button" data-cmd="insertUnorderedList" title="Liste">• Liste</button>'
                 '<button type="button" data-act="link" title="Lien">🔗 Lien</button>'
                 '<button type="button" data-act="img" title="Image">🖼 Image</button>'
                 '<button type="button" data-act="callout" title="Encadré">💡 Encadré</button>'
                 '<button type="button" data-act="warn" title="Encadré attention">⚠ Attention</button>'
                 '<span style="flex:1"></span><button type="button" data-act="src" class="rtx-src">&lt;/&gt; Code source</button></div>'
                 f'<div class="rtx" id="rtx_{tid}" contenteditable="true">{v}</div>'
                 f'<textarea name="{name}" id="src_{tid}" class="code" style="display:none;min-height:320px">{esc(v)}</textarea>')
    elif t == "html": inner = f'<textarea name="{name}" rows="{2 if compact else 3}" style="min-height:0">{esc(v)}</textarea>'
    elif t == "textarea": inner = f'<textarea name="{name}" rows="{3 if compact else 4}" style="min-height:0">{esc(v)}</textarea>'
    elif t == "lines": inner = f'<textarea name="{name}" rows="4" style="min-height:0" placeholder="Une entrée par ligne">{esc(v)}</textarea><p class="help" style="margin:.2rem 0 0">Une entrée par ligne.</p>'
    elif t == "select": inner = f'<select name="{name}">' + "".join(f'<option value="{esc(o)}" {"selected" if o==v else ""}>{esc(o)}</option>' for o in f.get("options", [])) + "</select>"
    elif t == "bool": inner = f'<label style="margin:.4rem 0;font-weight:400;display:flex;gap:.5rem;align-items:center"><input type="checkbox" name="{name}" value="true" {"checked" if str(v).lower() in ("true","1","oui") else ""}> Oui</label>'
    elif t == "icon":
        inner = '<div class="ico-pick">' + "".join(f'<label title="{esc(lab)}"><input type="radio" name="{name}" value="{k}" {"checked" if k==v else ""}><span><svg viewBox="0 0 24 24">{svg}</svg></span></label>' for k, (lab, svg) in B.ICONS.items()) + "</div>"
    elif t == "image":
        inner = (f'<div class="imgf"><img src="{esc(v)}" alt="" onerror="this.style.opacity=.2" id="prev_{esc(name)}"><div style="flex:1">'
                 f'<select name="{name}" onchange="prevImg(this,&quot;prev_{esc(name)}&quot;)">{image_options(v)}</select>'
                 f'<div class="size">📐 Taille recommandée : <b>{esc(f.get("size","selon l’emplacement"))}</b> · <a href="/images" target="_blank">téléverser une image ↗</a> puis rechargez cette page.</div></div></div>')
    else: inner = f'<input type="text" name="{name}" value="{esc(v)}">'
    return f'<div class="{"full" if t in ("html","textarea","lines","image","icon","richtext") else ""}"><label>{esc(f.get("label", f["key"]))}</label>{inner}{help_}</div>'

def repeat_row(sec_id, f, i, row, is_tpl=False):
    idx = "__IDX__" if is_tpl else str(i)
    inner = "".join(field_input(f"r__{sec_id}__{f['key']}__{idx}__{sub['key']}", sub, row.get(sub["key"], sub.get("value", "")), compact=True) for sub in f.get("fields", []))
    return (f'<div class="rep" data-row><div class="rep-head"><span class="rownum">#{"" if is_tpl else i+1}</span>'
            f'<button type="button" class="mv" onclick="mvRow(this,-1)" title="Monter">▲</button><button type="button" class="mv" onclick="mvRow(this,1)" title="Descendre">▼</button>'
            f'<button type="button" class="del" onclick="delRow(this)">Supprimer</button></div><div class="fgrid">{inner}</div></div>')

def page_blocks(msg=""):
    rows = "".join(f'<tr><td><b>{esc(b["label"])}</b></td><td><code>pages/{esc(b["page"])}</code></td><td>{b["n"]} sections</td><td><a class="btn sm" href="/blocks?f={esc(b["name"])}">Modifier les blocs</a></td></tr>' for b in blocks_list())
    body = f"""{msg}<h1>Blocs de page</h1>
<div class="card"><p class="help" style="margin-top:0">Chaque section de la page (hero, constat, chiffres, étapes, offre…) est un bloc avec ses champs : titre, textes, images, boutons, listes. Modifiez, enregistrez, puis « Régénérer » — sans toucher au HTML. Les pages non listées ici s'éditent via « Toutes les pages ».</p>
<table>{rows or '<tr><td>Aucune page avec blocs.</td></tr>'}</table></div>"""
    return layout("Blocs de page", body, "/blocks")

def opts_panel(sec, pal):
    """Panneau « Apparence » d'une section (style ACF) : palette nommée, disposition, style, balisage du titre."""
    o = sec.get("opts", {}) or {}
    sid = sec["id"]
    swatches = "".join(
        f'<label class="sw" title="{esc(n)} {esc(h)}"><input type="radio" name="o__{sid}__bg" value="{esc(h)}" {"checked" if o.get("bg") == h else ""}><span style="background:{esc(h)}"></span><small>{esc(n)}</small></label>'
        for n, h in pal)
    freeval = o.get("bg") if o.get("bg") and o.get("bg") not in [h for _, h in pal] else "#ffffff"
    freechk = "checked" if (o.get("bg") and o.get("bg") not in [h for _, h in pal]) else ""
    defchk = "checked" if not o.get("bg") else ""
    tsel = "".join(f'<option value="{v}" {"selected" if o.get("titletag", "") == v else ""}>{lab}</option>'
                   for v, lab in [("", "Par défaut"), ("h1", "H1"), ("h2", "H2"), ("h3", "H3"), ("h4", "H4"), ("h5", "H5"), ("h6", "H6"), ("p", "Paragraphe"), ("span", "Span (aspect titre, sans poids SEO)")])
    padsel = "".join(f'<option value="{v}" {"selected" if o.get("pad", "") == v else ""}>{lab}</option>'
                     for v, lab in [("", "Normal"), ("compact", "Compact"), ("large", "Aéré")])
    return f"""<details class="opts"><summary>🎨 Apparence de la section</summary><div class="fgrid" style="margin-top:.7rem">
<div class="full"><label>Couleur du fond</label><div class="palette">
<label class="sw"><input type="radio" name="o__{sid}__bg" value="" {defchk}><span style="background:repeating-conic-gradient(#eee 0 25%,#fff 0 50%) 0 0/12px 12px"></span><small>Défaut</small></label>
{swatches}
<label class="sw"><input type="radio" name="o__{sid}__bg" value="__free__" {freechk}><span style="background:conic-gradient(red,yellow,lime,cyan,blue,magenta,red)"></span><small>Autre</small></label>
<input type="color" name="o__{sid}__bgfree" value="{esc(freeval if str(freeval).startswith("#") and len(str(freeval)) == 7 else "#ffffff")}" style="width:44px;height:34px;padding:2px;border:1.5px solid var(--line);border-radius:8px">
</div></div>
<div><label>Balisage du titre</label><select name="o__{sid}__titletag">{tsel}</select><p class="help">S'applique au premier titre de la section.</p></div>
<div><label>Espacement haut/bas</label><select name="o__{sid}__pad">{padsel}</select></div>
<div><label style="font-weight:400;display:flex;gap:.5rem;align-items:center;margin-top:1.6rem"><input type="checkbox" name="o__{sid}__flip" {"checked" if o.get("flip") else ""}> Inverser les colonnes (image à gauche ⇄ droite)</label>
<label style="font-weight:400;display:flex;gap:.5rem;align-items:center"><input type="checkbox" name="o__{sid}__rounded" {"checked" if o.get("rounded") else ""}> Bords arrondis</label>
<label style="font-weight:400;display:flex;gap:.5rem;align-items:center"><input type="checkbox" name="o__{sid}__full" {"checked" if o.get("full") else ""}> Contenu pleine largeur</label></div>
</div></details>"""

def blocks_form_parts(d, open_first=True, page_rel=None):
    """Rend les sections de blocs (cartes repliables) + la barre de sections. Retourne (html_sections, html_toc)."""
    secs = ""
    chunk_sids, pal = set(), []
    if page_rel:
        try:
            _, body_ = read_page(page_rel)
            chunk_sids = {s_ for s_, _m in sec_chunks(body_) if s_}
            pal = site_palette()
        except Exception: pass
    for sec in d.get("sections", []):
        inputs = ""
        for f in sec.get("fields", []):
            if f.get("type") == "repeat":
                rows = "".join(repeat_row(sec["id"], f, i, r) for i, r in enumerate(f.get("items", [])))
                help_ = f'<p class="help" style="margin:.2rem 0">{esc(f["help"])}</p>' if f.get("help") else ""
                inputs += (f'<div class="full"><label>{esc(f["label"])}</label>{help_}<div data-list="{sec["id"]}__{f["key"]}">{rows}</div>'
                           f'<button type="button" class="btn sm sec" onclick="addRow(this)">＋ Ajouter</button>'
                           f'<template>{repeat_row(sec["id"], f, 0, {}, is_tpl=True)}</template></div>')
            else:
                inputs += field_input(f"f__{sec['id']}__{f['key']}", f, f.get("value", ""))
                if f.get("htag"):
                    inputs += (f'<div><label>Niveau du titre « {esc((f.get("label") or f["key"])[:30])} » <span class="help" style="font-weight:400">(hiérarchie SEO : un seul H1 par page, pas de saut de niveau)</span></label>'
                               f'<select name="h__{sec["id"]}__{f["key"]}" style="width:auto">' + "".join(f'<option value="{t}" {"selected" if f["htag"] == t else ""}>{t.upper()}</option>' for t in ("h1", "h2", "h3", "h4", "h5", "h6")) + "</select></div>")
        closed = "" if (open_first and not secs) else " closed"
        tools = ""
        opts_html = ""
        movable = page_rel and sec["id"] in chunk_sids
        if movable:
            fq = quote(page_rel)
            tools = (f'<span class="sec-tools" onclick="event.stopPropagation()">'
                     f'<span class="drag" draggable="true" title="Glisser pour réordonner">⠿</span>'
                     f'<button type="button" class="mv" onclick="mvSec(this,-1)" title="Monter">▲</button>'
                     f'<button type="button" class="mv" onclick="mvSec(this,1)" title="Descendre">▼</button>'
                     f'<a class="tool" href="/section-dup?f={fq}&sec={sec["id"]}" title="Dupliquer la section">⧉ Dupliquer</a>'
                     f'<a class="tool" href="/model-new?f={fq}&sec={sec["id"]}" title="Réutilisable sur d’autres pages">☆ Modèle</a>'
                     f'<a class="tool danger" href="/section-del?f={fq}&sec={sec["id"]}" onclick="return confirm(\'Supprimer cette section et son contenu ?\')">✕</a></span>')
            opts_html = opts_panel(sec, pal)
        secs += (f'<div class="card sec-card{closed}" id="sec-{esc(sec["id"])}" {"data-sid=" + chr(34) + esc(sec["id"]) + chr(34) if movable else ""}>'
                 f'<h2 onclick="this.parentElement.classList.toggle(\'closed\')"><span class="tag">{esc(sec["id"])}</span><span class="sec-title">{esc(sec["label"])}</span>{tools}<span class="chev">▼</span></h2>'
                 f'<div class="sec-body">{opts_html}<div class="fgrid">{inputs}</div></div></div>')
    toc = " · ".join(f'<a href="#sec-{esc(sec["id"])}">{esc(sec["label"])}</a>' for sec in d.get("sections", []))
    toc = f'<p class="help">Sections : {toc} · <a href="#" onclick="document.querySelectorAll(\'.sec-card\').forEach(function(c){{c.classList.remove(\'closed\')}});return false">tout déplier</a> · <a href="#" onclick="document.querySelectorAll(\'.sec-card\').forEach(function(c){{c.classList.add(\'closed\')}});return false">tout replier</a></p>' if d.get("sections") else ""
    return secs, toc

def add_section_box(page_rel, d):
    """Encart « Ajouter une section » (modèles de la bibliothèque)."""
    mm = load_models()["models"]
    if not mm:
        return '<div class="card"><h2 style="margin-top:0;font-size:1rem">＋ Ajouter une section</h2><p class="help">Votre bibliothèque est vide : sur n\'importe quelle section, cliquez « ☆ Modèle » pour l\'y ajouter — vous pourrez ensuite la poser ici et sur toutes les pages. <a href="/library">Ouvrir la bibliothèque</a></p></div>'
    fams = {}
    for x in mm: fams.setdefault(std_family(x.get("family")), []).append(x)
    opts = "".join(f'<optgroup label="{esc(fam)}">' + "".join(f'<option value="{esc(x["id"])}">{esc(x["name"])}</option>' for x in xs) + "</optgroup>" for fam in fam_sort(fams) for xs in [fams[fam]])
    pos = '<option value="">À la fin de la page</option>' + "".join(f'<option value="{esc(sec["id"])}">Après « {esc(sec["label"])[:40]} »</option>' for sec in d.get("sections", []))
    return f"""<div class="card"><h2 style="margin-top:0;font-size:1rem">＋ Ajouter une section</h2>
<form method="post" action="/section-add" class="actions"><input type="hidden" name="f" value="{esc(page_rel)}">
<label style="margin:0">Modèle</label><select name="model" style="width:auto;min-width:260px">{opts}</select>
<label style="margin:0">Position</label><select name="after" style="width:auto">{pos}</select>
<button class="btn sm">Ajouter la section</button><a class="btn sm sec" href="/library">Gérer la bibliothèque</a></form></div>"""

RTX_ASSETS = """<style>
.rtxbar{display:flex;gap:.25rem;flex-wrap:wrap;background:#f0f3f7;border:1px solid #dde3ea;border-bottom:0;border-radius:10px 10px 0 0;padding:.35rem}
.rtxbar button{border:1px solid transparent;background:transparent;border-radius:6px;padding:.25rem .55rem;cursor:pointer;font-size:.82rem;font-family:inherit}
.rtxbar button:hover{background:#fff;border-color:#dde3ea}
.rtx{background:#fff;border:1px solid #dde3ea;border-radius:0 0 10px 10px;padding:1rem 1.2rem;min-height:300px;max-height:640px;overflow:auto;font-size:.95rem;line-height:1.6}
.rtx:focus{outline:2px solid #1a73e8;outline-offset:-1px}
.rtx h2{font-size:1.3rem;margin:1.2em 0 .4em}.rtx h3{font-size:1.05rem;margin:1em 0 .3em}.rtx a{color:#1a73e8}
.rtx .callout,.rtx .callout-warn{border-left:4px solid #137333;background:#e6f4ea;border-radius:8px;padding:.7rem 1rem;margin:.8rem 0}
.rtx .callout-warn{border-color:#e37400;background:#fef7e0}
</style><script>
document.querySelectorAll(".rtxbar").forEach(function(bar){
  var id=bar.dataset.rtx,ed=document.getElementById("rtx_"+id),src=document.getElementById("src_"+id);
  function sync(){if(src.style.display==="none")src.value=ed.innerHTML;}
  bar.addEventListener("click",function(e){
    var b=e.target.closest("button");if(!b)return;e.preventDefault();
    if(b.dataset.cmd){document.execCommand(b.dataset.cmd,false,null);ed.focus();}
    else if(b.dataset.blk){document.execCommand("formatBlock",false,"<"+b.dataset.blk+">");ed.focus();}
    else if(b.dataset.act==="link"){var u=prompt("Adresse du lien (ex. /contact/ ou https://…)");if(u)document.execCommand("createLink",false,u);ed.focus();}
    else if(b.dataset.act==="img"){var m=prompt("Chemin de l'image (ex. /assets/img/uploads/photo.webp) — onglet Images pour téléverser");if(m)document.execCommand("insertHTML",false,'<img src="'+m+'" alt="" loading="lazy">');ed.focus();}
    else if(b.dataset.act==="callout"){document.execCommand("insertHTML",false,'<div class="callout"><b>Bon à savoir :</b> votre texte…</div><p></p>');ed.focus();}
    else if(b.dataset.act==="warn"){document.execCommand("insertHTML",false,'<div class="callout-warn"><b>Attention :</b> votre texte…</div><p></p>');ed.focus();}
    else if(b.dataset.act==="src"){
      if(src.style.display==="none"){src.value=ed.innerHTML;ed.style.display="none";src.style.display="block";b.innerHTML="👁 Visuel";}
      else{ed.innerHTML=src.value;src.style.display="none";ed.style.display="block";b.innerHTML="&lt;/&gt; Code source";}
    }
  });
  ed.addEventListener("input",sync);
  var form=ed.closest("form");
  if(form)form.addEventListener("submit",function(){if(src.style.display==="none")src.value=ed.innerHTML;});
});
</script>"""

BLOCKS_JS = """<script>
document.querySelectorAll('a[href^="#sec-"]').forEach(function(a){a.addEventListener('click',function(){var c=document.querySelector(a.getAttribute('href'));if(c)c.classList.remove('closed');});});
function prevImg(sel,id){document.getElementById(id).src=sel.value||'';}
function renum(list){list.querySelectorAll('[data-row]').forEach(function(r,i){r.querySelector('.rownum').textContent='#'+(i+1);r.querySelectorAll('[name]').forEach(function(el){el.name=el.name.replace(/__(\\d+|__IDX__)__/,'__'+i+'__');});});}
function addRow(btn){var wrap=btn.parentElement,list=wrap.querySelector('[data-list]'),tpl=wrap.querySelector('template');var div=document.createElement('div');div.innerHTML=tpl.innerHTML.trim();list.appendChild(div.firstChild);renum(list);}
function delRow(btn){if(!confirm('Supprimer cette entrée ?'))return;var row=btn.closest('[data-row]'),list=row.parentElement;row.remove();renum(list);}
function mvRow(btn,d){var row=btn.closest('[data-row]'),list=row.parentElement;var sib=d<0?row.previousElementSibling:row.nextElementSibling;if(!sib)return;if(d<0)list.insertBefore(row,sib);else list.insertBefore(sib,row);renum(list);}
function ins(t){var ta=document.getElementById('body'),s=ta.selectionStart,e=ta.selectionEnd;ta.value=ta.value.slice(0,s)+"\\n"+t+"\\n"+ta.value.slice(e);ta.focus();ta.selectionStart=ta.selectionEnd=s+t.length+2;}
function secOrder(){var o=[].map.call(document.querySelectorAll('.sec-card[data-sid]'),function(c){return c.dataset.sid}).join(',');var i=document.querySelector('input[name=sec_order]');if(i)i.value=o;}
function mvSec(btn,d){var card=btn.closest('.sec-card'),sib=d<0?card.previousElementSibling:card.nextElementSibling;while(sib&&!sib.dataset.sid)sib=d<0?sib.previousElementSibling:sib.nextElementSibling;if(!sib)return;if(d<0)card.parentNode.insertBefore(card,sib);else card.parentNode.insertBefore(sib,card);secOrder();}
(function(){var dragged=null;
document.querySelectorAll('.sec-card[data-sid] .drag').forEach(function(h){
  h.addEventListener('dragstart',function(e){dragged=h.closest('.sec-card');e.dataTransfer.effectAllowed='move';try{e.dataTransfer.setData('text/plain',dragged.dataset.sid);}catch(_){}var c=dragged;setTimeout(function(){c.style.opacity=.4},0);});
  h.addEventListener('dragend',function(){if(dragged){dragged.style.opacity='';dragged=null;}document.querySelectorAll('.sec-card.dragover').forEach(function(c){c.classList.remove('dragover')});secOrder();});
});
document.querySelectorAll('.sec-card[data-sid]').forEach(function(card){
  card.addEventListener('dragover',function(e){if(!dragged||dragged===card)return;e.preventDefault();card.classList.add('dragover');});
  card.addEventListener('dragleave',function(){card.classList.remove('dragover');});
  card.addEventListener('drop',function(e){if(!dragged||dragged===card)return;e.preventDefault();card.classList.remove('dragover');var r=card.getBoundingClientRect();if(e.clientY<r.top+r.height/2)card.parentNode.insertBefore(dragged,card);else card.parentNode.insertBefore(dragged,card.nextSibling);secOrder();});
});
secOrder();})();
</script>"""

def blocks_name_for(f): return re.sub(r"\.html$", "", f).replace("/", "__")

def page_edit(f, msg=""):
    meta, body = read_page(f); is_art = meta.get("type") == "article"
    fields = [("title", "Titre SEO (balise title, ≤ 65 caractères)"), ("description", "Meta description (140-160 caractères)"), ("bc_label", "Intitulé dans le fil d'Ariane (vide = titre court de la page) — les niveaux suivent tout seuls la parenté de l'adresse")]
    if not meta.get("bc_label") and meta.get("breadcrumb"):   # ancien format : on récupère l'intitulé déjà choisi
        last = meta["breadcrumb"].split(";")[-1].strip()
        meta["bc_label"] = (last.split("|")[0] if "|" in last else last).strip()
    if is_art: fields += [("card_title", "Titre court (cartes & listes)"), ("excerpt", "Extrait (cartes)"), ("og_image", "Image de couverture (chemin /assets/img/…)"), ("date", "Date (AAAA-MM-JJ)"), ("date_fr", "Date affichée (ex. 16 août 2026)")]
    else: fields += [("og_image", "Image de partage (optionnel)"), ("lang", "Langue de la page (fr, en…) — vide = langue par défaut"), ("translations", "Traductions (ex. en=/en/contact/,es=/es/contacto/)")]
    fields += [("og_title", "Titre de partage réseaux (og:title — vide = titre SEO)"), ("og_description", "Description de partage (og:description — vide = meta description)"),
               ("canonical", "URL canonique (vide = celle de la page ; /autre-page/ ou URL complète)")]
    inputs = "".join(f'<label>{esc(l)}</label><input type="text" name="m_{k}" value="{esc(meta.get(k, ""))}"{" data-count=65" if k == "title" else (" data-count=160" if k == "description" else "")}>' for k, l in fields)
    # adresse de la page (slug FR) éditable + indexation
    cur_slug = "" if f == "index.html" else re.sub(r"\.html$", "", f)
    if is_art and "/" in cur_slug:
        parts = cur_slug.split("/"); art_theme, leaf = parts[-2], parts[-1]
        topts = "".join(f'<option value="{esc(sl)}" {"selected" if sl == art_theme else ""}>{esc(lab)}</option>' for sl, lab in B.GUIDE_THEMES)
        if art_theme not in dict(B.GUIDE_THEMES): topts = f'<option value="{esc(art_theme)}" selected>{esc(art_theme)} (catégorie hors liste)</option>' + topts
        slug_in = (f'<div class="row"><div><label>Catégorie</label><select name="art_theme">{topts}</select>'
                   '<p class="help">Les catégories se créent dans l’onglet Articles.</p></div>'
                   f'<div><label>Adresse de l’article (slug)</label><input type="text" name="art_slug" value="{esc(leaf)}" style="font-family:ui-monospace,monospace">'
                   '<p class="help"><b>301 automatique</b> et liens internes réécrits si la catégorie ou l’adresse change.</p></div></div>')
    else:
        slug_in = ("" if f == "index.html" else f'<label>Adresse de la page (slug) — <b>301 automatique</b> vers la nouvelle adresse en cas de changement</label>'
               f'<input type="text" name="new_slug" value="{esc(cur_slug)}" style="font-family:ui-monospace,monospace">')
    noidx = f'<label style="font-weight:400;display:flex;gap:.5rem;align-items:center;margin:.6rem 0"><input type="checkbox" name="m_noindex" value="true" {"checked" if meta.get("noindex","false").lower()=="true" else ""}> Ne pas indexer cette page (noindex) — elle sort aussi du sitemap</label>'
    inputs = slug_in + inputs + noidx
    counters_js = """<script>
document.querySelectorAll('[data-count]').forEach(function(i){
  var max=parseInt(i.dataset.count),c=document.createElement('span');c.style.cssText='font-size:.75rem;margin-left:.4rem';
  i.insertAdjacentElement('afterend',c);
  function u(){var n=i.value.length;c.textContent=n+' / '+max+' caractères';c.style.color=(max===65?(n>65?'#c5221f':(n<25&&n>0?'#e37400':'#137333')):(n>160?'#c5221f':(n>=140?'#137333':(n>0?'#e37400':'#80898f'))));}
  i.addEventListener('input',u);u();});
if(location.hash){var el=document.querySelector(location.hash);if(el&&el.classList.contains('closed')){el.classList.remove('closed');el.scrollIntoView();}}
</script>"""
    hidden = "".join(f'<input type="hidden" name="m_{k}" value="{esc(v)}">' for k, v in meta.items() if k not in dict(fields) and k not in ("draft", "priority", "noindex", "breadcrumb"))
    snips = "".join(f'<button type="button" onclick="ins({esc(json.dumps(v))})">{esc(k)}</button>' for k, v in SNIPPETS.items())
    del_btn = ('<a class="btn sm danger" href="/delete?f=' + esc(f) + '" onclick="return confirm(\'Mettre cette page à la corbeille ?\')">Supprimer</a>') if role_of(CURRENT_USER) == "admin" else ""
    bname = blocks_name_for(f); has_blocks = os.path.exists(os.path.join(BLOCKS, bname + ".json"))
    url = B.url_from_path(f); back = "/articles" if is_art else "/pages"
    blocks_html = ""; toc = ""; addbox = ""
    if has_blocks:
        d = load_blocks(bname); secs, toc = blocks_form_parts(d, page_rel=f)
        sync = f'<a class="btn sm sec" href="/blocks-sync?f={esc(f)}" onclick="return confirm(\'Relire le HTML de la page et reconstruire la liste des blocs ? (à faire après avoir modifié la structure HTML ci-dessous)\')">↻ Resynchroniser les blocs depuis le HTML</a>'
        blocks_html = f'<h2 style="font-size:1.05rem;margin:1.2rem 0 .4rem;display:flex;align-items:center;gap:1rem">Blocs de la page <span class="help" style="font-weight:400">— glissez ⠿ pour réordonner · 🎨 Apparence dans chaque section</span><span style="flex:1"></span>{sync}</h2>{toc}<input type="hidden" name="name" value="{esc(bname)}"><input type="hidden" name="sec_order" value="">{secs}'
        addbox = add_section_box(f, d)
        html_title = "Structure HTML (avancé)"; html_help = "Ici, la structure de la page avec des jetons <code>{{B:section.champ}}</code> à la place des textes. Modifiez-la pour ajouter/retirer un élément, puis cliquez « Resynchroniser les blocs »."
        html_closed = " closed"
    elif not is_art:
        blocks_html = f'<div class="msg">Cette page n\'a pas encore de blocs : <a class="btn sm" href="/blocks-sync?f={esc(f)}">Activer les blocs (extraction automatique des textes, images et boutons)</a></div>'
        html_title = "Contenu de la page (HTML)"; html_help = "Le contenu ci-dessous est du HTML : les boutons « Insérer » ajoutent un bloc prêt à l'emploi à l'endroit du curseur."; html_closed = ""
    else:
        html_title = "Contenu de l'article (HTML)"; html_help = "Les boutons « Insérer » ajoutent un bloc prêt à l'emploi à l'endroit du curseur. Les variables <code>{{BREADCRUMB}} {{CALENDLY}} {{TEL}} {{EMAIL}}</code> sont remplacées automatiquement."; html_closed = ""
    body_html = f"""{msg}<h1>Éditer : <span style="color:var(--blue)">{esc(url)}</span> {"<span class=tag>article</span>" if is_art else ""}</h1>
<form method="post" action="/save"><input type="hidden" name="f" value="{esc(f)}">{hidden}
<div class="card sec-card closed" id="seo"><h2 onclick="this.parentElement.classList.toggle('closed')"><span class="tag">SEO</span>Référencement, statut, fil d'Ariane<span class="chev">▼</span></h2><div class="sec-body"><div class="row"><div>{inputs}</div><div><label>Priorité sitemap</label><select name="m_priority">{"".join(f'<option {"selected" if meta.get("priority","0.7")==v else ""}>{v}</option>' for v in ["1.0","0.9","0.8","0.7","0.6","0.5","0.3"])}</select>
<label>Statut</label><select name="m_draft"><option value="false" {"selected" if meta.get("draft")!="true" else ""}>Publié</option><option value="true" {"selected" if meta.get("draft")=="true" else ""}>Brouillon (non généré)</option></select></div></div></div></div>
{blocks_html}
<div class="card sec-card{html_closed}"><h2 onclick="this.parentElement.classList.toggle('closed')"><span class="tag">HTML</span>{html_title}<span class="chev">▼</span></h2><div class="sec-body"><p class="help">{html_help}</p><div class="snips"><span class="help" style="margin-right:.4rem">Insérer :</span>{snips}</div>
<textarea class="code" name="body" id="body">{esc(body)}</textarea></div></div>
<div class="sticky-actions actions"><button class="btn">Enregistrer</button><button class="btn blue" name="then" value="build">Enregistrer + régénérer</button><a class="btn sec" href="{PREVIEW_BASE}{url}" target="_blank">Aperçu ↗</a><a class="btn sec" href="{back}">Retour</a>
<span style="flex:1"></span>{del_btn}</div></form>
{addbox}
{BLOCKS_JS}
{RTX_ASSETS}
{counters_js}"""
    return layout("Éditer", body_html, back)


NAVBAR_PATH = os.path.join(ROOT, "blocks", "_navbar.json")
def load_navbar():
    try: return json.load(open(NAVBAR_PATH, encoding="utf-8"))
    except Exception: return {}

def nav_header_html(nv):
    """En-tête générée par le constructeur de menu : logo, fond, liens, téléphone, compte, bouton.
    HTML autonome (CSS embarqué, burger mobile en CSS pur) — écrit dans layout/header.html, donc
    traduit par la mécanique d'habillage existante et compatible sélecteur de langue / header-home."""
    bg = nv.get("bg") or "#ffffff"; fg = nv.get("color") or "#1c2a38"
    accent = nv.get("accent") or "#1a73e8"
    logo = (nv.get("logo") or "").strip(); lh = str(nv.get("logo_height") or "44")
    brand = (f'<img src="{esc(logo)}" alt="{esc(B.SITE_NAME)}" style="height:{esc(lh)}px;width:auto">' if logo
             else f'<span class="bcmnav-name">{esc(B.SITE_NAME)}</span>')
    links = ""
    for line in (nv.get("links") or "").splitlines():
        if "|" not in line: continue
        lab, url = (x.strip() for x in line.split("|", 1))
        if lab and url: links += f'<a href="{esc(url)}">{esc(lab)}</a>'
    side = ""
    if str(nv.get("tel")) in ("1", "true", "True"):
        side += (f'<a class="bcmnav-tel" href="tel:{esc(B.CONFIG.get("TEL_HREF") or "")}">'
                 f'<svg viewBox="0 0 24 24" width="15" height="15" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round"><path d="M22 16.9v3a2 2 0 0 1-2.2 2 19.8 19.8 0 0 1-8.6-3 19.5 19.5 0 0 1-6-6 19.8 19.8 0 0 1-3-8.7A2 2 0 0 1 4.1 2h3a2 2 0 0 1 2 1.7c.1 1 .4 2 .7 2.8a2 2 0 0 1-.5 2.1L8.1 9.9a16 16 0 0 0 6 6l1.3-1.2a2 2 0 0 1 2.1-.5c.9.3 1.9.6 2.8.7a2 2 0 0 1 1.7 2z"/></svg>'
                 f'{esc(nv.get("tel_label") or B.CONFIG.get("TEL") or "")}</a>')
    if (nv.get("account_url") or "").strip():
        side += f'<a class="bcmnav-account" href="{esc(nv["account_url"].strip())}">{esc(nv.get("account_label") or "Mon compte")}</a>'
    if (nv.get("cta_url") or "").strip():
        side += f'<a class="bcmnav-cta" href="{esc(nv["cta_url"].strip())}">{esc(nv.get("cta_label") or "Contact")}</a>'
    sticky = "position:sticky;top:0;z-index:60;" if str(nv.get("sticky", "1")) in ("1", "true", "True") else ""
    return f"""<header class="bcmnav">
  <div class="bcmnav-in">
    <a class="bcmnav-brand" href="/">{brand}</a>
    <input type="checkbox" id="bcmnav-t" class="bcmnav-toggle">
    <label for="bcmnav-t" class="bcmnav-burger" aria-label="Ouvrir le menu"><span></span><span></span><span></span></label>
    <nav class="bcmnav-links">{links}</nav>
    <div class="bcmnav-side">{side}</div>
  </div>
</header>
<style>
.bcmnav{{{sticky}background:{bg};color:{fg};border-bottom:1px solid rgba(0,0,0,.07);font-family:inherit}}
.bcmnav-in{{max-width:1200px;margin:0 auto;display:flex;align-items:center;gap:1.4rem;padding:.65rem 1.2rem}}
.bcmnav-brand{{display:flex;align-items:center;text-decoration:none;color:inherit}}
.bcmnav-name{{font-weight:700;font-size:1.15rem;letter-spacing:-.01em}}
.bcmnav-links{{display:flex;gap:1.2rem;flex:1;flex-wrap:wrap}}
.bcmnav-links a{{color:inherit;text-decoration:none;font-size:.95rem;padding:.3rem 0;border-bottom:2px solid transparent}}
.bcmnav-links a:hover{{border-bottom-color:{accent}}}
.bcmnav-side{{display:flex;align-items:center;gap:1rem;margin-left:auto}}
.bcmnav-tel,.bcmnav-account{{display:inline-flex;align-items:center;gap:.4rem;color:inherit;text-decoration:none;font-size:.92rem;white-space:nowrap}}
.bcmnav-tel:hover,.bcmnav-account:hover{{opacity:.75}}
.bcmnav-cta{{background:{accent};color:#fff;text-decoration:none;padding:.5rem 1.1rem;border-radius:10px;font-size:.92rem;white-space:nowrap}}
.bcmnav-cta:hover{{filter:brightness(1.08)}}
.bcmnav-toggle{{display:none}}
.bcmnav-burger{{display:none;flex-direction:column;gap:4px;cursor:pointer;margin-left:auto;padding:.4rem}}
.bcmnav-burger span{{width:22px;height:2px;background:currentColor;display:block}}
@media (max-width:920px){{
  .bcmnav-burger{{display:flex}}
  .bcmnav-links,.bcmnav-side{{display:none}}
  .bcmnav-toggle:checked~.bcmnav-links,.bcmnav-toggle:checked~.bcmnav-side{{display:flex;flex-direction:column;align-items:flex-start;width:100%;gap:.6rem;padding:.6rem 0}}
  .bcmnav-in{{flex-wrap:wrap}}
  .bcmnav-side{{margin-left:0}}
}}
</style>"""

LAYOUT = os.path.join(ROOT, "layout")
LAYOUT_FILES = [("header.html", "En-tête (header) du site"), ("footer.html", "Pied de page (footer)"),
                ("head.html", "Balises du <head> (styles, polices, scripts)"), ("scripts.html", "Scripts de fin de page")]
def page_layout(msg=""):
    cards = ""
    for fn, label in LAYOUT_FILES:
        fp = os.path.join(LAYOUT, fn)
        val = open(fp, encoding="utf-8").read() if os.path.exists(fp) else ""
        cards += f'<div class="card"><label style="margin-top:0">{esc(label)} <span class="help" style="font-weight:400">layout/{fn}</span></label><textarea class="code" name="{fn}" style="min-height:180px">{esc(val)}</textarea></div>'
        if fn == "header.html":
            hh = os.path.join(LAYOUT, "header-home.html")
            if os.path.exists(hh):
                hv = open(hh, encoding="utf-8").read()
                cards += ('<div class="card"><label style="margin-top:0">En-tête spécifique à la PAGE D\'ACCUEIL <span class="help" style="font-weight:400">layout/header-home.html</span></label>'
                          '<p class="help">Affiché uniquement sur l\'accueil (et les accueils traduits) ; toutes les autres pages gardent l\'en-tête commun ci-dessus.</p>'
                          f'<textarea class="code" name="header-home.html" style="min-height:180px">{esc(hv)}</textarea>'
                          '<div class="actions" style="margin-top:.6rem"><button class="btn sm danger" name="del_home_header" value="1" onclick="return confirm(\'Supprimer l\\\'en-tête d\\\'accueil ? L\\\'accueil reprendra l\\\'en-tête commun.\')">Supprimer cette variante</button></div></div>')
            else:
                cards += ('<p class="help" style="margin:-.4rem 0 1rem">Besoin d\'un menu différent sur la page d\'accueil ? '
                          '<button class="btn sm sec" name="mk_home_header" value="1">Créer un en-tête d\'accueil</button> '
                          '(copie de l\'en-tête commun, à modifier ensuite — les pages intérieures ne changent pas).</p>')
    # constructeur de menu paramétrable (optionnel)
    nv = load_navbar()
    on = str(nv.get("enabled")) in ("1", "true", "True")
    ck = lambda k, d="": esc(nv.get(k) or d)
    builder = f"""<div class="card sec-card {'closed' if not on else ''}"><h2 onclick="this.parentElement.classList.toggle('closed')">🧱 Constructeur de menu (optionnel){' <span class="tag">actif</span>' if on else ''}<span class="chev">▼</span></h2><div class="sec-body">
<p class="help">Composez l'en-tête sans toucher au HTML : logo, couleur de fond, liens, téléphone, bouton, lien compte. En l'activant, il <b>remplace</b> l'en-tête ci-dessus (l'original est sauvegardé et restauré si vous le désactivez). Il reste traduit par « Traduire l'habillage » — après modification du menu, relancez la traduction. Le menu mobile (burger) est automatique.</p>
<form method="post" action="/navbar-save">
<label style="font-weight:500;display:flex;gap:.5rem;align-items:center"><input type="checkbox" name="enabled" value="1" {"checked" if on else ""}> Activer ce menu (remplace l'en-tête importé)</label>
<div class="row"><div>
<label>Logo</label><select name="logo">{image_options(nv.get("logo") or "")}</select>
<label>Hauteur du logo (px)</label><input type="text" name="logo_height" value="{ck('logo_height','44')}">
<label>Couleur de fond</label><input type="text" name="bg" value="{ck('bg','#ffffff')}" placeholder="#ffffff">
<label>Couleur du texte</label><input type="text" name="color" value="{ck('color','#1c2a38')}">
<label>Couleur d'accent (bouton, survols)</label><input type="text" name="accent" value="{ck('accent','#1a73e8')}">
<label style="font-weight:500;display:flex;gap:.5rem;align-items:center;margin-top:1rem"><input type="checkbox" name="sticky" value="1" {"checked" if str(nv.get('sticky','1')) in ('1','true','True') else ""}> Menu collant (reste visible au défilement)</label>
</div><div>
<label>Liens du menu — un par ligne : <code>Texte | /adresse/</code></label><textarea name="links" style="min-height:140px" placeholder="Accueil | /&#10;Nos services | /services/&#10;Contact | /contact/">{ck('links')}</textarea>
<label style="font-weight:500;display:flex;gap:.5rem;align-items:center"><input type="checkbox" name="tel" value="1" {"checked" if str(nv.get('tel')) in ('1','true','True') else ""}> Afficher le téléphone (numéro des Réglages, cliquable)</label>
<label>Bouton d'action — libellé</label><input type="text" name="cta_label" value="{ck('cta_label','Contact')}">
<label>Bouton d'action — lien (vide = pas de bouton)</label><input type="text" name="cta_url" value="{ck('cta_url')}" placeholder="/contact/">
<label>Lien « compte » — libellé</label><input type="text" name="account_label" value="{ck('account_label')}" placeholder="Mon compte">
<label>Lien « compte » — adresse (vide = pas de lien)</label><input type="text" name="account_url" value="{ck('account_url')}" placeholder="https://espace-client…">
</div></div>
<div class="actions" style="margin-top:1rem"><button class="btn">Enregistrer et appliquer</button><span class="help">Appliqué = écrit dans l'en-tête + site régénéré. Décoché = l'en-tête importé d'origine est restauré.</span></div>
</form></div></div>"""
    cards = builder + cards
    # versions traduites de l'habillage (header + footer), une par langue
    others = [(c.strip(), l.strip()) for c, l in B.LANGS if c.strip() != B.DEFAULT_LANG]
    for lang, lbl in others:
        inner = ""
        for base in ("header", "footer"):
            fn = f"{base}.{lang}.html"; fp = os.path.join(LAYOUT, fn)
            val = open(fp, encoding="utf-8").read() if os.path.exists(fp) else ""
            note = "" if val else f'<p class="help">Pas encore traduit : les pages /{lang}/ affichent pour l’instant la version principale. Cliquez « Traduire l’habillage ».</p>'
            inner += f'<label>{"En-tête (header)" if base == "header" else "Pied de page (footer)"} — {esc(lbl)} <span class="help" style="font-weight:400">layout/{fn}</span></label>{note}<textarea class="code" name="{fn}" style="min-height:140px">{esc(val)}</textarea>'
        cards += (f'<div class="card"><h2 style="margin-top:0;font-size:1rem">🌐 Habillage en {esc(lbl)} ({lang.upper()})</h2>{inner}'
                  f'<div class="actions" style="margin-top:.8rem"><form method="post" action="/layout-translate" style="margin:0" onsubmit="return confirm(\'Traduire automatiquement l’en-tête et le pied de page en {esc(lbl)} ? Les versions {lang.upper()} ci-dessus seront remplacées (y compris vos corrections manuelles).\')"><input type="hidden" name="lang" value="{lang}"><button class="btn sm">Traduire l’habillage en {esc(lbl)}</button></form><span class="help">Traduction DeepL du HTML complet, balises préservées ; relisez puis Enregistrer + régénérer.</span></div></div>')
    langs_note = "" if others else '<p class="help">Pour un habillage multilingue : activez d’abord des langues dans <a href="/settings#set-langs">Réglages › Langues & traduction</a> — des versions traduites de l’en-tête et du pied de page apparaîtront ici.</p>'
    body = f"""{msg}<h1>Menu & habillage (site importé)</h1>
<p class="help">Ce site a été importé avec son propre habillage : l'en-tête (menu), le pied de page, les styles et les scripts d'origine sont conservés tels quels dans le dossier <code>layout/</code> et s'éditent ici en HTML. Le contenu des pages, lui, s'édite par blocs dans « Toutes les pages ».</p>
{langs_note}
<form method="post" action="/layout-save">{cards}
<div class="sticky-actions actions"><button class="btn">Enregistrer</button><button class="btn blue" name="then" value="build">Enregistrer + régénérer</button><a class="btn sec" href="{PREVIEW_BASE}/" target="_blank">Aperçu ↗</a></div></form>"""
    return layout("Menu & habillage", body, "/menu")

def layout_translate(lang):
    """Traduit header.html et footer.html en layout/<base>.<lang>.html (HTML complet, balises préservées)."""
    import translate as T
    srcs, names = [], []
    for base in ("header", "header-home", "footer"):
        fp = os.path.join(LAYOUT, f"{base}.html")
        if os.path.exists(fp): srcs.append(open(fp, encoding="utf-8").read()); names.append(base)
    if not srcs: raise ValueError("Aucun fichier layout/header.html ou footer.html à traduire.")
    shielded, tokens = [], []
    for t in srcs:
        sh, tk = T.shield(t); shielded.append(sh); tokens.append(tk)
    got = T.call_provider(shielded, lang, B.CONFIG)
    for base, tr_text, tk in zip(names, got, tokens):
        open(os.path.join(LAYOUT, f"{base}.{lang}.html"), "w", encoding="utf-8").write(T.unshield(tr_text, tk))
    return len(names)

# ---------- Opérations de sections (dupliquer, supprimer, réordonner, ajouter, apparence) ----------
import copy as _copy

SEC_RE = re.compile(r"<section\b[\s\S]*?</section>", re.I)
TOKEN_SID_RE = re.compile(r"\{\{B:([\w-]+)\.")

def sec_chunks(body):
    """[(sid, match)] des <section>…</section> de premier niveau portant des jetons."""
    out = []
    for m in SEC_RE.finditer(body):
        t = TOKEN_SID_RE.search(m.group(0))
        out.append((t.group(1) if t else None, m))
    return out

def chunk_of(body, sid):
    for s, m in sec_chunks(body):
        if s == sid: return m
    return None

def new_sid(d):
    ns = {sec["id"] for sec in d.get("sections", [])}
    i = 1
    while f"s{i}" in ns: i += 1
    return f"s{i}"

# ---------- Nomenclature Beecom — Standard des blocs v3.0 (familles + tags) ----------
# Référence interne commune aux sites WordPress full ACF et au générateur HTML.
# Détail : NOMENCLATURE-BEECOM.md à la racine du site (source du standard : projet 01 · Stack Full ACF).
FAM_HERO = "Héros / ouverture de page"; FAM_CONT = "Contenus & colonnes"; FAM_GAL = "Galeries & sliders"
FAM_CONV = "Conversion & réassurance"; FAM_PRAT = "Contenus pratiques & dynamiques"; FAM_EXT = "Extensions métier"
FAMILY_ORDER = [FAM_HERO, FAM_CONT, FAM_GAL, FAM_CONV, FAM_PRAT, FAM_EXT]
STD_TAGS = {
    FAM_HERO: ["FULLIMAGE", "BLOC_SUR_IMAGE", "VIDEO"],
    FAM_CONT: ["COLONNES_5050", "COLONNES_TIERS", "COLONNES_5050_SMALL", "COLONNES_5050_FAQ", "COLONNES_5050_PICTO", "PAGE_SIMPLE", "FAQ"],
    FAM_GAL: ["IMAGES_CARREES", "DIAPORAMA_3COL", "DIAPORAMA_INFINI", "VISITE_3D"],
    FAM_CONV: ["AVIS", "TEMOIGNAGE", "ATOUTS", "REASSURANCE", "CHIFFRES_CLES", "ETAPES", "LABELS", "TARIFS", "CTA_PAGES"],
    FAM_PRAT: ["ARTICLES", "SERVICES", "DOCUMENTS", "BONNES_ADRESSES", "CARTE"],
    FAM_EXT: ["HEBERGEMENTS", "EQUIPEMENTS", "METEO", "RESERVATION"],
}
# Tags proposés (pas encore dans le standard v3.0 — toute évolution se décide au projet 01)
STD_PROPOSALS = ["FORMULAIRE"]
# Anciennes familles (modèles enregistrés avant la nomenclature) → familles du standard, sans toucher aux fichiers
FAM_ALIAS = {"Héros": FAM_HERO, "FAQ": FAM_CONT, "Chiffres": FAM_CONV, "Témoignages": FAM_CONV,
             "Tarifs": FAM_CONV, "Appel à l'action": FAM_CONV, "Carrousel": FAM_GAL, "Formulaire": FAM_CONV,
             "Étapes": FAM_CONV, "Cartes / listes": FAM_CONT, "Image & texte": FAM_CONT, "Contenu": FAM_CONT}
def std_family(name):
    name = (name or "").strip()
    return name if name in FAMILY_ORDER else FAM_ALIAS.get(name, FAM_CONT)
def fam_sort(fams): return sorted(fams, key=lambda x: FAMILY_ORDER.index(x) if x in FAMILY_ORDER else 99)
# Détection par mots-clés dans le HTML : (famille, tag suggéré, mots-clés)
FAMILIES = [
    (FAM_HERO, "FULLIMAGE", ("hero",)),
    (FAM_HERO, "VIDEO", ("<video", "youtube.com/embed", "player.vimeo")),
    (FAM_CONT, "FAQ", ("faq", "<details")),
    (FAM_CONV, "CHIFFRES_CLES", ("stats", "chip", '"big"')),
    (FAM_CONV, "TEMOIGNAGE", ("testi",)),
    (FAM_CONV, "AVIS", ("avis", "review", "rating")),
    (FAM_CONV, "TARIFS", ("pricing", "price-card", "install-band", "tarif")),
    (FAM_CONV, "CTA_PAGES", ("cta",)),
    (FAM_GAL, "DIAPORAMA_INFINI", ("slider", "carousel", "swiper", "marquee")),
    (FAM_GAL, "IMAGES_CARREES", ("gallery", "galerie", "lightbox")),
    (FAM_PRAT, "CARTE", ("leaflet", "gmap", "maps.google", "openstreetmap")),
    (FAM_CONV, "FORMULAIRE", ("<form", "form-card")),
    (FAM_CONV, "ETAPES", ("steps", "step-head")),
    (FAM_CONT, "COLONNES_TIERS", ("card", "metier-card", "grid")),
    (FAM_CONT, "COLONNES_5050", ("two-col", "<img")),
]
def family_of(chunk):
    low = chunk.lower()
    for fam, _tag, keys in FAMILIES:
        if any(k in low for k in keys): return fam
    return FAM_CONT
def tag_of(chunk):
    """Tag suggéré du Standard Beecom pour une section HTML."""
    low = chunk.lower()
    for _fam, tag, keys in FAMILIES:
        if any(k in low for k in keys): return tag
    return "PAGE_SIMPLE"

def retoken(chunk, old_sid, new_id):
    chunk = chunk.replace("{{B:" + old_sid + ".", "{{B:" + new_id + ".")
    # les identifiants de tracking doivent rester uniques : on les retire de la copie
    chunk = re.sub(r'\s(?:id|data-vfg-trk)="trk-[^"]*"', "", chunk)
    return chunk

def section_duplicate(rel, sid):
    bname = blocks_name_for(rel); d = load_blocks(bname)
    meta, body = read_page(rel)
    m = chunk_of(body, sid)
    if not m: raise ValueError("Cette section ne peut pas être dupliquée (contenu hors <section>).")
    nid_ = new_sid(d)
    nchunk = retoken(m.group(0), sid, nid_)
    body = body[:m.end()] + "\n\n" + nchunk + body[m.end():]
    for i, sec in enumerate(d["sections"]):
        if sec["id"] == sid:
            nsec = _copy.deepcopy(sec); nsec["id"] = nid_; nsec["label"] = (sec.get("label") or sid) + " (copie)"
            for fl in nsec.get("fields", []): fl.pop("track", None); fl.pop("tid", None)
            d["sections"].insert(i + 1, nsec); break
    write_page(rel, meta, body); save_blocks(bname, d)
    return nid_

def section_delete(rel, sid):
    bname = blocks_name_for(rel); d = load_blocks(bname)
    meta, body = read_page(rel)
    m = chunk_of(body, sid)
    if m: body = (body[:m.start()] + body[m.end():]).replace("\n\n\n", "\n\n")
    d["sections"] = [sec for sec in d["sections"] if sec["id"] != sid]
    write_page(rel, meta, body); save_blocks(bname, d)

def section_reorder(rel, order):
    """order = liste de sids (sections adossées à un <section>) dans le nouvel ordre."""
    bname = blocks_name_for(rel); d = load_blocks(bname)
    meta, body = read_page(rel)
    chunks = [(s, m) for s, m in sec_chunks(body) if s]
    by_sid = {s: m.group(0) for s, m in chunks}
    order = [s for s in order if s in by_sid]
    if sorted(order) != sorted(by_sid.keys()): return False
    slots = [m for s, m in chunks]
    pieces = []; last = 0
    for slot, sid in zip(slots, order):
        pieces.append(body[last:slot.start()]); pieces.append(by_sid[sid]); last = slot.end()
    pieces.append(body[last:])
    body = "".join(pieces)
    # réordonner le JSON : sections « chunk » suivent l'ordre demandé, les autres gardent leur position
    movable = [sec for sec in d["sections"] if sec["id"] in by_sid]
    queue = {sec["id"]: sec for sec in movable}
    it = iter(order)
    d["sections"] = [queue[next(it)] if sec["id"] in by_sid else sec for sec in d["sections"]]
    write_page(rel, meta, body); save_blocks(bname, d)
    return True


def apply_section_opts(rel, sid, opts, fields_list):
    """Applique les options d'apparence au HTML de la section (classes vfg-* + variable --vfg-bg + balise du titre)."""
    meta, body = read_page(rel)
    m = chunk_of(body, sid)
    if not m: return
    chunk = m.group(0)
    endtag = chunk.index(">")
    opening, rest = chunk[:endtag + 1], chunk[endtag + 1:]
    # nettoyer nos classes et notre variable
    def clean_attr(op):
        def cl(mm):
            classes = [c for c in mm.group(1).split() if not c.startswith("vfg-")]
            return f'class="{" ".join(classes)}"' if classes else ""
        op = re.sub(r'class="([^"]*)"', cl, op)
        op = re.sub(r'style="([^"]*)"', lambda mm: ('style="' + re.sub(r"--vfg-bg:[^;\"]*;?", "", mm.group(1)).strip().strip(";") + '"'), op)
        op = re.sub(r'\s(?:class|style)=""', "", op)
        return op
    opening = clean_attr(opening)
    classes = []
    if opts.get("bg"): classes.append("vfg-bg")
    if opts.get("flip"): classes.append("vfg-flip")
    if opts.get("rounded"): classes.append("vfg-rounded")
    if opts.get("full"): classes.append("vfg-full")
    if opts.get("pad"): classes.append("vfg-pad-" + opts["pad"])
    if classes:
        if 'class="' in opening: opening = opening.replace('class="', 'class="' + " ".join(classes) + " ", 1)
        else: opening = opening[:-1] + f' class="{" ".join(classes)}">'
    if opts.get("bg"):
        if 'style="' in opening: opening = opening.replace('style="', f'style="--vfg-bg:{opts["bg"]};', 1)
        else: opening = opening[:-1] + f' style="--vfg-bg:{opts["bg"]}">'
    chunk = opening + rest
    # balisage du titre : premier champ dont le jeton est dans une balise de titre
    tt = opts.get("titletag", "")
    for fl in fields_list:
        tok = "{{B:" + sid + "." + fl["key"] + "}}"
        mm = re.search(r"<(h[1-6]|p|span)((?:(?!>)[\s\S])*)>\s*" + re.escape(tok), chunk)
        if not mm: continue
        cur, attrs = mm.group(1), mm.group(2)
        orig = opts.get("_title_orig") or (cur if cur.startswith("h") else "h2")
        opts["_title_orig"] = orig
        target = tt or orig
        attrs2 = re.sub(r'class="([^"]*)"', lambda a: 'class="' + " ".join(c for c in a.group(1).split() if not c.startswith("vfg-hd")) + '"', attrs)
        attrs2 = re.sub(r'\sclass=""', "", attrs2)
        if target in ("p", "span"):
            lvl = orig[1] if orig.startswith("h") else "2"
            if 'class="' in attrs2: attrs2 = attrs2.replace('class="', f'class="vfg-hd vfg-hd-{lvl} ', 1)
            else: attrs2 += f' class="vfg-hd vfg-hd-{lvl}"'
        pat = re.compile(r"<" + cur + re.escape(attrs) + r">(\s*" + re.escape(tok) + r"[\s\S]*?)</" + cur + r">")
        mfull = pat.search(chunk)
        if mfull:
            chunk = chunk[:mfull.start()] + f"<{target}{attrs2}>{mfull.group(1)}</{target}>" + chunk[mfull.end():]
        break
    body = body[:m.start()] + chunk + body[m.end():]
    write_page(rel, meta, body)

def save_section_opts(rel, name, fields):
    """Lit les champs o__<sid>__* du formulaire et applique les changements."""
    d = load_blocks(name); changed = False
    for sec in d.get("sections", []):
        sid = sec["id"]; pref = f"o__{sid}__"
        if not any(k.startswith(pref) for k in fields): continue
        bg = fields.get(pref + "bg", "")
        if bg == "__free__": bg = fields.get(pref + "bgfree", "")
        o = dict(sec.get("opts") or {})
        no = {"bg": bg, "flip": (pref + "flip") in fields, "rounded": (pref + "rounded") in fields,
              "full": (pref + "full") in fields, "pad": fields.get(pref + "pad", ""), "titletag": fields.get(pref + "titletag", "")}
        if o.get("_title_orig"): no["_title_orig"] = o["_title_orig"]
        if {k: v for k, v in o.items() if k != "_title_orig"} != {k: v for k, v in no.items() if k != "_title_orig"}:
            sec["opts"] = no
            apply_section_opts(rel, sid, no, sec.get("fields", []))
            changed = True
    if changed: save_blocks(name, d)
    return changed

# ---------- Bibliothèque de modèles ----------
MODELS_PATH = os.path.join(BLOCKS, "_modeles.json")
def load_models():
    try: return json.load(open(MODELS_PATH, encoding="utf-8"))
    except Exception: return {"models": []}
def save_models(d): json.dump(d, open(MODELS_PATH, "w", encoding="utf-8"), ensure_ascii=False, indent=1)

def model_from_section(rel, sid, name, family):
    bname = blocks_name_for(rel); d = load_blocks(bname)
    meta, body = read_page(rel)
    m = chunk_of(body, sid)
    if not m: raise ValueError("Cette section ne peut pas devenir un modèle (contenu hors <section>).")
    sec = next((x for x in d["sections"] if x["id"] == sid), None)
    if not sec: raise ValueError("Section introuvable.")
    mm = load_models()
    mid = slugify(name) or f"modele-{len(mm['models']) + 1}"
    k = 2
    while any(x["id"] == mid for x in mm["models"]): mid = f"{slugify(name)}-{k}"; k += 1
    nsec = _copy.deepcopy(sec)
    for fl in nsec.get("fields", []): fl.pop("track", None); fl.pop("tid", None)
    mm["models"].append({"id": mid, "name": name, "family": std_family(family) if family else family_of(m.group(0)),
                         "html": retoken(m.group(0), sid, "M"), "fields": nsec.get("fields", []),
                         "source": f"{rel} · {sec.get('label', sid)}", "created": datetime.date.today().isoformat()})
    save_models(mm)
    return mid

def section_add_from_model(rel, model_id, after_sid=""):
    mm = load_models()
    mod = next((x for x in mm["models"] if x["id"] == model_id), None)
    if not mod: raise ValueError("Modèle introuvable.")
    bname = blocks_name_for(rel)
    try: d = load_blocks(bname)
    except Exception: d = {"page": rel, "label": rel, "auto": True, "sections": []}
    meta, body = read_page(rel)
    nid_ = new_sid(d)
    chunk = mod["html"].replace("{{B:M.", "{{B:" + nid_ + ".")
    anchor = chunk_of(body, after_sid) if after_sid else None
    if anchor: body = body[:anchor.end()] + "\n\n" + chunk + body[anchor.end():]
    else: body = body.rstrip() + "\n\n" + chunk + "\n"
    nsec = {"id": nid_, "label": mod["name"], "fields": _copy.deepcopy(mod["fields"])}
    if after_sid:
        for i, sec in enumerate(d["sections"]):
            if sec["id"] == after_sid: d["sections"].insert(i + 1, nsec); break
        else: d["sections"].append(nsec)
    else: d["sections"].append(nsec)
    write_page(rel, meta, body); save_blocks(bname, d)
    return nid_

def site_sections_catalog():
    """Toutes les sections du site (pages à blocs), regroupées par famille, dédupliquées par structure."""
    cat = {}
    seen = set()
    for pg in list_pages():
        rel = pg["file"]; bname = blocks_name_for(rel)
        if not os.path.exists(os.path.join(BLOCKS, bname + ".json")): continue
        d = load_blocks(bname)
        try: meta, body = read_page(rel)
        except Exception: continue
        for sid, m in sec_chunks(body):
            if not sid: continue
            sec = next((x for x in d.get("sections", []) if x["id"] == sid), None)
            if not sec: continue
            sig = re.sub(r"\{\{B:[\w-]+\.", "{{B:X.", re.sub(r"\s+", " ", m.group(0)))[:600]
            h = hashlib.sha1(sig.encode()).hexdigest()[:10]
            fam = family_of(m.group(0))
            entry = {"page": rel, "url": pg["url"], "sid": sid, "label": sec.get("label", sid),
                     "fields": len(sec.get("fields", [])), "dup": h in seen}
            seen.add(h)
            cat.setdefault(fam, []).append(entry)
    return cat

# ---------- Palette du site (couleurs nommées, comme sur WordPress/ACF) ----------
def site_palette():
    """[(nom, hex)] depuis Réglages (PALETTE='Nom:#hex,…') ; sinon détection dans le CSS du site."""
    raw = (B.CONFIG.get("PALETTE") or "").strip()
    if raw:
        out = []
        for part in raw.split(","):
            if ":" in part:
                n, h = part.split(":", 1); out.append((n.strip(), h.strip()))
        if out: return out
    # détection : 1) variables CSS nommées (:root { --xxx: #hex }) 2) sinon couleurs de fond fréquentes
    css_all = ""
    for dp, dn, fns in os.walk(ASSETS):
        for fn in fns:
            if fn.endswith(".css"): css_all += open(os.path.join(dp, fn), encoding="utf-8", errors="replace").read() + "\n"
    out = []
    for mm in re.finditer(r"--([a-zA-Z][\w-]*)\s*:\s*(#[0-9a-fA-F]{3,8})\b", css_all):
        n = mm.group(1).replace("-", " ").strip().capitalize()
        if (n, mm.group(2).lower()) not in [(a, b) for a, b in out]: out.append((n, mm.group(2).lower()))
        if len(out) >= 8: break
    if not out:
        from collections import Counter
        cnt = Counter()
        for mm in re.finditer(r"background(?:-color)?\s*:\s*(#[0-9a-fA-F]{3,8})", css_all): cnt[mm.group(1).lower()] += 1
        out = [(f"Fond {i+1}", h) for i, (h, _) in enumerate(cnt.most_common(5))]
    if not any(h in ("#fff", "#ffffff") for _, h in out): out.insert(0, ("Blanc", "#ffffff"))
    return out or [("Blanc", "#ffffff")]


def page_library(msg=""):
    mm = load_models()["models"]
    fams = {}
    for x in mm: fams.setdefault(std_family(x.get("family")), []).append(x)
    cards = ""
    for fam in fam_sort(fams):
        xs = fams[fam]
        rows = "".join(f'<tr><td><b>{esc(x["name"])}</b><br><span class="help">{esc(x.get("source",""))}</span></td><td>{len(x.get("fields",[]))} champs</td><td>{esc(x.get("created",""))}</td><td><a class="btn sm danger" href="/model-del?id={esc(x["id"])}" onclick="return confirm(\'Supprimer ce modèle ? (les sections déjà posées sur les pages ne bougent pas)\')">Supprimer</a></td></tr>' for x in xs)
        cards += f'<div class="card"><h2 style="margin-top:0;font-size:1rem">{esc(fam)} ({len(xs)})</h2><table>{rows}</table></div>'
    if not mm: cards = '<div class="card"><p class="help" style="margin:0">Aucun modèle pour l\'instant. Ci-dessous, chaque section du site peut être enregistrée comme modèle réutilisable (bouton « En faire un modèle »).</p></div>'
    cat = site_sections_catalog()
    catrows = ""
    for fam in fam_sort(cat):
        xs = cat[fam]
        uniq = [x for x in xs if not x["dup"]]
        lis = "".join(f'<tr><td>{esc(x["label"])[:60]}</td><td><code style="font-size:.72rem">{esc(x["url"])}</code></td><td>{x["fields"]} champs</td><td><a class="btn sm sec" href="/model-new?f={quote(x["page"])}&sec={x["sid"]}">En faire un modèle</a></td></tr>' for x in uniq)
        catrows += f'<details style="margin-bottom:.6rem"><summary style="cursor:pointer;font-weight:600">{esc(fam)} — {len(uniq)} structure(s) unique(s) <span class="help">({len(xs)} au total sur le site)</span></summary><table style="margin-top:.5rem">{lis}</table></details>'
    tags = "".join(f'<details style="margin-bottom:.4rem"><summary style="cursor:pointer;font-weight:600">{esc(fam)}</summary><p style="margin:.4rem 0 0">' + " ".join(f'<code style="font-size:.78rem">{t}</code>' for t in STD_TAGS[fam]) + "</p></details>" for fam in FAMILY_ORDER)
    body = f"""{msg}<h1>Bibliothèque de sections</h1>
<p class="help">Le principe (comme ACF sur WordPress) : vous constituez une bibliothèque de <b>modèles</b> — une vingtaine suffit — à partir des sections existantes du site. Ensuite, sur n'importe quelle page : « ＋ Ajouter une section », choix du modèle, puis personnalisation des textes, images et de l'apparence (couleurs, disposition, balisage) dans la section posée.</p>
<h2 style="font-size:1.05rem">Mes modèles</h2>{cards}
<h2 style="font-size:1.05rem">Nomenclature Beecom — Standard des blocs v3.0</h2>
<div class="card"><p class="help" style="margin-top:0">Les mêmes familles et tags que sur nos sites WordPress full ACF : nommez chaque nouveau modèle avec le tag du standard quand il correspond (détail et correspondances : <code>NOMENCLATURE-BEECOM.md</code> à la racine du site). Un bloc sans équivalent : nom en français snake_case, tag en MAJUSCULES, à remonter comme proposition d'évolution du standard (projet 01).</p>{tags}</div>
<h2 style="font-size:1.05rem">Toutes les sections du site, par famille</h2>
<div class="card">{catrows or "<p class=help>Aucune page à blocs.</p>"}</div>"""
    return layout("Bibliothèque", body, "/library")

def page_model_new(f, sec, msg=""):
    d = load_blocks(blocks_name_for(f)); s_ = next((x for x in d.get("sections", []) if x["id"] == sec), None)
    label = s_.get("label", sec) if s_ else sec
    try:
        meta_, body_ = read_page(f); mch = chunk_of(body_, sec)
        guess = family_of(mch.group(0)) if mch else FAM_CONT
        tguess = tag_of(mch.group(0)) if mch else "PAGE_SIMPLE"
    except Exception: guess, tguess = FAM_CONT, "PAGE_SIMPLE"
    fsel = "".join(f'<option {"selected" if x == guess else ""}>{esc(x)}</option>' for x in FAMILY_ORDER)
    dl = '<datalist id="stdtags">' + "".join(f'<option value="{t}">{esc(fam)}</option>' for fam in FAMILY_ORDER for t in STD_TAGS[fam]) + "".join(f'<option value="{t}">proposition (hors standard v3.0)</option>' for t in STD_PROPOSALS) + "</datalist>"
    body = f"""{msg}<h1>Enregistrer comme modèle</h1>
<div class="card"><form method="post" action="/model-save"><input type="hidden" name="f" value="{esc(f)}"><input type="hidden" name="sec" value="{esc(sec)}">
<p class="help">La section « <b>{esc(label)}</b> » de <code>{esc(B.url_from_path(f))}</code> sera ajoutée à la bibliothèque, réutilisable sur toutes les pages (les textes actuels servent de contenu d'exemple).</p>
<div class="row"><div><label>Nom du modèle — nomenclature Beecom : tag du standard si équivalent (suggestion : <code>{tguess}</code>)</label><input type="text" name="name" value="{esc(label)}" list="stdtags" required>{dl}
<span class="help">Vous pouvez préciser une variante après le tag, ex. « COLONNES_5050 — image droite ». Sans équivalent dans le standard : français snake_case, tag en MAJUSCULES (proposition d'évolution à remonter au projet 01).</span></div>
<div><label>Famille (standard Beecom)</label><select name="family">{fsel}</select></div></div>
<div class="actions" style="margin-top:1rem"><button class="btn">Enregistrer le modèle</button><a class="btn sec" href="/edit?f={quote(f)}">Annuler</a></div></form></div>"""
    return layout("Nouveau modèle", body, "/library")

SITE_BLOCKS = {"_menu": ("Menu & pied de page", "/menu", "Modifiez ici les entrées du menu (ordre, libellés, liens, sous-menus), le bouton d'action, et le pied de page (colonnes de liens, textes, réseaux). Enregistrez puis « Régénérer ». Pour une version dans une autre langue : dupliquez blocks/_menu.json en blocks/_menu.en.json."),
               "_popup": ("Pop-up", "/popup", "Une fenêtre qui apparaît par-dessus la page (fond flouté), avec photo, titre, sous-titre, paragraphe et bouton — tous facultatifs. Croix de fermeture avec « fermer » dessous. Déclenchement : à l'arrivée sur une section (par défaut la 3ᵉ partie de la page d'accueil), après un délai, ou immédiatement.")}

def page_site_blocks(name, msg=""):
    title, path, help_ = SITE_BLOCKS[name]
    d = load_blocks(name); secs, toc = blocks_form_parts(d, open_first=True)
    body = f"""{msg}<h1>{esc(title)}</h1><p class="help">{help_}</p>{toc}
<form method="post" action="/blocks-save"><input type="hidden" name="name" value="{esc(name)}"><input type="hidden" name="back" value="{path}">
{secs}
<div class="sticky-actions actions"><button class="btn">Enregistrer</button><button class="btn blue" name="then" value="build">Enregistrer + régénérer</button><a class="btn sec" href="{PREVIEW_BASE}/" target="_blank">Aperçu ↗</a></div></form>
{BLOCKS_JS}"""
    return layout(title, body, path)

def sync_blocks(f):
    """(Re)construit les blocs d'une page depuis son HTML : les valeurs actuelles sont réinjectées, puis tout est ré-extrait."""
    import blocks_tools
    meta, body = read_page(f); bname = blocks_name_for(f)
    if "{{B:" in body: body = B.apply_blocks(body, f)      # HTML complet avec les valeurs actuelles
    tok, secs = blocks_tools.extract(body)
    label = re.sub(r"\s*\|.*$", "", meta.get("title", f))
    save_blocks(bname, {"page": f, "label": label, "auto": True, "sections": secs})
    write_page(f, meta, tok)
    return sum(len(s["fields"]) for s in secs), len(secs)

def save_blocks_form(fields):
    name = fields["name"]; d = load_blocks(name)
    for sec in d.get("sections", []):
        for f in sec.get("fields", []):
            if f.get("type") == "repeat":
                pref = f"r__{sec['id']}__{f['key']}__"; idxs = sorted({int(k[len(pref):].split("__")[0]) for k in fields if k.startswith(pref)})
                items = []
                for i in idxs:
                    row = {}
                    for sub in f.get("fields", []):
                        k = f"{pref}{i}__{sub['key']}"
                        row[sub["key"]] = ("true" if k in fields else "") if sub.get("type") == "bool" else fields.get(k, "").replace("\r\n", "\n").strip()
                    items.append(row)
                f["items"] = items
            else:
                k = f"f__{sec['id']}__{f['key']}"
                if f.get("type") == "bool": f["value"] = "true" if k in fields else ""
                elif k in fields: f["value"] = fields[k].replace("\r\n", "\n").strip()
                if f.get("type") == "url" and k in fields:
                    want = (k + "__track") in fields
                    if want != bool(f.get("track")):
                        f["track"] = want
                        if want and not f.get("tid"):
                            f["tid"] = "trk-" + slugify(name.replace("__", "-") + "-" + sec["id"] + "-" + f["key"])
                        apply_tracking(d.get("page"), sec["id"], f["key"], f.get("tid"), want)
    save_blocks(name, d); return d

def apply_tracking(page_rel, sec_id, key, tid, enable):
    """Ajoute/retire id + data-vfg-trk sur la balise <a> dont le href est le jeton {{B:sec.key}}."""
    if not page_rel or not tid: return
    try: meta, body = read_page(page_rel)
    except Exception: return
    token = "{{B:" + sec_id + "." + key + "}}"
    pat = re.compile(r"<a\b[^>]*href=\"" + re.escape(token) + r"\"[^>]*>")
    def rep(m):
        tag = m.group(0)
        tag = re.sub(r'\s(?:id|data-vfg-trk)="[^"]*"', "", tag)
        if enable: tag = tag[:-1] + f' id="{tid}" data-vfg-trk="{tid}">'
        return tag
    nb = pat.sub(rep, body)
    if nb != body: write_page(page_rel, meta, nb)

def page_new_article(msg=""):
    themes = "".join(f'<option value="{s}">{esc(t)}</option>' for s, t in B.GUIDE_THEMES)
    today = datetime.date.today(); mois = ["janvier","février","mars","avril","mai","juin","juillet","août","septembre","octobre","novembre","décembre"]
    body = f"""{msg}<h1>Nouvel article du guide</h1>
<form method="post" action="/create-article" enctype="multipart/form-data">
<div class="card"><div class="row"><div>
<label>Catégorie</label><select name="theme">{themes}</select><p class="help">Les catégories se gèrent dans l’onglet Articles (ajout en un champ).</p>
<label>Titre de l'article</label><input type="text" name="title" required oninput="document.getElementById('slug').value=mkSlug(this.value)">
<label>Sous-titre (accroche sous le H1)</label><input type="text" name="subtitle">
<label>Adresse (slug)</label><input type="text" name="slug" id="slug" required><p class="help">L'URL sera /{esc(B.BLOG_PREFIX)}&lt;catégorie&gt;/&lt;slug&gt;/</p>
</div><div>
<label>Titre SEO (balise title, ≤ 60 car. — sinon = titre)</label><input type="text" name="seo_title">
<label>Meta description (140-160 caractères)</label><textarea name="description" style="min-height:80px" required></textarea>
<label>Extrait pour les cartes (sinon = meta description)</label><input type="text" name="excerpt">
<div class="row"><div><label>Date</label><input type="text" name="date" value="{today.isoformat()}"></div><div><label>Date affichée</label><input type="text" name="date_fr" value="{today.day} {mois[today.month-1]} {today.year}"></div></div>
<label>Image de couverture — téléverser</label><input type="file" name="image" accept="image/*"><label>…ou choisir</label><select name="image_existing">{image_options()}</select><p class="help">Format conseillé 1200×675. Sans image : visuel par défaut.</p>
</div></div></div>
<div class="card"><label>Contenu <span style="font-weight:400">(Markdown simple ou HTML)</span></label>
<p class="help">## Titre de section · ### Sous-titre · **gras** · *italique* · [lien](/offre/) · - puce · 1. numérotée · &gt; encadré « Bon à savoir ». Le sommaire est généré automatiquement à partir des ## titres. Un bloc « L'essentiel à retenir » est ajouté si vous remplissez le champ ci-dessous.</p>
<label>L'essentiel à retenir (une puce par ligne, optionnel)</label><textarea name="essential" style="min-height:90px"></textarea>
<label>Texte de l'article</label><textarea class="code" name="body" style="min-height:420px" required></textarea>
<label>FAQ (optionnel) — une question par ligne au format <code>Question ? | Réponse.</code></label><textarea name="faq" style="min-height:90px"></textarea>
<label>Sources (optionnel, une par ligne)</label><textarea name="sources" style="min-height:70px"></textarea>
<div class="actions" style="margin-top:1rem"><button class="btn">Créer l'article</button><label style="margin:0;font-weight:400"><input type="checkbox" name="draft" value="true"> Enregistrer comme brouillon</label></div></div></form>
<script>function mkSlug(s){{return s.normalize('NFD').replace(/[\\u0300-\\u036f]/g,'').toLowerCase().replace(/[^a-z0-9]+/g,'-').replace(/^-+|-+$/g,'');}}</script>"""
    return layout("Nouvel article", body, "/new-article")

def page_new_page(msg=""):
    body = f"""{msg}<h1>Nouvelle page libre</h1><p class="help">Pour une page simple (événement, offre spéciale, page locale…). Pour une page métier complète, dupliquez plutôt une page métier existante depuis « Pages » (copier son contenu dans une nouvelle page).</p>
<form method="post" action="/create-page"><div class="card">
<div class="row"><div><label>Titre (H1)</label><input type="text" name="title" required oninput="document.getElementById('slug').value=mkSlug(this.value)"><label>Adresse (slug)</label><input type="text" name="slug" id="slug" required><p class="help">URL : /&lt;slug&gt;/ — ou un chemin comme <code>metiers/immobilier</code></p></div>
<div><label>Sous-titre</label><input type="text" name="subtitle"><label>Meta description</label><textarea name="description" style="min-height:80px" required></textarea>
<label>Type de page</label><select name="mode" onchange="document.getElementById('freezone').style.display=this.value=='code'?'':'none';document.getElementById('copyzone').style.display=this.value=='copy'?'':'none'">
<option value="builder">Construite par sections — recommandé (page vide, vous empilez ensuite les sections de la bibliothèque)</option>
<option value="copy">Copie d'une page existante</option>
<option value="code">Contenu libre (Markdown ou HTML)</option></select>
<div id="copyzone" style="display:none"><label>Partir d'une copie de la page…</label><select name="copy_of"><option value="">— page vierge (contenu ci-dessous) —</option>{"".join(f'<option value="{esc(pg["file"])}">{esc(pg["url"])}</option>' for pg in list_pages() if pg["type"] != "article")}</select><p class="help">Pratique pour un nouveau métier ou une traduction : la page est dupliquée avec ses blocs, vous n'avez plus qu'à modifier les textes.</p></div>
<label>Langue de la page (vide = par défaut)</label><input type="text" name="lang" placeholder="en"></div></div>
<div id="freezone" style="display:none"><label>Contenu (Markdown simple ou HTML)</label><textarea class="code" name="body" style="min-height:360px"></textarea></div>
<div class="actions" style="margin-top:1rem"><button class="btn">Créer la page</button></div></div></form>
<script>function mkSlug(s){{return s.normalize('NFD').replace(/[\\u0300-\\u036f]/g,'').toLowerCase().replace(/[^a-z0-9\\/]+/g,'-').replace(/^-+|-+$/g,'');}}</script>"""
    return layout("Nouvelle page", body, "/new-page")

# ---------- ALT d'images par IA (vision) ----------
def collect_missing_alts():
    """Champs « texte alternatif » vides, appariés à leur image : [{bname, page, url, sec, path, img}].
    path = ('f', index_champ) ou ('r', index_champ, index_ligne, sous-clef)."""
    out = []
    for pg in list_pages():
        rel = pg["file"]; bname = blocks_name_for(rel)
        if not os.path.exists(os.path.join(BLOCKS, bname + ".json")): continue
        d = load_blocks(bname)
        for sec in d.get("sections", []):
            flds = sec.get("fields", [])
            for i, f in enumerate(flds):
                if f.get("type") == "image" and f.get("value"):
                    nxt = flds[i + 1] if i + 1 < len(flds) else None
                    if nxt and nxt.get("type") == "text" and "texte alternatif" in (nxt.get("label") or "") and not (nxt.get("value") or "").strip():
                        out.append({"bname": bname, "page": rel, "url": pg["url"], "sec": sec["id"], "img": f["value"], "path": ("f", i + 1)})
                elif f.get("type") == "repeat":
                    subs = f.get("fields", [])
                    for si, sub in enumerate(subs):
                        if sub.get("type") != "image": continue
                        alt_sub = subs[si + 1] if si + 1 < len(subs) else None
                        if not (alt_sub and alt_sub.get("type") == "text" and "texte alternatif" in (alt_sub.get("label") or "")): continue
                        for ri, row in enumerate(f.get("items", [])):
                            img = row.get(sub["key"], "")
                            if img and not (row.get(alt_sub["key"]) or "").strip():
                                out.append({"bname": bname, "page": rel, "url": pg["url"], "sec": sec["id"], "img": img, "path": ("r", flds.index(f), ri, alt_sub["key"])})
    return out

def claude_alt(img_path, context):
    """Décrit une image locale via l'API Claude (vision) → texte d'alt en français."""
    key = (B.CONFIG.get("ANTHROPIC_KEY") or "").strip()
    if not key: raise ValueError("Clé API Anthropic manquante (Réglages › Langues & traduction).")
    fp = safe_join(ROOT, *[x for x in img_path.split("/") if x and x != ".."])
    ext = os.path.splitext(fp)[1].lower()
    media = {".jpg": "image/jpeg", ".jpeg": "image/jpeg", ".png": "image/png", ".webp": "image/webp", ".gif": "image/gif"}.get(ext)
    if not media or not os.path.isfile(fp): return None
    import base64, urllib.request
    data = base64.b64encode(open(fp, "rb").read()).decode()
    payload = {"model": (B.CONFIG.get("TRANSLATE_MODEL") or "claude-haiku-4-5").strip(), "max_tokens": 200,
               "system": "Tu écris des attributs alt en français pour un site vitrine de PME. Réponds UNIQUEMENT avec le texte de l'alt : factuel et descriptif, 120 caractères maximum, sans guillemets, sans point final, sans commencer par « Image » ou « Photo ».",
               "messages": [{"role": "user", "content": [
                   {"type": "image", "source": {"type": "base64", "media_type": media, "data": data}},
                   {"type": "text", "text": f"Contexte : {context}. Écris l'alt de cette image."}]}]}
    req = urllib.request.Request("https://api.anthropic.com/v1/messages", data=json.dumps(payload).encode("utf-8"),
                                 headers={"content-type": "application/json", "x-api-key": key, "anthropic-version": "2023-06-01"})
    with urllib.request.urlopen(req, timeout=90) as r: j = json.load(r)
    txt = "".join(b.get("text", "") for b in j.get("content", [])).strip().strip('"').strip()
    return txt[:160] or None

def generate_missing_alts(limit=25):
    """Remplit jusqu'à `limit` champs alt vides via l'IA. Retourne (nb_faits, nb_restants, détails)."""
    items = collect_missing_alts()
    done = 0; details = []
    for it in items[:limit]:
        try:
            alt = claude_alt(it["img"], f"page « {it['url']} » du site {B.SITE_NAME}")
        except ValueError: raise
        except Exception as e:
            details.append((it["img"], f"erreur : {e}")); continue
        if not alt: continue
        d = load_blocks(it["bname"])
        sec = next((s for s in d.get("sections", []) if s["id"] == it["sec"]), None)
        if not sec: continue
        if it["path"][0] == "f":
            sec["fields"][it["path"][1]]["value"] = alt
        else:
            _t, fi, ri, sk = it["path"]
            sec["fields"][fi]["items"][ri][sk] = alt
        save_blocks(it["bname"], d)
        details.append((it["img"], alt)); done += 1
    for img, alt in details: log(f"🖼 ALT généré — {img} → {alt}")
    return done, max(0, len(items) - limit), details


def page_images(msg="", opt_result=""):
    OPT_RESULT = opt_result
    items = ""
    for dp, dn, fns in os.walk(IMG):
        dn[:] = [d for d in dn if d != "_v"]   # variantes auto (perf) : internes
        for fn in sorted(fns):
            if fn.lower().endswith((".webp", ".jpg", ".jpeg", ".png", ".svg")):
                p = "/assets/" + os.path.relpath(os.path.join(dp, fn), ASSETS).replace(os.sep, "/")
                items += f'<div><img src="{esc(p)}" loading="lazy" alt=""><div>{esc(p)}</div><button class="btn sm sec" style="margin-top:.3rem" onclick="navigator.clipboard.writeText({json.dumps(p)});this.textContent=\'Copié ✔\'">Copier le chemin</button></div>'
    try: n_missing = len(collect_missing_alts())
    except Exception: n_missing = 0
    alt_card = f"""<div class="card"><h2 style="margin-top:0;font-size:1rem">🖼 Textes alternatifs (ALT) des images</h2>
<p class="help" style="margin-top:0">{"<b>" + str(n_missing) + "</b> image(s) de blocs sans texte alternatif." if n_missing else "Toutes les images des blocs ont un texte alternatif ✔"} En attendant, aucune image ne part jamais sans alt : à la génération, un alt de secours (dérivé du nom de fichier) est posé automatiquement. Le bouton ci-dessous écrit de <b>vraies descriptions</b> (IA vision, clé Anthropic des Réglages) directement dans les champs « texte alternatif » — relisibles dans chaque page, puis traduites comme le reste.</p>
{'<form method="post" action="/alt-ia" class="actions" onsubmit="this.querySelector(&quot;button&quot;).textContent=&quot;Description des images en cours…&quot;"><button class="btn">Générer les ALT manquants (IA) — ' + str(min(n_missing, 25)) + ' image(s)</button><span class="help">~1 centime/image · 25 max par clic · détail dans le journal du tableau de bord</span></form>' if n_missing else ''}</div>"""
    body = f"""{msg}<h1>Images</h1>{alt_card}
<div class="card"><form method="post" action="/upload" enctype="multipart/form-data"><label>Téléverser une image (jpg, png, webp) — redimensionnée à 1600 px max et convertie en WebP</label><input type="file" name="image" accept="image/*" required multiple>
<label>Nom (optionnel, sinon nom du fichier)</label><input type="text" name="name" placeholder="ex. plaque-qr-code-restaurant"><div class="actions" style="margin-top:1rem"><button class="btn">Téléverser</button></div></form>
<p class="help">Les images arrivent dans <code>/assets/img/uploads/</code>. Copiez le chemin puis collez-le dans une balise image (bouton « Image » de l'éditeur) ou choisissez-la dans un champ image des « Blocs de page ». Aperçu visible après « Régénérer ».</p></div>
<div class="card"><h2 style="margin-top:0;font-size:1rem">🗜️ Réduire le poids des images</h2>
<form method="post" action="/optimize" class="actions" onsubmit="this.querySelector('button').textContent='Optimisation en cours…'"><label style="margin:0">Seuil : images de plus de</label><input type="number" name="min_kb" value="150" style="width:90px"> Ko
<label style="margin:0">· qualité</label><input type="number" name="quality" value="80" min="50" max="95" style="width:80px"> %
<label style="margin:0">· largeur max</label><input type="number" name="max_w" value="1600" style="width:90px"> px
<button class="btn">Optimiser toutes les images</button></form>
<p class="help">Recompresse sur place (même nom, même chemin) les JPG/WebP/PNG plus lourds que le seuil : rien à changer dans les pages. Une sauvegarde de l'image d'origine n'est pas conservée : gardez vos originaux. Les images téléversées ici sont déjà converties en WebP ≤ 1600 px. Alternative en ligne : <a href="https://www.iloveimg.com/fr/compresser-image" target="_blank">iloveimg.com</a> ou <a href="https://squoosh.app" target="_blank">squoosh.app</a>.</p>{OPT_RESULT}</div>
<div class="card"><h2 style="margin-top:0;font-size:1rem">📐 Tailles recommandées</h2><table class="sizes">
<tr><th>Emplacement</th><th>Taille</th><th>Format / poids</th></tr>
<tr><td>Visuel du hero (accueil, offre)</td><td>1200 × 1200 px (carré)</td><td>WebP ou PNG fond transparent · < 300 Ko</td></tr>
<tr><td>Visuel métier (hero des pages métiers)</td><td>1200 × 900 px (4:3)</td><td>WebP fond transparent · généré via tools/render_mocks.py à partir d'une photo du gérant</td></tr>
<tr><td>Photo « gérant » (source des visuels métiers)</td><td>≥ 1600 × 1200 px, paysage</td><td>JPG · personne cadrée large, environnement visible</td></tr>
<tr><td>Couverture d'article du guide (cartes + haut d'article)</td><td>1200 × 750 px (16:10)</td><td>WebP · < 200 Ko</td></tr>
<tr><td>Image « preuve / résultats » (16:9)</td><td>1200 × 675 px</td><td>WebP · < 250 Ko</td></tr>
<tr><td>Image équipe (colonne portrait)</td><td>≈ 720 × 1500 px</td><td>PNG/WebP fond transparent · < 400 Ko</td></tr>
<tr><td>Image de partage réseaux (og:image)</td><td>1200 × 630 px</td><td>JPG · < 300 Ko</td></tr>
<tr><td>Photos dans un article</td><td>1200 px de large max</td><td>WebP · < 200 Ko (redimensionnées automatiquement au téléversement)</td></tr>
<tr><td>Logos partenaires / clients</td><td>hauteur 80 px (largeur libre)</td><td>PNG ou SVG fond transparent</td></tr>
</table></div>
<div class="imgs">{items}</div>"""
    return layout("Images", body, "/images")

def load_redirects():
    try: return json.load(open(B.REDIRECTS_PATH, encoding="utf-8"))
    except Exception: return []
REDIR_CODES = [("301", "301 — Permanente (SEO : transfère le référencement) — défaut"),
               ("302", "302 — Temporaire (l'ancienne URL reste la référence)"),
               ("303", "303 — Voir autre (après un formulaire)"),
               ("307", "307 — Temporaire stricte (conserve la méthode)"),
               ("308", "308 — Permanente stricte (conserve la méthode)"),
               ("410", "410 — Supprimée définitivement (pas de destination : dit à Google d'oublier la page)")]
def page_redirects(msg=""):
    rows = ""
    for i, r in enumerate(load_redirects()):
        code = str(r.get("code", "301"))
        sel = "".join(f'<option value="{c}" {"selected" if c == code else ""}>{c}</option>' for c, _ in REDIR_CODES)
        rows += (f'<tr><td><code>{esc(r["from"])}</code></td><td>{"→ <code>" + esc(r["to"]) + "</code>" if code != "410" else "<span class=tag d>supprimée</span>"}</td>'
                 f'<td><form method="post" action="/redirect-code" style="margin:0;display:flex;gap:.3rem"><input type="hidden" name="i" value="{i}"><select name="code" style="width:auto;padding:.25rem .4rem;font-size:.8rem">{sel}</select><button class="btn sm sec">✓</button></form></td>'
                 f'<td><a class="btn sm danger" href="/redirect-del?i={i}">Supprimer</a></td></tr>')
    codesel = "".join(f'<option value="{c}" {"selected" if c == "301" else ""}>{lab}</option>' for c, lab in REDIR_CODES)
    body = f"""{msg}<h1>Redirections <a class="btn sm sec" href="/redirect-export" style="margin-left:1rem">⬇ Exporter le plan (CSV)</a></h1><p class="help">Quand vous renommez ou supprimez une page, ajoutez une redirection : Google conserve le référencement et les visiteurs ne tombent pas sur une erreur. <b>301 par défaut</b> (le bon choix SEO dans 95 % des cas) ; le type se change au cas par cas. Écrit dans <code>.htaccess</code> (o2switch, OVH…) et <code>_redirects</code> (Netlify) à la génération.</p>
<div class="card"><form method="post" action="/redirect-add"><div class="row"><div><label>Ancienne adresse</label><input type="text" name="from" placeholder="/ancienne-page/" required></div><div><label>Nouvelle adresse (vide si type 410)</label><input type="text" name="to" placeholder="/nouvelle-page/ ou https://…"></div></div>
<label>Type de redirection</label><select name="code">{codesel}</select>
<div class="actions" style="margin-top:1rem"><button class="btn">Ajouter</button></div></form></div>
<div class="card sec-card closed"><h2 onclick="this.parentElement.classList.toggle('closed')" style="font-size:1rem">📥 Import en masse (CSV)<span class="chev">▼</span></h2><div class="sec-body">
<form method="post" action="/redirect-import"><label>Une redirection par ligne : <code>ancienne;nouvelle;type</code> (type optionnel : 301, 302 ou 410 — séparateur ; , ou tabulation)</label>
<textarea name="csv" rows="6" style="min-height:0;font-family:ui-monospace,monospace;font-size:.82rem" placeholder="/ancienne-page/;/nouvelle-page/;301&#10;/page-supprimee/;;410"></textarea>
<p class="help">Les doublons, boucles et lignes invalides sont ignorés (compte rendu après import).</p>
<div class="actions"><button class="btn">Importer</button></div></form></div></div>
<div class="card"><table><tr><th>De</th><th>Vers</th><th>Type</th><th></th></tr>{rows or '<tr><td colspan=4>Aucune redirection.</td></tr>'}</table></div>"""
    return layout("Redirections", body, "/redirects")

def page_settings(msg=""):
    c = B.CONFIG
    def f(k, label, help_="", typ="text", rows=3):
        v = c.get(k, "")
        if typ == "textarea": inp = f'<textarea name="{k}" rows="{rows}" style="min-height:0;font-size:.85rem">{esc(v)}</textarea>'
        elif typ == "select_form":
            o1 = "selected" if v == "php" else ""; o2 = "selected" if v == "web3forms" else ""
            inp = f'<select name="{k}"><option value="php" {o1}>Script PHP sur l’hébergement (recommandé : o2switch, OVH… — gratuit, accusé de réception au client)</option><option value="web3forms" {o2}>Web3Forms (service tiers, clé requise — pour un hébergement sans PHP type Netlify)</option></select>'
        else: inp = f'<input type="{typ}" name="{k}" value="{esc(v)}">'
        return f'<label>{esc(label)}</label>{inp}' + (f'<p class="help">{help_}</p>' if help_ else "")
    def card(title, inner, cid): return f'<div class="card sec-card closed" id="set-{cid}"><h2 onclick="this.parentElement.classList.toggle(&quot;closed&quot;)">{title}<span class="chev">▼</span></h2><div class="sec-body">{inner}</div></div>'
    h3 = lambda t: f'<h3 style="margin:1.2rem 0 .3rem;font-size:.95rem">{t}</h3>'
    c1 = card("Coordonnées & liens", f("TEL","Téléphone affiché")+f("TEL_HREF","Téléphone (format lien, ex. +33559033562)")+f("EMAIL","E-mail de contact affiché sur le site")+f("CALENDLY_URL","Lien Calendly")+f("ADDRESS","Adresse courte (pied de page)")+f("AGENCY_URL","Site de l’agence")+f("TAGLINE","Baseline")+f("PALETTE","Palette de couleurs du site (panneau « Apparence » des sections)","Couleurs nommées proposées en boutons, ex. <code>Base:#f7f8fa,Blanc:#ffffff,Navy:#000b22,Bleu clair:#e8f0fe</code>. Vide = détection automatique depuis le CSS du site.")
        +f("FAVICON","Favicon (chemin /assets/img/…)","Téléversez d’abord le fichier dans « Médias » (formats .svg, .ico ou .png), puis collez son chemin ici. Vide = favicon d’origine du site. Appliqué à toutes les pages à la régénération."), "coord")
    c2 = card("Formulaires & e-mails", f("FORM_MODE","Mode d’envoi","","select_form")
        +f("FORM_TO","Adresse(s) qui reçoivent les demandes","Plusieurs adresses possibles, séparées par des virgules. C’est ici que vous choisissez où arrivent les formulaires.")
        +f("FORM_FROM","Adresse d’expédition technique","Une adresse du domaine hébergé (ex. noreply@votre-fiche-google.fr) : créez-la dans cPanel › Comptes de messagerie pour une bonne délivrabilité. Les réponses des clients arrivent quand même sur l’adresse ci-dessus.")
        +f("FORM_FROM_NAME","Nom d’expéditeur affiché")
        +h3("Envoi SMTP authentifié (mode PHP — recommandé pour la délivrabilité)")
        +'<p class="help" style="margin:2px 0 8px">Créez la boîte e-mail d’expédition dans cPanel › Comptes de messagerie, puis renseignez ses accès ici : les e-mails partent en SMTP authentifié (moins de spam). Vide = envoi via la fonction mail() de PHP.</p>'
        +f("SMTP_HOST","Serveur SMTP","chez o2switch : mail.votre-domaine.fr")+f("SMTP_PORT","Port SMTP","465 (SSL) — valeur par défaut")+f("SMTP_USER","Identifiant SMTP","l’adresse e-mail complète, ex. contact@votre-domaine.fr")+f("SMTP_PASS","Mot de passe SMTP","Celui de la boîte e-mail (stocké dans config.json sur le serveur).","password")
        +h3("E-mail reçu par vous (notification)")+f("FORM_SUBJECT_ADMIN","Objet","Variables : {nom} {email} {sujet} {page} {date} {fiche} {telephone}")+f("FORM_ADMIN_MESSAGE","Message","{recap} = récapitulatif de tous les champs du formulaire","textarea",4)
        +h3("E-mail envoyé au client (accusé de réception)")+f("FORM_SUBJECT_CLIENT","Objet","Laissez vide pour ne pas envoyer d’accusé de réception.")+f("FORM_CLIENT_MESSAGE","Message","Texte brut ; {nom} {sujet} {recap} {fiche} {message} disponibles.","textarea",7)
        +f("WEB3FORMS_KEY","Clé Web3Forms (seulement en mode Web3Forms)","Créez un compte gratuit sur <a href=https://web3forms.com target=_blank>web3forms.com</a> : la clé arrive par mail."), "forms")
    c3 = card("Réseaux sociaux & Instagram", f("SOCIAL_FACEBOOK","Facebook (URL de la page)")+f("SOCIAL_INSTAGRAM","Instagram")+f("SOCIAL_LINKEDIN","LinkedIn")+f("SOCIAL_YOUTUBE","YouTube")+f("SOCIAL_TIKTOK","TikTok")+f("SOCIAL_X","X / Twitter")
        +'<p class="help">Les pictos s’affichent dans le pied de page dès qu’un lien est renseigné (désactivable dans Menu & pied de page). Le jeton <code>{{SOCIAL}}</code> les affiche aussi dans une page (ex. Contact, À propos).</p>'
        +f("INSTA_WIDGET","Feed Instagram — code d’intégration du widget","Instagram n’offre plus de flux public gratuit : utilisez un widget (Elfsight, LightWidget, SnapWidget, Behold…) et collez son code ici. Il s’affiche là où vous placez le jeton <code>{{INSTA_FEED}}</code> dans une page (bloc HTML).","textarea",4), "social")
    c4 = card("Cookies & consentement (Sirdata CMP)", f("CMP_SCRIPT","Code Sirdata CMP","Dans votre console Sirdata (choices.consentframework.com), copiez le code d’installation (balise &lt;script&gt;) et collez-le ici : il est injecté en tout premier dans le &lt;head&gt; de chaque page. Matomo est configuré sans cookies ; si vous ajoutez GA4 ou d’autres tags, déclarez-les dans Sirdata.","textarea",5)
        +f("HEAD_CODE","Autre code dans le &lt;head&gt;","Balise de vérification Search Console, Google Tag Manager, etc.","textarea",3), "cmp")
    c5 = card("Statistiques", f("MATOMO_URL","Matomo — URL de l’instance","ex. https://stats.agence-beecom.fr/ (laisser vide si pas encore installé)")+f("MATOMO_SITE_ID","Matomo — ID du site")
        +f("MATOMO_TOKEN","Matomo — jeton API (pour les statistiques du tableau de bord)","Matomo › Administration › Personnel › Sécurité › Jetons d’authentification : créez un jeton « lecture seule » et collez-le ici. Le tableau de bord affichera visites, pages vues et pages les plus consultées (période au choix).","password")
        +f("GA_ID","Google Analytics 4 (optionnel)"), "stats")
    provsel = f'<label>Fournisseur de traduction</label><select name="TRANSLATE_PROVIDER"><option value="deepl" {"selected" if c.get("TRANSLATE_PROVIDER","deepl")=="deepl" else ""}>DeepL en priorité (recommandé) — bascule automatique sur Claude si le quota DeepL est épuisé et qu&#39;une clé Anthropic est renseignée</option><option value="claude" {"selected" if c.get("TRANSLATE_PROVIDER")=="claude" else ""}>Claude uniquement (API Anthropic)</option></select>'
    c6 = card("Langues & traduction (optionnel)", f("LANGS","Langues du site","Vide = site en français uniquement. Sinon, ex. <code>fr:Français,en:English</code> (ou <code>fr:Français,en:English,es:Español</code>) : l'onglet <b>Traductions</b> s'active, chaque page se traduit en un clic avec URL traduite (/en/…), hreflang et sélecteur de langue automatiques. Le français reste à la racine.")
        +f("DEFAULT_LANG","Langue par défaut","fr")+provsel
        +f("DEEPL_KEY","Clé API DeepL","Compte gratuit : <a href=https://www.deepl.com/pro-api target=_blank>deepl.com/pro-api</a> — la clé gratuite se termine par <code>:fx</code>. Quota des nouvelles clés : 1 million de caractères AU TOTAL (non renouvelable) ; anciennes clés « API Free » : 500 000/mois. Le compteur réel s&#39;affiche dans l&#39;onglet Traductions.")
        +f("ANTHROPIC_KEY","Clé API Anthropic (si fournisseur Claude)","console.anthropic.com — facturé à l'usage (~0,50 € par site complet).")
        +f("TRANSLATE_MODEL","Modèle Claude (optionnel)","Vide = claude-haiku."), "langs")
    envsel = f'<label>Mode par défaut de l’aperçu local</label><select name="ENV"><option value="preprod" {"selected" if c.get("ENV")=="preprod" else ""}>Préprod (noindex)</option><option value="prod" {"selected" if c.get("ENV")=="prod" else ""}>Production</option></select>'
    pubsel = f'<label>Mode de publication</label><select name="PUBLISH_MODE"><option value="" {"selected" if not c.get("PUBLISH_MODE") else ""}>FTP (back-office sur votre ordinateur)</option><option value="copy" {"selected" if c.get("PUBLISH_MODE")=="copy" else ""}>Copie directe (back-office hébergé sur le même serveur que le site)</option></select>'
    c7 = card("Publication (préprod & production)", pubsel
        + f("DOCROOT_PREPROD","Copie directe — dossier public de la préprod","Chemin absolu, ex. /home/votrecompte/preprod.votre-domaine.fr (cPanel › Domaines › Racine du document). Sert aussi à la protection par mot de passe ci-dessous.")
        + f("DOCROOT_PROD","Copie directe — dossier public de la production","Chemin absolu, ex. /home/votrecompte/votre-domaine.fr")
        + f("FTP_HOST","Hôte FTP (mode FTP)","chez o2switch : ftp.votre-domaine.fr ou le nom du serveur (ex. xxxx.o2switch.net)")+f("FTP_USER","Utilisateur (identifiant cPanel ou compte FTP dédié)")+f("FTP_PASS","Mot de passe","Stocké en clair dans config.json sur votre ordinateur — ne partagez pas ce fichier.","password")
        +f("SERVER_HOME","Chemin du compte (cPanel › Informations générales › Répertoire home)","ex. /home/beecom — en mode FTP, sert à calculer le chemin de la protection préprod")
        +h3("Préprod")+f("PREPROD_URL","URL de la préprod","ex. https://dev.votre-domaine.fr (sous-domaine créé dans cPanel › Domaines)")+f("FTP_DIR_PREPROD","Dossier distant de la préprod","= « Racine du document » du sous-domaine dans cPanel, ex. /dev.votre-domaine.fr")
        +h3("Protection de la préprod par mot de passe (.htaccess)")
        +'<p class="help" style="margin:2px 0 8px">Le navigateur demandera cet identifiant et ce mot de passe avant d’afficher la préprod. Le moteur génère automatiquement le .htaccess et le .htpasswd — il lui faut le chemin absolu du dossier préprod sur le serveur : « Copie directe — dossier public de la préprod » ci-dessus, ou « Chemin du compte » + « Dossier distant de la préprod ». Après modification : Régénérer puis Publier en préprod.</p>'
        +f("PREPROD_USER","Identifiant de protection de la préprod","Demandé par le navigateur (fenêtre « Authentification requise »).")+f("PREPROD_PASS","Mot de passe de protection de la préprod","Laissez vide pour une préprod sans mot de passe (elle reste en noindex).","password")
        +h3("Production")+f("SITE_URL","URL publique du site")+f("FTP_DIR_PROD","Dossier distant de la production","= racine du domaine dans cPanel, ex. /votre-fiche-google.fr ou /public_html")+envsel, "ftp")
    body = (msg + '<h1>Réglages du site</h1><p class="help">Tout ce qui se règle une fois : coordonnées, formulaires & e-mails, réseaux sociaux, cookies, statistiques, langues, publication. Les réglages de référencement ont leur onglet dédié : <a href="/seo">SEO</a>. Cliquez sur une rubrique pour l’ouvrir.</p>'
            '<form method="post" action="/settings">' + c1 + c2 + c3 + c4 + c5 + c6 + c7 +
            '<div class="sticky-actions actions"><button class="btn">Enregistrer les réglages</button><span class="help">Après modification : « Régénérer » puis « Publier ».</span></div></form>'
            '<script>var h=location.hash;if(h&&document.querySelector(h))document.querySelector(h).classList.remove("closed");else document.querySelector(".sec-card").classList.remove("closed");</script>')
    return layout("Réglages", body, "/settings")

def page_seo(msg=""):
    c = B.CONFIG
    def f(k, label, help_="", typ="text", rows=3):
        v = c.get(k, "")
        inp = (f'<textarea name="{k}" rows="{rows}" style="min-height:0;font-size:.85rem">{esc(v)}</textarea>'
               if typ == "textarea" else f'<input type="{typ}" name="{k}" value="{esc(v)}">')
        return f'<label>{esc(label)}</label>{inp}' + (f'<p class="help">{help_}</p>' if help_ else "")
    glob = ('<div class="card"><h2 style="margin-top:0;font-size:1rem">Réglages SEO globaux & données structurées</h2>'
            '<form method="post" action="/settings"><input type="hidden" name="back" value="/seo">'
            + f("TITLE_SUFFIX","Suffixe des titres des nouvelles pages","Vide = « | nom du site ». Compté dans les 65 caractères.")
            + f("ORG_NAME","Nom de l’organisation (JSON-LD Organization)","Vide = « nom du site — un service de l’agence Beecom’ ».")
            + f("ORG_LOGO","Logo de l’organisation (chemin /assets/img/…)","Vide = logo du site.")
            + f("ORG_TEL","Téléphone au format international","ex. +33559033562")
            + f("ORG_STREET","Adresse — rue") + f("ORG_POSTAL","Code postal") + f("ORG_CITY","Ville") + f("ORG_REGION","Région","ex. Nouvelle-Aquitaine")
            + f("BLOG_BASE","Préfixe des adresses du blog (avancé)","Vide = catégories à la racine : <code>/categorie/article/</code> (défaut des nouveaux sites). Renseignez par ex. <code>guide</code> ou <code>blog</code> pour <code>/guide/categorie/article/</code>. ⚠ Ne changez pas ce réglage sur un site qui a déjà des articles : les pages existantes ne sont pas déplacées (les sites historiques sous /guide/ le restent automatiquement).")
            + f("ROBOTS_TXT","robots.txt de PRODUCTION (avancé)","Vide = défaut (tout autorisé + lien sitemap). La préprod reste toujours en Disallow automatique. Attention : un Disallow: / ici bloquerait tout Google.","textarea",4)
            + '<div class="actions" style="margin-top:1rem"><button class="btn">Enregistrer</button><span class="help">Après modification : « Régénérer » puis « Publier ».</span></div></form></div>')
    rows = ""
    for p in list_pages():
        meta, _ = read_page(p["file"])
        t = meta.get("title", ""); d = meta.get("description", "")
        lt, ld = len(t), len(d)
        ct = f'<span style="color:{"#c0392b" if lt > 65 else "#1e8e3e"};font-size:.72rem">{lt}/65</span>'
        cd = f'<span style="color:{"#c0392b" if ld > 160 or ld < 70 else "#1e8e3e"};font-size:.72rem">{ld}/160</span>'
        tags = ""
        if meta.get("noindex", "false").lower() == "true": tags += ' <span class="tag d">noindex</span>'
        if meta.get("canonical", "").strip(): tags += ' <span class="tag">canonical</span>'
        if p["draft"]: tags += ' <span class="tag d">brouillon</span>'
        rows += (f'<tr><td><code style="font-size:.74rem">{esc(p["url"])}</code>{tags}</td>'
                 f'<td>{esc(t) or "<span class=help>— vide —</span>"} {ct}</td>'
                 f'<td style="max-width:340px">{esc(d) or "<span class=help>— vide —</span>"} {cd}</td>'
                 f'<td><a class="btn sm sec" href="/edit?f={esc(p["file"])}#seo">Éditer</a></td></tr>')
    table = (f'<div class="card"><h2 style="margin-top:0;font-size:1rem">SEO page par page</h2>'
             '<p class="help">Titre ≤ 65 caractères, description entre 70 et 160 : en vert quand c’est bon, en rouge sinon. '
             'Le titre SEO, la méta description, le noindex, l’URL canonique et les titres de partage (og:) se modifient dans l’écran d’édition de chaque page (rubrique « Référencement »).</p>'
             f'<table><tr><th>Page</th><th>Titre SEO</th><th>Méta description</th><th></th></tr>{rows}</table></div>')
    body = (msg + '<h1>SEO</h1><p class="help">Tout le référencement au même endroit : réglages globaux (données structurées, robots.txt, suffixe des titres) et vue d’ensemble page par page. '
            'Le sitemap, les hreflang, les redirections 301 et le balisage Schema.org sont générés automatiquement à la régénération.</p>' + glob + table)
    return layout("SEO", body, "/seo")

def page_help():
    body = """<h1>Aide</h1>
<div class="card"><h2 style="margin-top:0">Le principe en 30 secondes</h2><p>Le site est « statique » : des fichiers HTML générés à partir de vos textes. Vous modifiez → vous cliquez <b>Régénérer</b> (le dossier <code>dist/</code> est reconstruit : menu, pied de page, SEO, sitemap…) → vous vérifiez dans l'<b>Aperçu</b> → vous cliquez <b>Publier</b> (envoi FTP de <code>dist/</code> sur l'hébergement). Tant que vous n'avez pas publié, rien ne change en ligne.</p></div>
<div class="card"><h2 style="margin-top:0">Menu, pied de page, pop-up, réglages</h2><p><b>Menu & pied de page</b> : ordre et libellés du menu, sous-menus (une ligne par lien : Texte | Lien | Sous-texte | picto), bouton d'action, colonnes du pied de page, liens légaux. <b>Pop-up</b> : fenêtre avec photo, titre, sous-titre, texte, bouton ; activable/désactivable ; déclenchée quand le visiteur atteint une section (3ᵉ partie de l'accueil par défaut). <b>Réglages</b> : coordonnées, formulaires (adresse de réception, e-mails de notification et d'accusé de réception), réseaux sociaux, feed Instagram, cookies Sirdata, statistiques, langues, publication FTP.</p></div>
<div class="card"><h2 style="margin-top:0">Blocs de page</h2><p>Chaque page (« Toutes les pages ») s'ouvre avec ses blocs, section par section. Pour la page d'accueil, chaque section (hero, constat, chiffres, étapes, offre, métiers, témoignages, FAQ…) est un formulaire dans <b>Blocs de page</b> : titres, textes, images (taille recommandée affichée sous le champ), boutons, listes que vous ajoutez, supprimez ou réordonnez (▲ ▼). Enregistrez puis Régénérez. Les images se téléversent d'abord dans <b>Images</b>, puis se choisissent dans la liste du champ.</p></div>
<div class="card"><h2 style="margin-top:0">Actions courantes</h2>
<p><b>Modifier un texte</b> : Pages → Éditer → modifiez dans la zone HTML (les balises &lt;p&gt;, &lt;h2&gt;… encadrent le texte) → Enregistrer + régénérer.</p>
<p><b>Ajouter un article</b> : ＋ Article → remplissez le formulaire, écrivez en Markdown (## pour les titres) → Créer. L'article apparaît automatiquement dans le hub Guide, sa page thème, les « À lire aussi », le sitemap. Modifiez-le ensuite comme une page normale.</p>
<p><b>Changer une image</b> : Images → téléverser → Copier le chemin → dans la page, remplacez le <code>src="…"</code> de la balise &lt;img&gt;.</p>
<p><b>Renommer/supprimer une page</b> : ajoutez une redirection de l'ancienne adresse vers la nouvelle (Redirections), puis régénérez.</p>
<p><b>Changer un prix</b> : les prix figurent dans le texte des pages (accueil, offre, forfaits, métiers) : Pages → Éditer → Ctrl/Cmd+F « 149 ». Le schéma Offer (données structurées) est dans <code>build.py</code> (SERVICE_LD).</p>
<p><b>Menu / pied de page / liste des métiers</b> : dans <code>build.py</code>, listes <code>METIERS</code>, <code>OFFRE</code>, <code>GUIDE_THEMES</code> (une ligne par entrée).</p>
<p><b>Charte, couleurs, tailles</b> : <code>assets/css/style.css</code> (variables en tête de fichier).</p></div>
<div class="card"><h2 style="margin-top:0">Comptes & rôles</h2><p><b>Administrateur</b> : tout (réglages, FTP, publication, redirections, suppression de pages, gestion des comptes). <b>Éditeur</b> : pages, articles, images, régénérer, aperçu, export zip. Les mots de passe sont stockés hachés dans <code>users.json</code>. Le back-office n'écoute que sur 127.0.0.1 : il n'est pas accessible depuis internet.</p></div>
<div class="card"><h2 style="margin-top:0">Sauvegarde</h2><p>Tout le site tient dans ce dossier. Sauvegardez-le (Time Machine, Drive, Git). Les pages supprimées vont dans <code>_corbeille/</code>.</p></div>"""
    return layout("Aide", body, "/help")

def bo_logo(white=False):
    """Logo du site pour l'habillage du back-office (connexion, barre latérale) : premier fichier
    logo* présent dans assets/img — variante blanche si white=True. '' si aucun (repli texte)."""
    try:
        files = sorted(f for f in os.listdir(IMG) if f.lower().startswith("logo")
                       and os.path.splitext(f)[1].lower() in (".png", ".svg", ".webp", ".jpg", ".jpeg"))
    except Exception: files = []
    def pick(pred):
        for f in files:
            if pred(f.lower()): return "/assets/img/" + f
        return ""
    if white:
        return pick(lambda f: "white" in f and "baseline" in f) or pick(lambda f: "white" in f) or pick(lambda f: True)
    return pick(lambda f: "baseline" in f and "white" not in f) or pick(lambda f: "white" not in f) or pick(lambda f: True)

def page_login(msg=""):
    lg = bo_logo()
    brand = f'<img src="{lg}" alt="{esc(B.SITE_NAME)}">' if lg else f'<h2 style="text-align:center;margin:0 0 1rem">{esc(B.SITE_NAME)}</h2>'
    return f"""<!DOCTYPE html><html lang="fr"><head><meta charset="utf-8"><title>Connexion — Back-office</title><meta name="viewport" content="width=device-width,initial-scale=1"><style>{CSS}
body{{background:var(--navy);display:flex;align-items:center;justify-content:center;min-height:100vh}}.box{{background:#fff;border-radius:16px;padding:2rem 2.2rem;width:min(420px,92%);box-shadow:0 30px 60px rgba(0,0,0,.4)}}.box img{{width:100%;max-width:280px;margin:0 auto 1.2rem;display:block}}</style></head>
<body><form class="box" method="post" action="/login">{brand}<p class="help" style="text-align:center;font-size:.92rem;margin-bottom:.4rem">Connectez-vous pour gérer le site.</p>{msg}
<label>E-mail</label><input type="text" name="email" autocomplete="username" required autofocus><label>Mot de passe</label><input type="password" name="password" autocomplete="current-password" required>
<div class="actions" style="margin-top:1.2rem"><button class="btn" style="width:100%">Se connecter</button></div>
<p class="help" style="text-align:center;margin-top:1rem">{'<a href="/forgot">Mot de passe oublié ?</a>' if ONLINE else 'Accès local uniquement (127.0.0.1). Mot de passe oublié ? Un administrateur peut le redéfinir dans « Utilisateurs » ; en dernier recours, supprimez la ligne du compte dans <code>users.json</code> et relancez.'}</p><p class="help" style="text-align:center;margin-top:.6rem;opacity:.55;font-size:.75rem">moteur v{VERSION}</p></form></body></html>"""

def page_forgot(msg=""):
    return f"""<!DOCTYPE html><html lang="fr"><head><meta charset="utf-8"><title>Mot de passe oublié</title><meta name="viewport" content="width=device-width,initial-scale=1"><style>{CSS}
body{{background:var(--navy);display:flex;align-items:center;justify-content:center;min-height:100vh}}.box{{background:#fff;border-radius:16px;padding:2rem 2.2rem;width:min(420px,92%)}}</style></head>
<body><form class="box" method="post" action="/forgot"><h2 style="margin:0 0 .3rem">Mot de passe oublié</h2><p class="help">Saisissez votre e-mail : si un compte existe, vous recevrez un lien valable 30 minutes.</p>{msg}
<label>E-mail</label><input type="text" name="email" required autofocus>
<div class="actions" style="margin-top:1.2rem"><button class="btn" style="width:100%">Recevoir le lien</button></div>
<p class="help" style="text-align:center;margin-top:1rem"><a href="/login">← Retour à la connexion</a></p></form></body></html>"""

def page_reset(email, tok, msg=""):
    return f"""<!DOCTYPE html><html lang="fr"><head><meta charset="utf-8"><title>Nouveau mot de passe</title><meta name="viewport" content="width=device-width,initial-scale=1"><style>{CSS}
body{{background:var(--navy);display:flex;align-items:center;justify-content:center;min-height:100vh}}.box{{background:#fff;border-radius:16px;padding:2rem 2.2rem;width:min(420px,92%)}}</style></head>
<body><form class="box" method="post" action="/reset"><h2 style="margin:0 0 .3rem">Nouveau mot de passe</h2>{msg}
<input type="hidden" name="email" value="{esc(email)}"><input type="hidden" name="token" value="{esc(tok)}">
<label>Nouveau mot de passe (12 caractères min.)</label><input type="password" name="new" required autofocus>
<label>Confirmez-le</label><input type="password" name="new2" required>
<div class="actions" style="margin-top:1.2rem"><button class="btn" style="width:100%">Changer le mot de passe</button></div></form></body></html>"""

def page_users(msg=""):
    rows = ""
    for u in load_users():
        me = u["email"].lower() == CURRENT_USER.get("email", "").lower()
        delb = "" if me else '<a class="btn sm danger" href="/user-del?email=' + esc(u["email"]) + '" onclick="return confirm(\'Supprimer ce compte ?\')">Supprimer</a>'
        rows += f'<tr><td><b>{esc(u["email"])}</b>{" <span class=tag>vous</span>" if me else ""}</td><td><span class="tag">{esc(ROLES.get(u["role"], u["role"]))}</span></td><td>{esc(u.get("created",""))}</td><td class="actions">{delb}</td></tr>'
    roles = "".join(f'<option value="{k}">{esc(v)}</option>' for k, v in ROLES.items() if k != "editeur")
    body = f"""{msg}<h1>Utilisateurs</h1>
<div class="card"><table><tr><th>E-mail</th><th>Rôle</th><th>Créé le</th><th></th></tr>{rows}</table></div>
<div class="card"><h2 style="margin-top:0">Ajouter ou modifier un compte</h2><form method="post" action="/users"><div class="row3"><div><label>E-mail</label><input type="text" name="email" required></div><div><label>Mot de passe (12 caractères min.)</label><input type="password" name="password" required minlength="12"></div><div><label>Rôle</label><select name="role">{roles}</select></div></div>
<label>Nom affiché (optionnel)</label><input type="text" name="name" placeholder="ex. Jean-Marc" style="max-width:320px"><p class="help">Affiché en haut à droite du back-office. Vide = déduit de l'e-mail.</p>
<p class="help">Si l'e-mail existe déjà, le mot de passe et le rôle sont remplacés. <b>Administrateur</b> : tout (réglages, comptes, menu, suppressions, licence). <b>SEO</b> : contenu + onglet SEO, redirections, traductions, publication préprod et production — pas de réglages généraux ni de comptes. <b>Client</b> : pages, articles, médias, aperçu + bouton « Publier en ligne » — rien de technique. Les anciens comptes « Éditeur » sont traités comme des Clients.</p>
<div class="actions" style="margin-top:.8rem"><button class="btn">Enregistrer le compte</button></div></form></div>"""
    return layout("Utilisateurs", body, "/users")

def page_profile(msg=""):
    body = f"""{msg}<h1>Mon compte</h1>
<div class="card"><h2 style="margin-top:0">Mon profil</h2><form method="post" action="/profile-name">
<p class="help">Connecté en tant que <b>{esc(CURRENT_USER.get("email",""))}</b> ({esc(ROLES.get(CURRENT_USER.get("role",""), ""))}).</p>
<label>Nom affiché</label><input type="text" name="name" value="{esc(CURRENT_USER.get("name",""))}" placeholder="{esc(display_name(CURRENT_USER))}" style="max-width:320px">
<p class="help">Affiché en haut à droite et dans le journal de bord. Vide = déduit de l'e-mail.</p>
<div class="actions" style="margin-top:.8rem"><button class="btn sm">Enregistrer</button></div></form></div>
<div class="card"><h2 style="margin-top:0">Mon mot de passe</h2><form method="post" action="/profile">
<label>Mot de passe actuel</label><input type="password" name="old" required><label>Nouveau mot de passe (12 caractères min.)</label><input type="password" name="new" required minlength="12"><label>Confirmer</label><input type="password" name="new2" required minlength="12">
<div class="actions" style="margin-top:1rem"><button class="btn">Changer mon mot de passe</button></div></form></div>"""
    return layout("Mon mot de passe", body, "/profile")

# ------------------------------------------------------------------ actions
def do_build(env=None):
    buf = io.StringIO(); old = sys.stdout; sys.stdout = buf
    try:
        import importlib; importlib.reload(B); n = B.build(env); ok = True
    except Exception as e:
        traceback.print_exc(file=buf); ok = False
    finally: sys.stdout = old
    out = buf.getvalue().strip(); log(("✔ " if ok else "✘ ") + out.replace("\n", " | ")); return ok, out

def do_publish(target="preprod"):
    c = B.CONFIG
    if ONLINE or c.get("PUBLISH_MODE") == "copy":
        # Le back-office tourne sur le même hébergement que le site : copie directe dans le dossier public.
        doc = (c.get("DOCROOT_PROD") if target == "prod" else c.get("DOCROOT_PREPROD")) or ""
        if not doc: return False, "Dossier de publication non renseigné (Réglages › Publication : chemin absolu du dossier public, ex. /home/compte/votre-domaine.fr)."
        ok, out = do_build("prod" if target == "prod" else "preprod")
        if not ok: return False, "Génération impossible : " + out[-200:]
        try:
            n = 0
            for dp, dn, fns in os.walk(DIST):
                r = os.path.relpath(dp, DIST); tgt = doc if r == "." else os.path.join(doc, r)
                os.makedirs(tgt, exist_ok=True)
                for fn in fns:
                    shutil.copy2(os.path.join(dp, fn), os.path.join(tgt, fn)); n += 1
            log(f"✔ Publication {target.upper()} : {n} fichiers copiés vers {doc}")
            do_build()
            return True, f"{target.upper()} : {n} fichiers publiés dans {doc}"
        except Exception as e:
            log(f"✘ Copie : {e}"); return False, f"Erreur de copie : {e}"
    if not (c["FTP_HOST"] and c["FTP_USER"]): return False, "FTP non configuré (Réglages)."
    ok, out = do_build("prod" if target == "prod" else "preprod")   # on régénère dans le bon mode juste avant d'envoyer
    if not ok: return False, "Génération impossible : " + out[-200:]
    try:
        ftp = ftplib.FTP(c["FTP_HOST"], timeout=30); ftp.login(c["FTP_USER"], c["FTP_PASS"]); ftp.encoding = "utf-8"
        base = (c["FTP_DIR_PROD"] if target == "prod" else c["FTP_DIR_PREPROD"]).rstrip("/") or "/"
        def mk(path):
            parts = [p for p in path.split("/") if p]; cur = ""
            for p in parts:
                cur += "/" + p
                try: ftp.mkd(cur)
                except ftplib.error_perm: pass
        mk(base); n = 0
        for dp, dn, fns in os.walk(DIST):
            r = os.path.relpath(dp, DIST).replace(os.sep, "/"); remote = base if r == "." else base + "/" + r
            if r != ".": mk(remote)
            for fn in fns:
                with open(os.path.join(dp, fn), "rb") as fh: ftp.storbinary(f"STOR {remote}/{fn}", fh); n += 1
        ftp.quit(); log(f"✔ Publication {target.upper()} : {n} fichiers envoyés vers {base}")
        do_build()   # on remet dist/ dans le mode par défaut des réglages
        return True, f"{target.upper()} : {n} fichiers publiés sur {c['FTP_HOST']}{base}"
    except Exception as e:
        log(f"✘ FTP : {e}"); return False, f"Erreur FTP : {e}"

def save_image(data, name, subdir="uploads"):
    os.makedirs(os.path.join(IMG, subdir), exist_ok=True)
    base = slugify(os.path.splitext(name)[0]) or "image"
    try:
        from PIL import Image
        im = Image.open(io.BytesIO(data)); im = im.convert("RGB") if im.mode not in ("RGB", "RGBA") else im
        if im.width > 1600: im = im.resize((1600, int(im.height * 1600 / im.width)))
        out = os.path.join(IMG, subdir, base + ".webp"); k = 2
        while os.path.exists(out): out = os.path.join(IMG, subdir, f"{base}-{k}.webp"); k += 1
        im.save(out, "WEBP", quality=82)
    except Exception:
        ext = os.path.splitext(name)[1].lower() or ".jpg"; out = os.path.join(IMG, subdir, base + ext); open(out, "wb").write(data)
    return "/assets/" + os.path.relpath(out, ASSETS).replace(os.sep, "/")


def optimize_images(min_kb=150, quality=80, max_w=1600, only=None):
    """Recompresse les images lourdes de assets/img (JPG/WebP → même format, PNG → PNG optimisé) sans changer leur chemin. Retourne une liste (chemin, avant, après, note)."""
    try:
        from PIL import Image
    except Exception:
        return None
    res = []
    for dp, dn, fns in os.walk(IMG):
        dn[:] = [d for d in dn if d != "_v"]   # variantes auto (perf) : internes
        for fn in sorted(fns):
            full = os.path.join(dp, fn); ext = fn.lower().rsplit(".", 1)[-1] if "." in fn else ""
            if ext not in ("jpg", "jpeg", "png", "webp"): continue
            relp = "/assets/" + os.path.relpath(full, ASSETS).replace(os.sep, "/")
            if only and relp != only: continue
            before = os.path.getsize(full)
            if before < min_kb * 1024 and not only: continue
            try:
                im = Image.open(full); im.load(); w, h = im.size; note = ""
                if w > max_w: im = im.resize((max_w, int(h * max_w / w)), Image.LANCZOS); note = f"redimensionnée {w}→{max_w} px"
                buf = io.BytesIO()
                if ext in ("jpg", "jpeg"):
                    im.convert("RGB").save(buf, "JPEG", quality=quality, optimize=True, progressive=True)
                elif ext == "webp":
                    im.save(buf, "WEBP", quality=quality, method=6)
                else:
                    if im.mode not in ("RGBA", "LA", "P"): im = im.convert("RGB")
                    q = im.convert("RGBA").quantize(colors=256, method=Image.Quantize.FASTOCTREE) if im.mode == "RGBA" else im
                    q.save(buf, "PNG", optimize=True); note = (note + " · " if note else "") + "PNG réduit à 256 couleurs"
                data = buf.getvalue()
                if len(data) < before * 0.92 or (note and len(data) < before):
                    open(full, "wb").write(data); res.append((relp, before, len(data), note or "recompressée"))
                else:
                    res.append((relp, before, before, "déjà optimale"))
            except Exception as e:
                res.append((relp, before, before, f"erreur : {e}"))
    return res

def parse_multipart(headers, body):
    ctype = headers.get("Content-Type", "")
    msg = BytesParser(policy=email_policy).parsebytes(b"Content-Type: " + ctype.encode() + b"\r\n\r\n" + body)
    fields, files = {}, []
    for part in msg.iter_parts():
        name = part.get_param("name", header="content-disposition"); fn = part.get_filename()
        payload = part.get_payload(decode=True)
        if fn: files.append((name, fn, payload))
        else: fields.setdefault(name, []).append(payload.decode("utf-8", "replace"))
    return {k: v[0] if len(v) == 1 else v for k, v in fields.items()}, files

def _norm_key(t):
    t = unicodedata.normalize("NFKD", t).encode("ascii", "ignore").decode().lower()
    return re.sub(r"[^a-z0-9]+", "-", t).strip("-")

def parse_article_md(txt):
    """Fichier .md d'article (livraisons « articles-pour-bo/ ») → champs du formulaire d'article.
    En-tête --- clef: valeur --- (titre, sous-titre, description, slug, categorie, titre-seo,
    date, couverture, brouillon), puis le contenu Markdown ; sections optionnelles repérées par
    leurs titres : « L'essentiel à retenir », « FAQ », « Sources ». Tolérant (alias, accents)."""
    txt = txt.replace("\r\n", "\n").lstrip("\ufeff")
    fm = {}
    m = re.match(r"^---\s*\n(.*?)\n---\s*\n?(.*)$", txt, re.S)
    body = txt
    if m:
        for line in m.group(1).splitlines():
            if ":" not in line: continue
            k, v = line.split(":", 1)
            fm[_norm_key(k)] = v.strip().strip('"').strip("'")
        body = m.group(2)
    def g(*keys):
        for k in keys:
            if fm.get(k): return fm[k]
        return ""
    title = g("titre", "title")
    # pas de titre en en-tête : premier « # Titre » du corps
    if not title:
        mh = re.search(r"^#\s+(.+)$", body, re.M)
        if mh: title = mh.group(1).strip(); body = body.replace(mh.group(0), "", 1)
    # sections spéciales par titres (les ## du contenu ordinaire ne changent pas de section)
    SPECIAL = {"essentiel": ("essentiel", "l-essentiel-a-retenir", "essentiel-a-retenir", "l-essentiel"),
               "faq": ("faq", "questions-frequentes", "foire-aux-questions"),
               "sources": ("sources", "source"),
               "contenu": ("contenu", "contenu-de-l-article", "texte-de-l-article", "article")}
    buf = {"contenu": [], "essentiel": [], "faq": [], "sources": []}
    cur = "contenu"
    for line in body.splitlines():
        h = re.match(r"^#{1,3}\s+(.*?)\s*$", line)
        if h:
            nk = _norm_key(h.group(1))
            hit = next((sec for sec, names in SPECIAL.items() if nk in names), None)
            if hit: cur = hit; continue
        buf[cur].append(line)
    bullets = lambda ls: "\n".join(re.sub(r"^\s*[-*•]\s*", "", l).strip() for l in ls if l.strip())
    return {
        "title": title,
        "subtitle": g("sous-titre", "soustitre", "subtitle"),
        "description": g("description", "meta-description", "meta"),
        "seo_title": g("titre-seo", "seo-title", "title-seo"),
        "slug": g("slug") or slugify(title),
        "theme": g("categorie", "category", "theme"),
        "date": g("date"), "excerpt": g("extrait", "excerpt"),
        "draft": "true" if g("brouillon", "draft").lower() in ("oui", "true", "1", "yes") else "false",
        "cover": g("couverture", "cover", "image"),
        "body": "\n".join(buf["contenu"]).strip(),
        "essential": bullets(buf["essentiel"]),
        "faq": "\n".join(l.strip() for l in buf["faq"] if "|" in l),
        "sources": bullets(buf["sources"]),
    }

def import_articles(files, auto_cat=True):
    """Import en masse : fichiers .md (+ covers, + .zip contenant les deux). Retourne [(nom, ok, message)]."""
    import zipfile, io
    mds, imgs = [], {}
    for name, fn, data in files:
        if not fn or not data: continue
        base = os.path.basename(fn)
        if base.lower().endswith(".zip"):
            try:
                with zipfile.ZipFile(io.BytesIO(data)) as z:
                    for zi in z.infolist():
                        if zi.is_dir(): continue
                        zb = os.path.basename(zi.filename)
                        if not zb or zb.startswith("."): continue
                        zd = z.read(zi)
                        if zb.lower().endswith((".md", ".markdown")): mds.append((zb, zd))
                        elif zb.lower().endswith((".webp", ".jpg", ".jpeg", ".png")): imgs[zb.lower()] = (zb, zd)
            except Exception as e:
                return [(base, False, f"zip illisible : {e}")]
        elif base.lower().endswith((".md", ".markdown")): mds.append((base, data))
        elif base.lower().endswith((".webp", ".jpg", ".jpeg", ".png")): imgs[base.lower()] = (base, data)
    if not mds: return [("—", False, "Aucun fichier .md trouvé dans l'envoi.")]
    out = []
    themes = {sl: sl for sl, _ in B.GUIDE_THEMES}
    themes.update({_norm_key(lab): sl for sl, lab in B.GUIDE_THEMES})
    for fn, data in sorted(mds):
        try:
            a = parse_article_md(data.decode("utf-8", "replace"))
            if not a["title"]: out.append((fn, False, "titre introuvable (en-tête « titre: » ou « # Titre »)")); continue
            if not a["body"]: out.append((fn, False, "contenu vide")); continue
            tkey = themes.get(a["theme"]) or themes.get(_norm_key(a["theme"]))
            if not tkey:
                if not a["theme"]: out.append((fn, False, "catégorie manquante (clef « categorie: »)")); continue
                if not auto_cat: out.append((fn, False, f"catégorie inconnue : {a['theme']} (cochez « créer les catégories manquantes »)")); continue
                tkey = create_theme(a["theme"])
                themes[tkey] = tkey; themes[_norm_key(a["theme"])] = tkey
            cov = []
            want = (a["cover"] or f"cover-{a['slug']}").lower()
            for key, (cb, cd) in imgs.items():
                if key == want or os.path.splitext(key)[0] in (os.path.splitext(want)[0], "cover-" + a["slug"]):
                    cov = [("image", cb, cd)]; break
            fields = {k: a[k] for k in ("title", "subtitle", "description", "seo_title", "slug", "theme", "date", "excerpt", "draft", "body", "essential", "faq", "sources")}
            fields["theme"] = tkey
            relp = create_article(fields, cov)
            nfaq = len([l for l in a["faq"].splitlines() if l.strip()])
            out.append((fn, True, f"→ /{B.BLOG_PREFIX}{tkey}/{slugify(a['slug'])}/" + (f" · FAQ ×{nfaq}" if nfaq else "") + (" · cover ✔" if cov else " · cover par défaut")))
        except ValueError as e:
            out.append((fn, False, str(e)))
        except Exception as e:
            out.append((fn, False, "erreur : " + str(e)))
    return out

def create_article(fields, files):
    theme = fields.get("theme", "avis-google"); title = fields.get("title", "").strip(); slug = slugify(fields.get("slug") or title)
    subtitle = fields.get("subtitle", "").strip(); desc = fields.get("description", "").strip()
    seo = fields.get("seo_title", "").strip() or title
    image = fields.get("image_existing", "") or B.CONFIG.get("DEFAULT_ARTICLE_IMG", B.DEFAULT_OG)
    for name, fn, data in files:
        if name == "image" and data: image = save_image(data, slug, B.BLOG_BASE or "blog"); break
    body_html = md_to_html(fields.get("body", ""))
    ess = [l.strip() for l in fields.get("essential", "").splitlines() if l.strip()]
    if ess: body_html = '<div class="essential" id="essentiel"><h2>L\'essentiel à retenir</h2><ul>' + "".join(f"<li>{esc(x)}</li>" for x in ess) + "</ul></div>\n" + body_html
    faq = [l.split("|", 1) for l in fields.get("faq", "").splitlines() if "|" in l]
    if faq: body_html += '\n<h2 id="faq">FAQ</h2>'
    toc = "".join(f'<li><a href="#{i}">{t}</a></li>' for i, t in re.findall(r'<h2 id="([^"]+)">(.*?)</h2>', body_html))
    url = f"{B.SITE_URL}/{B.BLOG_PREFIX}{theme}/{slug}/"
    from urllib.parse import quote
    # L'article reste STRUCTURÉ en champs (façon ACF) : contenu (éditeur visuel), FAQ (répéteur),
    # sources (liste) — jamais un seul gros HTML. Le corps de page n'embarque que des jetons.
    art_body = ('{{B:art.contenu}}'
                '\n<div class="faq">{{B:art.faq}}<details><summary>{q}</summary><div class="answer"><p>{r}</p></div></details>{{/B}}</div>'
                '\n<div class="sources">{{B:art.sources_titre}}<ul>{{B:art.sources}}<li>{line}</li>{{/B}}</ul></div>')
    content = ARTICLE_TPL.format(image=image, title_esc=esc(title), subtitle_esc=esc(subtitle), toc=toc, share=quote(url, safe=""), body=art_body, theme=theme)
    label = dict(B.GUIDE_THEMES).get(theme, theme)
    meta = {"title": seo + (B.CONFIG.get("TITLE_SUFFIX") or f" | {B.SITE_NAME}"), "description": desc, "type": "article",
            "date": fields.get("date") or datetime.date.today().isoformat(), "date_fr": fields.get("date_fr", ""), "og_image": image, "priority": "0.7",
            "card_title": title, "excerpt": fields.get("excerpt", "").strip() or desc, "draft": "true" if fields.get("draft") == "true" else "false"}
    relp = f"{B.BLOG_PREFIX}{theme}/{slug}.html"
    if os.path.exists(os.path.join(PAGES, relp)): raise ValueError("Un article avec cette adresse existe déjà.")
    write_page(relp, meta, content)
    src = [l.strip() for l in fields.get("sources", "").splitlines() if l.strip()]
    d = {"page": relp, "label": title[:60], "sections": [{"id": "art", "label": "Article", "fields": [
        {"key": "contenu", "label": "Contenu de l'article", "type": "richtext", "value": body_html},
        {"key": "faq", "label": "FAQ (générée en données structurées FAQPage automatiquement)", "type": "repeat",
         "fields": [{"key": "q", "label": "Question", "type": "text"}, {"key": "r", "label": "Réponse", "type": "textarea"}],
         "items": [{"q": q.strip(), "r": a.strip()} for q, a in faq]},
        {"key": "sources_titre", "label": "Intitulé des sources (vide = bloc masqué)", "type": "html", "value": "<b>Sources :</b>" if src else ""},
        {"key": "sources", "label": "Sources (une par ligne)", "type": "lines", "value": "\n".join(src)},
    ]}]}
    save_blocks(B.blocks_key(relp), d)
    log(f"✔ Article créé : /{B.BLOG_PREFIX}{theme}/{slug}/"); return relp

# ---------- Catégories du guide (blocks/_themes.json + page hub) ----------
THEMES_PATH = os.path.join(ROOT, "blocks", "_themes.json")
def save_themes(themes):
    json.dump({"themes": [{"slug": sl, "label": lab} for sl, lab in themes]},
              open(THEMES_PATH, "w", encoding="utf-8"), ensure_ascii=False, indent=1)
    import importlib; importlib.reload(B)

def create_theme(label):
    label = label.strip()
    if not label: raise ValueError("Indiquez le nom de la catégorie.")
    slug = slugify(label)
    if any(sl == slug for sl, _ in B.GUIDE_THEMES): raise ValueError(f"La catégorie « {label} » ({slug}) existe déjà.")
    relp = f"{B.BLOG_PREFIX}{slug}.html"
    if os.path.exists(os.path.join(PAGES, relp)): raise ValueError(f"Une page /{B.BLOG_PREFIX}{slug}/ existe déjà.")
    meta = {"title": f"{label} : nos guides", "description": f"Tous nos guides sur le thème « {label} ».",
            "bc_label": label, "type": "page", "priority": "0.7"}
    content = f"""<section class="hero hero-light hero-simple">
  <div class="container container-narrow center">
    {{{{BREADCRUMB}}}}
    <span class="kicker">{{{{B:s1.f1}}}}</span>
    <h1>{{{{B:s1.f2}}}}</h1>
    <p class="lead">{{{{B:s1.f3}}}}</p>
  </div>
</section>

<section class="section">
  <div class="container">
    <div class="center">
      <span class="sec-label">{{{{B:s2.f1}}}}</span>
      <h2>{{{{B:s2.f2}}}}</h2>
      <div class="gline"></div>
      <p class="intro">{{{{B:s2.f3}}}}</p>
    </div>
    <div class="grid grid-3 mt-3">
      {{{{ARTICLE_CARDS:{slug}}}}}
    </div>
    <div class="cta-inline mt-3"><p>{{{{B:s2.f4}}}}</p><a class="btn btn-primary" href="{{{{B:s2.f6}}}}">{{{{B:s2.f5}}}}</a></div>
  </div>
</section>"""
    write_page(relp, meta, content)
    d = {"page": relp, "label": f"{label} (hub du guide)", "sections": [
        {"id": "s1", "label": "En-tête", "fields": [
            {"key": "f1", "label": "Sur-titre", "type": "text", "value": "Le guide · Thème"},
            {"key": "f2", "label": "Titre principal (H1)", "type": "html", "value": esc(label)},
            {"key": "f3", "label": "Accroche", "type": "html", "value": f"Tous nos guides sur le thème « {esc(label)} »."}]},
        {"id": "s2", "label": "Liste des articles", "fields": [
            {"key": "f1", "label": "Étiquette de section", "type": "text", "value": "Le thème"},
            {"key": "f2", "label": "Titre de section (H2)", "type": "html", "value": "Les articles"},
            {"key": "f3", "label": "Introduction", "type": "html", "value": ""},
            {"key": "f4", "label": "Texte de l'appel à l'action", "type": "text", "value": "Une question sur ce thème ?"},
            {"key": "f5", "label": "Libellé du bouton", "type": "text", "value": "Contactez-nous"},
            {"key": "f6", "label": "Lien du bouton", "type": "url", "value": "/contact/"}]}]}
    save_blocks(B.blocks_key(relp), d)
    save_themes(list(B.GUIDE_THEMES) + [(slug, label)])
    log(f"✔ Catégorie créée : {label} (/{B.BLOG_PREFIX}{slug}/)")
    return slug

def delete_theme(slug):
    themes = list(B.GUIDE_THEMES)
    if not any(sl == slug for sl, _ in themes): raise ValueError("Catégorie inconnue.")
    base = os.path.join(PAGES, B.BLOG_BASE) if B.BLOG_BASE else PAGES
    folder = os.path.join(base, slug)
    if os.path.isdir(folder) and any(fn.endswith(".html") for fn in os.listdir(folder)):
        raise ValueError("Cette catégorie contient des articles : déplacez-les ou supprimez-les d'abord.")
    relp = f"{B.BLOG_PREFIX}{slug}.html"
    for pth in (os.path.join(PAGES, relp), os.path.join(BLOCKS, B.blocks_key(relp) + ".json")):
        if os.path.exists(pth): os.remove(pth)
    if os.path.isdir(folder):
        try: os.rmdir(folder)
        except OSError: pass
    save_themes([(sl, lab) for sl, lab in themes if sl != slug])
    log(f"✔ Catégorie supprimée : {slug}")

def _url_rx(old_url):
    """Motif de remplacement sûr d'une URL interne : pas au milieu d'une URL plus longue."""
    return re.compile("(?<![\\w-])" + re.escape(old_url) + "(?![\\w-])")

def replace_internal_url(old_url, new_url, extra_abs=None):
    """Réécrit old_url → new_url dans toutes les pages, blocs JSON et fichiers layout. Retourne le nombre de fichiers touchés."""
    rx = _url_rx(old_url); n = 0
    targets = []
    for dp, dn, fns in os.walk(PAGES):
        targets += [os.path.join(dp, fn) for fn in fns if fn.endswith(".html")]
    targets += [os.path.join(BLOCKS, fn) for fn in os.listdir(BLOCKS) if fn.endswith(".json")]
    if os.path.isdir(LAYOUT):
        targets += [os.path.join(LAYOUT, fn) for fn in os.listdir(LAYOUT) if fn.endswith(".html")]
    for fp in targets:
        try: t = open(fp, encoding="utf-8").read()
        except Exception: continue
        t2 = rx.sub(new_url, t)
        if extra_abs:
            for a_old, a_new in extra_abs: t2 = t2.replace(a_old, a_new)
        if t2 != t:
            open(fp, "w", encoding="utf-8").write(t2); n += 1
    return n

def redirect_loop(rlist, frm, to):
    """True si ajouter frm→to crée une boucle ou une chaîne qui revient sur frm."""
    seen = {frm}; cur = to
    mapping = {x.get("from"): x.get("to") for x in rlist if x.get("from")}
    mapping[frm] = to
    for _ in range(12):
        if cur in seen: return True
        seen.add(cur)
        cur = mapping.get(cur)
        if not cur: return False
    return True

def set_heading_tag(body, sid, key, new_tag):
    """Change la balise du titre qui contient le jeton {{B:sid.key}} dans le HTML source."""
    token = "{{B:%s.%s}}" % (sid, key)
    i = body.find(token)
    if i < 0: return body, False
    m = None
    for mm in re.finditer(r"<(h[1-6])\b", body[:i], re.I): m = mm
    if not m: return body, False
    tag = m.group(1).lower()
    close = body.find(f"</{tag}>", i)
    if close < 0 or tag == new_tag: return body, False
    nb = body[:m.start()] + "<" + new_tag + body[m.start() + 1 + len(tag):close] + "</" + new_tag + ">" + body[close + 3 + len(tag):]
    return nb, True

def apply_heading_tags(rel, bname, fields):
    """Applique les sélecteurs de niveau de titre (h__sec__key) : HTML source + blocs."""
    changes = [(k.split("__")[1], k.split("__")[2], v) for k, v in fields.items() if k.startswith("h__") and v in ("h1","h2","h3","h4","h5","h6")]
    if not changes: return 0
    d = load_blocks(bname); meta, body = read_page(rel); n = 0
    for sid, key, tag in changes:
        sec = next((x for x in d.get("sections", []) if x["id"] == sid), None)
        fl = next((x for x in (sec or {}).get("fields", []) if x["key"] == key), None)
        if not fl or fl.get("htag") == tag: continue
        body, ok = set_heading_tag(body, sid, key, tag)
        if ok: fl["htag"] = tag; n += 1
    if n: write_page(rel, meta, body); save_blocks(bname, d); log(f"Hn modifiés : {rel} ({n})")
    return n

def rename_page(rel, new_slug):
    """Change l'adresse (slug FR) d'une page : déplace page/blocs/traductions, réécrit les liens
    internes du site, ajoute une 301 (anti-boucle). Retourne (nouvelle_rel, changé)."""
    new_slug = "/".join(slugify(p) for p in new_slug.split("/") if p.strip())
    if not new_slug: raise ValueError("Adresse vide.")
    new_rel = new_slug + ".html"
    if new_rel == rel: return rel, False
    old_url, new_url = B.url_from_path(rel), "/" + new_slug + "/"
    if os.path.exists(os.path.join(PAGES, new_rel)): raise ValueError(f"Une page existe déjà à l'adresse {new_url}.")
    src = safe_join(PAGES, rel); dst = safe_join(PAGES, new_rel)
    os.makedirs(os.path.dirname(dst), exist_ok=True)
    shutil.move(src, dst)
    ob, nb = B.blocks_key(rel), B.blocks_key(new_rel)
    bp = os.path.join(BLOCKS, ob + ".json")
    if os.path.exists(bp):
        d = json.load(open(bp, encoding="utf-8")); d["page"] = new_rel
        json.dump(d, open(os.path.join(BLOCKS, nb + ".json"), "w", encoding="utf-8"), ensure_ascii=False, indent=1)
        os.remove(bp)
    tdir = os.path.join(ROOT, "translations")
    if os.path.isdir(tdir):
        for fn in sorted(os.listdir(tdir)):
            if fn.startswith(ob + "."):
                shutil.move(os.path.join(tdir, fn), os.path.join(tdir, nb + fn[len(ob):]))
    # liens internes (relatifs partout + absolus prod, utile pour les JSON-LD conservés)
    prod = B.CONFIG.get("SITE_URL", "").rstrip("/")
    extra = [(prod + old_url, prod + new_url)] if prod else None
    n_links = replace_internal_url(old_url, new_url, extra)
    # 301 : retire l'ancienne entrée éventuelle, redresse les chaînes, refuse les boucles
    r = load_redirects()
    r = [x for x in r if x.get("from") != old_url]
    for x in r:
        if x.get("to") == old_url: x["to"] = new_url
    if not redirect_loop(r, old_url, new_url):
        r.append({"from": old_url, "to": new_url, "code": "301"})
    json.dump(r, open(B.REDIRECTS_PATH, "w", encoding="utf-8"), ensure_ascii=False, indent=1)
    log(f"✎ Adresse changée : {old_url} → {new_url} — {n_links} fichier(s) avec liens réécrits, 301 ajoutée.")
    return new_rel, True

def create_page(fields):
    title = fields.get("title", "").strip(); slug = slugify(fields.get("slug") or title).replace("-/-", "/")
    slug = "/".join(slugify(p) for p in fields.get("slug", slug).split("/") if p) or slug
    meta = {"title": title + (B.CONFIG.get("TITLE_SUFFIX") or f" | {B.SITE_NAME}"), "description": fields.get("description", "").strip(), "priority": "0.6"}
    if fields.get("lang", "").strip(): meta["lang"] = fields["lang"].strip()
    relp = slug + ".html"
    if os.path.exists(os.path.join(PAGES, relp)): raise ValueError("Une page avec cette adresse existe déjà.")
    if fields.get("mode", "builder") == "builder" and not fields.get("copy_of", "").strip():
        write_page(relp, meta, "{{BREADCRUMB}}\n")
        sync_blocks(relp)
        log(f"✔ Page créée (constructeur) : /{slug}/"); return relp
    src = fields.get("copy_of", "").strip() if fields.get("mode") != "code" else ""
    if src:
        smeta, sbody = read_page(src)
        if "{{B:" in sbody: sbody = B.apply_blocks(sbody, src)
        for k in ("schema", "type", "body_class"):
            if k in smeta: meta[k] = smeta[k]
        write_page(relp, meta, sbody); sync_blocks(relp); log(f"✔ Page créée par copie de {src} : /{slug}/"); return relp
    content = PAGE_TPL.format(title_esc=esc(title), subtitle_esc=esc(fields.get("subtitle", "")), body=md_to_html(fields.get("body", "")))
    write_page(relp, meta, content); sync_blocks(relp); log(f"✔ Page créée : /{slug}/"); return relp

# ------------------------------------------------------------------ serveur
class Admin(BaseHTTPRequestHandler):
    def log_message(self, *a): pass
    def current_user(self):
        c = http.cookies.SimpleCookie(self.headers.get("Cookie", "")); tok = c["vfg_session"].value if "vfg_session" in c else None
        v = SESSIONS.get(tok)
        if not v: return None
        import time as _t
        if v.get("t", 0) < int(_t.time()) - SESS_TTL: SESSIONS.pop(tok, None); return None
        return find_user(v.get("e"))
    def require(self, path):
        """Retourne l'utilisateur ou envoie une redirection/erreur. None = stop."""
        global CURRENT_USER
        u = self.current_user()
        if not u: self.redirect("/login"); return None
        CURRENT_USER = {k: v for k, v in u.items() if k not in ("salt", "hash")}
        if not allowed(path, role_of(u)):
            self.send_html(layout("Accès refusé", '<div class="msg err">Cette action n\'est pas disponible avec votre niveau de compte.</div><p><a href="/">← Retour</a></p>'), 403); return None
        return u
    def send_html(self, s, code=200):
        b = s.encode("utf-8"); self.send_response(code); self.send_header("Content-Type", "text/html; charset=utf-8"); self.send_header("Content-Length", str(len(b))); self.end_headers(); self.wfile.write(b)
    def redirect(self, to):
        if "?" in to:
            path, qs = to.split("?", 1); to = path + "?" + "&".join(k + "=" + quote(v, safe="/:,;.") for k, v in (kv.split("=", 1) if "=" in kv else (kv, "") for kv in qs.split("&")))
        self.send_response(303); self.send_header("Location", to); self.end_headers()
    def msg(self, text, err=False): return f'<div class="msg{" err" if err else ""}">{esc(text)}</div>'
    def blocks_sync_all(self):
        np_, nf_ = 0, 0
        for pg in list_pages():
            rel = pg["file"]
            if not os.path.exists(os.path.join(BLOCKS, blocks_name_for(rel) + ".json")): continue
            try:
                nf, ns = sync_blocks(rel); np_ += 1; nf_ += nf
            except Exception as e: log(f"↻ Resync {rel} : erreur {e}")
        log(f"↻ Blocs resynchronisés sur tout le site : {np_} pages, {nf_} champs")
        return self.redirect(f"/translations?m=Blocs resynchronisés : {np_} page(s), {nf_} champs. Les nouveaux éléments détectés apparaissent « à mettre à jour » — cliquez « Tout traduire ».")
    def do_GET(self):
        u = urlparse(self.path); q = {k: v[0] for k, v in parse_qs(u.query).items()}; p = u.path
        if p == "/login": return self.send_html(page_login())
        if p == "/forgot" and ONLINE: return self.send_html(page_forgot())
        if p == "/reset" and ONLINE: return self.send_html(page_reset(q.get("e", ""), q.get("t", "")))
        if p == "/favicon.ico" or p.startswith("/assets/"):
            # Fichiers statiques du site (logo de l'écran de connexion, aperçus d'images) — publics, lecture seule.
            if p == "/favicon.ico":
                rel = next((c for c in ("root/favicon.ico", "assets/img/favicon.svg", "assets/favicon.ico", "assets/img/favicon.ico")
                            if os.path.isfile(os.path.join(ROOT, *c.split("/")))), "assets/img/favicon.svg")
            else:
                rel = unquote(p.lstrip("/"))
            try: fp = safe_join(ROOT, *[x for x in rel.split("/") if x and x != ".."])
            except Exception: return self.send_html("<h1>404</h1>", 404)
            if not os.path.isfile(fp): return self.send_html("<h1>404</h1>", 404)
            import mimetypes
            ctype = mimetypes.guess_type(fp)[0] or "application/octet-stream"
            data = open(fp, "rb").read()
            self.send_response(200); self.send_header("Content-Type", ctype); self.send_header("Cache-Control", "max-age=300"); self.send_header("Content-Length", str(len(data))); self.end_headers(); self.wfile.write(data); return
        if p == "/apercu" or p.startswith("/apercu/"):
            if not self.require(p): return
            rel = unquote(p[len("/apercu"):].lstrip("/")) or ""
            fp = safe_join(DIST, *([x for x in rel.split("/") if x] or [""]))
            if os.path.isdir(fp): fp = os.path.join(fp, "index.html")
            if not os.path.isfile(fp): return self.send_html("<h1>Fichier absent de l'aperçu — cliquez « Régénérer ».</h1>", 404)
            import mimetypes
            ctype = mimetypes.guess_type(fp)[0] or "application/octet-stream"
            data = open(fp, "rb").read()
            if ctype == "text/html":
                # réécrit les liens racine vers /apercu/ pour naviguer dans l'aperçu authentifié
                txt = data.decode("utf-8", "replace")
                txt = re.sub(r'((?:href|src|action)=")/(?!apercu/|/)', r'\1/apercu/', txt)
                data = txt.encode("utf-8"); ctype = "text/html; charset=utf-8"
            self.send_response(200); self.send_header("Content-Type", ctype); self.send_header("Cache-Control", "no-store"); self.send_header("Content-Length", str(len(data))); self.end_headers(); self.wfile.write(data); return
        if p == "/logout":
            c = http.cookies.SimpleCookie(self.headers.get("Cookie", ""))
            if "vfg_session" in c: SESSIONS.pop(c["vfg_session"].value, None); save_sessions(SESSIONS)
            self.send_response(303); self.send_header("Set-Cookie", "vfg_session=; Path=/; Max-Age=0"); self.send_header("Location", "/login"); self.end_headers(); return
        if not self.require(p): return
        try:
            if p == "/": return self.send_html(page_dashboard(self.msg(q["m"]) if "m" in q else "", q))
            if p == "/users": return self.send_html(page_users(self.msg(q["m"]) if "m" in q else ""))
            if p == "/profile": return self.send_html(page_profile(self.msg(q["m"]) if "m" in q else ""))
            if p == "/user-del":
                users = [x for x in load_users() if x["email"].lower() != q.get("email", "").lower()]
                if not any(x["role"] == "admin" for x in users): return self.redirect("/users?m=Impossible : il faut au moins un administrateur.")
                save_users(users); log(f"Compte supprimé : {q.get('email')}"); return self.redirect("/users?m=Compte supprimé.")
            if p == "/pages": return self.send_html(page_pages(self.msg(q["m"]) if "m" in q else ""))
            if p == "/edit": return self.send_html(page_edit(q["f"], self.msg(q["m"]) if "m" in q else ""))
            if p == "/blocks": return self.redirect("/edit?f=" + q["f"].replace("__", "/") + ".html") if "f" in q and not q["f"].startswith("_") else self.redirect("/pages")
            if p == "/articles": return self.send_html(page_articles(self.msg(q["m"]) if "m" in q else ""))
            if p == "/library": return self.send_html(page_library(self.msg(q["m"]) if "m" in q else ""))
            if p == "/model-new": return self.send_html(page_model_new(q["f"], q["sec"]))
            if p == "/model-del":
                mm = load_models(); mm["models"] = [x for x in mm["models"] if x["id"] != q.get("id")]; save_models(mm)
                return self.redirect("/library?m=Modèle supprimé.")
            if p == "/section-dup":
                nid_ = section_duplicate(q["f"], q["sec"]); log(f"⧉ Section dupliquée : {q['f']} {q['sec']} → {nid_}")
                return self.redirect(f"/edit?f={quote(q['f'])}&m=Section dupliquée (en dessous de l'originale). Modifiez ses textes puis Enregistrer + régénérer.#sec-{nid_}")
            if p == "/section-del":
                section_delete(q["f"], q["sec"]); log(f"✕ Section supprimée : {q['f']} {q['sec']}")
                return self.redirect(f"/edit?f={quote(q['f'])}&m=Section supprimée. Régénérez pour voir le résultat.")
            if p == "/menu":
                if not os.path.exists(os.path.join(BLOCKS, "_menu.json")) and os.path.isdir(LAYOUT): return self.send_html(page_layout(self.msg(q["m"]) if "m" in q else ""))
                return self.send_html(page_site_blocks("_menu", self.msg(q["m"]) if "m" in q else ""))
            if p == "/translations": return self.send_html(page_translations(self.msg(q["m"]) if "m" in q else ""))
            if p == "/popup": return self.send_html(page_site_blocks("_popup", self.msg(q["m"]) if "m" in q else ""))
            if p == "/blocks-sync":
                nf, ns = sync_blocks(q["f"]); log(f"↻ Blocs resynchronisés : {q['f']} ({nf} champs)"); return self.redirect(f"/edit?f={q['f']}&m=Blocs reconstruits : {ns} sections, {nf} champs.")
            if p == "/blocks-sync-all": return self.blocks_sync_all()
            if p == "/new-article": return self.send_html(page_new_article())
            if p == "/new-page": return self.send_html(page_new_page())
            if p == "/images": return self.send_html(page_images(self.msg(q["m"]) if "m" in q else ""))
            if p == "/redirects": return self.send_html(page_redirects())
            if p == "/redirect-export":
                rows = "".join(f'{x.get("from","")};{x.get("to","")};{x.get("code","301")}\n' for x in load_redirects())
                csv = "# Plan de redirections — " + B.SITE_NAME + " — exporté le " + datetime.date.today().isoformat() + "\n# format : ancienne;nouvelle;type (301/302/410) — réimportable tel quel\n" + rows
                data = csv.encode("utf-8")
                self.send_response(200)
                self.send_header("Content-Type", "text/csv; charset=utf-8")
                self.send_header("Content-Disposition", f'attachment; filename="redirections-{slugify(B.SITE_NAME)}.csv"')
                self.send_header("Content-Length", str(len(data)))
                self.end_headers(); self.wfile.write(data); return
            if p == "/settings":
                if role_of(CURRENT_USER) != "admin": return self.redirect("/seo?m=Les réglages généraux sont réservés aux administrateurs — vos réglages SEO sont ici.")
                return self.send_html(page_settings(self.msg(q["m"]) if "m" in q else ""))
            if p == "/seo": return self.send_html(page_seo(self.msg(q["m"]) if "m" in q else ""))
            if p == "/help": return self.send_html(page_help())
            if p == "/delete":
                f = q["f"]; src = safe_join(PAGES, f); os.makedirs(TRASH, exist_ok=True)
                shutil.move(src, os.path.join(TRASH, f.replace("/", "__") + f".{datetime.datetime.now():%Y%m%d%H%M%S}")); log(f"Page mise à la corbeille : {f}")
                return self.redirect("/pages?m=" + "Page déplacée dans _corbeille/. Pensez à ajouter une redirection puis à régénérer.")
            if p == "/redirect-del":
                r = load_redirects(); i = int(q["i"]);
                if 0 <= i < len(r): r.pop(i); json.dump(r, open(B.REDIRECTS_PATH, "w", encoding="utf-8"), ensure_ascii=False, indent=1)
                return self.redirect("/redirects")
            if p == "/export":
                buf = io.BytesIO()
                with zipfile.ZipFile(buf, "w", zipfile.ZIP_DEFLATED) as z:
                    for dp, dn, fns in os.walk(DIST):
                        for fn in fns:
                            if fn in (".htpasswd", "demandes.log"): continue   # jamais dans un zip qui circule
                            full = os.path.join(dp, fn); z.write(full, os.path.relpath(full, DIST))
                b = buf.getvalue(); self.send_response(200); self.send_header("Content-Type", "application/zip"); self.send_header("Content-Disposition", 'attachment; filename="votre-fiche-google_dist.zip"'); self.send_header("Content-Length", str(len(b))); self.end_headers(); self.wfile.write(b); return
            self.send_html("<h1>404</h1>", 404)
        except Exception as e:
            log("✘ Erreur serveur : " + traceback.format_exc().strip().splitlines()[-1])
            detail = f'<pre>{esc(traceback.format_exc())}</pre>' if not ONLINE else '<p class="help">Le détail technique est dans le journal du tableau de bord.</p>'
            self.send_html(layout("Erreur", f'<div class="msg err">Une erreur est survenue.</div>{detail}'), 500)
    def do_POST(self):
        u = urlparse(self.path); p = u.path; length = int(self.headers.get("Content-Length", 0)); raw = self.rfile.read(length)
        if ONLINE:
            host = (self.headers.get("Host") or "").split(":")[0]
            src = self.headers.get("Origin") or self.headers.get("Referer") or ""
            m = re.match(r"https?://([^/:]+)", src)
            if not m or m.group(1) != host:
                return self.send_html("<h1>Requête refusée (origine invalide).</h1>", 403)
        if p == "/login":
            f = {k: v[0] for k, v in parse_qs(raw.decode("utf-8"), keep_blank_values=True).items()}
            if login_locked(f.get("email", "")):
                return self.send_html(page_login('<div class="msg err">Trop de tentatives : compte verrouillé 15 minutes. Réessayez plus tard ou utilisez « Mot de passe oublié ».</div>'), 429)
            usr = find_user(f.get("email", ""))
            if usr and check_pw(usr, f.get("password", "")):
                login_clear(f.get("email", ""))
                import time as _t
                tok = secrets.token_urlsafe(32); SESSIONS[tok] = {"e": usr["email"], "t": int(_t.time())}; save_sessions(SESSIONS); log(f"Connexion : {usr['email']}")
                self.send_response(303); self.send_header("Set-Cookie", f"vfg_session={tok}; Path=/; Max-Age={SESS_TTL}; HttpOnly; SameSite=Strict" + ("; Secure" if ONLINE else "")); self.send_header("Location", "/"); self.end_headers(); return
            login_fail(f.get("email", ""))
            import time; time.sleep(1.2); return self.send_html(page_login('<div class="msg err">E-mail ou mot de passe incorrect.</div>'), 401)
        if p == "/forgot" and ONLINE:
            f = {k: v[0] for k, v in parse_qs(raw.decode("utf-8"), keep_blank_values=True).items()}
            email = f.get("email", "").strip()
            if find_user(email):
                tok = reset_token_for(email)
                host = self.headers.get("Host") or ""
                send_reset_mail(email, f"https://{host}/reset?e={quote(email)}&t={quote(tok)}")
                log(f"🔑 Demande de réinitialisation : {email}")
            import time; time.sleep(.8)
            return self.send_html(page_forgot('<div class="msg">Si un compte existe pour cette adresse, un e-mail vient de partir (regardez aussi les indésirables).</div>'))
        if p == "/reset" and ONLINE:
            f = {k: v[0] for k, v in parse_qs(raw.decode("utf-8"), keep_blank_values=True).items()}
            email, tok = f.get("email", ""), f.get("token", "")
            if f.get("new") != f.get("new2") or len(f.get("new", "")) < 12:
                return self.send_html(page_reset(email, tok, '<div class="msg err">Les deux mots de passe doivent être identiques (12 caractères minimum).</div>'))
            if not reset_consume(email, tok):
                return self.send_html(page_reset(email, tok, '<div class="msg err">Lien expiré ou invalide : refaites une demande depuis « Mot de passe oublié ».</div>'))
            usr = find_user(email); upsert_user(email, f["new"], usr["role"]); login_clear(email); log(f"🔑 Mot de passe réinitialisé : {email}")
            return self.send_html(page_login('<div class="msg">Mot de passe changé : connectez-vous.</div>'))
        if not self.require(p): return
        try:
            if self.headers.get("Content-Type", "").startswith("multipart/form-data"): fields, files = parse_multipart(self.headers, raw)
            else: fields = {k: v[0] for k, v in parse_qs(raw.decode("utf-8"), keep_blank_values=True).items()}; files = []
            if p == "/build":
                ok, out = do_build(); return self.redirect("/?m=" + ("Site régénéré : " + out if ok else "Erreur : " + out[-300:]))
            if p == "/blocks-sync-all": return self.blocks_sync_all()
            if p == "/test-mail":
                cfg = B.CONFIG
                to = [a.strip() for a in (cfg.get("FORM_TO") or "").split(",") if a.strip()]
                if not to:
                    return self.redirect("/?m=Test impossible : aucune adresse de réception (Réglages › Formulaires › « Adresse(s) qui reçoivent les demandes »).")
                if cfg.get("FORM_MODE") == "web3forms":
                    return self.redirect("/?m=Mode Web3Forms : le test se fait en envoyant le formulaire depuis la préprod (l'envoi ne passe pas par ce serveur).")
                host = (cfg.get("SMTP_HOST") or "").strip()
                if not host:
                    return self.redirect("/?m=SMTP non renseigné (Réglages › Formulaires) : les e-mails partiront via la fonction mail() de PHP — testable uniquement en envoyant le formulaire depuis la préprod. Pour un test d'ici, renseignez le SMTP.")
                try:
                    import smtplib
                    from email.mime.text import MIMEText
                    from email.utils import formataddr
                    port = int(cfg.get("SMTP_PORT") or 465)
                    frm = (cfg.get("FORM_FROM") or cfg.get("SMTP_USER") or "").strip()
                    body_txt = ("Ceci est un e-mail de TEST envoyé depuis le back-office de " + B.SITE_NAME +
                                " (" + datetime.datetime.now().strftime("%d/%m/%Y %H:%M") + ").\n\n"
                                "Si vous le recevez, la chaîne SMTP des formulaires fonctionne : serveur " + host +
                                ", expéditeur " + frm + ", destinataire(s) " + ", ".join(to) + ".\n\n— Test déclenché par " +
                                (CURRENT_USER.get("email") or "un administrateur") + " depuis le tableau de bord.")
                    m = MIMEText(body_txt, "plain", "utf-8")
                    m["Subject"] = "✔ Test formulaire — " + B.SITE_NAME
                    m["From"] = formataddr((cfg.get("FORM_FROM_NAME") or B.SITE_NAME, frm))
                    m["To"] = ", ".join(to)
                    if port == 465:
                        srv = smtplib.SMTP_SSL(host, port, timeout=12)
                    else:
                        srv = smtplib.SMTP(host, port, timeout=12); srv.starttls()
                    if cfg.get("SMTP_USER"): srv.login(cfg["SMTP_USER"], cfg.get("SMTP_PASS", ""))
                    srv.sendmail(frm, to, m.as_string()); srv.quit()
                    log("✉ E-mail de test envoyé à " + ", ".join(to))
                    return self.redirect("/?m=E-mail de test envoyé à " + ", ".join(to) + " — vérifiez la boîte (et les indésirables).")
                except Exception as e:
                    log("✘ E-mail de test : " + str(e))
                    return self.redirect("/?m=Échec de l'envoi : " + str(e)[:160] + " — vérifiez serveur, port, identifiant et mot de passe SMTP dans Réglages › Formulaires.")
            if p == "/publish":
                if fields.get("target") == "prod" and not B.LICENCE_OK:
                    log("🔐 Publication production refusée : " + B.LICENCE_MSG)
                    return self.redirect("/?m=Publication en production refusée — " + B.LICENCE_MSG)
                ok, out = do_publish(fields.get("target", "preprod")); return self.redirect("/?m=" + out)
            if p == "/save":
                f = fields["f"]; meta = {k[2:]: v.strip() for k, v in fields.items() if k.startswith("m_")}
                if meta.get("draft") == "false": meta.pop("draft", None)
                for k in list(meta):
                    if meta[k] == "" and k in ("lang", "translations", "og_image", "breadcrumb", "bc_label", "og_title", "og_description", "canonical", "noindex"): meta.pop(k)
                slug_msg = ""
                if fields.get("art_theme") and fields.get("art_slug"):
                    fields["new_slug"] = f"{B.BLOG_PREFIX}{fields['art_theme']}/{fields['art_slug']}"
                    # le fil d'Ariane est automatique (parenté de l'URL) : rien d'autre à recalculer
                if fields.get("new_slug") is not None and f != "index.html":
                    try:
                        nf, changed = rename_page(f, fields["new_slug"])
                        if changed:
                            if fields.get("name") == B.blocks_key(f): fields["name"] = B.blocks_key(nf)
                            slug_msg = f" Adresse changée → {B.url_from_path(nf)} (301 automatique depuis l'ancienne)."
                            f = nf
                    except ValueError as e:
                        return self.redirect(f"/edit?f={f}&m=Adresse non changée : {e}")
                write_page(f, meta, fields.get("body", "")); log(f"✔ Enregistré : {f}")
                if fields.get("name") and os.path.exists(safe_join(BLOCKS, fields["name"] + ".json")):
                    save_blocks_form(fields)
                    apply_heading_tags(f, fields["name"], fields)
                    save_section_opts(f, fields["name"], fields)
                    if fields.get("sec_order"):
                        try: section_reorder(f, [x for x in fields["sec_order"].split(",") if x])
                        except Exception as e: log(f"⚠ Réordonnancement impossible : {e}")
                if fields.get("then") == "build": ok, out = do_build(); return self.redirect(f"/edit?f={f}&m=" + ("Enregistré et régénéré." + slug_msg + " " + out if ok else "Enregistré, mais erreur de génération : " + out[-300:]))
                return self.redirect(f"/edit?f={f}&m=Enregistré.{slug_msg} Cliquez « Régénérer » pour voir le résultat.")
            if p == "/blocks-save":
                d = save_blocks_form(fields); log(f"✔ Blocs enregistrés : {fields['name']}"); back = fields.get("back") or "/pages"
                if fields.get("then") == "build": ok, out = do_build(); return self.redirect(f"{back}?m=" + ("Enregistré et régénéré. " + out if ok else "Enregistré, mais erreur de génération : " + out[-300:]))
                return self.redirect(f"{back}?m=Enregistré. Cliquez « Régénérer » pour voir le résultat.")
            if p == "/articles-import":
                res = import_articles([(n, fn, d) for n, fn, d in files if n == "lots"], auto_cat=bool(fields.get("autocat")))
                n_ok = sum(1 for _, ok, _ in res if ok)
                if n_ok: do_build()
                rows = "".join(f'<tr><td><code style="font-size:.76rem">{esc(f)}</code></td><td>{"✔" if ok else "✘"}</td><td>{m}</td></tr>' for f, ok, m in res)
                log(f"📥 Import d'articles : {n_ok}/{len(res)} créé(s)")
                rep = (f'<div class="card"><h2 style="margin-top:0">📥 Résultat de l\'import — {n_ok} article(s) créé(s) sur {len(res)}</h2>'
                       f'<table><tr><th>Fichier</th><th></th><th>Détail</th></tr>{rows}</table>'
                       + ('<p class="help">Site régénéré : vérifiez les articles dans l\'aperçu puis publiez.</p>' if n_ok else "") + '</div>')
                return self.send_html(page_articles(rep))
            if p == "/create-article":
                relp = create_article(fields, files); do_build(); return self.redirect(f"/edit?f={relp}&m=Article créé et site régénéré. Vous pouvez encore l'ajuster ici.")
            if p == "/create-page":
                relp = create_page(fields); do_build(); return self.redirect(f"/edit?f={relp}&m=Page créée et site régénéré.")
            if p == "/upload":
                paths = [save_image(data, fields.get("name") or fn) for name, fn, data in files if name == "image" and data]
                log(f"✔ {len(paths)} image(s) ajoutée(s)"); do_build(); return self.redirect("/images?m=" + f"{len(paths)} image(s) ajoutée(s) : " + ", ".join(paths))
            if p == "/navbar-save":
                nv = {k: fields.get(k, "").strip() for k in ("logo", "logo_height", "bg", "color", "accent", "links", "tel_label", "cta_label", "cta_url", "account_label", "account_url")}
                nv["enabled"] = "1" if fields.get("enabled") else "0"
                nv["sticky"] = "1" if fields.get("sticky") else "0"
                nv["tel"] = "1" if fields.get("tel") else "0"
                os.makedirs(os.path.dirname(NAVBAR_PATH), exist_ok=True)
                json.dump(nv, open(NAVBAR_PATH, "w", encoding="utf-8"), ensure_ascii=False, indent=1)
                os.makedirs(LAYOUT, exist_ok=True)
                hp, orig = os.path.join(LAYOUT, "header.html"), os.path.join(LAYOUT, "header-original.html")
                if nv["enabled"] == "1":
                    if os.path.exists(hp) and not os.path.exists(orig): shutil.copy2(hp, orig)   # sauvegarde unique de l'en-tête importé
                    open(hp, "w", encoding="utf-8").write(nav_header_html(nv))
                    log("🧱 Menu paramétrable appliqué (en-tête générée)"); do_build()
                    warn = " Pensez à relancer « Traduire l'habillage » pour les autres langues." if [c for c, _ in B.LANGS if c != B.DEFAULT_LANG] else ""
                    return self.redirect("/menu?m=Menu appliqué et site régénéré." + warn)
                else:
                    if os.path.exists(orig): shutil.copy2(orig, hp); log("🧱 Menu paramétrable désactivé : en-tête d'origine restauré"); do_build()
                    return self.redirect("/menu?m=Constructeur désactivé : l'en-tête importé d'origine est restauré. Site régénéré.")
            if p == "/layout-save":
                os.makedirs(LAYOUT, exist_ok=True)
                for fn in fields:
                    if re.fullmatch(r"(header|header-home|footer|head|scripts)(\.[a-z]{2,3})?\.html", fn):
                        v = fields[fn].replace("\r\n", "\n")
                        fp = os.path.join(LAYOUT, fn)
                        if v.strip() or os.path.exists(fp): open(fp, "w", encoding="utf-8").write(v)
                if fields.get("mk_home_header"):
                    src_h = os.path.join(LAYOUT, "header.html"); dst_h = os.path.join(LAYOUT, "header-home.html")
                    if os.path.exists(src_h) and not os.path.exists(dst_h): shutil.copy2(src_h, dst_h)
                    log("✔ En-tête d'accueil créé (copie de l'en-tête commun)")
                    return self.redirect("/menu?m=En-tête d'accueil créé : modifiez-le ci-dessous puis Enregistrer + régénérer.")
                if fields.get("del_home_header"):
                    for fn in os.listdir(LAYOUT):
                        if fn == "header-home.html" or re.fullmatch(r"header-home\.[a-z]{2,3}\.html", fn): os.remove(os.path.join(LAYOUT, fn))
                    log("✔ En-tête d'accueil supprimé"); do_build()
                    return self.redirect("/menu?m=Variante supprimée : l'accueil reprend l'en-tête commun. Site régénéré.")
                log("✔ Habillage (layout/) enregistré")
                if fields.get("then") == "build": ok, out = do_build(); return self.redirect("/menu?m=" + ("Enregistré et régénéré. " + out if ok else "Erreur : " + out[-300:]))
                return self.redirect("/menu?m=Enregistré. Cliquez « Régénérer ».")
            if p == "/model-save":
                mid = model_from_section(fields["f"], fields["sec"], fields.get("name", "Modèle"), fields.get("family", ""))
                log(f"☆ Modèle enregistré : {mid}")
                return self.redirect(f"/edit?f={quote(fields['f'])}&m=Modèle « {fields.get('name','')} » ajouté à la bibliothèque : il apparaît maintenant dans « Ajouter une section » sur toutes les pages.")
            if p == "/section-add":
                nid_ = section_add_from_model(fields["f"], fields["model"], fields.get("after", ""))
                log(f"＋ Section ajoutée : {fields['f']} ← {fields['model']}")
                return self.redirect(f"/edit?f={quote(fields['f'])}&m=Section ajoutée : personnalisez ses textes puis Enregistrer + régénérer.#sec-{nid_}")
            if p == "/layout-translate":
                back = fields.get("back") or "/menu"
                try:
                    n = layout_translate(fields["lang"]); log(f"🌐 Habillage traduit ({fields['lang']}) : {n} fichier(s)")
                    return self.redirect(back + "?m=Habillage traduit en " + fields["lang"].upper() + " : relisible dans « Menu & pied de page », puis Régénérer.")
                except Exception as e:
                    return self.redirect(back + "?m=Erreur de traduction : " + str(e)[:300])
            if p == "/translate":
                try:
                    m = do_translate(fields["name"], fields["lang"], fields.get("rel")); log(f"🌐 Traduction {fields['lang']} : {fields['name']} — {m}")
                    return self.redirect("/translations?m=" + m + " Cliquez « Régénérer » pour voir le résultat.")
                except Exception as e:
                    return self.redirect("/translations?m=Erreur de traduction : " + str(e)[:300])
            if p == "/translate-all":
                # Page de progression : le travail se fait par PETITES requêtes /translate-batch
                # (~10 s chacune), relancées et ré-essayées automatiquement par la page.
                lang = fields["lang"]
                return self.send_html(f"""<!DOCTYPE html><html lang="fr"><head><meta charset="utf-8"><title>Traduction en cours…</title><meta name="viewport" content="width=device-width,initial-scale=1"><style>{CSS}
body{{display:flex;align-items:center;justify-content:center;min-height:100vh;background:var(--soft)}}</style></head>
<body><div class="card" style="text-align:center;max-width:480px"><h2 style="margin-top:0">Traduction {esc(lang.upper())} en cours…</h2>
<p id="st">Préparation…</p><p class="help">Ne fermez pas cet onglet. En cas d'interruption, rien n'est perdu : relancez, la traduction reprend où elle en était.</p></div>
<script>
var done=0,errs=0,last="",fails=0;
function step(){{
  fetch("/translate-batch",{{method:"POST",headers:{{"Content-Type":"application/x-www-form-urlencoded"}},body:"lang="+encodeURIComponent({json.dumps(lang)})}})
  .then(function(r){{if(!r.ok)throw new Error("HTTP "+r.status);return r.json()}})
  .then(function(j){{
    fails=0; done+=j.done; errs+=j.errs; if(j.last)last=j.last;
    document.getElementById("st").innerHTML="<b>"+done+"</b> élément(s) traduit(s)"+(j.remaining? " — "+j.remaining+" restant(s)…":"")+(errs? " · "+errs+" erreur(s)":"");
    if(j.remaining>0){{setTimeout(step,300);return}}
    var m=done+" élément(s) traduit(s)"+(errs? ", "+errs+" erreur(s) — dernière : "+last.slice(0,180):" — tout est à jour.");
    window.location="/translations?m="+encodeURIComponent(m);
  }})
  .catch(function(e){{
    fails++;
    if(fails>6){{document.getElementById("st").innerHTML="Interruption réseau répétée ("+e+"). <a href=\\"/translations\\">Retour</a> — recliquez « Tout traduire », la traduction reprendra où elle en était.";return}}
    document.getElementById("st").textContent="Petite coupure ("+e+") — nouvelle tentative dans 3 s… ("+fails+"/6)";
    setTimeout(step,3000);
  }});
}}
step();
</script></body></html>""")
            if p == "/translate-batch":
                # Un lot : ~10 s de traduction maximum, réponse JSON. Idempotent (reprend où c'était).
                lang = fields["lang"]; done = errs = 0; last = ""
                import time as _t2; t0 = _t2.time()
                T = _tr_mod()
                if os.path.exists(os.path.join(B.BLOCKS_DIR, "_menu.json")):
                    try:
                        menu = json.load(open(os.path.join(B.BLOCKS_DIR, "_menu.json"), encoding="utf-8"))
                        mu = T.page_units({}, menu); mtr = T.load("_menu", lang)
                        if T.status(mu, mtr)[1:] != (0, 0):
                            do_translate("_menu", lang); done += 1
                    except Exception as e: errs += 1; last = str(e)
                elif os.path.isdir(LAYOUT) and not os.path.exists(os.path.join(LAYOUT, f"header.{lang}.html")):
                    try:
                        layout_translate(lang); done += 1
                    except Exception as e: errs += 1; last = str(e)
                remaining = 0
                for pg in list_pages():
                    if pg.get("draft"): continue
                    rel = pg["file"]
                    try:
                        bname, units, hb = tr_units_for(rel)
                        tr = T.load(bname, lang); t, m, st = T.status(units, tr)
                        if m == 0 and st == 0 and (tr.get("path") is not None or not t): continue
                        if _t2.time() - t0 > 10: remaining += 1; continue
                        do_translate(bname, lang, rel); done += 1
                    except Exception as e:
                        errs += 1; last = str(e)
                if remaining == 0 and errs == 0:
                    log(f"🌐 Tout traduire ({lang}) : terminé — régénération"); do_build()
                elif done or errs:
                    log(f"🌐 Tout traduire ({lang}) : lot de {done}, {errs} erreur(s), {remaining} restant(s)")
                body_json = json.dumps({"done": done, "errs": errs, "remaining": remaining, "last": last[:300], "finished": remaining == 0}).encode("utf-8")
                self.send_response(200); self.send_header("Content-Type", "application/json; charset=utf-8"); self.send_header("Content-Length", str(len(body_json))); self.end_headers(); self.wfile.write(body_json); return
            if p == "/trans-slug":
                import translate as T
                tr = T.load(fields["name"], fields["lang"])
                tr["path"] = "/".join(slugify(x) for x in fields.get("path", "").split("/") if x.strip())
                T.save(fields["name"], fields["lang"], tr)
                return self.redirect("/translations?m=Slug enregistré. Régénérez pour appliquer.")
            if p == "/alt-ia":
                try:
                    done, remaining, details = generate_missing_alts(25)
                except ValueError as e:
                    return self.send_html(page_images(self.msg(str(e), True)))
                rows = "".join(f'<tr><td><img src="{esc(i)}" style="height:44px;border-radius:6px"></td><td><code style="font-size:.72rem">{esc(i)}</code></td><td>{esc(a)}</td></tr>' for i, a in details)
                tbl = (f'<p><b>{done} texte(s) alternatif(s) générés</b>' + (f' — {remaining} restant(s) : cliquez à nouveau.' if remaining else ' — plus aucun manquant ✔') + '</p>'
                       f'<table><tr><th></th><th>Image</th><th>ALT généré (relisible dans chaque page)</th></tr>{rows}</table>') if details else "<p>Aucun champ alt vide à remplir.</p>"
                log(f"🖼 ALT générés par IA : {done} (restants : {remaining})"); do_build()
                return self.send_html(page_images(f'<div class="card"><h2 style="margin-top:0;font-size:1rem">🖼 Résultat de la génération</h2>{tbl}</div>'))
            if p == "/optimize":
                res = optimize_images(int(fields.get("min_kb") or 150), int(fields.get("quality") or 80), int(fields.get("max_w") or 1600))
                if res is None: return self.send_html(page_images(self.msg("Pillow n'est pas installé : dans le Terminal, tapez  pip3 install pillow  puis relancez le back-office. Sinon utilisez iloveimg.com.", True)))
                tot_b = sum(r[1] for r in res); tot_a = sum(r[2] for r in res)
                rows = "".join(f'<tr><td>{esc(r[0])}</td><td>{r[1]//1024} Ko</td><td>{r[2]//1024} Ko</td><td>{esc(r[3])}</td></tr>' for r in res)
                tbl = f'<p><b>{len(res)} image(s) traitée(s)</b> — {tot_b//1024} Ko → {tot_a//1024} Ko (−{(100 - tot_a*100//tot_b) if tot_b else 0} %).</p><table><tr><th>Image</th><th>Avant</th><th>Après</th><th>Note</th></tr>{rows}</table>' if res else "<p>Aucune image au-dessus du seuil.</p>"
                log(f"🗜️ Images optimisées : {len(res)}"); do_build(); return self.send_html(page_images("", tbl))
            if p == "/theme-add":
                try: slug = create_theme(fields.get("label", ""))
                except ValueError as e: return self.send_html(page_articles(self.msg(str(e), True)))
                return self.redirect(f"/articles?m=Catégorie créée : /{B.BLOG_PREFIX}{slug}/ — sa page hub est modifiable dans « Pages ». Régénérez puis publiez.")
            if p == "/theme-del":
                try: delete_theme(fields.get("slug", ""))
                except ValueError as e: return self.send_html(page_articles(self.msg(str(e), True)))
                return self.redirect("/articles?m=Catégorie supprimée. Pensez à ajouter une redirection si sa page hub était publiée. Régénérez puis publiez.")
            if p == "/redirect-add":
                code = fields.get("code", "301")
                if code != "410" and not fields.get("to", "").strip(): return self.redirect("/redirects?m=Indiquez une destination (ou choisissez le type 410).")
                frm, to = fields["from"].strip(), fields.get("to", "").strip()
                r = load_redirects()
                if code != "410" and (frm == to or redirect_loop(r, frm, to)):
                    return self.redirect("/redirects?m=Refusé : cette redirection créerait une boucle (" + frm + " ↔ " + to + ").")
                r.append({"from": frm, "to": to, "code": code}); json.dump(r, open(B.REDIRECTS_PATH, "w", encoding="utf-8"), ensure_ascii=False, indent=1); return self.redirect("/redirects?m=Redirection ajoutée. Régénérez puis publiez.")
            if p == "/redirect-import":
                r = load_redirects(); added = skipped = 0; existing = {x.get("from") for x in r}
                for line in (fields.get("csv") or "").splitlines():
                    line = line.strip().lstrip("\ufeff")
                    if not line or line.startswith("#"): continue
                    parts = [x.strip().strip('"') for x in re.split(r"[;,\t]", line)]
                    if not parts or not parts[0]: continue
                    frm = parts[0]; to = parts[1] if len(parts) > 1 else ""; code = (parts[2] if len(parts) > 2 and parts[2] else "301")
                    if code not in ("301", "302", "410"): code = "301"
                    if not frm.startswith("/"): frm = "/" + frm
                    if to and not to.startswith(("/", "http")): to = "/" + to
                    if (code != "410" and not to) or frm in existing or frm == to or (code != "410" and redirect_loop(r, frm, to)):
                        skipped += 1; continue
                    r.append({"from": frm, "to": to, "code": code}); existing.add(frm); added += 1
                json.dump(r, open(B.REDIRECTS_PATH, "w", encoding="utf-8"), ensure_ascii=False, indent=1)
                log(f"↪ Import redirections : {added} ajoutée(s), {skipped} ignorée(s)")
                return self.redirect(f"/redirects?m={added} redirection(s) importée(s), {skipped} ignorée(s) (doublons, boucles ou lignes invalides). Régénérez puis publiez.")
            if p == "/redirect-code":
                r = load_redirects(); i = int(fields["i"])
                if 0 <= i < len(r): r[i]["code"] = fields.get("code", "301"); json.dump(r, open(B.REDIRECTS_PATH, "w", encoding="utf-8"), ensure_ascii=False, indent=1)
                return self.redirect("/redirects?m=Type modifié. Régénérez puis publiez.")
            if p == "/users":
                if len(fields.get("password", "")) < 12: return self.redirect("/users?m=Mot de passe trop court (12 caractères minimum).")
                upsert_user(fields["email"], fields["password"], fields.get("role", "editeur"), fields.get("name", "")); log(f"Compte enregistré : {fields['email']}"); return self.redirect("/users?m=Compte enregistré.")
            if p == "/profile-name":
                users = load_users()
                for x in users:
                    if x["email"].lower() == CURRENT_USER.get("email", "").lower():
                        x["name"] = fields.get("name", "").strip(); CURRENT_USER["name"] = x["name"]
                save_users(users); return self.redirect("/profile?m=Profil enregistré.")
            if p == "/profile":
                usr = find_user(CURRENT_USER["email"])
                if not check_pw(usr, fields.get("old", "")): return self.redirect("/profile?m=Mot de passe actuel incorrect.")
                if fields.get("new") != fields.get("new2") or len(fields.get("new", "")) < 12: return self.redirect("/profile?m=Les deux mots de passe doivent être identiques (12 caractères min.).")
                upsert_user(usr["email"], fields["new"], usr["role"]); log("Mot de passe modifié"); return self.redirect("/profile?m=Mot de passe modifié.")
            if p == "/settings":
                cfg = {}
                if os.path.exists(B.CFG_PATH): cfg = json.load(open(B.CFG_PATH, encoding="utf-8"))
                SEO_KEYS = ("TITLE_SUFFIX", "ORG_NAME", "ORG_LOGO", "ORG_TEL", "ORG_STREET", "ORG_POSTAL", "ORG_CITY", "ORG_REGION", "ROBOTS_TXT", "BLOG_BASE")
                is_seo = role_of(CURRENT_USER) == "seo"
                for k in B.CONFIG:
                    if k in fields and (not is_seo or k in SEO_KEYS): cfg[k] = fields[k].replace("\r\n", "\n").strip()
                if is_seo: fields["back"] = "/seo"
                if "ENV" in fields and not is_seo: cfg["ENV"] = fields["ENV"]
                json.dump(cfg, open(B.CFG_PATH, "w", encoding="utf-8"), ensure_ascii=False, indent=1)
                try: os.chmod(B.CFG_PATH, 0o600)   # secrets (SMTP/FTP/clés API) : lisible par le compte seul
                except Exception: pass
                import importlib; importlib.reload(B); log("✔ Réglages enregistrés")
                back = fields.get("back") if fields.get("back", "").startswith("/") else "/settings"
                return self.redirect(back + "?m=Réglages enregistrés. Régénérez puis publiez.")
            self.send_html("<h1>404</h1>", 404)
        except Exception as e:
            log("✘ Erreur serveur : " + traceback.format_exc().strip().splitlines()[-1])
            detail = f'<pre>{esc(traceback.format_exc())}</pre>' if not ONLINE else '<p class="help">Le détail technique est dans le journal du tableau de bord.</p>'
            self.send_html(layout("Erreur", f'<div class="msg err">Une erreur est survenue.</div>{detail}<p><a href="javascript:history.back()">← Retour</a></p>'), 500)

class Preview(SimpleHTTPRequestHandler):
    def __init__(self, *a, **k): super().__init__(*a, directory=DIST, **k)
    def log_message(self, *a): pass
    def end_headers(self): self.send_header("Cache-Control", "no-store"); super().end_headers()

if __name__ == "__main__":
    os.makedirs(DIST, exist_ok=True)
    if not load_users():
        pw = secrets.token_urlsafe(9); upsert_user("contact@agence-beecom.fr", pw, "admin")
        print(f"Aucun compte trouvé : compte admin créé — contact@agence-beecom.fr / mot de passe temporaire : {pw}  (changez-le dans « mot de passe »)")
    if not os.path.exists(os.path.join(DIST, "index.html")): do_build()
    threading.Thread(target=lambda: HTTPServer(("127.0.0.1", PREVIEW_PORT), Preview).serve_forever(), daemon=True).start()
    srv = HTTPServer(("127.0.0.1", ADMIN_PORT), Admin)
    print(f"Back-office : http://127.0.0.1:{ADMIN_PORT}   |   Aperçu du site : http://127.0.0.1:{PREVIEW_PORT}   (Ctrl+C pour arrêter)")
    try: webbrowser.open(f"http://127.0.0.1:{ADMIN_PORT}")
    except Exception: pass
    try: srv.serve_forever()
    except KeyboardInterrupt: print("\nArrêt.")
