"""
Analytics Service Interface - Domain Service für Analytics und Reporting
"""

from abc import ABC, abstractmethod
from typing import List, Optional, Dict, Any, Union
from datetime import datetime, timedelta

from domain.entities.account_creation_event import AccountCreationEvent
from domain.entities.error_event import ErrorEvent
from domain.value_objects.error_summary import ErrorSummary
from domain.value_objects.report import Report, ReportType


class IAnalyticsService(ABC):
    """
    Interface für Analytics Service.
    Definiert die Geschäftslogik für Event-Tracking und Reporting.
    """
    
    @abstractmethod
    def log_event(self, event: Union[AccountCreationEvent, ErrorEvent, Any]) -> None:
        """
        Loggt ein Event für spätere Analyse.
        
        Args:
            event: Zu loggendes Event
        """
        pass
    
    @abstractmethod
    def get_success_rate(self, 
                        timeframe: Optional[timedelta] = None,
                        platform: Optional[str] = None) -> float:
        """
        Berechnet die Erfolgsrate für Account-Erstellung.
        
        Args:
            timeframe: Optional - Zeitrahmen für Berechnung
            platform: Optional - Spezifische Plattform
            
        Returns:
            Erfolgsrate zwischen 0.0 und 1.0
        """
        pass
    
    @abstractmethod
    def get_common_errors(self, 
                         limit: int = 10,
                         timeframe: Optional[timedelta] = None) -> List[ErrorSummary]:
        """
        Holt die häufigsten Fehler.
        
        Args:
            limit: Maximale Anzahl von Fehlern
            timeframe: Optional - Zeitrahmen für Analyse
            
        Returns:
            Liste von Fehler-Zusammenfassungen
        """
        pass
    
    @abstractmethod
    def generate_report(self, 
                       report_type: ReportType,
                       start: datetime,
                       end: datetime,
                       platforms: Optional[List[str]] = None) -> Report:
        """
        Generiert einen detaillierten Report.
        
        Args:
            report_type: Typ des Reports
            start: Startdatum
            end: Enddatum
            platforms: Optional - Filter für spezifische Plattformen
            
        Returns:
            Generierter Report
        """
        pass
    
    @abstractmethod
    def get_real_time_metrics(self) -> Dict[str, Any]:
        """
        Holt Echtzeit-Metriken für Dashboard.
        
        Returns:
            Dictionary mit aktuellen Metriken
        """
        pass
    
    @abstractmethod
    def track_performance(self, 
                         metric_name: str,
                         value: float,
                         tags: Optional[Dict[str, str]] = None) -> None:
        """
        Trackt eine Performance-Metrik.
        
        Args:
            metric_name: Name der Metrik
            value: Wert der Metrik
            tags: Optional - Zusätzliche Tags
        """
        pass
    
    @abstractmethod
    def get_account_creation_timeline(self, 
                                    hours: int = 24,
                                    platform: Optional[str] = None) -> Dict[str, Any]:
        """
        Holt Timeline der Account-Erstellungen.
        
        Args:
            hours: Anzahl Stunden zurück
            platform: Optional - Spezifische Plattform
            
        Returns:
            Timeline-Daten für Visualisierung
        """
        pass
    
    @abstractmethod
    def analyze_failure_patterns(self, 
                               timeframe: Optional[timedelta] = None) -> Dict[str, Any]:
        """
        Analysiert Muster in Fehlern.
        
        Args:
            timeframe: Optional - Zeitrahmen für Analyse
            
        Returns:
            Dictionary mit Fehler-Mustern und Insights
        """
        pass
    
    @abstractmethod
    def get_platform_comparison(self, 
                              timeframe: Optional[timedelta] = None) -> Dict[str, Any]:
        """
        Vergleicht Performance zwischen Plattformen.
        
        Args:
            timeframe: Optional - Zeitrahmen für Vergleich
            
        Returns:
            Dictionary mit Plattform-Vergleichsdaten
        """
        pass
    
    @abstractmethod
    def export_data(self, 
                   format: str = "json",
                   start: Optional[datetime] = None,
                   end: Optional[datetime] = None) -> bytes:
        """
        Exportiert Analytics-Daten.
        
        Args:
            format: Export-Format ("json", "csv", "excel")
            start: Optional - Startdatum
            end: Optional - Enddatum
            
        Returns:
            Exportierte Daten als Bytes
        """
        pass
    
    @abstractmethod
    def cleanup_old_events(self, older_than: datetime) -> int:
        """
        Bereinigt alte Events.
        
        Args:
            older_than: Lösche Events älter als dieses Datum
            
        Returns:
            Anzahl gelöschter Events
        """
        pass