code/scripts/features/advanced/pressure.py

"""Performance sous pression (matchs décisifs) - ISO 5055/5259.

Ce module implémente le calcul de la performance sous pression.
Feature psychologique: performance en fin de saison ou matchs serrés.

Matchs décisifs (SEUILS DOCUMENTÉS ISO 5259):
- Dernière ronde (ronde >= 7): Format interclubs FFE standard 7-11 rondes.
  Les 3 dernières rondes sont généralement décisives pour le classement final.
  Référence: Règlement FFE A02, format compétition interclubs.
- Score serré (écart <= 1 point): Match où chaque partie compte.
  Justification: pression psychologique maximale quand résultat incertain.

Clutch factor (SEUILS DOCUMENTÉS):
- > 0.1: "clutch" - joueur surperforme sous pression
- < -0.1: "choke" - joueur sous-performe sous pression
- [-0.1, 0.1]: "stable" - pas d'effet significatif
Seuil 0.1 = ~10% de différence de score, significatif statistiquement.

Sources:
- AI Sports Predictions 2025 (ainewshub.org)
- Sports Prediction PMC - "Psychological factors in sports"
- Règlement FFE A02 - Format interclubs

Conformité:
- ISO 5055: Module <300 lignes, responsabilité unique
- ISO 5259: Features calculées depuis données réelles, seuils documentés
"""

from __future__ import annotations

import logging

import numpy as np
import pandas as pd

logger = logging.getLogger(__name__)


def calculate_pressure_performance(df: pd.DataFrame, min_games: int = 3) -> pd.DataFrame:
    """Calcule la performance sous pression (matchs décisifs).

    Feature psychologique: performance en fin de saison ou matchs serrés.

    Matchs décisifs:
    - Dernière ronde (ronde >= 7)
    - Score serré (écart <= 1 point)

    Args:
    ----
        df: DataFrame échiquiers
        min_games: Minimum de matchs décisifs

    Returns:
    -------
        DataFrame avec colonnes:
        - joueur_nom: nom joueur
        - score_normal: performance matchs normaux
        - score_pression: performance matchs décisifs
        - nb_pression: nombre matchs décisifs
        - clutch_factor: score_pression - score_normal
        - pressure_type: 'clutch' (>0.1), 'choke' (<-0.1), 'stable'

    ISO 5259: Performance pression depuis contexte réel.
    """
    logger.info("Calcul performance sous pression...")

    if df.empty:
        return pd.DataFrame()

    parties = _prepare_pressure_df(df)
    pressure_stats = _collect_pressure_stats(parties)
    result = _build_pressure_result(pressure_stats, min_games)

    logger.info(f"  {len(result)} joueurs avec stats pression")
    return result


def _prepare_pressure_df(df: pd.DataFrame) -> pd.DataFrame:
    """Prepare le DataFrame avec flag decisif."""
    parties = df[
        ~df["type_resultat"].isin(["non_joue", "forfait_blanc", "forfait_noir", "double_forfait"])
    ].copy()
    parties["is_decisive"] = parties.apply(_is_decisive, axis=1)
    return parties


def _is_decisive(row: pd.Series) -> bool:
    """Determine si un match est decisif."""
    ronde = row.get("ronde", 0)
    score_dom = row.get("score_dom", 0)
    score_ext = row.get("score_ext", 0)
    return ronde >= 7 or abs(score_dom - score_ext) <= 1


def _collect_pressure_stats(parties: pd.DataFrame) -> dict[str, dict[str, list[float]]]:
    """Collecte les stats de pression par joueur."""
    pressure_stats: dict[str, dict[str, list[float]]] = {}

    for couleur in ["blanc", "noir"]:
        nom_col, res_col = f"{couleur}_nom", f"resultat_{couleur}"
        if nom_col not in parties.columns or res_col not in parties.columns:
            continue

        for _, row in parties.iterrows():
            joueur = str(row[nom_col])
            if joueur not in pressure_stats:
                pressure_stats[joueur] = {"normal": [], "pressure": []}

            key = "pressure" if row["is_decisive"] else "normal"
            pressure_stats[joueur][key].append(row[res_col])

    return pressure_stats


def _build_pressure_result(
    pressure_stats: dict[str, dict[str, list[float]]], min_games: int
) -> pd.DataFrame:
    """Construit le DataFrame resultat."""
    result_data = []
    for joueur, stats in pressure_stats.items():
        entry = _compute_player_pressure(joueur, stats, min_games)
        if entry:
            result_data.append(entry)
    return pd.DataFrame(result_data)


def _compute_player_pressure(joueur: str, stats: dict, min_games: int) -> dict | None:
    """Calcule les stats de pression d'un joueur."""
    nb_pressure, nb_normal = len(stats["pressure"]), len(stats["normal"])
    if nb_pressure < min_games or nb_normal < min_games:
        return None

    score_normal = np.mean(stats["normal"])
    score_pressure = np.mean(stats["pressure"])
    clutch = score_pressure - score_normal
    ptype = _classify_pressure_type(clutch)

    return {
        "joueur_nom": joueur,
        "score_normal": score_normal,
        "score_pression": score_pressure,
        "nb_normal": nb_normal,
        "nb_pression": nb_pressure,
        "clutch_factor": clutch,
        "pressure_type": ptype,
    }


def _classify_pressure_type(clutch: float) -> str:
    """Classifie le type de pression."""
    if clutch > 0.1:
        return "clutch"
    if clutch < -0.1:
        return "choke"
    return "stable"