"""Main Qt6 application window."""

from __future__ import annotations

import asyncio
import logging
import os
import sys
import threading
from pathlib import Path

from PySide6.QtCore import Qt, QTimer, Signal, QObject, QUrl, Property
from PySide6.QtGui import QPixmap, QAction, QKeySequence, QDesktopServices, QShortcut, QColor
from PySide6.QtWidgets import (
    QApplication,
    QMainWindow,
    QWidget,
    QVBoxLayout,
    QHBoxLayout,
    QStackedWidget,
    QComboBox,
    QLabel,
    QPushButton,
    QStatusBar,
    QSplitter,
    QMessageBox,
    QTextEdit,
    QMenu,
    QFileDialog,
    QSpinBox,
    QScrollArea,
    QProgressBar,
)

from dataclasses import dataclass, field

from ..core.db import Database, Site
from ..core.api.base import BooruClient, Post
from ..core.api.detect import client_for_type
from ..core.cache import download_image, download_thumbnail, cache_size_bytes, evict_oldest, evict_oldest_thumbnails
from ..core.config import MEDIA_EXTENSIONS

from .grid import ThumbnailGrid
from .preview import ImagePreview
from .search import SearchBar
from .sites import SiteManagerDialog
from .bookmarks import BookmarksView
from .library import LibraryView
from .settings import SettingsDialog

log = logging.getLogger("booru")


@dataclass
class SearchState:
    """Mutable state that resets on every new search."""
    shown_post_ids: set[int] = field(default_factory=set)
    page_cache: dict[int, list] = field(default_factory=dict)
    infinite_exhausted: bool = False
    infinite_last_page: int = 0
    infinite_api_exhausted: bool = False
    nav_page_turn: str | None = None
    append_queue: list = field(default_factory=list)


class LogHandler(logging.Handler, QObject):
    """Logging handler that emits to a QTextEdit."""

    log_signal = Signal(str)

    def __init__(self, widget: QTextEdit) -> None:
        logging.Handler.__init__(self)
        QObject.__init__(self)
        self._widget = widget
        self.log_signal.connect(self._append)
        self.setFormatter(logging.Formatter("%(asctime)s  %(levelname)-5s  %(message)s", datefmt="%H:%M:%S"))

    def emit(self, record: logging.LogRecord) -> None:
        msg = self.format(record)
        self.log_signal.emit(msg)

    def _append(self, msg: str) -> None:
        self._widget.append(msg)
        sb = self._widget.verticalScrollBar()
        sb.setValue(sb.maximum())


class AsyncSignals(QObject):
    """Signals for async worker results."""
    search_done = Signal(list)
    search_append = Signal(list)
    search_error = Signal(str)
    thumb_done = Signal(int, str)
    image_done = Signal(str, str)
    image_error = Signal(str)
    bookmark_done = Signal(int, str)
    bookmark_error = Signal(str)
    autocomplete_done = Signal(list)
    batch_progress = Signal(int, int)      # current, total
    batch_done = Signal(str)
    download_progress = Signal(int, int)  # bytes_downloaded, total_bytes
    prefetch_progress = Signal(int, float)  # index, progress (0-1 or -1 to hide)


# -- Info Panel --

class InfoPanel(QWidget):
    """Toggleable panel showing post details."""

    tag_clicked = Signal(str)

    # Tag category colors. Defaults follow the booru convention (Danbooru,
    # Gelbooru, etc.) so the panel reads naturally to anyone coming from a
    # booru site. Each is exposed as a Qt Property so a custom.qss can
    # override it via `qproperty-tag<Category>Color` selectors on
    # `InfoPanel`. An empty string means "use the default text color"
    # (the General category) and is preserved as a sentinel.
    _tag_artist_color = QColor("#f2ac08")
    _tag_character_color = QColor("#0a0")
    _tag_copyright_color = QColor("#c0f")
    _tag_species_color = QColor("#e44")
    _tag_meta_color = QColor("#888")
    _tag_lore_color = QColor("#888")

    def _get_artist(self): return self._tag_artist_color
    def _set_artist(self, c): self._tag_artist_color = QColor(c) if isinstance(c, str) else c
    tagArtistColor = Property(QColor, _get_artist, _set_artist)

    def _get_character(self): return self._tag_character_color
    def _set_character(self, c): self._tag_character_color = QColor(c) if isinstance(c, str) else c
    tagCharacterColor = Property(QColor, _get_character, _set_character)

    def _get_copyright(self): return self._tag_copyright_color
    def _set_copyright(self, c): self._tag_copyright_color = QColor(c) if isinstance(c, str) else c
    tagCopyrightColor = Property(QColor, _get_copyright, _set_copyright)

    def _get_species(self): return self._tag_species_color
    def _set_species(self, c): self._tag_species_color = QColor(c) if isinstance(c, str) else c
    tagSpeciesColor = Property(QColor, _get_species, _set_species)

    def _get_meta(self): return self._tag_meta_color
    def _set_meta(self, c): self._tag_meta_color = QColor(c) if isinstance(c, str) else c
    tagMetaColor = Property(QColor, _get_meta, _set_meta)

    def _get_lore(self): return self._tag_lore_color
    def _set_lore(self, c): self._tag_lore_color = QColor(c) if isinstance(c, str) else c
    tagLoreColor = Property(QColor, _get_lore, _set_lore)

    def _category_color(self, category: str) -> str:
        """Resolve a category name to a hex color string for inline QSS use.
        Returns "" for the General category (no override → use default text
        color) and unrecognized categories (so callers can render them with
        no color attribute set)."""
        cat = (category or "").lower()
        m = {
            "artist": self._tag_artist_color,
            "character": self._tag_character_color,
            "copyright": self._tag_copyright_color,
            "species": self._tag_species_color,
            "meta": self._tag_meta_color,
            "lore": self._tag_lore_color,
        }
        c = m.get(cat)
        return c.name() if c is not None else ""

    def __init__(self, parent: QWidget | None = None) -> None:
        super().__init__(parent)
        layout = QVBoxLayout(self)
        layout.setContentsMargins(6, 6, 6, 6)

        self._title = QLabel("No post selected")
        self._title.setStyleSheet("font-weight: bold;")
        layout.addWidget(self._title)

        self._details = QLabel()
        self._details.setWordWrap(True)
        self._details.setTextInteractionFlags(Qt.TextInteractionFlag.TextSelectableByMouse | Qt.TextInteractionFlag.TextBrowserInteraction)
        self._details.setMaximumHeight(120)
        layout.addWidget(self._details)

        self._tags_label = QLabel("Tags:")
        self._tags_label.setStyleSheet("font-weight: bold; margin-top: 8px;")
        layout.addWidget(self._tags_label)

        self._tags_scroll = QScrollArea()
        self._tags_scroll.setWidgetResizable(True)
        self._tags_scroll.setStyleSheet("QScrollArea { border: none; }")
        self._tags_widget = QWidget()
        self._tags_flow = QVBoxLayout(self._tags_widget)
        self._tags_flow.setContentsMargins(0, 0, 0, 0)
        self._tags_flow.setSpacing(2)
        self._tags_scroll.setWidget(self._tags_widget)
        layout.addWidget(self._tags_scroll, stretch=1)

    def set_post(self, post: Post) -> None:
        log.debug(f"InfoPanel: tag_categories={list(post.tag_categories.keys()) if post.tag_categories else 'empty'}")
        self._title.setText(f"Post #{post.id}")
        filetype = Path(post.file_url.split("?")[0]).suffix.lstrip(".").upper() if post.file_url else "unknown"
        source = post.source or "none"
        # Truncate display text but keep full URL for the link
        source_full = source
        if len(source) > 60:
            source_display = source[:57] + "..."
        else:
            source_display = source
        if source_full.startswith(("http://", "https://")):
            source_html = f'<a href="{source_full}" style="color: #4fc3f7;">{source_display}</a>'
        else:
            source_html = source_display
        from html import escape
        self._details.setText(
            f"Size: {post.width}x{post.height}\n"
            f"Score: {post.score}\n"
            f"Rating: {post.rating or 'unknown'}\n"
            f"Filetype: {filetype}"
        )
        self._details.setTextFormat(Qt.TextFormat.RichText)
        self._details.setText(
            f"Size: {post.width}x{post.height}<br>"
            f"Score: {post.score}<br>"
            f"Rating: {escape(post.rating or 'unknown')}<br>"
            f"Filetype: {filetype}<br>"
            f"Source: {source_html}"
        )
        self._details.setOpenExternalLinks(True)
        # Clear old tags
        while self._tags_flow.count():
            item = self._tags_flow.takeAt(0)
            if item.widget():
                item.widget().deleteLater()

        if post.tag_categories:
            # Display tags grouped by category. Colors come from the
            # tag*Color Qt Properties so a custom.qss can override any of
            # them via `InfoPanel { qproperty-tagCharacterColor: ...; }`.
            for category, tags in post.tag_categories.items():
                color = self._category_color(category)
                header = QLabel(f"{category}:")
                header.setStyleSheet(
                    f"font-weight: bold; margin-top: 6px; margin-bottom: 2px;"
                    + (f" color: {color};" if color else "")
                )
                self._tags_flow.addWidget(header)
                for tag in tags[:50]:
                    btn = QPushButton(tag)
                    btn.setFlat(True)
                    btn.setCursor(Qt.CursorShape.PointingHandCursor)
                    style = "QPushButton { text-align: left; padding: 1px 4px; border: none;"
                    if color:
                        style += f" color: {color};"
                    style += " }"
                    btn.setStyleSheet(style)
                    btn.clicked.connect(lambda checked, t=tag: self.tag_clicked.emit(t))
                    self._tags_flow.addWidget(btn)
        else:
            # Fallback: flat tag list (Gelbooru, Moebooru)
            for tag in post.tag_list[:100]:
                btn = QPushButton(tag)
                btn.setFlat(True)
                btn.setCursor(Qt.CursorShape.PointingHandCursor)
                btn.setStyleSheet(
                    "QPushButton { text-align: left; padding: 1px 4px; border: none; }"
                )
                btn.clicked.connect(lambda checked, t=tag: self.tag_clicked.emit(t))
                self._tags_flow.addWidget(btn)
        self._tags_flow.addStretch()

    def clear(self) -> None:
        self._title.setText("No post selected")
        self._details.setText("")
        while self._tags_flow.count():
            item = self._tags_flow.takeAt(0)
            if item.widget():
                item.widget().deleteLater()



# -- Main App --

class BooruApp(QMainWindow):
    def __init__(self) -> None:
        super().__init__()
        self.setWindowTitle("booru-viewer")
        self.setMinimumSize(900, 600)
        self.resize(1200, 800)

        self._db = Database()
        # Apply custom library directory if set
        lib_dir = self._db.get_setting("library_dir")
        if lib_dir:
            from ..core.config import set_library_dir
            set_library_dir(Path(lib_dir))
        # Apply saved thumbnail size
        saved_thumb = self._db.get_setting_int("thumbnail_size")
        if saved_thumb:
            import booru_viewer.gui.grid as grid_mod
            grid_mod.THUMB_SIZE = saved_thumb
        self._current_site: Site | None = None
        self._posts: list[Post] = []
        self._current_page = 1
        self._current_tags = ""
        self._current_rating = "all"
        self._min_score = 0
        self._loading = False
        self._search = SearchState()
        self._last_scroll_page = 0
        self._prefetch_pause = asyncio.Event()
        self._prefetch_pause.set()  # not paused
        self._signals = AsyncSignals()

        self._async_loop = asyncio.new_event_loop()
        self._async_thread = threading.Thread(target=self._async_loop.run_forever, daemon=True)
        self._async_thread.start()

        # Register the persistent loop as the process-wide app loop. Anything
        # that wants to schedule async work — `gui/sites.py`, `gui/bookmarks.py`,
        # any future helper — calls `core.concurrency.run_on_app_loop` which
        # uses this same loop. The whole point of PR2 is to never run async
        # code on a throwaway loop again.
        from ..core.concurrency import set_app_loop
        set_app_loop(self._async_loop)

        # Reset shared HTTP clients from previous session
        from ..core.api.base import BooruClient
        from ..core.api.e621 import E621Client
        BooruClient._shared_client = None
        E621Client._e621_client = None
        E621Client._e621_to_close = []
        import booru_viewer.core.cache as _cache_mod
        _cache_mod._shared_client = None

        self._setup_signals()
        self._setup_ui()
        self._setup_menu()
        self._load_sites()
        # Debounced save for the main window state — fires from resizeEvent
        # (and from the splitter timer's flush on close). Uses the same
        # 300ms debounce pattern as the splitter saver.
        self._main_window_save_timer = QTimer(self)
        self._main_window_save_timer.setSingleShot(True)
        self._main_window_save_timer.setInterval(300)
        self._main_window_save_timer.timeout.connect(self._save_main_window_state)
        # Restore window state (geometry, floating) on the next event-loop
        # iteration — by then main.py has called show() and the window has
        # been registered with the compositor.
        QTimer.singleShot(0, self._restore_main_window_state)

    def _setup_signals(self) -> None:
        Q = Qt.ConnectionType.QueuedConnection
        s = self._signals
        s.search_done.connect(self._on_search_done, Q)
        s.search_append.connect(self._on_search_append, Q)
        s.search_error.connect(self._on_search_error, Q)
        s.thumb_done.connect(self._on_thumb_done, Q)
        s.image_done.connect(self._on_image_done, Q)
        s.image_error.connect(self._on_image_error, Q)
        s.bookmark_done.connect(self._on_bookmark_done, Q)
        s.bookmark_error.connect(self._on_bookmark_error, Q)
        s.autocomplete_done.connect(self._on_autocomplete_done, Q)
        s.batch_progress.connect(self._on_batch_progress, Q)
        s.batch_done.connect(self._on_batch_done, Q)
        s.download_progress.connect(self._on_download_progress, Q)
        s.prefetch_progress.connect(self._on_prefetch_progress, Q)

    def _on_prefetch_progress(self, index: int, progress: float) -> None:
        if 0 <= index < len(self._grid._thumbs):
            self._grid._thumbs[index].set_prefetch_progress(progress)

    def _clear_loading(self) -> None:
        self._loading = False

    def _on_search_error(self, e: str) -> None:
        self._loading = False
        self._status.showMessage(f"Error: {e}")

    def _on_image_error(self, e: str) -> None:
        self._dl_progress.hide()
        self._status.showMessage(f"Error: {e}")

    def _on_bookmark_error(self, e: str) -> None:
        self._status.showMessage(f"Error: {e}")

    def _run_async(self, coro_func, *args):
        future = asyncio.run_coroutine_threadsafe(coro_func(*args), self._async_loop)
        future.add_done_callback(self._on_async_done)

    @staticmethod
    def _on_async_done(future):
        try:
            future.result()
        except Exception as e:
            log.error(f"Async worker failed: {e}")

    def _setup_ui(self) -> None:
        central = QWidget()
        self.setCentralWidget(central)
        layout = QVBoxLayout(central)
        layout.setContentsMargins(8, 8, 8, 8)
        layout.setSpacing(6)

        # Top bar: site selector + rating + search
        top = QHBoxLayout()

        self._site_combo = QComboBox()
        self._site_combo.setMinimumWidth(150)
        self._site_combo.currentIndexChanged.connect(self._on_site_changed)
        top.addWidget(self._site_combo)

        # Rating filter
        self._rating_combo = QComboBox()
        self._rating_combo.addItems(["All", "General", "Sensitive", "Questionable", "Explicit"])
        self._rating_combo.setMinimumWidth(100)
        self._rating_combo.currentTextChanged.connect(self._on_rating_changed)
        top.addWidget(self._rating_combo)

        # Score filter — type the value directly. Spinbox arrows hidden
        # since the field is small enough to type into and the +/- buttons
        # were just visual noise. setFixedHeight(23) overrides Qt's
        # QSpinBox sizeHint which still reserves vertical space for the
        # arrow buttons internally even when `setButtonSymbols(NoButtons)`
        # is set, leaving the spinbox 3px taller than the surrounding
        # combos/inputs/buttons in the top toolbar (26 vs 23).
        score_label = QLabel("Score≥")
        top.addWidget(score_label)
        self._score_spin = QSpinBox()
        self._score_spin.setRange(0, 99999)
        self._score_spin.setValue(0)
        self._score_spin.setFixedWidth(50)
        self._score_spin.setFixedHeight(23)
        self._score_spin.setButtonSymbols(QSpinBox.ButtonSymbols.NoButtons)
        top.addWidget(self._score_spin)

        self._media_filter = QComboBox()
        self._media_filter.addItems(["All", "Animated", "Video", "GIF", "Audio"])
        self._media_filter.setToolTip("Filter by media type")
        self._media_filter.setFixedWidth(90)
        top.addWidget(self._media_filter)

        page_label = QLabel("Page")
        top.addWidget(page_label)
        self._page_spin = QSpinBox()
        self._page_spin.setRange(1, 99999)
        self._page_spin.setValue(1)
        self._page_spin.setFixedWidth(50)
        self._page_spin.setFixedHeight(23)  # match the surrounding 23px row
        self._page_spin.setButtonSymbols(QSpinBox.ButtonSymbols.NoButtons)
        top.addWidget(self._page_spin)

        self._search_bar = SearchBar(db=self._db)
        self._search_bar.search_requested.connect(self._on_search)
        self._search_bar.autocomplete_requested.connect(self._request_autocomplete)
        top.addWidget(self._search_bar, stretch=1)

        layout.addLayout(top)

        # Nav bar
        nav = QHBoxLayout()
        self._browse_btn = QPushButton("Browse")
        self._browse_btn.setCheckable(True)
        self._browse_btn.setChecked(True)
        self._browse_btn.clicked.connect(lambda: self._switch_view(0))
        nav.addWidget(self._browse_btn)

        self._bookmark_btn = QPushButton("Bookmarks")
        self._bookmark_btn.setCheckable(True)
        self._bookmark_btn.clicked.connect(lambda: self._switch_view(1))
        nav.addWidget(self._bookmark_btn)

        self._library_btn = QPushButton("Library")
        self._library_btn.setCheckable(True)
        self._library_btn.setFixedWidth(80)
        self._library_btn.clicked.connect(lambda: self._switch_view(2))
        nav.addWidget(self._library_btn)

        layout.addLayout(nav)

        # Main content
        self._splitter = QSplitter(Qt.Orientation.Horizontal)

        # Left: stacked views
        self._stack = QStackedWidget()

        self._grid = ThumbnailGrid()
        self._grid.post_selected.connect(self._on_post_selected)
        self._grid.post_activated.connect(self._on_post_activated)
        self._grid.context_requested.connect(self._on_context_menu)
        self._grid.multi_context_requested.connect(self._on_multi_context_menu)
        self._grid.nav_past_end.connect(self._on_nav_past_end)
        self._grid.nav_before_start.connect(self._on_nav_before_start)
        self._stack.addWidget(self._grid)

        self._bookmarks_view = BookmarksView(self._db)
        self._bookmarks_view.bookmark_selected.connect(self._on_bookmark_selected)
        self._bookmarks_view.bookmark_activated.connect(self._on_bookmark_activated)
        self._bookmarks_view.bookmarks_changed.connect(self._refresh_browse_saved_dots)
        self._bookmarks_view.open_in_browser_requested.connect(
            lambda site_id, post_id: self._open_post_id_in_browser(post_id, site_id=site_id)
        )
        self._stack.addWidget(self._bookmarks_view)

        self._library_view = LibraryView(db=self._db)
        self._library_view.file_selected.connect(self._on_library_selected)
        self._library_view.file_activated.connect(self._on_library_activated)
        self._library_view.files_deleted.connect(self._on_library_files_deleted)
        self._stack.addWidget(self._library_view)

        self._splitter.addWidget(self._stack)

        # Right: preview + info (vertical split)
        self._right_splitter = right = QSplitter(Qt.Orientation.Vertical)

        self._preview = ImagePreview()
        self._preview.close_requested.connect(self._close_preview)
        self._preview.open_in_default.connect(self._open_preview_in_default)
        self._preview.open_in_browser.connect(self._open_preview_in_browser)
        self._preview.bookmark_requested.connect(self._bookmark_from_preview)
        self._preview.save_to_folder.connect(self._save_from_preview)
        self._preview.unsave_requested.connect(self._unsave_from_preview)
        self._preview.blacklist_tag_requested.connect(self._blacklist_tag_from_popout)
        self._preview.blacklist_post_requested.connect(self._blacklist_post_from_popout)
        self._preview.navigate.connect(self._navigate_preview)
        self._preview.play_next_requested.connect(self._on_video_end_next)
        self._preview.fullscreen_requested.connect(self._open_fullscreen_preview)
        self._preview.set_folders_callback(self._db.get_folders)
        self._fullscreen_window = None
        # Wide enough that the preview toolbar (Bookmark, Save, BL Tag,
        # BL Post, [stretch], Popout) has room to lay out all five buttons
        # at their fixed widths plus spacing without clipping the rightmost
        # one or compressing the row visually.
        self._preview.setMinimumWidth(380)
        right.addWidget(self._preview)

        self._dl_progress = QProgressBar()
        self._dl_progress.setMaximumHeight(6)
        self._dl_progress.setTextVisible(False)
        self._dl_progress.hide()
        right.addWidget(self._dl_progress)

        self._info_panel = InfoPanel()
        self._info_panel.tag_clicked.connect(self._on_tag_clicked)
        self._info_panel.setMinimumHeight(100)
        self._info_panel.hide()
        right.addWidget(self._info_panel)

        # Restore the right splitter sizes (preview / dl_progress / info)
        # from the persisted state. Falls back to the historic default if
        # nothing is saved or the saved string is malformed.
        saved_right = self._db.get_setting("right_splitter_sizes")
        right_applied = False
        if saved_right:
            try:
                parts = [int(p) for p in saved_right.split(",")]
                if len(parts) == 3 and all(p >= 0 for p in parts) and sum(parts) > 0:
                    right.setSizes(parts)
                    right_applied = True
            except ValueError:
                pass
        if not right_applied:
            right.setSizes([500, 0, 200])

        # Restore info panel visibility from the persisted state.
        if self._db.get_setting_bool("info_panel_visible"):
            self._info_panel.show()

        # Flag set during popout open/close so the splitter saver below
        # doesn't persist the temporary [0, 0, 1000] state the popout
        # uses to give the info panel the full right column.
        self._popout_active = False

        # Debounced saver for the right splitter (same pattern as main).
        self._right_splitter_save_timer = QTimer(self)
        self._right_splitter_save_timer.setSingleShot(True)
        self._right_splitter_save_timer.setInterval(300)
        self._right_splitter_save_timer.timeout.connect(self._save_right_splitter_sizes)
        right.splitterMoved.connect(
            lambda *_: self._right_splitter_save_timer.start()
        )

        self._splitter.addWidget(right)

        # Restore the persisted main-splitter sizes if present, otherwise
        # fall back to the historic default. The sizes are saved as a
        # comma-separated string in the settings table — same format as
        # slideshow_geometry to keep things consistent.
        saved_main_split = self._db.get_setting("main_splitter_sizes")
        applied = False
        if saved_main_split:
            try:
                parts = [int(p) for p in saved_main_split.split(",")]
                if len(parts) == 2 and all(p >= 0 for p in parts) and sum(parts) > 0:
                    self._splitter.setSizes(parts)
                    applied = True
            except ValueError:
                pass
        if not applied:
            self._splitter.setSizes([600, 500])
        # Debounced save on drag — splitterMoved fires hundreds of times
        # per second, so we restart a 300ms one-shot and save when it stops.
        self._main_splitter_save_timer = QTimer(self)
        self._main_splitter_save_timer.setSingleShot(True)
        self._main_splitter_save_timer.setInterval(300)
        self._main_splitter_save_timer.timeout.connect(self._save_main_splitter_sizes)
        self._splitter.splitterMoved.connect(
            lambda *_: self._main_splitter_save_timer.start()
        )
        layout.addWidget(self._splitter, stretch=1)

        # Bottom page nav (centered)
        self._bottom_nav = QWidget()
        bottom_nav = QHBoxLayout(self._bottom_nav)
        bottom_nav.setContentsMargins(0, 4, 0, 4)
        bottom_nav.addStretch()
        self._page_label = QLabel("Page 1")
        bottom_nav.addWidget(self._page_label)
        self._prev_page_btn = QPushButton("Prev")
        self._prev_page_btn.setFixedWidth(60)
        self._prev_page_btn.clicked.connect(self._prev_page)
        bottom_nav.addWidget(self._prev_page_btn)
        self._next_page_btn = QPushButton("Next")
        self._next_page_btn.setFixedWidth(60)
        self._next_page_btn.clicked.connect(self._next_page)
        bottom_nav.addWidget(self._next_page_btn)
        bottom_nav.addStretch()
        layout.addWidget(self._bottom_nav)

        # Infinite scroll
        self._infinite_scroll = self._db.get_setting_bool("infinite_scroll")
        if self._infinite_scroll:
            self._bottom_nav.hide()
        self._grid.reached_bottom.connect(self._on_reached_bottom)
        self._grid.verticalScrollBar().rangeChanged.connect(self._on_scroll_range_changed)

        # Log panel
        self._log_text = QTextEdit()
        self._log_text.setReadOnly(True)
        self._log_text.setMaximumHeight(150)
        self._log_text.setStyleSheet("font-family: monospace; font-size: 11px;")
        self._log_text.hide()
        layout.addWidget(self._log_text)

        # Hook up logging
        self._log_handler = LogHandler(self._log_text)
        self._log_handler.setLevel(logging.DEBUG)
        logging.getLogger("booru").addHandler(self._log_handler)
        logging.getLogger("booru").setLevel(logging.DEBUG)

        # Status bar
        self._status = QStatusBar()
        self.setStatusBar(self._status)
        self._status.showMessage("Ready")

        # Global shortcuts for preview navigation
        QShortcut(QKeySequence("Left"), self, lambda: self._navigate_preview(-1))
        QShortcut(QKeySequence("Right"), self, lambda: self._navigate_preview(1))
        QShortcut(QKeySequence("Ctrl+C"), self, self._copy_file_to_clipboard)

    def _setup_menu(self) -> None:
        menu = self.menuBar()
        file_menu = menu.addMenu("&File")

        sites_action = QAction("&Manage Sites...", self)
        sites_action.setShortcut(QKeySequence("Ctrl+S"))
        sites_action.triggered.connect(self._open_site_manager)
        file_menu.addAction(sites_action)

        settings_action = QAction("Se&ttings...", self)
        settings_action.setShortcut(QKeySequence("Ctrl+,"))
        settings_action.triggered.connect(self._open_settings)
        file_menu.addAction(settings_action)

        file_menu.addSeparator()

        batch_action = QAction("Batch &Download Page...", self)
        batch_action.setShortcut(QKeySequence("Ctrl+D"))
        batch_action.triggered.connect(self._batch_download)
        file_menu.addAction(batch_action)

        file_menu.addSeparator()

        quit_action = QAction("&Quit", self)
        quit_action.setShortcut(QKeySequence("Ctrl+Q"))
        quit_action.triggered.connect(self.close)
        file_menu.addAction(quit_action)

        view_menu = menu.addMenu("&View")

        info_action = QAction("Toggle &Info Panel", self)
        info_action.setShortcut(QKeySequence("Ctrl+I"))
        info_action.triggered.connect(self._toggle_info)
        view_menu.addAction(info_action)

        log_action = QAction("Toggle &Log", self)
        log_action.setShortcut(QKeySequence("Ctrl+L"))
        log_action.triggered.connect(self._toggle_log)
        view_menu.addAction(log_action)

        view_menu.addSeparator()

        fullscreen_action = QAction("&Fullscreen", self)
        fullscreen_action.setShortcut(QKeySequence("F11"))
        fullscreen_action.triggered.connect(self._toggle_fullscreen)
        view_menu.addAction(fullscreen_action)

        privacy_action = QAction("&Privacy Screen", self)
        privacy_action.setShortcut(QKeySequence("Ctrl+P"))
        privacy_action.triggered.connect(self._toggle_privacy)
        view_menu.addAction(privacy_action)

    def _load_sites(self) -> None:
        self._site_combo.clear()
        for site in self._db.get_sites():
            self._site_combo.addItem(site.name, site.id)
        # Select default site if configured
        default_id = self._db.get_setting_int("default_site_id")
        if default_id:
            idx = self._site_combo.findData(default_id)
            if idx >= 0:
                self._site_combo.setCurrentIndex(idx)

    def _make_client(self) -> BooruClient | None:
        if not self._current_site:
            return None
        s = self._current_site
        return client_for_type(s.api_type, s.url, s.api_key, s.api_user)

    def _on_site_changed(self, index: int) -> None:
        if index < 0:
            self._current_site = None
            return
        site_id = self._site_combo.currentData()
        sites = self._db.get_sites()
        site = next((s for s in sites if s.id == site_id), None)
        if not site:
            return
        self._current_site = site
        self._status.showMessage(f"Connected to {site.name}")

    def _on_rating_changed(self, text: str) -> None:
        self._current_rating = text.lower()

    def _switch_view(self, index: int) -> None:
        self._stack.setCurrentIndex(index)
        self._browse_btn.setChecked(index == 0)
        self._bookmark_btn.setChecked(index == 1)
        self._library_btn.setChecked(index == 2)
        # Clear grid selections and current post to prevent cross-tab action conflicts
        # Preview media stays visible but actions are disabled until a new post is selected
        self._grid.clear_selection()
        self._bookmarks_view._grid.clear_selection()
        self._library_view._grid.clear_selection()
        self._preview._current_post = None
        self._preview._current_site_id = None
        self._preview.update_bookmark_state(False)
        self._preview.update_save_state(False)
        # Show/hide preview toolbar buttons per tab
        is_library = index == 2
        self._preview._bookmark_btn.setVisible(not is_library)
        self._preview._bl_tag_btn.setVisible(not is_library)
        self._preview._bl_post_btn.setVisible(not is_library)
        if index == 1:
            self._bookmarks_view.refresh()
            self._bookmarks_view._grid.setFocus()
        elif index == 2:
            self._library_view.refresh()
        else:
            self._grid.setFocus()

    def _on_tag_clicked(self, tag: str) -> None:
        self._preview.clear()
        self._switch_view(0)
        self._search_bar.set_text(tag)
        self._on_search(tag)

    # -- Search --

    def _on_search(self, tags: str) -> None:
        self._current_tags = tags
        self._current_page = self._page_spin.value()
        self._search = SearchState()
        self._min_score = self._score_spin.value()
        self._preview.clear()
        self._next_page_btn.setVisible(True)
        self._prev_page_btn.setVisible(False)
        self._do_search()

    def _prev_page(self) -> None:
        if self._current_page > 1:
            self._current_page -= 1
            if self._current_page in self._search.page_cache:
                self._signals.search_done.emit(self._search.page_cache[self._current_page])
            else:
                self._do_search()

    def _next_page(self) -> None:
        if self._loading:
            return
        self._current_page += 1
        if self._current_page in self._search.page_cache:
            self._signals.search_done.emit(self._search.page_cache[self._current_page])
            return
        self._do_search()

    def _on_nav_past_end(self) -> None:
        if self._infinite_scroll:
            return  # infinite scroll handles this via reached_bottom
        self._search.nav_page_turn = "first"
        self._next_page()

    def _on_nav_before_start(self) -> None:
        if self._infinite_scroll:
            return
        if self._current_page > 1:
            self._search.nav_page_turn = "last"
            self._prev_page()

    def _on_reached_bottom(self) -> None:
        if not self._infinite_scroll or self._loading or self._search.infinite_exhausted:
            return
        self._loading = True
        self._current_page += 1

        search_tags = self._build_search_tags()
        page = self._current_page
        limit = self._db.get_setting_int("page_size") or 40

        bl_tags = set()
        if self._db.get_setting_bool("blacklist_enabled"):
            bl_tags = set(self._db.get_blacklisted_tags())
        bl_posts = self._db.get_blacklisted_posts()
        shown_ids = self._search.shown_post_ids.copy()
        seen = shown_ids.copy()  # local dedup for this backfill round

        def _filter(posts):
            if bl_tags:
                posts = [p for p in posts if not bl_tags.intersection(p.tag_list)]
            if bl_posts:
                posts = [p for p in posts if p.file_url not in bl_posts]
            posts = [p for p in posts if p.id not in seen]
            seen.update(p.id for p in posts)
            return posts

        async def _search():
            client = self._make_client()
            collected = []
            last_page = page
            api_exhausted = False
            try:
                current_page = page
                batch = await client.search(tags=search_tags, page=current_page, limit=limit)
                last_page = current_page
                filtered = _filter(batch)
                collected.extend(filtered)
                if len(batch) < limit:
                    api_exhausted = True
                elif len(collected) < limit:
                    for _ in range(9):
                        await asyncio.sleep(0.3)
                        current_page += 1
                        batch = await client.search(tags=search_tags, page=current_page, limit=limit)
                        last_page = current_page
                        filtered = _filter(batch)
                        collected.extend(filtered)
                        if len(batch) < limit:
                            api_exhausted = True
                            break
                        if len(collected) >= limit:
                            break
            except Exception as e:
                log.warning(f"Infinite scroll fetch failed: {e}")
            finally:
                self._search.infinite_last_page = last_page
                self._search.infinite_api_exhausted = api_exhausted
                self._signals.search_append.emit(collected)
                await client.close()

        self._run_async(_search)

    def _scroll_next_page(self) -> None:
        if self._loading:
            return
        self._current_page += 1
        self._do_search()

    def _scroll_prev_page(self) -> None:
        if self._loading or self._current_page <= 1:
            return
        self._current_page -= 1
        self._do_search()

    def _build_search_tags(self) -> str:
        """Build tag string with rating filter and negative tags."""
        parts = []
        if self._current_tags:
            parts.append(self._current_tags)

        # Rating filter — site-specific syntax
        # Danbooru/Gelbooru: 4-tier (general, sensitive, questionable, explicit)
        # Moebooru/e621: 3-tier (safe, questionable, explicit)
        rating = self._current_rating
        if rating != "all" and self._current_site:
            api = self._current_site.api_type
            if api == "danbooru":
                # Danbooru accepts both full words and single letters
                danbooru_map = {
                    "general": "g", "sensitive": "s",
                    "questionable": "q", "explicit": "e",
                }
                if rating in danbooru_map:
                    parts.append(f"rating:{danbooru_map[rating]}")
            elif api == "gelbooru":
                # Gelbooru requires full words, no abbreviations
                gelbooru_map = {
                    "general": "general", "sensitive": "sensitive",
                    "questionable": "questionable", "explicit": "explicit",
                }
                if rating in gelbooru_map:
                    parts.append(f"rating:{gelbooru_map[rating]}")
            elif api == "e621":
                # e621: 3-tier (s/q/e), accepts both full words and letters
                e621_map = {
                    "general": "s", "sensitive": "s",
                    "questionable": "q", "explicit": "e",
                }
                if rating in e621_map:
                    parts.append(f"rating:{e621_map[rating]}")
            else:
                # Moebooru (yande.re, konachan) — 3-tier, full words work
                # "general" and "sensitive" don't exist, map to "safe"
                moebooru_map = {
                    "general": "safe", "sensitive": "safe",
                    "questionable": "questionable", "explicit": "explicit",
                }
                if rating in moebooru_map:
                    parts.append(f"rating:{moebooru_map[rating]}")

        # Score filter
        if self._min_score > 0:
            parts.append(f"score:>={self._min_score}")

        # Media type filter
        media = self._media_filter.currentText()
        if media == "Animated":
            parts.append("animated")
        elif media == "Video":
            parts.append("video")
        elif media == "GIF":
            parts.append("animated_gif")
        elif media == "Audio":
            parts.append("audio")

        return " ".join(parts)

    def _do_search(self) -> None:
        if not self._current_site:
            self._status.showMessage("No site selected")
            return
        self._loading = True
        self._page_label.setText(f"Page {self._current_page}")
        self._status.showMessage("Searching...")

        search_tags = self._build_search_tags()
        log.info(f"Search: tags='{search_tags}' rating={self._current_rating}")
        page = self._current_page
        limit = self._db.get_setting_int("page_size") or 40

        # Gather blacklist filters once on the main thread
        bl_tags = set()
        if self._db.get_setting_bool("blacklist_enabled"):
            bl_tags = set(self._db.get_blacklisted_tags())
        bl_posts = self._db.get_blacklisted_posts()
        shown_ids = self._search.shown_post_ids.copy()
        seen = shown_ids.copy()

        def _filter(posts):
            if bl_tags:
                posts = [p for p in posts if not bl_tags.intersection(p.tag_list)]
            if bl_posts:
                posts = [p for p in posts if p.file_url not in bl_posts]
            posts = [p for p in posts if p.id not in seen]
            seen.update(p.id for p in posts)
            return posts

        async def _search():
            client = self._make_client()
            try:
                collected = []
                current_page = page
                batch = await client.search(tags=search_tags, page=current_page, limit=limit)
                filtered = _filter(batch)
                collected.extend(filtered)
                # Backfill only if first page didn't return enough after filtering
                if len(collected) < limit and len(batch) >= limit:
                    for _ in range(9):
                        await asyncio.sleep(0.3)
                        current_page += 1
                        batch = await client.search(tags=search_tags, page=current_page, limit=limit)
                        filtered = _filter(batch)
                        collected.extend(filtered)
                        log.debug(f"Backfill: page={current_page} batch={len(batch)} filtered={len(filtered)} total={len(collected)}/{limit}")
                        if len(collected) >= limit or len(batch) < limit:
                            break
                self._signals.search_done.emit(collected[:limit])
            except Exception as e:
                self._signals.search_error.emit(str(e))
            finally:
                await client.close()

        self._run_async(_search)

    def _on_search_done(self, posts: list) -> None:
        self._page_label.setText(f"Page {self._current_page}")
        self._posts = posts
        # Cache page results and track shown IDs
        ss = self._search
        ss.shown_post_ids.update(p.id for p in posts)
        ss.page_cache[self._current_page] = posts
        # Cap page cache in pagination mode (infinite scroll needs all pages)
        if not self._infinite_scroll and len(ss.page_cache) > 10:
            oldest = min(ss.page_cache.keys())
            del ss.page_cache[oldest]
        limit = self._db.get_setting_int("page_size") or 40
        at_end = len(posts) < limit
        if at_end:
            self._status.showMessage(f"{len(posts)} results (end)")
        else:
            self._status.showMessage(f"{len(posts)} results")
        # Update pagination buttons
        self._prev_page_btn.setVisible(self._current_page > 1)
        self._next_page_btn.setVisible(not at_end)
        thumbs = self._grid.set_posts(len(posts))
        self._grid.scroll_to_top()
        # Clear loading after a brief delay so scroll signals don't re-trigger
        QTimer.singleShot(100, self._clear_loading)

        from ..core.config import saved_dir, saved_folder_dir
        from ..core.cache import cached_path_for, cache_dir
        site_id = self._site_combo.currentData()

        # Pre-scan saved directories once instead of per-post exists() calls
        _sd = saved_dir()
        _saved_ids: set[int] = set()
        if _sd.exists():
            _saved_ids = {int(f.stem) for f in _sd.iterdir() if f.is_file() and f.stem.isdigit()}
        _folder_saved: dict[str, set[int]] = {}
        for folder in self._db.get_folders():
            d = saved_folder_dir(folder)
            if d.exists():
                _folder_saved[folder] = {int(f.stem) for f in d.iterdir() if f.is_file() and f.stem.isdigit()}

        # Pre-fetch bookmarks for the site once and project to a post-id set
        # so the per-post check below is an O(1) membership test instead of
        # a synchronous SQLite query (was N queries on the GUI thread).
        _favs = self._db.get_bookmarks(site_id=site_id) if site_id else []
        _bookmarked_ids: set[int] = {f.post_id for f in _favs}

        # Pre-scan the cache dir into a name set so the per-post drag-path
        # lookup is one stat-equivalent (one iterdir) instead of N stat calls.
        _cd = cache_dir()
        _cached_names: set[str] = set()
        if _cd.exists():
            _cached_names = {f.name for f in _cd.iterdir() if f.is_file()}

        for i, (post, thumb) in enumerate(zip(posts, thumbs)):
            # Bookmark status (DB)
            if post.id in _bookmarked_ids:
                thumb.set_bookmarked(True)
            # Saved status (filesystem) — independent of bookmark
            saved = post.id in _saved_ids
            if not saved:
                for folder_name, folder_ids in _folder_saved.items():
                    if post.id in folder_ids:
                        saved = True
                        break
            thumb.set_saved_locally(saved)
            # Set drag path from cache
            cached = cached_path_for(post.file_url)
            if cached.name in _cached_names:
                thumb._cached_path = str(cached)

            if post.preview_url:
                self._fetch_thumbnail(i, post.preview_url)

        # Auto-select first/last post if page turn was triggered by navigation
        turn = self._search.nav_page_turn
        if turn and posts:
            self._search.nav_page_turn = None
            if turn == "first":
                idx = 0
            else:
                idx = len(posts) - 1
            self._grid._select(idx)
            self._on_post_activated(idx)

        self._grid.setFocus()

        # Start prefetching from top of page
        if self._db.get_setting("prefetch_mode") in ("Nearby", "Aggressive") and posts:
            self._prefetch_adjacent(0)

        # Infinite scroll: if first page doesn't fill viewport, load more
        if self._infinite_scroll and posts:
            QTimer.singleShot(200, self._check_viewport_fill)

    def _on_scroll_range_changed(self, _min: int, max_val: int) -> None:
        """Scrollbar range changed (resize/splitter) — check if viewport needs filling."""
        if max_val == 0 and self._infinite_scroll and self._posts:
            QTimer.singleShot(100, self._check_viewport_fill)

    def _check_viewport_fill(self) -> None:
        """If content doesn't fill the viewport, trigger infinite scroll."""
        if not self._infinite_scroll or self._loading or self._search.infinite_exhausted:
            return
        # Force layout update so scrollbar range is current
        self._grid.widget().updateGeometry()
        QApplication.processEvents()
        sb = self._grid.verticalScrollBar()
        if sb.maximum() == 0 and self._posts:
            self._on_reached_bottom()

    def _on_search_append(self, posts: list) -> None:
        """Queue posts and add them one at a time as thumbnails arrive."""
        ss = self._search

        if not posts:
            # Only advance page if API is exhausted — otherwise we retry
            if ss.infinite_api_exhausted and ss.infinite_last_page > self._current_page:
                self._current_page = ss.infinite_last_page
            self._loading = False
            # Only mark exhausted if the API itself returned a short page,
            # not just because blacklist/dedup filtering emptied the results
            if ss.infinite_api_exhausted:
                ss.infinite_exhausted = True
                self._status.showMessage(f"{len(self._posts)} results (end)")
            else:
                # Viewport still not full ��� keep loading
                QTimer.singleShot(100, self._check_viewport_fill)
            return
        # Advance page counter past pages consumed by backfill
        if ss.infinite_last_page > self._current_page:
            self._current_page = ss.infinite_last_page
        ss.shown_post_ids.update(p.id for p in posts)
        ss.append_queue.extend(posts)
        self._drain_append_queue()

    def _drain_append_queue(self) -> None:
        """Add all queued posts to the grid at once, thumbnails load async."""
        ss = self._search
        if not ss.append_queue:
            self._loading = False
            return

        from ..core.config import saved_dir
        from ..core.cache import cached_path_for, cache_dir
        site_id = self._site_combo.currentData()
        _sd = saved_dir()
        _saved_ids: set[int] = set()
        if _sd.exists():
            _saved_ids = {int(f.stem) for f in _sd.iterdir() if f.is_file() and f.stem.isdigit()}

        # Pre-fetch bookmarks → set, and pre-scan cache dir → set, so the
        # per-post checks below avoid N synchronous SQLite/stat calls on the
        # GUI thread (matches the optimisation in _on_search_done).
        _favs = self._db.get_bookmarks(site_id=site_id) if site_id else []
        _bookmarked_ids: set[int] = {f.post_id for f in _favs}
        _cd = cache_dir()
        _cached_names: set[str] = set()
        if _cd.exists():
            _cached_names = {f.name for f in _cd.iterdir() if f.is_file()}

        posts = ss.append_queue[:]
        ss.append_queue.clear()
        start_idx = len(self._posts)
        self._posts.extend(posts)
        thumbs = self._grid.append_posts(len(posts))

        for i, (post, thumb) in enumerate(zip(posts, thumbs)):
            idx = start_idx + i
            if post.id in _bookmarked_ids:
                thumb.set_bookmarked(True)
            thumb.set_saved_locally(post.id in _saved_ids)
            cached = cached_path_for(post.file_url)
            if cached.name in _cached_names:
                thumb._cached_path = str(cached)
            if post.preview_url:
                self._fetch_thumbnail(idx, post.preview_url)

        self._status.showMessage(f"{len(self._posts)} results")

        # All done — unlock loading, evict
        self._loading = False
        self._auto_evict_cache()
        # Check if still at bottom or content doesn't fill viewport
        sb = self._grid.verticalScrollBar()
        from .grid import THUMB_SIZE, THUMB_SPACING
        threshold = THUMB_SIZE + THUMB_SPACING * 2
        if sb.maximum() == 0 or sb.value() >= sb.maximum() - threshold:
            self._on_reached_bottom()

    def _fetch_thumbnail(self, index: int, url: str) -> None:
        async def _download():
            try:
                path = await download_thumbnail(url)
                self._signals.thumb_done.emit(index, str(path))
            except Exception as e:
                log.warning(f"Thumb #{index} failed: {e}")
        self._run_async(_download)

    def _on_thumb_done(self, index: int, path: str) -> None:
        thumbs = self._grid._thumbs
        if 0 <= index < len(thumbs):
            pix = QPixmap(path)
            if not pix.isNull():
                thumbs[index].set_pixmap(pix)

    # -- Autocomplete --

    def _request_autocomplete(self, query: str) -> None:
        if not self._current_site or len(query) < 2:
            return

        async def _ac():
            client = self._make_client()
            try:
                results = await client.autocomplete(query)
                self._signals.autocomplete_done.emit(results)
            except Exception as e:
                log.warning(f"Operation failed: {e}")
            finally:
                await client.close()

        self._run_async(_ac)

    def _on_autocomplete_done(self, suggestions: list) -> None:
        self._search_bar.set_suggestions(suggestions)

    # -- Post selection / preview --

    def _on_post_selected(self, index: int) -> None:
        multi = self._grid.selected_indices
        if len(multi) > 1:
            self._status.showMessage(f"{len(multi)} posts selected")
            return
        if 0 <= index < len(self._posts):
            post = self._posts[index]
            self._status.showMessage(
                f"#{post.id}  {post.width}x{post.height}  score:{post.score}  [{post.rating}]  {Path(post.file_url.split('?')[0]).suffix.lstrip('.').upper() if post.file_url else ''}"
                + (f"  {post.created_at}" if post.created_at else "")
            )
            if self._info_panel.isVisible():
                self._info_panel.set_post(post)
            self._on_post_activated(index)

    def _on_post_activated(self, index: int) -> None:
        if 0 <= index < len(self._posts):
            post = self._posts[index]
            log.info(f"Preview: #{post.id} -> {post.file_url}")
            self._preview._current_post = post
            self._preview._current_site_id = self._site_combo.currentData()
            self._preview.set_post_tags(post.tag_categories, post.tag_list)
            site_id = self._preview._current_site_id
            self._preview.update_bookmark_state(
                bool(site_id and self._db.is_bookmarked(site_id, post.id))
            )
            self._preview.update_save_state(self._is_post_saved(post.id))
            self._status.showMessage(f"Loading #{post.id}...")
            self._dl_progress.show()
            self._dl_progress.setRange(0, 0)

            def _progress(downloaded, total):
                self._signals.download_progress.emit(downloaded, total)

            async def _load():
                self._prefetch_pause.clear()  # pause prefetch
                try:
                    path = await download_image(post.file_url, progress_callback=_progress)
                    info = (f"#{post.id}  {post.width}x{post.height}  score:{post.score}  [{post.rating}]  {Path(post.file_url.split('?')[0]).suffix.lstrip('.').upper() if post.file_url else ''}"
                            + (f"  {post.created_at}" if post.created_at else ""))
                    self._signals.image_done.emit(str(path), info)
                except Exception as e:
                    log.error(f"Image download failed: {e}")
                    self._signals.image_error.emit(str(e))
                finally:
                    self._prefetch_pause.set()  # resume prefetch

            self._run_async(_load)

            # Prefetch adjacent posts
            if self._db.get_setting("prefetch_mode") in ("Nearby", "Aggressive"):
                self._prefetch_adjacent(index)

    def _prefetch_adjacent(self, index: int) -> None:
        """Prefetch posts around the given index."""
        total = len(self._posts)
        if total == 0:
            return
        cols = self._grid._flow.columns
        mode = self._db.get_setting("prefetch_mode")

        if mode == "Nearby":
            # Just 4 cardinals: left, right, up, down
            order = []
            for offset in [1, -1, cols, -cols]:
                adj = index + offset
                if 0 <= adj < total:
                    order.append(adj)
        else:
            # Aggressive: ring expansion, capped to ~3 rows radius
            max_radius = 3
            max_posts = cols * max_radius * 2 + cols  # ~3 rows above and below
            seen = {index}
            order = []
            for dist in range(1, max_radius + 1):
                ring = set()
                for dy in (-dist, 0, dist):
                    for dx in (-dist, 0, dist):
                        if dy == 0 and dx == 0:
                            continue
                        adj = index + dy * cols + dx
                        if 0 <= adj < total and adj not in seen:
                            ring.add(adj)
                for adj in (index + dist, index - dist):
                    if 0 <= adj < total and adj not in seen:
                        ring.add(adj)
                for adj in sorted(ring):
                    seen.add(adj)
                    order.append(adj)
                if len(order) >= max_posts:
                    break

        async def _prefetch_spiral():
            for adj in order:
                await self._prefetch_pause.wait()  # yield to active downloads
                if 0 <= adj < len(self._posts) and self._posts[adj].file_url:
                    self._signals.prefetch_progress.emit(adj, 0.0)
                    try:
                        def _progress(dl, total_bytes, idx=adj):
                            if total_bytes > 0:
                                self._signals.prefetch_progress.emit(idx, dl / total_bytes)
                        await download_image(self._posts[adj].file_url, progress_callback=_progress)
                    except Exception as e:
                        log.warning(f"Operation failed: {e}")
                    self._signals.prefetch_progress.emit(adj, -1)
                    await asyncio.sleep(0.2)  # gentle pacing
        self._run_async(_prefetch_spiral)

    def _on_download_progress(self, downloaded: int, total: int) -> None:
        if total > 0:
            self._dl_progress.setRange(0, total)
            self._dl_progress.setValue(downloaded)
            self._dl_progress.show()
            mb = downloaded / (1024 * 1024)
            total_mb = total / (1024 * 1024)
            self._status.showMessage(f"Downloading... {mb:.1f}/{total_mb:.1f} MB")
        else:
            self._dl_progress.setRange(0, 0)  # indeterminate
            self._dl_progress.show()

    def _set_preview_media(self, path: str, info: str) -> None:
        """Set media on preview or just info if slideshow is open."""
        if self._fullscreen_window and self._fullscreen_window.isVisible():
            self._preview._info_label.setText(info)
            self._preview._current_path = path
        else:
            self._preview.set_media(path, info)

    def _update_fullscreen(self, path: str, info: str) -> None:
        """Sync the fullscreen window with the current preview media."""
        if self._fullscreen_window and self._fullscreen_window.isVisible():
            self._preview._video_player.stop()
            self._fullscreen_window.set_media(path, info)
            # Show/hide action buttons based on current tab
            show = self._stack.currentIndex() != 2
            self._fullscreen_window._bookmark_btn.setVisible(show)
            self._fullscreen_window._save_btn.setVisible(show)
            self._fullscreen_window._bl_tag_btn.setVisible(show)
            self._fullscreen_window._bl_post_btn.setVisible(show)
            if show:
                self._update_fullscreen_state()

    def _update_fullscreen_state(self) -> None:
        """Update popout button states for the current post."""
        if not self._fullscreen_window:
            return
        from ..core.config import saved_dir, saved_folder_dir, MEDIA_EXTENSIONS
        site_id = self._site_combo.currentData()

        if self._stack.currentIndex() == 1:
            # Bookmarks view
            grid = self._bookmarks_view._grid
            favs = self._bookmarks_view._bookmarks
            idx = grid.selected_index
            if 0 <= idx < len(favs):
                fav = favs[idx]
                saved = False
                if fav.folder:
                    saved = any(
                        (saved_folder_dir(fav.folder) / f"{fav.post_id}{ext}").exists()
                        for ext in MEDIA_EXTENSIONS
                    )
                else:
                    saved = any(
                        (saved_dir() / f"{fav.post_id}{ext}").exists()
                        for ext in MEDIA_EXTENSIONS
                    )
                self._fullscreen_window.update_state(True, saved)
                self._fullscreen_window.set_post_tags(
                    fav.tag_categories or {}, (fav.tags or "").split()
                )
            else:
                self._fullscreen_window.update_state(False, False)
        else:
            post = None
            idx = self._grid.selected_index
            if 0 <= idx < len(self._posts):
                post = self._posts[idx]
            elif self._preview._current_post:
                post = self._preview._current_post
            if post:
                s_id = self._preview._current_site_id or site_id
                bookmarked = bool(s_id and self._db.is_bookmarked(s_id, post.id))
                saved = self._is_post_saved(post.id)
                self._fullscreen_window.update_state(bookmarked, saved)
                self._fullscreen_window.set_post_tags(post.tag_categories, post.tag_list)
            else:
                self._fullscreen_window.update_state(False, False)

    def _on_image_done(self, path: str, info: str) -> None:
        self._dl_progress.hide()
        if self._fullscreen_window and self._fullscreen_window.isVisible():
            # Popout is open — only show there, keep preview clear
            self._preview._info_label.setText(info)
            self._preview._current_path = path
        else:
            self._set_preview_media(path, info)
        self._status.showMessage(f"{len(self._posts)} results — Loaded")
        # Update drag path on the selected thumbnail
        idx = self._grid.selected_index
        if 0 <= idx < len(self._grid._thumbs):
            self._grid._thumbs[idx]._cached_path = path
        self._update_fullscreen(path, info)
        # Auto-evict if over cache limit
        self._auto_evict_cache()

    def _auto_evict_cache(self) -> None:
        if not self._db.get_setting_bool("auto_evict"):
            return
        max_mb = self._db.get_setting_int("max_cache_mb")
        if max_mb <= 0:
            return
        max_bytes = max_mb * 1024 * 1024
        current = cache_size_bytes(include_thumbnails=False)
        if current > max_bytes:
            protected = set()
            for fav in self._db.get_bookmarks(limit=999999):
                if fav.cached_path:
                    protected.add(fav.cached_path)
            evicted = evict_oldest(max_bytes, protected)
            if evicted:
                log.info(f"Auto-evicted {evicted} cached files")
        # Thumbnail eviction
        max_thumb_mb = self._db.get_setting_int("max_thumb_cache_mb") or 500
        max_thumb_bytes = max_thumb_mb * 1024 * 1024
        evicted_thumbs = evict_oldest_thumbnails(max_thumb_bytes)
        if evicted_thumbs:
            log.info(f"Auto-evicted {evicted_thumbs} thumbnails")

    def _set_library_info(self, path: str) -> None:
        """Update info panel with library metadata for the given file."""
        stem = Path(path).stem
        if not stem.isdigit():
            return
        meta = self._db.get_library_meta(int(stem))
        if meta:
            from ..core.api.base import Post
            p = Post(
                id=int(stem), file_url=meta.get("file_url", ""),
                preview_url=None, tags=meta.get("tags", ""),
                score=meta.get("score", 0), rating=meta.get("rating"),
                source=meta.get("source"), tag_categories=meta.get("tag_categories", {}),
            )
            self._info_panel.set_post(p)
            info = f"#{p.id}  score:{p.score}  [{p.rating}]  {Path(path).suffix.lstrip('.').upper()}" + (f"  {p.created_at}" if p.created_at else "")
            self._status.showMessage(info)

    def _on_library_selected(self, path: str) -> None:
        self._show_library_post(path)

    def _on_library_activated(self, path: str) -> None:
        self._show_library_post(path)

    def _show_library_post(self, path: str) -> None:
        self._set_preview_media(path, Path(path).name)
        self._update_fullscreen(path, Path(path).name)
        self._set_library_info(path)
        # Build a Post from library metadata so toolbar actions work
        stem = Path(path).stem
        if stem.isdigit():
            post_id = int(stem)
            from ..core.api.base import Post
            meta = self._db.get_library_meta(post_id) or {}
            post = Post(
                id=post_id, file_url=meta.get("file_url", ""),
                preview_url=None, tags=meta.get("tags", ""),
                score=meta.get("score", 0), rating=meta.get("rating"),
                source=meta.get("source"),
                tag_categories=meta.get("tag_categories", {}),
            )
            self._preview._current_post = post
            self._preview._current_site_id = self._site_combo.currentData()
            self._preview.update_save_state(True)
            self._preview.set_post_tags(post.tag_categories, post.tag_list)
        else:
            self._preview._current_post = None
            self._preview.update_save_state(True)

    def _on_bookmark_selected(self, fav) -> None:
        self._status.showMessage(f"Bookmark #{fav.post_id}")
        # Show bookmark tags in info panel
        from ..core.api.base import Post
        cats = fav.tag_categories or {}
        if not cats:
            meta = self._db.get_library_meta(fav.post_id)
            cats = meta.get("tag_categories", {}) if meta else {}
        p = Post(
            id=fav.post_id, file_url=fav.file_url or "",
            preview_url=fav.preview_url, tags=fav.tags or "",
            score=fav.score or 0, rating=fav.rating,
            source=fav.source, tag_categories=cats,
        )
        self._info_panel.set_post(p)
        self._on_bookmark_activated(fav)

    def _on_bookmark_activated(self, fav) -> None:
        from ..core.api.base import Post
        cats = fav.tag_categories or {}
        post = Post(
            id=fav.post_id, file_url=fav.file_url or "",
            preview_url=fav.preview_url, tags=fav.tags or "",
            score=fav.score or 0, rating=fav.rating,
            source=fav.source, tag_categories=cats,
        )
        self._preview._current_post = post
        self._preview._current_site_id = fav.site_id
        self._preview.set_post_tags(post.tag_categories, post.tag_list)
        self._preview.update_bookmark_state(
            bool(self._db.is_bookmarked(fav.site_id, post.id))
        )
        self._preview.update_save_state(self._is_post_saved(post.id))
        info = f"Bookmark #{fav.post_id}"

        # Try local cache first
        if fav.cached_path and Path(fav.cached_path).exists():
            self._set_preview_media(fav.cached_path, info)
            self._update_fullscreen(fav.cached_path, info)
            return

        # Try saved library
        from ..core.config import saved_dir, saved_folder_dir
        search_dirs = [saved_dir()]
        if fav.folder:
            search_dirs.insert(0, saved_folder_dir(fav.folder))
        for d in search_dirs:
            for ext in MEDIA_EXTENSIONS:
                path = d / f"{fav.post_id}{ext}"
                if path.exists():
                    self._set_preview_media(str(path), info)
                    self._update_fullscreen(str(path), info)
                    return

        # Download it
        self._status.showMessage(f"Downloading #{fav.post_id}...")

        async def _dl():
            try:
                path = await download_image(fav.file_url)
                # Update cached_path in DB
                self._db.update_bookmark_cache_path(fav.id, str(path))
                info = f"Bookmark #{fav.post_id}"
                self._signals.image_done.emit(str(path), info)
            except Exception as e:
                self._signals.image_error.emit(str(e))

        self._run_async(_dl)

    def _save_main_splitter_sizes(self) -> None:
        """Persist the main grid/preview splitter sizes (debounced).

        Refuses to save when either side is collapsed (size 0). The user can
        end up with a collapsed right panel transiently — e.g. while the
        popout is open and the right panel is empty — and persisting that
        state traps them next launch with no visible preview area until they
        manually drag the splitter back.
        """
        sizes = self._splitter.sizes()
        if len(sizes) >= 2 and all(s > 0 for s in sizes):
            self._db.set_setting(
                "main_splitter_sizes", ",".join(str(s) for s in sizes)
            )

    def _save_right_splitter_sizes(self) -> None:
        """Persist the right splitter sizes (preview / dl_progress / info).

        Skipped while the popout is open — the popout temporarily collapses
        the preview pane and gives the info panel the full right column,
        and we don't want that transient layout persisted as the user's
        preferred state.
        """
        if getattr(self, '_popout_active', False):
            return
        sizes = self._right_splitter.sizes()
        if len(sizes) == 3 and sum(sizes) > 0:
            self._db.set_setting(
                "right_splitter_sizes", ",".join(str(s) for s in sizes)
            )

    def _hyprctl_main_window(self) -> dict | None:
        """Look up this main window in hyprctl clients. None off Hyprland.

        Matches by Wayland app_id (Hyprland reports it as `class`), which is
        set in run() via setDesktopFileName. Title would also work but it
        changes whenever the search bar updates the window title — class is
        constant for the lifetime of the window.
        """
        import os, subprocess, json
        if not os.environ.get("HYPRLAND_INSTANCE_SIGNATURE"):
            return None
        try:
            result = subprocess.run(
                ["hyprctl", "clients", "-j"],
                capture_output=True, text=True, timeout=1,
            )
            for c in json.loads(result.stdout):
                cls = c.get("class") or c.get("initialClass")
                if cls == "booru-viewer":
                    # Skip the popout — it shares our class but has a
                    # distinct title we set explicitly.
                    if (c.get("title") or "").endswith("Popout"):
                        continue
                    return c
        except Exception:
            pass
        return None

    def _save_main_window_state(self) -> None:
        """Persist the main window's last mode and (separately) the last
        known floating geometry.

        Two settings keys are used:
          - main_window_was_floating ("1" / "0"): the *last* mode the window
            was in (floating or tiled). Updated on every save.
          - main_window_floating_geometry ("x,y,w,h"): the position+size the
            window had the *last time it was actually floating*. Only updated
            when the current state is floating, so a tile→close→reopen→float
            sequence still has the user's old floating dimensions to use.

        This split is important because Hyprland's resizeEvent for a tiled
        window reports the tile slot size — saving that into the floating
        slot would clobber the user's chosen floating dimensions every time
        they tiled the window.
        """
        try:
            win = self._hyprctl_main_window()
            if win is None:
                # Non-Hyprland fallback: just track Qt's frameGeometry as
                # floating. There's no real tiled concept off-Hyprland.
                g = self.frameGeometry()
                self._db.set_setting(
                    "main_window_floating_geometry",
                    f"{g.x()},{g.y()},{g.width()},{g.height()}",
                )
                self._db.set_setting("main_window_was_floating", "1")
                return
            floating = bool(win.get("floating"))
            self._db.set_setting(
                "main_window_was_floating", "1" if floating else "0"
            )
            if floating and win.get("at") and win.get("size"):
                x, y = win["at"]
                w, h = win["size"]
                self._db.set_setting(
                    "main_window_floating_geometry", f"{x},{y},{w},{h}"
                )
            # When tiled, intentionally do NOT touch floating_geometry —
            # preserve the last good floating dimensions.
        except Exception:
            pass

    def _restore_main_window_state(self) -> None:
        """One-shot restore of saved floating geometry and last mode.

        Called from __init__ via QTimer.singleShot(0, ...) so it fires on the
        next event-loop iteration — by which time the window has been shown
        and (on Hyprland) registered with the compositor.

        Entirely skipped when BOORU_VIEWER_NO_HYPR_RULES is set — that flag
        means the user wants their own windowrules to handle the main
        window. Even seeding Qt's geometry could fight a `windowrule = size`,
        so we leave the initial Qt geometry alone too.
        """
        from ..core.config import hypr_rules_enabled
        if not hypr_rules_enabled():
            return
        # Migration: clear obsolete keys from earlier schemas so they can't
        # interfere. main_window_maximized came from a buggy version that
        # used Qt's isMaximized() which lies for Hyprland tiled windows.
        # main_window_geometry was the combined-format key that's now split.
        for stale in ("main_window_maximized", "main_window_geometry"):
            if self._db.get_setting(stale):
                self._db.set_setting(stale, "")

        floating_geo = self._db.get_setting("main_window_floating_geometry")
        was_floating = self._db.get_setting_bool("main_window_was_floating")
        if not floating_geo:
            return
        parts = floating_geo.split(",")
        if len(parts) != 4:
            return
        try:
            x, y, w, h = (int(p) for p in parts)
        except ValueError:
            return
        # Seed Qt with the floating geometry — even if we're going to leave
        # the window tiled now, this becomes the xdg-toplevel preferred size,
        # which Hyprland uses when the user later toggles to floating. So
        # mid-session float-toggle picks up the saved dimensions even when
        # the window opened tiled.
        self.setGeometry(x, y, w, h)
        import os
        if not os.environ.get("HYPRLAND_INSTANCE_SIGNATURE"):
            return
        # Slight delay so the window is registered before we try to find
        # its address. The popout uses the same pattern.
        QTimer.singleShot(
            50, lambda: self._hyprctl_apply_main_state(x, y, w, h, was_floating)
        )

    def _hyprctl_apply_main_state(self, x: int, y: int, w: int, h: int, floating: bool) -> None:
        """Apply saved floating mode + geometry to the main window via hyprctl.

        If floating==True, ensures the window is floating and resizes/moves it
        to the saved dimensions.

        If floating==False, the window is left tiled but we still "prime"
        Hyprland's per-window floating cache by briefly toggling to floating,
        applying the saved geometry, and toggling back. This is wrapped in
        a transient `no_anim` so the toggles are instant. Without this prime,
        a later mid-session togglefloating uses Hyprland's default size
        (Qt's xdg-toplevel preferred size doesn't carry through). With it,
        the user's saved floating dimensions are used.

        Skipped entirely when BOORU_VIEWER_NO_HYPR_RULES is set — that flag
        means the user wants their own windowrules to govern the main
        window and the app should keep its hands off.
        """
        import subprocess
        from ..core.config import hypr_rules_enabled
        if not hypr_rules_enabled():
            return
        win = self._hyprctl_main_window()
        if not win:
            return
        addr = win.get("address")
        if not addr:
            return
        cur_floating = bool(win.get("floating"))
        cmds: list[str] = []
        if floating:
            # Want floating: ensure floating, then size/move.
            if not cur_floating:
                cmds.append(f"dispatch togglefloating address:{addr}")
            cmds.append(f"dispatch resizewindowpixel exact {w} {h},address:{addr}")
            cmds.append(f"dispatch movewindowpixel exact {x} {y},address:{addr}")
        else:
            # Want tiled: prime the floating cache, then end on tiled. Use
            # transient no_anim so the toggles don't visibly flash through
            # a floating frame.
            cmds.append(f"dispatch setprop address:{addr} no_anim 1")
            if not cur_floating:
                cmds.append(f"dispatch togglefloating address:{addr}")
            cmds.append(f"dispatch resizewindowpixel exact {w} {h},address:{addr}")
            cmds.append(f"dispatch movewindowpixel exact {x} {y},address:{addr}")
            cmds.append(f"dispatch togglefloating address:{addr}")
            cmds.append(f"dispatch setprop address:{addr} no_anim 0")
        if not cmds:
            return
        try:
            subprocess.Popen(
                ["hyprctl", "--batch", " ; ".join(cmds)],
                stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL,
            )
        except FileNotFoundError:
            pass

    def _open_preview_in_default(self) -> None:
        # The preview is shared across tabs but its right-click menu used
        # to read browse-tab grid/posts unconditionally and then fell back
        # to "open the most recently modified file in the cache", which on
        # bookmarks/library tabs opened a completely unrelated image.
        # Branch on the active tab and use the right source.
        stack_idx = self._stack.currentIndex()
        if stack_idx == 1:
            # Bookmarks: prefer the bookmark's stored cached_path, fall back
            # to deriving the hashed cache filename from file_url in case
            # the stored path was set on a different machine or is stale.
            favs = self._bookmarks_view._bookmarks
            idx = self._bookmarks_view._grid.selected_index
            if 0 <= idx < len(favs):
                fav = favs[idx]
                from ..core.cache import cached_path_for
                path = None
                if fav.cached_path and Path(fav.cached_path).exists():
                    path = Path(fav.cached_path)
                else:
                    derived = cached_path_for(fav.file_url)
                    if derived.exists():
                        path = derived
                if path is not None:
                    self._preview._video_player.pause()
                    if self._fullscreen_window and self._fullscreen_window.isVisible():
                        self._fullscreen_window._video.pause()
                    QDesktopServices.openUrl(QUrl.fromLocalFile(str(path)))
                else:
                    self._status.showMessage("Bookmark not cached — open it first to download")
            return
        if stack_idx == 2:
            # Library: the preview's current path IS the local library file.
            # Don't go through cached_path_for — library files live under
            # saved_dir, not the cache.
            current = self._preview._current_path
            if current and Path(current).exists():
                self._preview._video_player.pause()
                if self._fullscreen_window and self._fullscreen_window.isVisible():
                    self._fullscreen_window._video.pause()
                QDesktopServices.openUrl(QUrl.fromLocalFile(current))
            return
        # Browse: original path. Removed the "open random cache file"
        # fallback — better to do nothing than to open the wrong image.
        idx = self._grid.selected_index
        if 0 <= idx < len(self._posts):
            self._open_in_default(self._posts[idx])

    def _open_preview_in_browser(self) -> None:
        # Same shape as _open_preview_in_default: route per active tab so
        # bookmarks open the post page on the bookmark's source site, not
        # the search dropdown's currently-selected site.
        stack_idx = self._stack.currentIndex()
        if stack_idx == 1:
            favs = self._bookmarks_view._bookmarks
            idx = self._bookmarks_view._grid.selected_index
            if 0 <= idx < len(favs):
                fav = favs[idx]
                self._open_post_id_in_browser(fav.post_id, site_id=fav.site_id)
        elif stack_idx == 2:
            # Library files have no booru source URL — nothing to open.
            return
        else:
            idx = self._grid.selected_index
            if 0 <= idx < len(self._posts):
                self._open_in_browser(self._posts[idx])

    def _navigate_preview(self, direction: int, wrap: bool = False) -> None:
        """Navigate to prev/next post in the preview. direction: -1 or +1.

        wrap=True wraps to the start (or end) of the bookmarks/library lists
        when running off the edge — used for the video-end "Next" auto-advance
        on tabs that don't have pagination.
        """
        if self._stack.currentIndex() == 1:
            # Bookmarks view
            grid = self._bookmarks_view._grid
            favs = self._bookmarks_view._bookmarks
            idx = grid.selected_index + direction
            if 0 <= idx < len(favs):
                grid._select(idx)
                self._on_bookmark_activated(favs[idx])
            elif wrap and favs:
                idx = 0 if direction > 0 else len(favs) - 1
                grid._select(idx)
                self._on_bookmark_activated(favs[idx])
        elif self._stack.currentIndex() == 2:
            # Library view
            grid = self._library_view._grid
            files = self._library_view._files
            idx = grid.selected_index + direction
            if 0 <= idx < len(files):
                grid._select(idx)
                self._library_view.file_activated.emit(str(files[idx]))
            elif wrap and files:
                idx = 0 if direction > 0 else len(files) - 1
                grid._select(idx)
                self._library_view.file_activated.emit(str(files[idx]))
        else:
            idx = self._grid.selected_index + direction
            log.info(f"Navigate: direction={direction} current={self._grid.selected_index} next={idx} total={len(self._posts)}")
            if 0 <= idx < len(self._posts):
                self._grid._select(idx)
                self._on_post_activated(idx)
            elif idx >= len(self._posts) and direction > 0 and len(self._posts) > 0 and not self._infinite_scroll:
                self._search.nav_page_turn = "first"
                self._next_page()
            elif idx < 0 and direction < 0 and self._current_page > 1 and not self._infinite_scroll:
                self._search.nav_page_turn = "last"
                self._prev_page()

    def _on_video_end_next(self) -> None:
        """Auto-advance from end of video in 'Next' mode.

        Wraps to start on bookmarks/library tabs (where there is no
        pagination), so a single video looping with Next mode keeps moving
        through the list indefinitely instead of stopping at the end. Browse
        tab keeps its existing page-turn behaviour.
        """
        self._navigate_preview(1, wrap=True)
        # Sync popout if it's open
        if self._fullscreen_window and self._preview._current_path:
            self._update_fullscreen(
                self._preview._current_path,
                self._preview._info_label.text(),
            )

    def _is_post_saved(self, post_id: int) -> bool:
        """Check if a post is saved in the library (any folder)."""
        from ..core.config import saved_dir, saved_folder_dir, MEDIA_EXTENSIONS
        _sd = saved_dir()
        if _sd.exists():
            for ext in MEDIA_EXTENSIONS:
                if (_sd / f"{post_id}{ext}").exists():
                    return True
        for folder in self._db.get_folders():
            d = saved_folder_dir(folder)
            if d.exists():
                for ext in MEDIA_EXTENSIONS:
                    if (d / f"{post_id}{ext}").exists():
                        return True
        return False

    def _get_preview_post(self):
        """Get the post currently shown in the preview, from grid or stored ref."""
        idx = self._grid.selected_index
        if 0 <= idx < len(self._posts):
            return self._posts[idx], idx
        if self._preview._current_post:
            return self._preview._current_post, -1
        return None, -1

    def _bookmark_from_preview(self) -> None:
        post, idx = self._get_preview_post()
        if not post:
            return
        site_id = self._preview._current_site_id or self._site_combo.currentData()
        if not site_id:
            return
        if idx >= 0:
            self._toggle_bookmark(idx)
        else:
            if self._db.is_bookmarked(site_id, post.id):
                self._db.remove_bookmark(site_id, post.id)
            else:
                from ..core.cache import cached_path_for
                cached = cached_path_for(post.file_url)
                self._db.add_bookmark(
                    site_id=site_id, post_id=post.id,
                    file_url=post.file_url, preview_url=post.preview_url or "",
                    tags=post.tags, rating=post.rating, score=post.score,
                    source=post.source, cached_path=str(cached) if cached.exists() else None,
                    tag_categories=post.tag_categories,
                )
        bookmarked = bool(self._db.is_bookmarked(site_id, post.id))
        self._preview.update_bookmark_state(bookmarked)
        self._update_fullscreen_state()
        # Refresh bookmarks tab if visible
        if self._stack.currentIndex() == 1:
            self._bookmarks_view.refresh()

    def _save_from_preview(self, folder: str) -> None:
        post, idx = self._get_preview_post()
        if post:
            target = folder if folder else None
            if folder and folder not in self._db.get_folders():
                self._db.add_folder(folder)
            self._save_to_library(post, target)
            # State updates happen in _on_bookmark_done after async save completes

    def _unsave_from_preview(self) -> None:
        post, idx = self._get_preview_post()
        if not post:
            return
        from ..core.cache import delete_from_library
        # Check all folders for saved files
        from ..core.config import saved_dir, saved_folder_dir, MEDIA_EXTENSIONS
        deleted = False
        # Try unsorted
        _sd = saved_dir()
        for ext in MEDIA_EXTENSIONS:
            p = _sd / f"{post.id}{ext}"
            if p.exists():
                p.unlink()
                deleted = True
        # Try all folders
        for folder in self._db.get_folders():
            d = saved_folder_dir(folder)
            for ext in MEDIA_EXTENSIONS:
                p = d / f"{post.id}{ext}"
                if p.exists():
                    p.unlink()
                    deleted = True
        if deleted:
            self._status.showMessage(f"Removed #{post.id} from library")
            self._preview.update_save_state(False)
            # Update browse grid thumbnail saved dot
            for i, p in enumerate(self._posts):
                if p.id == post.id and i < len(self._grid._thumbs):
                    self._grid._thumbs[i].set_saved_locally(False)
                    break
            # Update bookmarks grid thumbnail
            bm_grid = self._bookmarks_view._grid
            for i, fav in enumerate(self._bookmarks_view._bookmarks):
                if fav.post_id == post.id and i < len(bm_grid._thumbs):
                    bm_grid._thumbs[i].set_saved_locally(False)
                    break
            # Refresh library tab if visible
            if self._stack.currentIndex() == 2:
                self._library_view.refresh()
        else:
            self._status.showMessage(f"#{post.id} not in library")
        self._update_fullscreen_state()

    def _save_toggle_from_popout(self) -> None:
        if self._fullscreen_window and self._fullscreen_window._is_saved:
            self._unsave_from_preview()
        else:
            self._save_from_preview("")

    def _blacklist_tag_from_popout(self, tag: str) -> None:
        reply = QMessageBox.question(
            self, "Blacklist Tag",
            f"Blacklist tag \"{tag}\"?\nPosts with this tag will be hidden.",
            QMessageBox.StandardButton.Yes | QMessageBox.StandardButton.No,
        )
        if reply != QMessageBox.StandardButton.Yes:
            return
        self._db.add_blacklisted_tag(tag)
        self._db.set_setting("blacklist_enabled", "1")
        self._status.showMessage(f"Blacklisted: {tag}")
        self._remove_blacklisted_from_grid(tag=tag)

    def _blacklist_post_from_popout(self) -> None:
        post, idx = self._get_preview_post()
        if post:
            reply = QMessageBox.question(
                self, "Blacklist Post",
                f"Blacklist post #{post.id}?\nThis post will be hidden from results.",
                QMessageBox.StandardButton.Yes | QMessageBox.StandardButton.No,
            )
            if reply != QMessageBox.StandardButton.Yes:
                return
            self._db.add_blacklisted_post(post.file_url)
            self._status.showMessage(f"Post #{post.id} blacklisted")
            self._remove_blacklisted_from_grid(post_url=post.file_url)

    def _open_fullscreen_preview(self) -> None:
        path = self._preview._current_path
        if not path:
            return
        info = self._preview._info_label.text()
        # Grab video position before clearing
        video_pos = 0
        if self._preview._stack.currentIndex() == 1:
            video_pos = self._preview._video_player.get_position_ms()
        # Clear the main preview — popout takes over
        # Hide preview, expand info panel into the freed space.
        # Mark popout as active so the right splitter saver doesn't persist
        # this transient layout (which would lose the user's real preferred
        # sizes between sessions).
        self._popout_active = True
        self._info_was_visible = self._info_panel.isVisible()
        self._right_splitter_sizes = self._right_splitter.sizes()
        self._preview.clear()
        self._preview.hide()
        self._info_panel.show()
        self._right_splitter.setSizes([0, 0, 1000])
        self._preview._current_path = path
        # Populate info panel for the current post
        idx = self._grid.selected_index
        if 0 <= idx < len(self._posts):
            self._info_panel.set_post(self._posts[idx])
        from .preview import FullscreenPreview
        # Restore persisted window state
        saved_geo = self._db.get_setting("slideshow_geometry")
        saved_fs = self._db.get_setting_bool("slideshow_fullscreen")
        if saved_geo:
            parts = saved_geo.split(",")
            if len(parts) == 4:
                from PySide6.QtCore import QRect
                FullscreenPreview._saved_geometry = QRect(*[int(p) for p in parts])
                FullscreenPreview._saved_fullscreen = saved_fs
            else:
                FullscreenPreview._saved_geometry = None
                FullscreenPreview._saved_fullscreen = True
        else:
            FullscreenPreview._saved_fullscreen = True
        cols = self._grid._flow.columns
        show_actions = self._stack.currentIndex() != 2
        monitor = self._db.get_setting("slideshow_monitor")
        self._fullscreen_window = FullscreenPreview(grid_cols=cols, show_actions=show_actions, monitor=monitor, parent=self)
        self._fullscreen_window.navigate.connect(self._navigate_fullscreen)
        self._fullscreen_window.play_next_requested.connect(self._on_video_end_next)
        if show_actions:
            self._fullscreen_window.bookmark_requested.connect(self._bookmark_from_preview)
            self._fullscreen_window.save_toggle_requested.connect(self._save_toggle_from_popout)
            self._fullscreen_window.blacklist_tag_requested.connect(self._blacklist_tag_from_popout)
            self._fullscreen_window.blacklist_post_requested.connect(self._blacklist_post_from_popout)
        self._fullscreen_window.closed.connect(self._on_fullscreen_closed)
        self._fullscreen_window.privacy_requested.connect(self._toggle_privacy)
        # Set post tags for BL Tag menu
        post = self._preview._current_post
        if post:
            self._fullscreen_window.set_post_tags(post.tag_categories, post.tag_list)
        # Sync video player state from preview to popout
        pv = self._preview._video_player
        sv = self._fullscreen_window._video
        sv.volume = pv.volume
        sv.is_muted = pv.is_muted
        sv.autoplay = pv.autoplay
        sv.loop_state = pv.loop_state
        # Connect seek-after-load BEFORE set_media so we don't miss media_ready
        if video_pos > 0:
            def _seek_when_ready():
                sv.seek_to_ms(video_pos)
                try:
                    sv.media_ready.disconnect(_seek_when_ready)
                except RuntimeError:
                    pass
            sv.media_ready.connect(_seek_when_ready)
        self._fullscreen_window.set_media(path, info)
        if show_actions:
            self._update_fullscreen_state()

    def _on_fullscreen_closed(self) -> None:
        # Persist popout window state to DB
        if self._fullscreen_window:
            from .preview import FullscreenPreview
            fs = FullscreenPreview._saved_fullscreen
            geo = FullscreenPreview._saved_geometry
            self._db.set_setting("slideshow_fullscreen", "1" if fs else "0")
            if geo:
                self._db.set_setting("slideshow_geometry", f"{geo.x()},{geo.y()},{geo.width()},{geo.height()}")
        # Restore preview and info panel visibility
        self._preview.show()
        if not getattr(self, '_info_was_visible', False):
            self._info_panel.hide()
        if hasattr(self, '_right_splitter_sizes'):
            self._right_splitter.setSizes(self._right_splitter_sizes)
        # Clear the popout-active flag now that the right splitter is back
        # in its real shape — future splitterMoved events should persist.
        self._popout_active = False
        # Sync video player state from popout back to preview
        if self._fullscreen_window:
            sv = self._fullscreen_window._video
            pv = self._preview._video_player
            pv.volume = sv.volume
            pv.is_muted = sv.is_muted
            pv.autoplay = sv.autoplay
            pv.loop_state = sv.loop_state
        # Grab video position before cleanup
        video_pos = 0
        if self._fullscreen_window and self._fullscreen_window._stack.currentIndex() == 1:
            video_pos = self._fullscreen_window._video.get_position_ms()
        # Restore preview with current media
        path = self._preview._current_path
        info = self._preview._info_label.text()
        self._fullscreen_window = None
        if path:
            # Connect seek-after-load BEFORE set_media so we don't miss media_ready
            if video_pos > 0:
                def _seek_preview():
                    self._preview._video_player.seek_to_ms(video_pos)
                    try:
                        self._preview._video_player.media_ready.disconnect(_seek_preview)
                    except RuntimeError:
                        pass
                self._preview._video_player.media_ready.connect(_seek_preview)
            self._preview.set_media(path, info)

    def _navigate_fullscreen(self, direction: int) -> None:
        self._navigate_preview(direction)
        # For synchronous loads (cached/bookmarks), update immediately
        if self._preview._current_path:
            self._update_fullscreen(
                self._preview._current_path,
                self._preview._info_label.text(),
            )

    def _close_preview(self) -> None:
        self._preview.clear()

    # -- Context menu --

    def _on_context_menu(self, index: int, pos) -> None:
        if index < 0 or index >= len(self._posts):
            return
        post = self._posts[index]
        menu = QMenu(self)

        open_browser = menu.addAction("Open in Browser")
        open_default = menu.addAction("Open in Default App")
        menu.addSeparator()
        save_as = menu.addAction("Save As...")

        # Save to Library submenu
        save_lib_menu = menu.addMenu("Save to Library")
        save_lib_unsorted = save_lib_menu.addAction("Unsorted")
        save_lib_menu.addSeparator()
        save_lib_folders = {}
        for folder in self._db.get_folders():
            a = save_lib_menu.addAction(folder)
            save_lib_folders[id(a)] = folder
        save_lib_menu.addSeparator()
        save_lib_new = save_lib_menu.addAction("+ New Folder...")

        unsave_lib = None
        if self._is_post_saved(post.id):
            unsave_lib = menu.addAction("Unsave from Library")
        copy_clipboard = menu.addAction("Copy File to Clipboard")
        copy_url = menu.addAction("Copy Image URL")
        copy_tags = menu.addAction("Copy Tags")
        menu.addSeparator()
        fav_action = menu.addAction("Remove Bookmark" if self._is_current_bookmarked(index) else "Bookmark")
        menu.addSeparator()
        bl_menu = menu.addMenu("Blacklist Tag")
        if post.tag_categories:
            for category, tags in post.tag_categories.items():
                cat_menu = bl_menu.addMenu(category)
                for tag in tags[:30]:
                    cat_menu.addAction(tag)
        else:
            for tag in post.tag_list[:30]:
                bl_menu.addAction(tag)
        bl_post_action = menu.addAction("Blacklist Post")

        action = menu.exec(pos)
        if not action:
            return

        if action == open_browser:
            self._open_in_browser(post)
        elif action == open_default:
            self._open_in_default(post)
        elif action == save_as:
            self._save_as(post)
        elif action == save_lib_unsorted:
            self._save_to_library(post, None)
        elif action == save_lib_new:
            from PySide6.QtWidgets import QInputDialog, QMessageBox
            name, ok = QInputDialog.getText(self, "New Folder", "Folder name:")
            if ok and name.strip():
                try:
                    self._db.add_folder(name.strip())
                except ValueError as e:
                    QMessageBox.warning(self, "Invalid Folder Name", str(e))
                    return
                self._save_to_library(post, name.strip())
        elif id(action) in save_lib_folders:
            self._save_to_library(post, save_lib_folders[id(action)])
        elif action == unsave_lib:
            self._preview._current_post = post
            self._unsave_from_preview()
        elif action == copy_clipboard:
            self._copy_file_to_clipboard()
        elif action == copy_url:
            QApplication.clipboard().setText(post.file_url)
            self._status.showMessage("URL copied")
        elif action == copy_tags:
            QApplication.clipboard().setText(post.tags)
            self._status.showMessage("Tags copied")
        elif action == fav_action:
            self._toggle_bookmark(index)
        elif self._is_child_of_menu(action, bl_menu):
            tag = action.text()
            self._db.add_blacklisted_tag(tag)
            self._db.set_setting("blacklist_enabled", "1")
            # Clear preview if the previewed post has this tag
            if self._preview._current_path and tag in post.tag_list:
                from ..core.cache import cached_path_for
                cp = str(cached_path_for(post.file_url))
                if cp == self._preview._current_path:
                    self._preview.clear()
                    if self._fullscreen_window and self._fullscreen_window.isVisible():
                        self._fullscreen_window._viewer.clear()
                        self._fullscreen_window._video.stop()
            self._status.showMessage(f"Blacklisted: {tag}")
            self._remove_blacklisted_from_grid(tag=tag)
        elif action == bl_post_action:
            self._db.add_blacklisted_post(post.file_url)
            self._remove_blacklisted_from_grid(post_url=post.file_url)
            self._status.showMessage(f"Post #{post.id} blacklisted")
            self._do_search()

    def _remove_blacklisted_from_grid(self, tag: str = None, post_url: str = None) -> None:
        """Remove matching posts from the grid in-place without re-searching."""
        to_remove = []
        for i, post in enumerate(self._posts):
            if tag and tag in post.tag_list:
                to_remove.append(i)
            elif post_url and post.file_url == post_url:
                to_remove.append(i)

        if not to_remove:
            return

        # Check if previewed post is being removed
        from ..core.cache import cached_path_for
        for i in to_remove:
            cp = str(cached_path_for(self._posts[i].file_url))
            if cp == self._preview._current_path:
                self._preview.clear()
                if self._fullscreen_window and self._fullscreen_window.isVisible():
                    self._fullscreen_window._viewer.clear()
                    self._fullscreen_window._video.stop()
                break

        # Remove from posts list (reverse order to keep indices valid)
        for i in reversed(to_remove):
            self._posts.pop(i)

        # Rebuild grid with remaining posts
        thumbs = self._grid.set_posts(len(self._posts))
        from ..core.config import saved_dir
        site_id = self._site_combo.currentData()
        _sd = saved_dir()
        _saved_ids = {int(f.stem) for f in _sd.iterdir() if f.is_file() and f.stem.isdigit()} if _sd.exists() else set()

        for i, (post, thumb) in enumerate(zip(self._posts, thumbs)):
            if site_id and self._db.is_bookmarked(site_id, post.id):
                thumb.set_bookmarked(True)
            thumb.set_saved_locally(post.id in _saved_ids)
            from ..core.cache import cached_path_for as cpf
            cached = cpf(post.file_url)
            if cached.exists():
                thumb._cached_path = str(cached)
            if post.preview_url:
                self._fetch_thumbnail(i, post.preview_url)

        self._status.showMessage(f"{len(self._posts)} results — {len(to_remove)} removed")

    @staticmethod
    def _is_child_of_menu(action, menu) -> bool:
        parent = action.parent()
        while parent:
            if parent == menu:
                return True
            parent = getattr(parent, 'parent', lambda: None)()
        return False

    def _on_multi_context_menu(self, indices: list, pos) -> None:
        """Context menu for multi-selected posts."""
        posts = [self._posts[i] for i in indices if 0 <= i < len(self._posts)]
        if not posts:
            return
        count = len(posts)

        menu = QMenu(self)
        fav_all = menu.addAction(f"Bookmark All ({count})")

        save_menu = menu.addMenu(f"Save All to Library ({count})")
        save_unsorted = save_menu.addAction("Unsorted")
        save_folder_actions = {}
        for folder in self._db.get_folders():
            a = save_menu.addAction(folder)
            save_folder_actions[id(a)] = folder
        save_menu.addSeparator()
        save_new = save_menu.addAction("+ New Folder...")

        menu.addSeparator()
        unfav_all = menu.addAction(f"Remove All Bookmarks ({count})")
        menu.addSeparator()
        batch_dl = menu.addAction(f"Download All ({count})...")
        copy_urls = menu.addAction("Copy All URLs")

        action = menu.exec(pos)
        if not action:
            return

        if action == fav_all:
            self._bulk_bookmark(indices, posts)
        elif action == save_unsorted:
            self._bulk_save(indices, posts, None)
        elif action == save_new:
            from PySide6.QtWidgets import QInputDialog, QMessageBox
            name, ok = QInputDialog.getText(self, "New Folder", "Folder name:")
            if ok and name.strip():
                try:
                    self._db.add_folder(name.strip())
                except ValueError as e:
                    QMessageBox.warning(self, "Invalid Folder Name", str(e))
                    return
                self._bulk_save(indices, posts, name.strip())
        elif id(action) in save_folder_actions:
            self._bulk_save(indices, posts, save_folder_actions[id(action)])
        elif action == batch_dl:
            from .dialogs import select_directory
            dest = select_directory(self, "Download to folder")
            if dest:
                self._batch_download_posts(posts, dest)
        elif action == unfav_all:
            site_id = self._site_combo.currentData()
            if site_id:
                from ..core.cache import delete_from_library
                from ..core.config import saved_dir, saved_folder_dir
                for post in posts:
                    # Delete from unsorted library
                    delete_from_library(post.id, None)
                    # Delete from all folders
                    for folder in self._db.get_folders():
                        delete_from_library(post.id, folder)
                    self._db.remove_bookmark(site_id, post.id)
                for idx in indices:
                    if 0 <= idx < len(self._grid._thumbs):
                        self._grid._thumbs[idx].set_bookmarked(False)
                        self._grid._thumbs[idx].set_saved_locally(False)
                self._grid._clear_multi()
                self._status.showMessage(f"Removed {count} bookmarks")
        elif action == copy_urls:
            urls = "\n".join(p.file_url for p in posts)
            QApplication.clipboard().setText(urls)
            self._status.showMessage(f"Copied {count} URLs")

    def _bulk_bookmark(self, indices: list[int], posts: list[Post]) -> None:
        site_id = self._site_combo.currentData()
        if not site_id:
            return
        self._status.showMessage(f"Bookmarking {len(posts)}...")

        async def _do():
            for i, (idx, post) in enumerate(zip(indices, posts)):
                if self._db.is_bookmarked(site_id, post.id):
                    continue
                try:
                    path = await download_image(post.file_url)
                    self._db.add_bookmark(
                        site_id=site_id, post_id=post.id,
                        file_url=post.file_url, preview_url=post.preview_url,
                        tags=post.tags, rating=post.rating, score=post.score,
                        source=post.source, cached_path=str(path),
                        tag_categories=post.tag_categories,
                    )
                    self._signals.bookmark_done.emit(idx, f"Bookmarked {i+1}/{len(posts)}")
                except Exception as e:
                    log.warning(f"Operation failed: {e}")
            self._signals.batch_done.emit(f"Bookmarked {len(posts)} posts")

        self._run_async(_do)

    def _bulk_save(self, indices: list[int], posts: list[Post], folder: str | None) -> None:
        site_id = self._site_combo.currentData()
        where = folder or "Unsorted"
        self._status.showMessage(f"Saving {len(posts)} to {where}...")

        async def _do():
            from ..core.config import saved_dir, saved_folder_dir
            import shutil
            for i, (idx, post) in enumerate(zip(indices, posts)):
                try:
                    path = await download_image(post.file_url)
                    ext = Path(path).suffix
                    dest_dir = saved_folder_dir(folder) if folder else saved_dir()
                    dest = dest_dir / f"{post.id}{ext}"
                    if not dest.exists():
                        shutil.copy2(path, dest)
                    # Store metadata for library search
                    self._db.save_library_meta(
                        post_id=post.id, tags=post.tags,
                        tag_categories=post.tag_categories,
                        score=post.score, rating=post.rating,
                        source=post.source, file_url=post.file_url,
                    )
                    self._signals.bookmark_done.emit(idx, f"Saved {i+1}/{len(posts)} to {where}")
                except Exception as e:
                    log.warning(f"Operation failed: {e}")
            self._signals.batch_done.emit(f"Saved {len(posts)} to {where}")

        self._run_async(_do)

    def _ensure_bookmarked(self, post: Post) -> None:
        """Bookmark a post if not already bookmarked."""
        site_id = self._site_combo.currentData()
        if not site_id or self._db.is_bookmarked(site_id, post.id):
            return

        async def _fav():
            try:
                path = await download_image(post.file_url)
                self._db.add_bookmark(
                    site_id=site_id,
                    post_id=post.id,
                    file_url=post.file_url,
                    preview_url=post.preview_url,
                    tags=post.tags,
                    rating=post.rating,
                    score=post.score,
                    source=post.source,
                    cached_path=str(path),
                )
            except Exception as e:
                log.warning(f"Operation failed: {e}")

        self._run_async(_fav)

    def _batch_download_posts(self, posts: list, dest: str) -> None:
        async def _batch():
            for i, post in enumerate(posts):
                try:
                    path = await download_image(post.file_url)
                    ext = Path(path).suffix
                    target = Path(dest) / f"{post.id}{ext}"
                    if not target.exists():
                        import shutil
                        shutil.copy2(path, target)
                    self._signals.batch_progress.emit(i + 1, len(posts))
                except Exception as e:
                    log.warning(f"Batch #{post.id} failed: {e}")
            self._signals.batch_done.emit(f"Downloaded {len(posts)} images to {dest}")

        self._run_async(_batch)

    def _is_current_bookmarked(self, index: int) -> bool:
        site_id = self._site_combo.currentData()
        if not site_id or index < 0 or index >= len(self._posts):
            return False
        return self._db.is_bookmarked(site_id, self._posts[index].id)

    def _open_post_id_in_browser(self, post_id: int, site_id: int | None = None) -> None:
        """Open the post page in the system browser. site_id selects which
        site's URL/api scheme to use; defaults to the currently selected
        search site. Pass site_id explicitly when the post comes from a
        different source than the search dropdown (e.g. bookmarks)."""
        site = None
        if site_id is not None:
            sites = self._db.get_sites()
            site = next((s for s in sites if s.id == site_id), None)
        if site is None:
            site = self._current_site
        if not site:
            return
        base = site.url
        api = site.api_type
        if api == "danbooru" or api == "e621":
            url = f"{base}/posts/{post_id}"
        elif api == "gelbooru":
            url = f"{base}/index.php?page=post&s=view&id={post_id}"
        elif api == "moebooru":
            url = f"{base}/post/show/{post_id}"
        else:
            url = f"{base}/posts/{post_id}"
        QDesktopServices.openUrl(QUrl(url))

    def _open_in_browser(self, post: Post) -> None:
        self._open_post_id_in_browser(post.id)

    def _open_in_default(self, post: Post) -> None:
        from ..core.cache import cached_path_for, is_cached
        path = cached_path_for(post.file_url)
        if path.exists():
            # Pause any playing video before opening externally
            self._preview._video_player.pause()
            if self._fullscreen_window and self._fullscreen_window.isVisible():
                self._fullscreen_window._video.pause()
            QDesktopServices.openUrl(QUrl.fromLocalFile(str(path)))
        else:
            self._status.showMessage("Image not cached yet — double-click to download first")

    def _save_to_library(self, post: Post, folder: str | None) -> None:
        """Download and save image to the library folder structure."""
        from ..core.config import saved_dir, saved_folder_dir

        self._status.showMessage(f"Saving #{post.id} to library...")

        async def _save():
            try:
                path = await download_image(post.file_url)
                ext = Path(path).suffix
                if folder:
                    dest_dir = saved_folder_dir(folder)
                else:
                    dest_dir = saved_dir()
                dest = dest_dir / f"{post.id}{ext}"
                if not dest.exists():
                    import shutil
                    shutil.copy2(path, dest)

                # Copy browse thumbnail to library thumbnail cache
                if post.preview_url:
                    from ..core.config import thumbnails_dir
                    from ..core.cache import cached_path_for as _cpf
                    thumb_src = _cpf(post.preview_url, thumbnails_dir())
                    if thumb_src.exists():
                        lib_thumb_dir = thumbnails_dir() / "library"
                        lib_thumb_dir.mkdir(parents=True, exist_ok=True)
                        lib_thumb = lib_thumb_dir / f"{post.id}.jpg"
                        if not lib_thumb.exists():
                            import shutil as _sh
                            _sh.copy2(thumb_src, lib_thumb)

                # Store metadata for library search
                self._db.save_library_meta(
                    post_id=post.id, tags=post.tags,
                    tag_categories=post.tag_categories,
                    score=post.score, rating=post.rating,
                    source=post.source, file_url=post.file_url,
                )

                where = folder or "Unsorted"
                self._signals.bookmark_done.emit(
                    self._grid.selected_index,
                    f"Saved #{post.id} to {where}"
                )
            except Exception as e:
                self._signals.bookmark_error.emit(str(e))

        self._run_async(_save)

    def _save_as(self, post: Post) -> None:
        from ..core.cache import cached_path_for
        from .dialogs import save_file
        src = cached_path_for(post.file_url)
        if not src.exists():
            self._status.showMessage("Image not cached — double-click to download first")
            return
        ext = src.suffix
        dest = save_file(self, "Save Image", f"post_{post.id}{ext}", f"Images (*{ext})")
        if dest:
            import shutil
            shutil.copy2(src, dest)
            self._status.showMessage(f"Saved to {dest}")

    # -- Batch download --

    def _batch_download(self) -> None:
        if not self._posts:
            self._status.showMessage("No posts to download")
            return
        from .dialogs import select_directory
        dest = select_directory(self, "Download to folder")
        if not dest:
            return

        posts = list(self._posts)
        self._status.showMessage(f"Downloading {len(posts)} images...")

        async def _batch():
            for i, post in enumerate(posts):
                try:
                    path = await download_image(post.file_url)
                    ext = Path(path).suffix
                    target = Path(dest) / f"{post.id}{ext}"
                    if not target.exists():
                        import shutil
                        shutil.copy2(path, target)
                    self._signals.batch_progress.emit(i + 1, len(posts))
                except Exception as e:
                    log.warning(f"Batch #{post.id} failed: {e}")
            self._signals.batch_done.emit(f"Downloaded {len(posts)} images to {dest}")

        self._run_async(_batch)

    def _on_batch_progress(self, current: int, total: int) -> None:
        self._status.showMessage(f"Downloading {current}/{total}...")

    # -- Toggles --

    def _toggle_log(self) -> None:
        self._log_text.setVisible(not self._log_text.isVisible())

    def _toggle_info(self) -> None:
        new_visible = not self._info_panel.isVisible()
        self._info_panel.setVisible(new_visible)
        # Persist the user's intent so it survives the next launch.
        self._db.set_setting("info_panel_visible", "1" if new_visible else "0")
        if new_visible and 0 <= self._grid.selected_index < len(self._posts):
            self._info_panel.set_post(self._posts[self._grid.selected_index])

    def _open_site_manager(self) -> None:
        dlg = SiteManagerDialog(self._db, self)
        dlg.sites_changed.connect(self._load_sites)
        dlg.exec()

    def _open_settings(self) -> None:
        dlg = SettingsDialog(self._db, self)
        dlg.settings_changed.connect(self._apply_settings)
        self._bookmarks_imported = False
        dlg.bookmarks_imported.connect(lambda: setattr(self, '_bookmarks_imported', True))
        dlg.exec()
        if self._bookmarks_imported:
            self._switch_view(1)
            self._bookmarks_view.refresh()

    def _apply_settings(self) -> None:
        """Re-read settings from DB and apply to UI."""
        rating = self._db.get_setting("default_rating")
        idx = self._rating_combo.findText(rating.capitalize() if rating != "all" else "All")
        if idx >= 0:
            self._rating_combo.setCurrentIndex(idx)
        self._score_spin.setValue(self._db.get_setting_int("default_score"))
        self._bookmarks_view.refresh()
        # Apply infinite scroll toggle live
        self._infinite_scroll = self._db.get_setting_bool("infinite_scroll")
        self._bottom_nav.setVisible(not self._infinite_scroll)
        # Apply library dir
        lib_dir = self._db.get_setting("library_dir")
        if lib_dir:
            from ..core.config import set_library_dir
            set_library_dir(Path(lib_dir))
        # Apply thumbnail size
        from .grid import THUMB_SIZE
        new_size = self._db.get_setting_int("thumbnail_size")
        if new_size and new_size != THUMB_SIZE:
            import booru_viewer.gui.grid as grid_mod
            grid_mod.THUMB_SIZE = new_size
        self._status.showMessage("Settings applied")

    # -- Fullscreen & Privacy --

    def _toggle_fullscreen(self) -> None:
        if self.isFullScreen():
            self.showNormal()
        else:
            self.showFullScreen()

    # -- Privacy screen --

    def _toggle_privacy(self) -> None:
        if not hasattr(self, '_privacy_on'):
            self._privacy_on = False
            self._privacy_overlay = QWidget(self)
            self._privacy_overlay.setStyleSheet("background: black;")
            self._privacy_overlay.hide()

        self._privacy_on = not self._privacy_on
        if self._privacy_on:
            self._privacy_overlay.setGeometry(self.rect())
            self._privacy_overlay.raise_()
            self._privacy_overlay.show()
            self.setWindowTitle("booru-viewer")
            # Pause preview video
            if self._preview._stack.currentIndex() == 1:
                self._preview._video_player.pause()
            # Hide and pause popout
            if self._fullscreen_window and self._fullscreen_window.isVisible():
                if self._fullscreen_window._stack.currentIndex() == 1:
                    self._fullscreen_window._video.pause()
                self._fullscreen_window.hide()
        else:
            self._privacy_overlay.hide()
            if self._fullscreen_window:
                self._fullscreen_window.show()

    def resizeEvent(self, event) -> None:
        super().resizeEvent(event)
        if hasattr(self, '_privacy_overlay') and self._privacy_on:
            self._privacy_overlay.setGeometry(self.rect())
        # Capture window state proactively so the saved value is always
        # fresh — closeEvent's hyprctl query can fail if the compositor has
        # already started unmapping. Debounced via the 300ms timer.
        if hasattr(self, '_main_window_save_timer'):
            self._main_window_save_timer.start()

    def moveEvent(self, event) -> None:
        super().moveEvent(event)
        # moveEvent is unreliable on Wayland for floating windows but it
        # does fire on configure for some compositors — start the save
        # timer regardless. resizeEvent is the more reliable trigger.
        if hasattr(self, '_main_window_save_timer'):
            self._main_window_save_timer.start()

    # -- Keyboard shortcuts --

    def keyPressEvent(self, event) -> None:
        key = event.key()
        # Privacy screen always works
        if key == Qt.Key.Key_P and event.modifiers() == Qt.KeyboardModifier.ControlModifier:
            self._toggle_privacy()
            return
        # If privacy is on, only allow toggling it off
        if hasattr(self, '_privacy_on') and self._privacy_on:
            return
        if key == Qt.Key.Key_F and self._posts:
            idx = self._grid.selected_index
            if 0 <= idx < len(self._posts):
                self._toggle_bookmark(idx)
                return
        elif key == Qt.Key.Key_I:
            self._toggle_info()
            return
        elif key == Qt.Key.Key_O and self._posts:
            idx = self._grid.selected_index
            if 0 <= idx < len(self._posts):
                self._open_in_default(self._posts[idx])
                return
        elif key == Qt.Key.Key_Space:
            if self._preview._stack.currentIndex() == 1 and self._preview.underMouse():
                self._preview._video_player._toggle_play()
                return
        elif key == Qt.Key.Key_Period:
            if self._preview._stack.currentIndex() == 1:
                self._preview._video_player._seek_relative(1800)
                return
        elif key == Qt.Key.Key_Comma:
            if self._preview._stack.currentIndex() == 1:
                self._preview._video_player._seek_relative(-1800)
                return
        super().keyPressEvent(event)

    def _copy_file_to_clipboard(self, path: str | None = None) -> None:
        """Copy a file to clipboard. Tries wl-copy on Wayland, Qt fallback."""
        if not path:
            path = self._preview._current_path
        if not path:
            idx = self._grid.selected_index
            if 0 <= idx < len(self._posts):
                from ..core.cache import cached_path_for
                cp = cached_path_for(self._posts[idx].file_url)
                if cp.exists():
                    path = str(cp)
        if not path or not Path(path).exists():
            log.debug(f"Copy failed: path={path} preview_path={self._preview._current_path}")
            self._status.showMessage("Nothing to copy")
            return
        log.debug(f"Copying: {path}")

        from PySide6.QtCore import QMimeData, QUrl
        mime = QMimeData()
        mime.setUrls([QUrl.fromLocalFile(str(Path(path).resolve()))])
        # Also set image data for apps that prefer it
        pix = QPixmap(path)
        if not pix.isNull():
            mime.setImageData(pix.toImage())
        QApplication.clipboard().setMimeData(mime)
        self._status.showMessage(f"Copied to clipboard: {Path(path).name}")

    # -- Bookmarks --

    def _toggle_bookmark(self, index: int) -> None:
        post = self._posts[index]
        site_id = self._site_combo.currentData()
        if not site_id:
            return

        if self._db.is_bookmarked(site_id, post.id):
            self._db.remove_bookmark(site_id, post.id)
            self._status.showMessage(f"Unbookmarked #{post.id}")
            thumbs = self._grid._thumbs
            if 0 <= index < len(thumbs):
                thumbs[index].set_bookmarked(False)
        else:
            self._status.showMessage(f"Bookmarking #{post.id}...")

            async def _fav():
                try:
                    path = await download_image(post.file_url)
                    self._db.add_bookmark(
                        site_id=site_id,
                        post_id=post.id,
                        file_url=post.file_url,
                        preview_url=post.preview_url,
                        tags=post.tags,
                        rating=post.rating,
                        score=post.score,
                        source=post.source,
                        cached_path=str(path),
                        tag_categories=post.tag_categories,
                    )
                    self._signals.bookmark_done.emit(index, f"Bookmarked #{post.id}")
                except Exception as e:
                    self._signals.bookmark_error.emit(str(e))

            self._run_async(_fav)

    def _on_bookmark_done(self, index: int, msg: str) -> None:
        self._status.showMessage(f"{len(self._posts)} results — {msg}")
        # Detect batch operations (e.g. "Saved 3/10 to Unsorted") — skip heavy updates
        is_batch = "/" in msg and any(c.isdigit() for c in msg.split("/")[0][-2:])
        thumbs = self._grid._thumbs
        if 0 <= index < len(thumbs):
            if "Saved" in msg:
                thumbs[index].set_saved_locally(True)
            if "Bookmarked" in msg:
                thumbs[index].set_bookmarked(True)
        if not is_batch:
            if "Bookmarked" in msg:
                self._preview.update_bookmark_state(True)
            if "Saved" in msg:
                self._preview.update_save_state(True)
                if self._stack.currentIndex() == 1:
                    bm_grid = self._bookmarks_view._grid
                    bm_idx = bm_grid.selected_index
                    if 0 <= bm_idx < len(bm_grid._thumbs):
                        bm_grid._thumbs[bm_idx].set_saved_locally(True)
                if self._stack.currentIndex() == 2:
                    self._library_view.refresh()
            self._update_fullscreen_state()

    def _on_library_files_deleted(self, post_ids: list) -> None:
        """Library deleted files — clear saved dots on browse grid."""
        for i, p in enumerate(self._posts):
            if p.id in post_ids and i < len(self._grid._thumbs):
                self._grid._thumbs[i].set_saved_locally(False)

    def _refresh_browse_saved_dots(self) -> None:
        """Bookmarks changed — rescan saved state for all visible browse grid posts."""
        for i, p in enumerate(self._posts):
            if i < len(self._grid._thumbs):
                self._grid._thumbs[i].set_saved_locally(self._is_post_saved(p.id))
                site_id = self._site_combo.currentData()
                self._grid._thumbs[i].set_bookmarked(
                    bool(site_id and self._db.is_bookmarked(site_id, p.id))
                )

    def _on_batch_done(self, msg: str) -> None:
        self._status.showMessage(msg)
        self._update_fullscreen_state()
        if self._stack.currentIndex() == 1:
            self._bookmarks_view.refresh()
        if self._stack.currentIndex() == 2:
            self._library_view.refresh()

    def closeEvent(self, event) -> None:
        # Flush any pending splitter / window-state saves (debounce timers
        # may still be running if the user moved/resized within the last
        # 300ms) and capture the final state. Both must run BEFORE
        # _db.close().
        if self._main_splitter_save_timer.isActive():
            self._main_splitter_save_timer.stop()
        if self._main_window_save_timer.isActive():
            self._main_window_save_timer.stop()
        if hasattr(self, '_right_splitter_save_timer') and self._right_splitter_save_timer.isActive():
            self._right_splitter_save_timer.stop()
        self._save_main_splitter_sizes()
        self._save_right_splitter_sizes()
        self._save_main_window_state()

        # Cleanly shut the shared httpx pools down BEFORE stopping the loop
        # so the connection pool / keepalive sockets / TLS state get released
        # instead of being abandoned mid-flight. Has to run on the loop the
        # clients were bound to.
        try:
            from ..core.api.base import BooruClient
            from ..core.api.e621 import E621Client
            from ..core.cache import aclose_shared_client

            async def _close_all():
                await BooruClient.aclose_shared()
                await E621Client.aclose_shared()
                await aclose_shared_client()

            fut = asyncio.run_coroutine_threadsafe(_close_all(), self._async_loop)
            fut.result(timeout=5)
        except Exception as e:
            log.warning(f"Shared httpx aclose failed: {e}")

        self._async_loop.call_soon_threadsafe(self._async_loop.stop)
        self._async_thread.join(timeout=2)
        if self._db.get_setting_bool("clear_cache_on_exit"):
            from ..core.cache import clear_cache
            clear_cache(clear_images=True, clear_thumbnails=True)
            self._db.clear_search_history()
        self._db.close()
        super().closeEvent(event)


def _apply_windows_dark_mode(app: QApplication) -> None:
    """Detect Windows dark mode and apply Fusion dark palette if needed."""
    try:
        import winreg
        key = winreg.OpenKey(
            winreg.HKEY_CURRENT_USER,
            r"Software\Microsoft\Windows\CurrentVersion\Themes\Personalize",
        )
        value, _ = winreg.QueryValueEx(key, "AppsUseLightTheme")
        winreg.CloseKey(key)
        if value == 0:
            from PySide6.QtGui import QPalette, QColor
            app.setStyle("Fusion")
            palette = QPalette()
            palette.setColor(QPalette.ColorRole.Window, QColor(32, 32, 32))
            palette.setColor(QPalette.ColorRole.WindowText, QColor(255, 255, 255))
            palette.setColor(QPalette.ColorRole.Base, QColor(25, 25, 25))
            palette.setColor(QPalette.ColorRole.AlternateBase, QColor(38, 38, 38))
            palette.setColor(QPalette.ColorRole.ToolTipBase, QColor(50, 50, 50))
            palette.setColor(QPalette.ColorRole.ToolTipText, QColor(255, 255, 255))
            palette.setColor(QPalette.ColorRole.Text, QColor(255, 255, 255))
            palette.setColor(QPalette.ColorRole.Button, QColor(51, 51, 51))
            palette.setColor(QPalette.ColorRole.ButtonText, QColor(255, 255, 255))
            palette.setColor(QPalette.ColorRole.BrightText, QColor(255, 0, 0))
            palette.setColor(QPalette.ColorRole.Link, QColor(0, 120, 215))
            palette.setColor(QPalette.ColorRole.Highlight, QColor(0, 120, 215))
            palette.setColor(QPalette.ColorRole.HighlightedText, QColor(255, 255, 255))
            palette.setColor(QPalette.ColorRole.Mid, QColor(51, 51, 51))
            palette.setColor(QPalette.ColorRole.Dark, QColor(25, 25, 25))
            palette.setColor(QPalette.ColorRole.Shadow, QColor(0, 0, 0))
            palette.setColor(QPalette.ColorRole.Light, QColor(60, 60, 60))
            palette.setColor(QPalette.ColorRole.Midlight, QColor(55, 55, 55))
            palette.setColor(QPalette.ColorGroup.Disabled, QPalette.ColorRole.Text, QColor(127, 127, 127))
            palette.setColor(QPalette.ColorGroup.Disabled, QPalette.ColorRole.ButtonText, QColor(127, 127, 127))
            app.setPalette(palette)
            # Flatten Fusion's 3D look
            app.setStyleSheet(app.styleSheet() + """
                QPushButton {
                    border: 1px solid #555;
                    border-radius: 2px;
                    padding: 4px 12px;
                }
                QPushButton:hover { background-color: #444; }
                QPushButton:pressed { background-color: #333; }
                QComboBox {
                    border: 1px solid #555;
                    border-radius: 2px;
                    padding: 3px 6px;
                }
                QComboBox::drop-down {
                    border: none;
                }
                QSpinBox {
                    border: 1px solid #555;
                    border-radius: 2px;
                }
                QLineEdit, QTextEdit {
                    border: 1px solid #555;
                    border-radius: 2px;
                    padding: 3px;
                    color: #fff;
                    background-color: #191919;
                }
                QScrollBar:vertical {
                    background: #252525;
                    width: 12px;
                }
                QScrollBar::handle:vertical {
                    background: #555;
                    border-radius: 4px;
                    min-height: 20px;
                }
                QScrollBar::add-line:vertical, QScrollBar::sub-line:vertical {
                    height: 0;
                }
            """)
    except Exception as e:
        log.warning(f"Operation failed: {e}")


# Base popout overlay style — always loaded *before* the user QSS so the
# floating top toolbar (`#_slideshow_toolbar`) and bottom video controls
# (`#_slideshow_controls`) get a sane translucent-black-with-white-text
# look on themes that don't define their own overlay rules. Bundled themes
# in `themes/` redefine the same selectors with their @palette colors and
# win on tie (last rule of equal specificity wins in QSS), so anyone using
# a packaged theme keeps the themed overlay; anyone with a stripped-down
# custom.qss still gets a usable overlay instead of bare letterbox.
_BASE_POPOUT_OVERLAY_QSS = """
QWidget#_slideshow_toolbar,
QWidget#_slideshow_controls {
    background: rgba(0, 0, 0, 160);
}
QWidget#_slideshow_toolbar *,
QWidget#_slideshow_controls * {
    background: transparent;
    color: white;
    border: none;
}
QWidget#_slideshow_toolbar QPushButton,
QWidget#_slideshow_controls QPushButton {
    background: transparent;
    color: white;
    border: 1px solid rgba(255, 255, 255, 80);
    padding: 2px 6px;
}
QWidget#_slideshow_toolbar QPushButton:hover,
QWidget#_slideshow_controls QPushButton:hover {
    background: rgba(255, 255, 255, 30);
}
QWidget#_slideshow_toolbar QSlider::groove:horizontal,
QWidget#_slideshow_controls QSlider::groove:horizontal {
    background: rgba(255, 255, 255, 40);
    height: 4px;
    border: none;
}
QWidget#_slideshow_toolbar QSlider::handle:horizontal,
QWidget#_slideshow_controls QSlider::handle:horizontal {
    background: white;
    width: 10px;
    margin: -4px 0;
    border: none;
}
QWidget#_slideshow_toolbar QSlider::sub-page:horizontal,
QWidget#_slideshow_controls QSlider::sub-page:horizontal {
    background: white;
}
QWidget#_slideshow_toolbar QLabel,
QWidget#_slideshow_controls QLabel {
    background: transparent;
    color: white;
}
"""


def _load_user_qss(path: Path) -> str:
    """Load a QSS file with optional @palette variable substitution.

    Qt's QSS dialect has no native variables, so we add a tiny preprocessor:

        /* @palette
           accent:        #cba6f7
           bg:            #1e1e2e
           text:          #cdd6f4
        */

        QWidget {
            background-color: ${bg};
            color: ${text};
            selection-background-color: ${accent};
        }

    The header comment block is parsed for `name: value` pairs and any
    `${name}` reference elsewhere in the file is substituted with the
    corresponding value before the QSS is handed to Qt. This lets users
    recolor a bundled theme by editing the palette block alone, without
    hunting through the body for every hex literal.

    Backward compatibility: a file without an @palette block is returned
    as-is, so plain hand-written Qt-standard QSS still loads unchanged.
    Unknown ${name} references are left in place verbatim and logged as
    warnings so typos are visible in the log.
    """
    import re
    text = path.read_text()
    palette_match = re.search(r'/\*\s*@palette\b(.*?)\*/', text, re.DOTALL)
    if not palette_match:
        return text

    palette: dict[str, str] = {}
    for raw_line in palette_match.group(1).splitlines():
        # Strip leading whitespace and any leading * from C-style continuation
        line = raw_line.strip().lstrip('*').strip()
        if not line or ':' not in line:
            continue
        key, value = line.split(':', 1)
        key = key.strip()
        value = value.strip().rstrip(';').strip()
        # Allow trailing comments on the same line
        if '/*' in value:
            value = value.split('/*', 1)[0].strip()
        if key and value:
            palette[key] = value

    refs = set(re.findall(r'\$\{([a-zA-Z_][a-zA-Z0-9_]*)\}', text))
    missing = refs - palette.keys()
    if missing:
        log.warning(
            f"QSS @palette: unknown vars {sorted(missing)} in {path.name} "
            f"— left in place verbatim, fix the @palette block to define them"
        )

    def replace(m):
        return palette.get(m.group(1), m.group(0))

    return re.sub(r'\$\{([a-zA-Z_][a-zA-Z0-9_]*)\}', replace, text)


def run() -> None:
    from ..core.config import data_dir

    app = QApplication(sys.argv)

    # Set a stable Wayland app_id so Hyprland and other compositors can
    # consistently identify our windows by class (not by title, which
    # changes when search terms appear in the title bar). Qt translates
    # setDesktopFileName into the xdg-shell app_id on Wayland.
    app.setApplicationName("booru-viewer")
    app.setDesktopFileName("booru-viewer")

    # mpv requires LC_NUMERIC=C — Qt resets the locale in QApplication(),
    # so we must restore it after Qt init but before creating any mpv instances.
    import locale
    locale.setlocale(locale.LC_NUMERIC, "C")

    # Apply dark mode on Windows 10+ if system is set to dark
    if sys.platform == "win32":
        _apply_windows_dark_mode(app)

    # Load user custom stylesheet if it exists
    custom_css = data_dir() / "custom.qss"
    if custom_css.exists():
        try:
            # Use Fusion style with arrow color fix
            from PySide6.QtWidgets import QProxyStyle
            from PySide6.QtGui import QPalette, QColor, QPainter as _P
            from PySide6.QtCore import QPoint as _QP

            import re
            # Run through the @palette preprocessor (see _load_user_qss
            # for the dialect). Plain Qt-standard QSS files without an
            # @palette block are returned unchanged.
            css_text = _load_user_qss(custom_css)

            # Extract text color for arrows
            m = re.search(r'QWidget\s*\{[^}]*?(?:^|\s)color\s*:\s*(#[0-9a-fA-F]{3,8})', css_text, re.MULTILINE)
            arrow_color = QColor(m.group(1)) if m else QColor(200, 200, 200)

            class _DarkArrowStyle(QProxyStyle):
                """Fusion proxy that draws visible arrows on dark themes."""
                def drawPrimitive(self, element, option, painter, widget=None):
                    if element in (self.PrimitiveElement.PE_IndicatorSpinUp,
                                   self.PrimitiveElement.PE_IndicatorSpinDown,
                                   self.PrimitiveElement.PE_IndicatorArrowDown,
                                   self.PrimitiveElement.PE_IndicatorArrowUp):
                        painter.save()
                        painter.setRenderHint(_P.RenderHint.Antialiasing)
                        painter.setPen(Qt.PenStyle.NoPen)
                        painter.setBrush(arrow_color)
                        r = option.rect
                        cx, cy = r.center().x(), r.center().y()
                        s = min(r.width(), r.height()) // 3
                        from PySide6.QtGui import QPolygon
                        if element in (self.PrimitiveElement.PE_IndicatorSpinUp,
                                       self.PrimitiveElement.PE_IndicatorArrowUp):
                            painter.drawPolygon(QPolygon([
                                _QP(cx, cy - s), _QP(cx - s, cy + s), _QP(cx + s, cy + s)
                            ]))
                        else:
                            painter.drawPolygon(QPolygon([
                                _QP(cx - s, cy - s), _QP(cx + s, cy - s), _QP(cx, cy + s)
                            ]))
                        painter.restore()
                        return
                    super().drawPrimitive(element, option, painter, widget)

            app.setStyle(_DarkArrowStyle("Fusion"))
            # Prepend the base overlay defaults so even minimal custom.qss
            # files get a usable popout overlay. User rules with the same
            # selectors come last and win on tie.
            app.setStyleSheet(_BASE_POPOUT_OVERLAY_QSS + "\n" + css_text)

            # Extract selection color for grid highlight
            pal = app.palette()
            m = re.search(r'selection-background-color\s*:\s*(#[0-9a-fA-F]{3,8})', css_text)
            if m:
                pal.setColor(QPalette.ColorRole.Highlight, QColor(m.group(1)))
            app.setPalette(pal)
        except Exception as e:
            log.warning(f"Operation failed: {e}")
    else:
        # No custom.qss — still install the popout overlay defaults so the
        # floating toolbar/controls have a sane background instead of bare
        # letterbox color.
        app.setStyleSheet(_BASE_POPOUT_OVERLAY_QSS)

    # Set app icon (works in taskbar on all platforms)
    from PySide6.QtGui import QIcon
    # PyInstaller sets _MEIPASS for bundled data
    base_dir = Path(getattr(sys, '_MEIPASS', Path(__file__).parent.parent.parent))
    icon_path = base_dir / "icon.png"
    if not icon_path.exists():
        icon_path = Path(__file__).parent.parent.parent / "icon.png"
    if not icon_path.exists():
        icon_path = data_dir() / "icon.png"
    if icon_path.exists():
        app.setWindowIcon(QIcon(str(icon_path)))

    window = BooruApp()
    window.show()
    sys.exit(app.exec())