"""
Module for transcribing audio files using Whisper.
Optimized for CPU with whisper-tiny model.
"""

import os
import logging
from typing import Optional

try:
    import torch
    from transformers import WhisperProcessor, WhisperForConditionalGeneration
    import librosa
except ImportError as e:
    print(f"Import error: {e}")
    torch = None
    WhisperProcessor = None
    WhisperForConditionalGeneration = None
    librosa = None

# Configurazione logging
logging.basicConfig(level=logging.INFO)
logger = logging.getLogger(__name__)

# Variabili globali per il modello (caricato una sola volta)
_model = None
_processor = None


def load_whisper_model():
    """Load Whisper tiny model optimized for CPU."""
    global _model, _processor
    
    if _model is None or _processor is None:
        try:
            logger.info("Loading Whisper tiny model...")
            
            # Load processor and model
            _processor = WhisperProcessor.from_pretrained("openai/whisper-tiny")
            _model = WhisperForConditionalGeneration.from_pretrained("openai/whisper-tiny")
            
            # Configure for CPU
            _model.eval()
            if torch.cuda.is_available():
                _model = _model.to("cuda")
            else:
                _model = _model.to("cpu")
            
            logger.info("Whisper model loaded successfully")
            
        except Exception as e:
            logger.error(f"Error loading Whisper model: {str(e)}")
            raise
    
    return _model, _processor


def transcribe_audio(file_path: str, language: str = "en") -> Optional[str]:
    """
    Transcribe an audio file using Whisper.
    
    Args:
        file_path (str): Path to audio file
        language (str): Language of audio content (default: "en" for English)
        
    Returns:
        Optional[str]: Text transcription or None if error
    """
    if not os.path.exists(file_path):
        logger.error(f"Audio file not found: {file_path}")
        return None
    
    if librosa is None:
        logger.error("librosa not installed. Install with: pip install librosa")
        return None
    
    try:
        # Load the model
        model, processor = load_whisper_model()
        
        # Load and preprocess audio
        logger.info(f"Loading audio file: {file_path}")
        audio_array, sample_rate = librosa.load(file_path, sr=16000)
        
        # Preprocess audio
        inputs = processor(audio_array, sampling_rate=sample_rate, return_tensors="pt")
        
        # Move to appropriate device
        device = next(model.parameters()).device
        inputs = {k: v.to(device) for k, v in inputs.items()}
        
        # Generate transcription
        logger.info("Generating transcription...")
        with torch.no_grad():
            predicted_ids = model.generate(
                inputs["input_features"],
                max_length=448,
                num_beams=1,
                do_sample=False,
                language=language
            )
        
        # Decode the result
        transcription = processor.batch_decode(predicted_ids, skip_special_tokens=True)[0]
        
        logger.info("Transcription completed successfully")
        return transcription.strip()
        
    except Exception as e:
        logger.error(f"Error during transcription of {file_path}: {str(e)}")
        return None


def get_supported_audio_extensions() -> list:
    """Return supported audio extensions."""
    return ['.mp3', '.wav', '.m4a', '.flac', '.ogg']


def is_audio_file(file_path: str) -> bool:
    """Check if a file is a supported audio file."""
    if not file_path:
        return False
    
    file_extension = os.path.splitext(file_path)[1].lower()
    return file_extension in get_supported_audio_extensions()