notification_system.py

"""
Notification System Module

Provides alert and notification capabilities for trading events.
"""

from typing import List, Dict, Any, Optional, Callable
from datetime import datetime
from enum import Enum
import queue
import threading

from logger import system_logger, trading_logger


class NotificationLevel(Enum):
    """Notification severity levels."""
    INFO = "INFO"
    WARNING = "WARNING"
    ERROR = "ERROR"
    CRITICAL = "CRITICAL"
    SUCCESS = "SUCCESS"


class Notification:
    """Represents a single notification."""
    
    def __init__(
        self,
        level: NotificationLevel,
        title: str,
        message: str,
        category: str = "GENERAL",
        metadata: Optional[Dict] = None
    ):
        """
        Create notification.
        
        Args:
            level: Notification level
            title: Notification title
            message: Notification message
            category: Category (TRADE, RISK, SYSTEM, etc.)
            metadata: Additional metadata
        """
        self.level = level
        self.title = title
        self.message = message
        self.category = category
        self.metadata = metadata or {}
        self.timestamp = datetime.now()
        self.id = f"{self.timestamp.timestamp()}_{hash(message)}"
    
    def __str__(self) -> str:
        return f"[{self.level.value}] {self.title}: {self.message}"
    
    def to_dict(self) -> Dict[str, Any]:
        """Convert to dictionary."""
        return {
            'id': self.id,
            'level': self.level.value,
            'title': self.title,
            'message': self.message,
            'category': self.category,
            'metadata': self.metadata,
            'timestamp': self.timestamp.isoformat()
        }


class NotificationSystem:
    """
    Centralized notification system for the trading platform.
    Manages alerts, notifications, and callbacks.
    """
    
    def __init__(self, max_notifications: int = 1000):
        """
        Initialize notification system.
        
        Args:
            max_notifications: Maximum notifications to keep in history
        """
        self.max_notifications = max_notifications
        self.notifications: List[Notification] = []
        self.notification_queue = queue.Queue()
        self.callbacks: Dict[str, List[Callable]] = {
            'INFO': [],
            'WARNING': [],
            'ERROR': [],
            'CRITICAL': [],
            'SUCCESS': [],
            'ALL': []
        }
        self._lock = threading.Lock()
    
    def subscribe(
        self,
        callback: Callable[[Notification], None],
        level: Optional[str] = 'ALL'
    ):
        """
        Subscribe to notifications.
        
        Args:
            callback: Callback function to receive notifications
            level: Notification level to subscribe to (default: ALL)
        """
        with self._lock:
            if level not in self.callbacks:
                level = 'ALL'
            self.callbacks[level].append(callback)
            system_logger.debug(f"Subscribed callback to {level} notifications")
    
    def unsubscribe(self, callback: Callable, level: Optional[str] = 'ALL'):
        """
        Unsubscribe from notifications.
        
        Args:
            callback: Callback function to remove
            level: Notification level
        """
        with self._lock:
            if level in self.callbacks and callback in self.callbacks[level]:
                self.callbacks[level].remove(callback)
                system_logger.debug(f"Unsubscribed callback from {level} notifications")
    
    def notify(
        self,
        level: NotificationLevel,
        title: str,
        message: str,
        category: str = "GENERAL",
        metadata: Optional[Dict] = None
    ):
        """
        Send a notification.
        
        Args:
            level: Notification level
            title: Notification title
            message: Notification message
            category: Notification category
            metadata: Additional metadata
        """
        notification = Notification(level, title, message, category, metadata)
        
        with self._lock:
            # Add to history
            self.notifications.append(notification)
            
            # Limit history size
            if len(self.notifications) > self.max_notifications:
                self.notifications.pop(0)
            
            # Add to queue
            self.notification_queue.put(notification)
        
        # Log notification
        log_message = f"[{category}] {title}: {message}"
        if level == NotificationLevel.INFO:
            system_logger.info(log_message)
        elif level == NotificationLevel.WARNING:
            system_logger.warning(log_message)
        elif level in [NotificationLevel.ERROR, NotificationLevel.CRITICAL]:
            system_logger.error(log_message)
        
        # Execute callbacks
        self._execute_callbacks(notification)
    
    def _execute_callbacks(self, notification: Notification):
        """
        Execute registered callbacks for a notification.
        
        Args:
            notification: Notification to process
        """
        with self._lock:
            # Level-specific callbacks
            for callback in self.callbacks.get(notification.level.value, []):
                try:
                    callback(notification)
                except Exception as e:
                    system_logger.error(f"Callback error: {str(e)}")
            
            # General callbacks
            for callback in self.callbacks.get('ALL', []):
                try:
                    callback(notification)
                except Exception as e:
                    system_logger.error(f"Callback error: {str(e)}")
    
    def info(self, title: str, message: str, category: str = "GENERAL", **kwargs):
        """Send INFO notification."""
        self.notify(NotificationLevel.INFO, title, message, category, kwargs)
    
    def success(self, title: str, message: str, category: str = "GENERAL", **kwargs):
        """Send SUCCESS notification."""
        self.notify(NotificationLevel.SUCCESS, title, message, category, kwargs)
    
    def warning(self, title: str, message: str, category: str = "GENERAL", **kwargs):
        """Send WARNING notification."""
        self.notify(NotificationLevel.WARNING, title, message, category, kwargs)
    
    def error(self, title: str, message: str, category: str = "GENERAL", **kwargs):
        """Send ERROR notification."""
        self.notify(NotificationLevel.ERROR, title, message, category, kwargs)
    
    def critical(self, title: str, message: str, category: str = "GENERAL", **kwargs):
        """Send CRITICAL notification."""
        self.notify(NotificationLevel.CRITICAL, title, message, category, kwargs)
    
    # Trading-specific notifications
    
    def trade_executed(
        self,
        symbol: str,
        side: str,
        quantity: int,
        price: float,
        order_id: str = None
    ):
        """
        Notify about trade execution.
        
        Args:
            symbol: Stock symbol
            side: BUY or SELL
            quantity: Trade quantity
            price: Execution price
            order_id: Order ID
        """
        self.success(
            "Trade Executed",
            f"{side} {quantity} {symbol} @ ${price:.2f}",
            category="TRADE",
            symbol=symbol,
            side=side,
            quantity=quantity,
            price=price,
            order_id=order_id
        )
    
    def trade_failed(
        self,
        symbol: str,
        side: str,
        quantity: int,
        error: str
    ):
        """
        Notify about trade failure.
        
        Args:
            symbol: Stock symbol
            side: BUY or SELL
            quantity: Trade quantity
            error: Error message
        """
        self.error(
            "Trade Failed",
            f"Failed to {side} {quantity} {symbol}: {error}",
            category="TRADE",
            symbol=symbol,
            side=side,
            quantity=quantity,
            error=error
        )
    
    def risk_alert(self, alert_type: str, message: str, severity: str = "WARNING"):
        """
        Notify about risk alert.
        
        Args:
            alert_type: Type of risk alert
            message: Alert message
            severity: Alert severity
        """
        level = NotificationLevel.WARNING
        if severity == "CRITICAL":
            level = NotificationLevel.CRITICAL
        elif severity == "ERROR":
            level = NotificationLevel.ERROR
        
        self.notify(
            level,
            f"Risk Alert: {alert_type}",
            message,
            category="RISK",
            alert_type=alert_type
        )
    
    def system_event(self, event: str, details: str = ""):
        """
        Notify about system event.
        
        Args:
            event: Event name
            details: Event details
        """
        self.info(
            f"System: {event}",
            details,
            category="SYSTEM",
            event=event
        )
    
    def performance_milestone(self, milestone: str, value: Any):
        """
        Notify about performance milestone.
        
        Args:
            milestone: Milestone description
            value: Milestone value
        """
        self.success(
            "Performance Milestone",
            f"{milestone}: {value}",
            category="PERFORMANCE",
            milestone=milestone,
            value=value
        )
    
    def get_notifications(
        self,
        category: Optional[str] = None,
        level: Optional[NotificationLevel] = None,
        limit: int = 100
    ) -> List[Notification]:
        """
        Get notifications with optional filtering.
        
        Args:
            category: Filter by category
            level: Filter by level
            limit: Maximum number to return
            
        Returns:
            List of notifications
        """
        with self._lock:
            notifications = self.notifications.copy()
        
        # Apply filters
        if category:
            notifications = [n for n in notifications if n.category == category]
        
        if level:
            notifications = [n for n in notifications if n.level == level]
        
        # Return most recent
        return notifications[-limit:]
    
    def clear_notifications(self, category: Optional[str] = None):
        """
        Clear notifications.
        
        Args:
            category: Optional category to clear (clears all if None)
        """
        with self._lock:
            if category:
                self.notifications = [
                    n for n in self.notifications
                    if n.category != category
                ]
            else:
                self.notifications.clear()
    
    def get_unread_count(self) -> int:
        """
        Get count of notifications in queue.
        
        Returns:
            Number of unread notifications
        """
        return self.notification_queue.qsize()


# Global notification system instance
notification_system = NotificationSystem()