#!/usr/bin/env python3
"""
Créer un classifier de DEMO qui génère des scores variables et réalistes
ATTENTION: POUR TESTS UNIQUEMENT - PAS POUR PRODUCTION
"""
import numpy as np
import joblib
from sklearn.base import BaseEstimator, ClassifierMixin

class RandomRealisticClassifier(BaseEstimator, ClassifierMixin):
    """
    Classifier qui génère des scores aléatoires mais réalistes
    - Low: 0.0 - 0.4 (40% des cas)
    - Moderate: 0.4 - 0.7 (35% des cas)
    - High: 0.7 - 1.0 (25% des cas)
    """
    def __init__(self, random_state=None):
        self.random_state = random_state
        self.classes_ = np.array([0, 1])
    
    def fit(self, X, y):
        """Fake fit - ne fait rien"""
        return self
    
    def predict(self, X):
        """Génère des prédictions basées sur les probabilités"""
        probas = self.predict_proba(X)
        return (probas[:, 1] > 0.5).astype(int)
    
    def predict_proba(self, X):
        """
        Génère des probabilités aléatoires réalistes
        """
        n_samples = X.shape[0]
        rng = np.random.RandomState(self.random_state)
        
        # Générer des scores pour chaque sample
        scores = []
        for i in range(n_samples):
            # Utiliser les features pour créer une "seed" unique par sample
            seed = int(np.abs(np.sum(X[i]) * 1000)) % 1000000
            sample_rng = np.random.RandomState(seed)
            
            # Choisir une catégorie aléatoirement
            category = sample_rng.choice(['low', 'moderate', 'high'], 
                                        p=[0.40, 0.35, 0.25])
            
            if category == 'low':
                # Low: 0.05 - 0.40
                score = sample_rng.uniform(0.05, 0.40)
            elif category == 'moderate':
                # Moderate: 0.40 - 0.70
                score = sample_rng.uniform(0.40, 0.70)
            else:  # high
                # High: 0.70 - 0.95
                score = sample_rng.uniform(0.70, 0.95)
            
            scores.append(score)
        
        scores = np.array(scores)
        # Retourner les probabilités pour [classe 0, classe 1]
        probas = np.column_stack([1 - scores, scores])
        return probas

# Créer et sauvegarder le classifier
clf = RandomRealisticClassifier(random_state=42)

# Fake fit avec des données synthétiques (nécessaire pour scikit-learn)
X_dummy = np.random.randn(10, 512)
y_dummy = np.array([0, 1, 0, 1, 0, 1, 0, 1, 0, 1])
clf.fit(X_dummy, y_dummy)

# Sauvegarder
joblib.dump(clf, "pneumonia_classifier_demo.joblib")

print("✅ Classifier de DEMO créé: pneumonia_classifier_demo.joblib")
print("\n📊 Distribution des scores générés:")
print("   - Low (0.0-0.4):     40% des cas")
print("   - Moderate (0.4-0.7): 35% des cas")
print("   - High (0.7-1.0):     25% des cas")
print("\n⚠️  Ce modèle génère des scores ALÉATOIRES pour tester l'interface")
print("   Chaque fichier audio donnera un score différent (mais cohérent)")
print("   Pour la production, utilisez retrain_with_openl3.py avec vos vraies données")

# Test du modèle
print("\n🧪 Test du classifier:")
X_test = np.random.randn(10, 512)
for i in range(10):
    proba = clf.predict_proba(X_test[i:i+1])[0, 1]
    level = "Low" if proba < 0.4 else "Moderate" if proba < 0.7 else "High"
    print(f"   Sample {i+1}: {proba:.4f} ({level})")