app.py

#!/usr/bin/env python3
# -*- coding: utf-8 -*-

import sys
import io
import os
import locale

# Comprehensive UTF-8 encoding setup for Windows
if sys.platform.startswith('win'):
    try:
        # Set locale to UTF-8
        try:
            locale.setlocale(locale.LC_ALL, 'en_US.UTF-8')
        except:
            try:
                locale.setlocale(locale.LC_ALL, 'C.UTF-8')
            except:
                pass
        
        # Set console to UTF-8 mode
        os.system('chcp 65001 > nul 2>&1')
        
        # Set environment variables for UTF-8
        os.environ['PYTHONIOENCODING'] = 'utf-8:replace'
        os.environ['PYTHONUTF8'] = '1'
        
        # Force UTF-8 encoding for stdout/stderr with error handling
        try:
            if hasattr(sys.stdout, 'reconfigure'):
                sys.stdout.reconfigure(encoding='utf-8', errors='replace')
                sys.stderr.reconfigure(encoding='utf-8', errors='replace')
            else:
                # Fallback for older Python versions
                sys.stdout = io.TextIOWrapper(sys.stdout.buffer, encoding='utf-8', errors='replace')
                sys.stderr = io.TextIOWrapper(sys.stderr.buffer, encoding='utf-8', errors='replace')
        except Exception:
            # Final fallback
            sys.stdout = io.TextIOWrapper(sys.stdout.detach(), encoding='utf-8', errors='replace')
            sys.stderr = io.TextIOWrapper(sys.stderr.detach(), encoding='utf-8', errors='replace')
        
    except Exception as e:
        # Silently continue if encoding setup fails
        pass

# Store original print function before any imports
import builtins
_original_print = builtins.print

def safe_print(*args, **kwargs):
    """Safe print function that handles UTF-8 encoding"""
    try:
        # Convert all arguments to strings first to avoid encoding issues
        safe_args = []
        for arg in args:
            if isinstance(arg, str):
                # Ensure string can be encoded/decoded properly
                try:
                    arg.encode('utf-8')
                    safe_args.append(arg)
                except UnicodeEncodeError:
                    safe_args.append(arg.encode('utf-8', errors='replace').decode('utf-8'))
            else:
                safe_args.append(str(arg))
        
        _original_print(*safe_args, **kwargs)
    except (UnicodeEncodeError, UnicodeDecodeError) as e:
        # Last resort: convert to ASCII with replacement
        ascii_args = []
        for arg in args:
            if isinstance(arg, str):
                ascii_args.append(arg.encode('ascii', errors='replace').decode('ascii'))
            else:
                ascii_args.append(str(arg).encode('ascii', errors='replace').decode('ascii'))
        _original_print(*ascii_args, **kwargs)
    except Exception:
        # Ultimate fallback
        _original_print("[Encoding Error in Print]")

# Override built-in print
builtins.print = safe_print
"""
Live Translation AI Agent - Two Person Mode
Real-time Cross-Translation between Person A & Person B
"""

import gradio as gr
import numpy as np
import librosa
import soundfile as sf
import tempfile
import os
import time
import logging
import json
from typing import Optional, Tuple, Dict, List
import asyncio
import threading
from pathlib import Path

# Load environment variables from .env file
try:
    from dotenv import load_dotenv
    load_dotenv()
    print("Environment variables loaded from .env file")
except ImportError:
    print("python-dotenv not available, using system environment variables")

# Google Gemini integration
try:
    import google.generativeai as genai
    GEMINI_AVAILABLE = True
    print("Google Gemini library loaded successfully")
except ImportError:
    GEMINI_AVAILABLE = False
    print("Google Gemini library not available")

# Google Speech Recognition integration
try:
    import speech_recognition as sr
    SPEECH_RECOGNITION_AVAILABLE = True
    print("SpeechRecognition library loaded successfully")
except ImportError:
    SPEECH_RECOGNITION_AVAILABLE = False
    print("SpeechRecognition library not available")

# Edge TTS for speech synthesis
try:
    import edge_tts
    EDGE_TTS_AVAILABLE = True
    print("Edge TTS loaded successfully")
except ImportError:
    EDGE_TTS_AVAILABLE = False
    print("Edge TTS not available")

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

class TranslationAIAgent:
    """Main AI Agent for translation tasks - Google Gemini Powered"""
    
    def __init__(self):
        # Enhanced language and voice options with country flags
        self.language_voice_options = {
            'en': {
                'name': 'English',
                'options': [
                    {'code': 'en-us', 'display': 'English (United States)', 'voice': 'en-US-JennyNeural', 'alt_voice': 'en-US-GuyNeural'},
                    {'code': 'en-gb', 'display': 'English (United Kingdom)', 'voice': 'en-GB-LibbyNeural', 'alt_voice': 'en-GB-RyanNeural'},
                ]
            },
            'es': {
                'name': 'Spanish',
                'options': [
                    {'code': 'es-es', 'display': 'Spanish (Spain)', 'voice': 'es-ES-ElviraNeural', 'alt_voice': 'es-ES-AlvaroNeural'},
                    {'code': 'es-mx', 'display': 'Spanish (Mexico)', 'voice': 'es-MX-DaliaNeural', 'alt_voice': 'es-MX-JorgeNeural'},
                ]
            },
            'fr': {
                'name': 'French',
                'options': [
                    {'code': 'fr-fr', 'display': 'French (France)', 'voice': 'fr-FR-DeniseNeural', 'alt_voice': 'fr-FR-HenriNeural'},
                    {'code': 'fr-ca', 'display': 'French (Canada)', 'voice': 'fr-CA-SylvieNeural', 'alt_voice': 'fr-CA-AntoineNeural'},
                ]
            },
            'de': {
                'name': 'German',
                'options': [
                    {'code': 'de-de', 'display': 'German (Germany)', 'voice': 'de-DE-KatjaNeural', 'alt_voice': 'de-DE-ConradNeural'},
                ]
            },
            'vi': {
                'name': 'Vietnamese',
                'options': [
                    {'code': 'vi-vn', 'display': 'Vietnamese (Vietnam)', 'voice': 'vi-VN-HoaiMyNeural', 'alt_voice': 'vi-VN-NamMinhNeural'}
                ]
            },
            'ja': {
                'name': 'Japanese',
                'options': [
                    {'code': 'ja-jp', 'display': 'Japanese (Japan)', 'voice': 'ja-JP-NanamiNeural', 'alt_voice': 'ja-JP-KeitaNeural'}
                ]
            },
            'zh': {
                'name': 'Chinese',
                'options': [
                    {'code': 'zh-cn', 'display': 'Chinese (Simplified)', 'voice': 'zh-CN-XiaoxiaoNeural', 'alt_voice': 'zh-CN-YunxiNeural'},
                ]
            }
        }
        
        # Create simple supported languages mapping for backward compatibility
        self.supported_languages = {
            lang_code: lang_info['name'] 
            for lang_code, lang_info in self.language_voice_options.items()
        }
        
        # Create default voice mapping for backward compatibility
        self.voice_map = {
            lang_code: lang_info['options'][0]['voice']
            for lang_code, lang_info in self.language_voice_options.items()
        }
        
        self.setup_gemini_client()
        self.setup_speech_recognizer()
    
    def setup_gemini_client(self):
        """Setup Google Gemini client for translation"""
        try:
            if not GEMINI_AVAILABLE:
                logger.error("Google Gemini library not available - please install: pip install google-generativeai")
                self.gemini_model = None
                self.gemini_configured = False
                return
            
            # Get Google API key from environment
            api_key = (
                os.environ.get("GOOGLE_API_KEY") or 
                os.environ.get("GEMINI_API_KEY") or
                os.getenv("GOOGLE_API_KEY")
            )
            
            if api_key and api_key.strip() and not api_key.strip().startswith("your-"):
                genai.configure(api_key=api_key.strip())
                self.gemini_model = genai.GenerativeModel('gemini-2.0-flash-exp')
                self.gemini_configured = True
                logger.info("[SUCCESS] Google Gemini client configured successfully - Real translation mode enabled")
            else:
                self.gemini_model = None
                self.gemini_configured = False
                logger.error("❌ Google API key not found or invalid in environment variables")
                logger.error("Please set GOOGLE_API_KEY in your .env file with a valid API key")
                
        except Exception as e:
            logger.error(f"Gemini setup failed: {e}")
            self.gemini_model = None
            self.gemini_configured = False

    def setup_speech_recognizer(self):
        """Setup speech recognizer for audio input"""
        try:
            if not SPEECH_RECOGNITION_AVAILABLE:
                logger.error("SpeechRecognition library not available - please install: pip install SpeechRecognition")
                self.recognizer = None
                self.speech_configured = False
                return
            
            self.recognizer = sr.Recognizer()
            # More conservative settings for better recognition
            self.recognizer.energy_threshold = 1000  # Lower threshold for processed audio
            self.recognizer.dynamic_energy_threshold = False  # More consistent
            self.recognizer.pause_threshold = 0.5  # Shorter pauses
            self.recognizer.operation_timeout = 15  # Longer timeout
            self.recognizer.phrase_threshold = 0.3  # More sensitive phrase detection
            self.recognizer.non_speaking_duration = 0.2  # Less aggressive silence detection
            self.speech_configured = True
            logger.info("[SUCCESS] Speech recognizer configured successfully")
            
        except Exception as e:
            logger.error(f"Speech recognizer setup failed: {e}")
            self.recognizer = None
            self.speech_configured = False

    def speech_to_text(self, audio_path: str, language: str = 'auto') -> tuple[str, str]:
        """Convert speech to text using Gemini Flash 2.0 with language detection or specified language"""
        try:
            if not self.gemini_configured:
                raise Exception("Gemini client not configured. Please check your API key.")
            
            if not os.path.exists(audio_path):
                raise Exception(f"Audio file not found: {audio_path}")
            
            # Load and preprocess audio with better error handling
            try:
                # Wait a bit to ensure file is fully written
                import time as time_module
                time_module.sleep(0.5)
                
                # Try to access the file multiple times if needed
                for attempt in range(3):
                    try:
                        y, sr_rate = librosa.load(audio_path, sr=16000, duration=30)
                        break
                    except Exception as e:
                        if attempt < 2:
                            logger.warning(f"Audio loading attempt {attempt + 1} failed: {e}, retrying...")
                            time_module.sleep(0.5)
                        else:
                            raise e
                
                if len(y) == 0:
                    return "No audio data found", "unknown"
                
                # Check for audio clipping and quality issues
                max_amplitude = np.max(np.abs(y))
                rms_level = np.sqrt(np.mean(y**2))
                
                logger.info(f"Audio quality check - Max: {max_amplitude:.4f}, RMS: {rms_level:.4f}, Duration: {len(y)/sr_rate:.2f}s")
                
                # Handle clipped audio (amplitude = 1.0 means clipping)
                if max_amplitude >= 0.99:
                    logger.warning("⚠️ Audio appears to be clipped - applying de-clipping")
                    # Apply soft clipping recovery
                    y = np.tanh(y * 0.8) * 0.9  # Soft compression to recover from clipping
                    max_amplitude = np.max(np.abs(y))
                
                # Check if audio is too quiet
                if rms_level < 0.01:
                    logger.warning("⚠️ Audio level very low - boosting signal")
                    # Boost quiet audio
                    y = y * (0.1 / rms_level)
                    y = np.clip(y, -0.95, 0.95)  # Prevent new clipping
                elif rms_level > 0.5:
                    logger.warning("⚠️ Audio level very high - reducing signal")
                    # Reduce loud audio
                    y = y * (0.3 / rms_level)
                
                # Final normalization to safe level
                if max_amplitude > 0.8:
                    y = y * (0.7 / max_amplitude)
                elif max_amplitude > 0:
                    y = y * (0.7 / max_amplitude)  # Normalize to 70% to avoid clipping
                
                logger.info(f"After processing - Max: {np.max(np.abs(y)):.4f}, RMS: {np.sqrt(np.mean(y**2)):.4f}")
                
                # Apply simple noise reduction
                if len(y) > sr_rate:  # Only if audio is longer than 1 second
                    # Calculate RMS energy
                    frame_length = int(0.025 * sr_rate)  # 25ms frames
                    hop_length = int(0.010 * sr_rate)    # 10ms hop
                    rms = librosa.feature.rms(y=y, frame_length=frame_length, hop_length=hop_length)[0]
                    
                    # Simple voice activity detection
                    rms_threshold = np.percentile(rms, 30)  # Bottom 30% is likely silence
                    
                    # Keep frames above threshold
                    frame_indices = np.where(rms > rms_threshold)[0]
                    if len(frame_indices) > 0:
                        start_frame = max(0, frame_indices[0] - 2)
                        end_frame = min(len(rms) - 1, frame_indices[-1] + 2)
                        
                        start_sample = start_frame * hop_length
                        end_sample = min(len(y), end_frame * hop_length + frame_length)
                        
                        y = y[start_sample:end_sample]
                
                # Save processed audio to temporary file with unique name
                temp_dir = tempfile.gettempdir()
                temp_audio = os.path.join(temp_dir, f"speech_audio_{os.getpid()}_{int(time.time() * 1000)}.wav")
                
                # Ensure we can write to the temp file
                try:
                    sf.write(temp_audio, y, sr_rate, format='WAV', subtype='PCM_16')
                    
                    # Verify file was written
                    if not os.path.exists(temp_audio) or os.path.getsize(temp_audio) == 0:
                        raise Exception("Failed to write temporary audio file")
                        
                except Exception as e:
                    logger.error(f"Failed to save temporary audio: {e}")
                    return f"Audio processing failed: {str(e)}", "unknown"
                
                # Give file system time to finish writing
                time_module.sleep(0.1)
                
                # Use Gemini Flash 2.0 for speech-to-text
                logger.info("🧠 Using Gemini Flash 2.0 for speech recognition...")
                
                try:
                    # Upload audio file to Gemini
                    import google.generativeai as genai
                    
                    # Upload the audio file
                    audio_file = genai.upload_file(temp_audio, mime_type="audio/wav")
                    logger.info(f"📤 Audio uploaded to Gemini: {audio_file.name}")
                    
                    # Create prompt based on language preference
                    if language == 'auto':
                        prompt = """Please transcribe this audio file. 
                        
Instructions:
1. Listen to the audio and transcribe exactly what is spoken
2. Detect the language automatically 
3. Provide the transcription in the original language
4. Return ONLY the transcribed text, no explanations
5. If you cannot understand the audio, respond with "RECOGNITION_FAILED"

Transcription:"""
                    else:
                        # Map language codes to language names
                        lang_name_map = {
                            'en-US': 'English', 'vi-VN': 'Vietnamese', 'es-ES': 'Spanish',
                            'fr-FR': 'French', 'de-DE': 'German', 'ja-JP': 'Japanese', 
                            'zh-CN': 'Chinese', 'ko-KR': 'Korean', 'it-IT': 'Italian',
                            'pt-PT': 'Portuguese', 'ru-RU': 'Russian', 'ar-SA': 'Arabic',
                            'hi-IN': 'Hindi', 'th-TH': 'Thai', 'tr-TR': 'Turkish'
                        }
                        expected_lang = lang_name_map.get(language, 'English')
                        
                        prompt = f"""Please transcribe this audio file in {expected_lang}.
                        
Instructions:
1. Listen to the audio and transcribe exactly what is spoken
2. The audio should be in {expected_lang}
3. Provide the transcription in {expected_lang}
4. Return ONLY the transcribed text, no explanations
5. If you cannot understand the audio, respond with "RECOGNITION_FAILED"

Transcription:"""
                    
                    # Generate transcription with Gemini (with timeout)
                    try:
                        response = self.gemini_model.generate_content(
                            [prompt, audio_file],
                            generation_config=genai.types.GenerationConfig(
                                candidate_count=1,
                                max_output_tokens=200,
                                temperature=0.1
                            )
                        )
                        transcription = response.text.strip()
                    except Exception as gen_error:
                        logger.error(f"Gemini generation failed: {gen_error}")
                        raise gen_error
                    
                    logger.info(f"🧠 Gemini transcription result: {transcription[:100]}...")
                    
                    # Clean up uploaded file
                    try:
                        genai.delete_file(audio_file.name)
                        logger.info("🗑️ Cleaned up uploaded file from Gemini")
                    except:
                        pass
                    
                    # Check if recognition failed
                    if transcription == "RECOGNITION_FAILED" or "cannot understand" in transcription.lower():
                        logger.warning("❌ Gemini could not understand the audio")
                        return "Could not understand speech - please try speaking more clearly or check your microphone", "unknown"
                    
                    # Detect language of transcription using Gemini
                    detected_language = self.detect_language_with_gemini(transcription)
                    
                    logger.info(f"✅ Gemini transcription successful: {transcription[:50]}...")
                    logger.info(f"✅ Detected language: {detected_language}")
                    
                    return transcription, detected_language
                    
                except Exception as gemini_error:
                    logger.error(f"❌ Gemini transcription failed: {gemini_error}")
                    return f"Gemini transcription failed: {str(gemini_error)}", "unknown"
                
                finally:
                    # Clean up temp file
                    try:
                        os.remove(temp_audio)
                    except Exception as e:
                        logger.warning(f"Failed to cleanup temp file: {e}")
                
            except Exception as audio_error:
                logger.error(f"Audio processing error: {audio_error}")
                return f"Audio processing failed: {str(audio_error)}", "unknown"
                
        except Exception as e:
            error_msg = str(e)
            logger.error(f"Speech recognition error: {error_msg}")
            raise Exception(f"Speech recognition failed: {error_msg}")
    
    def detect_language_with_gemini(self, text: str) -> str:
        """Use Gemini to detect language of text"""
        try:
            if not self.gemini_configured or not text.strip():
                return "English"
            
            prompt = f"""Analyze this text and identify the language. Respond with just the language name in English (e.g., "English", "Vietnamese", "Spanish", etc.):

{text[:200]}"""
            
            response = self.gemini_model.generate_content(prompt)
            detected_lang = response.text.strip()
            
            # Validate response
            valid_languages = ['English', 'Vietnamese', 'Spanish', 'French', 'German', 'Japanese', 'Chinese', 'Korean', 'Italian', 'Portuguese', 'Russian', 'Arabic', 'Hindi', 'Thai', 'Turkish']
            if detected_lang in valid_languages:
                return detected_lang
            else:
                return "English"
                
        except Exception as e:
            logger.warning(f"Gemini language detection failed: {e}")
            return "English"
    
    def get_audio_duration(self, audio_path: str) -> float:
        """Get duration of audio file"""
        try:
            y, sr = librosa.load(audio_path)
            return len(y) / sr
        except:
            return 0.0

    def translate_text(self, text: str, source_lang: str, target_lang: str) -> str:
        """Translate text using Google Gemini Flash 2.0"""
        try:
            if not self.gemini_configured:
                raise Exception("Google Gemini client not configured. Please check your API key.")
            
            # Create translation prompt
            source_name = self.supported_languages.get(source_lang, source_lang)
            target_name = self.supported_languages.get(target_lang, target_lang)
            
            prompt = f"""Translate the following {source_name} text to {target_name}. Provide only the translation, no explanations or additional text:

{text}"""
            
            response = self.gemini_model.generate_content(
                prompt,
                generation_config=genai.types.GenerationConfig(
                    candidate_count=1,
                    max_output_tokens=300,
                    temperature=0.2
                )
            )
            translated_text = response.text.strip()
            
            if translated_text:
                logger.info(f"Gemini Flash 2.0 translation successful: {translated_text[:100]}...")
                return translated_text
            else:
                raise Exception("Empty translation response from Gemini")
            
        except Exception as e:
            error_msg = str(e)
            logger.error(f"Translation error: {error_msg}")
            
            # Check for quota exceeded error
            if "429" in error_msg or "quota" in error_msg.lower() or "insufficient_quota" in error_msg.lower():
                logger.warning("[WARNING] Google Gemini API quota exceeded - using fallback translation")
                target_name = self.supported_languages.get(target_lang, target_lang)
                return f"[API Quota Exceeded] Please add credits to your Google account. Original text: {text}"
            
            raise Exception(f"Translation failed: {error_msg}")

    async def generate_speech_with_custom_voice(self, text: str, voice: str) -> str:
        """Generate speech using Edge TTS with custom voice"""
        try:
            if not EDGE_TTS_AVAILABLE:
                logger.warning("Edge TTS not available")
                return None
            
            # Create temporary output file
            temp_dir = tempfile.gettempdir()
            output_path = os.path.join(temp_dir, f"tts_output_{int(time.time())}.wav")
            
            # Generate speech with specific voice
            communicate = edge_tts.Communicate(text, voice)
            await communicate.save(output_path)
            
            if os.path.exists(output_path):
                logger.info(f"Edge TTS generated with {voice}: {output_path}")
                return output_path
            else:
                return None
                
        except Exception as e:
            logger.error(f"TTS Error: {e}")
            return None

    def process_audio_translation_with_voice(
        self, 
        audio_path: str, 
        target_lang: str,
        voice: str,
        input_language: str = 'auto'
    ) -> Tuple[str, str, str, Optional[str]]:
        """Complete audio translation pipeline with custom voice selection and input language option"""
        
        if not audio_path:
            return "Please upload an audio file", "", "", None
        
        input_desc = "auto-detection" if input_language == 'auto' else f"specified language ({input_language})"
        logger.info(f"Processing audio translation with {input_desc} -> {target_lang} (voice: {voice})")
        
        # Step 1: Speech to text with language detection or specified language
        logger.info(f"Step 1: Transcribing audio with {input_desc}...")
        transcribed_text, detected_language = self.speech_to_text(audio_path, input_language)
        
        if transcribed_text.startswith("Error"):
            return transcribed_text, "", "", None
        
        logger.info(f"Transcription: {transcribed_text[:100]}...")
        logger.info(f"Language: {detected_language}")
        
        # Step 2: Translate text with Gemini Flash 2.0 using detected/specified language
        logger.info("Step 2: Translating text...")
        # Map detected language name to code for translation
        lang_code_map = {
            'English': 'en', 'Vietnamese': 'vi', 'Spanish': 'es', 'French': 'fr',
            'German': 'de', 'Italian': 'it', 'Portuguese': 'pt', 'Russian': 'ru',
            'Japanese': 'ja', 'Korean': 'ko', 'Chinese': 'zh', 'Arabic': 'ar',
            'Hindi': 'hi', 'Thai': 'th', 'Turkish': 'tr'
        }
        
        detected_lang_code = lang_code_map.get(detected_language, 'en')
        translated_text = self.translate_text(transcribed_text, detected_lang_code, target_lang)
        
        if translated_text.startswith("[Translation Error]"):
            return transcribed_text, detected_language, translated_text, None
        
        logger.info(f"Translation: {translated_text[:100]}...")
        
        # Step 3: Generate speech with Edge TTS using custom voice
        logger.info(f"Step 3: Generating speech with voice: {voice}")
        audio_output = asyncio.run(self.generate_speech_with_custom_voice(translated_text, voice))
        
        if audio_output:
            logger.info("Complete translation pipeline successful!")
        else:
            logger.warning("TTS generation failed, returning text only")
        
        return transcribed_text, detected_language, translated_text, audio_output

# Initialize AI Agent
agent = TranslationAIAgent()

# Interface Functions
def get_country_options() -> List[str]:
    """Get country options with flags for target language"""
    choices = []
    for lang_code, lang_info in agent.language_voice_options.items():
        for option in lang_info['options']:
            choice = f"{option['code']} | {option['display']}"
            choices.append(choice)
    return sorted(choices)

def get_input_language_options() -> List[str]:
    """Get input language options for speech recognition"""
    choices = ["auto | Auto-detect Language (Recommended)"]
    
    # Add specific language options
    language_options = [
        ("en-US", "English (United States)"),
        ("vi-VN", "Vietnamese (Vietnam)"), 
        ("es-ES", "Spanish (Spain)"),
        ("fr-FR", "French (France)"),
        ("de-DE", "German (Germany)"),
        ("ja-JP", "Japanese (Japan)"),
        ("zh-CN", "Chinese (Simplified)"),
        ("ko-KR", "Korean (South Korea)"),
        ("it-IT", "Italian (Italy)"),
        ("pt-PT", "Portuguese (Portugal)"),
        ("ru-RU", "Russian (Russia)"),
        ("ar-SA", "Arabic (Saudi Arabia)"),
        ("hi-IN", "Hindi (India)"),
        ("th-TH", "Thai (Thailand)"),
        ("tr-TR", "Turkish (Turkey)")
    ]
    
    for code, display in language_options:
        choice = f"{code} | {display}"
        choices.append(choice)
    
    return choices

def get_voice_options_for_country(country_selection: str) -> List[str]:
    """Get voice options for selected country"""
    if not country_selection or '|' not in country_selection:
        return ["Jenny (Female)", "Guy (Male)"]
    
    code = country_selection.split(' | ')[0].strip()
    
    for lang_info in agent.language_voice_options.values():
        for option in lang_info['options']:
            if option['code'] == code:
                main_voice = option['voice'].replace('Neural', '').split('-')[-1]
                alt_voice = option['alt_voice'].replace('Neural', '').split('-')[-1]
                
                def get_gender(voice_name):
                    female_names = ['Jenny', 'Libby', 'Natasha', 'Clara', 'Elvira', 'Dalia', 'Denise', 'Sylvie', 'Katja', 'Elsa', 'Raquel', 'Francisca', 'Svetlana', 'Nanami', 'SunHi', 'Xiaoxiao', 'HoaiMy']
                    return "(Female)" if any(name in voice_name for name in female_names) else "(Male)"
                
                return [
                    f"{main_voice} {get_gender(main_voice)}",
                    f"{alt_voice} {get_gender(alt_voice)}"
                ]
    
    return ["Jenny (Female)", "Guy (Male)"]

def get_voice_code_from_selections(country_selection: str, voice_selection: str) -> str:
    """Get full voice code from country and voice selections"""
    if not country_selection or '|' not in country_selection:
        return 'en-US-JennyNeural'
    
    code = country_selection.split(' | ')[0].strip()
    voice_name = voice_selection.split(' (')[0].strip()
    
    for lang_info in agent.language_voice_options.values():
        for option in lang_info['options']:
            if option['code'] == code:
                main_voice_name = option['voice'].replace('Neural', '').split('-')[-1]
                alt_voice_name = option['alt_voice'].replace('Neural', '').split('-')[-1]
                
                if voice_name == main_voice_name:
                    return option['voice']
                elif voice_name == alt_voice_name:
                    return option['alt_voice']
    
    return 'en-US-JennyNeural'

def get_language_code_from_country(country_selection: str) -> str:
    """Extract language code from country selection"""
    if not country_selection or '|' not in country_selection:
        return 'en'
    
    code = country_selection.split(' | ')[0].strip()
    return code.split('-')[0]

def update_voice_options(country_selection: str) -> gr.Dropdown:
    """Update voice dropdown based on country selection"""
    voice_options = get_voice_options_for_country(country_selection)
    return gr.Dropdown(choices=voice_options, value=voice_options[0] if voice_options else "Jenny (Female)")

def get_input_language_code_from_selection(input_lang_selection: str) -> str:
    """Extract language code from input language selection"""
    if not input_lang_selection or '|' not in input_lang_selection:
        return 'auto'
    
    code = input_lang_selection.split(' | ')[0].strip()
    if code == 'auto':
        return 'auto'
    
    return code

# Global conversation and audio state
conversation_state = {
    "person_a_messages": [],
    "person_b_messages": [],
    "person_a_translations": [],
    "person_b_translations": [],
    "latest_audio_for_a": None,  # Audio that Person A should hear
    "latest_audio_for_b": None   # Audio that Person B should hear
}

# Recording state management
recording_state = {
    "person_a_recording": False,
    "person_b_recording": False,
    "person_a_audio": None,
    "person_b_audio": None
}

def add_message_to_conversation(person, original, detected_lang, translation, target_person):
    """Add message to global conversation state"""
    if original and translation:
        timestamp = time.strftime("%H:%M")
        
        if person == "A":
            conversation_state["person_a_messages"].append(f"[{timestamp}] Person A ({detected_lang}): {original}")
            conversation_state["person_b_translations"].append(f"[{timestamp}] -> Person B: {translation}")
        else:  # person == "B"
            conversation_state["person_b_messages"].append(f"[{timestamp}] Person B ({detected_lang}): {original}")
            conversation_state["person_a_translations"].append(f"[{timestamp}] -> Person A: {translation}")

def get_full_conversation():
    """Get complete conversation history for both tabs"""
    all_messages = []
    max_length = max(
        len(conversation_state["person_a_messages"]), 
        len(conversation_state["person_b_messages"]),
        len(conversation_state["person_a_translations"]),
        len(conversation_state["person_b_translations"])
    )
    
    for i in range(max_length):
        if i < len(conversation_state["person_a_messages"]):
            all_messages.append(conversation_state["person_a_messages"][i])
        if i < len(conversation_state["person_b_translations"]):
            all_messages.append(conversation_state["person_b_translations"][i])
        if i < len(conversation_state["person_b_messages"]):
            all_messages.append(conversation_state["person_b_messages"][i])
        if i < len(conversation_state["person_a_translations"]):
            all_messages.append(conversation_state["person_a_translations"][i])
    
    return "\n".join(all_messages[-10:])  # Show last 10 messages

def translate_person_a_to_b(audio_file, country_b: str, voice_b: str, input_lang_a: str) -> tuple[str, Optional[str]]:
    """Person A speaks -> results appear in Person B's tab"""
    if audio_file is None:
        return "", None
    
    try:
        print(f"[DEBUG] Person A recording: {audio_file}")
        tgt_code = get_language_code_from_country(country_b)
        selected_voice = get_voice_code_from_selections(country_b, voice_b)
        input_language = get_input_language_code_from_selection(input_lang_a)
        print(f"[DEBUG] Input Language: {input_language}, Target: {tgt_code}, Voice: {selected_voice}")
        
        original_text, detected_lang, translated_text, audio_output = agent.process_audio_translation_with_voice(
            audio_file, tgt_code, selected_voice, input_language
        )
        
        print(f"[DEBUG] Results: {original_text[:50]}... -> {translated_text[:50]}...")
        print(f"[DEBUG] Audio output: {audio_output}")
        
        # Add to conversation
        add_message_to_conversation("A", original_text, detected_lang, translated_text, "B")
        
        # Return conversation for Person B's tab and audio
        conversation_history = get_full_conversation()
        print(f"[DEBUG] Conversation length: {len(conversation_history)}")
        
        return conversation_history, audio_output
        
    except Exception as e:
        print(f"[ERROR] translate_person_a_to_b: {e}")
        return f"Error: {str(e)}", None

def translate_person_b_to_a(audio_file, country_a: str, voice_a: str, input_lang_b: str) -> tuple[str, Optional[str]]:
    """Person B speaks -> results appear in Person A's tab"""
    if audio_file is None:
        return "", None
    
    try:
        print(f"[DEBUG] Person B recording: {audio_file}")
        tgt_code = get_language_code_from_country(country_a)
        selected_voice = get_voice_code_from_selections(country_a, voice_a)
        input_language = get_input_language_code_from_selection(input_lang_b)
        print(f"[DEBUG] Input Language: {input_language}, Target: {tgt_code}, Voice: {selected_voice}")
        
        original_text, detected_lang, translated_text, audio_output = agent.process_audio_translation_with_voice(
            audio_file, tgt_code, selected_voice, input_language
        )
        
        print(f"[DEBUG] Results: {original_text[:50]}... -> {translated_text[:50]}...")
        print(f"[DEBUG] Audio output: {audio_output}")
        
        # Add to conversation
        add_message_to_conversation("B", original_text, detected_lang, translated_text, "A")
        
        # Return conversation for Person A's tab and audio
        conversation_history = get_full_conversation()
        print(f"[DEBUG] Conversation length: {len(conversation_history)}")
        
        return conversation_history, audio_output
        
    except Exception as e:
        print(f"[ERROR] translate_person_b_to_a: {e}")
        return f"Error: {str(e)}", None

def get_audio_for_person_a() -> Optional[str]:
    """Get latest audio that Person A should hear"""
    return conversation_state.get("latest_audio_for_a")

def get_audio_for_person_b() -> Optional[str]:
    """Get latest audio that Person B should hear"""
    return conversation_state.get("latest_audio_for_b")

def toggle_person_a_recording():
    """Toggle Person A recording state and return button updates"""
    if recording_state["person_a_recording"]:
        # Currently recording, stop it
        recording_state["person_a_recording"] = False
        return (
            gr.Button("🎤 Talk", elem_classes=["talk-button"]),
            "<div style='text-align: center; padding: 10px; color: #666;'>Ready to record</div>"
        )
    else:
        # Not recording, start it
        recording_state["person_a_recording"] = True
        # Clear previous audio
        recording_state["person_a_audio"] = None
        return (
            gr.Button("🛑 Stop", elem_classes=["stop-button"]),
            "<div style='text-align: center; padding: 10px; color: #f44336;'>🔴 Click Stop when done recording</div>"
        )

def toggle_person_b_recording():
    """Toggle Person B recording state and return button updates"""
    if recording_state["person_b_recording"]:
        # Currently recording, stop it
        recording_state["person_b_recording"] = False
        return (
            gr.Button("🎤 Talk", elem_classes=["talk-button"]),
            "<div style='text-align: center; padding: 10px; color: #666;'>Ready to record</div>"
        )
    else:
        # Not recording, start it
        recording_state["person_b_recording"] = True
        # Clear previous audio
        recording_state["person_b_audio"] = None
        return (
            gr.Button("🛑 Stop", elem_classes=["stop-button"]),
            "<div style='text-align: center; padding: 10px; color: #f44336;'>🔴 Click Stop when done recording</div>"
        )

def handle_person_a_audio_update(audio_file):
    """Handle audio update for Person A"""
    if audio_file and recording_state["person_a_recording"]:
        recording_state["person_a_audio"] = audio_file
        # Auto-stop recording when audio is received
        recording_state["person_a_recording"] = False
        return audio_file, "🎤 Talk", "talk-button"
    return None, "🎤 Talk", "talk-button"

def handle_person_b_audio_update(audio_file):
    """Handle audio update for Person B"""
    if audio_file and recording_state["person_b_recording"]:
        recording_state["person_b_audio"] = audio_file
        # Auto-stop recording when audio is received
        recording_state["person_b_recording"] = False
        return audio_file, "🎤 Talk", "talk-button"
    return None, "🎤 Talk", "talk-button"

def process_person_a_translation(country_b: str, voice_b: str, input_lang_a: str):
    """Process translation for Person A using stored audio"""
    audio_file = recording_state.get("person_a_audio")
    if not audio_file:
        return "", None
    
    try:
        print(f"[DEBUG] Person A processing stored audio: {audio_file}")
        tgt_code = get_language_code_from_country(country_b)
        selected_voice = get_voice_code_from_selections(country_b, voice_b)
        input_language = get_input_language_code_from_selection(input_lang_a)
        
        original_text, detected_lang, translated_text, audio_output = agent.process_audio_translation_with_voice(
            audio_file, tgt_code, selected_voice, input_language
        )
        
        # Add to conversation
        add_message_to_conversation("A", original_text, detected_lang, translated_text, "B")
        
        # Clear processed audio
        recording_state["person_a_audio"] = None
        
        # Return conversation for Person B's tab and audio
        conversation_history = get_full_conversation()
        return conversation_history, audio_output
        
    except Exception as e:
        print(f"[ERROR] process_person_a_translation: {e}")
        return f"Error: {str(e)}", None

def process_person_b_translation(country_a: str, voice_a: str, input_lang_b: str):
    """Process translation for Person B using stored audio"""
    audio_file = recording_state.get("person_b_audio")
    if not audio_file:
        return "", None
    
    try:
        print(f"[DEBUG] Person B processing stored audio: {audio_file}")
        tgt_code = get_language_code_from_country(country_a)
        selected_voice = get_voice_code_from_selections(country_a, voice_a)
        input_language = get_input_language_code_from_selection(input_lang_b)
        
        original_text, detected_lang, translated_text, audio_output = agent.process_audio_translation_with_voice(
            audio_file, tgt_code, selected_voice, input_language
        )
        
        # Add to conversation
        add_message_to_conversation("B", original_text, detected_lang, translated_text, "A")
        
        # Clear processed audio
        recording_state["person_b_audio"] = None
        
        # Return conversation for Person A's tab and audio
        conversation_history = get_full_conversation()
        return conversation_history, audio_output
        
    except Exception as e:
        print(f"[ERROR] process_person_b_translation: {e}")
        return f"Error: {str(e)}", None


# Create Two-Person Translation Interface
with gr.Blocks(
    title="🎙️ Two-Person Live Translation",
    theme=gr.themes.Soft(),
    css="""
    .gradio-container { max-width: 1400px !important; margin: 0 auto !important; }
    .header {
        text-align: center;
        background: linear-gradient(135deg, #4A90E2 0%, #FF6B9D 100%);
        color: white;
        padding: 20px;
        border-radius: 10px;
        margin-bottom: 20px;
    }
    .status-box {
        background: rgba(78, 205, 196, 0.1);
        border: 2px solid rgba(78, 205, 196, 0.3);
        border-radius: 10px;
        padding: 15px;
        text-align: center;
        margin: 15px 0;
    }
    .footer {
        text-align: center;
        background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
        color: white;
        padding: 20px;
        border-radius: 10px;
        margin-top: 30px;
        box-shadow: 0 4px 6px rgba(0, 0, 0, 0.1);
    }
    .guide-box {
        background: rgba(255, 255, 255, 0.05);
        border: 1px solid rgba(255, 255, 255, 0.2);
        border-radius: 10px;
        padding: 20px;
        margin: 15px 0;
    }
    .step-card {
        background: rgba(78, 205, 196, 0.1);
        border-left: 4px solid #4ECDCC;
        padding: 15px;
        margin: 10px 0;
        border-radius: 5px;
    }
    .tips-card {
        background: rgba(255, 193, 7, 0.1);
        border-left: 4px solid #FFC107;
        padding: 15px;
        margin: 10px 0;
        border-radius: 5px;
    }
    .talk-button {
        background: linear-gradient(135deg, #4CAF50 0%, #45a049 100%) !important;
        color: white !important;
        border: none !important;
        padding: 15px 30px !important;
        font-size: 18px !important;
        font-weight: bold !important;
        border-radius: 25px !important;
        cursor: pointer !important;
        transition: all 0.3s ease !important;
        box-shadow: 0 4px 8px rgba(76, 175, 80, 0.3) !important;
        min-height: 60px !important;
    }
    .talk-button:hover {
        transform: translateY(-2px) !important;
        box-shadow: 0 6px 12px rgba(76, 175, 80, 0.4) !important;
    }
    .stop-button {
        background: linear-gradient(135deg, #f44336 0%, #d32f2f 100%) !important;
        color: white !important;
        border: none !important;
        padding: 15px 30px !important;
        font-size: 18px !important;
        font-weight: bold !important;
        border-radius: 25px !important;
        cursor: pointer !important;
        transition: all 0.3s ease !important;
        box-shadow: 0 4px 8px rgba(244, 67, 54, 0.3) !important;
        min-height: 60px !important;
        animation: pulse 2s infinite !important;
    }
    .stop-button:hover {
        transform: translateY(-2px) !important;
        box-shadow: 0 6px 12px rgba(244, 67, 54, 0.4) !important;
    }
    @keyframes pulse {
        0% { box-shadow: 0 4px 8px rgba(244, 67, 54, 0.3); }
        50% { box-shadow: 0 6px 16px rgba(244, 67, 54, 0.6); }
        100% { box-shadow: 0 4px 8px rgba(244, 67, 54, 0.3); }
    }
    .hidden-audio {
        display: none !important;
    }
    """
) as demo:
    
    # Header
    api_status = "Ready" if agent.gemini_configured else "Missing API Key"
    edge_tts_status = "Ready" if EDGE_TTS_AVAILABLE else "Not Available"
    
    gr.HTML(f"""
    <div class="header">
        <h1>🎙️ Two-Person Live Translation</h1>
        <p>Real-time Cross-Translation between Person A & Person B</p>
        <div style="margin-top: 15px;">
            <span style="background: rgba(255,255,255,0.2); padding: 6px 12px; border-radius: 15px; margin: 0 5px;">
                <strong>Gemini:</strong> {api_status}
            </span>
            <span style="background: rgba(255,255,255,0.2); padding: 6px 12px; border-radius: 15px; margin: 0 5px;">
                <strong>Edge TTS:</strong> {edge_tts_status}
            </span>
        </div>
        <div style="margin-top: 10px;">🧠 <strong>Digitized Brains</strong></div>
    </div>
    """)

    # Status Box
    gr.HTML(f"""
    <div class="status-box">
        <h4>🤖 AI Pipeline Status</h4>
        <div style="display: flex; justify-content: center; gap: 20px; flex-wrap: wrap;">
            <span><strong>🧠 Gemini Speech Recognition:</strong> {'🟢 Ready' if agent.gemini_configured else '🔴 Not Ready'}</span>
            <span><strong>🧠 Gemini Translation:</strong> {'🟢 Ready' if agent.gemini_configured else '🔴 Not Ready'}</span>
            <span><strong>🔊 Edge TTS:</strong> {'🟢 Ready' if EDGE_TTS_AVAILABLE else '🔴 Not Ready'}</span>
        </div>
    </div>
    """)

    with gr.Tabs():
        # Person A Tab - Only shows translation FROM Person B
        with gr.TabItem("Person A View"):
            gr.Markdown("### Person A receives translations from Person B")
            
            # Conversation History for Person A
            conversation_display_a = gr.Textbox(
                label="Full Conversation",
                lines=8,
                interactive=False,
                placeholder="Conversation will appear here...",
                value=""
            )
            
            with gr.Row():
                with gr.Column(scale=2):
                    # Audio component with custom recording interface
                    mic_a = gr.Audio(
                        sources=["microphone"],
                        type="filepath",
                        label="Person A: Record Your Voice",
                        elem_id="mic_a"
                    )
                    
                    # Talk/Stop button for Person A
                    talk_button_a = gr.Button(
                        "🎤 Talk",
                        elem_classes=["talk-button"],
                        size="lg",
                        elem_id="talk_button_a"
                    )
                    
                    # Status display for Person A
                    status_a = gr.HTML(
                        "<div style='text-align: center; padding: 10px; color: #666;'>Ready to record</div>",
                        elem_id="status_a"
                    )
                    
                with gr.Column(scale=1):
                    # Person A's input language selection
                    input_lang_a = gr.Dropdown(
                        choices=get_input_language_options(),
                        label="Person A's Input Language",
                        value="auto | Auto-detect Language (Recommended)",
                        info="Select your speaking language or use auto-detect"
                    )
                    
                    # Person B's output settings
                    country_b_for_a = gr.Dropdown(
                        choices=get_country_options(),
                        label="Person B's Language",
                        value="vi-vn | Vietnamese (Vietnam)"
                    )
                    voice_b_for_a = gr.Dropdown(
                        choices=["HoaiMy (Female)", "NamMinh (Male)"],
                        label="Person B's Voice",
                        value="HoaiMy (Female)"
                    )
            
            # Only show audio FROM Person B (Person A hears this)
            audio_from_b = gr.Audio(
                label="🔊 Translation Audio from Person B",
                interactive=False,
                value=None,
                autoplay=True
            )

        # Person B Tab - Only shows translation FROM Person A  
        with gr.TabItem("Person B View"):
            gr.Markdown("### Person B receives translations from Person A")
            
            # Conversation History for Person B
            conversation_display_b = gr.Textbox(
                label="Full Conversation",
                lines=8,
                interactive=False,
                placeholder="Conversation will appear here...",
                value=""
            )
            
            with gr.Row():
                with gr.Column(scale=2):
                    # Audio component with custom recording interface
                    mic_b = gr.Audio(
                        sources=["microphone"],
                        type="filepath",
                        label="Person B: Record Your Voice",
                        elem_id="mic_b"
                    )
                    
                    # Talk/Stop button for Person B
                    talk_button_b = gr.Button(
                        "🎤 Talk",
                        elem_classes=["talk-button"],
                        size="lg",
                        elem_id="talk_button_b"
                    )
                    
                    # Status display for Person B
                    status_b = gr.HTML(
                        "<div style='text-align: center; padding: 10px; color: #666;'>Ready to record</div>",
                        elem_id="status_b"
                    )
                    
                with gr.Column(scale=1):
                    # Person B's input language selection
                    input_lang_b = gr.Dropdown(
                        choices=get_input_language_options(),
                        label="Person B's Input Language",
                        value="auto | Auto-detect Language (Recommended)",
                        info="Select your speaking language or use auto-detect"
                    )
                    
                    # Person A's output settings
                    country_a_for_b = gr.Dropdown(
                        choices=get_country_options(),
                        label="Person A's Language",
                        value="en-us | English (United States)"
                    )
                    voice_a_for_b = gr.Dropdown(
                        choices=["Jenny (Female)", "Guy (Male)"],
                        label="Person A's Voice",
                        value="Jenny (Female)"
                    )
            
            # Only show audio FROM Person A (Person B hears this)
            audio_from_a = gr.Audio(
                label="🔊 Translation Audio from Person A",
                interactive=False,
                value=None,
                autoplay=True
            )


        # User Guide Tab
        with gr.TabItem("📚 User Guide"):
            gr.HTML("""
            <div class="guide-box">
                <h2 style="color: #4A90E2; margin-bottom: 20px;">🎙️ Two-Way Translation App User Guide</h2>
                <p style="font-size: 16px; margin-bottom: 20px;">This application enables two people to communicate in different languages through automatic translation.</p>
            </div>
            """)
            
            gr.HTML("""
            <div class="step-card">
                <h3>🚀 Step 1: Preparation</h3>
                <ul>
                    <li><strong>Check microphone:</strong> Ensure your microphone works properly</li>
                    <li><strong>Quiet environment:</strong> Find a location with minimal background noise</li>
                    <li><strong>Stable internet:</strong> Internet connection required for AI processing</li>
                    <li><strong>Speakers/headphones:</strong> To hear translated audio output</li>
                </ul>
            </div>
            """)
            
            gr.HTML("""
            <div class="step-card">
                <h3>👥 Step 2: Choose Your Tab</h3>
                <ul>
                    <li><strong>Person A View:</strong> For the first person</li>
                    <li><strong>Person B View:</strong> For the second person</li>
                    <li><strong>Each person only needs to focus on their own tab</strong></li>
                </ul>
            </div>
            """)
            
            gr.HTML("""
            <div class="step-card">
                <h3>🗣️ Step 3: Language Setup</h3>
                <ul>
                    <li><strong>Input Language:</strong> Select the language you will speak (or Auto-detect)</li>
                    <li><strong>Target Language:</strong> Choose the language to translate to</li>
                    <li><strong>Voice:</strong> Select voice for translated audio output</li>
                    <li><strong>Recommendation:</strong> Choose specific language instead of Auto-detect for better accuracy</li>
                </ul>
            </div>
            """)
            
            gr.HTML("""
            <div class="step-card">
                <h3>🎤 Step 4: One-Click Talk Button Recording</h3>
                <ul>
                    <li><strong>Click "🎤 Talk"</strong> - Button turns green and starts recording automatically</li>
                    <li><strong>Speak clearly for 3-7 seconds</strong> - Button shows "🛑 Stop" with red pulse animation</li>
                    <li><strong>Click "🛑 Stop"</strong> - Automatically stops recording and processes translation</li>
                    <li><strong>Audio automatically plays</strong> - Translation appears in the other person's view</li>
                    <li><strong>Ready for next recording</strong> - System automatically resets for next conversation</li>
                </ul>
            </div>
            """)
            
            gr.HTML("""
            <div class="step-card">
                <h3>✨ Key Features</h3>
                <ul>
                    <li><strong>🎯 One-Click Operation:</strong> No need to manually start/stop recording - Talk button handles everything</li>
                    <li><strong>🔄 Auto-Clear:</strong> System automatically clears previous recordings for seamless conversation flow</li>
                    <li><strong>🎵 Auto-Play:</strong> Translated audio plays immediately when ready</li>
                    <li><strong>🎨 Visual Feedback:</strong> Button colors and animations show current recording state</li>
                    <li><strong>🚀 Instant Translation:</strong> From speech to translation in one click</li>
                </ul>
            </div>
            """)
            
            gr.HTML("""
            <div class="tips-card">
                <h3>💡 Tips for Best Results</h3>
                <ul>
                    <li><strong>🎤 Microphone:</strong> Speak close to mic, not too loud or quiet</li>
                    <li><strong>⏱️ Duration:</strong> 3-7 seconds is ideal (not too short/long)</li>
                    <li><strong>🗣️ Speaking style:</strong> Clear, not too fast, natural punctuation</li>
                    <li><strong>🔇 Environment:</strong> Minimize background noise</li>
                    <li><strong>🌍 Language:</strong> Select correct input language instead of auto-detect</li>
                    <li><strong>🔄 Retry:</strong> If unsuccessful, try again with different approach</li>
                </ul>
            </div>
            """)
            
            gr.HTML("""
            <div class="step-card">
                <h3>🔧 Common Troubleshooting</h3>
                <ul>
                    <li><strong>"Could not understand speech":</strong> Speak more clearly, check microphone</li>
                    <li><strong>No audio output:</strong> Check speakers/headphones</li>
                    <li><strong>Incorrect translation:</strong> Select specific input language</li>
                    <li><strong>Slow processing:</strong> Check internet connection</li>
                </ul>
            </div>
            """)
            

    # JavaScript for controlling recording
    js_control_recording = """
    function(button_text, elem_classes) {
        // Get the button element and audio component
        const button = arguments[2];  // The button that was clicked
        const audio_component = document.querySelector('audio');
        
        if (button_text.includes('Talk')) {
            // Start recording
            if (audio_component) {
                const startButton = audio_component.querySelector('[aria-label="Record from microphone"]');
                if (startButton) startButton.click();
            }
            return ["🛑 Stop", "stop-button"];
        } else {
            // Stop recording  
            if (audio_component) {
                const stopButton = audio_component.querySelector('[aria-label="Stop recording"]');
                if (stopButton) stopButton.click();
            }
            return ["🎤 Talk", "talk-button"];
        }
    }
    """

    # Event Handlers
    # Voice options update
    country_b_for_a.change(
        fn=update_voice_options,
        inputs=[country_b_for_a],
        outputs=[voice_b_for_a]
    )
    
    country_a_for_b.change(
        fn=update_voice_options,
        inputs=[country_a_for_b],
        outputs=[voice_a_for_b]
    )
    
    # JavaScript-powered Talk/Stop button handlers
    def handle_person_a_recording():
        return None
    
    def handle_person_b_recording():
        return None
    
    talk_button_a.click(
        fn=handle_person_a_recording,
        js="""
        () => {
            console.log("🎤 Person A Talk button clicked");
            
            // Find Gradio's recording buttons (search globally after recording state changes)
            const micContainer = document.getElementById('mic_a');
            let recordBtn = micContainer.querySelector('.record-button');
            let stopBtn = micContainer.querySelector('.stop-button');
            
            // If not found in container, search globally (happens after recording)
            if (!recordBtn || !stopBtn) {
                const allRecordBtns = document.querySelectorAll('.record-button');
                const allStopBtns = document.querySelectorAll('.stop-button');
                
                // Find Person A buttons by checking parent containers
                for (let i = 0; i < allRecordBtns.length; i++) {
                    const btn = allRecordBtns[i];
                    const container = btn.closest('[id*="mic_a"]');
                    if (container && container.id === 'mic_a') {
                        recordBtn = btn;
                        stopBtn = allStopBtns[i];
                        console.log("🔍 Found Person A buttons globally:", container.id);
                        break;
                    }
                }
                
                // Fallback to first button if specific search fails
                if (!recordBtn) {
                    recordBtn = allRecordBtns[0];
                    stopBtn = allStopBtns[0];
                    console.log("🔍 Using fallback buttons");
                }
            }
            const statusEl = document.getElementById('status_a');
            const btn = document.getElementById('talk_button_a');
            
            // Initialize state if not exists
            if (!window.personARecording) {
                window.personARecording = { isRecording: false };
            }
            
            if (!window.personARecording.isRecording) {
                // Clear any existing audio first to restore record button
                const clearBtn = micContainer.querySelector('button[aria-label="Clear"]');
                if (clearBtn) {
                    console.log("🧹 Clearing existing audio for Person A");
                    clearBtn.click();
                    
                    // Wait a moment for UI to update, then find record button
                    setTimeout(() => {
                        const newRecordBtn = micContainer.querySelector('.record-button') || 
                                           document.querySelectorAll('.record-button')[0];
                        if (newRecordBtn) {
                            console.log("✅ Clicking Gradio's Record button for Person A");
                            newRecordBtn.click();
                            window.personARecording.isRecording = true;
                            
                            // Update UI
                            if (btn) {
                                btn.textContent = '🛑 Stop';
                                btn.className = btn.className.replace('talk-button', 'stop-button');
                            }
                            
                            if (statusEl) {
                                statusEl.innerHTML = '<div style="text-align: center; padding: 10px; color: #f44336;">🔴 Recording... Click Stop when done</div>';
                            }
                        }
                    }, 100);
                } else if (recordBtn) {
                    // No clear needed, record button available
                    console.log("✅ Clicking Gradio's Record button for Person A");
                    recordBtn.click();
                    window.personARecording.isRecording = true;
                    
                    // Update UI
                    if (btn) {
                        btn.textContent = '🛑 Stop';
                        btn.className = btn.className.replace('talk-button', 'stop-button');
                    }
                    
                    if (statusEl) {
                        statusEl.innerHTML = '<div style="text-align: center; padding: 10px; color: #f44336;">🔴 Recording... Click Stop when done</div>';
                    }
                }
                
            } else if (window.personARecording.isRecording && stopBtn) {
                // Stop recording by clicking Gradio's stop button
                console.log("⏹️ Clicking Gradio's Stop button for Person A");
                stopBtn.click();
                window.personARecording.isRecording = false;
                
                // Update UI
                if (btn) {
                    btn.textContent = '🎤 Talk';
                    btn.className = btn.className.replace('stop-button', 'talk-button');
                }
                
                if (statusEl) {
                    statusEl.innerHTML = '<div style="text-align: center; padding: 10px; color: #4CAF50;">✅ Processing translation...</div>';
                }
            } else {
                console.error("❌ Gradio recording buttons not found");
                if (statusEl) {
                    statusEl.innerHTML = '<div style="color: red;">❌ Recording interface not available</div>';
                }
            }
        }
        """
    )
    
    talk_button_b.click(
        fn=handle_person_b_recording,
        js="""
        () => {
            console.log("🎤 Person B Talk button clicked");
            
            // Find Gradio's recording buttons (search globally after recording state changes)
            const micContainer = document.getElementById('mic_b');
            let recordBtn = micContainer.querySelector('.record-button');
            let stopBtn = micContainer.querySelector('.stop-button');
            
            // If not found in container, search globally (happens after recording)
            if (!recordBtn || !stopBtn) {
                const allRecordBtns = document.querySelectorAll('.record-button');
                const allStopBtns = document.querySelectorAll('.stop-button');
                
                // Find Person B buttons by checking parent containers
                for (let i = 0; i < allRecordBtns.length; i++) {
                    const btn = allRecordBtns[i];
                    const container = btn.closest('[id*="mic_b"]');
                    if (container && container.id === 'mic_b') {
                        recordBtn = btn;
                        stopBtn = allStopBtns[i];
                        console.log("🔍 Found Person B buttons globally:", container.id);
                        break;
                    }
                }
                
                // Fallback to second button if specific search fails
                if (!recordBtn) {
                    recordBtn = allRecordBtns[1] || allRecordBtns[0];
                    stopBtn = allStopBtns[1] || allStopBtns[0];
                    console.log("🔍 Using fallback buttons for Person B");
                }
            }
            const statusEl = document.getElementById('status_b');
            const btn = document.getElementById('talk_button_b');
            
            // Initialize state if not exists
            if (!window.personBRecording) {
                window.personBRecording = { isRecording: false };
            }
            
            if (!window.personBRecording.isRecording) {
                // Clear any existing audio first to restore record button
                const clearBtn = micContainer.querySelector('button[aria-label="Clear"]');
                if (clearBtn) {
                    console.log("🧹 Clearing existing audio for Person B");
                    clearBtn.click();
                    
                    // Wait a moment for UI to update, then find record button
                    setTimeout(() => {
                        const newRecordBtn = micContainer.querySelector('.record-button') || 
                                           document.querySelectorAll('.record-button')[1];
                        if (newRecordBtn) {
                            console.log("✅ Clicking Gradio's Record button for Person B");
                            newRecordBtn.click();
                            window.personBRecording.isRecording = true;
                            
                            // Update UI
                            if (btn) {
                                btn.textContent = '🛑 Stop';
                                btn.className = btn.className.replace('talk-button', 'stop-button');
                            }
                            
                            if (statusEl) {
                                statusEl.innerHTML = '<div style="text-align: center; padding: 10px; color: #f44336;">🔴 Recording... Click Stop when done</div>';
                            }
                        }
                    }, 100);
                } else if (recordBtn) {
                    // No clear needed, record button available
                    console.log("✅ Clicking Gradio's Record button for Person B");
                    recordBtn.click();
                    window.personBRecording.isRecording = true;
                    
                    // Update UI
                    if (btn) {
                        btn.textContent = '🛑 Stop';
                        btn.className = btn.className.replace('talk-button', 'stop-button');
                    }
                    
                    if (statusEl) {
                        statusEl.innerHTML = '<div style="text-align: center; padding: 10px; color: #f44336;">🔴 Recording... Click Stop when done</div>';
                    }
                }
                
            } else if (window.personBRecording.isRecording && stopBtn) {
                // Stop recording by clicking Gradio's stop button
                console.log("⏹️ Clicking Gradio's Stop button for Person B");
                stopBtn.click();
                window.personBRecording.isRecording = false;
                
                // Update UI
                if (btn) {
                    btn.textContent = '🎤 Talk';
                    btn.className = btn.className.replace('stop-button', 'talk-button');
                }
                
                if (statusEl) {
                    statusEl.innerHTML = '<div style="text-align: center; padding: 10px; color: #4CAF50;">✅ Processing translation...</div>';
                }
            } else {
                console.error("❌ Gradio recording buttons not found");
                if (statusEl) {
                    statusEl.innerHTML = '<div style="color: red;">❌ Recording interface not available</div>';
                }
            }
        }
        """
    )
    
    # JavaScript to implement direct recording from Talk buttons
    gr.HTML("""
    <script>
    console.log("🎤 Setting up direct recording control...");
    
    let personARecording = false;
    let personBRecording = false;
    let personAMediaRecorder = null;
    let personBMediaRecorder = null;
    let personAStream = null;
    let personBStream = null;
    let personAAudioChunks = [];
    let personBAudioChunks = [];
    
    function findGradioAudioInputs() {
        // Find Gradio audio input components to send our recorded audio to
        console.log("🔍 Finding Gradio audio inputs...");
        const audioInputA = document.querySelector('#mic_a input[type="file"]');
        const audioInputB = document.querySelector('#mic_b input[type="file"]');
        
        console.log("Audio Input A found:", !!audioInputA);
        console.log("Audio Input B found:", !!audioInputB);
        
        return { audioInputA, audioInputB };
    }
    
    function createAudioFile(audioBlob, filename) {
        // Create a File object from audio blob
        const file = new File([audioBlob], filename, {
            type: 'audio/wav',
            lastModified: Date.now()
        });
        return file;
    }
    
    function sendAudioToGradio(audioFile, audioInput) {
        // Send recorded audio file to Gradio's file input
        try {
            if (audioInput) {
                // Create a FileList-like object
                const fileList = {
                    0: audioFile,
                    length: 1,
                    item: (index) => index === 0 ? audioFile : null
                };
                
                // Set the files property
                Object.defineProperty(audioInput, 'files', {
                    value: fileList,
                    writable: false
                });
                
                // Trigger change event
                const event = new Event('change', { bubbles: true });
                audioInput.dispatchEvent(event);
                
                console.log("✅ Audio file sent to Gradio:", audioFile.name);
                return true;
            }
        } catch (error) {
            console.error("❌ Failed to send audio to Gradio:", error);
        }
        return false;
    }
    
    function setupDirectRecording() {
        setTimeout(() => {
            const talkButtonA = document.getElementById('talk_button_a');
            const talkButtonB = document.getElementById('talk_button_b');
            const statusA = document.getElementById('status_a');
            const statusB = document.getElementById('status_b');
            
            console.log("Talk Button A found:", !!talkButtonA);
            console.log("Talk Button B found:", !!talkButtonB);
            
            // Find Gradio audio inputs
            const { audioInputA, audioInputB } = findGradioAudioInputs();
            
            // Setup Person A direct recording
            if (talkButtonA) {
                // Remove existing event listeners
                const newTalkButtonA = talkButtonA.cloneNode(true);
                talkButtonA.parentNode.replaceChild(newTalkButtonA, talkButtonA);
                
                newTalkButtonA.addEventListener('click', async function(e) {
                    e.preventDefault();
                    e.stopPropagation();
                    
                    console.log("🎤 Person A Talk button clicked, currently recording:", personARecording);
                    
                    if (!personARecording) {
                        // Start direct recording
                        try {
                            console.log("🔴 Starting Person A direct recording...");
                            
                            // Request microphone access
                            personAStream = await navigator.mediaDevices.getUserMedia({ 
                                audio: {
                                    sampleRate: 16000,
                                    channelCount: 1,
                                    echoCancellation: true,
                                    noiseSuppression: true
                                } 
                            });
                            
                            console.log("✅ Microphone access granted");
                            
                            // Create MediaRecorder
                            personAMediaRecorder = new MediaRecorder(personAStream, {
                                mimeType: 'audio/webm;codecs=opus'
                            });
                            
                            personAAudioChunks = [];
                            
                            // Setup event handlers
                            personAMediaRecorder.ondataavailable = function(event) {
                                if (event.data.size > 0) {
                                    personAAudioChunks.push(event.data);
                                }
                            };
                            
                            personAMediaRecorder.onstop = function() {
                                console.log("🎵 Person A recording stopped, processing...");
                                
                                // Create audio blob
                                const audioBlob = new Blob(personAAudioChunks, { type: 'audio/webm' });
                                console.log("Audio blob created:", audioBlob.size, "bytes");
                                
                                // Convert to file and send to Gradio
                                const audioFile = createAudioFile(audioBlob, `person_a_recording_${Date.now()}.webm`);
                                
                                if (sendAudioToGradio(audioFile, audioInputA)) {
                                    console.log("✅ Audio sent to Gradio successfully");
                                    if (statusA) {
                                        statusA.innerHTML = '<div style="text-align: center; padding: 10px; color: #4CAF50;">✅ Processing translation...</div>';
                                    }
                                } else {
                                    console.error("❌ Failed to send audio to Gradio");
                                    if (statusA) {
                                        statusA.innerHTML = '<div style="text-align: center; padding: 10px; color: #f44336;">❌ Failed to process audio</div>';
                                    }
                                }
                                
                                // Cleanup
                                personAStream.getTracks().forEach(track => track.stop());
                                personAStream = null;
                                personAMediaRecorder = null;
                            };
                            
                            // Start recording
                            personAMediaRecorder.start();
                            personARecording = true;
                            
                            // Update status
                            if (statusA) {
                                statusA.innerHTML = '<div style="text-align: center; padding: 10px; color: #f44336;">🔴 Recording... Click Stop when done</div>';
                            }
                            
                            console.log("✅ Person A recording started successfully");
                            
                        } catch (error) {
                            console.error("❌ Error starting Person A recording:", error);
                            if (statusA) {
                                statusA.innerHTML = '<div style="text-align: center; padding: 10px; color: #f44336;">❌ Microphone access denied or failed</div>';
                            }
                        }
                        
                    } else {
                        // Stop recording
                        console.log("⏹️ Stopping Person A recording...");
                        
                        if (personAMediaRecorder && personAMediaRecorder.state === 'recording') {
                            personAMediaRecorder.stop();
                            personARecording = false;
                            
                            if (statusA) {
                                statusA.innerHTML = '<div style="text-align: center; padding: 10px; color: #4CAF50;">✅ Processing audio...</div>';
                            }
                        }
                    }
                });
            }
            
            // Setup Person B direct recording  
            if (talkButtonB) {
                // Remove existing event listeners
                const newTalkButtonB = talkButtonB.cloneNode(true);
                talkButtonB.parentNode.replaceChild(newTalkButtonB, talkButtonB);
                
                newTalkButtonB.addEventListener('click', async function(e) {
                    e.preventDefault();
                    e.stopPropagation();
                    
                    console.log("🎤 Person B Talk button clicked, currently recording:", personBRecording);
                    
                    if (!personBRecording) {
                        // Start direct recording
                        try {
                            console.log("🔴 Starting Person B direct recording...");
                            
                            // Request microphone access
                            personBStream = await navigator.mediaDevices.getUserMedia({ 
                                audio: {
                                    sampleRate: 16000,
                                    channelCount: 1,
                                    echoCancellation: true,
                                    noiseSuppression: true
                                } 
                            });
                            
                            console.log("✅ Microphone access granted for Person B");
                            
                            // Create MediaRecorder
                            personBMediaRecorder = new MediaRecorder(personBStream, {
                                mimeType: 'audio/webm;codecs=opus'
                            });
                            
                            personBAudioChunks = [];
                            
                            // Setup event handlers
                            personBMediaRecorder.ondataavailable = function(event) {
                                if (event.data.size > 0) {
                                    personBAudioChunks.push(event.data);
                                }
                            };
                            
                            personBMediaRecorder.onstop = function() {
                                console.log("🎵 Person B recording stopped, processing...");
                                
                                // Create audio blob
                                const audioBlob = new Blob(personBAudioChunks, { type: 'audio/webm' });
                                console.log("Audio blob created:", audioBlob.size, "bytes");
                                
                                // Convert to file and send to Gradio
                                const audioFile = createAudioFile(audioBlob, `person_b_recording_${Date.now()}.webm`);
                                
                                if (sendAudioToGradio(audioFile, audioInputB)) {
                                    console.log("✅ Audio sent to Gradio successfully");
                                    if (statusB) {
                                        statusB.innerHTML = '<div style="text-align: center; padding: 10px; color: #4CAF50;">✅ Processing translation...</div>';
                                    }
                                } else {
                                    console.error("❌ Failed to send audio to Gradio");
                                    if (statusB) {
                                        statusB.innerHTML = '<div style="text-align: center; padding: 10px; color: #f44336;">❌ Failed to process audio</div>';
                                    }
                                }
                                
                                // Cleanup
                                personBStream.getTracks().forEach(track => track.stop());
                                personBStream = null;
                                personBMediaRecorder = null;
                            };
                            
                            // Start recording
                            personBMediaRecorder.start();
                            personBRecording = true;
                            
                            // Update status
                            if (statusB) {
                                statusB.innerHTML = '<div style="text-align: center; padding: 10px; color: #f44336;">🔴 Recording... Click Stop when done</div>';
                            }
                            
                            console.log("✅ Person B recording started successfully");
                            
                        } catch (error) {
                            console.error("❌ Error starting Person B recording:", error);
                            if (statusB) {
                                statusB.innerHTML = '<div style="text-align: center; padding: 10px; color: #f44336;">❌ Microphone access denied or failed</div>';
                            }
                        }
                        
                    } else {
                        // Stop recording
                        console.log("⏹️ Stopping Person B recording...");
                        
                        if (personBMediaRecorder && personBMediaRecorder.state === 'recording') {
                            personBMediaRecorder.stop();
                            personBRecording = false;
                            
                            if (statusB) {
                                statusB.innerHTML = '<div style="text-align: center; padding: 10px; color: #4CAF50;">✅ Processing audio...</div>';
                            }
                        }
                    }
                });
            }
            
            console.log("✅ Direct recording setup complete");
            
        }, 3000); // Wait for Gradio to fully load
    }
    
    // Initialize with retry mechanism
    function initDirectRecording() {
        setupDirectRecording();
        
        // Retry in case interface isn't ready
        setTimeout(() => {
            console.log("🔄 Retrying direct recording setup...");
            setupDirectRecording();
        }, 5000);
        
        setTimeout(() => {
            console.log("🔄 Final retry for direct recording setup...");
            setupDirectRecording();
        }, 8000);
    }
    
    // Start initialization
    if (document.readyState === 'loading') {
        document.addEventListener('DOMContentLoaded', initDirectRecording);
    } else {
        initDirectRecording();
    }
    
    console.log("🎤 Direct recording script loaded");
    alert("🎤 Direct recording script loaded");
    
    </script>
    """)
    
    # Enhanced audio change handlers with JavaScript state sync
    def handle_person_a_audio_change(audio, country_b, voice_b, input_lang_a_val):
        # Always process audio when received (JavaScript controls when recording happens)
        if audio:
            # Process translation
            conversation, audio_output = translate_person_a_to_b(audio, country_b, voice_b, input_lang_a_val)
            # Reset recording state and button
            recording_state["person_a_recording"] = False
            reset_button = gr.Button("🎤 Talk", elem_classes=["talk-button"])
            reset_status = """<div style='text-align: center; padding: 10px; color: #4CAF50;'>✅ Translation complete! Ready for next recording</div>
            <script>
            // Reset JavaScript state
            if (typeof personARecording !== 'undefined') {
                personARecording = false;
                console.log("🔄 Person A recording state reset");
            }
            </script>"""
            return conversation, audio_output, reset_button, reset_status
        return "", None, gr.Button("🎤 Talk", elem_classes=["talk-button"]), "<div style='text-align: center; padding: 10px; color: #666;'>Ready to record</div>"

    def handle_person_b_audio_change(audio, country_a, voice_a, input_lang_b_val):
        # Always process audio when received (JavaScript controls when recording happens)
        if audio:
            # Process translation
            conversation, audio_output = translate_person_b_to_a(audio, country_a, voice_a, input_lang_b_val)
            # Reset recording state and button
            recording_state["person_b_recording"] = False
            reset_button = gr.Button("🎤 Talk", elem_classes=["talk-button"])
            reset_status = """<div style='text-align: center; padding: 10px; color: #4CAF50;'>✅ Translation complete! Ready for next recording</div>
            <script>
            // Reset JavaScript state
            if (typeof personBRecording !== 'undefined') {
                personBRecording = false;
                console.log("🔄 Person B recording state reset");
            }
            </script>"""
            return conversation, audio_output, reset_button, reset_status
        return "", None, gr.Button("🎤 Talk", elem_classes=["talk-button"]), "<div style='text-align: center; padding: 10px; color: #666;'>Ready to record</div>"

    mic_a.change(
        fn=handle_person_a_audio_change,
        inputs=[mic_a, country_b_for_a, voice_b_for_a, input_lang_a],
        outputs=[conversation_display_b, audio_from_a, talk_button_a, status_a]
    )
    
    mic_b.change(
        fn=handle_person_b_audio_change,
        inputs=[mic_b, country_a_for_b, voice_a_for_b, input_lang_b],
        outputs=[conversation_display_a, audio_from_b, talk_button_b, status_b]
    )

    # Footer
    gr.HTML("""
    <div class="footer">
        <div style="display: flex; align-items: center; justify-content: center; gap: 10px; margin-bottom: 10px;">
            <span style="font-size: 24px;">🧠</span>
            <h3 style="margin: 0; font-size: 20px; font-weight: 600; background: linear-gradient(45deg, #fff, #e0e0e0); -webkit-background-clip: text; -webkit-text-fill-color: transparent; background-clip: text;">
                Digitized Brains - AI Translation
            </h3>
        </div>
        <div style="height: 1px; background: linear-gradient(90deg, transparent, rgba(255,255,255,0.3), transparent); margin: 15px 0;"></div>
        <p style="margin: 0; font-size: 14px; opacity: 0.8; font-style: italic;">
            Intelligent Communication Solutions
        </p>
    </div>
    """)

if __name__ == "__main__":
    print("===== Two-Person Live Translation Startup =====")
    print("Starting Two-Person Live Translation with Google Gemini")
    print(f"Google Gemini API Status: {'Ready' if agent.gemini_configured else 'Missing - Set GOOGLE_API_KEY'}")
    print(f"Edge TTS Status: {'Ready' if EDGE_TTS_AVAILABLE else 'Not Available'}")
    
    if agent.gemini_configured:
        print("Production Mode - Full Gemini AI Translation enabled")
        print("Speech Recognition: Google Gemini Flash 2.0")
        print("Language Detection: Google Gemini Flash 2.0")  
        print("Translation Model: Google Gemini Flash 2.0")
        print("🧠 All AI processing powered by Gemini Flash 2.0!")
    else:
        print("Demo Mode - Configure GOOGLE_API_KEY for full functionality")
    
    # Use environment port or default (7860 is Hugging Face standard)
    port = int(os.environ.get("PORT", os.environ.get("GRADIO_SERVER_PORT", 7860)))
    demo.launch(
        server_name="0.0.0.0",
        server_port=port,
        share=False,
        show_error=True,
        ssr_mode=False,  # Disable SSR for better container compatibility
        show_api=False   # Reduce overhead
    )