# browser/playwright_extensions.py

"""
Erweiterungen für den PlaywrightManager - Fügt zusätzliche Funktionalität hinzu
"""

import logging
from typing import Dict, Any, Optional
from browser.fingerprint_protection import FingerprintProtection

logger = logging.getLogger("playwright_extensions")

class PlaywrightExtensions:
    """
    Erweiterungsklasse für den PlaywrightManager.
    Bietet zusätzliche Funktionalität, ohne die Hauptklasse zu verändern.
    """

    def __init__(self, playwright_manager):
        """
        Initialisiert die Erweiterungsklasse.

        Args:
            playwright_manager: Eine Instanz des PlaywrightManager
        """
        self.playwright_manager = playwright_manager
        self.fingerprint_protection = None
        self.enhanced_stealth_enabled = False

    def enable_enhanced_fingerprint_protection(self, config: Optional[Dict[str, Any]] = None) -> bool:
        """
        Aktiviert den erweiterten Fingerprint-Schutz.

        Args:
            config: Optionale Konfiguration für den Fingerprint-Schutz

        Returns:
            bool: True bei Erfolg, False bei Fehler
        """
        try:
            # Sicherstellen, dass der Browser gestartet wurde
            if not hasattr(self.playwright_manager, 'context') or self.playwright_manager.context is None:
                logger.warning("Browser muss zuerst gestartet werden, bevor der Fingerprint-Schutz aktiviert werden kann")
                return False

            # Basis-Stealth-Konfiguration aus dem PlaywrightManager verwenden
            stealth_config = getattr(self.playwright_manager, 'stealth_config', {})

            # Mit der benutzerdefinierten Konfiguration erweitern, falls vorhanden
            if config:
                stealth_config.update(config)

            # Fingerprint-Schutz initialisieren
            self.fingerprint_protection = FingerprintProtection(
                context=self.playwright_manager.context,
                stealth_config=stealth_config
            )

            # Schutzmaßnahmen auf den Kontext anwenden
            self.fingerprint_protection.apply_to_context()

            # Status aktualisieren
            self.enhanced_stealth_enabled = True

            logger.info("Erweiterter Fingerprint-Schutz aktiviert")
            return True

        except Exception as e:
            logger.error(f"Fehler beim Aktivieren des erweiterten Fingerprint-Schutzes: {e}")
            return False

    def rotate_fingerprint(self, noise_level: Optional[float] = None) -> bool:
        """
        Rotiert den Browser-Fingerprint.

        Args:
            noise_level: Optionales neues Rauschniveau (0.0-1.0)

        Returns:
            bool: True bei Erfolg, False bei Fehler
        """
        if not self.enhanced_stealth_enabled or self.fingerprint_protection is None:
            logger.warning("Erweiterter Fingerprint-Schutz ist nicht aktiviert")
            return False

        return self.fingerprint_protection.rotate_fingerprint(noise_level)

    def get_fingerprint_status(self) -> Dict[str, Any]:
        """
        Gibt den aktuellen Status des Fingerprint-Schutzes zurück.

        Returns:
            Dict[str, Any]: Status des Fingerprint-Schutzes
        """
        if not self.enhanced_stealth_enabled or self.fingerprint_protection is None:
            return {"active": False, "message": "Erweiterter Fingerprint-Schutz ist nicht aktiviert"}

        return self.fingerprint_protection.get_fingerprint_status()

    def hook_into_playwright_manager(self) -> None:
        """
        Hängt die Erweiterungsmethoden an den PlaywrightManager.
        """
        if not self.playwright_manager:
            logger.error("Kein PlaywrightManager zum Anhängen der Erweiterungen")
            return

        # Originalstart-Methode speichern
        original_start = self.playwright_manager.start

        # Die start-Methode überschreiben, um den Fingerprint-Schutz automatisch zu aktivieren
        def enhanced_start(*args, **kwargs):
            result = original_start(*args, **kwargs)

            # Wenn start erfolgreich war und erweiterter Schutz aktiviert ist,
            # wenden wir den Fingerprint-Schutz auf den neuen Kontext an
            if result and self.enhanced_stealth_enabled and self.fingerprint_protection:
                self.fingerprint_protection.set_context(self.playwright_manager.context)
                self.fingerprint_protection.apply_to_context()

            return result

        # Methoden dynamisch zum PlaywrightManager hinzufügen
        self.playwright_manager.enable_enhanced_fingerprint_protection = self.enable_enhanced_fingerprint_protection
        self.playwright_manager.rotate_fingerprint = self.rotate_fingerprint
        self.playwright_manager.get_fingerprint_status = self.get_fingerprint_status
        self.playwright_manager.start = enhanced_start