# -*- coding: utf-8 -*-
"""Traduction du site (type WPML) — moteur votre-fiche-google.

Principe :
- Le français (langue par défaut) reste la source, servie à la racine (/).
- Chaque autre langue (Réglages › Langues, ex. « fr:Français,en:English ») est générée sous /<code>/…
  avec balises hreflang, sitemap, sélecteur de langue automatique.
- Les traductions sont stockées champ par champ dans translations/<page>.<lang>.json avec l'empreinte
  du texte source : quand un texte français change, le champ passe « à mettre à jour » et seul lui
  est retraduit (bouton dans le back-office › Traductions). Rien n'est traduit « en temps réel ».
- Fournisseurs : DeepL (clé API, gratuit jusqu'à 500 000 caractères/mois) ou Claude (clé API Anthropic).
  Tout est relisible/corrigeable à la main dans les fichiers translations/ ou via le back-office.
"""
import os, re, json, html, hashlib, urllib.request, urllib.parse

ROOT = os.path.dirname(os.path.abspath(__file__))
TRANS_DIR = os.path.join(ROOT, "translations")
TRANSLATABLE_TYPES = ("text", "html", "textarea", "lines", "richtext")
META_UNITS = ("title", "description", "card_title", "excerpt", "breadcrumb", "bc_label", "date_fr")

def sh(s): return hashlib.sha1((s or "").strip().encode("utf-8")).hexdigest()[:16]

def _skip_value(v):
    """Valeurs à ne pas traduire : vides, URLs, jetons seuls, nombres/prix seuls."""
    v = (v or "").strip()
    if not v: return True
    if re.fullmatch(r"\{\{[^}]+\}\}|\{[a-z_]+\}", v): return True
    if re.fullmatch(r"(https?://|/|mailto:|tel:)\S*", v): return True
    return False

# ------------------------------------------------------------------ unités traduisibles d'une page
def page_units(meta, blocks_data):
    """Liste [(unit_id, texte_source)] pour une page. unit_id : 'meta.title', 'f.sec.key', 'f.sec.key.3.sub'."""
    units = []
    for k in META_UNITS:
        v = meta.get(k, "")
        if k == "breadcrumb":
            if v: units.append(("meta.breadcrumb", _bc_texts(v)))
            continue
        if v and not _skip_value(v): units.append((f"meta.{k}", v))
    for sec in (blocks_data or {}).get("sections", []):
        for f in sec.get("fields", []):
            t = f.get("type", "text")
            if t == "repeat":
                for i, row in enumerate(f.get("items", [])):
                    for sub in f.get("fields", []):
                        if sub.get("type") in TRANSLATABLE_TYPES:
                            v = row.get(sub["key"], "")
                            if sub.get("type") == "lines": v = _lines_texts(v)
                            if not _skip_value(v): units.append((f"f.{sec['id']}.{f['key']}.{i}.{sub['key']}", v))
            elif t in TRANSLATABLE_TYPES:
                v = f.get("value", "")
                if t == "lines": v = _lines_texts(v)
                if not _skip_value(v): units.append((f"f.{sec['id']}.{f['key']}", v))
    return units

def _bc_texts(v):
    """Fil d'Ariane « Nom|/url;Nom2 » : on protège les URLs dans des jetons."""
    parts = []
    for seg in str(v or "").split(";"):
        seg = seg.strip()
        if "|" in seg:
            name, url = seg.split("|", 1)
            parts.append(f"{name.strip()} {{{{L:{url.strip()}}}}}")
        else: parts.append(seg)
    return " ;; ".join(parts)

def _bc_restore(v):
    parts = []
    for seg in re.split(r"\s*;;\s*|\s*;\s*(?=[A-ZÀ-Ý])", str(v or "")):
        seg = seg.strip()
        if not seg: continue
        m = re.match(r"^(.*?)\s*\{\{L:([^}]*)\}\}\s*$", seg)
        if m: parts.append(f"{m.group(1).strip()}|{m.group(2)}")
        else: parts.append(seg)
    return ";".join(parts)

def _lines_texts(v):
    """Pour un champ « lines » (Texte | Lien | Sous-texte | picto) : on ne traduit que les segments texte.
    On encode la partie non traduisible dans des jetons {{L:…}} qui seront protégés puis restitués."""
    out = []
    for line in str(v or "").splitlines():
        if not line.strip(): continue
        parts = [p.strip() for p in line.split("|")]
        if len(parts) == 1: out.append(parts[0])
        elif len(parts) >= 3 and parts[2]:
            out.append(f"{parts[0]} {{{{L:{parts[1]}}}}} ¦ {parts[2]} {{{{L2:{'|'.join(parts[3:])}}}}}")
        else:
            out.append(f"{parts[0]} {{{{L:{'|'.join(parts[1:])}}}}}")
    return "\n".join(out)

def _lines_restore(v):
    out = []
    for line in str(v or "").splitlines():
        if not line.strip(): continue
        m = re.match(r"^(.*?)\s*\{\{L:([^}]*)\}\}\s*(?:¦\s*(.*?)\s*\{\{L2:([^}]*)\}\})?\s*$", line.strip())
        if not m: out.append(line.strip()); continue
        txt, rest, sub, rest2 = m.group(1).strip(), m.group(2), (m.group(3) or "").strip(), (m.group(4) or "")
        if sub or rest2:
            tail = ("|" + rest2) if rest2 else ""
            out.append(f"{txt} | {rest} | {sub}{tail}".rstrip("|").rstrip())
        else:
            out.append(f"{txt} | {rest}" if rest else txt)
    return "\n".join(out)

def body_unit(body):
    """Pages sans blocs (articles) : le corps HTML entier est l'unité."""
    return ("body", body)

# ------------------------------------------------------------------ zones & attributs du corps de page
# Les formulaires et tableaux ne deviennent jamais des champs éditables (zones protégées de
# l'extraction) : on les traduit ici EN BLOC, en place. Idem pour les attributs visibles
# (placeholder, aria-label, valeur des boutons d'envoi) que DeepL ne traduit pas dans le HTML.
ZONE_RE = re.compile(r"<form\b[\s\S]*?</form>|<table\b[\s\S]*?</table>", re.I)
ATTR_RE = re.compile(r'\b(?:placeholder|aria-label)="([^"{}<>]{2,200})"|<input\b[^>]*type="submit"[^>]*\bvalue="([^"{}<>]{2,200})"', re.I)
CALC_RE = re.compile(r'data-calc="([^"]+)"|data-calc=\'([^\']+)\'', re.I)

def _calc_texts(raw):
    """Valeurs textuelles d'une config data-calc (JSON dans l'attribut, ex. unit/unitPlural)."""
    import html as _h
    try: cfgj = json.loads(_h.unescape(raw))
    except Exception: return []
    return [v for v in cfgj.values() if isinstance(v, str) and v.strip() and not _skip_value(v)]

def body_extra_units(body):
    """Unités supplémentaires d'une page à blocs : formulaires/tableaux entiers + attributs visibles."""
    units = []
    for m in ZONE_RE.finditer(body or ""):
        units.append(("zone." + sh(m.group(0)), m.group(0)))
    seen = set()
    for m in ATTR_RE.finditer(body or ""):
        txt = m.group(1) or m.group(2)
        if txt and txt.strip() and not _skip_value(txt) and txt not in seen:
            seen.add(txt); units.append(("attr." + sh(txt), txt))
    for m in CALC_RE.finditer(body or ""):
        for txt in _calc_texts(m.group(1) or m.group(2)):
            if txt not in seen:
                seen.add(txt); units.append(("attr." + sh(txt), txt))
    return units

def overlay_body_extras(body, tr):
    """Applique au corps de page les zones (form/table) et attributs traduits."""
    u = (tr or {}).get("units", {})
    if not u: return body
    def repz(m):
        t = u.get("zone." + sh(m.group(0)))
        return t["val"] if t and t.get("val") else m.group(0)
    body = ZONE_RE.sub(repz, body)
    def repa(m):
        txt = m.group(1) or m.group(2)
        t = u.get("attr." + sh(txt or ""))
        if not (txt and t and t.get("val")): return m.group(0)
        return m.group(0).replace(txt, t["val"], 1)
    body = ATTR_RE.sub(repa, body)
    def repc(m):
        import html as _h
        raw = m.group(1) or m.group(2)
        try: cfgj = json.loads(_h.unescape(raw))
        except Exception: return m.group(0)
        changed = False
        for k, v in list(cfgj.items()):
            if isinstance(v, str):
                t = u.get("attr." + sh(v))
                if t and t.get("val"): cfgj[k] = t["val"]; changed = True
        if not changed: return m.group(0)
        return 'data-calc="' + _h.escape(json.dumps(cfgj, ensure_ascii=False), quote=True) + '"'
    return CALC_RE.sub(repc, body)

# ------------------------------------------------------------------ stockage
def path_for(name, lang): return os.path.join(TRANS_DIR, f"{name}.{lang}.json")

def load(name, lang):
    p = path_for(name, lang)
    if os.path.exists(p):
        try: return json.load(open(p, encoding="utf-8"))
        except Exception: pass
    return {"page": name, "lang": lang, "units": {}}

def save(name, lang, data):
    os.makedirs(TRANS_DIR, exist_ok=True)
    json.dump(data, open(path_for(name, lang), "w", encoding="utf-8"), ensure_ascii=False, indent=1)

def status(units, tr):
    """(total, manquants, obsolètes) pour une liste d'unités source et une traduction chargée."""
    missing = stale = 0
    for uid, src in units:
        u = tr.get("units", {}).get(uid)
        if not u: missing += 1
        elif u.get("src") != sh(src): stale += 1
    return len(units), missing, stale

def is_complete(units, tr):
    """La page est publiable dans la langue quand tous ses champs/metas sont traduits.
    Les unités « zone.* / attr.* » (formulaires, tableaux, attributs) ne bloquent pas la
    publication : tant qu'elles manquent, ces zones restent dans la langue d'origine."""
    core = [(u, s) for u, s in units if not u.startswith(("zone.", "attr."))]
    t, m, s = status(core, tr)
    return t > 0 and m == 0

# ------------------------------------------------------------------ protection des jetons
TOKEN_RE = re.compile(r"\{\{[^}]+\}\}|\{[a-z_0-9]+[?!]?[^{}]*\}")
def shield(text):
    toks = []
    def rep(m): toks.append(m.group(0)); return f'<var id="{len(toks)-1}"></var>'
    return TOKEN_RE.sub(rep, text), toks
def unshield(text, toks):
    def rep(m):
        try: return toks[int(m.group(1))]
        except Exception: return ""
    text = re.sub(r'<var id="(\d+)"\s*/?>(?:</var>)?', rep, text)
    return re.sub(r"</var>", "", text)

# ------------------------------------------------------------------ fournisseurs
class TranslateError(Exception): pass

def call_provider(texts, target, cfg, source="fr"):
    """DeepL d'abord (recommandé) ; si son quota est épuisé et qu'une clé Anthropic est renseignée,
    bascule automatiquement sur Claude. TRANSLATE_PROVIDER = "claude" force Claude uniquement."""
    prov = (cfg.get("TRANSLATE_PROVIDER") or "deepl").strip()
    if prov == "claude": return _claude(texts, target, cfg, source)
    try:
        return _deepl(texts, target, cfg, source)
    except TranslateError as e:
        if "(456)" in str(e):   # 456 = quota DeepL épuisé
            if (cfg.get("ANTHROPIC_KEY") or "").strip():
                return _claude(texts, target, cfg, source)
            raise TranslateError("Quota DeepL épuisé (nouvelles clés : 1 million de caractères au total, non renouvelable). "
                                 "Renseignez une clé API Anthropic dans les Réglages pour une bascule automatique sur Claude, ou passez sur une offre DeepL payante.")
        raise

def deepl_usage(cfg):
    """(caractères utilisés, limite) du compte DeepL — None si indisponible."""
    key = (cfg.get("DEEPL_KEY") or "").strip()
    if not key: return None
    host = "api-free.deepl.com" if key.endswith(":fx") else "api.deepl.com"
    try:
        req = urllib.request.Request(f"https://{host}/v2/usage", headers={"Authorization": f"DeepL-Auth-Key {key}"})
        with urllib.request.urlopen(req, timeout=10) as r: j = json.load(r)
        return int(j.get("character_count", 0)), int(j.get("character_limit", 0))
    except Exception:
        return None

def _deepl(texts, target, cfg, source):
    key = (cfg.get("DEEPL_KEY") or "").strip()
    if not key: raise TranslateError("Clé DeepL manquante (Réglages › Langues & traduction). Compte gratuit : deepl.com/pro-api")
    host = "api-free.deepl.com" if key.endswith(":fx") else "api.deepl.com"
    out = []
    for i in range(0, len(texts), 40):
        batch = texts[i:i+40]
        data = [("source_lang", source.upper()), ("target_lang", target.upper()), ("tag_handling", "html")]
        data += [("text", t) for t in batch]
        req = urllib.request.Request(f"https://{host}/v2/translate", data=urllib.parse.urlencode(data).encode("utf-8"),
                                     headers={"Authorization": f"DeepL-Auth-Key {key}"})
        try:
            with urllib.request.urlopen(req, timeout=60) as r: j = json.load(r)
        except urllib.error.HTTPError as e:
            raise TranslateError(f"DeepL a refusé la demande ({e.code}) : {e.read().decode('utf-8', 'ignore')[:200]}")
        except Exception as e:
            raise TranslateError(f"Connexion DeepL impossible : {e}")
        got = [t["text"] for t in j.get("translations", [])]
        if len(got) != len(batch): raise TranslateError("Réponse DeepL incomplète.")
        out += got
    return out

def _claude(texts, target, cfg, source):
    key = (cfg.get("ANTHROPIC_KEY") or "").strip()
    if not key: raise TranslateError("Clé API Anthropic manquante (Réglages › Langues & traduction). console.anthropic.com")
    model = (cfg.get("TRANSLATE_MODEL") or "claude-haiku-4-5").strip()
    out = []
    for i in range(0, len(texts), 20):
        batch = texts[i:i+20]
        payload = {
            "model": model, "max_tokens": 8000,
            "system": (f"You translate website copy from {source} to {target} for a small-business marketing site. "
                       "Keep ALL HTML tags, attributes and <var id=\"n\"></var> placeholders exactly as they are, translating only human-readable text. "
                       "Keep the register natural and commercial, not literal. Numbers, prices, brand names (Beecom', Google Business Profile, Calendly) stay unchanged. "
                       "Input is a JSON array of strings; answer with ONLY the translated JSON array, same length, same order."),
            "messages": [{"role": "user", "content": json.dumps(batch, ensure_ascii=False)}],
        }
        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"})
        try:
            with urllib.request.urlopen(req, timeout=180) as r: j = json.load(r)
        except urllib.error.HTTPError as e:
            raise TranslateError(f"L'API Claude a refusé la demande ({e.code}) : {e.read().decode('utf-8', 'ignore')[:300]}")
        except Exception as e:
            raise TranslateError(f"Connexion à l'API Claude impossible : {e}")
        txt = "".join(b.get("text", "") for b in j.get("content", []))
        m = re.search(r"\[[\s\S]*\]", txt)
        if not m: raise TranslateError("Réponse de traduction illisible.")
        got = json.loads(m.group(0))
        if len(got) != len(batch): raise TranslateError("Réponse de traduction incomplète.")
        out += [str(g) for g in got]
    return out

# ------------------------------------------------------------------ traduction d'une page
def translate_units(units, tr, target, cfg, force=False):
    """Traduit les unités manquantes/obsolètes. Retourne (nb_traduits, nb_déjà_à_jour)."""
    todo = []
    for uid, src in units:
        u = tr["units"].get(uid)
        if force or not u or u.get("src") != sh(src): todo.append((uid, src))
    if not todo: return 0, len(units)
    shielded, tokens = [], []
    for uid, src in todo:
        s, tk = shield(src); shielded.append(s); tokens.append(tk)
    got = call_provider(shielded, target, cfg)
    for (uid, src), tr_text, tk in zip(todo, got, tokens):
        val = unshield(tr_text, tk)
        if uid == "meta.breadcrumb": val = _bc_restore(val)
        elif uid.startswith("f."):
            # champs lines : restaurer le format « Texte | Lien | Sous-texte »
            if "{{L:" in src or "{{L:" in val or "¦" in val: val = _lines_restore(val)
        tr["units"][uid] = {"src": sh(src), "val": val}
    return len(todo), len(units) - len(todo)

# ------------------------------------------------------------------ application (overlay) au build
def overlay_blocks(blocks_data, tr):
    """Retourne une copie de blocks_data avec les valeurs traduites (unités à jour ou obsolètes : on prend ce qu'on a)."""
    import copy
    d = copy.deepcopy(blocks_data)
    units = tr.get("units", {})
    for sec in d.get("sections", []):
        for f in sec.get("fields", []):
            if f.get("type") == "repeat":
                for i, row in enumerate(f.get("items", [])):
                    for sub in f.get("fields", []):
                        u = units.get(f"f.{sec['id']}.{f['key']}.{i}.{sub['key']}")
                        if u: row[sub["key"]] = u["val"]
            else:
                u = units.get(f"f.{sec['id']}.{f['key']}")
                if u: f["value"] = u["val"]
    return d

def overlay_meta(meta, tr):
    m = dict(meta); units = tr.get("units", {})
    for k in META_UNITS:
        u = units.get(f"meta.{k}")
        if u: m[k] = u["val"]
    return m

def get_body(tr):
    u = tr.get("units", {}).get("body")
    return u["val"] if u else None
