import os
import tempfile
import numpy as np
import pandas as pd
import torch
import torchaudio
import librosa
import matplotlib.pyplot as plt
import csv
from typing import List, Dict, Tuple, Optional
from scipy.stats import kurtosis, skew
import concurrent.futures
import multiprocessing
from functools import partial
import time
import threading
from queue import Queue
from dotenv import load_dotenv
from groq import Groq 

# Import required models
from pyannote.audio import Pipeline
import whisper
from transformers import Wav2Vec2ForSequenceClassification, Wav2Vec2Processor
from torch_vggish_yamnet import yamnet
from torch_vggish_yamnet.input_proc import WaveformToInput
import warnings
warnings.filterwarnings("ignore")

class UnifiedAudioAnalyzer:
    """
    Unified Audio Analysis System combining:
    1. Speaker Diarization + Transcription
    2. Audio Event Detection (YAMNet)
    3. Emotion Recognition + Paralinguistic Features
    
    Enhanced with parallel processing for faster execution
    """
    
    def __init__(self, enable_parallel_processing=True, max_workers=None):
        """Initialize all models and components"""
        print("🔄 Initializing Unified Audio Analyzer...")
        
        # Configure device
        self.device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
        print(f"Using device: {self.device}")
        
        # Parallel processing settings
        self.enable_parallel_processing = enable_parallel_processing
        self.max_workers = max_workers or max(1, multiprocessing.cpu_count() - 1)
        print(f"Parallel processing: {'Enabled' if enable_parallel_processing else 'Disabled'}")
        if enable_parallel_processing:
            print(f"Max workers: {self.max_workers}")
        
        # Initialize models
        self._load_diarization_models()
        self._load_emotion_models()
        self._load_event_detection_models()
        self._load_class_names()
        
        print("✅ All models loaded successfully!")
    
    def _load_diarization_models(self):
        """Load speaker diarization and transcription models"""
        print("Loading speaker diarization and transcription models...")
        
        # Load pyannote diarization pipeline
        try:
            self.diarization_pipeline = Pipeline.from_pretrained(
                "pyannote/speaker-diarization-3.1"
                # Uncomment and add your token: use_auth_token="YOUR_HUGGINGFACE_TOKEN"
            )
            if torch.cuda.is_available():
                self.diarization_pipeline = self.diarization_pipeline.to(self.device)
        except Exception as e:
            print(f"Warning: Could not load diarization model: {e}")
            self.diarization_pipeline = None
        
        # Load Whisper transcription model
        try:
            self.whisper_model = whisper.load_model("base")
        except Exception as e:
            print(f"Warning: Could not load Whisper model: {e}")
            self.whisper_model = None
    
    def _load_emotion_models(self):
        """Load emotion recognition models"""
        print("Loading emotion recognition models...")
        
        try:
            self.emotion_model = Wav2Vec2ForSequenceClassification.from_pretrained(
                "Dpngtm/wav2vec2-emotion-recognition"
            )
            self.emotion_processor = Wav2Vec2Processor.from_pretrained(
                "Dpngtm/wav2vec2-emotion-recognition"
            )
            self.emotion_labels = ["angry", "calm", "disgust", "fearful", "happy", "neutral", "sad", "surprised"]
        except Exception as e:
            print(f"Warning: Could not load emotion model: {e}")
            self.emotion_model = None
    
    def _load_event_detection_models(self):
        """Load YAMNet for audio event detection"""
        print("Loading audio event detection models...")
        
        try:
            self.yamnet_model = yamnet.yamnet(pretrained=True)
            self.yamnet_model.eval()
            self.yamnet_converter = WaveformToInput()
        except Exception as e:
            print(f"Warning: Could not load YAMNet model: {e}")
            self.yamnet_model = None
    
    def _load_class_names(self):
        """Load AudioSet class names for YAMNet from CSV"""
        csv_path = "yamnet_class_map.csv"
        self.audioset_classes = []
        try:
            with open(csv_path, "r") as f:
                reader = csv.reader(f)
                next(reader)  # skip header
                for row in reader:
                    self.audioset_classes.append(row[2])  # display_name
        except Exception as e:
            print(f"Warning: Could not load class names from {csv_path}: {e}")
            # Fallback to common AudioSet classes
            self.audioset_classes = [
                "Speech", "Male speech, man speaking", "Female speech, woman speaking",
                "Child speech, kid speaking", "Conversation", "Narration, monologue",
                "Babbling", "Speech synthesizer", "Shout", "Bellow", "Whoop", "Yell",
                "Children shouting", "Screaming", "Whispering", "Laughter", "Baby laughter",
                "Giggle", "Snicker", "Belly laugh", "Chuckle, chortle", "Crying, sobbing",
                "Baby cry, infant cry", "Whimper", "Wail, moan", "Sigh", "Singing",
                "Choir", "Yodeling", "Chant", "Mantra", "Male singing", "Female singing",
                "Child singing", "Synthetic singing", "Rapping", "Humming", "Music",
                "Musical instrument", "Piano", "Guitar", "Drum", "Orchestra", "Pop music",
                "Rock music", "Jazz", "Classical music", "Electronic music", "Animal",
                "Dog", "Cat", "Bird", "Insect", "Vehicle", "Car", "Motorcycle", "Train",
                "Aircraft", "Helicopter", "Wind", "Rain", "Thunder", "Water", "Fire",
                "Applause", "Crowd", "Footsteps", "Door", "Bell", "Alarm", "Clock"
            ]
    
    def _transcribe_segment_parallel(self, segment_data):
        """Helper function for parallel transcription of segments"""
        segment, sample_rate, speaker, start_time, end_time, whisper_model = segment_data
        
        try:
            # Create temporary file for this segment
            with tempfile.NamedTemporaryFile(suffix='.wav', delete=False) as temp_file:
                temp_filename = temp_file.name
                torchaudio.save(temp_filename, segment, sample_rate)
                
                # Transcribe segment
                try:
                    transcription_result = whisper_model.transcribe(
                        temp_filename,
                        language="en",
                        temperature=0,
                        no_speech_threshold=0.6
                    )
                    segment_text = transcription_result["text"].strip()
                    
                    if segment_text:
                        result = {
                            "speaker": speaker,
                            "start": round(start_time, 2),
                            "end": round(end_time, 2),
                            "duration": round(end_time - start_time, 2),
                            "text": segment_text,
                            "confidence": transcription_result.get("language_probability", 0.0)
                        }
                    else:
                        result = None
                        
                except Exception as e:
                    print(f"⚠️ Error transcribing segment: {e}")
                    result = None
                
                finally:
                    # Clean up temp file
                    try:
                        os.unlink(temp_filename)
                    except OSError:
                        pass
                
                return result
                
        except Exception as e:
            print(f"⚠️ Error in parallel transcription: {e}")
            return None
    
    def transcribe_with_diarization(self, audio_file: str, min_segment_duration: float = 1.0) -> List[Dict]:
        """Perform speaker diarization and transcription (aligned with main.py logic)"""
        if self.diarization_pipeline is None or self.whisper_model is None:
            print("❌ Diarization or transcription models not available")
            return []
        
        print("🎯 Performing speaker diarization and transcription...")
        
        # Perform diarization
        diarization_result = self.diarization_pipeline(audio_file,num_speakers=2)
        
        # Load audio
        waveform, sample_rate = torchaudio.load(audio_file)
        if sample_rate != 16000:
            waveform = torchaudio.functional.resample(waveform, sample_rate, 16000)
            sample_rate = 16000
        
        results = []
        temp_files = []
        
        try:
            for turn, _, speaker in diarization_result.itertracks(yield_label=True):
                if turn.end - turn.start < min_segment_duration:
                    continue
                
                # Extract segment
                start_sample = int(turn.start * sample_rate)
                end_sample = int(turn.end * sample_rate)
                segment = waveform[:, start_sample:end_sample]
                
                # Create temporary file for transcription
                with tempfile.NamedTemporaryFile(suffix='.wav', delete=False) as temp_file:
                    temp_filename = temp_file.name
                    temp_files.append(temp_filename)
                    torchaudio.save(temp_filename, segment, sample_rate)
                    
                    # Transcribe
                    try:
                        transcription_result = self.whisper_model.transcribe(
                            temp_filename,
                            language="en",
                            temperature=0,
                            no_speech_threshold=0.6
                        )
                        segment_text = transcription_result["text"].strip()
                        
                        if segment_text:
                            results.append({
                                "speaker": speaker,
                                "start": round(turn.start, 2),
                                "end": round(turn.end, 2),
                                "duration": round(turn.end - turn.start, 2),
                                "text": segment_text,
                                "confidence": transcription_result.get("language_probability", 0.0)
                            })
                    except Exception as e:
                        print(f"⚠️ Error transcribing segment: {e}")
                        continue
        
        finally:
            # Cleanup temp files
            for temp_file in temp_files:
                try:
                    os.unlink(temp_file)
                except OSError:
                    pass
        
        return results
    
    def detect_audio_events(self, audio_file: str, top_k: int = 10) -> Dict:
        """Detect audio events using YAMNet"""
        if self.yamnet_model is None:
            print("❌ YAMNet model not available")
            return {}
        
        print("🔊 Detecting audio events...")
        
        try:
            # Load and preprocess audio
            waveform, sr = torchaudio.load(audio_file)
            if sr != 16000:
                waveform = torchaudio.functional.resample(waveform, sr, 16000)
            
            # Process through YAMNet
            inputs = self.yamnet_converter(waveform, 16000)
            
            with torch.no_grad():
                embeddings, logits = self.yamnet_model(inputs)
                mean_logits = logits.mean(dim=0)
                probs = torch.softmax(mean_logits, dim=-1)
                top_probs, top_idx = torch.topk(probs, top_k)
            
            # Format results
            events = []
            for i in range(top_k):
                idx = top_idx[i].item()
                prob = top_probs[i].item()
                if idx < len(self.audioset_classes):
                    label = self.audioset_classes[idx]
                else:
                    label = f"Unknown_Class_{idx}"
                
                events.append({
                    "event": label,
                    "class_id": idx,
                    "probability": prob
                })
            
            return {
                "top_events": events,
                "total_classes": len(self.audioset_classes)
            }
        
        except Exception as e:
            print(f"⚠️ Error in event detection: {e}")
            return {}
    
    def _extract_feature_chunk(self, audio_chunk, sr, feature_type):
        """Helper function for parallel feature extraction"""
        try:
            if feature_type == "mfcc":
                mfcc = librosa.feature.mfcc(y=audio_chunk, sr=sr, n_mfcc=13)
                features = {}
                for i in range(13):
                    features[f'mfcc_{i+1}_mean'] = float(np.mean(mfcc[i]))
                    features[f'mfcc_{i+1}_std'] = float(np.std(mfcc[i]))
                return features
            
            elif feature_type == "chroma":
                chroma = librosa.feature.chroma_stft(y=audio_chunk, sr=sr)
                features = {}
                for i in range(12):
                    features[f'chroma_{i+1}_mean'] = float(np.mean(chroma[i]))
                return features
            
            elif feature_type == "spectral":
                features = {}
                features['spectral_centroid_mean'] = float(np.mean(librosa.feature.spectral_centroid(y=audio_chunk, sr=sr)[0]))
                features['spectral_rolloff_mean'] = float(np.mean(librosa.feature.spectral_rolloff(y=audio_chunk, sr=sr)[0]))
                return features
            
            elif feature_type == "basic":
                features = {}
                features['rms_energy'] = float(np.mean(librosa.feature.rms(y=audio_chunk)[0]))
                features['zero_crossing_rate'] = float(np.mean(librosa.feature.zero_crossing_rate(audio_chunk)[0]))
                return features
                
        except Exception as e:
            print(f"⚠️ Error extracting {feature_type} features: {e}")
            return {}
    
    def extract_paralinguistic_features(self, audio_data, sr):
        """Extract comprehensive paralinguistic features"""
        print("🎵 Extracting paralinguistic features...")
        
        features = {}
        
        # Basic properties
        features['duration'] = len(audio_data) / sr
        features['sample_rate'] = sr
        
        if self.enable_parallel_processing:
            print("🚀 Using parallel feature extraction...")
            
            # Prepare feature extraction tasks
            feature_tasks = [
                ("mfcc", audio_data, sr),
                ("chroma", audio_data, sr),
                ("spectral", audio_data, sr),
                ("basic", audio_data, sr)
            ]
            
            # Execute feature extraction in parallel
            with concurrent.futures.ThreadPoolExecutor(max_workers=min(4, self.max_workers)) as executor:
                future_to_feature = {
                    executor.submit(self._extract_feature_chunk, audio_chunk, sr, feature_type): feature_type
                    for feature_type, audio_chunk, sr in feature_tasks
                }
                
                for future in concurrent.futures.as_completed(future_to_feature):
                    feature_result = future.result()
                    features.update(feature_result)
        else:
            # Sequential feature extraction (original logic)
            # Energy features
            features['rms_energy'] = float(np.mean(librosa.feature.rms(y=audio_data)[0]))
            features['zero_crossing_rate'] = float(np.mean(librosa.feature.zero_crossing_rate(audio_data)[0]))
            
            # MFCC features
            mfcc = librosa.feature.mfcc(y=audio_data, sr=sr, n_mfcc=13)
            for i in range(13):
                features[f'mfcc_{i+1}_mean'] = float(np.mean(mfcc[i]))
                features[f'mfcc_{i+1}_std'] = float(np.std(mfcc[i]))
            
            # Spectral features
            features['spectral_centroid_mean'] = float(np.mean(librosa.feature.spectral_centroid(y=audio_data, sr=sr)[0]))
            features['spectral_rolloff_mean'] = float(np.mean(librosa.feature.spectral_rolloff(y=audio_data, sr=sr)[0]))
            
            # Chroma features
            chroma = librosa.feature.chroma_stft(y=audio_data, sr=sr)
            for i in range(12):
                features[f'chroma_{i+1}_mean'] = float(np.mean(chroma[i]))
        
        # Pitch features (kept sequential due to complexity)
        try:
            pitches, magnitudes = librosa.piptrack(y=audio_data, sr=sr, threshold=0.1)
            pitch_values = []
            for t in range(pitches.shape[1]):
                index = magnitudes[:, t].argmax()
                pitch = pitches[index, t]
                if pitch > 0:
                    pitch_values.append(pitch)
            
            if pitch_values:
                features['pitch_mean'] = float(np.mean(pitch_values))
                features['pitch_std'] = float(np.std(pitch_values))
                features['pitch_min'] = float(np.min(pitch_values))
                features['pitch_max'] = float(np.max(pitch_values))
            else:
                features.update({'pitch_mean': 0.0, 'pitch_std': 0.0, 'pitch_min': 0.0, 'pitch_max': 0.0})
        except:
            features.update({'pitch_mean': 0.0, 'pitch_std': 0.0, 'pitch_min': 0.0, 'pitch_max': 0.0})
        
        # Tempo
        try:
            tempo, _ = librosa.beat.beat_track(y=audio_data, sr=sr)
            if isinstance(tempo, np.ndarray):
                features['tempo'] = float(tempo.item() if tempo.size == 1 else tempo[0])
            else:
                features['tempo'] = float(tempo)
        except:
            features['tempo'] = 0.0
        
        return features
    
    def predict_emotion(self, audio_data, sr):
        """Predict emotion using transformer model"""
        if self.emotion_model is None:
            return None
        
        print("😊 Predicting emotions...")
        
        try:
            # Resample to 16kHz if needed
            if sr != 16000:
                audio_data = librosa.resample(audio_data, orig_sr=sr, target_sr=16000)
            
            # Process through model
            inputs = self.emotion_processor(audio_data, sampling_rate=16000, return_tensors="pt", padding=True)
            
            with torch.no_grad():
                outputs = self.emotion_model(**inputs)
                predictions = torch.nn.functional.softmax(outputs.logits, dim=-1)
            
            # Get emotion probabilities
            emotion_probs = {}
            for i, emotion in enumerate(self.emotion_labels):
                emotion_probs[emotion] = predictions[0][i].item()
            
            predicted_emotion = self.emotion_labels[predictions.argmax().item()]
            confidence = predictions.max().item()
            
            return {
                'predicted_emotion': predicted_emotion,
                'confidence': confidence,
                'all_emotions': emotion_probs
            }
            
        except Exception as e:
            print(f"⚠️ Error in emotion prediction: {e}")
            return None
    
    def analyze_complete_audio(self, audio_file: str) -> Dict:
        """Perform complete unified audio analysis with parallel processing"""
        if not os.path.exists(audio_file):
            print(f"❌ Audio file not found: {audio_file}")
            return {}
        
        print(f"\n🚀 Starting complete analysis of: {audio_file}")
        print("="*60)
        
        start_time = time.time()
        
        # Load audio for paralinguistic analysis
        try:
            audio_data, sr = librosa.load(audio_file, sr=22050)
            audio_data, _ = librosa.effects.trim(audio_data, top_db=20)
            audio_data = librosa.util.normalize(audio_data)
        except Exception as e:
            print(f"❌ Error loading audio: {e}")
            return {}
        
        if self.enable_parallel_processing:
            print("🚀 Running analysis components in parallel...")
            
            # Create a queue for results
            results_queue = Queue()
            
            # Define analysis functions
            def run_diarization():
                result = self.transcribe_with_diarization(audio_file)
                results_queue.put(('diarization', result))
            
            def run_event_detection():
                result = self.detect_audio_events(audio_file)
                results_queue.put(('events', result))
            
            def run_feature_extraction():
                result = self.extract_paralinguistic_features(audio_data, sr)
                results_queue.put(('features', result))
            
            def run_emotion_prediction():
                result = self.predict_emotion(audio_data, sr)
                results_queue.put(('emotion', result))
            
            # Start threads for parallel execution
            threads = [
                threading.Thread(target=run_diarization),
                threading.Thread(target=run_event_detection),
                threading.Thread(target=run_feature_extraction),
                threading.Thread(target=run_emotion_prediction)
            ]
            
            # Start all threads
            for thread in threads:
                thread.start()
            
            # Wait for all threads to complete
            for thread in threads:
                thread.join()
            
            # Collect results
            analysis_components = {}
            while not results_queue.empty():
                component, result = results_queue.get()
                analysis_components[component] = result
            
            # Assign results
            diarization_results = analysis_components.get('diarization', [])
            event_results = analysis_components.get('events', {})
            paralinguistic_features = analysis_components.get('features', {})
            emotion_results = analysis_components.get('emotion', None)
            
        else:
            # Sequential processing (original logic)
            # 1. Speaker Diarization + Transcription
            diarization_results = self.transcribe_with_diarization(audio_file)
            
            # 2. Audio Event Detection
            event_results = self.detect_audio_events(audio_file)
            
            # 3. Paralinguistic Features
            paralinguistic_features = self.extract_paralinguistic_features(audio_data, sr)
            
            # 4. Emotion Recognition
            emotion_results = self.predict_emotion(audio_data, sr)
        
        processing_time = time.time() - start_time
        print(f"⏱️ Total processing time: {processing_time:.2f} seconds")
        
        # Combine all results
        complete_analysis = {
            'file_info': {
                'filename': os.path.basename(audio_file),
                'filepath': audio_file,
                'duration': paralinguistic_features.get('duration', 0),
                'sample_rate': paralinguistic_features.get('sample_rate', 0),
                'processing_time': processing_time
            },
            'diarization_transcription': diarization_results,
            'audio_events': event_results,
            'paralinguistic_features': paralinguistic_features,
            'emotion_analysis': emotion_results
        }
        
        return complete_analysis
    
    def print_analysis_summary(self, analysis_results: Dict):
        """Print formatted analysis summary"""
        if not analysis_results:
            print("❌ No analysis results to display")
            return
        
        file_info = analysis_results.get('file_info', {})
        diarization = analysis_results.get('diarization_transcription', [])
        events = analysis_results.get('audio_events', {})
        emotion = analysis_results.get('emotion_analysis', {})
        
        print(f"\n{'='*80}")
        print("🎯 UNIFIED AUDIO ANALYSIS RESULTS")
        print(f"{'='*80}")
        
        # File Information
        print(f"📁 File: {file_info.get('filename', 'Unknown')}")
        print(f"⏱️ Duration: {file_info.get('duration', 0):.2f} seconds")
        print(f"🔊 Sample Rate: {file_info.get('sample_rate', 0)} Hz")
        print(f"⚡ Processing Time: {file_info.get('processing_time', 0):.2f} seconds")
        
        # 1. Speaker Diarization Results
        print(f"\n{'🎤 SPEAKER DIARIZATION & TRANSCRIPTION'}")
        print("-" * 50)
        if diarization:
            speakers = set(seg['speaker'] for seg in diarization)
            print(f"Speakers detected: {len(speakers)}")
            print(f"Total segments: {len(diarization)}")
            
            for i, segment in enumerate(diarization, 1):
                print(f"{i}. {segment['speaker']} [{segment['start']:.1f}s-{segment['end']:.1f}s]: {segment['text'][:80]}{'...' if len(segment['text']) > 80 else ''}")
        else:
            print("No diarization results available")
        
        # 2. Audio Event Detection
        print(f"\n{'🔊 AUDIO EVENT DETECTION (Top 10)'}")
        print("-" * 50)
        top_events = events.get('top_events', [])
        if top_events:
            for i, event in enumerate(top_events[:10], 1):
                print(f"{i:2d}. {event['event']:<30} | Probability: {event['probability']:.4f}")
        else:
            print("No audio events detected")
        
        # 3. Emotion Analysis
        print(f"\n{'😊 EMOTION ANALYSIS'}")
        print("-" * 30)
        if emotion:
            print(f"Predicted Emotion: {emotion['predicted_emotion']} (Confidence: {emotion['confidence']:.3f})")
            print("\nAll Emotion Probabilities:")
            for emo, prob in emotion['all_emotions'].items():
                print(f"  {emo.capitalize():<12}: {prob:.3f}")
        else:
            print("No emotion analysis available")
        
        # 4. Key Paralinguistic Features
        features = analysis_results.get('paralinguistic_features', {})
        if features:
            print(f"\n{'🎵 KEY PARALINGUISTIC FEATURES'}")
            print("-" * 40)
            print(f"RMS Energy: {features.get('rms_energy', 0):.4f}")
            print(f"Pitch Mean: {features.get('pitch_mean', 0):.2f} Hz")
            print(f"Spectral Centroid: {features.get('spectral_centroid_mean', 0):.2f} Hz")
            print(f"Tempo: {features.get('tempo', 0):.2f} BPM")
            print(f"Zero Crossing Rate: {features.get('zero_crossing_rate', 0):.4f}")
    
    def save_results_to_csv(self, analysis_results: Dict, output_prefix: str = "unified_analysis"):
        """Save analysis results to CSV files"""
        if not analysis_results:
            print("❌ No results to save")
            return
        
        # Save diarization results
        diarization = analysis_results.get('diarization_transcription', [])
        if diarization:
            df_diarization = pd.DataFrame(diarization)
            diarization_file = f"{output_prefix}_diarization.csv"
            df_diarization.to_csv(diarization_file, index=False)
            print(f"💾 Diarization results saved to: {diarization_file}")
        
        # Save audio events
        events = analysis_results.get('audio_events', {}).get('top_events', [])
        if events:
            df_events = pd.DataFrame(events)
            events_file = f"{output_prefix}_audio_events.csv"
            df_events.to_csv(events_file, index=False)
            print(f"💾 Audio events saved to: {events_file}")
        
        # Save paralinguistic features
        features = analysis_results.get('paralinguistic_features', {})
        if features:
            df_features = pd.DataFrame([features])
            features_file = f"{output_prefix}_features.csv"
            df_features.to_csv(features_file, index=False)
            print(f"💾 Features saved to: {features_file}")
        
        # Save emotion analysis
        emotion = analysis_results.get('emotion_analysis', {})
        if emotion:
            df_emotion = pd.DataFrame([emotion])
            emotion_file = f"{output_prefix}_emotion.csv"
            df_emotion.to_csv(emotion_file, index=False)
            print(f"💾 Emotion analysis saved to: {emotion_file}")
            
def summarize_audio_analysis_with_llm(analysis_results: dict) -> str:
    """
    Send all analysis results to a Groq LLM (gpt-oss-20b) and get a summary
    describing relationships between diarization, events, emotion, and features.
    Requires GROQ_API_KEY in environment.
    """
    # Prepare the prompt
    prompt = (
        "You are an expert audio scene interpreter. Given the structured audio analysis results, "
        "summarize what is happening in plain, natural language, as if explaining the situation to someone. "
        "Avoid technical terms, metrics, or probabilities. Instead, combine the speaker's words, background "
        "sounds, emotions and other paralingusistic features to infer the most likely real-world context. Keep it short and clear.\n\n"
        "Sample input : Recording of a person call reaching an airport (with background noise of airplanes, announcements, and crowd chatter). Sample output : The subway sound and other vehicle sound suggest that person is in Highway, and the aero plane sound indicate nearby Airport, while announcement provide information about the Airplane Schedule, that means person reached in boarding area or into the waiting hall.\n\n"
        f"Audio Analysis Results:\n{analysis_results}\n\n"
        "Plain Summary:"
    )

    # Load environment variables
    load_dotenv()
    api_key = os.getenv("GROQ_API_KEY")
    if not api_key:
        raise ValueError("GROQ_API_KEY environment variable not set.")

    # Initialize Groq client
    client = Groq(api_key=api_key)

    # Make the API call
    response = client.chat.completions.create(
        model="openai/gpt-oss-20b",
        messages=[
            {"role": "system", "content": "You are an expert audio analyst."},
            {"role": "user", "content": prompt},
        ],
    )

    # Extract summary
    summary = response.choices[0].message.content.strip()
    return summary

def main():
    """Main function demonstrating usage"""
    # Initialize analyzer with parallel processing enabled
    analyzer = UnifiedAudioAnalyzer(enable_parallel_processing=True, max_workers=None)
    
    # Specify input audio file
    audio_file = "dataset/flight/15.wav"  # Update with your audio file path
    
    if os.path.exists(audio_file):
        # Perform complete analysis
        results = analyzer.analyze_complete_audio(audio_file)
        
        # Print summary
        analyzer.print_analysis_summary(results)
        
        # Save results to CSV files
        # analyzer.save_results_to_csv(results, "my_audio_analysis")
        
        print(f"\n✅ Analysis complete! Check CSV files for detailed results.")
        summary=summarize_audio_analysis_with_llm(results)
        print("\n=== LLM Summary of Audio Analysis ===")
        print(summary)
    else:
        print(f"❌ Audio file not found: {audio_file}")
        print("Please update the audio_file path to point to your audio file.")

if __name__ == "__main__":
    main()