#!/usr/bin/env python3
"""Force la traduction EN→FR de TOUS les champs texte, reconstruit notes, régénère SQL."""
from __future__ import annotations

import json
import re
import time
import urllib.parse
import urllib.request
from pathlib import Path

DIR = Path(__file__).resolve().parent
JSON_PATH = DIR / "classified_all.json"
CACHE_PATH = DIR.parent / "translate_cache_fr.json"

FIELDS = [
    "summary",
    "pain_point",
    "objections",
    "next_step",
    "urgency",
    "budget",
    "language",
    "scam_type",
    "case_status",
    "payment",
    "interest",
]

STATIC = {
    "French": "Français",
    "English": "Anglais",
    "Russian": "Russe",
    "Polish": "Polonais",
    "Arabic": "Arabe",
    "Turkish": "Turc",
    "New": "Nouveau",
    "In progress": "En cours",
    "Pending": "En attente",
    "hot": "chaud",
    "warm": "tiède",
    "cold": "froid",
    "Account activation": "Activation du compte",
    "Bank transfer": "Virement bancaire",
    "Credit card": "Carte bancaire",
    "Call back next week": "Rappeler la semaine prochaine",
    "Follow up when customer has funds": "Relancer quand le client a des fonds",
    "Preparation of documents and follow up on Monday.": "Préparation des documents et suivi lundi.",
    "discussion of recovery process and fees": "Discussion du processus de récupération et des frais",
}


def is_english(text: str) -> bool:
    if not text or len(text.strip()) < 3:
        return False
    t = text.strip()
    if t in STATIC:
        return True
    # chiffres / codes seuls
    if re.fullmatch(r"[\d\s.,€$+\-_/]+", t):
        return False
    # arabe → à traduire aussi
    if re.search(r"[\u0600-\u06FF]", t):
        return True
    low = t.lower()
    eng_hits = len(
        re.findall(
            r"\b(the|and|with|for|from|this|that|customer|interested|follow|called|expressed|"
            r"recovery|account|scam|funds|looking|wants|needs|about|their|have|has|was|were|"
            r"will|would|should|could|been|being|into|over|under|after|before|during|"
            r"process|assistance|investment|platform|email|phone|call|next|step)\b",
            low,
        )
    )
    fr_hits = len(
        re.findall(
            r"\b(le|la|les|des|une|un|est|sont|pour|avec|dans|sur|pas|qui|que|son|sa|"
            r"appel|client|demande|récupération|arnaque|compte|fonds|intéressé|suite)\b",
            low,
        )
    )
    if eng_hits >= 2 and eng_hits > fr_hits:
        return True
    if eng_hits >= 1 and fr_hits == 0 and re.search(r"[A-Za-z]{4,}", t):
        # phrase courte anglaise
        if not re.search(r"[àâäéèêëïîôùûüç]", low):
            return True
    return False


def load_cache() -> dict:
    if CACHE_PATH.exists():
        try:
            return json.loads(CACHE_PATH.read_text(encoding="utf-8"))
        except Exception:
            return {}
    return {}


_cache = load_cache()
# purge entrées cache où source == cible (anglaise non traduite)
_cache = {
    k: v
    for k, v in _cache.items()
    if not (k.strip() == v.strip() and is_english(k))
}
_last = 0.0


def save_cache() -> None:
    CACHE_PATH.write_text(json.dumps(_cache, ensure_ascii=False), encoding="utf-8")


def _mymemory(chunk: str) -> str:
    langpair = "ar|fr" if re.search(r"[\u0600-\u06FF]", chunk) else "en|fr"
    url = "https://api.mymemory.translated.net/get?" + urllib.parse.urlencode(
        {"q": chunk[:450], "langpair": langpair, "de": "crm-batch@online-trade.net"}
    )
    with urllib.request.urlopen(url, timeout=40) as resp:
        data = json.loads(resp.read().decode("utf-8"))
    translated = ((data.get("responseData") or {}).get("translatedText") or chunk).strip()
    if "MYMEMORY WARNING" in translated.upper() or "INVALID" in translated.upper():
        return chunk
    return translated


def _libre(chunk: str) -> str:
    src = "ar" if re.search(r"[\u0600-\u06FF]", chunk) else "en"
    body = json.dumps({"q": chunk[:450], "source": src, "target": "fr", "format": "text"}).encode("utf-8")
    req = urllib.request.Request(
        "https://libretranslate.com/translate",
        data=body,
        headers={"Content-Type": "application/json", "User-Agent": "CRM-batch/1.0"},
        method="POST",
    )
    with urllib.request.urlopen(req, timeout=40) as resp:
        data = json.loads(resp.read().decode("utf-8"))
    return (data.get("translatedText") or chunk).strip()


def _google(chunk: str) -> str:
    from deep_translator import GoogleTranslator

    src = "ar" if re.search(r"[\u0600-\u06FF]", chunk) else "en"
    return GoogleTranslator(source=src, target="fr").translate(chunk[:4500])


def translate_chunk(chunk: str) -> str:
    global _last
    if chunk in STATIC:
        return STATIC[chunk]
    if chunk in _cache and not is_english(_cache[chunk]):
        return _cache[chunk]
    elapsed = time.time() - _last
    if elapsed < 0.5:
        time.sleep(0.5 - elapsed)

    translated = chunk
    for fn in (_mymemory, _libre, _google):
        try:
            candidate = fn(chunk)
            _last = time.time()
            if candidate and not is_english(candidate):
                translated = candidate
                break
            if candidate and candidate != chunk:
                translated = candidate  # mieux que rien
        except Exception:
            _last = time.time()
            continue

    _cache[chunk] = translated
    return translated


def translate_fr(text: str) -> str:
    text = (text or "").strip()
    if not text:
        return ""
    if text in STATIC:
        return STATIC[text]
    if not is_english(text) and not re.search(r"[\u0600-\u06FF]", text):
        return text
    if text in _cache and not is_english(_cache[text]):
        return _cache[text]

    parts: list[str] = []
    remaining = text
    while len(remaining) > 420:
        cut = remaining.rfind(". ", 0, 420)
        if cut < 60:
            cut = remaining.rfind(" ", 0, 420)
        if cut < 30:
            cut = 420
        parts.append(remaining[: cut + 1].strip())
        remaining = remaining[cut + 1 :].strip()
    if remaining:
        parts.append(remaining)

    out = [translate_chunk(p) for p in parts if p]
    result = " ".join(out).strip()
    _cache[text] = result
    return result


def dash(v: str) -> str:
    return v if v else "—"


def build_notes_fr(c: dict) -> str:
    status_map = {"hot": "chaud", "warm": "tiède", "cold": "froid"}
    st = status_map.get((c.get("status_temp") or "").lower(), c.get("status_temp") or "—")
    phone = c.get("phone") or ""
    if phone and not str(phone).startswith("+"):
        phone = "+" + "".join(ch for ch in phone if ch.isdigit())
    typ = c.get("type") or c.get("industry") or "—"
    return "\n".join(
        [
            "═══ FICHE CONTACT (import batch) ═══",
            f"Source : {c.get('source_file') or '—'}",
            f"Priorité CRM : {c.get('priority') or 'moyenne'}",
            f"Type : {typ}",
            f"Statut temporaire : {st}",
            "",
            "── Identité ──",
            f"Nom : {dash(c.get('name') or '')}",
            f"Téléphone : {dash(phone)}",
            f"E-mail : {dash(c.get('email') or '')}",
            f"Pays : {dash(c.get('country') or 'France')}",
            f"Langue : {dash(c.get('language') or '')}",
            "",
            "── Commercial ──",
            f"Industrie : {dash(c.get('industry') or typ)}",
            f"Courtier : {dash(c.get('broker') or '')}",
            f"Dépôt : {dash(c.get('deposit') or '')}",
            f"Étape FTD : {dash(c.get('ftd_stage') or '')}",
            f"Urgence : {dash(c.get('urgency') or '')}",
            f"Budget : {dash(c.get('budget') or '')}",
            "",
            "── Recovery ──",
            f"Montant perdu : {dash(c.get('amount_lost') or '')}",
            f"Type d'arnaque : {dash(c.get('scam_type') or '')}",
            f"Statut du dossier : {dash(c.get('case_status') or '')}",
            f"Banque : {dash(c.get('bank') or '')}",
            f"Paiement : {dash(c.get('payment') or '')}",
            "",
            "── Synthèse ──",
            f"Point de douleur : {dash(c.get('pain_point') or '')}",
            f"Objections : {dash(c.get('objections') or '')}",
            f"Résumé : {dash(c.get('summary') or '')}",
            f"Prochaine étape : {dash(c.get('next_step') or '')}",
            "",
            f"Date du lead : {dash(c.get('lead_date') or '')}",
            f"Code de sécurité : {dash(c.get('security_code') or '')}",
        ]
    )


def main() -> None:
    contacts = json.loads(JSON_PATH.read_text(encoding="utf-8"))
    total = len(contacts)
    still_en = 0
    for i, c in enumerate(contacts, 1):
        name = (c.get("name") or "?").encode("ascii", "replace").decode("ascii")
        print(f"[{i}/{total}] {name}", flush=True)
        for f in FIELDS:
            val = (c.get(f) or "").strip()
            if not val:
                continue
            translated = translate_fr(val)
            c[f] = translated
            if is_english(translated):
                still_en += 1
        # tags cold/warm/hot
        c["tags"] = [STATIC.get(t, t) for t in (c.get("tags") or [])]
        c["notes"] = build_notes_fr(c)
        if i % 15 == 0:
            save_cache()
            JSON_PATH.write_text(json.dumps(contacts, ensure_ascii=False, indent=2), encoding="utf-8")

    save_cache()
    JSON_PATH.write_text(json.dumps(contacts, ensure_ascii=False, indent=2), encoding="utf-8")
    print(f"JSON OK — champs encore EN detectes (approx): {still_en}", flush=True)

    import regen_clients_sql as regen

    regen.main()

    # contrôle final
    sql = (DIR / "import_ready.sql").read_text(encoding="utf-8")
    for p in ["The customer", "interested in", "follow-up", "The call"]:
        print(f"SQL leftover '{p}': {sql.count(p)}", flush=True)
    print("DONE", flush=True)


if __name__ == "__main__":
    main()
