"""Vote de typage entre couches (audit reel 2026-07-29).

Constat : ~5 spans PERSON du pipeline sont en realite des societes (et
inversement). Ces cas ne FUIENT pas (la valeur est masquee) mais degradent
la qualite des jetons envoyes au LLM ("PERSON_3" pour un editeur de
logiciel embrouille le modele).

Regle : quand deux sources independantes proposent le meme span (memes
frontieres a la normalisation pres) avec des types differents, on tranche
par priorite de fiabilite mesuree, et non par ordre d'arrivee :
- regex/gazetteer (deterministe) > tout
- camembert-ner generique sur PERSON/CITY (mesure : 0,5 % de fuite)
- fine-tune metier sur COMPANY/ADDRESS (mesure : le meilleur sur ces types)
"""

# fiabilite par (source, type) : plus haut = plus credible
PRIORITY = {
    ("regex", None): 100,
    ("gazetteer", "CITY"): 90,
    ("generic", "PERSON"): 80,
    ("generic", "CITY"): 70,
    ("noirci", "COMPANY"): 75,
    ("noirci", "ADDRESS"): 60,
    ("noirci", "CADASTRE"): 60,
    ("generic", "COMPANY"): 40,
    ("noirci", "PERSON"): 50,
    ("noirci", "CITY"): 40,
}
DEFAULT = 30


def score(source: str, etype: str) -> int:
    return PRIORITY.get((source, etype), PRIORITY.get((source, None), DEFAULT))


def resolve(candidates: list[dict]) -> list[dict]:
    """candidates : spans portant une cle 'source'. Les spans qui se
    chevauchent sont regroupes ; le type gagnant est celui de la source la
    plus fiable, les frontieres restent celles du span le plus long."""
    if not candidates:
        return []
    ordered = sorted(candidates, key=lambda c: (c["start"], -(c["end"] - c["start"])))
    groups: list[list[dict]] = []
    for c in ordered:
        if groups and c["start"] < groups[-1][0]["end"]:
            groups[-1].append(c)
        else:
            groups.append([c])

    out = []
    for grp in groups:
        longest = max(grp, key=lambda c: c["end"] - c["start"])
        best = max(grp, key=lambda c: score(c.get("source", "?"), c["type"]))
        out.append({"start": longest["start"], "end": longest["end"],
                    "type": best["type"], "value": longest["value"]})
    return out