"""
Controller für VK-spezifische Funktionalität
"""

import logging
from typing import Dict, Any

from controllers.platform_controllers.base_controller import BasePlatformController
from controllers.platform_controllers.base_worker_thread import BaseAccountCreationWorkerThread
from social_networks.vk.vk_automation import VKAutomation
from utils.logger import setup_logger

logger = setup_logger("vk_controller")

class VKWorkerThread(BaseAccountCreationWorkerThread):
    """Worker-Thread für VK-Account-Erstellung"""
    
    def __init__(self, params, session_controller=None, generator_tab=None):
        super().__init__(params, "VK", session_controller, generator_tab)
    
    def get_automation_class(self):
        """Gibt die VK-Automation-Klasse zurück"""
        return VKAutomation
    
    def get_error_interpretations(self) -> Dict[str, str]:
        """VK-spezifische Fehlerinterpretationen"""
        return {
            "phone": "Diese Telefonnummer wird bereits verwendet oder ist ungültig.",
            "code": "Der Verifizierungscode ist ungültig.",
            "blocked": "Zu viele Versuche. Bitte versuchen Sie es später erneut.",
            "captcha": "Bitte lösen Sie das Captcha."
        }
    

class VKController(BasePlatformController):
    """Controller für VK-Funktionalität"""
    
    def __init__(self, db_manager, proxy_rotator, email_handler, language_manager, theme_manager=None):
        super().__init__("vk", db_manager, proxy_rotator, email_handler, language_manager)
        logger.info("VK Controller initialisiert")
    
    def get_worker_thread_class(self):
        """Gibt die Worker-Thread-Klasse für VK zurück"""
        return VKWorkerThread
    
    def get_platform_display_name(self) -> str:
        """Gibt den Anzeigenamen der Plattform zurück"""
        return "VK"
    
    def validate_account_data(self, account_data: Dict[str, Any]) -> Dict[str, Any]:
        """Validiert die Account-Daten für VK"""
        errors = []
        
        # Pflichtfelder prüfen
        if not account_data.get("first_name"):
            errors.append("Vorname ist erforderlich")
        
        if not account_data.get("last_name"):
            errors.append("Nachname ist erforderlich")
            
        if not account_data.get("phone"):
            errors.append("Telefonnummer ist für VK erforderlich")
        
        if errors:
            return {
                "valid": False,
                "errors": errors
            }
        
        return {
            "valid": True,
            "errors": []
        }
    
    def get_default_settings(self) -> Dict[str, Any]:
        """Gibt die Standard-Einstellungen für VK zurück"""
        settings = super().get_default_settings()
        settings.update({
            "require_phone": True,
            "require_email": False,
            "default_country_code": "+7",  # Russland
            "supported_languages": ["ru", "en", "de"],
            "default_language": "ru"
        })
        return settings
    
    def start_account_creation(self, params):
        """Startet die VK-Account-Erstellung."""
        logger.info(f"Starte VK Account-Erstellung mit Parametern: {params}")
        
        # Validiere Eingaben
        is_valid, error_msg = self.validate_inputs(params)
        if not is_valid:
            self.get_generator_tab().show_error(error_msg)
            return
        
        # UI aktualisieren
        generator_tab = self.get_generator_tab()
        generator_tab.set_running(True)
        generator_tab.clear_log()
        generator_tab.set_progress(0)
        
        # Schmiedeanimation-Dialog erstellen und anzeigen
        from views.widgets.forge_animation_widget import ForgeAnimationDialog
        parent_widget = generator_tab.window()
        self.forge_dialog = ForgeAnimationDialog(parent_widget, "VK")
        self.forge_dialog.cancel_clicked.connect(self.stop_account_creation)
        self.forge_dialog.closed.connect(self.stop_account_creation)
        
        # Fensterposition vom Hauptfenster holen
        if parent_widget:
            window_pos = parent_widget.pos()
            params["window_position"] = (window_pos.x(), window_pos.y())
        
        # Fingerprint generieren
        try:
            from infrastructure.services.fingerprint.fingerprint_generator_service import FingerprintGeneratorService
            from domain.entities.browser_fingerprint import BrowserFingerprint
            import uuid
            
            fingerprint_service = FingerprintGeneratorService()
            fingerprint_data = fingerprint_service.generate_fingerprint()
            
            fingerprint = BrowserFingerprint.from_dict(fingerprint_data)
            fingerprint.fingerprint_id = str(uuid.uuid4())
            fingerprint.account_bound = True
            fingerprint.rotation_seed = str(uuid.uuid4())
            
            params["fingerprint"] = fingerprint.to_dict()
            logger.info(f"Fingerprint für VK Account-Erstellung generiert: {fingerprint.fingerprint_id}")
        except Exception as e:
            logger.error(f"Fehler beim Generieren des Fingerprints: {e}")
        
        # Worker-Thread starten
        session_controller = getattr(self, 'session_controller', None)
        generator_tab_ref = generator_tab if hasattr(generator_tab, 'store_created_account') else None
        
        self.worker_thread = VKWorkerThread(
            params,
            session_controller=session_controller,
            generator_tab=generator_tab_ref
        )
        
        # Signals verbinden
        self.worker_thread.update_signal.connect(self.forge_dialog.set_status)
        self.worker_thread.log_signal.connect(self.forge_dialog.add_log)
        self.worker_thread.error_signal.connect(self._handle_error)
        self.worker_thread.finished_signal.connect(self._handle_finished)
        self.worker_thread.progress_signal.connect(self.forge_dialog.set_progress)
        
        # Auch an Generator-Tab
        self.worker_thread.log_signal.connect(lambda msg: generator_tab.add_log(msg))
        self.worker_thread.progress_signal.connect(lambda value: generator_tab.set_progress(value))
        
        self.worker_thread.start()
        
        # Dialog anzeigen
        self.forge_dialog.start_animation()
        self.forge_dialog.show()