#!/usr/bin/env python3
"""
DigiPal - Advanced AI Monster Companion
Built with HuggingFace Transformers v4.52.4 & Gradio 5.34.2
Optimized for Qwen 2.5 models and Zero GPU deployment
"""

import os
import sys
import logging
import asyncio
from pathlib import Path
import signal
from typing import Dict, Any

# Add src to Python path
sys.path.insert(0, str(Path(__file__).parent / "src"))

# Import core components
from src.ui.gradio_interface import ModernDigiPalInterface
from src.deployment.zero_gpu_optimizer import ZeroGPUOptimizer
from src.utils.performance_tracker import PerformanceTracker

def setup_logging(log_level: str = "INFO"):
    """Setup comprehensive logging configuration"""
    
    # Create logs directory
    logs_dir = Path("logs")
    logs_dir.mkdir(exist_ok=True)
    
    # Configure logging
    logging.basicConfig(
        level=getattr(logging, log_level.upper()),
        format='%(asctime)s - %(name)s - %(levelname)s - %(funcName)s:%(lineno)d - %(message)s',
        handlers=[
            logging.FileHandler(logs_dir / "digipal.log"),
            logging.StreamHandler(sys.stdout)
        ]
    )
    
    # Set specific logger levels
    logging.getLogger("transformers").setLevel(logging.WARNING)
    logging.getLogger("torch").setLevel(logging.WARNING)
    logging.getLogger("gradio").setLevel(logging.INFO)

def setup_environment():
    """Setup environment variables and configurations"""
    
    # Create necessary directories
    directories = [
        "data/saves",
        "data/monsters", 
        "data/models",
        "data/cache",
        "logs",
        "config"
    ]
    
    for directory in directories:
        Path(directory).mkdir(parents=True, exist_ok=True)
    
    # Set environment variables for optimization
    os.environ["TOKENIZERS_PARALLELISM"] = "false"  # Avoid tokenizer warnings
    os.environ["TRANSFORMERS_CACHE"] = str(Path("data/cache").absolute())
    os.environ["HF_HOME"] = str(Path("data/cache").absolute())
    
    # CUDA optimization settings
    if "CUDA_VISIBLE_DEVICES" not in os.environ:
        os.environ["CUDA_VISIBLE_DEVICES"] = "0"
    
    # Memory optimization
    os.environ["PYTORCH_CUDA_ALLOC_CONF"] = "max_split_size_mb:128"

async def initialize_components() -> Dict[str, Any]:
    """Initialize all application components"""
    logger = logging.getLogger(__name__)
    
    try:
        # Initialize performance tracker
        performance_tracker = PerformanceTracker()
        await performance_tracker.initialize()
        
        # Initialize GPU optimizer
        gpu_optimizer = ZeroGPUOptimizer()
        resources = await gpu_optimizer.detect_available_resources()
        
        logger.info(f"Detected resources: {resources}")
        
        # Initialize main interface
        interface = ModernDigiPalInterface()
        await interface.initialize()
        
        return {
            "interface": interface,
            "performance_tracker": performance_tracker,
            "gpu_optimizer": gpu_optimizer,
            "resources": resources
        }
        
    except Exception as e:
        logger.error(f"Component initialization failed: {e}")
        raise

def handle_shutdown(signum, frame):
    """Handle graceful shutdown"""
    logger = logging.getLogger(__name__)
    logger.info(f"Received signal {signum}, shutting down gracefully...")
    
    # Cleanup operations would go here
    sys.exit(0)

def main():
    """Main application entry point"""
    
    # Setup signal handlers
    signal.signal(signal.SIGINT, handle_shutdown)
    signal.signal(signal.SIGTERM, handle_shutdown)
    
    # Setup environment
    setup_logging(os.getenv("LOG_LEVEL", "INFO"))
    setup_environment()
    
    logger = logging.getLogger(__name__)
    logger.info("Starting DigiPal Advanced Monster Companion...")
    
    try:
        # Check Python version
        if sys.version_info < (3, 8):
            raise RuntimeError("Python 3.8 or higher is required")
        
        # Initialize async event loop
        if sys.platform == "win32":
            asyncio.set_event_loop_policy(asyncio.WindowsProactorEventLoopPolicy())
        
        loop = asyncio.new_event_loop()
        asyncio.set_event_loop(loop)
        
        # Initialize components
        components = loop.run_until_complete(initialize_components())
        
        logger.info("All components initialized successfully")
        
        # Launch configuration based on environment
        launch_config = {
            "server_name": os.getenv("SERVER_NAME", "0.0.0.0"),
            "server_port": int(os.getenv("SERVER_PORT", "7860")),
            "share": os.getenv("SHARE", "false").lower() == "true",
            "debug": os.getenv("DEBUG", "false").lower() == "true",
            "show_error": True,
            "enable_queue": True,
            "max_threads": int(os.getenv("MAX_THREADS", "40")),
            "auth": None  # Can be configured for production
        }
        
        # Add SSL configuration for production
        if os.getenv("SSL_ENABLED", "false").lower() == "true":
            launch_config.update({
                "ssl_keyfile": os.getenv("SSL_KEYFILE"),
                "ssl_certfile": os.getenv("SSL_CERTFILE"),
                "ssl_keyfile_password": os.getenv("SSL_PASSWORD")
            })
        
        logger.info(f"Launching interface with config: {launch_config}")
        
        # Launch the interface
        components["interface"].launch(**launch_config)
        
    except KeyboardInterrupt:
        logger.info("Application stopped by user")
    except Exception as e:
        logger.error(f"Application failed to start: {e}")
        raise
    finally:
        logger.info("DigiPal application shutdown complete")

if __name__ == "__main__":
    main()