Datasets:

Pierrax
/

ffe-history

"""Features de fiabilité club/joueur - ISO 5055/25012.
Ce module extrait les features de fiabilité basées sur les forfaits
et les patterns de présence.
Conformité:
- ISO 5055: Module <300 lignes, responsabilité unique
- ISO 25012: Qualité données (fiabilité, complétude)
"""

from __future__ import annotations

import logging

import pandas as pd

logger = logging.getLogger(__name__)


def extract_club_reliability(df: pd.DataFrame) -> pd.DataFrame:
    """Extrait les features de fiabilité par club.
    Utilise les non_joue et forfaits pour identifier les clubs défaillants.
    Args:
    ----
        df: DataFrame échiquiers complet (avant filtrage)
    Returns:
    -------
        DataFrame avec colonnes:
        - equipe: nom du club
        - taux_forfait: % de forfaits sur l'historique
        - taux_non_joue: % de matchs non joués
        - fiabilite_score: score composite (1 - taux_défaillance)
    ISO 25012: Fiabilité mesurée depuis données réelles.
    """
    logger.info("Extraction features fiabilité clubs...")

    if df.empty or "type_resultat" not in df.columns:
        logger.warning("  DataFrame vide ou colonnes manquantes")
        return pd.DataFrame()

    forfaits_types = ["forfait_blanc", "forfait_noir", "double_forfait"]

    club_stats = []

    for equipe_col in ["equipe_dom", "equipe_ext"]:
        if equipe_col not in df.columns:
            continue

        stats = df.groupby(equipe_col).agg(
            total_matchs=("type_resultat", "count"),
            forfaits=("type_resultat", lambda x: x.isin(forfaits_types).sum()),
            non_joue=("type_resultat", lambda x: (x == "non_joue").sum()),
        )
        stats = stats.reset_index().rename(columns={equipe_col: "equipe"})
        club_stats.append(stats)

    if not club_stats:
        return pd.DataFrame()

    # Fusionner dom + ext
    all_stats = pd.concat(club_stats).groupby("equipe").sum().reset_index()

    # Calculer taux (éviter division par zéro)
    all_stats["taux_forfait"] = all_stats["forfaits"] / all_stats["total_matchs"].replace(0, 1)
    all_stats["taux_non_joue"] = all_stats["non_joue"] / all_stats["total_matchs"].replace(0, 1)
    all_stats["fiabilite_score"] = 1 - (
        all_stats["taux_forfait"] * 0.7 + all_stats["taux_non_joue"] * 0.3
    )

    logger.info(f"  {len(all_stats)} clubs avec stats fiabilité")

    return all_stats[["equipe", "taux_forfait", "taux_non_joue", "fiabilite_score"]]


def extract_player_reliability(df: pd.DataFrame) -> pd.DataFrame:
    """Extrait les features de fiabilité par joueur.
    Analyse les patterns de présence/absence pour chaque joueur.
    Args:
    ----
        df: DataFrame échiquiers complet
    Returns:
    -------
        DataFrame avec colonnes:
        - joueur_nom: nom complet du joueur
        - nb_matchs: nombre total de matchs
        - taux_presence: % de matchs effectivement joués
        - joueur_fantome: flag si < 20% présence
    ISO 25012: Complétude mesurée par taux de présence.
    """
    logger.info("Extraction features fiabilité joueurs...")

    if df.empty or "type_resultat" not in df.columns:
        logger.warning("  DataFrame vide ou colonnes manquantes")
        return pd.DataFrame()

    player_stats = []

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

        df_couleur = df[df[nom_col].notna()].copy()

        # Identifier les matchs joués vs non joués
        matchs_joues = ~df_couleur["type_resultat"].isin(
            ["non_joue", f"forfait_{couleur}", "double_forfait"]
        )

        # Capture matchs_joues via default arg to avoid B023
        stats = (
            df_couleur.groupby(nom_col)
            .agg(
                nb_matchs=("type_resultat", "count"),
                matchs_joues=(
                    "type_resultat",
                    lambda x, mj=matchs_joues: mj[x.index].sum(),
                ),
            )
            .reset_index()
            .rename(columns={nom_col: "joueur_nom"})
        )
        player_stats.append(stats)

    if not player_stats:
        return pd.DataFrame()

    # Fusionner blanc + noir
    all_stats = pd.concat(player_stats).groupby("joueur_nom").sum().reset_index()

    # Calculer taux (éviter division par zéro)
    all_stats["taux_presence"] = all_stats["matchs_joues"] / all_stats["nb_matchs"].replace(0, 1)
    all_stats["joueur_fantome"] = all_stats["taux_presence"] < 0.2

    logger.info(f"  {len(all_stats)} joueurs avec stats fiabilité")
    logger.info(f"  {all_stats['joueur_fantome'].sum()} joueurs fantômes (<20% présence)")

    return all_stats[["joueur_nom", "nb_matchs", "taux_presence", "joueur_fantome"]]


def extract_player_monthly_pattern(df: pd.DataFrame) -> pd.DataFrame:
    """Extrait les patterns de disponibilité mensuelle par joueur.
    Détecte les joueurs indisponibles certains mois (vacances, pro, etc.)
    Args:
    ----
        df: DataFrame échiquiers avec colonne 'date'
    Returns:
    -------
        DataFrame avec colonnes:
        - joueur_nom: nom complet
        - dispo_mois_1 ... dispo_mois_12: taux présence par mois
    ISO 5259: Feature temporelle pour prédiction disponibilité.
    """
    logger.info("Extraction patterns mensuels joueurs...")

    df_dated = _prepare_dated_df(df)
    if df_dated.empty:
        return pd.DataFrame()

    monthly_stats = _collect_monthly_stats(df_dated)
    result = _merge_monthly_stats(monthly_stats)

    logger.info(f"  {len(result)} joueurs avec patterns mensuels")
    return result


def _prepare_dated_df(df: pd.DataFrame) -> pd.DataFrame:
    """Prepare le DataFrame avec dates."""
    if df.empty or "date" not in df.columns:
        logger.warning("  Colonnes date manquantes, skip patterns mensuels")
        return pd.DataFrame()

    df_dated = df[df["date"].notna()].copy()
    if len(df_dated) == 0:
        logger.warning("  Pas de dates disponibles, skip patterns mensuels")
        return pd.DataFrame()

    df_dated["mois"] = pd.to_datetime(df_dated["date"]).dt.month
    return df_dated


def _collect_monthly_stats(df_dated: pd.DataFrame) -> list[pd.DataFrame]:
    """Collecte stats mensuelles par couleur."""
    monthly_stats = []

    for couleur in ["blanc", "noir"]:
        pivot = _build_monthly_pivot(df_dated, couleur)
        if pivot is not None:
            monthly_stats.append(pivot)

    return monthly_stats


def _build_monthly_pivot(df_dated: pd.DataFrame, couleur: str) -> pd.DataFrame | None:
    """Construit le pivot mensuel pour une couleur."""
    nom_col = f"{couleur}_nom"
    if nom_col not in df_dated.columns:
        return None

    matchs_joues = ~df_dated["type_resultat"].isin(
        ["non_joue", f"forfait_{couleur}", "double_forfait"]
    )

    df_couleur = df_dated[[nom_col, "mois"]].copy()
    df_couleur["joue"] = matchs_joues.astype(int)

    pivot = df_couleur.pivot_table(
        values="joue", index=nom_col, columns="mois", aggfunc="mean", fill_value=0
    )
    pivot = pivot.reset_index().rename(columns={nom_col: "joueur_nom"})
    pivot.columns = ["joueur_nom"] + [f"dispo_mois_{m}" for m in pivot.columns[1:]]

    return pivot


def _merge_monthly_stats(monthly_stats: list[pd.DataFrame]) -> pd.DataFrame:
    """Fusionne les stats mensuelles blanc/noir."""
    if not monthly_stats:
        return pd.DataFrame()

    if len(monthly_stats) == 1:
        return monthly_stats[0]

    result = monthly_stats[0].merge(
        monthly_stats[1], on="joueur_nom", how="outer", suffixes=("_b", "_n")
    )

    for m in range(1, 13):
        col_b, col_n = f"dispo_mois_{m}_b", f"dispo_mois_{m}_n"
        if col_b in result.columns and col_n in result.columns:
            result[f"dispo_mois_{m}"] = result[[col_b, col_n]].mean(axis=1)
            result = result.drop(columns=[col_b, col_n])

    return result

	"""Features de fiabilité club/joueur - ISO 5055/25012.

	Ce module extrait les features de fiabilité basées sur les forfaits
	et les patterns de présence.

	Conformité:
	- ISO 5055: Module <300 lignes, responsabilité unique
	- ISO 25012: Qualité données (fiabilité, complétude)
	"""

	from __future__ import annotations

	import logging

	import pandas as pd

	logger = logging.getLogger(__name__)


	def extract_club_reliability(df: pd.DataFrame) -> pd.DataFrame:
	"""Extrait les features de fiabilité par club.

	Utilise les non_joue et forfaits pour identifier les clubs défaillants.

	Args:
	----
	df: DataFrame échiquiers complet (avant filtrage)

	Returns:
	-------
	DataFrame avec colonnes:
	- equipe: nom du club
	- taux_forfait: % de forfaits sur l'historique
	- taux_non_joue: % de matchs non joués
	- fiabilite_score: score composite (1 - taux_défaillance)

	ISO 25012: Fiabilité mesurée depuis données réelles.
	"""
	logger.info("Extraction features fiabilité clubs...")

	if df.empty or "type_resultat" not in df.columns:
	logger.warning(" DataFrame vide ou colonnes manquantes")
	return pd.DataFrame()

	forfaits_types = ["forfait_blanc", "forfait_noir", "double_forfait"]

	club_stats = []

	for equipe_col in ["equipe_dom", "equipe_ext"]:
	if equipe_col not in df.columns:
	continue

	stats = df.groupby(equipe_col).agg(
	total_matchs=("type_resultat", "count"),
	forfaits=("type_resultat", lambda x: x.isin(forfaits_types).sum()),
	non_joue=("type_resultat", lambda x: (x == "non_joue").sum()),
	)
	stats = stats.reset_index().rename(columns={equipe_col: "equipe"})
	club_stats.append(stats)

	if not club_stats:
	return pd.DataFrame()

	# Fusionner dom + ext
	all_stats = pd.concat(club_stats).groupby("equipe").sum().reset_index()

	# Calculer taux (éviter division par zéro)
	all_stats["taux_forfait"] = all_stats["forfaits"] / all_stats["total_matchs"].replace(0, 1)
	all_stats["taux_non_joue"] = all_stats["non_joue"] / all_stats["total_matchs"].replace(0, 1)
	all_stats["fiabilite_score"] = 1 - (
	all_stats["taux_forfait"] * 0.7 + all_stats["taux_non_joue"] * 0.3
	)

	logger.info(f" {len(all_stats)} clubs avec stats fiabilité")

	return all_stats[["equipe", "taux_forfait", "taux_non_joue", "fiabilite_score"]]


	def extract_player_reliability(df: pd.DataFrame) -> pd.DataFrame:
	"""Extrait les features de fiabilité par joueur.

	Analyse les patterns de présence/absence pour chaque joueur.

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

	Returns:
	-------
	DataFrame avec colonnes:
	- joueur_nom: nom complet du joueur
	- nb_matchs: nombre total de matchs
	- taux_presence: % de matchs effectivement joués
	- joueur_fantome: flag si < 20% présence

	ISO 25012: Complétude mesurée par taux de présence.
	"""
	logger.info("Extraction features fiabilité joueurs...")

	if df.empty or "type_resultat" not in df.columns:
	logger.warning(" DataFrame vide ou colonnes manquantes")
	return pd.DataFrame()

	player_stats = []

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

	df_couleur = df[df[nom_col].notna()].copy()

	# Identifier les matchs joués vs non joués
	matchs_joues = ~df_couleur["type_resultat"].isin(
	["non_joue", f"forfait_{couleur}", "double_forfait"]
	)

	# Capture matchs_joues via default arg to avoid B023
	stats = (
	df_couleur.groupby(nom_col)
	.agg(
	nb_matchs=("type_resultat", "count"),
	matchs_joues=(
	"type_resultat",
	lambda x, mj=matchs_joues: mj[x.index].sum(),
	),
	)
	.reset_index()
	.rename(columns={nom_col: "joueur_nom"})
	)
	player_stats.append(stats)

	if not player_stats:
	return pd.DataFrame()

	# Fusionner blanc + noir
	all_stats = pd.concat(player_stats).groupby("joueur_nom").sum().reset_index()

	# Calculer taux (éviter division par zéro)
	all_stats["taux_presence"] = all_stats["matchs_joues"] / all_stats["nb_matchs"].replace(0, 1)
	all_stats["joueur_fantome"] = all_stats["taux_presence"] < 0.2

	logger.info(f" {len(all_stats)} joueurs avec stats fiabilité")
	logger.info(f" {all_stats['joueur_fantome'].sum()} joueurs fantômes (<20% présence)")

	return all_stats[["joueur_nom", "nb_matchs", "taux_presence", "joueur_fantome"]]


	def extract_player_monthly_pattern(df: pd.DataFrame) -> pd.DataFrame:
	"""Extrait les patterns de disponibilité mensuelle par joueur.

	Détecte les joueurs indisponibles certains mois (vacances, pro, etc.)

	Args:
	----
	df: DataFrame échiquiers avec colonne 'date'

	Returns:
	-------
	DataFrame avec colonnes:
	- joueur_nom: nom complet
	- dispo_mois_1 ... dispo_mois_12: taux présence par mois

	ISO 5259: Feature temporelle pour prédiction disponibilité.
	"""
	logger.info("Extraction patterns mensuels joueurs...")

	df_dated = _prepare_dated_df(df)
	if df_dated.empty:
	return pd.DataFrame()

	monthly_stats = _collect_monthly_stats(df_dated)
	result = _merge_monthly_stats(monthly_stats)

	logger.info(f" {len(result)} joueurs avec patterns mensuels")
	return result


	def _prepare_dated_df(df: pd.DataFrame) -> pd.DataFrame:
	"""Prepare le DataFrame avec dates."""
	if df.empty or "date" not in df.columns:
	logger.warning(" Colonnes date manquantes, skip patterns mensuels")
	return pd.DataFrame()

	df_dated = df[df["date"].notna()].copy()
	if len(df_dated) == 0:
	logger.warning(" Pas de dates disponibles, skip patterns mensuels")
	return pd.DataFrame()

	df_dated["mois"] = pd.to_datetime(df_dated["date"]).dt.month
	return df_dated


	def _collect_monthly_stats(df_dated: pd.DataFrame) -> list[pd.DataFrame]:
	"""Collecte stats mensuelles par couleur."""
	monthly_stats = []

	for couleur in ["blanc", "noir"]:
	pivot = _build_monthly_pivot(df_dated, couleur)
	if pivot is not None:
	monthly_stats.append(pivot)

	return monthly_stats


	def _build_monthly_pivot(df_dated: pd.DataFrame, couleur: str) -> pd.DataFrame \| None:
	"""Construit le pivot mensuel pour une couleur."""
	nom_col = f"{couleur}_nom"
	if nom_col not in df_dated.columns:
	return None

	matchs_joues = ~df_dated["type_resultat"].isin(
	["non_joue", f"forfait_{couleur}", "double_forfait"]
	)

	df_couleur = df_dated[[nom_col, "mois"]].copy()
	df_couleur["joue"] = matchs_joues.astype(int)

	pivot = df_couleur.pivot_table(
	values="joue", index=nom_col, columns="mois", aggfunc="mean", fill_value=0
	)
	pivot = pivot.reset_index().rename(columns={nom_col: "joueur_nom"})
	pivot.columns = ["joueur_nom"] + [f"dispo_mois_{m}" for m in pivot.columns[1:]]

	return pivot


	def _merge_monthly_stats(monthly_stats: list[pd.DataFrame]) -> pd.DataFrame:
	"""Fusionne les stats mensuelles blanc/noir."""
	if not monthly_stats:
	return pd.DataFrame()

	if len(monthly_stats) == 1:
	return monthly_stats[0]

	result = monthly_stats[0].merge(
	monthly_stats[1], on="joueur_nom", how="outer", suffixes=("_b", "_n")
	)

	for m in range(1, 13):
	col_b, col_n = f"dispo_mois_{m}_b", f"dispo_mois_{m}_n"
	if col_b in result.columns and col_n in result.columns:
	result[f"dispo_mois_{m}"] = result[[col_b, col_n]].mean(axis=1)
	result = result.drop(columns=[col_b, col_n])

	return result