# Path: views/platform_selector.py

"""
Plattformauswahl-Widget mit Tab-Navigation für die Social Media Account Generator Anwendung.
"""

from PyQt5.QtWidgets import QWidget, QVBoxLayout, QStackedWidget
from PyQt5.QtCore import pyqtSignal

from views.components.tab_navigation import TabNavigation
from views.components.platform_grid_view import PlatformGridView
from views.components.accounts_overview_view import AccountsOverviewView
from views.widgets.language_dropdown import LanguageDropdown


class PlatformSelector(QWidget):
    """Widget zur Auswahl der Plattform mit Tab-Navigation."""

    # Signal wird ausgelöst, wenn eine Plattform ausgewählt wird
    platform_selected = pyqtSignal(str)
    
    # Neue Signals für Account-Aktionen
    login_requested = pyqtSignal(dict)
    export_requested = pyqtSignal(dict)

    def __init__(self, language_manager=None, db_manager=None):
        super().__init__()
        self.language_manager = language_manager
        self.db_manager = db_manager
        self.accounts_tab = None  # Für Kompatibilität
        self.init_ui()
        
        if self.language_manager:
            self.language_manager.language_changed.connect(self.update_texts)
            self.update_texts()

    def init_ui(self):
        """Initialisiert die Benutzeroberfläche mit Tab-Navigation."""
        # Hauptlayout
        main_layout = QVBoxLayout(self)
        main_layout.setContentsMargins(0, 0, 0, 0)
        main_layout.setSpacing(0)
        
        # Tab Navigation
        self.tab_navigation = TabNavigation(self.language_manager)
        self.tab_navigation.tab_changed.connect(self._on_tab_changed)
        main_layout.addWidget(self.tab_navigation)
        
        # Content Container mit gestapelten Widgets
        self.content_stack = QStackedWidget()
        self.content_stack.setObjectName("content_stack")  # For QSS targeting, no inline styles!
        
        # Platform Grid View (Tab 0)
        self.platform_grid = PlatformGridView(self.language_manager)
        self.platform_grid.platform_selected.connect(self.platform_selected.emit)
        self.content_stack.addWidget(self.platform_grid)
        
        # Accounts Overview View (Tab 1)
        self.accounts_overview = AccountsOverviewView(self.db_manager, self.language_manager)
        self.accounts_overview.account_login_requested.connect(self._on_login_requested)
        self.accounts_overview.account_export_requested.connect(self._on_export_requested)
        self.accounts_overview.account_delete_requested.connect(self._on_delete_requested)
        self.content_stack.addWidget(self.accounts_overview)
        
        # Für Kompatibilität mit MainController - accounts_tab Referenz
        self.accounts_tab = self.accounts_overview
        
        main_layout.addWidget(self.content_stack)
        
        # Initial Tab setzen
        self.content_stack.setCurrentIndex(0)
        
        # Account-Anzahl initial laden
        self._update_account_count()

    def _on_tab_changed(self, index):
        """Behandelt Tab-Wechsel."""
        self.content_stack.setCurrentIndex(index)
        
        # Lade Accounts neu wenn Accounts-Tab ausgewählt wird
        if index == 1:
            self.load_accounts()

    def load_accounts(self):
        """Lädt die Konten in der Übersicht neu."""
        self.accounts_overview.load_accounts()
        self._update_account_count()

    def _update_account_count(self):
        """Aktualisiert die Account-Anzahl im Tab-Badge."""
        if self.db_manager:
            try:
                accounts = self.db_manager.get_all_accounts()
                self.tab_navigation.update_account_count(len(accounts))
            except:
                self.tab_navigation.update_account_count(0)

    def _on_login_requested(self, account_data):
        """Behandelt Login-Anfragen von Account-Karten."""
        self.login_requested.emit(account_data)

    def _on_export_requested(self, account_data):
        """Behandelt Export-Anfragen von Account-Karten."""
        # Für einzelne Account-Exports
        if hasattr(self, 'export_requested'):
            self.export_requested.emit([account_data])
        else:
            # Fallback: Direkter Export
            from controllers.account_controller import AccountController
            if self.db_manager:
                controller = AccountController(self.db_manager)
                controller.set_parent_view(self)
                controller.export_accounts(None, [account_data])

    def _on_delete_requested(self, account_data):
        """Behandelt Delete-Anfragen von Account-Karten."""
        if self.db_manager:
            try:
                # Lösche den Account aus der Datenbank
                self.db_manager.delete_account(account_data.get("id"))
                # Lade die Accounts neu
                self.load_accounts()
            except Exception as e:
                print(f"Fehler beim Löschen des Accounts: {e}")

    def update_texts(self):
        """Aktualisiert die Texte gemäß der aktuellen Sprache."""
        # Die Komponenten aktualisieren ihre Texte selbst
        pass