"""Seconde passe en majuscules ciblees : reveiller ce que le modele sait deja.

Mesure du 31/07/2026. En presentant au modele le MEME texte mis en
capitales, la fuite sur les societes tombait de 15,8 % a 7,2 %. Autrement
dit, une societe sur trois que le modele « rate » lui est en fait
familiere : il ne la reconnait pas ecrite « Pennylane » alors qu'il la
reconnait ecrite « PENNYLANE ». Cause : les pools BODACC et SIRENE qui ont
servi a fabriquer le corpus stockent les raisons sociales en capitales,
d'ou un corpus a 65 % de majuscules contre 17 % dans la vraie
correspondance.

Mettre tout le texte en capitales n'est pas exploitable : le modele voit
alors des societes partout et le sur-masquage monte a 57 %. On ne
majuscule donc que les mots capitalises qu'aucune de nos trois listes ne
connait (lexique francais, patronymes SIRENE, prenoms INSEE) : un mot
capitalise absent des trois est un candidat marque. Le sur-masquage reste a
14 % et la fuite societes tombe a 10,3 %.

Cout : une inference de plus par document. Le module est donc optionnel,
active par le detecteur qui en veut.

La transformation preserve la LONGUEUR du texte, donc les offsets trouves
sur la variante sont valables sur l'original. Les rares caracteres dont la
majuscule occupe plusieurs codets (« ß ») sont laisses tels quels.
"""

import gzip
import re
import unicodedata
from functools import lru_cache
from pathlib import Path

FORMES = Path(__file__).resolve().parents[2] / "data" / "formes_connues.txt.gz"

# mot capitalise d'au moins trois caracteres : « Pennylane », « Sage »,
# « GoCardless ». On exclut les mots d'une ou deux lettres, trop ambigus.
_MOT = re.compile(r"\b[A-ZÀ-Þ][a-zà-ÿ][\wÀ-ÿ.-]{1,}\b")


def _norm(s: str) -> str:
    s = unicodedata.normalize("NFD", s.upper())
    return "".join(c for c in s if unicodedata.category(c) != "Mn")


@lru_cache(maxsize=1)
def _connues() -> frozenset:
    if not FORMES.exists():
        return frozenset()
    with gzip.open(FORMES, "rt", encoding="utf-8") as f:
        return frozenset(l.strip() for l in f if l.strip())


def variante(text: str) -> str:
    """Le texte avec les mots capitalises inconnus passes en capitales."""
    connues = _connues()
    if not connues:
        return text
    out = list(text)
    for m in _MOT.finditer(text):
        mot = m.group(0)
        if _norm(mot) in connues:
            continue
        for i, c in enumerate(mot.upper()):
            if len(c) == 1:
                out[m.start() + i] = c
    return "".join(out)


def seconde_passe(text: str, spans: list[dict], detecteur,
                  types=("COMPANY",)) -> list[dict]:
    """Spans supplementaires trouves sur la variante en capitales.

    `detecteur` est la fonction de detection a rejouer. On ne retient que
    les types demandes, et jamais un span qui empiete sur un span deja
    trouve : la premiere passe, faite sur le texte authentique, fait foi.
    """
    var = variante(text)
    if var == text or len(var) != len(text):
        return []

    occupe = set()
    for s in spans:
        occupe.update(range(s["start"], s["end"]))

    extra = []
    for s in detecteur(var):
        if s["type"] not in types:
            continue
        r = set(range(s["start"], s["end"]))
        if r & occupe:
            continue
        occupe |= r
        extra.append({**s, "value": text[s["start"]:s["end"]]})
    return extra