code/scripts/feature_engineering.py

#!/usr/bin/env python3
"""Feature Engineering pour ALICE - Pipeline ML.

Ce module orchestre le pipeline de feature engineering.
Les features sont extraites par des modules specialises (ISO 5055 SRP).

Modules:
- features/reliability.py: Fiabilite club/joueur
- features/performance.py: Forme, couleur, position
- features/standings.py: Classement, zones d'enjeu
- features/advanced.py: H2H, fatigue, trajectoire Elo
- features/ffe_features.py: Features reglementaires FFE
- features/pipeline.py: Orchestration extraction/merge

Conformite ISO/IEC:
- 5055: Code maintenable (<300 lignes, SRP)
- 5259: Qualite donnees ML
- 25010: Qualite systeme
- 42001: Gouvernance IA

Usage:
    python scripts/feature_engineering.py
    python scripts/feature_engineering.py --output-dir data/features
"""

from __future__ import annotations

import argparse
import logging
from pathlib import Path

import pandas as pd

from scripts.features.pipeline import extract_all_features, merge_all_features

# Configuration paths
PROJECT_DIR = Path(__file__).parent.parent
DEFAULT_DATA_DIR = PROJECT_DIR / "data"

# Logging
logging.basicConfig(
    level=logging.INFO,
    format="%(asctime)s | %(levelname)-7s | %(message)s",
    datefmt="%H:%M:%S",
)
logger = logging.getLogger(__name__)


# ==============================================================================
# SPLIT TEMPOREL
# ==============================================================================


def temporal_split(
    df: pd.DataFrame,
    train_end: int = 2022,
    valid_end: int = 2023,
) -> tuple[pd.DataFrame, pd.DataFrame, pd.DataFrame]:
    """Split temporel des données pour éviter data leakage."""
    logger.info(
        f"Split temporel: train<={train_end}, valid={train_end + 1}-{valid_end}, test>{valid_end}"
    )

    train = df[df["saison"] <= train_end]
    valid = df[(df["saison"] > train_end) & (df["saison"] <= valid_end)]
    test = df[df["saison"] > valid_end]

    for name, split in [("Train", train), ("Valid", valid), ("Test", test)]:
        if not split.empty and "saison" in split.columns:
            logger.info(
                f"  {name}: {len(split):,} échiquiers "
                f"({split['saison'].min()}-{split['saison'].max()})"
            )
        else:
            logger.info(f"  {name}: {len(split):,} échiquiers")

    return train, valid, test


# ==============================================================================
# PIPELINE V2 - SANS DATA LEAKAGE (ISO 5259 / 42001)
# ==============================================================================


def compute_features_for_split(
    df_split: pd.DataFrame,
    df_history: pd.DataFrame,
    split_name: str,
    include_advanced: bool = True,
) -> pd.DataFrame:
    """Calcule les features pour un split avec historique approprié.

    ISO 5259: Pas de data leakage - historique limité au passé visible.
    ISO 5055: Complexité réduite via helpers (merge_helpers.py).
    """
    logger.info(
        f"  Computing features for {split_name} using {len(df_history):,} historical records..."
    )

    # Filter played games only
    df_history_played = df_history[
        ~df_history["type_resultat"].isin(
            ["non_joue", "forfait_blanc", "forfait_noir", "double_forfait"]
        )
    ]

    # Extract all features from history
    features = extract_all_features(df_history, df_history_played, include_advanced)

    # Merge features onto split
    result = merge_all_features(df_split.copy(), features, include_advanced)

    # Direct features (no history needed, computed per-row)
    _add_direct_features(result)

    # Temporal + adversaire features
    _add_contextual_features(result, df_history_played)

    logger.info(f"  {split_name}: {len(result):,} samples, {len(result.columns)} features")
    return result


def _add_direct_features(result: pd.DataFrame) -> None:
    """Add features computed directly from the row (no history needed)."""
    from scripts.features.composition import extract_home_feature, extract_title_features
    from scripts.features.player_enrichment import enrich_from_joueurs

    # Titre FIDE numérique + diff_titre
    title_feats = extract_title_features(result)
    for col in title_feats.columns:
        result[col] = title_feats[col]

    # Domicile blanc
    home_feat = extract_home_feature(result)
    for col in home_feat.columns:
        result[col] = home_feat[col]

    # Enrichissement joueur depuis joueurs.parquet (elo_type, categorie, k_coefficient)
    joueurs_path = DEFAULT_DATA_DIR / "joueurs.parquet"
    enrich_from_joueurs(result, joueurs_path)


def _add_contextual_features(result: pd.DataFrame, df_history_played: pd.DataFrame) -> None:
    """Add temporal, adversaire, and match context features."""
    from scripts.features.pipeline_extended import (
        extract_adversaire_niveau,
        extract_match_important,
        extract_temporal_features,
    )
    from scripts.features.standings import calculate_standings

    extract_temporal_features(result)
    standings = calculate_standings(df_history_played)
    extract_adversaire_niveau(result, standings)
    # match_important needs zone_enjeu columns already merged
    extract_match_important(result)


def run_feature_engineering_v2(
    data_dir: Path,
    output_dir: Path,
    include_advanced: bool = True,
) -> None:
    """Pipeline feature engineering V2 - SANS DATA LEAKAGE.

    ISO/IEC 42001, 5259 Conformant.
    """
    logger.info("=" * 60)
    logger.info("ALICE Engine - Feature Engineering V2 (No Leakage)")
    logger.info("ISO/IEC 42001, 5259 Conformant")
    logger.info("=" * 60)

    # Charger données
    echiquiers_path = data_dir / "echiquiers.parquet"
    if not echiquiers_path.exists():
        logger.error(f"Fichier non trouvé: {echiquiers_path}")
        logger.error("Exécutez d'abord: python scripts/parse_dataset.py")
        return

    logger.info(f"\nChargement {echiquiers_path}...")
    df = pd.read_parquet(echiquiers_path)
    logger.info(f"  {len(df):,} échiquiers chargés")

    # 1. Filtrer parties jouées et Elo valide
    logger.info("\n[1/4] Filtrage données...")
    df_played = df[
        ~df["type_resultat"].isin(["non_joue", "forfait_blanc", "forfait_noir", "double_forfait"])
    ]
    df_clean = df_played[(df_played["blanc_elo"] > 0) & (df_played["noir_elo"] > 0)]
    logger.info(f"  {len(df_clean):,} parties valides")

    # 2. SPLIT TEMPOREL D'ABORD (crucial pour éviter leakage)
    logger.info("\n[2/4] Split temporel AVANT features...")
    train_raw, valid_raw, test_raw = temporal_split(df_clean)

    # 3. Calculer features PAR SPLIT avec historique approprié
    logger.info("\n[3/4] Calcul features per-split (no leakage)...")

    # Train: features calculées sur train uniquement
    logger.info("\n  --- TRAIN ---")
    train = compute_features_for_split(
        df_split=train_raw,
        df_history=df[df["saison"] <= train_raw["saison"].max()],
        split_name="train",
        include_advanced=include_advanced,
    )

    # Valid: features calculées sur train + valid historique
    logger.info("\n  --- VALID ---")
    valid_history = df[df["saison"] <= valid_raw["saison"].max()]
    valid = compute_features_for_split(
        df_split=valid_raw,
        df_history=valid_history,
        split_name="valid",
        include_advanced=include_advanced,
    )

    # Test: features calculées sur tout l'historique (avant test)
    logger.info("\n  --- TEST ---")
    test_history = df[df["saison"] <= test_raw["saison"].min() - 1]
    test = compute_features_for_split(
        df_split=test_raw,
        df_history=test_history,
        split_name="test",
        include_advanced=include_advanced,
    )

    # 4. Export
    logger.info("\n[4/4] Export...")
    output_dir.mkdir(parents=True, exist_ok=True)

    train.to_parquet(output_dir / "train.parquet", index=False)
    valid.to_parquet(output_dir / "valid.parquet", index=False)
    test.to_parquet(output_dir / "test.parquet", index=False)

    # Résumé
    logger.info("\n" + "=" * 60)
    logger.info("Feature engineering V2 terminé!")
    logger.info("=" * 60)
    logger.info(f"\nFichiers générés dans {output_dir}/:")
    logger.info(f"  - train.parquet ({len(train):,} échiquiers, {len(train.columns)} features)")
    logger.info(f"  - valid.parquet ({len(valid):,} échiquiers)")
    logger.info(f"  - test.parquet ({len(test):,} échiquiers)")
    logger.info("\nDATA LEAKAGE: CORRIGÉ")
    logger.info("  - Split temporel effectué AVANT calcul des features")
    logger.info("  - Chaque split utilise uniquement les données historiques visibles")


def main() -> None:
    """Point d'entrée."""
    parser = argparse.ArgumentParser(description="Feature engineering ALICE")
    parser.add_argument(
        "--data-dir",
        type=Path,
        default=DEFAULT_DATA_DIR,
        help="Répertoire des données sources",
    )
    parser.add_argument(
        "--output-dir",
        type=Path,
        default=DEFAULT_DATA_DIR / "features",
        help="Répertoire de sortie",
    )
    parser.add_argument(
        "--no-advanced",
        action="store_true",
        help="Désactiver features avancées (H2H, fatigue, etc.)",
    )
    args = parser.parse_args()

    run_feature_engineering_v2(
        args.data_dir,
        args.output_dir,
        include_advanced=not args.no_advanced,
    )


if __name__ == "__main__":
    main()