# ============================================
# Fichier: trainers/cuml/svm_trainer.py
# ============================================

from cuml.svm import SVC
import cupy as cp
from typing import Optional

from cuml_trainer import CuMLTrainer
from config import Config
from interfaces.cuml_tfidf_vectorizer import CuMLTfidfVectorizer
from interfaces.metrics_calculator import DefaultMetricsCalculator

class SvmTrainer(CuMLTrainer):
    """
    Entraîneur spécifique utilisant un classifieur SVC (Support Vector Classifier) de la librairie cuML.
    Hérite de CuMLTrainer, qui hérite lui-même de BaseTrainer.
    
    Cette classe implémente les méthodes spécifiques à l'utilisation d'un modèle SVM
    pour la classification binaire ou multi-classes, en exploitant les capacités GPU
    offertes par la librairie cuML.
    """

    def __init__(self, config: Config, data_path: str, target_column: str) -> None:
        """
        Initialise un SvmTrainer avec la configuration et les paramètres
        du parent CuMLTrainer.

        :param config: Configuration globale du système.
        :param data_path: Chemin vers le fichier de données.
        :param target_column: Nom de la colonne cible.
        """
        super().__init__(config, data_path, target_column)

    def _build_classifier(self) -> None:
        """
        Crée et configure un classifieur SVC selon les paramètres 
        spécifiés dans la configuration.
        
        Utilise directement les paramètres de la configuration pour initialiser
        le modèle avec les hyperparamètres appropriés (ex: kernel, C, gamma, etc.).
        """
        params = self.config.model.params or {}
        self.classifier = SVC(**params)

    def build_components(self) -> None:
        """
        Instancie le vectorizer, le classifieur SVC et le calculateur de métriques.
        
        Cette méthode configure tous les composants nécessaires au fonctionnement
        du trainer, en se basant sur les paramètres spécifiés dans la configuration.
        """
        # Récupération de la méthode et des paramètres de vectorisation
        vector_method = self.config.vectorization.method
        vector_params = self.config.vectorization.dict().get(vector_method, {})
        self.vectorizer = CuMLTfidfVectorizer(**vector_params)

        # Construction du classifieur
        self._build_classifier()
        
        # Initialisation du calculateur de métriques
        self.metrics_calculator = DefaultMetricsCalculator()

    def train(self) -> None:
        """
        Entraîne le classifieur SVC sur les données vectorisées.
        
        Utilise l'implémentation fournie par la classe parente CuMLTrainer,
        qui s'occupe du chargement des données, de la vectorisation et de l'entraînement.
        """
        super().train()

    def evaluate(self) -> dict:
        """
        Évalue le classifieur SVC et calcule les métriques appropriées.
        
        Utilise l'implémentation fournie par la classe parente CuMLTrainer,
        qui s'occupe du chargement des données, de la vectorisation, de la prédiction
        et du calcul des métriques via le metrics_calculator.
        
        :return: Dictionnaire contenant les métriques calculées.
        """
        return super().evaluate()

    def _get_binary_predictions(self, X: cp.ndarray) -> cp.ndarray:
        """
        Retourne les prédictions binaires du modèle SVC.
        
        Cette méthode est spécifiquement utilisée pour obtenir des prédictions
        binaires (0/1) à partir du modèle entraîné.
        
        :param X: Matrice de caractéristiques au format cupy.ndarray.
        :return: Vecteur de prédictions binaires.
        """
        X_prepared = self._prepare_input_for_predict(X)
        return self.classifier.predict(X_prepared)
    
    def _get_positive_probabilities(self, X: cp.ndarray) -> Optional[cp.ndarray]:
        """
        Retourne les probabilités de la classe positive si disponible.
        
        Cette méthode est utilisée pour obtenir les probabilités d'appartenance
        à la classe positive, utile notamment pour calculer l'AUC-ROC ou 
        pour des seuils de décision personnalisés.
        
        :param X: Matrice de caractéristiques au format cupy.ndarray.
        :return: Vecteur de probabilités ou None si non disponible.
        """
        if hasattr(self.classifier, 'predict_proba'):
            X_prepared = self._prepare_input_for_predict(X)
            return self.classifier.predict_proba(X_prepared)[:, 1]
        return None