code/scripts/features/standings.py

"""Features classement équipe et zones d'enjeu - ISO 5055/5259.

Ce module calcule les classements réels depuis les scores de match
et détermine les zones d'enjeu (promotion/maintien).

Conformité:
- ISO 5055: Module <300 lignes, responsabilité unique
- ISO 5259: Position réelle, tie-breakers FFE implémentés (CORRIGÉ)
"""

from __future__ import annotations

import logging
from typing import Any

import pandas as pd

# Ré-exports pour compatibilité
from scripts.features.enjeu import extract_team_enjeu_fallback, extract_team_enjeu_features

logger = logging.getLogger(__name__)

# Export public
__all__ = [
    "calculate_standings",
    "extract_team_enjeu_features",
    "extract_team_enjeu_fallback",
]


def calculate_standings(df: pd.DataFrame) -> pd.DataFrame:
    """Calcule le classement réel par équipe/saison/groupe/ronde.

    CORRIGÉ: Implémente les tie-breakers FFE pour départager ex-aequo.

    Points Interclubs FFE:
    - Victoire match (score > adversaire): 2 pts
    - Nul match (score = adversaire): 1 pt
    - Défaite match (score < adversaire): 0 pt

    Tie-breakers FFE (dans l'ordre):
    1. Confrontation directe (résultat entre les ex-aequo)
    2. Différence de points de matchs (somme score_dom - score_ext)
    3. Nombre de victoires
    4. Nom alphabétique (dernier recours, stable)

    Args:
    ----
        df: DataFrame échiquiers complet

    Returns:
    -------
        DataFrame avec colonnes:
        - equipe, saison, competition, division, groupe, ronde
        - points_cumules: points accumulés jusqu'à cette ronde
        - position: classement à cette ronde (1 = premier)
        - nb_equipes: nombre total d'équipes dans le groupe
        - ecart_premier: points du 1er - points équipe
        - ecart_dernier: points équipe - points du dernier
        - victoires: nombre de victoires
        - diff_points_matchs: différence de points de matchs

    ISO 5259: Position calculée depuis données réelles avec tie-breakers.
    """
    logger.info("Calcul classement réel depuis scores matchs...")

    matches = _extract_unique_matches(df)
    if matches.empty:
        return pd.DataFrame()

    standings_data = _compute_all_standings(matches)

    result = pd.DataFrame(standings_data)
    logger.info(f"  {len(result)} lignes classement générées")
    return result


def _extract_unique_matches(df: pd.DataFrame) -> pd.DataFrame:
    """Extrait les matchs uniques du DataFrame."""
    if df.empty:
        return pd.DataFrame()

    match_cols = [
        "saison",
        "competition",
        "division",
        "groupe",
        "ronde",
        "equipe_dom",
        "equipe_ext",
        "score_dom",
        "score_ext",
    ]

    missing = [c for c in match_cols if c not in df.columns]
    if missing:
        logger.warning(f"  Colonnes manquantes pour classement: {missing}")
        return pd.DataFrame()

    matches = df.drop_duplicates(
        subset=["saison", "competition", "division", "groupe", "ronde", "equipe_dom", "equipe_ext"]
    )[match_cols].copy()

    logger.info(f"  {len(matches)} matchs uniques")
    return matches


def _compute_all_standings(matches: pd.DataFrame) -> list[dict]:
    """Calcule tous les classements par groupe."""
    standings_data = []

    for (saison, comp, div, groupe), group_matches in matches.groupby(
        ["saison", "competition", "division", "groupe"]
    ):
        group_standings = _compute_group_standings(group_matches, saison, comp, div, groupe)
        standings_data.extend(group_standings)

    return standings_data


def _compute_group_standings(
    group_matches: pd.DataFrame, saison: int, comp: str, div: str, groupe: str
) -> list[dict]:
    """Calcule le classement pour un groupe."""
    equipe_stats: dict[str, dict[str, Any]] = {}
    h2h: dict[tuple[str, str], int] = {}
    standings_data = []

    for ronde in sorted(group_matches["ronde"].unique()):
        ronde_matches = group_matches[group_matches["ronde"] == ronde]
        for _, match in ronde_matches.iterrows():
            _process_match(match, equipe_stats, h2h)

        standings_data.extend(
            _build_ronde_standings(equipe_stats, h2h, saison, comp, div, groupe, ronde)
        )

    return standings_data


def _build_ronde_standings(
    equipe_stats: dict, h2h: dict, saison: int, comp: str, div: str, groupe: str, ronde: int
) -> list[dict]:
    """Construit le classement pour une ronde."""
    ranking = _apply_tiebreakers(equipe_stats, h2h)
    nb_equipes = len(ranking)
    pts_premier = ranking[0][1]["points"] if ranking else 0
    pts_dernier = ranking[-1][1]["points"] if ranking else 0

    return [
        {
            "equipe": equipe,
            "saison": saison,
            "competition": comp,
            "division": div,
            "groupe": groupe,
            "ronde": ronde,
            "points_cumules": stats["points"],
            "matchs_joues": stats["matchs"],
            "victoires": stats["victoires"],
            "diff_points_matchs": stats["diff_points_matchs"],
            "position": pos,
            "nb_equipes": nb_equipes,
            "ecart_premier": pts_premier - stats["points"],
            "ecart_dernier": stats["points"] - pts_dernier,
        }
        for pos, (equipe, stats) in enumerate(ranking, 1)
    ]


def _process_match(
    match: pd.Series,
    equipe_stats: dict[str, dict[str, Any]],
    h2h: dict[tuple[str, str], int],
) -> None:
    """Traite un match et met à jour les stats."""
    dom = str(match["equipe_dom"])
    ext = str(match["equipe_ext"])
    sd = match["score_dom"]
    se = match["score_ext"]

    # Initialiser si nouvelle équipe
    for eq in [dom, ext]:
        if eq not in equipe_stats:
            equipe_stats[eq] = {
                "points": 0,
                "victoires": 0,
                "diff_points_matchs": 0,
                "matchs": 0,
            }

    # Mettre à jour stats
    equipe_stats[dom]["matchs"] += 1
    equipe_stats[ext]["matchs"] += 1
    equipe_stats[dom]["diff_points_matchs"] += sd - se
    equipe_stats[ext]["diff_points_matchs"] += se - sd

    # Attribuer points (2 victoire, 1 nul, 0 défaite)
    if sd > se:  # Dom gagne
        equipe_stats[dom]["points"] += 2
        equipe_stats[dom]["victoires"] += 1
        h2h[(dom, ext)] = h2h.get((dom, ext), 0) + 2
        h2h[(ext, dom)] = h2h.get((ext, dom), 0) + 0
    elif se > sd:  # Ext gagne
        equipe_stats[ext]["points"] += 2
        equipe_stats[ext]["victoires"] += 1
        h2h[(ext, dom)] = h2h.get((ext, dom), 0) + 2
        h2h[(dom, ext)] = h2h.get((dom, ext), 0) + 0
    else:  # Nul
        equipe_stats[dom]["points"] += 1
        equipe_stats[ext]["points"] += 1
        h2h[(dom, ext)] = h2h.get((dom, ext), 0) + 1
        h2h[(ext, dom)] = h2h.get((ext, dom), 0) + 1


def _apply_tiebreakers(
    equipe_stats: dict[str, dict[str, Any]],
    h2h: dict[tuple[str, str], int],
) -> list[tuple[str, dict[str, Any]]]:
    """Applique les tie-breakers FFE pour départager ex-aequo.

    Ordre des critères:
    1. Points
    2. Confrontation directe (H2H)
    3. Différence de points de matchs
    4. Nombre de victoires
    5. Nom alphabétique (stable)
    """

    def sort_key(item: tuple[str, dict[str, Any]]) -> tuple[Any, ...]:
        equipe, stats = item
        pts = stats["points"]
        diff = stats["diff_points_matchs"]
        vic = stats["victoires"]
        h2h_score = sum(h2h.get((equipe, other), 0) for other in equipe_stats if other != equipe)
        return (-pts, -h2h_score, -diff, -vic, equipe)

    return sorted(equipe_stats.items(), key=sort_key)