"""
Voice Processing Module
Author: RSK World (https://rskworld.in)
Founder: Molla Samser
Designer & Tester: Rima Khatun
Contact: help@rskworld.in, +91 93305 39277
Year: 2026
Description: Advanced voice input/output processing with speech recognition and synthesis
"""

import speech_recognition as sr
import pyttsx3
import io
import base64
import logging
import tempfile
import os
from typing import Optional, Dict, List
import threading
import queue
import wave
import audioop
try:
    import whisper
except ImportError:
    whisper = None
try:
    from pydub import AudioSegment
except ImportError:
    AudioSegment = None
import numpy as np

logger = logging.getLogger(__name__)

class VoiceProcessor:
    def __init__(self):
        self.recognizer = sr.Recognizer()
        self.microphone = None
        self.tts_engine = None
        self.is_listening = False
        self.audio_queue = queue.Queue()
        self.recognition_thread = None
        
        # Initialize speech recognition
        try:
            self.microphone = sr.Microphone()
            with self.microphone as source:
                self.recognizer.adjust_for_ambient_noise(source, duration=1)
        except Exception as e:
            logger.error(f"Failed to initialize microphone: {str(e)}")
        
        # Initialize text-to-speech
        try:
            self.tts_engine = pyttsx3.init()
            self._configure_tts()
        except Exception as e:
            logger.error(f"Failed to initialize TTS engine: {str(e)}")
        
        # Initialize Whisper model if available
        self.whisper_model = None
        if whisper:
            try:
                self.whisper_model = whisper.load_model("base")
            except Exception as e:
                logger.error(f"Failed to load Whisper model: {str(e)}")
        
        # Voice settings
        self.voice_settings = {
            'rate': 150,
            'volume': 0.9,
            'voice_id': None
        }
        
        # Supported languages for speech recognition
        self.speech_languages = {
            'en': 'en-US',
            'hi': 'hi-IN',
            'bn': 'bn-IN',
            'es': 'es-ES',
            'fr': 'fr-FR',
            'de': 'de-DE',
            'zh': 'zh-CN',
            'ja': 'ja-JP',
            'ar': 'ar-SA',
            'pt': 'pt-BR',
            'ru': 'ru-RU',
            'it': 'it-IT'
        }
    
    def _configure_tts(self):
        """Configure text-to-speech engine"""
        if self.tts_engine:
            try:
                # Get available voices
                voices = self.tts_engine.getProperty('voices')
                
                # Set voice based on language
                for voice in voices:
                    if 'english' in voice.name.lower() or 'en' in voice.id.lower():
                        self.voice_settings['voice_id'] = voice.id
                        break
                
                # Apply settings
                self.tts_engine.setProperty('rate', self.voice_settings['rate'])
                self.tts_engine.setProperty('volume', self.voice_settings['volume'])
                if self.voice_settings['voice_id']:
                    self.tts_engine.setProperty('voice', self.voice_settings['voice_id'])
                    
            except Exception as e:
                logger.error(f"Failed to configure TTS: {str(e)}")
    
    def recognize_speech_from_microphone(self, language: str = 'en') -> Optional[str]:
        """
        Recognize speech from microphone input
        """
        if not self.microphone:
            logger.error("Microphone not available")
            return None
        
        try:
            lang_code = self.speech_languages.get(language, 'en-US')
            
            with self.microphone as source:
                logger.info("Listening for speech...")
                audio = self.recognizer.listen(source, timeout=5, phrase_time_limit=30)
            
            logger.info("Processing speech recognition...")
            
            # Try Google Speech Recognition first
            try:
                text = self.recognizer.recognize_google(audio, language=lang_code)
                logger.info(f"Recognized: {text}")
                return text
            except sr.UnknownValueError:
                logger.warning("Google Speech Recognition could not understand audio")
                
                # Try Sphinx as fallback
                try:
                    text = self.recognizer.recognize_sphinx(audio)
                    logger.info(f"Sphinx recognized: {text}")
                    return text
                except sr.UnknownValueError:
                    logger.error("Sphinx could not understand audio")
                    return None
                    
        except sr.RequestError as e:
            logger.error(f"Speech recognition service error: {str(e)}")
            return None
        except Exception as e:
            logger.error(f"Speech recognition error: {str(e)}")
            return None
    
    def recognize_speech_from_file(self, audio_file_path: str, language: str = 'en') -> Optional[str]:
        """
        Recognize speech from audio file
        """
        try:
            lang_code = self.speech_languages.get(language, 'en-US')
            
            with sr.AudioFile(audio_file_path) as source:
                audio = self.recognizer.record(source)
            
            text = self.recognizer.recognize_google(audio, language=lang_code)
            return text
            
        except Exception as e:
            logger.error(f"File speech recognition error: {str(e)}")
            return None
    
    def recognize_speech_from_base64(self, audio_data: str, language: str = 'en') -> Optional[str]:
        """
        Recognize speech from base64 encoded audio data
        """
        try:
            # Decode base64 audio
            audio_bytes = base64.b64decode(audio_data)
            
            # Create temporary audio file
            with tempfile.NamedTemporaryFile(suffix='.wav', delete=False) as temp_file:
                temp_file.write(audio_bytes)
                temp_file_path = temp_file.name
            
            try:
                # Recognize from temporary file
                text = self.recognize_speech_from_file(temp_file_path, language)
                return text
            finally:
                # Clean up temporary file
                os.unlink(temp_file_path)
                
        except Exception as e:
            logger.error(f"Base64 speech recognition error: {str(e)}")
            return None
    
    def text_to_speech(self, text: str, language: str = 'en') -> Optional[bytes]:
        """
        Convert text to speech and return audio bytes
        """
        if not self.tts_engine:
            logger.error("TTS engine not available")
            return None
        
        try:
            # Create temporary file for audio
            with tempfile.NamedTemporaryFile(suffix='.wav', delete=False) as temp_file:
                temp_file_path = temp_file.name
            
            try:
                # Generate speech
                self.tts_engine.save_to_file(text, temp_file_path)
                self.tts_engine.runAndWait()
                
                # Read audio file
                with open(temp_file_path, 'rb') as audio_file:
                    audio_bytes = audio_file.read()
                
                return audio_bytes
                
            finally:
                # Clean up temporary file
                if os.path.exists(temp_file_path):
                    os.unlink(temp_file_path)
                    
        except Exception as e:
            logger.error(f"TTS error: {str(e)}")
            return None
    
    def text_to_speech_base64(self, text: str, language: str = 'en') -> Optional[str]:
        """
        Convert text to speech and return base64 encoded audio
        """
        audio_bytes = self.text_to_speech(text, language)
        if audio_bytes:
            return base64.b64encode(audio_bytes).decode('utf-8')
        return None
    
    def speak_text(self, text: str, language: str = 'en') -> bool:
        """
        Speak text aloud using system speakers
        """
        if not self.tts_engine:
            logger.error("TTS engine not available")
            return False
        
        try:
            self.tts_engine.say(text)
            self.tts_engine.runAndWait()
            return True
        except Exception as e:
            logger.error(f"Speech output error: {str(e)}")
            return False
    
    def start_continuous_listening(self, callback, language: str = 'en'):
        """
        Start continuous speech recognition in background
        """
        if self.is_listening:
            logger.warning("Already listening")
            return
        
        self.is_listening = True
        
        def listen_continuously():
            while self.is_listening:
                try:
                    text = self.recognize_speech_from_microphone(language)
                    if text:
                        callback(text)
                except Exception as e:
                    logger.error(f"Continuous listening error: {str(e)}")
                    continue
        
        self.recognition_thread = threading.Thread(target=listen_continuously, daemon=True)
        self.recognition_thread.start()
    
    def stop_continuous_listening(self):
        """
        Stop continuous speech recognition
        """
        self.is_listening = False
        if self.recognition_thread:
            self.recognition_thread.join(timeout=1)
    
    def get_available_microphones(self) -> List[Dict]:
        """
        Get list of available microphones
        """
        try:
            mic_list = []
            for index, name in enumerate(sr.Microphone.list_microphone_names()):
                mic_list.append({
                    'index': index,
                    'name': name
                })
            return mic_list
        except Exception as e:
            logger.error(f"Error listing microphones: {str(e)}")
            return []
    
    def get_available_voices(self) -> List[Dict]:
        """
        Get list of available TTS voices
        """
        if not self.tts_engine:
            return []
        
        try:
            voices = []
            for voice in self.tts_engine.getProperty('voices'):
                voices.append({
                    'id': voice.id,
                    'name': voice.name,
                    'languages': voice.languages,
                    'gender': voice.gender
                })
            return voices
        except Exception as e:
            logger.error(f"Error listing voices: {str(e)}")
            return []
    
    def set_voice_properties(self, rate: int = None, volume: float = None, voice_id: str = None):
        """
        Set TTS voice properties
        """
        if not self.tts_engine:
            return False
        
        try:
            if rate is not None:
                self.tts_engine.setProperty('rate', rate)
                self.voice_settings['rate'] = rate
            
            if volume is not None:
                self.tts_engine.setProperty('volume', volume)
                self.voice_settings['volume'] = volume
            
            if voice_id is not None:
                self.tts_engine.setProperty('voice', voice_id)
                self.voice_settings['voice_id'] = voice_id
            
            return True
        except Exception as e:
            logger.error(f"Error setting voice properties: {str(e)}")
            return False
    
    def get_voice_settings(self) -> Dict:
        """
        Get current voice settings
        """
        return self.voice_settings.copy()
    
    def is_microphone_available(self) -> bool:
        """
        Check if microphone is available
        """
        return self.microphone is not None
    
    def is_tts_available(self) -> bool:
        """
        Check if TTS is available
        """
        return self.tts_engine is not None
    
    def process_audio_stream(self, audio_data: bytes, sample_rate: int = 16000) -> Optional[str]:
        """
        Process audio stream data for speech recognition
        """
        try:
            # Convert audio data to AudioFile format
            if AudioSegment:
                audio = AudioSegment.from_file(io.BytesIO(audio_data))
                audio = audio.set_frame_rate(sample_rate).set_channels(1)
                audio = audio.export(format="wav")
                audio_bytes = audio.read()
            else:
                audio_bytes = audio_data
            
            audio = sr.AudioData(audio_bytes, sample_rate, 1)
            
            # Recognize speech
            text = self.recognizer.recognize_google(audio)
            return text
            
        except Exception as e:
            logger.error(f"Audio stream processing error: {str(e)}")
            return None