from PyQt6.QtWidgets import (QWidget, QVBoxLayout, QHBoxLayout, QLabel, 
                           QFrame, QPushButton, QLineEdit, QScrollArea,
                           QGridLayout, QSizePolicy, QSpacerItem, QApplication,
                           QDialog, QDialogButtonBox, QProgressBar, QMessageBox,
                           QTableWidget, QTableWidgetItem, QHeaderView, QAbstractItemView)
from PyQt6.QtCore import Qt, QTimer, pyqtSignal, QThread, QObject, QRunnable, QThreadPool, QPropertyAnimation, QEasingCurve, QRect
from PyQt6.QtGui import QFont, QPixmap, QPainter, QPen, QColor
import functools
import os
import threading
import requests
import re
from typing import List, Optional
from dataclasses import dataclass

# Import core components
from core.spotify_client import SpotifyClient, Artist, Album
from core.plex_client import PlexClient
from core.soulseek_client import SoulseekClient, AlbumResult
from core.matching_engine import MusicMatchingEngine
import asyncio


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

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 download...")
            
            # 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))




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 ArtistSearchWorker(QThread):
    """Background worker for artist search"""
    artists_found = pyqtSignal(list)  # List of ArtistMatch objects
    search_failed = pyqtSignal(str)
    
    def __init__(self, query: str, spotify_client: SpotifyClient, matching_engine: MusicMatchingEngine):
        super().__init__()
        self.query = query
        self.spotify_client = spotify_client
        self.matching_engine = matching_engine
    
    def run(self):
        try:
            # Search for artists using Spotify
            artists = self.spotify_client.search_artists(self.query, limit=10)
            
            # Create artist matches with confidence scores
            artist_matches = []
            for artist in artists:
                # Calculate confidence based on name similarity
                confidence = self.matching_engine.similarity_score(self.query.lower(), artist.name.lower())
                match = ArtistMatch(
                    artist=artist,
                    confidence=confidence,
                    match_reason=f"Name similarity: {confidence:.1%}"
                )
                artist_matches.append(match)
            
            # Sort by confidence score
            artist_matches.sort(key=lambda x: x.confidence, reverse=True)
            
            self.artists_found.emit(artist_matches)
            
        except Exception as e:
            self.search_failed.emit(str(e))

class AlbumFetchWorker(QThread):
    """Background worker for fetching artist albums"""
    albums_found = pyqtSignal(list, object)  # List of albums, selected artist
    fetch_failed = pyqtSignal(str)
    
    def __init__(self, artist: Artist, spotify_client: SpotifyClient):
        super().__init__()
        self.artist = artist
        self.spotify_client = spotify_client
    
    def run(self):
        try:
            print(f"🎵 Fetching albums for artist: {self.artist.name} (ID: {self.artist.id})")
            
            # Use the proper Spotify API method to get albums by artist
            albums = self.spotify_client.get_artist_albums(self.artist.id, album_type='album', limit=50)
            
            print(f"📀 Found {len(albums)} albums for {self.artist.name}")
            
            if not albums:
                print("⚠️ No albums found, trying with singles included...")
                # If no albums found, try including singles
                albums = self.spotify_client.get_artist_albums(self.artist.id, album_type='album,single', limit=50)
                print(f"📀 Found {len(albums)} items including singles")
            
            # Remove duplicates based on name (case insensitive)
            seen_names = set()
            unique_albums = []
            for album in albums:
                album_name_lower = album.name.lower()
                if album_name_lower not in seen_names:
                    seen_names.add(album_name_lower)
                    unique_albums.append(album)
            
            # Sort by release date (newest first)
            unique_albums.sort(key=lambda x: x.release_date if x.release_date else '', reverse=True)
            
            print(f"✅ Returning {len(unique_albums)} unique albums")
            self.albums_found.emit(unique_albums, self.artist)
            
        except Exception as e:
            error_msg = f"Failed to fetch albums for {self.artist.name}: {str(e)}"
            print(f"❌ {error_msg}")
            self.fetch_failed.emit(error_msg)

class AlbumSearchWorker(QThread):
    """Background worker for searching albums on Soulseek"""
    search_results = pyqtSignal(list)  # List of AlbumResult objects
    search_failed = pyqtSignal(str)
    search_progress = pyqtSignal(str)  # Progress messages
    
    def __init__(self, query: str, soulseek_client: SoulseekClient):
        super().__init__()
        self.query = query
        self.soulseek_client = soulseek_client
        self._stop_requested = False
    
    def stop(self):
        """Request to stop the search"""
        self._stop_requested = True
    
    def run(self):
        """Executes the album search asynchronously."""
        loop = None
        try:
            if not self.soulseek_client:
                self.search_failed.emit("Soulseek client not available")
                return
            
            # Create a new event loop for this thread to run async operations
            loop = asyncio.new_event_loop()
            asyncio.set_event_loop(loop)
            
            self.search_progress.emit(f"Searching for: {self.query}")
            
            # Perform the async search using the provided query
            results = loop.run_until_complete(self.soulseek_client.search(self.query))
            
            if self._stop_requested:
                return
            
            # The search method returns a tuple of (tracks, albums)
            tracks, albums = results if results else ([], [])
            album_results = albums if albums else []
            
            # Sort by a combination of track count and total size for relevance
            album_results.sort(key=lambda x: (x.track_count, x.total_size), reverse=True)
            
            self.search_results.emit(album_results)
            
        except Exception as e:
            if not self._stop_requested:
                import traceback
                traceback.print_exc()
                self.search_failed.emit(str(e))
        finally:
            # Ensure the event loop is properly closed
            if loop:
                try:
                    loop.close()
                except Exception as e:
                    print(f"Error closing event loop in AlbumSearchWorker: {e}")

class AlbumStatusProcessingWorkerSignals(QObject):
    """Signals for the AlbumStatusProcessingWorker"""
    completed = pyqtSignal(list)  # List of status update results
    error = pyqtSignal(str)       # Error message

class AlbumStatusProcessingWorker(QRunnable):
    """
    Background worker for processing album download status updates.
    Based on the working pattern from downloads.py and sync.py.
    """
    
    def __init__(self, soulseek_client, download_items_data):
        super().__init__()
        self.signals = AlbumStatusProcessingWorkerSignals()
        self.soulseek_client = soulseek_client
        self.download_items_data = download_items_data
    
    def run(self):
        """Process status updates for album downloads in background thread"""
        try:
            import asyncio
            import os
            
            # Create new event loop for this thread
            loop = asyncio.new_event_loop()
            asyncio.set_event_loop(loop)
            
            try:
                # Get all current transfers from slskd API
                transfers_data = loop.run_until_complete(
                    self.soulseek_client._make_request('GET', 'transfers/downloads')
                )
                
                if not transfers_data:
                    self.signals.completed.emit([])
                    return
                
                # Parse transfers into flat list and create lookup dictionary
                all_transfers = []
                transfers_by_id = {}
                
                for user_data in transfers_data:
                    username = user_data.get('username', '')
                    
                    # Handle files directly under user object (newer API format)
                    if 'files' in user_data and isinstance(user_data['files'], list):
                        for file_data in user_data['files']:
                            file_data['username'] = username
                            all_transfers.append(file_data)
                            if 'id' in file_data:
                                transfers_by_id[file_data['id']] = file_data
                    
                    # Handle files nested in directories (older API format)
                    if 'directories' in user_data and isinstance(user_data['directories'], list):
                        for directory in user_data['directories']:
                            if 'files' in directory and isinstance(directory['files'], list):
                                for file_data in directory['files']:
                                    file_data['username'] = username
                                    all_transfers.append(file_data)
                                    if 'id' in file_data:
                                        transfers_by_id[file_data['id']] = file_data
                
                print(f"🔍 Album status worker found {len(all_transfers)} total transfers")
                
                # Process each download item
                results = []
                used_transfer_ids = set()  # Prevent duplicate matching
                
                for item_data in self.download_items_data:
                    download_id = item_data.get('download_id')
                    file_path = item_data.get('file_path', '')
                    widget_id = item_data.get('widget_id')
                    
                    print(f"🔍 Processing album download: ID={download_id}, file={os.path.basename(file_path)}")
                    
                    matching_transfer = None
                    
                    # Primary matching: by download ID
                    if download_id and download_id in transfers_by_id and download_id not in used_transfer_ids:
                        matching_transfer = transfers_by_id[download_id]
                        used_transfer_ids.add(download_id)
                        print(f"   ✅ ID match found for {download_id}")
                    
                    # Fallback matching: by filename
                    elif file_path:
                        expected_basename = os.path.basename(file_path).lower()
                        for transfer in all_transfers:
                            transfer_id = transfer.get('id')
                            if transfer_id in used_transfer_ids:
                                continue
                                
                            transfer_filename = transfer.get('filename', '')
                            transfer_basename = os.path.basename(transfer_filename).lower()
                            
                            if transfer_basename == expected_basename:
                                matching_transfer = transfer
                                used_transfer_ids.add(transfer_id)
                                print(f"   🎯 Filename match: {expected_basename}")
                                # Update download_id if it was missing
                                if not download_id:
                                    download_id = transfer_id
                                break
                    
                    # Determine status and create result
                    if matching_transfer:
                        state = matching_transfer.get('state', '').strip()
                        progress = 0.0
                        
                        # Map slskd states to our status system
                        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'
                            progress = 100.0
                        elif 'InProgress' in state:
                            new_status = 'downloading'
                            # Extract progress from state or progress field
                            if 'progress' in matching_transfer:
                                progress = float(matching_transfer.get('progress', 0.0))
                            else:
                                # Try to extract from state string
                                import re
                                progress_match = re.search(r'(\d+(?:\.\d+)?)%', state)
                                if progress_match:
                                    progress = float(progress_match.group(1))
                        else:
                            new_status = 'queued'
                        
                        result = {
                            'widget_id': widget_id,
                            'download_id': download_id,
                            'status': new_status,
                            'progress': progress,
                            'state': state,
                            'filename': matching_transfer.get('filename', ''),
                            'size': matching_transfer.get('size', 0),
                            'transferred': matching_transfer.get('bytesTransferred', 0),
                            'speed': matching_transfer.get('averageSpeed', 0)
                        }
                        
                        print(f"   📊 Status: {new_status} ({progress:.1f}%)")
                    else:
                        # Download not found in API - increment missing count
                        api_missing_count = item_data.get('api_missing_count', 0) + 1
                        
                        if api_missing_count >= 3:
                            # Grace period exceeded - mark as failed
                            new_status = 'failed'
                            print(f"   ❌ Download missing from API (failed after 3 checks)")
                        else:
                            # Still in grace period
                            new_status = 'missing'
                            print(f"   ⚠️ Download missing from API (attempt {api_missing_count}/3)")
                        
                        result = {
                            'widget_id': widget_id,
                            'download_id': download_id,
                            'status': new_status,
                            'api_missing_count': api_missing_count,
                            'progress': 0.0
                        }
                    
                    results.append(result)
                
                print(f"🎯 Album status worker completed: {len(results)} results")
                self.signals.completed.emit(results)
                
            finally:
                loop.close()
                
        except Exception as e:
            import traceback
            traceback.print_exc()
            self.signals.error.emit(f"Album status processing failed: {str(e)}")



class PlexLibraryWorker(QThread):
    """Background worker for checking Plex library"""
    library_checked = pyqtSignal(set)  # Set of owned album names (final result)
    album_matched = pyqtSignal(str)    # Individual album match (album name)
    check_failed = pyqtSignal(str)
    
    def __init__(self, albums, plex_client, matching_engine):
        super().__init__()
        self.albums = albums
        self.plex_client = plex_client
        self.matching_engine = matching_engine
        self._stop_requested = False
    
    def stop(self):
        """Request to stop the check"""
        self._stop_requested = True
    
    def run(self):
        try:
            print("🔍 Starting robust Plex album matching...")
            owned_albums = set()
            
            if not self.plex_client or not self.plex_client.ensure_connection():
                print("⚠️ Plex client not available or not connected")
                self.library_checked.emit(owned_albums)
                return
            
            if self._stop_requested:
                return
            
            print(f"📚 Checking {len(self.albums)} Spotify albums against Plex library...")
            
            # Use robust matching for each album
            for i, spotify_album in enumerate(self.albums):
                if self._stop_requested:
                    return
                
                print(f"🎵 Checking album {i+1}/{len(self.albums)}: {spotify_album.name}")
                
                # Create multiple search variations
                album_variations = []
                
                # Original name
                album_variations.append(spotify_album.name)
                
                # Cleaned name (removes versions, etc.)
                cleaned_name = self.matching_engine.clean_album_name(spotify_album.name)
                if cleaned_name != spotify_album.name.lower():
                    album_variations.append(cleaned_name)
                
                # Try different artist combinations
                artists_to_try = spotify_album.artists[:2] if spotify_album.artists else [""]
                
                all_plex_matches = []
                
                # Search with different combinations
                for artist in artists_to_try:
                    if self._stop_requested:
                        return
                    
                    artist_clean = self.matching_engine.clean_artist(artist) if artist else ""
                    
                    for album_name in album_variations:
                        if self._stop_requested:
                            return
                        
                        # Search Plex for this combination
                        print(f"   🔍 Searching Plex: album='{album_name}', artist='{artist_clean}'")
                        plex_albums = self.plex_client.search_albums(album_name, artist_clean, limit=5)
                        print(f"   📀 Found {len(plex_albums)} Plex albums")
                        all_plex_matches.extend(plex_albums)
                        
                        # Also try album-only search if artist+album didn't work
                        if not plex_albums and artist_clean:
                            print(f"   🔍 Trying album-only search: album='{album_name}'")
                            album_only_results = self.plex_client.search_albums(album_name, "", limit=5)
                            print(f"   📀 Found {len(album_only_results)} albums (album-only)")
                            all_plex_matches.extend(album_only_results)
                
                # Remove duplicates based on album ID
                unique_matches = {}
                for match in all_plex_matches:
                    unique_matches[match['id']] = match
                
                unique_plex_albums = list(unique_matches.values())
                
                if unique_plex_albums:
                    # Use robust matching to find best match
                    best_match, confidence = self.matching_engine.find_best_album_match(
                        spotify_album, unique_plex_albums
                    )
                    
                    if best_match and confidence >= 0.8:
                        owned_albums.add(spotify_album.name)
                        print(f"✅ Match found: '{spotify_album.name}' -> '{best_match['title']}' (confidence: {confidence:.2f})")
                        # Emit individual match for real-time UI update
                        self.album_matched.emit(spotify_album.name)
                    else:
                        print(f"❌ No confident match for '{spotify_album.name}' (best: {confidence:.2f})")
                else:
                    print(f"❌ No Plex candidates found for '{spotify_album.name}'")
            
            print(f"🎯 Final result: {len(owned_albums)} owned albums out of {len(self.albums)}")
            print(f"🚀 Emitting signal with owned_albums: {list(owned_albums)}")
            self.library_checked.emit(owned_albums)
            
        except Exception as e:
            if not self._stop_requested:
                error_msg = f"Error checking Plex library: {e}"
                print(f"❌ {error_msg}")
                self.check_failed.emit(error_msg)

class AlbumSearchDialog(QDialog):
    """Dialog for displaying album search results and allowing selection"""
    album_selected = pyqtSignal(object)  # AlbumResult object
    
    def __init__(self, album: Album, parent=None):
        super().__init__(parent)
        self.album = album
        self.selected_album_result = None
        self.selected_widget = None
        self.search_worker = None
        self.setup_ui()
        self.start_search() # Start automatic search on open
    
    def setup_ui(self):
        self.setWindowTitle(f"Download Source for: {self.album.name}")
        self.setFixedSize(800, 700)
        self.setStyleSheet("""
            QDialog { background: #191414; color: #ffffff; }
            QScrollArea { border: 1px solid #404040; border-radius: 8px; background: #282828; }
            QLineEdit { 
                background: #333; border: 1px solid #555; border-radius: 4px; 
                padding: 8px; font-size: 12px;
            }
            QPushButton {
                background-color: #444; border: 1px solid #666; border-radius: 4px;
                padding: 8px 12px; font-size: 12px;
            }
            QPushButton:hover { background-color: #555; }
        """)
        
        layout = QVBoxLayout(self)
        layout.setContentsMargins(20, 20, 20, 20)
        layout.setSpacing(15)
        
        # Header
        header_label = QLabel(f"Searching for: {self.album.name} by {', '.join(self.album.artists)}")
        header_label.setFont(QFont("Arial", 14, QFont.Weight.Bold))
        
        # Manual Search Section
        search_layout = QHBoxLayout()
        self.manual_search_input = QLineEdit()
        self.manual_search_input.setPlaceholderText("Refine search: Artist Album Title...")
        self.manual_search_input.returnPressed.connect(self.trigger_manual_search)
        
        self.search_cancel_btn = QPushButton("Search")
        self.search_cancel_btn.setFixedWidth(120)
        self.search_cancel_btn.clicked.connect(self.handle_search_cancel_click)
        
        search_layout.addWidget(self.manual_search_input, 1)
        search_layout.addWidget(self.search_cancel_btn)
        
        # Status
        self.status_label = QLabel("Initializing search...")
        self.status_label.setStyleSheet("color: #b3b3b3;")
        
        # Results Area
        self.results_scroll = QScrollArea()
        self.results_scroll.setWidgetResizable(True)
        self.results_widget = QWidget()
        self.results_layout = QVBoxLayout(self.results_widget)
        self.results_layout.setSpacing(8)
        self.results_layout.setContentsMargins(10, 10, 10, 10)
        self.results_layout.addStretch(1)
        self.results_scroll.setWidget(self.results_widget)
        
        # Bottom Buttons
        button_layout = QHBoxLayout()
        self.download_btn = QPushButton("Download Selected")
        self.download_btn.setEnabled(False) # Initially disabled
        self.download_btn.setStyleSheet("background-color: #1db954; color: black;")
        
        close_btn = QPushButton("Close")
        
        self.download_btn.clicked.connect(self.download_selected)
        close_btn.clicked.connect(self.reject)
        
        button_layout.addStretch(1)
        button_layout.addWidget(self.download_btn)
        button_layout.addWidget(close_btn)
        
        layout.addWidget(header_label)
        layout.addLayout(search_layout)
        layout.addWidget(self.status_label)
        layout.addWidget(self.results_scroll, 1)
        layout.addLayout(button_layout)

    def handle_search_cancel_click(self):
        """Toggles between starting a search and cancelling an active one."""
        if self.search_worker and self.search_worker.isRunning():
            self.cancel_search()
        else:
            self.trigger_manual_search()

    def trigger_manual_search(self):
        """Starts a new search using the text from the manual search input."""
        query = self.manual_search_input.text().strip()
        if query:
            self.start_search(query)

    def start_search(self, query: Optional[str] = None):
        """
        Starts the album search. If a query is provided, it's a manual search.
        Otherwise, it constructs an automatic query.
        """
        if self.search_worker and self.search_worker.isRunning():
            self.search_worker.stop()
            self.search_worker.wait()

        self.clear_results()
        self.download_btn.setEnabled(False)
        self.status_label.setText("Searching...")
        self.set_search_button_to_cancel(True)

        if query is None:
            artist_part = self.album.artists[0] if self.album.artists else ""
            query = f"{artist_part} {self.album.name}".strip()
        
        self.manual_search_input.setText(query)

        parent_page = self.parent()
        if hasattr(parent_page, 'soulseek_client') and parent_page.soulseek_client:
            self.search_worker = AlbumSearchWorker(query, parent_page.soulseek_client)
            self.search_worker.search_results.connect(self.on_search_results)
            self.search_worker.search_failed.connect(self.on_search_failed)
            self.search_worker.search_progress.connect(self.on_search_progress)
            self.search_worker.start()
        else:
            self.on_search_failed("Soulseek client not available")

    def cancel_search(self):
        if self.search_worker and self.search_worker.isRunning():
            self.search_worker.stop()
            self.status_label.setText("Search cancelled.")
            self.set_search_button_to_cancel(False)
    
    def on_search_progress(self, message):
        self.status_label.setText(message)
    
    def on_search_results(self, album_results):
        self.set_search_button_to_cancel(False)
        self.clear_results()
        if not album_results:
            self.status_label.setText("No albums found for this query.")
            return

        self.status_label.setText(f"Found {len(album_results)} potential albums. Click one to select.")
        
        for album_result in album_results[:25]: # Show top 25
            result_item = self.create_result_item(album_result)
            self.results_layout.insertWidget(self.results_layout.count() - 1, result_item)

    def on_search_failed(self, error):
        self.set_search_button_to_cancel(False)
        self.status_label.setText(f"Search failed: {error}")

    def create_result_item(self, album_result: AlbumResult):
        """Creates a larger, more informative, and clickable result item widget."""
        item = QFrame()
        item.setFixedHeight(75) # Increased height for better readability
        item.setCursor(Qt.CursorShape.PointingHandCursor)
        item.setStyleSheet("""
            QFrame {
                background: rgba(40, 40, 40, 0.8);
                border: 1px solid #555;
                border-radius: 6px;
            }
        """)
        # Connect the click event for the whole frame
        item.mousePressEvent = lambda event: self.select_result(album_result, item)
        
        layout = QHBoxLayout(item)
        layout.setContentsMargins(15, 10, 15, 10)
        layout.setSpacing(15)
        
        info_layout = QVBoxLayout()
        info_layout.setSpacing(4)
        
        title_label = QLabel(f"{album_result.album_title} by {album_result.artist}")
        title_label.setFont(QFont("Arial", 11, QFont.Weight.Bold))
        
        details_text = (f"{album_result.track_count} tracks | "
                        f"{self.format_size(album_result.total_size)} | "
                        f"Uploader: {album_result.username}")
        details_label = QLabel(details_text)
        details_label.setFont(QFont("Arial", 9))
        details_label.setStyleSheet("color: #b3b3b3;")
        
        info_layout.addWidget(title_label)
        info_layout.addWidget(details_label)
        
        quality_badge = self.create_quality_badge(album_result)
        
        layout.addLayout(info_layout, 1)
        layout.addWidget(quality_badge)
        
        return item

    def create_quality_badge(self, album_result: AlbumResult):
        """Creates a styled badge for displaying audio quality."""
        quality = album_result.dominant_quality.upper()
        
        # Safely calculate average bitrate from the album's tracks
        bitrate = 0
        if hasattr(album_result, 'tracks') and album_result.tracks:
            valid_bitrates = [
                track.bitrate for track in album_result.tracks 
                if hasattr(track, 'bitrate') and track.bitrate
            ]
            if valid_bitrates:
                bitrate = sum(valid_bitrates) // len(valid_bitrates)
        
        badge_text = quality
        if quality == 'MP3' and bitrate > 0:
            badge_text = f"MP3 {bitrate}k"
        elif quality == 'VBR':
            badge_text = "MP3 VBR"
            
        badge = QLabel(badge_text)
        badge.setFixedWidth(80)
        badge.setAlignment(Qt.AlignmentFlag.AlignCenter)
        badge.setFont(QFont("Arial", 9, QFont.Weight.Bold))
        
        if quality == 'FLAC':
            style = "background-color: #4CAF50; color: white; border-radius: 4px; padding: 5px;"
        elif bitrate >= 320:
            style = "background-color: #2196F3; color: white; border-radius: 4px; padding: 5px;"
        elif bitrate >= 192 or quality == 'VBR':
            style = "background-color: #FFC107; color: black; border-radius: 4px; padding: 5px;"
        else:
            style = "background-color: #F44336; color: white; border-radius: 4px; padding: 5px;"
            
        badge.setStyleSheet(style)
        return badge

    def clear_results(self):
        """Removes all result widgets from the layout, preserving the stretch item."""
        self.selected_widget = None # Clear selection
        # Iterate backwards to safely remove items while preserving the stretch
        for i in reversed(range(self.results_layout.count())):
            item = self.results_layout.itemAt(i)
            if item.widget():
                widget = item.widget()
                widget.deleteLater()

    def format_size(self, size_bytes):
        if size_bytes >= 1024**3: return f"{size_bytes / 1024**3:.1f} GB"
        if size_bytes >= 1024**2: return f"{size_bytes / 1024**2:.1f} MB"
        return f"{size_bytes / 1024:.1f} KB"
    
    def select_result(self, album_result, selected_item_widget):
        """Handles the selection of a result and provides visual feedback."""
        self.selected_album_result = album_result
        self.download_btn.setEnabled(True)

        # Deselect previous widget
        if self.selected_widget:
            self.selected_widget.setStyleSheet("""
                QFrame { background: rgba(40, 40, 40, 0.8); border: 1px solid #555; border-radius: 6px; }
            """)
        
        # Apply selected style to the new widget
        selected_item_widget.setStyleSheet("""
            QFrame { background: rgba(29, 185, 84, 0.2); border: 1px solid #1db954; border-radius: 6px; }
        """)
        self.selected_widget = selected_item_widget

    def download_selected(self):
        if self.selected_album_result:
            self.album_selected.emit(self.selected_album_result)
            self.accept()
    
    def set_search_button_to_cancel(self, is_searching: bool):
        """Changes the search button's text and style."""
        if is_searching:
            self.search_cancel_btn.setText("Cancel Search")
            self.search_cancel_btn.setStyleSheet("background-color: #F44336; color: white;")
        else:
            self.search_cancel_btn.setText("Search")
            self.search_cancel_btn.setStyleSheet("background-color: #1db954; color: black;")

    def closeEvent(self, event):
        self.cancel_search()
        super().closeEvent(event)



class ArtistResultCard(QFrame):
    """Card widget for displaying artist search results"""
    artist_selected = pyqtSignal(object)  # Artist object
    
    def __init__(self, artist_match: ArtistMatch, parent=None):
        super().__init__(parent)
        self.artist_match = artist_match
        self.artist = artist_match.artist
        self.setup_ui()
        self.load_artist_image()
    
    def setup_ui(self):
        self.setFixedSize(200, 280)
        self.setCursor(Qt.CursorShape.PointingHandCursor)
        
        # Base styling with gradient background
        self.setStyleSheet("""
            ArtistResultCard {
                background: qlineargradient(x1:0, y1:0, x2:0, y2:1,
                    stop:0 rgba(45, 45, 45, 0.95),
                    stop:1 rgba(35, 35, 35, 0.98));
                border-radius: 12px;
                border: 2px solid rgba(80, 80, 80, 0.4);
            }
            ArtistResultCard:hover {
                background: qlineargradient(x1:0, y1:0, x2:0, y2:1,
                    stop:0 rgba(29, 185, 84, 0.2),
                    stop:1 rgba(24, 156, 71, 0.3));
                border: 2px solid rgba(29, 185, 84, 0.8);
            }
        """)
        
        layout = QVBoxLayout(self)
        layout.setContentsMargins(12, 12, 12, 12)
        layout.setSpacing(8)
        
        # Artist image container
        self.image_container = QFrame()
        self.image_container.setFixedSize(176, 176)
        self.image_container.setStyleSheet("""
            QFrame {
                background: #404040;
                border-radius: 88px;
                border: 2px solid #606060;
            }
        """)
        
        image_layout = QVBoxLayout(self.image_container)
        image_layout.setContentsMargins(0, 0, 0, 0)
        
        self.image_label = QLabel()
        self.image_label.setFixedSize(172, 172)
        self.image_label.setAlignment(Qt.AlignmentFlag.AlignCenter)
        self.image_label.setStyleSheet("""
            QLabel {
                background: transparent;
                border-radius: 86px;
                color: #b3b3b3;
                font-size: 48px;
            }
        """)
        self.image_label.setText("🎵")
        
        image_layout.addWidget(self.image_label)
        
        # Artist name
        name_label = QLabel(self.artist.name)
        name_label.setFont(QFont("Arial", 12, QFont.Weight.Bold))
        name_label.setStyleSheet("color: #ffffff; padding: 4px;")
        name_label.setWordWrap(True)
        name_label.setAlignment(Qt.AlignmentFlag.AlignCenter)
        
        # Confidence score
        confidence_label = QLabel(f"Match: {self.artist_match.confidence:.0%}")
        confidence_label.setFont(QFont("Arial", 9))
        confidence_label.setStyleSheet("color: #1db954; padding: 2px;")
        confidence_label.setAlignment(Qt.AlignmentFlag.AlignCenter)
        
        # Followers count
        followers_text = self.format_followers(self.artist.followers)
        followers_label = QLabel(f"{followers_text} followers")
        followers_label.setFont(QFont("Arial", 8))
        followers_label.setStyleSheet("color: #b3b3b3; padding: 2px;")
        followers_label.setAlignment(Qt.AlignmentFlag.AlignCenter)
        
        layout.addWidget(self.image_container, 0, Qt.AlignmentFlag.AlignCenter)
        layout.addWidget(name_label)
        layout.addWidget(confidence_label)
        layout.addWidget(followers_label)
        layout.addStretch()
    
    def format_followers(self, count: int) -> str:
        """Format follower count in human readable format"""
        if count >= 1000000:
            return f"{count / 1000000:.1f}M"
        elif count >= 1000:
            return f"{count / 1000:.1f}K"
        else:
            return str(count)
    
    def load_artist_image(self):
        """Load artist image in background"""
        if self.artist.image_url:
            downloader = ImageDownloader(self.artist.image_url, self.image_label)
            downloader.signals.finished.connect(self.on_image_loaded)
            downloader.signals.error.connect(self.on_image_error)
            QThreadPool.globalInstance().start(downloader)
    
    def on_image_loaded(self, label, pixmap):
        """Handle successful image load"""
        if label == self.image_label:
            # Scale and mask the image to fit the circular container
            scaled_pixmap = pixmap.scaled(172, 172, Qt.AspectRatioMode.KeepAspectRatioByExpanding, Qt.TransformationMode.SmoothTransformation)
            
            # Create circular mask
            masked_pixmap = QPixmap(172, 172)
            masked_pixmap.fill(Qt.GlobalColor.transparent)
            
            painter = QPainter(masked_pixmap)
            painter.setRenderHint(QPainter.RenderHint.Antialiasing)
            painter.setBrush(QColor(255, 255, 255))
            painter.setPen(QPen(QColor(255, 255, 255)))
            painter.drawEllipse(0, 0, 172, 172)
            painter.setCompositionMode(QPainter.CompositionMode.CompositionMode_SourceIn)
            painter.drawPixmap(0, 0, scaled_pixmap)
            painter.end()
            
            self.image_label.setPixmap(masked_pixmap)
    
    def on_image_error(self, error):
        """Handle image load error"""
        print(f"Failed to load artist image: {error}")
    
    def mousePressEvent(self, event):
        """Handle click to select artist"""
        if event.button() == Qt.MouseButton.LeftButton:
            self.artist_selected.emit(self.artist)
        super().mousePressEvent(event)

class AlbumCard(QFrame):
    """Card widget for displaying album information"""
    download_requested = pyqtSignal(object)  # Album object
    
    def __init__(self, album: Album, is_owned: bool = False, parent=None):
        super().__init__(parent)
        self.album = album
        self.is_owned = is_owned
        self.setup_ui()
        self.load_album_image()
    
    def setup_ui(self):
        self.setFixedSize(180, 240)
        
        self.setStyleSheet("""
            AlbumCard {
                background: qlineargradient(x1:0, y1:0, x2:0, y2:1,
                    stop:0 rgba(40, 40, 40, 0.9),
                    stop:1 rgba(30, 30, 30, 0.95));
                border-radius: 10px;
                border: 1px solid rgba(70, 70, 70, 0.5);
            }
            AlbumCard: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.6);
            }
        """)
        
        layout = QVBoxLayout(self)
        layout.setContentsMargins(8, 8, 8, 8)
        layout.setSpacing(6)
        
        # Album image container
        self.image_container = QFrame()
        self.image_container.setFixedSize(164, 164)
        self.image_container.setStyleSheet("""
            QFrame {
                background: #404040;
                border-radius: 6px;
                border: 1px solid #606060;
            }
        """)
        
        image_layout = QVBoxLayout(self.image_container)
        image_layout.setContentsMargins(0, 0, 0, 0)
        
        self.image_label = QLabel()
        self.image_label.setFixedSize(162, 162)
        self.image_label.setAlignment(Qt.AlignmentFlag.AlignCenter)
        self.image_label.setStyleSheet("""
            QLabel {
                background: transparent;
                border-radius: 5px;
                color: #b3b3b3;
                font-size: 32px;
            }
        """)
        self.image_label.setText("💿")
        
        image_layout.addWidget(self.image_label)
        
        # Overlay for ownership status
        self.overlay = QLabel(self.image_container)
        self.overlay.setFixedSize(164, 164)
        self.overlay.setAlignment(Qt.AlignmentFlag.AlignCenter)
        
        if self.is_owned:
            self.overlay.setStyleSheet("""
                QLabel {
                    background: rgba(29, 185, 84, 0.8);
                    border-radius: 6px;
                    color: white;
                    font-size: 24px;
                    font-weight: bold;
                }
            """)
            self.overlay.setText("✓")
        else:
            self.overlay.setStyleSheet("""
                QLabel {
                    background: rgba(0, 0, 0, 0.7);
                    border-radius: 6px;
                    color: white;
                    font-size: 16px;
                    font-weight: bold;
                }
            """)
            self.overlay.setText("📥\nDownload")
            self.overlay.setCursor(Qt.CursorShape.PointingHandCursor)
        
        self.overlay.hide()  # Initially hidden, shown on hover
        
        # Download progress overlay (shown during downloads)
        self.progress_overlay = QLabel(self.image_container)
        self.progress_overlay.setFixedSize(164, 164)
        self.progress_overlay.setAlignment(Qt.AlignmentFlag.AlignCenter)
        self.progress_overlay.setStyleSheet("""
            QLabel {
                background: rgba(0, 0, 0, 0.8);
                border-radius: 6px;
                color: white;
                font-size: 12px;
                font-weight: bold;
                padding: 8px;
            }
        """)
        self.progress_overlay.hide()  # Initially hidden
        
        # Permanent ownership indicator (always visible)
        self.status_indicator = QLabel(self.image_container)
        self.status_indicator.setFixedSize(24, 24)
        self.status_indicator.move(140, 8)  # Top-right corner
        self.status_indicator.setAlignment(Qt.AlignmentFlag.AlignCenter)
        self.update_status_indicator()
        
        # Album name
        album_label = QLabel(self.album.name)
        album_label.setFont(QFont("Arial", 9, QFont.Weight.Bold))
        album_label.setStyleSheet("color: #ffffff; padding: 2px;")
        album_label.setWordWrap(True)
        album_label.setAlignment(Qt.AlignmentFlag.AlignCenter)
        album_label.setMaximumHeight(32)
        
        # Release year
        year_label = QLabel(self.album.release_date[:4] if self.album.release_date else "Unknown")
        year_label.setFont(QFont("Arial", 8))
        year_label.setStyleSheet("color: #b3b3b3; padding: 1px;")
        year_label.setAlignment(Qt.AlignmentFlag.AlignCenter)
        
        layout.addWidget(self.image_container, 0, Qt.AlignmentFlag.AlignCenter)
        layout.addWidget(album_label)
        layout.addWidget(year_label)
        layout.addStretch()
    
    def load_album_image(self):
        """Load album image in background"""
        if self.album.image_url:
            downloader = ImageDownloader(self.album.image_url, self.image_label)
            downloader.signals.finished.connect(self.on_image_loaded)
            downloader.signals.error.connect(self.on_image_error)
            QThreadPool.globalInstance().start(downloader)
    
    def on_image_loaded(self, label, pixmap):
        """Handle successful image load"""
        if label == self.image_label:
            scaled_pixmap = pixmap.scaled(162, 162, Qt.AspectRatioMode.KeepAspectRatioByExpanding, Qt.TransformationMode.SmoothTransformation)
            self.image_label.setPixmap(scaled_pixmap)
    
    def on_image_error(self, error):
        """Handle image load error"""
        print(f"Failed to load album image: {error}")
    
    def enterEvent(self, event):
        """Show overlay on hover"""
        self.overlay.show()
        super().enterEvent(event)
    
    def leaveEvent(self, event):
        """Hide overlay when not hovering"""
        self.overlay.hide()
        super().leaveEvent(event)
    
    def update_status_indicator(self):
        """Update the permanent status indicator"""
        if self.is_owned:
            self.status_indicator.setStyleSheet("""
                QLabel {
                    background: rgba(29, 185, 84, 0.9);
                    border-radius: 12px;
                    color: white;
                    font-size: 14px;
                    font-weight: bold;
                }
            """)
            self.status_indicator.setText("✓")
            self.status_indicator.setToolTip("Album owned in Plex")
        else:
            self.status_indicator.setStyleSheet("""
                QLabel {
                    background: rgba(220, 53, 69, 0.8);
                    border-radius: 12px;
                    color: white;
                    font-size: 12px;
                    font-weight: bold;
                }
            """)
            self.status_indicator.setText("📥")
            self.status_indicator.setToolTip("Album available for download")
    
    def update_ownership(self, is_owned: bool):
        """Update ownership status and refresh UI"""
        if self.is_owned != is_owned:  # Only log if status actually changed
            print(f"🔄 '{self.album.name}' ownership: {self.is_owned} -> {is_owned}")
        
        self.is_owned = is_owned
        
        # Update the permanent indicator
        self.update_status_indicator()
        
        # Update the hover overlay
        if self.is_owned:
            self.overlay.setStyleSheet("""
                QLabel {
                    background: rgba(29, 185, 84, 0.8);
                    border-radius: 6px;
                    color: white;
                    font-size: 24px;
                    font-weight: bold;
                }
            """)
            self.overlay.setText("✓")
            self.overlay.setCursor(Qt.CursorShape.ArrowCursor)
        else:
            self.overlay.setStyleSheet("""
                QLabel {
                    background: rgba(0, 0, 0, 0.7);
                    border-radius: 6px;
                    color: white;
                    font-size: 16px;
                    font-weight: bold;
                }
            """)
            self.overlay.setText("📥\nDownload")
            self.overlay.setCursor(Qt.CursorShape.PointingHandCursor)
    
    def set_download_in_progress(self):
        """Set album card to download in progress state"""
        # Hide hover overlay and show progress overlay
        self.overlay.hide()
        self.progress_overlay.setText("⏳\nPreparing...")
        self.progress_overlay.show()
        
        # Update status indicator
        self.status_indicator.setStyleSheet("""
            QLabel {
                background: rgba(255, 193, 7, 0.9);
                border-radius: 12px;
                color: white;
                font-size: 12px;
                font-weight: bold;
            }
        """)
        self.status_indicator.setText("⏳")
        self.status_indicator.setToolTip("Album downloading...")
    
    def update_download_progress(self, completed_tracks: int, total_tracks: int, percentage: int):
        """Update download progress display"""
        progress_text = f"📥 Downloading\n{completed_tracks}/{total_tracks} tracks\n{percentage}%"
        self.progress_overlay.setText(progress_text)
        self.progress_overlay.show()
        
        # Update status indicator with progress
        self.status_indicator.setText(f"{percentage}%")
        self.status_indicator.setToolTip(f"Downloading: {completed_tracks}/{total_tracks} tracks ({percentage}%)")
    
    def set_download_completed(self):
        """Set album card to download completed state"""
        # Hide progress overlay
        self.progress_overlay.hide()
        
        # Update to owned state
        self.update_ownership(True)
        
        # Show completion message briefly
        self.progress_overlay.setText("✅\nCompleted!")
        self.progress_overlay.setStyleSheet("""
            QLabel {
                background: rgba(29, 185, 84, 0.9);
                border-radius: 6px;
                color: white;
                font-size: 12px;
                font-weight: bold;
                padding: 8px;
            }
        """)
        self.progress_overlay.show()
        
        # Hide completion message after 3 seconds
        QTimer.singleShot(3000, self.progress_overlay.hide)
    
    def mousePressEvent(self, event):
        """Handle click for download"""
        # Don't allow downloads if already downloading or owned
        if (event.button() == Qt.MouseButton.LeftButton and 
            not self.is_owned and 
            not self.progress_overlay.isVisible()):
            self.download_requested.emit(self.album)
        super().mousePressEvent(event)

class DownloadMissingAlbumTracksModal(QDialog):
    """Enhanced modal for downloading missing album tracks with live progress tracking"""
    process_finished = pyqtSignal()
    
    def __init__(self, album, album_card, parent_page, downloads_page, plex_client):
        super().__init__(parent_page)
        self.album = album
        self.album_card = album_card
        self.parent_page = parent_page
        self.downloads_page = downloads_page
        self.plex_client = plex_client
        self.matching_engine = MusicMatchingEngine()
        
        # State tracking
        self.total_tracks = len(album.tracks)
        self.matched_tracks_count = 0
        self.tracks_to_download_count = 0
        self.downloaded_tracks_count = 0
        self.analysis_complete = False
        
        # Initialize attributes to prevent crash on close
        self.download_in_progress = False
        self.cancel_requested = False
        self.permanently_failed_tracks = []
        
        print(f"📊 Total album tracks: {self.total_tracks}")
        
        # Track analysis results
        self.analysis_results = []
        self.missing_tracks = []
        
        # Worker tracking
        self.active_workers = []
        self.fallback_pools = []

        # Status Polling
        self.download_status_pool = QThreadPool()
        self.download_status_pool.setMaxThreadCount(1)
        self._is_status_update_running = False

        self.download_status_timer = QTimer(self)
        self.download_status_timer.timeout.connect(self.poll_all_download_statuses)
        self.download_status_timer.start(2000) 

        self.active_downloads = [] 
        
        print("🎨 Setting up album modal UI...")
        self.setup_ui()
        print("✅ Album modal initialization complete")

    def generate_smart_search_queries(self, artist_name, track_name):
        """Generate multiple search query variations for better matching"""
        queries = []

        # Step 1: Use the original, full track name
        if artist_name:
            # Attempt 1: Full Artist + Full Track Name
            queries.append(f"{artist_name} {track_name}".strip())

            # Attempt 2: Full Track Name + First Word of Artist
            artist_words = artist_name.split()
            if artist_words:
                first_word = artist_words[0]
                if first_word.lower() == 'the' and len(artist_words) > 1:
                    first_word = artist_words[1]
                
                if len(first_word) > 1:
                    queries.append(f"{track_name} {first_word}".strip())

        # Attempt 3: Full Track Name only
        queries.append(track_name.strip())

        # Step 2: Clean the track name for the final fallback
        cleaned_name = re.sub(r'\s*\([^)]*\)', '', track_name).strip()
        cleaned_name = re.sub(r'\s*\[[^\]]*\]', '', cleaned_name).strip()

        # Attempt 4: Cleaned Track Name only (if different from original)
        if cleaned_name and cleaned_name.lower() != track_name.lower():
            queries.append(cleaned_name.strip())

        # Remove duplicates while preserving order
        unique_queries = []
        for query in queries:
            if query and query not in unique_queries:
                unique_queries.append(query)
        
        print(f"🧠 Generated {len(unique_queries)} smart queries for '{track_name}'. Sequence: {unique_queries}")
        return unique_queries

    def setup_ui(self):
        """Set up the enhanced modal UI"""
        self.setWindowTitle(f"Download Missing Tracks - {self.album.name}")
        self.resize(1200, 900)
        self.setWindowFlags(Qt.WindowType.Window)
        
        self.setStyleSheet("""
            QDialog { background-color: #1e1e1e; color: #ffffff; }
            QLabel { color: #ffffff; }
            QPushButton {
                background-color: #1db954; color: #000000; border: none;
                border-radius: 6px; font-size: 13px; font-weight: bold;
                padding: 10px 20px; min-width: 100px;
            }
            QPushButton:hover { background-color: #1ed760; }
            QPushButton:disabled { background-color: #404040; color: #888888; }
        """)
        
        main_layout = QVBoxLayout(self)
        main_layout.setContentsMargins(25, 25, 25, 25)
        main_layout.setSpacing(15)
        
        top_section = self.create_compact_top_section()
        main_layout.addWidget(top_section)
        
        progress_section = self.create_progress_section()
        main_layout.addWidget(progress_section)
        
        table_section = self.create_track_table()
        main_layout.addWidget(table_section, stretch=1)
        
        button_section = self.create_buttons()
        main_layout.addWidget(button_section)
        
    def create_compact_top_section(self):
        """Create compact top section with header and dashboard combined"""
        top_frame = QFrame()
        top_frame.setStyleSheet("""
            QFrame {
                background-color: #2d2d2d; border: 1px solid #444444;
                border-radius: 8px; padding: 15px;
            }
        """)
        
        layout = QVBoxLayout(top_frame)
        layout.setSpacing(15)
        
        header_layout = QHBoxLayout()
        title_section = QVBoxLayout()
        title_section.setSpacing(2)
        
        title = QLabel("Download Missing Album Tracks")
        title.setFont(QFont("Arial", 16, QFont.Weight.Bold))
        title.setStyleSheet("color: #1db954;")
        
        subtitle = QLabel(f"Album: {self.album.name} by {', '.join(self.album.artists)}")
        subtitle.setFont(QFont("Arial", 11))
        subtitle.setStyleSheet("color: #aaaaaa;")
        
        title_section.addWidget(title)
        title_section.addWidget(subtitle)
        
        dashboard_layout = QHBoxLayout()
        dashboard_layout.setSpacing(20)
        
        self.total_card = self.create_compact_counter_card("📀 Total", str(self.total_tracks), "#1db954")
        self.matched_card = self.create_compact_counter_card("✅ Found", "0", "#4CAF50")
        self.download_card = self.create_compact_counter_card("⬇️ Missing", "0", "#ff6b6b")
        self.downloaded_card = self.create_compact_counter_card("✅ Downloaded", "0", "#4CAF50")
        
        dashboard_layout.addWidget(self.total_card)
        dashboard_layout.addWidget(self.matched_card)
        dashboard_layout.addWidget(self.download_card)
        dashboard_layout.addWidget(self.downloaded_card)
        dashboard_layout.addStretch()
        
        header_layout.addLayout(title_section)
        header_layout.addStretch()
        header_layout.addLayout(dashboard_layout)
        
        layout.addLayout(header_layout)
        return top_frame
        
    def create_compact_counter_card(self, title, count, color):
        """Create a compact counter card widget"""
        card = QFrame()
        card.setStyleSheet(f"""
            QFrame {{
                background-color: #3a3a3a; border: 2px solid {color};
                border-radius: 6px; padding: 8px 12px; min-width: 80px;
            }}
        """)
        
        layout = QVBoxLayout(card)
        layout.setContentsMargins(0, 0, 0, 0)
        layout.setSpacing(2)
        
        count_label = QLabel(count)
        count_label.setFont(QFont("Arial", 16, QFont.Weight.Bold))
        count_label.setStyleSheet(f"color: {color}; background: transparent;")
        count_label.setAlignment(Qt.AlignmentFlag.AlignCenter)
        
        title_label = QLabel(title)
        title_label.setFont(QFont("Arial", 9))
        title_label.setStyleSheet("color: #cccccc; background: transparent;")
        title_label.setAlignment(Qt.AlignmentFlag.AlignCenter)
        
        layout.addWidget(count_label)
        layout.addWidget(title_label)
        
        if "Total" in title: self.total_count_label = count_label
        elif "Found" in title: self.matched_count_label = count_label
        elif "Missing" in title: self.download_count_label = count_label
        elif "Downloaded" in title: self.downloaded_count_label = count_label
            
        return card
        
    def create_progress_section(self):
        """Create compact dual progress bar section"""
        progress_frame = QFrame()
        progress_frame.setStyleSheet("""
            QFrame {
                background-color: #2d2d2d; border: 1px solid #444444;
                border-radius: 8px; padding: 12px;
            }
        """)
        
        layout = QVBoxLayout(progress_frame)
        layout.setSpacing(8)
        
        analysis_container = QVBoxLayout()
        analysis_container.setSpacing(4)
        
        analysis_label = QLabel("🔍 Plex Analysis")
        analysis_label.setFont(QFont("Arial", 11, QFont.Weight.Bold))
        analysis_label.setStyleSheet("color: #cccccc;")
        
        self.analysis_progress = QProgressBar()
        self.analysis_progress.setFixedHeight(20)
        self.analysis_progress.setStyleSheet("""
            QProgressBar {
                border: 1px solid #555555; border-radius: 10px; text-align: center;
                background-color: #444444; color: #ffffff; font-size: 11px; font-weight: bold;
            }
            QProgressBar::chunk { background-color: #1db954; border-radius: 9px; }
        """)
        self.analysis_progress.setVisible(False)
        
        analysis_container.addWidget(analysis_label)
        analysis_container.addWidget(self.analysis_progress)
        
        download_container = QVBoxLayout()
        download_container.setSpacing(4)
        
        download_label = QLabel("⬇️ Download Progress")
        download_label.setFont(QFont("Arial", 11, QFont.Weight.Bold))
        download_label.setStyleSheet("color: #cccccc;")
        
        self.download_progress = QProgressBar()
        self.download_progress.setFixedHeight(20)
        self.download_progress.setStyleSheet("""
            QProgressBar {
                border: 1px solid #555555; border-radius: 10px; text-align: center;
                background-color: #444444; color: #ffffff; font-size: 11px; font-weight: bold;
            }
            QProgressBar::chunk { background-color: #ff6b6b; border-radius: 9px; }
        """)
        self.download_progress.setVisible(False)
        
        download_container.addWidget(download_label)
        download_container.addWidget(self.download_progress)
        
        layout.addLayout(analysis_container)
        layout.addLayout(download_container)
        
        return progress_frame
        
    def create_track_table(self):
        """Create enhanced track table"""
        table_frame = QFrame()
        table_frame.setStyleSheet("""
            QFrame {
                background-color: #2d2d2d; border: 1px solid #444444;
                border-radius: 8px; padding: 0px;
            }
        """)
        
        layout = QVBoxLayout(table_frame)
        layout.setContentsMargins(15, 15, 15, 15)
        layout.setSpacing(10)
        
        header_label = QLabel("📋 Album Track Analysis")
        header_label.setFont(QFont("Arial", 13, QFont.Weight.Bold))
        header_label.setStyleSheet("color: #ffffff; padding: 5px;")
        
        self.track_table = QTableWidget()
        self.track_table.setColumnCount(5)
        self.track_table.setHorizontalHeaderLabels(["Track", "Artist", "Duration", "Matched", "Status"])
        self.track_table.horizontalHeader().setSectionResizeMode(QHeaderView.ResizeMode.Stretch)
        self.track_table.horizontalHeader().setSectionResizeMode(2, QHeaderView.ResizeMode.Interactive)
        self.track_table.horizontalHeader().setSectionResizeMode(3, QHeaderView.ResizeMode.Interactive)
        self.track_table.setColumnWidth(2, 90)
        self.track_table.setColumnWidth(3, 140)
        
        self.track_table.setStyleSheet("""
            QTableWidget {
                background-color: #3a3a3a; alternate-background-color: #424242;
                selection-background-color: #1db954; selection-color: #000000;
                gridline-color: #555555; color: #ffffff; border: 1px solid #555555;
                font-size: 12px;
            }
            QHeaderView::section {
                background-color: #1db954; color: #000000; font-weight: bold;
                font-size: 13px; padding: 12px 8px; border: none;
            }
            QTableWidget::item { padding: 12px 8px; border-bottom: 1px solid #4a4a4a; }
        """)
        
        self.track_table.setAlternatingRowColors(True)
        self.track_table.setSelectionBehavior(QAbstractItemView.SelectionBehavior.SelectRows)
        self.track_table.verticalHeader().setDefaultSectionSize(35)
        self.track_table.verticalHeader().setVisible(False)
        
        self.populate_track_table()
        
        layout.addWidget(header_label)
        layout.addWidget(self.track_table)
        
        return table_frame
    
    def populate_track_table(self):
        """Populate track table with album tracks"""
        self.track_table.setRowCount(len(self.album.tracks))
        for i, track in enumerate(self.album.tracks):
            self.track_table.setItem(i, 0, QTableWidgetItem(track.name))
            artist_name = track.artists[0] if track.artists else "Unknown"
            self.track_table.setItem(i, 1, QTableWidgetItem(artist_name))
            duration = self.format_duration(track.duration_ms)
            duration_item = QTableWidgetItem(duration)
            duration_item.setTextAlignment(Qt.AlignmentFlag.AlignCenter)
            self.track_table.setItem(i, 2, duration_item)
            matched_item = QTableWidgetItem("⏳ Pending")
            matched_item.setTextAlignment(Qt.AlignmentFlag.AlignCenter)
            self.track_table.setItem(i, 3, matched_item)
            status_item = QTableWidgetItem("—")
            status_item.setTextAlignment(Qt.AlignmentFlag.AlignCenter)
            self.track_table.setItem(i, 4, status_item)
            for col in range(5):
                self.track_table.item(i, col).setFlags(self.track_table.item(i, col).flags() & ~Qt.ItemFlag.ItemIsEditable)

    def format_duration(self, duration_ms):
        """Convert milliseconds to MM:SS format"""
        seconds = duration_ms // 1000
        return f"{seconds // 60}:{seconds % 60:02d}"
        
    def create_buttons(self):
        """Create improved button section"""
        button_frame = QFrame(styleSheet="background-color: transparent; padding: 10px;")
        layout = QHBoxLayout(button_frame)
        layout.setSpacing(15)
        layout.setContentsMargins(0, 10, 0, 0)

        self.correct_failed_btn = QPushButton("🔧 Correct Failed Matches")
        self.correct_failed_btn.setFixedWidth(220)
        self.correct_failed_btn.setStyleSheet("""
            QPushButton { background-color: #ffc107; color: #000000; border-radius: 20px; font-weight: bold; }
            QPushButton:hover { background-color: #ffca28; }
        """)
        self.correct_failed_btn.clicked.connect(self.on_correct_failed_matches_clicked)
        self.correct_failed_btn.hide()
        
        self.begin_search_btn = QPushButton("Begin Search")
        self.begin_search_btn.setFixedSize(160, 40)
        self.begin_search_btn.setStyleSheet("""
            QPushButton {
                background-color: #1db954; color: #000000; border: none;
                border-radius: 20px; font-size: 14px; font-weight: bold;
            }
            QPushButton:hover { background-color: #1ed760; }
        """)
        self.begin_search_btn.clicked.connect(self.on_begin_search_clicked)
        
        self.cancel_btn = QPushButton("Cancel")
        self.cancel_btn.setFixedSize(110, 40)
        self.cancel_btn.setStyleSheet("""
            QPushButton { background-color: #d32f2f; color: #ffffff; border-radius: 20px;}
            QPushButton:hover { background-color: #f44336; }
        """)
        self.cancel_btn.clicked.connect(self.on_cancel_clicked)
        self.cancel_btn.hide()
        
        self.close_btn = QPushButton("Close")
        self.close_btn.setFixedSize(110, 40)
        self.close_btn.setStyleSheet("""
            QPushButton { background-color: #616161; color: #ffffff; border-radius: 20px;}
            QPushButton:hover { background-color: #757575; }
        """)
        self.close_btn.clicked.connect(self.on_close_clicked)
        
        layout.addStretch()
        layout.addWidget(self.begin_search_btn)
        layout.addWidget(self.cancel_btn)
        layout.addWidget(self.correct_failed_btn)
        layout.addWidget(self.close_btn)
        
        return button_frame

    def on_begin_search_clicked(self):
        """Handle Begin Search button click - starts Plex analysis"""
        # Trigger UI updates on album card
        if self.album_card:
            self.album_card.set_download_in_progress()

        self.begin_search_btn.hide()
        self.cancel_btn.show()
        self.analysis_progress.setVisible(True)
        self.analysis_progress.setMaximum(self.total_tracks)
        self.analysis_progress.setValue(0)
        self.download_in_progress = True
        self.start_plex_analysis()

    def start_plex_analysis(self):
        """Start Plex analysis for album tracks"""
        from ui.pages.sync import PlaylistTrackAnalysisWorker
        worker = PlaylistTrackAnalysisWorker(self.album.tracks, self.plex_client)
        worker.signals.analysis_started.connect(self.on_analysis_started)
        worker.signals.track_analyzed.connect(self.on_track_analyzed)
        worker.signals.analysis_completed.connect(self.on_analysis_completed)
        worker.signals.analysis_failed.connect(self.on_analysis_failed)
        self.active_workers.append(worker)
        QThreadPool.globalInstance().start(worker)
            
    def on_analysis_started(self, total_tracks):
        print(f"🔍 Album analysis started for {total_tracks} tracks")
        
    def on_track_analyzed(self, track_index, result):
        """Handle individual track analysis completion with live UI updates"""
        self.analysis_progress.setValue(track_index)
        if result.exists_in_plex:
            matched_text = f"✅ Found ({result.confidence:.1f})"
            self.matched_tracks_count += 1
            self.matched_count_label.setText(str(self.matched_tracks_count))
        else:
            matched_text = "❌ Missing"
            self.tracks_to_download_count += 1
            self.download_count_label.setText(str(self.tracks_to_download_count))
        self.track_table.setItem(track_index - 1, 3, QTableWidgetItem(matched_text))
        
    def on_analysis_completed(self, results):
        """Handle analysis completion"""
        self.analysis_complete = True
        self.analysis_results = results
        self.missing_tracks = [r for r in results if not r.exists_in_plex]
        print(f"✅ Album analysis complete: {len(self.missing_tracks)} to download")
        if self.missing_tracks:
            self.start_download_progress()
        else:
            self.download_in_progress = False
            self.cancel_btn.hide()
            self.process_finished.emit() 
            QMessageBox.information(self, "Analysis Complete", "All album tracks already exist in Plex! No downloads needed.")
            
    def on_analysis_failed(self, error_message):
        print(f"❌ Album analysis failed: {error_message}")
        QMessageBox.critical(self, "Analysis Failed", f"Failed to analyze album tracks: {error_message}")
        self.cancel_btn.hide()
        self.begin_search_btn.show()

    def start_download_progress(self):
        """Start actual download progress tracking"""
        self.download_progress.setVisible(True)
        self.download_progress.setMaximum(len(self.missing_tracks))
        self.download_progress.setValue(0)
        self.start_parallel_downloads()
    
    def start_parallel_downloads(self):
        """Start multiple track downloads in parallel for better performance"""
        self.active_parallel_downloads = 0
        self.download_queue_index = 0
        self.failed_downloads = 0
        self.completed_downloads = 0
        self.successful_downloads = 0
        self.start_next_batch_of_downloads()
    
    def start_next_batch_of_downloads(self, max_concurrent=3):
        """Start the next batch of downloads up to the concurrent limit"""
        while (self.active_parallel_downloads < max_concurrent and 
               self.download_queue_index < len(self.missing_tracks)):
            track_result = self.missing_tracks[self.download_queue_index]
            track = track_result.spotify_track
            track_index = self.find_track_index_in_album(track)
            self.track_table.setItem(track_index, 4, QTableWidgetItem("🔍 Searching..."))
            self.search_and_download_track_parallel(track, self.download_queue_index, track_index)
            self.active_parallel_downloads += 1
            self.download_queue_index += 1
        
        if (self.download_queue_index >= len(self.missing_tracks) and self.active_parallel_downloads == 0):
            self.on_all_downloads_complete()
    
    def search_and_download_track_parallel(self, spotify_track, download_index, track_index):
        """Search for track and download via infrastructure path - PARALLEL VERSION"""
        artist_name = spotify_track.artists[0] if spotify_track.artists else ""
        search_queries = self.generate_smart_search_queries(artist_name, spotify_track.name)
        self.start_track_search_with_queries_parallel(spotify_track, search_queries, track_index, track_index, download_index)
    
    def start_track_search_with_queries_parallel(self, spotify_track, search_queries, track_index, table_index, download_index):
        """Start track search with parallel completion handling"""
        if not hasattr(self, 'parallel_search_tracking'):
            self.parallel_search_tracking = {}
        
        self.parallel_search_tracking[download_index] = {
            'spotify_track': spotify_track, 'track_index': track_index,
            'table_index': table_index, 'download_index': download_index,
            'completed': False, 'used_sources': set(), 'candidates': [], 'retry_count': 0
        }
        self.start_search_worker_parallel(search_queries, spotify_track, track_index, table_index, 0, download_index)

    def start_search_worker_parallel(self, queries, spotify_track, track_index, table_index, query_index, download_index):
        """Start search worker with parallel completion handling."""
        if query_index >= len(queries):
            self.on_parallel_track_failed(download_index, "All search strategies failed")
            return

        query = queries[query_index]
        worker = self.ParallelSearchWorker(self.parent_page.soulseek_client, query)
        
        worker.signals.search_completed.connect(
            lambda r, q: self.on_search_query_completed_parallel(r, queries, spotify_track, track_index, table_index, query_index, q, download_index)
        )
        worker.signals.search_failed.connect(
            lambda q, e: self.on_search_query_completed_parallel([], queries, spotify_track, track_index, table_index, query_index, q, download_index)
        )
        QThreadPool.globalInstance().start(worker)

    def on_search_query_completed_parallel(self, results, queries, spotify_track, track_index, table_index, query_index, query, download_index):
        """Handle completion of a parallel search query. If it fails, trigger the next query."""
        if hasattr(self, 'cancel_requested') and self.cancel_requested: return
            
        valid_candidates = self.get_valid_candidates(results, spotify_track, query)
        
        if valid_candidates:
            # Cache the candidates for future retries
            self.parallel_search_tracking[download_index]['candidates'] = valid_candidates
            best_match = valid_candidates[0]
            self.start_validated_download_parallel(best_match, spotify_track, track_index, table_index, download_index)
            return

        next_query_index = query_index + 1
        if next_query_index < len(queries):
            self.start_search_worker_parallel(queries, spotify_track, track_index, table_index, next_query_index, download_index)
        else:
            self.on_parallel_track_failed(download_index, f"No valid results after trying all {len(queries)} queries.")

    def start_validated_download_parallel(self, slskd_result, spotify_metadata, track_index, table_index, download_index):
        """Start download with validated metadata"""
        track_info = self.parallel_search_tracking[download_index]

        # Reset state if this track was previously marked as completed (for retries)
        if track_info.get('completed', False):
            print(f"🔄 Resetting state for manually retried track (index: {download_index}).")
            track_info['completed'] = False
            
            if self.failed_downloads > 0:
                self.failed_downloads -= 1
            
            self.active_parallel_downloads += 1
            
            if self.completed_downloads > 0:
                self.completed_downloads -= 1

        # Add the new download source to used sources to prevent retrying with same user/file
        source_key = f"{getattr(slskd_result, 'username', 'unknown')}_{slskd_result.filename}"
        track_info['used_sources'].add(source_key)
        
        # Update UI to show the new download has been queued
        spotify_based_result = self.create_spotify_based_search_result_from_validation(slskd_result, spotify_metadata)
        self.track_table.setItem(table_index, 4, QTableWidgetItem("... Queued"))
        
        # Start the actual download process
        self.start_matched_download_via_infrastructure_parallel(spotify_based_result, track_index, table_index, download_index)
    
    def start_matched_download_via_infrastructure_parallel(self, spotify_based_result, track_index, table_index, download_index):
        """Start infrastructure download with parallel completion tracking"""
        try:
            artist = type('Artist', (), {'name': spotify_based_result.artist})()
            download_item = self.downloads_page._start_download_with_artist(spotify_based_result, artist)
            
            if download_item:
                self.active_downloads.append({
                    'download_index': download_index, 'track_index': track_index,
                    'table_index': table_index, 'download_id': download_item.download_id,
                    'slskd_result': spotify_based_result, 'candidates': self.parallel_search_tracking[download_index]['candidates']
                })
            else:
                self.on_parallel_track_failed(download_index, "Failed to start download")
        except Exception as e:
            self.on_parallel_track_failed(download_index, str(e))
    
    def poll_all_download_statuses(self):
        """Poll download statuses for active downloads"""
        if self._is_status_update_running or not self.active_downloads:
            return
        self._is_status_update_running = True
        
        # Create a snapshot of data needed by the worker thread
        items_to_check = []
        for d in self.active_downloads:
            if d.get('slskd_result') and hasattr(d['slskd_result'], 'filename'):
                items_to_check.append({
                    'widget_id': d['download_index'], 
                    'download_id': d.get('download_id'),
                    'file_path': d['slskd_result'].filename,
                    'api_missing_count': d.get('api_missing_count', 0)
                })

        if not items_to_check:
            self._is_status_update_running = False
            return
        
        # Import the worker from sync.py
        from ui.pages.sync import SyncStatusProcessingWorker
        worker = SyncStatusProcessingWorker(
            self.parent_page.soulseek_client, 
            items_to_check
        )
        
        worker.signals.completed.connect(self._handle_processed_status_updates)
        worker.signals.error.connect(lambda e: print(f"Album Status Worker Error: {e}"))
        self.download_status_pool.start(worker)

    def _handle_processed_status_updates(self, results):
        """Handle status updates from the background worker and trigger retry logic"""
        import time
        
        # Create a lookup for faster access to active download items
        active_downloads_map = {d['download_index']: d for d in self.active_downloads}

        for result in results:
            download_index = result['widget_id']
            new_status = result['status']
            
            download_info = active_downloads_map.get(download_index)
            if not download_info:
                continue

            # Update the main download_info object with the latest missing count
            if 'api_missing_count' in result:
                 download_info['api_missing_count'] = result['api_missing_count']

            # Update the download_id if the worker found a match by filename
            if result.get('transfer_id') and download_info.get('download_id') != result['transfer_id']:
                print(f"ℹ️ Corrected download ID for '{download_info['slskd_result'].filename}'")
                download_info['download_id'] = result['transfer_id']

            # Handle terminal states (completed, failed, cancelled)
            if new_status in ['failed', 'cancelled']:
                if download_info in self.active_downloads:
                    self.active_downloads.remove(download_info)
                self.retry_parallel_download_with_fallback(download_info)

            elif new_status == 'completed':
                if download_info in self.active_downloads:
                    self.active_downloads.remove(download_info)
                self.on_parallel_track_completed(download_index, success=True)

            # Handle transient states (downloading, queued)
            elif new_status == 'downloading':
                 progress = result.get('progress', 0)
                 self.track_table.setItem(download_info['table_index'], 4, QTableWidgetItem(f"⏬ Downloading ({progress}%)"))
                 
                 # Reset queue timer if it exists
                 if 'queued_start_time' in download_info:
                     del download_info['queued_start_time']

                 # Add timeout for downloads stuck at 0%
                 if progress < 1:
                     if 'downloading_start_time' not in download_info:
                         download_info['downloading_start_time'] = time.time()
                     # 90-second timeout for being stuck at 0%
                     elif time.time() - download_info['downloading_start_time'] > 90:
                         print(f"⚠️ Download for '{download_info['slskd_result'].filename}' is stuck at 0%. Retrying.")
                         if download_info in self.active_downloads:
                             self.active_downloads.remove(download_info)
                         self.retry_parallel_download_with_fallback(download_info)
                 else:
                     # Progress is being made, reset the timer
                     if 'downloading_start_time' in download_info:
                         del download_info['downloading_start_time']

            elif new_status == 'queued':
                 self.track_table.setItem(download_info['table_index'], 4, QTableWidgetItem("... Queued"))
                 # Start a timer to detect if it's stuck in queue
                 if 'queued_start_time' not in download_info:
                     download_info['queued_start_time'] = time.time()
                 elif time.time() - download_info['queued_start_time'] > 90: # 90-second timeout
                     print(f"⚠️ Download for '{download_info['slskd_result'].filename}' is stuck in queue. Retrying.")
                     if download_info in self.active_downloads:
                         self.active_downloads.remove(download_info)
                     self.retry_parallel_download_with_fallback(download_info)
        
        self._is_status_update_running = False

    def retry_parallel_download_with_fallback(self, failed_download_info):
        """Retries a failed download by selecting the next-best cached candidate"""
        download_index = failed_download_info['download_index']
        track_info = self.parallel_search_tracking[download_index]
        
        track_info['retry_count'] += 1
        if track_info['retry_count'] > 2: # Max 3 attempts total (1 initial + 2 retries)
            self.on_parallel_track_failed(download_index, "All retries failed.")
            return

        candidates = failed_download_info.get('candidates', [])
        used_sources = track_info.get('used_sources', set())
        
        next_candidate = None
        for candidate in candidates:
            source_key = f"{getattr(candidate, 'username', 'unknown')}_{candidate.filename}"
            if source_key not in used_sources:
                next_candidate = candidate
                break

        if not next_candidate:
            self.on_parallel_track_failed(download_index, "No alternative sources in cache")
            return

        print(f"🔄 Retrying album download {download_index + 1} with next candidate: {next_candidate.filename}")
        self.track_table.setItem(failed_download_info['table_index'], 4, QTableWidgetItem(f"🔄 Retrying ({track_info['retry_count']})..."))
        
        self.start_validated_download_parallel(
            next_candidate, track_info['spotify_track'], track_info['track_index'],
            track_info['table_index'], download_index
        )

    def on_parallel_track_completed(self, download_index, success):
        """Handle completion of a parallel track download"""
        track_info = self.parallel_search_tracking.get(download_index)
        if not track_info or track_info.get('completed', False): return
        
        track_info['completed'] = True
        if success:
            self.track_table.setItem(track_info['table_index'], 4, QTableWidgetItem("✅ Downloaded"))
            self.downloaded_tracks_count += 1
            self.downloaded_count_label.setText(str(self.downloaded_tracks_count))
            self.successful_downloads += 1
        else:
            self.track_table.setItem(track_info['table_index'], 4, QTableWidgetItem("❌ Failed"))
            self.failed_downloads += 1
            if track_info not in self.permanently_failed_tracks:
                self.permanently_failed_tracks.append(track_info)
            self.update_failed_matches_button()
        
        self.completed_downloads += 1
        self.active_parallel_downloads -= 1
        self.download_progress.setValue(self.completed_downloads)
        self.start_next_batch_of_downloads()
    
    def on_parallel_track_failed(self, download_index, reason):
        """Handle failure of a parallel track download"""
        print(f"❌ Album parallel download {download_index + 1} failed: {reason}")
        self.on_parallel_track_completed(download_index, False)
    
    def update_failed_matches_button(self):
        """Shows, hides, and updates the counter on the 'Correct Failed Matches' button"""
        count = len(self.permanently_failed_tracks)
        if count > 0:
            self.correct_failed_btn.setText(f"🔧 Correct {count} Failed Match{'es' if count > 1 else ''}")
            self.correct_failed_btn.show()
        else:
            self.correct_failed_btn.hide()

    def find_track_index_in_album(self, spotify_track):
        """Find the table row index for a given Spotify track"""
        for i, album_track in enumerate(self.album.tracks):
            if album_track.id == spotify_track.id:
                return i
        return None
        
    def on_all_downloads_complete(self):
        """Handle completion of all downloads"""
        self.download_in_progress = False
        print("🎉 All album downloads completed!")
        self.cancel_btn.hide()
        
        # Emit process_finished signal to unlock UI
        self.process_finished.emit()

        # Determine the final message based on success or failure
        if self.permanently_failed_tracks:
            final_message = f"Completed downloading {self.successful_downloads}/{len(self.missing_tracks)} missing album tracks!\n\nYou can now manually correct any failed downloads or close this window."
            
            # If there are failures, ensure the modal is visible and bring it to the front
            if self.isHidden():
                self.show()
            self.activateWindow()
            self.raise_()
        else:
            final_message = f"Completed downloading {self.successful_downloads}/{len(self.missing_tracks)} missing album tracks!\n\nAll tracks were downloaded successfully!"

        QMessageBox.information(self, "Downloads Complete", final_message)

    def get_valid_candidates(self, results, spotify_track, query):
        """Score and filter search results, then perform strict artist verification"""
        if not results:
            return []

        # Get initial confident matches based on title, bitrate, etc.
        initial_candidates = self.matching_engine.find_best_slskd_matches(spotify_track, results)

        if not initial_candidates:
            print(f"⚠️ No initial candidates found for '{spotify_track.name}' from query '{query}'.")
            return []
            
        print(f"✅ Found {len(initial_candidates)} initial candidates for '{spotify_track.name}'. Now verifying artist...")

        # Perform strict artist verification on the initial candidates
        verified_candidates = []
        spotify_artist_name = spotify_track.artists[0] if spotify_track.artists else ""
        
        # Robust normalization for both artist name and file path
        normalized_spotify_artist = re.sub(r'[^a-zA-Z0-9]', '', spotify_artist_name).lower()

        for candidate in initial_candidates:
            # The 'filename' from Soulseek includes the full folder path
            slskd_full_path = candidate.filename
            
            # Apply the same robust normalization to the Soulseek path
            normalized_slskd_path = re.sub(r'[^a-zA-Z0-9]', '', slskd_full_path).lower()
            
            # Check if the cleaned artist's name is in the cleaned folder path
            if normalized_spotify_artist in normalized_slskd_path:
                print(f"✔️ Artist '{spotify_artist_name}' VERIFIED in path: '{slskd_full_path}'")
                verified_candidates.append(candidate)
            else:
                print(f"❌ Artist '{spotify_artist_name}' NOT found in path: '{slskd_full_path}'. Discarding candidate.")

        if verified_candidates:
            best_confidence = verified_candidates[0].confidence
            print(f"✅ Found {len(verified_candidates)} VERIFIED matches for '{spotify_track.name}'. Best score: {best_confidence:.2f}")
        else:
            print(f"⚠️ No verified matches found for '{spotify_track.name}' after checking file paths.")

        return verified_candidates
    
    def create_spotify_based_search_result_from_validation(self, slskd_result, spotify_metadata):
        """Create SpotifyBasedSearchResult from validation results"""
        class SpotifyBasedSearchResult:
            def __init__(self):
                self.filename = getattr(slskd_result, 'filename', f"{spotify_metadata.name}.flac")
                self.username = getattr(slskd_result, 'username', 'unknown')
                self.size = getattr(slskd_result, 'size', 0)
                self.quality = getattr(slskd_result, 'quality', 'flac')
                self.artist = spotify_metadata.artists[0] if spotify_metadata.artists else "Unknown"
                self.title = spotify_metadata.name
                self.album = spotify_metadata.album
        return SpotifyBasedSearchResult()

    # Inner class for the search worker
    class ParallelSearchWorker(QRunnable):
        def __init__(self, soulseek_client, query):
            super().__init__()
            self.soulseek_client = soulseek_client
            self.query = query
            self.signals = self.create_signals()

        def create_signals(self):
            class Signals(QObject):
                search_completed = pyqtSignal(list, str)
                search_failed = pyqtSignal(str, str)
            return Signals()

        def run(self):
            loop = None
            try:
                import asyncio
                loop = asyncio.new_event_loop()
                asyncio.set_event_loop(loop)
                search_result = loop.run_until_complete(self.soulseek_client.search(self.query))
                results_list = search_result[0] if isinstance(search_result, tuple) and search_result else []
                self.signals.search_completed.emit(results_list, self.query)
            except Exception as e:
                self.signals.search_failed.emit(self.query, str(e))
            finally:
                if loop: loop.close()
        
    def on_cancel_clicked(self):
        """Handle Cancel button"""
        self.cancel_operations()
        self.process_finished.emit()
        self.reject()
        
    def on_close_clicked(self):
        """Handle Close button"""
        if self.cancel_requested or not self.download_in_progress:
            self.cancel_operations()
            self.process_finished.emit()
        self.reject()
        
    def cancel_operations(self):
        """Cancel any ongoing operations"""
        print("🛑 Cancelling album download operations...")
        self.cancel_requested = True
        
        # Stop workers
        for worker in self.active_workers:
            if hasattr(worker, 'cancel'):
                worker.cancel()
        self.active_workers.clear()
        
        # Stop polling
        self.download_status_timer.stop()
        print("🛑 Album modal operations cancelled successfully.")
        
    def on_correct_failed_matches_clicked(self):
        """Handle failed matches correction using ManualMatchModal from sync.py"""
        if not self.permanently_failed_tracks: 
            return
            
        # Import the ManualMatchModal from sync.py
        from ui.pages.sync import ManualMatchModal
        
        manual_modal = ManualMatchModal(self)
        manual_modal.track_resolved.connect(self.on_manual_match_resolved)
        manual_modal.exec()

    def on_manual_match_resolved(self, resolved_track_info):
        """Handle a track being successfully resolved by the ManualMatchModal"""
        original_failed_track = next((t for t in self.permanently_failed_tracks if t['download_index'] == resolved_track_info['download_index']), None)
        if original_failed_track:
            self.permanently_failed_tracks.remove(original_failed_track)
        self.update_failed_matches_button()

class ArtistsPage(QWidget):
    def __init__(self, downloads_page=None, parent=None):
        super().__init__(parent)
        
        # Core clients
        self.spotify_client = None
        self.plex_client = None
        self.soulseek_client = None
        self.downloads_page = downloads_page  # Store reference to DownloadsPage
        self.matching_engine = MusicMatchingEngine()
        
        # State management
        self.selected_artist = None
        self.current_albums = []
        self.matched_count = 0
        self.artist_search_worker = None
        self.album_fetch_worker = None
        self.plex_library_worker = None
        
        # Album download tracking
        self.album_downloads = {}  # {album_id: {total_tracks: X, completed_tracks: Y, active_downloads: [download_ids], album_card: card_ref}}
        self.completed_downloads = set()  # Track downloads that have been completed (to handle cleanup)
        self.download_status_timer = QTimer(self)
        self.download_status_timer.timeout.connect(self.poll_album_download_statuses)
        self.download_status_timer.start(2000)  # Poll every 2 seconds (consistent with sync.py)
        self.download_status_pool = QThreadPool()
        self.download_status_pool.setMaxThreadCount(1)  # One worker at a time to avoid conflicts
        self._is_status_update_running = False
        
        # UI setup
        self.setup_ui()
        self.setup_clients()
    
    def setup_clients(self):
        """Initialize client connections"""
        try:
            self.spotify_client = SpotifyClient()
            self.plex_client = PlexClient()
            self.soulseek_client = SoulseekClient()
        except Exception as e:
            print(f"Failed to initialize clients: {e}")
    
    def setup_ui(self):
        self.setStyleSheet("""
            ArtistsPage {
                background: #191414;
            }
        """)
        
        main_layout = QVBoxLayout(self)
        main_layout.setContentsMargins(30, 30, 30, 30)
        main_layout.setSpacing(20)
        
        # Create main container for dynamic content switching
        self.main_container = QWidget()
        container_layout = QVBoxLayout(self.main_container)
        container_layout.setContentsMargins(0, 0, 0, 0)
        container_layout.setSpacing(0)
        
        # Initial centered search interface
        self.search_interface = self.create_search_interface()
        container_layout.addWidget(self.search_interface)
        
        # Artist view (initially hidden)
        self.artist_view = self.create_artist_view()
        self.artist_view.hide()
        container_layout.addWidget(self.artist_view)
        
        main_layout.addWidget(self.main_container)
    
    def create_search_interface(self):
        """Create the initial centered search interface"""
        widget = QWidget()
        layout = QVBoxLayout(widget)
        
        # Add vertical stretch to center content
        layout.addStretch(2)
        
        # Title section
        title_container = QWidget()
        title_layout = QVBoxLayout(title_container)
        title_layout.setAlignment(Qt.AlignmentFlag.AlignCenter)
        title_layout.setSpacing(10)
        
        title_label = QLabel("Discover Artists")
        title_label.setFont(QFont("Arial", 32, QFont.Weight.Bold))
        title_label.setStyleSheet("color: #ffffff;")
        title_label.setAlignment(Qt.AlignmentFlag.AlignCenter)
        
        subtitle_label = QLabel("Search for any artist to explore their complete discography")
        subtitle_label.setFont(QFont("Arial", 16))
        subtitle_label.setStyleSheet("color: #b3b3b3;")
        subtitle_label.setAlignment(Qt.AlignmentFlag.AlignCenter)
        
        title_layout.addWidget(title_label)
        title_layout.addWidget(subtitle_label)
        
        # Search bar
        search_container = QFrame()
        search_container.setFixedHeight(80)
        search_container.setStyleSheet("""
            QFrame {
                background: qlineargradient(x1:0, y1:0, x2:0, y2:1,
                    stop:0 rgba(50, 50, 50, 0.9),
                    stop:1 rgba(40, 40, 40, 0.95));
                border-radius: 16px;
                border: 2px solid rgba(29, 185, 84, 0.3);
            }
        """)
        
        search_layout = QHBoxLayout(search_container)
        search_layout.setContentsMargins(24, 20, 24, 20)
        search_layout.setSpacing(16)
        
        self.search_input = QLineEdit()
        self.search_input.setPlaceholderText("Search for an artist... (e.g., 'The Beatles', 'Taylor Swift')")
        self.search_input.setFixedHeight(40)
        self.search_input.setStyleSheet("""
            QLineEdit {
                background: rgba(70, 70, 70, 0.8);
                border: 2px solid rgba(100, 100, 100, 0.3);
                border-radius: 20px;
                padding: 0 20px;
                color: #ffffff;
                font-size: 16px;
                font-weight: 500;
            }
            QLineEdit:focus {
                border: 2px solid rgba(29, 185, 84, 0.8);
                background: rgba(80, 80, 80, 0.9);
            }
            QLineEdit::placeholder {
                color: rgba(255, 255, 255, 0.5);
            }
        """)
        self.search_input.returnPressed.connect(self.perform_artist_search)
        
        search_btn = QPushButton("🔍 Search Artists")
        search_btn.setFixedHeight(40)
        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: 14px;
                font-weight: bold;
                padding: 0 24px;
            }
            QPushButton:hover {
                background: qlineargradient(x1:0, y1:0, x2:0, y2:1,
                    stop:0 rgba(30, 215, 96, 1.0),
                    stop:1 rgba(26, 174, 81, 1.0));
            }
        """)
        search_btn.clicked.connect(self.perform_artist_search)
        
        search_layout.addWidget(self.search_input)
        search_layout.addWidget(search_btn)
        
        # Status label
        self.search_status = QLabel("Ready to search")
        self.search_status.setFont(QFont("Arial", 12))
        self.search_status.setStyleSheet("color: rgba(255, 255, 255, 0.7); padding: 10px;")
        self.search_status.setAlignment(Qt.AlignmentFlag.AlignCenter)
        
        # Artist results container (initially hidden)
        self.artist_results_container = QFrame()
        self.artist_results_container.setStyleSheet("""
            QFrame {
                background: rgba(30, 30, 30, 0.6);
                border-radius: 12px;
                border: 1px solid rgba(60, 60, 60, 0.4);
            }
        """)
        self.artist_results_container.hide()
        
        results_layout = QVBoxLayout(self.artist_results_container)
        results_layout.setContentsMargins(20, 16, 20, 20)
        results_layout.setSpacing(16)
        
        results_header = QLabel("Artist Results")
        results_header.setFont(QFont("Arial", 14, QFont.Weight.Bold))
        results_header.setStyleSheet("color: #ffffff;")
        
        results_layout.addWidget(results_header)
        
        # Scrollable artist results
        self.artist_scroll = QScrollArea()
        self.artist_scroll.setWidgetResizable(True)
        self.artist_scroll.setVerticalScrollBarPolicy(Qt.ScrollBarPolicy.ScrollBarAsNeeded)
        self.artist_scroll.setHorizontalScrollBarPolicy(Qt.ScrollBarPolicy.ScrollBarAlwaysOff)
        self.artist_scroll.setMaximumHeight(400)
        self.artist_scroll.setStyleSheet("""
            QScrollArea {
                border: none;
                background: transparent;
            }
            QScrollBar:vertical {
                background: rgba(80, 80, 80, 0.3);
                width: 8px;
                border-radius: 4px;
            }
            QScrollBar::handle:vertical {
                background: rgba(29, 185, 84, 0.8);
                border-radius: 4px;
                min-height: 20px;
            }
        """)
        
        self.artist_results_widget = QWidget()
        self.artist_results_layout = QHBoxLayout(self.artist_results_widget)
        self.artist_results_layout.setSpacing(16)
        self.artist_results_layout.setContentsMargins(0, 0, 0, 0)
        
        self.artist_scroll.setWidget(self.artist_results_widget)
        results_layout.addWidget(self.artist_scroll)
        
        # Add everything to main layout
        layout.addWidget(title_container)
        layout.addSpacing(40)
        layout.addWidget(search_container)
        layout.addSpacing(20)
        layout.addWidget(self.search_status)
        layout.addSpacing(20)
        layout.addWidget(self.artist_results_container)
        layout.addStretch(2)
        
        return widget
    
    def create_artist_view(self):
        """Create the artist view for displaying albums"""
        widget = QWidget()
        layout = QVBoxLayout(widget)
        layout.setContentsMargins(0, 0, 0, 0)
        layout.setSpacing(20)
        
        # Header with artist info and repositioned search
        header = QFrame()
        header.setFixedHeight(100)
        header.setStyleSheet("""
            QFrame {
                background: qlineargradient(x1:0, y1:0, x2:0, y2:1,
                    stop:0 rgba(40, 40, 40, 0.9),
                    stop:1 rgba(30, 30, 30, 0.95));
                border-radius: 12px;
                border: 1px solid rgba(60, 60, 60, 0.4);
            }
        """)
        
        header_layout = QHBoxLayout(header)
        header_layout.setContentsMargins(20, 16, 20, 16)
        header_layout.setSpacing(20)
        
        # Artist info section
        artist_info_layout = QVBoxLayout()
        
        self.artist_name_label = QLabel()
        self.artist_name_label.setFont(QFont("Arial", 20, QFont.Weight.Bold))
        self.artist_name_label.setStyleSheet("color: #ffffff;")
        
        self.artist_stats_label = QLabel()
        self.artist_stats_label.setFont(QFont("Arial", 11))
        self.artist_stats_label.setStyleSheet("color: #b3b3b3;")
        
        artist_info_layout.addWidget(self.artist_name_label)
        artist_info_layout.addWidget(self.artist_stats_label)
        
        # New search bar (smaller, in header)
        self.header_search_input = QLineEdit()
        self.header_search_input.setPlaceholderText("Search for another artist...")
        self.header_search_input.setFixedHeight(36)
        self.header_search_input.setFixedWidth(300)
        self.header_search_input.setStyleSheet("""
            QLineEdit {
                background: rgba(60, 60, 60, 0.8);
                border: 1px solid rgba(100, 100, 100, 0.4);
                border-radius: 18px;
                padding: 0 16px;
                color: #ffffff;
                font-size: 12px;
            }
            QLineEdit:focus {
                border: 1px solid rgba(29, 185, 84, 0.8);
            }
        """)
        self.header_search_input.returnPressed.connect(self.perform_new_artist_search)
        
        # Back button
        back_btn = QPushButton("← Back to Search")
        back_btn.setFixedHeight(36)
        back_btn.setStyleSheet("""
            QPushButton {
                background: transparent;
                border: 1px solid rgba(29, 185, 84, 0.6);
                border-radius: 18px;
                color: #1db954;
                font-size: 12px;
                padding: 0 16px;
            }
            QPushButton:hover {
                background: rgba(29, 185, 84, 0.1);
            }
        """)
        back_btn.clicked.connect(self.return_to_search)
        
        header_layout.addLayout(artist_info_layout)
        header_layout.addStretch()
        header_layout.addWidget(self.header_search_input)
        header_layout.addWidget(back_btn)
        
        # Albums section
        albums_container = QFrame()
        albums_container.setStyleSheet("""
            QFrame {
                background: rgba(25, 25, 25, 0.6);
                border-radius: 12px;
                border: 1px solid rgba(50, 50, 50, 0.4);
            }
        """)
        
        albums_layout = QVBoxLayout(albums_container)
        albums_layout.setContentsMargins(20, 16, 20, 20)
        albums_layout.setSpacing(16)
        
        # Albums header
        albums_header_layout = QHBoxLayout()
        
        albums_title = QLabel("Albums")
        albums_title.setFont(QFont("Arial", 16, QFont.Weight.Bold))
        albums_title.setStyleSheet("color: #ffffff;")
        
        self.albums_status = QLabel("Loading albums...")
        self.albums_status.setFont(QFont("Arial", 11))
        self.albums_status.setStyleSheet("color: #b3b3b3;")
        
        albums_header_layout.addWidget(albums_title)
        albums_header_layout.addStretch()
        albums_header_layout.addWidget(self.albums_status)
        
        albums_layout.addLayout(albums_header_layout)
        
        # Albums grid
        self.albums_scroll = QScrollArea()
        self.albums_scroll.setWidgetResizable(True)
        self.albums_scroll.setVerticalScrollBarPolicy(Qt.ScrollBarPolicy.ScrollBarAsNeeded)
        self.albums_scroll.setHorizontalScrollBarPolicy(Qt.ScrollBarPolicy.ScrollBarAlwaysOff)
        self.albums_scroll.setStyleSheet("""
            QScrollArea {
                border: none;
                background: transparent;
            }
            QScrollBar:vertical {
                background: rgba(80, 80, 80, 0.3);
                width: 8px;
                border-radius: 4px;
            }
            QScrollBar::handle:vertical {
                background: rgba(29, 185, 84, 0.8);
                border-radius: 4px;
                min-height: 20px;
            }
        """)
        
        self.albums_widget = QWidget()
        self.albums_grid_layout = QGridLayout(self.albums_widget)
        self.albums_grid_layout.setSpacing(16)
        self.albums_grid_layout.setContentsMargins(0, 0, 0, 0)
        
        self.albums_scroll.setWidget(self.albums_widget)
        albums_layout.addWidget(self.albums_scroll)
        
        layout.addWidget(header)
        layout.addWidget(albums_container, 1)
        
        return widget
    
    def perform_artist_search(self):
        """Perform artist search"""
        query = self.search_input.text().strip()
        if not query:
            self.search_status.setText("Please enter an artist name")
            self.search_status.setStyleSheet("color: #ff6b6b; padding: 10px;")
            return
        
        if not self.spotify_client or not self.spotify_client.is_authenticated():
            self.search_status.setText("Spotify not connected")
            self.search_status.setStyleSheet("color: #ff6b6b; padding: 10px;")
            return
        
        self.search_status.setText("🔍 Searching for artists...")
        self.search_status.setStyleSheet("color: #1db954; padding: 10px;")
        
        # Clear previous results
        self.clear_artist_results()
        
        # Start search worker
        if self.artist_search_worker:
            self.artist_search_worker.terminate()
            self.artist_search_worker.wait()
        
        self.artist_search_worker = ArtistSearchWorker(query, self.spotify_client, self.matching_engine)
        self.artist_search_worker.artists_found.connect(self.on_artists_found)
        self.artist_search_worker.search_failed.connect(self.on_artist_search_failed)
        self.artist_search_worker.start()
    
    def perform_new_artist_search(self):
        """Perform new artist search from header"""
        query = self.header_search_input.text().strip()
        if query:
            self.search_input.setText(query)
            self.return_to_search()
            QTimer.singleShot(100, self.perform_artist_search)
    
    def on_artists_found(self, artist_matches):
        """Handle artist search results"""
        if not artist_matches:
            self.search_status.setText("No artists found")
            self.search_status.setStyleSheet("color: #ff6b6b; padding: 10px;")
            return
        
        self.search_status.setText(f"Found {len(artist_matches)} artists")
        self.search_status.setStyleSheet("color: #1db954; padding: 10px;")
        
        # Display artist results
        for artist_match in artist_matches[:10]:  # Show top 10 results
            card = ArtistResultCard(artist_match)
            card.artist_selected.connect(self.on_artist_selected)
            self.artist_results_layout.addWidget(card)
        
        self.artist_results_layout.addStretch()
        self.artist_results_container.show()
    
    def on_artist_search_failed(self, error):
        """Handle artist search failure"""
        self.search_status.setText(f"Search failed: {error}")
        self.search_status.setStyleSheet("color: #ff6b6b; padding: 10px;")
    
    def on_artist_selected(self, artist):
        """Handle artist selection"""
        self.selected_artist = artist
        
        # Update artist view
        self.artist_name_label.setText(artist.name)
        self.artist_stats_label.setText(f"{artist.followers:,} followers • {len(artist.genres)} genres")
        
        # Switch to artist view
        self.search_interface.hide()
        self.artist_view.show()
        
        # Start fetching albums
        self.fetch_artist_albums(artist)
    
    def fetch_artist_albums(self, artist):
        """Fetch albums for selected artist"""
        self.albums_status.setText("Loading albums...")
        
        # Clear previous albums
        self.clear_albums()
        
        # Start album fetch worker
        if self.album_fetch_worker:
            self.album_fetch_worker.terminate()
            self.album_fetch_worker.wait()
        
        self.album_fetch_worker = AlbumFetchWorker(artist, self.spotify_client)
        self.album_fetch_worker.albums_found.connect(self.on_albums_found)
        self.album_fetch_worker.fetch_failed.connect(self.on_album_fetch_failed)
        self.album_fetch_worker.start()
    
    def on_albums_found(self, albums, artist):
        """Handle album fetch results"""
        if not albums:
            self.albums_status.setText("No albums found")
            return
        
        self.current_albums = albums
        self.albums_status.setText(f"Found {len(albums)} albums • Checking Plex library...")
        
        # Initialize match counter for real-time updates
        self.matched_count = 0
        
        # Display albums immediately (without ownership info)
        self.display_albums(albums, set())
        
        # Start Plex library check in background - will update UI when complete
        self.start_plex_library_check(albums)
    
    def display_albums(self, albums, owned_albums):
        """Display albums in the grid"""
        print(f"🎨 Displaying {len(albums)} albums, {len(owned_albums)} owned")
        
        # Clear existing albums
        self.clear_albums()
        
        row, col = 0, 0
        max_cols = 5
        
        for album in albums:
            is_owned = album.name in owned_albums
            
            card = AlbumCard(album, is_owned)
            if not is_owned:
                card.download_requested.connect(self.on_album_download_requested)
            
            self.albums_grid_layout.addWidget(card, row, col)
            
            col += 1
            if col >= max_cols:
                col = 0
                row += 1
    
    def start_plex_library_check(self, albums):
        """Start Plex library check in background"""
        # Stop any existing Plex worker
        if self.plex_library_worker:
            self.plex_library_worker.stop()
            self.plex_library_worker.terminate()
            self.plex_library_worker.wait()
        
        # Start new Plex worker
        self.plex_library_worker = PlexLibraryWorker(albums, self.plex_client, self.matching_engine)
        self.plex_library_worker.library_checked.connect(self.on_plex_library_checked)
        self.plex_library_worker.album_matched.connect(self.on_album_matched)
        self.plex_library_worker.check_failed.connect(self.on_plex_library_check_failed)
        self.plex_library_worker.start()
    
    def on_plex_library_checked(self, owned_albums):
        """Handle final Plex library check completion"""
        print(f"📨 Plex check completed: {len(owned_albums)} total matches")
        
        if not self.current_albums:
            print("📨 No current albums, skipping final update")
            return
        
        # Update final status message
        owned_count = len(owned_albums)
        total_count = len(self.current_albums)
        missing_count = total_count - owned_count
        
        self.albums_status.setText(f"Found {total_count} albums • {owned_count} owned • {missing_count} available for download")
        
        print(f"✅ Plex check complete: {owned_count}/{total_count} albums owned")
    
    def on_album_matched(self, album_name):
        """Handle individual album match for real-time UI update"""
        print(f"🎯 Real-time match: '{album_name}'")
        
        # Update match counter
        self.matched_count += 1
        
        # Update status text in real-time
        if self.current_albums:
            total_count = len(self.current_albums)
            remaining_count = total_count - self.matched_count
            self.albums_status.setText(f"Found {total_count} albums • {self.matched_count} owned • {remaining_count} checking...")
        
        # Find and update the specific album card
        for i in range(self.albums_grid_layout.count()):
            item = self.albums_grid_layout.itemAt(i)
            if item and item.widget():
                album_card = item.widget()
                if hasattr(album_card, 'album') and album_card.album.name == album_name:
                    print(f"🔄 Real-time update: '{album_name}' -> owned")
                    album_card.update_ownership(True)
                    break
    
    def on_plex_library_check_failed(self, error):
        """Handle Plex library check failure"""
        print(f"Plex library check failed: {error}")
        if self.current_albums:
            self.albums_status.setText(f"Found {len(self.current_albums)} albums • Plex check failed")
            # Display albums without ownership info
            self.display_albums(self.current_albums, set())
    
    def on_album_fetch_failed(self, error):
        """Handle album fetch failure"""
        self.albums_status.setText(f"Failed to load albums: {error}")
    
    def on_album_download_requested(self, album: Album):
        """Handle album download request from an AlbumCard using new modal system."""
        print(f"🎵 Download requested for album: {album.name} by {', '.join(album.artists)}")
        
        # Find the album card for this album to pass to modal
        album_card = None
        for i in range(self.albums_grid_layout.count()):
            item = self.albums_grid_layout.itemAt(i)
            if item and item.widget():
                card = item.widget()
                if hasattr(card, 'album') and card.album.id == album.id:
                    album_card = card
                    break
        
        if not album_card:
            QMessageBox.critical(self, "Error", "Could not find album card for tracking.")
            return
            
        # Check if we have necessary clients
        if not self.downloads_page:
            QMessageBox.critical(self, "Error", "Downloads page is not connected. Cannot start download.")
            return
            
        if not self.plex_client:
            QMessageBox.critical(self, "Error", "Plex client is not available. Cannot verify existing tracks.")
            return
        
        print("🚀 Fetching album tracks and creating DownloadMissingAlbumTracksModal...")
        
        # First, we need to fetch the tracks for this album
        try:
            # Get the full album data with tracks from Spotify
            album_data = self.spotify_client.get_album(album.id)
            if not album_data or not album_data.get('tracks'):
                QMessageBox.critical(self, "Error", f"Could not fetch tracks for album '{album.name}'. Please try again.")
                return
            
            # Import Track class for track creation
            from core.spotify_client import Track
            
            # Convert track data to Track objects
            tracks = []
            track_items = album_data['tracks']['items']
            
            for track_data in track_items:
                # Add missing fields that are required by Track.from_spotify_track()
                track_data['album'] = {
                    'name': album_data['name'],
                    'id': album_data['id']
                }
                # Album tracks don't have popularity field, so set it to 0
                if 'popularity' not in track_data:
                    track_data['popularity'] = 0
                    
                track = Track.from_spotify_track(track_data)
                tracks.append(track)
                
            print(f"✅ Fetched {len(tracks)} tracks for album '{album.name}'")
            
            # Create a copy of the album with tracks added
            album_with_tracks = album
            album_with_tracks.tracks = tracks  # Add tracks attribute dynamically
            
            # Create and show the new sophisticated modal
            modal = DownloadMissingAlbumTracksModal(
                album=album_with_tracks,  # Use the album with tracks
                album_card=album_card,
                parent_page=self,
                downloads_page=self.downloads_page,
                plex_client=self.plex_client
            )
            
            # Connect the process finished signal to handle cleanup
            modal.process_finished.connect(lambda: self.on_album_download_process_finished(album.id, album_card))
            
            # Show the modal
            modal.exec()
            
        except Exception as e:
            print(f"❌ Error fetching album tracks: {e}")
            QMessageBox.critical(self, "Error", f"Failed to fetch album tracks: {str(e)}\n\nPlease check your Spotify connection and try again.")
    
    def on_album_download_process_finished(self, album_id: str, album_card):
        """Handle cleanup when album download process is finished"""
        print(f"🏁 Album download process finished for album: {album_id}")
        
        # Reset the album card state if needed
        if album_card and hasattr(album_card, 'set_download_completed'):
            album_card.set_download_completed()
        
        print("✅ Album download process cleanup completed")
    
    # === LEGACY METHODS - NO LONGER USED WITH NEW MODAL SYSTEM ===
    # These methods were part of the old manual album download flow
    # Keeping them commented for reference but they are replaced by DownloadMissingAlbumTracksModal
    
    # def on_album_selected_for_download(self, album_result: AlbumResult):
    #     """
    #     [DEPRECATED] Handles album selection from the search dialog and delegates the
    #     matched album download process to the main DownloadsPage.
    #     REPLACED BY: DownloadMissingAlbumTracksModal which handles everything internally
    #     """
    #     print(f"Selected album for download: {album_result.album_title} by {album_result.artist}")
    #     
    #     if self.downloads_page:
    #         # Start tracking this album download
    #         album_id = f"{self.album_to_download.id}"
    #         self.start_album_download_tracking(album_id, album_result, self.album_to_download)
    #         
    #         # Delegate to the DownloadsPage to handle the matched download
    #         # This will open the Spotify matching modal and add to the central queue
    #         print("🚀 Delegating to DownloadsPage to start matched album download...")
    #         self.downloads_page.start_matched_album_download(album_result)
    #     else:
    #         QMessageBox.critical(self, "Error", "Downloads page is not connected. Cannot start download.")
    
    # def start_album_download_tracking(self, album_id: str, album_result: AlbumResult, spotify_album: Album):
    #     """
    #     [DEPRECATED] Start tracking downloads for an album
    #     REPLACED BY: DownloadMissingAlbumTracksModal handles its own tracking
    #     """
    #     # Find the album card for this album
    #     album_card = None
    #     for i in range(self.albums_grid_layout.count()):
    #         item = self.albums_grid_layout.itemAt(i)
    #         if item and item.widget():
    #             card = item.widget()
    #             if hasattr(card, 'album') and card.album.id == spotify_album.id:
    #                 album_card = card
    #                 break
    #     
    #     if album_card:
    #         # Initialize tracking for this album
    #         self.album_downloads[album_id] = {
    #             'total_tracks': album_result.track_count,
    #             'completed_tracks': 0,
    #             'active_downloads': [],
    #             'album_card': album_card,
    #             'album_result': album_result,
    #             'spotify_album': spotify_album
    #         }
    #         
    #         # Update album card to show download in progress
    #         album_card.set_download_in_progress()
    #         print(f"📊 Started tracking album: {spotify_album.name} ({album_result.track_count} tracks)")
    
    # === END LEGACY METHODS ===
    
    def poll_album_download_statuses(self):
        """Poll download statuses for tracked albums"""
        if self._is_status_update_running or not self.album_downloads:
            return
        
        # Collect all active download IDs from tracked albums
        all_download_ids = []
        for album_info in self.album_downloads.values():
            all_download_ids.extend(album_info.get('active_downloads', []))
        
        if not all_download_ids:
            # No active downloads to check, but we might need to populate the active_downloads
            # by checking the downloads page for downloads related to our tracked albums
            self.update_active_downloads_from_queue()
            return
        
        self._is_status_update_running = True
        
        # Create items to check with enhanced data structure for album tracking
        items_to_check = []
        
        # Build comprehensive data for each tracked download
        for album_id, album_info in self.album_downloads.items():
            active_downloads = album_info.get('active_downloads', [])
            
            for download_id in active_downloads:
                # Try to get filename from downloads page if possible
                file_path = self._get_download_filename(download_id)
                
                item_data = {
                    'widget_id': download_id,  # Use download_id as widget_id for tracking
                    'download_id': download_id,
                    'file_path': file_path,
                    'api_missing_count': 0,  # Track for grace period logic
                    'album_id': album_id  # Link back to album for easier processing
                }
                items_to_check.append(item_data)
        
        if not items_to_check:
            self._is_status_update_running = False
            return
        
        print(f"🔍 Starting album status check for {len(items_to_check)} downloads across {len(self.album_downloads)} albums")
        
        # Create and start our dedicated album worker
        worker = AlbumStatusProcessingWorker(
            self.soulseek_client,
            items_to_check
        )
        worker.signals.completed.connect(self._handle_album_status_updates)
        worker.signals.error.connect(lambda e: self._on_album_status_error(e))
        self.download_status_pool.start(worker)
    
    def _get_download_filename(self, download_id):
        """Try to get filename for a download ID from the downloads page"""
        if not self.downloads_page or not hasattr(self.downloads_page, 'download_queue'):
            return ''
        
        # Check active queue first
        if hasattr(self.downloads_page.download_queue, 'active_queue'):
            for item in self.downloads_page.download_queue.active_queue.download_items:
                # Check for exact ID match first
                if hasattr(item, 'download_id') and item.download_id == download_id:
                    if hasattr(item, 'filename'):
                        return item.filename
                    elif hasattr(item, 'title'):
                        return f"{item.title}.mp3"  # Fallback with extension
                
                # Also check if the real ID of this item matches
                real_id = self._get_real_download_id(item)
                if real_id and real_id == download_id:
                    if hasattr(item, 'filename'):
                        return item.filename
                    elif hasattr(item, 'title'):
                        return f"{item.title}.mp3"  # Fallback with extension
        
        # Check finished queue
        if hasattr(self.downloads_page.download_queue, 'finished_queue'):
            for item in self.downloads_page.download_queue.finished_queue.download_items:
                # Check for exact ID match first
                if hasattr(item, 'download_id') and item.download_id == download_id:
                    if hasattr(item, 'filename'):
                        return item.filename
                    elif hasattr(item, 'title'):
                        return f"{item.title}.mp3"  # Fallback with extension
                
                # Also check if the real ID of this item matches
                real_id = self._get_real_download_id(item)
                if real_id and real_id == download_id:
                    if hasattr(item, 'filename'):
                        return item.filename
                    elif hasattr(item, 'title'):
                        return f"{item.title}.mp3"  # Fallback with extension
        
        return ''
    
    def _on_album_status_error(self, error_msg):
        """Handle errors from album status worker"""
        print(f"❌ Album status worker error: {error_msg}")
        self._is_status_update_running = False
    
    def update_active_downloads_from_queue(self):
        """Update active downloads list by checking the downloads page queue"""
        if not self.downloads_page or not hasattr(self.downloads_page, 'download_queue'):
            return
        
        # Get all active downloads from the downloads page
        active_items = []
        finished_items = []
        
        if hasattr(self.downloads_page.download_queue, 'active_queue'):
            active_items = self.downloads_page.download_queue.active_queue.download_items
        
        if hasattr(self.downloads_page.download_queue, 'finished_queue'):
            finished_items = self.downloads_page.download_queue.finished_queue.download_items
        
        print(f"🔍 Checking {len(active_items)} active downloads and {len(finished_items)} finished downloads for album tracking")
        
        # For each tracked album, check if any downloads match
        for album_id, album_info in self.album_downloads.items():
            album_result = album_info.get('album_result')
            spotify_album = album_info.get('spotify_album')
            if not album_result or not spotify_album:
                continue
            
            album_name = spotify_album.name if spotify_album else 'Unknown'
            print(f"🎵 Looking for downloads matching album: {album_name} by {album_result.artist}")
            
            # Look for downloads that match this album's tracks (both active and finished)
            matching_downloads = []
            completed_count = 0
            
            # Check both active and finished downloads
            all_items = active_items + finished_items
            
            for download_item in all_items:
                # Enhanced matching logic for better album detection
                is_match = self._is_download_from_album(download_item, album_result, spotify_album)
                
                if is_match:
                    # Debug: show what download ID we're working with
                    current_id = getattr(download_item, 'download_id', 'NO_ID')
                    title = getattr(download_item, 'title', 'Unknown')
                    print(f"   🔍 Found matching item: '{title}' with download_id: {current_id}")
                    
                    # Use the download ID directly from the item (should be the real one)
                    if current_id and current_id != 'NO_ID':
                        # Check if this item is in finished items (completed)
                        if download_item in finished_items:
                            completed_count += 1
                            print(f"   ✅ Found completed track: '{title}' (ID: {current_id})")
                        else:
                            # It's an active download - use the current ID
                            matching_downloads.append(current_id)
                            print(f"   🔄 Added active download ID: {current_id} for '{title}'")
                    else:
                        print(f"   ⚠️ No download ID found for: '{title}'")
            
            # Update the active downloads and completed count for this album
            old_active = album_info.get('active_downloads', [])
            old_completed = album_info.get('completed_tracks', 0)
            
            album_info['active_downloads'] = matching_downloads
            
            # Update completed tracks count if we found more completed items
            if completed_count > old_completed:
                print(f"📈 Updating completed tracks: {old_completed} -> {completed_count}")
                album_info['completed_tracks'] = completed_count
                # Trigger UI update
                self.update_album_card_progress(album_id)
            
            # Log changes
            if len(matching_downloads) != len(old_active) or completed_count != old_completed:
                print(f"📊 Album '{album_name}': {len(old_active)} -> {len(matching_downloads)} active, {old_completed} -> {completed_count} completed")
            
            if not matching_downloads and completed_count == 0:
                total_tracks = album_info.get('total_tracks', 0)
                print(f"❌ No matching downloads found for album: {album_name} (expected {total_tracks} tracks)")
    
    def _get_real_download_id(self, download_item):
        """Extract the real slskd download ID from a download item"""
        if not hasattr(download_item, 'download_id'):
            return None
            
        download_id = download_item.download_id
        
        # Check if it's already a UUID (real ID from slskd)
        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, re.IGNORECASE):
            # It's already a real UUID
            return download_id
        
        # Check if it's a simple numeric ID
        if download_id.isdigit():
            return download_id
        
        # If it's a composite ID like "username_filename_timestamp_suffix", 
        # we need to look it up in the slskd API by filename
        if hasattr(download_item, 'filename') and download_item.filename:
            # Try to find the real ID by querying current downloads by filename
            real_id = self._lookup_download_id_by_filename(download_item.filename)
            if real_id:
                print(f"🔍 Found real ID {real_id} for composite ID {download_id}")
                return real_id
        
        # If we can't determine the real ID, return the composite one
        # The worker will try filename matching as fallback
        return download_id
    
    def _lookup_download_id_by_filename(self, filename):
        """Look up the real download ID by filename from slskd API"""
        if not self.soulseek_client:
            return None
            
        try:
            import asyncio
            import os
            
            # Create a temporary event loop to make the API call
            loop = asyncio.new_event_loop()
            asyncio.set_event_loop(loop)
            
            try:
                transfers_data = loop.run_until_complete(
                    self.soulseek_client._make_request('GET', 'transfers/downloads')
                )
                
                if not transfers_data:
                    return None
                
                expected_basename = os.path.basename(filename).lower()
                
                # Search through all transfers for matching filename
                for user_data in transfers_data:
                    # Check files directly under user object
                    if 'files' in user_data and isinstance(user_data['files'], list):
                        for file_data in user_data['files']:
                            api_filename = file_data.get('filename', '')
                            api_basename = os.path.basename(api_filename).lower()
                            if api_basename == expected_basename:
                                return file_data.get('id')
                    
                    # Check files in directories
                    if 'directories' in user_data and isinstance(user_data['directories'], list):
                        for directory in user_data['directories']:
                            if 'files' in directory and isinstance(directory['files'], list):
                                for file_data in directory['files']:
                                    api_filename = file_data.get('filename', '')
                                    api_basename = os.path.basename(api_filename).lower()
                                    if api_basename == expected_basename:
                                        return file_data.get('id')
                
            finally:
                loop.close()
                
        except Exception as e:
            print(f"❌ Error looking up download ID for {filename}: {e}")
            
        return None
    
    def _is_download_from_album(self, download_item, album_result, spotify_album):
        """Enhanced matching logic to determine if a download belongs to the tracked album"""
        # Check for explicit album match flag (from Spotify matching modal)
        if hasattr(download_item, 'matched_download') and download_item.matched_download:
            print(f"   🎯 Found explicitly matched download: {getattr(download_item, 'title', 'Unknown')}")
            return True
        
        # Check for album metadata match
        if hasattr(download_item, 'album') and download_item.album and spotify_album:
            download_album = download_item.album.lower().strip()
            spotify_album_name = spotify_album.name.lower().strip()
            
            # Exact or partial album name match
            if (download_album == spotify_album_name or 
                download_album in spotify_album_name or 
                spotify_album_name in download_album):
                print(f"   🎵 Album name match: '{download_album}' ~ '{spotify_album_name}'")
                return True
        
        # Check artist matching
        artist_match = False
        if hasattr(download_item, 'artist') and download_item.artist:
            download_artist = download_item.artist.lower().strip()
            
            # Check against album result artist
            if album_result and album_result.artist:
                album_artist = album_result.artist.lower().strip()
                if (download_artist == album_artist or 
                    download_artist in album_artist or 
                    album_artist in download_artist):
                    artist_match = True
            
            # Check against Spotify album artists
            if spotify_album and spotify_album.artists:
                for spotify_artist in spotify_album.artists:
                    spotify_artist_name = spotify_artist.lower().strip()
                    if (download_artist == spotify_artist_name or 
                        download_artist in spotify_artist_name or 
                        spotify_artist_name in download_artist):
                        artist_match = True
                        break
        
        # For artist match, also check if it's recent (to avoid false positives from other albums)
        if artist_match:
            # Check if download was started recently (within album tracking timeframe)
            # This helps filter out downloads from other albums by the same artist
            if hasattr(download_item, 'created_time') or hasattr(download_item, 'start_time'):
                # Could add timestamp checking here if needed
                pass
            print(f"   👤 Artist match found for: {getattr(download_item, 'title', 'Unknown')}")
            return True
        
        # Check filename-based matching as last resort
        if hasattr(download_item, 'filename') and download_item.filename:
            filename = download_item.filename.lower()
            
            # Check if filename contains album name
            if spotify_album and spotify_album.name.lower() in filename:
                print(f"   📂 Filename contains album name: {download_item.filename}")
                return True
            
            # Check if filename contains artist name
            if album_result and album_result.artist and album_result.artist.lower() in filename:
                print(f"   📂 Filename contains artist name: {download_item.filename}")
                return True
        
        return False
    
    def _handle_album_status_updates(self, results):
        """Handle status updates from the background worker"""
        if not results:
            self._is_status_update_running = False
            return
        
        print(f"📊 Processing {len(results)} album download status updates")
        
        albums_to_update = set()
        albums_completed = set()
        
        for result in results:
            download_id = result.get('download_id')
            widget_id = result.get('widget_id')
            status = result.get('status', '')
            progress = result.get('progress', 0.0)
            album_id = result.get('album_id')  # Direct album link from our enhanced data
            
            # Handle missing downloads with grace period
            if status == 'missing':
                api_missing_count = result.get('api_missing_count', 0)
                # Check if this download was previously completed but now missing (due to cleanup)
                if self._was_download_previously_completed(download_id):
                    print(f"✅ Download {download_id} was previously completed (now cleaned up)")
                    status = 'completed'  # Treat as completed
                else:
                    # Update the missing count in our tracking data for next poll
                    self._update_missing_count(download_id, api_missing_count)
                    continue
            
            # Find which album this download belongs to
            target_album_id = album_id  # Use direct link if available
            if not target_album_id:
                # Fallback: search through all albums
                for aid, album_info in self.album_downloads.items():
                    if download_id in album_info.get('active_downloads', []):
                        target_album_id = aid
                        break
            
            if not target_album_id or target_album_id not in self.album_downloads:
                print(f"⚠️ Could not find album for download {download_id}")
                continue
            
            album_info = self.album_downloads[target_album_id]
            album_name = album_info.get('spotify_album', {}).name if album_info.get('spotify_album') else 'Unknown'
            
            print(f"🎵 Album '{album_name}': Download {download_id} status = {status} ({progress:.1f}%)")
            
            # Handle status changes
            if status == 'completed':
                # Only process if not already handled by notification system
                if not self._was_download_previously_completed(download_id):
                    # Mark this download as completed in our tracking
                    self._mark_download_as_completed(download_id)
                    
                    # Only increment if not already counted
                    if download_id in album_info.get('active_downloads', []):
                        album_info['completed_tracks'] += 1
                        album_info['active_downloads'].remove(download_id)
                        albums_to_update.add(target_album_id)
                        print(f"✅ Album track completed via polling: {album_info['completed_tracks']}/{album_info['total_tracks']}")
                        
                        # Check if album is fully completed
                        if (album_info['completed_tracks'] >= album_info['total_tracks'] and 
                            not album_info.get('active_downloads')):
                            albums_completed.add(target_album_id)
                else:
                    print(f"✅ Download {download_id} already counted as completed")
            
            elif status in ['failed', 'cancelled']:
                # Remove from active downloads but don't increment completed
                if download_id in album_info['active_downloads']:
                    album_info['active_downloads'].remove(download_id)
                albums_to_update.add(target_album_id)
                print(f"❌ Album track {status}: {download_id}")
            
            elif status in ['downloading', 'queued']:
                # Update progress for in-progress downloads
                albums_to_update.add(target_album_id)
                if progress > 0:
                    print(f"⏳ Track downloading: {progress:.1f}%")
        
        # Update album cards for albums that had status changes
        for album_id in albums_to_update:
            self.update_album_card_progress(album_id)
        
        # Handle completed albums
        for album_id in albums_completed:
            album_info = self.album_downloads[album_id]
            album_card = album_info.get('album_card')
            spotify_album = album_info.get('spotify_album')
            album_name = spotify_album.name if spotify_album else 'Unknown'
            
            if album_card:
                album_card.set_download_completed()
            
            # Remove from tracking
            del self.album_downloads[album_id]
            print(f"🎉 Album download completed and removed from tracking: {album_name}")
        
        self._is_status_update_running = False
    
    def _update_missing_count(self, download_id, missing_count):
        """Update missing count for downloads in grace period"""
        # Find and update the missing count in our tracked items
        # This helps maintain grace period logic across polling cycles
        for album_info in self.album_downloads.values():
            if download_id in album_info.get('active_downloads', []):
                # We could store per-download missing counts if needed
                # For now, if missing count reaches 3, the worker marks it as failed
                if missing_count >= 3:
                    # Remove from active downloads as it's considered failed
                    album_info['active_downloads'] = [
                        did for did in album_info.get('active_downloads', []) 
                        if did != download_id
                    ]
                    print(f"❌ Removed failed download {download_id} from album tracking")
                break
    
    def _mark_download_as_completed(self, download_id):
        """Mark a download as completed to handle cleanup detection"""
        if download_id:
            self.completed_downloads.add(download_id)
            print(f"📝 Marked download {download_id} as completed")
    
    def _was_download_previously_completed(self, download_id):
        """Check if a download was previously marked as completed"""
        return download_id in self.completed_downloads
    
    def notify_download_completed(self, download_id, download_item=None):
        """Called by downloads page when a download completes (before cleanup)"""
        print(f"🔔 Downloads page notified completion of: {download_id}")
        if download_item:
            print(f"   Item: '{getattr(download_item, 'title', 'Unknown')}' by '{getattr(download_item, 'artist', 'Unknown')}'")
        
        # Check if already processed to prevent double counting
        if self._was_download_previously_completed(download_id):
            print(f"⏭️ Download {download_id} already processed, skipping")
            return
        
        # Mark as completed immediately
        self._mark_download_as_completed(download_id)
        
        # Find which album this belongs to - try multiple approaches
        target_album_id = None
        
        # Approach 1: Direct ID match (might work if IDs were updated)
        for album_id, album_info in self.album_downloads.items():
            if download_id in album_info.get('active_downloads', []):
                target_album_id = album_id
                print(f"✅ Found album by direct ID match: {album_id}")
                break
        
        # Approach 2: Match by download item attributes if we have the item
        if not target_album_id and download_item:
            for album_id, album_info in self.album_downloads.items():
                album_result = album_info.get('album_result')
                spotify_album = album_info.get('spotify_album')
                
                if self._is_download_from_album(download_item, album_result, spotify_album):
                    target_album_id = album_id
                    print(f"✅ Found album by item matching: {album_id}")
                    break
        
        # Approach 3: Remove any composite ID that might match this download
        if not target_album_id and download_item:
            item_title = getattr(download_item, 'title', '')
            for album_id, album_info in self.album_downloads.items():
                # Look for any active download that might be this track
                active_downloads = album_info.get('active_downloads', [])
                for active_id in active_downloads[:]:  # Copy list to avoid modification during iteration
                    # Check if this composite ID refers to the same track
                    if item_title and item_title.lower() in active_id.lower():
                        # Replace the composite ID with the real ID
                        album_info['active_downloads'].remove(active_id)
                        album_info['active_downloads'].append(download_id)
                        target_album_id = album_id
                        print(f"✅ Found album by title matching and updated ID: {active_id} -> {download_id}")
                        break
                
                if target_album_id:
                    break
        
        if target_album_id:
            album_info = self.album_downloads[target_album_id]
            
            # Remove the download ID from active downloads (might be composite or real)
            if download_id in album_info['active_downloads']:
                album_info['active_downloads'].remove(download_id)
            
            # Increment completed count
            album_info['completed_tracks'] += 1
            
            # Update UI immediately
            self.update_album_card_progress(target_album_id)
            
            spotify_album = album_info.get('spotify_album')
            album_name = spotify_album.name if spotify_album else 'Unknown'
            print(f"✅ Album '{album_name}' track completed via notification: {album_info['completed_tracks']}/{album_info['total_tracks']}")
            
            # Check if album is complete
            if (album_info['completed_tracks'] >= album_info['total_tracks'] and 
                not album_info.get('active_downloads')):
                
                album_card = album_info.get('album_card')
                if album_card:
                    album_card.set_download_completed()
                
                # Remove from tracking
                del self.album_downloads[target_album_id]
                print(f"🎉 Album download completed via notification: {album_name}")
        else:
            print(f"⚠️ Could not find album for completed download: {download_id}")
            if download_item:
                print(f"   Title: '{getattr(download_item, 'title', 'Unknown')}'")
                print(f"   Artist: '{getattr(download_item, 'artist', 'Unknown')}'")
                print(f"   Album: '{getattr(download_item, 'album', 'Unknown')}'")
            
            # List current tracked albums for debugging
            print(f"   Currently tracking {len(self.album_downloads)} albums:")
            for aid, ainfo in self.album_downloads.items():
                sa = ainfo.get('spotify_album')
                name = sa.name if sa else 'Unknown'
                active_count = len(ainfo.get('active_downloads', []))
                print(f"     {aid}: '{name}' ({active_count} active downloads)")
    
    def update_album_card_progress(self, album_id: str):
        """Update the album card with current download progress"""
        album_info = self.album_downloads.get(album_id)
        if not album_info:
            return
        
        album_card = album_info.get('album_card')
        if not album_card:
            return
        
        completed = album_info.get('completed_tracks', 0)
        total = album_info.get('total_tracks', 1)  # Avoid division by zero
        active_downloads = album_info.get('active_downloads', [])
        
        # Calculate progress percentage
        percentage = int((completed / total) * 100) if total > 0 else 0
        
        # Determine album download state
        if completed >= total and not active_downloads:
            # Album is fully complete - this will be handled in the main status handler
            # Don't call set_download_completed here to avoid duplicate processing
            print(f"🎯 Album '{album_info.get('spotify_album', {}).name if album_info.get('spotify_album') else 'Unknown'}' is complete: {completed}/{total}")
            return
        elif not active_downloads and completed == 0:
            # No active downloads and nothing completed - might be initializing
            album_card.set_download_in_progress()
            print(f"🔄 Album initializing downloads...")
        elif active_downloads:
            # Has active downloads - show progress
            album_card.update_download_progress(completed, total, percentage)
            print(f"📊 Album progress: {completed}/{total} tracks ({percentage}%)")
        else:
            # Some completed but no active - might be stalled or failed
            if completed > 0:
                album_card.update_download_progress(completed, total, percentage)
                print(f"⚠️ Album partially complete: {completed}/{total} tracks ({percentage}%)")
            else:
                album_card.set_download_in_progress()
                print(f"🔄 Album status unclear, showing in progress...")
        
        # Update the album card's status indicator to show download activity
        if hasattr(album_card, 'status_indicator'):
            if active_downloads:
                # Show progress percentage or downloading indicator
                if percentage > 0:
                    album_card.status_indicator.setText(f"{percentage}%")
                    album_card.status_indicator.setToolTip(f"Downloading: {completed}/{total} tracks ({percentage}%)")
                else:
                    album_card.status_indicator.setText("⏳")
                    album_card.status_indicator.setToolTip("Starting download...")
            elif completed > 0:
                # Show partial completion
                album_card.status_indicator.setText(f"{percentage}%")
                album_card.status_indicator.setToolTip(f"Partially downloaded: {completed}/{total} tracks")

    def return_to_search(self):
        """Return to search interface"""
        # Stop any running workers
        self.stop_all_workers()
        
        # Clear state
        self.selected_artist = None
        self.current_albums = []
        self.matched_count = 0
        self.header_search_input.clear()
        
        # Clear albums display
        self.clear_albums()
        
        # Switch views
        self.artist_view.hide()
        self.search_interface.show()
    
    def cleanup_download_tracking(self):
        """Clean up download tracking resources"""
        print("🧹 Starting album download tracking cleanup...")
        
        # Stop the download status timer
        if hasattr(self, 'download_status_timer') and self.download_status_timer.isActive():
            self.download_status_timer.stop()
            print("   ⏹️ Stopped download status timer")
        
        # Reset any album cards that are showing download progress
        cards_reset = 0
        for album_info in list(self.album_downloads.values()):
            album_card = album_info.get('album_card')
            if album_card:
                # Hide progress overlays
                if hasattr(album_card, 'progress_overlay'):
                    album_card.progress_overlay.hide()
                
                # Reset status indicator if album wasn't owned originally
                if hasattr(album_card, 'update_ownership') and not album_card.is_owned:
                    # Reset to available for download state
                    album_card.update_ownership(False)
                
                cards_reset += 1
        
        if cards_reset > 0:
            print(f"   🔄 Reset {cards_reset} album cards")
        
        # Clear download tracking state
        tracked_albums = len(self.album_downloads)
        completed_downloads = len(self.completed_downloads)
        self.album_downloads.clear()
        self.completed_downloads.clear()
        self._is_status_update_running = False
        
        if tracked_albums > 0:
            print(f"   🗑️ Cleared tracking for {tracked_albums} albums")
        
        # Shutdown the download status thread pool gracefully
        if hasattr(self, 'download_status_pool'):
            try:
                # Clear any pending tasks
                self.download_status_pool.clear()
                
                # Wait for active tasks to complete (with timeout)
                if not self.download_status_pool.waitForDone(2000):  # Wait up to 2 seconds
                    print("   ⚠️ Download status pool did not finish within timeout")
                else:
                    print("   ✅ Download status pool shut down cleanly")
                    
            except Exception as e:
                print(f"   ❌ Error cleaning up download status pool: {e}")
        
        print("🧹 Album download tracking cleanup completed")
    
    def restart_download_tracking(self):
        """Restart download tracking timer if stopped"""
        if hasattr(self, 'download_status_timer') and not self.download_status_timer.isActive():
            self.download_status_timer.start(2000)
            print("🔄 Download tracking timer restarted")
    
    def stop_all_workers(self):
        """Stop all background workers"""
        print("🛑 Stopping all artist page workers...")
        
        workers_stopped = 0
        
        if self.artist_search_worker and self.artist_search_worker.isRunning():
            print("   🔍 Stopping artist search worker...")
            self.artist_search_worker.terminate()
            if self.artist_search_worker.wait(2000):  # Wait up to 2 seconds
                print("   ✅ Artist search worker stopped")
            else:
                print("   ⚠️ Artist search worker did not stop within timeout")
            self.artist_search_worker = None
            workers_stopped += 1
            
        if self.album_fetch_worker and self.album_fetch_worker.isRunning():
            print("   📀 Stopping album fetch worker...")
            self.album_fetch_worker.terminate()
            if self.album_fetch_worker.wait(2000):  # Wait up to 2 seconds
                print("   ✅ Album fetch worker stopped")
            else:
                print("   ⚠️ Album fetch worker did not stop within timeout")
            self.album_fetch_worker = None
            workers_stopped += 1
            
        if self.plex_library_worker and self.plex_library_worker.isRunning():
            print("   📚 Stopping Plex library worker...")
            self.plex_library_worker.stop()
            self.plex_library_worker.terminate()
            if self.plex_library_worker.wait(2000):  # Wait up to 2 seconds
                print("   ✅ Plex library worker stopped")
            else:
                print("   ⚠️ Plex library worker did not stop within timeout")
            self.plex_library_worker = None
            workers_stopped += 1
        
        if workers_stopped > 0:
            print(f"   🛑 Stopped {workers_stopped} background workers")
        
        # Stop download tracking (this includes its own worker cleanup)
        self.cleanup_download_tracking()
        
        print("🛑 All workers stopped")
    
    def clear_artist_results(self):
        """Clear artist search results"""
        while self.artist_results_layout.count() > 0:
            item = self.artist_results_layout.takeAt(0)
            if item.widget():
                item.widget().deleteLater()
        self.artist_results_container.hide()
    
    def clear_albums(self):
        """Clear album display"""
        while self.albums_grid_layout.count() > 0:
            item = self.albums_grid_layout.takeAt(0)
            if item.widget():
                item.widget().deleteLater()
        # Don't clear self.current_albums here - it's needed for Plex updates
    
    def closeEvent(self, event):
        """Handle page close/cleanup"""
        self.stop_all_workers()
        super().closeEvent(event)