"""
OCPP Driver module for WebSocket server - handles different event storage backends
Can reuse drivers from client module and add WebSocket-specific drivers
"""
import logging

from ..config import get_config
from .database_driver import DatabaseDriver

logger = logging.getLogger(__name__)


# WebSocket-specific driver implementations

class WebSocketFileDriver:
    """WebSocket-specific file driver with enhanced logging"""
    
    def __init__(self):
        self.log_file = "ocpp_server_events.log"
        logger.info(f"WebSocket file driver initialized - logging to {self.log_file}")
        
    async def log_event(self, event_type: str, data: dict, source: str) -> dict:
        """Log an OCPP event with WebSocket-specific metadata"""
        try:
            import json
            from datetime import datetime
            
            # Enhanced log entry with WebSocket metadata
            log_entry = {
                "timestamp": datetime.utcnow().isoformat() + "Z",
                "event_type": event_type,
                "source": source,
                "server_type": "websocket",
                "data": data
            }
            
            # Append to WebSocket-specific log file
            with open(self.log_file, "a", encoding="utf-8") as f:
                f.write(json.dumps(log_entry) + "\n")
            
            logger.debug(f"[WS_FILE] Logged {event_type} event from {source} to {self.log_file}")
            return {"status": "logged", "file": self.log_file, "event_type": event_type}
            
        except Exception as e:
            logger.error(f"[WS_FILE] Failed to log event to {self.log_file}: {e}")
            return {"status": "error", "error": str(e)}
    
    async def send_message(self, charge_point_id: str, message: dict) -> dict:
        """Send/log a message - compatibility method"""
        action = message.get("action", "Unknown")
        data = message.get("data", message)
        return await self.log_event(action, data, charge_point_id)


class WebSocketConsoleDriver:
    """WebSocket-specific console driver with enhanced formatting"""
    
    def __init__(self):
        logger.info("WebSocket console driver initialized - enhanced output to stdout")
        
    async def log_event(self, event_type: str, data: dict, source: str) -> dict:
        """Print an enhanced OCPP event to stdout"""
        try:
            import json
            from datetime import datetime
            
            timestamp = datetime.utcnow().isoformat() + "Z"
            
            # Enhanced console output for WebSocket server
            print(f"🌐 WebSocket OCPP Event: {event_type}")
            print(f"📅 Time: {timestamp}")
            print(f"🔌 Charge Point: {source}")
            print(f"📊 Data: {json.dumps(data, indent=2)}")
            print("=" * 60)
            
            logger.debug(f"[WS_CONSOLE] Printed {event_type} event from {source} to stdout")
            return {"status": "logged", "output": "stdout", "event_type": event_type}
            
        except Exception as e:
            logger.error(f"[WS_CONSOLE] Failed to print event: {e}")
            return {"status": "error", "error": str(e)}
    
    async def send_message(self, charge_point_id: str, message: dict) -> dict:
        """Send/log a message - compatibility method"""
        action = message.get("action", "Unknown")
        data = message.get("data", message)
        return await self.log_event(action, data, charge_point_id)


def get_driver():
    """Get the configured OCPP driver based on config DRIVER setting"""
    config = get_config()
    driver_type = config.driver.lower()
    
    if driver_type == "database":
        logger.info("Initializing database driver")
        return DatabaseDriver()
    elif driver_type == "file":
        logger.info("Initializing WebSocket file driver")
        return WebSocketFileDriver()
    elif driver_type == "console":
        logger.info("Initializing WebSocket console driver")
        return WebSocketConsoleDriver()
    elif driver_type == "null":
        logger.info("Initializing simple null driver")
        return SimpleNullDriver()
    else:
        logger.warning(f"Unknown driver type: {driver_type}, falling back to WebSocket file driver")
        return WebSocketFileDriver()


class SimpleNullDriver:
    """Simple null driver implementation (fallback)"""
    
    def __init__(self):
        logger.info("Simple null driver initialized - discarding all events")
        
    async def log_event(self, event_type: str, data: dict, source: str) -> dict:
        """Discard an OCPP event (no-op)"""
        logger.debug(f"[NULL] Discarded {event_type} event from {source}")
        return {"status": "discarded", "event_type": event_type}
    
    async def send_message(self, charge_point_id: str, message: dict) -> dict:
        """Send/log a message - compatibility method"""
        action = message.get("action", "Unknown")
        return {"status": "discarded", "action": action}


__all__ = ["get_driver", "WebSocketFileDriver", "WebSocketConsoleDriver", "DatabaseDriver"]