soulsync/ui/pages/downloads.py

from PyQt6.QtWidgets import (QWidget, QVBoxLayout, QHBoxLayout, QLabel, 
                           QFrame, QPushButton, QProgressBar, QListWidget,
                           QListWidgetItem, QComboBox, QLineEdit, QScrollArea, QMessageBox,
                           QSplitter, QSizePolicy, QSpacerItem, QTabWidget, QDialog, QGridLayout)
from PyQt6.QtCore import Qt, QThread, pyqtSignal, QTimer, QUrl, QPropertyAnimation, QEasingCurve, QParallelAnimationGroup, QFileSystemWatcher, pyqtProperty, QObject, QRunnable, QThreadPool
from PyQt6.QtGui import QFont, QPainter, QPen, QColor, QPixmap
from PyQt6.QtMultimedia import QMediaPlayer, QAudioOutput
import functools  # For fixing lambda memory leaks
import os
import threading
from threading import RLock, Lock
from queue import Queue, Empty
from config.settings import config_manager
# Import the new search result classes
from core.soulseek_client import TrackResult, AlbumResult
from core.spotify_client import SpotifyClient, Artist, Album
from core.matching_engine import MusicMatchingEngine
from core.lyrics_client import LyricsClient
import requests
from typing import List, Optional
from dataclasses import dataclass
# Metadata enhancement imports
from mutagen import File as MutagenFile
from mutagen.id3 import ID3, TIT2, TPE1, TALB, TDRC, TRCK, TCON, TPE2, TPOS, TXXX, APIC
from mutagen.flac import FLAC, Picture
from mutagen.mp4 import MP4, MP4Cover
from mutagen.oggvorbis import OggVorbis
import urllib.request
import mimetypes

@dataclass
class ArtistMatch:
    """Represents an artist match with confidence score"""
    artist: Artist
    confidence: float
    match_reason: str = ""

@dataclass
class AlbumMatch:
    """Represents an album match with confidence score"""
    album: Album
    confidence: float
    match_reason: str = ""


class ImageDownloaderSignals(QObject):
    """Signals for the ImageDownloader worker."""
    finished = pyqtSignal(QLabel, QPixmap)
    error = pyqtSignal(str)

class ImageDownloader(QRunnable):
    """Worker to download an image in the background."""
    def __init__(self, url: str, target_label: QLabel):
        super().__init__()
        self.signals = ImageDownloaderSignals()
        self.url = url
        self.target_label = target_label

    def run(self):
        try:
            if not self.url:
                self.signals.error.emit("No image URL provided.")
                return

            response = requests.get(self.url, stream=True, timeout=10)
            response.raise_for_status()
            
            pixmap = QPixmap()
            pixmap.loadFromData(response.content)
            
            if not pixmap.isNull():
                self.signals.finished.emit(self.target_label, pixmap)
            else:
                self.signals.error.emit("Failed to load image from data.")
                
        except requests.RequestException as e:
            self.signals.error.emit(f"Network error downloading image: {e}")
        except Exception as e:
            self.signals.error.emit(f"Error processing image: {e}")


class DownloadCompletionWorkerSignals(QObject):
    """Signals for the download completion worker"""
    completed = pyqtSignal(object, str)  # download_item, organized_path
    error = pyqtSignal(object, str)  # download_item, error_message

class DownloadCompletionWorker(QRunnable):
    """Background worker to handle download completion processing without blocking UI"""
    
    def __init__(self, download_item, absolute_file_path, organize_func):
        super().__init__()
        self.download_item = download_item
        self.absolute_file_path = absolute_file_path
        self.organize_func = organize_func
        self.signals = DownloadCompletionWorkerSignals()
        
    def run(self):
        """Process download completion in background thread"""
        try:
            print(f"🧵 Background worker processing: '{self.download_item.title}' by '{self.download_item.matched_artist.name}'")
            
            # Add a small delay to ensure file is fully written
            import time
            time.sleep(1)
            
            # Organize the file into Transfer folder structure
            organized_path = self.organize_func(self.download_item, self.absolute_file_path)
            
            # Emit completion signal
            self.signals.completed.emit(self.download_item, organized_path or self.absolute_file_path)
            
        except Exception as e:
            print(f"❌ Error in background worker: {e}")
            import traceback
            traceback.print_exc()
            # Emit error signal
            self.signals.error.emit(self.download_item, str(e))


# OPTIMIZATION: This worker runs the existing status update logic in the background.
class StatusProcessingWorkerSignals(QObject):
    """Defines the signals available from the StatusProcessingWorker."""
    completed = pyqtSignal(list)
    error = pyqtSignal(str)

class StatusProcessingWorker(QRunnable):
    """
    Runs the expensive download status processing in a background thread to prevent UI lag.
    It performs all the matching and logic, then returns a list of actions for the main thread to execute.
    """
    def __init__(self, soulseek_client, download_items):
        super().__init__()
        self.signals = StatusProcessingWorkerSignals()
        self.soulseek_client = soulseek_client
        # We operate on a copy of the item data to avoid thread conflicts
        self.download_items_data = [{
            'widget_id': id(item),
            'download_id': item.download_id,
            'title': item.title,
            'artist': item.artist,
            'file_path': item.file_path,
            'status': item.status,
            'matched_artist': getattr(item, 'matched_artist', None)
        } for item in download_items]

    def run(self):
        """The main logic of the background worker."""
        try:
            # This is the core of your original update_download_status method.
            import asyncio
            loop = asyncio.new_event_loop()
            asyncio.set_event_loop(loop)

            transfers_data = loop.run_until_complete(
                self.soulseek_client._make_request('GET', 'transfers/downloads')
            )
            loop.close()

            results = []
            if not transfers_data:
                self.signals.completed.emit([])
                return

            all_transfers = [
                file for user_data in transfers_data if 'directories' in user_data
                for directory in user_data['directories'] if 'files' in directory
                for file in directory['files']
            ]

            # Create a lookup for faster matching
            transfers_by_id = {t['id']: t for t in all_transfers}
            
            # --- This is your existing, working logic, now running in the background ---
            for item_data in self.download_items_data:
                if item_data['status'].lower() in ['completed', 'finished', 'cancelled', 'failed']:
                    continue

                matching_transfer = transfers_by_id.get(item_data['download_id'])

                if not matching_transfer:
                    # Fallback to filename matching if ID match fails
                    import os
                    dl_filename = os.path.basename(item_data['file_path']).lower()
                    for t in all_transfers:
                        if os.path.basename(t.get('filename', '')).lower() == dl_filename:
                            matching_transfer = t
                            break

                if matching_transfer:
                    state = matching_transfer.get('state', 'Unknown')
                    progress = matching_transfer.get('percentComplete', 0)
                    new_status = 'queued'

                    # Determine the new status with the correct order of checks.
                    # Terminal states like Cancelled and Failed must be checked BEFORE Completed.
                    if 'Cancelled' in state or 'Canceled' in state:
                        new_status = 'cancelled'
                    elif 'Failed' in state or 'Errored' in state:
                        new_status = 'failed'
                    elif 'Completed' in state or 'Succeeded' in state:
                        new_status = 'completed'
                    elif 'InProgress' in state:
                        new_status = 'downloading'
                    else:
                        new_status = 'queued'

                    # **CRITICAL FIX:** Package all necessary data for the main thread.
                    payload = {
                        'widget_id': item_data['widget_id'],
                        'status': new_status,
                        'progress': int(progress),
                        'speed': int(matching_transfer.get('averageSpeed', 0)),
                        'path': matching_transfer.get('filename', item_data['file_path']),
                        'transfer_id': matching_transfer.get('id'), # This is key for cleanup
                        'username': matching_transfer.get('username') # Also key for cleanup
                    }
                    
                    if new_status == 'completed' and item_data['matched_artist']:
                        payload['action'] = 'process_matched_completion'
                    
                    results.append(payload)
                else:
                    # This handles downloads that have disappeared from the API (e.g., failed, cancelled by user).
                    # We add a grace period before marking as failed to handle temporary API glitches.
                    item_data['api_missing_count'] = item_data.get('api_missing_count', 0) + 1
                    
                    if item_data['api_missing_count'] >= 3:
                        # After being missing for 3 update cycles (3 seconds), mark it as failed.
                        payload = {
                            'widget_id': item_data['widget_id'],
                            'status': 'failed',
                            'progress': item_data.get('progress', 0),
                            'speed': 0,
                            'path': item_data['file_path'],
                            'transfer_id': item_data['download_id'],
                            'username': item_data['artist'] 
                        }
                        results.append(payload)

            self.signals.completed.emit(results)
        except Exception as e:
            import traceback
            traceback.print_exc()
            self.signals.error.emit(str(e))

class OptimizedDownloadCompletionWorker(QRunnable):
    """OPTIMIZATION v2: Non-blocking background worker for download completion processing"""
    
    def __init__(self, download_item, absolute_file_path, organize_func):
        super().__init__()
        self.download_item = download_item
        self.absolute_file_path = absolute_file_path
        self.organize_func = organize_func
        self.signals = DownloadCompletionWorkerSignals()
        
    def run(self):
        """Process download completion without blocking operations"""
        try:
            # OPTIMIZATION: Use file system monitoring instead of sleep
            import os
            from pathlib import Path
            
            # Verify file exists and is not being written to
            file_path = Path(self.absolute_file_path)
            if file_path.exists():
                initial_size = file_path.stat().st_size
                # Quick non-blocking check for file stability
                import time
                time.sleep(0.1)  # Minimal delay
                if file_path.exists() and file_path.stat().st_size == initial_size:
                    # File is stable, proceed with organization
                    organized_path = self.organize_func(self.download_item, self.absolute_file_path)
                    self.signals.completed.emit(self.download_item, organized_path or self.absolute_file_path)
                else:
                    # File still being written, retry with shorter delay
                    time.sleep(0.5)
                    organized_path = self.organize_func(self.download_item, self.absolute_file_path)
                    self.signals.completed.emit(self.download_item, organized_path or self.absolute_file_path)
            else:
                raise FileNotFoundError(f"Download file not found: {self.absolute_file_path}")
            
        except Exception as e:
            print(f"❌ Error in optimized worker: {e}")
            import traceback
            traceback.print_exc()
            self.signals.error.emit(self.download_item, str(e))

class ThreadSafeQueueManager:
    """OPTIMIZATION v2: Thread-safe queue management system to prevent race conditions"""
    
    def __init__(self):
        self._download_items_lock = RLock()  # Reentrant lock for nested operations
        self._state_transition_lock = Lock()  # Lock for atomic state changes
        self._id_mapping_lock = Lock()  # Lock for ID mapping operations
        self._download_items = []
        self._pending_operations = Queue()  # Queue for pending operations
        
    def add_download_item_safe(self, download_item):
        """Thread-safe addition of download items"""
        with self._download_items_lock:
            self._download_items.append(download_item)
    
    def remove_download_item_safe(self, download_item):
        """Thread-safe removal of download items"""
        with self._download_items_lock:
            if download_item in self._download_items:
                self._download_items.remove(download_item)
                return True
            return False
    
    def get_download_items_copy(self):
        """Get thread-safe copy of download items"""
        with self._download_items_lock:
            return self._download_items.copy()
    
    def find_item_by_id_safe(self, download_id):
        """Thread-safe search for download item by ID"""
        with self._download_items_lock:
            for item in self._download_items:
                if hasattr(item, 'download_id') and item.download_id == download_id:
                    return item
            return None
    
    def atomic_state_transition(self, download_item, new_status, callback=None):
        """Perform atomic state transitions to prevent inconsistencies"""
        with self._state_transition_lock:
            old_status = getattr(download_item, 'status', 'unknown')
            download_item.status = new_status
            if callback:
                callback(download_item, old_status, new_status)
    
    def update_id_mapping_safe(self, download_item, new_id):
        """Thread-safe ID mapping updates"""
        with self._id_mapping_lock:
            old_id = getattr(download_item, 'download_id', None)
            download_item.download_id = new_id

class SpotifyMatchingModal(QDialog):
    """A redesigned modal for matching downloads to Spotify artists and albums."""
    
    match_confirmed = pyqtSignal(Artist, Album)
    cancelled = pyqtSignal()
    
    def __init__(self, original_result: object, spotify_client: SpotifyClient, matching_engine: MusicMatchingEngine, parent=None, is_album=False, album_result=None):
        super().__init__(parent)
        self.original_result = original_result
        self.spotify_client = spotify_client
        self.matching_engine = matching_engine
        self.is_album = is_album
        self.album_result = album_result
        self.image_download_pool = QThreadPool()
        self.image_download_pool.setMaxThreadCount(4)
        self.selected_artist: Optional[Artist] = None
        self.selected_album: Optional[Album] = None
        
        self.setWindowTitle("Match Download to Spotify")
        self.setModal(True)
        self.resize(1100, 750)
        
        self.setStyleSheet("""
            QDialog { background-color: #121212; border: none; }
            QLabel { color: #FFFFFF; }
            QPushButton {
                background-color: #1DB954; color: #FFFFFF; border: none;
                border-radius: 15px; padding: 10px 20px; font-size: 14px; font-weight: 600;
            }
            QPushButton:hover { background-color: #1ED760; }
            QPushButton:disabled { background-color: #2A2A2A; color: #535353; }
            QPushButton#cancel, QPushButton#skip { background-color: #535353; }
            QPushButton#cancel:hover, QPushButton#skip:hover { background-color: #6A6A6A; }
            QLineEdit {
                background-color: #2A2A2A; border: 2px solid #535353; border-radius: 15px;
                color: white; padding: 12px; font-size: 14px;
            }
            QLineEdit:focus { border: 2px solid #1DB954; }
            QFrame#card {
                background-color: #1E1E1E; border: 2px solid #2A2A2A; border-radius: 12px;
            }
            QFrame#card:hover { border: 2px solid #1DB954; background-color: #282828; }
        """)
        
        self.current_stage = "artist"
        self.setup_ui()
        self.generate_auto_artist_suggestions()

    def setup_ui(self):
        main_layout = QVBoxLayout(self)
        main_layout.setContentsMargins(20, 20, 20, 20)
        main_layout.setSpacing(15)

        # Different header text based on mode
        if self.is_album:
            header_text = "Step 1: Select the correct Artist"
        else:
            header_text = "Select the correct Artist for this Single"
        self.header_label = QLabel(header_text)
        self.header_label.setStyleSheet("font-size: 22px; font-weight: bold; color: #1DB954;")
        main_layout.addWidget(self.header_label)

        auto_title = QLabel("Top Suggestions")
        auto_title.setStyleSheet("font-size: 16px; color: #B3B3B3;")
        self.auto_suggestions_layout = QHBoxLayout()
        self.auto_suggestions_layout.setSpacing(20)
        
        main_layout.addWidget(auto_title)
        main_layout.addLayout(self.auto_suggestions_layout)
        
        manual_title = QLabel("Or, Search Manually")
        manual_title.setStyleSheet("font-size: 16px; color: #B3B3B3; margin-top: 15px;")
        self.search_input = QLineEdit()
        self.search_input.setPlaceholderText("Manually search for an artist...")
        self.search_input.textChanged.connect(self.on_search_text_changed)
        self.manual_results_layout = QHBoxLayout()
        self.manual_results_layout.setSpacing(20)

        main_layout.addWidget(manual_title)
        main_layout.addWidget(self.search_input)
        main_layout.addLayout(self.manual_results_layout)
        main_layout.addStretch()

        button_layout = QHBoxLayout()
        self.confirm_btn = QPushButton("Confirm Selection")
        self.confirm_btn.clicked.connect(self.confirm_selection)
        self.confirm_btn.setEnabled(False)

        skip_btn = QPushButton("Skip Matching")
        skip_btn.setObjectName("skip")
        skip_btn.clicked.connect(self.skip_matching)

        cancel_btn = QPushButton("Cancel")
        cancel_btn.setObjectName("cancel")
        cancel_btn.clicked.connect(self.reject)

        button_layout.addWidget(skip_btn)
        button_layout.addStretch()
        button_layout.addWidget(self.confirm_btn)
        button_layout.addWidget(cancel_btn)
        main_layout.addLayout(button_layout)

        self.search_timer = QTimer()
        self.search_timer.setSingleShot(True)
        self.search_timer.timeout.connect(self.perform_manual_search)

    def download_and_set_image(self, url: str, target_label: QLabel):
        """Starts a background worker to download and set an image."""
        worker = ImageDownloader(url, target_label)
        worker.signals.finished.connect(self._on_image_downloaded)
        worker.signals.error.connect(lambda msg: print(f"Image Error: {msg} for url {url}"))
        self.image_download_pool.start(worker)

    def _on_image_downloaded(self, target_label: QLabel, pixmap: QPixmap):
        """Slot to apply the downloaded pixmap to the target label."""
        if target_label and not pixmap.isNull():
            # Scale pixmap to fill the label, cropping if necessary
            scaled_pixmap = pixmap.scaled(target_label.size(), 
                                          Qt.AspectRatioMode.KeepAspectRatioByExpanding, 
                                          Qt.TransformationMode.SmoothTransformation)
            target_label.setPixmap(scaled_pixmap)

    def generate_auto_artist_suggestions(self):
        self._clear_layout(self.auto_suggestions_layout)
        self._show_loading_cards(self.auto_suggestions_layout, "Finding artist...")
        self.suggestion_thread = ArtistSuggestionThread(
            self.original_result, self.spotify_client, self.matching_engine, self.is_album, self.album_result
        )
        self.suggestion_thread.suggestions_ready.connect(self.display_artist_suggestions)
        self.suggestion_thread.start()

    def generate_auto_album_suggestions(self):
        self._clear_layout(self.auto_suggestions_layout)
        self._show_loading_cards(self.auto_suggestions_layout, "Finding album...")

        # Use the correct result object for album suggestions.
        # If it's an album download, use the full album_result for context.
        # Otherwise, use the original_result (a single track).
        context_result = self.album_result if self.is_album and self.album_result else self.original_result

        self.album_suggestion_thread = AlbumSuggestionThread(
            self.selected_artist, context_result, self.spotify_client, self.matching_engine
        )
        self.album_suggestion_thread.suggestions_ready.connect(self.display_album_suggestions)
        self.album_suggestion_thread.start()

    def display_artist_suggestions(self, suggestions: List[ArtistMatch]):
        self._clear_layout(self.auto_suggestions_layout)
        if not suggestions:
            self.auto_suggestions_layout.addWidget(QLabel("No automatic artist matches found."))
            return
        self.auto_suggestions_layout.addStretch()
        for suggestion in suggestions[:4]:
            self.auto_suggestions_layout.addWidget(self.create_artist_card(suggestion.artist, suggestion.confidence))
        self.auto_suggestions_layout.addStretch()

    def display_album_suggestions(self, suggestions: List[AlbumMatch]):
        self._clear_layout(self.auto_suggestions_layout)
        if not suggestions:
            self.auto_suggestions_layout.addWidget(QLabel(f"No automatic album matches found for {self.selected_artist.name}."))
            return
        self.auto_suggestions_layout.addStretch()
        for suggestion in suggestions[:4]:
            self.auto_suggestions_layout.addWidget(self.create_album_card(suggestion.album, suggestion.confidence))
        self.auto_suggestions_layout.addStretch()

    def on_search_text_changed(self):
        self.search_timer.stop()
        if len(self.search_input.text().strip()) >= 2:
            self.search_timer.start(400)

    def perform_manual_search(self):
        query = self.search_input.text().strip()
        if not query: return
        
        self._clear_layout(self.manual_results_layout)
        
        if self.current_stage == "artist":
            self._show_loading_cards(self.manual_results_layout, "Searching artists...")
            self.search_thread = ArtistSearchThread(query, self.spotify_client, self.matching_engine, self.original_result)
            self.search_thread.search_results.connect(self.display_manual_artist_results)
            self.search_thread.start()
        else:
            self._show_loading_cards(self.manual_results_layout, "Searching albums...")
            self.search_thread = AlbumSearchThread(query, self.selected_artist, self.spotify_client, self.matching_engine)
            self.search_thread.search_results.connect(self.display_manual_album_results)
            self.search_thread.start()

    def display_manual_artist_results(self, results: List[ArtistMatch]):
        self._clear_layout(self.manual_results_layout)
        if not results:
            self.manual_results_layout.addWidget(QLabel("No artists found."))
            return
        self.manual_results_layout.addStretch()
        for result in results[:4]:
            self.manual_results_layout.addWidget(self.create_artist_card(result.artist, result.confidence))
        self.manual_results_layout.addStretch()

    def display_manual_album_results(self, results: List[AlbumMatch]):
        self._clear_layout(self.manual_results_layout)
        if not results:
            self.manual_results_layout.addWidget(QLabel("No albums found."))
            return
        self.manual_results_layout.addStretch()
        for result in results[:4]:
            self.manual_results_layout.addWidget(self.create_album_card(result.album, result.confidence))
        self.manual_results_layout.addStretch()

    def select_artist(self, artist: Artist):
        self.selected_artist = artist
        print(f"Artist selected: {artist.name}")
        
        # For singles mode, we can confirm with just the artist selection
        if not self.is_album:
            self.confirm_btn.setEnabled(True)
            self.confirm_btn.setText(f"Confirm: {artist.name[:30]}...")
            # Update header to indicate completion
            self.header_label.setText("✅ Artist Selected - Ready to Download")
        else:
            # For album mode, proceed to album selection
            self.transition_to_album_stage()

    def select_album(self, album: Album):
        self.selected_album = album
        print(f"Album selected: {album.name}")
        self.confirm_btn.setEnabled(True)
        self.confirm_btn.setText(f"Confirm: {album.name[:25]}...")

    def transition_to_album_stage(self):
        self.current_stage = "album"
        self.header_label.setText(f"Step 2: Select Album for {self.selected_artist.name}")
        self.search_input.setPlaceholderText("Manually search for an album...")
        self.search_input.clear()
        self.confirm_btn.setEnabled(False)
        self.confirm_btn.setText("Confirm Selection")
        self._clear_layout(self.manual_results_layout)
        self.generate_auto_album_suggestions()

    def confirm_selection(self):
        if self.selected_artist:
            # For singles mode, we only need the artist
            if not self.is_album:
                # Create a dummy album object for singles mode
                dummy_album = Album(
                    id="singles-dummy", 
                    name="Singles Collection", 
                    artists=[self.selected_artist.name], 
                    total_tracks=1, 
                    release_date="", 
                    album_type="single"
                )
                self.match_confirmed.emit(self.selected_artist, dummy_album)
                self.accept()
            # For album mode, we need both artist and album
            elif self.selected_album:
                self.match_confirmed.emit(self.selected_artist, self.selected_album)
                self.accept()

    def skip_matching(self):
        self.skipped_matching = True
        self.reject()

    def reject(self):
        if not hasattr(self, 'skipped_matching'):
            self.skipped_matching = False
        # Clean up the image download pool
        self.image_download_pool.clear()
        self.image_download_pool.waitForDone(5000) # Wait max 5 seconds for tasks to finish
        self.cancelled.emit()
        super().reject()

    def create_artist_card(self, artist: Artist, confidence: float) -> QFrame:
        card = QFrame()
        card.setObjectName("card")
        card.setFixedSize(220, 130)
        # The main card needs a layout to stack widgets
        card_layout = QGridLayout(card)
        card_layout.setContentsMargins(0, 0, 0, 0)

        # 1. Background Layer (for the image)
        background_label = QLabel()
        background_label.setScaledContents(True)
        background_label.setStyleSheet("border-radius: 12px;")

        # 2. Gradient Overlay Layer (for text readability)
        gradient_overlay = QWidget()
        gradient_overlay.setStyleSheet("""
            QWidget {
                background: qlineargradient(x1:0, y1:0, x2:0, y2:1,
                    stop:0 rgba(18, 18, 18, 0.4),
                    stop:0.6 rgba(18, 18, 18, 0.7),
                    stop:1 rgba(18, 18, 18, 0.9));
                border-radius: 12px;
            }
        """)
        
        # 3. Content Layer (the text)
        content_layout = QVBoxLayout(gradient_overlay)
        content_layout.setContentsMargins(12, 12, 12, 12)
        
        name = QLabel(artist.name)
        name.setWordWrap(True)
        name.setStyleSheet("font-size: 16px; font-weight: bold; color: white; background: transparent; border: none;")
        
        confidence_label = QLabel(f"{confidence:.0%} match")
        confidence_label.setStyleSheet("color: #B3B3B3; font-size: 12px; background: transparent; border: none;")
        
        content_layout.addWidget(name)
        content_layout.addStretch()
        content_layout.addWidget(confidence_label)

        # Stack the layers
        card_layout.addWidget(background_label, 0, 0)
        card_layout.addWidget(gradient_overlay, 0, 0)

        # Set up interaction
        card.mousePressEvent = lambda event: self.select_artist(artist)

        # Fetch the artist image in the background
        if hasattr(artist, 'image_url') and artist.image_url:
            self.download_and_set_image(artist.image_url, background_label)

        return card

    def create_album_card(self, album: Album, confidence: float) -> QFrame:
        card = QFrame()
        card.setObjectName("card")
        card.setFixedSize(220, 130)
        # The main card needs a layout to stack widgets
        card_layout = QGridLayout(card)
        card_layout.setContentsMargins(0, 0, 0, 0)

        # 1. Background Layer (for the image)
        background_label = QLabel()
        background_label.setScaledContents(True)
        background_label.setStyleSheet("border-radius: 12px;")

        # 2. Gradient Overlay Layer (for text readability)
        gradient_overlay = QWidget()
        gradient_overlay.setStyleSheet("""
            QWidget {
                background: qlineargradient(x1:0, y1:0, x2:0, y2:1,
                    stop:0 rgba(18, 18, 18, 0.4),
                    stop:0.6 rgba(18, 18, 18, 0.7),
                    stop:1 rgba(18, 18, 18, 0.9));
                border-radius: 12px;
            }
        """)
        
        # 3. Content Layer (the text)
        content_layout = QVBoxLayout(gradient_overlay)
        content_layout.setContentsMargins(12, 12, 12, 12)
        
        name = QLabel(album.name)
        name.setWordWrap(True)
        name.setStyleSheet("font-size: 14px; font-weight: bold; color: white; background: transparent; border: none;")
        
        year = album.release_date.split('-')[0] if album.release_date else ""
        details = QLabel(f"{album.album_type.title()} • {year}")
        details.setStyleSheet("color: #B3B3B3; font-size: 12px; background: transparent; border: none;")
        
        content_layout.addWidget(name)
        content_layout.addWidget(details)
        content_layout.addStretch()

        # Stack the layers
        card_layout.addWidget(background_label, 0, 0)
        card_layout.addWidget(gradient_overlay, 0, 0)

        # Set up interaction
        card.mousePressEvent = lambda event: self.select_album(album)

        # Fetch the album image in the background
        if hasattr(album, 'image_url') and album.image_url:
            self.download_and_set_image(album.image_url, background_label)

        return card

    def _show_loading_cards(self, layout: QHBoxLayout, text: str):
        layout.addStretch()
        for _ in range(4):
            loading_card = QFrame()
            loading_card.setObjectName("card")
            loading_card.setFixedSize(220, 130)
            card_layout = QVBoxLayout(loading_card)
            card_layout.addWidget(QLabel(text), 0, Qt.AlignmentFlag.AlignCenter)
            layout.addWidget(loading_card)
        layout.addStretch()

    def _clear_layout(self, layout: QHBoxLayout):
        while layout.count():
            child = layout.takeAt(0)
            if child.widget():
                child.widget().deleteLater()

class ArtistSuggestionThread(QThread):
    """Background thread for generating artist suggestions"""
    
    suggestions_ready = pyqtSignal(list)
    
    def __init__(self, track_result: TrackResult, spotify_client: SpotifyClient, matching_engine: MusicMatchingEngine, is_album=False, album_result=None):
        super().__init__()
        self.track_result = track_result
        self.spotify_client = spotify_client
        self.matching_engine = matching_engine
        self.is_album = is_album
        self.album_result = album_result
    
    def run(self):
        """Generate artist suggestions"""
        try:
            print(f"🔍 Starting auto suggestions for: {self.track_result.artist} - {self.track_result.title}")
            suggestions = self.generate_artist_suggestions()
            print(f"✅ Generated {len(suggestions)} auto suggestions")
            self.suggestions_ready.emit(suggestions)
        except Exception as e:
            print(f"❌ Error generating suggestions: {e}")
            self.suggestions_ready.emit([])
    
    def generate_artist_suggestions(self) -> List[ArtistMatch]:
        """Generate artist suggestions using multiple strategies"""
        suggestions = []
        
        # Debug logging
        print(f"🔍 [DEBUG] Auto suggestion input data:")
        print(f"    track_result.artist: '{getattr(self.track_result, 'artist', 'NOT_FOUND')}'")
        print(f"    track_result.title: '{getattr(self.track_result, 'title', 'NOT_FOUND')}'")
        print(f"    track_result.album: '{getattr(self.track_result, 'album', 'NOT_FOUND')}'")
        print(f"    track_result type: {type(self.track_result)}")
        print(f"    spotify_client available: {self.spotify_client is not None}")
        print(f"    matching_engine available: {self.matching_engine is not None}")
        if self.spotify_client:
            print(f"    spotify_client.is_authenticated(): {self.spotify_client.is_authenticated()}")
        print(f"    track_result attributes: {[attr for attr in dir(self.track_result) if not attr.startswith('_')]}")
        
        # Special handling for albums - use album title to find artist instead of track data
        if self.is_album and self.album_result and self.album_result.album_title:
            print(f"🎵 [DEBUG] Album mode detected - using album title for artist search")
            print(f"    album_title: '{self.album_result.album_title}'")
            print(f"    album_artist: '{getattr(self.album_result, 'artist', 'NOT_FOUND')}'")
            
            # Clean album title for searching (remove year prefixes like "(2005)")
            album_title = self.album_result.album_title
            import re
            clean_album_title = re.sub(r'^\(\d{4}\)\s*', '', album_title).strip()
            print(f"    clean_album_title: '{clean_album_title}'")
            
            # Strategy: Search tracks using album title to find the artist
            print(f"🔍 Album Strategy: Searching tracks for album '{clean_album_title}'")
            tracks = self.spotify_client.search_tracks(clean_album_title, limit=20)
            print(f"📊 Found {len(tracks)} tracks from album search")
            
            # Collect unique artist names and their associated tracks/albums first
            unique_artists = {}  # artist_name -> list of (track, album) tuples
            for track in tracks:
                for artist_name in track.artists:
                    if artist_name not in unique_artists:
                        unique_artists[artist_name] = []
                    unique_artists[artist_name].append((track, track.album))
            
            print(f"🚀 [PERF] Found {len(unique_artists)} unique artists to lookup (down from {sum(len(track.artists) for track in tracks)} total)")
            
            # Batch fetch artist objects using concurrent futures for speed
            from concurrent.futures import ThreadPoolExecutor, as_completed
            import time
            
            start_time = time.time()
            artist_objects = {}  # artist_name -> Artist object
            
            def fetch_artist(artist_name):
                """Fetch single artist with error handling"""
                try:
                    matches = self.spotify_client.search_artists(artist_name, limit=1)
                    if matches:
                        return artist_name, matches[0]
                except Exception as e:
                    print(f"⚠️ Error fetching artist '{artist_name}': {e}")
                return artist_name, None
            
            # Use limited concurrency to respect rate limits while improving speed
            with ThreadPoolExecutor(max_workers=3) as executor:
                future_to_artist = {executor.submit(fetch_artist, name): name for name in unique_artists.keys()}
                
                for future in as_completed(future_to_artist):
                    artist_name, artist_obj = future.result()
                    if artist_obj:
                        artist_objects[artist_name] = artist_obj
            
            fetch_time = time.time() - start_time
            print(f"⚡ [PERF] Fetched {len(artist_objects)} artists in {fetch_time:.2f}s using concurrent API calls")
            
            # Now calculate confidence scores for each artist
            artist_scores = {}
            for artist_name, track_album_pairs in unique_artists.items():
                if artist_name not in artist_objects:
                    continue
                    
                artist = artist_objects[artist_name]
                best_confidence = 0
                best_album_match = ""
                
                # Find the best confidence score across all albums for this artist
                for track, album in track_album_pairs:
                    # Calculate confidence based on album title match
                    confidence = self.matching_engine.similarity_score(
                        self.matching_engine.normalize_string(clean_album_title),
                        self.matching_engine.normalize_string(album)
                    )
                    
                    # Boost confidence if album artist matches
                    if hasattr(self.album_result, 'artist') and self.album_result.artist:
                        artist_confidence = self.matching_engine.similarity_score(
                            self.matching_engine.normalize_string(self.album_result.artist),
                            self.matching_engine.normalize_string(artist.name)
                        )
                        confidence = max(confidence, artist_confidence)
                    
                    # Keep highest confidence for this artist
                    if confidence > best_confidence:
                        best_confidence = confidence
                        best_album_match = album
                
                # Store the artist with their best confidence
                artist_scores[artist.id] = {
                    'artist': artist,
                    'confidence': best_confidence,
                    'album_match': best_album_match
                }
            
            # Add high-confidence album artists to suggestions
            for artist_data in artist_scores.values():
                if artist_data['confidence'] >= 0.6:  # Higher threshold for album matches
                    print(f"✅ Added album artist match: {artist_data['artist'].name} ({artist_data['confidence']:.2f}) via '{artist_data['album_match']}'")
                    suggestions.append(ArtistMatch(
                        artist=artist_data['artist'],
                        confidence=artist_data['confidence'],
                        match_reason=f"Album match via '{artist_data['album_match']}'"
                    ))
            
            print(f"🎯 [DEBUG] Album strategy generated {len(suggestions)} suggestions")
            
            # If we found good album matches, return them (don't try track-based strategies)
            if suggestions:
                # Remove duplicates and sort by confidence
                unique_suggestions = {}
                for suggestion in suggestions:
                    if suggestion.artist.id not in unique_suggestions or unique_suggestions[suggestion.artist.id].confidence < suggestion.confidence:
                        unique_suggestions[suggestion.artist.id] = suggestion
                
                final_suggestions = sorted(unique_suggestions.values(), key=lambda x: x.confidence, reverse=True)
                print(f"🎯 [DEBUG] Returning {len(final_suggestions)} album-based suggestions")
                return final_suggestions[:5]
        
        # Try to get artist name from different sources (for singles or fallback)
        artist_name = None
        if self.track_result.artist and self.track_result.artist != "Unknown Artist":
            artist_name = self.track_result.artist
        elif hasattr(self.track_result, 'user') and self.track_result.user:
            # Sometimes the artist might be in the user field
            artist_name = self.track_result.user
        elif hasattr(self.track_result, 'filename') and self.track_result.filename:
            # Try to extract artist from filename
            import os
            filename = os.path.basename(self.track_result.filename)
            if ' - ' in filename:
                artist_name = filename.split(' - ')[0].strip()
        
        print(f"🎯 [DEBUG] Determined artist name: '{artist_name}'")
        
        # Strategy 1: Search for the artist name directly
        if artist_name and artist_name != "Unknown Artist":
            artist_query = self.matching_engine.normalize_string(artist_name)
            print(f"🔍 Strategy 1: Searching for artist '{artist_query}'")
            artists = self.spotify_client.search_artists(artist_query, limit=10)
            print(f"📊 Found {len(artists)} artists from Spotify")
            
            for artist in artists:
                confidence = self.matching_engine.similarity_score(
                    self.matching_engine.normalize_string(artist_name),
                    self.matching_engine.normalize_string(artist.name)
                )
                
                if confidence >= 0.3:  # Minimum threshold
                    print(f"✅ Added artist match: {artist.name} ({confidence:.2f})")
                    suggestions.append(ArtistMatch(
                        artist=artist,
                        confidence=confidence,
                        match_reason="Artist name match"
                    ))
        else:
            print(f"❌ Strategy 1 skipped: artist_name='{artist_name}', original_artist='{getattr(self.track_result, 'artist', 'NO_ATTR')}'")
        
        # Strategy 2: Search for "artist - title" combination
        if artist_name and self.track_result.title:
            combined_query = f"{artist_name} {self.track_result.title}"
            print(f"🔍 Strategy 2: Searching for combined query '{combined_query}'")
            tracks = self.spotify_client.search_tracks(combined_query, limit=10)
            print(f"📊 Found {len(tracks)} tracks from Spotify")
            
            for track in tracks:
                for artist_name in track.artists:
                    # Find matching artist
                    artist_matches = self.spotify_client.search_artists(artist_name, limit=1)
                    if artist_matches:
                        artist = artist_matches[0]
                        
                        # Calculate combined confidence based on artist and title match
                        artist_confidence = self.matching_engine.similarity_score(
                            self.matching_engine.normalize_string(artist_name),
                            self.matching_engine.normalize_string(artist.name)
                        )
                        title_confidence = self.matching_engine.similarity_score(
                            self.matching_engine.normalize_string(self.track_result.title),
                            self.matching_engine.normalize_string(track.name)
                        )
                        
                        combined_confidence = (artist_confidence * 0.7 + title_confidence * 0.3)
                        
                        if combined_confidence >= 0.4:
                            suggestions.append(ArtistMatch(
                                artist=artist,
                                confidence=combined_confidence,
                                match_reason="Track match"
                            ))
        
        # Remove duplicates and sort by confidence
        unique_suggestions = {}
        for suggestion in suggestions:
            if suggestion.artist.id not in unique_suggestions or unique_suggestions[suggestion.artist.id].confidence < suggestion.confidence:
                unique_suggestions[suggestion.artist.id] = suggestion
        
        final_suggestions = sorted(unique_suggestions.values(), key=lambda x: x.confidence, reverse=True)
        
        # Debug final results
        print(f"🎯 [DEBUG] Final suggestions count: {len(final_suggestions)}")
        for i, suggestion in enumerate(final_suggestions[:5]):
            print(f"    {i+1}. {suggestion.artist.name} ({suggestion.confidence:.2f}) - {suggestion.match_reason}")
        
        return final_suggestions[:5]

class ArtistSearchThread(QThread):
    """Background thread for manual artist search"""
    
    search_results = pyqtSignal(list)
    
    def __init__(self, query: str, spotify_client: SpotifyClient, matching_engine: MusicMatchingEngine, track_result: TrackResult):
        super().__init__()
        self.query = query
        self.spotify_client = spotify_client
        self.matching_engine = matching_engine
        self.track_result = track_result
    
    def run(self):
        """Perform artist search"""
        try:
            artists = self.spotify_client.search_artists(self.query, limit=10)
            results = []
            
            for artist in artists:
                # Calculate confidence based on search query match
                confidence = self.matching_engine.similarity_score(
                    self.matching_engine.normalize_string(self.query),
                    self.matching_engine.normalize_string(artist.name)
                )
                
                # Boost confidence if it also matches the original track artist
                if self.track_result.artist:
                    original_match = self.matching_engine.similarity_score(
                        self.matching_engine.normalize_string(self.track_result.artist),
                        self.matching_engine.normalize_string(artist.name)
                    )
                    confidence = max(confidence, original_match)
                
                results.append(ArtistMatch(
                    artist=artist,
                    confidence=confidence,
                    match_reason="Search result"
                ))
            
            # Sort by confidence
            results.sort(key=lambda x: x.confidence, reverse=True)
            self.search_results.emit(results)
            
        except Exception as e:
            print(f"Error searching artists: {e}")
            self.search_results.emit([])

class AlbumSearchThread(QThread):
    """Background thread for album search by artist"""
    
    search_results = pyqtSignal(list)
    
    def __init__(self, query: str, artist: Artist, spotify_client: SpotifyClient, matching_engine: MusicMatchingEngine):
        super().__init__()
        self.query = query
        self.artist = artist
        self.spotify_client = spotify_client
        self.matching_engine = matching_engine
    
    def run(self):
        """Perform album search"""
        try:
            # Search for albums by the selected artist
            search_query = f"artist:{self.artist.name} {self.query}"
            albums = self.spotify_client.search_albums(search_query, limit=10)
            results = []
            
            for album in albums:
                # Check if this album is actually by our selected artist
                artist_match = False
                for album_artist in album.artists:
                    if self.matching_engine.similarity_score(
                        self.matching_engine.normalize_string(self.artist.name),
                        self.matching_engine.normalize_string(album_artist)
                    ) >= 0.8:
                        artist_match = True
                        break
                
                if artist_match:
                    # Calculate confidence based on search query match with album name
                    confidence = self.matching_engine.similarity_score(
                        self.matching_engine.normalize_string(self.query),
                        self.matching_engine.normalize_string(album.name)
                    )
                    
                    results.append(AlbumMatch(
                        album=album,
                        confidence=confidence,
                        match_reason="Album search result"
                    ))
            
            # Sort by confidence
            results.sort(key=lambda x: x.confidence, reverse=True)
            self.search_results.emit(results)
            
        except Exception as e:
            print(f"Error searching albums: {e}")
            self.search_results.emit([])

class AlbumSuggestionThread(QThread):
    """Background thread for generating automatic album suggestions for a given artist."""
    
    suggestions_ready = pyqtSignal(list)
    
    def __init__(self, selected_artist: Artist, original_result: object, spotify_client: SpotifyClient, matching_engine: MusicMatchingEngine):
        super().__init__()
        self.artist = selected_artist
        self.original_result = original_result
        self.spotify_client = spotify_client
        self.matching_engine = matching_engine
    
    def run(self):
        """Fetch albums for the artist and find the best matches."""
        try:
            import re # Import the regular expression module

            target_album_name = ""
            if isinstance(self.original_result, AlbumResult):
                target_album_name = self.original_result.album_title
                print(f"🎵 Album context for auto-match from AlbumResult: '{target_album_name}'")
            elif hasattr(self.original_result, 'album') and self.original_result.album:
                target_album_name = self.original_result.album
                print(f"🎵 Album context for auto-match from TrackResult: '{target_album_name}'")
            else:
                target_album_name = self.original_result.title 
                print(f"🎵 Album context for auto-match using fallback to track title: '{target_album_name}'")

            if not target_album_name:
                self.suggestions_ready.emit([])
                return

            # More aggressive cleaning for the search query.
            # 1. Remove bracketed content like [flac], (Explicit), [2024], etc.
            cleaned_search_term = re.sub(r'\s*[\[\(].*?[\]\)]', '', target_album_name).strip()
            
            # 2. Remove the artist's name from the string if it's present.
            artist_pattern = r'^' + re.escape(self.artist.name) + r'\s*-\s*'
            cleaned_search_term = re.sub(artist_pattern, '', cleaned_search_term, flags=re.IGNORECASE)
            
            # 3. Clean up any remaining leading/trailing dashes or spaces.
            cleaned_search_term = cleaned_search_term.strip(' -')

            print(f"🧹 Cleaned album search term: '{target_album_name}' -> '{cleaned_search_term}'")

            search_query = f"artist:{self.artist.name} album:{cleaned_search_term}"
            print(f"🔍 Searching Spotify for albums with query: '{search_query}'")
            
            spotify_albums = self.spotify_client.search_albums(search_query, limit=10)
            print(f"📊 Found {len(spotify_albums)} potential albums from Spotify search.")

            suggestions = []
            for album in spotify_albums:
                is_correct_artist = any(self.matching_engine.similarity_score(self.artist.name, art) > 0.85 for art in album.artists)
                
                if not is_correct_artist:
                    print(f"⚠️ Skipping album '{album.name}' as artist does not match '{self.artist.name}'")
                    continue

                confidence = self.matching_engine.similarity_score(
                    self.matching_engine.normalize_string(target_album_name),
                    self.matching_engine.normalize_string(album.name)
                )
                
                if self.matching_engine.normalize_string(cleaned_search_term) in self.matching_engine.normalize_string(album.name):
                    confidence = max(confidence, 0.95)
                
                if confidence >= 0.5:
                    print(f"✅ Found album match: '{album.name}' with confidence {confidence:.2f}")
                    suggestions.append(AlbumMatch(
                        album=album,
                        confidence=confidence,
                        match_reason="Direct album search"
                    ))

            # **IMPROVEMENT**: Intelligently de-duplicate results with the same name.
            # This prefers versions marked as 'album' and those with more tracks.
            unique_suggestions = {}
            for suggestion in suggestions:
                album_key = self.matching_engine.normalize_string(suggestion.album.name)
                
                if album_key not in unique_suggestions:
                    unique_suggestions[album_key] = suggestion
                else:
                    existing_suggestion = unique_suggestions[album_key]
                    is_new_better = False
                    
                    # Higher confidence is always better
                    if suggestion.confidence > existing_suggestion.confidence:
                        is_new_better = True
                    elif suggestion.confidence == existing_suggestion.confidence:
                        # 'album' type is preferred over 'single'
                        if suggestion.album.album_type == 'album' and existing_suggestion.album.album_type != 'album':
                            is_new_better = True
                        # More tracks is better if types are the same
                        elif suggestion.album.album_type == existing_suggestion.album.album_type and hasattr(suggestion.album, 'total_tracks') and hasattr(existing_suggestion.album, 'total_tracks') and suggestion.album.total_tracks > existing_suggestion.album.total_tracks:
                            is_new_better = True

                    if is_new_better:
                        print(f"🔄 Replacing duplicate album '{album_key}' with a better version (type: {suggestion.album.album_type}, tracks: {getattr(suggestion.album, 'total_tracks', 'N/A')})")
                        unique_suggestions[album_key] = suggestion
            
            final_suggestions = sorted(unique_suggestions.values(), key=lambda x: x.confidence, reverse=True)
            
            print(f"✅ Generated {len(final_suggestions)} final album suggestions.")
            self.suggestions_ready.emit(final_suggestions[:4])

        except Exception as e:
            print(f"❌ Error generating album suggestions: {e}")
            import traceback
            traceback.print_exc()
            self.suggestions_ready.emit([])


class BouncingDotsWidget(QWidget):
    """Animated bouncing dots loading indicator"""
    
    def __init__(self, parent=None):
        super().__init__(parent)
        self.setFixedSize(60, 20)
        self.dots = ['●', '●', '●']
        self._current_dot = 0
        
        # Animation setup
        self.setup_animation()
        
    def setup_animation(self):
        """Set up the bouncing animation sequence"""
        self.timer = QTimer()
        self.timer.timeout.connect(self.update_dots)
        
    def start_animation(self):
        """Start the bouncing animation"""
        self.timer.start(400)  # Update every 400ms for smoother bouncing
        
    def stop_animation(self):
        """Stop the bouncing animation"""
        if hasattr(self, 'timer'):
            self.timer.stop()
        self._current_dot = 0
        self.update()
        
    def update_dots(self):
        """Update which dot is bouncing"""
        self._current_dot = (self._current_dot + 1) % 3
        self.update()
        
    def get_current_dot(self):
        return self._current_dot
        
    def set_current_dot(self, value):
        self._current_dot = value
        self.update()
        
    # Create the Qt property for animation system
    current_dot = pyqtProperty(int, get_current_dot, set_current_dot)
        
    def paintEvent(self, event):
        """Custom paint event to draw the bouncing dots"""
        painter = QPainter(self)
        painter.setRenderHint(QPainter.RenderHint.Antialiasing)
        
        # Set color and font
        painter.setPen(QPen(Qt.GlobalColor.white, 2))
        font = painter.font()
        font.setPointSize(12)
        painter.setFont(font)
        
        # Draw three dots with bouncing effect
        dot_width = 20
        for i in range(3):
            x = i * dot_width
            y = 15 if i == self._current_dot else 10  # Bounce effect
            
            # Make current dot larger and brighter
            if i == self._current_dot:
                painter.setPen(QPen(Qt.GlobalColor.green, 3))
            else:
                painter.setPen(QPen(Qt.GlobalColor.gray, 2))
                
            painter.drawText(x, y, self.dots[i])

class SpinningCircleWidget(QWidget):
    """Animated spinning circle loading indicator"""
    
    def __init__(self, parent=None):
        super().__init__(parent)
        self.setFixedSize(60, 60)  # Increased from 30x30 to 60x60
        self._angle = 0
        
        # Animation setup
        self.animation = QPropertyAnimation(self, b"rotation_angle")
        self.animation.setDuration(1000)  # 1 second per rotation
        self.animation.setStartValue(0)
        self.animation.setEndValue(360)
        self.animation.setLoopCount(-1)  # Infinite loop
        self.animation.setEasingCurve(QEasingCurve.Type.Linear)
        
    def start_animation(self):
        """Start the spinning animation"""
        self.animation.start()
        
    def stop_animation(self):
        """Stop the spinning animation"""
        self.animation.stop()
        self._angle = 0
        self.update()
        
    def get_rotation_angle(self):
        return self._angle
        
    def set_rotation_angle(self, angle):
        self._angle = angle
        self.update()
        
    rotation_angle = pyqtProperty(float, get_rotation_angle, set_rotation_angle)
        
    def paintEvent(self, event):
        """Custom paint event to draw the spinning circle"""
        painter = QPainter(self)
        painter.setRenderHint(QPainter.RenderHint.Antialiasing)
        
        # Set up the painting area
        rect = self.rect()
        center_x = rect.width() // 2
        center_y = rect.height() // 2
        radius = min(center_x, center_y) - 2
        
        # Rotate the painter
        painter.translate(center_x, center_y)
        painter.rotate(self._angle)
        
        # Draw circle segments with varying opacity
        pen = QPen(Qt.GlobalColor.green, 3)
        painter.setPen(pen)
        
        # Draw 8 dots around the circle
        import math
        for i in range(8):
            angle_step = 2 * math.pi / 8
            dot_angle = i * angle_step
            
            # Calculate position for each dot
            x = radius * 0.7 * math.cos(dot_angle)
            y = radius * 0.7 * math.sin(dot_angle)
            
            # Fade effect - dots further from current position are dimmer
            distance = abs(i - (self._angle / 45)) % 8
            opacity = max(0.2, 1.0 - distance * 0.15)
            
            # Set color with proper opacity using QColor and alpha channel
            color = QColor(29, 185, 84)  # App's green theme color
            color.setAlpha(int(opacity * 255))  # Apply calculated opacity
            pen.setColor(color)
            painter.setPen(pen)
            
            painter.drawEllipse(int(x-2), int(y-2), 4, 4)

class AudioPlayer(QMediaPlayer):
    """Simple audio player for streaming music files"""
    playback_finished = pyqtSignal()
    playback_error = pyqtSignal(str)
    
    def __init__(self, parent=None):
        super().__init__(parent)
        
        # Set up audio output
        self.audio_output = QAudioOutput()
        self.setAudioOutput(self.audio_output)
        
        # Connect signals
        self.mediaStatusChanged.connect(self._on_media_status_changed)
        self.errorOccurred.connect(self._on_error_occurred)
        self.playbackStateChanged.connect(self._on_playback_state_changed)
        
        # Track current file
        self.current_file_path = None
        self.is_playing = False
    
    def _on_playback_state_changed(self, state):
        """Keep is_playing flag synchronized with actual playback state"""
        from PyQt6.QtMultimedia import QMediaPlayer
        state_names = {
            QMediaPlayer.PlaybackState.StoppedState: "STOPPED",
            QMediaPlayer.PlaybackState.PlayingState: "PLAYING", 
            QMediaPlayer.PlaybackState.PausedState: "PAUSED"
        }
        print(f"🎵 AudioPlayer state changed to: {state_names.get(state, 'UNKNOWN')}")
        self.is_playing = (state == QMediaPlayer.PlaybackState.PlayingState)
    
    def play_file(self, file_path):
        """Play an audio file from the given path"""
        try:
            if not file_path or not os.path.exists(file_path):
                self.playback_error.emit(f"File not found: {file_path}")
                return False
            
            # Stop any current playback
            self.stop()
            
            # Set the new media source
            self.current_file_path = file_path
            self.setSource(QUrl.fromLocalFile(file_path))
            
            # Start playback
            self.play()
            # is_playing will be set automatically by _on_playback_state_changed
            
            print(f"🎵 Started playing: {os.path.basename(file_path)}")
            return True
            
        except Exception as e:
            error_msg = f"Error playing audio file: {str(e)}"
            print(error_msg)
            self.playback_error.emit(error_msg)
            return False
    
    def toggle_playback(self):
        """Toggle between play and pause"""
        current_state = self.playbackState()
        print(f"🔄 toggle_playback() - Current state: {current_state}")
        print(f"🔄 toggle_playback() - Current source: {self.source().toString()}")
        
        if current_state == QMediaPlayer.PlaybackState.PlayingState:
            print("⏸️ AudioPlayer: Pausing playback")
            self.pause()
            # is_playing will be set automatically by _on_playback_state_changed
            return False  # Now paused
        else:
            print("▶️ AudioPlayer: Attempting to resume/play")
            
            # Check if we have a valid source to play
            if not self.source().isValid() and self.current_file_path:
                print(f"🔧 AudioPlayer: No source set, restoring from: {self.current_file_path}")
                self.setSource(QUrl.fromLocalFile(self.current_file_path))
            
            self.play()
            # is_playing will be set automatically by _on_playback_state_changed
            return True   # Now playing
    
    def stop_playback(self):
        """Stop playback and reset"""
        print("⏹️ AudioPlayer: stop_playback() called")
        self.stop()
        # is_playing will be set automatically by _on_playback_state_changed
        self.release_file()
    
    def release_file(self, clear_file_path=True):
        """Release the current file handle by clearing the media source
        
        Args:
            clear_file_path (bool): Whether to clear the stored file path.
                                  Set to False to keep the path for potential resuming.
        """
        print(f"🔓 AudioPlayer: release_file() called - clearing source: {self.source().toString()}")
        self.setSource(QUrl())  # Clear the media source to release file handle
        if clear_file_path:
            self.current_file_path = None
        print("🔓 Released audio file handle")
    
    def _on_media_status_changed(self, status):
        """Handle media status changes"""
        if status == QMediaPlayer.MediaStatus.EndOfMedia:
            print("🎵 Playback finished")
            # is_playing will be set automatically by _on_playback_state_changed
            self.playback_finished.emit()
        elif status == QMediaPlayer.MediaStatus.InvalidMedia:
            error_msg = "Invalid media file or unsupported format"
            print(f"❌ {error_msg}")
            # is_playing will be set automatically by _on_playback_state_changed
            self.playback_error.emit(error_msg)
    
    def _on_error_occurred(self, error, error_string):
        """Handle playback errors"""
        error_msg = f"Audio playback error: {error_string}"
        print(f"❌ {error_msg}")
        # is_playing will be set automatically by _on_playback_state_changed
        self.playback_error.emit(error_msg)

class DownloadThread(QThread):
    download_completed = pyqtSignal(str, object)  # Download ID or success message, download_item
    download_failed = pyqtSignal(str, object)  # Error message, download_item
    download_progress = pyqtSignal(str, object)  # Progress message, download_item
    
    def __init__(self, soulseek_client, search_result, download_item):
        super().__init__()
        self.soulseek_client = soulseek_client
        self.search_result = search_result
        self.download_item = download_item
        self._stop_requested = False
        
    def run(self):
        loop = None
        try:
            import asyncio
            self.download_progress.emit(f"Starting download: {self.search_result.filename}", self.download_item)
            
            # Create a completely fresh event loop for this thread
            loop = asyncio.new_event_loop()
            asyncio.set_event_loop(loop)
            
            # Perform download with proper error handling
            download_id = loop.run_until_complete(self._do_download())
            
            if not self._stop_requested:
                if download_id:
                    self.download_completed.emit(f"Download started: {download_id}", self.download_item)
                else:
                    self.download_failed.emit("Download failed to start", self.download_item)
                
                # Give signals time to be processed before thread exits
                import time
                time.sleep(0.1)
            
        except Exception as e:
            if not self._stop_requested:
                self.download_failed.emit(str(e), self.download_item)
                # Give error signal time to be processed
                import time
                time.sleep(0.1)
        finally:
            # Ensure proper cleanup
            if loop:
                try:
                    # Close any remaining tasks
                    pending = asyncio.all_tasks(loop)
                    for task in pending:
                        task.cancel()
                    
                    if pending:
                        loop.run_until_complete(asyncio.gather(*pending, return_exceptions=True))
                    
                    loop.close()
                except Exception as e:
                    print(f"Error cleaning up download event loop: {e}")
    
    async def _do_download(self):
        """Perform the actual download with proper async handling"""
        return await self.soulseek_client.download(
            self.search_result.username, 
            self.search_result.filename,
            self.search_result.size
        )
    
    def stop(self):
        """Stop the download gracefully"""
        self._stop_requested = True

class SessionInfoThread(QThread):
    session_info_completed = pyqtSignal(dict)  # Session info dict
    session_info_failed = pyqtSignal(str)  # Error message
    
    def __init__(self, soulseek_client):
        super().__init__()
        self.soulseek_client = soulseek_client
        self._stop_requested = False
        
    def run(self):
        loop = None
        try:
            import asyncio
            
            # Create a completely fresh event loop for this thread
            loop = asyncio.new_event_loop()
            asyncio.set_event_loop(loop)
            
            # Check if stop was requested before starting
            if self._stop_requested:
                return
            
            # Get session info
            session_info = loop.run_until_complete(self._get_session_info())
            
            # Only emit if not stopped
            if not self._stop_requested:
                self.session_info_completed.emit(session_info or {})
            
        except Exception as e:
            if not self._stop_requested:
                self.session_info_failed.emit(str(e))
        finally:
            # Ensure proper cleanup
            if loop:
                try:
                    # Close any remaining tasks
                    pending = asyncio.all_tasks(loop)
                    for task in pending:
                        task.cancel()
                    
                    if pending:
                        loop.run_until_complete(asyncio.gather(*pending, return_exceptions=True))
                    
                    loop.close()
                except Exception as e:
                    print(f"Error cleaning up session info event loop: {e}")
    
    async def _get_session_info(self):
        """Get the session information"""
        return await self.soulseek_client.get_session_info()
    
    def stop(self):
        """Stop the session info gathering gracefully"""
        self._stop_requested = True

class ExploreApiThread(QThread):
    exploration_completed = pyqtSignal(dict)  # API info dict
    exploration_failed = pyqtSignal(str)  # Error message
    
    def __init__(self, soulseek_client):
        super().__init__()
        self.soulseek_client = soulseek_client
        self._stop_requested = False
        
    def run(self):
        loop = None
        try:
            import asyncio
            
            # Create a completely fresh event loop for this thread
            loop = asyncio.new_event_loop()
            asyncio.set_event_loop(loop)
            
            # Check if stop was requested before starting
            if self._stop_requested:
                return
            
            # Explore the API
            api_info = loop.run_until_complete(self._explore_api())
            
            # Only emit if not stopped
            if not self._stop_requested:
                self.exploration_completed.emit(api_info)
            
        except Exception as e:
            if not self._stop_requested:
                self.exploration_failed.emit(str(e))
        finally:
            # Ensure proper cleanup
            if loop:
                try:
                    # Close any remaining tasks
                    pending = asyncio.all_tasks(loop)
                    for task in pending:
                        task.cancel()
                    
                    if pending:
                        loop.run_until_complete(asyncio.gather(*pending, return_exceptions=True))
                    
                    loop.close()
                except Exception as e:
                    print(f"Error cleaning up exploration event loop: {e}")
    
    async def _explore_api(self):
        """Perform the actual API exploration"""
        return await self.soulseek_client.explore_api_endpoints()
    
    def stop(self):
        """Stop the exploration gracefully"""
        self._stop_requested = True

class TransferStatusThread(QThread):
    """Thread for fetching real-time download transfer status from slskd API"""
    transfer_status_completed = pyqtSignal(object)  # Transfer data from API
    transfer_status_failed = pyqtSignal(str)  # Error message
    
    def __init__(self, soulseek_client):
        super().__init__()
        self.soulseek_client = soulseek_client
        self._stop_requested = False
        
    def run(self):
        loop = None
        try:
            import asyncio
            
            # Create a fresh event loop for this thread
            loop = asyncio.new_event_loop()
            asyncio.set_event_loop(loop)
            
            # Check if stop was requested before starting
            if self._stop_requested:
                return
            
            # Get transfer status data from /api/v0/transfers/downloads
            transfer_data = loop.run_until_complete(self._get_transfer_status())
            
            # Only emit if not stopped
            if not self._stop_requested:
                self.transfer_status_completed.emit(transfer_data or [])
            
        except Exception as e:
            if not self._stop_requested:
                self.transfer_status_failed.emit(str(e))
        finally:
            # Ensure proper cleanup
            if loop:
                try:
                    # Close any remaining tasks
                    pending = asyncio.all_tasks(loop)
                    for task in pending:
                        task.cancel()
                    
                    if pending:
                        loop.run_until_complete(asyncio.gather(*pending, return_exceptions=True))
                    
                    loop.close()
                except Exception as e:
                    print(f"Error cleaning up transfer status event loop: {e}")
    
    async def _get_transfer_status(self):
        """Get the transfer status from slskd API"""
        try:
            # Use the soulseek client's _make_request method to get transfer data
            response_data = await self.soulseek_client._make_request('GET', 'transfers/downloads')
            return response_data
        except Exception as e:
            print(f"Error fetching transfer status: {e}")
            return []
    
    def stop(self):
        """Stop the transfer status gathering gracefully"""
        self._stop_requested = True

class ApiCleanupThread(QThread):
    """Thread for signaling download completion to slskd API without blocking UI"""
    cleanup_completed = pyqtSignal(bool, str, str)  # success, download_id, username
    
    def __init__(self, soulseek_client, download_id, username):
        super().__init__()
        self.soulseek_client = soulseek_client
        self.download_id = download_id
        self.username = username
        
    def run(self):
        """Signal download completion in background thread"""
        loop = None
        try:
            import asyncio
            
            # Create a fresh event loop for this thread
            loop = asyncio.new_event_loop()
            asyncio.set_event_loop(loop)
            
            # Signal download completion
            success = loop.run_until_complete(
                self.soulseek_client.signal_download_completion(
                    self.download_id, 
                    self.username, 
                    remove=True
                )
            )
            
            # Emit completion signal
            self.cleanup_completed.emit(success, self.download_id, self.username)
            
        except Exception as e:
            print(f"⚠️ Error in API cleanup thread: {e}")
            self.cleanup_completed.emit(False, self.download_id, self.username)
        finally:
            # Ensure proper cleanup
            if loop:
                try:
                    # Close any remaining tasks
                    pending = asyncio.all_tasks(loop)
                    for task in pending:
                        task.cancel()
                    
                    if pending:
                        loop.run_until_complete(asyncio.gather(*pending, return_exceptions=True))
                    
                    loop.close()
                except Exception as e:
                    print(f"Error cleaning up API cleanup event loop: {e}")

class SearchThread(QThread):
    search_completed = pyqtSignal(object)  # Tuple of (tracks, albums) or list for backward compatibility
    search_failed = pyqtSignal(str)  # Error message
    search_progress = pyqtSignal(str)  # Progress message
    search_results_partial = pyqtSignal(object, object, int)  # tracks, albums, response count
    
    def __init__(self, soulseek_client, query):
        super().__init__()
        self.soulseek_client = soulseek_client
        self.query = query
        self._stop_requested = False
        
    def progress_callback(self, tracks, albums, response_count):
        """Callback function for progressive search results"""
        if not self._stop_requested:
            # Emit live results immediately
            self.search_results_partial.emit(tracks, albums, response_count)
            # Update progress message with current count
            self.search_progress.emit(f"Found {len(tracks)} tracks, {len(albums)} albums from {response_count} responses")
        
    def run(self):
        loop = None
        try:
            import asyncio
            self.search_progress.emit(f"Searching for: {self.query}")
            
            # Create a completely fresh event loop for this thread
            loop = asyncio.new_event_loop()
            asyncio.set_event_loop(loop)
            
            # Perform search with progressive callback
            results = loop.run_until_complete(self._do_search())
            
            if not self._stop_requested:
                # Emit final completion with proper tuple format
                # results should be a tuple (tracks, albums) from the search client
                self.search_completed.emit(results)
            
        except Exception as e:
            if not self._stop_requested:
                self.search_failed.emit(str(e))
        finally:
            # Ensure proper cleanup
            if loop:
                try:
                    # Close any remaining tasks
                    pending = asyncio.all_tasks(loop)
                    for task in pending:
                        task.cancel()
                    
                    if pending:
                        loop.run_until_complete(asyncio.gather(*pending, return_exceptions=True))
                    
                    loop.close()
                except Exception as e:
                    print(f"Error cleaning up event loop: {e}")
    
    async def _do_search(self):
        """Perform the actual search with progressive callback"""
        return await self.soulseek_client.search(self.query, progress_callback=self.progress_callback)
    
    def stop(self):
        """Stop the search gracefully"""
        self._stop_requested = True

class TrackedStatusUpdateThread(QThread):
    """Tracked status update thread that can be properly stopped and cleaned up"""
    status_updated = pyqtSignal(list)
    
    def __init__(self, soulseek_client, parent=None):
        super().__init__(parent)
        self.soulseek_client = soulseek_client
        self._stop_requested = False
        
    def run(self):
        loop = None
        try:
            import asyncio
            
            # Check if stop was requested before starting
            if self._stop_requested:
                return
                
            loop = asyncio.new_event_loop()
            asyncio.set_event_loop(loop)
            downloads = loop.run_until_complete(self.soulseek_client.get_all_downloads())
            
            # Only emit if not stopped
            if not self._stop_requested:
                self.status_updated.emit(downloads or [])
                
        except Exception as e:
            if not self._stop_requested:
                print(f"Error fetching download status: {e}")
                self.status_updated.emit([])
        finally:
            # Ensure proper cleanup
            if loop:
                try:
                    # Close any remaining tasks
                    pending = asyncio.all_tasks(loop)
                    for task in pending:
                        task.cancel()
                    
                    if pending:
                        loop.run_until_complete(asyncio.gather(*pending, return_exceptions=True))
                    
                    loop.close()
                except Exception as e:
                    print(f"Error cleaning up status update event loop: {e}")
    
    def stop(self):
        """Stop the status update thread gracefully"""
        self._stop_requested = True

class StreamingThread(QThread):
    """Thread for streaming audio files without saving them permanently"""
    streaming_started = pyqtSignal(str, object)  # Message, search_result
    streaming_finished = pyqtSignal(str, object)  # Message, search_result  
    streaming_failed = pyqtSignal(str, object)   # Error message, search_result
    streaming_progress = pyqtSignal(float, object)  # Progress percentage (0-100), search_result
    streaming_queued = pyqtSignal(str, object)  # Queue message, search_result
    
    def __init__(self, soulseek_client, search_result):
        super().__init__()
        self.soulseek_client = soulseek_client
        self.search_result = search_result
        self._stop_requested = False
        
    def run(self):
        loop = None
        try:
            import asyncio
            import os
            import time
            import shutil
            import glob
            from pathlib import Path
            
            self.streaming_started.emit(f"Starting stream: {self.search_result.filename}", self.search_result)
            
            # Create a fresh event loop for this thread
            loop = asyncio.new_event_loop()
            asyncio.set_event_loop(loop)
            
            # Get paths
            from config.settings import config_manager
            download_path = config_manager.get('soulseek.download_path', './downloads')
            
            # Use the Stream folder in project root (not inside downloads)
            project_root = os.path.dirname(os.path.dirname(os.path.dirname(__file__)))  # Go up from ui/pages/
            stream_folder = os.path.join(project_root, 'Stream')
            
            # Ensure Stream directory exists
            os.makedirs(stream_folder, exist_ok=True)
            
            # Clear any existing files in Stream folder (only one file at a time)
            for existing_file in glob.glob(os.path.join(stream_folder, '*')):
                try:
                    if os.path.isfile(existing_file):
                        os.remove(existing_file)
                    elif os.path.isdir(existing_file):
                        shutil.rmtree(existing_file)
                except Exception as e:
                    print(f"Warning: Could not remove existing stream file: {e}")
            
            # Start the download (goes to normal downloads folder initially)
            download_result = loop.run_until_complete(self._do_stream_download())
            
            if not self._stop_requested:
                if download_result:
                    self.streaming_started.emit(f"Downloading for stream: {self.search_result.filename}", self.search_result)
                    
                    # Standard streaming - wait for complete download
                    max_wait_time = 45  # Wait up to 45 seconds
                    poll_interval = 2   # Check every 2 seconds
                    
                    last_progress_sent = 0.0
                    found_file = None  # Initialize found_file outside the loop
                    
                    # Queue state tracking
                    queue_start_time = None
                    queue_timeout = 15.0  # 15 seconds max in queue
                    last_download_state = None
                    actively_downloading = False
                    
                    for wait_count in range(max_wait_time // poll_interval):
                        if self._stop_requested:
                            break
                            
                        # Only use real API progress data - no time-based estimation
                        
                        # Check download progress via slskd API
                        api_progress = None
                        download_state = None
                        try:
                            # Use the same API call as download queue monitoring for consistency
                            transfers_data = loop.run_until_complete(self.soulseek_client._make_request('GET', 'transfers/downloads'))
                            download_status = self._find_streaming_download_in_transfers(transfers_data)
                            if download_status:
                                api_progress = download_status.get('percentComplete', 0)
                                download_state = download_status.get('state', '').lower()
                                print(f"API Download - State: {download_status.get('state')}, Progress: {api_progress:.1f}%")
                                
                                # Categorize download state (aligned with download queue logic)
                                original_state = download_status.get('state', '')  # Keep original case for completion check
                                is_queued = any(keyword in download_state for keyword in ['queued', 'initializing', 'remote'])
                                is_downloading = 'inprogress' in download_state
                                is_completed = ('Succeeded' in original_state or ('Completed' in original_state and 'Errored' not in original_state)) or api_progress >= 100
                                
                                # Track queue state timing
                                if is_queued and queue_start_time is None:
                                    queue_start_time = time.time()
                                    print(f"📋 Download entered queue state: {original_state}")
                                    self.streaming_queued.emit(f"Queuing with uploader...", self.search_result)
                                elif is_downloading and not actively_downloading:
                                    actively_downloading = True
                                    queue_start_time = None  # Reset queue timer
                                    print(f"🚀 Download started actively downloading: {original_state}")
                                    # Emit a progress update to indicate downloading has started
                                    if api_progress > 0:
                                        self.streaming_progress.emit(api_progress, self.search_result)
                                
                                # Check for queue timeout
                                if is_queued and queue_start_time:
                                    queue_elapsed = time.time() - queue_start_time
                                    if queue_elapsed > queue_timeout:
                                        print(f"⏰ Queue timeout after {queue_elapsed:.1f}s - download stuck in queue")
                                        self.streaming_failed.emit(f"Queue timeout - uploader not responding. Try another source.", self.search_result)
                                        return
                                
                                # Check if download is complete
                                if is_completed:
                                    print(f"✓ Download completed via API status: {original_state}")
                                    # Try to find the actual file - with retries for file system sync
                                    for retry_count in range(5):  # Try up to 5 times with delays
                                        found_file = self._find_downloaded_file(download_path)
                                        if found_file:
                                            print(f"✓ Found completed file after {retry_count} retries: {found_file}")
                                            break
                                        else:
                                            print(f"⏳ File not found yet, waiting... (retry {retry_count + 1}/5)")
                                            time.sleep(1)  # Wait 1 second for file system to sync
                                    
                                    if found_file:
                                        print(f"✓ Found downloaded file: {found_file}")
                                        
                                        # Move the file to Stream folder with original filename
                                        original_filename = os.path.basename(found_file)
                                        stream_path = os.path.join(stream_folder, original_filename)
                                        
                                        try:
                                            # Move file to Stream folder
                                            shutil.move(found_file, stream_path)
                                            print(f"✓ Moved file to stream folder: {stream_path}")
                                            
                                            # Clean up empty directories left behind
                                            self._cleanup_empty_directories(download_path, found_file)
                                            
                                            # Signal that streaming is ready (100% progress)
                                            self.streaming_progress.emit(100.0, self.search_result)
                                            self.streaming_finished.emit(f"Stream ready: {os.path.basename(found_file)}", self.search_result)
                                            self.temp_file_path = stream_path
                                            print(f"✓ Stream file ready for playback: {stream_path}")
                                            
                                            # Signal API that download is complete
                                            try:
                                                download_id = download_status.get('id', '')
                                                if download_id and self.search_result.username:
                                                    import asyncio
                                                    from services.service_manager import service_manager
                                                    soulseek_client = service_manager.get_soulseek_client()
                                                    if soulseek_client:
                                                        # Run the async API call
                                                        loop = asyncio.new_event_loop()
                                                        asyncio.set_event_loop(loop)
                                                        success = loop.run_until_complete(
                                                            soulseek_client.signal_download_completion(download_id, self.search_result.username, remove=True)
                                                        )
                                                        loop.close()
                                                        if success:
                                                            print(f"✓ Successfully signaled completion for download {download_id}")
                                                        else:
                                                            print(f"⚠️ Failed to signal completion for download {download_id}")
                                            except Exception as e:
                                                print(f"⚠️ Error signaling download completion: {e}")
                                            
                                            break  # Exit main polling loop
                                            
                                        except Exception as e:
                                            print(f"Error moving file to stream folder: {e}")
                                            self.streaming_failed.emit(f"Failed to prepare stream file: {e}", self.search_result)
                                            break
                                else:
                                    # Handle progress updates for active downloads
                                    if is_downloading and actively_downloading and api_progress is not None and api_progress > 0:
                                        if api_progress != last_progress_sent:
                                            self.streaming_progress.emit(api_progress, self.search_result)
                                            print(f"Progress update: {api_progress:.1f}% (Real API data)")
                                            last_progress_sent = api_progress
                        except Exception as e:
                            print(f"Warning: Could not check download progress: {e}")
                            # Continue to next iteration if API call fails
                            continue
                        
                        # Search for the downloaded file in the downloads directory
                        found_file = self._find_downloaded_file(download_path)
                        
                        if found_file:
                            print(f"✓ Found downloaded file: {found_file}")
                            
                            # Move the file to Stream folder with original filename
                            original_filename = os.path.basename(found_file)
                            stream_path = os.path.join(stream_folder, original_filename)
                            
                            try:
                                # Move file to Stream folder
                                shutil.move(found_file, stream_path)
                                print(f"✓ Moved file to stream folder: {stream_path}")
                                
                                # Clean up empty directories left behind
                                self._cleanup_empty_directories(download_path, found_file)
                                
                                # Signal that streaming is ready (100% progress)
                                self.streaming_progress.emit(100.0, self.search_result)
                                self.streaming_finished.emit(f"Stream ready: {os.path.basename(found_file)}", self.search_result)
                                self.temp_file_path = stream_path
                                print(f"✓ Stream file ready for playback: {stream_path}")
                                break
                                
                            except Exception as e:
                                print(f"Error moving file to stream folder: {e}")
                                self.streaming_failed.emit(f"Failed to prepare stream file: {e}", self.search_result)
                                break
                        else:
                            # Still downloading, wait a bit more
                            print(f"Waiting for download to complete... ({wait_count * poll_interval}s elapsed)")
                            time.sleep(poll_interval)
                    else:
                        # Timed out waiting for file
                        print(f"❌ Polling loop completed, timeout reached. found_file = {found_file}")
                        self.streaming_failed.emit("Stream download timed out - file not found", self.search_result)
                        
                else:
                    self.streaming_failed.emit("Streaming failed to start", self.search_result)
                
        except Exception as e:
            if not self._stop_requested:
                self.streaming_failed.emit(str(e), self.search_result)
        finally:
            # Ensure proper cleanup
            if loop:
                try:
                    # Close any remaining tasks
                    pending = asyncio.all_tasks(loop)
                    for task in pending:
                        task.cancel()
                    
                    if pending:
                        loop.run_until_complete(asyncio.gather(*pending, return_exceptions=True))
                    
                    loop.close()
                except Exception as e:
                    print(f"Error cleaning up streaming event loop: {e}")
    
    def _find_streaming_download_in_transfers(self, transfers_data):
        """Find streaming download in transfer data using same logic as download queue"""
        try:
            if not transfers_data:
                return None
                
            # Flatten the transfers data structure (same as download queue logic)
            all_transfers = []
            for user_data in transfers_data:
                if 'directories' in user_data:
                    for directory in user_data['directories']:
                        if 'files' in directory:
                            all_transfers.extend(directory['files'])
            
            # Look for our specific file by filename and username
            target_filename = os.path.basename(self.search_result.filename)
            target_username = self.search_result.username
            
            print(f"🔍 Looking for streaming download - Target: {target_username}:{target_filename}")
            print(f"🔍 Found {len(all_transfers)} total transfers in API")
            
            for i, transfer in enumerate(all_transfers):
                transfer_filename = os.path.basename(transfer.get('filename', ''))
                transfer_username = transfer.get('username', '')
                
                print(f"📁 Transfer {i+1}: {transfer_username}:{transfer_filename} - State: {transfer.get('state')} - Progress: {transfer.get('percentComplete', 0):.1f}%")
                
                if (transfer_filename == target_filename and 
                    transfer_username == target_username):
                    print(f"✅ Found matching streaming download: {transfer.get('state')} - {transfer.get('percentComplete', 0):.1f}%")
                    return transfer
            
            print(f"❌ No matching streaming download found for {target_username}:{target_filename}")
            return None
        except Exception as e:
            print(f"Error finding streaming download in transfers: {e}")
            return None
    
    def _find_downloaded_file(self, download_path):
        """Find the downloaded audio file in the downloads directory tree"""
        import os
        
        # Audio file extensions to look for
        audio_extensions = {'.mp3', '.flac', '.ogg', '.aac', '.wma', '.wav', '.m4a'}
        
        # Get the base filename without path
        target_filename = os.path.basename(self.search_result.filename)
        
        try:
            # Walk through the downloads directory to find the file
            for root, dirs, files in os.walk(download_path):
                for file in files:
                    # Check if this is our target file
                    if file == target_filename:
                        file_path = os.path.join(root, file)
                        # Verify it's an audio file and has content
                        if (os.path.splitext(file)[1].lower() in audio_extensions and 
                            os.path.getsize(file_path) > 1024):  # At least 1KB
                            return file_path
                    
                    # Also check for any audio files that might match partially
                    # (in case filename is slightly different)
                    file_lower = file.lower()
                    target_lower = target_filename.lower()
                    
                    # Remove common variations
                    target_clean = target_lower.replace(' ', '').replace('-', '').replace('_', '')
                    file_clean = file_lower.replace(' ', '').replace('-', '').replace('_', '')
                    
                    if (os.path.splitext(file)[1].lower() in audio_extensions and
                        len(file_clean) > 10 and  # Reasonable filename length
                        (target_clean in file_clean or file_clean in target_clean) and
                        os.path.getsize(os.path.join(root, file)) > 1024):
                        return os.path.join(root, file)
                        
        except Exception as e:
            print(f"Error searching for downloaded file: {e}")
            
        return None
    
    def _cleanup_empty_directories(self, download_path, moved_file_path):
        """Clean up empty directories left after moving a file"""
        import os
        
        try:
            # Get the directory that contained the moved file
            file_dir = os.path.dirname(moved_file_path)
            
            # Only clean up if it's a subdirectory of downloads (not the downloads folder itself)
            if file_dir != download_path and file_dir.startswith(download_path):
                # Check if directory is empty
                if os.path.isdir(file_dir) and not os.listdir(file_dir):
                    print(f"Removing empty directory: {file_dir}")
                    os.rmdir(file_dir)
                    
                    # Recursively check parent directories
                    parent_dir = os.path.dirname(file_dir)
                    if (parent_dir != download_path and 
                        parent_dir.startswith(download_path) and
                        os.path.isdir(parent_dir) and 
                        not os.listdir(parent_dir)):
                        print(f"Removing empty parent directory: {parent_dir}")
                        os.rmdir(parent_dir)
                        
        except Exception as e:
            print(f"Warning: Could not clean up empty directories: {e}")
    
    async def _do_stream_download(self):
        """Perform the streaming download using normal download mechanism"""
        # Use the same download mechanism as regular downloads
        # The file will be downloaded to the normal downloads folder first
        return await self.soulseek_client.download(
            self.search_result.username, 
            self.search_result.filename,
            self.search_result.size
        )
    
    
    def stop(self):
        """Stop the streaming gracefully"""
        self._stop_requested = True

class TrackItem(QFrame):
    """Individual track item within an album"""
    track_download_requested = pyqtSignal(object)  # TrackResult object
    track_stream_requested = pyqtSignal(object)    # TrackResult object
    
    def __init__(self, track_result, parent=None):
        super().__init__(parent)
        self.track_result = track_result
        self.setup_ui()
    
    def setup_ui(self):
        self.setFixedHeight(50)
        self.setSizePolicy(QSizePolicy.Policy.Expanding, QSizePolicy.Policy.Fixed)
        
        self.setStyleSheet("""
            TrackItem {
                background: rgba(40, 40, 40, 0.5);
                border-radius: 8px;
                border: 1px solid rgba(60, 60, 60, 0.3);
                margin: 2px 8px;
            }
            TrackItem:hover {
                background: rgba(50, 50, 50, 0.7);
                border: 1px solid rgba(29, 185, 84, 0.5);
            }
        """)
        
        layout = QHBoxLayout(self)
        layout.setContentsMargins(12, 8, 12, 8)
        layout.setSpacing(12)
        
        # Track info
        track_info = QVBoxLayout()
        track_info.setSpacing(2)
        
        # Track title
        title = QLabel(self.track_result.title or "Unknown Title")
        title.setFont(QFont("Arial", 11, QFont.Weight.Bold))
        title.setStyleSheet("color: #ffffff;")
        
        # Track details - enhanced with more information including prominent artist display
        details = []
        if self.track_result.track_number:
            details.append(f"#{self.track_result.track_number:02d}")
        
        # Always show artist information prominently for tracks within albums
        if self.track_result.artist:
            details.append(f"🎤 {self.track_result.artist}")
        
        details.append(self.track_result.quality.upper())
        if self.track_result.bitrate:
            details.append(f"{self.track_result.bitrate}kbps")
        
        # Add duration if available
        if self.track_result.duration:
            duration_mins = self.track_result.duration // 60
            duration_secs = self.track_result.duration % 60
            details.append(f"{duration_mins}:{duration_secs:02d}")
        
        details.append(f"{self.track_result.size // (1024*1024)}MB")
        
        details_text = " • ".join(details)
        track_details = QLabel(details_text)
        track_details.setFont(QFont("Arial", 9))
        track_details.setStyleSheet("color: rgba(179, 179, 179, 0.8);")
        
        track_info.addWidget(title)
        track_info.addWidget(track_details)
        
        # Control buttons
        button_layout = QHBoxLayout()
        button_layout.setSpacing(8)
        
        # Play button
        play_btn = QPushButton("▶️")
        play_btn.setFixedSize(32, 32)
        play_btn.clicked.connect(self.request_stream)
        play_btn.setStyleSheet("""
            QPushButton {
                background: rgba(29, 185, 84, 0.8);
                border: none;
                border-radius: 16px;
                color: #000000;
                font-size: 12px;
                font-weight: bold;
            }
            QPushButton:hover {
                background: rgba(30, 215, 96, 1.0);
            }
        """)
        
        # Download button  
        download_btn = QPushButton("⬇️")
        download_btn.setFixedSize(32, 32)
        download_btn.clicked.connect(self.request_download)
        download_btn.setStyleSheet("""
            QPushButton {
                background: rgba(64, 64, 64, 0.8);
                border: 1px solid rgba(29, 185, 84, 0.6);
                border-radius: 16px;
                color: #1db954;
                font-size: 10px;
            }
            QPushButton:hover {
                background: rgba(29, 185, 84, 0.2);
            }
        """)
        
        # Matched Download button
        matched_download_btn = QPushButton("📱")
        matched_download_btn.setFixedSize(32, 32)
        matched_download_btn.clicked.connect(self.request_matched_download)
        matched_download_btn.setToolTip("Download with Spotify Matching")
        matched_download_btn.setStyleSheet("""
            QPushButton {
                background: rgba(64, 64, 64, 0.8);
                border: 1px solid rgba(147, 51, 234, 0.6);
                border-radius: 16px;
                color: #9333ea;
                font-size: 10px;
            }
            QPushButton:hover {
                background: rgba(147, 51, 234, 0.2);
            }
        """)
        
        button_layout.addWidget(play_btn)
        button_layout.addWidget(download_btn)
        button_layout.addWidget(matched_download_btn)
        
        # Store button references for state management
        self.play_btn = play_btn
        self.download_btn = download_btn
        self.matched_download_btn = matched_download_btn
        
        # Assembly
        layout.addLayout(track_info, 1)
        layout.addLayout(button_layout)
    
    def request_stream(self):
        """Request streaming of this track"""
        self.track_stream_requested.emit(self.track_result)
    
    def request_download(self):
        """Request download of this track"""
        self.track_download_requested.emit(self.track_result)
    
    def request_matched_download(self):
        """Request a matched download with Spotify integration"""
        # Get reference to the DownloadsPage to handle matched download
        downloads_page = self.get_downloads_page()
        if downloads_page:
            downloads_page.start_matched_download(self.track_result)
    
    def get_downloads_page(self):
        """Get reference to the parent DownloadsPage"""
        parent = self.parent()
        while parent:
            if hasattr(parent, 'audio_player'):  # DownloadsPage has audio_player
                return parent
            parent = parent.parent()
        return None
    
    def set_loading_state(self):
        """Set play button to loading state"""
        self.play_btn.setText("⏳")
        self.play_btn.setEnabled(False)
    
    def set_queue_state(self):
        """Set play button to queue state"""
        self.play_btn.setText("📋")
        self.play_btn.setEnabled(False)
        self.play_btn.setStyleSheet("""
            QPushButton {
                background: rgba(255, 165, 0, 0.2);
                border: 1px solid rgba(255, 165, 0, 0.4);
                border-radius: 18px;
                color: rgba(255, 165, 0, 0.8);
                font-size: 12px;
            }
        """)
    
    def set_download_queued_state(self):
        """Set download button to queued state (disabled, shows queued)"""
        self.download_btn.setText("⏳")
        self.download_btn.setEnabled(False)
        self.download_btn.setStyleSheet("""
            QPushButton {
                background: rgba(100, 100, 100, 0.5);
                border: 1px solid rgba(150, 150, 150, 0.3);
                border-radius: 16px;
                color: rgba(255, 255, 255, 0.6);
                font-size: 10px;
            }
        """)
    
    def set_download_downloading_state(self):
        """Set download button to downloading state"""
        self.download_btn.setText("📥")
        self.download_btn.setEnabled(False)
        self.download_btn.setStyleSheet("""
            QPushButton {
                background: rgba(29, 185, 84, 0.3);
                border: 1px solid rgba(29, 185, 84, 0.6);
                border-radius: 16px;
                color: #1db954;
                font-size: 10px;
            }
        """)
    
    def set_download_completed_state(self):
        """Set download button to completed state"""
        self.download_btn.setText("✅")
        self.download_btn.setEnabled(False)
        self.download_btn.setStyleSheet("""
            QPushButton {
                background: rgba(40, 167, 69, 0.3);
                border: 1px solid rgba(40, 167, 69, 0.6);
                border-radius: 16px;
                color: #28a745;
                font-size: 10px;
            }
        """)
    
    def reset_download_state(self):
        """Reset download button to default state"""
        self.download_btn.setText("⬇️")
        self.download_btn.setEnabled(True)
        self.download_btn.setStyleSheet("""
            QPushButton {
                background: rgba(64, 64, 64, 0.8);
                border: 1px solid rgba(29, 185, 84, 0.6);
                border-radius: 16px;
                color: #1db954;
                font-size: 10px;
            }
            QPushButton:hover {
                background: rgba(29, 185, 84, 0.2);
            }
        """)
    
    def set_playing_state(self):
        """Set play button to playing/pause state"""
        self.play_btn.setText("⏸️")
        self.play_btn.setEnabled(True)
    
    def reset_play_state(self):
        """Reset play button to default state"""
        self.play_btn.setText("▶️")
        self.play_btn.setEnabled(True)

class AlbumResultItem(QFrame):
    """Expandable UI component for displaying album search results"""
    album_download_requested = pyqtSignal(object)  # AlbumResult object
    matched_album_download_requested = pyqtSignal(object)  # AlbumResult object for matched download
    track_download_requested = pyqtSignal(object)  # TrackResult object  
    track_stream_requested = pyqtSignal(object, object)  # TrackResult object, TrackItem object
    
    def __init__(self, album_result, parent=None):
        super().__init__(parent)
        self.album_result = album_result
        self.is_expanded = False
        self.track_items = []
        self.tracks_container = None
        self.setup_ui()
    
    def setup_ui(self):
        # Dynamic height based on expansion state with better proportions
        self.collapsed_height = 110  # Increased from 80px for better breathing room
        self.setFixedHeight(self.collapsed_height)
        self.setSizePolicy(QSizePolicy.Policy.Expanding, QSizePolicy.Policy.Fixed)
        
        # Enable mouse tracking for click detection
        self.setMouseTracking(True)
        
        self.setStyleSheet("""
            AlbumResultItem {
                background: qlineargradient(x1:0, y1:0, x2:0, y2:1,
                    stop:0 rgba(52, 52, 58, 0.95),
                    stop:1 rgba(42, 42, 48, 0.98));
                border-radius: 20px;
                border: 1px solid rgba(75, 75, 82, 0.5);
                margin: 10px 5px;
            }
            AlbumResultItem:hover {
                background: qlineargradient(x1:0, y1:0, x2:0, y2:1,
                    stop:0 rgba(60, 60, 68, 0.98),
                    stop:1 rgba(50, 50, 58, 1.0));
                border: 1px solid rgba(29, 185, 84, 0.8);
            }
        """)
        
        # Main vertical layout for album header + tracks
        main_layout = QVBoxLayout(self)
        main_layout.setContentsMargins(0, 0, 0, 0)
        main_layout.setSpacing(0)
        
        # Album header (always visible, clickable)
        self.header_widget = QWidget()
        self.header_widget.setFixedHeight(90)  # Increased to match collapsed_height
        self.header_widget.setStyleSheet("QWidget { background: transparent; }")
        header_layout = QHBoxLayout(self.header_widget)
        header_layout.setContentsMargins(16, 12, 16, 16)  # More balanced padding - reduced top, added bottom
        header_layout.setSpacing(16)  # Consistent spacing with other elements
        
        # Album icon with expand indicator
        icon_container = QVBoxLayout()
        album_icon = QLabel("💿")
        album_icon.setFixedSize(48, 48)  # Larger for better presence
        album_icon.setAlignment(Qt.AlignmentFlag.AlignCenter)
        album_icon.setStyleSheet("""
            QLabel {
                font-size: 24px;
                background: qlineargradient(x1:0, y1:0, x2:1, y2:1,
                    stop:0 rgba(29, 185, 84, 0.2),
                    stop:1 rgba(24, 156, 71, 0.15));
                border-radius: 24px;
                border: 2px solid rgba(29, 185, 84, 0.4);
                color: rgba(29, 185, 84, 1.0);
            }
        """)
        
        # Expand indicator
        self.expand_indicator = QLabel("▶")
        self.expand_indicator.setFixedSize(20, 20)  # Slightly larger
        self.expand_indicator.setAlignment(Qt.AlignmentFlag.AlignCenter)
        self.expand_indicator.setStyleSheet("""
            QLabel {
                color: rgba(29, 185, 84, 0.9);
                font-size: 14px;
                font-weight: bold;
                background: rgba(29, 185, 84, 0.1);
                border-radius: 10px;
                border: 1px solid rgba(29, 185, 84, 0.2);
            }
        """)
        
        icon_container.addWidget(album_icon)
        icon_container.addWidget(self.expand_indicator)
        
        # Album info section
        info_section = QVBoxLayout()
        info_section.setSpacing(2)
        info_section.setContentsMargins(0, 0, 0, 0)
        
        # Album title
        album_title = QLabel(self.album_result.album_title)
        album_title.setFont(QFont("Arial", 12, QFont.Weight.Bold))
        album_title.setStyleSheet("color: #ffffff;")
        
        # Artist and details - with prominent artist display
        details = []
        
        # Make artist more prominent by placing it first and with better formatting
        if self.album_result.artist:
            details.append(f"🎤 {self.album_result.artist}")
        
        details.append(f"{self.album_result.track_count} tracks")
        details.append(f"{self.album_result.size_mb}MB")
        details.append(self.album_result.dominant_quality.upper())
        if self.album_result.year:
            details.append(f"({self.album_result.year})")
        
        # Add speed information
        speed_info = self._get_album_speed_display()
        if speed_info:
            details.append(speed_info)
        
        details_text = " • ".join(details)
        album_details = QLabel(details_text)
        album_details.setFont(QFont("Arial", 10))
        album_details.setStyleSheet("color: rgba(179, 179, 179, 0.9);")
        
        # User info
        user_info = QLabel(f"👤 {self.album_result.username}")
        user_info.setFont(QFont("Arial", 9))
        user_info.setStyleSheet("color: rgba(29, 185, 84, 0.8);")
        
        info_section.addWidget(album_title)
        info_section.addWidget(album_details)
        info_section.addWidget(user_info)
        
        # Download buttons layout
        download_buttons_layout = QVBoxLayout()
        download_buttons_layout.setSpacing(4)
        
        # Download button
        self.download_btn = QPushButton("⬇️ Download Album")
        self.download_btn.setFixedSize(160, 36)  # Slightly larger for better presence
        self.download_btn.clicked.connect(self.request_album_download)
        self.download_btn.setStyleSheet("""
            QPushButton {
                background: qlineargradient(x1:0, y1:0, x2:0, y2:1,
                    stop:0 rgba(29, 185, 84, 0.95),
                    stop:1 rgba(24, 156, 71, 0.9));
                border: 2px solid rgba(29, 185, 84, 0.3);
                border-radius: 18px;
                color: #000000;
                font-size: 12px;
                font-weight: bold;
                padding: 8px 12px;
            }
            QPushButton:hover {
                background: qlineargradient(x1:0, y1:0, x2:0, y2:1,
                    stop:0 rgba(30, 215, 96, 1.0),
                    stop:1 rgba(25, 180, 80, 1.0));
                border: 2px solid rgba(29, 185, 84, 0.6);
            }
            QPushButton:pressed {
                background: qlineargradient(x1:0, y1:0, x2:0, y2:1,
                    stop:0 rgba(20, 150, 70, 1.0),
                    stop:1 rgba(15, 120, 60, 1.0));
            }
        """)
        
        # Matched Download button
        self.matched_download_btn = QPushButton("🎯 Matched Album")
        self.matched_download_btn.setFixedSize(160, 36)  # Match the other button
        self.matched_download_btn.clicked.connect(self.request_matched_album_download)
        self.matched_download_btn.setToolTip("Download Album with Spotify Matching")
        self.matched_download_btn.setStyleSheet("""
            QPushButton {
                background: qlineargradient(x1:0, y1:0, x2:0, y2:1,
                    stop:0 rgba(147, 51, 234, 0.95),
                    stop:1 rgba(124, 43, 200, 0.9));
                border: 2px solid rgba(147, 51, 234, 0.3);
                border-radius: 18px;
                color: #ffffff;
                font-size: 12px;
                font-weight: bold;
                padding: 8px 12px;
            }
            QPushButton:hover {
                background: qlineargradient(x1:0, y1:0, x2:0, y2:1,
                    stop:0 rgba(167, 71, 254, 1.0),
                    stop:1 rgba(144, 63, 220, 1.0));
                border: 2px solid rgba(147, 51, 234, 0.6);
            }
            QPushButton:pressed {
                background: qlineargradient(x1:0, y1:0, x2:0, y2:1,
                    stop:0 rgba(120, 50, 200, 1.0),
                    stop:1 rgba(100, 40, 180, 1.0));
            }
        """)
        
        download_buttons_layout.addWidget(self.download_btn)
        download_buttons_layout.addWidget(self.matched_download_btn)
        
        # Set minimum width to ensure buttons always visible
        self.setMinimumWidth(420)  # Increased to accommodate larger buttons
        
        # Assembly header
        header_layout.addLayout(icon_container)
        header_layout.addLayout(info_section, 1)  # Flexible content area
        header_layout.addLayout(download_buttons_layout, 0)  # Fixed button area, always visible
        
        # Tracks container (hidden by default)
        self.tracks_container = QWidget()
        self.tracks_container.setVisible(False)
        tracks_layout = QVBoxLayout(self.tracks_container)
        tracks_layout.setContentsMargins(16, 8, 16, 16)
        tracks_layout.setSpacing(4)
        
        # Create track items
        for track in self.album_result.tracks:
            track_item = TrackItem(track)
            track_item.track_download_requested.connect(self.track_download_requested.emit)
            # Use lambda to pass both track result and track item reference
            track_item.track_stream_requested.connect(
                lambda track_result, item=track_item: self.handle_track_stream_request(track_result, item)
            )
            tracks_layout.addWidget(track_item)
            self.track_items.append(track_item)
        
        # Assembly main layout
        main_layout.addWidget(self.header_widget)
        main_layout.addWidget(self.tracks_container)
        
        # Make header clickable
        self.header_widget.mousePressEvent = self.toggle_expansion
    
    def request_album_download(self):
        """Request download of the entire album"""
        self.download_btn.setText("⏳")
        self.download_btn.setEnabled(False)
        self.album_download_requested.emit(self.album_result)
    
    def request_matched_album_download(self):
        """Request matched download of the entire album with Spotify integration"""
        self.matched_download_btn.setText("⏳")
        self.matched_download_btn.setEnabled(False)
        self.matched_album_download_requested.emit(self.album_result)
    
    def toggle_expansion(self, event):
        """Toggle album expansion to show/hide tracks"""
        self.is_expanded = not self.is_expanded
        
        if self.is_expanded:
            # Expand to show tracks
            self.tracks_container.setVisible(True)
            self.expand_indicator.setText("▼")
            # Calculate height: header + (tracks * track_height) + padding
            track_height = 54  # 50px + margin
            total_height = self.collapsed_height + (len(self.track_items) * track_height) + 24
            self.setFixedHeight(total_height)
        else:
            # Collapse to hide tracks
            self.tracks_container.setVisible(False)
            self.expand_indicator.setText("▶")
            self.setFixedHeight(self.collapsed_height)
        
        # Force layout update
        self.updateGeometry()
        if self.parent():
            self.parent().updateGeometry()
    
    def handle_track_stream_request(self, track_result, track_item):
        """Handle stream request from a track item, passing the correct button reference"""
        # Emit the stream request with the track item that contains the button
        self.track_stream_requested.emit(track_result, track_item)
    
    def _get_album_speed_display(self):
        """Get formatted speed display for album cards"""
        # Get speed data from album result
        speed = getattr(self.album_result, 'upload_speed', None) or 0
        slots = getattr(self.album_result, 'free_upload_slots', None) or 0
        
        if speed > 0:
            # Use same logic as Singles but return text only (no icons for inline display)
            if speed > 200:
                icon = "🚀"
            elif speed > 100:
                icon = "🚀" if slots > 0 else "⚡"
            elif speed > 50:
                icon = "⚡"
            else:
                icon = "🐌"
            
            # Convert to MB/s and format
            speed_mb = speed / 1024
            if speed_mb >= 1:
                return f"{icon} {speed_mb:.1f}MB/s"
            else:
                return f"{icon} {speed}KB/s"
        
        return None  # No speed data

class SearchResultItem(QFrame):
    download_requested = pyqtSignal(object)  # SearchResult object
    stream_requested = pyqtSignal(object)    # SearchResult object for streaming
    expansion_requested = pyqtSignal(object)  # Signal when this item wants to expand
    
    def __init__(self, search_result, parent=None):
        super().__init__(parent)
        self.search_result = search_result
        self.is_downloading = False
        self.is_expanded = False
        self.setup_ui()
    
    def setup_ui(self):
        # Dynamic height based on state (compact: 85px, expanded: 200px for better visual breathing room)
        self.compact_height = 85  # Increased from 75px to match Albums proportions
        self.expanded_height = 200  # Increased from 180px for more comfortable content layout
        self.setFixedHeight(self.compact_height)
        
        # Ensure consistent sizing and layout behavior
        self.setSizePolicy(QSizePolicy.Policy.Expanding, QSizePolicy.Policy.Fixed)
        
        # Enable mouse tracking for click detection
        self.setMouseTracking(True)
        
        self.setStyleSheet("""
            SearchResultItem {
                background: qlineargradient(x1:0, y1:0, x2:0, y2:1,
                    stop:0 rgba(48, 48, 52, 0.95),
                    stop:1 rgba(38, 38, 42, 0.98));
                border-radius: 18px;
                border: 1px solid rgba(70, 70, 76, 0.5);
                margin: 8px 4px;
            }
            SearchResultItem:hover {
                background: qlineargradient(x1:0, y1:0, x2:0, y2:1,
                    stop:0 rgba(55, 55, 60, 0.98),
                    stop:1 rgba(45, 45, 50, 1.0));
                border: 1px solid rgba(29, 185, 84, 0.8);
            }
        """)
        
        layout = QHBoxLayout(self)
        layout.setContentsMargins(16, 16, 16, 16)  # Match Albums margins for consistency
        layout.setSpacing(16)  # Increased spacing for better visual separation
        
        # Left section: Music icon + filename
        left_section = QHBoxLayout()
        left_section.setSpacing(12)  # Increased from 8px for better separation
        
        # Enhanced music icon with modern styling
        music_icon = QLabel("🎵")
        music_icon.setFixedSize(44, 44)  # Slightly larger for better presence
        music_icon.setAlignment(Qt.AlignmentFlag.AlignCenter)
        music_icon.setStyleSheet("""
            QLabel {
                background: qlineargradient(x1:0, y1:0, x2:1, y2:1,
                    stop:0 rgba(29, 185, 84, 0.3),
                    stop:1 rgba(24, 156, 71, 0.2));
                border-radius: 22px;
                border: 2px solid rgba(29, 185, 84, 0.4);
                font-size: 18px;
                color: rgba(29, 185, 84, 1.0);
            }
            QLabel:hover {
                background: qlineargradient(x1:0, y1:0, x2:1, y2:1,
                    stop:0 rgba(29, 185, 84, 0.5),
                    stop:1 rgba(24, 156, 71, 0.3));
                border: 2px solid rgba(29, 185, 84, 0.7);
            }
        """)
        
        # Content area that will change based on expanded state
        self.content_widget = QWidget()
        self.content_layout = QVBoxLayout(self.content_widget)
        self.content_layout.setContentsMargins(0, 4, 0, 4)  # Increased vertical margins for better centering
        self.content_layout.setSpacing(2)  # Reduced spacing to prevent text cut-off
        
        # Extract song info
        primary_info = self._extract_song_info()
        
        # Create both compact and expanded content but show only one
        self.create_persistent_content(primary_info)
        
        # Right section: Play and download buttons
        buttons_layout = QHBoxLayout()
        buttons_layout.setSpacing(8)  # Increased from 4px for better button separation
        
        # Play button for streaming preview
        self.play_btn = QPushButton("▶️")
        self.play_btn.setFixedSize(46, 46)  # Larger for better accessibility
        self.play_btn.clicked.connect(self.request_stream)
        self.play_btn.setStyleSheet("""
            QPushButton {
                background: qlineargradient(x1:0, y1:0, x2:0, y2:1,
                    stop:0 rgba(255, 193, 7, 0.95),
                    stop:1 rgba(255, 152, 0, 0.9));
                border: 2px solid rgba(255, 193, 7, 0.3);
                border-radius: 23px;
                color: #000000;
                font-size: 18px;
                font-weight: bold;
            }
            QPushButton:hover {
                background: qlineargradient(x1:0, y1:0, x2:0, y2:1,
                    stop:0 rgba(255, 213, 79, 1.0),
                    stop:1 rgba(255, 171, 64, 1.0));
                border: 2px solid rgba(255, 193, 7, 0.6);
            }
            QPushButton:pressed {
                background: qlineargradient(x1:0, y1:0, x2:0, y2:1,
                    stop:0 rgba(255, 152, 0, 1.0),
                    stop:1 rgba(245, 124, 0, 1.0));
            }
        """)
        
        # Download button
        self.download_btn = QPushButton("⬇️")
        self.download_btn.setFixedSize(46, 46)  # Match play button size
        self.download_btn.clicked.connect(self.request_download)
        self.download_btn.setStyleSheet("""
            QPushButton {
                background: qlineargradient(x1:0, y1:0, x2:0, y2:1,
                    stop:0 rgba(29, 185, 84, 0.95),
                    stop:1 rgba(24, 156, 71, 0.9));
                border: 2px solid rgba(29, 185, 84, 0.3);
                border-radius: 23px;
                color: #000000;
                font-size: 18px;
                font-weight: bold;
            }
            QPushButton:hover {
                background: qlineargradient(x1:0, y1:0, x2:0, y2:1,
                    stop:0 rgba(30, 215, 96, 1.0),
                    stop:1 rgba(25, 180, 80, 1.0));
                border: 2px solid rgba(29, 185, 84, 0.6);
            }
            QPushButton:pressed {
                background: qlineargradient(x1:0, y1:0, x2:0, y2:1,
                    stop:0 rgba(24, 156, 71, 1.0),
                    stop:1 rgba(20, 130, 60, 1.0));
            }
        """)
        
        # Matched Download button
        self.matched_download_btn = QPushButton("🎯")
        self.matched_download_btn.setFixedSize(46, 46)  # Match other buttons
        self.matched_download_btn.clicked.connect(self.request_matched_download)
        self.matched_download_btn.setToolTip("Download with Spotify Matching")
        self.matched_download_btn.setStyleSheet("""
            QPushButton {
                background: qlineargradient(x1:0, y1:0, x2:0, y2:1,
                    stop:0 rgba(147, 51, 234, 0.95),
                    stop:1 rgba(124, 43, 200, 0.9));
                border: 2px solid rgba(147, 51, 234, 0.3);
                border-radius: 23px;
                color: #ffffff;
                font-size: 18px;
                font-weight: bold;
            }
            QPushButton:hover {
                background: qlineargradient(x1:0, y1:0, x2:0, y2:1,
                    stop:0 rgba(167, 71, 254, 1.0),
                    stop:1 rgba(144, 63, 220, 1.0));
                border: 2px solid rgba(147, 51, 234, 0.6);
            }
            QPushButton:pressed {
                background: qlineargradient(x1:0, y1:0, x2:0, y2:1,
                    stop:0 rgba(124, 43, 200, 1.0),
                    stop:1 rgba(104, 33, 180, 1.0));
            }
        """)
        
        # Assemble the layout
        left_section.addWidget(music_icon)
        left_section.addWidget(self.content_widget, 1)
        
        buttons_layout.addWidget(self.play_btn)
        buttons_layout.addWidget(self.download_btn)
        buttons_layout.addWidget(self.matched_download_btn)
        
        # Set minimum width to ensure buttons always visible
        self.setMinimumWidth(300)  # Ensure minimum space for content + buttons
        
        layout.addLayout(left_section, 1)  # Flexible content area
        layout.addLayout(buttons_layout, 0)  # Fixed button area, always visible
    
    def create_persistent_content(self, primary_info):
        """Create both compact and expanded content with visibility control"""
        # Title row (always visible) with character limit and ellipsis
        title_text = primary_info['title']
        if len(title_text) > 55:  # Increased character limit since smaller font fits more text
            title_text = title_text[:52] + "..."
        
        self.title_label = QLabel(title_text)
        self.title_label.setFont(QFont("Arial", 12, QFont.Weight.Bold))  # 12px matches Albums and prevents cut-off
        self.title_label.setStyleSheet("color: #ffffff; letter-spacing: 0.2px;")
        self.title_label.setSizePolicy(QSizePolicy.Policy.Expanding, QSizePolicy.Policy.Preferred)
        # Ensure text doesn't overflow the label and allow click-through
        self.title_label.setWordWrap(False)
        # Remove text selection to allow clicks to propagate to parent widget
        self.title_label.setTextInteractionFlags(Qt.TextInteractionFlag.NoTextInteraction)
        
        # Expand indicator with enhanced styling
        self.expand_indicator = QLabel("⏵")
        self.expand_indicator.setFixedSize(20, 20)  # Increased size for better visibility
        self.expand_indicator.setAlignment(Qt.AlignmentFlag.AlignCenter)
        self.expand_indicator.setStyleSheet("""
            QLabel {
                color: rgba(255, 255, 255, 0.7);
                font-size: 12px;
                background: rgba(255, 255, 255, 0.1);
                border-radius: 10px;
            }
            QLabel:hover {
                color: rgba(29, 185, 84, 0.9);
                background: rgba(29, 185, 84, 0.15);
            }
        """)
        
        # Quality badge (now visible in compact view)
        self.quality_badge = self._create_compact_quality_badge()
        
        # Create uploader info label for compact view with artist information
        result = self.search_result[0] if isinstance(self.search_result, list) else self.search_result
        
        # Build secondary info with artist prominently displayed (excluding uploader)
        info_parts = []
        
        # Add artist information if available
        if hasattr(result, 'artist') and result.artist:
            info_parts.append(f"🎤 {result.artist}")
        
        # Add quality info
        quality_text = result.quality.upper()
        if result.bitrate:
            quality_text += f" • {result.bitrate}kbps"
        info_parts.append(quality_text)
        
        # Add size info
        size_mb = result.size // (1024*1024)
        info_parts.append(f"{size_mb}MB")
        
        secondary_info_text = " • ".join(info_parts)
        self.secondary_info = QLabel(secondary_info_text)
        self.secondary_info.setFont(QFont("Arial", 9, QFont.Weight.Normal))
        self.secondary_info.setStyleSheet("color: rgba(179, 179, 179, 0.8); letter-spacing: 0.1px;")
        self.secondary_info.setWordWrap(False)
        self.secondary_info.setTextInteractionFlags(Qt.TextInteractionFlag.NoTextInteraction)
        
        # Create separate uploader info with green styling like albums
        self.uploader_info = QLabel(f"👤 {result.username}")
        self.uploader_info.setFont(QFont("Arial", 9))
        self.uploader_info.setStyleSheet("color: rgba(29, 185, 84, 0.8);")
        self.uploader_info.setWordWrap(False)
        self.uploader_info.setTextInteractionFlags(Qt.TextInteractionFlag.NoTextInteraction)
        
        title_row = QHBoxLayout()
        title_row.setContentsMargins(0, 0, 0, 0)
        title_row.addWidget(self.title_label)
        title_row.addWidget(self.quality_badge)
        title_row.addWidget(self.expand_indicator)
        
        # Add secondary info row for compact view with uploader info
        secondary_row = QHBoxLayout()
        secondary_row.setContentsMargins(0, 0, 0, 0)  # Remove margins to prevent cut-off
        secondary_row.addWidget(self.secondary_info)
        secondary_row.addStretch()  # Push text to left
        secondary_row.addWidget(self.uploader_info)  # Add green uploader info on the right
        
        # Expanded content (initially hidden)
        self.expanded_content = QWidget()
        expanded_layout = QVBoxLayout(self.expanded_content)
        expanded_layout.setContentsMargins(0, 4, 0, 4)  # Small margins for better text positioning
        expanded_layout.setSpacing(4)  # Increased from 1px to 4px for better readability
        
        # Expanded content shows only unique information not in compact view
        # Duration info (if available) - this is unique to expanded view
        expanded_details = []
        if self.search_result.duration:
            duration_mins = self.search_result.duration // 60
            duration_secs = self.search_result.duration % 60
            expanded_details.append(f"Duration: {duration_mins}:{duration_secs:02d}")
        
        # Full file path info (unique to expanded view)
        result = self.search_result[0] if isinstance(self.search_result, list) else self.search_result
        if hasattr(result, 'filename'):
            expanded_details.append(f"File: {result.filename}")
        
        if expanded_details:
            self.expanded_details = QLabel(" • ".join(expanded_details))
            self.expanded_details.setFont(QFont("Arial", 10))
            self.expanded_details.setStyleSheet("color: rgba(136, 136, 136, 0.8); letter-spacing: 0.1px;")
            self.expanded_details.setWordWrap(True)  # Allow wrapping for long filenames
            expanded_layout.addWidget(self.expanded_details)
        
        # Speed indicator (unique to expanded view)
        self.speed_indicator = self._create_compact_speed_indicator()
        speed_row = QHBoxLayout()
        speed_row.addWidget(self.speed_indicator)
        speed_row.addStretch()
        expanded_layout.addLayout(speed_row)
        
        # Initially hide expanded content
        self.expanded_content.hide()
        
        # Add to main layout
        self.content_layout.addLayout(title_row)
        self.content_layout.addLayout(secondary_row)  # Add secondary info row
        self.content_layout.addWidget(self.expanded_content)
    
    def update_expanded_state(self):
        """Update UI based on expanded state without recreating widgets"""
        if self.is_expanded:
            self.expand_indicator.setText("⏷")
            self.expand_indicator.setStyleSheet("""
                QLabel {
                    color: rgba(29, 185, 84, 0.9);
                    font-size: 14px;
                    background: rgba(29, 185, 84, 0.15);
                    border-radius: 10px;
                }
            """)
            self.expanded_content.show()
        else:
            self.expand_indicator.setText("⏵")
            self.expand_indicator.setStyleSheet("""
                QLabel {
                    color: rgba(255, 255, 255, 0.7);
                    font-size: 14px;
                    background: rgba(255, 255, 255, 0.1);
                    border-radius: 10px;
                }
                QLabel:hover {
                    color: rgba(29, 185, 84, 0.9);
                    background: rgba(29, 185, 84, 0.15);
                }
            """)
            self.expanded_content.hide()
        
        # Quality badge is now always visible in compact view
    
    def mousePressEvent(self, event):
        """Handle mouse clicks to toggle expand/collapse"""
        # Only respond to left clicks and avoid clicks on the download button
        if event.button() == Qt.MouseButton.LeftButton:
            # Check if click is on download button (more precise detection)
            button_rect = self.download_btn.geometry()
            # Add some padding to the button area to be more forgiving
            button_rect.adjust(-5, -5, 5, 5)
            if not button_rect.contains(event.pos()):
                # Emit signal to parent to handle accordion behavior
                self.expansion_requested.emit(self)
        super().mousePressEvent(event)
    
    def set_expanded(self, expanded, animate=True):
        """Set expanded state externally (called by parent for accordion behavior)"""
        if self.is_expanded == expanded:
            return  # No change needed
        
        self.is_expanded = expanded
        
        if animate:
            self._animate_to_state()
        else:
            # Immediate state change without animation
            if self.is_expanded:
                self.setFixedHeight(self.expanded_height)
            else:
                self.setFixedHeight(self.compact_height)
            self.update_expanded_state()
    
    def toggle_expanded(self):
        """Toggle between compact and expanded states with animation"""
        self.set_expanded(not self.is_expanded, animate=True)
    
    def _animate_to_state(self):
        """Animate to the current expanded state with enhanced easing"""
        from PyQt6.QtCore import QPropertyAnimation, QEasingCurve
        
        # Start height animation with smoother easing
        self.animation = QPropertyAnimation(self, b"minimumHeight")
        self.animation.setDuration(300)  # Slightly longer for smoother feel
        self.animation.setEasingCurve(QEasingCurve.Type.OutQuart)  # More elegant easing curve
        
        if self.is_expanded:
            # Expand animation
            self.animation.setStartValue(self.compact_height)
            self.animation.setEndValue(self.expanded_height)
            # Show content immediately for expand (feels more responsive)
            self.update_expanded_state()
        else:
            # Collapse animation
            self.animation.setStartValue(self.expanded_height)
            self.animation.setEndValue(self.compact_height)
            # Hide content immediately for collapse (cleaner look)
            self.update_expanded_state()
        
        # Update fixed height when animation completes
        self.animation.finished.connect(self._finalize_height)
        self.animation.start()
    
    def _finalize_height(self):
        """Set final height after animation completes"""
        if self.is_expanded:
            self.setFixedHeight(self.expanded_height)
        else:
            self.setFixedHeight(self.compact_height)
        
        # Force parent layout update to ensure proper spacing
        if self.parent():
            self.parent().updateGeometry()
    
    def sizeHint(self):
        """Provide consistent size hint for layout calculations"""
        if self.is_expanded:
            return self.size().expandedTo(self.minimumSize()).boundedTo(self.maximumSize())
        else:
            return self.size().expandedTo(self.minimumSize()).boundedTo(self.maximumSize())
    
    def _truncate_file_path(self, username, filename):
        """Truncate file path to show max 3 levels: file + parent + grandparent folder"""
        import os
        
        # If username looks like a simple username (no path separators), return as-is
        if '/' not in username and '\\' not in username:
            return username
        
        # Get filename without extension for comparison
        file_base = os.path.splitext(os.path.basename(filename))[0]
        
        # Split path using both Windows and Unix separators
        path_parts = username.replace('\\', '/').split('/')
        
        # Remove empty parts
        path_parts = [part for part in path_parts if part.strip()]
        
        # If path is already short, return as-is
        if len(path_parts) <= 3:
            return '/'.join(path_parts)
        
        # Take last 3 components (file + parent + grandparent)
        truncated_parts = path_parts[-3:]
        
        # If we truncated, add ellipsis at the beginning
        if len(path_parts) > 3:
            return '.../' + '/'.join(truncated_parts)
        else:
            return '/'.join(truncated_parts)
    
    def _extract_song_info(self):
        """Extract song title and artist from TrackResult"""
        # Handle case where search_result is a list (shouldn't happen but be defensive)
        if isinstance(self.search_result, list):
            if len(self.search_result) > 0:
                # Take the first item if it's a list
                actual_result = self.search_result[0]
            else:
                # Empty list, return defaults
                return {'title': 'Unknown Title', 'artist': 'Unknown Artist'}
        else:
            actual_result = self.search_result
        
        # TrackResult objects have parsed metadata available
        if hasattr(actual_result, 'title') and hasattr(actual_result, 'artist'):
            # Use parsed metadata from TrackResult
            return {
                'title': actual_result.title or 'Unknown Title',
                'artist': actual_result.artist or 'Unknown Artist'
            }
        
        # Fallback: parse from filename if metadata not available
        if hasattr(actual_result, 'filename'):
            filename = actual_result.filename
            
            # Remove file extension
            name_without_ext = filename.rsplit('.', 1)[0]
            
            # Common patterns for artist - title separation
            separators = [' - ', ' – ', ' — ', '_-_', ' | ']
            
            for sep in separators:
                if sep in name_without_ext:
                    parts = name_without_ext.split(sep, 1)
                    return {
                        'title': parts[1].strip(),
                        'artist': parts[0].strip()
                    }
            
            # If no separator found, use filename as title
            return {
                'title': name_without_ext,
                'artist': 'Unknown Artist'
            }
        else:
            # No filename attribute, return defaults
            return {
                'title': 'Unknown Title',
                'artist': 'Unknown Artist'
            }
    
    def _create_compact_quality_badge(self):
        """Create a compact quality indicator badge"""
        # Handle list case defensively
        result = self.search_result[0] if isinstance(self.search_result, list) else self.search_result
        
        quality = result.quality.upper()
        bitrate = result.bitrate
        
        if quality == 'FLAC':
            badge_text = "FLAC"
            badge_color = "#1db954"
        elif bitrate and bitrate >= 320:
            badge_text = f"{bitrate}k"
            badge_color = "#1db954"
        elif bitrate and bitrate >= 256:
            badge_text = f"{bitrate}k"
            badge_color = "#ffa500"
        elif bitrate and bitrate >= 192:
            badge_text = f"{bitrate}k"
            badge_color = "#ffaa00"
        else:
            badge_text = quality[:3]  # Truncate for compact display
            badge_color = "#e22134"
        
        badge = QLabel(badge_text)
        badge.setFont(QFont("Arial", 8, QFont.Weight.Bold))
        badge.setAlignment(Qt.AlignmentFlag.AlignCenter)
        badge.setFixedSize(40, 16)
        badge.setStyleSheet(f"""
            QLabel {{
                background: {badge_color};
                color: #000000;
                border-radius: 8px;
                padding: 1px 4px;
            }}
        """)
        
        return badge
    
    def _create_compact_speed_indicator(self):
        """Create compact upload speed indicator"""
        # Handle list case defensively
        result = self.search_result[0] if isinstance(self.search_result, list) else self.search_result
        
        # Get speed and slots data with fallback handling
        speed = getattr(result, 'upload_speed', None) or 0
        slots = getattr(result, 'free_upload_slots', None) or 0
        
        # Debug: Print actual values to see what we're getting
        print(f"[DEBUG] Speed indicator - speed: {speed}, slots: {slots}, user: {getattr(result, 'username', 'unknown')}")
        
        # Speed-focused logic (slots as bonus, not requirement)
        if speed > 200:
            indicator_color = "#1db954"
            icon = "🚀"
            tooltip = f"Very Fast: {speed} KB/s" + (f", {slots} slots" if slots > 0 else "")
        elif speed > 100:
            indicator_color = "#1db954" if slots > 0 else "#4CAF50"
            icon = "🚀" if slots > 0 else "⚡"
            tooltip = f"Fast: {speed} KB/s" + (f", {slots} slots" if slots > 0 else "")
        elif speed > 50:
            indicator_color = "#ffa500"
            icon = "⚡"
            tooltip = f"Good: {speed} KB/s" + (f", {slots} slots" if slots > 0 else "")
        elif speed > 0:
            indicator_color = "#ffaa00"
            icon = "🐌"
            tooltip = f"Slow: {speed} KB/s" + (f", {slots} slots" if slots > 0 else "")
        else:
            indicator_color = "#e22134"
            icon = "⏳"
            tooltip = "No speed data available"
        
        # Convert KB/s to MB/s and format nicely
        if speed > 0:
            speed_mb = speed / 1024  # Convert KB to MB
            if speed_mb >= 1:
                speed_display = f"{speed_mb:.1f}MB/s"
            else:
                speed_display = f"{speed}KB/s"
            speed_text = f"{icon} {speed_display}"
        else:
            speed_text = icon
        
        indicator = QLabel(speed_text)
        indicator.setFont(QFont("Arial", 9))  # Slightly smaller to fit text
        indicator.setStyleSheet(f"color: {indicator_color};")
        indicator.setToolTip(tooltip)  # Add tooltip for debugging
        indicator.setMinimumWidth(60)  # Allow space for icon + speed text
        indicator.setFixedHeight(16)
        
        return indicator
    
    def _create_quality_badge(self):
        """Create a quality indicator badge (legacy - kept for compatibility)"""
        return self._create_compact_quality_badge()
    
    def _create_speed_indicator(self):
        """Create upload speed indicator (legacy - kept for compatibility)"""
        return self._create_compact_speed_indicator()
    
    def request_download(self):
        if not self.is_downloading:
            self.is_downloading = True
            self.download_btn.setText("⏳")
            self.download_btn.setEnabled(False)
            self.download_requested.emit(self.search_result)
    
    def request_matched_download(self):
        """Request a matched download with Spotify integration"""
        if not self.is_downloading:
            # Get reference to the DownloadsPage to handle matched download
            downloads_page = self.get_downloads_page()
            if downloads_page:
                downloads_page.start_matched_download(self.search_result)
    
    def request_stream(self):
        """Request streaming of this audio file"""
        # Check if file is a valid audio type
        audio_extensions = ['.mp3', '.flac', '.ogg', '.aac', '.wma', '.wav']
        filename_lower = self.search_result.filename.lower()
        
        is_audio = any(filename_lower.endswith(ext) for ext in audio_extensions)
        
        if is_audio:
            # Get reference to the DownloadsPage to check audio player state
            downloads_page = self.get_downloads_page()
            
            # If this button is currently playing, toggle pause/resume
            if (downloads_page and 
                downloads_page.currently_playing_button == self and 
                downloads_page.audio_player.is_playing):
                
                # Toggle playback (pause/resume)
                is_playing = downloads_page.audio_player.toggle_playback()
                if is_playing:
                    self.set_playing_state()
                else:
                    self.play_btn.setText("▶️")  # Play icon when paused
                    self.play_btn.setEnabled(True)
                return
            
            # Otherwise, start new streaming
            # Change button state to indicate streaming is starting
            self.play_btn.setText("⏸️")  # Pause icon to indicate playing
            self.play_btn.setEnabled(False)
            
            # Emit streaming request
            self.stream_requested.emit(self.search_result)
            
            # Note: Button state will be managed by the audio player callbacks
            # No timer reset - the audio player will handle state changes
        else:
            print(f"Cannot stream non-audio file: {self.search_result.filename}")
    
    def get_downloads_page(self):
        """Get reference to the parent DownloadsPage"""
        parent = self.parent()
        while parent:
            if hasattr(parent, 'audio_player'):  # DownloadsPage has audio_player
                return parent
            parent = parent.parent()
        return None
    
    def reset_play_state(self, original_text="▶️"):
        """Reset the play button state"""
        self.play_btn.setText(original_text)
        self.play_btn.setEnabled(True)
    
    def set_playing_state(self):
        """Set button to playing state"""
        self.play_btn.setText("⏸️")
        self.play_btn.setEnabled(True)
    
    def set_loading_state(self):
        """Set button to loading state"""
        self.play_btn.setText("⌛")
        self.play_btn.setEnabled(False)
    
    def set_queue_state(self):
        """Set play button to queue state"""
        self.play_btn.setText("📋")
        self.play_btn.setEnabled(False)
        self.play_btn.setStyleSheet("""
            QPushButton {
                background: rgba(255, 165, 0, 0.2);
                border: 1px solid rgba(255, 165, 0, 0.4);
                border-radius: 18px;
                color: rgba(255, 165, 0, 0.8);
                font-size: 12px;
            }
        """)
    
    def reset_download_state(self):
        """Reset the download button state"""
        self.is_downloading = False
        self.download_btn.setText("⬇️")
        self.download_btn.setEnabled(True)

class DownloadItem(QFrame):
    def __init__(self, title: str, artist: str, status: str, progress: int = 0, 
                 file_size: int = 0, download_speed: int = 0, file_path: str = "", 
                 download_id: str = "", soulseek_client=None, parent=None):
        super().__init__(parent)
        self.title = title
        self.artist = artist
        self.status = status
        self.progress = progress
        self.file_size = file_size
        self.download_speed = download_speed
        self.file_path = file_path
        self.download_id = download_id  # Track download ID for cancellation
        self.soulseek_client = soulseek_client  # For cancellation functionality
        
        # Add completion tracking to prevent duplicate processing
        self._completion_processed = False
        self._completion_lock = threading.Lock()
        
        self.setup_ui()
    
    def mark_completion_processed(self) -> bool:
        """Thread-safe method to mark download as completion-processed.
        Returns True if this is the first time marking completion, False if already processed."""
        with self._completion_lock:
            if self._completion_processed:
                return False  # Already processed
            self._completion_processed = True
            return True  # First time processing
    
    def is_completion_processed(self) -> bool:
        """Check if completion has already been processed."""
        with self._completion_lock:
            return self._completion_processed
    
    def setup_ui(self):
        self.setFixedHeight(85)  # More generous height for better spacing
        self.setStyleSheet("""
            DownloadItem {
                background: qlineargradient(x1:0, y1:0, x2:0, y2:1,
                    stop:0 rgba(40, 40, 40, 0.95),
                    stop:1 rgba(32, 32, 32, 0.95));
                border-radius: 12px;
                border: 1px solid rgba(64, 64, 64, 0.4);
                margin: 6px 4px;
            }
            DownloadItem:hover {
                background: qlineargradient(x1:0, y1:0, x2:0, y2:1,
                    stop:0 rgba(50, 50, 50, 0.95),
                    stop:1 rgba(40, 40, 40, 0.98));
                border: 1px solid rgba(29, 185, 84, 0.7);
            }
        """)
        
        # Main horizontal layout
        layout = QHBoxLayout(self)
        layout.setContentsMargins(16, 12, 16, 12)
        layout.setSpacing(16)
        
        # Left section: Filename + uploader (flexible)
        left_section = QVBoxLayout()
        left_section.setSpacing(4)
        
        # Extract filename with extension from file_path
        filename_with_ext = "Unknown File"
        if self.file_path:
            from pathlib import Path
            try:
                filename_with_ext = Path(self.file_path).name
            except:
                filename_with_ext = self.title  # fallback
        else:
            filename_with_ext = self.title  # fallback
        
        # Filename with extension (main info)
        filename_label = QLabel(filename_with_ext)
        filename_label.setFont(QFont("Segoe UI", 13, QFont.Weight.Bold))
        filename_label.setStyleSheet("color: #ffffff;")
        filename_label.setWordWrap(False)
        filename_label.setSizePolicy(QSizePolicy.Policy.Expanding, QSizePolicy.Policy.Fixed)
        
        # Uploader info
        uploader_label = QLabel(f"from {self.artist}")
        uploader_label.setFont(QFont("Segoe UI", 10))
        uploader_label.setStyleSheet("color: #b3b3b3;")
        uploader_label.setWordWrap(False)
        uploader_label.setSizePolicy(QSizePolicy.Policy.Expanding, QSizePolicy.Policy.Fixed)
        
        left_section.addWidget(filename_label)
        left_section.addWidget(uploader_label)
        
        # Middle section: Progress (fixed width)
        progress_widget = QWidget()
        progress_widget.setFixedWidth(120)
        progress_layout = QVBoxLayout(progress_widget)
        progress_layout.setSpacing(6)
        progress_layout.setContentsMargins(0, 0, 0, 0)
        
        # Progress bar
        self.progress_bar = QProgressBar()
        self.progress_bar.setFixedHeight(8)
        self.progress_bar.setValue(self.progress)
        self.progress_bar.setStyleSheet("""
            QProgressBar {
                border: none;
                border-radius: 4px;
                background: #404040;
            }
            QProgressBar::chunk {
                background: #1db954;
                border-radius: 4px;
            }
        """)
        
        # Status text
        status_mapping = {
            "completed, succeeded": "Finished",
            "completed, cancelled": "Cancelled",
            "completed": "Finished",
            "cancelled": "Cancelled",
            "downloading": "Downloading",
            "failed": "Failed",
            "queued": "Queued"
        }
        
        clean_status = status_mapping.get(self.status.lower(), self.status.title())
        if self.status.lower() in ["downloading", "queued"]:
            status_text = f"{clean_status} - {self.progress}%"
        else:
            status_text = clean_status
        
        self.status_label = QLabel(status_text)
        self.status_label.setFont(QFont("Segoe UI", 9))
        self.status_label.setStyleSheet("color: #b3b3b3;")
        self.status_label.setAlignment(Qt.AlignmentFlag.AlignCenter)
        
        progress_layout.addWidget(self.progress_bar)
        progress_layout.addWidget(self.status_label)
        
        # Right section: Action button (fixed width)
        self.action_btn = QPushButton()
        self.action_btn.setFixedSize(90, 36)
        
        if self.status == "downloading":
            self.action_btn.setText("Cancel")
            self.action_btn.clicked.connect(self.cancel_download)
            self.action_btn.setStyleSheet("""
                QPushButton {
                    background: qlineargradient(x1:0, y1:0, x2:0, y2:1,
                        stop:0 rgba(220, 53, 69, 0.8),
                        stop:1 rgba(220, 53, 69, 1.0));
                    color: white;
                    border: none;
                    border-radius: 8px;
                    font-weight: bold;
                    font-size: 11px;
                }
                QPushButton:hover {
                    background: qlineargradient(x1:0, y1:0, x2:0, y2:1,
                        stop:0 rgba(200, 33, 49, 0.9),
                        stop:1 rgba(200, 33, 49, 1.0));
                }
            """)
        elif self.status == "failed":
            self.action_btn.setText("Retry")
            self.action_btn.clicked.connect(self.retry_download)
            self.action_btn.setStyleSheet("""
                QPushButton {
                    background: qlineargradient(x1:0, y1:0, x2:0, y2:1,
                        stop:0 rgba(255, 193, 7, 0.8),
                        stop:1 rgba(255, 193, 7, 1.0));
                    color: #000;
                    border: none;
                    border-radius: 8px;
                    font-weight: bold;
                    font-size: 11px;
                }
                QPushButton:hover {
                    background: qlineargradient(x1:0, y1:0, x2:0, y2:1,
                        stop:0 rgba(235, 173, 0, 0.9),
                        stop:1 rgba(235, 173, 0, 1.0));
                }
            """)
        else:
            self.action_btn.setText("📂 Open")
            self.action_btn.clicked.connect(self.open_download_location)
            self.action_btn.setStyleSheet("""
                QPushButton {
                    background: qlineargradient(x1:0, y1:0, x2:0, y2:1,
                        stop:0 rgba(40, 167, 69, 0.8),
                        stop:1 rgba(40, 167, 69, 1.0));
                    color: white;
                    border: none;
                    border-radius: 8px;
                    font-weight: bold;
                    font-size: 11px;
                }
                QPushButton:hover {
                    background: qlineargradient(x1:0, y1:0, x2:0, y2:1,
                        stop:0 rgba(20, 147, 49, 0.9),
                        stop:1 rgba(20, 147, 49, 1.0));
                }
            """)
        
        # Add everything to main layout
        layout.addLayout(left_section, 1)  # Flexible
        layout.addWidget(progress_widget)  # Fixed width
        layout.addWidget(self.action_btn)  # Fixed width
    
    def open_download_location(self):
        """Open the download location in file explorer"""
        import os
        import platform
        from pathlib import Path
        
        if not self.file_path:
            return
            
        try:
            file_path = Path(self.file_path)
            if file_path.exists():
                # Open the folder containing the file
                folder_path = file_path.parent
                
                system = platform.system()
                if system == "Windows":
                    os.startfile(str(folder_path))
                elif system == "Darwin":  # macOS
                    os.system(f'open "{folder_path}"')
                else:  # Linux
                    os.system(f'xdg-open "{folder_path}"')
            else:
                # If file doesn't exist, try to open the download directory from config
                from config.settings import config_manager
                download_path = config_manager.get('soulseek.download_path', './downloads')
                
                system = platform.system()
                if system == "Windows":
                    os.startfile(download_path)
                elif system == "Darwin":  # macOS
                    os.system(f'open "{download_path}"')
                else:  # Linux
                    os.system(f'xdg-open "{download_path}"')
                    
        except Exception as e:
            print(f"Error opening download location: {e}")
    
    def update_status(self, status: str, progress: int = None, download_speed: int = None, file_path: str = None):
        """SAFE UPDATE: Update download item status without UI destruction"""
        # Update properties
        self.status = status
        if progress is not None:
            self.progress = progress
        if download_speed is not None:
            self.download_speed = download_speed
        if file_path:
            self.file_path = file_path
            
        # SAFE UI UPDATES: Update widgets directly instead of recreating
        try:
            # Update progress bar safely
            if hasattr(self, 'progress_bar') and self.progress_bar:
                self.progress_bar.setValue(self.progress)
            
            # Update status label safely
            if hasattr(self, 'status_label') and self.status_label:
                # Clean up status text display
                status_mapping = {
                    "completed, succeeded": "Finished",
                    "completed, cancelled": "Cancelled",
                    "completed": "Finished",
                    "cancelled": "Cancelled",
                    "downloading": "Downloading",
                    "failed": "Failed",
                    "queued": "Queued"
                }
                
                clean_status = status_mapping.get(self.status.lower(), self.status.title())
                status_text = clean_status
                
                if self.status.lower() in ["downloading", "queued"]:
                    status_text += f" - {self.progress}%"
                    
                self.status_label.setText(status_text)
                
            # Update action button based on status
            if hasattr(self, 'action_btn') and self.action_btn:
                if self.status == "downloading":
                    self.action_btn.setText("Cancel")
                    # Disconnect old connections
                    self.action_btn.clicked.disconnect()
                    self.action_btn.clicked.connect(self.cancel_download)
                    self.action_btn.setStyleSheet("""
                        QPushButton {
                            background: qlineargradient(x1:0, y1:0, x2:0, y2:1,
                                stop:0 rgba(220, 53, 69, 0.8),
                                stop:1 rgba(220, 53, 69, 1.0));
                            color: white;
                            border: none;
                            border-radius: 8px;
                            font-weight: bold;
                            font-size: 11px;
                        }
                        QPushButton:hover {
                            background: qlineargradient(x1:0, y1:0, x2:0, y2:1,
                                stop:0 rgba(200, 33, 49, 0.9),
                                stop:1 rgba(200, 33, 49, 1.0));
                        }
                    """)
                elif self.status == "failed":
                    self.action_btn.setText("Retry")
                    # Disconnect old connections
                    self.action_btn.clicked.disconnect()
                    self.action_btn.clicked.connect(self.retry_download)
                    self.action_btn.setStyleSheet("""
                        QPushButton {
                            background: qlineargradient(x1:0, y1:0, x2:0, y2:1,
                                stop:0 rgba(255, 193, 7, 0.8),
                                stop:1 rgba(255, 193, 7, 1.0));
                            color: #000;
                            border: none;
                            border-radius: 8px;
                            font-weight: bold;
                            font-size: 11px;
                        }
                        QPushButton:hover {
                            background: qlineargradient(x1:0, y1:0, x2:0, y2:1,
                                stop:0 rgba(235, 173, 0, 0.9),
                                stop:1 rgba(235, 173, 0, 1.0));
                        }
                    """)
                else:
                    self.action_btn.setText("📂 Open")
                    # Disconnect old connections
                    self.action_btn.clicked.disconnect()
                    self.action_btn.clicked.connect(self.open_download_location)
                    self.action_btn.setStyleSheet("""
                        QPushButton {
                            background: qlineargradient(x1:0, y1:0, x2:0, y2:1,
                                stop:0 rgba(40, 167, 69, 0.8),
                                stop:1 rgba(40, 167, 69, 1.0));
                            color: white;
                            border: none;
                            border-radius: 8px;
                            font-weight: bold;
                            font-size: 11px;
                        }
                        QPushButton:hover {
                            background: qlineargradient(x1:0, y1:0, x2:0, y2:1,
                                stop:0 rgba(20, 147, 49, 0.9),
                                stop:1 rgba(20, 147, 49, 1.0));
                        }
                    """)
                
        except Exception as e:
            print(f"Error updating download item UI: {e}")
            # Fallback: only recreate if safe update fails
            self.setup_ui()
    
    def cancel_download(self):
        """Cancel the download using the SoulseekClient"""
        if not self.soulseek_client or not self.download_id:
            print(f"Cannot cancel download: missing client or download ID")
            return
        
        # Find the parent DownloadsPage to use its async helper
        parent_page = self.parent()
        while parent_page and not hasattr(parent_page, '_run_async_operation'):
            parent_page = parent_page.parent()
        
        if parent_page:
            # Use the parent's async helper for safe event loop management
            def on_success(result):
                if result:
                    print(f"Successfully cancelled download: {self.title}")
                    self.update_status("cancelled", progress=0)
                    
                    # Find the parent TabbedDownloadManager and move to finished tab
                    parent_widget = self.parent()
                    while parent_widget:
                        if hasattr(parent_widget, 'move_to_finished'):
                            parent_widget.move_to_finished(self)
                            break
                        parent_widget = parent_widget.parent()
                        
                else:
                    print(f"Failed to cancel download: {self.title}")
            
            def on_error(error):
                print(f"Error cancelling download {self.title}: {error}")
            
            parent_page._run_async_operation(
                self.soulseek_client.cancel_download,
                self.download_id,
                success_callback=on_success,
                error_callback=on_error
            )
        else:
            print(f"[ERROR] Could not find parent DownloadsPage for async operation")
    
    def retry_download(self):
        """Retry a failed download"""
        # For now, just update status back to downloading
        # In a full implementation, this would restart the download
        self.update_status("downloading", progress=0)
        print(f"Retry requested for: {self.title}")
    
    def show_details(self):
        """Show download details"""
        details = f"""
Download Details:
Title: {self.title}
Artist: {self.artist}
Status: {self.status}
Progress: {self.progress}%
File Size: {self.file_size // (1024*1024)}MB
Download ID: {self.download_id}
File Path: {self.file_path}
        """
        print(details)

class CompactDownloadItem(QFrame):
    """Compact download item optimized for queue display"""
    def __init__(self, title: str, artist: str, status: str = "queued", 
                 progress: int = 0, file_size: int = 0, download_speed: int = 0, 
                 file_path: str = "", download_id: str = "", username: str = "", 
                 soulseek_client=None, queue_type: str = "active", 
                 album: str = None, track_number: int = None,
                 parent=None):
        super().__init__(parent)
        self.title = title
        self.artist = artist
        self.status = status
        self.progress = progress
        self.file_size = file_size
        self.download_speed = download_speed
        self.file_path = file_path
        self.download_id = download_id
        self.username = username
        self.soulseek_client = soulseek_client
        self.queue_type = queue_type  # "active" or "finished"
        
        # Album metadata for matched downloads
        self.album = album
        self.track_number = track_number
        
        # Add completion tracking to prevent duplicate processing
        self._completion_processed = False
        self._completion_lock = threading.Lock()
        
        self.setup_ui()
    
    def mark_completion_processed(self) -> bool:
        """Thread-safe method to mark download as completion-processed.
        Returns True if this is the first time marking completion, False if already processed."""
        with self._completion_lock:
            if self._completion_processed:
                return False  # Already processed
            self._completion_processed = True
            return True  # First time processing
    
    def is_completion_processed(self) -> bool:
        """Check if completion has already been processed."""
        with self._completion_lock:
            return self._completion_processed
    
    def setup_ui(self):
        self.setMinimumHeight(85)  # Further increased minimum to give more room for artist names
        self.setMaximumHeight(140)  # Increased maximum for better text accommodation
        self.setSizePolicy(QSizePolicy.Policy.Expanding, QSizePolicy.Policy.Minimum)
        self.setStyleSheet("""
            CompactDownloadItem {
                background: rgba(45, 45, 45, 0.95);
                border-radius: 6px;
                border: 1px solid rgba(60, 60, 60, 0.6);
                margin: 2px 1px;
            }
            CompactDownloadItem:hover {
                background: rgba(55, 55, 55, 1.0);
                border: 1px solid rgba(29, 185, 84, 0.5);
            }
        """)
        
        # Main vertical layout for better space utilization
        layout = QVBoxLayout(self)
        layout.setContentsMargins(12, 12, 12, 12)  # Further increased margins for better text spacing
        layout.setSpacing(10)  # Increased spacing between filename and bottom row
        
        # Top row: Filename with text wrapping
        filename_with_ext = self.get_display_filename()
        self.filename_label = QLabel(filename_with_ext)
        self.filename_label.setFont(QFont("Segoe UI", 10, QFont.Weight.Medium))
        self.filename_label.setStyleSheet("color: #ffffff; background: transparent;")
        self.filename_label.setWordWrap(True)  # Enable text wrapping
        self.filename_label.setSizePolicy(QSizePolicy.Policy.Expanding, QSizePolicy.Policy.Minimum)
        self.filename_label.setToolTip(filename_with_ext)
        
        # Bottom row: Uploader, Progress/Status, and Action button
        bottom_layout = QHBoxLayout()
        bottom_layout.setContentsMargins(0, 2, 0, 0)  # Added small top margin for better spacing
        bottom_layout.setSpacing(10)  # Increased spacing between elements
        
        # Uploader info - remove fixed width constraint and allow text wrapping
        self.uploader_label = QLabel()
        self.uploader_label.setFont(QFont("Segoe UI", 9, QFont.Weight.Normal))
        self.uploader_label.setStyleSheet("color: #b8b8b8; background: transparent;")
        self.uploader_label.setWordWrap(True)  # Enable text wrapping
        self.uploader_label.setSizePolicy(QSizePolicy.Policy.Expanding, QSizePolicy.Policy.Minimum)  # Changed from Fixed to Minimum
        self.uploader_label.setMinimumHeight(20)  # Ensure minimum height for text visibility
        self.uploader_label.setToolTip(f"Uploader: {self.artist}")
        self.uploader_label.setText(self.artist)  # Set text directly instead of using ellipsis function
        
        # Conditional layout based on queue type - PRESERVE ALL EXISTING BUTTON CODE
        if self.queue_type == "active":
            # Section 3: Progress (KEEP EXISTING PROGRESS WIDGET EXACTLY AS IS)
            progress_widget = QWidget()
            progress_widget.setFixedWidth(90)
            progress_layout = QVBoxLayout(progress_widget)
            progress_layout.setContentsMargins(0, 0, 0, 0)
            progress_layout.setSpacing(1)
            
            # Compact progress bar - COMPLETELY UNCHANGED
            self.progress_bar = QProgressBar()
            self.progress_bar.setFixedHeight(6)
            self.progress_bar.setValue(self.progress)
            self.progress_bar.setStyleSheet("""
                QProgressBar {
                    border: none;
                    border-radius: 3px;
                    background: rgba(60, 60, 60, 0.8);
                }
                QProgressBar::chunk {
                    background: rgba(29, 185, 84, 1.0);
                    border-radius: 3px;
                }
            """)
            
            # Progress percentage - COMPLETELY UNCHANGED
            self.progress_label = QLabel(f"{self.progress}%")
            self.progress_label.setFont(QFont("Segoe UI", 8))
            self.progress_label.setStyleSheet("color: #c0c0c0;")
            self.progress_label.setAlignment(Qt.AlignmentFlag.AlignCenter)
            
            progress_layout.addWidget(self.progress_bar)
            progress_layout.addWidget(self.progress_label)
            
            # Section 4: Cancel button - PRESERVE EXACTLY AS IS, NO CHANGES
            self.cancel_btn = QPushButton("Cancel")
            self.cancel_btn.setFixedSize(60, 35)
            self.cancel_btn.clicked.connect(self.cancel_download)
            self.cancel_btn.setStyleSheet("""
                QPushButton {
                    background: rgba(220, 53, 69, 0.9);
                    color: white;
                    border: 1px solid rgba(220, 53, 69, 0.6);
                    border-radius: 4px;
                    font-size: 9px;
                    font-weight: 500;
                }
                QPushButton:hover {
                    background: rgba(240, 73, 89, 1.0);
                }
                QPushButton:pressed {
                    background: rgba(200, 43, 58, 1.0);
                }
            """)
            
            # Add to bottom layout
            bottom_layout.addWidget(self.uploader_label, 1)
            bottom_layout.addWidget(progress_widget)
            bottom_layout.addWidget(self.cancel_btn)
            
        else:
            # Finished downloads - display a different widget based on the final status.
            self.progress_bar = None
            self.progress_label = None

            final_status = self.status.lower()
            
            action_widget = QWidget()
            action_layout = QHBoxLayout(action_widget)
            action_layout.setContentsMargins(0, 0, 0, 0)
            action_layout.setAlignment(Qt.AlignmentFlag.AlignRight)
            action_widget.setFixedWidth(70)

            if 'completed' in final_status or 'succeeded' in final_status:
                # For successfully completed downloads, show the 'Open' button.
                open_btn = QPushButton("📂 Open")
                open_btn.setFixedSize(60, 35)
                open_btn.clicked.connect(self.open_download_location)
                open_btn.setStyleSheet("""
                    QPushButton {
                        background: rgba(40, 167, 69, 0.9); color: white; border: 1px solid rgba(29, 185, 84, 0.6);
                        border-radius: 4px; font-size: 9px; font-weight: 500;
                    }
                    QPushButton:hover { background: rgba(50, 187, 79, 1.0); }
                    QPushButton:pressed { background: rgba(32, 140, 58, 1.0); }
                """)
                action_layout.addWidget(open_btn)

            elif 'cancelled' in final_status or 'canceled' in final_status:
                # For cancelled downloads, show a "Cancelled" label.
                status_label = QLabel("Cancelled")
                status_label.setStyleSheet("color: #ffa500; font-weight: bold; font-size: 10px;")
                status_label.setAlignment(Qt.AlignmentFlag.AlignCenter)
                action_layout.addWidget(status_label)

            elif 'failed' in final_status or 'errored' in final_status:
                # For failed or errored downloads, show a "Failed" label.
                status_label = QLabel("Failed")
                status_label.setStyleSheet("color: #e22134; font-weight: bold; font-size: 10px;")
                status_label.setAlignment(Qt.AlignmentFlag.AlignCenter)
                action_layout.addWidget(status_label)

            else: # Fallback for any other unexpected status
                open_btn = QPushButton("📂 Open")
                open_btn.setFixedSize(60, 35)
                open_btn.clicked.connect(self.open_download_location)
                action_layout.addWidget(open_btn)

            # Add the uploader label and the new action_widget to the layout.
            bottom_layout.addWidget(self.uploader_label, 1)
            bottom_layout.addWidget(action_widget)

        # Add both sections to main layout
        layout.addWidget(self.filename_label)
        layout.addLayout(bottom_layout)
    
    def _set_ellipsis_text(self, label, text, max_width):
        """Set text with ellipsis if it's too long for the given width"""
        font_metrics = label.fontMetrics()
        # Reserve some padding space (8px total)
        available_width = max_width - 8
        
        if font_metrics.horizontalAdvance(text) <= available_width:
            label.setText(text)
        else:
            # Truncate with ellipsis
            ellipsis_width = font_metrics.horizontalAdvance("...")
            available_for_text = available_width - ellipsis_width
            
            # Binary search for the right length
            left, right = 0, len(text)
            while left < right:
                mid = (left + right + 1) // 2
                if font_metrics.horizontalAdvance(text[:mid]) <= available_for_text:
                    left = mid
                else:
                    right = mid - 1
            
            truncated_text = text[:left] + "..."
            label.setText(truncated_text)
    
    def get_display_filename(self):
        """Extract just the filename with extension for display"""
        if self.file_path:
            from pathlib import Path
            try:
                return Path(self.file_path).name
            except:
                pass
        # Fallback to title if no file_path or error
        return self.title if self.title else "Unknown File"
    
    def get_status_text(self):
        """Get appropriate status text for display"""
        status_mapping = {
            "completed, succeeded": "Done",
            "completed, cancelled": "Cancelled", 
            "completed": "Done",
            "cancelled": "Cancelled",
            "downloading": f"{self.progress}%",
            "failed": "Failed",
            "queued": "Queued"
        }
        return status_mapping.get(self.status.lower(), self.status.title())
    
    def update_status(self, status: str, progress: int = None, download_speed: int = None, file_path: str = None):
        """Update the status and progress of the download item"""
        self.status = status
        if progress is not None:
            self.progress = progress
        if download_speed is not None:
            self.download_speed = download_speed
        if file_path:
            self.file_path = file_path
            # Update filename display if file_path changed
            if hasattr(self, 'filename_label') and self.filename_label:
                try:
                    filename_with_ext = self.get_display_filename()
                    self.filename_label.setText(filename_with_ext)
                    self.filename_label.setToolTip(filename_with_ext)
                except RuntimeError:
                    # Qt object has been deleted, skip update
                    pass
        
        # Update progress components for active downloads only
        if self.queue_type == "active":
            if hasattr(self, 'progress_bar') and self.progress_bar:
                try:
                    self.progress_bar.setValue(self.progress)
                except RuntimeError:
                    # Qt object has been deleted, skip update
                    pass
            if hasattr(self, 'progress_label') and self.progress_label:
                try:
                    self.progress_label.setText(f"{self.progress}%")
                except RuntimeError:
                    # Qt object has been deleted, skip update
                    pass
            
            # Update cancel button state based on status
            if hasattr(self, 'cancel_btn') and self.cancel_btn:
                try:
                    if status.lower() in ['cancelled', 'canceled', 'failed']:
                        # Disable button and update text for cancelled/failed downloads
                        self.cancel_btn.setText("Cancelled")
                        self.cancel_btn.setEnabled(False)
                        self.cancel_btn.setStyleSheet("""
                            QPushButton {
                                background: rgba(100, 100, 100, 0.5);
                                color: rgba(255, 255, 255, 0.6);
                                border: 1px solid rgba(100, 100, 100, 0.4);
                                border-radius: 4px;
                                font-size: 9px;
                                font-weight: 500;
                            }
                        """)
                    elif status.lower() in ['downloading', 'queued']:
                        # Re-enable button for active downloads
                        self.cancel_btn.setText("Cancel")
                        self.cancel_btn.setEnabled(True)
                        self.cancel_btn.setStyleSheet("""
                            QPushButton {
                                background: rgba(220, 53, 69, 0.9);
                                color: white;
                                border: 1px solid rgba(220, 53, 69, 0.6);
                                border-radius: 4px;
                                font-size: 9px;
                                font-weight: 500;
                            }
                        QPushButton:hover {
                            background: rgba(240, 73, 89, 1.0);
                        }
                        QPushButton:pressed {
                            background: rgba(200, 43, 58, 1.0);
                        }
                    """)
                except RuntimeError:
                    # Qt object has been deleted, skip update
                    pass
    
    def cancel_download(self):
        """Cancel the download using soulseek client"""
        print(f"[DEBUG] Cancel button clicked - download_id: {self.download_id}, username: {self.username}, title: {self.title}")
        if self.soulseek_client and self.download_id:
            print(f"🚫 Cancelling download: {self.download_id}")
            
            # Find the parent DownloadsPage to use its async helper
            parent_page = self.parent()
            while parent_page and not hasattr(parent_page, '_run_async_operation'):
                parent_page = parent_page.parent()
            
            if parent_page:
                # Use the parent's async helper for safe event loop management
                def on_success(result):
                    print(f"[DEBUG] Cancel result: {result}")
                    if result:
                        print(f"✅ Successfully cancelled download: {self.title}")
                        self.update_status("cancelled")
                    else:
                        print(f"❌ Failed to cancel download: {self.title}")
                
                def on_error(error):
                    print(f"❌ Failed to cancel download: {error}")
                
                parent_page._run_async_operation(
                    self.soulseek_client.cancel_download,
                    self.download_id, self.username,
                    success_callback=on_success,
                    error_callback=on_error
                )
            else:
                print(f"[ERROR] Could not find parent DownloadsPage for async operation")
        else:
            print(f"[DEBUG] Cancel failed - soulseek_client: {self.soulseek_client}, download_id: {self.download_id}")
    
    def retry_download(self):
        """Retry a failed download"""
        print(f"🔄 Retrying download: {self.title}")
        # This would trigger a new download attempt
        # Implementation depends on how retries are handled in the main system
        self.update_status("queued", 0)
    
    def open_download_location(self):
        """Open the download location in file explorer"""
        import os
        import platform
        from pathlib import Path
        
        print(f"[DEBUG] Open button clicked - file_path: {self.file_path}, title: {self.title}")
        
        if not self.file_path:
            print(f"[DEBUG] No file_path set for download: {self.title}")
            # Fallback to opening the general downloads folder
            try:
                from config.settings import config_manager
                download_path = config_manager.get('soulseek.download_path', './downloads')
                
                system = platform.system()
                if system == "Windows":
                    os.startfile(download_path)
                elif system == "Darwin":  # macOS
                    os.system(f'open "{download_path}"')
                else:  # Linux
                    os.system(f'xdg-open "{download_path}"')
                    
                print(f"📂 Opened downloads folder: {download_path}")
            except Exception as e:
                print(f"❌ Failed to open downloads folder: {e}")
            return
            
        try:
            file_path = Path(self.file_path)
            print(f"[DEBUG] Checking file existence: {file_path}")
            
            if file_path.exists():
                folder_path = file_path.parent
                print(f"[DEBUG] Opening folder: {folder_path}")
                
                system = platform.system()
                if system == "Windows":
                    os.startfile(folder_path)
                elif system == "Darwin":  # macOS
                    os.system(f"open '{folder_path}'")
                else:  # Linux
                    os.system(f"xdg-open '{folder_path}'")
                    
                print(f"📂 Opened folder: {folder_path}")
            else:
                print(f"❌ File not found: {file_path}")
                # Try to find the file in the downloads directory using the filename
                filename = os.path.basename(self.file_path)
                print(f"[DEBUG] Searching for file: {filename}")
                
                from config.settings import config_manager
                download_path = config_manager.get('soulseek.download_path', './downloads')
                
                # Search for the file in the downloads directory tree
                found_file = None
                for root, dirs, files in os.walk(download_path):
                    for file in files:
                        if file == filename:
                            found_file = os.path.join(root, file)
                            print(f"[DEBUG] Found file at: {found_file}")
                            break
                    if found_file:
                        break
                
                if found_file:
                    folder_path = os.path.dirname(found_file)
                    print(f"[DEBUG] Opening found folder: {folder_path}")
                    
                    system = platform.system()
                    if system == "Windows":
                        os.startfile(folder_path)
                    elif system == "Darwin":  # macOS
                        os.system(f'open "{folder_path}"')
                    else:  # Linux
                        os.system(f'xdg-open "{folder_path}"')
                        
                    print(f"📂 Opened folder: {folder_path}")
                else:
                    print(f"❌ Could not find file {filename} in downloads directory")
                    # Fallback to opening the downloads folder
                    system = platform.system()
                    if system == "Windows":
                        os.startfile(download_path)
                    elif system == "Darwin":  # macOS
                        os.system(f'open "{download_path}"')
                    else:  # Linux
                        os.system(f'xdg-open "{download_path}"')
                        
                    print(f"📂 Opened downloads folder as fallback: {download_path}")
                    
        except Exception as e:
            print(f"❌ Failed to open download location: {e}")

class DownloadQueue(QFrame):
    def __init__(self, title="Download Queue", queue_type="active", parent=None):
        super().__init__(parent)
        self.queue_title = title
        self.queue_type = queue_type  # "active" or "finished"
        
        # Widget lifecycle optimization - batch widget deletions
        self.deletion_timer = QTimer()
        self.deletion_timer.setSingleShot(True)
        self.deletion_timer.timeout.connect(self._process_pending_deletions)
        self.deletion_timer.setInterval(100)  # 100ms delay for batching
        self.pending_deletions = []
        
        self.setup_ui()
    
    def setup_ui(self):
        self.setStyleSheet("""
            DownloadQueue {
                background: qlineargradient(x1:0, y1:0, x2:0, y2:1,
                    stop:0 rgba(45, 45, 45, 0.9),
                    stop:1 rgba(35, 35, 35, 0.95));
                border-radius: 10px;
                border: 1px solid rgba(80, 80, 80, 0.5);
            }
        """)
        
        layout = QVBoxLayout(self)
        layout.setContentsMargins(12, 8, 12, 12)  # Slightly increased top padding
        layout.setSpacing(8)  # Increased spacing for better visual breathing room
        
        # Header
        header_layout = QHBoxLayout()
        header_layout.setContentsMargins(0, 0, 0, 0)
        
        self.title_label = QLabel(self.queue_title)
        self.title_label.setFont(QFont("Segoe UI", 11, QFont.Weight.Bold))
        self.title_label.setStyleSheet("""
            color: rgba(255, 255, 255, 0.95);
            font-weight: 600;
            padding: 0;
            margin: 0;
        """)
        
        queue_count = QLabel("Empty")
        queue_count.setFont(QFont("Segoe UI", 9))
        queue_count.setStyleSheet("""
            color: rgba(255, 255, 255, 0.6);
            padding: 0;
            margin: 0;
        """)
        
        header_layout.addWidget(self.title_label)
        header_layout.addStretch()
        header_layout.addWidget(queue_count)
        
        # Queue list
        queue_scroll = QScrollArea()
        queue_scroll.setWidgetResizable(True)
        queue_scroll.setMinimumHeight(200)
        queue_scroll.setStyleSheet("""
            QScrollArea {
                border: none;
                background: transparent;
                padding: 0px;
                margin: 0px;
            }
            QScrollArea > QWidget > QWidget {
                background: transparent;
            }
            QScrollBar:vertical {
                background: #404040;
                width: 8px;
                border-radius: 4px;
                margin: 0px;
            }
            QScrollBar::handle:vertical {
                background: #1db954;
                border-radius: 4px;
                margin: 0px;
            }
            QScrollBar::add-line:vertical, QScrollBar::sub-line:vertical {
                border: none;
                background: none;
                height: 0px;
            }
        """)
        
        queue_widget = QWidget()
        queue_layout = QVBoxLayout(queue_widget)
        queue_layout.setContentsMargins(0, 0, 0, 0)  # Remove any internal margins
        queue_layout.setSpacing(6)  # Increased spacing between download items for better readability
        
        # Dynamic download items - initially empty
        self.queue_layout = queue_layout
        self.queue_count_label = queue_count
        self.download_items = []
        
        # Add initial message when queue is empty
        self.empty_message = QLabel("No downloads yet.")
        self.empty_message.setFont(QFont("Arial", 10))
        self.empty_message.setStyleSheet("color: rgba(255, 255, 255, 0.5); padding: 15px; text-align: center;")
        self.empty_message.setAlignment(Qt.AlignmentFlag.AlignCenter)
        queue_layout.addWidget(self.empty_message)
        
        queue_layout.addStretch()
        queue_scroll.setWidget(queue_widget)
        
        layout.addLayout(header_layout)
        layout.addWidget(queue_scroll)
    
    def add_download_item(self, title: str, artist: str, status: str = "queued", 
                         progress: int = 0, file_size: int = 0, download_speed: int = 0, 
                         file_path: str = "", download_id: str = "", username: str = "", 
                         soulseek_client=None, album: str = None, track_number: int = None):
        """Add a new download item to the queue"""
        # Hide empty message if this is the first item
        if len(self.download_items) == 0:
            self.empty_message.hide()
        
        # Create new compact download item with queue type  
        item = CompactDownloadItem(title, artist, status, progress, file_size, download_speed, 
                                 file_path, download_id, username, soulseek_client, self.queue_type,
                                 album, track_number)
        self.download_items.append(item)
        
        # Insert before the stretch (which is always last)
        insert_index = self.queue_layout.count() - 1
        self.queue_layout.insertWidget(insert_index, item)
        
        # Update count
        self.update_queue_count()
        
        return item
    
    def update_queue_count(self):
        """Update the queue count label"""
        count = len(self.download_items)
        if count == 0:
            self.queue_count_label.setText("Empty")
            if not self.empty_message.isHidden():
                self.empty_message.show()
        else:
            self.queue_count_label.setText(f"{count} item{'s' if count != 1 else ''}")
    
    def remove_download_item(self, item):
        """Remove a download item from the queue"""
        print(f"[DEBUG] remove_download_item() called for '{item.title}' with status '{item.status}'")
        print(f"[DEBUG] Queue has {len(self.download_items)} items before removal")
        
        if item in self.download_items:
            print(f"[DEBUG] Item found in download_items list, removing...")
            self.download_items.remove(item)
            print(f"[DEBUG] Removed from download_items list. New count: {len(self.download_items)}")
            
            print(f"[DEBUG] Removing widget from queue_layout...")
            self.queue_layout.removeWidget(item)
            print(f"[DEBUG] Scheduling widget deletion...")
            self._schedule_widget_deletion(item)
            
            print(f"[DEBUG] Updating queue count...")
            self.update_queue_count()
            
            # Notify parent download manager to update tab counts
            print(f"[DEBUG] Finding parent to update tab counts...")
            parent_widget = self.parent()
            while parent_widget and not hasattr(parent_widget, 'update_tab_counts'):
                parent_widget = parent_widget.parent()
            if parent_widget and hasattr(parent_widget, 'update_tab_counts'):
                print(f"[DEBUG] Calling parent.update_tab_counts()...")
                parent_widget.update_tab_counts()
            else:
                print(f"[DEBUG] No parent with update_tab_counts found")
                
            print(f"[DEBUG] remove_download_item() completed for '{item.title}'")
        else:
            print(f"[DEBUG] Item '{item.title}' NOT found in download_items list!")
    
    def _schedule_widget_deletion(self, widget):
        """Schedule a widget for batched deletion to improve performance"""
        self.pending_deletions.append(widget)
        if not self.deletion_timer.isActive():
            self.deletion_timer.start()
    
    def _process_pending_deletions(self):
        """Process all pending widget deletions in a batch"""
        print(f"[DEBUG] Processing {len(self.pending_deletions)} pending widget deletions")
        for widget in self.pending_deletions:
            try:
                widget.deleteLater()
            except Exception as e:
                print(f"[DEBUG] Error deleting widget: {e}")
        self.pending_deletions.clear()
    
    def clear_completed_downloads(self):
        """Remove all completed and cancelled download items"""
        print(f"[DEBUG] DownloadQueue.clear_completed_downloads() called with {len(self.download_items)} items")
        items_to_remove = []
        
        for item in self.download_items:
            print(f"[DEBUG] Checking item '{item.title}' with status '{item.status}'")
            
            # Normalize status for comparison (handle compound statuses like "Completed, Succeeded")
            status_lower = item.status.lower()
            should_remove = False
            
            # Check for exact matches
            # Check for terminal states with the correct priority to ensure proper cleanup.
            # Cancelled and Failed must be checked BEFORE more general states like Completed.
            if any(keyword in status_lower for keyword in ["cancelled", "canceled", "failed", "errored"]):
                should_remove = True
                print(f"[DEBUG] Matched terminal state (Cancelled/Failed): '{item.status}'")
            elif any(keyword in status_lower for keyword in ["completed", "finished", "succeeded"]):
                should_remove = True
                print(f"[DEBUG] Matched terminal state (Completed): '{item.status}'")
            
            if should_remove:
                print(f"[DEBUG] Item '{item.title}' marked for removal (status: '{item.status}')")
                items_to_remove.append(item)
            else:
                print(f"[DEBUG] Item '{item.title}' NOT marked for removal (status: '{item.status}')")
        
        print(f"[DEBUG] Removing {len(items_to_remove)} items from queue")
        for item in items_to_remove:
            print(f"[DEBUG] Removing item: '{item.title}'")
            self.remove_download_item(item)
        
        print(f"[DEBUG] DownloadQueue.clear_completed_downloads() finished. Remaining items: {len(self.download_items)}")

class TabbedDownloadManager(QTabWidget):
    """Tabbed interface for managing active and finished downloads"""
    
    def __init__(self, parent=None):
        super().__init__(parent)
        
        # UI update batching to prevent excessive updates during transitions
        self.update_timer = QTimer()
        self.update_timer.setSingleShot(True)
        self.update_timer.timeout.connect(self._perform_batched_update)
        self.update_timer.setInterval(50)  # 50ms batch window
        self.pending_updates = set()
        
        self.setup_ui()
    
    def setup_ui(self):
        """Setup the tabbed interface with active and finished download queues"""
        self.setStyleSheet("""
            QTabWidget::pane {
                border: 1px solid #404040;
                border-radius: 8px;
                background: #282828;
                padding: 0px;
                margin: 0px;
            }
            QTabWidget::tab-bar {
                alignment: center;
            }
            QTabBar::tab {
                background: #404040;
                color: #ffffff;
                border: 1px solid #606060;
                border-bottom: none;
                border-top-left-radius: 8px;
                border-top-right-radius: 8px;
                padding: 6px 12px;
                margin-right: 1px;
                font-size: 10px;
                font-weight: bold;
                min-width: 80px;
            }
            QTabBar::tab:selected {
                background: #1db954;
                color: #000000;
                border: 1px solid #1db954;
            }
            QTabBar::tab:hover:!selected {
                background: #505050;
            }
        """)
        
        # Create two download queues with appropriate titles and queue types
        self.active_queue = DownloadQueue("Active Downloads", "active")
        self.finished_queue = DownloadQueue("Finished Downloads", "finished")
        
        # Update the finished queue count label
        self.finished_queue.queue_count_label.setText("Empty")
        
        # Add tabs
        self.addTab(self.active_queue, "Download Queue")
        self.addTab(self.finished_queue, "Finished Downloads")
        
        # Set initial tab counts
        self.update_tab_counts()
    
    def add_download_item(self, title: str, artist: str, status: str = "queued", 
                         progress: int = 0, file_size: int = 0, download_speed: int = 0, 
                         file_path: str = "", download_id: str = "", username: str = "", 
                         soulseek_client=None, album: str = None, track_number: int = None):
        """Add a new download item to the active queue"""
        item = self.active_queue.add_download_item(
            title, artist, status, progress, file_size, download_speed, 
            file_path, download_id, username, soulseek_client, album, track_number
        )
        self.update_tab_counts()
        return item
    
    def move_to_finished(self, download_item):
        """Move a download item from active to finished queue"""
        
        # Performance monitoring
        import time
        start_time = time.time()
        
        if download_item in self.active_queue.download_items:
            # Remove from active queue
            self.active_queue.remove_download_item(download_item)
            
            # Ensure completed downloads have 100% progress
            final_progress = download_item.progress
            if download_item.status == 'completed':
                final_progress = 100
                print(f"[DEBUG] Ensuring completed download '{download_item.title}' has 100% progress")
            
            # Add to finished queue
            finished_item = self.finished_queue.add_download_item(
                title=download_item.title,
                artist=download_item.artist,
                status=download_item.status,
                progress=final_progress,
                file_size=download_item.file_size,
                download_speed=download_item.download_speed,
                file_path=download_item.file_path,
                download_id=download_item.download_id,
                username=download_item.username,
                soulseek_client=download_item.soulseek_client
            )
            
            # Signal API that download is complete (only for completed downloads)
            # Note: Cancelled downloads already have their API signal sent by cancel_download()
            try:
                if (download_item.status == 'completed' and 
                    download_item.download_id and download_item.username and download_item.soulseek_client):
                    
                    # PERFORMANCE FIX: Use dedicated thread for API cleanup to prevent UI blocking
                    # Find the parent DownloadsPage that manages the API cleanup threads
                    parent_page = self.parent()
                    while parent_page and not hasattr(parent_page, 'api_cleanup_threads'):
                        parent_page = parent_page.parent()
                    
                    if parent_page and hasattr(parent_page, 'api_cleanup_threads'):
                        # Create and start API cleanup thread
                        cleanup_thread = ApiCleanupThread(
                            download_item.soulseek_client,
                            download_item.download_id,
                            download_item.username
                        )
                        cleanup_thread.cleanup_completed.connect(parent_page.api_cleanup_finished)
                        cleanup_thread.finished.connect(lambda: self._cleanup_api_thread(cleanup_thread))
                        
                        # Track the thread
                        parent_page.api_cleanup_threads.append(cleanup_thread)
                        
                        # Start the thread
                        cleanup_thread.start()
                        
                        print(f"🧵 Started API cleanup thread for download {download_item.download_id}")
                    else:
                        print(f"⚠️ Cannot find parent DownloadsPage for API cleanup thread")
                        # Fallback: Skip API cleanup to prevent blocking
                        print(f"⚠️ Skipping API cleanup for download {download_item.download_id}")
                        
            except Exception as e:
                print(f"⚠️ Error setting up download completion cleanup: {e}")
            
            self.update_tab_counts()
            
            # Emit signal for session download tracking
            parent_page = self.parent()
            while parent_page and not hasattr(parent_page, 'download_session_completed'):
                parent_page = parent_page.parent()
            if parent_page and hasattr(parent_page, 'download_session_completed'):
                parent_page.download_session_completed.emit(download_item.title, download_item.artist)
            
            # Performance monitoring
            end_time = time.time()
            duration_ms = (end_time - start_time) * 1000
            print(f"⏱️ move_to_finished completed in {duration_ms:.2f}ms for '{download_item.title}'")
            
            return finished_item
        
        # Performance monitoring for early return
        end_time = time.time()
        duration_ms = (end_time - start_time) * 1000
        print(f"⏱️ move_to_finished early return in {duration_ms:.2f}ms (item not in active queue)")
        return None
    
    def _cleanup_api_thread(self, thread):
        """Clean up API cleanup thread when it finishes"""
        try:
            # Find the parent DownloadsPage that manages the API cleanup threads
            parent_page = self.parent()
            while parent_page and not hasattr(parent_page, 'api_cleanup_threads'):
                parent_page = parent_page.parent()
            
            if parent_page and hasattr(parent_page, 'api_cleanup_threads'):
                if thread in parent_page.api_cleanup_threads:
                    parent_page.api_cleanup_threads.remove(thread)
                
                # Clean up the thread
                if thread.isRunning():
                    thread.wait(1000)  # Wait up to 1 second for completion
                thread.deleteLater()
                
                print(f"🧹 Cleaned up API cleanup thread")
        except Exception as e:
            print(f"⚠️ Error cleaning up API cleanup thread: {e}")
    
    def update_tab_counts(self):
        """Schedule a batched tab count update to prevent excessive UI updates"""
        self.pending_updates.add('tab_counts')
        if not self.update_timer.isActive():
            self.update_timer.start()
    
    def _perform_batched_update(self):
        """Perform all pending UI updates in a single batch"""
        if 'tab_counts' in self.pending_updates:
            self._update_tab_counts_immediate()
        
        # Clear pending updates
        self.pending_updates.clear()
    
    def _update_tab_counts_immediate(self):
        """Immediately update tab labels with current counts (internal use only)"""
        active_count = len(self.active_queue.download_items)
        finished_count = len(self.finished_queue.download_items)
        
        self.setTabText(0, f"Download Queue ({active_count})")
        self.setTabText(1, f"Finished Downloads ({finished_count})")
        
        # Also update the download manager stats if they exist
        # Find the DownloadsPage in the parent hierarchy
        parent_widget = self.parent()
        while parent_widget and not hasattr(parent_widget, 'update_download_manager_stats'):
            parent_widget = parent_widget.parent()
        
        if parent_widget and hasattr(parent_widget, 'update_download_manager_stats'):
            parent_widget.update_download_manager_stats(active_count, finished_count)
        else:
            print(f"[DEBUG] Could not find parent with update_download_manager_stats method")
    
    def clear_completed_downloads(self):
        """Clear completed and cancelled downloads from both slskd backend and local queues"""
        # Delegate to parent (DownloadsPage) which has access to soulseek_client
        if hasattr(self.parent(), 'clear_completed_downloads'):
            self.parent().clear_completed_downloads()
        else:
            # Fallback to local clearing if parent method not available
            print("[DEBUG] No parent clear method found, clearing locally only")
            # Clear from both active and finished queues
            self.active_queue.clear_completed_downloads()
            self.finished_queue.clear_completed_downloads()
            self.update_tab_counts()
    
    def clear_local_queues_only(self):
        """Clear only the local UI queues without backend operations (for use by parent)"""
        print("[DEBUG] TabbedDownloadManager.clear_local_queues_only() called")
        print(f"[DEBUG] Active queue has {len(self.active_queue.download_items)} items")
        print(f"[DEBUG] Finished queue has {len(self.finished_queue.download_items)} items")
        
        # Clear from both active and finished queues
        print("[DEBUG] Clearing active queue...")
        self.active_queue.clear_completed_downloads()
        print("[DEBUG] Clearing finished queue...")
        self.finished_queue.clear_completed_downloads()
        print("[DEBUG] Updating tab counts...")
        self.update_tab_counts()
        
        print(f"[DEBUG] After clearing - Active: {len(self.active_queue.download_items)}, Finished: {len(self.finished_queue.download_items)}")
    
    @property
    def download_items(self):
        """Return all download items from active queue for compatibility"""
        return self.active_queue.download_items

class DownloadsPage(QWidget):
    # Signals for media player communication
    track_started = pyqtSignal(object)  # Track result object
    track_paused = pyqtSignal()
    track_resumed = pyqtSignal() 
    track_stopped = pyqtSignal()
    track_finished = pyqtSignal()
    track_position_updated = pyqtSignal(float, float)  # current_position, duration in seconds
    track_loading_started = pyqtSignal(object)  # Track result object when streaming starts
    track_loading_finished = pyqtSignal(object)  # Track result object when streaming completes
    track_loading_progress = pyqtSignal(float, object)  # Progress percentage (0-100), track result object
    
    # Signal for dashboard stats tracking  
    download_session_completed = pyqtSignal(str, str)  # Emitted when a download completes (title, artist)
    
    # Signals for dashboard activity tracking
    download_activity = pyqtSignal(str, str, str, str)  # icon, title, subtitle, time
    
    # Signal for clear completed downloads completion (thread-safe communication)
    clear_completed_finished = pyqtSignal(bool, object)  # backend_success, ui_callback
    
    # Signal for API cleanup completion (thread-safe communication)
    api_cleanup_finished = pyqtSignal(bool, str, str)  # success, download_id, username
    
    def __init__(self, soulseek_client=None, parent=None):
        super().__init__(parent)
        self.soulseek_client = soulseek_client
        
        # --- FIX: Ensure the soulseek_client uses the download path from config ---
        if self.soulseek_client:
            from config.settings import config_manager
            download_path = config_manager.get('soulseek.download_path')
            if download_path and hasattr(self.soulseek_client, 'download_path'):
                self.soulseek_client.download_path = download_path
                print(f"✅ Set soulseek_client download path to: {download_path}")
        # --- END FIX ---

        self.search_thread = None
        self.explore_thread = None
        self.session_thread = None
        self.download_threads = []
        self.status_update_threads = []
        self.api_cleanup_threads = []
        self.search_results = []
        self.current_filtered_results = []
        self.download_items = []
        self.displayed_results = 0
        self.results_per_page = 15
        self.is_loading_more = False
        self._results_to_load_queue = []
        self.status_processing_pool = QThreadPool()
        self.status_processing_pool.setMaxThreadCount(1)
        self._is_status_update_running = False
        
        self.spotify_client = SpotifyClient()
        self.matching_engine = MusicMatchingEngine()
        
        import threading
        from concurrent.futures import ThreadPoolExecutor
        self.album_cache_lock = threading.Lock()
        self.album_groups = {}
        self.album_artists = {}
        self.album_editions = {}
        self.album_name_cache = {}
        
        self.api_thread_pool = ThreadPoolExecutor(max_workers=3, thread_name_prefix="SpotifyAPI")
        self.active_suggestion_threads = set()
        
        self.completion_thread_pool = QThreadPool()
        self.completion_thread_pool.setMaxThreadCount(2)
        
        self._optimized_api_pool = ThreadPoolExecutor(max_workers=8, thread_name_prefix="OptimizedAPI")
        self._optimized_completion_pool = QThreadPool()
        self._optimized_completion_pool.setMaxThreadCount(4)
        self._cleanup_pools = []
        
        self._queue_manager = ThreadSafeQueueManager()
        self._queue_consistency_lock = RLock()
        
        self.audio_player = AudioPlayer(self)
        self.audio_player.playback_finished.connect(self.on_audio_playback_finished)
        self.audio_player.playback_error.connect(self.on_audio_playback_error)
        self.currently_playing_button = None
        self.currently_expanded_item = None
        
        self.download_status_timer = QTimer()
        self.download_status_timer.timeout.connect(self.update_download_status)
        self.download_status_timer.start(1000)
        
        self._use_optimized_systems = False
        
        self._polling_intervals = {
            'active': 1500,
            'idle': 3000,
            'bulk_pause': 5000
        }
        self._current_polling_mode = 'active'
        self._bulk_operation_active = False
        self._last_active_count = 0
        
        self.downloads_to_cleanup = set()
        self.individual_downloads_to_cleanup = []
        
        self.clear_completed_finished.connect(self._handle_clear_completion)
        
        self.api_cleanup_finished.connect(self._handle_api_cleanup_completion)
        
        self.setup_ui()
    
    def set_toast_manager(self, toast_manager):
        """Set the toast manager for showing notifications"""
        self.toast_manager = toast_manager



    def setup_ui(self):
        self.setStyleSheet("""
            DownloadsPage {
                background: qlineargradient(x1:0, y1:0, x2:0, y2:1,
                    stop:0 rgba(25, 20, 20, 1.0),
                    stop:1 rgba(15, 15, 15, 1.0));
            }
        """)
        
        main_layout = QVBoxLayout(self)
        # Responsive margins that adapt to window size  
        main_layout.setContentsMargins(20, 16, 20, 20)  # Increased for better breathing room
        main_layout.setSpacing(16)  # Increased spacing for better visual hierarchy
        
        # Elegant Header
        header = self.create_elegant_header()
        main_layout.addWidget(header)
        
        # Main Content Area with responsive splitter
        content_splitter = QSplitter(Qt.Orientation.Horizontal)
        content_splitter.setChildrenCollapsible(False)  # Prevent panels from collapsing completely
        
        # LEFT: Search & Results section
        search_and_results = self.create_search_and_results_section()
        search_and_results.setMinimumWidth(400)  # Minimum width for usability
        content_splitter.addWidget(search_and_results)
        
        # RIGHT: Controls Panel
        controls_panel = self.create_collapsible_controls_panel()
        controls_panel.setMinimumWidth(280)  # Minimum width for controls
        controls_panel.setMaximumWidth(400)  # Maximum width to prevent overgrowth
        content_splitter.addWidget(controls_panel)
        
        # Set initial splitter proportions (roughly 70/30)
        content_splitter.setSizes([700, 300])
        content_splitter.setStretchFactor(0, 1)  # Search results gets priority for extra space
        content_splitter.setStretchFactor(1, 0)  # Controls panel stays fixed width when possible
        
        main_layout.addWidget(content_splitter)
    
    def create_elegant_header(self):
        """Create an elegant, minimal header"""
        header = QFrame()
        header.setMinimumHeight(80)  # Minimum height, can grow if needed
        header.setMaximumHeight(120)  # Maximum to prevent overgrowth
        header.setSizePolicy(QSizePolicy.Policy.Expanding, QSizePolicy.Policy.Preferred)
        header.setStyleSheet("""
            QFrame {
                background: transparent;
                border: none;
            }
        """)
        
        layout = QHBoxLayout(header)
        layout.setContentsMargins(20, 16, 20, 16)  # Increased padding for better header prominence
        layout.setSpacing(16)  # Increased spacing for better hierarchy
        
        # Icon and Title
        title_section = QVBoxLayout()
        title_section.setSpacing(6)  # Increased for better title hierarchy
        
        title_label = QLabel("🎵 Music Downloads")
        title_label.setFont(QFont("Segoe UI", 28, QFont.Weight.Bold))  # Larger for better prominence
        title_label.setStyleSheet("""
            color: #ffffff;
            font-weight: 700;
            letter-spacing: 1px;
        """)
        
        subtitle_label = QLabel("Search, discover, and download high-quality music")
        subtitle_label.setFont(QFont("Segoe UI", 13))
        subtitle_label.setStyleSheet("""
            color: rgba(255, 255, 255, 0.85);
            font-weight: 300;
            letter-spacing: 0.5px;
            margin-top: 4px;
        """)
        
        title_section.addWidget(title_label)
        title_section.addWidget(subtitle_label)
        
        layout.addLayout(title_section)
        layout.addStretch()
        
        return header
    
    def create_search_and_results_section(self):
        """Create the main search and results area - the star of the show"""
        section = QFrame()
        section.setStyleSheet("""
            QFrame {
                background: qlineargradient(x1:0, y1:0, x2:0, y2:1,
                    stop:0 rgba(40, 40, 40, 0.4),
                    stop:1 rgba(30, 30, 30, 0.6));
                border-radius: 16px;
                border: 1px solid rgba(64, 64, 64, 0.3);
            }
        """)
        
        layout = QVBoxLayout(section)
        layout.setContentsMargins(16, 12, 16, 12)  # Responsive spacing consistent with main layout
        layout.setSpacing(12)  # Consistent 12px spacing
        
        # Elegant Search Bar
        search_container = self.create_elegant_search_bar()
        layout.addWidget(search_container)
        
        # Filter Controls (initially hidden until we have results)
        self.filter_container = self.create_filter_controls()
        self.filter_container.setVisible(False)  # Hide until we have search results
        layout.addWidget(self.filter_container)
        
        # Search Status with better visual feedback and loading animations
        status_container = QWidget()
        status_layout = QHBoxLayout(status_container)
        status_layout.setContentsMargins(10, 8, 10, 8)
        status_layout.setSpacing(12)
        
        # Search status label
        self.search_status = QLabel("Ready to search • Enter artist, song, or album name")
        self.search_status.setFont(QFont("Arial", 11))
        self.search_status.setStyleSheet("""
            color: rgba(255, 255, 255, 0.7);
            padding: 2px 8px;
        """)
        
        # Loading animations (initially hidden)
        self.bouncing_dots = BouncingDotsWidget()
        self.bouncing_dots.setVisible(False)
        
        self.spinning_circle = SpinningCircleWidget()
        self.spinning_circle.setVisible(False)
        
        # Add to status layout
        status_layout.addWidget(self.spinning_circle)
        status_layout.addWidget(self.search_status)
        status_layout.addWidget(self.bouncing_dots)
        status_layout.addStretch()
        
        # Style the container
        status_container.setStyleSheet("""
            QWidget {
                background: qlineargradient(x1:0, y1:0, x2:1, y2:0,
                    stop:0 rgba(29, 185, 84, 0.12),
                    stop:1 rgba(29, 185, 84, 0.08));
                border-radius: 10px;
                border: 1px solid rgba(29, 185, 84, 0.25);
            }
        """)
        
        layout.addWidget(status_container)
        
        # Search Results - The main attraction
        results_container = QFrame()
        results_container.setStyleSheet("""
            QFrame {
                background: rgba(20, 20, 20, 0.3);
                border-radius: 12px;
                border: 1px solid rgba(64, 64, 64, 0.2);
            }
        """)
        
        results_layout = QVBoxLayout(results_container)
        results_layout.setContentsMargins(16, 12, 16, 16)  # Improved responsive spacing for better breathing room
        results_layout.setSpacing(12)  # Increased spacing for better visual hierarchy
        
        # Results header
        results_header = QLabel("Search Results")
        results_header.setFont(QFont("Segoe UI", 14, QFont.Weight.Bold))
        results_header.setStyleSheet("""
            color: rgba(255, 255, 255, 0.95);
            font-weight: 600;
            padding: 4px 8px;
        """)
        results_layout.addWidget(results_header)
        
        # Scrollable results area - this gets ALL remaining space
        self.search_results_scroll = QScrollArea()
        self.search_results_scroll.setWidgetResizable(True)
        self.search_results_scroll.setVerticalScrollBarPolicy(Qt.ScrollBarPolicy.ScrollBarAsNeeded)
        self.search_results_scroll.setHorizontalScrollBarPolicy(Qt.ScrollBarPolicy.ScrollBarAlwaysOff)
        self.search_results_scroll.setStyleSheet("""
            QScrollArea {
                border: none;
                background: transparent;
                border-radius: 8px;
            }
            QScrollBar:vertical {
                background: rgba(64, 64, 64, 0.3);
                width: 8px;
                border-radius: 4px;
                margin: 0;
            }
            QScrollBar::handle:vertical {
                background: qlineargradient(x1:0, y1:0, x2:0, y2:1,
                    stop:0 rgba(29, 185, 84, 0.8),
                    stop:1 rgba(29, 185, 84, 0.6));
                border-radius: 4px;
                min-height: 20px;
            }
            QScrollBar::handle:vertical:hover {
                background: rgba(29, 185, 84, 1.0);
            }
        """)
        
        self.search_results_widget = QWidget()
        self.search_results_layout = QVBoxLayout(self.search_results_widget)
        self.search_results_layout.setSpacing(8)  # Reduced spacing for more compact search results
        self.search_results_layout.setContentsMargins(12, 12, 12, 12)  # Increased for better edge spacing
        
        # Add centered loading animation for search results area
        self.results_loading_container = QWidget()
        results_loading_layout = QVBoxLayout(self.results_loading_container)
        results_loading_layout.setAlignment(Qt.AlignmentFlag.AlignCenter)
        
        self.results_spinning_circle = SpinningCircleWidget()
        self.results_loading_label = QLabel("Searching for results...")
        self.results_loading_label.setAlignment(Qt.AlignmentFlag.AlignCenter)
        self.results_loading_label.setStyleSheet("""
            color: rgba(255, 255, 255, 0.7);
            font-size: 14px;
            margin-top: 10px;
        """)
        
        results_loading_layout.addWidget(self.results_spinning_circle, 0, Qt.AlignmentFlag.AlignCenter)
        results_loading_layout.addWidget(self.results_loading_label, 0, Qt.AlignmentFlag.AlignCenter)
        self.results_loading_container.setVisible(False)  # Initially hidden
        
        # Add to main results layout
        self.search_results_layout.addWidget(self.results_loading_container)
        self.search_results_layout.addStretch()
        self.search_results_scroll.setWidget(self.search_results_widget)
        
        # Connect scroll detection for automatic loading
        scroll_bar = self.search_results_scroll.verticalScrollBar()
        scroll_bar.valueChanged.connect(self.on_scroll_changed)
        
        results_layout.addWidget(self.search_results_scroll)
        layout.addWidget(results_container, 1)  # This takes all remaining space
        
        return section
    
    def create_elegant_search_bar(self):
        """Create a beautiful, modern search bar"""
        container = QFrame()
        container.setFixedHeight(70)
        container.setStyleSheet("""
            QFrame {
                background: qlineargradient(x1:0, y1:0, x2:0, y2:1,
                    stop:0 rgba(50, 50, 50, 0.8),
                    stop:1 rgba(40, 40, 40, 0.9));
                border-radius: 12px;
                border: 1px solid rgba(29, 185, 84, 0.3);
            }
        """)
        
        layout = QHBoxLayout(container)
        layout.setContentsMargins(20, 16, 20, 16)  # Increased responsive spacing for better visual balance
        layout.setSpacing(16)  # Increased spacing for better visual hierarchy
        
        # Search input with enhanced styling
        self.search_input = QLineEdit()
        self.search_input.setPlaceholderText("Search for music... (e.g., 'Virtual Mage', 'Queen Bohemian Rhapsody')")
        self.search_input.setFixedHeight(40)
        self.search_input.setSizePolicy(QSizePolicy.Policy.Expanding, QSizePolicy.Policy.Fixed)  # Responsive width
        self.search_input.returnPressed.connect(self.perform_search)
        self.search_input.setStyleSheet("""
            QLineEdit {
                background: rgba(60, 60, 60, 0.7);
                border: 2px solid rgba(100, 100, 100, 0.3);
                border-radius: 20px;
                padding: 0 20px;
                color: #ffffff;
                font-size: 14px;
                font-weight: 500;
            }
            QLineEdit:focus {
                border: 2px solid rgba(29, 185, 84, 0.8);
                background: rgba(70, 70, 70, 0.9);
            }
            QLineEdit::placeholder {
                color: rgba(255, 255, 255, 0.5);
            }
        """)
        
        # Enhanced search button
        self.search_btn = QPushButton("🔍 Search")
        self.search_btn.setFixedSize(120, 40)
        self.search_btn.clicked.connect(self.perform_search)
        self.search_btn.setStyleSheet("""
            QPushButton {
                background: qlineargradient(x1:0, y1:0, x2:0, y2:1,
                    stop:0 rgba(29, 185, 84, 1.0),
                    stop:1 rgba(24, 156, 71, 1.0));
                border: none;
                border-radius: 20px;
                color: #000000;
                font-size: 13px;
                font-weight: bold;
            }
            QPushButton:hover {
                background: qlineargradient(x1:0, y1:0, x2:0, y2:1,
                    stop:0 rgba(30, 215, 96, 1.0),
                    stop:1 rgba(25, 180, 80, 1.0));
            }
            QPushButton:pressed {
                background: qlineargradient(x1:0, y1:0, x2:0, y2:1,
                    stop:0 rgba(24, 156, 71, 1.0),
                    stop:1 rgba(20, 130, 60, 1.0));
            }
            QPushButton:disabled {
                background: rgba(100, 100, 100, 0.3);
                color: rgba(255, 255, 255, 0.3);
            }
        """)
        
        # Cancel search button (initially hidden)
        self.cancel_search_btn = QPushButton("✕ Cancel")
        self.cancel_search_btn.setFixedSize(100, 40)
        self.cancel_search_btn.clicked.connect(self.cancel_search)
        self.cancel_search_btn.setVisible(False)  # Hidden by default
        self.cancel_search_btn.setStyleSheet("""
            QPushButton {
                background: qlineargradient(x1:0, y1:0, x2:0, y2:1,
                    stop:0 rgba(220, 53, 69, 0.9),
                    stop:1 rgba(200, 43, 58, 0.9));
                border: none;
                border-radius: 20px;
                color: #ffffff;
                font-size: 13px;
                font-weight: bold;
            }
            QPushButton:hover {
                background: qlineargradient(x1:0, y1:0, x2:0, y2:1,
                    stop:0 rgba(240, 73, 89, 1.0),
                    stop:1 rgba(220, 63, 79, 1.0));
            }
            QPushButton:pressed {
                background: qlineargradient(x1:0, y1:0, x2:0, y2:1,
                    stop:0 rgba(200, 43, 58, 1.0),
                    stop:1 rgba(180, 33, 48, 1.0));
            }
        """)
        
        layout.addWidget(self.search_input)
        layout.addWidget(self.cancel_search_btn)
        layout.addWidget(self.search_btn)
        
        return container
    
    def create_filter_controls(self):
        """Create elegant collapsible filter controls for Albums vs Singles, File Formats, and Sorting"""
        container = QFrame()
        container.setStyleSheet("""
            QFrame {
                background: qlineargradient(x1:0, y1:0, x2:0, y2:1,
                    stop:0 rgba(45, 45, 45, 0.6),
                    stop:1 rgba(35, 35, 35, 0.8));
                border-radius: 10px;
                border: 1px solid rgba(80, 80, 80, 0.25);
            }
        """)
        
        main_layout = QVBoxLayout(container)
        main_layout.setContentsMargins(16, 8, 16, 8)
        main_layout.setSpacing(6)
        
        # Initialize collapse state
        self.filters_collapsed = True
        
        # Toggle button row
        toggle_row = QHBoxLayout()
        toggle_row.setSpacing(8)
        
        self.filter_toggle_btn = QPushButton("⏷ Filters")
        self.filter_toggle_btn.setFixedHeight(32)
        self.filter_toggle_btn.setMinimumWidth(100)
        self.filter_toggle_btn.clicked.connect(self.toggle_filter_panel)
        self.filter_toggle_btn.setStyleSheet("""
            QPushButton {
                background: qlineargradient(x1:0, y1:0, x2:0, y2:1,
                    stop:0 rgba(80, 80, 80, 0.9),
                    stop:1 rgba(70, 70, 70, 0.95));
                border: 1px solid rgba(100, 100, 100, 0.3);
                border-radius: 6px;
                color: rgba(255, 255, 255, 0.8);
                font-size: 11px;
                font-weight: 600;
                font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif;
                letter-spacing: 0.3px;
            }
            QPushButton:hover {
                background: qlineargradient(x1:0, y1:0, x2:0, y2:1,
                    stop:0 rgba(90, 90, 90, 0.9),
                    stop:1 rgba(80, 80, 80, 0.95));
                color: rgba(255, 255, 255, 0.9);
            }
            QPushButton:pressed {
                background: qlineargradient(x1:0, y1:0, x2:0, y2:1,
                    stop:0 rgba(60, 60, 60, 0.9),
                    stop:1 rgba(50, 50, 50, 0.95));
            }
        """)
        
        toggle_row.addWidget(self.filter_toggle_btn)
        toggle_row.addStretch()
        main_layout.addLayout(toggle_row)
        
        # Collapsible content container
        self.filter_content = QWidget()
        self.filter_content_layout = QVBoxLayout(self.filter_content)
        self.filter_content_layout.setContentsMargins(0, 0, 0, 0)
        self.filter_content_layout.setSpacing(6)
        
        # First row: Type filters (Albums vs Singles)
        type_row = QHBoxLayout()
        type_row.setSpacing(8)
        
        type_label = QLabel("Type:")
        type_label.setStyleSheet("""
            QLabel {
                color: rgba(255, 255, 255, 0.8);
                font-size: 11px;
                font-weight: 600;
                font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif;
                letter-spacing: 0.3px;
            }
        """)
        
        # Initialize filter and sort state
        self.current_filter = "all"  # "all", "albums", "singles"
        self.current_format_filter = "all"  # "all", "flac", "mp3", "ogg", "aac", "wma"
        self.current_sort = "relevance"  # "relevance", "quality", "size", "name", "uploader", "bitrate", "duration", "availability", "speed"
        self.reverse_order = False  # False = normal order, True = reverse order
        self.current_search_query = ""  # Store search query for relevance calculation
        
        # Type filter buttons
        self.filter_all_btn = QPushButton("All")
        self.filter_albums_btn = QPushButton("Albums")
        self.filter_singles_btn = QPushButton("Singles")
        
        # Store type buttons for easy access
        self.filter_buttons = {
            "all": self.filter_all_btn,
            "albums": self.filter_albums_btn,
            "singles": self.filter_singles_btn
        }
        
        # Connect type button signals
        self.filter_all_btn.clicked.connect(lambda: self.set_filter("all"))
        self.filter_albums_btn.clicked.connect(lambda: self.set_filter("albums"))
        self.filter_singles_btn.clicked.connect(lambda: self.set_filter("singles"))
        
        # Apply styling to type buttons
        for btn_key, btn in self.filter_buttons.items():
            btn.setFixedHeight(28)
            btn.setMinimumWidth(60)
            self.update_filter_button_style(btn, btn_key == "all")
            
        type_row.addWidget(type_label)
        type_row.addWidget(self.filter_all_btn)
        type_row.addWidget(self.filter_albums_btn)
        type_row.addWidget(self.filter_singles_btn)
        type_row.addStretch()
        
        # Second row: Format filters
        format_row = QHBoxLayout()
        format_row.setSpacing(8)
        
        format_label = QLabel("Format:")
        format_label.setStyleSheet("""
            QLabel {
                color: rgba(255, 255, 255, 0.8);
                font-size: 11px;
                font-weight: 600;
                font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif;
                letter-spacing: 0.3px;
            }
        """)
        
        # Format filter buttons
        self.format_all_btn = QPushButton("All")
        self.format_flac_btn = QPushButton("FLAC")
        self.format_mp3_btn = QPushButton("MP3")
        self.format_ogg_btn = QPushButton("OGG")
        self.format_aac_btn = QPushButton("AAC")
        self.format_wma_btn = QPushButton("WMA")
        
        # Store format buttons for easy access
        self.format_buttons = {
            "all": self.format_all_btn,
            "flac": self.format_flac_btn,
            "mp3": self.format_mp3_btn,
            "ogg": self.format_ogg_btn,
            "aac": self.format_aac_btn,
            "wma": self.format_wma_btn
        }
        
        # Connect format button signals
        self.format_all_btn.clicked.connect(lambda: self.set_format_filter("all"))
        self.format_flac_btn.clicked.connect(lambda: self.set_format_filter("flac"))
        self.format_mp3_btn.clicked.connect(lambda: self.set_format_filter("mp3"))
        self.format_ogg_btn.clicked.connect(lambda: self.set_format_filter("ogg"))
        self.format_aac_btn.clicked.connect(lambda: self.set_format_filter("aac"))
        self.format_wma_btn.clicked.connect(lambda: self.set_format_filter("wma"))
        
        # Apply styling to format buttons
        for btn_key, btn in self.format_buttons.items():
            btn.setFixedHeight(28)
            btn.setMinimumWidth(50)
            self.update_filter_button_style(btn, btn_key == "all")
            
        format_row.addWidget(format_label)
        format_row.addWidget(self.format_all_btn)
        format_row.addWidget(self.format_flac_btn)
        format_row.addWidget(self.format_mp3_btn)
        format_row.addWidget(self.format_ogg_btn)
        format_row.addWidget(self.format_aac_btn)
        format_row.addWidget(self.format_wma_btn)
        format_row.addStretch()
        
        # Third row: Sorting controls
        sort_row = QHBoxLayout()
        sort_row.setSpacing(8)
        
        sort_label = QLabel("Sort by:")
        sort_label.setStyleSheet("""
            QLabel {
                color: rgba(255, 255, 255, 0.8);
                font-size: 11px;
                font-weight: 600;
                font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif;
                letter-spacing: 0.3px;
            }
        """)
        
        # Reverse order toggle button - simple arrows
        self.reverse_order_btn = QPushButton("↓")
        self.reverse_order_btn.setFixedSize(28, 28)  # Square button
        self.reverse_order_btn.clicked.connect(self.toggle_reverse_order)
        self.update_filter_button_style(self.reverse_order_btn, False)  # Start inactive
        
        # Sort buttons
        self.sort_relevance_btn = QPushButton("Relevance")
        self.sort_quality_btn = QPushButton("Quality")
        self.sort_size_btn = QPushButton("Size")
        self.sort_name_btn = QPushButton("Name")
        self.sort_uploader_btn = QPushButton("Uploader")
        self.sort_bitrate_btn = QPushButton("Bitrate")
        self.sort_duration_btn = QPushButton("Duration")
        self.sort_availability_btn = QPushButton("Available")
        self.sort_speed_btn = QPushButton("Speed")
        
        # Store sort buttons for easy access
        self.sort_buttons = {
            "relevance": self.sort_relevance_btn,
            "quality": self.sort_quality_btn,
            "size": self.sort_size_btn,
            "name": self.sort_name_btn,
            "uploader": self.sort_uploader_btn,
            "bitrate": self.sort_bitrate_btn,
            "duration": self.sort_duration_btn,
            "availability": self.sort_availability_btn,
            "speed": self.sort_speed_btn
        }
        
        # Connect sort button signals
        self.sort_relevance_btn.clicked.connect(lambda: self.set_sort("relevance"))
        self.sort_quality_btn.clicked.connect(lambda: self.set_sort("quality"))
        self.sort_size_btn.clicked.connect(lambda: self.set_sort("size"))
        self.sort_name_btn.clicked.connect(lambda: self.set_sort("name"))
        self.sort_uploader_btn.clicked.connect(lambda: self.set_sort("uploader"))
        self.sort_bitrate_btn.clicked.connect(lambda: self.set_sort("bitrate"))
        self.sort_duration_btn.clicked.connect(lambda: self.set_sort("duration"))
        self.sort_availability_btn.clicked.connect(lambda: self.set_sort("availability"))
        self.sort_speed_btn.clicked.connect(lambda: self.set_sort("speed"))
        
        # Apply styling to sort buttons
        for btn_key, btn in self.sort_buttons.items():
            btn.setFixedHeight(28)
            btn.setMinimumWidth(55)
            self.update_filter_button_style(btn, btn_key == "relevance")
            
        sort_row.addWidget(sort_label)
        sort_row.addWidget(self.reverse_order_btn)
        sort_row.addWidget(self.sort_relevance_btn)
        sort_row.addWidget(self.sort_quality_btn)
        sort_row.addWidget(self.sort_size_btn)
        sort_row.addWidget(self.sort_name_btn)
        sort_row.addWidget(self.sort_uploader_btn)
        sort_row.addWidget(self.sort_bitrate_btn)
        sort_row.addWidget(self.sort_duration_btn)
        sort_row.addWidget(self.sort_availability_btn)
        sort_row.addWidget(self.sort_speed_btn)
        sort_row.addStretch()
        
        # Add all filter rows to the collapsible content
        self.filter_content_layout.addLayout(type_row)
        self.filter_content_layout.addLayout(format_row)
        self.filter_content_layout.addLayout(sort_row)
        
        # Add collapsible content to main layout
        main_layout.addWidget(self.filter_content)
        
        # Start collapsed
        self.filter_content.setVisible(False)
        container.setFixedHeight(50)  # Height for toggle button only
        
        return container
    
    def toggle_filter_panel(self):
        """Toggle the filter panel between collapsed and expanded states"""
        self.filters_collapsed = not self.filters_collapsed
        
        if self.filters_collapsed:
            # Collapse
            self.filter_content.setVisible(False)
            self.filter_toggle_btn.setText("⏷ Filters")
            self.filter_container.setFixedHeight(50)
        else:
            # Expand
            self.filter_content.setVisible(True)
            self.filter_toggle_btn.setText("⏶ Filters")
            self.filter_container.setFixedHeight(175)  # Height for all content
    
    def update_filter_button_style(self, button, is_active):
        """Update the visual style of filter buttons based on active state"""
        if is_active:
            button.setStyleSheet("""
                QPushButton {
                    background: qlineargradient(x1:0, y1:0, x2:0, y2:1,
                        stop:0 #1ed760,
                        stop:1 #1db954);
                    border: none;
                    border-radius: 16px;
                    color: #000000;
                    font-size: 11px;
                    font-weight: 700;
                    font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif;
                    padding: 0 12px;
                }
                QPushButton:hover {
                    background: qlineargradient(x1:0, y1:0, x2:0, y2:1,
                        stop:0 #1fdf64,
                        stop:1 #1ed760);
                }
                QPushButton:pressed {
                    background: qlineargradient(x1:0, y1:0, x2:0, y2:1,
                        stop:0 #1ca851,
                        stop:1 #169c46);
                }
            """)
        else:
            button.setStyleSheet("""
                QPushButton {
                    background: qlineargradient(x1:0, y1:0, x2:0, y2:1,
                        stop:0 rgba(80, 80, 80, 0.4),
                        stop:1 rgba(60, 60, 60, 0.6));
                    border: 1px solid rgba(120, 120, 120, 0.3);
                    border-radius: 16px;
                    color: rgba(255, 255, 255, 0.8);
                    font-size: 11px;
                    font-weight: 500;
                    font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif;
                    padding: 0 12px;
                }
                QPushButton:hover {
                    background: qlineargradient(x1:0, y1:0, x2:0, y2:1,
                        stop:0 rgba(100, 100, 100, 0.5),
                        stop:1 rgba(80, 80, 80, 0.7));
                    border: 1px solid rgba(140, 140, 140, 0.4);
                    color: rgba(255, 255, 255, 0.9);
                }
                QPushButton:pressed {
                    background: qlineargradient(x1:0, y1:0, x2:0, y2:1,
                        stop:0 rgba(60, 60, 60, 0.6),
                        stop:1 rgba(40, 40, 40, 0.8));
                }
            """)
    
    def set_filter(self, filter_type):
        """Set the active filter and update UI"""
        self.current_filter = filter_type
        
        # Update button styles
        for btn_key, btn in self.filter_buttons.items():
            self.update_filter_button_style(btn, btn_key == filter_type)
        
        # Apply the filter to current results
        self.apply_filter()
    
    def set_format_filter(self, format_type):
        """Set the current format filter and update button styles"""
        self.current_format_filter = format_type
        
        # Update format button styles
        for btn_key, btn in self.format_buttons.items():
            self.update_filter_button_style(btn, btn_key == format_type)
        
        # Apply the filter to current results
        self.apply_filter()
    
    def set_sort(self, sort_type):
        """Set the current sort type and update button styles"""
        self.current_sort = sort_type
        
        # Update sort button styles
        for btn_key, btn in self.sort_buttons.items():
            self.update_filter_button_style(btn, btn_key == sort_type)
        
        # Apply the sort to current results
        self.apply_filter()
    
    def toggle_reverse_order(self):
        """Toggle the reverse order setting and update button styles"""
        self.reverse_order = not self.reverse_order
        
        # Update arrow direction and button style
        if self.reverse_order:
            self.reverse_order_btn.setText("↑")  # Up arrow for reverse order
        else:
            self.reverse_order_btn.setText("↓")  # Down arrow for normal order
        
        self.update_filter_button_style(self.reverse_order_btn, self.reverse_order)
        
        # Apply the new sort order to current results
        self.apply_filter()
    
    def sort_results(self, results):
        """Sort search results based on current sort type and reverse order setting"""
        if not results or not hasattr(self, 'current_sort'):
            return results
        
        # Define default reverse logic for each sort type (normal behavior)
        default_reverse_logic = {
            "relevance": True,      # High relevance first
            "quality": True,        # High quality first  
            "size": True,           # Large files first
            "name": False,          # A-Z alphabetical
            "uploader": False,      # A-Z alphabetical
            "bitrate": True,        # High bitrate first
            "duration": True,       # Long duration first
            "availability": True,   # More available first
            "speed": True           # Fast speed first
        }
        
        # Get the default reverse setting for current sort type
        default_reverse = default_reverse_logic.get(self.current_sort, False)
        
        # Apply user's reverse order toggle (XOR logic)
        # If reverse_order is True, flip the default behavior
        final_reverse = default_reverse if not self.reverse_order else not default_reverse
        
        # Apply the appropriate sorting
        if self.current_sort == "relevance":
            sorted_results = sorted(results, key=self._sort_by_relevance, reverse=final_reverse)
        elif self.current_sort == "quality":
            sorted_results = sorted(results, key=self._sort_by_quality, reverse=final_reverse)
        elif self.current_sort == "size":
            sorted_results = sorted(results, key=self._sort_by_size, reverse=final_reverse)
        elif self.current_sort == "name":
            sorted_results = sorted(results, key=self._sort_by_name, reverse=final_reverse)
        elif self.current_sort == "uploader":
            sorted_results = sorted(results, key=self._sort_by_uploader, reverse=final_reverse)
        elif self.current_sort == "bitrate":
            sorted_results = sorted(results, key=self._sort_by_bitrate, reverse=final_reverse)
        elif self.current_sort == "duration":
            sorted_results = sorted(results, key=self._sort_by_duration, reverse=final_reverse)
        elif self.current_sort == "availability":
            sorted_results = sorted(results, key=self._sort_by_availability, reverse=final_reverse)
        elif self.current_sort == "speed":
            sorted_results = sorted(results, key=self._sort_by_speed, reverse=final_reverse)
        else:
            sorted_results = results
        
        return sorted_results
    
    def _sort_by_relevance(self, result):
        """Sort by relevance score combining search matching, quality, completeness, and availability"""
        if not hasattr(self, 'current_search_query') or not self.current_search_query:
            # Fallback to quality score if no search query
            return self._sort_by_quality(result)
        
        score = 0.0
        query_terms = self.current_search_query.lower().split()
        
        # 1. Search Term Matching (40% weight - 0.4 max)
        search_score = self._calculate_search_match_score(result, query_terms)
        score += search_score * 0.4
        
        # 2. Quality Score (25% weight - 0.25 max)
        quality_score = self._sort_by_quality(result)
        score += quality_score * 0.25
        
        # 3. File Completeness (20% weight - 0.2 max)
        completeness_score = self._calculate_completeness_score(result)
        score += completeness_score * 0.2
        
        # 4. User Reliability (10% weight - 0.1 max)
        reliability_score = self._calculate_reliability_score(result)
        score += reliability_score * 0.1
        
        # 5. File Freshness (5% weight - 0.05 max)
        freshness_score = self._calculate_freshness_score(result)
        score += freshness_score * 0.05
        
        return score
    
    def _calculate_search_match_score(self, result, query_terms):
        """Calculate search term matching score (0.0 to 1.0)"""
        if not query_terms:
            return 0.0
        
        # Get searchable text
        searchable_text = ""
        if hasattr(result, 'album_title'):  # AlbumResult
            searchable_text = f"{result.album_title} {result.artist or ''}"
        elif hasattr(result, 'filename'):  # TrackResult
            searchable_text = f"{result.filename} {result.artist or ''} {result.title or ''} {result.album or ''}"
        
        searchable_text = searchable_text.lower()
        full_query = self.current_search_query.lower()
        
        score = 0.0
        
        # Exact match bonus (1.0 points)
        if full_query in searchable_text:
            score += 1.0
        
        # Individual term matches (0.5 points each)
        term_matches = 0
        for term in query_terms:
            if term in searchable_text:
                term_matches += 1
        score += (term_matches / len(query_terms)) * 0.5
        
        # Position bonus (0.3 points if terms appear early)
        position_bonus = 0.0
        for term in query_terms:
            pos = searchable_text.find(term)
            if pos >= 0:
                # Earlier positions get higher bonus
                position_bonus += max(0, (50 - pos) / 50) * 0.3
        score += position_bonus / len(query_terms)
        
        return min(score, 1.0)
    
    def _calculate_completeness_score(self, result):
        """Calculate file completeness score (0.0 to 1.0)"""
        score = 0.0
        
        if hasattr(result, 'tracks'):  # AlbumResult
            # Complete albums bonus
            track_count = len(result.tracks)
            if 8 <= track_count <= 20:
                score += 0.8
            elif 5 <= track_count <= 25:
                score += 0.6
            elif track_count > 25:
                score += 0.4
            else:
                score += 0.2
                
            # Album metadata bonus
            if result.artist and result.album_title:
                score += 0.2
        else:  # TrackResult
            # Popular song length bonus
            if hasattr(result, 'duration') and result.duration:
                if 180 <= result.duration <= 300:  # 3-5 minutes
                    score += 0.6
                elif 120 <= result.duration <= 360:  # 2-6 minutes
                    score += 0.4
                else:
                    score += 0.2
            else:
                score += 0.3  # Default if no duration
                
            # Track metadata bonus
            if result.artist and result.title:
                score += 0.4
            elif result.artist or result.title:
                score += 0.2
        
        return min(score, 1.0)
    
    def _calculate_reliability_score(self, result):
        """Calculate user reliability score (0.0 to 1.0)"""
        score = 0.0
        
        # High upload speed bonus
        if hasattr(result, 'upload_speed'):
            if result.upload_speed > 500:
                score += 0.3
            elif result.upload_speed > 200:
                score += 0.2
            elif result.upload_speed > 100:
                score += 0.1
        
        # Available slots bonus
        if hasattr(result, 'free_upload_slots') and result.free_upload_slots > 0:
            score += 0.2
        
        # Low queue bonus
        if hasattr(result, 'queue_length'):
            if result.queue_length < 5:
                score += 0.1
            elif result.queue_length > 20:
                score -= 0.1
        
        return max(0.0, min(score, 1.0))
    
    def _calculate_freshness_score(self, result):
        """Calculate file freshness/naming quality score (0.0 to 1.0)"""
        score = 0.0
        
        filename = ""
        if hasattr(result, 'album_title'):  # AlbumResult
            filename = result.album_title
        elif hasattr(result, 'filename'):  # TrackResult
            filename = result.filename
        
        if filename:
            # Proper naming patterns bonus
            if any(pattern in filename.lower() for pattern in [' - ', '_', ' / ', ' & ']):
                score += 0.2
            
            # Standard format bonus
            if any(ext in filename.lower() for ext in ['.flac', '.mp3', '.ogg', '.aac']):
                score += 0.1
            
            # Avoid weird characters penalty
            if any(char in filename for char in ['@', '#', '$', '%', '!', '?']):
                score -= 0.1
                
            # Length bonus (not too short, not too long)
            if 10 <= len(filename) <= 100:
                score += 0.1
        
        return max(0.0, min(score, 1.0))
    
    def _sort_by_quality(self, result):
        """Sort by quality score (higher is better)"""
        if hasattr(result, 'quality_score'):
            return result.quality_score
        return 0
    
    def _sort_by_size(self, result):
        """Sort by file/album size (larger first)"""
        size = 0
        if hasattr(result, 'total_size'):  # AlbumResult
            size = result.total_size
        elif hasattr(result, 'size'):  # TrackResult
            size = result.size
        return size
    
    def _sort_by_name(self, result):
        """Sort alphabetically by filename/album title"""
        name = ""
        if hasattr(result, 'album_title'):  # AlbumResult
            name = result.album_title.lower()
        elif hasattr(result, 'filename'):  # TrackResult
            name = result.filename.lower()
        return name
    
    def _sort_by_uploader(self, result):
        """Sort alphabetically by username"""
        return result.username.lower() if hasattr(result, 'username') else ""
    
    def _sort_by_bitrate(self, result):
        """Sort by bitrate (higher first)"""
        if hasattr(result, 'bitrate') and result.bitrate:
            return result.bitrate
        # For albums, get average bitrate from tracks
        elif hasattr(result, 'tracks') and result.tracks:
            bitrates = [track.bitrate for track in result.tracks if track.bitrate]
            return sum(bitrates) / len(bitrates) if bitrates else 0
        return 0
    
    def _sort_by_duration(self, result):
        """Sort by duration (longer first)"""
        if hasattr(result, 'duration') and result.duration:
            return result.duration
        # For albums, sum all track durations
        elif hasattr(result, 'tracks') and result.tracks:
            durations = [track.duration for track in result.tracks if track.duration]
            return sum(durations) if durations else 0
        return 0
    
    def _sort_by_availability(self, result):
        """Sort by availability (free slots high, queue length low is better)"""
        free_slots = result.free_upload_slots if hasattr(result, 'free_upload_slots') else 0
        queue_length = result.queue_length if hasattr(result, 'queue_length') else 0
        # Higher free slots and lower queue length = more available
        return free_slots - (queue_length * 0.1)
    
    def _sort_by_speed(self, result):
        """Sort by upload speed (faster first)"""
        return result.upload_speed if hasattr(result, 'upload_speed') else 0
    
    def apply_filter(self):
        """Apply the current type and format filters to search results"""
        if not hasattr(self, '_temp_tracks') or not hasattr(self, '_temp_albums'):
            return
            
        # First, filter by type (Albums vs Singles)
        if self.current_filter == "all":
            type_filtered = self._temp_albums + self._temp_tracks
        elif self.current_filter == "albums":
            type_filtered = self._temp_albums
        elif self.current_filter == "singles":
            type_filtered = self._temp_tracks
        else:
            type_filtered = self._temp_albums + self._temp_tracks
        
        # Then, filter by format
        if self.current_format_filter == "all":
            filtered_results = type_filtered
        else:
            # Filter results by file format
            filtered_results = []
            for result in type_filtered:
                # For albums, check if any tracks match the format
                if hasattr(result, 'tracks') and result.tracks:
                    # Album result - check if any tracks match format
                    matching_tracks = [track for track in result.tracks 
                                     if track.quality.lower() == self.current_format_filter.lower()]
                    if matching_tracks:
                        # Create a copy of the album with only matching tracks
                        filtered_album = result
                        filtered_album.tracks = matching_tracks
                        filtered_results.append(filtered_album)
                else:
                    # Single track result - check format directly
                    if hasattr(result, 'quality') and result.quality.lower() == self.current_format_filter.lower():
                        filtered_results.append(result)
        
        # Apply sorting to filtered results
        sorted_results = self.sort_results(filtered_results)
        # Update the filtered results cache for pagination
        self.current_filtered_results = sorted_results
        
        # Clear current display
        self.clear_search_results()
        self.displayed_results = 0
        self.currently_expanded_item = None  # Reset expanded state when applying filters
        
        # Show sorted results (respecting pagination)
        remaining_slots = self.results_per_page
        results_to_show = sorted_results[:remaining_slots]
        
        # Temporarily disable layout updates for smoother batch loading
        self.search_results_widget.setUpdatesEnabled(False)
        
        for result in results_to_show:
            if isinstance(result, AlbumResult):
                # Create expandable album result item
                result_item = AlbumResultItem(result)
                result_item.album_download_requested.connect(self.start_album_download)
                result_item.matched_album_download_requested.connect(self.start_matched_album_download)
                result_item.track_download_requested.connect(self.start_download)
                result_item.track_stream_requested.connect(lambda search_result, track_item: self.start_stream(search_result, track_item))
            else:
                # Create individual track result item
                result_item = SearchResultItem(result)
                result_item.download_requested.connect(self.start_download)
                result_item.stream_requested.connect(lambda search_result, item=result_item: self.start_stream(search_result, item))
                result_item.expansion_requested.connect(self.handle_expansion_request)
            
            # Insert before the stretch
            insert_position = self.search_results_layout.count() - 1
            self.search_results_layout.insertWidget(insert_position, result_item)
        
        self.displayed_results = len(results_to_show)
        
        # Re-enable layout updates
        self.search_results_widget.setUpdatesEnabled(True)
        
        # Update status to show filter results
        total_albums = len(self._temp_albums)
        total_tracks = len(self._temp_tracks)
        total_filtered = len(sorted_results)
        
        if self.current_filter == "all":
            filter_status = f"Showing all {total_filtered} results"
        elif self.current_filter == "albums":
            filter_status = f"Showing {total_albums} albums"
        elif self.current_filter == "singles":
            filter_status = f"Showing {total_tracks} singles"
        else:
            filter_status = f"Showing {total_filtered} results"
            
        # Update the search status to reflect filtering
        if total_filtered > 0:
            if total_filtered > self.results_per_page:
                filter_status += f" (showing first {len(results_to_show)})"
            self.search_status.setText(f"✨ {filter_status} • {total_albums} albums, {total_tracks} singles")
        else:
            self.search_status.setText(f"No results found for '{self.current_filter}' filter")
    
    def create_collapsible_controls_panel(self):
        """Create a compact, elegant controls panel"""
        panel = QFrame()
        panel.setStyleSheet("""
            QFrame {
                background: qlineargradient(x1:0, y1:0, x2:0, y2:1,
                    stop:0 rgba(40, 40, 40, 0.85),
                    stop:1 rgba(25, 25, 25, 0.95));
                border-radius: 18px;
                border: 1px solid rgba(80, 80, 80, 0.4);
            }
        """)
        
        layout = QVBoxLayout(panel)
        layout.setContentsMargins(8, 14, 8, 16)  # Reduced side margins for wider download queue
        layout.setSpacing(14)  # Increased spacing for better section separation
        
        # Panel header
        header = QLabel("Download Manager")
        header.setFont(QFont("Arial", 12, QFont.Weight.Bold))
        header.setStyleSheet("color: rgba(255, 255, 255, 0.9); padding: 6px 0; margin: 0;")
        layout.addWidget(header)
        
        # Quick stats with improved styling
        stats_frame = QFrame()
        stats_frame.setStyleSheet("""
            QFrame {
                background: qlineargradient(x1:0, y1:0, x2:0, y2:1,
                    stop:0 rgba(45, 45, 45, 0.7),
                    stop:1 rgba(35, 35, 35, 0.8));
                border-radius: 10px;
                border: 1px solid rgba(80, 80, 80, 0.3);
            }
        """)
        stats_layout = QVBoxLayout(stats_frame)
        stats_layout.setContentsMargins(10, 8, 10, 8)
        stats_layout.setSpacing(4)
        
        self.active_downloads_label = QLabel("• Active Downloads: 0")
        self.active_downloads_label.setFont(QFont("Arial", 9))
        self.active_downloads_label.setStyleSheet("color: rgba(255, 255, 255, 0.8); margin: 0; padding: 2px 0;")
        
        self.finished_downloads_label = QLabel("• Finished Downloads: 0")
        self.finished_downloads_label.setFont(QFont("Arial", 9))
        self.finished_downloads_label.setStyleSheet("color: rgba(255, 255, 255, 0.8); margin: 0; padding: 2px 0;")
        
        stats_layout.addWidget(self.active_downloads_label)
        stats_layout.addWidget(self.finished_downloads_label)
        layout.addWidget(stats_frame)
        
        # Control buttons with enhanced styling
        controls_frame = QFrame()
        controls_frame.setStyleSheet("""
            QFrame {
                background: qlineargradient(x1:0, y1:0, x2:0, y2:1,
                    stop:0 rgba(50, 50, 50, 0.6),
                    stop:1 rgba(30, 30, 30, 0.7));
                border-radius: 10px;
                border: 1px solid rgba(70, 70, 70, 0.4);
            }
        """)
        controls_layout = QVBoxLayout(controls_frame)
        controls_layout.setContentsMargins(10, 10, 10, 10)
        controls_layout.setSpacing(6)
        
        clear_btn = QPushButton("🗑️ Clear Completed")
        clear_btn.setFixedHeight(28)
        clear_btn.clicked.connect(self.clear_completed_downloads)
        clear_btn.setStyleSheet(self._get_control_button_style("#e22134"))
        
        controls_layout.addWidget(clear_btn)
        layout.addWidget(controls_frame)
        
        # Download Queue Section - Now with tabs for active and finished downloads
        queue_container = QFrame()
        queue_container.setStyleSheet("""
            QFrame {
                background: transparent;
                border: none;
                margin-top: 5px;
            }
        """)
        queue_layout = QVBoxLayout(queue_container)
        queue_layout.setContentsMargins(0, 0, 0, 0)
        
        self.download_queue = TabbedDownloadManager(self)
        queue_layout.addWidget(self.download_queue)
        layout.addWidget(queue_container)
        
        # Force initial counter update after queue is set up
        if self.download_queue:
            self.download_queue.update_tab_counts()
        
        # Initialize stats display
        self.update_download_manager_stats(0, 0)
        
        
        return panel
    
    def update_download_manager_stats(self, active_count, finished_count):
        """Update the download manager statistics display"""
        if hasattr(self, 'active_downloads_label'):
            self.active_downloads_label.setText(f"• Active Downloads: {active_count}")
        if hasattr(self, 'finished_downloads_label'):
            self.finished_downloads_label.setText(f"• Finished Downloads: {finished_count}")
    
    def create_compact_status_bar(self):
        """Create a minimal status bar"""
        status_bar = QFrame()
        status_bar.setFixedHeight(40)
        status_bar.setStyleSheet("""
            QFrame {
                background: rgba(20, 20, 20, 0.8);
                border-radius: 8px;
                border: 1px solid rgba(64, 64, 64, 0.2);
            }
        """)
        
        layout = QHBoxLayout(status_bar)
        layout.setContentsMargins(16, 8, 16, 8)
        layout.setSpacing(12)
        
        connection_status = QLabel("🟢 slskd Connected")
        connection_status.setFont(QFont("Arial", 10))
        connection_status.setStyleSheet("color: rgba(29, 185, 84, 0.9);")
        
        layout.addWidget(connection_status)
        layout.addStretch()
        
        download_path_info = QLabel(f"📁 Downloads: {self.soulseek_client.download_path if self.soulseek_client else './downloads'}")
        download_path_info.setFont(QFont("Arial", 9))
        download_path_info.setStyleSheet("color: rgba(255, 255, 255, 0.6);")
        layout.addWidget(download_path_info)
        
        return status_bar
    
    def _get_control_button_style(self, color):
        """Get consistent button styling with improved aesthetics"""
        return f"""
            QPushButton {{
                background: qlineargradient(x1:0, y1:0, x2:0, y2:1,
                    stop:0 rgba{tuple(int(color[i:i+2], 16) for i in (1, 3, 5)) + (40,)},
                    stop:1 rgba{tuple(int(color[i:i+2], 16) for i in (1, 3, 5)) + (25,)});
                border: 1px solid rgba{tuple(int(color[i:i+2], 16) for i in (1, 3, 5)) + (80,)};
                border-radius: 14px;
                color: {color};
                font-size: 10px;
                font-weight: 600;
                padding: 5px 10px;
                text-align: center;
            }}
            QPushButton:hover {{
                background: qlineargradient(x1:0, y1:0, x2:0, y2:1,
                    stop:0 rgba{tuple(int(color[i:i+2], 16) for i in (1, 3, 5)) + (60,)},
                    stop:1 rgba{tuple(int(color[i:i+2], 16) for i in (1, 3, 5)) + (40,)});
                border: 1px solid {color};
                color: #ffffff;
            }}
            QPushButton:pressed {{
                background: rgba{tuple(int(color[i:i+2], 16) for i in (1, 3, 5)) + (80,)};
                border: 1px solid {color};
            }}
        """
    
    def create_search_section(self):
        section = QFrame()
        section.setFixedHeight(350)
        section.setStyleSheet("""
            QFrame {
                background: #282828;
                border-radius: 8px;
                border: 1px solid #404040;
            }
        """)
        
        layout = QVBoxLayout(section)
        layout.setContentsMargins(20, 20, 20, 20)
        layout.setSpacing(15)
        
        # Search header
        search_header = QLabel("Search & Download")
        search_header.setFont(QFont("Arial", 16, QFont.Weight.Bold))
        search_header.setStyleSheet("color: #ffffff;")
        
        # Search input and button
        search_layout = QHBoxLayout()
        
        self.search_input = QLineEdit()
        self.search_input.setPlaceholderText("Search for music (e.g., 'Artist - Song Title')")
        self.search_input.setFixedHeight(40)
        self.search_input.returnPressed.connect(self.perform_search)
        self.search_input.setStyleSheet("""
            QLineEdit {
                background: #404040;
                border: 1px solid #606060;
                border-radius: 20px;
                padding: 0 15px;
                color: #ffffff;
                font-size: 12px;
            }
            QLineEdit:focus {
                border: 1px solid #1db954;
            }
        """)
        
        self.search_btn = QPushButton("🔍 Search")
        self.search_btn.setFixedSize(100, 40)
        self.search_btn.clicked.connect(self.perform_search)
        self.search_btn.setStyleSheet("""
            QPushButton {
                background: #1db954;
                border: none;
                border-radius: 20px;
                color: #000000;
                font-size: 12px;
                font-weight: bold;
            }
            QPushButton:hover {
                background: #1ed760;
            }
            QPushButton:disabled {
                background: #404040;
                color: #666666;
            }
        """)
        
        search_layout.addWidget(self.search_input)
        search_layout.addWidget(self.search_btn)
        
        # Search status
        self.search_status = QLabel("Enter a search term and click Search")
        self.search_status.setFont(QFont("Arial", 10))
        self.search_status.setStyleSheet("color: #b3b3b3;")
        
        # Search results
        self.search_results_scroll = QScrollArea()
        self.search_results_scroll.setWidgetResizable(True)
        self.search_results_scroll.setStyleSheet("""
            QScrollArea {
                border: none;
                background: transparent;
            }
            QScrollBar:vertical {
                background: #404040;
                width: 8px;
                border-radius: 4px;
            }
            QScrollBar::handle:vertical {
                background: #1db954;
                border-radius: 4px;
            }
        """)
        
        self.search_results_widget = QWidget()
        self.search_results_layout = QVBoxLayout(self.search_results_widget)
        self.search_results_layout.setSpacing(5)
        
        # Just add stretch - no load more button needed with auto-scroll
        self.search_results_layout.addStretch()
        self.search_results_scroll.setWidget(self.search_results_widget)
        
        layout.addWidget(search_header)
        layout.addLayout(search_layout)
        layout.addWidget(self.search_status)
        layout.addWidget(self.search_results_scroll)
        
        return section
    
    def perform_search(self):
        query = self.search_input.text().strip()
        if not query:
            self.update_search_status("⚠️ Please enter a search term", "#ffa500")
            return
        
        if not self.soulseek_client:
            self.update_search_status("❌ Soulseek client not available", "#e22134")
            return
        
        # Stop any existing search
        if self.search_thread and self.search_thread.isRunning():
            self.search_thread.stop()
            self.search_thread.wait(1000)  # Wait up to 1 second
            if self.search_thread.isRunning():
                self.search_thread.terminate()
        
        # Clear previous results and reset state
        self.clear_search_results()
        self.displayed_results = 0
        self.is_loading_more = False
        self.currently_expanded_item = None  # Reset expanded state
        
        # Reset filter to "all" and sort to "relevance", hide filter controls
        self.current_filter = "all"
        self.current_sort = "relevance"
        self.reverse_order = False  # Reset reverse order to normal
        self.current_search_query = query  # Store search query for relevance calculation
        if hasattr(self, 'filter_buttons'):
            for btn_key, btn in self.filter_buttons.items():
                self.update_filter_button_style(btn, btn_key == "all")
        if hasattr(self, 'format_buttons'):
            for btn_key, btn in self.format_buttons.items():
                self.update_filter_button_style(btn, btn_key == "all")
        if hasattr(self, 'sort_buttons'):
            for btn_key, btn in self.sort_buttons.items():
                self.update_filter_button_style(btn, btn_key == "relevance")
        if hasattr(self, 'reverse_order_btn'):
            self.reverse_order_btn.setText("↓")  # Reset to down arrow
            self.update_filter_button_style(self.reverse_order_btn, False)  # Reset to inactive
        self.filter_container.setVisible(False)
        
        # Enhanced searching state with animation
        self.search_btn.setText("🔍 Searching...")
        self.search_btn.setEnabled(False)
        self.update_search_status(f"Searching for '{query}'... Results will appear as they are found", "#1db954")
        
        # Emit activity signal for search start
        self.download_activity.emit("🔍", "Search Started", f"Searching for '{query}'", "Now")
        
        # Show loading animations
        self.start_search_animations()
        
        # Start new search thread
        self.search_thread = SearchThread(self.soulseek_client, query)
        self.search_thread.search_completed.connect(self.on_search_completed)
        self.search_thread.search_failed.connect(self.on_search_failed)
        self.search_thread.search_progress.connect(self.on_search_progress)
        self.search_thread.search_results_partial.connect(self.on_search_results_partial)
        self.search_thread.finished.connect(self.on_search_thread_finished)
        self.search_thread.start()
        
        # Show cancel button and hide search button during search
        self.cancel_search_btn.setVisible(True)
        self.search_btn.setVisible(False)
    
    def cancel_search(self):
        """Cancel the current search operation"""
        if self.search_thread and self.search_thread.isRunning():
            # Stop the search thread
            self.search_thread.stop()
            self.search_thread.wait(1000)  # Wait up to 1 second
            if self.search_thread.isRunning():
                self.search_thread.terminate()
        
        # Reset UI state
        self.search_btn.setText("🔍 Search")
        self.search_btn.setEnabled(True)
        self.search_btn.setVisible(True)
        self.cancel_search_btn.setVisible(False)
        
        # Stop animations and update status
        self.stop_search_animations()
        self.update_search_status("Search cancelled", "#ffa500")
    
    def update_search_status(self, message, color="#ffffff"):
        """Update search status with enhanced styling"""
        self.search_status.setText(message)
        
        if color == "#1db954":  # Success/searching
            bg_color = "rgba(29, 185, 84, 0.15)"
            border_color = "rgba(29, 185, 84, 0.3)"
        elif color == "#ffa500":  # Warning
            bg_color = "rgba(255, 165, 0, 0.15)"
            border_color = "rgba(255, 165, 0, 0.3)"
        elif color == "#e22134":  # Error
            bg_color = "rgba(226, 33, 52, 0.15)"
            border_color = "rgba(226, 33, 52, 0.3)"
        else:  # Default
            bg_color = "rgba(100, 100, 100, 0.1)"
            border_color = "rgba(100, 100, 100, 0.2)"
        
        self.search_status.setStyleSheet(f"""
            color: {color};
            padding: 2px 8px;
        """)
    
    def start_search_animations(self):
        """Start all search loading animations"""
        # Show and start status area animations
        self.spinning_circle.setVisible(True)
        self.spinning_circle.start_animation()
        self.bouncing_dots.setVisible(True)
        self.bouncing_dots.start_animation()
        
        # Show and start results area loading
        self.results_loading_container.setVisible(True)
        self.results_spinning_circle.start_animation()
    
    def stop_search_animations(self):
        """Stop and hide all search loading animations"""
        # Stop and hide status area animations
        self.spinning_circle.stop_animation()
        self.spinning_circle.setVisible(False)
        self.bouncing_dots.stop_animation()
        self.bouncing_dots.setVisible(False)
        
        # Stop and hide results area loading
        self.results_spinning_circle.stop_animation()
        self.results_loading_container.setVisible(False)
    
    def on_search_thread_finished(self):
        """Clean up when search thread finishes"""
        if self.search_thread:
            self.search_thread.deleteLater()
            self.search_thread = None
    
    def clear_search_results(self):
        # Remove all result items except the stretch
        for i in reversed(range(self.search_results_layout.count())):
            item = self.search_results_layout.itemAt(i)
            if item.widget():
                item.widget().deleteLater()
            elif item.spacerItem():
                continue  # Keep the stretch spacer
            else:
                self.search_results_layout.removeItem(item)
    
    def on_search_results_partial(self, tracks, albums, response_count):
        """Handle progressive search results as they come in"""
        # Combine tracks and albums into a single list for display (albums first, then tracks)
        combined_results = albums + tracks
        
        # Initialize temp results if not exists
        if not hasattr(self, '_temp_search_results'):
            self._temp_search_results = []
        if not hasattr(self, '_temp_tracks'):
            self._temp_tracks = []
        if not hasattr(self, '_temp_albums'):
            self._temp_albums = []
        
        # Store tracks and albums separately and combined
        self._temp_tracks = tracks.copy()  # Replace with full updated list
        self._temp_albums = albums.copy()  # Replace with full updated list
        self._temp_search_results = combined_results.copy()
        
        # Update filtered results cache to match current filter and apply sorting
        if hasattr(self, 'current_filter'):
            if self.current_filter == "all":
                filtered_results = combined_results.copy()
            elif self.current_filter == "albums":
                filtered_results = albums.copy()
            elif self.current_filter == "singles":
                filtered_results = tracks.copy()
            else:
                filtered_results = combined_results.copy()
        else:
            filtered_results = combined_results.copy()
        
        # Apply sorting to filtered results
        self.current_filtered_results = self.sort_results(filtered_results)
        
        # Clear existing results and display the updated complete set
        # This ensures proper sorting and no duplicates
        self.clear_search_results()
        self.displayed_results = 0
        
        # Only display up to the current page limit 
        remaining_slots = self.results_per_page
        results_to_show = combined_results[:remaining_slots]
        
        # Temporarily disable layout updates for smoother batch loading
        self.search_results_widget.setUpdatesEnabled(False)
        
        for result in results_to_show:
            if isinstance(result, AlbumResult):
                # Create expandable album result item
                result_item = AlbumResultItem(result)
                result_item.album_download_requested.connect(self.start_album_download)
                result_item.matched_album_download_requested.connect(self.start_matched_album_download)
                result_item.track_download_requested.connect(self.start_download)  # Individual track downloads
                result_item.track_stream_requested.connect(lambda search_result, track_item: self.start_stream(search_result, track_item))  # Individual track streaming
            else:
                # Create individual track result item
                result_item = SearchResultItem(result)
                result_item.download_requested.connect(self.start_download)
                result_item.stream_requested.connect(lambda search_result, item=result_item: self.start_stream(search_result, item))
                result_item.expansion_requested.connect(self.handle_expansion_request)
            
            # Insert before the stretch
            insert_position = self.search_results_layout.count() - 1
            self.search_results_layout.insertWidget(insert_position, result_item)
        
        # Re-enable updates and force layout refresh
        self.search_results_widget.setUpdatesEnabled(True)
        self.search_results_widget.updateGeometry()
        self.search_results_layout.update()
        self.search_results_scroll.updateGeometry()
        
        self.displayed_results = len(results_to_show)
        
        # Show filter controls during live search when we have meaningful results
        total_results = len(tracks) + len(albums)
        should_show_filters = (
            # Show if we have both albums and tracks (diverse results)
            (len(albums) > 0 and len(tracks) > 0) or
            # Or if we have enough results to make filtering useful
            total_results >= 5
        )
        
        if should_show_filters and not self.filter_container.isVisible():
            self.filter_container.setVisible(True)
        
        # Update status message with real-time feedback
        if self.displayed_results < self.results_per_page:
            self.update_search_status(f"✨ Found {total_results} results ({len(tracks)} tracks, {len(albums)} albums) from {response_count} users • Live updating...", "#1db954")
        else:
            self.update_search_status(f"✨ Found {total_results} results ({len(tracks)} tracks, {len(albums)} albums) from {response_count} users • Showing first {self.results_per_page} (scroll for more)", "#1db954")
    
    def on_search_completed(self, results):
        self.search_btn.setText("🔍 Search")
        self.search_btn.setEnabled(True)
        self.search_btn.setVisible(True)
        self.cancel_search_btn.setVisible(False)
        
        # Stop loading animations
        self.stop_search_animations()
        
        # Use the temp results that have been accumulating during live updates
        if hasattr(self, '_temp_tracks') and hasattr(self, '_temp_albums'):
            tracks = self._temp_tracks
            albums = self._temp_albums
            combined_results = self._temp_search_results
        elif isinstance(results, tuple) and len(results) == 2:
            # Fallback to final results if temp not available
            tracks, albums = results
            combined_results = albums + tracks
        else:
            # Fallback for old list format or empty results
            tracks = results or []
            albums = []
            combined_results = results or []
        
        # Store final results
        self.search_results = combined_results
        self.current_filtered_results = self.sort_results(combined_results)  # Initialize with sorted results
        self.track_results = tracks
        self.album_results = albums
        
        total_results = len(combined_results)
        
        if total_results == 0:
            if self.displayed_results == 0:
                self.update_search_status("😔 No results found • Try a different search term or artist name", "#ffa500")
            else:
                self.update_search_status(f"✨ Search completed • Found {self.displayed_results} total results", "#1db954")
            # Hide filter controls when no results
            self.filter_container.setVisible(False)
            return
        
        # Update status with album/track breakdown
        album_count = len(albums)
        track_count = len(tracks)
        
        status_parts = []
        if album_count > 0:
            status_parts.append(f"{album_count} album{'s' if album_count != 1 else ''}")
        if track_count > 0:
            status_parts.append(f"{track_count} track{'s' if track_count != 1 else ''}")
        
        result_summary = " • ".join(status_parts) if status_parts else f"{total_results} results"
        
        # Show filter controls when we have results
        self.filter_container.setVisible(True)
        
        # Emit activity signal for search completion
        search_query = self.search_input.text().strip()
        self.download_activity.emit("✅", "Search Complete", f"Found {total_results} results for '{search_query}'", "Now")
        
        # Update status based on whether there are more results to load
        if self.displayed_results < total_results:
            remaining = total_results - self.displayed_results
            self.update_search_status(f"✅ Search completed • Found {result_summary} • Showing first {self.displayed_results} (scroll down for {remaining} more)", "#1db954")
        else:
            self.update_search_status(f"✅ Search completed • Found {result_summary}", "#1db954")
    
    def clear_search_results(self):
        """Clear all search result items from the layout"""
        # Remove all SearchResultItem and AlbumResultItem widgets (but keep stretch)
        items_to_remove = []
        for i in range(self.search_results_layout.count()):
            item = self.search_results_layout.itemAt(i)
            if item and item.widget():
                widget = item.widget()
                if isinstance(widget, (SearchResultItem, AlbumResultItem)):
                    items_to_remove.append(widget)
        
        for widget in items_to_remove:
            self.search_results_layout.removeWidget(widget)
            widget.deleteLater()
    
    def on_scroll_changed(self, value):
        """Handle scroll changes to implement lazy loading"""
        if self.is_loading_more or not self.current_filtered_results:
            return
        
        scroll_bar = self.search_results_scroll.verticalScrollBar()
        
        # Check if we're near the bottom (90% scrolled)
        if scroll_bar.maximum() > 0:
            scroll_percentage = value / scroll_bar.maximum()
            
            if scroll_percentage >= 0.9 and self.displayed_results < len(self.current_filtered_results):
                self.load_more_results()
    
    # In downloads.py, find and REPLACE the existing load_more_results method with this:

    def load_more_results(self):
        """
        Prepares a batch of results and initiates the staggered loading process.
        """
        if self.is_loading_more or not self.current_filtered_results:
            return

        self.is_loading_more = True
        
        # Calculate how many more results to show
        start_index = self.displayed_results
        end_index = min(start_index + self.results_per_page, len(self.current_filtered_results))
        
        # Get the batch of results to load and add them to our queue
        results_to_add = self.current_filtered_results[start_index:end_index]
        self._results_to_load_queue.extend(results_to_add)

        # Update status to show that we are loading more
        self.update_search_status(f"✨ Loading more results...", "#1db954")

        # Kick off the staggered loading process by loading the first item
        if self._results_to_load_queue:
            QTimer.singleShot(0, self._load_next_result_item)
        else:
            self.is_loading_more = False


    def handle_expansion_request(self, requesting_item):
        """Handle accordion-style expansion where only one item can be expanded at a time"""
        # If there's a currently expanded item and it's not the requesting item, collapse it
        if self.currently_expanded_item and self.currently_expanded_item != requesting_item:
            try:
                self.currently_expanded_item.set_expanded(False, animate=True)
            except RuntimeError:
                # Widget has been deleted, just clear the reference
                self.currently_expanded_item = None
        
        # Toggle the requesting item
        new_expanded_state = not requesting_item.is_expanded
        requesting_item.set_expanded(new_expanded_state, animate=True)
        
        # Update tracking
        if new_expanded_state:
            self.currently_expanded_item = requesting_item
        else:
            self.currently_expanded_item = None
    
    def on_search_failed(self, error_msg):
        self.search_btn.setText("🔍 Search")
        self.search_btn.setEnabled(True)
        self.search_btn.setVisible(True)
        self.cancel_search_btn.setVisible(False)
        
        # Stop loading animations
        self.stop_search_animations()
        
        self.update_search_status(f"❌ Search failed: {error_msg}", "#e22134")
    
    def on_search_progress(self, message):
        self.update_search_status(f"🔍 {message}", "#1db954")
    
    def start_download(self, search_result):
        """Start downloading a search result using threaded approach"""
        try:
            # Extract track info for queue display
            full_filename = search_result.filename
            
            # Extract just the filename part (without directory path)
            import os
            filename = os.path.basename(full_filename)
            
            # Use TrackResult's parsed metadata if available, otherwise parse filename
            if hasattr(search_result, 'title') and search_result.title:
                title = search_result.title
                print(f"[DEBUG] Using TrackResult title: '{title}'")
            else:
                # Fallback: Parse title from filename 
                name_without_ext = filename
                if '.' in name_without_ext:
                    name_without_ext = '.'.join(name_without_ext.split('.')[:-1])
                
                # Check for track number prefix and remove it
                import re
                track_number_match = re.match(r'^(\d+)\.\s*(.+)', name_without_ext)
                if track_number_match:
                    name_without_track_num = track_number_match.group(2)
                else:
                    name_without_track_num = name_without_ext
                
                # Extract just the title (remove artist if present)
                parts = name_without_track_num.split(' - ')
                if len(parts) >= 2:
                    title = ' - '.join(parts[1:]).strip()  # Everything after first " - "
                else:
                    title = name_without_track_num.strip()
                
                print(f"[DEBUG] Parsed title from filename: '{title}'")
            
            # Use TrackResult's artist if available, otherwise parse or use username
            if hasattr(search_result, 'artist') and search_result.artist:
                artist = search_result.artist
                print(f"[DEBUG] Using TrackResult artist: '{artist}'")
            else:
                # Fallback: Parse artist from filename or use uploader
                name_without_ext = filename
                if '.' in name_without_ext:
                    name_without_ext = '.'.join(name_without_ext.split('.')[:-1])
                
                # Remove track number prefix - handle multiple formats
                import re
                name_without_track_num = name_without_ext
                
                # Try different track number patterns
                track_patterns = [
                    r'^(\d+)\.\s*(.+)',        # "06. Artist - Track"
                    r'^(\d+)\s*-\s*(.+)',      # "06 - Artist - Track" 
                    r'^(\d+)\s+(.+)'           # "06 Artist - Track"
                ]
                
                for pattern in track_patterns:
                    match = re.match(pattern, name_without_ext)
                    if match:
                        name_without_track_num = match.group(2)
                        break
                
                # Extract artist (first part before " - ")
                parts = name_without_track_num.split(' - ')
                if len(parts) >= 2:
                    # First part is artist, second part is track title
                    artist = parts[0].strip()
                    # Verify this doesn't look like a track number
                    if re.match(r'^\d+$', artist.strip()):
                        # If first part is just a number, use username as fallback
                        artist = search_result.username
                else:
                    artist = search_result.username
                
                print(f"[DEBUG] Parsed artist from filename: '{artist}'")
            
            # Final cleanup - ensure we have meaningful values
            if not title or title == '':
                title = filename  # Ultimate fallback
            if not artist or artist == '':
                artist = search_result.username  # Ultimate fallback
            
            print(f"[DEBUG] Extracted title info from '{full_filename}' -> title: '{title}', artist: '{artist}'")
            
            # Extract album context from search_result if available (for matched album downloads)
            album_name = None
            track_number = None
            
            if hasattr(search_result, 'album') and search_result.album:
                album_name = search_result.album
                print(f"[DEBUG] Found album context: '{album_name}'")
            
            if hasattr(search_result, 'track_number') and search_result.track_number:
                track_number = search_result.track_number
                print(f"[DEBUG] Found track number: {track_number}")
            
            # Generate a unique download ID for tracking and cancellation  
            import time
            import uuid
            timestamp = time.time()
            unique_suffix = str(uuid.uuid4())[:8]  # Short unique identifier
            download_id = f"{search_result.username}_{filename}_{int(timestamp)}_{unique_suffix}"
            
            # Add to download queue immediately as "downloading" with album context
            download_item = self.download_queue.add_download_item(
                title=title,
                artist=artist,
                status="downloading",
                progress=0,
                file_size=search_result.size,
                download_id=download_id,
                username=search_result.username,
                file_path=full_filename,  # Store the full path for matching
                soulseek_client=self.soulseek_client,
                album=album_name,
                track_number=track_number
            )
            
            print(f"[DEBUG] Created download item with album context: album='{album_name}', track_number={track_number}")
            
            # Emit activity signal for download start
            self.download_activity.emit("📥", "Download Started", f"'{title}' by {artist}", "Now")
            
            # Create and start download thread
            download_thread = DownloadThread(self.soulseek_client, search_result, download_item)
            download_thread.download_completed.connect(self.on_download_completed, Qt.ConnectionType.QueuedConnection)
            download_thread.download_failed.connect(self.on_download_failed, Qt.ConnectionType.QueuedConnection)
            download_thread.download_progress.connect(self.on_download_progress, Qt.ConnectionType.QueuedConnection)
            download_thread.finished.connect(
                functools.partial(self.on_download_thread_finished, download_thread), 
                Qt.ConnectionType.QueuedConnection
            )
            
            # Track the thread
            self.download_threads.append(download_thread)
            
            # Start the download
            download_thread.start()
            
            # Download started - feedback will appear in download queue
            
        except Exception as e:
            print(f"Failed to start download: {str(e)}")
    
    def start_album_download(self, album_result):
        """Start downloading all tracks in an album"""
        try:
            print(f"🎵 Starting album download: {album_result.album_title} by {album_result.artist}")
            
            # First, find and disable all track download buttons for this album
            self.disable_album_track_buttons(album_result)
            
            # Download each track in the album
            for track in album_result.tracks:
                self.start_download(track)
            
            print(f"✓ Queued {len(album_result.tracks)} tracks for download from album: {album_result.album_title}")
            
        except Exception as e:
            print(f"Failed to start album download: {str(e)}")
    
    def disable_album_track_buttons(self, album_result):
        """Disable all track download buttons for an album to prevent duplicate downloads"""
        # Find the AlbumResultItem that contains these tracks
        for album_item in self.findChildren(AlbumResultItem):
            if (album_item.album_result.album_title == album_result.album_title and 
                album_item.album_result.artist == album_result.artist):
                
                # Disable all track download buttons in this album
                for track_item in album_item.track_items:
                    track_item.set_download_queued_state()
                print(f"[DEBUG] Disabled {len(album_item.track_items)} track download buttons for album: {album_result.album_title}")
                break
    
    def start_matched_download(self, search_result):
        """Start a matched download for a single track using the new modal."""
        try:
            if not self.spotify_client.is_authenticated():
                self.start_download(search_result)
                return

            modal = SpotifyMatchingModal(search_result, self.spotify_client, self.matching_engine, self, is_album=False)
            # Use a lambda to pass the original search_result to the handler
            modal.match_confirmed.connect(
                lambda artist, album: self._handle_match_confirmed(search_result, artist, album, is_album_download=False)
            )
            
            if modal.exec() == QDialog.DialogCode.Accepted:
                print("✅ Match confirmed via modal.")
            elif hasattr(modal, 'skipped_matching') and modal.skipped_matching:
                print("🔄 Matching skipped, proceeding with normal download.")
                self.start_download(search_result)
            else:
                print("🚫 Match process cancelled by user.")
                
        except Exception as e:
            print(f"❌ Error in matched download process: {e}")
            self.start_download(search_result)

    def start_matched_album_download(self, album_result):
        """Start a matched download for a full album using the new modal."""
        try:
            if not self.spotify_client.is_authenticated():
                self.start_album_download(album_result)
                return

            # Use the first track as a reference for the modal
            first_track = album_result.tracks[0] if album_result.tracks else None
            if not first_track:
                print("❌ Cannot start matched download for an empty album.")
                self.start_album_download(album_result)
                return

            modal = SpotifyMatchingModal(first_track, self.spotify_client, self.matching_engine, self, is_album=True, album_result=album_result)
            modal.match_confirmed.connect(
                lambda artist, album: self._handle_match_confirmed(album_result, artist, album, is_album_download=True)
            )

            if modal.exec() == QDialog.DialogCode.Accepted:
                print("✅ Album match confirmed via modal.")
            elif hasattr(modal, 'skipped_matching') and modal.skipped_matching:
                print("🔄 Album matching skipped, proceeding with normal download.")
                self.start_album_download(album_result)
            else:
                print("🚫 Album match process cancelled by user.")

        except Exception as e:
            print(f"❌ Error in matched album download process: {e}")
            self.start_album_download(album_result)

    
    def _handle_matched_download(self, search_result, artist: Artist):
        """Handle the download after artist selection from modal"""
        try:
            print(f"🎯 Starting matched download for '{search_result.title}' by '{artist.name}'")
            
            # Store the selected artist metadata with the search result
            search_result.matched_artist = artist
            
            # Start the download with normal process but enhanced with Spotify metadata
            download_item = self._start_download_with_artist(search_result, artist)
            
            if download_item:
                print(f"✅ Successfully created matched download for '{download_item.title}'")
            else:
                print(f"❌ Failed to create matched download, falling back to normal download")
                self.start_download(search_result)
            
        except Exception as e:
            print(f"❌ Error handling matched download: {e}")
            # Fallback to normal download
            self.start_download(search_result)
    
    def _handle_match_confirmed(self, original_result, artist: Artist, album: Album, is_album_download=False):
        """
        Handles the final confirmed match from the modal for both single tracks and full albums.
        """
        try:
            if is_album_download:
                # This is a full album download
                print(f"🎯 Confirmed album match: '{album.name}' by '{artist.name}'")
                # Now, we process each track in the original album_result
                for track in original_result.tracks:
                    track.matched_artist = artist
                    track.matched_album = album
                    track.album = album.name # Overwrite album name for consistency
                    self._start_download_with_artist(track, artist)
            else:
                # This is a single track download
                print(f"🎯 Confirmed single track match: '{original_result.title}' -> Artist: '{artist.name}', Album: '{album.name}'")
                original_result.matched_artist = artist
                original_result.matched_album = album
                
                # For singles-only mode, don't overwrite with dummy album name
                if album.id != "singles-dummy":
                    original_result.album = album.name
                # If it's our dummy album, keep the original album name from the search result
                
                self._start_download_with_artist(original_result, artist)

        except Exception as e:
            print(f"❌ Error handling confirmed match: {e}")
            # Fallback to normal download
            if is_album_download:
                self.start_album_download(original_result)
            else:
                self.start_download(original_result)


    def _start_download_with_artist(self, search_result, artist: Artist):
        """Start download and immediately assign matched artist - no race conditions"""
        try:
            # Extract track info for queue display (same as start_download)
            full_filename = search_result.filename
            import os
            filename = os.path.basename(full_filename)
            
            # Use TrackResult's parsed metadata if available, otherwise parse filename
            if hasattr(search_result, 'title') and search_result.title:
                title = search_result.title
            else:
                # Fallback parsing logic (copied from start_download)
                name_without_ext = filename
                if '.' in name_without_ext:
                    name_without_ext = '.'.join(name_without_ext.split('.')[:-1])
                
                import re
                track_number_match = re.match(r'^(\d+)\.\s*(.+)', name_without_ext)
                if track_number_match:
                    name_without_track_num = track_number_match.group(2)
                else:
                    name_without_track_num = name_without_ext
                
                parts = name_without_track_num.split(' - ')
                if len(parts) >= 2:
                    title = ' - '.join(parts[1:]).strip()
                else:
                    title = name_without_track_num.strip()
            
            # Use TrackResult's artist if available, otherwise parse or use username
            if hasattr(search_result, 'artist') and search_result.artist:
                original_artist = search_result.artist
            else:
                # Same fallback logic as start_download
                name_without_ext = filename
                if '.' in name_without_ext:
                    name_without_ext = '.'.join(name_without_ext.split('.')[:-1])
                
                import re
                name_without_track_num = name_without_ext
                
                # Try different track number patterns
                track_patterns = [
                    r'^(\d+)\.\s*(.+)',        # "06. Artist - Track"
                    r'^(\d+)\s*-\s*(.+)',      # "06 - Artist - Track" 
                    r'^(\d+)\s+(.+)'           # "06 Artist - Track"
                ]
                
                for pattern in track_patterns:
                    match = re.match(pattern, name_without_ext)
                    if match:
                        name_without_track_num = match.group(2)
                        break
                
                parts = name_without_track_num.split(' - ')
                if len(parts) >= 2:
                    original_artist = parts[0].strip()
                    # Verify this doesn't look like a track number
                    if re.match(r'^\d+$', original_artist.strip()):
                        # If first part is just a number, use username as fallback
                        original_artist = search_result.username
                else:
                    original_artist = search_result.username
            
            # Final cleanup
            if not title or title == '':
                title = filename
            if not original_artist or original_artist == '':
                original_artist = search_result.username
            
            # Extract album context
            album_name = getattr(search_result, 'album', None)
            track_number = getattr(search_result, 'track_number', None)
            
            # If no track number found, try to extract from filename
            if not track_number:
                track_number = self._extract_track_number_from_filename(filename, title)
                if track_number:
                    print(f"✅ Extracted track number from filename: {track_number}")
                else:
                    print(f"❌ Could not extract track number from filename: '{filename}'")
            
            # Generate download ID
            import time
            import uuid
            timestamp = time.time()
            unique_suffix = str(uuid.uuid4())[:8]  # Short unique identifier
            download_id = f"{search_result.username}_{filename}_{int(timestamp)}_{unique_suffix}"
            
            # Create download item with matched artist immediately
            download_item = self.download_queue.add_download_item(
                title=title,
                artist=original_artist,
                status="downloading",
                progress=0,
                file_size=search_result.size,
                download_id=download_id,
                username=search_result.username,
                file_path=full_filename,
                soulseek_client=self.soulseek_client,
                album=album_name,
                track_number=track_number
            )
            
            # Immediately assign the matched artist - no timing delays
            if download_item:
                download_item.matched_artist = artist
                print(f"✅ Matched artist '{artist.name}' assigned to download item '{download_item.title}'")
            
            # Emit activity signal for download start (with matched artist)
            self.download_activity.emit("📥", "Download Started", f"'{title}' by {artist.name if artist else original_artist}", "Now")
            
            # Start the download thread
            download_thread = DownloadThread(self.soulseek_client, search_result, download_item)
            download_thread.download_completed.connect(self.on_download_completed, Qt.ConnectionType.QueuedConnection)
            download_thread.download_failed.connect(self.on_download_failed, Qt.ConnectionType.QueuedConnection)
            download_thread.download_progress.connect(self.on_download_progress, Qt.ConnectionType.QueuedConnection)
            download_thread.finished.connect(
                functools.partial(self.on_download_thread_finished, download_thread), 
                Qt.ConnectionType.QueuedConnection
            )
            
            self.download_threads.append(download_thread)
            download_thread.start()
            
            return download_item
            
        except Exception as e:
            print(f"❌ Failed to start download with artist: {str(e)}")
            return None
    
    def _ensure_album_consistency(self, download_items, artist: Artist, album_name: str):
        """Ensure all download items have consistent album naming for proper grouping"""
        try:
            with self.album_cache_lock:
                # Create cache key for this album
                album_key = f"{artist.name}::{album_name}"
                
                # Store the definitive album name
                self.album_name_cache[album_key] = album_name
                
                print(f"🔒 Cached album name: '{album_name}' for key: '{album_key}'")
                
                # Ensure all download items use the same album name
                for download_item in download_items:
                    if hasattr(download_item, 'album'):
                        download_item.album = album_name
                        print(f"   ✅ Set album name for '{download_item.title}': '{album_name}'")
                
        except Exception as e:
            print(f"❌ Error ensuring album consistency: {e}")
    
    def _assign_matched_artist_to_download_item(self, search_result, artist: Artist):
        """Assign matched artist to the corresponding download item"""
        try:
            print(f"🔍 Looking for download item matching: '{search_result.title}' by '{search_result.artist}'")
            print(f"📋 Current download items: {len(self.download_queue.download_items)}")
            
            matched = False
            # Find the download item for this search result
            for i, download_item in enumerate(self.download_queue.download_items):
                print(f"    Item {i}: '{getattr(download_item, 'title', 'NO_TITLE')}' by '{getattr(download_item, 'artist', 'NO_ARTIST')}'")
                
                if (hasattr(download_item, 'title') and download_item.title == search_result.title and
                    hasattr(download_item, 'artist') and download_item.artist == search_result.artist):
                    download_item.matched_artist = artist
                    print(f"✅ Assigned matched artist '{artist.name}' to download item '{download_item.title}'")
                    matched = True
                    break
            
            if not matched:
                print(f"❌ Could not find matching download item for '{search_result.title}' by '{search_result.artist}'")
                # Try a more lenient search
                for i, download_item in enumerate(self.download_queue.download_items):
                    if (hasattr(download_item, 'title') and 
                        self.matching_engine.normalize_string(download_item.title) == self.matching_engine.normalize_string(search_result.title)):
                        download_item.matched_artist = artist
                        print(f"✅ Assigned matched artist '{artist.name}' to download item '{download_item.title}' (lenient match)")
                        matched = True
                        break
                
                if not matched:
                    print(f"❌ Still could not find matching download item - assignment failed")
                        
        except Exception as e:
            print(f"❌ Error assigning matched artist to download item: {e}")
    
    def _handle_matched_album_download(self, album_result, artist: Artist):
        """Handle the album download after artist selection from modal"""
        # OPTIMIZATION v2: Use optimized version if enabled
        if hasattr(self, '_use_optimized_systems') and self._use_optimized_systems:
            return self._handle_matched_album_download_v2(album_result, artist)
            
        try:
            print(f"🎯 Starting matched album download for '{album_result.album_title}' by '{artist.name}'")
            print(f"📀 Processing {len(album_result.tracks)} tracks with matched artist")
            
            # Store the selected artist metadata and album context with each track
            print(f"🔍 Album context being set:")
            print(f"    Album result title: '{album_result.album_title}'")
            print(f"    Matched artist: '{artist.name}'")
            
            # Clean up the album title - remove "Album - Artist -" prefix if present
            clean_album_title = self._clean_album_title(album_result.album_title, artist.name)
            print(f"    Cleaned album title: '{clean_album_title}'")
            
            for track_index, track in enumerate(album_result.tracks, 1):
                track.matched_artist = artist
                
                # Preserve album context - this is CRITICAL for proper album detection
                track.album = clean_album_title  # Use cleaned album title
                
                # Extract original track number from filename instead of using sequential index
                if hasattr(track, 'filename'):
                    import os
                    filename = os.path.basename(track.filename)
                    original_track_num = self._extract_track_number_from_filename(filename, track.title)
                    if original_track_num:
                        track.track_number = original_track_num
                        print(f"   🎵 Preserved original track number: {original_track_num}")
                    else:
                        # Only use sequential as fallback if no original number found
                        track.track_number = track_index
                        print(f"   ⚠️ Using fallback sequential track number: {track_index}")
                else:
                    # Fallback to sequential numbering if no filename available
                    track.track_number = track_index
                    print(f"   ⚠️ Using fallback sequential track number (no filename): {track_index}")
                
                # Clean up track title - remove artist prefix if present
                clean_track_title = self._clean_track_title(track.title, artist.name)
                track.title = clean_track_title
                
                print(f"   🎵 Track {track_index}: '{clean_track_title}' -> Artist: '{artist.name}', Album: '{clean_album_title}', Track#: {track.track_number}")
            
            # Start downloading all tracks with matched artist immediately
            import time
            download_items = []
            for track_index, track in enumerate(album_result.tracks, 1):
                print(f"🎬 Starting download {track_index}/{len(album_result.tracks)}: {track.title}")
                download_item = self._start_download_with_artist(track, artist)
                if download_item:
                    download_items.append(download_item)
                    # Small delay between downloads to avoid overwhelming Soulseek
                    time.sleep(0.1)
            
            print(f"✅ Successfully queued {len(download_items)}/{len(album_result.tracks)} tracks with matched artist")
            
            # Pre-calculate and cache the album name to ensure consistency
            if download_items:
                self._ensure_album_consistency(download_items, artist, clean_album_title)
            
            print(f"✓ Queued {len(album_result.tracks)} tracks for matched download from album: {album_result.album_title}")
            print(f"🎯 All tracks have album context preserved: '{album_result.album_title}'")
            
        except Exception as e:
            print(f"❌ Error handling matched album download: {e}")
            # Fallback to normal album download
            self.start_album_download(album_result)

    def _handle_matched_album_download_v2(self, album_result, artist: Artist):
        """OPTIMIZATION v2: Handle album download with non-blocking batch processing"""
        try:
            
            # Set bulk operation flag for adaptive polling
            self._bulk_operation_active = True
            
            # Clean up the album title
            clean_album_title = self._clean_album_title(album_result.album_title, artist.name)
            
            # Prepare all tracks with metadata (no blocking operations)
            prepared_tracks = []
            for track_index, track in enumerate(album_result.tracks, 1):
                track.matched_artist = artist
                track.album = clean_album_title
                
                # Extract track number without blocking
                if hasattr(track, 'filename'):
                    import os
                    filename = os.path.basename(track.filename)
                    original_track_num = self._extract_track_number_from_filename(filename, track.title)
                    if original_track_num:
                        track.track_number = original_track_num
                    else:
                        track.track_number = track_index
                else:
                    track.track_number = track_index
                
                prepared_tracks.append(track)
            
            # Use background thread pool for batch download initiation
            def batch_download_tracks():
                download_items = []
                for track_index, track in enumerate(prepared_tracks, 1):
                    try:
                        download_item = self._start_download_with_artist(track, artist)
                        if download_item:
                            download_items.append(download_item)
                            # No sleep - let the system handle queuing naturally
                    except Exception as e:
                        print(f"❌ Failed to start download for track {track.title}: {e}")
                
                # Ensure album consistency in background
                if download_items:
                    self._ensure_album_consistency(download_items, artist, clean_album_title)
                
                # Reset bulk operation flag
                self._bulk_operation_active = False
                
                print(f"✅ Queued {len(download_items)}/{len(prepared_tracks)} tracks")
                return download_items
            
            # Submit to optimized thread pool
            self._optimized_api_pool.submit(batch_download_tracks)
            
        except Exception as e:
            print(f"❌ Optimized album download failed: {e}")
            self._bulk_operation_active = False
            # Fallback to original method
            self._handle_matched_album_download(album_result, artist)
    
    def _handle_matched_album_download_with_album(self, album_result, artist: Artist, selected_album: Album):
        """Handle the album download after both artist and album selection from modal"""
        try:
            print(f"🎯 Starting matched album download with FORCED album selection")
            print(f"    Original album: '{album_result.album_title}'")
            print(f"    Selected artist: '{artist.name}'")
            print(f"    Selected album: '{selected_album.name}'")
            print(f"    🔒 ALL tracks will be forced into: '{selected_album.name}'")
            
            # Fetch official track titles from Spotify album
            print(f"🎵 Fetching official track titles from Spotify album...")
            spotify_tracks = self._get_spotify_album_tracks(selected_album)
            
            download_items = []
            
            # Process all tracks and FORCE them into the selected album
            for track_index, track in enumerate(album_result.tracks, 1):
                track.matched_artist = artist
                track.album = selected_album.name  # FORCE album name
                track.matched_album = selected_album  # Store the full album object
                track._force_album_name = selected_album.name  # Flag to prevent album detection override
                track._force_album_mode = True  # Flag to skip individual Spotify lookups
                
                # Extract original track number from filename
                if hasattr(track, 'filename'):
                    import os
                    filename = os.path.basename(track.filename)
                    original_track_num = self._extract_track_number_from_filename(filename, track.title)
                    if original_track_num:
                        track.track_number = original_track_num
                    else:
                        track.track_number = track_index
                
                # Match to Spotify track title if available
                spotify_title = self._match_track_to_spotify_title(track, spotify_tracks)
                if spotify_title:
                    print(f"   🎵 Track {track_index}: '{track.title}' -> Spotify title: '{spotify_title}'")
                    track._spotify_title = spotify_title  # Store the official Spotify title
                    track._spotify_clean_title = spotify_title  # This will be used for file naming
                else:
                    print(f"   🎵 Track {track_index}: '{track.title}' -> No Spotify match found, using original")
                
                print(f"   🔒 FORCED into Album: {selected_album.name}")
                
                # Start individual track download with enhanced metadata
                download_item = self._start_download_with_artist(track, artist)
                if download_item:
                    # Also apply the forced album to the download item
                    download_item._force_album_name = selected_album.name
                    download_item._force_album_mode = True
                    
                    # Apply Spotify title to download item if available
                    if hasattr(track, '_spotify_clean_title'):
                        download_item._spotify_clean_title = track._spotify_clean_title
                        print(f"✅ Applied Spotify title to download item: '{track._spotify_clean_title}'")
                    
                    download_items.append(download_item)
                    print(f"✓ Successfully queued track: {track.title}")
                else:
                    print(f"❌ Failed to queue track: {track.title}")
            
            # Ensure all download items have consistent album information
            for download_item in download_items:
                if hasattr(download_item, 'matched_artist'):
                    download_item._force_album_name = selected_album.name
                    download_item._force_album_mode = True
            
            print(f"✓ Queued {len(album_result.tracks)} tracks for matched download - ALL FORCED into album: {selected_album.name}")
            
        except Exception as e:
            print(f"❌ Error handling matched album download with album selection: {e}")
            # Fallback to normal album download
            self.start_album_download(album_result)
    
    def _assign_matched_artist_to_album_downloads(self, album_result, artist: Artist):
        """Assign matched artist to all download items for an album"""
        try:
            print(f"📋 Assigning matched artist '{artist.name}' to all album download items")
            print(f"📀 Album has {len(album_result.tracks)} tracks")
            print(f"📋 Current download queue has {len(self.download_queue.download_items)} items")
            
            assigned_count = 0
            
            # Find download items for all tracks in this album
            for track_idx, track in enumerate(album_result.tracks):
                print(f"🔍 Looking for track {track_idx + 1}: '{track.title}' by '{track.artist}'")
                
                matched = False
                for download_item in self.download_queue.download_items:
                    if (hasattr(download_item, 'title') and download_item.title == track.title and
                        hasattr(download_item, 'artist') and download_item.artist == track.artist):
                        download_item.matched_artist = artist
                        assigned_count += 1
                        print(f"   ✅ Assigned to: {download_item.title}")
                        matched = True
                        break
                
                if not matched:
                    print(f"   ❌ Could not find download item for: {track.title}")
                    # Try a more lenient search
                    for download_item in self.download_queue.download_items:
                        if (hasattr(download_item, 'title') and 
                            self.matching_engine.normalize_string(download_item.title) == self.matching_engine.normalize_string(track.title)):
                            download_item.matched_artist = artist
                            assigned_count += 1
                            print(f"   ✅ Assigned to: {download_item.title} (lenient match)")
                            matched = True
                            break
                    
                    if not matched:
                        print(f"   ❌ Still could not find download item for: {track.title}")
            
            print(f"✅ Successfully assigned matched artist to {assigned_count}/{len(album_result.tracks)} album tracks")
            
            # If we didn't assign to all tracks, let's try again with a longer delay
            if assigned_count < len(album_result.tracks):
                print(f"⏰ Some assignments failed, will retry in 1 second...")
                QTimer.singleShot(1000, lambda: self._retry_album_assignment(album_result, artist, assigned_count))
            
        except Exception as e:
            print(f"❌ Error assigning matched artist to album download items: {e}")
    
    def _retry_album_assignment(self, album_result, artist: Artist, previous_count: int):
        """Retry assignment for album tracks that failed the first time"""
        try:
            print(f"🔄 Retrying album assignment for remaining tracks...")
            new_assigned = 0
            
            for track in album_result.tracks:
                # Only try to assign if not already assigned
                found_assigned = False
                for download_item in self.download_queue.download_items:
                    if (hasattr(download_item, 'title') and download_item.title == track.title and
                        hasattr(download_item, 'matched_artist') and download_item.matched_artist):
                        found_assigned = True
                        break
                
                if not found_assigned:
                    # Try to find and assign
                    for download_item in self.download_queue.download_items:
                        if (hasattr(download_item, 'title') and 
                            self.matching_engine.normalize_string(download_item.title) == self.matching_engine.normalize_string(track.title)):
                            download_item.matched_artist = artist
                            new_assigned += 1
                            print(f"   ✅ Retry assigned to: {download_item.title}")
                            break
            
            total_assigned = previous_count + new_assigned
            print(f"🔄 Retry complete: {total_assigned}/{len(album_result.tracks)} tracks now assigned")
            
        except Exception as e:
            print(f"❌ Error in retry assignment: {e}")
    
    def _handle_modal_cancelled(self, search_result):
        """Handle when modal is cancelled for single track downloads"""
        print(f"🚫 Modal cancelled for track: {search_result.title}")
        # Re-enable any disabled download buttons for this track
        # Since track downloads don't disable buttons, this is mainly for consistency
    
    def _handle_album_modal_cancelled(self, album_result):
        """Handle when modal is cancelled for album downloads - re-enable buttons"""
        print(f"🚫 Album modal cancelled for: {album_result.album_title}")
        
        # Re-enable all track download buttons for this album
        self._enable_album_track_buttons(album_result)
    
    def _enable_album_track_buttons(self, album_result):
        """Re-enable all track download buttons for an album"""
        try:
            # Find the AlbumResultItem and re-enable its buttons
            for i in range(self.search_results_layout.count()):
                item = self.search_results_layout.itemAt(i)
                if item and item.widget():
                    widget = item.widget()
                    if hasattr(widget, 'album_result') and widget.album_result == album_result:
                        # Re-enable the matched download button
                        if hasattr(widget, 'matched_download_btn'):
                            widget.matched_download_btn.setText("🎯 Download w/ Matching")
                            widget.matched_download_btn.setEnabled(True)
                        
                        # Re-enable the regular download button
                        if hasattr(widget, 'download_btn'):
                            widget.download_btn.setText("⬇️ Download Album")
                            widget.download_btn.setEnabled(True)
                        
                        print(f"✅ Re-enabled buttons for album: {album_result.album_title}")
                        break
        except Exception as e:
            print(f"❌ Error re-enabling album buttons: {e}")
    

    def _cleanup_empty_directories(self, download_path, moved_file_path):
        """
        Clean up empty directories left after moving a file, ignoring hidden files.
        Walks up the directory tree until it finds a non-empty folder or the root download path.
        """
        import os

        try:
            # Start with the directory that contained the moved file
            # For you, this will be 'downloads/SomeAlbumFolder'
            current_dir = os.path.dirname(moved_file_path)

            # This loop will continue as long as the directory is inside the main download path
            while current_dir != download_path and current_dir.startswith(download_path):
                # Check if the directory is empty, IGNORING hidden files like .DS_Store
                is_empty = True
                for entry in os.listdir(current_dir):
                    if not entry.startswith('.'):  # This is the key fix
                        is_empty = False
                        break
                
                if is_empty:
                    print(f"Removing empty directory (ignoring hidden files): {current_dir}")
                    try:
                        os.rmdir(current_dir)
                        # After deleting, move up to the parent to check it too
                        current_dir = os.path.dirname(current_dir)
                    except OSError as e:
                        print(f"Warning: Could not remove directory {current_dir}: {e}")
                        break # Stop if we can't remove a directory
                else:
                    # If the directory is not empty, the job is done.
                    print(f"Stopping cleanup at non-empty directory: {current_dir}")
                    break

        except Exception as e:
            print(f"Warning: An error occurred during directory cleanup: {e}")


    def _organize_matched_download(self, download_item, original_file_path: str) -> Optional[str]:
        """Organize a matched download into the Transfer folder structure"""
        try:
            import os
            import shutil
            from pathlib import Path
            
            if not hasattr(download_item, 'matched_artist'):
                print("❌ No matched artist information found")
                return None
            
            artist = download_item.matched_artist
            print(f"🎯 Organizing download for artist: {artist.name}")
            
            # --- FIX: Get transfer directory from config instead of hardcoding ---
            # OLD CODE:
            # project_root = os.path.dirname(os.path.dirname(os.path.dirname(__file__)))
            # transfer_dir = os.path.join(project_root, 'Transfer')
            
            # NEW CODE:
            transfer_dir = config_manager.get('soulseek.transfer_path', './Transfer')
            os.makedirs(transfer_dir, exist_ok=True)
            
            # Create artist directory
            artist_dir = os.path.join(transfer_dir, self._sanitize_filename(artist.name))
            os.makedirs(artist_dir, exist_ok=True)
            
            # Determine if this is a single or album track
            album_info = self._detect_album_info(download_item, artist)
            
            # Resolve consistent album name for grouping tracks from same album
            if album_info and album_info['is_album']:
                print(f"\n🎯 SMART ALBUM GROUPING for track: '{download_item.title}'")
                print(f"   Original album: '{getattr(download_item, 'album', 'None')}'")
                print(f"   Detected album: '{album_info.get('album_name', 'None')}'")
                
                consistent_album_name = self._resolve_album_group(download_item, artist, album_info)
                album_info['album_name'] = consistent_album_name
                
                print(f"   Final album name: '{consistent_album_name}'")
                print(f"🔗 ✅ Album grouping complete!\n")
            
            if album_info and album_info['is_album']:
                # Album track structure: Transfer/ARTIST/ARTIST - ALBUM/TRACK# TRACK.ext
                print(f"🔍 Creating album folder:")
                print(f"    Artist name: '{artist.name}'")
                print(f"    Album name from album_info: '{album_info['album_name']}'")
                print(f"    Original download item title: '{download_item.title}'")
                
                # Use the Spotify title information if available (most accurate for matched tracks)
                clean_track_name = download_item.title
                if hasattr(download_item, '_spotify_clean_title') and download_item._spotify_clean_title:
                    clean_track_name = download_item._spotify_clean_title
                elif album_info.get('clean_track_name'):
                    clean_track_name = album_info['clean_track_name']
                    
                print(f"    Clean track name to use: '{clean_track_name}'")
                
                album_folder_name = f"{self._sanitize_filename(artist.name)} - {self._sanitize_filename(album_info['album_name'])}"
                album_dir = os.path.join(artist_dir, album_folder_name)
                os.makedirs(album_dir, exist_ok=True)
                
                # Create track filename with number (just track number + clean title, NO artist)
                file_ext = os.path.splitext(original_file_path)[1]
                track_number = album_info.get('track_number', 1)
                track_filename = f"{track_number:02d} - {self._sanitize_filename(clean_track_name)}{file_ext}"
                new_file_path = os.path.join(album_dir, track_filename)
                
                print(f"📁 Album folder created: '{album_folder_name}'")
                print(f"🎵 Track filename: '{track_filename}'")
                
            else:
                # Single track structure: Transfer/ARTIST/ARTIST - SINGLE/SINGLE.ext
                # Use the Spotify title information if available (most accurate for matched tracks)
                clean_track_name = download_item.title
                if hasattr(download_item, '_spotify_clean_title') and download_item._spotify_clean_title:
                    clean_track_name = download_item._spotify_clean_title
                elif album_info and album_info.get('clean_track_name'):
                    clean_track_name = album_info['clean_track_name']
                    
                print(f"    Original download item title: '{download_item.title}'")
                print(f"    Clean track name to use: '{clean_track_name}'")
                
                single_folder_name = f"{self._sanitize_filename(artist.name)} - {self._sanitize_filename(clean_track_name)}"
                single_dir = os.path.join(artist_dir, single_folder_name)
                os.makedirs(single_dir, exist_ok=True)
                
                # Create single filename with clean track name
                file_ext = os.path.splitext(original_file_path)[1]
                single_filename = f"{self._sanitize_filename(clean_track_name)}{file_ext}"
                new_file_path = os.path.join(single_dir, single_filename)
                
                print(f"📁 Single track: {single_folder_name}/{single_filename}")
            
            # Check if source file exists, and try to find it if not
            if not os.path.exists(original_file_path):
                print(f"❌ Source file not found: {original_file_path}")
                
                # Try to find the file using different methods
                found_file = self._find_downloaded_file(original_file_path, download_item)
                if found_file:
                    print(f"✅ Found file at: {found_file}")
                    original_file_path = found_file
                else:
                    print(f"❌ Could not locate downloaded file anywhere")
                    return None
            
            # File organization and overwrite logic will be handled after metadata enhancement
            
            # 🆕 METADATA ENHANCEMENT - Enhance BEFORE moving to avoid race conditions
            if self._enhance_file_metadata(original_file_path, download_item, artist, album_info):
                print(f"✅ Metadata enhanced with Spotify data")
            else:
                print(f"⚠️ Metadata enhancement failed, using original tags")
            
            # Verify source file exists before attempting move
            if not os.path.exists(original_file_path):
                print(f"❌ Source file not found: {original_file_path}")
                return None
                
            # Explicit overwrite: check if file exists, remove it, then move
            if os.path.isfile(new_file_path):
                os.remove(new_file_path)
            
            # Move the enhanced file to destination
            shutil.move(original_file_path, new_file_path)
            
            # Verify the move was successful
            if not os.path.exists(new_file_path):
                print(f"❌ File move failed - destination file not found: {new_file_path}")
                return None
                
            if os.path.exists(original_file_path):
                try:
                    os.remove(original_file_path)
                except Exception as cleanup_error:
                    print(f"⚠️ Could not remove original file: {cleanup_error}")
            
            # Clean up any empty directories left in the downloads folder
            try:
                downloads_path = config_manager.get('soulseek.download_path', './Downloads')
                self._cleanup_empty_directories(downloads_path, original_file_path)
            except Exception as cleanup_error:
                print(f"⚠️ Could not clean up empty directories: {cleanup_error}")
            
            # Download cover art for both albums and singles
            if album_info and album_info['is_album']:
                # Album track - download to album directory
                self._download_cover_art(artist, album_info, os.path.dirname(new_file_path))
            else:
                # Single track - create minimal album_info for cover art download
                single_album_info = self._create_single_track_album_info(download_item, artist)
                if single_album_info:
                    self._download_cover_art(artist, single_album_info, os.path.dirname(new_file_path))

            # Generate LRC lyrics file at final location (elegant addition)
            self._generate_lrc_file(new_file_path, download_item, artist, album_info)

            print(f"✅ Successfully organized matched download: {new_file_path}")
            return new_file_path
            
        except Exception as e:
            print(f"❌ Error organizing matched download: {e}")
            return None
    



    def _sanitize_filename(self, filename: str) -> str:
        """Sanitize filename for file system compatibility"""
        import re
        # Replace invalid characters with underscores
        sanitized = re.sub(r'[<>:"/\\|?*]', '_', filename)
        # Remove multiple spaces and trim
        sanitized = re.sub(r'\s+', ' ', sanitized).strip()
        # Windows forbids trailing dots/spaces on files and folders
        sanitized = sanitized.rstrip('. ') or '_'
        # Windows reserved device names
        if re.match(r'^(CON|PRN|AUX|NUL|COM[1-9]|LPT[1-9])(\.|$)', sanitized, re.IGNORECASE):
            sanitized = '_' + sanitized
        # Limit length to avoid filesystem issues
        return sanitized[:200] if len(sanitized) > 200 else sanitized
    
    def _clean_album_title(self, album_title: str, artist_name: str) -> str:
        """Clean up album title by removing common prefixes, suffixes, and artist redundancy"""
        import re
        
        # Start with the original title
        original = album_title.strip()
        cleaned = original
        print(f"🧹 Album Title Cleaning: '{original}' (artist: '{artist_name}')")
        
        # Remove "Album - " prefix
        cleaned = re.sub(r'^Album\s*-\s*', '', cleaned, flags=re.IGNORECASE)
        
        # Remove artist name prefix if it appears at the beginning
        # This handles cases like "Kendrick Lamar - good kid, m.A.A.d city"
        artist_pattern = re.escape(artist_name) + r'\s*-\s*'
        cleaned = re.sub(f'^{artist_pattern}', '', cleaned, flags=re.IGNORECASE)
        
        # Remove common Soulseek suffixes in square brackets and parentheses
        # Examples: [Deluxe Edition] [2012] [320 Kbps] [Album+iTunes+Bonus Tracks] [F10]
        #           (Deluxe Edition) (2012) (320 Kbps) etc.
        # Remove year patterns like [2012], (2020), etc.
        cleaned = re.sub(r'\s*[\[\(]\d{4}[\]\)]\s*', ' ', cleaned)
        
        # Remove quality/format indicators
        quality_patterns = [
            r'\s*[\[\(][0-9]+\s*kbps[\]\)]\s*',
            r'\s*[\[\(][0-9]+k[\]\)]\s*', 
            r'\s*[\[\(]320[\]\)]\s*',
            r'\s*[\[\(]flac[\]\)]\s*',
            r'\s*[\[\(]mp3[\]\)]\s*',
            r'\s*[\[\(]wav[\]\)]\s*',
            r'\s*[\[\(]lossless[\]\)]\s*'
        ]
        for pattern in quality_patterns:
            cleaned = re.sub(pattern, ' ', cleaned, flags=re.IGNORECASE)
        
        # Remove source/torrent indicators  
        source_patterns = [
            r'\s*[\[\(]album[\]\)]\s*',
            r'\s*[\[\(]itunes[\]\)]\s*',
            r'\s*[\[\(]spotify[\]\)]\s*',
            r'\s*[\[\(]cd[\]\)]\s*',
            r'\s*[\[\(]web[\]\)]\s*',
            r'\s*[\[\(]f\d+[\]\)]\s*',  # [F10], [F24], etc.
            r'\s*[\[\(]bonus\s*tracks?[\]\)]\s*',
            r'\s*[\[\(]remaster(ed)?[\]\)]\s*',
            r'\s*[\[\(]clean[\]\)]\s*',
            r'\s*[\[\(]explicit[\]\)]\s*',
            r'\s*[\[\(]album\+itunes\+bonus\s*tracks?[\]\)]\s*',  # [Album+iTunes+Bonus Tracks]
            r'\s*[\[\(]itunes\+bonus[\]\)]\s*',
            r'\s*[\[\(]bonus[\]\)]\s*'
        ]
        for pattern in source_patterns:
            cleaned = re.sub(pattern, ' ', cleaned, flags=re.IGNORECASE)
        
        # Remove edition indicators but preserve meaningful ones like "Deluxe Edition"
        # Only remove if they're standalone or with obvious non-meaningful text
        cleaned = re.sub(r'\s*[\[\(](deluxe\s*edition|special\s*edition|expanded\s*edition)[\]\)]\s*', r' (\1)', cleaned, flags=re.IGNORECASE)
        
        # Clean up multiple spaces, leading/trailing spaces and dashes
        cleaned = re.sub(r'\s+', ' ', cleaned)
        cleaned = re.sub(r'^[-\s]+', '', cleaned)
        cleaned = re.sub(r'[-\s]+$', '', cleaned)
        cleaned = cleaned.strip()
        
        # If everything was removed, try a more conservative approach
        if not cleaned or len(cleaned) < 3:
            # Extract just the main album name before any brackets
            fallback = re.split(r'[\[\(]', album_title)[0].strip()
            # Remove artist prefix from fallback
            fallback = re.sub(f'^{re.escape(artist_name)}\\s*-\\s*', '', fallback, flags=re.IGNORECASE)
            cleaned = fallback.strip() if fallback.strip() else album_title
            print(f"🧹 Album Title used fallback: '{fallback}'")
        
        print(f"🧹 Album Title Result: '{original}' -> '{cleaned}'")
        return cleaned
    
    def _clean_track_title(self, track_title: str, artist_name: str) -> str:
        """Clean up track title by removing artist prefix and other unwanted elements"""
        import re
        
        # Start with the original title
        original = track_title.strip()
        cleaned = original
        print(f"🧹 Track Title Cleaning: '{original}' (artist: '{artist_name}')")
        
        # Remove track numbers from the beginning if present
        # Handles cases like "01 - Track Name", "1. Track Name", "01. Track Name"
        cleaned = re.sub(r'^\d{1,2}[\.\s\-]+', '', cleaned)
        
        # Remove artist name prefix if it appears at the beginning
        # This handles cases like "Kendrick Lamar - Track Name"
        artist_pattern = re.escape(artist_name) + r'\s*-\s*'
        cleaned = re.sub(f'^{artist_pattern}', '', cleaned, flags=re.IGNORECASE)
        
        # Remove album name prefix if it appears (e.g., "GNX - 01 - wacced out murals")
        # Look for pattern: "WORD - NUMBER - actual_title"
        cleaned = re.sub(r'^[A-Za-z0-9\.]+\s*-\s*\d{1,2}\s*-\s*', '', cleaned)
        
        # Remove common file quality indicators from track titles
        quality_patterns = [
            r'\s*[\[\(][0-9]+\s*kbps[\]\)]\s*',
            r'\s*[\[\(]flac[\]\)]\s*',
            r'\s*[\[\(]mp3[\]\)]\s*',
            r'\s*[\[\(]320[\]\)]\s*'
        ]
        for pattern in quality_patterns:
            cleaned = re.sub(pattern, '', cleaned, flags=re.IGNORECASE)
        
        # Clean up any remaining extra spaces, dashes, or dots at the start/end
        cleaned = re.sub(r'^[-\s\.]+', '', cleaned)
        cleaned = re.sub(r'[-\s\.]+$', '', cleaned)
        cleaned = re.sub(r'\s+', ' ', cleaned).strip()
        
        # If everything was removed, try more conservative approach
        if not cleaned or len(cleaned) < 2:
            # Remove just the most obvious prefixes
            fallback = track_title.strip()
            fallback = re.sub(r'^\d{1,2}[\.\s\-]+', '', fallback)  # Remove track numbers
            fallback = re.sub(f'^{re.escape(artist_name)}\\s*-\\s*', '', fallback, flags=re.IGNORECASE)
            cleaned = fallback.strip() if fallback.strip() else track_title
            print(f"🧹 Track Title used fallback: '{fallback}'")
        
        print(f"🧹 Track Title Result: '{original}' -> '{cleaned}'")
        return cleaned
    
    def _resolve_album_group(self, download_item, artist: Artist, album_info: dict) -> str:
        """
        Smart album grouping: Start with standard, upgrade to deluxe if ANY track is deluxe.
        This ensures all tracks from the same album get the same folder name.
        """
        try:
            with self.album_cache_lock:
                # Get the original album name from the download item (if it has one)
                original_album = getattr(download_item, 'album', None)
                detected_album = album_info.get('album_name', '')
                
                # Extract base album name (without edition indicators)
                if album_info.get('spotify_track'):
                    # Use Spotify album name for base
                    base_album = self._get_base_album_name(detected_album)
                elif original_album:
                    # Clean the original Soulseek album name 
                    cleaned_original = self._clean_album_title(original_album, artist.name)
                    base_album = self._get_base_album_name(cleaned_original)
                else:
                    base_album = self._get_base_album_name(detected_album)
                
                # Normalize the base name (handle case variations, etc.)
                base_album = self._normalize_base_album_name(base_album, artist.name)
                
                # Create a key for this album group (artist + base album)
                album_key = f"{artist.name}::{base_album}"
                
                # Check if we already have a cached result for this album
                if album_key in self.album_name_cache:
                    cached_name = self.album_name_cache[album_key]
                    print(f"🔍 Using cached album name for '{album_key}': '{cached_name}'")
                    return cached_name
                
                print(f"🔍 Album grouping - Key: '{album_key}', Detected: '{detected_album}'")
                
                # Check if this track indicates a deluxe edition
                is_deluxe_track = False
                if album_info.get('spotify_track'):
                    is_deluxe_track = self._detect_deluxe_edition(detected_album)
                elif original_album:
                    is_deluxe_track = self._detect_deluxe_edition(original_album)
                
                # Get current edition level for this album group (default to standard)
                current_edition = self.album_editions.get(album_key, "standard")
                
                # SMART ALGORITHM: Upgrade to deluxe if this track is deluxe
                if is_deluxe_track and current_edition == "standard":
                    print(f"🎯 UPGRADE: Album '{base_album}' upgraded from standard to deluxe!")
                    self.album_editions[album_key] = "deluxe"
                    current_edition = "deluxe"
                
                # Build final album name based on edition level
                if current_edition == "deluxe":
                    final_album_name = f"{base_album} (Deluxe Edition)"
                else:
                    final_album_name = base_album
                
                # Store the resolution in both caches
                self.album_groups[album_key] = final_album_name
                self.album_name_cache[album_key] = final_album_name
                self.album_artists[album_key] = artist.name
                
                print(f"🔗 Album resolution: '{detected_album}' -> '{final_album_name}' (edition: {current_edition})")
                
                return final_album_name
            
        except Exception as e:
            print(f"❌ Error resolving album group: {e}")
            return album_info.get('album_name', download_item.title)
    
    def _normalize_base_album_name(self, base_album: str, artist_name: str) -> str:
        """
        Normalize the base album name to handle case variations and known corrections.
        """
        import re
        
        # Apply known album corrections for consistent naming
        normalized_lower = base_album.lower().strip()
        
        known_corrections = {
            'good kid maad city': 'good kid, m.A.A.d city',
            'good kid m.a.a.d city': 'good kid, m.A.A.d city',
            'good kid m.a.a.d. city': 'good kid, m.A.A.d city',
            'good kid m a a d city': 'good kid, m.A.A.d city',
            'good kid m.a.a.d city': 'good kid, m.A.A.d city'
        }
        
        for key, correction in known_corrections.items():
            if key == normalized_lower:
                print(f"📝 Base album correction: '{base_album}' -> '{correction}'")
                return correction
        
        # If no specific correction, return cleaned version
        return base_album.strip()
    
    def _normalize_spotify_album_variants(self, album_name: str, artist_name: str) -> str:
        """
        Normalize different Spotify album variants to a consistent name.
        E.g., 'good kid, m.A.A.d city' and 'good kid, m.A.A.d city (Deluxe)' 
        should both resolve to 'good kid, m.A.A.d city (Deluxe Edition)'
        """
        import re
        
        normalized = album_name.strip()
        
        # Convert various deluxe indicators to standard format
        deluxe_patterns = [
            (r'\s*\(deluxe\)\s*$', ' (Deluxe Edition)'),
            (r'\s*\[deluxe\]\s*$', ' (Deluxe Edition)'),
            (r'\s*deluxe\s*$', ' (Deluxe Edition)'),
            (r'\s*\(deluxe\s+edition\)\s*$', ' (Deluxe Edition)'),
            (r'\s*\[deluxe\s+edition\]\s*$', ' (Deluxe Edition)')
        ]
        
        for pattern, replacement in deluxe_patterns:
            if re.search(pattern, normalized, re.IGNORECASE):
                normalized = re.sub(pattern, replacement, normalized, flags=re.IGNORECASE)
                break
        
        # Normalize case inconsistencies for known albums
        # This handles cases like "good kid, m.A.A.d city" vs "Good Kid M.A.A.D City"
        known_album_corrections = {
            'good kid maad city': 'good kid, m.A.A.d city',
            'good kid m.a.a.d city': 'good kid, m.A.A.d city',
            'good kid m.a.a.d. city': 'good kid, m.A.A.d city',
            'good kid m.a.a.d city': 'good kid, m.A.A.d city',
            'good kid m a a d city': 'good kid, m.A.A.d city'
        }
        
        normalized_lower = normalized.lower()
        for key, correction in known_album_corrections.items():
            if key in normalized_lower:
                # Preserve any edition suffix
                suffix = ''
                if '(deluxe edition)' in normalized_lower:
                    suffix = ' (Deluxe Edition)'
                elif '(deluxe)' in normalized_lower:
                    suffix = ' (Deluxe Edition)'
                    
                normalized = correction + suffix
                break
        
        print(f"📀 Album variant normalization: '{album_name}' -> '{normalized}'")
        return normalized
    
    def _detect_deluxe_edition(self, album_name: str) -> bool:
        """
        Detect if an album name indicates a deluxe/special edition.
        Returns True if it's a deluxe variant, False for standard.
        """
        if not album_name:
            return False
        
        album_lower = album_name.lower()
        
        # Check for deluxe indicators
        deluxe_indicators = [
            'deluxe',
            'deluxe edition', 
            'special edition',
            'expanded edition',
            'extended edition',
            'bonus',
            'remastered',
            'anniversary',
            'collectors edition',
            'limited edition'
        ]
        
        for indicator in deluxe_indicators:
            if indicator in album_lower:
                print(f"🎯 Detected deluxe edition: '{album_name}' contains '{indicator}'")
                return True
        
        return False
    
    def _get_base_album_name(self, album_name: str) -> str:
        """
        Extract the base album name without edition indicators.
        E.g., 'good kid, m.A.A.d city (Deluxe Edition)' -> 'good kid, m.A.A.d city'
        """
        import re
        
        # Remove common edition suffixes
        base_name = album_name
        
        # Remove edition indicators in parentheses or brackets
        base_name = re.sub(r'\s*[\[\(](deluxe|special|expanded|extended|bonus|remastered|anniversary|collectors?|limited).*?[\]\)]\s*$', '', base_name, flags=re.IGNORECASE)
        
        # Remove standalone edition words at the end
        base_name = re.sub(r'\s+(deluxe|special|expanded|extended|bonus|remastered|anniversary|collectors?|limited)\s*(edition)?\s*$', '', base_name, flags=re.IGNORECASE)
        
        return base_name.strip()
    
    def _detect_album_info(self, download_item, artist: Artist) -> Optional[dict]:
        """Detect if track is part of an album using Spotify API as primary source"""
        try:
            print(f"🔍 Album detection for '{download_item.title}' by '{artist.name}':")
            print(f"    Has album attr: {hasattr(download_item, 'album')}")
            if hasattr(download_item, 'album'):
                print(f"    Album value: '{download_item.album}'")
            
            # CHECK FOR FORCED ALBUM MODE FIRST
            if hasattr(download_item, '_force_album_mode') and download_item._force_album_mode:
                print(f"🔒 FORCED ALBUM MODE DETECTED - Using forced album name")
                forced_album = getattr(download_item, '_force_album_name', 'Unknown Album')
                print(f"    Forced album: '{forced_album}'")
                
                # Try to get album image URL from matched_album if available
                album_image_url = None
                if hasattr(download_item, 'matched_album') and download_item.matched_album:
                    album_image_url = download_item.matched_album.image_url
                
                return {
                    'is_album': True,
                    'album_name': forced_album,
                    'track_number': getattr(download_item, 'track_number', 1),
                    'clean_track_name': download_item.title,
                    'confidence': 1.0,  # 100% confidence since it's forced
                    'source': 'forced_user_selection',
                    'album_image_url': album_image_url
                }
            
            # PRIORITY 1: Try album-aware search if we have album context
            if hasattr(download_item, 'album') and download_item.album and download_item.album.strip() and download_item.album != "Unknown Album":
                print(f"🎯 ALBUM-AWARE SEARCH: Looking for '{download_item.title}' in album '{download_item.album}'")
                album_result = self._search_track_in_album_context(download_item, artist)
                if album_result:
                    print(f"✅ Found track in album context - using album classification")
                    return album_result
                else:
                    print(f"⚠️ Track not found in album context, falling back to individual search")
            
            # PRIORITY 2: Fallback to individual track search for clean metadata
            print(f"🔍 Searching Spotify for individual track info (PRIORITY 2)...")
            
            # Clean the track title before searching - remove artist prefix
            clean_title = self._clean_track_title(download_item.title, artist.name)
            print(f"🧹 Cleaned title: '{download_item.title}' -> '{clean_title}'")
            
            # Search for the track by artist and cleaned title
            query = f"artist:{artist.name} track:{clean_title}"
            tracks = self.spotify_client.search_tracks(query, limit=5)
            
            # Find the best matching track
            best_match = None
            best_confidence = 0
            
            if tracks:
                for track in tracks:
                    # Calculate confidence based on artist and title similarity
                    artist_confidence = self.matching_engine.similarity_score(
                        self.matching_engine.normalize_string(artist.name),
                        self.matching_engine.normalize_string(track.artists[0])
                    )
                    title_confidence = self.matching_engine.similarity_score(
                        self.matching_engine.normalize_string(clean_title),
                        self.matching_engine.normalize_string(track.name)
                    )
                    
                    combined_confidence = (artist_confidence * 0.6 + title_confidence * 0.4)
                    
                    if combined_confidence > best_confidence and combined_confidence > 0.6:  # Lower threshold for better matches
                        best_match = track
                        best_confidence = combined_confidence
            
            # If we found a good Spotify match, use it for clean metadata
            if best_match and best_confidence > 0.6:
                print(f"✅ Found matching Spotify track: '{best_match.name}' - Album: '{best_match.album}' (confidence: {best_confidence:.2f})")
                
                # Get detailed track information using Spotify's track API
                detailed_track = None
                if hasattr(best_match, 'id') and best_match.id:
                    print(f"🔍 Getting detailed track info from Spotify API for track ID: {best_match.id}")
                    detailed_track = self.spotify_client.get_track_details(best_match.id)
                
                # Use detailed track data if available
                if detailed_track:
                    print(f"✅ Got detailed track data from Spotify API")
                    album_name = self._clean_album_title(detailed_track['album']['name'], artist.name)
                    clean_track_name = detailed_track['name']  # Use Spotify's clean track name
                    album_type = detailed_track['album'].get('album_type', 'album')
                    total_tracks = detailed_track['album'].get('total_tracks', 1)
                    spotify_track_number = detailed_track.get('track_number', 1)
                    
                    print(f"📀 Spotify album info: '{album_name}' (type: {album_type}, total_tracks: {total_tracks}, track#: {spotify_track_number})")
                    print(f"🎵 Clean track name from Spotify: '{clean_track_name}'")
                    
                    # Enhanced album detection using detailed API data
                    is_album = (
                        # Album type is 'album' (not 'single')
                        album_type == 'album' and
                        # Album has multiple tracks
                        total_tracks > 1 and
                        # Album name different from track name
                        self.matching_engine.normalize_string(album_name) != self.matching_engine.normalize_string(clean_track_name) and
                        # Album name is not just the artist name
                        self.matching_engine.normalize_string(album_name) != self.matching_engine.normalize_string(artist.name)
                    )
                    
                    track_num = spotify_track_number
                    print(f"🎯 Using Spotify track number: {track_num}")
                    
                    # Store the clean Spotify track name for use in file organization (only if not already set)
                    if not hasattr(download_item, '_spotify_clean_title') or not download_item._spotify_clean_title:
                        download_item._spotify_clean_title = clean_track_name
                    download_item._spotify_clean_album = album_name
                    
                    # Extract album image URL from detailed track data
                    album_image_url = None
                    if detailed_track.get('album', {}).get('images'):
                        # Get the largest image (first one in Spotify's array)
                        album_image_url = detailed_track['album']['images'][0]['url']
                    
                    if is_album:
                        print(f"🎯 Spotify detection: Album track - '{album_name}'")
                        return {
                            'is_album': True,
                            'album_name': album_name,
                            'track_number': track_num,
                            'spotify_track': best_match,
                            'clean_track_name': clean_track_name,
                            'album_image_url': album_image_url
                        }
                    else:
                        print(f"🎯 Spotify detection: Single track - using clean track name")
                        return {
                            'is_album': False,
                            'album_name': clean_track_name,  # Use clean track name for single structure
                            'track_number': 1,
                            'spotify_track': best_match,
                            'clean_track_name': clean_track_name,
                            'album_image_url': album_image_url
                        }
                        
                else:
                    print(f"⚠️ Could not get detailed track data, using basic Spotify search data")
                    album_name = self._clean_album_title(best_match.album, artist.name)
                    clean_track_name = best_match.name
                    
                    # Fallback album detection logic
                    is_album = (
                        # Album name different from track name (indicates multi-track album)
                        self.matching_engine.normalize_string(album_name) != self.matching_engine.normalize_string(clean_track_name) and
                        # Album name doesn't contain "single" or similar terms
                        not any(term in album_name.lower() for term in ['single', 'ep']) and
                        # Album name is not just the artist name
                        self.matching_engine.normalize_string(album_name) != self.matching_engine.normalize_string(artist.name)
                    )
                    
                    # Get track number from metadata or filename as fallback
                    track_num = self._extract_track_number(download_item)
                    
                    # Only set if not already set (preserve original Spotify title from modal)
                    if not hasattr(download_item, '_spotify_clean_title') or not download_item._spotify_clean_title:
                        download_item._spotify_clean_title = clean_track_name
                    download_item._spotify_clean_album = album_name
                    
                    # Try to get album image URL from matched_album if available
                    album_image_url = None
                    if hasattr(download_item, 'matched_album') and download_item.matched_album:
                        album_image_url = download_item.matched_album.image_url
                    
                    return {
                        'is_album': is_album,
                        'album_name': album_name if is_album else clean_track_name,
                        'track_number': track_num if is_album else 1,
                        'spotify_track': best_match,
                        'clean_track_name': clean_track_name,
                        'album_image_url': album_image_url
                    }
            
            # PRIORITY 3: Fallback to Soulseek album context if Spotify search failed
            print(f"🔍 No good Spotify match found (confidence: {best_confidence:.2f}), checking Soulseek album context...")
            
            if hasattr(download_item, 'album') and download_item.album and download_item.album != "Unknown Album":
                clean_album = self._clean_album_title(download_item.album, artist.name)
                clean_title = self._clean_track_title(download_item.title, artist.name)
                track_num = self._extract_track_number(download_item)
                
                print(f"✅ Using cleaned Soulseek album context: '{clean_album}' (cleaned from '{download_item.album}')")
                print(f"🧹 Cleaned track title: '{clean_title}' (cleaned from '{download_item.title}')")
                
                # Only set if not already set (preserve original Spotify title from modal)
                if not hasattr(download_item, '_spotify_clean_title') or not download_item._spotify_clean_title:
                    download_item._spotify_clean_title = clean_title
                download_item._spotify_clean_album = clean_album
                
                # Try to get album image URL from matched_album if available
                album_image_url = None
                if hasattr(download_item, 'matched_album') and download_item.matched_album:
                    album_image_url = download_item.matched_album.image_url
                
                return {
                    'is_album': True,
                    'album_name': clean_album,
                    'track_number': track_num,
                    'spotify_track': None,
                    'clean_track_name': clean_title,
                    'album_image_url': album_image_url
                }
            
            # PRIORITY 4: Complete fallback - single track with cleaned title
            print(f"🎯 No album context found, defaulting to single track structure with cleaned title")
            clean_title = self._clean_track_title(download_item.title, artist.name)
            
            # Only set if not already set (preserve original Spotify title from modal)
            if not hasattr(download_item, '_spotify_clean_title') or not download_item._spotify_clean_title:
                download_item._spotify_clean_title = clean_title
            
            # Try to get album image URL from matched_album if available
            album_image_url = None
            if hasattr(download_item, 'matched_album') and download_item.matched_album:
                album_image_url = download_item.matched_album.image_url
            
            return {
                'is_album': False,
                'album_name': clean_title,  # Use clean track name as single name
                'track_number': 1,
                'spotify_track': None,
                'clean_track_name': clean_title,
                'album_image_url': album_image_url
            }
            
        except Exception as e:
            print(f"❌ Error detecting album info: {e}")
            # Emergency fallback to single structure with basic cleaning
            clean_title = self._clean_track_title(download_item.title, artist.name)
            
            # Try to get album image URL from matched_album if available
            album_image_url = None
            if hasattr(download_item, 'matched_album') and download_item.matched_album:
                album_image_url = download_item.matched_album.image_url
            
            return {
                'is_album': False,
                'album_name': clean_title,
                'track_number': 1,
                'spotify_track': None,
                'clean_track_name': clean_title,
                'album_image_url': album_image_url
            }
    
    def _search_track_in_album_context(self, download_item, artist: Artist) -> Optional[dict]:
        """Search for a track within its album context to avoid promotional single confusion"""
        try:
            album_name = download_item.album
            track_title = download_item.title
            
            print(f"🎯 Album-aware search: '{track_title}' in album '{album_name}' by '{artist.name}'")
            
            # Clean the album name for better search results
            clean_album = self._clean_album_title(album_name, artist.name)
            clean_track = self._clean_track_title(track_title, artist.name)
            
            # Search for the specific album first
            album_query = f"album:{clean_album} artist:{artist.name}"
            print(f"🔍 Searching albums: {album_query}")
            albums = self.spotify_client.search_albums(album_query, limit=5)
            
            if not albums:
                print(f"❌ No albums found for query: {album_query}")
                return None
            
            # Check each album to see if our track is in it
            for album in albums:
                print(f"🎵 Checking album: '{album.name}' ({album.total_tracks} tracks)")
                
                # Get tracks from this album
                album_tracks_data = self.spotify_client.get_album_tracks(album.id)
                if not album_tracks_data or 'items' not in album_tracks_data:
                    print(f"❌ Could not get tracks for album: {album.name}")
                    continue
                
                # Check if our track is in this album
                for track_data in album_tracks_data['items']:
                    track_name = track_data['name']
                    track_number = track_data['track_number']
                    
                    # Calculate similarity between our track and this album track
                    similarity = self.matching_engine.similarity_score(
                        self.matching_engine.normalize_string(clean_track),
                        self.matching_engine.normalize_string(track_name)
                    )
                    
                    # Use higher threshold for remix matching to ensure precision
                    is_remix = any(word in clean_track.lower() for word in ['remix', 'mix', 'edit', 'version'])
                    threshold = 0.9 if is_remix else 0.7  # Much stricter for remixes
                    
                    if similarity > threshold:
                        print(f"✅ FOUND: '{track_name}' (track #{track_number}) matches '{clean_track}' (similarity: {similarity:.2f})")
                        print(f"🎯 Forcing album classification for track in '{album.name}'")
                        
                        # Return album info - force album classification!
                        return {
                            'is_album': True,  # Always true - we found it in an album!
                            'album_name': album.name,
                            'track_number': track_number,
                            'clean_track_name': clean_track,  # Use the ORIGINAL download title, not the database match
                            'album_image_url': album.image_url,
                            'confidence': similarity,
                            'source': 'album_context_search'
                        }
                
                print(f"❌ Track '{clean_track}' not found in album '{album.name}'")
            
            print(f"❌ Track '{clean_track}' not found in any matching albums")
            return None
            
        except Exception as e:
            print(f"❌ Error in album-aware search: {e}")
            return None
    
    def _download_cover_art(self, artist: Artist, album_info: dict, target_dir: str):
        """Download cover art for the album, prioritizing album artwork from Spotify"""
        try:
            import requests
            import os
            
            cover_path = os.path.join(target_dir, "cover.jpg")
            
            # Skip if cover already exists
            if os.path.exists(cover_path):
                print("📷 Cover art already exists")
                return
            
            image_url = None
            source_description = ""
            
            # Priority 1: Use album artwork from album_info if available
            if album_info.get('album_image_url'):
                image_url = album_info['album_image_url']
                source_description = f"album artwork for '{album_info.get('album_name', 'Unknown Album')}'"
                print(f"📷 Using album artwork from album_info")
            
            # Priority 2: Try to get album artwork via Spotify search if we have album name
            elif album_info.get('album_name') and hasattr(self, 'spotify_client'):
                try:
                    print(f"📷 Searching Spotify for album artwork: '{album_info['album_name']}' by '{artist.name}'")
                    # Search for the specific album
                    search_query = f"album:{album_info['album_name']} artist:{artist.name}"
                    albums = self.spotify_client.search_albums(search_query, limit=1)
                    
                    if albums and len(albums) > 0:
                        album = albums[0]
                        if album.image_url:
                            image_url = album.image_url
                            source_description = f"Spotify album artwork for '{album.name}'"
                            print(f"📷 Found album artwork via Spotify search")
                        else:
                            print(f"📷 Album found but no image available")
                    else:
                        print(f"📷 No album found in Spotify search")
                except Exception as e:
                    print(f"📷 Error searching Spotify for album artwork: {e}")
            
            # Priority 3: Fall back to artist image
            if not image_url and artist.image_url:
                image_url = artist.image_url
                source_description = f"artist image for '{artist.name}'"
                print(f"📷 Falling back to artist image")
            
            # No image available
            if not image_url:
                print("📷 No cover art available (no album artwork or artist image)")
                return
            
            print(f"📷 Downloading {source_description} from: {image_url}")
            response = requests.get(image_url, timeout=10)
            response.raise_for_status()
            
            with open(cover_path, 'wb') as f:
                f.write(response.content)
            
            print(f"✅ Cover art downloaded: {cover_path}")
            
        except Exception as e:
            print(f"❌ Error downloading cover art: {e}")
    
    def _create_single_track_album_info(self, download_item, artist: Artist) -> Optional[dict]:
        """Create album_info dict for single track cover art download"""
        try:
            # Check if we have matched_album from Spotify matching
            if hasattr(download_item, 'matched_album') and download_item.matched_album:
                album = download_item.matched_album
                print(f"📷 Single track has matched album: '{album.name}' with image: {bool(album.image_url)}")
                return {
                    'album_name': album.name,
                    'album_image_url': album.image_url,
                    'is_album': False,  # This is still a single track
                    'track_number': 1,
                    'clean_track_name': download_item.title
                }
            
            # If no matched_album, try to detect from track title or existing album field
            album_name = None
            if hasattr(download_item, 'album') and download_item.album and download_item.album.strip():
                album_name = download_item.album.strip()
                print(f"📷 Using album name from download_item: '{album_name}'")
            else:
                print(f"📷 No album information available for single track")
                return None
            
            # Create basic album_info for cover art search
            return {
                'album_name': album_name,
                'album_image_url': None,  # Will be searched in _download_cover_art
                'is_album': False,  # This is still a single track
                'track_number': 1,
                'clean_track_name': download_item.title
            }
            
        except Exception as e:
            print(f"❌ Error creating single track album info: {e}")
            return None

    def _generate_lrc_file(self, file_path: str, download_item, artist, album_info: dict) -> bool:
        """
        Generate LRC lyrics file using LRClib API.
        Elegant addition to post-processing - extracts metadata from existing context.
        """
        try:
            # Initialize lyrics client if not already done
            if not hasattr(self, 'lyrics_client'):
                self.lyrics_client = LyricsClient()

            if not self.lyrics_client:
                return False

            # Get track metadata from download_item
            track_name = getattr(download_item, 'title', 'Unknown Track')

            # Handle artist parameter (can be dict or object)
            if isinstance(artist, dict):
                artist_name = artist.get('name', 'Unknown Artist')
            elif hasattr(artist, 'name'):
                artist_name = artist.name
            else:
                artist_name = str(artist) if artist else 'Unknown Artist'

            album_name = None
            duration_seconds = None

            # Get album name if available
            if album_info and album_info.get('is_album'):
                album_name = album_info.get('album_name')

            # Get duration from download_item if available
            if hasattr(download_item, 'duration') and download_item.duration:
                try:
                    duration_seconds = int(download_item.duration)
                except (ValueError, TypeError):
                    pass

            # Generate LRC file using lyrics client
            success = self.lyrics_client.create_lrc_file(
                audio_file_path=file_path,
                track_name=track_name,
                artist_name=artist_name,
                album_name=album_name,
                duration_seconds=duration_seconds
            )

            if success:
                print(f"🎵 LRC file generated for: {track_name}")
            else:
                print(f"🎵 No lyrics found for: {track_name}")

            return success

        except Exception as e:
            print(f"❌ Error generating LRC file for {file_path}: {e}")
            return False

    def _extract_track_number(self, download_item, spotify_track=None) -> int:
        """Extract track number from various sources"""
        try:
            print(f"🔢 Extracting track number for: '{download_item.title}'")
            
            # Method 1: Check if download_item has track_number attribute (explicit metadata)
            if hasattr(download_item, 'track_number') and download_item.track_number:
                track_num = int(download_item.track_number)
                print(f"    ✅ Found track_number attribute: {track_num}")
                return track_num
            
            # Method 2: Parse from filename (e.g., "01. Track Name.mp3", "01 - Track Name.flac")
            if hasattr(download_item, 'title'):
                import re
                # Look for patterns like "01. ", "01 ", "01-", "1. ", etc.
                patterns = [
                    r'^(\d{1,2})[\.\s\-]+',  # "01. " or "01 " or "01-"
                    r'(\d{1,2})\s*[\.\-]\s*',  # "01." or "01-" with optional spaces
                ]
                
                for pattern in patterns:
                    match = re.match(pattern, download_item.title.strip())
                    if match:
                        track_num = int(match.group(1))
                        print(f"    ✅ Parsed from title pattern '{pattern}': {track_num}")
                        return track_num
            
            # Method 3: Parse from filename if available
            if hasattr(download_item, 'filename'):
                import re
                import os
                # Get just the filename without extension and path
                base_name = os.path.splitext(os.path.basename(download_item.filename))[0]
                
                patterns = [
                    r'^(\d{1,2})[\.\s\-]+',  # "01. " or "01 " or "01-"
                    r'(\d{1,2})\s*[\.\-]\s*',  # "01." or "01-" with optional spaces
                ]
                
                for pattern in patterns:
                    match = re.match(pattern, base_name.strip())
                    if match:
                        track_num = int(match.group(1))
                        print(f"    ✅ Parsed from filename pattern '{pattern}': {track_num}")
                        return track_num
            
            # Method 4: Get from Spotify track data (would need album API call)
            if spotify_track:
                # This would require additional Spotify API call to get full album
                # For now, we'll skip this but could be enhanced later
                print(f"    ⏭️ Spotify track data available but not implemented yet")
                pass
            
            # Default to 1 if no track number found
            print(f"    ⚠️ No track number found, defaulting to 1")
            return 1
            
        except Exception as e:
            print(f"❌ Error extracting track number: {e}")
            return 1
    
    def _find_downloaded_file(self, original_file_path: str, download_item) -> Optional[str]:
        """Try to find the downloaded file using various methods"""
        try:
            import os
            import glob
            from pathlib import Path
            
            print(f"🔍 Searching for downloaded file...")
            print(f"    Original path: {original_file_path}")
            
            # Get the download directory
            download_dir = self.soulseek_client.download_path if self.soulseek_client else './downloads'
            print(f"    Download directory: {download_dir}")
            
            # Normalize path separators (convert Windows \\ to /)
            normalized_path = original_file_path.replace('\\', '/')
            
            # Extract filename from the API path
            api_filename = os.path.basename(normalized_path)
            print(f"    Looking for filename: {api_filename}")
            
            # Method 1: Try the exact path first (but normalized)
            if os.path.exists(original_file_path):
                print(f"    ✅ Found exact path: {original_file_path}")
                return original_file_path
            
            # Method 2: Search in the download directory recursively
            search_patterns = [
                os.path.join(download_dir, "**", api_filename),
                os.path.join(download_dir, "**", f"*{download_item.title}*"),
                os.path.join(download_dir, "**", f"*{download_item.artist}*")
            ]
            
            for pattern in search_patterns:
                print(f"    Searching pattern: {pattern}")
                matches = glob.glob(pattern, recursive=True)
                if matches:
                    # Filter for audio files
                    audio_extensions = {'.mp3', '.flac', '.ogg', '.aac', '.wma', '.wav', '.m4a'}
                    audio_matches = [f for f in matches if os.path.splitext(f)[1].lower() in audio_extensions]
                    
                    if audio_matches:
                        # Return the first match that exists and has reasonable size
                        for match in audio_matches:
                            if os.path.exists(match) and os.path.getsize(match) > 1024:  # At least 1KB
                                print(f"    ✅ Found match: {match}")
                                return match
            
            # Method 3: Look for recently modified files in download directory
            print(f"    Searching for recent files in download directory...")
            recent_files = []
            audio_extensions = {'.mp3', '.flac', '.ogg', '.aac', '.wma', '.wav', '.m4a'}
            
            # Debug: List all files in download directory
            print(f"    📂 Files in download directory:")
            for root, dirs, files in os.walk(download_dir):
                for file in files:
                    file_path = os.path.join(root, file)
                    rel_path = os.path.relpath(file_path, download_dir)
                    file_size = os.path.getsize(file_path) if os.path.exists(file_path) else 0
                    print(f"        {rel_path} ({file_size} bytes)")
                    
                    if os.path.splitext(file)[1].lower() in audio_extensions:
                        # Check if file was modified recently (within last 5 minutes)
                        import time
                        if time.time() - os.path.getmtime(file_path) < 300:  # 5 minutes
                            recent_files.append((file_path, os.path.getmtime(file_path)))
            
            # Sort by modification time (most recent first)
            recent_files.sort(key=lambda x: x[1], reverse=True)
            
            for file_path, _ in recent_files[:5]:  # Check top 5 most recent
                print(f"    Checking recent file: {file_path}")
                # Simple filename matching
                if (download_item.title.lower() in os.path.basename(file_path).lower() or
                    download_item.artist.lower() in os.path.basename(file_path).lower()):
                    print(f"    ✅ Found recent match: {file_path}")
                    return file_path
            
            print(f"    ❌ No matching files found")
            return None
            
        except Exception as e:
            print(f"❌ Error searching for downloaded file: {e}")
            return None
    
    def update_album_track_button_states(self, download_item, status):
        """Update track download button states based on download progress"""
        
        # Find the track item that corresponds to this download
        album_items_found = self.findChildren(AlbumResultItem)
        
        for album_item in album_items_found:
            
            for track_item in album_item.track_items:
                track_title = track_item.track_result.title
                track_artist = track_item.track_result.artist
                
                
                # Match by track title and artist
                if (track_title == download_item.title and track_artist == download_item.artist):
                    
                    
                    # Update button state based on download status
                    if status == 'downloading':
                        track_item.set_download_downloading_state()
                        print(f"[DEBUG] Set button to downloading state (📥)")
                    elif status in ['completed', 'finished']:
                        track_item.set_download_completed_state()
                        print(f"[DEBUG] Set button to completed state (✅)")
                    elif status in ['queued', 'initializing']:
                        track_item.set_download_queued_state()
                        print(f"[DEBUG] Set button to queued state (⏳)")
                    elif status in ['failed', 'cancelled', 'canceled']:
                        track_item.reset_download_state()  # Allow retry
                        print(f"[DEBUG] 🔓 RESET button to downloadable state (⬇️) - track can now be downloaded again!")
                    else:
                        print(f"[DEBUG] ⚠️ Unknown status '{status}' - no button update performed")
                    
                    return
        
    
    def start_stream(self, search_result, result_item=None):
        """Start streaming a search result using StreamingThread or toggle if same track"""
        try:
            # Check if this is the same track that's currently playing
            current_track_id = getattr(self, 'current_track_id', None)
            new_track_id = f"{search_result.username}:{search_result.filename}"
            
            print(f"🎮 start_stream() called for: {search_result.filename}")
            print(f"🎮 Current track ID: {current_track_id}")
            print(f"🎮 New track ID: {new_track_id}")
            print(f"🎮 Currently playing button: {self.currently_playing_button}")
            print(f"🎮 Result item: {result_item}")
            print(f"🎮 Button match: {self.currently_playing_button == result_item}")
            print(f"🎮 Track ID match: {current_track_id == new_track_id}")
            
            if current_track_id == new_track_id and self.currently_playing_button == result_item:
                # Same track clicked - toggle playback
                print(f"🔄 Toggling playback for: {search_result.filename}")
                
                toggle_result = self.audio_player.toggle_playback()
                print(f"🔄 toggle_playback() returned: {toggle_result}")
                
                if toggle_result:
                    # Now playing
                    result_item.set_playing_state()
                    self.track_resumed.emit()
                    print("🎵 Song card: Resumed playback")
                else:
                    # Now paused
                    result_item.set_loading_state()  # Use loading as "paused" state
                    self.track_paused.emit()
                    print("⏸️ Song card: Paused playback")
                
                return
            else:
                print(f"🆕 Different track or button - starting new stream")
            
            print(f"Starting stream: {search_result.filename} from {search_result.username}")
            
            # Different track - stop current and start new
            if self.currently_playing_button:
                self.audio_player.stop_playback()
                try:
                    self.currently_playing_button.reset_play_state()
                except RuntimeError:
                    # Button was deleted, ignore
                    pass
            
            # Stop any existing streaming threads AND cancel their downloads
            self._stop_all_streaming_threads()
            self._cancel_current_streaming_download_sync()
            
            # Track the new currently playing button and track
            self.currently_playing_button = result_item
            self.current_track_id = new_track_id
            self.current_track_result = search_result
            
            # Clear Stream folder before starting new stream (release current file since we're switching)
            self.clear_stream_folder(release_current_file=True)
            
            # Check if file is a valid audio type
            audio_extensions = ['.mp3', '.flac', '.ogg', '.aac', '.wma', '.wav']
            filename_lower = search_result.filename.lower()
            
            is_audio = any(filename_lower.endswith(ext) for ext in audio_extensions)
            
            if is_audio:
                print(f"✓ Streaming audio file: {search_result.filename}")
                print(f"  Quality: {search_result.quality}")
                print(f"  Size: {search_result.size // (1024*1024)}MB")
                print(f"  User: {search_result.username}")
                
                # Track current streaming download for potential cancellation
                self.current_streaming_download = {
                    'username': search_result.username,
                    'filename': search_result.filename,
                    'download_id': None  # Will be set when download starts
                }
                print(f"🎯 Tracking new streaming download: {search_result.username}:{search_result.filename}")
                
                # Create and start streaming thread
                streaming_thread = StreamingThread(self.soulseek_client, search_result)
                streaming_thread.streaming_started.connect(self.on_streaming_started, Qt.ConnectionType.QueuedConnection)
                streaming_thread.streaming_finished.connect(self.on_streaming_finished, Qt.ConnectionType.QueuedConnection)
                streaming_thread.streaming_progress.connect(self.on_streaming_progress, Qt.ConnectionType.QueuedConnection)
                streaming_thread.streaming_queued.connect(self.on_streaming_queued, Qt.ConnectionType.QueuedConnection)
                streaming_thread.streaming_failed.connect(self.on_streaming_failed, Qt.ConnectionType.QueuedConnection)
                streaming_thread.finished.connect(
                    functools.partial(self.on_streaming_thread_finished, streaming_thread),
                    Qt.ConnectionType.QueuedConnection
                )
                
                # Track the streaming thread
                if not hasattr(self, 'streaming_threads'):
                    self.streaming_threads = []
                self.streaming_threads.append(streaming_thread)
                
                # Start the streaming
                streaming_thread.start()
                
            else:
                print(f"✗ Cannot stream non-audio file: {search_result.filename}")
                
        except Exception as e:
            print(f"Failed to start stream: {str(e)}")
    
    def on_streaming_started(self, message, search_result):
        """Handle streaming start"""
        print(f"Streaming started: {message}")
        # Set button to loading state while file is being prepared
        if self.currently_playing_button:
            try:
                self.currently_playing_button.set_loading_state()
            except RuntimeError:
                # Button was deleted, ignore
                pass
        
        # Emit signal for media player loading animation
        self.track_loading_started.emit(search_result)
    
    def on_streaming_finished(self, message, search_result):
        """Handle streaming completion - start actual audio playback"""
        print(f"Streaming finished: {message}")
        
        # Check if this streaming result is for the currently requested track
        # Prevent old downloads from interrupting new songs
        if hasattr(self, 'current_track_result') and self.current_track_result:
            current_track_id = f"{self.current_track_result.username}:{self.current_track_result.filename}"
            finished_track_id = f"{search_result.username}:{search_result.filename}"
            
            if current_track_id != finished_track_id:
                print(f"🚫 Ignoring old streaming result for: {search_result.filename}")
                print(f"   Current track: {current_track_id}")
                print(f"   Finished track: {finished_track_id}")
                return
        
        try:
            # Find the stream file in the Stream folder
            project_root = os.path.dirname(os.path.dirname(os.path.dirname(__file__)))  # Go up from ui/pages/
            stream_folder = os.path.join(project_root, 'Stream')
            
            # Find any audio file in the stream folder (should only be one)
            stream_file = None
            audio_extensions = {'.mp3', '.flac', '.ogg', '.aac', '.wma', '.wav', '.m4a'}
            
            for filename in os.listdir(stream_folder):
                file_path = os.path.join(stream_folder, filename)
                if (os.path.isfile(file_path) and 
                    os.path.splitext(filename)[1].lower() in audio_extensions):
                    stream_file = file_path
                    break
            
            if stream_file and os.path.exists(stream_file):
                # Start audio playback
                success = self.audio_player.play_file(stream_file)
                if success:
                    print(f"🎵 Started audio playback: {os.path.basename(stream_file)}")
                    # Set button to playing state
                    if self.currently_playing_button:
                        try:
                            self.currently_playing_button.set_playing_state()
                        except RuntimeError:
                            # Button was deleted, ignore
                            pass
                    # Emit track started signal for sidebar media player
                    if hasattr(self, 'current_track_result') and self.current_track_result:
                        self.track_loading_finished.emit(self.current_track_result)
                        self.track_started.emit(self.current_track_result)
                else:
                    print(f"❌ Failed to start audio playback")
                    # Reset button on failure
                    if self.currently_playing_button:
                        try:
                            self.currently_playing_button.reset_play_state()
                        except RuntimeError:
                            # Button was deleted, ignore
                            pass
                        self.currently_playing_button = None
            else:
                print(f"❌ Stream file not found in {stream_folder}")
                # Reset button on failure
                if self.currently_playing_button:
                    try:
                        self.currently_playing_button.reset_play_state()
                    except RuntimeError:
                        # Button was deleted, ignore
                        pass
                    self.currently_playing_button = None
                
        except Exception as e:
            print(f"❌ Error starting audio playback: {e}")
            # Reset button on error
            if self.currently_playing_button:
                try:
                    self.currently_playing_button.reset_play_state()
                except RuntimeError:
                    # Button was deleted, ignore
                    pass
                self.currently_playing_button = None
    
    def on_streaming_progress(self, progress_percent, search_result):
        """Handle streaming progress updates"""
        print(f"Streaming progress: {progress_percent:.1f}% for {search_result.filename}")
        
        # Check if this progress is for the currently requested track
        if hasattr(self, 'current_track_result') and self.current_track_result:
            current_track_id = f"{self.current_track_result.username}:{self.current_track_result.filename}"
            progress_track_id = f"{search_result.username}:{search_result.filename}"
            
            if current_track_id == progress_track_id:
                # Emit progress signal for media player
                self.track_loading_progress.emit(progress_percent, search_result)
            else:
                print(f"🚫 Ignoring progress for old streaming result: {search_result.filename}")
    
    def on_streaming_queued(self, queue_msg, search_result):
        """Handle streaming queue state updates"""
        print(f"Queue status: {queue_msg} for {search_result.filename}")
        
        # Check if this queue status is for the currently requested track
        if hasattr(self, 'current_track_result') and self.current_track_result:
            current_track_id = f"{self.current_track_result.username}:{self.current_track_result.filename}"
            queued_track_id = f"{search_result.username}:{search_result.filename}"
            
            if current_track_id == queued_track_id:
                # Show queue status in button
                if self.currently_playing_button:
                    try:
                        self.currently_playing_button.set_queue_state()
                    except RuntimeError:
                        # Button was deleted, ignore
                        pass
                print(f"📋 Showing queue status for current track")
            else:
                print(f"🚫 Ignoring queue status for old streaming result: {search_result.filename}")
    
    def on_streaming_failed(self, error_msg, search_result):
        """Handle streaming failure"""
        print(f"Streaming failed: {error_msg}")
        # Reset any play button that might be waiting
        if self.currently_playing_button:
            try:
                self.currently_playing_button.reset_play_state()
            except RuntimeError:
                # Button was deleted, ignore
                pass
            self.currently_playing_button = None
    
    def _stop_all_streaming_threads(self):
        """Stop all active streaming threads to prevent old downloads from interrupting new streams"""
        if hasattr(self, 'streaming_threads'):
            print(f"🛑 Stopping {len(self.streaming_threads)} active streaming threads")
            
            for thread in self.streaming_threads[:]:  # Use slice copy to avoid modification during iteration
                try:
                    if thread.isRunning():
                        print(f"🛑 Stopping streaming thread for: {getattr(thread.search_result, 'filename', 'unknown')}")
                        thread.stop()  # Request stop
                        
                        # Give thread more time to stop gracefully (3 seconds)
                        if not thread.wait(3000):  # Wait up to 3 seconds
                            print(f"⚠️ Streaming thread taking longer to stop, giving more time...")
                            # Try one more time with longer wait
                            if not thread.wait(2000):  # Additional 2 seconds
                                print(f"⚠️ Force terminating unresponsive streaming thread")
                                thread.terminate()
                                thread.wait(1000)  # Wait for termination
                            else:
                                print(f"✓ Streaming thread stopped gracefully (delayed)")
                        else:
                            print(f"✓ Streaming thread stopped gracefully")
                    
                    # Remove from list
                    if thread in self.streaming_threads:
                        self.streaming_threads.remove(thread)
                        
                except Exception as e:
                    print(f"⚠️ Error stopping streaming thread: {e}")
            
            print(f"✓ All streaming threads stopped")
    
    async def _cancel_current_streaming_download(self):
        """Cancel the current streaming download via slskd API to prevent queue clogging"""
        if not hasattr(self, 'current_streaming_download') or not self.current_streaming_download:
            return
            
        try:
            username = self.current_streaming_download['username']
            filename = self.current_streaming_download['filename']
            print(f"🚫 Attempting to cancel streaming download: {username}:{os.path.basename(filename)}")
            
            # Find the download ID by searching current transfers
            all_transfers = await self.soulseek_client._make_request('GET', 'transfers/downloads')
            download_id = None
            
            if all_transfers:
                # Flatten transfer data to find our download
                for user_data in all_transfers:
                    if user_data.get('username') == username:
                        for directory in user_data.get('directories', []):
                            for file_data in directory.get('files', []):
                                if os.path.basename(file_data.get('filename', '')) == os.path.basename(filename):
                                    download_id = file_data.get('id')
                                    break
                            if download_id:
                                break
                    if download_id:
                        break
            
            if download_id:
                print(f"🚫 Found streaming download ID: {download_id}")
                # Cancel the download with remove=False (slskd won't allow remove=True for active downloads)
                success = await self.soulseek_client.cancel_download(download_id, username, remove=False)
                if success:
                    print(f"✓ Successfully cancelled streaming download: {os.path.basename(filename)}")
                else:
                    print(f"⚠️ Failed to cancel streaming download: {os.path.basename(filename)}")
                    # Try without remove flag as fallback
                    try:
                        success = await self.soulseek_client.cancel_download(download_id, username, remove=False)
                        if success:
                            print(f"✓ Cancelled streaming download with fallback method: {os.path.basename(filename)}")
                    except Exception as fallback_e:
                        print(f"⚠️ Fallback cancellation also failed: {fallback_e}")
            else:
                print(f"⚠️ Could not find download ID for streaming download: {os.path.basename(filename)}")
                
        except Exception as e:
            print(f"⚠️ Error cancelling streaming download: {e}")
            # Continue with graceful fallback - don't let cancellation errors break streaming
            print(f"🔄 Continuing with new stream despite cancellation error")
        finally:
            # Clean up any partial files from the cancelled streaming download
            if hasattr(self, 'current_streaming_download') and self.current_streaming_download:
                await self._cleanup_cancelled_streaming_files(self.current_streaming_download)
            
            # Clear tracking regardless of success to prevent stuck state
            self.current_streaming_download = None
            print(f"🧹 Cleared streaming download tracking")
            
        # Also clean up any completed streaming downloads to prevent queue clogging
        await self._cleanup_completed_streaming_downloads()
    
    async def _cleanup_completed_streaming_downloads(self):
        """Remove completed streaming downloads from slskd to prevent queue clogging"""
        try:
            print(f"🧹 Cleaning up completed streaming downloads...")
            
            # Get current transfers to find completed ones
            all_transfers = await self.soulseek_client._make_request('GET', 'transfers/downloads')
            completed_streaming_downloads = []
            
            if all_transfers:
                # Look for completed downloads that might be from streaming
                for user_data in all_transfers:
                    username = user_data.get('username', '')
                    for directory in user_data.get('directories', []):
                        for file_data in directory.get('files', []):
                            state = file_data.get('state', '')
                            filename = file_data.get('filename', '')
                            download_id = file_data.get('id', '')
                            
                            # Check if this is a completed download
                            if ('Completed' in state and 'Succeeded' in state) and download_id:
                                # Consider audio files as potential streaming downloads
                                audio_extensions = {'.mp3', '.flac', '.ogg', '.aac', '.wma', '.wav', '.m4a'}
                                file_ext = os.path.splitext(filename)[1].lower()
                                
                                if file_ext in audio_extensions:
                                    completed_streaming_downloads.append({
                                        'id': download_id,
                                        'username': username,
                                        'filename': filename
                                    })
            
            # Remove completed streaming downloads (limit to prevent excessive cleanup)
            max_cleanup = 5  # Only clean up 5 at a time to be conservative
            for download in completed_streaming_downloads[:max_cleanup]:
                try:
                    success = await self.soulseek_client.cancel_download(
                        download['id'], download['username'], remove=True
                    )
                    if success:
                        print(f"🧹 Cleaned up completed streaming download: {os.path.basename(download['filename'])}")
                    else:
                        print(f"⚠️ Failed to clean up: {os.path.basename(download['filename'])}")
                except Exception as e:
                    print(f"⚠️ Error cleaning up download {download['id']}: {e}")
                    
            if completed_streaming_downloads:
                print(f"🧹 Completed streaming download cleanup: {len(completed_streaming_downloads[:max_cleanup])} items removed")
            else:
                print(f"🧹 No completed streaming downloads found to clean up")
                
        except Exception as e:
            print(f"⚠️ Error during streaming download cleanup: {e}")
    
    async def _cleanup_cancelled_streaming_files(self, download_info):
        """Clean up partial files from cancelled streaming downloads"""
        try:
            username = download_info.get('username', '')
            filename = download_info.get('filename', '')
            
            if not username or not filename:
                return
                
            print(f"🧹 Cleaning up cancelled streaming files for: {os.path.basename(filename)}")
            
            # Get downloads directory from config
            from config.settings import config_manager
            downloads_config = config_manager.get_downloads_config()
            download_path = downloads_config.get('path', './downloads')
            
            # Look for partial/completed files in downloads directory
            filename_base = os.path.splitext(os.path.basename(filename))[0]
            
            # Search for files that might match this download
            for root, dirs, files in os.walk(download_path):
                for file in files:
                    # Check if this file could be from our cancelled download
                    if (filename_base.lower() in file.lower() or 
                        os.path.basename(filename).lower() == file.lower()):
                        
                        file_path = os.path.join(root, file)
                        try:
                            print(f"🗑️ Removing cancelled streaming file: {file_path}")
                            os.remove(file_path)
                            
                            # Clean up empty directories
                            self._cleanup_empty_directories(download_path, file_path)
                            
                        except Exception as e:
                            print(f"⚠️ Error removing file {file_path}: {e}")
                            
        except Exception as e:
            print(f"⚠️ Error cleaning up cancelled streaming files: {e}")
    
    def _cancel_current_streaming_download_sync(self):
        """Synchronous wrapper for cancelling current streaming download"""
        if hasattr(self, 'current_streaming_download') and self.current_streaming_download:
            # Use async event loop to run the cancellation
            import asyncio
            import threading
            
            try:
                # Try to get existing event loop first
                try:
                    loop = asyncio.get_running_loop()
                    # Loop is already running, we need to run in a thread
                    def run_in_thread():
                        new_loop = asyncio.new_event_loop()
                        asyncio.set_event_loop(new_loop)
                        try:
                            new_loop.run_until_complete(self._cancel_current_streaming_download())
                        finally:
                            new_loop.close()
                    
                    thread = threading.Thread(target=run_in_thread)
                    thread.start()
                    thread.join(timeout=5.0)  # Wait max 5 seconds
                    return
                except RuntimeError:
                    # No event loop in current thread
                    pass
                
                # Create and use new event loop
                loop = asyncio.new_event_loop()
                asyncio.set_event_loop(loop)
                try:
                    loop.run_until_complete(self._cancel_current_streaming_download())
                finally:
                    loop.close()
                    
            except Exception as e:
                print(f"⚠️ Error in sync streaming download cancellation: {e}")
                print(f"🔄 Continuing with new stream despite sync cancellation error")
                # Clear tracking as fallback to prevent stuck state
                self.current_streaming_download = None
    
    def on_streaming_thread_finished(self, thread):
        """Clean up when streaming thread finishes"""
        try:
            if hasattr(self, 'streaming_threads') and thread in self.streaming_threads:
                self.streaming_threads.remove(thread)
            
            # Disconnect all signals to prevent stale connections
            try:
                thread.streaming_started.disconnect()
                thread.streaming_finished.disconnect()
                thread.streaming_failed.disconnect()
                thread.finished.disconnect()
            except Exception:
                pass  # Ignore if signals are already disconnected
            
            # Ensure thread is properly stopped before deletion
            if thread.isRunning():
                thread.stop()
                thread.wait(1000)  # Wait up to 1 second
            
            # Use QTimer.singleShot for delayed cleanup
            QTimer.singleShot(100, thread.deleteLater)
            
        except Exception as e:
            print(f"Error cleaning up finished streaming thread: {e}")
    
    def on_audio_playback_finished(self):
        """Handle when audio playback finishes"""
        print("🎵 Audio playback completed")
        # Reset the play button to play state
        if self.currently_playing_button:
            try:
                self.currently_playing_button.reset_play_state()
            except RuntimeError:
                # Button was deleted, ignore
                pass
            self.currently_playing_button = None
        
        # Emit track finished signal for sidebar media player
        self.track_finished.emit()
        
        # Clear Stream folder when playback finishes (release file since playback is done)
        self.clear_stream_folder(release_current_file=True)
        
        # Clear track state
        self.current_track_id = None
        self.current_track_result = None
    
    def on_audio_playback_error(self, error_msg):
        """Handle audio playback errors"""
        print(f"❌ Audio playback error: {error_msg}")
        # Reset the play button to play state
        if self.currently_playing_button:
            try:
                self.currently_playing_button.reset_play_state()
            except RuntimeError:
                # Button was deleted, ignore
                pass
            self.currently_playing_button = None
        
        # Emit track stopped signal for sidebar media player
        self.track_stopped.emit()
        
        # Clear Stream folder when playback errors (release file since there's an error)
        self.clear_stream_folder(release_current_file=True)
        
        # Clear track state
        self.current_track_id = None
        self.current_track_result = None
    
    def handle_sidebar_play_pause(self):
        """Handle play/pause request from sidebar media player"""
        # Use the actual QMediaPlayer state instead of manual flag
        from PyQt6.QtMultimedia import QMediaPlayer
        
        current_state = self.audio_player.playbackState()
        print(f"🎮 handle_sidebar_play_pause() - Current state: {current_state}")
        print(f"🎮 handle_sidebar_play_pause() - Current source: {self.audio_player.source().toString()}")
        
        if current_state == QMediaPlayer.PlaybackState.PlayingState:
            print("⏸️ Sidebar: Pausing playback")
            self.audio_player.pause()
            # is_playing will be set automatically by _on_playback_state_changed
            if self.currently_playing_button:
                try:
                    self.currently_playing_button.set_loading_state()  # Use as "paused" state
                except RuntimeError:
                    # Button was deleted, ignore
                    pass
            self.track_paused.emit()
            print("⏸️ Paused from sidebar")
        else:
            print("▶️ Sidebar: Attempting to resume/play")
            self.audio_player.play()
            # is_playing will be set automatically by _on_playback_state_changed
            if self.currently_playing_button:
                try:
                    self.currently_playing_button.set_playing_state()
                except RuntimeError:
                    # Button was deleted, ignore
                    pass
            self.track_resumed.emit()
            print("🎵 Resumed from sidebar")
    
    def handle_sidebar_stop(self):
        """Handle stop request from sidebar media player"""
        self.audio_player.stop_playback()
        if self.currently_playing_button:
            try:
                self.currently_playing_button.reset_play_state()
            except RuntimeError:
                # Button was deleted, ignore
                pass
            self.currently_playing_button = None
        
        # Emit track stopped signal
        self.track_stopped.emit()
        
        # Clear Stream folder when stopping (release file since user explicitly stopped)
        self.clear_stream_folder(release_current_file=True)
        
        # Clear track state
        self.current_track_id = None
        self.current_track_result = None
        print("⏹️ Stopped from sidebar")
    
    def handle_sidebar_volume(self, volume):
        """Handle volume change from sidebar media player"""
        self.audio_player.audio_output.setVolume(volume)
        print(f"🔊 Volume set to {int(volume * 100)}% from sidebar")
    
    def clear_stream_folder(self, release_current_file=True):
        """Clear all files from the Stream folder to prevent playing wrong files
        
        Args:
            release_current_file (bool): Whether to release the current audio file handle.
                                       Set to False if you want to clear old files but keep current playback.
        """
        try:
            # Only release file handles if explicitly requested
            if release_current_file and hasattr(self, 'audio_player') and self.audio_player:
                self.audio_player.release_file()
                print("🔓 Released audio player file handle before clearing")
            
            project_root = os.path.dirname(os.path.dirname(os.path.dirname(__file__)))  # Go up from ui/pages/
            stream_folder = os.path.join(project_root, 'Stream')
            
            if os.path.exists(stream_folder):
                for filename in os.listdir(stream_folder):
                    file_path = os.path.join(stream_folder, filename)
                    if os.path.isfile(file_path):
                        try:
                            os.remove(file_path)
                            print(f"🗑️ Cleared old stream file: {filename}")
                        except Exception as e:
                            print(f"⚠️ Could not remove stream file {filename}: {e}")
                    
        except Exception as e:
            print(f"⚠️ Error clearing stream folder: {e}")
    
    def on_download_completed(self, message, download_item):
        """Handle successful download start (NOT completion)"""
        print(f"Download started: {message}")
        
        # Extract download ID from message if available
        if "Download started:" in message and download_item:
            # Message format is "Download started: <download_id>"
            download_id_part = message.replace("Download started:", "").strip()
            
            # Check if this looks like a UUID (real download ID) vs filename
            import re
            uuid_pattern = r'^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$'
            if re.match(uuid_pattern, download_id_part, re.IGNORECASE):
                download_item.download_id = download_id_part
                print(f"[DEBUG] Stored real download ID: {download_id_part}")
            else:
                print(f"[DEBUG] Using filename as download ID: {download_id_part}")
                download_item.download_id = download_id_part
        
        # Set status to downloading, not completed!
        download_item.status = "downloading"
        download_item.progress = 0
        
    def on_download_failed(self, error_msg, download_item):
        """Handle download failure"""
        print(f"Download failed: {error_msg}")
        # Update download item status to failed
        download_item.status = "failed"
        download_item.progress = 0
        
        # Emit activity signal for download failure
        self.download_activity.emit("❌", "Download Failed", f"'{download_item.title}' - {error_msg}", "Now")
        
        # Error logged to console for debugging
    
    def on_download_progress(self, message, download_item):
        """Handle download progress updates"""
        print(f"Download progress: {message}")
        # Extract progress percentage if available from message
        # For now just show as downloading
        download_item.status = "downloading"
    
    def on_download_thread_finished(self, thread):
        """Clean up when download thread finishes"""
        try:
            if thread in self.download_threads:
                self.download_threads.remove(thread)
            
            # Disconnect all signals to prevent stale connections
            try:
                thread.download_completed.disconnect()
                thread.download_failed.disconnect()
                thread.download_progress.disconnect()
                thread.finished.disconnect()
            except Exception:
                pass  # Ignore if signals are already disconnected
            
            # Ensure thread is properly stopped before deletion
            if thread.isRunning():
                thread.stop()
                thread.wait(1000)  # Wait up to 1 second
            
            # Use QTimer.singleShot for delayed cleanup to ensure signal processing is complete
            QTimer.singleShot(100, thread.deleteLater)
            
        except Exception as e:
            print(f"Error cleaning up finished download thread: {e}")
    
    def _run_async_operation(self, async_func, *args, success_callback=None, error_callback=None):
        """Helper method to run async operations safely with proper event loop management"""
        import asyncio
        import threading
        
        def run_operation():
            """Run the async operation in a separate thread with its own event loop"""
            try:
                # Create a fresh event loop for this thread
                loop = asyncio.new_event_loop()
                asyncio.set_event_loop(loop)
                
                # Run the async operation
                result = loop.run_until_complete(async_func(*args))
                
                # Schedule success callback on main thread if provided
                if success_callback:
                    QTimer.singleShot(0, lambda: success_callback(result))
                    
                return result
                
            except Exception as e:
                print(f"[ERROR] Exception in async operation: {e}")
                import traceback
                traceback.print_exc()
                
                # Schedule error callback on main thread if provided
                if error_callback:
                    # Capture the error in a closure to avoid lambda variable issues
                    def call_error_callback(error=e):
                        error_callback(error)
                    QTimer.singleShot(0, call_error_callback)
                    
                return False
                
            finally:
                # Always close the loop we created
                try:
                    loop.close()
                except Exception as close_e:
                    print(f"[WARNING] Error closing event loop: {close_e}")
        
        try:
            # Run the operation in a separate thread
            operation_thread = threading.Thread(target=run_operation, daemon=True)
            operation_thread.start()
            
        except Exception as e:
            print(f"[ERROR] Exception starting async operation thread: {e}")
            import traceback
            traceback.print_exc()

    def clear_completed_downloads(self):
        """Clear completed and cancelled downloads from both slskd backend and local queues"""
        print("[DEBUG] DownloadsPage.clear_completed_downloads() method called!")
        print(f"[DEBUG] Current download queue stats:")
        print(f"[DEBUG] - Active queue: {len(self.download_queue.active_queue.download_items)} items")
        print(f"[DEBUG] - Finished queue: {len(self.download_queue.finished_queue.download_items)} items")
        
        if not self.soulseek_client:
            print("[ERROR] No soulseek client available for clearing downloads")
            return
        
        # Run async clear operation using threading to avoid event loop conflicts
        import asyncio
        import threading
        
        # Define UI update callback outside the thread (with proper self reference)
        def update_ui_callback():
            """UI update callback that runs on main thread"""
            print("[DEBUG] *** UI CALLBACK EXECUTED *** - Starting UI clear operations...")
            try:
                # Step 1: Clear local queues
                print("[DEBUG] Step 1: Calling clear_local_queues_only()...")
                self.download_queue.clear_local_queues_only()
                print("[DEBUG] Step 1 completed successfully")
                
                # Step 2: Update download status
                print("[DEBUG] Step 2: Calling update_download_status()...")
                self.update_download_status()
                print("[DEBUG] Step 2 completed successfully")
                
                print("[DEBUG] *** UI CALLBACK COMPLETED *** - All UI clear operations finished")
            except Exception as e:
                print(f"[ERROR] Exception in UI callback: {e}")
                import traceback
                traceback.print_exc()
                # Even if there's an error, try to update the display
                try:
                    print("[DEBUG] Attempting fallback queue update...")
                    if hasattr(self, 'download_queue'):
                        self.download_queue.update_tab_counts()
                except Exception as fallback_e:
                    print(f"[ERROR] Fallback update also failed: {fallback_e}")
        
        def run_clear_operation():
            """Run the clear operation in a separate thread with its own event loop"""
            success = False
            try:
                # Create a fresh event loop for this thread
                loop = asyncio.new_event_loop()
                asyncio.set_event_loop(loop)
                
                print("[DEBUG] 🗑️ Clearing all completed/cancelled downloads from slskd backend...")
                success = loop.run_until_complete(self.soulseek_client.clear_all_completed_downloads())
                
                if success:
                    print("[DEBUG] ✅ Successfully cleared completed/cancelled downloads from backend")
                else:
                    print("[WARNING] ❌ Backend reported failure, but proceeding with UI clearing anyway")
                    print("[WARNING] (Web UI may have cleared successfully despite backend failure report)")
                    
            except Exception as e:
                print(f"[ERROR] Exception during clear completed downloads: {e}")
                import traceback
                traceback.print_exc()
            finally:
                # Always close the loop we created
                try:
                    loop.close()
                except Exception as close_e:
                    print(f"[WARNING] Error closing event loop: {close_e}")
                
                # CRITICAL: Use signal to communicate with main thread (thread-safe)
                print("[DEBUG] Thread completed, emitting completion signal...")
                self.clear_completed_finished.emit(success, update_ui_callback)
        
        try:
            # Run the clear operation in a separate thread
            clear_thread = threading.Thread(target=run_clear_operation, daemon=True)
            clear_thread.start()
            
        except Exception as e:
            print(f"[ERROR] Exception starting clear completed downloads thread: {e}")
            import traceback
            traceback.print_exc()

    def _handle_clear_completion(self, backend_success, ui_callback):
        """Handle completion of clear operation on main thread"""
        print(f"[DEBUG] _handle_clear_completion called on main thread - backend_success: {backend_success}")
        
        # ALWAYS clear UI regardless of backend success/failure
        # This ensures UI stays in sync even if backend reports false negatives
        print("[DEBUG] Executing UI callback on main thread...")
        try:
            ui_callback()
        except Exception as e:
            print(f"[ERROR] Exception executing UI callback: {e}")
            import traceback
            traceback.print_exc()
    
    def _handle_api_cleanup_completion(self, success, download_id, username):
        """Handle completion of API cleanup operation on main thread"""
        if success:
            print(f"✓ Successfully signaled completion for download {download_id}")
        else:
            print(f"⚠️ Failed to signal completion for download {download_id}")
    
    def _on_download_completion_finished(self, download_item, organized_path):
        """Handle successful completion of background download processing"""
        print(f"✅ Background processing completed for '{download_item.title}' -> {organized_path}")
        
        # Update the download item status and progress on main thread
        download_item.update_status(
            status='completed',
            progress=100,
            download_speed=0,
            file_path=organized_path
        )
        
        # Move completed items to finished queue on main thread
        print(f"[DEBUG] Moving completed download '{download_item.title}' to finished queue")
        self.download_queue.move_to_finished(download_item)
    
    def _on_download_completion_error(self, download_item, error_message):
        """Handle error in background download processing"""
        print(f"❌ Background processing failed for '{download_item.title}': {error_message}")
        
        # Still mark as completed but with original path, move to finished queue
        download_item.update_status(
            status='completed',
            progress=100,
            download_speed=0,
            file_path=download_item.file_path  # Keep original path on error
        )
        
        # Move to finished queue even on error
        print(f"[DEBUG] Moving download '{download_item.title}' to finished queue after error")
        self.download_queue.move_to_finished(download_item)
    
    def _update_adaptive_polling(self):
        """OPTIMIZATION v2: Update polling frequency based on download activity"""
        try:
            active_downloads = len([item for item in self.download_queue.download_items 
                                  if item.status.lower() in ['downloading', 'queued', 'initializing']])
            
            # Determine optimal polling mode
            new_mode = 'idle'
            if self._bulk_operation_active:
                new_mode = 'bulk_pause'
            elif active_downloads > 0:
                new_mode = 'active'
            
            # Update timer if mode changed
            if new_mode != self._current_polling_mode:
                new_interval = self._polling_intervals[new_mode]
                self.download_status_timer.setInterval(new_interval)
                self._current_polling_mode = new_mode
                
            self._last_active_count = active_downloads
            
        except Exception as e:
            pass  # Silent adaptive polling failures

    def update_download_status_v2(self):
        """OPTIMIZATION v2: Robust queue state management with thread safety"""
        if not self.soulseek_client:
            return
            
        # Use thread-safe access to download items
        download_items = self._queue_manager.get_download_items_copy()
        if not download_items:
            return
            
        # Update adaptive polling
        self._update_adaptive_polling()
        
        def handle_status_update_v2(transfers_data):
            """Enhanced status update handler with robust state management"""
            import time
            try:
                if not transfers_data:
                    return
                    
                # Flatten transfers data efficiently
                all_transfers = []
                for user_data in transfers_data:
                    if 'directories' in user_data:
                        for directory in user_data['directories']:
                            if 'files' in directory:
                                all_transfers.extend(directory['files'])
                
                
                # Use thread-safe operations throughout
                with self._queue_consistency_lock:
                    matched_transfer_ids = set()
                    
                    # Process each download item with improved matching
                    for download_item in download_items:
                        if download_item.status.lower() in ['completed', 'finished', 'cancelled', 'failed']:
                            continue
                            
                        # Enhanced ID-based matching
                        matching_transfer = self._find_matching_transfer_v2(
                            download_item, all_transfers, matched_transfer_ids
                        )
                        
                        if matching_transfer:
                            matched_transfer_ids.add(matching_transfer.get('id'))
                            self._process_transfer_match_v2(download_item, matching_transfer)
                        else:
                            self._handle_missing_transfer_v2(download_item)
                    
                    # Update UI counters
                    self.download_queue.update_tab_counts()
                    
                    # Enhanced logging: periodic queue health summary
                    if not hasattr(self, '_last_queue_summary_time'):
                        self._last_queue_summary_time = 0
                    if time.time() - self._last_queue_summary_time > 30:  # Every 30 seconds
                        self._log_queue_health_summary(download_items)
                        self._last_queue_summary_time = time.time()
                
            except Exception as e:
                print(f"[ERROR] Status update v2 failed: {e}")
                import traceback
                traceback.print_exc()
        
        # Create status thread with error handling
        try:
            status_thread = TransferStatusThread(self.soulseek_client)
            status_thread.transfer_status_completed.connect(handle_status_update_v2)
            status_thread.finished.connect(lambda: self._cleanup_status_thread_v2(status_thread))
            
            # Track threads for cleanup
            if not hasattr(self, '_active_status_threads_v2'):
                self._active_status_threads_v2 = set()
            self._active_status_threads_v2.add(status_thread)
            
            status_thread.start()
            
        except Exception as e:
            print(f"[ERROR] Failed to start status update thread v2: {e}")
    
    def _log_queue_health_summary(self, download_items):
        """Log periodic queue health summary for debugging stuck downloads"""
        import time
        
        try:
            if not download_items:
                return
                
            # Count downloads by status
            status_counts = {}
            stuck_downloads = []
            
            for item in download_items:
                status = item.status.lower()
                status_counts[status] = status_counts.get(status, 0) + 1
                
                # Check for potentially stuck downloads
                if hasattr(item, 'queue_start_time') and item.queue_start_time:
                    queue_age = time.time() - item.queue_start_time
                    if queue_age > 15:  # More than 15 seconds in queue
                        stuck_downloads.append((item.title, queue_age))
                
                # Check for items with high API missing counts
                if hasattr(item, 'api_missing_count_v2') and item.api_missing_count_v2 > 1:
                    stuck_downloads.append((item.title, f"API missing {item.api_missing_count_v2} cycles"))
            
            # Log summary
            print(f"📊 Queue Health: {status_counts}")
            if stuck_downloads:
                print(f"⚠️ Potentially stuck downloads: {len(stuck_downloads)}")
                for title, issue in stuck_downloads[:3]:  # Show first 3
                    if isinstance(issue, str):
                        print(f"   - {title}: {issue}")
                    else:
                        print(f"   - {title}: queued for {issue:.1f}s")
                        
        except Exception as e:
            pass  # Silent logging failures
    
    def _find_matching_transfer_v2(self, download_item, all_transfers, matched_ids):
        """Enhanced transfer matching with better ID tracking"""
        # Primary: ID-based matching
        if hasattr(download_item, 'download_id') and download_item.download_id:
            for transfer in all_transfers:
                transfer_id = transfer.get('id')
                if transfer_id == download_item.download_id and transfer_id not in matched_ids:
                    return transfer
        
        # Fallback: Enhanced filename matching (simplified for performance)
        for transfer in all_transfers:
            transfer_id = transfer.get('id')
            if transfer_id in matched_ids:
                continue
                
            filename = transfer.get('filename', '').lower()
            title = download_item.title.lower()
            
            # Quick contains check for performance
            if title in filename or any(word in filename for word in title.split() if len(word) > 3):
                return transfer
        
        return None
    
    def _process_transfer_match_v2(self, download_item, transfer):
        """Process matched transfer with atomic state updates and progressive timeout logic"""
        import time
        
        state = transfer.get('state', 'Unknown')
        progress = min(100, max(0, transfer.get('percentComplete', 0)))
        
        # Initialize queue tracking if needed
        if not hasattr(download_item, 'queue_start_time'):
            download_item.queue_start_time = None
        
        # Determine new status
        if 'Completed' in state or 'Succeeded' in state:
            new_status = 'completed'
            progress = 100
        elif 'Cancelled' in state or 'Canceled' in state:
            new_status = 'cancelled'
        elif 'Failed' in state or 'Errored' in state:
            new_status = 'failed'
        elif 'InProgress' in state:
            new_status = 'downloading'
        else:
            new_status = 'queued'
        
        # Track queue state transitions for progressive timeout
        if new_status in ['queued', 'initializing'] and download_item.queue_start_time is None:
            download_item.queue_start_time = time.time()
            print(f"🕐 Download entered queue: {download_item.title}")
        elif new_status in ['downloading', 'completed', 'cancelled', 'failed']:
            if download_item.queue_start_time:
                queue_duration = time.time() - download_item.queue_start_time
                print(f"⏱️ Download '{download_item.title}' was in queue for {queue_duration:.1f}s")
            download_item.queue_start_time = None  # Reset queue timer
        
        # Atomic status update
        self._queue_manager.atomic_state_transition(
            download_item, new_status,
            callback=lambda item, old, new: self._handle_status_change_v2(item, old, new, transfer)
        )
        
        # Update progress and metadata
        download_item.update_status(
            status=new_status,
            progress=int(progress),
            download_speed=int(transfer.get('averageSpeed', 0)),
            file_path=transfer.get('filename', download_item.file_path)
        )
        
        # Reset API missing count when transfer is found and add enhanced logging
        if hasattr(download_item, 'api_missing_count_v2') and download_item.api_missing_count_v2 > 0:
            print(f"✅ Download reconnected to API after {download_item.api_missing_count_v2} missing cycles: {download_item.title}")
            download_item.api_missing_count_v2 = 0
        
        # Update ID mapping if needed
        transfer_id = transfer.get('id')
        if transfer_id and (not hasattr(download_item, 'download_id') or download_item.download_id != transfer_id):
            self._queue_manager.update_id_mapping_safe(download_item, transfer_id)
    
    def _handle_status_change_v2(self, download_item, old_status, new_status, transfer):
        """Handle status change transitions"""
        if new_status in ['completed', 'cancelled', 'failed']:
            # Move to finished queue
            self.download_queue.move_to_finished(download_item)
            
            # Emit specific activity signal for failures
            if new_status == 'failed':
                self.download_activity.emit("❌", "Download Failed", f"'{download_item.title}' by {download_item.artist}", "Now")
            elif new_status == 'cancelled':
                self.download_activity.emit("⏹️", "Download Cancelled", f"'{download_item.title}' by {download_item.artist}", "Now")
            
            # Cleanup API if needed
            if new_status in ['cancelled', 'failed'] and hasattr(download_item, 'download_id'):
                self._schedule_api_cleanup_v2(download_item)
                
                # Schedule fallback cleanup check for errored downloads
                if new_status == 'failed':
                    self._schedule_fallback_cleanup_check()
    
    def _handle_missing_transfer_v2(self, download_item):
        """Handle downloads missing from API with improved grace period and queue age tracking"""
        import time
        
        # Initialize tracking attributes
        if not hasattr(download_item, 'api_missing_count_v2'):
            download_item.api_missing_count_v2 = 0
        if not hasattr(download_item, 'queue_start_time'):
            download_item.queue_start_time = None
        
        # Track when downloads first enter queued state
        current_status = download_item.status.lower()
        if current_status in ['queued', 'initializing'] and download_item.queue_start_time is None:
            download_item.queue_start_time = time.time()
            print(f"🕐 Started tracking queue time for: {download_item.title}")
        elif current_status not in ['queued', 'initializing']:
            download_item.queue_start_time = None  # Reset if no longer queued
        
        download_item.api_missing_count_v2 += 1
        
        # Enhanced timeout logic with queue age consideration
        queue_timeout_exceeded = False
        if download_item.queue_start_time:
            queue_age = time.time() - download_item.queue_start_time
            queue_timeout = 180.0  # 3 minutes max in queue
            if queue_age > queue_timeout:
                queue_timeout_exceeded = True
                print(f"⏰ Queue timeout exceeded: {download_item.title} stuck in queue for {queue_age:.1f}s")
        
        # Fail download if API missing for 3 cycles OR queue timeout exceeded
        if download_item.api_missing_count_v2 >= 3 or queue_timeout_exceeded:
            if queue_timeout_exceeded:
                print(f"⚠️ Download failed due to queue timeout: {download_item.title}")
            else:
                print(f"⚠️ Download missing from API for {download_item.api_missing_count_v2} cycles: {download_item.title}")
            self._queue_manager.atomic_state_transition(download_item, 'failed')
            self.download_queue.move_to_finished(download_item)
    
    def _schedule_api_cleanup_v2(self, download_item):
        """Schedule API cleanup with robust retry mechanism"""
        def cleanup_task_with_retry():
            import time
            import asyncio
            
            max_retries = 3
            retry_delays = [2, 5, 10]  # Progressive delays in seconds
            
            for attempt in range(max_retries):
                try:
                    if not (hasattr(download_item, 'download_id') and download_item.soulseek_client):
                        return
                    
                    # Wait before cleanup to let API stabilize
                    if attempt == 0:
                        time.sleep(1)  # Initial delay for API stabilization
                    else:
                        time.sleep(retry_delays[attempt - 1])
                    
                    loop = asyncio.new_event_loop()
                    asyncio.set_event_loop(loop)
                    
                    try:
                        success = loop.run_until_complete(
                            download_item.soulseek_client.cancel_download(
                                download_item.download_id, 
                                getattr(download_item, 'username', ''), 
                                remove=True
                            )
                        )
                        
                        if success:
                            return  # Success, exit retry loop
                        else:
                            if attempt == max_retries - 1:
                                print(f"❌ API cleanup failed after {max_retries} attempts: {download_item.title}")
                            
                    finally:
                        loop.close()
                        
                except Exception as e:
                    if attempt == max_retries - 1:
                        print(f"❌ API cleanup failed after {max_retries} attempts: {e}")
                    # Continue to next retry
                        
        self._optimized_api_pool.submit(cleanup_task_with_retry)
    
    def _schedule_fallback_cleanup_check(self):
        """Schedule a fallback cleanup check for persistent errored entries"""
        def fallback_cleanup_task():
            import time
            import asyncio
            
            # Wait longer before fallback cleanup
            time.sleep(30)  # 30 second delay
            
            try:
                if not self.soulseek_client:
                    return
                
                # Get current transfers to find persistent errored entries
                loop = asyncio.new_event_loop()
                asyncio.set_event_loop(loop)
                
                try:
                    transfers_data = loop.run_until_complete(
                        self.soulseek_client.get_all_downloads()
                    )
                    
                    if transfers_data:
                        # Find errored entries that should have been cleaned up
                        persistent_errors = []
                        for user_data in transfers_data:
                            if 'directories' in user_data:
                                for directory in user_data['directories']:
                                    if 'files' in directory:
                                        for transfer in directory['files']:
                                            state = transfer.get('state', '')
                                            if any(error_state in state for error_state in ['Failed', 'Errored', 'Cancelled']):
                                                persistent_errors.append(transfer)
                        
                        # Clean up persistent errors (max 5 at a time to be conservative)
                        for transfer in persistent_errors[:5]:
                            try:
                                success = loop.run_until_complete(
                                    self.soulseek_client.cancel_download(
                                        transfer.get('id'), 
                                        transfer.get('username', ''), 
                                        remove=True
                                    )
                                )
                                if success:
                                    print(f"✅ Fallback cleanup successful for persistent error")
                            except Exception as e:
                                pass  # Silent fallback failures
                                
                finally:
                    loop.close()
                    
            except Exception as e:
                pass  # Silent fallback failures
        
        # Schedule fallback cleanup
        self._optimized_api_pool.submit(fallback_cleanup_task)
    
    def _cleanup_status_thread_v2(self, thread):
        """Clean up status threads"""
        try:
            if hasattr(self, '_active_status_threads_v2') and thread in self._active_status_threads_v2:
                self._active_status_threads_v2.remove(thread)
            thread.deleteLater()
        except Exception as e:
            pass  # Silent thread cleanup failures

    def enable_optimized_systems(self):
        """Enable all v2 optimization systems"""
        self._use_optimized_systems = True
        print("✅ Enabled optimized download systems")
        
        # Switch to optimized timer callback
        self.download_status_timer.timeout.disconnect()
        self.download_status_timer.timeout.connect(self.update_download_status_v2)
        
        # Update timer interval for initial adaptive mode
        self.download_status_timer.setInterval(self._polling_intervals['active'])
    
    def disable_optimized_systems(self):
        """Disable v2 optimizations and revert to original behavior"""
        self._use_optimized_systems = False
        print("⚠️ Disabled optimizations, reverted to original system")
        
        # Revert to original timer callback
        self.download_status_timer.timeout.disconnect()
        self.download_status_timer.timeout.connect(self.update_download_status)
        self.download_status_timer.setInterval(1000)  # Back to 1 second

# In class DownloadsPage, REPLACE your old update_download_status method with this one.

    def update_download_status(self):
        """
        Starts the background worker to process download statuses without blocking the UI.
        This method is called by the QTimer.
        """
        if self._is_status_update_running or not self.soulseek_client:
            return # Don't start a new worker if one is already processing.

        # Check if there are any active downloads to process
        active_items = [item for item in self.download_queue.active_queue.download_items]
        if not active_items:
            self._is_status_update_running = False
            return

        self._is_status_update_running = True

        # Create and start the background worker
        worker = StatusProcessingWorker(
            soulseek_client=self.soulseek_client,
            download_items=active_items
        )

        # Connect signals from the worker to the main thread handler
        worker.signals.completed.connect(self._handle_processed_status_updates)
        worker.signals.error.connect(lambda e: print(f"Status Worker Error: {e}"))
        
        # The worker will automatically be cleaned up by the thread pool.
        self.status_processing_pool.start(worker)


    def _periodic_cleanup_check(self):
        """Check for completed downloads and clean them up intelligently"""
        if not self.soulseek_client:
            return
            
        try:
            # Clean up bulk downloads found in previous tick
            if self.downloads_to_cleanup:
                print(f"[CLEANUP] Bulk cleaning {len(self.downloads_to_cleanup)} completed downloads from backend")
                self._cleanup_backend_downloads(self.downloads_to_cleanup)
                self.downloads_to_cleanup.clear()
            
            # Clean up individual downloads found in previous tick (errored ones)
            if self.individual_downloads_to_cleanup:
                print(f"[CLEANUP] Individually cleaning {len(self.individual_downloads_to_cleanup)} errored downloads from backend")
                self._cleanup_individual_downloads(self.individual_downloads_to_cleanup)
                self.individual_downloads_to_cleanup.clear()
            
            # Find new completed downloads for next tick
            self._find_completed_downloads_for_cleanup()
            
        except Exception as e:
            print(f"[ERROR] Error in periodic cleanup: {e}")
    
    def _find_completed_downloads_for_cleanup(self):
        """Find downloads that need cleanup in the next tick"""
        try:
            # Get current downloads from backend
            async def check_backend_downloads():
                try:
                    result = await self.soulseek_client.get_all_downloads()
                    if result:
                        bulk_cleanup_states = {'Completed, Succeeded', 'Completed, Cancelled', 'Cancelled', 'Canceled'}
                        individual_cleanup_states = {'Completed, Errored', 'Failed', 'Errored'}
                        
                        new_bulk_cleanup = set()
                        new_individual_cleanup = []
                        
                        for download in result:
                            if download.state in bulk_cleanup_states:
                                # These can be cleared with bulk clear operation
                                download_key = f"{download.username}:{download.id}"
                                new_bulk_cleanup.add(download_key)
                            elif download.state in individual_cleanup_states:
                                # These need individual removal calls
                                download_info = {
                                    'username': download.username,
                                    'id': download.id,
                                    'state': download.state
                                }
                                new_individual_cleanup.append(download_info)
                        
                        if new_bulk_cleanup or new_individual_cleanup:
                            print(f"[CLEANUP] Found {len(new_bulk_cleanup)} bulk + {len(new_individual_cleanup)} individual downloads needing cleanup")
                            self.downloads_to_cleanup.update(new_bulk_cleanup)
                            if new_individual_cleanup:
                                # Store individual cleanup items separately
                                if not hasattr(self, 'individual_downloads_to_cleanup'):
                                    self.individual_downloads_to_cleanup = []
                                self.individual_downloads_to_cleanup.extend(new_individual_cleanup)
                except Exception as e:
                    print(f"[ERROR] Error checking backend downloads: {e}")
            
            # Run in background to avoid blocking UI
            def run_check():
                import asyncio
                try:
                    loop = asyncio.new_event_loop()
                    asyncio.set_event_loop(loop)
                    loop.run_until_complete(check_backend_downloads())
                finally:
                    try:
                        loop.close()
                    except Exception:
                        pass

            from concurrent.futures import ThreadPoolExecutor
            with ThreadPoolExecutor(max_workers=1) as executor:
                executor.submit(run_check)
                
        except Exception as e:
            print(f"[ERROR] Error finding downloads for cleanup: {e}")
    
    def _cleanup_backend_downloads(self, download_keys):
        """Clean up specific downloads from backend"""
        try:
            def do_cleanup():
                try:
                    # Use the existing clear all completed downloads method
                    # This is simpler and more reliable than individual cleanup
                    success = self.soulseek_client.clear_all_completed_downloads()
                    if success:
                        print(f"[CLEANUP] Successfully cleared completed downloads from backend")
                    else:
                        print(f"[CLEANUP] Failed to clear completed downloads from backend")
                except Exception as e:
                    print(f"[ERROR] Error during backend cleanup: {e}")
            
            # Run cleanup in background
            from concurrent.futures import ThreadPoolExecutor
            with ThreadPoolExecutor(max_workers=1) as executor:
                executor.submit(do_cleanup)
                
        except Exception as e:
            print(f"[ERROR] Error in cleanup backend downloads: {e}")
    
    def _cleanup_individual_downloads(self, download_infos):
        """Clean up specific errored downloads individually using cancel_download with remove=True"""
        try:
            def do_individual_cleanup():
                try:
                    import asyncio
                    
                    async def cleanup_downloads():
                        success_count = 0
                        for download_info in download_infos:
                            try:
                                username = download_info['username']
                                download_id = download_info['id']
                                state = download_info['state']
                                
                                print(f"[CLEANUP] Removing {state} download: {username}/{download_id}")
                                success = await self.soulseek_client.cancel_download(
                                    download_id=download_id, 
                                    username=username, 
                                    remove=True
                                )
                                
                                if success:
                                    success_count += 1
                                    print(f"[CLEANUP] ✅ Successfully removed {state} download: {username}/{download_id}")
                                else:
                                    print(f"[CLEANUP] ❌ Failed to remove {state} download: {username}/{download_id}")
                                    
                            except Exception as e:
                                print(f"[ERROR] Error removing individual download {download_info}: {e}")
                        
                        print(f"[CLEANUP] Individual cleanup completed: {success_count}/{len(download_infos)} removed")
                    
                    # Run the async cleanup
                    asyncio.run(cleanup_downloads())
                    
                except Exception as e:
                    print(f"[ERROR] Error during individual cleanup: {e}")
            
            # Run cleanup in background
            from concurrent.futures import ThreadPoolExecutor
            with ThreadPoolExecutor(max_workers=1) as executor:
                executor.submit(do_individual_cleanup)
                
        except Exception as e:
            print(f"[ERROR] Error in cleanup individual downloads: {e}")
    
    
    def cleanup_all_threads(self):
        """Stop and cleanup all active threads"""
        try:
            # Stop download status timer first
            if hasattr(self, 'download_status_timer'):
                self.download_status_timer.stop()
            
            # Stop search thread
            if self.search_thread and self.search_thread.isRunning():
                self.search_thread.stop()
                self.search_thread.wait(2000)  # Wait up to 2 seconds
                if self.search_thread.isRunning():
                    self.search_thread.terminate()
                    self.search_thread.wait(1000)
                self.search_thread.deleteLater()
                self.search_thread = None
            
            # Stop explore thread
            if self.explore_thread and self.explore_thread.isRunning():
                self.explore_thread.stop()
                self.explore_thread.wait(2000)  # Wait up to 2 seconds
                if self.explore_thread.isRunning():
                    self.explore_thread.terminate()
                    self.explore_thread.wait(1000)
                self.explore_thread.deleteLater()
                self.explore_thread = None
            
            # Stop session thread
            if self.session_thread and self.session_thread.isRunning():
                self.session_thread.stop()
                self.session_thread.wait(2000)  # Wait up to 2 seconds
                if self.session_thread.isRunning():
                    self.session_thread.terminate()
                    self.session_thread.wait(1000)
                self.session_thread.deleteLater()
                self.session_thread = None
            
            # CRITICAL FIX: Stop all status update threads
            for status_thread in self.status_update_threads[:]:  # Copy list to avoid modification during iteration
                try:
                    # Disconnect signals first
                    try:
                        status_thread.status_updated.disconnect()
                        status_thread.finished.disconnect()
                    except Exception:
                        pass  # Ignore if signals are already disconnected
                    
                    if status_thread.isRunning():
                        status_thread.stop()
                        status_thread.wait(2000)  # Wait up to 2 seconds
                        if status_thread.isRunning():
                            status_thread.terminate()
                            status_thread.wait(1000)
                    status_thread.deleteLater()
                except Exception as e:
                    print(f"Error cleaning up status update thread: {e}")
            
            self.status_update_threads.clear()
            
            # Stop all download threads with proper cleanup
            for download_thread in self.download_threads[:]:  # Copy list to avoid modification during iteration
                try:
                    # Disconnect signals first
                    try:
                        download_thread.download_completed.disconnect()
                        download_thread.download_failed.disconnect()
                        download_thread.download_progress.disconnect()
                        download_thread.finished.disconnect()
                    except Exception:
                        pass  # Ignore if signals are already disconnected
                    
                    if download_thread.isRunning():
                        download_thread.stop()
                        download_thread.wait(2000)  # Wait up to 2 seconds
                        if download_thread.isRunning():
                            download_thread.terminate()
                            download_thread.wait(1000)
                    download_thread.deleteLater()
                except Exception as e:
                    print(f"Error cleaning up download thread: {e}")
            
            self.download_threads.clear()
            
            # Stop all API cleanup threads
            for cleanup_thread in self.api_cleanup_threads[:]:  # Copy list to avoid modification during iteration
                try:
                    # Disconnect signals first
                    try:
                        cleanup_thread.cleanup_completed.disconnect()
                        cleanup_thread.finished.disconnect()
                    except Exception:
                        pass  # Ignore if signals are already disconnected
                    
                    if cleanup_thread.isRunning():
                        cleanup_thread.wait(2000)  # Wait up to 2 seconds for completion
                        if cleanup_thread.isRunning():
                            cleanup_thread.terminate()
                            cleanup_thread.wait(1000)
                    cleanup_thread.deleteLater()
                except Exception as e:
                    print(f"Error cleaning up API cleanup thread: {e}")
            
            self.api_cleanup_threads.clear()
            
        except Exception as e:
            print(f"Error during thread cleanup: {e}")
    
    def closeEvent(self, event):
        """Handle widget close event"""
        self.cleanup_all_threads()
        super().closeEvent(event)
    
    def __del__(self):
        """Destructor - ensure cleanup happens even if closeEvent isn't called"""
        try:
            self.cleanup_all_threads()
        except:
            pass  # Ignore errors during destruction
    
    def on_paths_updated(self, key: str, value: str):
        """Handle settings path updates for immediate effect"""
        # No action needed - paths are fetched dynamically via config_manager.get()
        # This method exists for future extensibility if caching is added later
        pass
    
    def create_controls_section(self):
        section = QWidget()
        layout = QVBoxLayout(section)
        layout.setSpacing(20)
        
        # Download controls
        controls_frame = QFrame()
        controls_frame.setStyleSheet("""
            QFrame {
                background: #282828;
                border-radius: 8px;
                border: 1px solid #404040;
            }
        """)
        
        controls_layout = QVBoxLayout(controls_frame)
        controls_layout.setContentsMargins(20, 20, 20, 20)
        controls_layout.setSpacing(15)
        
        # Controls title
        controls_title = QLabel("Download Controls")
        controls_title.setFont(QFont("Arial", 14, QFont.Weight.Bold))
        controls_title.setStyleSheet("color: #ffffff;")
        
        # Pause/Resume button
        pause_btn = QPushButton("⏸️ Pause Downloads")
        pause_btn.setFixedHeight(40)
        pause_btn.setStyleSheet("""
            QPushButton {
                background: #1db954;
                border: none;
                border-radius: 20px;
                color: #000000;
                font-size: 12px;
                font-weight: bold;
            }
            QPushButton:hover {
                background: #1ed760;
            }
        """)
        
        # Clear completed button
        clear_btn = QPushButton("🗑️ Clear Completed")
        clear_btn.setFixedHeight(35)
        clear_btn.clicked.connect(self.clear_completed_downloads)  # Connect to the clearing method
        clear_btn.setStyleSheet("""
            QPushButton {
                background: transparent;
                border: 1px solid #e22134;
                border-radius: 17px;
                color: #e22134;
                font-size: 11px;
                font-weight: bold;
            }
            QPushButton:hover {
                background: rgba(226, 33, 52, 0.1);
            }
        """)
        
        controls_layout.addWidget(controls_title)
        controls_layout.addWidget(pause_btn)
        controls_layout.addWidget(clear_btn)
        
        # Download stats
        stats_frame = QFrame()
        stats_frame.setStyleSheet("""
            QFrame {
                background: #282828;
                border-radius: 8px;
                border: 1px solid #404040;
            }
        """)
        
        stats_layout = QVBoxLayout(stats_frame)
        stats_layout.setContentsMargins(20, 20, 20, 20)
        stats_layout.setSpacing(15)
        
        # Stats title
        stats_title = QLabel("Download Statistics")
        stats_title.setFont(QFont("Arial", 14, QFont.Weight.Bold))
        stats_title.setStyleSheet("color: #ffffff;")
        
        # Stats items
        stats_items = [
            ("Total Downloads", "247"),
            ("Completed", "238"),
            ("Failed", "4"),
            ("In Progress", "2"),
            ("Queued", "3")
        ]
        
        stats_layout.addWidget(stats_title)
        
        for label, value in stats_items:
            item_layout = QHBoxLayout()
            
            label_widget = QLabel(label)
            label_widget.setFont(QFont("Arial", 11))
            label_widget.setStyleSheet("color: #b3b3b3;")
            
            value_widget = QLabel(value)
            value_widget.setFont(QFont("Arial", 11, QFont.Weight.Bold))
            value_widget.setStyleSheet("color: #ffffff;")
            
            item_layout.addWidget(label_widget)
            item_layout.addStretch()
            item_layout.addWidget(value_widget)
            
            stats_layout.addLayout(item_layout)
        
        layout.addWidget(controls_frame)
        layout.addWidget(stats_frame)
        layout.addStretch()
        
        return section
    
    def create_missing_tracks_section(self):
        section = QFrame()
        section.setFixedHeight(250)
        section.setStyleSheet("""
            QFrame {
                background: #282828;
                border-radius: 8px;
                border: 1px solid #404040;
            }
        """)
        
        layout = QVBoxLayout(section)
        layout.setContentsMargins(20, 20, 20, 20)
        layout.setSpacing(15)
        
        # Header
        header_layout = QHBoxLayout()
        
        title_label = QLabel("Missing Tracks")
        title_label.setFont(QFont("Arial", 16, QFont.Weight.Bold))
        title_label.setStyleSheet("color: #ffffff;")
        
        count_label = QLabel("23 tracks")
        count_label.setFont(QFont("Arial", 11))
        count_label.setStyleSheet("color: #b3b3b3;")
        
        download_all_btn = QPushButton("📥 Download All")
        download_all_btn.setFixedSize(150, 35)
        download_all_btn.setStyleSheet("""
            QPushButton {
                background: #1db954;
                border: none;
                border-radius: 17px;
                color: #000000;
                font-size: 11px;
                font-weight: bold;
            }
            QPushButton:hover {
                background: #1ed760;
            }
        """)
        
        header_layout.addWidget(title_label)
        header_layout.addWidget(count_label)
        header_layout.addStretch()
        header_layout.addWidget(download_all_btn)
        
        # Missing tracks scroll area
        missing_scroll = QScrollArea()
        missing_scroll.setWidgetResizable(True)
        missing_scroll.setStyleSheet("""
            QScrollArea {
                border: none;
                background: transparent;
            }
            QScrollBar:vertical {
                background: #404040;
                width: 6px;
                border-radius: 3px;
            }
            QScrollBar::handle:vertical {
                background: #1db954;
                border-radius: 3px;
            }
        """)
        
        missing_widget = QWidget()
        missing_layout = QVBoxLayout(missing_widget)
        missing_layout.setSpacing(8)
        missing_layout.setContentsMargins(0, 0, 0, 0)
        
        # Sample missing tracks with playlist info
        missing_tracks = [
            ("Song Title 1", "Artist Name 1", "Liked Songs"),
            ("Another Track", "Different Artist", "Road Trip Mix"),
            ("Cool Song", "Band Name", "Workout Playlist"),
            ("Missing Hit", "Popular Artist", "Discover Weekly"),
            ("Rare Track", "Indie Artist", "Chill Vibes")
        ]
        
        for track_title, artist, playlist in missing_tracks:
            track_item = self.create_missing_track_item(track_title, artist, playlist)
            missing_layout.addWidget(track_item)
        
        missing_layout.addStretch()
        missing_scroll.setWidget(missing_widget)
        
        layout.addLayout(header_layout)
        layout.addWidget(missing_scroll)
        
        return section
    
    def create_missing_track_item(self, track_title: str, artist: str, playlist: str):
        item = QFrame()
        item.setFixedHeight(45)
        item.setStyleSheet("""
            QFrame {
                background: #333333;
                border-radius: 6px;
                border: 1px solid #404040;
            }
            QFrame:hover {
                background: #3a3a3a;
                border: 1px solid #1db954;
            }
        """)
        
        layout = QHBoxLayout(item)
        layout.setContentsMargins(12, 8, 12, 8)
        layout.setSpacing(10)
        
        # Track info
        info_layout = QVBoxLayout()
        info_layout.setSpacing(2)
        
        track_label = QLabel(f"{track_title} - {artist}")
        track_label.setFont(QFont("Arial", 10, QFont.Weight.Medium))
        track_label.setStyleSheet("color: #ffffff;")
        
        playlist_label = QLabel(f"from: {playlist}")
        playlist_label.setFont(QFont("Arial", 9))
        playlist_label.setStyleSheet("color: #1db954;")
        
        info_layout.addWidget(track_label)
        info_layout.addWidget(playlist_label)
        
        # Download button
        download_btn = QPushButton("📥")
        download_btn.setFixedSize(30, 30)
        download_btn.setStyleSheet("""
            QPushButton {
                background: rgba(29, 185, 84, 0.2);
                border: 1px solid #1db954;
                border-radius: 15px;
                color: #1db954;
                font-size: 12px;
            }
            QPushButton:hover {
                background: #1db954;
                color: #000000;
            }
        """)
        
        layout.addLayout(info_layout)
        layout.addStretch()
        layout.addWidget(download_btn)
        
        return item
    
    def _extract_track_number_from_filename(self, filename: str, title: str = None) -> Optional[int]:
        """Extract track number from filename or title"""
        try:
            import re
            import os
            
            # Try extracting from title first if available
            if title:
                patterns = [
                    r'^(\d{1,2})[\.\s\-_]+',  # "01. " or "01 " or "01-" or "01_"
                    r'^(\d{1,2})\s*[\.\-_]\s*',  # "01." or "01-" or "01_" with optional spaces
                    r'^(\d{1,2})\s+',  # "01 " (space only)
                    r'^(\d{1,2})[\)\]\}]\s*',  # "01) " or "01] " or "01} "
                    r'^\[(\d{1,2})\]',  # "[01]" bracket format
                    r'^\((\d{1,2})\)',  # "(01)" parenthesis format
                ]
                
                for pattern in patterns:
                    match = re.match(pattern, title.strip())
                    if match:
                        track_num = int(match.group(1))
                        print(f"    🎵 Found track number in title '{title}': {track_num}")
                        return track_num
            
            # Try extracting from filename
            base_name = os.path.splitext(filename)[0]  # Remove extension
            
            patterns = [
                r'^(\d{1,2})[\.\s\-_]+',  # "01. " or "01 " or "01-" or "01_"
                r'^(\d{1,2})\s*[\.\-_]\s*',  # "01." or "01-" or "01_" with optional spaces
                r'^(\d{1,2})\s+',  # "01 " (space only)
                r'^(\d{1,2})[\)\]\}]\s*',  # "01) " or "01] " or "01} "
                r'^\[(\d{1,2})\]',  # "[01]" bracket format
                r'^\((\d{1,2})\)',  # "(01)" parenthesis format
                r'^Track\s*(\d{1,2})',  # "Track 01" or "Track01"
                r'^T(\d{1,2})',  # "T01" format
            ]
            
            for pattern in patterns:
                match = re.match(pattern, base_name.strip())
                if match:
                    track_num = int(match.group(1))
                    print(f"    🎵 Found track number in filename '{filename}': {track_num}")
                    return track_num
            
            print(f"    ❌ No track number found in filename: '{filename}'")
            return None
            
        except Exception as e:
            print(f"❌ Error extracting track number from filename: {e}")
            return None
    
    def _get_spotify_album_tracks(self, selected_album: Album) -> List[dict]:
        """Fetch all tracks from the selected Spotify album"""
        try:
            print(f"🎵 Fetching tracks from Spotify album: {selected_album.name}")
            tracks_data = self.spotify_client.get_album_tracks(selected_album.id)
            
            if tracks_data and 'items' in tracks_data:
                tracks = []
                for track_data in tracks_data['items']:
                    tracks.append({
                        'name': track_data['name'],
                        'track_number': track_data['track_number'],
                        'duration_ms': track_data['duration_ms'],
                        'id': track_data['id']
                    })
                print(f"✅ Found {len(tracks)} tracks in Spotify album")
                return tracks
            else:
                print(f"❌ No tracks found in Spotify album")
                return []
                
        except Exception as e:
            print(f"❌ Error fetching Spotify album tracks: {e}")
            return []
    
    def _match_track_to_spotify_title(self, track, spotify_tracks: List[dict]) -> Optional[str]:
        """Match a downloaded track to a Spotify track title using similarity scoring"""
        try:
            if not spotify_tracks:
                return None
            
            original_title = track.title
            print(f"🔍 Matching track: '{original_title}'")
            
            # Clean the original title by removing track number prefixes
            import re
            cleaned_original = original_title
            track_num_match = re.match(r'^(\d+)\s*[\.\-_]\s*(.+)', cleaned_original.strip())
            if track_num_match:
                cleaned_original = track_num_match.group(2).strip()
                print(f"   🧹 Cleaned title (removed track number): '{cleaned_original}'")
            
            best_match = None
            best_score = 0.0
            
            # Try matching by track number first (most reliable)
            if hasattr(track, 'track_number') and track.track_number:
                for spotify_track in spotify_tracks:
                    if spotify_track['track_number'] == track.track_number:
                        print(f"✅ Matched by track number {track.track_number}: '{spotify_track['name']}'")
                        return spotify_track['name']
            
            # Fallback to title similarity matching using cleaned titles
            for spotify_track in spotify_tracks:
                # Normalize both titles for comparison (use cleaned original)
                normalized_original = self.matching_engine.normalize_string(cleaned_original)
                normalized_spotify = self.matching_engine.normalize_string(spotify_track['name'])
                
                print(f"   📊 Comparing: '{normalized_original}' vs '{normalized_spotify}'")
                
                # Calculate similarity score
                score = self.matching_engine.similarity_score(normalized_original, normalized_spotify)
                
                if score > best_score:
                    best_score = score
                    best_match = spotify_track
                    print(f"   ⬆️ New best match ({score:.2f}): '{spotify_track['name']}'")
            
            # Only return match if confidence is high enough
            if best_match and best_score >= 0.6:  # 60% similarity threshold
                print(f"✅ Matched by title similarity ({best_score:.2f}): '{best_match['name']}'")
                return best_match['name']
            else:
                print(f"❌ No good title match found (best score: {best_score:.2f})")
                return None
                
        except Exception as e:
            print(f"❌ Error matching track to Spotify title: {e}")
            return None

    # In downloads.py, add this new method inside the DownloadsPage class (e.g., after load_more_results)

    def _load_next_result_item(self):
        """
        Processes one item from the loading queue and schedules the next.
        This breaks up the work into small, non-blocking chunks.
        """
        if not self._results_to_load_queue:
            self.is_loading_more = False
            return

        # Pop one result from the front of the queue
        result = self._results_to_load_queue.pop(0)
        
        # Create the appropriate widget for the result
        if isinstance(result, AlbumResult):
            result_item = AlbumResultItem(result)
            result_item.album_download_requested.connect(self.start_album_download)
            result_item.matched_album_download_requested.connect(self.start_matched_album_download)
            result_item.track_download_requested.connect(self.start_download)
            result_item.track_stream_requested.connect(lambda r, i=result_item: self.start_stream(r, i))
        else:
            result_item = SearchResultItem(result)
            result_item.download_requested.connect(self.start_download)
            result_item.stream_requested.connect(lambda r, i=result_item: self.start_stream(r, i))
            result_item.expansion_requested.connect(self.handle_expansion_request)
        
        # Insert the newly created widget into the layout
        insert_position = self.search_results_layout.count() - 1
        self.search_results_layout.insertWidget(insert_position, result_item)
        self.displayed_results += 1

        # If there are more items in the queue, schedule the next one immediately
        if self._results_to_load_queue:
            QTimer.singleShot(0, self._load_next_result_item)
        else:
            # All items for this batch are loaded
            self.is_loading_more = False
            # Update the status message now that loading is complete
            total_filtered = len(self.current_filtered_results)
            if self.displayed_results < total_filtered:
                remaining = total_filtered - self.displayed_results
                self.update_search_status(f"✨ Showing {self.displayed_results} of {total_filtered} results (scroll for {remaining} more)", "#1db954")
            else:
                self.update_search_status(f"✨ Showing all {total_filtered} results", "#1db954")

    # In class DownloadsPage, add this new method

    def _handle_processed_status_updates(self, results):
        """
        This runs on the main thread and applies updates from the background worker.
        It crucially updates download_id and username before moving items to ensure
        API cleanup works correctly.
        """
        # Create a lookup for active items by their memory ID for fast access
        items_by_id = {id(item): item for item in self.download_queue.active_queue.download_items}

        items_to_move = []

        # Batch UI updates to prevent multiple repaints
        self.download_queue.setUpdatesEnabled(False)

        for result in results:
            download_item = items_by_id.get(result['widget_id'])
            if not download_item:
                continue

            # **THE CRITICAL FIX IS HERE:**
            # Update the item with the real transfer ID and username from the API.
            # This ensures that when move_to_finished is called, it has the correct data for API cleanup.
            if result.get('transfer_id'):
                download_item.download_id = result['transfer_id']
            if result.get('username'):
                download_item.username = result['username']

            # Update the item's visual status
            download_item.update_status(
                status=result['status'],
                progress=result['progress'],
                download_speed=result['speed'],
                file_path=result['path']
            )
            
            action = result.get('action')
            new_status = result['status']

            if new_status == 'completed' and action == 'process_matched_completion':
                # This is a matched download that just finished.
                if download_item.mark_completion_processed():
                    worker = DownloadCompletionWorker(
                        download_item=download_item,
                        absolute_file_path=result['path'],
                        organize_func=self._organize_matched_download
                    )
                    worker.signals.completed.connect(self._on_download_completion_finished)
                    worker.signals.error.connect(self._on_download_completion_error)
                    self.completion_thread_pool.start(worker)

            elif new_status in ['completed', 'failed', 'cancelled']:
                # For regular completed items or any failed/cancelled item.
                if download_item not in items_to_move:
                    items_to_move.append(download_item)
        
        # Now, move all the items that need moving in one go
        for item in items_to_move:
            self.download_queue.move_to_finished(item)

        # Re-enable UI updates and trigger a single repaint
        self.download_queue.setUpdatesEnabled(True)
        self.download_queue.update()
        self.download_queue.update_tab_counts()

        # Allow the next worker to run
        self._is_status_update_running = False    

    # =====================================
    # METADATA ENHANCEMENT SYSTEM
    # =====================================
    
    def _enhance_file_metadata(self, file_path: str, download_item, artist: Artist, album_info: dict) -> bool:
        """
        Core function to enhance audio file metadata using Spotify data
        
        Args:
            file_path: Path to the audio file in Transfer folder
            download_item: Original search result with attached Spotify metadata
            artist: Matched Spotify Artist object  
            album_info: Album detection results with track numbering
            
        Returns:
            bool: Success/failure of metadata enhancement
        """
        try:
            # Check if metadata enhancement is enabled
            if not config_manager.get('metadata_enhancement.enabled', True):
                print("🎵 Metadata enhancement disabled in config")
                return True
                
            print(f"🎵 Enhancing metadata for: {os.path.basename(file_path)}")
            
            # Load the audio file
            audio_file = MutagenFile(file_path)
            if audio_file is None:
                print(f"❌ Could not load audio file with Mutagen: {file_path}")
                return False
                
            # Extract comprehensive metadata from Spotify
            metadata = self._extract_spotify_metadata(download_item, artist, album_info)
            if not metadata:
                print(f"⚠️ Could not extract Spotify metadata, preserving original tags")
                return True
                
            # Determine file format and apply appropriate tags
            file_format = self._detect_audio_format(file_path, audio_file)
            success = False
            
            if file_format == 'mp3':
                print(f"🎵 Applying ID3 tags for {file_path}")
                success = self._apply_id3_tags(audio_file, metadata, file_path)
            elif file_format == 'flac':
                print(f"🎵 Applying FLAC tags for {file_path}")
                success = self._apply_flac_tags(audio_file, metadata, file_path)
            elif file_format in ['mp4', 'm4a']:
                print(f"🎵 Applying MP4 tags for {file_path}")
                success = self._apply_mp4_tags(audio_file, metadata, file_path)
            elif file_format == 'ogg':
                print(f"🎵 Applying OGG tags for {file_path}")
                success = self._apply_ogg_tags(audio_file, metadata, file_path)
            else:
                print(f"⚠️ Unsupported audio format for metadata enhancement: {file_format}")
                return True
                
            if success:
                # Optionally embed album art
                if config_manager.get('metadata_enhancement.embed_album_art', True):
                    self._embed_album_art_metadata(file_path, audio_file, metadata, file_format)
                    
                print(f"✅ Metadata enhanced with Spotify data")
                return True
            else:
                print(f"⚠️ Metadata enhancement failed, original tags preserved")
                return False
                
        except Exception as e:
            print(f"❌ Error enhancing metadata for {file_path}: {e}")
            return False
    
    def _extract_spotify_metadata(self, download_item, artist: Artist, album_info: dict) -> dict:
        """
        Extract comprehensive metadata from Spotify objects
        
        Returns complete metadata dictionary with:
        - Basic tags (title, artist, album, year, track#)
        - Advanced tags (genres, album artist, total tracks)
        - Plex-specific optimizations
        - Album art URL for embedding
        - Spotify IDs for future enhancements
        """
        try:
            metadata = {}
            
            # Debug: Log what we're working with
            print(f"🔍 Extracting metadata for: {download_item.title}")
            print(f"   - Artist: {artist.name if artist else 'None'}")
            print(f"   - Album info: {album_info}")
            print(f"   - Has _spotify_clean_title: {hasattr(download_item, '_spotify_clean_title')}")
            print(f"   - Has matched_album: {hasattr(download_item, 'matched_album')}")
            
            if not artist:
                print(f"❌ No artist provided for metadata extraction")
                return {}
            
            # Basic track information
            metadata['title'] = getattr(download_item, '_spotify_clean_title', download_item.title)
            metadata['artist'] = artist.name
            metadata['album_artist'] = artist.name  # Critical for Plex
            
            # Album information
            if album_info and album_info.get('is_album'):
                metadata['album'] = album_info.get('album_name', 'Unknown Album')
                metadata['track_number'] = album_info.get('track_number', 1)
                metadata['total_tracks'] = album_info.get('total_tracks', 1)
                if album_info.get('disc_number'):
                    metadata['disc_number'] = album_info['disc_number']
            else:
                # Single track
                metadata['album'] = metadata['title']  # For singles, album = title
                metadata['track_number'] = 1
                metadata['total_tracks'] = 1
            
            # Release date
            if hasattr(download_item, 'matched_album') and download_item.matched_album:
                if hasattr(download_item.matched_album, 'release_date'):
                    metadata['date'] = download_item.matched_album.release_date[:4] if download_item.matched_album.release_date else None
            
            # Genre information from artist
            if hasattr(artist, 'genres') and artist.genres:
                # Use first genre or combine multiple
                if len(artist.genres) == 1:
                    metadata['genre'] = artist.genres[0]
                else:
                    # Combine up to 3 genres
                    metadata['genre'] = ', '.join(artist.genres[:3])
            
            # Album art URL
            if hasattr(download_item, 'matched_album') and download_item.matched_album:
                if hasattr(download_item.matched_album, 'image_url') and download_item.matched_album.image_url:
                    metadata['album_art_url'] = download_item.matched_album.image_url
            
            # Spotify IDs for future enhancements
            metadata['spotify_artist_id'] = artist.id if hasattr(artist, 'id') else None
            if hasattr(download_item, 'matched_album') and download_item.matched_album:
                metadata['spotify_album_id'] = getattr(download_item.matched_album, 'id', None)
            
            print(f"🎯 Extracted metadata summary:")
            print(f"   - Title: {metadata.get('title')}")
            print(f"   - Artist: {metadata.get('artist')}")
            print(f"   - Album: {metadata.get('album')}")
            print(f"   - Track #: {metadata.get('track_number')}")
            print(f"   - Date: {metadata.get('date')}")
            print(f"   - Genre: {metadata.get('genre')}")
            print(f"   - Album art: {'Yes' if metadata.get('album_art_url') else 'No'}")
            print(f"   - Total fields: {len(metadata)}")
            
            # Special debugging for problematic tracks
            if metadata.get('title') == 'Tell Me What You Want' or metadata.get('track_number') == 13:
                print(f"🔍 [DEBUG] Special track detected - Tell Me What You Want:")
                print(f"   - Full metadata dict: {metadata}")
                print(f"   - Album info dict: {album_info}")
                print(f"   - Artist object: {artist}")
                if hasattr(download_item, 'matched_album'):
                    print(f"   - matched_album: {download_item.matched_album}")
                else:
                    print(f"   - No matched_album attribute")
            
            return metadata
            
        except Exception as e:
            print(f"❌ Error extracting Spotify metadata: {e}")
            import traceback
            traceback.print_exc()
            return {}
    
    def _detect_audio_format(self, file_path: str, audio_file) -> str:
        """Detect the audio format for appropriate tag handling"""
        try:
            file_ext = os.path.splitext(file_path)[1].lower()
            
            # Direct extension mapping
            format_map = {
                '.mp3': 'mp3',
                '.flac': 'flac', 
                '.m4a': 'm4a',
                '.mp4': 'mp4',
                '.ogg': 'ogg',
                '.oga': 'ogg'
            }
            
            if file_ext in format_map:
                return format_map[file_ext]
                
            # Fallback to mutagen detection
            if hasattr(audio_file, 'mime'):
                mime_type = audio_file.mime[0] if audio_file.mime else ''
                if 'mp3' in mime_type or 'mpeg' in mime_type:
                    return 'mp3'
                elif 'flac' in mime_type:
                    return 'flac'
                elif 'mp4' in mime_type or 'm4a' in mime_type:
                    return 'mp4'
                elif 'ogg' in mime_type:
                    return 'ogg'
            
            return 'unknown'
            
        except Exception as e:
            print(f"⚠️ Could not detect audio format: {e}")
            return 'unknown'
    
    def _apply_id3_tags(self, audio_file, metadata: dict, file_path: str) -> bool:
        """Handle MP3 ID3v2.4 tags with full Unicode support"""
        try:
            # Ensure ID3 tags exist
            if not hasattr(audio_file, 'tags') or audio_file.tags is None:
                audio_file.add_tags()
            
            tags = audio_file.tags
            
            # Basic tags
            tags.setall('TIT2', [TIT2(encoding=3, text=metadata.get('title', ''))])  # Title
            tags.setall('TPE1', [TPE1(encoding=3, text=metadata.get('artist', ''))])  # Artist
            tags.setall('TPE2', [TPE2(encoding=3, text=metadata.get('album_artist', ''))])  # Album Artist
            tags.setall('TALB', [TALB(encoding=3, text=metadata.get('album', ''))])  # Album
            
            # Date
            if metadata.get('date'):
                tags.setall('TDRC', [TDRC(encoding=3, text=metadata['date'])])
            
            # Track number
            track_text = f"{metadata.get('track_number', 1)}/{metadata.get('total_tracks', 1)}"
            tags.setall('TRCK', [TRCK(encoding=3, text=track_text)])
            
            # Genre
            if metadata.get('genre'):
                tags.setall('TCON', [TCON(encoding=3, text=metadata['genre'])])
            
            # Disc number
            if metadata.get('disc_number'):
                tags.setall('TPOS', [TPOS(encoding=3, text=str(metadata['disc_number']))])
            
            # Spotify IDs for future reference
            if metadata.get('spotify_artist_id'):
                tags.setall('TXXX:Spotify Artist ID', [TXXX(encoding=3, desc='Spotify Artist ID', text=metadata['spotify_artist_id'])])
            if metadata.get('spotify_album_id'):
                tags.setall('TXXX:Spotify Album ID', [TXXX(encoding=3, desc='Spotify Album ID', text=metadata['spotify_album_id'])])
            
           
            
            audio_file.save()
            return True
            
        except Exception as e:
            print(f"❌ Error applying ID3 tags: {e}")
            return False
    
    def _apply_flac_tags(self, audio_file, metadata: dict, file_path: str) -> bool:
        """Handle FLAC Vorbis comments for lossless files"""
        try:
            print(f"🎵 Applying FLAC tags with {len(metadata)} metadata fields")
            
            # Read existing tags first to preserve non-empty values
            existing_title = audio_file.get('TITLE', [''])[0] if audio_file.get('TITLE') else ''
            existing_artist = audio_file.get('ARTIST', [''])[0] if audio_file.get('ARTIST') else ''
            existing_album = audio_file.get('ALBUM', [''])[0] if audio_file.get('ALBUM') else ''
            existing_date = audio_file.get('DATE', [''])[0] if audio_file.get('DATE') else ''
            existing_genre = audio_file.get('GENRE', [''])[0] if audio_file.get('GENRE') else ''
            
            print(f"   - Existing tags: Title='{existing_title}', Artist='{existing_artist}', Album='{existing_album}'")
            
            # Only update if we have non-empty Spotify data OR if existing tag is empty
            if metadata.get('title') and metadata.get('title').strip():
                audio_file['TITLE'] = metadata['title']
                print(f"   - Updated TITLE: '{existing_title}' → '{metadata['title']}'")
            elif existing_title:
                print(f"   - Preserving existing TITLE: '{existing_title}' (Spotify data empty)")
            
            if metadata.get('artist') and metadata.get('artist').strip():
                audio_file['ARTIST'] = metadata['artist']
                print(f"   - Updated ARTIST: '{existing_artist}' → '{metadata['artist']}'")
            elif existing_artist:
                print(f"   - Preserving existing ARTIST: '{existing_artist}' (Spotify data empty)")
            
            if metadata.get('album_artist') and metadata.get('album_artist').strip():
                audio_file['ALBUMARTIST'] = metadata['album_artist']
            elif not audio_file.get('ALBUMARTIST'):
                audio_file['ALBUMARTIST'] = metadata.get('album_artist', '')
            
            if metadata.get('album') and metadata.get('album').strip():
                audio_file['ALBUM'] = metadata['album']
                print(f"   - Updated ALBUM: '{existing_album}' → '{metadata['album']}'")
            elif existing_album:
                print(f"   - Preserving existing ALBUM: '{existing_album}' (Spotify data empty)")
            
            # Date - only update if we have a date and existing is empty OR we have better data
            if metadata.get('date') and metadata.get('date').strip():
                audio_file['DATE'] = metadata['date']
                print(f"   - Updated DATE: '{existing_date}' → '{metadata['date']}'")
            elif existing_date:
                print(f"   - Preserving existing DATE: '{existing_date}' (Spotify data empty)")
            
            # Track number - always update since this comes from album detection
            audio_file['TRACKNUMBER'] = str(metadata.get('track_number', 1))
            audio_file['TRACKTOTAL'] = str(metadata.get('total_tracks', 1))
            
            # Genre - only update if we have genre data and existing is empty OR we have better data
            if metadata.get('genre') and metadata.get('genre').strip():
                audio_file['GENRE'] = metadata['genre']
                print(f"   - Updated GENRE: '{existing_genre}' → '{metadata['genre']}'")
            elif existing_genre:
                print(f"   - Preserving existing GENRE: '{existing_genre}' (Spotify data empty)")
            
            # Disc number
            if metadata.get('disc_number'):
                audio_file['DISCNUMBER'] = str(metadata['disc_number'])
            
            # Spotify IDs
            if metadata.get('spotify_artist_id'):
                audio_file['SPOTIFY_ARTIST_ID'] = metadata['spotify_artist_id']
            if metadata.get('spotify_album_id'):
                audio_file['SPOTIFY_ALBUM_ID'] = metadata['spotify_album_id']
            
            
            print(f"   - Saving FLAC file with enhanced metadata...")
            audio_file.save()
            print(f"   - ✅ FLAC tags saved successfully")
            return True
            
        except Exception as e:
            print(f"❌ Error applying FLAC tags: {e}")
            import traceback
            traceback.print_exc()
            return False
    
    def _apply_mp4_tags(self, audio_file, metadata: dict, file_path: str) -> bool:
        """Handle MP4/M4A iTunes-style tags"""
        try:
            # Basic tags
            audio_file['\xa9nam'] = [metadata.get('title', '')]  # Title
            audio_file['\xa9ART'] = [metadata.get('artist', '')]  # Artist
            audio_file['aART'] = [metadata.get('album_artist', '')]  # Album Artist
            audio_file['\xa9alb'] = [metadata.get('album', '')]  # Album
            
            # Date
            if metadata.get('date'):
                audio_file['\xa9day'] = [metadata['date']]
            
            # Track number
            track_num = metadata.get('track_number', 1)
            total_tracks = metadata.get('total_tracks', 1)
            audio_file['trkn'] = [(track_num, total_tracks)]
            
            # Genre
            if metadata.get('genre'):
                audio_file['\xa9gen'] = [metadata['genre']]
            
            # Disc number
            if metadata.get('disc_number'):
                audio_file['disk'] = [(metadata['disc_number'], 0)]
            
            # Spotify IDs (using custom tags)
            if metadata.get('spotify_artist_id'):
                audio_file['----:com.apple.iTunes:Spotify Artist ID'] = [metadata['spotify_artist_id'].encode('utf-8')]
            if metadata.get('spotify_album_id'):
                audio_file['----:com.apple.iTunes:Spotify Album ID'] = [metadata['spotify_album_id'].encode('utf-8')]
            
            
            
            audio_file.save()
            return True
            
        except Exception as e:
            print(f"❌ Error applying MP4 tags: {e}")
            return False
    
    def _apply_ogg_tags(self, audio_file, metadata: dict, file_path: str) -> bool:
        """Handle OGG Vorbis comments"""
        try:
            # Basic tags
            audio_file['TITLE'] = metadata.get('title', '')
            audio_file['ARTIST'] = metadata.get('artist', '')
            audio_file['ALBUMARTIST'] = metadata.get('album_artist', '')
            audio_file['ALBUM'] = metadata.get('album', '')
            
            # Date
            if metadata.get('date'):
                audio_file['DATE'] = metadata['date']
            
            # Track number
            audio_file['TRACKNUMBER'] = str(metadata.get('track_number', 1))
            audio_file['TRACKTOTAL'] = str(metadata.get('total_tracks', 1))
            
            # Genre
            if metadata.get('genre'):
                audio_file['GENRE'] = metadata['genre']
            
            # Disc number
            if metadata.get('disc_number'):
                audio_file['DISCNUMBER'] = str(metadata['disc_number'])
            
            # Spotify IDs
            if metadata.get('spotify_artist_id'):
                audio_file['SPOTIFY_ARTIST_ID'] = metadata['spotify_artist_id']
            if metadata.get('spotify_album_id'):
                audio_file['SPOTIFY_ALBUM_ID'] = metadata['spotify_album_id']
            
            audio_file.save()
            return True
            
        except Exception as e:
            print(f"❌ Error applying OGG tags: {e}")
            return False
    
    def _embed_album_art_metadata(self, file_path: str, audio_file, metadata: dict, file_format: str) -> bool:
        """Download and embed high-quality Spotify album art"""
        try:
            if not metadata.get('album_art_url'):
                print("🎨 No album art URL available for embedding")
                return True
                
            print(f"🎨 Downloading album art for embedding...")
            
            # Download album art
            album_art_url = metadata['album_art_url']
            response = urllib.request.urlopen(album_art_url, timeout=10)
            image_data = response.read()
            
            if not image_data:
                print("❌ Failed to download album art data")
                return False
                
            # Determine image format
            image_format = 'image/jpeg'  # Spotify typically uses JPEG
            
            # Embed based on format
            if file_format == 'mp3':
                if not hasattr(audio_file, 'tags') or audio_file.tags is None:
                    audio_file.add_tags()
                    
                audio_file.tags.setall('APIC', [APIC(
                    encoding=3,  # UTF-8
                    mime=image_format,
                    type=3,  # Cover (front)
                    desc='Cover',
                    data=image_data
                )])
                
            elif file_format == 'flac':
                picture = Picture()
                picture.data = image_data
                picture.type = 3  # Cover (front)
                picture.mime = image_format
                picture.width = 640
                picture.height = 640
                picture.depth = 24
                audio_file.add_picture(picture)
                
            elif file_format in ['mp4', 'm4a']:
                if image_format == 'image/jpeg':
                    audio_file['covr'] = [MP4Cover(image_data, imageformat=MP4Cover.FORMAT_JPEG)]
                else:
                    audio_file['covr'] = [MP4Cover(image_data, imageformat=MP4Cover.FORMAT_PNG)]
            
            # Save with embedded art
            audio_file.save()
            print(f"🎨 ✅ Album art successfully embedded")
            return True
            
        except Exception as e:
            print(f"❌ Error embedding album art: {e}")
            return False
    
    def cleanup_resources(self):
        """Clean up resources when page is destroyed"""
        try:
            # Shutdown thread pools
            if hasattr(self, 'api_thread_pool'):
                self.api_thread_pool.shutdown(wait=False)
                print("🧹 API thread pool shutdown")
            
            if hasattr(self, 'completion_thread_pool'):
                self.completion_thread_pool.waitForDone(3000)  # Wait up to 3 seconds for completion
                print("🧹 Completion thread pool shutdown")
        except Exception as e:
            print(f"❌ Error during resource cleanup: {e}")