"""Generation de squelettes de documents par sous-agents LLM (Haiku).

Methode GLiNER2-PII (analyse §4) : le LLM ecrit des SQUELETTES a slots, pas
des documents finis. Nos generateurs injectent les valeurs (checksums
valides), donc les offsets gold restent exacts par construction, et la
diversite de prose vient du LLM.

Validation stricte avant d'entrer au pool :
- slots ⊂ inventaire connu, syntaxe exacte, indices numeriques
- remplissage reel via fill_template sur 2 seeds (aucune accolade restante,
  ≥ 2 entites)
- longueur 80-1500 caracteres, dedup par similarite (difflib ≥ 0,88 = rejet)
Repartition train/eval deterministe par hash (≈ 85/15), pools disjoints.

Sortie : bench/synth/templates_llm.json, charge par templates.all_templates.

Usage :
    python -m bench.synth.llm_templates --target 500 --parallel 8
"""

import argparse
import difflib
import hashlib
import json
import random
import re
import subprocess
from concurrent.futures import ThreadPoolExecutor
from pathlib import Path

from bench.pii.generators import PiiFactory
from bench.synth.build import _SLOT_TYPES, fill_template

OUT = Path(__file__).resolve().parent / "templates_llm.json"

DOMAINS_CORRESPONDANCE = {
    "email_signature": "emails professionnels FR se terminant par un bloc de signature complet (prénom+nom, fonction, société, téléphone, site) après un corps long de plusieurs paragraphes",
    "email_tiers": "emails où l'on cite des sociétés TIERCES en pleine prose sans forme juridique : l'éditeur du logiciel, la plateforme utilisée, le prestataire de paiement, un concurrent, le client du client",
    "compte_rendu": "comptes rendus de réunion nominatifs longs : participants prénom+nom en début de paragraphe, sociétés et outils cités plusieurs fois, décisions datées",
    "echange_long": "fils d'emails longs (800-1500 caractères) avec relances, plusieurs interlocuteurs nommés et plusieurs sociétés mentionnées au fil du texte",
    "note_projet": "notes internes de projet citant des outils SaaS, des plateformes et des partenaires par leur marque, plus des identifiants de dossier",
}

DOMAINS = {
    "juridique": "assignations, conclusions, jugements, courriers d'avocat, PV d'huissier, requêtes",
    "compta": "factures, relances, devis, avoirs, notes de frais, courriers URSSAF/impôts, rapprochements",
    "rh": "contrats de travail, bulletins de paie, CV, convocations, attestations, soldes de tout compte, DPAE",
    "immobilier": "baux, états des lieux, quittances, compromis, mandats de gestion, PV d'AG de copropriété",
    "email_client": "emails et messages de clients ou au client : réclamations, résiliations, SAV, relances, WhatsApp/SMS",
    "assurance_banque": "déclarations de sinistre, avis d'échéance, crédits, résiliations, alertes bancaires",
    "sante_social": "certificats médicaux, courriers mutuelle, CPAM, arrêts de travail, dossiers CAF",
    "administratif": "courriers préfecture, cartes grises, impôts locaux, état civil, demandes de documents",
}

STYLES = [
    "courrier formel et long, avec en-tête, objet, formules de politesse",
    "email court et pressé, tutoiement possible, phrases inachevées",
    "formulaire ou fiche : lignes 'Libellé : valeur', sauts de ligne fréquents",
    "acte ou document officiel dense, numérotation d'articles, majuscules d'en-tête",
    "message type WhatsApp/SMS : familier, ponctuation relâchée, urgence",
    "document tabulaire dégradé type OCR : colonnes aplaties, libellés abrégés",
]

SLOTS_DOC = """person1, person2... (personne ; {person1_v} = variante de surface de la MÊME personne : nom seul, initiale, M./Mme + nom)
company1... (société), address1... (adresse postale), city1... (ville)
email1..., phone1..., date1... (date quelconque), date_birth1... (date de NAISSANCE uniquement)
iban1..., nir1... (n° sécu), siren1..., siret1..., tva1... (TVA intracom), card1... (carte bancaire)
plate1... (plaque immat), rg1... (n° RG tribunal, écrire 'RG' à proximité), cadastre1... (référence cadastrale complète, ne pas écrire 'section' avant)
ip1..., amount1... (montant avec devise), ref1... (n° de dossier/facture NON confidentiel)"""

PROMPT = """Tu écris des SQUELETTES de documents français réalistes pour un corpus d'entraînement à la détection de données personnelles. Un squelette = le texte du document où chaque donnée personnelle est remplacée par un slot entre accolades. Nos générateurs rempliront les slots.

Domaine : {domain} ({desc}).
Style imposé : {style}.

Slots autorisés (UNIQUEMENT ceux-là, syntaxe exacte {{nom+numéro}}) :
{slots}

Règles :
- 12 squelettes, très différents entre eux (structures, longueurs 300-900 caractères, tons variés)
- AUCUNE donnée personnelle en clair : tout passe par les slots (pas de nom, ville, montant ou numéro inventé dans le texte)
- Le même numéro = la même entité (réutiliser {{person1}} ou {{person1_v}} pour reparler de la même personne)
- 3 à 8 slots par squelette, mélanger les types, utiliser aussi les types rares (nir, plate, cadastre, tva, card, ip)
- Utiliser \\n pour les sauts de ligne
- Le texte hors slots doit être du français naturel de vrai document, pas générique

Réponds UNIQUEMENT avec un tableau JSON de 12 chaînes, sans commentaire."""

_SLOT_RE = re.compile(r"\{([a-z_]+?)(\d+)(_v)?\}")
_BRACE_RE = re.compile(r"[{}]")


def _valid_slots(tpl: str) -> bool:
    stripped = _SLOT_RE.sub("", tpl)
    if _BRACE_RE.search(stripped):
        return False
    ok = False
    for name, _, variant in _SLOT_RE.findall(tpl):
        if name not in _SLOT_TYPES:
            return False
        if variant and name != "person":
            return False
        ok = True
    return ok


def validate(tpl: str) -> bool:
    if not (80 <= len(tpl) <= 1500) or not _valid_slots(tpl):
        return False
    try:
        for seed in (1, 2):
            seg = fill_template(tpl, PiiFactory(seed=seed), random.Random(seed))
            if "{" in seg["text"] or len(seg["entities"]) < 2:
                return False
    except Exception:
        return False
    return True


def _signature(tpl: str) -> str:
    return re.sub(r"\s+", " ", _SLOT_RE.sub("@", tpl)).lower()


def _too_similar(tpl: str, accepted_sigs: list[str]) -> bool:
    sig = _signature(tpl)
    for other in accepted_sigs:
        if difflib.SequenceMatcher(None, sig, other).quick_ratio() >= 0.88 and \
           difflib.SequenceMatcher(None, sig, other).ratio() >= 0.88:
            return True
    return False


def _ask(job) -> list[str]:
    domain, desc, style, salt = job
    prompt = PROMPT.format(domain=domain, desc=desc, style=style,
                           slots=SLOTS_DOC)
    prompt += f"\n(lot {salt} : évite les scénarios évidents déjà trop vus)"
    try:
        r = subprocess.run(["claude", "-p", prompt, "--model", "haiku"],
                           capture_output=True, text=True, timeout=300)
        m = re.search(r"\[.*\]", r.stdout, re.DOTALL)
        if not m:
            return []
        out = json.loads(m.group(0))
        return [t for t in out if isinstance(t, str)]
    except Exception:
        return []


def main():
    ap = argparse.ArgumentParser()
    ap.add_argument("--target", type=int, default=500)
    ap.add_argument("--parallel", type=int, default=8)
    ap.add_argument("--eval-share", type=float, default=0.15)
    ap.add_argument("--profile", choices=["metier", "correspondance"], default="metier")
    ap.add_argument("--out", default=None)
    args = ap.parse_args()

    jobs = []
    salt = 0
    domains = DOMAINS_CORRESPONDANCE if args.profile == "correspondance" else DOMAINS
    while len(jobs) * 12 < args.target * 1.6:
        for domain, desc in domains.items():
            for style in STYLES:
                jobs.append((domain, desc, style, salt))
        salt += 1
    rng = random.Random(0)
    rng.shuffle(jobs)

    accepted: dict[str, dict[str, list[str]]] = {
        "train": {d: [] for d in domains}, "eval": {d: [] for d in domains}}
    sigs: list[str] = []
    stats = {"recus": 0, "invalides": 0, "doublons": 0}

    with ThreadPoolExecutor(max_workers=args.parallel) as pool:
        for job, result in zip(jobs, pool.map(_ask, jobs)):
            domain = job[0]
            for tpl in result:
                stats["recus"] += 1
                tpl = tpl.strip()
                if not validate(tpl):
                    stats["invalides"] += 1
                    continue
                if _too_similar(tpl, sigs):
                    stats["doublons"] += 1
                    continue
                sigs.append(_signature(tpl))
                h = int(hashlib.sha256(tpl.encode()).hexdigest(), 16)
                split = "eval" if (h % 100) < args.eval_share * 100 else "train"
                accepted[split][domain].append(tpl)
            total = sum(len(lst) for s in accepted.values() for lst in s.values())
            if total >= args.target:
                break

    total = sum(len(lst) for s in accepted.values() for lst in s.values())
    n_eval = sum(len(lst) for lst in accepted["eval"].values())
    out_path = Path(args.out) if args.out else OUT
    out_path.write_text(json.dumps(accepted, ensure_ascii=False, indent=1),
                        encoding="utf-8")
    print(f"{total} squelettes acceptes ({n_eval} eval) -> {out_path}")
    print(stats)


if __name__ == "__main__":
    main()