"""
Unit-Tests für GeneratorTabFactory.
Validiert die Factory-Implementierung und plattform-spezifische Tab-Erstellung.
"""

import unittest
import sys
import os
from unittest.mock import MagicMock, patch

# Füge Projekt-Root zum Path hinzu
sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))

from PyQt5.QtWidgets import QApplication, QWidget
from views.tabs.generator_tab_factory import GeneratorTabFactory, create_generator_tab
from views.tabs.generator_tab import GeneratorTab


class TestGeneratorTabFactory(unittest.TestCase):
    """
    Test-Suite für GeneratorTabFactory.
    """
    
    @classmethod
    def setUpClass(cls):
        """Erstelle QApplication für Qt-Widgets."""
        if not QApplication.instance():
            cls.app = QApplication([])
        else:
            cls.app = QApplication.instance()
    
    def setUp(self):
        """Setup vor jedem Test."""
        # Registry zurücksetzen
        GeneratorTabFactory.clear_registry()
        self.language_manager = MagicMock()
    
    def test_create_generic_tab_for_unknown_platform(self):
        """Test: Factory erstellt generischen Tab für unbekannte Plattform."""
        tab = GeneratorTabFactory.create_tab("unknown_platform", self.language_manager)
        
        self.assertIsInstance(tab, QWidget)
        self.assertIsInstance(tab, GeneratorTab)
    
    def test_create_facebook_tab(self):
        """Test: Factory erstellt FacebookGeneratorTab für Facebook."""
        tab = GeneratorTabFactory.create_tab("facebook", self.language_manager)
        
        self.assertIsInstance(tab, QWidget)
        # Prüfe ob es der Facebook-spezifische Tab ist
        # FacebookGeneratorTab hat gender_male, gender_female, gender_custom Attribute
        self.assertTrue(hasattr(tab, 'gender_male'), "Facebook-Tab sollte gender_male haben")
        self.assertTrue(hasattr(tab, 'gender_female'), "Facebook-Tab sollte gender_female haben")
        self.assertTrue(hasattr(tab, 'gender_custom'), "Facebook-Tab sollte gender_custom haben")
    
    def test_case_insensitive_platform_names(self):
        """Test: Plattform-Namen sind case-insensitive."""
        tab1 = GeneratorTabFactory.create_tab("FACEBOOK", self.language_manager)
        tab2 = GeneratorTabFactory.create_tab("Facebook", self.language_manager)
        tab3 = GeneratorTabFactory.create_tab("facebook", self.language_manager)
        
        # Alle sollten Facebook-Tabs sein
        for tab in [tab1, tab2, tab3]:
            self.assertTrue(hasattr(tab, 'gender_male'))
    
    def test_registry_functionality(self):
        """Test: Tab-Registry funktioniert korrekt."""
        # Erstelle Mock-Tab-Klasse
        class MockTab(QWidget):
            def __init__(self, platform, language_manager):
                super().__init__()
                self.platform = platform
                self.language_manager = language_manager
        
        # Registriere Mock-Tab
        GeneratorTabFactory.register_tab("test_platform", MockTab)
        
        # Erstelle Tab
        tab = GeneratorTabFactory.create_tab("test_platform", self.language_manager)
        
        self.assertIsInstance(tab, MockTab)
        self.assertEqual(tab.platform, "test_platform")
    
    def test_lazy_loading(self):
        """Test: Tabs werden lazy geladen."""
        # Registry sollte initial leer sein
        self.assertEqual(len(GeneratorTabFactory._tab_registry), 0)
        
        # Erstelle Facebook-Tab
        tab = GeneratorTabFactory.create_tab("facebook", self.language_manager)
        
        # Jetzt sollte Facebook in Registry sein
        self.assertIn("facebook", GeneratorTabFactory._tab_registry)
    
    def test_get_supported_platforms(self):
        """Test: Liste der unterstützten Plattformen."""
        platforms = GeneratorTabFactory.get_supported_platforms()
        
        # Sollte bekannte Plattformen enthalten
        self.assertIn("facebook", platforms)
        self.assertIn("instagram", platforms)
        self.assertIn("tiktok", platforms)
        self.assertIn("x", platforms)
    
    def test_is_platform_supported(self):
        """Test: Plattform-Support-Prüfung."""
        self.assertTrue(GeneratorTabFactory.is_platform_supported("facebook"))
        self.assertTrue(GeneratorTabFactory.is_platform_supported("FACEBOOK"))
        self.assertFalse(GeneratorTabFactory.is_platform_supported("unknown"))
    
    def test_convenience_function(self):
        """Test: Convenience-Funktion create_generator_tab."""
        tab = create_generator_tab("facebook", self.language_manager)
        
        self.assertIsInstance(tab, QWidget)
        self.assertTrue(hasattr(tab, 'gender_male'))
    
    def test_error_handling_fallback(self):
        """Test: Factory fällt auf generischen Tab zurück bei Fehlern."""
        # Simuliere einen Fehler beim Tab-Erstellen
        with patch('views.tabs.facebook_generator_tab.FacebookGeneratorTab.__init__',
                  side_effect=Exception("Test error")):
            
            tab = GeneratorTabFactory.create_tab("facebook", self.language_manager)
            
            # Sollte auf generischen Tab zurückfallen
            self.assertIsInstance(tab, GeneratorTab)
    
    def test_signal_compatibility(self):
        """Test: Alle Tabs haben die erforderlichen Signale."""
        platforms = ["facebook", "instagram", "tiktok", "x"]
        
        for platform in platforms:
            tab = GeneratorTabFactory.create_tab(platform, self.language_manager)
            
            # Prüfe erforderliche Signale
            self.assertTrue(hasattr(tab, 'start_requested'), 
                          f"{platform}-Tab sollte start_requested Signal haben")
            self.assertTrue(hasattr(tab, 'stop_requested'),
                          f"{platform}-Tab sollte stop_requested Signal haben")
            self.assertTrue(hasattr(tab, 'account_created'),
                          f"{platform}-Tab sollte account_created Signal haben")
    
    def tearDown(self):
        """Cleanup nach jedem Test."""
        GeneratorTabFactory.clear_registry()


if __name__ == '__main__':
    unittest.main()