#!/usr/bin/env python3
"""Traduit tous les champs texte en français + régénère notes et import_ready.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"

STATIC = {
    "French": "Français",
    "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",
    "Crypto": "Crypto",
    "Cryptocurrency scam": "Arnaque cryptomonnaie",
    "Crypto scam": "Arnaque crypto",
    "Investment scam": "Arnaque à l'investissement",
    "General scam": "Arnaque générale",
    "No experience": "Aucune expérience",
    "Beginner": "Débutant",
    "Middle-aged (30-55)": "Âge moyen (30-55)",
    "Senior (55+)": "Senior (55+)",
    "Senior": "Senior",
}

TEXT_FIELDS = [
    "summary",
    "pain_point",
    "objections",
    "next_step",
    "urgency",
    "budget",
    "language",
    "scam_type",
    "case_status",
    "payment",
]


def load_cache() -> dict:
    if CACHE_PATH.exists():
        try:
            return json.loads(CACHE_PATH.read_text(encoding="utf-8"))
        except Exception:
            return {}
    return {}


def save_cache(cache: dict) -> None:
    CACHE_PATH.write_text(json.dumps(cache, ensure_ascii=False), encoding="utf-8")


_cache = load_cache()
_last = 0.0


def looks_french(text: str) -> bool:
    t = f" {text.lower()} "
    hits = sum(
        1
        for w in (
            " le ", " la ", " les ", " de ", " des ", " un ", " une ",
            " et ", " est ", " pour ", " avec ", " dans ", " pas ",
            " qui ", " que ", " son ", " sa ", " une ", " du ",
        )
        if w in t
    )
    if hits >= 3:
        return True
    if re.search(r"[àâäéèêëïîôùûüç]", text.lower()) and hits >= 1:
        return True
    return False


def translate_fr(text: str) -> str:
    global _last
    text = (text or "").strip()
    if not text:
        return ""
    if text in STATIC:
        return STATIC[text]
    if text in _cache:
        return _cache[text]
    if re.fullmatch(r"[\d\s.,€$+\-_/]+", text):
        _cache[text] = text
        return text
    # déjà FR et pas d'arabe
    if looks_french(text) and not re.search(r"[\u0600-\u06FF]", text):
        _cache[text] = text
        return text

    chunks: list[str] = []
    remaining = text
    while len(remaining) > 450:
        cut = remaining.rfind(". ", 0, 450)
        if cut < 80:
            cut = remaining.rfind(" ", 0, 450)
        if cut < 40:
            cut = 450
        chunks.append(remaining[: cut + 1].strip())
        remaining = remaining[cut + 1 :].strip()
    if remaining:
        chunks.append(remaining)

    out: list[str] = []
    for chunk in chunks:
        if chunk in STATIC:
            out.append(STATIC[chunk])
            continue
        if chunk in _cache:
            out.append(_cache[chunk])
            continue
        elapsed = time.time() - _last
        if elapsed < 0.35:
            time.sleep(0.35 - elapsed)
        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, "langpair": langpair, "de": "crm@online-trade.net"}
        )
        try:
            with urllib.request.urlopen(url, timeout=30) as resp:
                data = json.loads(resp.read().decode("utf-8"))
            translated = (data.get("responseData") or {}).get("translatedText") or chunk
            if "INVALID" in translated.upper() or "MYMEMORY WARNING" in translated.upper():
                translated = chunk
            _cache[chunk] = translated
            out.append(translated)
        except Exception:
            out.append(chunk)
        _last = time.time()

    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 "—")
    prio = c.get("priority") or "moyenne"
    typ = c.get("type") or c.get("industry") or "—"
    phone = c.get("phone") or ""
    if phone and not str(phone).startswith("+"):
        phone = "+" + "".join(ch for ch in phone if ch.isdigit())

    lines = [
        "═══ FICHE CONTACT (import batch) ═══",
        f"Source : {c.get('source_file') or '—'}",
        f"Priorité CRM : {prio}",
        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 '')}",
    ]
    return "\n".join(lines)


def main() -> None:
    contacts = json.loads(JSON_PATH.read_text(encoding="utf-8"))
    total = len(contacts)
    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 field in TEXT_FIELDS:
            val = c.get(field) or ""
            if val:
                c[field] = translate_fr(val)
        # tags status en FR si cold/warm/hot
        tags = []
        for t in c.get("tags") or []:
            tags.append(STATIC.get(t, t))
        c["tags"] = tags
        c["notes"] = build_notes_fr(c)
        if i % 10 == 0:
            save_cache(_cache)

    save_cache(_cache)
    JSON_PATH.write_text(json.dumps(contacts, ensure_ascii=False, indent=2), encoding="utf-8")
    print("JSON OK", flush=True)

    # régénérer SQL
    import regen_clients_sql as regen

    regen.main()
    print("DONE", flush=True)


if __name__ == "__main__":
    main()
