"""
Model Comparison Utility for Music Classification

Project: Music Classification Dataset
Author: Molla Samser
Company: RSK World
Designer & Tester: Rima Khatun
Website: https://rskworld.in
Email: help@rskworld.in, support@rskworld.in
Phone: +91 93305 39277
Description: Compare different ML models for music genre classification
License: Educational Purpose Only
"""

import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import seaborn as sns
from sklearn.ensemble import RandomForestClassifier, GradientBoostingClassifier
from sklearn.svm import SVC
from sklearn.neighbors import KNeighborsClassifier
from sklearn.naive_bayes import GaussianNB
from sklearn.tree import DecisionTreeClassifier
from sklearn.linear_model import LogisticRegression
from sklearn.metrics import accuracy_score, precision_score, recall_score, f1_score
from sklearn.metrics import confusion_matrix, classification_report
import time
import warnings
warnings.filterwarnings('ignore')


class ModelComparator:
    """
    Compare multiple ML models for music genre classification
    
    Author: Molla Samser (RSK World)
    Website: https://rskworld.in
    Email: help@rskworld.in
    Phone: +91 93305 39277
    """
    
    def __init__(self):
        """Initialize Model Comparator"""
        self.models = {}
        self.results = {}
        self.setup_models()
    
    def setup_models(self):
        """
        Setup all models for comparison
        
        Author: Molla Samser (RSK World)
        """
        self.models = {
            'Random Forest': RandomForestClassifier(n_estimators=100, random_state=42),
            'Gradient Boosting': GradientBoostingClassifier(n_estimators=100, random_state=42),
            'SVM (RBF)': SVC(kernel='rbf', random_state=42, probability=True),
            'SVM (Linear)': SVC(kernel='linear', random_state=42, probability=True),
            'KNN (k=5)': KNeighborsClassifier(n_neighbors=5),
            'KNN (k=7)': KNeighborsClassifier(n_neighbors=7),
            'Decision Tree': DecisionTreeClassifier(random_state=42),
            'Naive Bayes': GaussianNB(),
            'Logistic Regression': LogisticRegression(max_iter=1000, random_state=42)
        }
    
    def train_and_evaluate(self, X_train, y_train, X_test, y_test):
        """
        Train and evaluate all models
        
        Args:
            X_train: Training features
            y_train: Training labels
            X_test: Test features
            y_test: Test labels
        """
        print("="*70)
        print("Model Comparison - Music Genre Classification")
        print("Author: Molla Samser | Company: RSK World")
        print("="*70)
        print(f"\nTraining {len(self.models)} models...")
        print(f"Training samples: {len(X_train)}")
        print(f"Test samples: {len(X_test)}\n")
        
        for name, model in self.models.items():
            print(f"Training {name}...")
            
            # Train
            start_time = time.time()
            model.fit(X_train, y_train)
            train_time = time.time() - start_time
            
            # Predict
            start_time = time.time()
            y_pred = model.predict(X_test)
            predict_time = time.time() - start_time
            
            # Metrics
            accuracy = accuracy_score(y_test, y_pred)
            precision = precision_score(y_test, y_pred, average='weighted', zero_division=0)
            recall = recall_score(y_test, y_pred, average='weighted', zero_division=0)
            f1 = f1_score(y_test, y_pred, average='weighted', zero_division=0)
            
            self.results[name] = {
                'model': model,
                'accuracy': accuracy,
                'precision': precision,
                'recall': recall,
                'f1_score': f1,
                'train_time': train_time,
                'predict_time': predict_time,
                'predictions': y_pred
            }
            
            print(f"  ✓ Accuracy: {accuracy*100:.2f}% | Time: {train_time:.2f}s\n")
        
        print("All models trained successfully!")
    
    def get_results_dataframe(self):
        """
        Get results as pandas DataFrame
        
        Returns:
            DataFrame with model comparison results
        """
        data = []
        for name, results in self.results.items():
            data.append({
                'Model': name,
                'Accuracy': results['accuracy'] * 100,
                'Precision': results['precision'] * 100,
                'Recall': results['recall'] * 100,
                'F1-Score': results['f1_score'] * 100,
                'Train Time (s)': results['train_time'],
                'Predict Time (s)': results['predict_time']
            })
        
        df = pd.DataFrame(data)
        df = df.sort_values('Accuracy', ascending=False)
        return df
    
    def plot_comparison(self, save_path=None):
        """
        Plot model comparison
        
        Author: Molla Samser
        Company: RSK World
        Website: https://rskworld.in
        """
        df = self.get_results_dataframe()
        
        fig, axes = plt.subplots(2, 2, figsize=(15, 10))
        fig.suptitle('Music Genre Classification - Model Comparison\nRSK World - Molla Samser', 
                     fontsize=14, fontweight='bold')
        
        # Accuracy comparison
        axes[0, 0].barh(df['Model'], df['Accuracy'], color='steelblue')
        axes[0, 0].set_xlabel('Accuracy (%)')
        axes[0, 0].set_title('Model Accuracy Comparison')
        axes[0, 0].grid(axis='x', alpha=0.3)
        
        # Metrics comparison
        metrics = ['Accuracy', 'Precision', 'Recall', 'F1-Score']
        x = np.arange(len(df))
        width = 0.2
        
        for i, metric in enumerate(metrics):
            axes[0, 1].bar(x + i*width, df[metric], width, label=metric)
        
        axes[0, 1].set_xlabel('Models')
        axes[0, 1].set_ylabel('Score (%)')
        axes[0, 1].set_title('Performance Metrics Comparison')
        axes[0, 1].set_xticks(x + width * 1.5)
        axes[0, 1].set_xticklabels(df['Model'], rotation=45, ha='right')
        axes[0, 1].legend()
        axes[0, 1].grid(axis='y', alpha=0.3)
        
        # Training time comparison
        axes[1, 0].barh(df['Model'], df['Train Time (s)'], color='coral')
        axes[1, 0].set_xlabel('Training Time (seconds)')
        axes[1, 0].set_title('Training Time Comparison')
        axes[1, 0].grid(axis='x', alpha=0.3)
        
        # Accuracy vs Time scatter
        axes[1, 1].scatter(df['Train Time (s)'], df['Accuracy'], 
                          s=100, c='green', alpha=0.6, edgecolors='black')
        for idx, row in df.iterrows():
            axes[1, 1].annotate(row['Model'], 
                               (row['Train Time (s)'], row['Accuracy']),
                               fontsize=8, ha='right')
        axes[1, 1].set_xlabel('Training Time (seconds)')
        axes[1, 1].set_ylabel('Accuracy (%)')
        axes[1, 1].set_title('Accuracy vs Training Time')
        axes[1, 1].grid(alpha=0.3)
        
        plt.tight_layout()
        
        if save_path:
            plt.savefig(save_path, dpi=300, bbox_inches='tight')
            print(f"\nPlot saved to {save_path}")
        
        plt.show()
    
    def print_results(self):
        """Print detailed results"""
        df = self.get_results_dataframe()
        
        print("\n" + "="*70)
        print("Model Comparison Results")
        print("="*70)
        print(df.to_string(index=False))
        print("="*70)
        
        best_model = df.iloc[0]['Model']
        best_accuracy = df.iloc[0]['Accuracy']
        
        print(f"\n🏆 Best Model: {best_model}")
        print(f"   Accuracy: {best_accuracy:.2f}%")
        
        print("\n© 2026 RSK World - Molla Samser")
        print("Website: https://rskworld.in")
    
    def get_best_model(self):
        """Get the best performing model"""
        best_name = max(self.results, key=lambda x: self.results[x]['accuracy'])
        return best_name, self.results[best_name]['model']


# Example usage
if __name__ == "__main__":
    """
    Demo script for ModelComparator
    
    Author: Molla Samser
    Company: RSK World
    Website: https://rskworld.in
    """
    print("Model Comparison Utility")
    print("Author: Molla Samser | RSK World")
    print("Website: https://rskworld.in")
    print("\nThis utility compares multiple ML models:")
    print("- Random Forest")
    print("- Gradient Boosting")
    print("- SVM (RBF & Linear)")
    print("- K-Nearest Neighbors")
    print("- Decision Tree")
    print("- Naive Bayes")
    print("- Logistic Regression")
    
    print("\n© 2026 RSK World - Molla Samser")

"""
Feature Extractor Module for Music Classification

Project: Music Classification Dataset
Author: Molla Samser
Company: RSK World
Designer & Tester: Rima Khatun
Website: https://rskworld.in
Email: help@rskworld.in, support@rskworld.in
Phone: +91 93305 39277
Description: Extract audio features for music genre classification
License: Educational Purpose Only
"""

import librosa
import numpy as np
from typing import Dict, List, Tuple
import warnings
warnings.filterwarnings('ignore')


class FeatureExtractor:
    """
    Feature extraction class for audio analysis
    
    Author: Molla Samser (RSK World)
    Website: https://rskworld.in
    """
    
    def __init__(self, sample_rate: int = 22050):
        """
        Initialize FeatureExtractor
        
        Args:
            sample_rate: Sample rate of audio files
        """
        self.sample_rate = sample_rate
        
    def extract_mfcc(self, audio: np.ndarray, n_mfcc: int = 13) -> np.ndarray:
        """
        Extract MFCC features
        
        Args:
            audio: Audio time series
            n_mfcc: Number of MFCCs to extract
            
        Returns:
            MFCC features array
        """
        mfcc = librosa.feature.mfcc(y=audio, sr=self.sample_rate, n_mfcc=n_mfcc)
        return np.mean(mfcc.T, axis=0)
    
    def extract_spectral_centroid(self, audio: np.ndarray) -> float:
        """
        Extract spectral centroid
        
        Args:
            audio: Audio time series
            
        Returns:
            Mean spectral centroid value
        """
        spectral_centroid = librosa.feature.spectral_centroid(y=audio, sr=self.sample_rate)
        return np.mean(spectral_centroid)
    
    def extract_spectral_rolloff(self, audio: np.ndarray) -> float:
        """
        Extract spectral rolloff
        
        Args:
            audio: Audio time series
            
        Returns:
            Mean spectral rolloff value
        """
        spectral_rolloff = librosa.feature.spectral_rolloff(y=audio, sr=self.sample_rate)
        return np.mean(spectral_rolloff)
    
    def extract_zero_crossing_rate(self, audio: np.ndarray) -> float:
        """
        Extract zero crossing rate
        
        Args:
            audio: Audio time series
            
        Returns:
            Mean zero crossing rate
        """
        zcr = librosa.feature.zero_crossing_rate(audio)
        return np.mean(zcr)
    
    def extract_chroma(self, audio: np.ndarray) -> np.ndarray:
        """
        Extract chroma features
        
        Args:
            audio: Audio time series
            
        Returns:
            Chroma features array
        """
        chroma = librosa.feature.chroma_stft(y=audio, sr=self.sample_rate)
        return np.mean(chroma.T, axis=0)
    
    def extract_tempo(self, audio: np.ndarray) -> float:
        """
        Extract tempo (BPM)
        
        Args:
            audio: Audio time series
            
        Returns:
            Tempo in beats per minute
        """
        tempo, _ = librosa.beat.beat_track(y=audio, sr=self.sample_rate)
        return float(tempo)
    
    def extract_spectral_bandwidth(self, audio: np.ndarray) -> float:
        """
        Extract spectral bandwidth
        
        Args:
            audio: Audio time series
            
        Returns:
            Mean spectral bandwidth
        """
        spectral_bandwidth = librosa.feature.spectral_bandwidth(y=audio, sr=self.sample_rate)
        return np.mean(spectral_bandwidth)
    
    def extract_rms_energy(self, audio: np.ndarray) -> float:
        """
        Extract RMS energy
        
        Args:
            audio: Audio time series
            
        Returns:
            Mean RMS energy
        """
        rms = librosa.feature.rms(y=audio)
        return np.mean(rms)
    
    def extract_all_features(self, audio: np.ndarray) -> Dict[str, any]:
        """
        Extract all features at once
        
        Args:
            audio: Audio time series
            
        Returns:
            Dictionary containing all extracted features
        """
        features = {
            'mfcc': self.extract_mfcc(audio),
            'spectral_centroid': self.extract_spectral_centroid(audio),
            'spectral_rolloff': self.extract_spectral_rolloff(audio),
            'zero_crossing_rate': self.extract_zero_crossing_rate(audio),
            'chroma': self.extract_chroma(audio),
            'tempo': self.extract_tempo(audio),
            'spectral_bandwidth': self.extract_spectral_bandwidth(audio),
            'rms_energy': self.extract_rms_energy(audio)
        }
        
        return features
    
    def flatten_features(self, features: Dict[str, any]) -> np.ndarray:
        """
        Flatten feature dictionary to 1D array
        
        Args:
            features: Dictionary of features
            
        Returns:
            Flattened feature array
        """
        feature_list = []
        
        for key, value in features.items():
            if isinstance(value, np.ndarray):
                feature_list.extend(value)
            else:
                feature_list.append(value)
        
        return np.array(feature_list)


# Example usage
if __name__ == "__main__":
    """
    Demo script for FeatureExtractor
    
    Author: Molla Samser
    Company: RSK World
    Website: https://rskworld.in
    """
    from audio_processor import AudioProcessor
    
    # Initialize processors
    audio_processor = AudioProcessor()
    feature_extractor = FeatureExtractor()
    
    # Example audio file
    audio_path = "../data/audio/jazz/jazz_001.wav"
    
    # Load audio
    print(f"Loading audio from: {audio_path}")
    audio = audio_processor.load_audio(audio_path)
    
    # Extract all features
    print("\nExtracting features...")
    features = feature_extractor.extract_all_features(audio)
    
    # Display features
    print("\nExtracted Features:")
    print(f"- MFCC shape: {features['mfcc'].shape}")
    print(f"- Spectral Centroid: {features['spectral_centroid']:.2f}")
    print(f"- Spectral Rolloff: {features['spectral_rolloff']:.2f}")
    print(f"- Zero Crossing Rate: {features['zero_crossing_rate']:.6f}")
    print(f"- Chroma shape: {features['chroma'].shape}")
    print(f"- Tempo: {features['tempo']:.2f} BPM")
    print(f"- Spectral Bandwidth: {features['spectral_bandwidth']:.2f}")
    print(f"- RMS Energy: {features['rms_energy']:.6f}")
    
    # Flatten features
    flat_features = feature_extractor.flatten_features(features)
    print(f"\nFlattened features shape: {flat_features.shape}")