everything.py

# Copyright 2025 Apple Dragon
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#     http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.

import sys
import os
import stat
import json
import subprocess
import time
import csv
import shutil
import zipfile
import traceback
import threading
from concurrent.futures import ThreadPoolExecutor, as_completed
from pathlib import Path

from PyQt6.QtWidgets import (
    QApplication, QMainWindow, QWidget, QVBoxLayout, QHBoxLayout, QLabel, QLineEdit,
    QCheckBox, QPushButton, QTreeWidget, QTreeWidgetItem, QProgressBar, QMenu,
    QFileDialog, QMessageBox, QGroupBox, QInputDialog, QPlainTextEdit, QSplitter, QStackedWidget, QCompleter,
    QSlider, QToolButton, QStyle, QGraphicsDropShadowEffect, QTabWidget, QDialog, QRadioButton, QButtonGroup,
    QProgressDialog, QStyledItemDelegate
)
from PyQt6.QtCore import Qt, QThread, pyqtSignal, QTimer, QUrl, QMimeData, QPropertyAnimation, QEasingCurve, QMargins
from PyQt6.QtGui import QActionGroup, QBrush
from PyQt6.QtMultimedia import QMediaPlayer, QAudioOutput
from PyQt6.QtMultimediaWidgets import QVideoWidget
from PyQt6.QtGui import QPixmap, QMovie, QPainter, QFont, QColor, QPen, QLinearGradient, QGradient
from PyQt6.QtCore import QRectF, QEvent
from PyQt6.QtSvg import QSvgRenderer
from PyQt6.QtCharts import (
    QChart,
    QChartView,
    QBarSet,
    QHorizontalBarSeries,
    QBarCategoryAxis,
    QValueAxis,
)

CONFIG_PATH = os.path.expanduser("~/.everythingByMdfind.json")
DEBOUNCE_DELAY = 800

def read_config():
    if not os.path.isfile(CONFIG_PATH):
        return {}
    try:
        with open(CONFIG_PATH, "r", encoding="utf-8") as f:
            return json.load(f)
    except (OSError, ValueError) as exc:
        # ValueError covers json.JSONDecodeError (corrupt file); fall back to
        # defaults rather than crashing, but make the reason visible.
        print(f"Failed to read config: {exc}")
        return {}

def write_config(data):
    # Write to a temp file and atomically replace the target so an interrupted
    # write can never leave a half-written / corrupt config behind.
    tmp_path = CONFIG_PATH + ".tmp"
    try:
        with open(tmp_path, "w", encoding="utf-8") as f:
            json.dump(data, f, indent=2)
            f.flush()
            os.fsync(f.fileno())
        os.replace(tmp_path, CONFIG_PATH)
    except (OSError, ValueError) as exc:
        print(f"Failed to write config: {exc}")
        try:
            if os.path.exists(tmp_path):
                os.remove(tmp_path)
        except OSError:
            pass


def get_dialog_stylesheet(dark_mode=False, include_radio=False, button_padding="10px 16px"):
    """Generate consistent dialog stylesheet for dark/light mode.
    
    Args:
        dark_mode: True for dark theme, False for light theme
        include_radio: True to include QRadioButton styles
        button_padding: CSS padding for QPushButton
    """
    if dark_mode:
        base = """
            QDialog { background-color: #2d2d30; color: #d4d4d4; }
            QLabel { color: #e1e4e8; font-size: 14px; }
            QPushButton {
                background: qlineargradient(x1: 0, y1: 0, x2: 0, y2: 1, stop: 0 #0e4775, stop: 1 #0a3d66);
                border: 1px solid #1177bb; border-radius: 6px; padding: %s;
                color: white; font-weight: 600; min-width: 80px;
            }
            QPushButton:hover {
                background: qlineargradient(x1: 0, y1: 0, x2: 0, y2: 1, stop: 0 #1177bb, stop: 1 #0e639c);
            }
        """ % button_padding
        radio = """
            QRadioButton { color: #d4d4d4; font-size: 13px; padding: 8px; }
            QRadioButton::indicator { width: 16px; height: 16px; }
            QRadioButton::indicator:unchecked { border: 2px solid #404040; border-radius: 9px; background: #252526; }
            QRadioButton::indicator:checked { border: 2px solid #007fd4; border-radius: 9px; background: #007fd4; }
        """
    else:
        base = """
            QDialog { background-color: #ffffff; color: #24292f; }
            QLabel { color: #24292f; font-size: 14px; }
            QPushButton {
                background: qlineargradient(x1: 0, y1: 0, x2: 0, y2: 1, stop: 0 #2ea043, stop: 1 #238636);
                border: 1px solid #1a7f37; border-radius: 6px; padding: %s;
                color: white; font-weight: 600; min-width: 80px;
            }
            QPushButton:hover {
                background: qlineargradient(x1: 0, y1: 0, x2: 0, y2: 1, stop: 0 #2c974b, stop: 1 #1f883d);
            }
        """ % button_padding
        radio = """
            QRadioButton { color: #24292f; font-size: 13px; padding: 8px; }
            QRadioButton::indicator { width: 16px; height: 16px; }
            QRadioButton::indicator:unchecked { border: 2px solid #d1d9e0; border-radius: 9px; background: #ffffff; }
            QRadioButton::indicator:checked { border: 2px solid #0969da; border-radius: 9px; background: #0969da; }
        """
    return base + radio if include_radio else base


# Beautiful ToolTip class for showing confirmation messages
class BeautifulToolTip(QWidget):
    def __init__(self, parent=None):
        super().__init__(parent)
        self.setWindowFlags(Qt.WindowType.ToolTip | Qt.WindowType.FramelessWindowHint)
        self.setAttribute(Qt.WidgetAttribute.WA_TranslucentBackground)
        self.setFixedSize(280, 80)
        
        # Create layout
        layout = QVBoxLayout(self)
        layout.setContentsMargins(25, 20, 25, 20)
        
        # Create label
        self.label = QLabel()
        self.label.setAlignment(Qt.AlignmentFlag.AlignCenter)
        self.label.setWordWrap(True)
        font = QFont()
        font.setPointSize(16)
        font.setBold(True)
        font.setWeight(QFont.Weight.ExtraBold)
        self.label.setFont(font)
        
        # Add text shadow effect to label
        label_shadow = QGraphicsDropShadowEffect()
        label_shadow.setBlurRadius(8)
        label_shadow.setOffset(2, 2)
        label_shadow.setColor(QColor(0, 0, 0, 180))
        self.label.setGraphicsEffect(label_shadow)
        
        layout.addWidget(self.label)
        
        # Set up style
        self.setup_style()
        
        # Add shadow effect
        shadow = QGraphicsDropShadowEffect()
        shadow.setBlurRadius(30)
        shadow.setOffset(0, 6)
        shadow.setColor(QColor(0, 0, 0, 200))
        self.setGraphicsEffect(shadow)
        
        # Animation
        self.opacity_animation = QPropertyAnimation(self, b"windowOpacity")
        self.opacity_animation.setDuration(200)
        self.opacity_animation.setEasingCurve(QEasingCurve.Type.OutQuad)
        
        # Auto-hide timer
        self.hide_timer = QTimer()
        self.hide_timer.setSingleShot(True)
        self.hide_timer.timeout.connect(self.fade_out)
        
    def setup_style(self, dark=False):
        """Setup tooltip style. dark=True for dark mode blue style."""
        if dark:
            colors = ("rgba(33, 150, 243, 180)", "rgba(25, 118, 210, 180)", "150")
        else:
            colors = ("rgba(76, 175, 80, 200)", "rgba(56, 142, 60, 200)", "120")
        
        self.setStyleSheet(f"""
            BeautifulToolTip {{
                background: qlineargradient(x1: 0, y1: 0, x2: 0, y2: 1,
                    stop: 0 {colors[0]},
                    stop: 1 {colors[1]});
                border-radius: 15px;
                border: 3px solid rgba(255, 255, 255, {colors[2]});
            }}
            QLabel {{
                color: white;
                font-weight: bold;
                font-size: 16px;
                background: transparent;
                border: none;
                padding: 2px;
            }}
        """)
    
    def setup_dark_style(self):
        """Convenience method for dark style."""
        self.setup_style(dark=True)
    
    def show_message(self, message, parent_widget, duration=2000):
        # Stop any existing animations and timers first
        self.hide_timer.stop()
        self.opacity_animation.stop()
        
        # Safely disconnect any existing signal connections to prevent conflicts
        try:
            self.opacity_animation.finished.disconnect()
        except TypeError:
            # No connections exist, which is fine
            pass
        
        self.label.setText(message)
        
        # Position relative to parent widget
        if parent_widget:
            parent_rect = parent_widget.geometry()
            parent_center = parent_widget.mapToGlobal(parent_rect.center())
            
            # Position tooltip above the center of parent widget
            tooltip_x = parent_center.x() - self.width() // 2
            tooltip_y = parent_center.y() - parent_rect.height() // 2 - self.height() - 20
            
            # Ensure tooltip stays within screen bounds
            screen = QApplication.primaryScreen().geometry()
            if tooltip_x < 10:
                tooltip_x = 10
            elif tooltip_x + self.width() > screen.width() - 10:
                tooltip_x = screen.width() - self.width() - 10
            
            if tooltip_y < 10:
                tooltip_y = parent_center.y() + parent_rect.height() // 2 + 20
            
            self.move(tooltip_x, tooltip_y)
        
        # Show with fade-in animation
        self.setWindowOpacity(0.0)
        self.show()
        self.raise_()
        
        self.opacity_animation.setStartValue(0.0)
        self.opacity_animation.setEndValue(1.0)
        self.opacity_animation.start()
        
        # Auto-hide after duration
        self.hide_timer.start(duration)
    
    def fade_out(self):
        # Stop the hide timer to prevent conflicts
        self.hide_timer.stop()
        
        self.opacity_animation.setStartValue(1.0)
        self.opacity_animation.setEndValue(0.0)
        
        # Connect the finished signal only when we need it
        self.opacity_animation.finished.connect(self.hide_and_cleanup)
        self.opacity_animation.start()
    
    def hide_and_cleanup(self):
        """Hide the tooltip and clean up signal connections"""
        # Safely disconnect all signals to prevent conflicts
        try:
            self.opacity_animation.finished.disconnect()
        except TypeError:
            # No connections exist, which is fine
            pass
        self.hide()
        # Reset opacity for next time
        self.setWindowOpacity(1.0)


# Export Format Selection Dialog
class ExportFormatDialog(QDialog):
    def __init__(self, parent=None):
        super().__init__(parent)
        self.setWindowTitle("🚀 Export Format Selection")
        self.setModal(True)
        self.setFixedSize(520, 480)  # increase size to prevent text truncation
        
        # Apply current theme styling
        is_dark = hasattr(parent, 'dark_mode') and parent.dark_mode
        self.setStyleSheet(get_dialog_stylesheet(dark_mode=is_dark, include_radio=True, button_padding="10px 20px"))
        
        layout = QVBoxLayout(self)
        layout.setContentsMargins(20, 25, 20, 20)  # increase top margin to ensure title is fully visible
        layout.setSpacing(8)  # set appropriate spacing

        # Title
        title = QLabel("📤 Choose Export Format")
        title.setStyleSheet("""
            font-size: 18px; 
            font-weight: bold; 
            margin-bottom: 15px; 
            padding: 8px 5px; 
            min-height: 35px;
            max-height: 50px;
        """)
        title.setAlignment(Qt.AlignmentFlag.AlignCenter)  
        title.setWordWrap(True)
        layout.addWidget(title)
        
        # Format options - use list to avoid repetition
        self.format_group = QButtonGroup(self)
        format_options = [
            ("📄 JSON - Modern structured data", "Export as JSON with metadata and structured information",
             "    → Best for data processing, APIs, and modern applications"),
            ("📊 Excel - Spreadsheet with styling", "Export as Excel file with formatting and multiple columns",
             "    → Perfect for data analysis, charts, and business reports"),
            ("🌐 HTML - Interactive web page", "Export as styled HTML page with search and filtering",
             "    → Great for sharing, presentations, and web viewing"),
            ("📝 Markdown - Documentation format", "Export as Markdown for GitHub, documentation sites",
             "    → Ideal for GitHub, wikis, and documentation"),
            ("📋 CSV - Legacy spreadsheet format", "Export as simple CSV for basic compatibility",
             "    → Simple format for basic spreadsheet applications"),
        ]
        
        desc_style = "color: #6c757d; font-size: 12px; margin-left: 20px; padding: 2px 0px;"
        for idx, (label, tooltip, description) in enumerate(format_options):
            radio = QRadioButton(label)
            radio.setToolTip(tooltip)
            self.format_group.addButton(radio, idx)
            layout.addWidget(radio)
            
            desc = QLabel(description)
            desc.setStyleSheet(desc_style)
            desc.setWordWrap(True)
            layout.addWidget(desc)
            
            if idx < len(format_options) - 1:
                layout.addSpacing(5)
            
            if idx == 0:
                radio.setChecked(True)  # Set JSON as default
        
        layout.addStretch()
        
        # Buttons
        button_layout = QHBoxLayout()
        button_layout.addStretch()
        
        cancel_btn = QPushButton("Cancel")
        cancel_btn.clicked.connect(self.reject)
        button_layout.addWidget(cancel_btn)
        
        export_btn = QPushButton("📤 Export")
        export_btn.clicked.connect(self.accept)
        export_btn.setDefault(True)
        button_layout.addWidget(export_btn)
        
        layout.addLayout(button_layout)
    
    def get_selected_format(self):
        """Return the selected export format"""
        formats = ["json", "excel", "html", "markdown", "csv"]
        return formats[self.format_group.checkedId()]


# Export Success Dialog with multiple actions
class ExportSuccessDialog(QDialog):
    def __init__(self, parent=None, file_path="", export_format=""):
        super().__init__(parent)
        self.file_path = file_path
        self.export_format = export_format
        self.setWindowTitle("✅ Export Successful")
        self.setModal(True)
        self.setFixedSize(420, 200)
        
        # Apply current theme styling
        is_dark = hasattr(parent, 'dark_mode') and parent.dark_mode
        self.setStyleSheet(get_dialog_stylesheet(dark_mode=is_dark))
        
        layout = QVBoxLayout(self)
        layout.setContentsMargins(20, 20, 20, 20)
        layout.setSpacing(15)
        
        # Success message
        success_label = QLabel(f"✅ Successfully exported {export_format.upper()} file!")
        success_label.setStyleSheet("font-size: 16px; font-weight: bold; color: #28a745; margin-bottom: 10px;")
        layout.addWidget(success_label)
        
        # File path
        path_label = QLabel(f"📁 Location: {file_path}")
        path_label.setStyleSheet("font-size: 12px; word-wrap: true; margin-bottom: 10px;")
        path_label.setWordWrap(True)
        layout.addWidget(path_label)
        
        layout.addStretch()
        
        # Buttons
        button_layout = QHBoxLayout()
        
        # OK button
        ok_btn = QPushButton("OK")
        ok_btn.clicked.connect(self.accept)
        ok_btn.setDefault(True)
        button_layout.addWidget(ok_btn)
        
        # Open file button
        open_btn = QPushButton("📄 Open File")
        open_btn.clicked.connect(self.open_file)
        button_layout.addWidget(open_btn)
        
        # Open in Finder button
        finder_btn = QPushButton("🔍 Open in Finder")
        finder_btn.clicked.connect(self.open_in_finder)
        button_layout.addWidget(finder_btn)
        
        layout.addLayout(button_layout)
    
    def open_file(self):
        """Open the exported file with default application"""
        try:
            subprocess.run(["open", self.file_path], check=True)
        except Exception as e:
            QMessageBox.warning(self, "Error", f"Could not open file: {str(e)}")
    
    def open_in_finder(self):
        """Open the file location in Finder"""
        try:
            subprocess.run(["open", "-R", self.file_path], check=True)
        except Exception as e:
            QMessageBox.warning(self, "Error", f"Could not open Finder: {str(e)}")


# Custom Slider that responds to direct clicks
class ClickableSlider(QSlider):
    def __init__(self, orientation):
        super().__init__(orientation)
        
    def mousePressEvent(self, event):
        # Calculate the relative position of the click and convert to value
        value = self.minimum() + (self.maximum() - self.minimum()) * event.position().x() / self.width()
        self.setValue(int(value))
        # Emit the sliderMoved signal to update video position
        self.sliderMoved.emit(int(value))
        # Pass the event to the parent class
        super().mousePressEvent(event)

# Custom ChartView that handles clicks on entire chart area including axis labels
class ClickableChartView(QChartView):
    """Custom QChartView that allows clicking anywhere on a chart row to select it"""
    
    def __init__(self, chart, parent=None):
        super().__init__(chart, parent)
        self.main_window = None
        self.click_timer = QTimer()
        self.click_timer.setSingleShot(True)
        self.click_timer.timeout.connect(self._handle_single_click)
        self.click_count = 0
        self.last_click_index = -1
        
    def mousePressEvent(self, event):
        if event.button() == Qt.MouseButton.LeftButton:
            # Get the position relative to the chart
            pos = event.position() if hasattr(event, 'position') else event.pos()
            
            # Try to find which bar/category was clicked
            chart = self.chart()
            if not chart:
                super().mousePressEvent(event)
                return
            
            # Get the chart's plot area
            plot_area = chart.plotArea()
            
            # Check if click is within the chart area (including axis labels on the left)
            if pos.y() >= plot_area.top() and pos.y() <= plot_area.bottom():
                # Calculate which bar index based on Y position
                if hasattr(self, 'main_window') and self.main_window:
                    categories = getattr(self.main_window, 'scan_chart_categories', [])
                    if categories:
                        bar_height = plot_area.height() / len(categories)
                        # QtCharts displays horizontal bars from bottom to top
                        # So we need to reverse the index calculation
                        y_from_top = pos.y() - plot_area.top()
                        index = len(categories) - 1 - int(y_from_top / bar_height)
                        
                        if 0 <= index < len(categories):
                            # Handle click/double-click detection
                            if self.click_count == 0:
                                self.click_count = 1
                                self.last_click_index = index
                                self.click_timer.start(300)  # 300ms for double-click detection
                            elif self.click_count == 1 and self.last_click_index == index:
                                # Double-click detected
                                self.click_timer.stop()
                                self.click_count = 0
                                self.last_click_index = -1
                                if self.main_window:
                                    self.main_window.on_scan_chart_bar_double_clicked(index, None)
                                return
        
        super().mousePressEvent(event)
    
    def _handle_single_click(self):
        """Handle single click after timer expires (no double-click detected)"""
        if self.click_count == 1 and self.last_click_index >= 0:
            if self.main_window:
                self.main_window.on_scan_chart_bar_clicked(self.last_click_index, None)
        self.click_count = 0
        self.last_click_index = -1


# Custom QTreeWidget to support drag and drop of files to external applications
class DraggableTreeWidget(QTreeWidget):
    """Custom QTreeWidget to support drag and drop of files to external applications"""
    def __init__(self, parent=None):
        super().__init__(parent)
        self.setDragEnabled(True)

    def mimeTypes(self):
        return ['text/uri-list']

    def mimeData(self, items):
        mime_data = QMimeData()
        urls = []
        for item in items:
            path = item.text(3)  # column 3 is the full path
            urls.append(QUrl.fromLocalFile(path))
        mime_data.setUrls(urls)
        return mime_data


# Convert file size to a human-readable string
def format_size(size):
    """Convert file size to a human-readable string"""
    for unit in ['B', 'KB', 'MB', 'GB', 'TB']:
        if size < 1024:
            return f"{size:.2f} {unit}"
        size /= 1024
    return f"{size:.2f} TB"


def format_time_label(position_ms, duration_ms):
    """Format time in MM:SS / MM:SS format for media players."""
    current_mins, current_secs = divmod(position_ms // 1000, 60)
    total_mins, total_secs = divmod(duration_ms // 1000, 60)
    return f"🕒 {current_mins:02d}:{current_secs:02d} / {total_mins:02d}:{total_secs:02d}"


# Item-data role that carries a row's share-of-total (0-100 float) for the
# "Share" column. Rows without it (normal search results) render nothing.
SHARE_ROLE = Qt.ItemDataRole.UserRole + 100


class PercentBarDelegate(QStyledItemDelegate):
    """Draws a horizontal proportion bar with a percentage label.

    Used by the disk-analysis "Share" column to show each folder's fraction
    of the scanned total. The value is read from SHARE_ROLE; the framework
    still paints the row background/selection so highlighting stays uniform.
    """

    def __init__(self, parent=None, dark_mode_getter=None):
        super().__init__(parent)
        self._dark_mode_getter = dark_mode_getter

    def paint(self, painter, option, index):
        # Let the style paint the background/selection first (this column's
        # display text is empty, so nothing else is drawn over the bar).
        super().paint(painter, option, index)

        value = index.data(SHARE_ROLE)
        if value is None:
            return
        try:
            pct = float(value)
        except (TypeError, ValueError):
            return
        pct = max(0.0, min(100.0, pct))

        dark = bool(self._dark_mode_getter()) if self._dark_mode_getter else False
        if dark:
            track_color = QColor("#242536")
            grad_start, grad_end = QColor("#3b6fd6"), QColor("#8ab4ff")
        else:
            track_color = QColor("#eaeef5")
            grad_start, grad_end = QColor("#2f6fed"), QColor("#7fb0ff")

        rect = QRectF(option.rect).adjusted(6, 5, -6, -5)
        if rect.width() <= 0 or rect.height() <= 0:
            return
        radius = rect.height() / 2.0  # pill-shaped

        painter.save()
        painter.setRenderHint(QPainter.RenderHint.Antialiasing, True)
        # Track
        painter.setPen(Qt.PenStyle.NoPen)
        painter.setBrush(track_color)
        painter.drawRoundedRect(rect, radius, radius)
        # Filled portion with a left→right accent gradient
        if pct > 0:
            fill_width = max(rect.height(), rect.width() * pct / 100.0)
            fill_rect = QRectF(rect.x(), rect.y(), fill_width, rect.height())
            gradient = QLinearGradient(fill_rect.topLeft(), fill_rect.topRight())
            gradient.setColorAt(0.0, grad_start)
            gradient.setColorAt(1.0, grad_end)
            painter.setBrush(QBrush(gradient))
            painter.drawRoundedRect(fill_rect, radius, radius)
        # Percentage label centred on the bar; white over the fill reads well
        # in both themes.
        painter.setPen(QPen(QColor("#ffffff") if pct >= 45 else (
            QColor("#c8d3f5") if dark else QColor("#33415c"))))
        font = painter.font()
        font.setPointSizeF(max(8.0, font.pointSizeF() - 0.5))
        font.setBold(True)
        painter.setFont(font)
        painter.drawText(rect, int(Qt.AlignmentFlag.AlignCenter), f"{pct:.1f}%")
        painter.restore()


class LoadingOverlay(QWidget):
    """Lightweight, asset-free loading overlay.

    Draws a translucent scrim over its parent plus a centered rounded card
    with an animated spinner and a message — a much cleaner replacement for a
    modal QProgressDialog. Clicking anywhere cancels (if a callback is set).
    """

    def __init__(self, parent, dark_mode=True):
        super().__init__(parent)
        self._angle = 0
        self._message = "Scanning…"
        self._dark = dark_mode
        self._cancel_callback = None
        self._timer = QTimer(self)
        self._timer.timeout.connect(self._advance)
        self.setCursor(Qt.CursorShape.ArrowCursor)
        self.hide()

    def _advance(self):
        self._angle = (self._angle + 12) % 360
        self.update()

    def start(self, message, dark_mode=None, cancel_callback=None):
        if dark_mode is not None:
            self._dark = dark_mode
        self._message = message
        self._cancel_callback = cancel_callback
        parent = self.parentWidget()
        if parent:
            self.setGeometry(parent.rect())
            parent.installEventFilter(self)
        self.raise_()
        self.show()
        if not self._timer.isActive():
            self._timer.start(40)  # ~25 fps

    def stop(self):
        self._timer.stop()
        parent = self.parentWidget()
        if parent:
            parent.removeEventFilter(self)
        self.hide()

    def eventFilter(self, obj, event):
        if obj is self.parentWidget() and event.type() == QEvent.Type.Resize:
            self.setGeometry(self.parentWidget().rect())
        return super().eventFilter(obj, event)

    def mousePressEvent(self, event):
        if self._cancel_callback:
            self._cancel_callback()

    def paintEvent(self, event):
        painter = QPainter(self)
        painter.setRenderHint(QPainter.RenderHint.Antialiasing, True)

        # Scrim dimming the chart behind the overlay
        scrim = QColor(15, 16, 30, 165) if self._dark else QColor(245, 247, 251, 190)
        painter.fillRect(self.rect(), scrim)

        # Centered card
        cw, ch = 220, 130
        cx = (self.width() - cw) // 2
        cy = (self.height() - ch) // 2
        card = QRectF(cx, cy, cw, ch)
        painter.setPen(Qt.PenStyle.NoPen)
        painter.setBrush(QColor("#1f2233") if self._dark else QColor("#ffffff"))
        painter.drawRoundedRect(card, 16, 16)

        # Spinner: faint full ring + a rotating accent arc
        accent = QColor("#8ab4ff") if self._dark else QColor("#2f6fed")
        track = QColor(255, 255, 255, 45) if self._dark else QColor(0, 0, 0, 30)
        radius = 20
        sx = cx + cw / 2
        sy = cy + 42
        spinner_rect = QRectF(sx - radius, sy - radius, 2 * radius, 2 * radius)
        painter.setBrush(Qt.BrushStyle.NoBrush)
        ring_pen = QPen(track, 4)
        ring_pen.setCapStyle(Qt.PenCapStyle.RoundCap)
        painter.setPen(ring_pen)
        painter.drawArc(spinner_rect, 0, 360 * 16)
        arc_pen = QPen(accent, 4)
        arc_pen.setCapStyle(Qt.PenCapStyle.RoundCap)
        painter.setPen(arc_pen)
        painter.drawArc(spinner_rect, -self._angle * 16, 100 * 16)

        # Message + subtle cancel hint
        painter.setPen(QPen(QColor("#c8d3f5") if self._dark else QColor("#33415c")))
        font = painter.font()
        font.setPointSize(11)
        font.setBold(True)
        painter.setFont(font)
        painter.drawText(QRectF(cx, cy + 74, cw, 22),
                         int(Qt.AlignmentFlag.AlignHCenter | Qt.AlignmentFlag.AlignTop),
                         self._message)
        if self._cancel_callback:
            painter.setPen(QPen(QColor(200, 211, 245, 140) if self._dark else QColor(90, 100, 120, 160)))
            hint_font = painter.font()
            hint_font.setPointSize(9)
            hint_font.setBold(False)
            painter.setFont(hint_font)
            painter.drawText(QRectF(cx, cy + 98, cw, 18),
                             int(Qt.AlignmentFlag.AlignHCenter | Qt.AlignmentFlag.AlignTop),
                             "Click to cancel")


# Class to manage individual search tabs
class SearchTab:
    """Manages the data and widgets for a single search tab"""
    def __init__(self, query="", directory="", file_name_search=True, match_case=False, full_match=False, min_size="", max_size="", extensions="", is_pinned=False, tab_title="", extra_clause=None, is_bookmark=False, is_scan_tab=False):
        self.query = query
        self.directory = directory
        self.file_name_search = file_name_search
        self.match_case = match_case
        self.full_match = full_match
        self.min_size = min_size
        self.max_size = max_size
        self.extensions = extensions
        
        # Pin state
        self.is_pinned = is_pinned
        self.tab_title = tab_title  # Store original tab title
        self.is_scan_tab = is_scan_tab
        
        # Bookmark search fields
        self.extra_clause = extra_clause
        self.is_bookmark = is_bookmark

        # Search results data
        self.all_file_data = []
        self.file_data = []
        self.current_loaded = 0
        self.items_found_count = 0  # Store the number of items found for this tab
        self.scan_chart_data = []  # Usage scan visualization cache
        self.scan_chart_title = ""
        
        # Create the tree widget for this tab
        self.tree = DraggableTreeWidget()
        # Column 4 ("Share") shows a proportion bar for disk-analysis tabs and
        # stays hidden for ordinary search results. Path remains column 3 so
        # existing column references are unaffected.
        self.tree.setColumnCount(5)
        self.tree.setHeaderLabels(["Name", "Size", "Date Modified", "Path", "Share"])
        self.tree.setSelectionMode(QTreeWidget.SelectionMode.ExtendedSelection)
        self.tree.setSelectionBehavior(QTreeWidget.SelectionBehavior.SelectRows)
        self.tree.setSortingEnabled(False)
        self.tree.setColumnWidth(0, 200)
        self.tree.setColumnWidth(1, 80)
        self.tree.setColumnWidth(2, 130)
        self.tree.setColumnWidth(3, 350)
        self.tree.setColumnWidth(4, 150)
        self.tree.setColumnHidden(4, True)
        # Show the "Share" bar right after "Size" (visual position 2) while
        # keeping its logical index 4, so it is immediately visible instead of
        # hidden past the wide "Path" column. Logical indices are unchanged.
        self.tree.header().moveSection(self.tree.header().visualIndex(4), 2)
        
        # Sort settings
        self.sort_column = -1
        self.sort_order = Qt.SortOrder.AscendingOrder
        
        # Search worker thread
        self.search_worker = None


# Thread class to run mdfind in the background.
# Reads results line by line based on search parameters and sends them to the main thread.
class SearchWorker(QThread):
    """Thread class to run mdfind in the background.
    Reads results line by line based on search parameters and sends them to the main thread."""
    progress_signal = pyqtSignal(int)
    result_signal = pyqtSignal(list)
    error_signal = pyqtSignal(str)
    
    def __init__(self, query, directory, search_by_file_name, match_case, full_match, extra_clause=None, is_bookmark=False):
        super().__init__()
        self.query = query
        self.directory = directory
        self.search_by_file_name = search_by_file_name
        self.match_case = match_case
        self.full_match = full_match
        self.extra_clause = extra_clause
        self.is_bookmark = is_bookmark
        self._is_running = True
        self.process = None

    def run(self):
        files_info = []
        idx = 0
        cmd = ["mdfind"]

        # If it's a bookmark search, use only the extra clause
        if self.is_bookmark and self.extra_clause is not None:
            query_str = self.extra_clause
        else:
            # Normal search behavior as before
            full_match_str = "" if self.full_match else "*"
            case_modifier = "" if self.match_case else "cd"
            if self.search_by_file_name:
                query_str = f'kMDItemFSName == "{full_match_str}{self.query}{full_match_str}"{case_modifier}'
                if self.extra_clause is not None:
                    query_str += f" && {self.extra_clause}"
            else:
                if self.query != "":
                    query_str = f'kMDItemTextContent == "{full_match_str}{self.query}{full_match_str}"{case_modifier}'
                    if self.extra_clause is not None:
                        query_str += f" && {self.extra_clause}"
                else:
                    if self.extra_clause is not None:
                        query_str = self.extra_clause
                    else:
                        return
                    
        cmd.append(query_str)

        if self.directory:
            dir_expanded = os.path.expanduser(self.directory)
            cmd.extend(["-onlyin", dir_expanded])

        # print(f"Running mdfind with query: {cmd}")
        try:
            self.process = subprocess.Popen(cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True)
        except Exception as e:
            self.error_signal.emit(str(e))
            return

        try:
            while self._is_running:
                line = self.process.stdout.readline()
                if not line:
                    break
                idx += 1
                path = line.strip()
                if path:
                    try:
                        # Use single os.stat() call instead of multiple os.path calls
                        stat_result = os.stat(path)
                        is_dir = stat.S_ISDIR(stat_result.st_mode)
                        size_ = 0 if is_dir else stat_result.st_size
                        mtime = stat_result.st_mtime
                        files_info.append((os.path.basename(path), size_, mtime, path))
                    except (OSError, IOError):
                        # File may have been deleted or is inaccessible
                        continue
                if idx % 10 == 0:
                    self.progress_signal.emit(min(100, idx % 100))
            self.process.wait()
            self.result_signal.emit(files_info)
        except Exception as e:
            self.error_signal.emit(str(e))
            self.stop()
        finally:
            self.progress_signal.emit(0)

    def stop(self):
        self._is_running = False
        if self.process is not None:
            try:
                self.process.terminate()
            except Exception:
                pass


class DirectoryScanWorker(QThread):
    """Scan top-level directories under a root path and report sizes"""

    progress_signal = pyqtSignal(int, int, str)  # processed, total, current dir name
    result_signal = pyqtSignal(list)
    error_signal = pyqtSignal(str)
    cancelled_signal = pyqtSignal()

    # Cap parallel `du` processes so we speed up wall-clock time on many
    # folders without thrashing the disk with unbounded concurrency.
    MAX_WORKERS = 8

    def __init__(self, root_path, entries=None):
        super().__init__()
        self.root_path = Path(root_path)
        self.entries = entries
        self._is_running = True
        self._procs = set()
        self._procs_lock = threading.Lock()

    def run(self):
        try:
            entries = self.entries if self.entries is not None else [entry for entry in self.root_path.iterdir() if entry.is_dir()]
        except Exception as exc:
            self.error_signal.emit(f"Failed to list '{self.root_path}': {exc}")
            return

        total = len(entries)
        if total == 0:
            self.result_signal.emit([])
            return

        # Scan folders concurrently: `du` is largely I/O-bound, so overlapping
        # several folders shrinks total scan time dramatically versus running
        # them one after another.
        results = []
        processed = 0
        max_workers = min(self.MAX_WORKERS, total)
        with ThreadPoolExecutor(max_workers=max_workers) as executor:
            future_to_entry = {
                executor.submit(self._get_directory_size, entry): entry
                for entry in entries
            }
            for future in as_completed(future_to_entry):
                if not self._is_running:
                    # Cancel anything still queued; running processes are
                    # terminated via stop().
                    executor.shutdown(wait=False, cancel_futures=True)
                    self.cancelled_signal.emit()
                    return

                entry = future_to_entry[future]
                try:
                    size_bytes = future.result()
                except Exception:
                    size_bytes = 0
                results.append((entry.name, size_bytes))
                processed += 1
                self.progress_signal.emit(processed, total, entry.name)

        if not self._is_running:
            self.cancelled_signal.emit()
            return

        self.result_signal.emit(results)

    def _get_directory_size(self, entry):
        if not self._is_running:
            return 0
        try:
            proc = subprocess.Popen(
                ["du", "-skxP", str(entry)],
                stdout=subprocess.PIPE,
                stderr=subprocess.PIPE
            )
        except (OSError, ValueError):
            return 0

        with self._procs_lock:
            self._procs.add(proc)
        try:
            stdout, _ = proc.communicate()
        except Exception:
            return 0
        finally:
            with self._procs_lock:
                self._procs.discard(proc)

        try:
            text = stdout.decode(errors="ignore").strip()
            if text:
                last_line = text.splitlines()[-1]
                first_token = last_line.split()[0]
                return int(first_token) * 1024
        except (ValueError, IndexError):
            return 0
        return 0

    def stop(self):
        self._is_running = False
        # Terminate in-flight `du` processes so cancellation is responsive
        # instead of waiting for large folders to finish.
        with self._procs_lock:
            for proc in list(self._procs):
                try:
                    proc.terminate()
                except Exception:
                    pass


class SubdirScanWorker(QThread):
    """Scan immediate subdirectories of a directory in background"""
    
    result_signal = pyqtSignal(list)  # List of (name, size, Path) tuples
    error_signal = pyqtSignal(str)
    
    def __init__(self, parent_dir):
        super().__init__()
        self.parent_dir = Path(parent_dir)
        self._is_running = True
    
    def run(self):
        try:
            completed = subprocess.run(
                ["du", "-d", "1", "-kxP", str(self.parent_dir)],
                stdout=subprocess.PIPE,
                stderr=subprocess.PIPE,
                check=False,
                timeout=60
            )
            stdout = completed.stdout.decode(errors="ignore").strip()
            if not stdout:
                self.result_signal.emit([])
                return
            
            results = []
            lines = stdout.splitlines()
            parent_path = self.parent_dir.resolve()
            
            for line in lines:
                if not self._is_running:
                    return
                
                parts = line.split(maxsplit=1)
                if len(parts) < 2:
                    continue
                try:
                    size_kb = int(parts[0])
                    path_str = parts[1]
                    entry_path = Path(path_str).resolve()
                    
                    # Skip the parent directory itself
                    if entry_path == parent_path:
                        continue
                    
                    # Only include immediate children
                    if entry_path.parent == parent_path and entry_path.is_dir():
                        results.append((entry_path.name, size_kb * 1024, entry_path))
                except (ValueError, OSError):
                    continue
            
            self.result_signal.emit(results)
        except subprocess.TimeoutExpired:
            self.error_signal.emit("Scan timeout - directory too large or slow")
        except Exception as exc:
            self.error_signal.emit(f"Scan failed: {exc}")
    
    def stop(self):
        self._is_running = False


class ImageLoaderThread(QThread):
    """Background thread for loading and scaling images to avoid UI blocking"""
    loaded = pyqtSignal(QPixmap, int, int)  # pixmap, original_width, original_height
    error = pyqtSignal(str)
    
    def __init__(self, path, target_size):
        super().__init__()
        self.path = path
        self.target_size = target_size
        
    def run(self):
        try:
            pixmap = QPixmap(self.path)
            if pixmap.isNull():
                self.error.emit(f"Failed to load image: {self.path}")
                return
            
            original_width = pixmap.width()
            original_height = pixmap.height()
            
            # Scale down if larger than target size
            if pixmap.width() > self.target_size.width() or pixmap.height() > self.target_size.height():
                pixmap = pixmap.scaled(
                    self.target_size,
                    Qt.AspectRatioMode.KeepAspectRatio,
                    Qt.TransformationMode.SmoothTransformation
                )
            
            self.loaded.emit(pixmap, original_width, original_height)
        except Exception as e:
            self.error.emit(str(e))


class MediaPlayerManager:
    """Manages media playback functionality shared between embedded and standalone players"""
    
    def __init__(self, parent=None):
        self.parent = parent
        self.audio_output = QAudioOutput()
        self.media_player = QMediaPlayer()
        self.audio_output.setVolume(0.7)  # Default 70%
        self.video_extensions = set()
        self.audio_extensions = set()
        self.current_media_path = None
        self.slider_dragging = False
        self.was_playing = False
        
    def setup_extensions(self, video_ext, audio_ext):
        """Set up the video and audio extensions"""
        self.video_extensions = video_ext
        self.audio_extensions = audio_ext
    
    def set_video_output(self, video_widget):
        """Set the video output widget"""
        self.media_player.setVideoOutput(video_widget)
        self.media_player.setAudioOutput(self.audio_output)
    
    def play_media(self, path, is_audio=False):
        """Play a media file"""
        self.current_media_path = path
        self.media_player.setSource(QUrl.fromLocalFile(path))
        self.media_player.play()
        return True
    
    def stop(self):
        """Stop media playback"""
        self.media_player.stop()
        self.current_media_path = None
    
    def toggle_play_pause(self):
        """Toggle between play and pause states"""
        if self.media_player.playbackState() == QMediaPlayer.PlaybackState.PlayingState:
            self.media_player.pause()
            return False
        else:
            self.media_player.play()
            return True
    
    def set_position(self, position):
        """Set the playback position"""
        self.media_player.setPosition(position)
    
    def get_position(self):
        """Get the current playback position"""
        return self.media_player.position()
    
    def get_duration(self):
        """Get the media duration"""
        return self.media_player.duration()
    
    def set_volume(self, volume_percent):
        """Set volume as a percentage (0-100)"""
        self.audio_output.setVolume(volume_percent / 100.0)
    
    def toggle_mute(self):
        """Toggle audio mute state"""
        current_mute = self.audio_output.isMuted()
        self.audio_output.setMuted(not current_mute)
        return not current_mute
    
    def get_volume(self):
        """Get current volume as percentage (0-100)"""
        return int(self.audio_output.volume() * 100)
    
    def on_slider_pressed(self):
        """Handle slider press event"""
        self.slider_dragging = True
        self.was_playing = self.media_player.playbackState() == QMediaPlayer.PlaybackState.PlayingState
        if self.was_playing:
            self.media_player.pause()
    
    def on_slider_released(self):
        """Handle slider release event"""
        self.slider_dragging = False
        if self.was_playing:
            self.media_player.play()
    
    def connect_signals(self, position_callback, duration_callback, state_callback):
        """Connect signal handlers for the media player"""
        self.media_player.positionChanged.connect(position_callback)
        self.media_player.durationChanged.connect(duration_callback)
        self.media_player.playbackStateChanged.connect(state_callback)


# Update StandalonePlayerWindow to use MediaPlayerManager
class StandalonePlayerWindow(QMainWindow):
    def __init__(self, parent=None):
        super().__init__(parent)
        self.setWindowTitle("Media Player")
        self.resize(800, 600)  # Default size, user can resize
        
        # Main widget and layout
        central_widget = QWidget()
        main_layout = QVBoxLayout(central_widget)
        
        # Video widget
        self.video_widget = QVideoWidget()
        if getattr(QVideoWidget, "setAspectRatioMode", None) is not None:
            self.video_widget.setAspectRatioMode(Qt.AspectRatioMode.KeepAspectRatio)
        
        self.video_widget.installEventFilter(self)
        
        # Audio label for audio files
        self.audio_label = QLabel()
        self.audio_label.setAlignment(Qt.AlignmentFlag.AlignCenter)
        self.audio_label.setWordWrap(True)
        font = QFont()
        font.setPointSize(16)
        font.setBold(True)
        self.audio_label.setFont(font)
        self.audio_label.setVisible(False)
        
        self.audio_label.installEventFilter(self)
        
        # Media container to hold both video widget and audio label
        media_container = QWidget()
        media_layout = QVBoxLayout(media_container)
        media_layout.setContentsMargins(0, 0, 0, 0)
        media_layout.addWidget(self.video_widget)
        media_layout.addWidget(self.audio_label)
        
        main_layout.addWidget(media_container, 1)
        
        # Controls layout
        controls_layout = QHBoxLayout()
        
        # Play/Pause button
        self.play_button = QToolButton()
        self.play_button.setIcon(self.style().standardIcon(QStyle.StandardPixmap.SP_MediaPlay))
        controls_layout.addWidget(self.play_button)
        
        # Time label
        self.time_label = QLabel("🕒 00:00 / 00:00")
        self.time_label.setMinimumWidth(100)
        controls_layout.addWidget(self.time_label)
        
        # Seek slider
        self.seek_slider = ClickableSlider(Qt.Orientation.Horizontal)
        self.seek_slider.setRange(0, 0)
        controls_layout.addWidget(self.seek_slider, 4)
        
        # Volume button
        self.volume_button = QToolButton()
        self.volume_button.setIcon(self.style().standardIcon(QStyle.StandardPixmap.SP_MediaVolume))
        controls_layout.addWidget(self.volume_button)
        
        # Volume slider
        self.volume_slider = QSlider(Qt.Orientation.Horizontal)
        self.volume_slider.setRange(0, 100)
        self.volume_slider.setValue(70)  # Default volume
        self.volume_slider.setMaximumWidth(100)
        controls_layout.addWidget(self.volume_slider)
        
        main_layout.addLayout(controls_layout)
        
        # Create the media player manager
        self.player_manager = MediaPlayerManager(self)
        self.player_manager.set_video_output(self.video_widget)
        
        # Connect signals
        self.play_button.clicked.connect(self.toggle_play_pause)
        self.seek_slider.sliderMoved.connect(self.player_manager.set_position)
        self.seek_slider.sliderPressed.connect(self.player_manager.on_slider_pressed)
        self.seek_slider.sliderReleased.connect(self.player_manager.on_slider_released)
        self.volume_button.clicked.connect(self.toggle_mute)
        self.volume_slider.valueChanged.connect(self.player_manager.set_volume)
        
        # Connect media player signals
        self.player_manager.connect_signals(
            self.update_position, 
            self.update_duration,
            self.on_playback_state_changed
        )
        
        self.setCentralWidget(central_widget)
        self.continuous_playback = False
        self.dark_mode = False
        self.current_media_path = None
        
    def setup_extensions(self, video_ext, audio_ext):
        """Set up the video and audio extensions from the parent app"""
        self.player_manager.setup_extensions(video_ext, audio_ext)
        
    def set_continuous_playback(self, enabled):
        """Set whether continuous playback is enabled"""
        self.continuous_playback = enabled
        
    def set_dark_mode(self, enabled):
        """Set dark mode for the player"""
        self.dark_mode = enabled
        filename = os.path.basename(self.current_media_path) if self.current_media_path else ""
        if filename:
            self.set_audio_label_text(filename, not enabled)
        
    def play_media(self, path, is_video=True):
        """Play a media file"""
        self.current_media_path = path
        
        # Update UI based on media type
        if is_video:
            self.video_widget.setVisible(True)
            self.audio_label.setVisible(False)
        else:
            self.video_widget.setVisible(False)
            self.audio_label.setVisible(True)
            filename = os.path.basename(path)
            self.set_audio_label_text(filename, self.dark_mode)
        
        # Use the player manager to play the media
        self.player_manager.play_media(path)
        self.play_button.setIcon(self.style().standardIcon(QStyle.StandardPixmap.SP_MediaPause))
        
    def toggle_play_pause(self):
        is_playing = self.player_manager.toggle_play_pause()
        icon = QStyle.StandardPixmap.SP_MediaPause if is_playing else QStyle.StandardPixmap.SP_MediaPlay
        self.play_button.setIcon(self.style().standardIcon(icon))
    
    def update_position(self, position):
        try:
            if not self.player_manager.slider_dragging:
                self.seek_slider.setValue(position)
            
            total_duration = self.player_manager.get_duration()
            self.time_label.setText(format_time_label(position, total_duration))
        except Exception:
            pass
    
    def update_duration(self, duration):
        self.seek_slider.setRange(0, duration)
        if duration > 0:
            self.play_button.setIcon(self.style().standardIcon(QStyle.StandardPixmap.SP_MediaPause))
    
    def toggle_mute(self):
        is_muted = self.player_manager.toggle_mute()
        icon = QStyle.StandardPixmap.SP_MediaVolumeMuted if is_muted else QStyle.StandardPixmap.SP_MediaVolume
        self.volume_button.setIcon(self.style().standardIcon(icon))
        
        if not is_muted:
            self.volume_slider.setValue(self.player_manager.get_volume())
    
    def on_playback_state_changed(self, state):
        if state == QMediaPlayer.PlaybackState.StoppedState:
            if self.continuous_playback and self.player_manager.get_position() > 0:
                # Signal to the main app that we need to play the next media
                self.parent().play_next_in_standalone()
    
    def set_audio_label_text(self, filename, is_dark=False):
        """Set audio label text with consistent styling"""
        color = 'white' if is_dark else 'black'
        self.audio_label.setText(f"<div style='padding: 20px; border-radius: 10px;'>"
                                f"<div style='font-size: 24pt; color: {color};'>{filename}</div>"
                                f"</div>")
    
    def closeEvent(self, event):
        # Signal the parent to restore the embedded player
        self.parent().restore_embedded_player()
        event.accept()
        
    def eventFilter(self, obj, event):
        if event.type() == event.Type.MouseButtonPress and (obj == self.video_widget or obj == self.audio_label):
            if event.button() == Qt.MouseButton.LeftButton:
                self.toggle_play_pause()
                return True
        return super().eventFilter(obj, event)


class MdfindApp(QMainWindow):
    def __init__(self):
        super().__init__()
                    
        # Load theme and settings from config
        config = read_config()
        self.theme_mode = config.get("theme_mode", "light")  # light, dark, tokyo_night, tokyo_night_storm
        self.history_enabled = config.get("history_enabled", True)
        self.preview_enabled = config.get("preview_enabled", False) 
        self.continuous_playback = config.get("continuous_playback", False)
        self.simple_mode = config.get("simple_mode", False)  # Simple/Advanced UI toggle
        
        # Keep backward compatibility with old dark_mode setting
        if "dark_mode" in config and "theme_mode" not in config:
            self.theme_mode = "dark" if config["dark_mode"] else "light"
        
        # For backward compatibility, also set dark_mode property
        self.dark_mode = self.theme_mode in ["dark", "tokyo_night", "tokyo_night_storm"]
        self.slider_dragging = False  # Initialize slider_dragging attribute
        self.setWindowTitle("Everything by mdfind")
        size = config.get("window_size", {"width": 1920, "height": 1000})
        self.resize(size["width"], size["height"])
        
        # Set window properties for modern appearance
        self.setWindowFlags(self.windowFlags())
        
        # Setup custom titlebar theming
        self.setup_custom_titlebar()

        # Define recognizable extensions before initializing extension emoji map
        self.image_extensions = {".jpg", ".jpeg", ".png", ".gif", ".bmp", ".webp",".heic"}
        self.video_extensions = {".mp4", ".mov", ".avi", ".mkv", ".mpg", ".mpeg"}
        self.audio_extensions = {".mp3", ".wav", ".aac", ".ogg", ".flac", ".m4a", ".wma", ".caf",".aif",".m4r",".au"}

        # ========== Menu Bar ==========
        menubar = self.menuBar()
        
        # File menu
        file_menu = menubar.addMenu('📁 File')
        export_action = file_menu.addAction('📤 Export Results...')
        export_action.triggered.connect(self.export_results)
        export_action.setShortcut('Ctrl+E')
        
        help_menu = menubar.addMenu('❓ Help')
        about_action = help_menu.addAction('ℹ️ About')
        about_action.triggered.connect(self.show_about_dialog)
        # Add a "History" menu
        history_menu = menubar.addMenu('📚 History')
        clear_history_action = history_menu.addAction('🧹 Clear History')
        clear_history_action.triggered.connect(self.clear_history)
        enable_history_action = history_menu.addAction("✅ Enable History")
        enable_history_action.setCheckable(True)
        enable_history_action.setChecked(self.history_enabled)
        enable_history_action.triggered.connect(self.toggle_history)

        # Add a "View" menu
        view_menu = menubar.addMenu('👀 View')
        
        # Simple Mode toggle
        simple_mode_action = view_menu.addAction('✨ Simple Mode')
        simple_mode_action.setCheckable(True)
        simple_mode_action.setChecked(self.simple_mode)
        simple_mode_action.triggered.connect(self.toggle_simple_mode)
        self.simple_mode_action = simple_mode_action
        view_menu.addSeparator()
        
        toggle_preview_action = view_menu.addAction('👁️ Toggle Preview')
        toggle_preview_action.setCheckable(True)
        toggle_preview_action.setChecked(self.preview_enabled) # Use the loaded setting instead of hardcoded False
        toggle_preview_action.triggered.connect(self.toggle_preview)
        # Store reference to the toggle_preview_action for later use
        self.toggle_preview_action = toggle_preview_action

        # Add continuous playback action
        continuous_playback_action = view_menu.addAction('🔄 Continuous Playback')
        continuous_playback_action.setCheckable(True)
        continuous_playback_action.setChecked(self.continuous_playback)
        continuous_playback_action.triggered.connect(self.toggle_continuous_playback)
        self.continuous_playback_action = continuous_playback_action
        
        # Theme selection submenu
        themes_menu = view_menu.addMenu('🎨 Themes')
        
        # Create theme action group for exclusive selection
        self.theme_action_group = QActionGroup(self)
        
        # Light theme
        light_theme_action = themes_menu.addAction('☀️ Light')
        light_theme_action.setCheckable(True)
        light_theme_action.triggered.connect(lambda: self.set_theme('light'))
        self.theme_action_group.addAction(light_theme_action)
        
        # Dark theme
        dark_theme_action = themes_menu.addAction('🌙 Dark')
        dark_theme_action.setCheckable(True)
        dark_theme_action.triggered.connect(lambda: self.set_theme('dark'))
        self.theme_action_group.addAction(dark_theme_action)
        
        # Tokyo Night theme
        tokyo_night_action = themes_menu.addAction('🌃 Tokyo Night')
        tokyo_night_action.setCheckable(True)
        tokyo_night_action.triggered.connect(lambda: self.set_theme('tokyo_night'))
        self.theme_action_group.addAction(tokyo_night_action)
        
        # Tokyo Night Storm theme
        tokyo_storm_action = themes_menu.addAction('⛈️ Tokyo Night Storm')
        tokyo_storm_action.setCheckable(True)
        tokyo_storm_action.triggered.connect(lambda: self.set_theme('tokyo_night_storm'))
        self.theme_action_group.addAction(tokyo_storm_action)
        
        # Chinolor Dark theme (Chinese traditional colors)
        chinolor_dark_action = themes_menu.addAction('🏮 Chinolor Dark')
        chinolor_dark_action.setCheckable(True)
        chinolor_dark_action.triggered.connect(lambda: self.set_theme('chinolor_dark'))
        self.theme_action_group.addAction(chinolor_dark_action)
        
        # Chinolor Light theme (Chinese traditional colors)
        chinolor_light_action = themes_menu.addAction('🏯 Chinolor Light')
        chinolor_light_action.setCheckable(True)
        chinolor_light_action.triggered.connect(lambda: self.set_theme('chinolor_light'))
        self.theme_action_group.addAction(chinolor_light_action)
        
        # Set current theme as checked
        if self.theme_mode == 'light':
            light_theme_action.setChecked(True)
        elif self.theme_mode == 'dark':
            dark_theme_action.setChecked(True)
        elif self.theme_mode == 'tokyo_night':
            tokyo_night_action.setChecked(True)
        elif self.theme_mode == 'tokyo_night_storm':
            tokyo_storm_action.setChecked(True)
        elif self.theme_mode == 'chinolor_dark':
            chinolor_dark_action.setChecked(True)
        elif self.theme_mode == 'chinolor_light':
            chinolor_light_action.setChecked(True)
        
        # Apply the current theme
        self.apply_current_theme()
        
        # === Bookmarks Menu ===
        bookmarks_menu = menubar.addMenu("🔖 Bookmarks")
        bookmarks_menu.addAction("📏 Large Files", self.bookmark_large_files)
        bookmarks_menu.addAction("🎬 Video Files", self.bookmark_videos)
        bookmarks_menu.addAction("🎵 Audio Files", self.bookmark_audio)
        bookmarks_menu.addAction("🖼️ Images", self.bookmark_images)
        bookmarks_menu.addAction("🗜️ Archives", self.bookmark_archives)
        bookmarks_menu.addAction("📱 Applications", self.bookmark_applications)
        bookmarks_menu.addSeparator()
        bookmarks_menu.addAction("🕐 Recent 24 Hours", self.bookmark_recent_24h)
        bookmarks_menu.addAction("📅 Recent 7 Days", self.bookmark_recent_7d)
        bookmarks_menu.addAction("📆 Recent 30 Days", self.bookmark_recent_30d)
        
        self.initialize_extension_emoji_map()
        
        # ======= Main layout: QSplitter, left for search/list and right for preview ===========
        splitter = QSplitter(self)
        splitter.setOrientation(Qt.Orientation.Horizontal)
        splitter.setChildrenCollapsible(False)
        splitter.setObjectName("mainSplitter")
        self.setCentralWidget(splitter)

        # ========== Left side ==========
        left_container = QWidget()
        left_container.setObjectName("leftContainer")
        left_layout = QVBoxLayout(left_container)
        left_layout.setContentsMargins(20, 16, 20, 16)
        left_layout.setSpacing(16)

        # First row: Search Query input and statistics
        form_layout = QHBoxLayout()
        lbl_query = QLabel("🔍 Search Query:")
        lbl_query.setObjectName("queryLabel")
        
        self.edit_query = QLineEdit()
        self.edit_query.setPlaceholderText("Enter search terms...")

        # Create toggle buttons inside the search input (like VS Code)
        self.chk_file_name = QToolButton()
        self.chk_file_name.setCheckable(True)
        self.chk_file_name.setChecked(True)
        self.chk_file_name.setToolTip("Search by File Name\n(when off: search in file content and metadata)")
        self.chk_file_name.setText("Fn")
        self.chk_file_name.setObjectName("searchToggleBtn")

        self.chk_match_case = QToolButton()
        self.chk_match_case.setCheckable(True)
        self.chk_match_case.setToolTip("Match Case")
        self.chk_match_case.setText("Aa")
        self.chk_match_case.setObjectName("searchToggleBtn")

        self.chk_full_match = QToolButton()
        self.chk_full_match.setCheckable(True)
        self.chk_full_match.setToolTip("Full Match")
        self.chk_full_match.setText('""')
        self.chk_full_match.setObjectName("searchToggleBtn")

        # Build the search container: QLineEdit + toggle buttons
        self.search_container = QWidget()
        self.search_container.setObjectName("searchContainer")
        search_container_layout = QHBoxLayout(self.search_container)
        search_container_layout.setContentsMargins(0, 0, 4, 0)
        search_container_layout.setSpacing(2)
        search_container_layout.addWidget(self.edit_query)
        search_container_layout.addWidget(self.chk_file_name)
        search_container_layout.addWidget(self.chk_match_case)
        search_container_layout.addWidget(self.chk_full_match)

        # Track focus to style the search container border
        self.edit_query.installEventFilter(self)

        self.lbl_items_found = QLabel("📊 0 items found")
        self.lbl_items_found.setObjectName("itemsFoundLabel")
        
        # Add refresh button
        self.btn_refresh = QPushButton("🔄 Refresh")
        self.btn_refresh.setToolTip("Refresh current search")
        self.btn_refresh.setMaximumWidth(120)
        self.btn_refresh.clicked.connect(self.refresh_current_search)

        form_layout.addWidget(lbl_query)
        form_layout.addWidget(self.search_container, 4)
        form_layout.addWidget(self.lbl_items_found, 1)
        form_layout.addWidget(self.btn_refresh)
        left_layout.addLayout(form_layout)

        # Second row: Directory selection (optional)
        self.dir_row_widget = QWidget()
        form_layout2 = QHBoxLayout(self.dir_row_widget)
        form_layout2.setContentsMargins(0, 0, 0, 0)
        lbl_dir = QLabel("📁 Directory (optional):")
        lbl_dir.setObjectName("directoryLabel")
        
        self.edit_dir = QLineEdit()
        self.edit_dir.setPlaceholderText("Leave empty to search everywhere...")
        
        btn_select_dir = QPushButton("📂 Select Dir")
        btn_select_dir.clicked.connect(self.select_directory)

        self.scan_home_button = QPushButton("🏠 Analyze Home Space")
        self.scan_home_button.clicked.connect(self.start_directory_scan)

        form_layout2.addWidget(lbl_dir)
        form_layout2.addWidget(self.edit_dir, 3)
        form_layout2.addWidget(btn_select_dir, 1)
        form_layout2.addWidget(self.scan_home_button, 1)
        left_layout.addWidget(self.dir_row_widget)

        # Advanced Filters group with collapse toggle
        filter_header_layout = QHBoxLayout()
        self.filter_toggle_btn = QPushButton("▼ Advanced Filters")
        self.filter_toggle_btn.setFlat(True)
        self.filter_toggle_btn.setCursor(Qt.CursorShape.PointingHandCursor)
        self.filter_toggle_btn.clicked.connect(self.toggle_filters)
        self.filter_toggle_btn.setStyleSheet("text-align: left; padding: 5px;")
        filter_header_layout.addWidget(self.filter_toggle_btn)
        filter_header_layout.addStretch()
        left_layout.addLayout(filter_header_layout)
        
        group_advanced = QGroupBox()
        group_advanced.setObjectName("advancedFiltersGroup")
        adv_layout = QHBoxLayout()

        lbl_min_size = QLabel("📏 Min Size (bytes):")
        self.edit_min_size = QLineEdit()
        lbl_max_size = QLabel("📐 Max Size (bytes):")
        self.edit_max_size = QLineEdit()
        lbl_extension = QLabel("📄 File Extension:")
        self.edit_extension = QLineEdit()
        self.edit_extension.setPlaceholderText("pdf;docx;xls")

        # Set custom context menu for all QLineEdit fields
        for edit in (self.edit_query, self.edit_dir, self.edit_min_size, self.edit_max_size, self.edit_extension):
            edit.setContextMenuPolicy(Qt.ContextMenuPolicy.CustomContextMenu)
            edit.customContextMenuRequested.connect(self.show_lineedit_context_menu)

        adv_layout.addWidget(lbl_min_size, 2)
        adv_layout.addWidget(self.edit_min_size, 5)
        adv_layout.addWidget(lbl_max_size, 2)
        adv_layout.addWidget(self.edit_max_size, 5)
        adv_layout.addWidget(lbl_extension, 2)
        adv_layout.addWidget(self.edit_extension, 5)

        group_advanced.setLayout(adv_layout)
        self.group_advanced = group_advanced
        left_layout.addWidget(group_advanced)

        # Search results tabs
        self.tab_widget = QTabWidget()
        self.tab_widget.setTabsClosable(True)
        self.tab_widget.setUsesScrollButtons(True)  # Enable scroll buttons when tabs overflow
        self.tab_widget.setMovable(True)  # Allow dragging tabs to reorder
        

        self.tab_widget.tabCloseRequested.connect(self.close_tab)
        self.tab_widget.currentChanged.connect(self.on_tab_changed)
        
        # Get screen width for tab sizing
        screen = QApplication.primaryScreen()
        screen_width = screen.size().width()
        tab_width = screen_width // 8  # Tab width is 1/8 of screen width
        
        # Set tab style similar to Chrome
        self.tab_width = tab_width
        self.update_tab_style()
        
        # Set elide mode for long titles
        self.tab_widget.setElideMode(Qt.TextElideMode.ElideRight)
        
        # Set up context menu for tabs - on tab bar instead of tab widget
        tab_bar = self.tab_widget.tabBar()
        tab_bar.setContextMenuPolicy(Qt.ContextMenuPolicy.CustomContextMenu)
        tab_bar.customContextMenuRequested.connect(self.show_tab_context_menu)
        
        # Create tab context menu
        self.tab_context_menu = QMenu(self)
        
        # Pin/Unpin action - will be updated dynamically
        self.pin_action = self.tab_context_menu.addAction("📌 Pin Tab", self.toggle_pin_tab)
        self.tab_context_menu.addSeparator()

        # Scan selected directory action (enabled only when a folder is selected)
        self.scan_selected_dir_action = self.tab_context_menu.addAction(
            "📁 Scan Selected Folder", self.scan_selected_directory
        )
        self.scan_selected_dir_action.setEnabled(True)
        self.tab_context_menu.addSeparator()

        self.tab_context_menu.addAction("❌ Close", self.close_current_tab)
        self.tab_context_menu.addAction("🚫 Close Others", self.close_other_tabs)
        self.tab_context_menu.addAction("⬅️ Close to the Left", self.close_left_tabs)
        self.tab_context_menu.addAction("➡️ Close to the Right", self.close_right_tabs)
        self.tab_context_menu.addAction("🗑️ Close All", self.close_all_tabs)
        
        left_layout.addWidget(self.tab_widget, stretch=1)
        
        # Dictionary to store SearchTab instances by tab index
        self.search_tabs = {}
        self.context_menu_selected_dir = None
        
        # Maximum number of pinned tabs
        self.MAX_PINNED_TABS = 10
        
        # Progress bar
        self.progress = QProgressBar()
        self.progress.setMaximum(100)
        left_layout.addWidget(self.progress)

        splitter.addWidget(left_container)

        # ========== Right side Preview ==========
        self.preview_container = QWidget()
        self.preview_container.setObjectName("previewContainer")
        preview_layout = QVBoxLayout(self.preview_container)
        preview_layout.setContentsMargins(16, 16, 16, 16)
        preview_layout.setSpacing(12)
        
        # Header layout with Preview title and buttons
        header_layout = QHBoxLayout()
        header_layout.setContentsMargins(0, 0, 0, 8)
        
        preview_title = QLabel("🖼️ Preview")
        preview_title.setObjectName("previewTitle")
        header_layout.addWidget(preview_title)
        header_layout.addStretch()
        
        # Add a pop-out button with descriptive label for consistency
        popout_button = QPushButton("🔲 Pop-out")
        popout_button.setMinimumWidth(110)
        popout_button.setCursor(Qt.CursorShape.PointingHandCursor)
        popout_button.setToolTip("Open in standalone player")
        popout_button.clicked.connect(self.open_standalone_player)
        popout_button.setObjectName("previewPopoutButton")
        
        # Add the popout button to the header
        header_layout.addWidget(popout_button)
        
        # Add a more stylish close button to the header
        close_button = QPushButton("✖ Close")
        close_button.setMinimumWidth(110)
        close_button.setCursor(Qt.CursorShape.PointingHandCursor)
        close_button.setToolTip("Close preview panel")
        close_button.clicked.connect(self.close_preview)
        
        # Apply special styling to the close button to make it more elegant
        close_button.setObjectName("previewCloseButton")
        
        header_layout.addWidget(close_button)
        
        preview_layout.addLayout(header_layout)

        # Chart navigation bar (back button + breadcrumb)
        self.chart_nav_container = QWidget()
        chart_nav_layout = QHBoxLayout(self.chart_nav_container)
        chart_nav_layout.setContentsMargins(8, 4, 8, 4)
        chart_nav_layout.setSpacing(8)
        
        self.chart_back_button = QPushButton("← Back")
        self.chart_back_button.setMaximumWidth(80)
        self.chart_back_button.setToolTip("Return to parent directory")
        self.chart_back_button.clicked.connect(self.on_chart_back_clicked)
        self.chart_back_button.setVisible(False)
        chart_nav_layout.addWidget(self.chart_back_button)
        
        self.chart_breadcrumb = QLabel()
        self.chart_breadcrumb.setWordWrap(False)
        self.chart_breadcrumb.setStyleSheet("font-weight: 600; padding: 4px 8px;")
        chart_nav_layout.addWidget(self.chart_breadcrumb, stretch=1)
        chart_nav_layout.addStretch()
        
        self.chart_nav_container.setVisible(False)
        preview_layout.addWidget(self.chart_nav_container)

        # Interactive usage chart (hidden until a scan runs)
        self.scan_chart = QChart()
        self.scan_chart.legend().setVisible(True)
        self.scan_chart.legend().setAlignment(Qt.AlignmentFlag.AlignBottom)
        self.scan_chart.setAnimationOptions(QChart.AnimationOption.SeriesAnimations)
        # Normal chart margins
        self.scan_chart.setMargins(QMargins(24, 18, 32, 24))
        self.scan_chart.setBackgroundRoundness(12)
        self.scan_chart_view = ClickableChartView(self.scan_chart)
        self.scan_chart_view.main_window = self
        self.scan_chart_view.setRenderHint(QPainter.RenderHint.Antialiasing)
        self.scan_chart_view.setMinimumHeight(420)
        self.scan_chart_view.setVisible(False)
        self.scan_chart_view.setObjectName("scanChartView")
        
        # Hint label for user guidance. Rich text lets us emphasize the
        # double-click affordance, which users kept missing.
        self.chart_hint_label = QLabel()
        self.chart_hint_label.setTextFormat(Qt.TextFormat.RichText)
        self.chart_hint_label.setText(
            "🖱️ <b>Double-click</b> a bar to drill into subfolders"
            " &nbsp;·&nbsp; single-click to select in the list"
        )
        self.chart_hint_label.setAlignment(Qt.AlignmentFlag.AlignCenter)
        self.chart_hint_label.setVisible(False)
        self._style_chart_hint()
        # A pointing-hand cursor + tooltip make the chart feel clickable.
        self.scan_chart_view.setCursor(Qt.CursorShape.PointingHandCursor)
        self.scan_chart_view.setToolTip("Double-click a bar to drill into subfolders")
        self.scan_chart_view.setStyleSheet(
            "QChartView#scanChartView {"
            "  border: 1px solid rgba(0, 0, 0, 0.15);"
            "  border-radius: 14px;"
            "  background: rgba(0, 0, 0, 0.01);"
            "  padding: 12px;"
            "}"
        )
        preview_layout.addWidget(self.scan_chart_view)
        preview_layout.addWidget(self.chart_hint_label)
        self._current_scan_series = None
        self.scan_chart_path_map = {}
        self.scan_chart_categories = []
        self.scan_chart_tab_index = None
        self.scan_chart_nav_stack = []  # Stack to track navigation history
        self.scan_chart_current_path = None  # Current directory being displayed
        self._update_scan_chart_theme()
        self._chart_overrides_preview = False
        
        # Create vertical splitter for preview (top) and metadata (bottom)
        self.preview_splitter = QSplitter(Qt.Orientation.Vertical)
        preview_layout.addWidget(self.preview_splitter, stretch=1)

        # Keep the existing QStackedWidget as top
        self.preview_stack = QStackedWidget()

        # 1) Text Preview
        self.text_preview = QPlainTextEdit()
        self.text_preview.setReadOnly(True)

        # 2) Image Preview: Fixed size, scale manually if needed
        self.image_label = QLabel()
        self.image_label.setFixedSize(500, 400)
        self.image_label.setScaledContents(False)
        self.image_label.setAlignment(Qt.AlignmentFlag.AlignCenter)
        
        # Wrap image_label in a centered container
        image_container = QWidget()
        image_layout = QVBoxLayout(image_container)
        image_layout.setContentsMargins(0, 0, 0, 0)
        image_layout.addWidget(self.image_label, alignment=Qt.AlignmentFlag.AlignCenter)

        # 3) Video/Audio Preview Container
        media_container = QWidget()
        media_layout = QVBoxLayout(media_container)
        media_layout.setContentsMargins(0, 0, 0, 0)
        
        # Video widget
        self.video_widget = QVideoWidget()
        self.video_widget.setFixedSize(500, 400)
        if getattr(QVideoWidget, "setAspectRatioMode", None) is not None:
            self.video_widget.setAspectRatioMode(Qt.AspectRatioMode.KeepAspectRatio)
        
        self.video_widget.installEventFilter(self)
        
        self.audio_label = QLabel()
        self.audio_label.setFixedSize(500, 400)
        self.audio_label.setAlignment(Qt.AlignmentFlag.AlignCenter)
        self.audio_label.setWordWrap(True)

        font = QFont()
        font.setPointSize(16)
        font.setBold(True)
        self.audio_label.setFont(font)
        self.audio_label.setVisible(False)
        
        self.audio_label.installEventFilter(self)
        
        media_layout.addWidget(self.video_widget, alignment=Qt.AlignmentFlag.AlignCenter)
        media_layout.addWidget(self.audio_label, alignment=Qt.AlignmentFlag.AlignCenter)
        
        # Set up media player
        self.audio_output = QAudioOutput()
        self.media_player = QMediaPlayer()
        self.media_player.setVideoOutput(self.video_widget)
        self.media_player.setAudioOutput(self.audio_output)
        self.media_player.positionChanged.connect(self.update_position)
        self.media_player.durationChanged.connect(self.update_duration)
        self.media_player.playbackStateChanged.connect(self.on_playback_state_changed)
        
        # Create video controls
        video_controls_layout = QHBoxLayout()
        
        # Play/Pause button
        self.play_button = QToolButton()
        self.play_button.setIcon(self.style().standardIcon(QStyle.StandardPixmap.SP_MediaPlay))
        self.play_button.clicked.connect(self.toggle_play_pause)
        video_controls_layout.addWidget(self.play_button)
        
        # Current time label
        self.time_label = QLabel("🕒 00:00 / 00:00")
        self.time_label.setMinimumWidth(100)
        video_controls_layout.addWidget(self.time_label)
        
        # Seekbar - replace standard QSlider with our ClickableSlider
        self.seek_slider = ClickableSlider(Qt.Orientation.Horizontal)
        self.seek_slider.setRange(0, 0)
        self.seek_slider.sliderMoved.connect(self.set_position)
        self.seek_slider.sliderPressed.connect(self.on_slider_pressed)
        self.seek_slider.sliderReleased.connect(self.on_slider_released)
        video_controls_layout.addWidget(self.seek_slider, 4)  # Give seekbar more space
        
        # Volume button and slider
        self.volume_button = QToolButton()
        self.volume_button.setIcon(self.style().standardIcon(QStyle.StandardPixmap.SP_MediaVolume))
        self.volume_button.clicked.connect(self.toggle_mute)
        video_controls_layout.addWidget(self.volume_button)
        
        self.volume_slider = QSlider(Qt.Orientation.Horizontal)
        self.volume_slider.setRange(0, 100)
        self.volume_slider.setValue(70)  # Default volume
        self.volume_slider.setMaximumWidth(100)
        self.volume_slider.valueChanged.connect(self.set_volume)
        self.audio_output.setVolume(0.7)  # Set initial volume to 70%
        video_controls_layout.addWidget(self.volume_slider)
        
        # Add all controls to the media layout
        media_layout.addLayout(video_controls_layout)
        
        # Add container to stack instead of self.video_widget directly.
        self.preview_stack.addWidget(self.text_preview)  # index 0
        self.preview_stack.addWidget(image_container)   # index 1
        self.preview_stack.addWidget(media_container)      # index 2

        self.preview_splitter.addWidget(self.preview_stack)

        # Bottom pane: metadata info
        self.media_info = QPlainTextEdit()
        self.media_info.setReadOnly(True)
        self.preview_splitter.addWidget(self.media_info)

        splitter.addWidget(self.preview_container)
        splitter.setSizes([800, 400])  # Initial left-right ratio

        # Make the preview panel invisible by default
        self.preview_container.setVisible(self.preview_enabled) # Use the loaded setting instead of always hidden

        # Load last sort settings from config
        config = read_config()
        self.default_sort_column = config.get("sort_column", -1)
        self.default_sort_order = Qt.SortOrder(config.get("sort_order", 0))  # 0 = Ascending, 1 = Descending

        self.query_history = config.get("query_history", [])
        self.query_completer = QCompleter(self.query_history)
        self.query_completer.setCaseSensitivity(Qt.CaseSensitivity.CaseInsensitive)
        self.query_completer.setCompletionMode(QCompleter.CompletionMode.PopupCompletion)
        self.query_completer.setMaxVisibleItems(8)  # Show max 8 items in dropdown
        self.query_completer.setFilterMode(Qt.MatchFlag.MatchContains)  # Match anywhere in string
        self.edit_query.setCompleter(self.query_completer)

        # ========== Signal bindings ==========
        self.search_timer = QTimer()
        self.search_timer.setSingleShot(True)
        self.search_timer.timeout.connect(self.start_search)
        self.edit_query.textChanged.connect(self.on_query_changed)
        # connect Enter key press
        self.edit_query.returnPressed.connect(self.on_search_enter)
        self.edit_dir.textChanged.connect(self.on_dir_changed)

        self.chk_file_name.toggled.connect(lambda: self.search_timer.start(DEBOUNCE_DELAY))
        self.chk_match_case.toggled.connect(lambda: self.search_timer.start(DEBOUNCE_DELAY))
        self.chk_full_match.toggled.connect(lambda: self.search_timer.start(DEBOUNCE_DELAY))
        self.edit_min_size.textChanged.connect(self.on_filter_changed)
        self.edit_max_size.textChanged.connect(self.on_filter_changed)
        self.edit_extension.textChanged.connect(self.on_filter_changed)

        self.single_context_menu = QMenu(self)
        self.single_context_menu.addAction("🚀 Open", self.open_with_default_app)
        self.single_context_menu.addAction("🗑️ Delete", self.delete_file)
        self.single_context_menu.addAction("📋 Copy to...", self.copy_file)
        self.single_context_menu.addAction("📦 Move to...", self.move_file)
        self.single_context_menu.addAction("✏️ Rename", self.rename_file)
        self.single_context_menu.addAction("📄 Copy full path with file name", self.copy_full_path)
        self.single_context_menu.addAction("📁 Copy path without file name", self.copy_path_only)
        self.single_context_menu.addAction("📝 Copy file name only", self.copy_file_name_only)
        self.single_context_menu.addSeparator()
        self.scan_item_action = self.single_context_menu.addAction("📁 Analyze Folder Space", self.scan_selected_tree_item)
        self.scan_item_action.setEnabled(False)
        self.single_context_menu.addSeparator()
        self.single_context_menu.addAction("🗜️ Compress to ZIP", self.compress_file)
        self.single_context_menu.addAction("🔍 Open in Finder", self.open_in_finder)
        self.single_context_menu.addAction("📝 Spotlight Metadata", self.show_spotlight_metadata)
        self.single_context_menu.addAction("📤 Export Results", self.export_results)

        self.multi_context_menu = QMenu(self)
        self.multi_context_menu.addAction("🚀 Open", self.open_multiple_files)
        self.multi_context_menu.addAction("🗑️ Delete", self.delete_multiple_files)
        self.multi_context_menu.addAction("📋 Copy to...", self.copy_multiple_files)
        self.multi_context_menu.addAction("📦 Move to...", self.move_multiple_files)
        self.multi_context_menu.addAction("✏️ Batch Rename", self.batch_rename_files)
        self.multi_context_menu.addSeparator()
        self.multi_context_menu.addAction("🗜️ Compress to ZIP", self.compress_multiple_files)

        self.batch_size = 100

        # Directory scan state
        self.scan_worker = None
        self.scan_total_dirs = 0
        self.scan_processed_dirs = 0
        self.scan_root_display = ""
        self.scan_dialog = None
        self.scan_context_label = "Home Space Analysis"
        self.scan_tab_prefix = "Home Space"

        # Create the standalone player window but don't show it yet
        self.standalone_player = StandalonePlayerWindow(self)
        self.standalone_player_active = False
        
        # Configure standalone player
        self.standalone_player.setup_extensions(self.video_extensions, self.audio_extensions)
        self.standalone_player.set_continuous_playback(self.continuous_playback)
        self.standalone_player.set_dark_mode(self.dark_mode)
        
        # Create the media player manager for embedded player
        self.player_manager = MediaPlayerManager(self)
        
        # Set up media player
        self.audio_output = self.player_manager.audio_output
        self.media_player = self.player_manager.media_player
        self.player_manager.set_video_output(self.video_widget)
        self.player_manager.connect_signals(
            self.update_position,
            self.update_duration,
            self.on_playback_state_changed
        )
        
        # Set up recognized extensions in the player manager
        self.player_manager.setup_extensions(self.video_extensions, self.audio_extensions)
        
        # Initialize beautiful tooltip for copy confirmations
        self.tooltip = BeautifulToolTip(self)
        
        # Restore pinned tabs from previous session
        self.restore_pinned_tabs()
        
        # Apply simple mode settings on startup
        if self.simple_mode:
            self.dir_row_widget.hide()
            self.group_advanced.hide()
            self.filter_toggle_btn.hide()
        else:
            # In advanced mode, start with filters collapsed
            self.group_advanced.hide()
            self.filter_toggle_btn.setText("▶ Advanced Filters")
        
    # ========== Tab Management ==========
    def get_current_tree(self):
        """Get the tree widget of the currently active tab"""
        current_index = self.tab_widget.currentIndex()
        if current_index == -1 or current_index not in self.search_tabs:
            return None
        
        # Safety check: ensure tab and tree are still valid
        tab = self.search_tabs.get(current_index)
        if tab and hasattr(tab, 'tree'):
            try:
                # Test if tree is still valid
                tab.tree.topLevelItemCount()
                return tab.tree
            except RuntimeError:
                # Tree widget is destroyed
                return None
        return None
    
    def get_current_tab(self):
        """Get the SearchTab instance of the currently active tab"""
        current_index = self.tab_widget.currentIndex()
        if current_index == -1 or current_index not in self.search_tabs:
            return None
        return self.search_tabs[current_index]
    
    def _connect_tree_signals(self, search_tab):
        """Connect common tree widget signals for a search tab"""
        search_tab.tree.itemSelectionChanged.connect(self.on_tree_selection_changed)
        search_tab.tree.setContextMenuPolicy(Qt.ContextMenuPolicy.CustomContextMenu)
        search_tab.tree.customContextMenuRequested.connect(self.show_context_menu)
        search_tab.tree.itemDoubleClicked.connect(self.open_with_default_app)
        search_tab.tree.header().setSectionsClickable(True)
        search_tab.tree.header().setSortIndicatorShown(True)
        search_tab.tree.header().sectionClicked.connect(self.on_header_clicked)
        search_tab.tree.verticalScrollBar().valueChanged.connect(self.check_scroll_position)

    def create_new_tab(self, query="", directory="", tab_title="", extra_clause=None, is_bookmark=False, force_parameters=False, is_scan_tab=False):
        """Create a new search tab"""
        if force_parameters:
            search_query = query
            search_directory = directory
        else:
            search_query = query or self.edit_query.text().strip()
            search_directory = directory or self.edit_dir.text().strip()

        # Create SearchTab instance with current search parameters
        search_tab = SearchTab(
            query=search_query,
            directory=search_directory,
            file_name_search=self.chk_file_name.isChecked(),
            match_case=self.chk_match_case.isChecked(),
            full_match=self.chk_full_match.isChecked(),
            min_size=self.edit_min_size.text().strip(),
            max_size=self.edit_max_size.text().strip(),
            extensions=self.edit_extension.text().strip(),
            tab_title=tab_title,
            extra_clause=extra_clause,
            is_bookmark=is_bookmark,
            is_scan_tab=is_scan_tab  # Store the original title
        )
        
        # Apply default sort settings
        search_tab.sort_column = self.default_sort_column
        search_tab.sort_order = self.default_sort_order
        if self.default_sort_column != -1:
            search_tab.tree.header().setSortIndicator(self.default_sort_column, self.default_sort_order)
        
        # Install the share-bar delegate on the "Share" column (column 4).
        share_delegate = PercentBarDelegate(
            search_tab.tree, dark_mode_getter=lambda: getattr(self, 'dark_mode', False)
        )
        search_tab.tree.setItemDelegateForColumn(4, share_delegate)
        search_tab._share_delegate = share_delegate  # keep a reference alive

        # Connect tree signals
        self._connect_tree_signals(search_tab)
        
        # Create tab title - use custom title if provided, otherwise use query or default
        if tab_title:
            final_tab_title = tab_title
        elif search_query:
            final_tab_title = search_query
        else:
            final_tab_title = "New Search"
        
        # Store the title
        search_tab.tab_title = final_tab_title
        
        # Add tab to widget (after pinned tabs)
        pinned_count = self.get_pinned_count()
        index = self.tab_widget.insertTab(pinned_count, search_tab.tree, final_tab_title)
        
        # Re-index all tabs after insertion
        new_tabs = {}
        for i in range(self.tab_widget.count()):
            for old_i, tab in self.search_tabs.items():
                if self.tab_widget.widget(i) == tab.tree:
                    new_tabs[i] = tab
                    break
        # Add the new tab
        new_tabs[index] = search_tab
        self.search_tabs = new_tabs
        
        self.tab_widget.setCurrentIndex(index)
        
        # Set custom close button for better visibility
        self.update_tab_close_button(index)
        
        # Update tab widths for all tabs
        self.update_tab_style()
        
        return search_tab
    
    def close_tab(self, index):
        """Close a search tab"""
        if index in self.search_tabs:
            # Stop any running search
            tab = self.search_tabs[index]
            if tab.search_worker and tab.search_worker.isRunning():
                tab.search_worker.stop()
                tab.search_worker.wait()
            
            # Disconnect tree signals to prevent crashes
            try:
                tab.tree.itemSelectionChanged.disconnect()
                tab.tree.customContextMenuRequested.disconnect()
                tab.tree.itemDoubleClicked.disconnect()
                tab.tree.header().sectionClicked.disconnect()
                tab.tree.verticalScrollBar().valueChanged.disconnect()
            except (TypeError, RuntimeError):
                pass  # Ignore if already disconnected
            
            # Remove tab
            del self.search_tabs[index]
            self.tab_widget.removeTab(index)
            
            # Update indices for remaining tabs
            new_tabs = {}
            for i in range(self.tab_widget.count()):
                old_index = None
                for old_i, tab in self.search_tabs.items():
                    if self.tab_widget.widget(i) == tab.tree:
                        old_index = old_i
                        break
                if old_index is not None:
                    new_tabs[i] = self.search_tabs[old_index]
            self.search_tabs = new_tabs
            
            # Update tab widths after closing
            if self.tab_widget.count() > 0:
                self.update_tab_style()
                self._update_scan_chart_for_tab()
            else:
                self._clear_scan_chart()
    
    def on_tab_changed(self, index):
        """Handle tab change event"""
        if index >= 0:
            # Check if this is a restored pinned tab that needs initial search
            if index in self.search_tabs:
                tab = self.search_tabs[index]
                if hasattr(tab, 'needs_initial_search') and tab.needs_initial_search:
                    self.trigger_tab_search(index, tab)
                    tab.needs_initial_search = False
            
            # Get the current tab data
            current_tab = self.get_current_tab()
            if current_tab:
                # Block signals to avoid triggering new searches when updating UI
                self.edit_query.blockSignals(True)
                self.edit_dir.blockSignals(True)
                self.chk_file_name.blockSignals(True)
                self.chk_match_case.blockSignals(True)
                self.chk_full_match.blockSignals(True)
                self.edit_min_size.blockSignals(True)
                self.edit_max_size.blockSignals(True)
                self.edit_extension.blockSignals(True)
                
                try:
                    # Update the query input field with the tab's query
                    self.edit_query.setText(current_tab.query)
                    
                    # Update the directory input field with the tab's directory
                    self.edit_dir.setText(current_tab.directory)
                    
                    # Update the checkboxes with the tab's search parameters
                    self.chk_file_name.setChecked(current_tab.file_name_search)
                    self.chk_match_case.setChecked(current_tab.match_case)
                    self.chk_full_match.setChecked(current_tab.full_match)
                    
                    # Update the filter fields with the tab's filter parameters
                    self.edit_min_size.setText(current_tab.min_size)
                    self.edit_max_size.setText(current_tab.max_size)
                    self.edit_extension.setText(current_tab.extensions)
                    
                    # Update the items found label with the tab's result count
                    self.lbl_items_found.setText(f"📊 {current_tab.items_found_count} items found")
                finally:
                    # Re-enable signals
                    self.edit_query.blockSignals(False)
                    self.edit_dir.blockSignals(False)
                    self.chk_file_name.blockSignals(False)
                    self.chk_match_case.blockSignals(False)
                    self.chk_full_match.blockSignals(False)
                    self.edit_min_size.blockSignals(False)
                    self.edit_max_size.blockSignals(False)
                    self.edit_extension.blockSignals(False)
            else:
                # No current tab, reset items found label
                self.lbl_items_found.setText("📊 0 items found")
            
            # Update the preview panel based on the new tab's selection
            self.on_tree_selection_changed()
            
            # Update all tab close buttons since current tab changed
            self.update_all_tab_close_buttons()
            self._update_scan_chart_for_tab()
        else:
            # No tabs available (index < 0), reset items found label
            self.lbl_items_found.setText("📊 0 items found")
            self._clear_scan_chart()
    
    def show_lineedit_context_menu(self, pos):
        """Show context menu with emoji icons for QLineEdit widgets"""
        edit = self.sender()
        if not edit:
            return
        menu = QMenu(self)
        menu.addAction("↩️ Undo", edit.undo)
        menu.addAction("↪️ Redo", edit.redo)
        menu.addSeparator()
        menu.addAction("✂️ Cut", edit.cut)
        menu.addAction("📋 Copy", edit.copy)
        menu.addAction("📌 Paste", edit.paste)
        menu.addAction("🗑️ Delete", lambda: edit.insert("") if edit.hasSelectedText() else None)
        menu.addSeparator()
        menu.addAction("✅ Select All", edit.selectAll)
        menu.exec(edit.mapToGlobal(pos))

    def show_tab_context_menu(self, pos):
        """Show context menu for tabs"""
        # Get the tab bar
        tab_bar = self.tab_widget.tabBar()
        
        # Find which tab was clicked
        self.context_menu_tab_index = tab_bar.tabAt(pos)
        
        if self.context_menu_tab_index >= 0:
            # Update pin action text based on current pin state
            tab = self.search_tabs.get(self.context_menu_tab_index)
            if tab and tab.is_pinned and not tab.is_scan_tab:
                self.pin_action.setText("📍 Unpin Tab")
            else:
                self.pin_action.setText("📌 Pin Tab")

            can_toggle_pin = bool(tab) and (tab.is_pinned or not tab.is_scan_tab)
            self.pin_action.setEnabled(can_toggle_pin)
            if tab and tab.is_scan_tab and not tab.is_pinned:
                self.pin_action.setToolTip("Usage scan tabs cannot be pinned.")
            else:
                self.pin_action.setToolTip("")

            # Determine if a directory is selected in this tab's tree
            self.context_menu_selected_dir = None
            if tab and hasattr(tab, 'tree'):
                try:
                    selected_items = tab.tree.selectedItems()
                except RuntimeError:
                    selected_items = []
                if selected_items:
                    path = selected_items[0].text(3)
                    if os.path.isdir(path):
                        self.context_menu_selected_dir = path
            self.scan_selected_dir_action.setEnabled(self.context_menu_selected_dir is not None)
            
            # Show the context menu at the cursor position
            global_pos = tab_bar.mapToGlobal(pos)
            self.tab_context_menu.exec(global_pos) 
               
    def close_current_tab(self):
        """Close the tab that was right-clicked"""
        if hasattr(self, 'context_menu_tab_index') and self.context_menu_tab_index >= 0:
            self.close_tab(self.context_menu_tab_index)
    
    def _close_tabs_by_filter(self, should_close):
        """Close unpinned tabs where should_close(index) returns True"""
        for i in reversed(range(self.tab_widget.count())):
            if should_close(i):
                tab = self.search_tabs.get(i)
                if not (tab and tab.is_pinned):
                    self.close_tab(i)

    def close_other_tabs(self):
        """Close all tabs except the one that was right-clicked (skip pinned tabs)"""
        if hasattr(self, 'context_menu_tab_index') and self.context_menu_tab_index >= 0:
            idx = self.context_menu_tab_index
            self._close_tabs_by_filter(lambda i: i != idx)
    
    def close_left_tabs(self):
        """Close all tabs to the left of the clicked tab (skip pinned tabs)"""
        if hasattr(self, 'context_menu_tab_index') and self.context_menu_tab_index >= 0:
            idx = self.context_menu_tab_index
            self._close_tabs_by_filter(lambda i: i < idx)
    
    def close_right_tabs(self):
        """Close all tabs to the right of the clicked tab (skip pinned tabs)"""
        if hasattr(self, 'context_menu_tab_index') and self.context_menu_tab_index >= 0:
            idx = self.context_menu_tab_index
            self._close_tabs_by_filter(lambda i: i > idx)
    
    def close_all_tabs(self):
        """Close all search tabs (skip pinned tabs)"""
        tab_count = self.tab_widget.count()
        if tab_count == 0:
            return
        
        # Count unpinned tabs
        unpinned_count = sum(1 for tab in self.search_tabs.values() if not tab.is_pinned)
        
        if unpinned_count == 0:
            self.show_info("No Tabs to Close", "All tabs are pinned.")
            return
        
        reply = self.show_question(
            "Close All Tabs",
            f"Are you sure you want to close all {unpinned_count} unpinned tabs?",
            QMessageBox.StandardButton.Yes | QMessageBox.StandardButton.No
        )
        if reply == QMessageBox.StandardButton.Yes:
            # Close tabs in reverse order to maintain correct indices (skip pinned)
            for i in reversed(range(tab_count)):
                tab = self.search_tabs.get(i)
                # Skip pinned tabs
                if not (tab and tab.is_pinned):
                    self.close_tab(i)

    def scan_selected_directory(self):
        """Trigger a usage scan for the folder selected in the tab's tree"""
        selected_path = getattr(self, "context_menu_selected_dir", None)
        if not selected_path or not os.path.isdir(selected_path):
            self.show_info("Folder Space Analysis", "Please select a folder in the tab first.")
            return

        # Switch to the tab where the context menu was opened
        if hasattr(self, 'context_menu_tab_index') and self.context_menu_tab_index >= 0:
            self.tab_widget.setCurrentIndex(self.context_menu_tab_index)

        self.start_directory_scan(Path(selected_path))

    def scan_selected_tree_item(self):
        """Trigger a usage scan for the folder selected inside the current tab tree"""
        tree = self.get_current_tree()
        if not tree:
            self.show_info("Folder Space Analysis", "Please select a folder first.")
            return

        try:
            selected_items = tree.selectedItems()
        except RuntimeError:
            selected_items = []

        if not selected_items:
            self.show_info("Folder Space Analysis", "Please select a folder first.")
            return

        path = selected_items[0].text(3)
        if not path or not os.path.isdir(path):
            self.show_info("Folder Space Analysis", "Please select a folder first.")
            return

        self.start_directory_scan(Path(path))
                
    # ========== Pin/Unpin Tab Methods ==========
    def toggle_pin_tab(self):
        """Toggle pin state of the right-clicked tab"""
        if hasattr(self, 'context_menu_tab_index') and self.context_menu_tab_index >= 0:
            index = self.context_menu_tab_index
            tab = self.search_tabs.get(index)
            if not tab:
                return
            
            if tab.is_scan_tab and not tab.is_pinned:
                self.show_info("Pin Unavailable", "Usage scan result tabs cannot be pinned.")
                return

            if tab.is_pinned:
                self.unpin_tab(index)
            else:
                self.pin_tab(index)
    
    def pin_tab(self, index):
        """Pin a tab"""
        if index not in self.search_tabs:
            return
        
        tab = self.search_tabs[index]

        if tab.is_scan_tab:
            self.show_info("Pin Unavailable", "Usage scan result tabs cannot be pinned.")
            return
        
        # Check if we've reached the maximum number of pinned tabs
        pinned_count = sum(1 for t in self.search_tabs.values() if t.is_pinned)
        if pinned_count >= self.MAX_PINNED_TABS:
            self.show_warning("Maximum Pinned Tabs", 
                            f"You can only pin up to {self.MAX_PINNED_TABS} tabs at once.")
            return
        
        # Set pin state
        tab.is_pinned = True
        
        # Store the original title if not already stored
        if not tab.tab_title:
            tab.tab_title = self.tab_widget.tabText(index)
        
        # Move tab to the end of pinned tabs section
        self.reorder_tabs_after_pin_change()
        
        # Update tab appearance
        self.update_tab_style()
        
        # Save pinned tabs to config
        self.save_pinned_tabs()
    
    def unpin_tab(self, index):
        """Unpin a tab"""
        if index not in self.search_tabs:
            return
        
        tab = self.search_tabs[index]
        tab.is_pinned = False
        
        # Reorder tabs
        self.reorder_tabs_after_pin_change()
        
        # Update tab appearance
        self.update_tab_style()
        
        # Save pinned tabs to config
        self.save_pinned_tabs()
    
    def reorder_tabs_after_pin_change(self):
        """Reorder tabs so pinned tabs are at the beginning"""
        # Collect all tabs with their data
        all_tabs = []
        for i in range(self.tab_widget.count()):
            tab = self.search_tabs.get(i)
            if tab:
                title = self.tab_widget.tabText(i)
                all_tabs.append((i, tab, title))
        
        # Sort: pinned tabs first, then unpinned tabs (maintain relative order)
        pinned_tabs = [(i, tab, title) for i, tab, title in all_tabs if tab.is_pinned]
        unpinned_tabs = [(i, tab, title) for i, tab, title in all_tabs if not tab.is_pinned]
        
        # Block signals to prevent triggering tab changes
        self.tab_widget.blockSignals(True)
        
        try:
            # Remove all tabs
            for i in reversed(range(self.tab_widget.count())):
                self.tab_widget.removeTab(i)
            
            # Clear the search_tabs dict
            self.search_tabs.clear()
            
            # Re-add tabs in correct order: pinned first, then unpinned
            new_index = 0
            for old_i, tab, title in pinned_tabs + unpinned_tabs:
                self.tab_widget.addTab(tab.tree, title)
                self.search_tabs[new_index] = tab
                self.update_tab_close_button(new_index)
                new_index += 1
        finally:
            self.tab_widget.blockSignals(False)
        
        # Update all tab styling
        self.update_tab_style()
        self._update_scan_chart_for_tab()
    
    def get_pinned_count(self):
        """Get the number of currently pinned tabs"""
        return sum(1 for tab in self.search_tabs.values() if tab.is_pinned)
    
    def save_pinned_tabs(self):
        """Save pinned tabs to config"""
        config = read_config()
        pinned_tabs_data = []
        
        for i in range(self.tab_widget.count()):
            tab = self.search_tabs.get(i)
            if tab and tab.is_pinned:
                pinned_tabs_data.append({
                    "query": tab.query,
                    "directory": tab.directory,
                    "title": tab.tab_title or self.tab_widget.tabText(i),
                    "file_name_search": tab.file_name_search,
                    "match_case": tab.match_case,
                    "full_match": tab.full_match,
                    "min_size": tab.min_size,
                    "max_size": tab.max_size,
                    "extensions": tab.extensions,
                    "extra_clause": tab.extra_clause,
                    "is_bookmark": tab.is_bookmark
                })
        
        config["pinned_tabs"] = pinned_tabs_data
        write_config(config)
    
    def trigger_tab_search(self, index, search_tab):
        """Trigger search for a restored pinned tab"""
        # Don't start if already searching
        if search_tab.search_worker is not None and search_tab.search_worker.isRunning():
            return
        
        # Start the search
        search_tab.search_worker = SearchWorker(
            search_tab.query,
            search_tab.directory,
            search_tab.file_name_search,
            search_tab.match_case,
            search_tab.full_match,
            search_tab.extra_clause,
            search_tab.is_bookmark
        )
        search_tab.search_worker.progress_signal.connect(self.update_progress)
        search_tab.search_worker.result_signal.connect(lambda results, st=search_tab: self.update_tree(results, st))
        search_tab.search_worker.error_signal.connect(self.show_error)
        search_tab.search_worker.start()
    
    def restore_pinned_tabs(self):
        """Restore pinned tabs from config on startup"""
        config = read_config()
        pinned_tabs_data = config.get("pinned_tabs", [])
        
        if not pinned_tabs_data:
            return
        
        # Restore each pinned tab
        for tab_data in pinned_tabs_data:
            # Create SearchTab with is_pinned=True
            search_tab = SearchTab(
                query=tab_data.get("query", ""),
                directory=tab_data.get("directory", ""),
                file_name_search=tab_data.get("file_name_search", True),
                match_case=tab_data.get("match_case", False),
                full_match=tab_data.get("full_match", False),
                min_size=tab_data.get("min_size", ""),
                max_size=tab_data.get("max_size", ""),
                extensions=tab_data.get("extensions", ""),
                is_pinned=True,
                tab_title=tab_data.get("title", ""),
                extra_clause=tab_data.get("extra_clause"),
                is_bookmark=tab_data.get("is_bookmark", False)
            )
            
            # Apply default sort settings
            search_tab.sort_column = self.default_sort_column
            search_tab.sort_order = self.default_sort_order
            if self.default_sort_column != -1:
                search_tab.tree.header().setSortIndicator(self.default_sort_column, self.default_sort_order)
            
            # Connect tree signals
            self._connect_tree_signals(search_tab)
            
            # Use stored title with pin icon
            tab_title = search_tab.tab_title or "Pinned Tab"
            display_title = f"📌 {tab_title}"
            
            # Add tab to widget
            index = self.tab_widget.addTab(search_tab.tree, display_title)
            self.search_tabs[index] = search_tab
            
            # Set custom close button (will be hidden for pinned tabs)
            self.update_tab_close_button(index)
            
            # Mark tab as needing search (will be triggered when user switches to it)
            if search_tab.query or search_tab.extra_clause:
                search_tab.needs_initial_search = True
        
        # Update tab styling after all pinned tabs are restored
        if pinned_tabs_data:
            self.update_tab_style()
            
            # Trigger search for the first pinned tab only (will become active)
            if 0 in self.search_tabs:
                first_tab = self.search_tabs[0]
                if hasattr(first_tab, 'needs_initial_search') and first_tab.needs_initial_search:
                    self.trigger_tab_search(0, first_tab)
                    first_tab.needs_initial_search = False
            
    # ========== Preview logic ==========
    def on_tree_selection_changed(self):
        # if preview is not visible, do nothing
        if not self.preview_container.isVisible():
            return
        
        tree = self.get_current_tree()
        if not tree:
            return
        
        # Safety check: ensure tree widget is still valid
        try:
            selected_items = tree.selectedItems()
        except RuntimeError:
            # Tree widget might be destroyed
            return
            
        if not selected_items or len(selected_items) != 1:
            # For multiple or no selection: stop media playback and clear preview
            self.player_manager.stop()
            self.preview_stack.setCurrentIndex(0)
            self.text_preview.setPlainText("")
            self.media_info.setPlainText("")  # Clear bottom pane
            return

        path = selected_items[0].text(3)
        if not os.path.isfile(path):
            self.player_manager.stop()
            self.preview_stack.setCurrentIndex(0)
            self.text_preview.setPlainText("No preview available.")
            self.media_info.setPlainText("")
            return

        # Stop previous media playback
        self.player_manager.stop()
        
        # If standalone player is active, use it instead
        if self.standalone_player_active:
            self.show_in_standalone_player(path)
            return

        # Display basic file info in the bottom pane
        self.display_file_info(path)

        # Check file extension for preview type
        _, ext = os.path.splitext(path)
        ext = ext.lower()

        if ext in self.image_extensions or ext == ".svg":
            self.display_image_preview(path, ext)
        elif ext in self.video_extensions:
            self.display_video_preview(path)
        elif ext in self.audio_extensions:
            self.display_audio_preview(path)
        else:
            self.display_text_preview(path)

    def display_file_info(self, path):
        """Display basic file information in the info pane"""
        file_stat = os.stat(path)
        size_kb = round(file_stat.st_size / 1024, 2)
        self.media_info.setPlainText(
            f"File: {path}\nSize: {size_kb} KB\nLast Modified: {time.ctime(file_stat.st_mtime)}"
        )
        
    def display_image_preview(self, path, ext):
        """Handle display of image files"""
        if ext == ".gif":
            movie = QMovie(path)
            self.image_label.setMovie(movie)
            movie.start()
            # Show resolution info from the current frame if available
            pix = movie.currentPixmap()
            self.media_info.appendPlainText(
                f"Resolution: {pix.width()} x {pix.height()}"
            )
        elif ext == ".svg":
            renderer = QSvgRenderer(path)
            default_size = renderer.defaultSize()
            container_size = self.image_label.size()
            ratio = min(container_size.width() / default_size.width(), 
                        container_size.height() / default_size.height())
            new_width = int(default_size.width() * ratio)
            new_height = int(default_size.height() * ratio)
            pixmap = QPixmap(new_width, new_height)
            pixmap.fill(Qt.GlobalColor.transparent)
            painter = QPainter(pixmap)
            renderer.render(painter)
            painter.end()
            self.image_label.setPixmap(pixmap)
            self.media_info.appendPlainText(
                f"Resolution: {new_width} x {new_height}"
            )
        else:
            # Use async loading for regular images to avoid UI blocking
            self.image_label.setText("Loading...")
            self._image_loader = ImageLoaderThread(path, self.image_label.size())
            self._image_loader.loaded.connect(self._on_image_loaded)
            self._image_loader.error.connect(self._on_image_error)
            self._image_loader.start()
        self.preview_stack.setCurrentIndex(1)
    
    def _on_image_loaded(self, pixmap, orig_width, orig_height):
        """Handle async image load completion"""
        self.image_label.setPixmap(pixmap)
        self.media_info.appendPlainText(f"Resolution: {orig_width} x {orig_height}")
    
    def _on_image_error(self, error_msg):
        """Handle async image load error"""
        self.image_label.setText("Error loading image")
        
    def display_video_preview(self, path):
        """Handle display of video files"""
        # Reset controls before loading new media
        self.seek_slider.setValue(0)
        self.seek_slider.setRange(0, 0)
        self.time_label.setText("🕒 00:00 / 00:00")
        self.play_button.setIcon(self.style().standardIcon(QStyle.StandardPixmap.SP_MediaPlay))
        
        # Make video widget visible for video files
        self.video_widget.setVisible(True)
        self.audio_label.setVisible(False)
        
        # Play the media
        self.player_manager.play_media(path)
        self.play_button.setIcon(self.style().standardIcon(QStyle.StandardPixmap.SP_MediaPause))
        self.preview_stack.setCurrentIndex(2)
        
    def display_audio_preview(self, path):
        """Handle display of audio files"""
        # Reset controls before loading new audio
        self.seek_slider.setValue(0)
        self.seek_slider.setRange(0, 0)
        self.time_label.setText("🕒 00:00 / 00:00")
        self.play_button.setIcon(self.style().standardIcon(QStyle.StandardPixmap.SP_MediaPlay))
        
        # Hide video, show audio label
        self.video_widget.setVisible(False)
        self.audio_label.setVisible(True)
        
        # Set audio label text
        filename = os.path.basename(path)
        self.set_audio_label_display(filename)
        
        # Play the media
        self.player_manager.play_media(path)
        self.play_button.setIcon(self.style().standardIcon(QStyle.StandardPixmap.SP_MediaPause))
        self.preview_stack.setCurrentIndex(2)
    
    def set_audio_label_display(self, filename):
        """Set audio label display with consistent styling"""
        color = 'white' if self.dark_mode else 'black'
        self.audio_label.setText(f"<div style='padding: 20px; border-radius: 10px;'>"
                                f"<div style='font-size: 24pt; color: {color};'>{filename}</div>"
                                f"</div>")
        
    def display_text_preview(self, path):
        """Handle display of text files"""
        try:
            with open(path, 'rb') as f:
                chunk = f.read(512)
            chunk.decode('utf-8')
            with open(path, 'r', encoding='utf-8', errors='replace') as f:
                content = f.read(4096)
            self.text_preview.setPlainText(content)
            self.preview_stack.setCurrentIndex(0)
        except Exception:
            self.text_preview.setPlainText("No preview available.")
            self.preview_stack.setCurrentIndex(0)

    # === Video Player Control Methods ===
    def toggle_play_pause(self):
        is_playing = self.player_manager.toggle_play_pause()
        icon = QStyle.StandardPixmap.SP_MediaPause if is_playing else QStyle.StandardPixmap.SP_MediaPlay
        self.play_button.setIcon(self.style().standardIcon(icon))
    
    def set_position(self, position):
        self.player_manager.set_position(position)
    
    def update_position(self, position):
        try:
            if not self.player_manager.slider_dragging:
                self.seek_slider.setValue(position)
            
            total_duration = self.player_manager.get_duration()
            self.time_label.setText(format_time_label(position, total_duration))
        except Exception:
            # Silently handle errors during position update to prevent player crashes
            pass
        
    def update_duration(self, duration):
        self.seek_slider.setRange(0, duration)
        
        # Update play button state
        if duration > 0:
            self.play_button.setIcon(self.style().standardIcon(QStyle.StandardPixmap.SP_MediaPause))
            self.update_video_info()
    
    def set_volume(self, volume):
        self.player_manager.set_volume(volume)
        
        # Update volume button icon based on volume level
        if volume == 0:
            self.volume_button.setIcon(self.style().standardIcon(QStyle.StandardPixmap.SP_MediaVolumeMuted))
        else:
            self.volume_button.setIcon(self.style().standardIcon(QStyle.StandardPixmap.SP_MediaVolume))
    
    def toggle_mute(self):
        is_muted = self.player_manager.toggle_mute()
        icon = QStyle.StandardPixmap.SP_MediaVolumeMuted if is_muted else QStyle.StandardPixmap.SP_MediaVolume
        self.volume_button.setIcon(self.style().standardIcon(icon))
        
        if not is_muted:
            self.volume_slider.setValue(self.player_manager.get_volume())
    
    def on_slider_pressed(self):
        self.player_manager.on_slider_pressed()
    
    def on_slider_released(self):
        self.player_manager.on_slider_released()
    
    # ========== Lazy loading ==========
    def check_scroll_position(self):
        tree = self.get_current_tree()
        if not tree:
            return
        scrollbar = tree.verticalScrollBar()
        if scrollbar.value() >= scrollbar.maximum() - 10:
            self.load_more_items()
            
    def initialize_extension_emoji_map(self):
        """Create a mapping of file extensions to emoji icons for better performance"""
        self.extension_emoji_map = {
            # Images
            **{ext: "📷" for ext in self.image_extensions},
            # Videos
            **{ext: "🎬" for ext in self.video_extensions},
            # Audio
            **{ext: "🎵" for ext in self.audio_extensions},
            # Documents
            **{ext: "📚" for ext in ['.pdf', '.epub', '.mobi']},
            **{ext: "📝" for ext in ['.doc', '.docx', '.rtf', '.txt', '.md']},
            # Spreadsheets
            **{ext: "📊" for ext in ['.xls', '.xlsx', '.csv']},
            # Archives
            **{ext: "🗜️" for ext in ['.zip', '.rar', '.tar', '.gz', '.7z']},
            # Code
            **{ext: "💻" for ext in ['.py', '.js', '.html', '.css', '.java', '.cpp', '.c', '.swift']},
            # Config
            **{ext: "⚙️" for ext in ['.json', '.xml', '.yml', '.yaml', '.ini', '.conf']},
        }

    def load_more_items(self, search_tab=None):
        if search_tab is None:
            search_tab = self.get_current_tab()
        if not search_tab:
            return
            
        if not search_tab.file_data or search_tab.current_loaded >= len(search_tab.file_data):
            return
        end_idx = min(search_tab.current_loaded + self.batch_size, len(search_tab.file_data))
        items_to_load = search_tab.file_data[search_tab.current_loaded:end_idx]
        
        # Disable updates for better performance during batch add
        search_tab.tree.setUpdatesEnabled(False)
        
        # For disk-analysis tabs, express each row's size as a share of the
        # scanned total so the "Share" column can draw a proportion bar.
        is_scan = getattr(search_tab, 'is_scan_tab', False)
        scan_total = getattr(search_tab, 'scan_total_size', 0) or 0

        # Batch create all tree items first
        tree_items = []
        for item in items_to_load:
            name, size, mtime, path = item
            display_size = format_size(size)
            display_time = time.strftime('%Y-%m-%d %H:%M:%S', time.localtime(mtime))

            # emoji based on file type - use size==0 check to avoid extra os.path.isdir call
            # Disk-analysis rows are always folders, so show the folder icon
            # even though they have a non-zero size.
            if is_scan or (size == 0 and os.path.isdir(path)):
                display_name = f"📁 {name}"
            else:
                # Get file extension and add appropriate emoji
                _, ext = os.path.splitext(name.lower())
                display_name = f"{self.extension_emoji_map.get(ext, '📄')} {name}"

            tree_item = QTreeWidgetItem([display_name, display_size, display_time, path])
            if is_scan and scan_total > 0:
                tree_item.setData(4, SHARE_ROLE, size / scan_total * 100)
            tree_items.append(tree_item)
        
        # Batch add all items at once
        search_tab.tree.addTopLevelItems(tree_items)
        
        # Re-enable updates
        search_tab.tree.setUpdatesEnabled(True)
        
        search_tab.current_loaded = end_idx
    # ========== Search handling ==========
    def on_query_changed(self):
        self.search_timer.start(DEBOUNCE_DELAY)

    def on_dir_changed(self):
        self.search_timer.start(DEBOUNCE_DELAY)

    def start_search(self, extra_clause=None, is_bookmark=False, tab_title=""):
        query = self.edit_query.text().strip()
        directory = self.edit_dir.text().strip()
        
        # If not bookmark, no query, and no extra clause, don't search
        if not is_bookmark and not query and extra_clause is None:
            return

        # Create a new tab for this search
        search_tab = self.create_new_tab(query, directory, tab_title, extra_clause, is_bookmark)
        
        # Stop any existing search in this tab
        if search_tab.search_worker is not None and search_tab.search_worker.isRunning():
            search_tab.search_worker.stop()
            search_tab.search_worker.wait()

        # Create new search worker
        search_tab.search_worker = SearchWorker(
            query, directory,
            self.chk_file_name.isChecked(),
            self.chk_match_case.isChecked(),
            self.chk_full_match.isChecked(),
            extra_clause,  # Pass extra clause if provided
            is_bookmark    # Pass the bookmark flag
        )
        search_tab.search_worker.progress_signal.connect(self.update_progress)
        search_tab.search_worker.result_signal.connect(lambda results: self.update_tree(results, search_tab))
        search_tab.search_worker.error_signal.connect(self.show_error)
        search_tab.search_worker.start()

        # Only update history if enabled and not a bookmark search
        if not is_bookmark and self.history_enabled and query and query not in self.query_history:
            self.query_history.insert(0, query)
            if len(self.query_history) > 100:
                self.query_history.pop()
            cfg = read_config()
            cfg["query_history"] = self.query_history
            write_config(cfg)
            self.query_completer.model().setStringList(self.query_history)

    def refresh_current_search(self):
        """Refresh the current search in the active tab, or create a new tab if none exists"""
        current_tab = self.get_current_tab()
        
        # If no current tab exists, create a new search with current form parameters
        if not current_tab:
            # Use current form values to start a new search
            query = self.edit_query.text().strip()
            
            # If there's no query, don't start a search
            if not query:
                return
                
            # Start a new search which will create a new tab
            self.start_search()
            return
            
        # Get current search parameters from the tab
        query = current_tab.query
        directory = current_tab.directory
        file_name_search = current_tab.file_name_search
        match_case = current_tab.match_case
        full_match = current_tab.full_match
        
        # Stop any existing search in this tab
        if current_tab.search_worker is not None and current_tab.search_worker.isRunning():
            current_tab.search_worker.stop()
            current_tab.search_worker.wait()

        # Create new search worker with the same parameters
        current_tab.search_worker = SearchWorker(
            query, directory,
            file_name_search,
            match_case,
            full_match,
            None,  # No extra clause for refresh
            False  # Not a bookmark search
        )
        current_tab.search_worker.progress_signal.connect(self.update_progress)
        current_tab.search_worker.result_signal.connect(lambda results: self.update_tree(results, current_tab))
        current_tab.search_worker.error_signal.connect(self.show_error)
        current_tab.search_worker.start()

    def update_progress(self, value):
        self.progress.setValue(value)

    def update_tree(self, files_info, search_tab=None):
        if search_tab is None:
            search_tab = self.get_current_tab()
        if not search_tab:
            return
            
        search_tab.tree.clear()
        search_tab.all_file_data = files_info
        search_tab.current_loaded = 0
        filtered_files = self.apply_filters_and_sorting(search_tab.all_file_data)
        search_tab.file_data = filtered_files
        
        # Update the tab's items found count
        search_tab.items_found_count = len(filtered_files)
        
        if not filtered_files:
            self.lbl_items_found.setText("📊 0 items found")
            return
        
        self.lbl_items_found.setText(f"📊 {len(filtered_files)} items found")

        if search_tab.sort_column != -1:
            self.sort_data(search_tab)
        else:
            self.load_more_items(search_tab)

    def show_error(self, msg):
        self.show_critical("❌ Error", msg)

    # ========== Directory scan ==========
    def start_directory_scan(self, target_path=None):
        # QAction.triggered(bool) passes a boolean checked state; treat that as no target path
        if isinstance(target_path, bool):
            target_path = None
        if self.scan_worker and self.scan_worker.isRunning():
            self.show_info(self.scan_context_label, "A scan is already running.")
            return

        if target_path is None:
            scan_path = Path.home()
            self.scan_context_label = "Home Space Analysis"
            self.scan_tab_prefix = "Home Space"
        else:
            scan_path = Path(target_path)
            folder_label = scan_path.name or str(scan_path)
            self.scan_context_label = f"Folder Space Analysis ({folder_label})"
            self.scan_tab_prefix = f"{folder_label} Space"

        if not scan_path.is_dir():
            self.show_error(f"Directory scan failed: {scan_path} is not a directory.")
            return

        try:
            entries = sorted(
                [entry for entry in scan_path.iterdir() if entry.is_dir()],
                key=lambda item: item.name.lower()
            )
        except Exception as exc:
            self.show_error(f"Directory scan failed: {exc}")
            return

        if not entries:
            self.show_info(self.scan_context_label, f"No subdirectories found under {scan_path}.")
            return

        self.scan_total_dirs = len(entries)
        self.scan_processed_dirs = 0
        self.scan_root_display = str(scan_path)
        self.progress.setValue(0)
        self._open_scan_dialog(
            f"Scanning {self.scan_root_display}\n0/{self.scan_total_dirs} folders processed"
        )

        if hasattr(self, 'scan_home_button'):
            self.scan_home_button.setEnabled(False)

        self.scan_worker = DirectoryScanWorker(scan_path, entries=entries)
        self.scan_worker.progress_signal.connect(self.on_scan_progress)
        self.scan_worker.result_signal.connect(self.on_scan_results)
        self.scan_worker.error_signal.connect(self.on_scan_error)
        self.scan_worker.cancelled_signal.connect(self.on_scan_cancelled)
        self.scan_worker.finished.connect(self.on_scan_finished)
        self.scan_worker.start()

    def cancel_directory_scan(self):
        if self.scan_worker and self.scan_worker.isRunning():
            self.scan_worker.stop()
            if self.scan_dialog:
                self.scan_dialog.setLabelText("Cancelling scan...")
        else:
            self._close_scan_dialog()

    def on_scan_progress(self, processed, total, current_name):
        self.scan_processed_dirs = processed
        percent = int(processed * 100 / total) if total else 0
        self.progress.setValue(percent)
        dialog = self.scan_dialog
        if dialog:
            dialog.setMaximum(total)
            dialog.setValue(processed)
            dialog.setLabelText(f"Processing {processed}/{total}: {current_name}")

    def on_scan_results(self, results):
        root_path = self.scan_root_display or str(Path.home())
        self._close_scan_dialog()
        self._show_scan_results_tab(root_path, results)
        self._reset_scan_state()

    def on_scan_cancelled(self):
        self._close_scan_dialog()
        self._reset_scan_state()

    def on_scan_error(self, message):
        self._close_scan_dialog()
        self.show_error(message)
        self._reset_scan_state()

    def on_scan_finished(self):
        self.scan_worker = None

    def _open_scan_dialog(self, initial_text):
        self._close_scan_dialog()
        self.scan_dialog = QProgressDialog(initial_text, "Cancel Scan", 0, max(1, self.scan_total_dirs), self)
        self.scan_dialog.setWindowTitle(self.scan_context_label)
        self.scan_dialog.setWindowModality(Qt.WindowModality.ApplicationModal)
        self.scan_dialog.setAutoClose(False)
        self.scan_dialog.setAutoReset(False)
        self.scan_dialog.canceled.connect(self.cancel_directory_scan)
        self.apply_dialog_dark_mode(self.scan_dialog)
        self.scan_dialog.setMinimumSize(560, 240)
        self.scan_dialog.resize(560, 240)
        self.scan_dialog.show()

    def _close_scan_dialog(self):
        if self.scan_dialog:
            self.scan_dialog.hide()
            self.scan_dialog.deleteLater()
            self.scan_dialog = None

    def _reset_scan_state(self):
        if hasattr(self, 'scan_home_button'):
            self.scan_home_button.setEnabled(True)
        self.progress.setValue(0)
        self.scan_root_display = ""
        self.scan_total_dirs = 0
        self.scan_processed_dirs = 0

    def _populate_scan_tree(self, tab, enriched, dir_path=None):
        """Fill a scan tab's tree, share column and metadata from a list of
        (name, size, mtime, path) rows.

        Shared by the top-level scan, drill-down and back-navigation paths so
        folder icons, the share bar and lazy loading behave identically no
        matter how the tab was produced.
        """
        tab.tree.clear()
        tab.all_file_data = enriched
        tab.file_data = enriched
        tab.current_loaded = 0
        tab.items_found_count = len(enriched)
        tab.scan_total_size = sum(row[1] for row in enriched)
        tab.scan_dir_path = dir_path  # explicit identity for back-navigation
        tab.tree.setColumnHidden(4, False)  # reveal the "Share" bar column
        while tab.current_loaded < len(enriched):
            self.load_more_items(tab)
        self.lbl_items_found.setText(f"📊 {len(enriched)} items found")

    def _show_scan_results_tab(self, root_path, results):
        if not results:
            self.show_info(self.scan_context_label, "Scan completed but no folders were reported.")
            return

        timestamp = time.strftime("%H:%M:%S")
        tab_title = f"{self.scan_tab_prefix} ({timestamp})"
        scan_tab = self.create_new_tab(
            query="",
            directory=root_path,
            tab_title=tab_title,
            extra_clause=None,
            is_bookmark=False,
            force_parameters=True,
            is_scan_tab=True
        )
        scan_tab.query = ""
        sorted_results = sorted(results, key=lambda item: item[1], reverse=True)
        enriched = []
        for name, size in sorted_results:
            path = os.path.join(root_path, name)
            try:
                mtime = os.path.getmtime(path)
            except Exception:
                mtime = 0
            enriched.append((name, size, mtime, path))

        scan_tab.scan_chart_data = enriched
        scan_tab.scan_chart_title = root_path
        self._populate_scan_tree(scan_tab, enriched, dir_path=root_path)

        self._ensure_preview_visible()
        self._populate_scan_chart(scan_tab, self.tab_widget.currentIndex())

    # ========== Scan preview helpers ==========
    def _ensure_preview_visible(self):
        """Force preview pane open when visualization is required."""
        if self.preview_container.isVisible():
            return
        if hasattr(self, 'toggle_preview_action'):
            self.toggle_preview_action.setChecked(True)
        self.toggle_preview(True)

    def _set_preview_widgets_hidden_for_chart(self, hide):
        self._chart_overrides_preview = hide
        target_visible = not hide
        if hasattr(self, 'preview_stack'):
            self.preview_stack.setVisible(target_visible)
        if hasattr(self, 'media_info'):
            self.media_info.setVisible(target_visible)

    def _clear_scan_chart(self):
        if not hasattr(self, 'scan_chart_view'):
            return
        if self._current_scan_series:
            try:
                self._current_scan_series.clicked.disconnect(self.on_scan_chart_bar_clicked)
                self._current_scan_series.doubleClicked.disconnect(self.on_scan_chart_bar_double_clicked)
            except (TypeError, RuntimeError):
                pass
            self._current_scan_series = None
        self.scan_chart.removeAllSeries()
        self.scan_chart_view.setVisible(False)
        self.scan_chart_path_map.clear()
        self.scan_chart_categories = []
        self.scan_chart_tab_index = None
        self.scan_chart_nav_stack = []
        self.scan_chart_current_path = None
        if hasattr(self, 'chart_nav_container'):
            self.chart_nav_container.setVisible(False)
        if hasattr(self, 'chart_hint_label'):
            self.chart_hint_label.setVisible(False)
        self._set_preview_widgets_hidden_for_chart(False)

    def _populate_scan_chart(self, scan_tab, tab_index):
        if not hasattr(self, 'scan_chart_view'):
            return

        data = getattr(scan_tab, 'scan_chart_data', []) or []
        if not data:
            self._clear_scan_chart()
            return

        sorted_data = sorted(data, key=lambda item: item[1], reverse=True)
        total_size = sum(item[1] for item in sorted_data)

        if self._current_scan_series:
            try:
                self._current_scan_series.clicked.disconnect(self.on_scan_chart_bar_clicked)
            except (TypeError, RuntimeError):
                pass
            self._current_scan_series = None
        self.scan_chart.removeAllSeries()
        self.scan_chart_path_map.clear()

        bar_limit = 10
        top_entries = sorted_data[:bar_limit]
        remaining = sorted_data[bar_limit:]
        others_size = sum(item[1] for item in remaining)
        entries = top_entries[:]
        if others_size > 0:
            entries.append(("Others", others_size, 0, None))

        # Pick a single display unit based on the largest entry so small
        # folders no longer collapse to "0.00 GB" — the axis adapts to the
        # data (KB / MB / GB / TB) instead of always using GB.
        max_size = entries[0][1] if entries else 0
        if max_size >= 1024 ** 4:
            divisor, unit = 1024 ** 4, "TB"
        elif max_size >= 1024 ** 3:
            divisor, unit = 1024 ** 3, "GB"
        elif max_size >= 1024 ** 2:
            divisor, unit = 1024 ** 2, "MB"
        else:
            divisor, unit = 1024, "KB"
        self.scan_chart_unit = unit

        # A category axis draws its first entry at the bottom, so reverse the
        # (largest-first) list to put the biggest folder at the TOP of the chart.
        entries = list(reversed(entries))

        categories = []
        values = []
        raw_sizes = []  # Store raw byte sizes for tooltips

        for idx, (name, size, _mtime, path) in enumerate(entries):
            # Category label (Y-axis) carries the human-readable size plus its
            # share of the total so the breakdown is legible at a glance.
            size_str = format_size(size)
            pct = (size / total_size * 100) if total_size else 0
            categories.append(f"{name}  —  {size_str} ({pct:.0f}%)")
            values.append(size / divisor if size else 0)
            raw_sizes.append(size)
            self.scan_chart_path_map[idx] = path

        # Store raw sizes for potential tooltip use
        self.scan_chart_raw_sizes = raw_sizes
        self.scan_chart_categories = categories

        series = QHorizontalBarSeries()
        bar_set = QBarSet(f"Size ({unit})")
        for i, value in enumerate(values):
            bar_set.append(value)
        series.append(bar_set)
        # Disable bar labels since size is shown in Y-axis category names
        series.setLabelsVisible(False)
        series.setBarWidth(0.82)
        series.clicked.connect(self.on_scan_chart_bar_clicked)
        series.doubleClicked.connect(self.on_scan_chart_bar_double_clicked)

        # Fill every bar with a smooth left→right accent gradient (per-bar,
        # thanks to object-bounding coordinates) for a clean, coordinated look
        # instead of Qt's default multi-colour palette.
        gradient = QLinearGradient(0, 0, 1, 0)
        gradient.setCoordinateMode(QGradient.CoordinateMode.ObjectBoundingMode)
        if self.dark_mode:
            gradient.setColorAt(0.0, QColor("#3b6fd6"))
            gradient.setColorAt(1.0, QColor("#8ab4ff"))
            border = QColor("#2a2b3c")
        else:
            gradient.setColorAt(0.0, QColor("#2f6fed"))
            gradient.setColorAt(1.0, QColor("#7fb0ff"))
            border = QColor("#ffffff")
        bar_set.setBrush(QBrush(gradient))
        bar_set.setBorderColor(border)

        self.scan_chart.addSeries(series)

        for axis in list(self.scan_chart.axes()):
            self.scan_chart.removeAxis(axis)

        axis_font = QFont()
        axis_font.setPointSize(11)
        axis_x = QValueAxis()
        axis_x.setTitleText(f"Size ({unit})")
        axis_x.setLabelFormat("%.2f")
        if values:
            # Normal axis range since labels are on Y-axis now
            axis_x.setMax(max(values) * 1.1)
        axis_x.setLabelsFont(axis_font)
        axis_x.setTitleFont(axis_font)

        axis_y = QBarCategoryAxis()
        axis_y.append(categories)
        # Folder names are self-explanatory, so no axis title is needed here.
        axis_y.setLabelsFont(axis_font)

        self.scan_chart.addAxis(axis_x, Qt.AlignmentFlag.AlignBottom)
        self.scan_chart.addAxis(axis_y, Qt.AlignmentFlag.AlignLeft)
        series.attachAxis(axis_x)
        series.attachAxis(axis_y)

        self._current_scan_series = series
        title = scan_tab.scan_chart_title or scan_tab.tab_title or "Usage Scan"
        total_text = format_size(total_size) if total_size else "0 B"
        self.scan_chart.setTitle(f"{title} — Total {total_text}")
        title_font = self.scan_chart.titleFont()
        title_font.setPointSize(14)
        title_font.setBold(True)
        self.scan_chart.setTitleFont(title_font)
        self.scan_chart_view.setVisible(True)
        self.scan_chart_tab_index = tab_index
        self.scan_chart.legend().setVisible(False)
        self._set_preview_widgets_hidden_for_chart(True)
        
        # Show hint label
        if hasattr(self, 'chart_hint_label'):
            self.chart_hint_label.setVisible(True)
        
        # Update navigation breadcrumb
        if hasattr(self, 'chart_breadcrumb'):
            if self.scan_chart_current_path:
                self.chart_breadcrumb.setText(f"📂 {self.scan_chart_current_path}")
                self.chart_nav_container.setVisible(True)
                self.chart_back_button.setVisible(len(self.scan_chart_nav_stack) > 0)
            else:
                self.chart_nav_container.setVisible(False)
        
        # Apply current theme colors to chart axes
        self._update_scan_chart_theme()

    def _update_scan_chart_for_tab(self):
        if not hasattr(self, 'scan_chart_view'):
            return
        current_index = self.tab_widget.currentIndex()
        current_tab = self.search_tabs.get(current_index)
        if current_tab and current_tab.is_scan_tab and getattr(current_tab, 'scan_chart_data', None):
            self._populate_scan_chart(current_tab, current_index)
            # Ensure theme is applied after populating
            self._update_scan_chart_theme()
        else:
            self._clear_scan_chart()

    def _update_scan_chart_theme(self):
        if not hasattr(self, 'scan_chart'):
            return
        bg = QColor("#1a1b26" if self.dark_mode else "#ffffff")
        fg = QColor("#c0caf5" if self.dark_mode else "#24292f")
        self.scan_chart.setBackgroundBrush(QBrush(bg))
        self.scan_chart.setTitleBrush(QBrush(fg))
        legend = self.scan_chart.legend()
        legend.setLabelColor(fg)
        for axis in self.scan_chart.axes():
            axis.setLabelsBrush(QBrush(fg))
            axis.setTitleBrush(QBrush(fg))
        self._style_chart_hint()

    def _style_chart_hint(self):
        """Theme-aware, prominent styling for the drill-down hint banner."""
        if not hasattr(self, 'chart_hint_label'):
            return
        if self.dark_mode:
            style = (
                "color: #b9c6f2; font-size: 12.5px; font-weight: 500;"
                " padding: 7px 12px;"
                " background: rgba(122, 162, 247, 0.18);"
                " border: 1px solid rgba(122, 162, 247, 0.35);"
                " border-radius: 8px; margin-top: 6px;"
            )
        else:
            style = (
                "color: #1f4d8a; font-size: 12.5px; font-weight: 500;"
                " padding: 7px 12px;"
                " background: rgba(47, 111, 237, 0.10);"
                " border: 1px solid rgba(47, 111, 237, 0.30);"
                " border-radius: 8px; margin-top: 6px;"
            )
        self.chart_hint_label.setStyleSheet(style)

    def on_scan_chart_bar_clicked(self, index, bar_set):
        target_path = self.scan_chart_path_map.get(index)
        if not target_path:
            return
        if self.scan_chart_tab_index is None:
            return
        if self.scan_chart_tab_index >= self.tab_widget.count():
            return
        self.tab_widget.setCurrentIndex(self.scan_chart_tab_index)
        tab = self.search_tabs.get(self.scan_chart_tab_index)
        if not tab:
            return
        tree = tab.tree
        if not tree:
            return
        for row in range(tree.topLevelItemCount()):
            item = tree.topLevelItem(row)
            if item.text(3) == target_path:
                tree.setCurrentItem(item)
                tree.scrollToItem(item)
                break

    def on_scan_chart_bar_double_clicked(self, index, bar_set):
        """Handle double-click on bar to drill down into subdirectories"""
        target_path = self.scan_chart_path_map.get(index)
        if not target_path or target_path is None:
            return
        
        target_dir = Path(target_path)
        if not target_dir.is_dir():
            return
        
        # Prevent multiple concurrent scans
        if hasattr(self, 'subdir_scan_worker') and self.subdir_scan_worker and self.subdir_scan_worker.isRunning():
            return
        
        # Save current state to navigation stack
        if self.scan_chart_tab_index is not None:
            tab = self.search_tabs.get(self.scan_chart_tab_index)
            if tab:
                current_state = {
                    'path': self.scan_chart_current_path,
                    'data': list(tab.scan_chart_data),
                    'title': tab.scan_chart_title
                }
                self.scan_chart_nav_stack.append(current_state)
        
        # Show an inline loading overlay on the chart (much nicer than a modal
        # progress dialog).
        self._show_subdir_loading(f"Scanning {target_dir.name}…")

        # Start background scan
        self.subdir_scan_target = target_dir
        self.subdir_scan_worker = SubdirScanWorker(target_dir)
        self.subdir_scan_worker.result_signal.connect(self._on_subdir_scan_complete)
        self.subdir_scan_worker.error_signal.connect(self._on_subdir_scan_error)
        self.subdir_scan_worker.finished.connect(self._on_subdir_scan_finished)
        self.subdir_scan_worker.start()
    
    def _show_subdir_loading(self, message):
        """Show the inline loading overlay on top of the usage chart."""
        overlay = getattr(self, 'subdir_loading_overlay', None)
        if overlay is None:
            overlay = LoadingOverlay(self.scan_chart_view, dark_mode=self.dark_mode)
            self.subdir_loading_overlay = overlay
        overlay.start(message, dark_mode=self.dark_mode,
                      cancel_callback=self._cancel_subdir_scan)

    def _hide_subdir_loading(self):
        overlay = getattr(self, 'subdir_loading_overlay', None)
        if overlay is not None:
            overlay.stop()

    def _cancel_subdir_scan(self):
        """Cancel the running subdirectory scan"""
        if hasattr(self, 'subdir_scan_worker') and self.subdir_scan_worker:
            self.subdir_scan_worker.stop()
            # Wait for thread to finish gracefully
            if self.subdir_scan_worker.isRunning():
                self.subdir_scan_worker.wait(1000)  # Wait up to 1 second
            self.subdir_scan_worker = None
        self._hide_subdir_loading()

    def _on_subdir_scan_complete(self, subdirs):
        """Handle subdirectory scan completion"""
        self._hide_subdir_loading()

        if not subdirs:
            target_path = str(self.subdir_scan_target) if hasattr(self, 'subdir_scan_target') else "directory"
            self.show_info("No Subdirectories", f"No accessible subdirectories found in:\n{target_path}")
            return
        
        if not hasattr(self, 'subdir_scan_target'):
            return
        
        # Convert to format: (name, size, mtime, path), largest first.
        chart_data = []
        for name, size, path in subdirs:
            try:
                mtime = path.stat().st_mtime if path.exists() else 0
            except Exception:
                mtime = 0
            chart_data.append((name, size, mtime, str(path)))
        chart_data.sort(key=lambda row: row[1], reverse=True)

        # Create a new tab for the subdirectory
        target_path = str(self.subdir_scan_target)
        tab_title = f"📊 {self.subdir_scan_target.name}"

        new_tab = self.create_new_tab(
            query="",
            directory="",
            tab_title=tab_title,
            is_scan_tab=True
        )

        # Set up the new tab with scan data
        new_tab.scan_chart_data = chart_data
        new_tab.scan_chart_title = f"{self.subdir_scan_target.name}"
        new_tab.is_scan_tab = True

        # Get the new tab index
        new_tab_index = None
        for idx, tab in self.search_tabs.items():
            if tab == new_tab:
                new_tab_index = idx
                break

        if new_tab_index is not None:
            # Update global chart state to new tab
            self.scan_chart_tab_index = new_tab_index
            self.scan_chart_current_path = target_path

            # Populate chart in new tab
            self._populate_scan_chart(new_tab, new_tab_index)

            # Populate tree + share column via the shared helper
            self._populate_scan_tree(new_tab, chart_data, dir_path=target_path)
    
    def _on_subdir_scan_error(self, error_msg):
        """Handle subdirectory scan error"""
        self._hide_subdir_loading()
        self.show_error(error_msg)
    
    def _on_subdir_scan_finished(self):
        """Clean up after subdirectory scan finishes"""
        if hasattr(self, 'subdir_scan_worker') and self.subdir_scan_worker:
            # Wait for thread to completely finish
            if self.subdir_scan_worker.isRunning():
                self.subdir_scan_worker.wait(500)  # Wait up to 0.5 seconds
            self.subdir_scan_worker = None

    def on_chart_back_clicked(self):
        """Navigate back to parent directory in chart"""
        if not self.scan_chart_nav_stack:
            return
        
        # Pop previous state from stack
        prev_state = self.scan_chart_nav_stack.pop()
        prev_path = prev_state['path']
        
        # Check if a tab already exists for this path (matched by the explicit
        # directory each scan tab records, rather than inferring it from the
        # first row's parent which breaks on same-named folders).
        existing_tab_index = None
        for idx, tab in self.search_tabs.items():
            if getattr(tab, 'is_scan_tab', False) and getattr(tab, 'scan_dir_path', None) == prev_path:
                existing_tab_index = idx
                break
        
        if existing_tab_index is not None:
            # Switch to existing tab
            self.tab_widget.setCurrentIndex(existing_tab_index)
            self.scan_chart_tab_index = existing_tab_index
            self.scan_chart_current_path = prev_path
        else:
            # Create new tab for previous state
            prev_path_obj = Path(prev_path)
            tab_title = f"📊 {prev_path_obj.name or prev_path_obj}"
            
            new_tab = self.create_new_tab(
                query="",
                directory="",
                tab_title=tab_title,
                is_scan_tab=True
            )
            
            # Set up the new tab with previous state data
            new_tab.scan_chart_data = prev_state['data']
            new_tab.scan_chart_title = prev_state['title']
            new_tab.is_scan_tab = True
            
            # Get the new tab index
            new_tab_index = None
            for idx, tab in self.search_tabs.items():
                if tab == new_tab:
                    new_tab_index = idx
                    break
            
            if new_tab_index is not None:
                # Update global chart state
                self.scan_chart_tab_index = new_tab_index
                self.scan_chart_current_path = prev_path
                
                # Populate chart in new tab
                self._populate_scan_chart(new_tab, new_tab_index)

                # Populate tree + share column via the shared helper
                self._populate_scan_tree(new_tab, prev_state['data'], dir_path=prev_path)

    # ========== Filtering and sorting ==========
    def on_filter_changed(self):
        """Handle changes to filter fields and update current tab attributes"""
        current_tab = self.get_current_tab()
        if current_tab:
            # Update the current tab's filter attributes
            current_tab.min_size = self.edit_min_size.text().strip()
            current_tab.max_size = self.edit_max_size.text().strip()
            current_tab.extensions = self.edit_extension.text().strip()
        
        # Reapply the filter with updated values
        self.reapply_filter()
    
    def reapply_filter(self):
        search_tab = self.get_current_tab()
        if not search_tab or not search_tab.all_file_data:
            return
        filtered_files = self.apply_filters_and_sorting(search_tab.all_file_data)
        search_tab.file_data = filtered_files
        search_tab.tree.clear()
        search_tab.current_loaded = 0
        
        # Update the tab's items found count
        search_tab.items_found_count = len(filtered_files)

        if search_tab.sort_column != -1:
            self.sort_data(search_tab)
        else:
            self.load_more_items(search_tab)

        self.lbl_items_found.setText(f"📊 {len(filtered_files)} items found")

    def apply_filters_and_sorting(self, files_info):
        filtered = files_info[:]
        try:
            min_size = int(self.edit_min_size.text()) if self.edit_min_size.text() else None
        except ValueError:
            min_size = None
        try:
            max_size = int(self.edit_max_size.text()) if self.edit_max_size.text() else None
        except ValueError:
            max_size = None

        if min_size is not None:
            filtered = [item for item in filtered if item[1] >= min_size]
        if max_size is not None:
            filtered = [item for item in filtered if item[1] <= max_size]

        ext_text = self.edit_extension.text().strip()
        if ext_text:
            exts = []
            for part in ext_text.split(";"):
                part = part.strip()
                if part and not part.startswith("."):
                    part = "." + part
                if part:
                    exts.append(part.lower())
            if exts:
                filtered = [item for item in filtered if any(item[0].lower().endswith(e) for e in exts)]

        return filtered

    def on_header_clicked(self, column):
        search_tab = self.get_current_tab()
        if not search_tab:
            return
            
        if search_tab.sort_column == column:
            search_tab.sort_order = (Qt.SortOrder.DescendingOrder
                               if search_tab.sort_order == Qt.SortOrder.AscendingOrder
                               else Qt.SortOrder.AscendingOrder)
        else:
            search_tab.sort_column = column
            search_tab.sort_order = Qt.SortOrder.AscendingOrder
        search_tab.tree.header().setSortIndicator(column, search_tab.sort_order)
        self.sort_data(search_tab)

    def sort_data(self, search_tab=None):
        if search_tab is None:
            search_tab = self.get_current_tab()
        if not search_tab:
            return
            
        if not search_tab.file_data or search_tab.sort_column == -1:
            return

        def get_sort_key(item):
            if search_tab.sort_column == 0:
                return item[0].lower()
            elif search_tab.sort_column == 1 or search_tab.sort_column == 4:
                # Column 4 ("Share") is proportional to size, so sort by size.
                return float(item[1])
            elif search_tab.sort_column == 2:
                return float(item[2])
            else:
                return item[3].lower()

        search_tab.file_data.sort(
            key=get_sort_key,
            reverse=(search_tab.sort_order == Qt.SortOrder.DescendingOrder)
        )
        search_tab.tree.clear()
        search_tab.current_loaded = 0
        self.load_more_items(search_tab)

    # ========== Context menu logic ==========
    def show_context_menu(self, pos):
        tree = self.get_current_tree()
        if not tree:
            return
        selected_items = tree.selectedItems()
        if not selected_items:
            return
        if len(selected_items) == 1:
            tree.setCurrentItem(selected_items[0])
            path = selected_items[0].text(3)
            self.scan_item_action.setEnabled(bool(path and os.path.isdir(path)))
            self.single_context_menu.exec(tree.viewport().mapToGlobal(pos))
        else:
            self.multi_context_menu.exec(tree.viewport().mapToGlobal(pos))

    def get_selected_file(self):
        tree = self.get_current_tree()
        if not tree:
            return None
        item = tree.currentItem()
        if item:
            return item.text(3)
        return None

    def get_selected_files(self):
        tree = self.get_current_tree()
        if not tree:
            return []
        return [item.text(3) for item in tree.selectedItems()]

    # ========== File operations ==========
    def open_with_default_app(self):
        path = self.get_selected_file()
        if not path:
            return
        try:
            process = subprocess.Popen(["open", path], stdout=subprocess.PIPE, stderr=subprocess.PIPE)
            _, stderr = process.communicate()
            if process.returncode != 0:
                error_msg = stderr.decode('utf-8').strip()
                self.show_critical("Error", f"Could not open file: {error_msg}")
                reply = self.show_question(
                    "Open with Text Editor?",
                    "Would you like to open this file with TextEdit instead?",
                    QMessageBox.StandardButton.Yes | QMessageBox.StandardButton.No
                )
                if reply == QMessageBox.StandardButton.Yes:
                    subprocess.Popen(["open", "-a", "TextEdit", path])
        except Exception as e:
            self.show_critical("Error", f"Error opening file: {str(e)}")

    def open_multiple_files(self):
        for path in self.get_selected_files():
            try:
                subprocess.Popen(["open", path])
            except Exception as e:
                self.show_critical("Error", f"Could not open file {path}: {str(e)}")

    def delete_file(self):
        path = self.get_selected_file()
        if not path:
            return
        reply = self.show_question(
            "🗑️ Delete",
            f"Are you sure you want to delete '{path}'?",
            QMessageBox.StandardButton.Yes | QMessageBox.StandardButton.No
        )
        if reply == QMessageBox.StandardButton.Yes:
            try:
                if os.path.isdir(path):
                    shutil.rmtree(path)  # Delete directory and contents
                else:
                    os.remove(path)  # Delete file
                tree = self.get_current_tree()
                if tree:
                    index = tree.indexOfTopLevelItem(tree.currentItem())
                    tree.takeTopLevelItem(index)
                self.show_info("Deleted", f"File '{path}' deleted.")
            except Exception as e:
                self.show_critical("Error", str(e))

    def delete_multiple_files(self):
        files = self.get_selected_files()
        if not files:
            return
        reply = self.show_question(
            "🗑️ Delete Multiple Files",
            f"Are you sure you want to delete {len(files)} files?",
            QMessageBox.StandardButton.Yes | QMessageBox.StandardButton.No
        )
        if reply == QMessageBox.StandardButton.Yes:
            error_files = []
            for path in files:
                try:
                    if os.path.isdir(path):
                        shutil.rmtree(path)  # Delete directory and contents
                    else:
                        os.remove(path)  # Delete file
                except Exception as e:
                    error_files.append(f"{path}: {str(e)}")
            tree = self.get_current_tree()
            if tree:
                for item in tree.selectedItems():
                    index = tree.indexOfTopLevelItem(item)
                    tree.takeTopLevelItem(index)
            if error_files:
                self.show_warning(
                    "⚠️ Deletion Errors",
                    "Some files could not be deleted:\n" + "\n".join(error_files)
                )
            else:
                self.show_info("✅ Success", f"Successfully deleted {len(files)} files.")

    def copy_file(self):
        path = self.get_selected_file()
        if not path:
            return
        dest = QFileDialog.getExistingDirectory(self, "Select Destination Directory")
        if dest:
            try:
                shutil.copy2(path, dest)
                self.show_info("Copied", f"File '{path}' copied to '{dest}'.")
            except Exception as e:
                self.show_critical("Error", str(e))

    def copy_multiple_files(self):
        files = self.get_selected_files()
        if not files:
            return
        dest = QFileDialog.getExistingDirectory(self, "Select Destination Directory")
        if not dest:
            return
        error_files = []
        success_count = 0
        for path in files:
            try:
                shutil.copy2(path, dest)
                success_count += 1
            except Exception as e:
                error_files.append(f"{path}: {str(e)}")
        if error_files:
            self.show_warning(
                "⚠️ Copy Errors",
                f"Copied {success_count} files.\nErrors occurred with:\n" + "\n".join(error_files)
            )
        else:
            self.show_info("✅ Success", f"Successfully copied {success_count} files to {dest}")

    def move_file(self):
        path = self.get_selected_file()
        if not path:
            return
        dest = QFileDialog.getExistingDirectory(self, "Select Destination Directory")
        if dest:
            try:
                shutil.move(path, dest)
                tree = self.get_current_tree()
                if tree:
                    index = tree.indexOfTopLevelItem(tree.currentItem())
                    tree.takeTopLevelItem(index)
                self.show_info("Moved", f"File '{path}' moved to '{dest}'.")
            except Exception as e:
                self.show_critical("Error", str(e))

    def move_multiple_files(self):
        files = self.get_selected_files()
        if not files:
            return
        dest = QFileDialog.getExistingDirectory(self, "Select Destination Directory")
        if not dest:
            return
        error_files = []
        success_count = 0
        for path in files:
            try:
                shutil.move(path, dest)
                success_count += 1
                tree = self.get_current_tree()
                if tree:
                    for item in tree.selectedItems():
                        if item.text(3) == path:
                            index = tree.indexOfTopLevelItem(item)
                            tree.takeTopLevelItem(index)
            except Exception as e:
                error_files.append(f"{path}: {str(e)}")
        if error_files:
            self.show_warning(
                "⚠️ Move Errors",
                f"Moved {success_count} files.\nErrors occurred with:\n" + "\n".join(error_files)
            )
        else:
            self.show_info("✅ Success", f"Successfully moved {success_count} files to {dest}")

    def rename_file(self):
        path = self.get_selected_file()
        if not path:
            return
        directory = os.path.dirname(path)
        old_name = os.path.basename(path)
        
        # Create input dialog and apply theme
        input_dialog = QInputDialog(self)
        input_dialog.setWindowTitle("✏️ Rename File")
        input_dialog.setLabelText(f"Enter new name for {old_name}:")
        input_dialog.setTextValue(old_name)
        input_dialog.setInputMode(QInputDialog.InputMode.TextInput)
        self.apply_dialog_dark_mode(input_dialog)
        
        ok = input_dialog.exec()
        new_name = input_dialog.textValue()
        
        if ok and new_name:
            new_full_path = os.path.join(directory, new_name)
            try:
                os.rename(path, new_full_path)
                tree = self.get_current_tree()
                if tree:
                    current_item = tree.currentItem()
                    if current_item:
                        # Update display name with emoji
                        _, ext = os.path.splitext(new_name.lower())
                        if os.path.isdir(new_full_path):
                            display_name = f"📁 {new_name}"
                        else:
                            display_name = f"{self.extension_emoji_map.get(ext, '📄')} {new_name}"
                        current_item.setText(0, display_name)
                        current_item.setText(3, new_full_path)
                self.show_info("✅ Success", "File renamed successfully.")
            except Exception as e:
                self.show_critical("Error", f"Could not rename file: {str(e)}")

    def batch_rename_files(self):
        files = self.get_selected_files()
        if not files:
            return
        
        # Create input dialog for prefix and apply theme
        prefix_dialog = QInputDialog(self)
        prefix_dialog.setWindowTitle("✏️ Batch Rename")
        prefix_dialog.setLabelText("Enter prefix (optional):")
        prefix_dialog.setInputMode(QInputDialog.InputMode.TextInput)
        self.apply_dialog_dark_mode(prefix_dialog)
        
        ok_prefix = prefix_dialog.exec()
        prefix = prefix_dialog.textValue()
        if not ok_prefix:
            return
        
        # Create input dialog for suffix and apply theme
        suffix_dialog = QInputDialog(self)
        suffix_dialog.setWindowTitle("✏️ Batch Rename")
        suffix_dialog.setLabelText("Enter suffix (optional):")
        suffix_dialog.setInputMode(QInputDialog.InputMode.TextInput)
        self.apply_dialog_dark_mode(suffix_dialog)
        
        ok_suffix = suffix_dialog.exec()
        suffix = suffix_dialog.textValue()
        if not ok_suffix:
            return

        error_files = []
        success_count = 0
        tree = self.get_current_tree()
        if not tree:
            return
        selected_items = tree.selectedItems()

        for item in selected_items:
            old_path = item.text(3)
            old_name = os.path.basename(old_path)
            directory = os.path.dirname(old_path)
            base_name, ext = os.path.splitext(old_name)
            new_name = f"{prefix}{base_name}{suffix}{ext}"
            new_full_path = os.path.join(directory, new_name)
            try:
                os.rename(old_path, new_full_path)
                success_count += 1
                # Update display name with emoji
                if os.path.isdir(new_full_path):
                    display_name = f"📁 {new_name}"
                else:
                    display_name = f"{self.extension_emoji_map.get(ext.lower(), '📄')} {new_name}"
                item.setText(0, display_name)
                item.setText(3, new_full_path)
            except Exception as e:
                error_files.append(f"{old_path} -> {new_full_path}: {str(e)}")

        if error_files:
            self.show_warning(
                "⚠️ Batch Rename Errors",
                f"Renamed {success_count} files.\nErrors:\n" + "\n".join(error_files)
            )
        else:
            self.show_info("✅ Success", f"Successfully renamed {success_count} files.")

    # ========== Compression functions ==========
    def compress_file(self):
        """Compress a single file to ZIP"""
        path = self.get_selected_file()
        if not path:
            return
        
        # Get default ZIP file name
        base_name = os.path.splitext(os.path.basename(path))[0]
        default_zip_name = f"{base_name}.zip"
        
        # Ask user for ZIP file location and name
        zip_path, _ = QFileDialog.getSaveFileName(
            self, 
            "Save ZIP file as...", 
            default_zip_name,
            "ZIP Files (*.zip);;All Files (*)"
        )
        
        if not zip_path:
            return
        
        try:
            with zipfile.ZipFile(zip_path, 'w', zipfile.ZIP_DEFLATED) as zipf:
                if os.path.isfile(path):
                    # Add single file
                    zipf.write(path, os.path.basename(path))
                elif os.path.isdir(path):
                    # Add directory and all its contents
                    for root, dirs, files in os.walk(path):
                        for file in files:
                            file_path = os.path.join(root, file)
                            arcname = os.path.relpath(file_path, os.path.dirname(path))
                            zipf.write(file_path, arcname)
            
            # Create callback function for opening in Finder
            def open_zip_in_finder():
                subprocess.run(["open", "-R", zip_path], check=True)
            
            self.show_info_dialog_with_action(
                "🗜️ Single File Compression", 
                f"File compressed to: {zip_path}", 
                "🔍 Open in Finder", 
                open_zip_in_finder
            )
            
        except Exception as e:
            self.show_critical("🗜️ Compression Error", f"Failed to compress file: {str(e)}")

    def compress_multiple_files(self):
        """Compress multiple files to ZIP"""
        files = self.get_selected_files()
        if not files:
            return
        
        # Get default ZIP file name
        default_zip_name = f"compressed_files_{len(files)}_items.zip"
        
        # Ask user for ZIP file location and name
        zip_path, _ = QFileDialog.getSaveFileName(
            self, 
            "Save ZIP file as...", 
            default_zip_name,
            "ZIP Files (*.zip);;All Files (*)"
        )
        
        if not zip_path:
            return
        
        try:
            with zipfile.ZipFile(zip_path, 'w', zipfile.ZIP_DEFLATED) as zipf:
                for path in files:
                    if os.path.isfile(path):
                        # Add file with just its name (no full path structure)
                        zipf.write(path, os.path.basename(path))
                    elif os.path.isdir(path):
                        # Add directory and all its contents
                        dir_name = os.path.basename(path)
                        for root, dirs, files_in_dir in os.walk(path):
                            for file in files_in_dir:
                                file_path = os.path.join(root, file)
                                # Create archive path that preserves directory structure
                                arcname = os.path.join(dir_name, os.path.relpath(file_path, path))
                                zipf.write(file_path, arcname)
            
            # Create callback function for opening in Finder
            def open_zip_in_finder():
                subprocess.run(["open", "-R", zip_path], check=True)
            
            self.show_info_dialog_with_action(
                "🗜️ Multiple Files Compression", 
                f"{len(files)} items compressed to: {zip_path}", 
                "🔍 Open in Finder", 
                open_zip_in_finder
            )
            
        except Exception as e:
            self.show_critical("🗜️ Compression Error", f"Failed to compress files: {str(e)}")

    # ========== Copy path to clipboard ==========
    def show_tooltip(self, message):
        """Show a beautiful tooltip for copy confirmations"""
        # Update tooltip style based on current theme
        if self.dark_mode:
            self.tooltip.setup_dark_style()
        else:
            self.tooltip.setup_style()
        
        # Show tooltip relative to the tree widget with longer duration
        tree = self.get_current_tree()
        if tree:
            self.tooltip.show_message(message, tree, 2000)
    
    def copy_full_path(self):
        path = self.get_selected_file()
        if not path:
            return
        QApplication.clipboard().setText(path)
        self.show_tooltip("✅ Full path copied!")

    def copy_path_only(self):
        path = self.get_selected_file()
        if not path:
            return
        directory = os.path.dirname(path)
        QApplication.clipboard().setText(directory)
        self.show_tooltip("✅ Directory path copied!")

    def copy_file_name_only(self):
        path = self.get_selected_file()
        if not path:
            return
        filename = os.path.basename(path)
        QApplication.clipboard().setText(filename)
        self.show_tooltip("✅ File name copied!")

    # ========== Export Data ==========
    def export_results(self):
        """Export search results to various formats"""
        search_tab = self.get_current_tab()
        if not search_tab or not search_tab.file_data:
            self.show_warning("⚠️ Warning", "No data to export.")
            return
        
        # Show format selection dialog
        format_dialog = ExportFormatDialog(self)
        if format_dialog.exec() != QDialog.DialogCode.Accepted:
            return
            
        export_format = format_dialog.get_selected_format()
        
        # Set up file dialog based on format
        if export_format == "json":
            file_path, _ = QFileDialog.getSaveFileName(
                self, "Export to JSON", "", 
                "JSON Files (*.json);;All Files (*)"
            )
            if file_path:
                self.export_to_json(file_path, search_tab.file_data)
        elif export_format == "excel":
            file_path, _ = QFileDialog.getSaveFileName(
                self, "Export to Excel", "", 
                "Excel Files (*.xlsx);;All Files (*)"
            )
            if file_path:
                self.export_to_excel(file_path, search_tab.file_data)
        elif export_format == "html":
            file_path, _ = QFileDialog.getSaveFileName(
                self, "Export to HTML", "", 
                "HTML Files (*.html);;All Files (*)"
            )
            if file_path:
                self.export_to_html(file_path, search_tab.file_data)
        elif export_format == "markdown":
            file_path, _ = QFileDialog.getSaveFileName(
                self, "Export to Markdown", "", 
                "Markdown Files (*.md);;All Files (*)"
            )
            if file_path:
                self.export_to_markdown(file_path, search_tab.file_data)
        else:  # CSV (legacy support)
            file_path, _ = QFileDialog.getSaveFileName(
                self, "Export to CSV", "", 
                "CSV Files (*.csv);;All Files (*)"
            )
            if file_path:
                self.export_to_csv(file_path, search_tab.file_data)

    def export_to_json(self, file_path, file_data):
        """Export data to JSON format"""
        try:
            export_data = {
                "exported_at": time.strftime('%Y-%m-%d %H:%M:%S'),
                "total_files": len(file_data),
                "files": []
            }
            
            for item in file_data:
                name, size, mtime, path = item
                file_info = {
                    "name": name,
                    "size_bytes": size,
                    "size_human": format_size(size),
                    "modified_timestamp": mtime,
                    "modified_date": time.strftime('%Y-%m-%d %H:%M:%S', time.localtime(mtime)),
                    "path": path,
                    "extension": os.path.splitext(name)[1].lower(),
                    "is_directory": os.path.isdir(path)
                }
                export_data["files"].append(file_info)
            
            with open(file_path, 'w', encoding='utf-8') as f:
                json.dump(export_data, f, indent=2, ensure_ascii=False)
                
            # Show success dialog with action buttons
            success_dialog = ExportSuccessDialog(self, file_path, "json")
            success_dialog.exec()
        except Exception as e:
            self.show_critical("❌ Export Error", f"Failed to export JSON: {str(e)}")

    def export_to_excel(self, file_path, file_data):
        """Export data to Excel format"""
        try:
            # Check if openpyxl is available
            try:
                import openpyxl
            except ImportError:
                self.show_critical("❌ Missing Dependency", 
                    "Excel export requires 'openpyxl' library.\nInstall with: pip install openpyxl")
                return
            
            wb = openpyxl.Workbook()
            ws = wb.active
            ws.title = "Search Results"
            
            # Headers
            headers = ['Name', 'Size (Bytes)', 'Size (Human)', 'Modified Date', 'Extension', 'Type', 'Path']
            ws.append(headers)
            
            # Style headers
            for cell in ws[1]:
                cell.font = openpyxl.styles.Font(bold=True)
                cell.fill = openpyxl.styles.PatternFill(start_color="366092", end_color="366092", fill_type="solid")
                cell.font = openpyxl.styles.Font(color="FFFFFF", bold=True)
            
            # Data rows
            for item in file_data:
                name, size, mtime, path = item
                ext = os.path.splitext(name)[1].lower()
                file_type = "Directory" if os.path.isdir(path) else "File"
                modified_date = time.strftime('%Y-%m-%d %H:%M:%S', time.localtime(mtime))
                
                ws.append([name, size, format_size(size), modified_date, ext, file_type, path])
            
            # Auto-adjust column widths
            for column in ws.columns:
                max_length = 0
                column_letter = column[0].column_letter
                for cell in column:
                    try:
                        if len(str(cell.value)) > max_length:
                            max_length = len(str(cell.value))
                    except Exception:
                        pass
                adjusted_width = min(max_length + 2, 50)  # Max width of 50
                ws.column_dimensions[column_letter].width = adjusted_width
            
            wb.save(file_path)
            # Show success dialog with action buttons
            success_dialog = ExportSuccessDialog(self, file_path, "excel")
            success_dialog.exec()
        except Exception as e:
            self.show_critical("❌ Export Error", f"Failed to export Excel: {str(e)}")

    def export_to_html(self, file_path, file_data):
        """Export data to HTML format"""
        try:
            html_content = f'''<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Search Results - Everything by mdfind</title>
    <style>
        body {{
            font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif;
            margin: 20px;
            background-color: #f5f5f7;
        }}
        .container {{
            max-width: 1200px;
            margin: 0 auto;
            background: white;
            border-radius: 12px;
            box-shadow: 0 4px 20px rgba(0,0,0,0.1);
            overflow: hidden;
        }}
        .header {{
            background: linear-gradient(135deg, #007acc, #005a9e);
            color: white;
            padding: 30px;
            text-align: center;
        }}
        .stats {{
            display: flex;
            justify-content: space-around;
            padding: 20px;
            background: #f8f9fa;
            border-bottom: 1px solid #dee2e6;
        }}
        .stat {{
            text-align: center;
        }}
        .stat-number {{
            font-size: 24px;
            font-weight: bold;
            color: #007acc;
        }}
        .stat-label {{
            color: #6c757d;
            font-size: 14px;
        }}
        table {{
            width: 100%;
            border-collapse: collapse;
        }}
        th, td {{
            padding: 12px 15px;
            text-align: left;
            border-bottom: 1px solid #dee2e6;
        }}
        th {{
            background-color: #f8f9fa;
            font-weight: 600;
            color: #495057;
        }}
        tr:hover {{
            background-color: #f8f9fa;
        }}
        .file-icon {{
            margin-right: 8px;
        }}
        .path {{
            font-family: Monaco, 'Courier New', monospace;
            font-size: 12px;
            color: #6c757d;
            max-width: 300px;
            overflow: hidden;
            text-overflow: ellipsis;
            white-space: nowrap;
        }}
        .footer {{
            text-align: center;
            padding: 20px;
            color: #6c757d;
            font-size: 14px;
        }}
    </style>
</head>
<body>
    <div class="container">
        <div class="header">
            <h1>🔍 Search Results</h1>
            <p>Generated by Everything by mdfind</p>
            <p>{time.strftime('%Y-%m-%d %H:%M:%S')}</p>
        </div>
        
        <div class="stats">
            <div class="stat">
                <div class="stat-number">{len(file_data)}</div>
                <div class="stat-label">Total Files</div>
            </div>
            <div class="stat">
                <div class="stat-number">{sum(1 for item in file_data if os.path.isdir(item[3]))}</div>
                <div class="stat-label">Directories</div>
            </div>
            <div class="stat">
                <div class="stat-number">{format_size(sum(item[1] for item in file_data))}</div>
                <div class="stat-label">Total Size</div>
            </div>
        </div>
        
        <table>
            <thead>
                <tr>
                    <th>📁 Name</th>
                    <th>📊 Size</th>
                    <th>🕒 Modified</th>
                    <th>📍 Path</th>
                </tr>
            </thead>
            <tbody>'''
            
            for item in file_data:
                name, size, mtime, path = item
                is_dir = os.path.isdir(path)
                icon = "📁" if is_dir else "📄"
                ext = os.path.splitext(name)[1].lower()
                
                # Get appropriate emoji for file type
                if not is_dir:
                    icon = self.extension_emoji_map.get(ext, "📄")
                
                size_display = "—" if is_dir else format_size(size)
                modified_date = time.strftime('%Y-%m-%d %H:%M', time.localtime(mtime))
                
                html_content += f'''
                <tr>
                    <td><span class="file-icon">{icon}</span>{name}</td>
                    <td>{size_display}</td>
                    <td>{modified_date}</td>
                    <td class="path" title="{path}">{path}</td>
                </tr>'''
            
            html_content += '''
            </tbody>
        </table>
        
        <div class="footer">
            <p>Generated by <strong>Everything by mdfind</strong> - A powerful file search tool for macOS</p>
        </div>
    </div>
</body>
</html>'''
            
            with open(file_path, 'w', encoding='utf-8') as f:
                f.write(html_content)
                
            # Show success dialog with action buttons
            success_dialog = ExportSuccessDialog(self, file_path, "html")
            success_dialog.exec()
        except Exception as e:
            self.show_critical("❌ Export Error", f"Failed to export HTML: {str(e)}")

    def export_to_markdown(self, file_path, file_data):
        """Export data to Markdown format"""
        try:
            md_content = f'''# 🔍 Search Results

**Generated by Everything by mdfind**  
**Date:** {time.strftime('%Y-%m-%d %H:%M:%S')}  
**Total Files:** {len(file_data)}

## 📊 Statistics

- **Total Files:** {len(file_data)}
- **Directories:** {sum(1 for item in file_data if os.path.isdir(item[3]))}
- **Regular Files:** {sum(1 for item in file_data if not os.path.isdir(item[3]))}
- **Total Size:** {format_size(sum(item[1] for item in file_data))}

## 📋 File List

| Name | Size | Modified | Path |
|------|------|----------|------|
'''
            
            for item in file_data:
                name, size, mtime, path = item
                is_dir = os.path.isdir(path)
                
                # Escape pipe characters for markdown table
                name_escaped = name.replace('|', '\\|')
                path_escaped = path.replace('|', '\\|')
                
                size_display = "—" if is_dir else format_size(size)
                modified_date = time.strftime('%Y-%m-%d %H:%M', time.localtime(mtime))
                
                # Add appropriate emoji
                icon = "📁" if is_dir else self.extension_emoji_map.get(os.path.splitext(name)[1].lower(), "📄")
                
                md_content += f'| {icon} {name_escaped} | {size_display} | {modified_date} | `{path_escaped}` |\n'
            
            md_content += f'''
---

*Generated by [Everything by mdfind](https://github.com/appledragon/everythingByMdfind) - {time.strftime('%Y-%m-%d %H:%M:%S')}*
'''
            
            with open(file_path, 'w', encoding='utf-8') as f:
                f.write(md_content)
                
            # Show success dialog with action buttons
            success_dialog = ExportSuccessDialog(self, file_path, "markdown")
            success_dialog.exec()
        except Exception as e:
            self.show_critical("❌ Export Error", f"Failed to export Markdown: {str(e)}")

    def export_to_csv(self, file_path, file_data):
        """Export data to CSV format (legacy)"""
        try:
            with open(file_path, 'w', newline='', encoding='utf-8') as csvfile:
                writer = csv.writer(csvfile)
                writer.writerow(['Name', 'Size', 'Modification Time', 'Path'])
                for item in file_data:
                    writer.writerow(item)
            # Show success dialog with action buttons
            success_dialog = ExportSuccessDialog(self, file_path, "csv")
            success_dialog.exec()
        except Exception as e:
            self.show_critical("❌ Export Error", f"Failed to export CSV: {str(e)}")

    # ========== Miscellaneous ==========
    def open_in_finder(self):
        path = self.get_selected_file()
        if not path:
            return
        try:
            subprocess.Popen(["open", "-R", path])
        except Exception as e:
            self.show_critical("Error", f"Could not open Finder: {e}")

    def show_spotlight_metadata(self):
        """Show Spotlight metadata for the selected file using mdls"""
        path = self.get_selected_file()
        if not path:
            return
        try:
            result = subprocess.run(
                ["mdls", path],
                capture_output=True, text=True, timeout=10
            )
            output = result.stdout.strip() if result.stdout else "No metadata available."
        except FileNotFoundError:
            self.show_warning("⚠️ Not Available", "mdls is not available on this system (macOS only).")
            return
        except subprocess.TimeoutExpired:
            self.show_warning("⚠️ Timeout", "Metadata query timed out.")
            return
        except Exception as e:
            self.show_critical("Error", f"Failed to get metadata: {e}")
            return

        dialog = QDialog(self)
        dialog.setWindowTitle(f"🔬 Spotlight Metadata — {os.path.basename(path)}")
        dialog.resize(680, 520)

        is_dark = hasattr(self, 'dark_mode') and self.dark_mode
        dialog.setStyleSheet(get_dialog_stylesheet(dark_mode=is_dark))

        layout = QVBoxLayout(dialog)
        layout.setContentsMargins(16, 16, 16, 16)
        layout.setSpacing(10)

        title = QLabel(f"📄 {os.path.basename(path)}")
        title.setStyleSheet("font-size: 16px; font-weight: bold; margin-bottom: 4px;")
        title.setWordWrap(True)
        layout.addWidget(title)

        path_label = QLabel(f"📁 {os.path.dirname(path)}")
        path_label.setStyleSheet("font-size: 11px; color: #888888; margin-bottom: 8px;")
        path_label.setWordWrap(True)
        layout.addWidget(path_label)

        text_edit = QPlainTextEdit()
        text_edit.setPlainText(output)
        text_edit.setReadOnly(True)
        text_edit.setStyleSheet(f"""
            QPlainTextEdit {{
                background-color: {'#1e1e1e' if is_dark else '#f6f8fa'};
                color: {'#d4d4d4' if is_dark else '#24292f'};
                border: 1px solid {'#404040' if is_dark else '#d1d9e0'};
                border-radius: 6px;
                padding: 8px;
                font-family: "Cascadia Code", "Fira Code", "Consolas", monospace;
                font-size: 12px;
            }}
        """)
        layout.addWidget(text_edit, 1)

        btn_layout = QHBoxLayout()
        btn_layout.addStretch()

        copy_btn = QPushButton("📋 Copy")
        copy_btn.clicked.connect(lambda: (
            QApplication.clipboard().setText(output),
            self.show_tooltip("Metadata copied to clipboard!")
        ))
        btn_layout.addWidget(copy_btn)

        close_btn = QPushButton("Close")
        close_btn.clicked.connect(dialog.accept)
        btn_layout.addWidget(close_btn)

        layout.addLayout(btn_layout)
        dialog.exec()

    def select_directory(self):
        current = os.path.expanduser(self.edit_dir.text())
        directory = QFileDialog.getExistingDirectory(self, "Select Directory", current)
        if directory:
            self.edit_dir.setText(directory)
            self.start_search()

    def toggle_preview(self, checked):
        self.preview_container.setVisible(checked)
        if checked and getattr(self, '_chart_overrides_preview', False):
            if hasattr(self, 'preview_stack'):
                self.preview_stack.setVisible(False)
            if hasattr(self, 'media_info'):
                self.media_info.setVisible(False)
        # Save preview state to config
        self.preview_enabled = checked
        cfg = read_config()
        cfg["preview_enabled"] = checked
        write_config(cfg)
    

    
    def update_tab_close_button(self, index):
        """Update close button styling and visibility for a tab"""
        tab_bar = self.tab_widget.tabBar()
        tab = self.search_tabs.get(index)
        
        if tab and tab.is_pinned:
            # Hide close button for pinned tabs
            close_button = tab_bar.tabButton(index, tab_bar.ButtonPosition.RightSide)
            if close_button:
                close_button.hide()
        else:
            # Show close button for unpinned tabs
            close_button = tab_bar.tabButton(index, tab_bar.ButtonPosition.RightSide)
            if close_button:
                close_button.show()
                close_button.setToolTip("Close tab")
                close_button.setText("×")
                    
    def update_all_tab_close_buttons(self):
        """Update all tab close buttons to show clear X"""
        for i in range(self.tab_widget.count()):
            self.update_tab_close_button(i)
    
    def calculate_tab_width(self):
        """Calculate appropriate tab width based on number of tabs and screen size"""
        tab_count = self.tab_widget.count()
        if tab_count == 0:
            return {
                'pinned': 80,
                'unpinned': 240
            }
        
        tab_bar = self.tab_widget.tabBar()
        available_width = tab_bar.width()
        
        # Reserve space for scroll buttons and margins
        reserved_width = 80
        available_width = max(available_width - reserved_width, 200)
        
        # Count pinned and unpinned tabs
        pinned_count = self.get_pinned_count()
        unpinned_count = tab_count - pinned_count
        
        # Pinned tabs get fixed smaller width
        pinned_tab_width = 80
        
        # Calculate width for unpinned tabs
        min_tab_width = 80
        max_tab_width = 240
        
        if unpinned_count > 0:
            # Subtract space used by pinned tabs
            space_for_unpinned = available_width - (pinned_count * pinned_tab_width)
            optimal_width = space_for_unpinned // unpinned_count
            unpinned_tab_width = max(min_tab_width, min(optimal_width, max_tab_width))
        else:
            unpinned_tab_width = max_tab_width
        
        return {
            'pinned': pinned_tab_width,
            'unpinned': unpinned_tab_width
        }
                    
    def update_tab_style(self):
        """Update tab styling based on current theme"""
        tab_widths = self.calculate_tab_width()
        pinned_width = tab_widths['pinned']
        unpinned_width = tab_widths['unpinned']
        
        # Update tab text to show pin icon for pinned tabs
        for i in range(self.tab_widget.count()):
            tab = self.search_tabs.get(i)
            if tab:
                title = tab.tab_title or self.tab_widget.tabText(i).replace("📌 ", "")
                if tab.is_pinned:
                    self.tab_widget.setTabText(i, f"📌 {title}")
                else:
                    self.tab_widget.setTabText(i, title)
        
        if self.dark_mode:
            pane_border, pane_bg = '#3c3c3c', '#2b2b2b'
            tab_bg, tab_fg = '#2b2b2b', '#cccccc'
            sel_bg, sel_fg, sel_top = '#3c3c3c', 'white', '2px'
            hover_bg = '#383838'
        else:
            pane_border, pane_bg = '#c0c0c0', 'white'
            tab_bg, tab_fg = '#f0f0f0', '#333333'
            sel_bg, sel_fg, sel_top = 'white', '#000000', '3px'
            hover_bg = '#e0e0e0'

        self.tab_widget.setStyleSheet(f"""
            QTabWidget::pane {{
                border: 1px solid {pane_border};
                background-color: {pane_bg};
                border-radius: 4px;
            }}
            QTabBar::tab {{
                background-color: {tab_bg};
                color: {tab_fg};
                padding: 8px 12px;
                margin-right: 2px;
                border-top-left-radius: 4px;
                border-top-right-radius: 4px;
                min-width: {unpinned_width}px;
                max-width: {unpinned_width}px;
            }}
            QTabBar::tab:selected {{
                background-color: {sel_bg};
                color: {sel_fg};
                border-top: {sel_top} solid #007acc;
            }}
            QTabBar::tab:hover {{
                background-color: {hover_bg};
            }}
            QTabBar::tab:!selected {{
                margin-top: 2px;
            }}
            QTabBar::tab:first {{
                min-width: {pinned_width}px;
                max-width: {pinned_width}px;
            }}
        """)
        
        # Update all tab close buttons
        self.update_all_tab_close_buttons()
        
    def set_non_dark_mode(self):
        colors = {
            'bg_main': '#ffffff', 'bg_title': '#f6f8fa', 'bg_alt': '#f6f8fa',
            'bg_input': '#ffffff',
            'fg_main': '#24292f', 'heading_color': '#24292f',
            'accent': '#0969da', 'accent_hover': '#1f7bd3', 'accent_pressed': '#0550ae',
            'btn_start': '#2ea043', 'btn_end': '#238636', 'btn_border': '#1a7f37',
            'btn_hover_start': '#2c974b', 'btn_hover_end': '#1f883d', 'btn_hover_border': '#1a7f37',
            'btn_pressed_start': '#238636', 'btn_pressed_end': '#196c2e',
            'border': '#d1d9e0', 'border_hover': '#8c959f',
            'selection': '#dbeafe', 'selection_alt': '#bfdbfe', 'selection_text': '#1e40af',
            'border_rgba': '0, 0, 0, 0.02', 'border_rgba_item': '0, 0, 0, 0.05',
            'accent_rgba': '0, 0, 0, 0.1',
            'items_found_color': '#656d76',
            'close_rgba': '220, 53, 69, 0.2', 'close_color': '#e24d5a', 'close_pressed': '#b92f3c',
            'tab_hover': '#e0e0e0', 'close_rgba_pressed': '220, 53, 69, 0.3',
            'disabled_bg': '#f6f8fa', 'disabled_fg': '#8c959f', 'disabled_border': '#d1d9e0',
            'toolbutton_hover_border': '#d1d9e0',
        }
        self.setStyleSheet(self._get_theme_stylesheet(colors))
        if hasattr(self, 'tab_widget'):
            self.update_tab_style()
        self._update_scan_chart_theme()
    
    def set_dark_mode(self):
        colors = {
            'bg_main': '#181818', 'bg_title': '#2d2d30', 'bg_alt': '#1e1e1e',
            'bg_input': '#252526',
            'fg_main': '#d4d4d4', 'heading_color': '#e1e4e8',
            'accent': '#007fd4', 'accent_hover': '#2196f3', 'accent_pressed': '#005a9e',
            'btn_start': '#0e4775', 'btn_end': '#0a3d66', 'btn_border': '#1177bb',
            'btn_hover_start': '#1177bb', 'btn_hover_end': '#0e639c', 'btn_hover_border': '#2196f3',
            'btn_pressed_start': '#083d5c', 'btn_pressed_end': '#062d43',
            'border': '#404040', 'border_hover': '#505050',
            'selection': '#264f78', 'selection_alt': '#1e3a5f', 'selection_text': 'white',
            'border_rgba': '255, 255, 255, 0.02', 'border_rgba_item': '255, 255, 255, 0.05',
            'accent_rgba': '255, 255, 255, 0.1',
            'items_found_color': '#8b949e',
            'close_rgba': '220, 53, 69, 0.2', 'close_color': '#d3414f', 'close_pressed': '#9b2a35',
            'tab_hover': '#4a4a4a', 'close_rgba_pressed': '220, 53, 69, 0.3',
            'scrollbar_handle': '#555555', 'scrollbar_handle_hover': '#666666',
            'disabled_bg': '#404040', 'disabled_fg': '#858585', 'disabled_border': '#5a5a5a',
            'toolbutton_hover_border': '#505050',
            'tree_bg': '#252526', 'lineedit_focus_bg': '#1e1e1e',
            'selection_input': '#0078d4',
            'tree_hover_rgba': '255, 255, 255, 0.08',
        }
        self.setStyleSheet(self._get_theme_stylesheet(colors))
        if hasattr(self, 'tab_widget'):
            self.update_tab_style()
        self._update_scan_chart_theme()


    def setup_custom_titlebar(self):
        """Setup custom titlebar theming support"""
        import sys
        
        # Enable custom titlebar on macOS
        if sys.platform == "darwin":
            self.setUnifiedTitleAndToolBarOnMac(True)
        
        # Set window attributes for better theming support
        self.setAttribute(Qt.WidgetAttribute.WA_TranslucentBackground, False)
        
        # Enable dark mode detection and theming
        if sys.platform == "win32":
            try:
                # Import Windows API for titlebar theming
                import ctypes
                from ctypes import wintypes, windll
                
                # Store the window handle for later use
                self.hwnd = int(self.winId())
                
                # Enable DWM window attributes
                windll.user32.SetWindowPos(
                    self.hwnd, 0, 0, 0, 0, 0,
                    0x0001 | 0x0002 | 0x0020  # SWP_NOSIZE | SWP_NOMOVE | SWP_FRAMECHANGED
                )
            except Exception as e:
                print(f"Warning: Could not setup Windows titlebar theming: {e}")
                self.hwnd = None

    def update_titlebar_for_theme(self):
        """Update system titlebar appearance based on current theme"""
        import sys
        
        # Determine if current theme is dark or light
        is_dark_theme = self.dark_mode
        
        try:
            if sys.platform == "win32":
                # Windows 10/11 native dark titlebar support
                self.apply_windows_titlebar_theme(is_dark_theme)
            elif sys.platform == "darwin":
                # macOS native appearance support
                self.apply_macos_titlebar_theme(is_dark_theme)
            else:
                # Linux/other platforms - use Qt styling
                self.apply_qt_titlebar_theme()
                
        except Exception as e:
            print(f"Warning: Could not apply titlebar theme: {e}")
            # Fallback: update window title to show current theme
            self.update_window_title_fallback()

    def apply_windows_titlebar_theme(self, is_dark):
        """Apply Windows 10/11 native titlebar theming"""
        try:
            import ctypes
            from ctypes import wintypes, windll, byref, sizeof, c_bool
            
            hwnd = int(self.winId())
            
            # DWMWA_USE_IMMERSIVE_DARK_MODE (20) for Windows 11
            # DWMWA_USE_IMMERSIVE_DARK_MODE_BEFORE_20H1 (19) for older Windows 10
            
            # Try Windows 11 attribute first
            success = False
            try:
                result = windll.dwmapi.DwmSetWindowAttribute(
                    hwnd, 20, byref(c_bool(is_dark)), sizeof(c_bool)
                )
                success = (result == 0)
            except Exception:
                pass
            
            # If Windows 11 method failed, try older Windows 10 method
            if not success:
                try:
                    windll.dwmapi.DwmSetWindowAttribute(
                        hwnd, 19, byref(c_bool(is_dark)), sizeof(c_bool)
                    )
                except Exception:
                    pass
            
            # Also try to set the window caption color (Windows 11+)
            try:
                # Get theme colors
                if is_dark:
                    # Dark theme colors
                    if self.theme_mode == 'tokyo_night':
                        caption_color = 0x3b2824  # #24283b in BGR format
                    elif self.theme_mode == 'tokyo_night_storm':
                        caption_color = 0x3a2e2a  # #2a2e3a in BGR format
                    elif self.theme_mode == 'chinolor_dark':
                        caption_color = 0x3b3b3b  # #3b3b3b in BGR format
                    else:
                        caption_color = 0x302d2d  # #2d2d30 in BGR format (default dark)
                else:
                    # Light theme colors
                    if self.theme_mode == 'chinolor_light':
                        caption_color = 0xf2f4f5  # #f5f4f2 in BGR format
                    else:
                        caption_color = 0xfaf8f6  # #f6f8fa in BGR format (default light)
                
                # DWMWA_CAPTION_COLOR (35) - Windows 11 22H2+
                windll.dwmapi.DwmSetWindowAttribute(
                    hwnd, 35, byref(wintypes.DWORD(caption_color)), sizeof(wintypes.DWORD)
                )
            except Exception:
                pass  # Caption color setting not supported on this Windows version
                
        except Exception as e:
            print(f"Windows titlebar theming failed: {e}")

    def apply_macos_titlebar_theme(self, is_dark):
        """Apply macOS native titlebar theming"""
        try:
            # Apply the appearance through unified titlebar setting
            self.setUnifiedTitleAndToolBarOnMac(True)
        except Exception as e:
            print(f"macOS titlebar theming failed: {e}")

    def apply_qt_titlebar_theme(self):
        """Apply Qt-based titlebar theming for other platforms"""
        # For Linux and other platforms, we can style the window frame
        try:
            # Set window properties that might affect the titlebar
            if self.dark_mode:
                self.setProperty("darkMode", True)
            else:
                self.setProperty("darkMode", False)
            
            # Force style update
            self.style().unpolish(self)
            self.style().polish(self)
            
        except Exception as e:
            print(f"Qt titlebar theming failed: {e}")

    def update_window_title_fallback(self):
        """Fallback method: update window title to show current theme"""
        base_title = "Everything by mdfind"
        theme_display = self.theme_mode.replace('_', ' ').title()
        self.setWindowTitle(f"{base_title} - {theme_display} Theme")

    def apply_current_theme(self):
        """Apply the currently selected theme"""
        if self.theme_mode == 'light':
            self.set_non_dark_mode()
        elif self.theme_mode == 'dark':
            self.set_dark_mode()
        elif self.theme_mode == 'tokyo_night':
            self.set_tokyo_night_mode()
        elif self.theme_mode == 'tokyo_night_storm':
            self.set_tokyo_night_storm_mode()
        elif self.theme_mode == 'chinolor_dark':
            self.set_chinolor_dark_mode()
        elif self.theme_mode == 'chinolor_light':
            self.set_chinolor_light_mode()
        
        # Update titlebar to match the applied theme
        self.update_titlebar_for_theme()
        self._update_scan_chart_theme()

    def set_theme(self, theme_mode):
        """Set the theme mode and apply it"""
        self.theme_mode = theme_mode
        self.dark_mode = theme_mode in ["dark", "tokyo_night", "tokyo_night_storm", "chinolor_dark"]
        
        # Apply the theme
        self.apply_current_theme()
        
        # Update tab widget style
        if hasattr(self, 'update_tab_style'):
            self.update_tab_style()
        
        # Update standalone player theme
        if hasattr(self, 'standalone_player'):
            self.standalone_player.set_dark_mode(self.dark_mode)
        
        # Save theme to config
        cfg = read_config()
        cfg["theme_mode"] = theme_mode
        cfg["dark_mode"] = self.dark_mode  # Keep for backward compatibility
        write_config(cfg)

    def _get_theme_stylesheet(self, raw_colors):
        """Generate stylesheet from color dictionary.
        Supports optional override keys with defaults for flexible theming.
        """
        c = dict(raw_colors)
        # Defaults for optional keys - existing themes don't need to specify these
        c.setdefault('heading_color', c['accent'])
        c.setdefault('bg_input', c['bg_alt'])
        c.setdefault('btn_start', c['accent'])
        c.setdefault('btn_end', c['accent_pressed'])
        c.setdefault('btn_border', c['accent'])
        c.setdefault('btn_hover_start', c['accent_hover'])
        c.setdefault('btn_hover_end', c['accent'])
        c.setdefault('btn_hover_border', c['accent_hover'])
        c.setdefault('btn_pressed_start', c['accent_pressed'])
        c.setdefault('btn_pressed_end', c['border'])
        c.setdefault('scrollbar_handle', c['border'])
        c.setdefault('scrollbar_handle_hover', c['border_hover'])
        c.setdefault('disabled_bg', c['bg_alt'])
        c.setdefault('disabled_fg', c['border_hover'])
        c.setdefault('disabled_border', c['border'])
        c.setdefault('toolbutton_hover_border', c['border_hover'])
        c.setdefault('tree_bg', c['bg_input'])
        c.setdefault('lineedit_focus_bg', c['bg_alt'])
        c.setdefault('selection_input', c['accent'])
        c.setdefault('tree_hover_rgba', c['accent_rgba'])
        return f"""
            QMainWindow {{
                background-color: {c['bg_main']};
                color: {c['fg_main']};
                font-family: "Segoe UI", "SF Pro Display", system-ui, sans-serif;
                font-size: 13px;
            }}
            QMainWindow::title {{
                background-color: {c['bg_title']};
                color: {c['fg_main']};
                padding: 8px;
                font-weight: 600;
            }}
            QWidget {{
                background-color: {c['bg_main']};
                color: {c['fg_main']};
            }}
            QLabel, QCheckBox {{
                color: {c['fg_main']};
                background: transparent;
                font-size: 13px;
                font-weight: 400;
            }}
            QGroupBox {{
                color: {c['heading_color']};
                border: 1px solid {c['border']};
                border-radius: 8px;
                margin: 12px 0px;
                padding-top: 16px;
                font-weight: 600;
                background-color: rgba({c['border_rgba']});
            }}
            QGroupBox::title {{
                subcontrol-origin: margin;
                left: 12px;
                padding: 0 8px 0 8px;
                background: {c['bg_main']};
                color: {c['heading_color']};
            }}
            QPushButton {{
                background: qlineargradient(x1: 0, y1: 0, x2: 0, y2: 1,
                    stop: 0 {c['btn_start']}, stop: 1 {c['btn_end']});
                border: 1px solid {c['btn_border']};
                border-radius: 6px;
                padding: 10px 18px;
                color: white;
                font-weight: 600;
                min-height: 22px;
                font-size: 13px;
            }}
            QPushButton:hover {{
                background: qlineargradient(x1: 0, y1: 0, x2: 0, y2: 1,
                    stop: 0 {c['btn_hover_start']}, stop: 1 {c['btn_hover_end']});
                border-color: {c['btn_hover_border']};
            }}
            QPushButton:pressed {{
                background: qlineargradient(x1: 0, y1: 0, x2: 0, y2: 1,
                    stop: 0 {c['btn_pressed_start']}, stop: 1 {c['btn_pressed_end']});
            }}
            QPushButton:disabled {{
                background-color: {c['disabled_bg']};
                color: {c['disabled_fg']};
                border-color: {c['disabled_border']};
            }}
            QLineEdit {{
                border: 2px solid {c['border']};
                padding: 8px 12px;
                border-radius: 6px;
                background-color: {c['bg_input']};
                color: {c['fg_main']};
                selection-background-color: {c['selection_input']};
                selection-color: white;
                font-size: 13px;
                min-height: 18px;
            }}
            QLineEdit:focus {{
                border: 2px solid {c['accent']};
                background-color: {c['lineedit_focus_bg']};
            }}
            QLineEdit:hover {{
                border-color: {c['border_hover']};
            }}
            #searchContainer {{
                border: 2px solid {c['border']};
                border-radius: 6px;
                background-color: {c['bg_input']};
            }}
            #searchContainer[focused="true"] {{
                border: 2px solid {c['accent']};
            }}
            #searchContainer QLineEdit {{
                border: none;
                padding: 8px 12px;
                border-radius: 0px;
                background-color: transparent;
                min-height: 18px;
            }}
            #searchContainer QLineEdit:focus {{
                border: none;
                background-color: transparent;
            }}
            #searchContainer QLineEdit:hover {{
                border: none;
            }}
            #searchToggleBtn {{
                background-color: transparent;
                border: 1px solid transparent;
                border-radius: 3px;
                padding: 2px;
                color: {c['fg_main']};
                font-size: 13px;
                font-weight: bold;
                min-width: 24px;
                max-width: 24px;
                min-height: 22px;
                max-height: 22px;
            }}
            #searchToggleBtn:hover {{
                background-color: rgba({c['accent_rgba']});
                border-color: {c['border']};
            }}
            #searchToggleBtn:checked {{
                background-color: {c['accent']};
                color: white;
                border-color: {c['accent']};
            }}
            QPlainTextEdit {{
                background-color: {c['bg_alt']};
                color: {c['fg_main']};
                border: 1px solid {c['border']};
                border-radius: 6px;
                selection-background-color: {c['selection_input']};
                selection-color: white;
                padding: 8px;
                font-family: "Cascadia Code", "Fira Code", "Consolas", monospace;
                line-height: 1.4;
            }}
            QTreeWidget {{
                background-color: {c['tree_bg']};
                color: {c['fg_main']};
                border: 1px solid {c['border']};
                outline: 0;
                selection-background-color: {c['selection']};
                alternate-background-color: {c['bg_alt']};
                border-radius: 6px;
                gridline-color: {c['border']};
            }}
            QTreeWidget::item {{
                padding: 6px 8px;
                border: none;
                border-bottom: 1px solid rgba({c['border_rgba_item']});
            }}
            QTreeWidget::item:hover {{
                background-color: rgba({c['tree_hover_rgba']});
            }}
            QTreeWidget::item:selected {{
                background: qlineargradient(x1: 0, y1: 0, x2: 1, y2: 0,
                    stop: 0 {c['selection']}, stop: 1 {c['selection_alt']});
                color: {c['selection_text']};
                border-radius: 3px;
            }}
            QHeaderView::section {{
                background: qlineargradient(x1: 0, y1: 0, x2: 0, y2: 1,
                    stop: 0 {c['bg_title']}, stop: 1 {c['bg_main']});
                color: {c['heading_color']};
                border: none;
                border-right: 1px solid {c['border']};
                padding: 8px 12px;
                font-weight: 600;
                font-size: 12px;
            }}
            QHeaderView::section:hover {{
                background-color: {c['border']};
            }}
            QSplitter::handle {{
                background-color: {c['border']};
                margin: 2px;
                border-radius: 2px;
            }}
            QSplitter::handle:hover {{
                background-color: {c['accent']};
            }}
            QSplitter::handle:horizontal {{
                width: 6px;
            }}
            QSplitter::handle:vertical {{
                height: 6px;
            }}
            QToolButton {{
                background-color: transparent;
                border: 1px solid transparent;
                border-radius: 6px;
                padding: 8px;
                color: {c['fg_main']};
                min-width: 20px;
                min-height: 20px;
            }}
            QToolButton:hover {{
                background-color: rgba({c['accent_rgba']});
                border-color: {c['toolbutton_hover_border']};
            }}
            QToolButton:pressed {{
                background-color: {c['selection']};
            }}
            QSlider::groove:horizontal {{
                border: none;
                height: 6px;
                background-color: {c['border']};
                border-radius: 3px;
            }}
            QSlider::handle:horizontal {{
                background: qlineargradient(x1: 0, y1: 0, x2: 0, y2: 1,
                    stop: 0 {c['accent']}, stop: 1 {c['accent_pressed']});
                border: 1px solid {c['accent']};
                width: 18px;
                margin: -6px 0;
                border-radius: 9px;
            }}
            QSlider::handle:horizontal:hover {{
                background: qlineargradient(x1: 0, y1: 0, x2: 0, y2: 1,
                    stop: 0 {c['accent_hover']}, stop: 1 {c['accent']});
            }}
            QSlider::add-page:horizontal {{
                background-color: {c['border']};
                border-radius: 3px;
            }}
            QSlider::sub-page:horizontal {{
                background: qlineargradient(x1: 0, y1: 0, x2: 1, y2: 0,
                    stop: 0 {c['accent']}, stop: 1 {c['accent_pressed']});
                border-radius: 3px;
            }}
            QProgressBar {{
                background-color: {c['border']};
                border: none;
                border-radius: 4px;
                text-align: center;
                color: {c['fg_main']};
                height: 10px;
            }}
            QProgressBar::chunk {{
                background: qlineargradient(x1: 0, y1: 0, x2: 1, y2: 0,
                    stop: 0 {c['accent']}, stop: 1 {c['accent_pressed']});
                border-radius: 4px;
            }}
            QMenuBar {{
                background: qlineargradient(x1: 0, y1: 0, x2: 0, y2: 1,
                    stop: 0 {c['bg_title']}, stop: 1 {c['bg_main']});
                color: {c['fg_main']};
                border-bottom: 1px solid {c['border']};
                padding: 2px;
            }}
            QMenuBar::item {{
                background: transparent;
                padding: 8px 16px;
                border-radius: 4px;
            }}
            QMenuBar::item:selected {{
                background-color: rgba({c['accent_rgba']});
            }}
            QMenu {{
                background-color: {c['bg_title']};
                color: {c['fg_main']};
                border: 1px solid {c['border']};
                border-radius: 6px;
                padding: 4px 0;
            }}
            QMenu::item {{
                padding: 8px 20px;
                border-radius: 4px;
                margin: 2px 6px;
            }}
            QMenu::item:selected {{
                background-color: {c['selection']};
            }}
            QMenu::separator {{
                height: 1px;
                background-color: {c['border']};
                margin: 4px 8px;
            }}
            QCheckBox::indicator {{
                width: 16px;
                height: 16px;
                border: 2px solid {c['border']};
                border-radius: 3px;
                background-color: {c['bg_main']};
            }}
            QCheckBox::indicator:hover {{
                border-color: {c['accent']};
            }}
            QCheckBox::indicator:checked {{
                background-color: {c['accent']};
                border-color: {c['accent']};
            }}
            #queryLabel, #directoryLabel {{
                font-weight: 600;
                color: {c['heading_color']};
                padding: 4px 0;
            }}
            #itemsFoundLabel {{
                color: {c['items_found_color']};
                font-size: 12px;
                font-weight: 500;
                padding: 4px 8px;
                background-color: rgba({c['accent_rgba']});
                border-radius: 4px;
            }}
            #previewTitle {{
                font-size: 16px;
                font-weight: 700;
                color: {c['heading_color']};
                padding: 8px 0;
                border-bottom: 2px solid {c['accent']};
                margin-bottom: 8px;
            }}
            #leftContainer {{
                background-color: {c['bg_main']};
                border-right: 1px solid {c['border']};
            }}
            #previewContainer {{
                background-color: {c['bg_alt']};
                border-left: 1px solid {c['border']};
            }}
            #mainSplitter {{
                background-color: {c['bg_main']};
            }}
            #mainSplitter::handle {{
                background-color: {c['border']};
                border: 1px solid {c['border_hover']};
                margin: 4px;
                border-radius: 3px;
            }}
            #mainSplitter::handle:hover {{
                background-color: {c['accent']};
            }}
            #mainSplitter::handle:horizontal {{
                width: 8px;
            }}
            QListView {{
                background-color: {c['bg_title']};
                color: {c['fg_main']};
                border: 1px solid {c['border']};
                border-radius: 6px;
                padding: 4px;
                selection-background-color: {c['selection']};
                outline: 0;
            }}
            QListView::item {{
                padding: 8px 12px;
                border: none;
                border-radius: 4px;
                margin: 2px;
            }}
            QListView::item:hover {{
                background-color: rgba({c['accent_rgba']});
            }}
            QListView::item:selected {{
                background-color: {c['selection']};
                color: {c['selection_alt']};
            }}
            QScrollBar:vertical {{
                background-color: {c['bg_title']};
                width: 14px;
                margin: 0;
                border-radius: 7px;
            }}
            QScrollBar::handle:vertical {{
                background-color: {c['scrollbar_handle']};
                border-radius: 7px;
                min-height: 20px;
                margin: 2px;
            }}
            QScrollBar::handle:vertical:hover {{
                background-color: {c['scrollbar_handle_hover']};
            }}
            QScrollBar::add-line:vertical, QScrollBar::sub-line:vertical {{
                height: 0px;
            }}
            QScrollBar:horizontal {{
                background-color: {c['bg_title']};
                height: 14px;
                margin: 0;
                border-radius: 7px;
            }}
            QScrollBar::handle:horizontal {{
                background-color: {c['scrollbar_handle']};
                border-radius: 7px;
                min-width: 20px;
                margin: 2px;
            }}
            QScrollBar::handle:horizontal:hover {{
                background-color: {c['scrollbar_handle_hover']};
            }}
            QScrollBar::add-line:horizontal, QScrollBar::sub-line:horizontal {{
                width: 0px;
            }}
            QToolTip {{
                background-color: {c['bg_title']};
                color: {c['fg_main']};
                border: 1px solid {c['border']};
                border-radius: 4px;
                padding: 6px 8px;
                font-size: 12px;
            }}
            #previewPopoutButton {{
                background: qlineargradient(x1: 0, y1: 0, x2: 0, y2: 1,
                    stop: 0 {c['accent_hover']}, stop: 1 {c['accent']});
                border: 1px solid {c['accent']};
                border-radius: 6px;
                color: white;
                font-size: 13px;
                font-weight: 600;
                padding: 8px 18px;
                min-height: 26px;
            }}
            #previewPopoutButton:hover {{
                background: qlineargradient(x1: 0, y1: 0, x2: 0, y2: 1,
                    stop: 0 {c['accent_hover']}, stop: 1 {c['accent_hover']});
                border-color: {c['accent_hover']};
            }}
            #previewPopoutButton:pressed {{
                background: qlineargradient(x1: 0, y1: 0, x2: 0, y2: 1,
                    stop: 0 {c['accent_pressed']}, stop: 1 {c['accent']});
            }}
            #previewCloseButton {{
                background: qlineargradient(x1: 0, y1: 0, x2: 0, y2: 1,
                    stop: 0 {c['close_color']}, stop: 1 {c['close_pressed']});
                border: 1px solid {c['close_pressed']};
                border-radius: 6px;
                color: white;
                font-size: 13px;
                font-weight: 600;
                padding: 8px 18px;
                min-height: 26px;
            }}
            #previewCloseButton:hover {{
                background: qlineargradient(x1: 0, y1: 0, x2: 0, y2: 1,
                    stop: 0 {c['close_color']}, stop: 1 {c['close_color']});
                border-color: {c['close_color']};
            }}
            #previewCloseButton:pressed {{
                background: qlineargradient(x1: 0, y1: 0, x2: 0, y2: 1,
                    stop: 0 {c['close_pressed']}, stop: 1 {c['close_pressed']});
            }}
            QTabWidget::pane {{
                border: 1px solid {c['border']};
                background: {c['bg_main']};
            }}
            QTabBar {{
                alignment: left;
            }}
            QTabBar::tab {{
                background: {c['bg_title']};
                border: 1px solid {c['border']};
                border-bottom: none;
                border-top: 2px solid transparent;
                padding: 6px 12px 8px 12px;
                margin-right: 2px;
                min-width: 120px;
                max-width: 200px;
                color: {c['fg_main']};
            }}
            QTabBar::tab:selected {{
                background: {c['bg_main']};
                border-color: {c['border']};
                border-top: 2px solid {c['accent']};
            }}
            QTabBar::tab:hover {{
                background: {c['tab_hover']};
                border-top: 2px solid {c['accent_hover']};
            }}
            QTabBar::tab:hover:selected {{
                border-top: 2px solid {c['accent']};
            }}
            QTabBar QToolButton {{
                background: rgba({c['accent_rgba']});
                border: 1px solid {c['border']};
                border-radius: 4px;
                color: {c['fg_main']};
                font-size: 16px;
                font-weight: bold;
                min-width: 18px;
                min-height: 18px;
                max-width: 18px;
                max-height: 18px;
                margin: 2px;
            }}
            QTabBar QToolButton:hover {{
                background: rgba({c['close_rgba']});
                color: {c['close_color']};
                border: 1px solid {c['close_color']};
            }}
            QTabBar QToolButton:pressed {{
                background: rgba({c['close_rgba_pressed']});
                color: {c['close_color']};
            }}
        """

    def set_tokyo_night_mode(self):
        """Set Tokyo Night theme"""
        colors = {
            'bg_main': '#1a1b26',
            'bg_title': '#24283b',
            'bg_alt': '#16161e',
            'fg_main': '#c0caf5',
            'accent': '#7aa2f7',
            'accent_hover': '#7dcfff',
            'accent_pressed': '#565f89',
            'border': '#414868',
            'border_hover': '#565f89',
            'selection': '#283457',
            'selection_alt': '#414868',
            'selection_text': '#7dcfff',
            'border_rgba': '65, 72, 104, 0.1',
            'border_rgba_item': '65, 72, 104, 0.3',
            'accent_rgba': '122, 162, 247, 0.1',
            'items_found_color': '#9aa5ce',
            'close_rgba': '247, 118, 142, 0.2',
            'close_color': '#f7768e',
            'close_pressed': '#e06c75',
            'tab_hover': '#2a2e3a',
            'close_rgba_pressed': '247, 118, 142, 0.4'
        }
        self.setStyleSheet(self._get_theme_stylesheet(colors))
        
        # Update tab widget style if it exists
        if hasattr(self, 'tab_widget'):
            self.update_tab_style()
        self._update_scan_chart_theme()

    def set_tokyo_night_storm_mode(self):
        """Set Tokyo Night Storm theme (darker variant)"""
        colors = {
            'bg_main': '#24283b',
            'bg_title': '#2a2e3a',
            'bg_alt': '#1a1b26',
            'fg_main': '#c0caf5',
            'accent': '#7aa2f7',
            'accent_hover': '#7dcfff',
            'accent_pressed': '#565f89',
            'border': '#414868',
            'border_hover': '#565f89',
            'selection': '#283457',
            'selection_alt': '#414868',
            'selection_text': '#7dcfff',
            'border_rgba': '65, 72, 104, 0.1',
            'border_rgba_item': '65, 72, 104, 0.3',
            'accent_rgba': '122, 162, 247, 0.1',
            'items_found_color': '#9aa5ce',
            'close_rgba': '247, 118, 142, 0.2',
            'close_color': '#f7768e',
            'close_pressed': '#e06c75',
            'tab_hover': '#32374a',
            'close_rgba_pressed': '247, 118, 142, 0.4'
        }
        self.setStyleSheet(self._get_theme_stylesheet(colors))
        
        # Update tab widget style if it exists
        if hasattr(self, 'tab_widget'):
            self.update_tab_style()
        self._update_scan_chart_theme()

    def set_chinolor_dark_mode(self):
        """Set Chinolor Dark theme (Chinese traditional colors - dark variant)"""
        colors = {
            'bg_main': '#2b2b2b', 'bg_title': '#3b3b3b', 'bg_alt': '#1e1e1e',
            'bg_input': '#1e1e1e',
            'fg_main': '#e4dfd7', 'heading_color': '#d19c97',
            'accent': '#8abcd1', 'accent_hover': '#9bc7d6', 'accent_pressed': '#5f8ca3',
            'btn_start': '#8abcd1', 'btn_end': '#5f8ca3', 'btn_border': '#8abcd1',
            'btn_hover_start': '#9bc7d6', 'btn_hover_end': '#8abcd1', 'btn_hover_border': '#9bc7d6',
            'btn_pressed_start': '#5f8ca3', 'btn_pressed_end': '#4a4a4a',
            'border': '#4a4a4a', 'border_hover': '#6a6a6a',
            'selection': '#5dbe8a', 'selection_alt': '#4a9d6f', 'selection_text': 'white',
            'border_rgba': '74, 74, 74, 0.1', 'border_rgba_item': '74, 74, 74, 0.3',
            'accent_rgba': '138, 188, 193, 0.2',
            'items_found_color': '#b5a895',
            'close_rgba': '209, 156, 151, 0.3', 'close_color': '#d19c97', 'close_pressed': '#b5857f',
            'tab_hover': '#4a4a4a', 'close_rgba_pressed': '209, 156, 151, 0.4',
            'scrollbar_handle': '#4a4a4a', 'scrollbar_handle_hover': '#6a6a6a',
            'disabled_bg': '#4a4a4a', 'disabled_fg': '#6a6a6a', 'disabled_border': '#4a4a4a',
            'toolbutton_hover_border': '#8abcd1',
            'selection_input': '#5dbe8a',
        }
        self.setStyleSheet(self._get_theme_stylesheet(colors))
        if hasattr(self, 'tab_widget'):
            self.update_tab_style()
        self._update_scan_chart_theme()

    def set_chinolor_light_mode(self):
        """Set Chinolor Light theme (Chinese traditional colors - light variant)"""
        colors = {
            'bg_main': '#faf9f7',
            'bg_title': '#f5f4f2',
            'bg_alt': 'white',
            'fg_main': '#2b312c',
            'accent': '#1781b5',
            'accent_hover': '#2091c5',
            'accent_pressed': '#145a8a',
            'border': '#d4d0c8',
            'border_hover': '#b4b0a8',
            'selection': '#207f4c',
            'selection_alt': '#1a6b3f',
            'selection_text': 'white',
            'border_rgba': '212, 208, 200, 0.1',
            'border_rgba_item': '212, 208, 200, 0.5',
            'accent_rgba': '23, 129, 181, 0.1',
            'items_found_color': '#5a6055',
            'close_rgba': '192, 62, 62, 0.2',
            'close_color': '#c03e3e',
            'close_pressed': '#a03333',
            'tab_hover': '#e5e2da',
            'close_rgba_pressed': '192, 62, 62, 0.4'
        }
        self.setStyleSheet(self._get_theme_stylesheet(colors))
        
        # Update tab widget style if it exists
        if hasattr(self, 'tab_widget'):
            self.update_tab_style()
        self._update_scan_chart_theme()

    def toggle_history(self, checked):
        self.history_enabled = checked
        cfg = read_config()
        cfg["history_enabled"] = checked
        write_config(cfg)
        
    def show_about_dialog(self):
        about_text = """
<h2>Everything by mdfind</h2>
<p>A powerful file search tool for macOS that leverages the Spotlight engine.</p>
<p><b>Version:</b> 1.4.3</p>
<p><b>Author:</b> Apple Dragon</p>
"""
        QMessageBox.about(self, "About Everything by mdfind", about_text)

    def clear_history(self):
        reply = self.show_question(
            "🧹 Clear History",
            "Are you sure you want to clear your search history?",
            QMessageBox.StandardButton.Yes | QMessageBox.StandardButton.No
        )
        if reply == QMessageBox.StandardButton.Yes:
            self.query_history = []
            cfg = read_config()
            cfg["query_history"] = self.query_history
            write_config(cfg)
            self.query_completer.model().setStringList(self.query_history)
            self.show_info("🧹 History Cleared", "Search history cleared.")
    
    def create_dialog_icon(self, emoji, color):
        """Create a colored icon pixmap for dialog boxes"""
        pixmap = QPixmap(64, 64)
        pixmap.fill(Qt.GlobalColor.transparent)
        
        painter = QPainter(pixmap)
        painter.setRenderHint(QPainter.RenderHint.Antialiasing)
        
        # Draw emoji with larger font
        font = QFont()
        font.setPointSize(48)
        painter.setFont(font)
        painter.setPen(QColor(color))
        painter.drawText(pixmap.rect(), Qt.AlignmentFlag.AlignCenter, emoji)
        
        painter.end()
        return pixmap

    def apply_dialog_dark_mode(self, dialog):
        """Apply modern styling to dialog boxes based on current theme"""
        if self.dark_mode:
            dialog.setStyleSheet("""
                QDialog, QMessageBox, QInputDialog, QProgressDialog {
                    background-color: #2d2d30;
                    color: #d4d4d4;
                    border: 1px solid #404040;
                    border-radius: 8px;
                }
                QLabel {
                    color: #d4d4d4;
                    font-size: 13px;
                    padding: 8px;
                }
                QLineEdit {
                    background-color: #1e1e1e;
                    color: #d4d4d4;
                    border: 1px solid #555555;
                    border-radius: 4px;
                    padding: 8px;
                    selection-background-color: #264f78;
                    selection-color: #ffffff;
                }
                QLineEdit:focus {
                    border: 1px solid #1177bb;
                    background-color: #252525;
                }
                QProgressDialog QLabel {
                    margin-bottom: 8px;
                }
                QProgressDialog QProgressBar {
                    min-height: 24px;
                    border-radius: 6px;
                    margin-top: 0px;
                    margin-bottom: 50px;
                }
                QPushButton {
                    background: qlineargradient(x1: 0, y1: 0, x2: 0, y2: 1,
                        stop: 0 #0e4775, stop: 1 #0a3d66);
                    border: 1px solid #1177bb;
                    border-radius: 6px;
                    padding: 10px 20px;
                    color: white;
                    font-weight: 600;
                    min-width: 80px;
                }
                QPushButton:hover {
                    background: qlineargradient(x1: 0, y1: 0, x2: 0, y2: 1,
                        stop: 0 #1177bb, stop: 1 #0e639c);
                    border-color: #2196f3;
                }
                QPushButton:pressed {
                    background: qlineargradient(x1: 0, y1: 0, x2: 0, y2: 1,
                        stop: 0 #083d5c, stop: 1 #062d43);
                }
                QProgressDialog QPushButton {
                    margin-top: 18px;
                    padding: 6px 16px;
                    min-width: 110px;
                }
                QMessageBox QLabel#qt_msgbox_label {
                    color: #d4d4d4;
                }
                QMessageBox QLabel#qt_msgboxex_icon_label {
                    background-color: transparent;
                }
            """)
            
            # Fix icon visibility in dark mode by using a text-based icon instead
            if isinstance(dialog, QMessageBox):
                icon_type = dialog.icon()
                # Create a custom colored pixmap for better visibility in dark mode
                if icon_type == QMessageBox.Icon.Question:
                    # Use a custom question icon with better visibility
                    dialog.setIconPixmap(self.create_dialog_icon("❓", "#4a9eff"))
                elif icon_type == QMessageBox.Icon.Warning:
                    dialog.setIconPixmap(self.create_dialog_icon("⚠️", "#ffcc00"))
                elif icon_type == QMessageBox.Icon.Critical:
                    dialog.setIconPixmap(self.create_dialog_icon("❌", "#ff4444"))
                elif icon_type == QMessageBox.Icon.Information:
                    dialog.setIconPixmap(self.create_dialog_icon("ℹ️", "#4a9eff"))
        else:
            dialog.setStyleSheet("""
                QDialog, QMessageBox, QInputDialog, QProgressDialog {
                    background-color: #ffffff;
                    color: #24292f;
                    border: 1px solid #d1d9e0;
                    border-radius: 8px;
                }
                QLabel {
                    color: #24292f;
                    font-size: 13px;
                    padding: 8px;
                }
                QLineEdit {
                    background-color: #ffffff;
                    color: #24292f;
                    border: 1px solid #d1d9e0;
                    border-radius: 4px;
                    padding: 8px;
                    selection-background-color: #0969da;
                    selection-color: #ffffff;
                }
                QLineEdit:focus {
                    border: 1px solid #0969da;
                    background-color: #f6f8fa;
                }
                QProgressDialog QLabel {
                    margin-bottom: 8px;
                }
                QProgressDialog QProgressBar {
                    min-height: 24px;
                    border-radius: 6px;
                    margin-top: 0px;
                    margin-bottom: 50px;
                }
                QPushButton {
                    background: qlineargradient(x1: 0, y1: 0, x2: 0, y2: 1,
                        stop: 0 #2ea043, stop: 1 #238636);
                    border: 1px solid #1a7f37;
                    border-radius: 6px;
                    padding: 10px 20px;
                    color: white;
                    font-weight: 600;
                    min-width: 80px;
                }
                QPushButton:hover {
                    background: qlineargradient(x1: 0, y1: 0, x2: 0, y2: 1,
                        stop: 0 #2c974b, stop: 1 #1f883d);
                    border-color: #1a7f37;
                }
                QPushButton:pressed {
                    background: qlineargradient(x1: 0, y1: 0, x2: 0, y2: 1,
                        stop: 0 #238636, stop: 1 #196c2e);
                }
                QProgressDialog QPushButton {
                    margin-top: 18px;
                    padding: 6px 16px;
                    min-width: 110px;
                }
            """)

    def show_info_dialog_with_action(self, title, message, action_button_text="Action", action_callback=None):
        """Show a custom dialog with OK and an optional action button"""
        msg = QMessageBox(self)
        msg.setWindowTitle(title)
        msg.setIcon(QMessageBox.Icon.Information)
        msg.setText(message)
        
        # Add custom buttons
        ok_button = msg.addButton("OK", QMessageBox.ButtonRole.AcceptRole)
        action_button = None
        
        if action_callback is not None:
            action_button = msg.addButton(action_button_text, QMessageBox.ButtonRole.ActionRole)
        
        # Apply dark mode styling
        self.apply_dialog_dark_mode(msg)
        
        # Execute dialog and handle response
        msg.exec()
        
        # Check which button was clicked and execute callback if provided
        if action_button and msg.clickedButton() == action_button and action_callback:
            try:
                action_callback()
            except Exception as e:
                self.show_critical("Error", f"Action failed: {str(e)}")

    def _show_message(self, title, message, icon, buttons=None):
        msg = QMessageBox(self)
        msg.setWindowTitle(title)
        msg.setIcon(icon)
        msg.setText(message)
        if buttons:
            msg.setStandardButtons(buttons)
        self.apply_dialog_dark_mode(msg)
        return msg.exec()

    def show_info(self, title, message):
        self._show_message(title, message, QMessageBox.Icon.Information)

    def show_warning(self, title, message):
        self._show_message(title, message, QMessageBox.Icon.Warning)

    def show_critical(self, title, message):
        self._show_message(title, message, QMessageBox.Icon.Critical)

    def show_question(self, title, message, buttons):
        return self._show_message(title, message, QMessageBox.Icon.Question, buttons)

    def resizeEvent(self, event):
        """Handle window resize events"""
        super().resizeEvent(event)
        # Update tab widths when window is resized
        if hasattr(self, 'tab_widget') and self.tab_widget.count() > 0:
            self.update_tab_style()
    
    def closeEvent(self, event):
        try:
            self.save_pinned_tabs()

            # Clean up all tabs to prevent crashes
            for index in list(self.search_tabs.keys()):
                self.close_tab(index)

            # Stop media player
            if hasattr(self, 'player_manager'):
                self.player_manager.stop()

            # Stop directory scan worker
            if self.scan_worker and self.scan_worker.isRunning():
                self.scan_worker.stop()
                self.scan_worker.wait(3000)
            
            # Stop subdirectory scan worker
            if hasattr(self, 'subdir_scan_worker') and self.subdir_scan_worker and self.subdir_scan_worker.isRunning():
                self.subdir_scan_worker.stop()
                self.subdir_scan_worker.wait(2000)
        except KeyboardInterrupt:
            print("Close interrupted by user.")
        except Exception as exc:
            print(f"Error while closing application: {exc}")
            traceback.print_exc()
        finally:
            try:
                self._close_scan_dialog()
            except Exception:
                pass

            try:
                config = read_config()
                config["window_size"] = {"width": self.width(), "height": self.height()}
                write_config(config)
            except Exception as cfg_exc:
                print(f"Failed to save window size: {cfg_exc}")

            super().closeEvent(event)
            
    # === Updated bookmark methods ===
    BOOKMARK_QUERIES = {
        'large_files': ('kMDItemFSSize >= 52428800', 'Large Files'),
        'videos': ('kMDItemContentTypeTree = "public.movie"', 'Video Files'),
        'audio': ('kMDItemContentTypeTree = "public.audio"', 'Audio Files'),
        'images': ('kMDItemContentTypeTree = "public.image"', 'Images'),
        'archives': ('kMDItemContentTypeTree = "public.archive"', 'Archives'),
        'applications': ('kMDItemContentType == "com.apple.application-bundle"', 'Applications'),
        'recent_24h': ('kMDItemFSContentChangeDate >= $time.today(-1)', 'Recent 24h'),
        'recent_7d': ('kMDItemFSContentChangeDate >= $time.today(-7)', 'Recent 7 Days'),
        'recent_30d': ('kMDItemFSContentChangeDate >= $time.today(-30)', 'Recent 30 Days'),
    }

    def _run_bookmark(self, key):
        clause, title = self.BOOKMARK_QUERIES[key]
        self.start_search(extra_clause=clause, is_bookmark=True, tab_title=title)

    def bookmark_large_files(self): self._run_bookmark('large_files')
    def bookmark_videos(self): self._run_bookmark('videos')
    def bookmark_audio(self): self._run_bookmark('audio')
    def bookmark_images(self): self._run_bookmark('images')
    def bookmark_archives(self): self._run_bookmark('archives')
    def bookmark_applications(self): self._run_bookmark('applications')
    def bookmark_recent_24h(self): self._run_bookmark('recent_24h')
    def bookmark_recent_7d(self): self._run_bookmark('recent_7d')
    def bookmark_recent_30d(self): self._run_bookmark('recent_30d')

    # Close the preview panel
    def close_preview(self):
        # Update the menu action state
        self.toggle_preview_action.setChecked(False)
        
        # Close the standalone player if it's active
        if self.standalone_player_active:
            self.standalone_player.close()
            self.standalone_player_active = False
        
        # Call the existing toggle_preview method with False to hide the panel
        self.toggle_preview(False)

    # toggle continuous playback method
    def toggle_continuous_playback(self, checked):
        self.continuous_playback = checked
        # Update the standalone player too
        self.standalone_player.set_continuous_playback(checked)
        cfg = read_config()
        cfg["continuous_playback"] = checked
        write_config(cfg)

    # media playback state change handler
    def on_playback_state_changed(self, state):
        if state == QMediaPlayer.PlaybackState.StoppedState:
            # Check if the media actually finished playing (not stopped manually)
            # and if continuous playback is enabled
            if self.continuous_playback and self.media_player.position() > 0:
                # Media finished playing, play the next one
                self.play_next_media()

    # method to play the next media file
    def play_next_media(self):
        # Get all items in the tree
        tree = self.get_current_tree()
        if not tree:
            return
            
        item_count = tree.topLevelItemCount()
        if item_count == 0:
            return

        # Find the currently selected item
        current_index = -1
        selected_items = tree.selectedItems()
        if selected_items:
            current_item = selected_items[0]
            for i in range(item_count):
                if tree.topLevelItem(i) == current_item:
                    current_index = i
                    break

        # Find the next media file
        next_index = current_index + 1
        while next_index < item_count:
            next_item = tree.topLevelItem(next_index)
            path = next_item.text(3)
            _, ext = os.path.splitext(path)
            ext = ext.lower()
            
            if ext in self.video_extensions or ext in self.audio_extensions:
                # Select the item in the tree
                tree.setCurrentItem(next_item)
                tree.scrollToItem(next_item)
                
                # Try to play the media
                try:
                    # Make sure preview panel is visible
                    if not self.preview_container.isVisible():
                        self.toggle_preview(True)
                        self.toggle_preview_action.setChecked(True)
                    
                    # Setup for audio or video playback
                    if ext in self.video_extensions:
                        self.video_widget.setVisible(True)
                        self.audio_label.setVisible(False)
                    elif ext in self.audio_extensions:
                        self.video_widget.setVisible(False)
                        self.audio_label.setVisible(True)
                        filename = os.path.basename(path)
                        self.set_audio_label_display(filename)
                    
                    # Load and play the media
                    self.media_player.setSource(QUrl.fromLocalFile(path))
                    self.media_player.play()
                    self.play_button.setIcon(self.style().standardIcon(QStyle.StandardPixmap.SP_MediaPause))
                    self.preview_stack.setCurrentIndex(2)  # Show media player widget
                    return
                except Exception as e:
                    print(f"Failed to play media file: {path}, error: {str(e)}")
                    # If it fails, continue to the next one
            
            next_index += 1

    def open_standalone_player(self):
        """Open the current media in a standalone player window"""
        # If the standalone player is already active, just restore and bring it to front
        if self.standalone_player_active:
            # Restore from minimized state if needed
            self.standalone_player.setWindowState(self.standalone_player.windowState() & ~Qt.WindowState.WindowMinimized)
            self.standalone_player.show()
            self.standalone_player.raise_()
            return
            
        tree = self.get_current_tree()
        if not tree:
            return
            
        selected_items = tree.selectedItems()
        if not selected_items or len(selected_items) != 1:
            return
            
        path = selected_items[0].text(3)
        if not os.path.isfile(path):
            return
            
        _, ext = os.path.splitext(path)
        ext = ext.lower()
        
        if ext not in self.video_extensions and ext not in self.audio_extensions:
            return  # Only open for media files
            
        # Stop the embedded player
        self.media_player.stop()
        
        # Set up and show the standalone player
        is_video = ext in self.video_extensions
        self.standalone_player.play_media(path, is_video)
        self.standalone_player_active = True
        self.standalone_player.show()
        self.standalone_player.raise_()
        
        # Update UI to reflect that media is playing in standalone player
        self.preview_stack.setCurrentIndex(0)  # Switch to text preview
        self.text_preview.setPlainText("Media playing in standalone player window.")
    
    def show_in_standalone_player(self, path):
        """Show the given media path in the standalone player"""
        if not self.standalone_player_active:
            return

        _, ext = os.path.splitext(path)
        ext = ext.lower()
        
        if ext in self.video_extensions or ext in self.audio_extensions:
            is_video = ext in self.video_extensions
            self.standalone_player.play_media(path, is_video)
            self.standalone_player.raise_()
            
            # Update UI to reflect that media is playing in standalone player
            self.preview_stack.setCurrentIndex(0)  # Switch to text preview
            self.text_preview.setPlainText("Media playing in standalone player window.")
    
    def restore_embedded_player(self):
        """Called when the standalone player is closed"""
        if not self.standalone_player_active:
            return
            
        self.standalone_player_active = False
        
        # If there's a selected item, show it in the embedded player
        tree = self.get_current_tree()
        if tree:
            selected_items = tree.selectedItems()
            if selected_items and len(selected_items) == 1:
                path = selected_items[0].text(3)
            if os.path.isfile(path):
                # Re-trigger selection change to reload the preview
                self.on_tree_selection_changed()
    
    def play_next_in_standalone(self):
        """Play the next media file in the standalone player"""
        if not self.standalone_player_active:
            return
            
        # Find the next media file just like in play_next_media
        tree = self.get_current_tree()
        if not tree:
            return
            
        item_count = tree.topLevelItemCount()
        if item_count == 0:
            return

        # Find the currently selected item
        current_index = -1
        selected_items = tree.selectedItems()
        if selected_items:
            current_item = selected_items[0]
            for i in range(item_count):
                if tree.topLevelItem(i) == current_item:
                    current_index = i
                    break

        # Find the next media file
        next_index = current_index + 1
        while next_index < item_count:
            next_item = tree.topLevelItem(next_index)
            path = next_item.text(3)
            _, ext = os.path.splitext(path)
            ext = ext.lower()
            
            if ext in self.video_extensions or ext in self.audio_extensions:
                # Select the item in the tree
                tree.setCurrentItem(next_item)
                tree.scrollToItem(next_item)
                
                # Play in standalone player
                is_video = ext in self.video_extensions
                self.standalone_player.play_media(path, is_video)
                return
            
            next_index += 1

    def eventFilter(self, obj, event):
        if obj == self.edit_query:
            if event.type() == event.Type.FocusIn:
                self.search_container.setProperty("focused", True)
                self.search_container.style().unpolish(self.search_container)
                self.search_container.style().polish(self.search_container)
                return False
            elif event.type() == event.Type.FocusOut:
                self.search_container.setProperty("focused", False)
                self.search_container.style().unpolish(self.search_container)
                self.search_container.style().polish(self.search_container)
                return False
        if event.type() == event.Type.MouseButtonPress and (obj == self.video_widget or obj == self.audio_label):
            if event.button() == Qt.MouseButton.LeftButton:
                self.toggle_play_pause()
                return True
        return super().eventFilter(obj, event)
    
    def update_video_info(self):
        """Update the media info panel with video metadata"""
        if not hasattr(self.media_player, 'videoSink') or not self.media_player.videoSink():
            return
            
        size = self.media_player.videoSink().videoSize()
        duration_secs = self.media_player.duration() // 1000
        
        # Skip if resolution is invalid
        if size.width() <= 0 or size.height() <= 0:
            return
            
        self.media_info.appendPlainText(
            f"\nResolution: {size.width()} x {size.height()}\n"
            f"Duration: {duration_secs} seconds"
        )

    def on_search_enter(self):
        """Handle Enter key press in the search query field"""
        query = self.edit_query.text().strip()
        if query:  # Only search if the query isn't just whitespace
            # Cancel any pending search timer
            self.search_timer.stop()
            # Execute search immediately
            self.start_search()
    
    def toggle_simple_mode(self, checked):
        """Toggle between simple and advanced UI mode"""
        self.simple_mode = checked
        
        if self.simple_mode:
            # Simple mode: hide advanced features
            self.dir_row_widget.hide()
            self.group_advanced.hide()
            self.filter_toggle_btn.hide()
            
            # Hide some menu items
            self.menuBar().findChild(QMenu, None, Qt.FindChildOption.FindDirectChildrenOnly)
            
            # Make window more compact
            if self.height() > 700:
                self.resize(self.width(), 700)
        else:
            # Advanced mode: show all features
            self.dir_row_widget.show()
            self.filter_toggle_btn.show()
            # Keep advanced filters state as it was
            
        # Save preference
        config = read_config()
        config["simple_mode"] = self.simple_mode
        write_config(config)
    
    def toggle_filters(self):
        """Toggle visibility of advanced filters"""
        is_visible = self.group_advanced.isVisible()
        self.group_advanced.setVisible(not is_visible)
        
        # Update button text
        if is_visible:
            self.filter_toggle_btn.setText("▶ Advanced Filters")
        else:
            self.filter_toggle_btn.setText("▼ Advanced Filters")
            
if __name__ == "__main__":
    app = QApplication(sys.argv)
    app.setApplicationName("Everything by mdfind")
    app.setOrganizationName("AppleDragon")
    
    window = MdfindApp()
    window.show()
    
    try:
        sys.exit(app.exec())
    except Exception as e:
        print(f"Application error: {e}")