AccountForger-neuerUpload/application/services/error_handler.py

"""
Zentralisiertes Error Handling für AccountForger
"""
import logging
from typing import Dict, Any, Optional
from dataclasses import dataclass

from domain.exceptions import (
    AccountCreationException, 
    RateLimitException,
    CaptchaRequiredException,
    ValidationException,
    ProxyException,
    NetworkException,
    AccountForgerException
)


@dataclass
class ErrorResult:
    """Strukturiertes Fehler-Ergebnis"""
    user_message: str
    technical_details: str
    recovery_suggestion: Optional[str] = None
    error_type: Optional[str] = None
    retry_possible: bool = False
    retry_after: Optional[int] = None


class ErrorHandler:
    """Zentralisiertes Error Handling"""
    
    def __init__(self, logger: Optional[logging.Logger] = None):
        self.logger = logger or logging.getLogger(__name__)
    
    def handle_account_creation_error(self, error: Exception, context: Dict[str, Any]) -> ErrorResult:
        """Behandelt Account-Erstellungsfehler einheitlich"""
        self.logger.error(f"Account creation failed: {error}", extra=context)
        
        # Spezifische Exception-Typen behandeln
        if isinstance(error, RateLimitException):
            return ErrorResult(
                user_message=error.user_friendly_message,
                technical_details=str(error),
                recovery_suggestion=error.recovery_suggestion,
                error_type="rate_limit",
                retry_possible=True,
                retry_after=error.retry_after
            )
            
        elif isinstance(error, CaptchaRequiredException):
            return ErrorResult(
                user_message=error.user_friendly_message,
                technical_details=str(error),
                recovery_suggestion=error.recovery_suggestion,
                error_type="captcha",
                retry_possible=False
            )
            
        elif isinstance(error, ValidationException):
            return ErrorResult(
                user_message=f"Eingabefehler: {error.message}",
                technical_details=str(error),
                recovery_suggestion="Bitte überprüfen Sie Ihre Eingaben",
                error_type="validation",
                retry_possible=False
            )
            
        elif isinstance(error, ProxyException):
            return ErrorResult(
                user_message="Proxy-Verbindungsfehler",
                technical_details=str(error),
                recovery_suggestion="Überprüfen Sie Ihre Proxy-Einstellungen",
                error_type="proxy",
                retry_possible=True
            )
            
        elif isinstance(error, NetworkException):
            return ErrorResult(
                user_message="Netzwerkverbindungsfehler",
                technical_details=str(error),
                recovery_suggestion=error.details.get("recovery_suggestion", "Überprüfen Sie Ihre Internetverbindung"),
                error_type="network",
                retry_possible=True
            )
            
        elif isinstance(error, AccountCreationException):
            return ErrorResult(
                user_message=error.user_friendly_message,
                technical_details=str(error),
                recovery_suggestion=error.recovery_suggestion,
                error_type=error.error_type,
                retry_possible=True
            )
            
        # Generische Fehler
        else:
            return ErrorResult(
                user_message="Ein unerwarteter Fehler ist aufgetreten",
                technical_details=str(error),
                recovery_suggestion="Bitte versuchen Sie es später erneut",
                error_type="unknown",
                retry_possible=True
            )
    
    def interpret_error_message(self, error_msg: str, platform: str) -> ErrorResult:
        """Interpretiert String-Fehlermeldungen und gibt strukturierte Ergebnisse zurück"""
        error_lower = error_msg.lower()
        
        # Rate Limit Patterns
        if any(pattern in error_lower for pattern in ["rate limit", "too many", "zu viele"]):
            return ErrorResult(
                user_message="Zu viele Versuche - bitte später erneut versuchen",
                technical_details=error_msg,
                recovery_suggestion="Warten Sie 5-10 Minuten vor dem nächsten Versuch",
                error_type="rate_limit",
                retry_possible=True,
                retry_after=300  # 5 Minuten
            )
            
        # Captcha Patterns
        elif any(pattern in error_lower for pattern in ["captcha", "verification required", "verifizierung erforderlich"]):
            return ErrorResult(
                user_message=f"{platform} erfordert eine Captcha-Verifizierung",
                technical_details=error_msg,
                recovery_suggestion="Nutzen Sie einen anderen Proxy oder versuchen Sie es später",
                error_type="captcha",
                retry_possible=False
            )
            
        # Username Patterns
        elif any(pattern in error_lower for pattern in ["username", "benutzername", "already taken", "bereits vergeben"]):
            return ErrorResult(
                user_message="Der gewählte Benutzername ist nicht verfügbar",
                technical_details=error_msg,
                recovery_suggestion="Versuchen Sie einen anderen Benutzernamen",
                error_type="username_taken",
                retry_possible=True
            )
            
        # Password Patterns
        elif any(pattern in error_lower for pattern in ["password", "passwort", "weak", "schwach"]):
            return ErrorResult(
                user_message="Das Passwort erfüllt nicht die Anforderungen",
                technical_details=error_msg,
                recovery_suggestion=f"Verwenden Sie ein stärkeres Passwort mit Groß-/Kleinbuchstaben, Zahlen und Sonderzeichen",
                error_type="weak_password",
                retry_possible=True
            )
            
        # Network Patterns
        elif any(pattern in error_lower for pattern in ["network", "netzwerk", "connection", "verbindung", "timeout"]):
            return ErrorResult(
                user_message="Netzwerkverbindungsfehler",
                technical_details=error_msg,
                recovery_suggestion="Überprüfen Sie Ihre Internetverbindung",
                error_type="network",
                retry_possible=True
            )
            
        # Default
        else:
            return ErrorResult(
                user_message=f"Fehler bei der Registrierung: {error_msg}",
                technical_details=error_msg,
                recovery_suggestion="Überprüfen Sie Ihre Eingaben und versuchen Sie es erneut",
                error_type="unknown",
                retry_possible=True
            )