"""
Interface for data aggregation and heatmap generation.
"""

from abc import ABC, abstractmethod
from typing import Dict, List
from ..models.core import (
    OrderBookSnapshot, PriceBuckets, HeatmapData, 
    ImbalanceMetrics, ConsolidatedOrderBook
)


class AggregationEngine(ABC):
    """Aggregates data into price buckets and heatmaps"""
    
    @abstractmethod
    def create_price_buckets(self, orderbook: OrderBookSnapshot, 
                           bucket_size: float) -> PriceBuckets:
        """
        Convert order book data to price buckets.
        
        Args:
            orderbook: Order book snapshot
            bucket_size: Size of each price bucket
            
        Returns:
            PriceBuckets: Aggregated price bucket data
        """
        pass
    
    @abstractmethod
    def update_heatmap(self, symbol: str, buckets: PriceBuckets) -> HeatmapData:
        """
        Update heatmap data with new price buckets.
        
        Args:
            symbol: Trading symbol
            buckets: Price bucket data
            
        Returns:
            HeatmapData: Updated heatmap visualization data
        """
        pass
    
    @abstractmethod
    def calculate_imbalances(self, orderbook: OrderBookSnapshot) -> ImbalanceMetrics:
        """
        Calculate order book imbalance metrics.
        
        Args:
            orderbook: Order book snapshot
            
        Returns:
            ImbalanceMetrics: Calculated imbalance metrics
        """
        pass
    
    @abstractmethod
    def aggregate_across_exchanges(self, symbol: str, 
                                 orderbooks: List[OrderBookSnapshot]) -> ConsolidatedOrderBook:
        """
        Aggregate order book data from multiple exchanges.
        
        Args:
            symbol: Trading symbol
            orderbooks: List of order book snapshots from different exchanges
            
        Returns:
            ConsolidatedOrderBook: Consolidated order book data
        """
        pass
    
    @abstractmethod
    def calculate_volume_weighted_price(self, orderbooks: List[OrderBookSnapshot]) -> float:
        """
        Calculate volume-weighted average price across exchanges.
        
        Args:
            orderbooks: List of order book snapshots
            
        Returns:
            float: Volume-weighted average price
        """
        pass
    
    @abstractmethod
    def get_market_depth(self, orderbook: OrderBookSnapshot, 
                        depth_levels: List[float]) -> Dict[float, Dict[str, float]]:
        """
        Calculate market depth at different price levels.
        
        Args:
            orderbook: Order book snapshot
            depth_levels: List of depth percentages (e.g., [0.1, 0.5, 1.0])
            
        Returns:
            Dict: Market depth data {level: {'bid_volume': x, 'ask_volume': y}}
        """
        pass
    
    @abstractmethod
    def smooth_heatmap(self, heatmap: HeatmapData, smoothing_factor: float) -> HeatmapData:
        """
        Apply smoothing to heatmap data to reduce noise.
        
        Args:
            heatmap: Raw heatmap data
            smoothing_factor: Smoothing factor (0.0 to 1.0)
            
        Returns:
            HeatmapData: Smoothed heatmap data
        """
        pass
    
    @abstractmethod
    def calculate_liquidity_score(self, orderbook: OrderBookSnapshot) -> float:
        """
        Calculate liquidity score for an order book.
        
        Args:
            orderbook: Order book snapshot
            
        Returns:
            float: Liquidity score (0.0 to 1.0)
        """
        pass
    
    @abstractmethod
    def detect_support_resistance(self, heatmap: HeatmapData) -> Dict[str, List[float]]:
        """
        Detect support and resistance levels from heatmap data.
        
        Args:
            heatmap: Heatmap data
            
        Returns:
            Dict: {'support': [prices], 'resistance': [prices]}
        """
        pass