"""
Debug configuration for Auto Diffusers Config
Provides centralized logging setup for the entire application
"""

import logging
import os
from datetime import datetime

def setup_debug_logging(log_level='DEBUG', log_to_file=True, log_to_console=True):
    """
    Set up comprehensive debug logging for the entire application
    
    Args:
        log_level (str): Logging level ('DEBUG', 'INFO', 'WARNING', 'ERROR')
        log_to_file (bool): Whether to log to files
        log_to_console (bool): Whether to log to console
    """
    
    # Create logs directory if it doesn't exist
    if log_to_file:
        os.makedirs('logs', exist_ok=True)
    
    # Clear any existing handlers
    root_logger = logging.getLogger()
    root_logger.handlers.clear()
    
    # Set root logging level
    numeric_level = getattr(logging, log_level.upper(), logging.DEBUG)
    root_logger.setLevel(numeric_level)
    
    # Create formatter
    formatter = logging.Formatter(
        '%(asctime)s - %(name)s - %(levelname)s - %(funcName)s:%(lineno)d - %(message)s',
        datefmt='%Y-%m-%d %H:%M:%S'
    )
    
    handlers = []
    
    # Console handler
    if log_to_console:
        console_handler = logging.StreamHandler()
        console_handler.setLevel(numeric_level)
        console_handler.setFormatter(formatter)
        handlers.append(console_handler)
    
    # File handlers
    if log_to_file:
        timestamp = datetime.now().strftime('%Y%m%d_%H%M%S')
        
        # Main application log
        main_log_file = f'logs/auto_diffusers_{timestamp}.log'
        file_handler = logging.FileHandler(main_log_file)
        file_handler.setLevel(numeric_level)
        file_handler.setFormatter(formatter)
        handlers.append(file_handler)
        
        # Error-only log
        error_log_file = f'logs/errors_{timestamp}.log'
        error_handler = logging.FileHandler(error_log_file)
        error_handler.setLevel(logging.ERROR)
        error_handler.setFormatter(formatter)
        handlers.append(error_handler)
    
    # Add all handlers to root logger
    for handler in handlers:
        root_logger.addHandler(handler)
    
    # Set up specific logger configurations
    configure_component_loggers(numeric_level)
    
    logging.info("=" * 80)
    logging.info("AUTO DIFFUSERS CONFIG - DEBUG SESSION STARTED")
    logging.info("=" * 80)
    logging.info(f"Log level: {log_level}")
    logging.info(f"Logging to console: {log_to_console}")
    logging.info(f"Logging to file: {log_to_file}")
    if log_to_file:
        logging.info(f"Main log file: {main_log_file}")
        logging.info(f"Error log file: {error_log_file}")
    logging.info("=" * 80)


def configure_component_loggers(level):
    """Configure logging for individual components"""
    
    # Main application components
    components = [
        'auto_diffusers',
        'hardware_detector', 
        'simple_memory_calculator',
        'gradio_app',
        '__main__'
    ]
    
    for component in components:
        logger = logging.getLogger(component)
        logger.setLevel(level)
        # Don't propagate to avoid duplicate messages
        logger.propagate = True
    
    # Third-party library logging (reduce verbosity)
    third_party_loggers = {
        'urllib3': logging.WARNING,
        'requests': logging.WARNING,
        'httpx': logging.WARNING,
        'gradio': logging.INFO,
        'google': logging.INFO,
        'huggingface_hub': logging.INFO
    }
    
    for lib_name, lib_level in third_party_loggers.items():
        lib_logger = logging.getLogger(lib_name)
        lib_logger.setLevel(lib_level)


def log_system_info():
    """Log comprehensive system information at startup"""
    import platform
    import sys
    import os
    
    logger = logging.getLogger(__name__)
    
    logger.info("SYSTEM INFORMATION:")
    logger.info(f"  Platform: {platform.system()} {platform.release()}")
    logger.info(f"  Architecture: {platform.machine()}")
    logger.info(f"  Python: {sys.version}")
    logger.info(f"  Working directory: {os.getcwd()}")
    logger.info(f"  Process ID: {os.getpid()}")
    
    # Environment variables (non-sensitive)
    env_vars = ['GOOGLE_API_KEY', 'CUDA_VISIBLE_DEVICES', 'PYTORCH_CUDA_ALLOC_CONF']
    logger.info("ENVIRONMENT VARIABLES:")
    for var in env_vars:
        value = os.getenv(var, 'Not set')
        if var == 'GOOGLE_API_KEY' and value != 'Not set':
            value = f"Set (length: {len(value)})"
        logger.info(f"  {var}: {value}")


def log_session_end():
    """Log session end information"""
    logger = logging.getLogger(__name__)
    logger.info("=" * 80)
    logger.info("AUTO DIFFUSERS CONFIG - DEBUG SESSION ENDED")
    logger.info("=" * 80)


if __name__ == "__main__":
    # Example usage
    setup_debug_logging(log_level='DEBUG')
    log_system_info()
    
    # Test logging from different components
    logger = logging.getLogger(__name__)
    logger.debug("This is a debug message")
    logger.info("This is an info message")
    logger.warning("This is a warning message")
    logger.error("This is an error message")
    
    log_session_end()