#!/usr/bin/env python3
"""
LiveTalker - Real-time Voice Assistant with VAD and Turn-Taking
"""

import asyncio
import logging
import signal
import sys
from pathlib import Path

from gateway.websocket_server import LiveTalkerGateway
from personality.personality_manager import PersonalityManager

# Configure logging
logging.basicConfig(
    level=logging.INFO,
    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
    handlers=[
        logging.StreamHandler(sys.stdout),
        logging.FileHandler('livetalker.log')
    ]
)

logger = logging.getLogger(__name__)

class LiveTalkerApp:
    def __init__(self):
        self.gateway = None
        self.personality_manager = PersonalityManager()
        self.running = False
        
    async def start(self, host="0.0.0.0", port=8000, vllm_endpoint="http://localhost:8091"):
        """Start the LiveTalker application"""
        logger.info("Starting LiveTalker...")
        
        # Initialize personality manager with default personality
        if not self.personality_manager.get_current_personality():
            self.personality_manager.set_current_personality("luna")
        
        # Create and configure gateway
        self.gateway = LiveTalkerGateway(vllm_endpoint=vllm_endpoint)
        
        # Add personality manager to gateway
        self.gateway.personality_manager = self.personality_manager
        
        # Setup signal handlers for graceful shutdown
        signal.signal(signal.SIGINT, self._signal_handler)
        signal.signal(signal.SIGTERM, self._signal_handler)
        
        self.running = True
        
        try:
            logger.info(f"LiveTalker gateway starting on {host}:{port}")
            logger.info(f"vLLM endpoint: {vllm_endpoint}")
            logger.info(f"Current personality: {self.personality_manager.get_current_personality().name}")
            
            # Start the gateway
            await asyncio.create_subprocess_exec(
                "uvicorn",
                "gateway.websocket_server:LiveTalkerGateway().app",
                "--host", host,
                "--port", str(port),
                "--reload",
                "--log-level", "info"
            )
            
            # Keep running until shutdown
            while self.running:
                await asyncio.sleep(1)
                
        except KeyboardInterrupt:
            logger.info("Received interrupt signal")
        except Exception as e:
            logger.error(f"Error starting application: {e}")
        finally:
            await self.shutdown()
    
    def _signal_handler(self, signum, frame):
        """Handle shutdown signals"""
        logger.info(f"Received signal {signum}")
        self.running = False
    
    async def shutdown(self):
        """Shutdown the application gracefully"""
        logger.info("Shutting down LiveTalker...")
        self.running = False
        
        if self.gateway:
            # Close all active sessions
            for session_id in list(self.gateway.active_sessions.keys()):
                self.gateway._cleanup_session(session_id)
        
        logger.info("LiveTalker shutdown complete")

def main():
    """Main entry point"""
    import argparse
    
    parser = argparse.ArgumentParser(description="LiveTalker - Real-time Voice Assistant")
    parser.add_argument("--host", default="0.0.0.0", help="Host to bind to (default: 0.0.0.0)")
    parser.add_argument("--port", type=int, default=8000, help="Port to bind to (default: 8000)")
    parser.add_argument("--vllm-endpoint", default="http://localhost:8091", 
                       help="vLLM server endpoint (default: http://localhost:8091)")
    parser.add_argument("--personality", default="luna", 
                       help="Default personality to use (default: luna)")
    parser.add_argument("--log-level", default="INFO", 
                       choices=["DEBUG", "INFO", "WARNING", "ERROR"],
                       help="Log level (default: INFO)")
    
    args = parser.parse_args()
    
    # Set log level
    logging.getLogger().setLevel(getattr(logging, args.log_level))
    
    # Create and start the application
    app = LiveTalkerApp()
    
    # Set initial personality if specified
    if args.personality != "luna":  # luna is already default
        if not app.personality_manager.set_current_personality(args.personality):
            logger.warning(f"Personality '{args.personality}' not found, using 'luna'")
    
    try:
        asyncio.run(app.start(
            host=args.host,
            port=args.port,
            vllm_endpoint=args.vllm_endpoint
        ))
    except KeyboardInterrupt:
        logger.info("Application interrupted by user")
    except Exception as e:
        logger.error(f"Application error: {e}")
        sys.exit(1)

if __name__ == "__main__":
    main()