"""
Account Creation Event Entity - Event für jede Account-Erstellung
"""

from dataclasses import dataclass, field
from datetime import datetime, timedelta
from typing import List, Dict, Any, Optional
from enum import Enum
import uuid


class WorkflowStepStatus(Enum):
    """Status eines Workflow-Schritts"""
    PENDING = "pending"
    IN_PROGRESS = "in_progress"
    COMPLETED = "completed"
    FAILED = "failed"
    SKIPPED = "skipped"


@dataclass
class WorkflowStep:
    """Einzelner Schritt im Account-Erstellungsprozess"""
    step_name: str
    start_time: datetime
    end_time: Optional[datetime] = None
    status: WorkflowStepStatus = WorkflowStepStatus.PENDING
    retry_count: int = 0
    error_message: Optional[str] = None
    metadata: Dict[str, Any] = field(default_factory=dict)
    
    @property
    def duration(self) -> Optional[timedelta]:
        """Berechnet die Dauer des Schritts"""
        if self.start_time and self.end_time:
            return self.end_time - self.start_time
        return None
    
    @property
    def success(self) -> bool:
        """Prüft ob der Schritt erfolgreich war"""
        return self.status == WorkflowStepStatus.COMPLETED
    
    def to_dict(self) -> Dict[str, Any]:
        """Konvertiert zu Dictionary"""
        return {
            'step_name': self.step_name,
            'start_time': self.start_time.isoformat(),
            'end_time': self.end_time.isoformat() if self.end_time else None,
            'status': self.status.value,
            'retry_count': self.retry_count,
            'error_message': self.error_message,
            'metadata': self.metadata,
            'duration_seconds': self.duration.total_seconds() if self.duration else None
        }


@dataclass
class AccountData:
    """Daten des erstellten Accounts"""
    platform: str
    username: str
    password: str
    email: str
    phone: Optional[str] = None
    full_name: Optional[str] = None
    birthday: Optional[str] = None
    profile_image: Optional[str] = None
    bio: Optional[str] = None
    verification_status: str = "unverified"
    metadata: Dict[str, Any] = field(default_factory=dict)


@dataclass
class ErrorDetails:
    """Details zu aufgetretenen Fehlern"""
    error_type: str
    error_message: str
    stack_trace: Optional[str] = None
    screenshot_path: Optional[str] = None
    recovery_attempted: bool = False
    recovery_successful: bool = False
    context: Dict[str, Any] = field(default_factory=dict)


@dataclass
class AccountCreationEvent:
    """Event für jede Account-Erstellung"""
    
    event_id: str = field(default_factory=lambda: str(uuid.uuid4()))
    timestamp: datetime = field(default_factory=datetime.now)
    account_data: Optional[AccountData] = None
    session_id: str = ""
    fingerprint_id: str = ""
    duration: Optional[timedelta] = None
    success: bool = False
    error_details: Optional[ErrorDetails] = None
    steps_completed: List[WorkflowStep] = field(default_factory=list)
    
    # Performance-Metriken
    total_retry_count: int = 0
    network_requests: int = 0
    screenshots_taken: int = 0
    
    # Kontext-Informationen
    proxy_used: bool = False
    proxy_type: Optional[str] = None
    browser_type: str = "chromium"
    headless: bool = False
    
    def add_step(self, step: WorkflowStep):
        """Fügt einen Workflow-Schritt hinzu"""
        self.steps_completed.append(step)
        if step.retry_count > 0:
            self.total_retry_count += step.retry_count
    
    def get_step(self, step_name: str) -> Optional[WorkflowStep]:
        """Holt einen Schritt nach Name"""
        for step in self.steps_completed:
            if step.step_name == step_name:
                return step
        return None
    
    def calculate_duration(self):
        """Berechnet die Gesamtdauer der Account-Erstellung"""
        if self.steps_completed:
            first_step = min(self.steps_completed, key=lambda s: s.start_time)
            last_step = max(self.steps_completed, key=lambda s: s.end_time or s.start_time)
            if last_step.end_time:
                self.duration = last_step.end_time - first_step.start_time
    
    def get_success_rate(self) -> float:
        """Berechnet die Erfolgsrate der Schritte"""
        if not self.steps_completed:
            return 0.0
        successful_steps = sum(1 for step in self.steps_completed if step.success)
        return successful_steps / len(self.steps_completed)
    
    def to_dict(self) -> Dict[str, Any]:
        """Konvertiert Event zu Dictionary für Serialisierung"""
        return {
            'event_id': self.event_id,
            'timestamp': self.timestamp.isoformat(),
            'account_data': {
                'platform': self.account_data.platform,
                'username': self.account_data.username,
                'email': self.account_data.email,
                'phone': self.account_data.phone,
                'full_name': self.account_data.full_name,
                'birthday': self.account_data.birthday,
                'verification_status': self.account_data.verification_status,
                'metadata': self.account_data.metadata
            } if self.account_data else None,
            'session_id': self.session_id,
            'fingerprint_id': self.fingerprint_id,
            'duration_seconds': self.duration.total_seconds() if self.duration else None,
            'success': self.success,
            'error_details': {
                'error_type': self.error_details.error_type,
                'error_message': self.error_details.error_message,
                'recovery_attempted': self.error_details.recovery_attempted,
                'recovery_successful': self.error_details.recovery_successful,
                'context': self.error_details.context
            } if self.error_details else None,
            'steps_completed': [step.to_dict() for step in self.steps_completed],
            'total_retry_count': self.total_retry_count,
            'network_requests': self.network_requests,
            'screenshots_taken': self.screenshots_taken,
            'proxy_used': self.proxy_used,
            'proxy_type': self.proxy_type,
            'browser_type': self.browser_type,
            'headless': self.headless,
            'success_rate': self.get_success_rate()
        }