"""
Factory Pattern für die Erstellung plattform-spezifischer Generator-Tabs.
Clean Architecture Implementation für erweiterbare Tab-Generierung.
"""

import logging
from typing import Optional, Dict, Type
from PyQt5.QtWidgets import QWidget

# Base imports
from views.tabs.generator_tab import GeneratorTab

logger = logging.getLogger("generator_tab_factory")


class GeneratorTabFactory:
    """
    Factory-Klasse zur Erstellung plattform-spezifischer Generator-Tabs.
    
    Diese Factory verwendet das Strategy Pattern intern, um verschiedene
    Tab-Implementierungen basierend auf der Plattform zu erstellen.
    Neue Plattformen können einfach durch Hinzufügen zur Registry erweitert werden.
    """
    
    # Registry für plattform-spezifische Tabs
    # Key: Plattform-Name (lowercase), Value: Tab-Klasse
    _tab_registry: Dict[str, Type[QWidget]] = {}
    
    @classmethod
    def register_tab(cls, platform: str, tab_class: Type[QWidget]) -> None:
        """
        Registriert eine Tab-Klasse für eine bestimmte Plattform.
        
        Args:
            platform: Name der Plattform (wird zu lowercase konvertiert)
            tab_class: Die Tab-Klasse für diese Plattform
        """
        platform_lower = platform.lower()
        cls._tab_registry[platform_lower] = tab_class
        logger.info(f"Tab-Klasse {tab_class.__name__} für Plattform '{platform}' registriert")
    
    @classmethod
    def create_tab(cls, platform: str, language_manager: Optional[object] = None) -> QWidget:
        """
        Erstellt einen Generator-Tab für die angegebene Plattform.
        
        Diese Methode verwendet Lazy Loading für plattform-spezifische Tabs,
        um zirkuläre Imports zu vermeiden und die Performance zu optimieren.
        
        Args:
            platform: Name der Plattform
            language_manager: Optionaler Language Manager für Internationalisierung
            
        Returns:
            QWidget: Der erstellte Generator-Tab
            
        Raises:
            ValueError: Wenn die Plattform nicht unterstützt wird
        """
        platform_lower = platform.lower()
        
        # Lazy Loading und Registrierung für bekannte Plattformen
        if platform_lower not in cls._tab_registry:
            cls._lazy_load_platform_tab(platform_lower)
        
        # Tab-Klasse aus Registry holen
        tab_class = cls._tab_registry.get(platform_lower)
        
        if tab_class:
            logger.info(f"Erstelle {tab_class.__name__} für Plattform '{platform}'")
            try:
                return tab_class(platform, language_manager)
            except Exception as e:
                logger.error(f"Fehler beim Erstellen des Tabs für '{platform}': {e}")
                logger.info(f"Fallback auf generischen GeneratorTab für '{platform}'")
                return GeneratorTab(platform, language_manager)
        else:
            # Fallback auf generischen Tab
            logger.info(f"Verwende generischen GeneratorTab für Plattform '{platform}'")
            return GeneratorTab(platform, language_manager)
    
    @classmethod
    def _lazy_load_platform_tab(cls, platform: str) -> None:
        """
        Lädt plattform-spezifische Tab-Klassen lazy (bei Bedarf).
        
        Dies vermeidet zirkuläre Imports und verbessert die Startzeit,
        indem nur benötigte Module geladen werden.
        
        Args:
            platform: Name der Plattform (lowercase)
        """
        try:
            if platform == "facebook":
                from views.tabs.facebook_generator_tab import FacebookGeneratorTab
                cls.register_tab("facebook", FacebookGeneratorTab)
                
            elif platform == "instagram":
                # Instagram verwendet möglicherweise einen spezifischen Tab
                # Vorerst den generischen Tab verwenden
                cls.register_tab("instagram", GeneratorTab)
                
            elif platform == "tiktok":
                # TikTok könnte einen eigenen Tab haben
                # Prüfe ob TikTokGeneratorTab existiert
                try:
                    from views.tabs.tiktok_generator_tab import TikTokGeneratorTab
                    cls.register_tab("tiktok", TikTokGeneratorTab)
                except ImportError:
                    # Fallback auf generischen Tab
                    cls.register_tab("tiktok", GeneratorTab)
                    
            elif platform == "x":
                # X (Twitter) Tab
                try:
                    from views.tabs.x_generator_tab import XGeneratorTab
                    cls.register_tab("x", XGeneratorTab)
                except ImportError:
                    cls.register_tab("x", GeneratorTab)
                    
            else:
                # Unbekannte Plattform - verwende generischen Tab
                cls.register_tab(platform, GeneratorTab)
                
        except ImportError as e:
            logger.warning(f"Konnte spezifischen Tab für '{platform}' nicht laden: {e}")
            # Registriere generischen Tab als Fallback
            cls.register_tab(platform, GeneratorTab)
    
    @classmethod
    def get_supported_platforms(cls) -> list:
        """
        Gibt eine Liste der unterstützten Plattformen zurück.
        
        Returns:
            list: Liste der Plattform-Namen
        """
        # Bekannte Plattformen, die lazy geladen werden können
        known_platforms = ["facebook", "instagram", "tiktok", "x"]
        
        # Bereits registrierte Plattformen hinzufügen
        registered = list(cls._tab_registry.keys())
        
        # Kombiniere und entferne Duplikate
        all_platforms = list(set(known_platforms + registered))
        all_platforms.sort()
        
        return all_platforms
    
    @classmethod
    def is_platform_supported(cls, platform: str) -> bool:
        """
        Prüft, ob eine Plattform unterstützt wird.
        
        Args:
            platform: Name der Plattform
            
        Returns:
            bool: True wenn unterstützt, sonst False
        """
        return platform.lower() in cls.get_supported_platforms()
    
    @classmethod
    def clear_registry(cls) -> None:
        """
        Löscht die Tab-Registry.
        Hauptsächlich für Tests und Cleanup.
        """
        cls._tab_registry.clear()
        logger.debug("Tab-Registry gelöscht")


# Convenience-Funktion für direkten Import
def create_generator_tab(platform: str, language_manager: Optional[object] = None) -> QWidget:
    """
    Convenience-Funktion zum Erstellen eines Generator-Tabs.
    
    Args:
        platform: Name der Plattform
        language_manager: Optionaler Language Manager
        
    Returns:
        QWidget: Der erstellte Generator-Tab
    """
    return GeneratorTabFactory.create_tab(platform, language_manager)