"""Lance un detecteur sur un gold JSONL et ecrit les predictions + le score.

Usage :
    python -m bench.detect.run data/bench_v0.jsonl --out data/pred_regex.jsonl

Detecteurs disponibles : regex (couche A). Les candidats NER/GLiNER viendront
s'ajouter ici en phase 2 (meme interface : detect(text) -> spans).

Le rapport est decoupe clean / bruite OCR : la degradation du regex sur le
bruit est une mesure attendue du benchmark (analyse §7.4).
"""

import argparse
import json

from bench.detect import regex_layer
from bench.harness.score import format_report, load_jsonl, score


def _ner(text):
    from bench.detect import ner_onnx

    return ner_onnx.detect(text)


def _clip(span, occupied, text):
    """Decoupe un span autour des zones occupees : on garde les morceaux
    libres (jeter le span entier ferait perdre "Jean Dupont" quand le NER
    sort "Jean Dupont, 87, chemin Roux" et que le regex prend l'adresse)."""
    pieces = []
    start = None
    for i in range(span["start"], span["end"] + 1):
        free = i < span["end"] and i not in occupied
        if free and start is None:
            start = i
        elif not free and start is not None:
            while start < i and not text[start].isalnum():
                start += 1
            end = i
            while end > start and not text[end - 1].isalnum():
                end -= 1
            if end - start >= 2:
                pieces.append({"start": start, "end": end,
                               "type": span["type"], "value": text[start:end]})
            start = None
    return pieces


def _fusion(text):
    """regex + NER : la couche regex (checksums) est prioritaire sur ses
    spans ; le NER complete partout ailleurs, decoupe si chevauchement."""
    spans = regex_layer.detect(text)
    occupied = set()
    for s in spans:
        occupied.update(range(s["start"], s["end"]))
    for s in _ner(text):
        for piece in _clip(s, occupied, text):
            occupied.update(range(piece["start"], piece["end"]))
            spans.append(piece)
    return sorted(spans, key=lambda s: s["start"])


def _full(text):
    """regex + NER + propagation document-entier des personnes."""
    from bench.detect.propagation import propagate

    spans = _fusion(text)
    spans.extend(propagate(text, spans))
    from bench.detect.propagation import propagate_exact, propagate_enumerations
    from bench.detect.tools_filter import filtrer
    spans.extend(propagate_exact(text, spans))
    spans.extend(propagate_enumerations(text, spans))
    spans.extend(propagate_exact(text, spans))
    return filtrer(sorted(spans, key=lambda s: s["start"]))


def _hybrid(text):
    """La reco mesuree : regex -> gazetteer communes -> camembert-ner
    generique (PERSON/CITY, meilleur rappel) -> Anonym-IA (le reste) ->
    propagation."""
    from bench.detect import gazetteer, ner_onnx
    from bench.detect.propagation import propagate

    spans = regex_layer.detect(text)
    occupied = set()
    for s in spans:
        occupied.update(range(s["start"], s["end"]))

    for source in (
        gazetteer.detect(text),
        [s for s in ner_onnx.detect_generic(text) if s["type"] in ("PERSON", "CITY")],
        _ner(text),
    ):
        for s in source:
            for piece in _clip(s, occupied, text):
                occupied.update(range(piece["start"], piece["end"]))
                spans.append(piece)

    spans.extend(propagate(text, spans))
    from bench.detect.propagation import propagate_exact, propagate_enumerations
    from bench.detect.tools_filter import filtrer
    spans.extend(propagate_exact(text, spans))
    spans.extend(propagate_enumerations(text, spans))
    spans.extend(propagate_exact(text, spans))
    return filtrer(sorted(spans, key=lambda s: s["start"]))


def _camembert_baseline(text):
    from bench.detect.ner_baseline import detect

    return detect(text)


def _hybrid2(text):
    """hybrid + NOTRE fine-tune en moteur COMPANY/filet metier, insere entre
    camembert-ner (qui garde PERSON/CITY) et Anonym-IA (types exotiques)."""
    from bench.detect import gazetteer, ner_onnx
    from bench.detect.propagation import propagate

    spans = regex_layer.detect(text)
    occupied = set()
    for s in spans:
        occupied.update(range(s["start"], s["end"]))

    for source in (
        gazetteer.detect(text),
        [s for s in ner_onnx.detect_generic(text) if s["type"] in ("PERSON", "CITY")],
        ner_onnx.detect_noirci(text),
        _ner(text),
    ):
        for s in source:
            for piece in _clip(s, occupied, text):
                occupied.update(range(piece["start"], piece["end"]))
                spans.append(piece)

    spans.extend(propagate(text, spans))
    from bench.detect.propagation import propagate_exact, propagate_enumerations
    from bench.detect.tools_filter import filtrer
    spans.extend(propagate_exact(text, spans))
    spans.extend(propagate_enumerations(text, spans))
    spans.extend(propagate_exact(text, spans))
    return filtrer(sorted(spans, key=lambda s: s["start"]))


def _lite(text):
    """Candidat executable : regex -> gazetteer -> UN seul modele (notre
    fine-tune v2, corpus v4 mixte metier+WikiNER) -> propagation."""
    from bench.detect import gazetteer, ner_onnx
    from bench.detect.propagation import propagate

    from bench.detect import vocabulaire

    spans = regex_layer.detect(text)
    occupied = set()
    for s in spans:
        occupied.update(range(s["start"], s["end"]))
    from bench.detect import gazetteer_company
    # le vocabulaire local passe avant les modeles : c'est une connaissance
    # certaine, elle doit ancrer la propagation plutot que la subir
    for source in (vocabulaire.detect(text), gazetteer.detect(text),
                   ner_onnx.detect_noirci(text),
                   gazetteer_company.detect(text)):
        for s in source:
            for piece in _clip(s, occupied, text):
                occupied.update(range(piece["start"], piece["end"]))
                spans.append(piece)
    spans.extend(propagate(text, spans))
    from bench.detect.propagation import propagate_exact, propagate_enumerations
    from bench.detect.tools_filter import filtrer
    spans.extend(propagate_exact(text, spans))
    spans.extend(propagate_enumerations(text, spans))
    spans.extend(propagate_exact(text, spans))
    return filtrer(sorted(spans, key=lambda s: s["start"]))


def _lite2(text):
    """lite + seconde passe en majuscules ciblees (bench/detect/casse.py).
    Une inference de plus par document, contre un tiers de fuite COMPANY
    en moins. Voir la mesure du 31/07 dans doc/memory/matrice_comparaison.md."""
    from bench.detect.casse import seconde_passe
    from bench.detect.propagation import propagate_exact
    from bench.detect.tools_filter import filtrer

    spans = list(_lite(text))
    spans.extend(seconde_passe(text, spans, _lite))
    spans.extend(propagate_exact(text, spans))
    return filtrer(sorted(spans, key=lambda s: s["start"]))


def _hybrid3(text):
    """hybrid2 SANS Anonym-IA : ablation anti sur-masquage (2026-07-29).
    regex -> gazetteer -> generique (PERSON/CITY) -> noirci v2 -> propagation."""
    from bench.detect import gazetteer, ner_onnx
    from bench.detect.propagation import propagate

    spans = regex_layer.detect(text)
    occupied = set()
    for s in spans:
        occupied.update(range(s["start"], s["end"]))
    for source in (
        gazetteer.detect(text),
        [s for s in ner_onnx.detect_generic(text) if s["type"] in ("PERSON", "CITY")],
        ner_onnx.detect_noirci(text),
    ):
        for s in source:
            for piece in _clip(s, occupied, text):
                occupied.update(range(piece["start"], piece["end"]))
                spans.append(piece)
    spans.extend(propagate(text, spans))
    from bench.detect.propagation import propagate_exact, propagate_enumerations
    from bench.detect.tools_filter import filtrer
    spans.extend(propagate_exact(text, spans))
    spans.extend(propagate_enumerations(text, spans))
    spans.extend(propagate_exact(text, spans))
    return filtrer(sorted(spans, key=lambda s: s["start"]))


DETECTORS = {
    "regex": regex_layer.detect,
    "lite": _lite,
    "lite2": _lite2,
    "hybrid3": _hybrid3,
    "ner": _ner,
    "regex+ner": _fusion,
    "full": _full,
    "hybrid": _hybrid,
    "hybrid2": _hybrid2,
    "camembert-ner": _camembert_baseline,
}


def main():
    ap = argparse.ArgumentParser(description="Detection + scoring sur un gold JSONL")
    ap.add_argument("gold")
    ap.add_argument("--detector", choices=DETECTORS, default="regex")
    ap.add_argument("--out", help="fichier predictions JSONL (optionnel)")
    args = ap.parse_args()

    detector = DETECTORS[args.detector]
    gold = load_jsonl(args.gold)
    preds = {
        doc_id: {"id": doc_id, "entities": detector(doc["text"])}
        for doc_id, doc in gold.items()
    }

    if args.out:
        with open(args.out, "w", encoding="utf-8") as f:
            for p in preds.values():
                f.write(json.dumps(p, ensure_ascii=False) + "\n")

    for label, keep in [
        ("TOUT", lambda d: True),
        ("CLEAN", lambda d: not d.get("noise")),
        ("BRUITE OCR", lambda d: d.get("noise")),
    ]:
        subset = {i: d for i, d in gold.items() if keep(d)}
        if not subset:
            continue
        print(f"\n=== {args.detector} / {label} ({len(subset)} segments) ===")
        print(format_report(score(subset, preds)))


if __name__ == "__main__":
    main()