"""Présence joueur (ALI) - ISO 5055/5259.

Ce module calcule les features de présence pour ALI
(Adversarial Lineup Inference).

Features (DOCUMENTÉES ISO 5259):
- taux_presence_saison: % rondes jouées cette saison [0, 1]
- derniere_presence: Nombre de rondes depuis dernière apparition
- regularite: Classification basée sur taux de présence
  - 'regulier': > 70% des rondes (titulaire stable)
  - 'occasionnel': 30-70% des rondes (rotation)
  - 'rare': < 30% des rondes (remplaçant, blessé, indisponible)

Justification seuils:
- 70%: Joueur présent 6+ rondes sur 9 = titulaire
- 30%: Joueur présent 2-3 rondes sur 9 = remplaçant occasionnel
- Référence: Analyse statistique compositions interclubs FFE

Conformité:
- ISO 5055: Module <300 lignes, responsabilité unique
- ISO 5259: Features depuis données réelles, seuils documentés
- ISO 42001: Prédictions AI traçables
"""

from __future__ import annotations

import logging

import pandas as pd

logger = logging.getLogger(__name__)


def calculate_presence_features(
    df: pd.DataFrame,
    saison: int | None = None,
) -> pd.DataFrame:
    """Calcule les features de présence par joueur.

    Args:
    ----
        df: DataFrame échiquiers avec colonnes joueur, ronde, saison
        saison: Saison à analyser (None = toutes)

    Returns:
    -------
        DataFrame avec colonnes:
        - joueur_nom: nom joueur
        - saison: saison concernée
        - taux_presence_saison: float [0, 1]
        - derniere_presence: int (nb rondes depuis dernier match)
        - nb_rondes_jouees: int
        - nb_rondes_total: int
        - regularite: 'regulier', 'occasionnel', 'rare'

    ISO 5259: Présence calculée depuis historique réel.
    """
    logger.info("Calcul features présence joueur...")

    df_filtered = _filter_by_saison(df, saison)
    if df_filtered.empty:
        return pd.DataFrame()

    presence_data = _collect_presence_data(df_filtered)
    result = _aggregate_presence_data(presence_data)

    logger.info(f"  {len(result)} joueurs avec features présence")
    return result


def _filter_by_saison(df: pd.DataFrame, saison: int | None) -> pd.DataFrame:
    """Filtre le DataFrame par saison."""
    if df.empty:
        return pd.DataFrame()
    if saison is not None:
        return df[df["saison"] == saison].copy()
    return df


def _collect_presence_data(df: pd.DataFrame) -> list[dict]:
    """Collecte les donnees de presence par joueur/saison."""
    presence_data = []

    for s in df["saison"].unique():
        df_saison = df[df["saison"] == s]
        nb_rondes_total = df_saison["ronde"].nunique()
        if nb_rondes_total == 0:
            continue

        ronde_max = df_saison["ronde"].max()
        _collect_saison_presence(df_saison, s, nb_rondes_total, ronde_max, presence_data)

    return presence_data


def _collect_saison_presence(
    df_saison: pd.DataFrame, s: int, nb_rondes_total: int, ronde_max: int, presence_data: list
) -> None:
    """Collecte presence pour une saison."""
    for couleur in ["blanc", "noir"]:
        nom_col = f"{couleur}_nom"
        if nom_col not in df_saison.columns:
            continue

        for joueur, group in df_saison.groupby(nom_col):
            entry = _compute_player_presence(joueur, group, s, nb_rondes_total, ronde_max)
            presence_data.append(entry)


def _compute_player_presence(
    joueur: str, group: pd.DataFrame, saison: int, nb_rondes_total: int, ronde_max: int
) -> dict:
    """Calcule les stats de presence d'un joueur."""
    rondes_jouees = group["ronde"].unique()
    nb_rondes_jouees = len(rondes_jouees)
    taux = nb_rondes_jouees / nb_rondes_total
    regularite = _classify_regularite(taux)

    return {
        "joueur_nom": joueur,
        "saison": saison,
        "taux_presence_saison": round(taux, 3),
        "derniere_presence": ronde_max - max(rondes_jouees),
        "nb_rondes_jouees": nb_rondes_jouees,
        "nb_rondes_total": nb_rondes_total,
        "regularite": regularite,
    }


def _classify_regularite(taux: float) -> str:
    """Classifie la regularite du joueur."""
    if taux > 0.7:
        return "regulier"
    if taux >= 0.3:
        return "occasionnel"
    return "rare"


def _aggregate_presence_data(presence_data: list[dict]) -> pd.DataFrame:
    """Agrege les donnees de presence."""
    result = pd.DataFrame(presence_data)
    if not result.empty:
        result = (
            result.groupby(["joueur_nom", "saison"])
            .agg(
                taux_presence_saison=("taux_presence_saison", "max"),
                derniere_presence=("derniere_presence", "min"),
                nb_rondes_jouees=("nb_rondes_jouees", "max"),
                nb_rondes_total=("nb_rondes_total", "first"),
                regularite=("regularite", "first"),
            )
            .reset_index()
        )
    return result