gui.py

"""
gui.py – Erweiterte GUI für MediaBrain
- Sidebar Navigation
- Globale Suche
- Favoriten-Ansicht
- Einstellungen-Fenster
- Verbesserte MediaItemWidgets
"""

import logging

logger = logging.getLogger(__name__)

from PySide6.QtWidgets import (
    QApplication, QMainWindow, QWidget, QVBoxLayout, QHBoxLayout,
    QLabel, QListWidget, QListWidgetItem, QPushButton, QLineEdit,
    QStackedWidget, QMenu, QScrollArea, QFrame, QSplitter, QTabWidget,
    QComboBox, QCheckBox, QSystemTrayIcon
)
from PySide6.QtCore import Qt, QSize
from PySide6.QtGui import QAction, QIcon, QPixmap, QFont as QGuiFont, QColor as QGuiColor, QPainter as QGuiPainter

from core import MediaManager, MediaItem, BlacklistManager, TagManager
import config
from pathlib import Path
from theme_engine import ThemeEngine

# Erweiterte Suche
from search_advanced import AdvancedSearchBar, SearchEngine, SearchCriteria

# Global theme engine instance
_theme_engine = ThemeEngine()

# Tag-Manager Referenz (wird von MainWindow gesetzt, damit alle Views darauf zugreifen koennen)
_tag_manager: TagManager = None


def get_tag_manager() -> TagManager:
    """Returns the global TagManager instance."""
    return _tag_manager

def notify_gui_refresh():
    """Benachrichtigt die GUI über Änderungen, ohne MediaBrain.py zu importieren (verhindert Circular Import)."""
    mw = QApplication.activeWindow()
    # Falls das aktive Fenster nicht das MainWindow ist (z.B. ein Dialog),
    # suchen wir in allen Top-Level-Widgets
    if not mw or not hasattr(mw, "refresh_all_views"):
        for widget in QApplication.topLevelWidgets():
            if hasattr(widget, "refresh_all_views"):
                mw = widget
                break

    if mw and hasattr(mw, "refresh_all_views"):
        mw.refresh_all_views()


# ============================================================
# 1. Suchleiste
# ============================================================

class SearchBar(QWidget):
    def __init__(self, placeholder="Suchen...", on_search=None):
        super().__init__()
        self.on_search = on_search

        layout = QHBoxLayout()
        self.setLayout(layout)

        self.input = QLineEdit()
        self.input.setPlaceholderText(placeholder)
        self.input.textChanged.connect(self._trigger_search)

        layout.addWidget(self.input)

    def _trigger_search(self):
        if self.on_search:
            self.on_search(self.input.text())


# ============================================================
# 2. Collapsible Panel
# ============================================================

class CollapsiblePanel(QWidget):
    def __init__(self, title="Details", content_widget=None):
        super().__init__()

        self.is_open = False
        self._title = title

        self.main_layout = QVBoxLayout()
        self.setLayout(self.main_layout)

        self.header = QPushButton(f"\u25B6  {title}")
        self.header.setCheckable(True)
        self.header.setStyleSheet("text-align: left; font-size: 14px; padding: 6px 12px;")
        self.header.clicked.connect(self.toggle)
        self.main_layout.addWidget(self.header)

        self.content = content_widget or QLabel("Keine Details verfügbar")
        self.content.setVisible(False)
        self.main_layout.addWidget(self.content)

    def toggle(self):
        self.is_open = not self.is_open
        self.content.setVisible(self.is_open)
        arrow = "\u25BC" if self.is_open else "\u25B6"
        self.header.setText(f"{arrow}  {self._title}")


# ============================================================
# 3. MediaItemWidget (verbessert)
# ============================================================

class MediaItemWidget(QFrame):
    def __init__(self, item: MediaItem, media_manager: MediaManager, blacklist_manager: BlacklistManager):
        super().__init__()
        self.item = item
        self.media_manager = media_manager
        self.blacklist_manager = blacklist_manager

        self.setFrameStyle(QFrame.Shape.StyledPanel | QFrame.Shadow.Plain)
        # Styling handled by central QSS theme

        layout = QHBoxLayout()
        layout.setContentsMargins(6, 4, 6, 4)
        layout.setSpacing(8)
        self.setLayout(layout)

        # Icon
        type_icons = {"movie": "🎬", "music": "🎵", "series": "📺", "clip": "🎞"}
        icon_text = type_icons.get(item.type, "📄")
        icon = QLabel(icon_text)
        icon.setFixedSize(QSize(28, 28))
        icon.setAlignment(Qt.AlignmentFlag.AlignCenter)
        icon.setStyleSheet("font-size: 16px;")
        layout.addWidget(icon)

        # Titel + Source
        title_label = QLabel(f"<b>{item.title}</b>  <span style='color: gray; font-size: 11px;'>({item.source})</span>")
        title_label.setTextFormat(Qt.TextFormat.RichText)
        title_label.setWordWrap(True)
        layout.addWidget(title_label, 1)

        # Buttons kompakt
        fav_btn = QPushButton("\u2605" if item.is_favorite else "\u2606")
        fav_btn.setFixedSize(QSize(40, 40))
        fav_btn.setToolTip("Favorit entfernen" if item.is_favorite else "Als Favorit markieren")
        fav_color = "#FFC107" if item.is_favorite else "#888888"
        fav_btn.setStyleSheet(f"font-size: 24px; color: {fav_color}; border: none; background: transparent; padding: 0px;")
        fav_btn.clicked.connect(self.toggle_favorite)
        layout.addWidget(fav_btn)

        open_btn = QPushButton("\u25B6 Oeffnen")
        open_btn.setFixedHeight(30)
        open_btn.clicked.connect(self.open_item)
        layout.addWidget(open_btn)

        details_btn = QPushButton("\u2139 Details")
        details_btn.setFixedHeight(30)
        details_btn.clicked.connect(self.open_detail_page)
        layout.addWidget(details_btn)

        # Kontextmenü
        self.setContextMenuPolicy(Qt.ContextMenuPolicy.CustomContextMenu)
        self.customContextMenuRequested.connect(self.open_context_menu)

    def open_item(self):
        try:
            from core import OpenHandler
            handler = OpenHandler(self.media_manager)
            handler.open_item(self.item)
        except Exception as e:
            from PySide6.QtWidgets import QMessageBox
            QMessageBox.warning(self, "Fehler", f"Konnte Medium nicht oeffnen: {e}")

    def open_detail_page(self):
        try:
            from gui import MainWindow
            mw = QApplication.activeWindow()
            if hasattr(mw, "open_detail"):
                mw.open_detail(self.item)
        except Exception as e:
            from PySide6.QtWidgets import QMessageBox
            QMessageBox.warning(self, "Fehler", f"Detailseite konnte nicht geoeffnet werden: {e}")

    def toggle_favorite(self):
        try:
            new_value = 0 if self.item.is_favorite else 1
            self.media_manager.db.execute(
                "UPDATE media_items SET is_favorite = ? WHERE id = ?",
                (new_value, self.item.id)
            )
            notify_gui_refresh()
        except Exception as e:
            from PySide6.QtWidgets import QMessageBox
            QMessageBox.warning(self, "Fehler", f"Favorit konnte nicht geaendert werden: {e}")


    def toggle_details(self):
        self.details_panel.toggle()
    def show_in_explorer(self):
        try:
            import subprocess, platform, os
            path = self.item.local_path

            system = platform.system()
            if system == "Windows":
                subprocess.Popen(["explorer", "/select,", path])
            elif system == "Darwin":
                subprocess.Popen(["open", "-R", path])
            else:
                folder = os.path.dirname(path)
                subprocess.Popen(["xdg-open", folder])
        except Exception as e:
            from PySide6.QtWidgets import QMessageBox
            QMessageBox.warning(self, "Fehler", f"Konnte Datei nicht im Explorer anzeigen: {e}")

    def delete_file(self):
        try:
            from PySide6.QtWidgets import QMessageBox
            import os

            reply = QMessageBox.question(
                self, "Datei loeschen",
                f"Soll die Datei wirklich unwiderruflich geloescht werden?\n\n{self.item.local_path}",
                QMessageBox.StandardButton.Yes | QMessageBox.StandardButton.No,
                QMessageBox.StandardButton.No
            )
            if reply != QMessageBox.StandardButton.Yes:
                return

            if os.path.exists(self.item.local_path):
                os.remove(self.item.local_path)

            self.media_manager.db.execute(
                "DELETE FROM media_items WHERE id = ?",
                (self.item.id,)
            )
            notify_gui_refresh()
        except Exception as e:
            from PySide6.QtWidgets import QMessageBox
            QMessageBox.warning(self, "Fehler", f"Datei konnte nicht geloescht werden: {e}")

    def refresh_metadata(self):
        # Später: ID3/MP4 neu einlesen
        logger.debug("[Meta] Metadaten aktualisieren (noch nicht implementiert)")

    def open_context_menu(self, pos):
        menu = QMenu(self)

        fav_action = QAction("Favorit entfernen" if self.item.is_favorite else "Als Favorit markieren")
        fav_action.triggered.connect(self.toggle_favorite)
        menu.addAction(fav_action)

        temp_delete_action = QAction("Temporär ausblenden")
        temp_delete_action.triggered.connect(self.temp_delete)
        menu.addAction(temp_delete_action)

        blacklist_menu = menu.addMenu("Blacklist…")
        for code, label in [
            (1, "1 Tag"),
            (2, "1 Woche"),
            (3, "1 Monat"),
            (4, "3 Monate"),
            (5, "1 Jahr"),
            (6, "Für immer")
        ]:
            act = QAction(label)
            act.triggered.connect(lambda _, c=code: self.blacklist(c))
            blacklist_menu.addAction(act)

        if self.item.blacklist_flag == 1:
            unblack = QAction("Blacklist entfernen")
            unblack.triggered.connect(lambda: (self.blacklist_manager.set_blacklist(self.item.id, False), notify_gui_refresh()))
            menu.addAction(unblack)

        menu.addSeparator()

        # Datei-Aktionen (nur für lokale Dateien)
        if self.item.is_local_file:
            show_action = QAction("Im Explorer anzeigen")
            show_action.triggered.connect(self.show_in_explorer)
            menu.addAction(show_action)

            if config.config.get("allow_file_deletion"):
                delete_action = QAction("Datei löschen")
                delete_action.triggered.connect(self.delete_file)
                menu.addAction(delete_action)

            meta_action = QAction("Lokale Metadaten aktualisieren")
            meta_action.triggered.connect(self.refresh_metadata)
            menu.addAction(meta_action)

        # Online-Metadaten abrufen (NEU!)
        online_meta_action = QAction("🌐 Online-Metadaten abrufen")
        online_meta_action.triggered.connect(self.fetch_online_metadata)
        menu.addAction(online_meta_action)

        menu.exec(self.mapToGlobal(pos))

    def temp_delete(self):
        try:
            from datetime import datetime
            self.media_manager.db.execute(
                "UPDATE media_items SET blacklist_flag = 1, procedure_code = 1, blacklisted_at = ? WHERE id = ?",
                (datetime.now().isoformat(), self.item.id)
            )
            notify_gui_refresh()
        except Exception as e:
            from PySide6.QtWidgets import QMessageBox
            QMessageBox.warning(self, "Fehler", f"Temporaeres Ausblenden fehlgeschlagen: {e}")

    def blacklist(self, code):
        try:
            self.blacklist_manager.set_blacklist(self.item.id, True, code)
            notify_gui_refresh()
        except Exception as e:
            from PySide6.QtWidgets import QMessageBox
            QMessageBox.warning(self, "Fehler", f"Blacklist-Aktion fehlgeschlagen: {e}")

    def fetch_online_metadata(self):
        """Holt Online-Metadaten von TMDb/OMDb/MusicBrainz und aktualisiert den DB-Eintrag."""
        from metadata_v2 import MetadataFetcher
        from PySide6.QtWidgets import QMessageBox

        try:
            fetcher = MetadataFetcher()

            # Status prüfen
            status = fetcher.get_status()
            if not any(status.values()):
                QMessageBox.warning(self, "API nicht verfügbar",
                    "Keine API-Keys konfiguriert. Bitte in settings.json eintragen.")
                return

            # Metadaten basierend auf Typ abrufen
            result = fetcher.auto_fetch(
                title=self.item.title,
                media_type=self.item.type,
                year=getattr(self.item, 'year', None),
                artist=getattr(self.item, 'artist', None)
            )

            if not result:
                QMessageBox.information(self, "Keine Ergebnisse",
                    f"Keine Online-Metadaten gefunden für '{self.item.title}'")
                return

            # Datenbank aktualisieren
            updates = []
            params = []

            if result.get("description") and result["description"] != self.item.description:
                updates.append("description = ?")
                params.append(result["description"])

            if result.get("thumbnail_url"):
                updates.append("thumbnail_url = ?")
                params.append(result["thumbnail_url"])

            if result.get("rating"):
                updates.append("rating = ?")
                params.append(result["rating"])

            if updates:
                params.append(self.item.id)
                query = f"UPDATE media_items SET {', '.join(updates)} WHERE id = ?"
                self.media_manager.db.execute(query, tuple(params))

                QMessageBox.information(self, "Metadaten aktualisiert",
                    f"Metadaten für '{result.get('title', self.item.title)}' wurden aktualisiert.\n"
                    f"Quelle: {result.get('source', 'unbekannt')}")

                # GUI aktualisieren
                notify_gui_refresh()
            else:
                QMessageBox.information(self, "Keine neuen Daten",
                    "Die gefundenen Metadaten sind bereits identisch.")
        except Exception as e:
            QMessageBox.critical(self, "Fehler",
                f"Metadaten konnten nicht abgerufen werden: {e}")


# Duplikat blacklist() entfernt - existiert bereits in Zeile 285 mit Error-Handling


from PySide6.QtCore import QAbstractListModel, Qt, QModelIndex, QRect
from PySide6.QtWidgets import QListView, QMenu, QStyledItemDelegate, QStyle
from PySide6.QtGui import QPainter, QFont, QColor, QPen, QFontMetrics

# --- 1. Das Daten-Modell (Hält die Daten effizient im Speicher) ---
class MediaListModel(QAbstractListModel):
    """Model for virtualized media item lists.

    Stores MediaItem objects and exposes them via Qt roles.
    Supports efficient bulk-updates via beginResetModel/endResetModel.
    """
    def __init__(self, media_items=None):
        super().__init__()
        self.media_items = media_items or []

    def data(self, index, role):
        if not index.isValid() or index.row() >= len(self.media_items):
            return None

        item = self.media_items[index.row()]

        if role == Qt.ItemDataRole.DisplayRole:
            fav_mark = "★ " if item.is_favorite else ""
            return f"{fav_mark}{item.title} ({item.source})"

        if role == Qt.ItemDataRole.ToolTipRole:
            desc = item.description or ""
            tags_str = ""
            tm = get_tag_manager()
            if tm:
                tags = tm.get_tags_for_media(item.id)
                if tags:
                    tags_str = "\nTags: " + ", ".join(t["name"] for t in tags)
            return f"{desc}\nQuelle: {item.source}{tags_str}"

        if role == Qt.ItemDataRole.UserRole:
            return item

        return None

    def rowCount(self, index=QModelIndex()):
        return len(self.media_items)

    def update_data(self, new_items):
        """Replaces the entire dataset efficiently."""
        self.beginResetModel()
        self.media_items = new_items
        self.endResetModel()


# --- 1b. Custom Delegate fuer reichere Darstellung ---
class MediaItemDelegate(QStyledItemDelegate):
    """Paints media items with icon, title, source, and tag chips.

    Replaces the old approach of creating individual QFrame widgets
    per item. Qt only creates delegate instances for visible rows,
    so this scales to thousands of items without slowdown.
    """

    TYPE_ICONS = {
        "movie": "\U0001f3ac", "music": "\U0001f3b5",
        "series": "\U0001f4fa", "clip": "\U0001f39e",
        "podcast": "\U0001f399", "audiobook": "\U0001f4da",
        "document": "\U0001f4c4", "file": "\U0001f4c4",
    }

    ROW_HEIGHT = 52

    def __init__(self, parent=None):
        super().__init__(parent)
        self._tag_cache = {}  # media_id -> list of tag dicts

    def invalidate_tag_cache(self):
        """Clears the tag cache. Call after tag changes."""
        self._tag_cache.clear()

    def _get_tags(self, media_id):
        """Lazy-loads tags for a media item with caching."""
        if media_id not in self._tag_cache:
            tm = get_tag_manager()
            if tm:
                self._tag_cache[media_id] = tm.get_tags_for_media(media_id)
            else:
                self._tag_cache[media_id] = []
        return self._tag_cache[media_id]

    def sizeHint(self, option, index):
        return option.rect.size() if option.rect.height() >= self.ROW_HEIGHT else \
            QSize(option.rect.width(), self.ROW_HEIGHT)

    def paint(self, painter: QPainter, option, index):
        painter.save()

        item = index.data(Qt.ItemDataRole.UserRole)
        if not item:
            super().paint(painter, option, index)
            painter.restore()
            return

        # Background (selection / alternating)
        if option.state & QStyle.StateFlag.State_Selected:
            painter.fillRect(option.rect, option.palette.highlight())
            text_color = option.palette.highlightedText().color()
        else:
            if index.row() % 2 == 1:
                painter.fillRect(option.rect, option.palette.alternateBase())
            text_color = option.palette.text().color()

        rect = option.rect.adjusted(6, 4, -6, -4)
        x = rect.x()
        y = rect.y()

        # Icon
        icon_text = self.TYPE_ICONS.get(item.type, "\U0001f4c4")
        icon_font = QFont(painter.font())
        icon_font.setPointSize(14)
        painter.setFont(icon_font)
        painter.setPen(QPen(text_color))
        painter.drawText(x, y, 24, rect.height(), Qt.AlignmentFlag.AlignCenter, icon_text)
        x += 30

        # Fav star
        if item.is_favorite:
            fav_font = QFont(painter.font())
            fav_font.setPointSize(15)
            painter.setFont(fav_font)
            painter.setPen(QPen(QColor("#FFC107")))
            painter.drawText(x, y, 22, rect.height(), Qt.AlignmentFlag.AlignCenter, "\u2605")
            x += 26

        # Title (bold)
        title_font = QFont(option.font)
        title_font.setBold(True)
        painter.setFont(title_font)
        painter.setPen(QPen(text_color))
        fm = QFontMetrics(title_font)
        title_text = fm.elidedText(item.title or "Unbekannt", Qt.TextElideMode.ElideRight, rect.width() - (x - rect.x()) - 150)
        painter.drawText(x, y, rect.width(), rect.height() // 2, Qt.AlignmentFlag.AlignVCenter, title_text)
        title_width = fm.horizontalAdvance(title_text)

        # Source (gray, smaller)
        source_font = QFont(option.font)
        source_font.setPointSize(max(option.font.pointSize() - 1, 8))
        painter.setFont(source_font)
        painter.setPen(QPen(QColor("#888888")))
        source_text = f"  ({item.source})"
        painter.drawText(x + title_width, y, rect.width(), rect.height() // 2, Qt.AlignmentFlag.AlignVCenter, source_text)

        # Tags (bottom row, small colored chips)
        tags = self._get_tags(item.id)
        if tags:
            tag_font = QFont(option.font)
            tag_font.setPointSize(max(option.font.pointSize() - 2, 7))
            painter.setFont(tag_font)
            tag_x = x
            tag_y = y + rect.height() // 2 + 2
            tag_fm = QFontMetrics(tag_font)

            for tag in tags[:5]:  # Max 5 tags shown
                tag_name = tag["name"]
                tag_color = QColor(tag.get("color", "#607D8B"))
                tw = tag_fm.horizontalAdvance(tag_name) + 10
                th = tag_fm.height() + 4

                if tag_x + tw > rect.right():
                    break

                # Chip background
                chip_rect = QRect(tag_x, tag_y, tw, th)
                painter.setPen(Qt.PenStyle.NoPen)
                light_color = QColor(tag_color)
                light_color.setAlpha(40)
                painter.setBrush(light_color)
                painter.drawRoundedRect(chip_rect, 3, 3)

                # Chip text
                painter.setPen(QPen(tag_color))
                painter.drawText(chip_rect, Qt.AlignmentFlag.AlignCenter, tag_name)

                tag_x += tw + 4

        painter.restore()


# --- Helper: Shared context menu builder for QListView-based views ---
def _build_item_context_menu(parent_widget, item: MediaItem, media_manager, blacklist_manager, refresh_callback):
    """Builds a standard context menu for a media item.

    Used by LibraryView, FavoritesView, GlobalSearchView to avoid code duplication.
    Returns the QMenu (caller must exec it).
    """
    menu = QMenu(parent_widget)

    # Open
    act_open = QAction("Oeffnen", parent_widget)
    act_open.triggered.connect(lambda: _open_media_item(item, media_manager))
    menu.addAction(act_open)

    # Details
    act_details = QAction("Details anzeigen", parent_widget)
    act_details.triggered.connect(lambda: _show_detail(item))
    menu.addAction(act_details)

    menu.addSeparator()

    # Favorite toggle
    fav_text = "Favorit entfernen" if item.is_favorite else "Zu Favoriten"
    act_fav = QAction(fav_text, parent_widget)
    act_fav.triggered.connect(lambda: (_toggle_fav(item, media_manager), refresh_callback()))
    menu.addAction(act_fav)

    # Blacklist submenu
    bl_menu = menu.addMenu("Auf Blacklist setzen")
    for code, label in [(1, "1 Tag"), (2, "1 Woche"), (3, "1 Monat"),
                         (4, "3 Monate"), (5, "1 Jahr"), (6, "Fuer immer")]:
        act = QAction(label, parent_widget)
        act.triggered.connect(lambda _, c=code: (blacklist_manager.set_blacklist(item.id, True, c), refresh_callback()))
        bl_menu.addAction(act)

    if item.blacklist_flag == 1:
        act_unbl = QAction("Blacklist entfernen", parent_widget)
        act_unbl.triggered.connect(lambda: (blacklist_manager.set_blacklist(item.id, False), refresh_callback()))
        menu.addAction(act_unbl)

    # Tags submenu
    tm = get_tag_manager()
    if tm:
        menu.addSeparator()
        tag_menu = menu.addMenu("Tags")
        current_tags = tm.get_tags_for_media(item.id)
        current_tag_ids = {t["id"] for t in current_tags}
        all_tags = tm.list_tags()

        for tag in all_tags:
            act_tag = QAction(tag["name"], parent_widget)
            act_tag.setCheckable(True)
            act_tag.setChecked(tag["id"] in current_tag_ids)
            act_tag.triggered.connect(
                lambda checked, t_id=tag["id"]: (
                    tm.add_tag_to_media(item.id, t_id) if checked
                    else tm.remove_tag_from_media(item.id, t_id),
                    refresh_callback()
                )
            )
            tag_menu.addAction(act_tag)

        if all_tags:
            tag_menu.addSeparator()

        act_new_tag = QAction("+ Neuer Tag...", parent_widget)
        act_new_tag.triggered.connect(lambda: _create_and_assign_tag(parent_widget, item.id, refresh_callback))
        tag_menu.addAction(act_new_tag)

    # Local file actions
    if item.is_local_file:
        menu.addSeparator()
        act_explorer = QAction("Im Explorer anzeigen", parent_widget)
        act_explorer.triggered.connect(lambda: _show_in_explorer(item))
        menu.addAction(act_explorer)

    return menu


def _open_media_item(item, media_manager):
    """Opens a media item via OpenHandler."""
    try:
        from core import OpenHandler
        handler = OpenHandler(media_manager)
        handler.open_item(item)
    except Exception as e:
        logger.error("Could not open item: %s", e)


def _show_detail(item):
    """Opens the detail view for an item."""
    mw = QApplication.activeWindow()
    if hasattr(mw, "open_detail"):
        mw.open_detail(item)


def _toggle_fav(item, media_manager):
    """Toggles favorite status in DB."""
    new_val = 0 if item.is_favorite else 1
    media_manager.db.execute("UPDATE media_items SET is_favorite=? WHERE id=?", (new_val, item.id))


def _show_in_explorer(item):
    """Opens the file location in OS file manager."""
    try:
        import subprocess, platform, os
        path = item.local_path
        system = platform.system()
        if system == "Windows":
            subprocess.Popen(["explorer", "/select,", path])
        elif system == "Darwin":
            subprocess.Popen(["open", "-R", path])
        else:
            subprocess.Popen(["xdg-open", os.path.dirname(path)])
    except Exception as e:
        logger.error("Could not show in explorer: %s", e)


def _create_and_assign_tag(parent_widget, media_id, refresh_callback):
    """Shows an input dialog to create a new tag and assign it to a media item."""
    from PySide6.QtWidgets import QInputDialog
    tm = get_tag_manager()
    if not tm:
        return
    name, ok = QInputDialog.getText(parent_widget, "Neuer Tag", "Tag-Name:")
    if ok and name.strip():
        try:
            tag_id = tm.create_tag(name.strip())
            tm.add_tag_to_media(media_id, tag_id)
            refresh_callback()
        except ValueError as e:
            from PySide6.QtWidgets import QMessageBox
            QMessageBox.warning(parent_widget, "Fehler", str(e))


# --- 2. Die optimierte View (Zeigt die Liste an) ---
class LibraryView(QWidget):
    """Virtualized library view for a specific media type.

    Uses QListView + MediaListModel + MediaItemDelegate for efficient
    rendering of large media collections. Supports search, tag filtering,
    and context menu actions.
    """

    def __init__(self, media_type, media_manager: MediaManager, blacklist_manager: BlacklistManager):
        super().__init__()
        self.media_type = media_type
        self.media_manager = media_manager
        self.blacklist_manager = blacklist_manager
        self._needs_refresh = True

        layout = QVBoxLayout()
        self.setLayout(layout)

        # Search bar
        self.search_bar = AdvancedSearchBar()
        self.search_bar.search_triggered.connect(self.apply_search)
        layout.addWidget(self.search_bar)

        # Tag filter row
        tag_row = QHBoxLayout()
        tag_row.addWidget(QLabel("Tag-Filter:"))
        self.tag_combo = QComboBox()
        self.tag_combo.addItem("Alle", None)
        self.tag_combo.currentIndexChanged.connect(lambda: self.refresh())
        tag_row.addWidget(self.tag_combo, 1)
        layout.addLayout(tag_row)

        # Virtualized list
        self.list_view = QListView()
        self.model = MediaListModel()
        self.delegate = MediaItemDelegate(self)
        self.list_view.setModel(self.model)
        self.list_view.setItemDelegate(self.delegate)
        self.list_view.setAlternatingRowColors(True)
        self.list_view.doubleClicked.connect(self._on_double_click)
        self.list_view.setContextMenuPolicy(Qt.ContextMenuPolicy.CustomContextMenu)
        self.list_view.customContextMenuRequested.connect(self._on_context_menu)
        layout.addWidget(self.list_view)

        self.refresh()

    def _refresh_tag_combo(self):
        """Updates the tag filter combo box with current tags."""
        tm = get_tag_manager()
        if not tm:
            return
        current_data = self.tag_combo.currentData()
        self.tag_combo.blockSignals(True)
        self.tag_combo.clear()
        self.tag_combo.addItem("Alle", None)
        for tag in tm.list_tags():
            self.tag_combo.addItem(f"{tag['name']} ({tag['count']})", tag["id"])
        # Restore selection
        if current_data is not None:
            for i in range(self.tag_combo.count()):
                if self.tag_combo.itemData(i) == current_data:
                    self.tag_combo.setCurrentIndex(i)
                    break
        self.tag_combo.blockSignals(False)

    def refresh(self):
        self._refresh_tag_combo()
        self.delegate.invalidate_tag_cache()
        selected_tag_id = self.tag_combo.currentData()
        tag_ids = [selected_tag_id] if selected_tag_id else None
        items = self.media_manager.list_by_type_with_tags(self.media_type, tag_ids=tag_ids)
        self.model.update_data(items)

    def apply_search(self, criteria: SearchCriteria):
        self.delegate.invalidate_tag_cache()
        engine = SearchEngine(self.media_manager.db)
        criteria.media_type = self.media_type
        results = engine.search(criteria)
        self.model.update_data(results)

    def _on_double_click(self, index):
        item = self.model.data(index, Qt.ItemDataRole.UserRole)
        if item:
            _open_media_item(item, self.media_manager)

    def _on_context_menu(self, pos):
        index = self.list_view.indexAt(pos)
        if not index.isValid():
            return
        item = self.model.data(index, Qt.ItemDataRole.UserRole)
        if not item:
            return
        menu = _build_item_context_menu(self, item, self.media_manager, self.blacklist_manager, self.refresh)
        menu.exec(self.list_view.mapToGlobal(pos))
# ============================================================
# 5. FavoritenView
# ============================================================

class FavoritesView(QWidget):
    """Virtualized favorites view using QListView + Model/Delegate pattern."""

    def __init__(self, media_manager: MediaManager, blacklist_manager: BlacklistManager):
        super().__init__()
        self.media_manager = media_manager
        self.blacklist_manager = blacklist_manager
        self._needs_refresh = True

        layout = QVBoxLayout()
        self.setLayout(layout)

        layout.addWidget(QLabel("Favoriten"))

        self.list_view = QListView()
        self.model = MediaListModel()
        self.delegate = MediaItemDelegate(self)
        self.list_view.setModel(self.model)
        self.list_view.setItemDelegate(self.delegate)
        self.list_view.setAlternatingRowColors(True)
        self.list_view.doubleClicked.connect(self._on_double_click)
        self.list_view.setContextMenuPolicy(Qt.ContextMenuPolicy.CustomContextMenu)
        self.list_view.customContextMenuRequested.connect(self._on_context_menu)
        layout.addWidget(self.list_view)

        self.refresh()

    def refresh(self):
        try:
            self.delegate.invalidate_tag_cache()
            items = self.media_manager.list_favorites(limit=100)
            self.model.update_data(items)
        except Exception as e:
            logger.error("FavoritesView.refresh() error: %s", e)

    def _on_double_click(self, index):
        item = self.model.data(index, Qt.ItemDataRole.UserRole)
        if item:
            from core import OpenHandler
            handler = OpenHandler(self.media_manager)
            handler.open_item(item)

    def _on_context_menu(self, pos):
        index = self.list_view.indexAt(pos)
        if not index.isValid():
            return
        item = self.model.data(index, Qt.ItemDataRole.UserRole)
        if not item:
            return
        menu = _build_item_context_menu(self, item, self.media_manager, self.blacklist_manager, self.refresh)
        menu.exec(self.list_view.mapToGlobal(pos))


# ============================================================
# 6. Globale Suche
# ============================================================

class GlobalSearchView(QWidget):
    """Virtualized global search view using QListView + Model/Delegate pattern."""

    def __init__(self, media_manager: MediaManager, blacklist_manager: BlacklistManager):
        super().__init__()
        self.media_manager = media_manager
        self.blacklist_manager = blacklist_manager
        self._needs_refresh = False

        layout = QVBoxLayout()
        self.setLayout(layout)

        self.search_bar = AdvancedSearchBar()
        self.search_bar.search_triggered.connect(self.apply_search)
        layout.addWidget(self.search_bar)

        self.result_label = QLabel("")
        self.result_label.setObjectName("mutedLabel")
        layout.addWidget(self.result_label)

        self.list_view = QListView()
        self.model = MediaListModel()
        self.delegate = MediaItemDelegate(self)
        self.list_view.setModel(self.model)
        self.list_view.setItemDelegate(self.delegate)
        self.list_view.setAlternatingRowColors(True)
        self.list_view.doubleClicked.connect(self._on_double_click)
        self.list_view.setContextMenuPolicy(Qt.ContextMenuPolicy.CustomContextMenu)
        self.list_view.customContextMenuRequested.connect(self._on_context_menu)
        layout.addWidget(self.list_view)

    def apply_search(self, criteria: SearchCriteria):
        try:
            if not criteria.text.strip() and not criteria.provider and not criteria.media_type:
                self.model.update_data([])
                self.result_label.setText("")
                return

            self.delegate.invalidate_tag_cache()
            engine = SearchEngine(self.media_manager.db)
            results = engine.search(criteria)
            self.model.update_data(results)
            self.result_label.setText(f"{len(results)} Ergebnisse gefunden")
        except Exception as e:
            logger.error("GlobalSearchView.apply_search() error: %s", e)
            self.result_label.setText(f"Suchfehler: {e}")

    def refresh(self):
        """No-op: search results are not auto-refreshed."""
        pass

    def _on_double_click(self, index):
        item = self.model.data(index, Qt.ItemDataRole.UserRole)
        if item:
            from core import OpenHandler
            handler = OpenHandler(self.media_manager)
            handler.open_item(item)

    def _on_context_menu(self, pos):
        index = self.list_view.indexAt(pos)
        if not index.isValid():
            return
        item = self.model.data(index, Qt.ItemDataRole.UserRole)
        if not item:
            return
        menu = _build_item_context_menu(self, item, self.media_manager, self.blacklist_manager,
                                         lambda: self.search_bar._trigger_search())
        menu.exec(self.list_view.mapToGlobal(pos))


# ============================================================
# 7. Einstellungen-Fenster
# ============================================================

class SettingsWindow(QWidget):
    def __init__(self):
        super().__init__()
        self.setWindowTitle("Einstellungen")
        self.resize(600, 400)

        layout = QVBoxLayout()
        self.setLayout(layout)

        tabs = QTabWidget()
        layout.addWidget(tabs)

        # Allgemein
        general = QWidget()
        g_layout = QVBoxLayout()
        general.setLayout(g_layout)

        theme_label = QLabel("Theme:")
        theme_select = QComboBox()
        for key, name in _theme_engine.list_themes():
            theme_select.addItem(name, key)
        # Set current
        current_theme = config.config.get("ui.theme", "light")
        for i in range(theme_select.count()):
            if theme_select.itemData(i) == current_theme:
                theme_select.setCurrentIndex(i)
                break
        def on_theme_change(index):
            theme_key = theme_select.itemData(index)
            if theme_key:
                config.config.set("ui.theme", theme_key)
                for widget in QApplication.topLevelWidgets():
                    if hasattr(widget, "apply_theme"):
                        widget.apply_theme()
        theme_select.currentIndexChanged.connect(on_theme_change)

        g_layout.addWidget(theme_label)
        g_layout.addWidget(theme_select)

        # System Tray
        tray_checkbox = QCheckBox("System Tray aktivieren (Minimieren statt Beenden)")
        tray_checkbox.setChecked(config.config.get("ui.system_tray", False))
        def on_tray_change(state):
            enabled = bool(state)
            config.config.set("ui.system_tray", enabled)
            # MainWindow benachrichtigen
            for widget in QApplication.topLevelWidgets():
                if hasattr(widget, "update_system_tray"):
                    widget.update_system_tray(enabled)
        tray_checkbox.stateChanged.connect(on_tray_change)
        g_layout.addWidget(tray_checkbox)

        g_layout.addStretch()

        tabs.addTab(general, "Allgemein")

        # Provider
        provider = QWidget()
        p_layout = QVBoxLayout()
        provider.setLayout(p_layout)

        for name in config.config.get("providers", {}).keys():
            label = QLabel(f"{name} Oeffnen mit:")
            combo = QComboBox()
            combo.addItems(["browser", "app", "local", "auto"])
            combo.setCurrentText(config.config.get(f"providers.{name}.preferred_open_method", "auto"))
            combo.currentTextChanged.connect(
                lambda v, n=name: config.config.set(f"providers.{n}.preferred_open_method", v)
            )
            p_layout.addWidget(label)
            p_layout.addWidget(combo)

        p_layout.addStretch()
        tabs.addTab(provider, "Provider")

        # Sicherheit
        security = QWidget()
        s_layout = QVBoxLayout()
        security.setLayout(s_layout)

        delete_checkbox = QCheckBox("Loeschen lokaler Dateien erlauben")
        delete_checkbox.setChecked(config.config.get("allow_file_deletion", False))
        delete_checkbox.stateChanged.connect(
            lambda v: config.config.set("allow_file_deletion", bool(v))
        )

        s_layout.addWidget(delete_checkbox)
        s_layout.addStretch()

        tabs.addTab(security, "Sicherheit")



# ============================================================
# DashboardView – zentrale Startseite
# ============================================================

# In gui.py

class DashboardView(QWidget):
    def __init__(self, media_manager: MediaManager, blacklist_manager: BlacklistManager, open_settings_callback=None, open_blacklist_callback=None):
        super().__init__()

        self.media_manager = media_manager
        self.blacklist_manager = blacklist_manager
        
        # SearchEngine für erweiterte Suche
        self.search_engine = SearchEngine(self.media_manager.db)
        
        # Callbacks speichern
        self.open_settings_callback = open_settings_callback
        self.open_blacklist_callback = open_blacklist_callback

        layout = QVBoxLayout()
        self.setLayout(layout)

        # 1. Erweiterte Suche (ersetzt alte SearchBar)
        self.search_bar = AdvancedSearchBar()
        self.search_bar.search_triggered.connect(self.apply_search)
        layout.addWidget(self.search_bar)

        # 2. Quick Actions (Statisch - wird nicht neu geladen -> KEIN FLACKERN MEHR)
        actions_layout = QHBoxLayout()
        
        btn_scan = QPushButton("Bibliothek scannen")
        # btn_scan.clicked.connect(...) # Später Funktion einbauen
        actions_layout.addWidget(btn_scan)

        btn_settings = QPushButton("Einstellungen")
        if self.open_settings_callback:
            btn_settings.clicked.connect(self.open_settings_callback)
        actions_layout.addWidget(btn_settings)

        btn_bl = QPushButton("Blacklist anzeigen")
        if self.open_blacklist_callback:
            btn_bl.clicked.connect(self.open_blacklist_callback)
        actions_layout.addWidget(btn_bl)
        
        actions_layout.addStretch()
        layout.addLayout(actions_layout)

        # 3. Scrollbereich für dynamischen Inhalt
        self.scroll = QScrollArea()
        self.scroll.setWidgetResizable(True)
        self.scroll.setFrameShape(QFrame.Shape.NoFrame)
        self.scroll.viewport().setStyleSheet("background-color: transparent;")
        layout.addWidget(self.scroll)

        self._init_container()
        self.refresh()

    def _init_container(self):
        """Erstellt einen neuen Container fuer den Scrollbereich."""
        self.container = QWidget()
        self.container.setStyleSheet("background-color: transparent;")
        self.container_layout = QVBoxLayout()
        self.container_layout.setContentsMargins(4, 4, 4, 4)
        self.container.setLayout(self.container_layout)
        self.scroll.setWidget(self.container)

    def refresh(self):
        try:
            # Alten Container komplett ersetzen (verhindert Scroll-Artefakte)
            old = self.scroll.takeWidget()
            if old:
                old.deleteLater()
            self._init_container()

            # --- A. Favoriten ---
            fav_label = QLabel("Favoriten")
            fav_label.setObjectName("sectionHeader")
            self.container_layout.addWidget(fav_label)

            # Optimiert: Nutzt MediaManager-Methoden statt raw Queries
            fav_items = self.media_manager.list_favorites(limit=5)

            if fav_items:
                for item in fav_items:
                    widget = MediaItemWidget(item, self.media_manager, self.blacklist_manager)
                    self.container_layout.addWidget(widget)
            else:
                self.container_layout.addWidget(QLabel("Keine Favoriten markiert."))

            # --- B. Zuletzt geöffnet ---
            recent_label = QLabel("Zuletzt geoeffnet")
            recent_label.setObjectName("sectionHeader")
            self.container_layout.addWidget(recent_label)

            recent_items = self.media_manager.list_recent(limit=10)

            if recent_items:
                for item in recent_items:
                    widget = MediaItemWidget(item, self.media_manager, self.blacklist_manager)
                    self.container_layout.addWidget(widget)
            else:
                self.container_layout.addWidget(QLabel("Noch keine Aktivitaeten."))

            self.container_layout.addStretch()
        except Exception as e:
            self.container_layout.addWidget(QLabel(f"Fehler beim Laden des Dashboards: {e}"))

    def apply_search(self, criteria: SearchCriteria):
        """Führt erweiterte Suche basierend auf SearchCriteria aus."""
        # Container komplett ersetzen
        old = self.scroll.takeWidget()
        if old:
            old.deleteLater()
        self._init_container()

        # Prüfe ob Filter aktiv sind
        has_filters = (
            criteria.text.strip() or 
            criteria.media_type or 
            criteria.provider or 
            criteria.favorites_only or 
            criteria.time_filter_days or
            criteria.tags
        )
        
        if not has_filters:
            self.refresh()
            return

        # Suchinfo anzeigen
        filter_parts = []
        if criteria.text:
            filter_parts.append(f'"{criteria.text}"')
        if criteria.media_type:
            filter_parts.append(f"Typ: {criteria.media_type}")
        if criteria.provider:
            filter_parts.append(f"Provider: {criteria.provider}")
        if criteria.favorites_only:
            filter_parts.append("⭐ Favoriten")
        if criteria.time_filter_days:
            filter_parts.append(f"Letzte {criteria.time_filter_days} Tage")
            
        search_info = " | ".join(filter_parts) if filter_parts else "Alle"
        search_label = QLabel(f"Suche: {search_info}")
        search_label.setObjectName("sectionHeader")
        self.container_layout.addWidget(search_label)

        # Suche ausführen via SearchEngine
        results = self.search_engine.search(criteria)
        
        if results:
            count_label = QLabel(f"{len(results)} Ergebnisse gefunden")
            count_label.setObjectName("mutedLabel")
            self.container_layout.addWidget(count_label)
            
            for media_item in results:
                widget = MediaItemWidget(media_item, self.media_manager, self.blacklist_manager)
                self.container_layout.addWidget(widget)
        else:
            no_results = QLabel("Keine Treffer gefunden.")
            no_results.setObjectName("mutedLabel")
            self.container_layout.addWidget(no_results)
            
        self.container_layout.addStretch()
# ============================================================
# BlacklistView – vollständige Verwaltung
# ============================================================

from datetime import datetime, timedelta
from PySide6.QtWidgets import (
    QWidget, QVBoxLayout, QLabel, QScrollArea, QHBoxLayout,
    QPushButton, QComboBox, QFrame
)
from PySide6.QtCore import Qt

class BlacklistView(QWidget):
    def __init__(self, media_manager: MediaManager, blacklist_manager: BlacklistManager):
        super().__init__()

        self.media_manager = media_manager
        self.blacklist_manager = blacklist_manager

        layout = QVBoxLayout()
        self.setLayout(layout)

        title = QLabel("Blacklist-Verwaltung")
        title.setObjectName("pageTitle")
        layout.addWidget(title)

        # -------------------------------------------------------
        # Filterleiste
        # -------------------------------------------------------
        filter_row = QHBoxLayout()

        self.provider_filter = QComboBox()
        self.provider_filter.addItem("Alle Provider")
        for p in ["netflix", "youtube", "spotify", "local"]:
            self.provider_filter.addItem(p)
        self.provider_filter.currentTextChanged.connect(self.refresh)
        filter_row.addWidget(self.provider_filter)

        self.duration_filter = QComboBox()
        self.duration_filter.addItem("Alle Dauern")
        self.duration_filter.addItems([
            "1 Tag", "1 Woche", "1 Monat", "3 Monate", "1 Jahr", "Für immer"
        ])
        self.duration_filter.currentTextChanged.connect(self.refresh)
        filter_row.addWidget(self.duration_filter)

        self.expiry_filter = QComboBox()
        self.expiry_filter.addItem("Alle")
        self.expiry_filter.addItem("Nur abgelaufen")
        self.expiry_filter.addItem("Nur aktiv")
        self.expiry_filter.currentTextChanged.connect(self.refresh)
        filter_row.addWidget(self.expiry_filter)

        layout.addLayout(filter_row)

        # -------------------------------------------------------
        # Buttons
        # -------------------------------------------------------
        btn_row = QHBoxLayout()

        btn_clear_expired = QPushButton("Abgelaufene entfernen")
        btn_clear_expired.clicked.connect(self._remove_expired)
        btn_row.addWidget(btn_clear_expired)

        btn_clear_all = QPushButton("Alle entfernen")
        btn_clear_all.clicked.connect(self._remove_all)
        btn_row.addWidget(btn_clear_all)

        btn_row.addStretch()
        layout.addLayout(btn_row)

        # -------------------------------------------------------
        # Scrollbereich
        # -------------------------------------------------------
        self.scroll = QScrollArea()
        self.scroll.setWidgetResizable(True)
        self.scroll.setFrameShape(QFrame.Shape.NoFrame)
        self.scroll.viewport().setStyleSheet("background-color: transparent;")
        layout.addWidget(self.scroll)

        self._init_container()
        self.refresh()

    def _init_container(self):
        """Erstellt einen neuen Container fuer den Scrollbereich."""
        self.container = QWidget()
        self.container.setStyleSheet("background-color: transparent;")
        self.container_layout = QVBoxLayout()
        self.container_layout.setContentsMargins(4, 4, 4, 4)
        self.container.setLayout(self.container_layout)
        self.scroll.setWidget(self.container)

    # -----------------------------------------------------------
    # Ablaufdatum berechnen
    # -----------------------------------------------------------
    def _expiry_date(self, start: datetime, code: int):
        if code == 1:
            return start + timedelta(days=1)
        if code == 2:
            return start + timedelta(weeks=1)
        if code == 3:
            return start + timedelta(days=30)
        if code == 4:
            return start + timedelta(days=90)
        if code == 5:
            return start + timedelta(days=365)
        if code == 6:
            return None
        return None

    # -----------------------------------------------------------
    # Blacklist-Ansicht aktualisieren
    # -----------------------------------------------------------
    def refresh(self):
        # Container komplett ersetzen (verhindert Scroll-Artefakte)
        old = self.scroll.takeWidget()
        if old:
            old.deleteLater()
        self._init_container()

        # Filter-Werte ermitteln
        provider_filter = self.provider_filter.currentText()
        duration_filter = self.duration_filter.currentText()
        expiry_filter = self.expiry_filter.currentText()

        # SQL-Filter für Provider und Dauer (statt Python-seitiger Filterung)
        source = None if provider_filter == "Alle Provider" else provider_filter

        code_map = {
            "1 Tag": 1, "1 Woche": 2, "1 Monat": 3,
            "3 Monate": 4, "1 Jahr": 5, "Für immer": 6
        }
        procedure_code = code_map.get(duration_filter)

        # Optimiert: Filter in SQL statt Python-Iteration über alle Items
        items = self.media_manager.list_blacklisted(
            source=source,
            procedure_code=procedure_code,
            limit=200
        )

        for item in items:
            # Ablauf-Filter (muss in Python bleiben wegen Datumsberechnung)
            if item.blacklisted_at:
                start = datetime.fromisoformat(item.blacklisted_at)
                expiry = self._expiry_date(start, item.procedure_code)
                expired = expiry and datetime.now() > expiry
            else:
                expired = False

            if expiry_filter == "Nur abgelaufen" and not expired:
                continue
            if expiry_filter == "Nur aktiv" and expired:
                continue

            # Widget erzeugen
            widget = self._create_blacklist_widget(item, expired, expiry)
            self.container_layout.addWidget(widget)

        self.container_layout.addStretch()

    # -----------------------------------------------------------
    # Einzelnes Blacklist-Widget
    # -----------------------------------------------------------
    def _create_blacklist_widget(self, item: MediaItem, expired: bool, expiry):
        frame = QFrame()
        frame.setFrameStyle(QFrame.Shape.Panel | QFrame.Shadow.Raised)
        layout = QVBoxLayout()
        frame.setLayout(layout)

        title = QLabel(f"{item.title} ({item.source})")
        title.setObjectName("sectionHeader")
        layout.addWidget(title)

        layout.addWidget(QLabel(f"Sperrcode: {item.procedure_code}"))
        layout.addWidget(QLabel(f"Seit: {item.blacklisted_at}"))

        if expiry:
            layout.addWidget(QLabel(f"Ablaufdatum: {expiry}"))
        else:
            layout.addWidget(QLabel("Ablaufdatum: Nie"))

        if expired:
            expired_label = QLabel("Status: Abgelaufen")
            expired_label.setObjectName("dangerLabel")
            layout.addWidget(expired_label)
        else:
            layout.addWidget(QLabel("Status: Aktiv"))

        # Buttons
        btn_row = QHBoxLayout()

        btn_remove = QPushButton("Entfernen")
        btn_remove.clicked.connect(lambda: self._remove_single(item.id))
        btn_row.addWidget(btn_remove)

        btn_change = QPushButton("Dauer ändern")
        btn_change.clicked.connect(lambda: self._change_duration(item.id))
        btn_row.addWidget(btn_change)

        btn_row.addStretch()
        layout.addLayout(btn_row)

        return frame

    # -----------------------------------------------------------
    # Aktionen
    # -----------------------------------------------------------
    def _remove_single(self, item_id):
        try:
            self.blacklist_manager.set_blacklist(item_id, False)
            self.refresh()
        except Exception as e:
            from PySide6.QtWidgets import QMessageBox
            QMessageBox.warning(self, "Fehler", f"Blacklist-Eintrag konnte nicht entfernt werden: {e}")

    def _change_duration(self, item_id):
        try:
            self.blacklist_manager.set_blacklist(item_id, True, 2)
            self.refresh()
        except Exception as e:
            from PySide6.QtWidgets import QMessageBox
            QMessageBox.warning(self, "Fehler", f"Dauer konnte nicht geaendert werden: {e}")

    def _remove_expired(self):
        """Entfernt alle abgelaufenen Blacklist-Einträge in einem Batch-UPDATE."""
        try:
            rows = self.media_manager.db.fetchall("""
                SELECT id, blacklisted_at, procedure_code
                FROM media_items
                WHERE blacklist_flag = 1 AND procedure_code < 6 AND blacklisted_at IS NOT NULL
            """)

            expired_ids = []
            now = datetime.now()
            for row in rows:
                start = datetime.fromisoformat(row["blacklisted_at"])
                expiry = self._expiry_date(start, row["procedure_code"])
                if expiry and now > expiry:
                    expired_ids.append(row["id"])

            if expired_ids:
                placeholders = ",".join("?" * len(expired_ids))
                self.media_manager.db.execute(f"""
                    UPDATE media_items
                    SET blacklist_flag = 0,
                        procedure_code = 0,
                        blacklisted_at = NULL
                    WHERE id IN ({placeholders})
                """, tuple(expired_ids))

            self.refresh()
        except Exception as e:
            from PySide6.QtWidgets import QMessageBox
            QMessageBox.warning(self, "Fehler", f"Abgelaufene konnten nicht entfernt werden: {e}")

    def _remove_all(self):
        try:
            self.media_manager.db.execute("""
                UPDATE media_items
                SET blacklist_flag = 0,
                    blacklisted_at = NULL,
                    procedure_code = 0
                WHERE blacklist_flag = 1
            """)
            self.refresh()
        except Exception as e:
            from PySide6.QtWidgets import QMessageBox
            QMessageBox.warning(self, "Fehler", f"Blacklist konnte nicht geleert werden: {e}")

class MediaDetailView(QWidget):
    def __init__(self, item: MediaItem, media_manager: MediaManager, blacklist_manager: BlacklistManager, back_callback):
        super().__init__()

        self.item = item
        self.media_manager = media_manager
        self.blacklist_manager = blacklist_manager
        self.back_callback = back_callback

        layout = QVBoxLayout()
        self.setLayout(layout)

        # Titel
        title = QLabel(item.title)
        title.setObjectName("pageTitle")
        layout.addWidget(title)

        # Thumbnail
        if item.thumbnail_url:
            thumb = QLabel(f"[Thumbnail: {item.thumbnail_url}]")
            layout.addWidget(thumb)

        # Beschreibung
        desc = QLabel(item.description or "Keine Beschreibung verfügbar.")
        desc.setWordWrap(True)
        layout.addWidget(desc)

        # Metadaten
        meta = QLabel(
            f"Typ: {item.type}\n"
            f"Provider: {item.source}\n"
            f"Provider-ID: {item.provider_id}\n"
            f"Erstellt am: {item.created_at}\n"
            f"Zuletzt geöffnet: {item.last_opened_at}\n"
            f"Öffnungsmethode: {item.open_method or '-'}"
        )
        layout.addWidget(meta)

        # Buttons
        btn_row = QHBoxLayout()

        open_btn = QPushButton("Öffnen")
        open_btn.clicked.connect(self.open_item)
        btn_row.addWidget(open_btn)

        fav_btn = QPushButton("Favorit" if not item.is_favorite else "Favorit entfernen")
        fav_btn.clicked.connect(self.toggle_favorite)
        btn_row.addWidget(fav_btn)

        back_btn = QPushButton("Zurück")
        back_btn.clicked.connect(self.back_callback)
        btn_row.addWidget(back_btn)

        btn_row.addStretch()
        layout.addLayout(btn_row)

    def open_item(self):
        try:
            from core import OpenHandler
            handler = OpenHandler(self.media_manager)
            handler.open_item(self.item)
        except Exception as e:
            from PySide6.QtWidgets import QMessageBox
            QMessageBox.warning(self, "Fehler", f"Konnte Medium nicht oeffnen: {e}")

    def toggle_favorite(self):
        try:
            new_value = 0 if self.item.is_favorite else 1
            self.media_manager.db.execute(
                "UPDATE media_items SET is_favorite = ? WHERE id = ?",
                (new_value, self.item.id)
            )
            notify_gui_refresh()
        except Exception as e:
            from PySide6.QtWidgets import QMessageBox
            QMessageBox.warning(self, "Fehler", f"Favorit konnte nicht geaendert werden: {e}")
# ============================================================
# 8. Statistik-View
# ============================================================

class StatsView(QWidget):
    """Statistik-Panel fuer MediaBrain.

    Zeigt:
    - Gesamtanzahl Medien in der Bibliothek
    - Medien pro Typ (movie, series, music, clip, etc.)
    - Geschaetzter Speicherverbrauch lokaler Dateien
    - Top 5 zuletzt hinzugefuegte Medien
    """

    def __init__(self, media_manager: MediaManager, parent=None):
        super().__init__(parent)
        self.media_manager = media_manager
        self._needs_refresh = True
        self._build_ui()

    def _build_ui(self):
        """Erstellt das Layout des Statistik-Panels."""
        import os
        layout = QVBoxLayout(self)
        layout.setContentsMargins(20, 20, 20, 20)
        layout.setSpacing(16)

        header = QLabel("<h2>📊 Statistiken & Dashboard</h2>")
        layout.addWidget(header)

        # --- Kennzahlen-Grid ---
        self.lbl_total = QLabel("Gesamtanzahl Medien: --")
        self.lbl_total.setObjectName("sectionHeader")
        layout.addWidget(self.lbl_total)

        self.lbl_storage = QLabel("Geschaetzter Speicher (lokal): –")
        layout.addWidget(self.lbl_storage)

        # --- Medien pro Typ ---
        layout.addWidget(QLabel("<b>Medien nach Typ:</b>"))
        self.type_list = QListWidget()
        self.type_list.setMaximumHeight(160)
        layout.addWidget(self.type_list)

        # --- Zuletzt hinzugefuegt ---
        layout.addWidget(QLabel("<b>Zuletzt hinzugefuegt (Top 5):</b>"))
        self.recent_list = QListWidget()
        self.recent_list.setMaximumHeight(150)
        layout.addWidget(self.recent_list)

        btn_refresh = QPushButton("🔄 Aktualisieren")
        btn_refresh.clicked.connect(self.refresh)
        layout.addWidget(btn_refresh)

        layout.addStretch()

    def refresh(self):
        """Laedt die Statistiken neu aus der Datenbank."""
        import os
        db = self.media_manager.db

        try:
            # 1. Gesamtanzahl
            total_row = db.conn.execute(
                "SELECT COUNT(*) AS cnt FROM media_items WHERE blacklist_flag = 0"
            ).fetchone()
            total = total_row["cnt"] if total_row else 0
            self.lbl_total.setText(f"Gesamtanzahl Medien: {total}")

            # 2. Medien pro Typ
            type_rows = db.conn.execute(
                "SELECT type, COUNT(*) AS cnt FROM media_items WHERE blacklist_flag = 0 GROUP BY type ORDER BY cnt DESC"
            ).fetchall()
            self.type_list.clear()
            type_icons = {
                "movie": "🎬", "series": "📺", "music": "🎵",
                "clip": "🎞️", "podcast": "🎙️", "audiobook": "📚", "document": "📄"
            }
            for row in type_rows:
                icon = type_icons.get(row["type"], "▪")
                self.type_list.addItem(f"  {icon}  {row['type'].capitalize()}: {row['cnt']}")

            # 3. Speicherverbrauch lokaler Dateien
            local_rows = db.conn.execute(
                "SELECT local_path FROM media_items WHERE is_local_file = 1 AND local_path IS NOT NULL AND local_path != ''"
            ).fetchall()
            total_bytes = 0
            for r in local_rows:
                try:
                    sz = os.path.getsize(r["local_path"])
                    total_bytes += sz
                except OSError:
                    pass
            if total_bytes > 0:
                total_gb = total_bytes / (1024 ** 3)
                self.lbl_storage.setText(f"Geschaetzter Speicher (lokal): {total_gb:.2f} GB ({len(local_rows)} Dateien)")
            else:
                self.lbl_storage.setText(f"Geschaetzter Speicher (lokal): Keine lokalen Dateien erfasst")

            # 4. Zuletzt hinzugefuegt (Top 5)
            recent_rows = db.conn.execute(
                "SELECT title, type, created_at FROM media_items ORDER BY created_at DESC LIMIT 5"
            ).fetchall()
            self.recent_list.clear()
            for r in recent_rows:
                date_str = (r["created_at"] or "")[:10]
                self.recent_list.addItem(f"  {date_str}  [{r['type']}]  {r['title']}")

        except Exception as e:
            logger.error(f"StatsView.refresh() Fehler: {e}")

        self._needs_refresh = False


# ============================================================
# 9. MainWindow mit Sidebar
# ============================================================

class MainWindow(QMainWindow):
    def __init__(self, media_manager: MediaManager, blacklist_manager: BlacklistManager, tag_manager: TagManager = None):
        super().__init__()

        self.media_manager = media_manager
        self.blacklist_manager = blacklist_manager
        self.tag_manager = tag_manager

        # Set global tag_manager reference for all views
        global _tag_manager
        _tag_manager = tag_manager

        self.setWindowTitle("MediaBrain")
        self.resize(
            config.config.get("ui.window_width", 1200),
            config.config.get("ui.window_height", 800)
        )

        # Hauptlayout: Sidebar + Content
        splitter = QSplitter()
        self.setCentralWidget(splitter)

        # Sidebar
        sidebar = QWidget()
        sidebar_layout = QVBoxLayout()
        sidebar.setLayout(sidebar_layout)
        sidebar.setObjectName("Sidebar") # Für CSS Styling

        btn_dash = QPushButton("Übersicht")
        btn_dash.clicked.connect(lambda: self._switch_view(self.dashboard))
        sidebar_layout.addWidget(btn_dash)

        btn_movies = QPushButton("Filme")
        btn_movies.clicked.connect(lambda: self._switch_view(self.library_movies))
        sidebar_layout.addWidget(btn_movies)

        btn_series = QPushButton("Serien")
        btn_series.clicked.connect(lambda: self._switch_view(self.library_series))
        sidebar_layout.addWidget(btn_series)

        btn_music = QPushButton("Musik")
        btn_music.clicked.connect(lambda: self._switch_view(self.library_music))
        sidebar_layout.addWidget(btn_music)

        btn_clips = QPushButton("Clips")
        btn_clips.clicked.connect(lambda: self._switch_view(self.library_clips))
        sidebar_layout.addWidget(btn_clips)

        btn_favs = QPushButton("Favoriten")
        btn_favs.clicked.connect(lambda: self._switch_view(self.favorites))
        sidebar_layout.addWidget(btn_favs)

        btn_blacklist = QPushButton("Blacklist")
        btn_blacklist.clicked.connect(lambda: self._switch_view(self.blacklist_view))
        sidebar_layout.addWidget(btn_blacklist)

        btn_stats = QPushButton("📊 Statistiken")
        btn_stats.clicked.connect(lambda: self._switch_view(self.stats_view))
        sidebar_layout.addWidget(btn_stats)

        btn_settings = QPushButton("Einstellungen")
        btn_settings.clicked.connect(self.open_settings)
        sidebar_layout.addWidget(btn_settings)

        sidebar_layout.addStretch()

        splitter.addWidget(sidebar)

        # Content Stack
        self.stack = QStackedWidget()
        splitter.addWidget(self.stack)

        # --- Views Initialisieren ---

        # 1. Dashboard (Korrigiert: Echte View statt QLabel)
        self.dashboard = DashboardView(
            media_manager, 
            blacklist_manager,
            open_settings_callback=self.open_settings,
            open_blacklist_callback=lambda: self.stack.setCurrentWidget(self.blacklist_view)
        )
        self.stack.addWidget(self.dashboard)

        # 2. Libraries
        self.library_movies = LibraryView("movie", media_manager, blacklist_manager)
        self.stack.addWidget(self.library_movies)

        self.library_series = LibraryView("series", media_manager, blacklist_manager)
        self.stack.addWidget(self.library_series)

        self.library_music = LibraryView("music", media_manager, blacklist_manager)
        self.stack.addWidget(self.library_music)

        self.library_clips = LibraryView("clip", media_manager, blacklist_manager)
        self.stack.addWidget(self.library_clips)

        # 3. Favoriten
        self.favorites = FavoritesView(media_manager, blacklist_manager)
        self.stack.addWidget(self.favorites)

        # 4. Blacklist (Korrigiert: Echte View statt QLabel)
        self.blacklist_view = BlacklistView(media_manager, blacklist_manager)
        self.stack.addWidget(self.blacklist_view)

        # 5. Statistiken
        self.stats_view = StatsView(media_manager)
        self.stack.addWidget(self.stats_view)

        # 6. Suche
        self.global_search = GlobalSearchView(media_manager, blacklist_manager)
        self.stack.addWidget(self.global_search)
        
        # Theme anwenden
        self.apply_theme()

        # Detail View Platzhalter
        self.detail_view = None

        # System Tray
        self.tray_icon = None
        if config.config.get("ui.system_tray", False):
            self._setup_system_tray()

    def open_detail(self, item):
        # Alte Detail-View entfernen um Memory Leak zu vermeiden
        if self.detail_view is not None:
            self.stack.removeWidget(self.detail_view)
            self.detail_view.deleteLater()

        self.detail_view = MediaDetailView(
            item,
            self.media_manager,
            self.blacklist_manager,
            back_callback=lambda: self.stack.setCurrentWidget(self.dashboard)
        )
        self.stack.addWidget(self.detail_view)
        self.stack.setCurrentWidget(self.detail_view)
           
    def refresh_all_views(self):
        """Aktualisiert Views - optimiert: nur sichtbare View sofort, Rest lazy.

        Statt alle 7 Views gleichzeitig zu refreshen (7+ DB-Queries),
        wird nur die aktuell sichtbare View sofort aktualisiert.
        Die anderen Views werden beim nächsten Anzeigen refreshed (dirty-Flag).
        """
        try:
            current = self.stack.currentWidget()

            # Alle Views als 'dirty' markieren
            all_views = [
                self.dashboard, self.library_movies, self.library_series,
                self.library_music, self.library_clips, self.favorites,
                self.blacklist_view, self.stats_view
            ]
            for view in all_views:
                view._needs_refresh = True

            # Nur die aktuelle View sofort refreshen
            if current and hasattr(current, 'refresh'):
                current.refresh()
                current._needs_refresh = False
        except Exception as e:
            from PySide6.QtWidgets import QMessageBox
            QMessageBox.warning(self, "Fehler", f"GUI konnte nicht vollständig aktualisiert werden: {e}")

    def _switch_view(self, view):
        """Wechselt zur gewünschten View und refreshed sie, falls sie dirty ist."""
        self.stack.setCurrentWidget(view)
        if getattr(view, '_needs_refresh', False) and hasattr(view, 'refresh'):
            view.refresh()
            view._needs_refresh = False

    def open_settings(self):
        self.settings_window = SettingsWindow()
        self.settings_window.show()
    
    def _setup_system_tray(self):
        """Erstellt das System-Tray-Icon mit Kontextmenu."""
        if self.tray_icon is not None:
            return

        # Einfaches Tray-Icon erstellen (blauer Kreis mit M)
        pixmap = QPixmap(64, 64)
        pixmap.fill(QGuiColor(0, 0, 0, 0))
        painter = QGuiPainter(pixmap)
        painter.setRenderHint(QGuiPainter.RenderHint.Antialiasing)
        painter.setBrush(QGuiColor("#5b8dd9"))
        painter.setPen(Qt.PenStyle.NoPen)
        painter.drawEllipse(2, 2, 60, 60)
        font = QGuiFont("Segoe UI", 30, QGuiFont.Weight.Bold)
        painter.setFont(font)
        painter.setPen(QGuiColor("white"))
        painter.drawText(pixmap.rect(), Qt.AlignmentFlag.AlignCenter, "M")
        painter.end()

        self.tray_icon = QSystemTrayIcon(QIcon(pixmap), self)
        self.tray_icon.setToolTip("MediaBrain")

        # Kontextmenu
        tray_menu = QMenu()
        act_show = QAction("MediaBrain oeffnen", self)
        act_show.triggered.connect(self._restore_from_tray)
        tray_menu.addAction(act_show)

        tray_menu.addSeparator()

        act_quit = QAction("Beenden", self)
        act_quit.triggered.connect(self._quit_app)
        tray_menu.addAction(act_quit)

        self.tray_icon.setContextMenu(tray_menu)
        self.tray_icon.activated.connect(self._on_tray_activated)
        self.tray_icon.show()

    def _remove_system_tray(self):
        """Entfernt das System-Tray-Icon."""
        if self.tray_icon is not None:
            self.tray_icon.hide()
            self.tray_icon.deleteLater()
            self.tray_icon = None

    def update_system_tray(self, enabled):
        """Aktiviert oder deaktiviert den System Tray."""
        if enabled:
            self._setup_system_tray()
        else:
            self._remove_system_tray()

    def _restore_from_tray(self):
        """Stellt das Fenster aus dem System Tray wieder her."""
        self.showNormal()
        self.activateWindow()
        self.raise_()

    def _on_tray_activated(self, reason):
        """Doppelklick auf Tray-Icon oeffnet das Fenster."""
        if reason == QSystemTrayIcon.ActivationReason.DoubleClick:
            self._restore_from_tray()

    def _quit_app(self):
        """Beendet die Anwendung vollstaendig."""
        self._remove_system_tray()
        QApplication.instance().quit()

    def closeEvent(self, event):
        """Minimiert ins Tray statt zu schliessen (wenn Tray aktiv)."""
        if self.tray_icon is not None and self.tray_icon.isVisible():
            event.ignore()
            self.hide()
            self.tray_icon.showMessage(
                "MediaBrain",
                "MediaBrain laeuft im Hintergrund weiter.\nDoppelklick auf das Tray-Icon zum Oeffnen.",
                QSystemTrayIcon.MessageIcon.Information,
                2000
            )
        else:
            event.accept()

    def apply_theme(self):
        """Applies the current theme from config using ThemeEngine.

        Generates a complete QSS stylesheet and applies it to the
        entire application. Theme changes take effect immediately.
        """
        theme_key = config.config.get("ui.theme", "light")
        try:
            qss = _theme_engine.get_stylesheet(theme_key)
            QApplication.instance().setStyleSheet(qss)
        except Exception as e:
            logger.error("Failed to apply theme '%s': %s", theme_key, e)