#!/usr/bin/env python3
"""
Simple launcher script for the Gradio app with better error handling and debug logging.
"""

import os
import sys
from dotenv import load_dotenv

# Load environment variables
load_dotenv()

# Import and setup debug configuration
try:
    from debug_config import setup_debug_logging, log_system_info, log_session_end
    import logging
    
    # Setup debug logging (can be controlled via environment variable)
    debug_level = os.getenv('DEBUG_LEVEL', 'INFO')
    log_to_file = os.getenv('LOG_TO_FILE', 'true').lower() == 'true'
    log_to_console = os.getenv('LOG_TO_CONSOLE', 'true').lower() == 'true'
    
    setup_debug_logging(log_level=debug_level, log_to_file=log_to_file, log_to_console=log_to_console)
    logger = logging.getLogger(__name__)
    
except ImportError:
    # Fallback if debug_config is not available
    import logging
    logging.basicConfig(level=logging.INFO)
    logger = logging.getLogger(__name__)

def check_requirements():
    """Check if all required packages are installed."""
    logger.info("Checking package requirements...")
    
    required_packages = [
        'gradio', 'google.generativeai', 'torch', 'psutil'
    ]
    
    missing = []
    for package in required_packages:
        try:
            __import__(package.replace('-', '_'))
            logger.debug(f"✓ Package {package} found")
        except ImportError:
            missing.append(package)
            logger.warning(f"✗ Package {package} missing")
    
    if missing:
        logger.error(f"Missing packages: {', '.join(missing)}")
        print(f"Missing packages: {', '.join(missing)}")
        print("Please run: pip install -r requirements.txt")
        return False
    
    logger.info("All required packages are available")
    return True

def check_api_key():
    """Check if API key is configured."""
    logger.info("Checking API key configuration...")
    
    api_key = os.getenv('GOOGLE_API_KEY')
    if not api_key:
        logger.error("GOOGLE_API_KEY not found in environment variables")
        print("ERROR: GOOGLE_API_KEY not found in .env file")
        print("Please add your Gemini API key to the .env file:")
        print("GOOGLE_API_KEY=your_api_key_here")
        return False
    
    logger.info(f"API key found (length: {len(api_key)})")
    return True

def main():
    logger.info("Starting Auto Diffusers Config application")
    print("🚀 Starting Auto Diffusers Config Gradio App...")
    
    # Log system information
    try:
        log_system_info()
    except:
        logger.warning("Could not log system info")
    
    # Check requirements
    if not check_requirements():
        logger.error("Requirements check failed, exiting")
        sys.exit(1)
    
    if not check_api_key():
        logger.error("API key check failed, exiting")
        sys.exit(1)
    
    try:
        logger.info("Importing Gradio interface module")
        from gradio_app import create_gradio_interface
        
        logger.info("All requirements satisfied, launching interface")
        print("✅ All requirements satisfied")
        print("🌐 Launching Gradio interface...")
        
        interface = create_gradio_interface()
        logger.info("Gradio interface created successfully")
        
        logger.info("Starting Gradio server on 0.0.0.0:7860")
        interface.launch(
            server_name="0.0.0.0",
            server_port=7860,
            share=True,
            show_error=True,
            inbrowser=True
        )
        
    except ImportError as e:
        logger.error(f"Import error: {e}")
        print(f"Import error: {e}")
        print("Make sure all dependencies are installed: pip install -r requirements.txt")
    except Exception as e:
        logger.error(f"Error launching app: {e}", exc_info=True)
        print(f"Error launching app: {e}")
    finally:
        try:
            log_session_end()
        except:
            logger.warning("Could not log session end")

if __name__ == "__main__":
    main()