pii/generators.py

"""Generation de valeurs PII francaises pour le corpus synthetique.

Chaque generateur renvoie (valeur_texte, type_entite). Les formats de surface
varient volontairement (espaces IBAN, points telephone, casse noms) : le
benchmark doit refleter la realite des documents, pas des valeurs canoniques.
"""

import random
from dataclasses import dataclass, field

from faker import Faker

from . import checksums as ck

# Types d'entites du benchmark (aligne sur l'analyse, doc/memory/analyse.md §2)
TYPES = [
    "PERSON", "COMPANY", "ADDRESS", "CITY", "EMAIL", "PHONE", "DATE",
    "DATE_BIRTH", "IBAN", "NIR", "SIREN", "SIRET", "TVA", "CARD", "PLATE",
    "RG", "CADASTRE", "IP", "AMOUNT", "REF", "URL", "SECRET",
    "USERAGENT", "MAC", "IPV6", "AGE", "ACCOUNT",
]


@dataclass
class Person:
    """Une personne avec ses variantes de surface (piege n°1 : 'Dupont' seul)."""
    first: str
    last: str
    civ: str = "M."

    @property
    def full(self) -> str:
        return f"{self.first} {self.last}"

    def variants(self) -> list[str]:
        return [
            self.full,
            f"{self.civ} {self.last}",
            self.last.upper(),
            self.last,
            f"{self.civ} {self.first} {self.last.upper()}",
            f"{self.first[0]}. {self.last}",
            f"{self.last}, {self.first}",  # etat civil / BODACC : Nom, Prenom
        ]


@dataclass
class PiiFactory:
    seed: int = 0
    rng: random.Random = field(init=False)
    fk: Faker = field(init=False)

    def __post_init__(self):
        self.rng = random.Random(self.seed)
        self.fk = Faker("fr_FR")
        self.fk.seed_instance(self.seed)

    # --- personnes / societes / lieux ------------------------------------
    def person(self) -> Person:
        civ = self.rng.choice(["M.", "Mme", "Me", "Dr"])
        if civ == "Mme":
            first = self.fk.first_name_female()
        else:
            first = self.fk.first_name_male()
        return Person(first=first, last=self.fk.last_name(), civ=civ)

    def company(self) -> str:
        # styles releves sur BODACC (remontees reelles 2026-07-28) : marques
        # tout-majuscules, sigles, style domaine — pas que du Faker propre
        style = self.rng.random()
        if style < 0.5:
            base = self.fk.company()
            forme = self.rng.choice(["", "", " SARL", " SAS", " SA", " SCI"])
            return base + forme
        if style < 0.7:
            suffix = self.rng.choice(["", "", " TRANSPORTS", " CONSEIL",
                                      " IMMO", " DISTRIBUTION", " BATIMENT"])
            return self.fk.last_name().upper().replace(" ", "") + suffix
        if style < 0.8:
            return self.fk.last_name().upper() + "." + self.rng.choice(["FR", "COM"])
        if style < 0.9:
            letters = [w[0].upper() for w in self.fk.company().split()[:3]]
            while len(letters) < 2:
                letters.append(self.rng.choice("BCDFGMPRST"))
            return ".".join(letters) + "."
        return self.fk.company().upper()

    def address(self) -> str:
        # formes reelles : plages de numeros, lieux-dits, hameaux sans type
        # de voie, Grande Rue, residences (remontees BODACC)
        style = self.rng.random()
        if style < 0.55:
            return self.fk.street_address()
        if style < 0.65:
            n = self.rng.randint(1, 120)
            return f"{n}-{n + self.rng.choice([2, 4, 6])} {self.fk.street_name()}"
        if style < 0.75:
            art = self.rng.choice(["La", "Le", "Les"])
            return f"Lieu-dit {art} {self.fk.last_name()}"
        if style < 0.85:
            return f"{self.rng.randint(1, 40)} {self.fk.last_name()}"
        if style < 0.93:
            return f"{self.rng.randint(1, 60)} Grande Rue"
        art = self.rng.choice(["La", "Le", "Les"])
        return (f"{self.rng.randint(1, 30)} Résidence {art} "
                f"{self.fk.last_name()}")

    def city(self) -> str:
        city = self.fk.city()
        if city.startswith("Saint") and self.rng.random() < 0.5:
            return city.replace("Sainte-", "Ste-").replace("Saint-", "St-")
        return city

    def email(self, person: Person | None = None) -> str:
        if person and self.rng.random() < 0.7:
            dom = self.rng.choice(["gmail.com", "orange.fr", "free.fr", "outlook.fr"])
            sep = self.rng.choice([".", "", "-"])
            return f"{person.first.lower()}{sep}{person.last.lower()}@{dom}".replace(" ", "")
        return self.fk.email()

    # --- identifiants a checksum -----------------------------------------
    def iban(self) -> str:
        raw = ck.gen_iban_fr(self.rng)
        if self.rng.random() < 0.6:
            return " ".join(raw[i:i + 4] for i in range(0, len(raw), 4))
        return raw

    def nir(self) -> str:
        raw = ck.gen_nir(self.rng)
        if self.rng.random() < 0.5:
            p = [raw[0], raw[1:3], raw[3:5], raw[5:7], raw[7:10], raw[10:13], raw[13:15]]
            return " ".join(p)
        return raw

    def siren(self) -> str:
        raw = ck.gen_siren(self.rng)
        if self.rng.random() < 0.5:
            return f"{raw[:3]} {raw[3:6]} {raw[6:]}"
        return raw

    def siret(self) -> str:
        raw = ck.gen_siret(self.rng)
        if self.rng.random() < 0.5:
            return f"{raw[:3]} {raw[3:6]} {raw[6:9]} {raw[9:]}"
        return raw

    def tva(self) -> str:
        raw = ck.gen_tva_fr(self.rng)
        if self.rng.random() < 0.4:
            return f"{raw[:4]} {raw[4:]}"
        return raw

    def card(self) -> str:
        raw = ck.gen_carte_bancaire(self.rng)
        if self.rng.random() < 0.5:
            return " ".join(raw[i:i + 4] for i in range(0, 16, 4))
        return raw

    # --- regex sans checksum ----------------------------------------------
    def phone(self) -> str:
        prefix = self.rng.choice(["01", "02", "03", "04", "05", "06", "07", "09"])
        digits = [f"{self.rng.randint(0, 99):02d}" for _ in range(4)]
        style = self.rng.random()
        if style < 0.3:
            return "+33 " + prefix[1] + " " + " ".join(digits)
        if style < 0.6:
            return prefix + " " + " ".join(digits)
        if style < 0.8:
            return prefix + "." + ".".join(digits)
        return prefix + "".join(digits)

    def plate(self) -> str:
        letters = "BCDFGHJKLMNPRSTVWXZ"
        if self.rng.random() < 0.8:
            return (f"{self.rng.choice(letters)}{self.rng.choice(letters)}-"
                    f"{self.rng.randint(100, 999)}-"
                    f"{self.rng.choice(letters)}{self.rng.choice(letters)}")
        return (f"{self.rng.randint(100, 999)} "
                f"{''.join(self.rng.choices(letters, k=3))} "
                f"{self.rng.randint(1, 95):02d}")

    def rg(self) -> str:
        return f"{self.rng.randint(18, 26):02d}/{self.rng.randint(1, 99999):05d}"

    def cadastre(self) -> str:
        letters = "ABCDEFGHIKLMNOPRSTVXYZ"
        section = "".join(self.rng.choices(letters, k=self.rng.choice([1, 2])))
        return f"section {section} n° {self.rng.randint(1, 999)}"

    def ip(self) -> str:
        return self.fk.ipv4()

    # --- divers ------------------------------------------------------------
    def date(self) -> str:
        d = self.fk.date_between(start_date="-3y", end_date="today")
        if self.rng.random() < 0.5:
            return d.strftime("%d/%m/%Y")
        months = ["janvier", "février", "mars", "avril", "mai", "juin", "juillet",
                  "août", "septembre", "octobre", "novembre", "décembre"]
        return f"{d.day} {months[d.month - 1]} {d.year}"

    def ref(self) -> str:
        """Numero de dossier/facture NON etiquete : distracteur numerique."""
        return f"{self.rng.randint(100, 99999):05d}"

    def date_birth(self) -> str:
        d = self.fk.date_of_birth(minimum_age=18, maximum_age=90)
        style = self.rng.random()
        if style < 0.4:
            return d.strftime("%d/%m/%Y")
        if style < 0.7:
            months = ["janvier", "février", "mars", "avril", "mai", "juin", "juillet",
                      "août", "septembre", "octobre", "novembre", "décembre"]
            return f"{d.day} {months[d.month - 1]} {d.year}"
        return d.strftime("%d.%m.%Y")

    def amount(self) -> str:
        v = self.rng.choice([
            f"{self.rng.randint(100, 9999)},{self.rng.randint(0, 99):02d}",
            f"{self.rng.randint(1, 99)} {self.rng.randint(100, 999)},{self.rng.randint(0, 99):02d}",
            str(self.rng.randint(50, 5000)),
        ])
        # decimale POINT et devise EUR : formats reels (BODACC, exports
        # bancaires), remontee 2026-07-28
        style = self.rng.random()
        if style < 0.15:
            return f"{self.rng.randint(500, 90000)}.{self.rng.randint(0, 99):02d} EUR"
        if style < 0.25:
            return f"{v.replace(',', '.').replace(' ', '')} EUR"
        if style < 0.35:
            return f"{v} euros"
        return f"{v} €"