"""
Menschliches Verhalten für den Social Media Account Generator.
"""

import random
import time
import logging
import math
from typing import Optional, Tuple, List, Dict, Any, Callable

logger = logging.getLogger("human_behavior")

class HumanBehavior:
    """Klasse zur Simulation von menschlichem Verhalten für die Automatisierung."""
    
    def __init__(self, speed_factor: float = 1.0, randomness: float = 0.5):
        """
        Initialisiert die HumanBehavior-Klasse.
        
        Args:
            speed_factor: Faktormultiplikator für die Geschwindigkeit (höher = schneller)
            randomness: Faktor für die Zufälligkeit (0-1, höher = zufälliger)
        """
        self.speed_factor = max(0.1, min(10.0, speed_factor))  # Begrenzung auf 0.1-10.0
        self.randomness = max(0.0, min(1.0, randomness))  # Begrenzung auf 0.0-1.0
        
        # Typische Verzögerungen (in Sekunden) - ERHÖHT für Anti-Detection
        self.delays = {
            "typing_per_char": 0.08,    # Verzögerung pro Zeichen beim Tippen (erhöht)
            "mouse_movement": 0.5,      # Verzögerung für Mausbewegung
            "click": 0.15,              # Verzögerung für Mausklick (erhöht)
            "page_load": 8.0,           # Verzögerung für das Laden einer Seite (STARK erhöht: 5-15s)
            "form_fill": 4.0,           # Verzögerung zwischen Formularfeldern (STARK erhöht: 2-8s)
            "decision": 3.0,            # Verzögerung für Entscheidungen (erhöht)
            "scroll": 0.5,              # Verzögerung für Scrollbewegungen (erhöht)
            "verification": 30.0,       # Verzögerung für Verifizierungsprozesse (STARK erhöht: 15-45s)
            "image_upload": 5.0,        # Verzögerung für Bildupload (erhöht)
            "navigation": 2.0,          # Verzögerung für Navigation (erhöht)
            "cookie_reading": 5.0,      # NEU: Cookie-Banner lesen (3-8s)
            "field_transition": 5.0,    # NEU: Zwischen Formularfeldern (2-8s)
            "thinking": 2.0             # NEU: Kurze Denkpause
        }
    
    def sleep(self, delay_type: str, multiplier: float = 1.0) -> None:
        """
        Pausiert die Ausführung für eine bestimmte Zeit, basierend auf dem Verzögerungstyp.
        
        Args:
            delay_type: Typ der Verzögerung (aus self.delays)
            multiplier: Zusätzlicher Multiplikator für die Verzögerung
        """
        base_delay = self.delays.get(delay_type, 0.5)  # Standardverzögerung, wenn der Typ nicht bekannt ist
        
        # Berechne die effektive Verzögerung
        delay = base_delay * multiplier / self.speed_factor
        
        # Füge Zufälligkeit hinzu
        if self.randomness > 0:
            # Variiere die Verzögerung um ±randomness%
            variation = 1.0 + (random.random() * 2 - 1) * self.randomness
            delay *= variation
        
        # Stelle sicher, dass die Verzögerung nicht negativ ist
        delay = max(0, delay)
        
        logger.debug(f"Schlafe für {delay:.2f}s ({delay_type})")
        time.sleep(delay)
    
    def random_delay(self, min_seconds: float = 1.0, max_seconds: float = 3.0) -> None:
        """
        Führt eine zufällige Wartezeit aus, um menschliches Verhalten zu simulieren.
        
        Args:
            min_seconds: Minimale Wartezeit in Sekunden
            max_seconds: Maximale Wartezeit in Sekunden
        """
        return self._random_delay(min_seconds, max_seconds)
    
    def _random_delay(self, min_seconds: float = 1.0, max_seconds: float = 3.0) -> None:
        """
        Führt eine zufällige Wartezeit aus, um menschliches Verhalten zu simulieren.

        Args:
            min_seconds: Minimale Wartezeit in Sekunden
            max_seconds: Maximale Wartezeit in Sekunden
        """
        delay = random.uniform(min_seconds, max_seconds)
        logger.debug(f"Zufällige Wartezeit: {delay:.2f} Sekunden")
        time.sleep(delay)

    def anti_detection_delay(self, action_type: str = "form_fill") -> None:
        """
        Erzeugt eine realistische Anti-Detection-Verzögerung.

        Diese Methode verwendet längere, zufälligere Wartezeiten um Bot-Erkennung
        zu vermeiden. Die Verzögerungen sind bewusst lang um menschliches
        Verhalten realistischer zu simulieren.

        Args:
            action_type: Art der Aktion:
                - "form_fill": Zwischen Formularfeldern (2-8s)
                - "page_load": Auf neuen Seiten (5-15s)
                - "verification": Vor Code-Eingabe (15-45s)
                - "cookie_reading": Cookie-Banner lesen (3-8s)
                - "thinking": Kurze Denkpause (1-3s)
        """
        delay_ranges = {
            "form_fill": (2.0, 8.0),       # Zwischen Formularfeldern
            "page_load": (5.0, 15.0),      # Auf neuen Seiten
            "verification": (15.0, 45.0),  # Vor Code-Eingabe
            "cookie_reading": (3.0, 8.0),  # Cookie-Banner lesen
            "thinking": (1.0, 3.0),        # Kurze Denkpause
            "field_focus": (0.5, 1.5),     # Vor Feldinteraktion
        }

        min_delay, max_delay = delay_ranges.get(action_type, (2.0, 5.0))

        # Basis-Verzögerung
        delay = random.uniform(min_delay, max_delay)

        # Zusätzliche Variation basierend auf randomness
        if self.randomness > 0:
            variation = 1.0 + (random.random() * 2 - 1) * self.randomness * 0.3
            delay *= variation

        # Speed-Factor anwenden (aber nicht zu stark reduzieren)
        delay = delay / max(self.speed_factor, 0.5)

        # Gelegentlich extra lange Pause (simuliert Ablenkung/Nachdenken)
        if random.random() < 0.1:
            extra_delay = random.uniform(2.0, 5.0)
            delay += extra_delay
            logger.debug(f"Extra Denkpause: +{extra_delay:.2f}s")

        logger.debug(f"Anti-Detection Delay ({action_type}): {delay:.2f}s")
        time.sleep(max(0.5, delay))  # Minimum 0.5s

    def type_text(self, text: str, on_char_typed: Optional[Callable[[str], None]] = None,
                 error_probability: float = 0.15, correction_probability: float = 0.95) -> str:
        """
        Simuliert menschliches Tippen mit realistischen Tippfehlern und Korrekturen.

        Die Fehlerrate wurde auf 15% erhöht (vorher 5%) um realistischeres
        menschliches Verhalten zu simulieren. Echte Menschen machen häufig
        Tippfehler und korrigieren diese sofort.

        Args:
            text: Zu tippender Text
            on_char_typed: Optionale Funktion, die für jedes getippte Zeichen aufgerufen wird
            error_probability: Wahrscheinlichkeit für Tippfehler (0-1), Standard: 0.15 (15%)
            correction_probability: Wahrscheinlichkeit, Tippfehler zu korrigieren (0-1)

        Returns:
            Der tatsächlich getippte Text (mit oder ohne Fehler)
        """
        # Fehlerrate zwischen 10-20% halten für Realismus
        base_error_prob = max(0.10, min(0.20, error_probability))
        # Anpassen basierend auf Zufälligkeit (aber nicht unter 10%)
        adjusted_error_prob = max(0.10, base_error_prob * (0.8 + self.randomness * 0.4))

        result = ""
        i = 0

        while i < len(text):
            char = text[i]

            # Potentieller Tippfehler
            if random.random() < adjusted_error_prob:
                # Auswahl eines Fehlertyps:
                # - Falsches Zeichen (Tastatur-Nachbarn) - 50%
                # - Transposition (Buchstaben vertauschen) - 15%
                # - Ausgelassenes Zeichen - 15%
                # - Doppeltes Zeichen - 20%
                error_type = random.choices(
                    ["wrong", "transposition", "skip", "double"],
                    weights=[0.50, 0.15, 0.15, 0.20],
                    k=1
                )[0]

                if error_type == "wrong":
                    # Falsches Zeichen tippen (Tastatur-Nachbarn)
                    keyboard_neighbors = self.get_keyboard_neighbors(char)
                    if keyboard_neighbors:
                        wrong_char = random.choice(keyboard_neighbors)
                        result += wrong_char
                        if on_char_typed:
                            on_char_typed(wrong_char)
                        self.sleep("typing_per_char")

                        # Pause bevor Fehler "bemerkt" wird
                        time.sleep(random.uniform(0.1, 0.4))

                        # Entscheiden, ob der Fehler korrigiert wird
                        if random.random() < correction_probability:
                            # Löschen des falschen Zeichens
                            result = result[:-1]
                            if on_char_typed:
                                on_char_typed("\b")  # Backspace
                            self.sleep("typing_per_char", 1.8)

                            # Korrektes Zeichen tippen
                            result += char
                            if on_char_typed:
                                on_char_typed(char)
                            self.sleep("typing_per_char")
                    else:
                        # Wenn keine Nachbarn gefunden werden, normales Zeichen tippen
                        result += char
                        if on_char_typed:
                            on_char_typed(char)
                        self.sleep("typing_per_char")

                elif error_type == "transposition" and i < len(text) - 1:
                    # Buchstaben vertauschen (häufiger Tippfehler)
                    next_char = text[i + 1]
                    result += next_char + char  # Vertauscht
                    if on_char_typed:
                        on_char_typed(next_char)
                        self.sleep("typing_per_char")
                        on_char_typed(char)
                    self.sleep("typing_per_char")

                    # Korrektur der Transposition
                    if random.random() < correction_probability:
                        time.sleep(random.uniform(0.2, 0.5))  # Bemerken des Fehlers
                        # Beide Zeichen löschen
                        result = result[:-2]
                        if on_char_typed:
                            on_char_typed("\b")
                            self.sleep("typing_per_char", 1.3)
                            on_char_typed("\b")
                        self.sleep("typing_per_char", 1.5)

                        # Korrekte Reihenfolge tippen
                        result += char + next_char
                        if on_char_typed:
                            on_char_typed(char)
                            self.sleep("typing_per_char")
                            on_char_typed(next_char)
                        self.sleep("typing_per_char")

                    i += 1  # Nächstes Zeichen überspringen (bereits verarbeitet)

                elif error_type == "skip":
                    # Zeichen auslassen (nichts tun)
                    # In 50% der Fälle später bemerken und nachtippen
                    if random.random() < 0.5 and i < len(text) - 1:
                        # Nächstes Zeichen normal tippen
                        pass  # Wird übersprungen
                    pass

                elif error_type == "double":
                    # Zeichen doppelt tippen
                    result += char + char
                    if on_char_typed:
                        on_char_typed(char)
                        self.sleep("typing_per_char", 0.3)  # Sehr kurz zwischen Doppel
                        on_char_typed(char)
                    self.sleep("typing_per_char")

                    # Pause bevor Fehler bemerkt wird
                    time.sleep(random.uniform(0.15, 0.35))

                    # Entscheiden, ob der Fehler korrigiert wird
                    if random.random() < correction_probability:
                        # Löschen des doppelten Zeichens
                        result = result[:-1]
                        if on_char_typed:
                            on_char_typed("\b")  # Backspace
                        self.sleep("typing_per_char", 1.3)
            else:
                # Normales Tippen ohne Fehler
                result += char
                if on_char_typed:
                    on_char_typed(char)

                # Variable Tippgeschwindigkeit basierend auf Zeichen
                if char in ' .,!?;:':
                    # Längere Pause nach Satzzeichen/Leerzeichen
                    self.sleep("typing_per_char", random.uniform(1.2, 1.8))
                elif char.isupper():
                    # Leicht länger für Großbuchstaben (Shift-Taste)
                    self.sleep("typing_per_char", random.uniform(1.0, 1.3))
                else:
                    self.sleep("typing_per_char", random.uniform(0.8, 1.2))

            i += 1

            # Gelegentliche längere Pause (Nachdenken)
            if random.random() < 0.05:
                time.sleep(random.uniform(0.3, 0.8))

        return result
    
    def get_keyboard_neighbors(self, char: str) -> List[str]:
        """
        Gibt die Tastatur-Nachbarn eines Zeichens zurück.
        
        Args:
            char: Das Zeichen, für das Nachbarn gefunden werden sollen
            
        Returns:
            Liste von benachbarten Zeichen
        """
        # QWERTY-Tastaturlayout
        keyboard_layout = {
            "1": ["2", "q"],
            "2": ["1", "3", "q", "w"],
            "3": ["2", "4", "w", "e"],
            "4": ["3", "5", "e", "r"],
            "5": ["4", "6", "r", "t"],
            "6": ["5", "7", "t", "y"],
            "7": ["6", "8", "y", "u"],
            "8": ["7", "9", "u", "i"],
            "9": ["8", "0", "i", "o"],
            "0": ["9", "-", "o", "p"],
            "-": ["0", "=", "p", "["],
            "=": ["-", "[", "]"],
            "q": ["1", "2", "w", "a"],
            "w": ["2", "3", "q", "e", "a", "s"],
            "e": ["3", "4", "w", "r", "s", "d"],
            "r": ["4", "5", "e", "t", "d", "f"],
            "t": ["5", "6", "r", "y", "f", "g"],
            "y": ["6", "7", "t", "u", "g", "h"],
            "u": ["7", "8", "y", "i", "h", "j"],
            "i": ["8", "9", "u", "o", "j", "k"],
            "o": ["9", "0", "i", "p", "k", "l"],
            "p": ["0", "-", "o", "[", "l", ";"],
            "[": ["-", "=", "p", "]", ";", "'"],
            "]": ["=", "[", "'", "\\"],
            "a": ["q", "w", "s", "z"],
            "s": ["w", "e", "a", "d", "z", "x"],
            "d": ["e", "r", "s", "f", "x", "c"],
            "f": ["r", "t", "d", "g", "c", "v"],
            "g": ["t", "y", "f", "h", "v", "b"],
            "h": ["y", "u", "g", "j", "b", "n"],
            "j": ["u", "i", "h", "k", "n", "m"],
            "k": ["i", "o", "j", "l", "m", ","],
            "l": ["o", "p", "k", ";", ",", "."],
            ";": ["p", "[", "l", "'", ".", "/"],
            "'": ["[", "]", ";", "/"],
            "z": ["a", "s", "x"],
            "x": ["s", "d", "z", "c"],
            "c": ["d", "f", "x", "v"],
            "v": ["f", "g", "c", "b"],
            "b": ["g", "h", "v", "n"],
            "n": ["h", "j", "b", "m"],
            "m": ["j", "k", "n", ","],
            ",": ["k", "l", "m", "."],
            ".": ["l", ";", ",", "/"],
            "/": [";", "'", "."],
            " ": ["c", "v", "b", "n", "m"]  # Leertaste hat viele benachbarte Tasten
        }
        
        # Für Großbuchstaben die Nachbarn der Kleinbuchstaben verwenden
        if char.lower() != char and char.lower() in keyboard_layout:
            return [neighbor.upper() if random.choice([True, False]) else neighbor 
                    for neighbor in keyboard_layout[char.lower()]]
        
        return keyboard_layout.get(char, [])
    
    def mouse_move(self, from_point: Optional[Tuple[int, int]] = None, 
                  to_point: Tuple[int, int] = (0, 0),
                  on_move: Optional[Callable[[Tuple[int, int]], None]] = None) -> None:
        """
        Simuliert eine menschliche Mausbewegung mit natürlicher Beschleunigung und Verzögerung.
        
        Args:
            from_point: Startpunkt der Bewegung (oder None für aktuelle Position)
            to_point: Zielpunkt der Bewegung
            on_move: Optionale Funktion, die für jede Zwischenposition aufgerufen wird
        """
        # Wenn kein Startpunkt angegeben ist, einen zufälligen verwenden
        if from_point is None:
            from_point = (random.randint(0, 1000), random.randint(0, 800))
        
        # Berechne die Entfernung
        dx = to_point[0] - from_point[0]
        dy = to_point[1] - from_point[1]
        distance = (dx**2 + dy**2)**0.5
        
        # Anzahl der Zwischenschritte basierend auf der Entfernung
        # Mehr Schritte für realistischere Bewegung
        steps = max(20, int(distance / 5))
        
        # Wähle zufällig einen Bewegungstyp
        movement_type = random.choice(["bezier", "arc", "zigzag", "smooth"])
        
        if movement_type == "bezier":
            # Bézierkurve mit mehr Variation
            control_variance = distance / 4
            control_point_1 = (
                from_point[0] + dx * random.uniform(0.2, 0.4) + random.randint(-int(control_variance), int(control_variance)),
                from_point[1] + dy * random.uniform(0.1, 0.3) + random.randint(-int(control_variance), int(control_variance))
            )
            control_point_2 = (
                from_point[0] + dx * random.uniform(0.6, 0.8) + random.randint(-int(control_variance), int(control_variance)),
                from_point[1] + dy * random.uniform(0.7, 0.9) + random.randint(-int(control_variance), int(control_variance))
            )
        else:
            # Standard Kontrollpunkte für andere Bewegungstypen
            control_point_1 = (from_point[0] + dx * 0.3, from_point[1] + dy * 0.3)
            control_point_2 = (from_point[0] + dx * 0.7, from_point[1] + dy * 0.7)
        
        # Micro-Pauses und Geschwindigkeitsvariationen
        micro_pause_probability = 0.1
        speed_variations = [0.5, 0.8, 1.0, 1.2, 1.5]
        
        # Bewegung durchführen
        for i in range(steps + 1):
            t = i / steps
            
            if movement_type == "bezier":
                # Kubische Bézierkurve
                x = (1-t)**3 * from_point[0] + 3*(1-t)**2*t * control_point_1[0] + 3*(1-t)*t**2 * control_point_2[0] + t**3 * to_point[0]
                y = (1-t)**3 * from_point[1] + 3*(1-t)**2*t * control_point_1[1] + 3*(1-t)*t**2 * control_point_2[1] + t**3 * to_point[1]
            elif movement_type == "arc":
                # Bogenbewegung
                arc_height = distance * 0.2 * (1 if random.random() > 0.5 else -1)
                x = from_point[0] + dx * t
                y = from_point[1] + dy * t + arc_height * 4 * t * (1-t)
            elif movement_type == "zigzag":
                # Zickzack-Bewegung
                zigzag_amplitude = distance * 0.05
                x = from_point[0] + dx * t + zigzag_amplitude * math.sin(t * math.pi * 4)
                y = from_point[1] + dy * t
            else:  # smooth
                # Glatte S-Kurve
                s_curve = t * t * (3 - 2 * t)
                x = from_point[0] + dx * s_curve
                y = from_point[1] + dy * s_curve
            
            # Füge leichtes "Zittern" hinzu für mehr Realismus
            if self.randomness > 0.3:
                jitter = 2 * self.randomness
                x += random.uniform(-jitter, jitter)
                y += random.uniform(-jitter, jitter)
            
            # Runde auf ganze Zahlen
            curr_point = (int(x), int(y))
            
            # Callback aufrufen, wenn vorhanden
            if on_move:
                on_move(curr_point)
            
            # Micro-Pause einbauen
            if random.random() < micro_pause_probability:
                time.sleep(random.uniform(0.05, 0.2))
            
            # Variable Geschwindigkeit
            speed_factor = random.choice(speed_variations)
            
            # Verzögerung basierend auf der Position in der Bewegung
            # Am Anfang und Ende langsamer, in der Mitte schneller
            if i < 0.15 * steps or i > 0.85 * steps:
                self.sleep("mouse_movement", 2.0 * speed_factor / steps)
            elif i < 0.3 * steps or i > 0.7 * steps:
                self.sleep("mouse_movement", 1.5 * speed_factor / steps)
            else:
                self.sleep("mouse_movement", 0.8 * speed_factor / steps)
    
    def click(self, double: bool = False, right: bool = False) -> None:
        """
        Simuliert einen Mausklick mit menschlicher Verzögerung.
        
        Args:
            double: True für Doppelklick, False für Einzelklick
            right: True für Rechtsklick, False für Linksklick
        """
        click_type = "right" if right else "left"
        click_count = 2 if double else 1
        
        for _ in range(click_count):
            logger.debug(f"{click_type.capitalize()}-Klick")
            self.sleep("click")
            
            if double and _ == 0:
                # Kürzere Pause zwischen Doppelklicks
                self.sleep("click", 0.3)
    
    def scroll(self, direction: str = "down", amount: int = 5, 
              on_scroll: Optional[Callable[[int], None]] = None) -> None:
        """
        Simuliert Scrollen mit menschlicher Verzögerung.
        
        Args:
            direction: "up" oder "down"
            amount: Anzahl der Scroll-Ereignisse
            on_scroll: Optionale Funktion, die für jedes Scroll-Ereignis aufgerufen wird
        """
        if direction not in ["up", "down"]:
            logger.warning(f"Ungültige Scrollrichtung: {direction}")
            return
        
        # Vorzeichenwechsel für die Richtung
        scroll_factor = -1 if direction == "up" else 1
        
        # Wähle ein Scroll-Pattern
        patterns = ["smooth", "reading", "fast_scan", "search", "momentum"]
        pattern = random.choice(patterns)
        
        logger.debug(f"Verwende Scroll-Pattern: {pattern}")
        
        # Pattern-spezifische Parameter
        if pattern == "smooth":
            # Gleichmäßiges Scrollen
            for i in range(amount):
                scroll_amount = scroll_factor * random.randint(2, 4)
                if on_scroll:
                    on_scroll(scroll_amount)
                if i < amount - 1:
                    self.sleep("scroll", random.uniform(0.8, 1.2))
                    
        elif pattern == "reading":
            # Lese-Pattern: langsam mit Pausen
            for i in range(amount):
                scroll_amount = scroll_factor * 1
                if on_scroll:
                    on_scroll(scroll_amount)
                if i < amount - 1:
                    if random.random() < 0.3:  # 30% Chance für Lese-Pause
                        time.sleep(random.uniform(0.5, 2.0))
                    else:
                        self.sleep("scroll", random.uniform(1.5, 2.5))
                        
        elif pattern == "fast_scan":
            # Schnelles Überfliegen
            for i in range(amount):
                scroll_amount = scroll_factor * random.randint(5, 8)
                if on_scroll:
                    on_scroll(scroll_amount)
                if i < amount - 1:
                    self.sleep("scroll", random.uniform(0.1, 0.3))
                    
        elif pattern == "search":
            # Suchen-Pattern: unregelmäßig, vor und zurück
            total_scrolled = 0
            for i in range(amount):
                if random.random() < 0.2 and total_scrolled > 5:  # 20% Chance zurückzuscrollen
                    scroll_amount = -scroll_factor * random.randint(1, 3)
                else:
                    scroll_amount = scroll_factor * random.randint(2, 5)
                total_scrolled += abs(scroll_amount)
                if on_scroll:
                    on_scroll(scroll_amount)
                if i < amount - 1:
                    self.sleep("scroll", random.uniform(0.3, 1.0))
                    
        else:  # momentum
            # Momentum-Scrolling (wie Touch-Geräte)
            initial_speed = random.randint(8, 12)
            deceleration = 0.85
            current_speed = initial_speed
            
            while current_speed > 0.5 and amount > 0:
                scroll_amount = scroll_factor * int(current_speed)
                if on_scroll:
                    on_scroll(scroll_amount)
                current_speed *= deceleration
                amount -= 1
                if amount > 0:
                    self.sleep("scroll", 0.05)  # Sehr kurze Pausen für flüssige Bewegung
        
        # Gelegentliches "Overscroll" und Bounce-Back
        if random.random() < 0.1 and pattern != "momentum":
            time.sleep(0.1)
            if on_scroll:
                on_scroll(-scroll_factor * 2)  # Kleiner Bounce-Back
    
    def wait_for_page_load(self, multiplier: float = 1.0) -> None:
        """
        Wartet eine angemessene Zeit auf das Laden einer Seite.
        
        Args:
            multiplier: Multiplikator für die Standardwartezeit
        """
        self.sleep("page_load", multiplier)
    
    def wait_between_actions(self, action_type: str = "decision", multiplier: float = 1.0) -> None:
        """
        Wartet zwischen Aktionen, um menschliches Verhalten zu simulieren.
        
        Args:
            action_type: Art der Aktion
            multiplier: Multiplikator für die Standardwartezeit
        """
        self.sleep(action_type, multiplier)
    
    def navigate_sequence(self, steps: int, min_delay: float = 0.5, max_delay: float = 2.0) -> None:
        """
        Simuliert eine Sequenz von Navigationsschritten mit variierenden Verzögerungen.
        
        Args:
            steps: Anzahl der Navigationsschritte
            min_delay: Minimale Verzögerung zwischen Schritten
            max_delay: Maximale Verzögerung zwischen Schritten
        """
        for i in range(steps):
            # Zufällige Verzögerung zwischen Navigationsschritten
            delay = random.uniform(min_delay, max_delay)
            
            logger.debug(f"Navigationsschritt {i+1}/{steps}, Verzögerung: {delay:.2f}s")
            time.sleep(delay / self.speed_factor)
    
    def human_delay_pattern(self, action_type: str = "default", intensity: str = "medium") -> None:
        """
        Erzeugt ein komplexes, menschliches Verzögerungsmuster.
        
        Args:
            action_type: Art der Aktion (entscheidet über Basismuster)
            intensity: Intensität des Musters ("low", "medium", "high")
        """
        # Verzögerungsmuster basierend auf Aktionstyp und Intensität
        patterns = {
            "default": {
                "low": (0.2, 0.5),
                "medium": (0.5, 1.0),
                "high": (1.0, 2.0)
            },
            "reading": {
                "low": (1.0, 2.0),
                "medium": (2.0, 4.0),
                "high": (3.0, 6.0)
            },
            "thinking": {
                "low": (1.5, 3.0),
                "medium": (3.0, 5.0),
                "high": (5.0, 8.0)
            },
            "verification": {
                "low": (3.0, 5.0),
                "medium": (5.0, 8.0),
                "high": (8.0, 12.0)
            }
        }
        
        # Standardmuster verwenden, wenn nicht bekannt
        pattern = patterns.get(action_type, patterns["default"])
        delay_range = pattern.get(intensity, pattern["medium"])
        
        # Zufällige Verzögerung im angegebenen Bereich
        delay = random.uniform(delay_range[0], delay_range[1])
        
        # Anpassung basierend auf Geschwindigkeit und Zufälligkeit
        delay = delay / self.speed_factor
        
        if self.randomness > 0:
            # Füge ein zufälliges "Zittern" hinzu
            jitter = random.uniform(-0.2, 0.2) * self.randomness * delay
            delay += jitter
        
        logger.debug(f"Menschliche Verzögerung ({action_type}, {intensity}): {delay:.2f}s")
        time.sleep(max(0, delay))
    
    def simulate_form_filling(self, fields: int, field_callback: Optional[Callable[[int], None]] = None) -> None:
        """
        Simuliert das Ausfüllen eines Formulars mit menschlichem Verhalten.
        
        Args:
            fields: Anzahl der auszufüllenden Felder
            field_callback: Optionale Funktion, die für jedes Feld aufgerufen wird
        """
        for i in range(fields):
            logger.debug(f"Fülle Formularfeld {i+1}/{fields} aus")
            
            if field_callback:
                field_callback(i)
            
            # Verzögerung zwischen Feldern
            if i < fields - 1:  # Keine Verzögerung nach dem letzten Feld
                # Gelegentlich längere Pausen einbauen
                if random.random() < 0.2 * self.randomness:
                    self.human_delay_pattern("thinking", "low")
                else:
                    self.sleep("form_fill")
    
    def simulate_captcha_solving(self, on_progress: Optional[Callable[[float], None]] = None) -> None:
        """
        Simuliert das Lösen eines CAPTCHAs mit menschlichem Verhalten.
        
        Args:
            on_progress: Optionale Funktion, die mit dem Fortschritt (0-1) aufgerufen wird
        """
        # Simuliere einen komplexen Prozess mit mehreren Schritten
        steps = random.randint(4, 8)
        
        for i in range(steps):
            progress = (i + 1) / steps
            
            logger.debug(f"CAPTCHA-Lösung Fortschritt: {progress:.0%}")
            
            if on_progress:
                on_progress(progress)
            
            # Verschiedene Verzögerungsmuster für die einzelnen Schritte
            if i == 0:
                # Anfängliches Lesen/Verstehen
                self.human_delay_pattern("reading", "medium")
            elif i == steps - 1:
                # Abschließende Überprüfung/Bestätigung
                self.human_delay_pattern("verification", "low")
            else:
                # Auswahl/Interaktion
                self.human_delay_pattern("thinking", "medium")