Datasets:

Pierrax
/

ffe-history

"""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)

	"""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)