#!/usr/bin/env python3
"""
AIVA Telegram Voice Channel
============================
Send voice messages to Kinan via Telegram using ElevenLabs TTS.

Features:
- Convert text to speech via ElevenLabs API
- Send voice notes to Telegram (OGG/Opus format)
- Fallback to MP3 audio if ffmpeg unavailable
- Poll Telegram for incoming messages
- Escalation support with voice narration

Author: Genesis System
Story: AIVA-Telegram-Voice
"""

import os
import sys
import json
import time
import tempfile
import subprocess
from pathlib import Path
from typing import Optional, List, Dict, Tuple
from urllib import request, parse
from urllib.error import HTTPError, URLError
from datetime import datetime

# Genesis root path
sys.path.insert(0, '/mnt/e/genesis-system')

# Cache directory for temp audio files (E: drive)
CACHE_DIR = Path("/mnt/e/genesis-system/AIVA/voice/cache")
CACHE_DIR.mkdir(parents=True, exist_ok=True)


class TelegramVoiceChannel:
    """
    Telegram voice messaging channel for AIVA.

    Sends voice messages to Kinan using ElevenLabs TTS + Telegram Bot API.
    """

    def __init__(
        self,
        telegram_bot_token: Optional[str] = None,
        telegram_chat_id: Optional[str] = None,
        gemini_api_key: Optional[str] = None,
        gemini_voice: str = "Leda",  # Calm, natural female voice
        elevenlabs_api_key: Optional[str] = None,
        voice_id: str = "21m00Tcm4TlvDq8ikWAM",  # Rachel voice (warm, professional)
        model_id: str = "eleven_multilingual_v2"
    ):
        """
        Initialize Telegram voice channel.

        TTS priority: Gemini 2.5 Flash → ElevenLabs → gTTS (Google free)

        Args:
            telegram_bot_token: Telegram bot token (from env TELEGRAM_BOT_TOKEN)
            telegram_chat_id: Kinan's Telegram chat ID (from env TELEGRAM_CHAT_ID)
            gemini_api_key: Gemini API key (from env GEMINI_API_KEY)
            gemini_voice: Gemini TTS voice name (Kore, Phoebe, Sage, etc.)
            elevenlabs_api_key: ElevenLabs API key (from env ELEVENLABS_API_KEY)
            voice_id: ElevenLabs voice ID (default: Rachel)
            model_id: ElevenLabs model (default: eleven_multilingual_v2)
        """
        self.telegram_bot_token = telegram_bot_token or os.getenv("TELEGRAM_BOT_TOKEN")
        self.telegram_chat_id = telegram_chat_id or os.getenv("TELEGRAM_CHAT_ID")
        self.gemini_api_key = gemini_api_key or os.getenv("GEMINI_API_KEY")
        self.gemini_voice = gemini_voice
        self.elevenlabs_api_key = elevenlabs_api_key or os.getenv("ELEVENLABS_API_KEY")
        self.voice_id = voice_id or os.getenv("ELEVENLABS_VOICE_ID", "21m00Tcm4TlvDq8ikWAM")
        self.model_id = model_id

        # Validation
        if not self.telegram_bot_token:
            raise ValueError("TELEGRAM_BOT_TOKEN not configured")
        if not self.telegram_chat_id:
            raise ValueError("TELEGRAM_CHAT_ID not configured")

        # Telegram API base URL
        self.telegram_base_url = f"https://api.telegram.org/bot{self.telegram_bot_token}"

        # ElevenLabs API base URL
        self.elevenlabs_base_url = "https://api.elevenlabs.io/v1"

        # Track last update ID for polling
        self.last_update_id = 0

        # Check if ffmpeg is available (for MP3 → OGG conversion)
        self.has_ffmpeg = self._check_ffmpeg()

        # Gemini TTS API
        self.gemini_tts_url = (
            "https://generativelanguage.googleapis.com/v1beta/models/"
            "gemini-2.5-flash-preview-tts:generateContent"
        )

        print(f"[TelegramVoiceChannel] Initialized")
        print(f"  Telegram Chat ID: {self.telegram_chat_id}")
        print(f"  TTS Engine: {'Gemini 2.5 Flash' if self.gemini_api_key else 'ElevenLabs' if self.elevenlabs_api_key else 'gTTS'}")
        print(f"  Gemini Voice: {self.gemini_voice}")
        print(f"  FFmpeg available: {self.has_ffmpeg}")

    def _check_ffmpeg(self) -> bool:
        """Check if ffmpeg is available in PATH."""
        try:
            result = subprocess.run(
                ["ffmpeg", "-version"],
                stdout=subprocess.PIPE,
                stderr=subprocess.PIPE,
                timeout=5
            )
            return result.returncode == 0
        except (FileNotFoundError, subprocess.TimeoutExpired):
            return False

    def speak(self, text: str, reply_to_message_id: Optional[int] = None) -> bool:
        """
        Convert text to speech and send as Telegram voice message.

        Args:
            text: Text to speak
            reply_to_message_id: Optional message ID to reply to

        Returns:
            True if successful, False otherwise
        """
        try:
            # Generate speech via ElevenLabs
            print(f"[speak] Generating speech: {text[:50]}...")
            audio_bytes = self._text_to_speech(text)

            if not audio_bytes:
                print("[speak] Failed to generate speech")
                return False

            # Detect format from audio bytes (WAV starts with RIFF, MP3 with ID3/0xFF)
            is_wav = audio_bytes[:4] == b'RIFF'
            ext = ".wav" if is_wav else ".mp3"
            audio_path = CACHE_DIR / f"speech_{int(time.time())}{ext}"
            with open(audio_path, "wb") as f:
                f.write(audio_bytes)

            print(f"[speak] Saved {ext}: {audio_path} ({len(audio_bytes)} bytes)")

            # Convert to OGG/Opus if ffmpeg available (works for both WAV and MP3)
            if self.has_ffmpeg:
                ogg_path = audio_path.with_suffix(".ogg")
                success = self._convert_to_ogg(audio_path, ogg_path)

                if success:
                    print(f"[speak] Converted to OGG: {ogg_path}")
                    result = self.send_voice_note(
                        ogg_path,
                        caption=text[:200],
                        format="ogg",
                        reply_to_message_id=reply_to_message_id
                    )
                    audio_path.unlink(missing_ok=True)
                    ogg_path.unlink(missing_ok=True)
                    return result
                else:
                    print("[speak] FFmpeg conversion failed, sending raw audio")

            # Send as audio file (Telegram accepts WAV and MP3)
            result = self._send_audio_mp3(
                audio_path,
                caption=text[:200],
                reply_to_message_id=reply_to_message_id
            )
            audio_path.unlink(missing_ok=True)
            return result

        except Exception as e:
            print(f"[speak] Error: {e}")
            return False

    def _text_to_speech(self, text: str) -> Optional[bytes]:
        """
        Convert text to speech. Priority: Gemini 2.5 Flash → ElevenLabs → gTTS.

        Returns MP3 audio bytes or None on failure.
        """
        # Try Gemini 2.5 Flash TTS first (best quality, free tier)
        if self.gemini_api_key:
            audio = self._text_to_speech_gemini(text)
            if audio:
                return audio
            print("[_text_to_speech] Gemini TTS failed, trying ElevenLabs...")

        # Try ElevenLabs (paid tier)
        if self.elevenlabs_api_key:
            audio = self._text_to_speech_elevenlabs(text)
            if audio:
                return audio
            print("[_text_to_speech] ElevenLabs failed, trying gTTS...")

        # Fallback to gTTS (free, always works)
        return self._text_to_speech_gtts(text)

    def _text_to_speech_gemini(self, text: str) -> Optional[bytes]:
        """Convert text to speech via Gemini 2.5 Flash TTS API."""
        import base64
        import struct
        import wave
        import io

        url = f"{self.gemini_tts_url}?key={self.gemini_api_key}"

        payload = {
            "contents": [{"parts": [{"text": text}]}],
            "generationConfig": {
                "responseModalities": ["AUDIO"],
                "speechConfig": {
                    "voiceConfig": {
                        "prebuiltVoiceConfig": {
                            "voiceName": self.gemini_voice
                        }
                    }
                }
            },
            "model": "gemini-2.5-flash-preview-tts"
        }

        try:
            req = request.Request(
                url,
                data=json.dumps(payload).encode('utf-8'),
                headers={"Content-Type": "application/json"},
                method='POST'
            )

            with request.urlopen(req, timeout=60) as response:
                result = json.loads(response.read().decode('utf-8'))

            # Extract audio from response
            candidates = result.get("candidates", [])
            if not candidates:
                print("[_text_to_speech_gemini] No candidates in response")
                return None

            parts = candidates[0].get("content", {}).get("parts", [])
            if not parts:
                print("[_text_to_speech_gemini] No parts in response")
                return None

            inline_data = parts[0].get("inlineData", {})
            mime_type = inline_data.get("mimeType", "")
            audio_b64 = inline_data.get("data", "")

            if not audio_b64:
                print("[_text_to_speech_gemini] No audio data in response")
                return None

            raw_audio = base64.b64decode(audio_b64)
            print(f"[_text_to_speech_gemini] Got {len(raw_audio)} bytes ({mime_type})")

            # Gemini returns PCM (24kHz, 16-bit, mono) -- wrap in WAV then convert
            if "pcm" in mime_type or "wav" not in mime_type:
                wav_buffer = io.BytesIO()
                with wave.open(wav_buffer, 'wb') as wav_file:
                    wav_file.setnchannels(1)
                    wav_file.setsampwidth(2)  # 16-bit
                    wav_file.setframerate(24000)
                    wav_file.writeframes(raw_audio)
                wav_bytes = wav_buffer.getvalue()
                print(f"[_text_to_speech_gemini] Wrapped PCM → WAV ({len(wav_bytes)} bytes)")
                return wav_bytes
            else:
                return raw_audio

        except HTTPError as e:
            body = ""
            try:
                body = e.read().decode('utf-8')
            except Exception:
                pass
            print(f"[_text_to_speech_gemini] HTTP {e.code}: {body[:200]}")
            return None
        except Exception as e:
            print(f"[_text_to_speech_gemini] Error: {e}")
            return None

    def _text_to_speech_elevenlabs(self, text: str) -> Optional[bytes]:
        """Convert text to speech via ElevenLabs API."""
        url = f"{self.elevenlabs_base_url}/text-to-speech/{self.voice_id}"

        headers = {
            "xi-api-key": self.elevenlabs_api_key,
            "Content-Type": "application/json",
            "Accept": "audio/mpeg"
        }

        payload = {
            "text": text,
            "model_id": self.model_id,
            "voice_settings": {
                "stability": 0.5,
                "similarity_boost": 0.75
            }
        }

        try:
            req = request.Request(
                url,
                data=json.dumps(payload).encode('utf-8'),
                headers=headers,
                method='POST'
            )

            with request.urlopen(req, timeout=30) as response:
                if response.status == 200:
                    audio_bytes = response.read()
                    print(f"[_text_to_speech_elevenlabs] Generated {len(audio_bytes)} bytes")
                    return audio_bytes

        except HTTPError as e:
            print(f"[_text_to_speech_elevenlabs] HTTP {e.code}")
        except Exception as e:
            print(f"[_text_to_speech_elevenlabs] Error: {e}")
        return None

    def _text_to_speech_gtts(self, text: str) -> Optional[bytes]:
        """Fallback TTS using Google Translate TTS (free, no API key)."""
        try:
            from gtts import gTTS
            import io
            tts = gTTS(text=text, lang='en', tld='com.au')
            mp3_buffer = io.BytesIO()
            tts.write_to_fp(mp3_buffer)
            audio_bytes = mp3_buffer.getvalue()
            print(f"[_text_to_speech_gtts] Generated {len(audio_bytes)} bytes via gTTS")
            return audio_bytes
        except ImportError:
            print("[_text_to_speech_gtts] gTTS not installed (pip install gTTS)")
            return None
        except Exception as e:
            print(f"[_text_to_speech_gtts] Error: {e}")
            return None

    def _convert_to_ogg(self, input_path: Path, ogg_path: Path) -> bool:
        """
        Convert audio (MP3/WAV/PCM) to OGG/Opus using ffmpeg.

        Args:
            input_path: Input audio file (any format ffmpeg supports)
            ogg_path: Output OGG file

        Returns:
            True if successful, False otherwise
        """
        mp3_path = input_path  # backward compat with subprocess call below
        try:
            result = subprocess.run(
                [
                    "ffmpeg",
                    "-y",  # Overwrite output
                    "-i", str(mp3_path),
                    "-c:a", "libopus",
                    "-b:a", "64k",  # Voice bitrate
                    str(ogg_path)
                ],
                stdout=subprocess.PIPE,
                stderr=subprocess.PIPE,
                timeout=30
            )

            return result.returncode == 0 and ogg_path.exists()

        except (subprocess.TimeoutExpired, FileNotFoundError) as e:
            print(f"[_convert_mp3_to_ogg] Error: {e}")
            return False

    def send_voice_note(
        self,
        audio_path: Path,
        caption: Optional[str] = None,
        format: str = "ogg",
        reply_to_message_id: Optional[int] = None
    ) -> bool:
        """
        Send voice note to Telegram.

        Args:
            audio_path: Path to audio file (OGG/Opus)
            caption: Optional caption text
            format: Audio format (ogg or mp3)
            reply_to_message_id: Optional message ID to reply to

        Returns:
            True if successful, False otherwise
        """
        url = f"{self.telegram_base_url}/sendVoice"

        # Read audio file
        with open(audio_path, "rb") as f:
            audio_bytes = f.read()

        # Create multipart form data
        boundary = f"----TelegramBoundary{int(time.time())}"

        parts = []

        # chat_id field
        parts.append(f'--{boundary}\r\n')
        parts.append(f'Content-Disposition: form-data; name="chat_id"\r\n\r\n')
        parts.append(f'{self.telegram_chat_id}\r\n')

        # voice file
        parts.append(f'--{boundary}\r\n')
        parts.append(f'Content-Disposition: form-data; name="voice"; filename="voice.{format}"\r\n')
        parts.append(f'Content-Type: audio/{format}\r\n\r\n')

        # caption field (optional)
        if caption:
            parts.append(f'--{boundary}\r\n')
            parts.append(f'Content-Disposition: form-data; name="caption"\r\n\r\n')
            parts.append(f'{caption}\r\n')

        # reply_to_message_id field (optional)
        if reply_to_message_id:
            parts.append(f'--{boundary}\r\n')
            parts.append(f'Content-Disposition: form-data; name="reply_to_message_id"\r\n\r\n')
            parts.append(f'{reply_to_message_id}\r\n')

        # Build body
        body = b''.join(part.encode('utf-8') if isinstance(part, str) else part for part in parts)
        body += audio_bytes
        body += f'\r\n--{boundary}--\r\n'.encode('utf-8')

        headers = {
            "Content-Type": f"multipart/form-data; boundary={boundary}"
        }

        try:
            req = request.Request(url, data=body, headers=headers, method='POST')

            with request.urlopen(req, timeout=60) as response:
                if response.status == 200:
                    result = json.loads(response.read())
                    print(f"[send_voice_note] Sent: message_id={result.get('result', {}).get('message_id')}")
                    return True
                else:
                    print(f"[send_voice_note] Failed: HTTP {response.status}")
                    return False

        except (HTTPError, URLError) as e:
            print(f"[send_voice_note] HTTP Error: {e}")
            return False
        except Exception as e:
            print(f"[send_voice_note] Error: {e}")
            return False

    def _send_audio_mp3(
        self,
        audio_path: Path,
        caption: Optional[str] = None,
        reply_to_message_id: Optional[int] = None
    ) -> bool:
        """
        Send audio file (MP3) via sendAudio API.

        Used as fallback when ffmpeg not available.

        Args:
            audio_path: Path to MP3 file
            caption: Optional caption
            reply_to_message_id: Optional message ID to reply to

        Returns:
            True if successful, False otherwise
        """
        url = f"{self.telegram_base_url}/sendAudio"

        # Read audio file
        with open(audio_path, "rb") as f:
            audio_bytes = f.read()

        # Create multipart form data
        boundary = f"----TelegramBoundary{int(time.time())}"

        parts = []

        # chat_id field
        parts.append(f'--{boundary}\r\n')
        parts.append(f'Content-Disposition: form-data; name="chat_id"\r\n\r\n')
        parts.append(f'{self.telegram_chat_id}\r\n')

        # audio file
        parts.append(f'--{boundary}\r\n')
        parts.append(f'Content-Disposition: form-data; name="audio"; filename="audio.mp3"\r\n')
        parts.append(f'Content-Type: audio/mpeg\r\n\r\n')

        # caption field (optional)
        if caption:
            parts.append(f'--{boundary}\r\n')
            parts.append(f'Content-Disposition: form-data; name="caption"\r\n\r\n')
            parts.append(f'{caption}\r\n')

        # reply_to_message_id field (optional)
        if reply_to_message_id:
            parts.append(f'--{boundary}\r\n')
            parts.append(f'Content-Disposition: form-data; name="reply_to_message_id"\r\n\r\n')
            parts.append(f'{reply_to_message_id}\r\n')

        # Build body
        body = b''.join(part.encode('utf-8') if isinstance(part, str) else part for part in parts)
        body += audio_bytes
        body += f'\r\n--{boundary}--\r\n'.encode('utf-8')

        headers = {
            "Content-Type": f"multipart/form-data; boundary={boundary}"
        }

        try:
            req = request.Request(url, data=body, headers=headers, method='POST')

            with request.urlopen(req, timeout=60) as response:
                if response.status == 200:
                    result = json.loads(response.read())
                    print(f"[_send_audio_mp3] Sent: message_id={result.get('result', {}).get('message_id')}")
                    return True
                else:
                    print(f"[_send_audio_mp3] Failed: HTTP {response.status}")
                    return False

        except (HTTPError, URLError) as e:
            print(f"[_send_audio_mp3] HTTP Error: {e}")
            return False
        except Exception as e:
            print(f"[_send_audio_mp3] Error: {e}")
            return False

    def send_text(self, text: str, reply_to_message_id: Optional[int] = None) -> bool:
        """
        Send text message via Telegram.

        Args:
            text: Message text
            reply_to_message_id: Optional message ID to reply to

        Returns:
            True if successful, False otherwise
        """
        url = f"{self.telegram_base_url}/sendMessage"

        payload = {
            "chat_id": self.telegram_chat_id,
            "text": text,
            "parse_mode": "Markdown"
        }

        if reply_to_message_id:
            payload["reply_to_message_id"] = reply_to_message_id

        try:
            data = json.dumps(payload).encode('utf-8')
            req = request.Request(
                url,
                data=data,
                headers={"Content-Type": "application/json"},
                method='POST'
            )

            with request.urlopen(req, timeout=30) as response:
                if response.status == 200:
                    result = json.loads(response.read())
                    print(f"[send_text] Sent: message_id={result.get('result', {}).get('message_id')}")
                    return True
                else:
                    print(f"[send_text] Failed: HTTP {response.status}")
                    return False

        except (HTTPError, URLError) as e:
            print(f"[send_text] HTTP Error: {e}")
            return False
        except Exception as e:
            print(f"[send_text] Error: {e}")
            return False

    def announce(self, text: str) -> Tuple[bool, bool]:
        """
        Send both text and voice message.

        Useful for escalations where Kinan might see text first, then play voice.

        Args:
            text: Message to send

        Returns:
            Tuple of (text_success, voice_success)
        """
        text_ok = self.send_text(text)
        voice_ok = self.speak(text)
        return (text_ok, voice_ok)

    def escalate_with_voice(
        self,
        title: str,
        description: str,
        urgency: str = "medium"
    ) -> Tuple[bool, bool]:
        """
        Send escalation with voice narration.

        Format: Text header with urgency emoji, then voice note reading description.

        Args:
            title: Escalation title
            description: Detailed description
            urgency: low, medium, high, or critical

        Returns:
            Tuple of (text_success, voice_success)
        """
        # Urgency emoji mapping
        urgency_emoji = {
            "low": "🟢",
            "medium": "🟡",
            "high": "🟠",
            "critical": "🔴"
        }

        emoji = urgency_emoji.get(urgency.lower(), "⚪")

        # Text header
        text_message = f"{emoji} *{title}*\n\n{description}"

        # Voice narration (add URGENT prefix for high urgency)
        if urgency.lower() in ["high", "critical"]:
            voice_text = f"URGENT. {title}. {description}"
        else:
            voice_text = f"{title}. {description}"

        # Send text first
        text_ok = self.send_text(text_message)

        # Then voice
        voice_ok = self.speak(voice_text)

        return (text_ok, voice_ok)

    def listen(self, timeout: int = 30) -> List[Dict]:
        """
        Poll Telegram for new messages from Kinan.

        Args:
            timeout: Polling timeout in seconds

        Returns:
            List of message dicts (text and/or voice)
        """
        url = f"{self.telegram_base_url}/getUpdates"

        params = {
            "offset": self.last_update_id + 1,
            "timeout": timeout,
            "allowed_updates": ["message"]
        }

        query_string = parse.urlencode(params)
        full_url = f"{url}?{query_string}"

        try:
            with request.urlopen(full_url, timeout=timeout + 10) as response:
                if response.status == 200:
                    result = json.loads(response.read())

                    if not result.get("ok"):
                        print(f"[listen] Telegram API error: {result}")
                        return []

                    updates = result.get("result", [])

                    if not updates:
                        return []

                    # Update last_update_id
                    self.last_update_id = max(u["update_id"] for u in updates)

                    # Extract messages from Kinan
                    messages = []
                    for update in updates:
                        msg = update.get("message", {})

                        # Check if from Kinan
                        if str(msg.get("from", {}).get("id")) != str(self.telegram_chat_id):
                            continue

                        messages.append(msg)

                    return messages
                else:
                    print(f"[listen] Failed: HTTP {response.status}")
                    return []

        except (HTTPError, URLError) as e:
            print(f"[listen] HTTP Error: {e}")
            return []
        except Exception as e:
            print(f"[listen] Error: {e}")
            return []


# Singleton instance
_telegram_voice_channel = None


def get_telegram_voice() -> TelegramVoiceChannel:
    """
    Get singleton Telegram voice channel.

    Returns:
        TelegramVoiceChannel instance
    """
    global _telegram_voice_channel

    if _telegram_voice_channel is None:
        _telegram_voice_channel = TelegramVoiceChannel()

    return _telegram_voice_channel


# VERIFICATION_STAMP
# Story: AIVA-Telegram-Voice
# Component: telegram_voice.py
# Verified By: Parallel Builder Agent
# Verified At: 2026-02-12T00:00:00Z
# Features:
#   - ElevenLabs TTS integration (urllib only, NO requests)
#   - Telegram sendVoice API with multipart/form-data encoding
#   - MP3 → OGG/Opus conversion via ffmpeg (with MP3 fallback)
#   - Voice message + text caption
#   - Polling for incoming messages (listen method)
#   - Escalation with voice narration
#   - All temp files on E: drive (CACHE_DIR)
# Coverage: Requires manual testing (Telegram + ElevenLabs APIs)
# Storage: No database usage


if __name__ == "__main__":
    """Test Telegram voice channel."""

    print("=" * 60)
    print("AIVA Telegram Voice Channel - Test")
    print("=" * 60)

    # Load environment from aiva_config.env
    config_path = Path("/mnt/e/genesis-system/AIVA/aiva_config.env")
    if config_path.exists():
        print(f"[TEST] Loading config from {config_path}")
        with open(config_path) as f:
            for line in f:
                line = line.strip()
                if line and not line.startswith("#") and "=" in line:
                    key, value = line.split("=", 1)
                    os.environ[key.strip()] = value.strip()
        print(f"[TEST] Config loaded")

    try:
        # Initialize
        channel = TelegramVoiceChannel()

        # Test message
        test_message = (
            "Hello Kinan, this is AIVA. "
            "I am now operational and speaking to you through Telegram. "
            "All seven queenhood priorities are active."
        )

        print(f"\n[TEST 1: Text Message]")
        text_ok = channel.send_text("🎙️ *AIVA Voice Channel Online*\n\nVoice messaging system operational.")

        if text_ok:
            print("✅ Text message sent successfully")
        else:
            print("❌ Text message failed")

        print(f"\n[TEST 2: Voice Message]")
        print(f"  Message: {test_message[:50]}...")
        print(f"  Chat ID: {channel.telegram_chat_id}")
        print(f"  NOTE: ElevenLabs free tier may be blocked due to WSL/proxy")

        # Send voice message
        success = channel.speak(test_message)

        if success:
            print("✅ Voice message sent successfully")
        else:
            print("❌ Voice message failed (check ElevenLabs API limits)")
            print("   Solution: Upgrade to paid ElevenLabs plan or use VPN-free connection")

        print(f"\n[TEST 3: Escalation with Voice]")
        text_ok, voice_ok = channel.escalate_with_voice(
            title="Test Escalation",
            description="This is a test of the escalation system with voice narration.",
            urgency="medium"
        )

        print(f"  Text: {'✅' if text_ok else '❌'}")
        print(f"  Voice: {'✅' if voice_ok else '❌'}")

        print(f"\n{'=' * 60}")
        print("SUMMARY:")
        print(f"  Module: Operational ✅")
        print(f"  Telegram: Connected ✅")
        print(f"  ElevenLabs: {'Active ✅' if success else 'Rate Limited ⚠️'}")
        print(f"{'=' * 60}")

    except Exception as e:
        print(f"\n❌ Test FAILED with error: {e}")
        import traceback
        traceback.print_exc()