"""
WebSocket debugging utilities.

This module provides utilities for configuring WebSocket logging and debugging
based on configuration settings.
"""
import logging
import sys
from typing import Optional
from pathlib import Path

from ..core.config import get_config_manager


def setup_websocket_logging(
    enable_debug: Optional[bool] = None,
    rxtx_log_level: Optional[str] = None,
    message_proc_log_level: Optional[str] = None,
    log_file: Optional[str] = None
) -> None:
    """
    Set up WebSocket logging based on configuration.
    
    Args:
        enable_debug: Enable WebSocket debugging (overrides config)
        rxtx_log_level: Log level for RX/TX messages (overrides config)
        message_proc_log_level: Log level for message processing (overrides config)
        log_file: Optional log file path for WebSocket messages
    """
    # Get configuration
    config_manager = get_config_manager()
    logging_config = config_manager.get_logging_config()
    
    # Use provided values or fall back to config
    debug_enabled = enable_debug if enable_debug is not None else logging_config.websocket_debug
    rxtx_level = rxtx_log_level or logging_config.websocket_rxtx_log_level
    msg_proc_level = message_proc_log_level or logging_config.websocket_message_proc_log_level
    
    # Configure WebSocket RX/TX logger
    ws_rxtx_logger = logging.getLogger("websocket.rxtx")
    ws_rxtx_logger.setLevel(getattr(logging, rxtx_level.upper(), logging.INFO))
    
    # Configure WebSocket message processor logger  
    ws_msg_proc_logger = logging.getLogger("websocket.message_processor")
    ws_msg_proc_logger.setLevel(getattr(logging, msg_proc_level.upper(), logging.DEBUG))
    
    # Configure main WebSocket logger
    ws_logger = logging.getLogger("websocket")
    ws_logger.setLevel(logging.DEBUG if debug_enabled else logging.INFO)
    
    # Set up console handler for debugging if not already present
    if debug_enabled and not ws_rxtx_logger.handlers:
        # Create console handler
        console_handler = logging.StreamHandler(sys.stdout)
        console_handler.setLevel(getattr(logging, rxtx_level.upper(), logging.INFO))
        
        # Create formatter for WebSocket messages
        formatter = logging.Formatter(
            "%(asctime)s | WEBSOCKET | %(name)s | %(message)s",
            datefmt="%Y-%m-%d %H:%M:%S"
        )
        console_handler.setFormatter(formatter)
        
        # Add handler to both WebSocket loggers
        ws_rxtx_logger.addHandler(console_handler)
        ws_msg_proc_logger.addHandler(console_handler)
        
    # Set up file handler if log file is specified
    if log_file:
        log_path = Path(log_file)
        log_path.parent.mkdir(parents=True, exist_ok=True)
        
        # Create file handler
        file_handler = logging.FileHandler(log_path)
        file_handler.setLevel(logging.DEBUG)
        
        # Create detailed formatter for file output
        file_formatter = logging.Formatter(
            "%(asctime)s | %(levelname)s | %(name)s | %(message)s"
        )
        file_handler.setFormatter(file_formatter)
        
        # Add to all WebSocket loggers
        ws_rxtx_logger.addHandler(file_handler)
        ws_msg_proc_logger.addHandler(file_handler)
        ws_logger.addHandler(file_handler)
        
    # Log configuration status
    main_logger = logging.getLogger("detector_worker.websocket_debug")
    main_logger.info(f"WebSocket debugging configured: "
                    f"enabled={debug_enabled}, "
                    f"rxtx_level={rxtx_level}, "
                    f"msg_proc_level={msg_proc_level}, "
                    f"log_file={log_file}")


def enable_websocket_debug() -> None:
    """Enable WebSocket debugging with default settings."""
    setup_websocket_logging(
        enable_debug=True,
        rxtx_log_level="INFO",
        message_proc_log_level="DEBUG"
    )


def disable_websocket_debug() -> None:
    """Disable WebSocket debugging."""
    # Set all WebSocket loggers to WARNING level to reduce noise
    ws_loggers = [
        "websocket",
        "websocket.rxtx", 
        "websocket.message_processor"
    ]
    
    for logger_name in ws_loggers:
        logger = logging.getLogger(logger_name)
        logger.setLevel(logging.WARNING)
        
        # Remove all handlers
        for handler in logger.handlers[:]:
            logger.removeHandler(handler)


def get_websocket_debug_status() -> dict:
    """
    Get current WebSocket debugging status.
    
    Returns:
        Dictionary with debugging status information
    """
    config_manager = get_config_manager()
    logging_config = config_manager.get_logging_config()
    
    # Check current logger levels
    ws_rxtx_logger = logging.getLogger("websocket.rxtx")
    ws_msg_proc_logger = logging.getLogger("websocket.message_processor")
    ws_logger = logging.getLogger("websocket")
    
    return {
        "config": {
            "websocket_debug": logging_config.websocket_debug,
            "websocket_rxtx_log_level": logging_config.websocket_rxtx_log_level,
            "websocket_message_proc_log_level": logging_config.websocket_message_proc_log_level
        },
        "runtime": {
            "websocket_logger_level": logging.getLevelName(ws_logger.level),
            "rxtx_logger_level": logging.getLevelName(ws_rxtx_logger.level),
            "msg_proc_logger_level": logging.getLevelName(ws_msg_proc_logger.level),
            "handler_count": {
                "websocket": len(ws_logger.handlers),
                "rxtx": len(ws_rxtx_logger.handlers),
                "msg_proc": len(ws_msg_proc_logger.handlers)
            }
        }
    }


def log_websocket_stats() -> None:
    """Log WebSocket communication statistics."""
    logger = logging.getLogger("websocket.stats")
    
    # This could be extended to track actual message counts
    # For now, just log the current status
    status = get_websocket_debug_status()
    logger.info(f"WebSocket Debug Status: {status}")