Kemono-Downloader/main.py

import sys
import os
import time
import requests
import re
import threading
import queue # Standard library queue, not directly used for the new link queue
import hashlib
import http.client
import traceback
import random # <-- Import random for generating delays
from collections import deque # <-- Import deque for the link queue

from concurrent.futures import ThreadPoolExecutor, CancelledError, Future

from PyQt5.QtGui import (
    QIcon,
    QIntValidator
)
from PyQt5.QtWidgets import (
    QApplication, QWidget, QLabel, QLineEdit, QTextEdit, QPushButton,
    QVBoxLayout, QHBoxLayout, QFileDialog, QMessageBox, QListWidget,
    QRadioButton, QButtonGroup, QCheckBox, QSplitter, QSizePolicy, QDialog,
    QFrame,
    QAbstractButton
)
from PyQt5.QtCore import Qt, QThread, pyqtSignal, QMutex, QMutexLocker, QObject, QTimer, QSettings
from urllib.parse import urlparse

try:
    from PIL import Image
except ImportError:
    Image = None

from io import BytesIO

# --- Import from downloader_utils ---
try:
    print("Attempting to import from downloader_utils...")
    from downloader_utils import (
        KNOWN_NAMES,
        clean_folder_name,
        extract_post_info,
        download_from_api,
        PostProcessorSignals,
        PostProcessorWorker,
        DownloadThread as BackendDownloadThread, # Renamed to avoid conflict
        SKIP_SCOPE_FILES,
        SKIP_SCOPE_POSTS,
        SKIP_SCOPE_BOTH
    )
    print("Successfully imported names from downloader_utils.")
except ImportError as e:
    print(f"--- IMPORT ERROR ---")
    print(f"Failed to import from 'downloader_utils.py': {e}")
    # Define fallbacks if import fails, so the app might still run with limited functionality or show an error.
    KNOWN_NAMES = []
    PostProcessorSignals = QObject # Fallback to base QObject
    PostProcessorWorker = object # Fallback to base object
    BackendDownloadThread = QThread # Fallback to base QThread
    def clean_folder_name(n): return str(n) # Simple fallback
    def extract_post_info(u): return None, None, None # Fallback
    def download_from_api(*a, **k): yield [] # Fallback generator
    SKIP_SCOPE_FILES = "files"
    SKIP_SCOPE_POSTS = "posts"
    SKIP_SCOPE_BOTH = "both"
    # Potentially show a critical error to the user here if downloader_utils is essential
    # For now, printing to console is the primary error indication.
except Exception as e:
    print(f"--- UNEXPECTED IMPORT ERROR ---")
    print(f"An unexpected error occurred during import: {e}")
    traceback.print_exc()
    print(f"-----------------------------", file=sys.stderr)
    sys.exit(1) # Exit if a critical, unexpected error occurs during import
# --- End Import ---

# --- Import Tour Dialog ---
try:
    from tour import TourDialog # Assuming tour.py exists in the same directory
    print("Successfully imported TourDialog from tour.py.")
except ImportError as e:
    print(f"--- TOUR IMPORT ERROR ---")
    print(f"Failed to import TourDialog from 'tour.py': {e}")
    print("Tour functionality will be unavailable.")
    TourDialog = None # Fallback if tour.py is not found
except Exception as e:
    print(f"--- UNEXPECTED TOUR IMPORT ERROR ---")
    print(f"An unexpected error occurred during tour import: {e}")
    traceback.print_exc()
    TourDialog = None
# --- End Tour Import ---


# --- Constants for Thread Limits ---
MAX_THREADS = 200 # Max post workers for creator feeds
RECOMMENDED_MAX_THREADS = 50 # Recommended max post workers
MAX_FILE_THREADS_PER_POST_OR_WORKER = 10 # Max file download threads for single post or per creator feed worker
# --- END ---

HTML_PREFIX = "<!HTML!>" # Prefix to indicate a log message is HTML

# --- QSettings Constants ---
CONFIG_ORGANIZATION_NAME = "KemonoDownloader" # Company/Organization Name for settings
CONFIG_APP_NAME_MAIN = "ApplicationSettings"  # Application Name for settings
MANGA_FILENAME_STYLE_KEY = "mangaFilenameStyleV1" # Key for storing manga filename style
STYLE_POST_TITLE = "post_title" # Constant for post title filename style
STYLE_ORIGINAL_NAME = "original_name" # Constant for original filename style
SKIP_WORDS_SCOPE_KEY = "skipWordsScopeV1" # Key for storing skip words scope
# --- END QSettings ---


class DownloaderApp(QWidget):
    # Signals for cross-thread communication and UI updates
    character_prompt_response_signal = pyqtSignal(bool) # Signal for character prompt response
    log_signal = pyqtSignal(str) # Signal for logging messages to the UI
    add_character_prompt_signal = pyqtSignal(str) # Signal to prompt adding a character
    overall_progress_signal = pyqtSignal(int, int) # Signal for overall download progress (total, processed)
    finished_signal = pyqtSignal(int, int, bool, list) # Signal when download finishes (dl_count, skip_count, cancelled, kept_original_names)
    external_link_signal = pyqtSignal(str, str, str, str) # Signal for found external links (post_title, link_text, url, platform)
    file_progress_signal = pyqtSignal(str, int, int) # Signal for individual file download progress (filename, downloaded_bytes, total_bytes)


    def __init__(self):
        super().__init__()
        # Initialize QSettings for storing application settings persistently
        self.settings = QSettings(CONFIG_ORGANIZATION_NAME, CONFIG_APP_NAME_MAIN)
        self.config_file = "Known.txt" # File to store known character/show names

        # Download process related attributes
        self.download_thread = None # Holds the single download thread instance
        self.thread_pool = None # Holds the ThreadPoolExecutor for multi-threaded downloads
        self.cancellation_event = threading.Event() # Event to signal cancellation to threads
        self.active_futures = [] # List of active Future objects from the thread pool
        self.total_posts_to_process = 0 # Total posts identified for the current download
        self.processed_posts_count = 0 # Number of posts processed so far
        self.download_counter = 0 # Total files downloaded in the current session/run
        self.skip_counter = 0 # Total files skipped in the current session/run

        # Signals object for PostProcessorWorker instances
        self.worker_signals = PostProcessorSignals()
        # Mutex and response attribute for synchronous character add prompt
        self.prompt_mutex = QMutex()
        self._add_character_response = None

        # Sets to keep track of downloaded files/hashes to avoid re-downloads in the same session
        self.downloaded_files = set() # Set of downloaded filenames (final saved names)
        self.downloaded_files_lock = threading.Lock() # Lock for accessing downloaded_files set
        self.downloaded_file_hashes = set() # Set of MD5 hashes of downloaded files
        self.downloaded_file_hashes_lock = threading.Lock() # Lock for accessing downloaded_file_hashes set

        # External links related attributes
        self.show_external_links = False # Flag to control display of external links log
        self.external_link_queue = deque() # Queue for processing external links with delays
        self._is_processing_external_link_queue = False # Flag to prevent concurrent processing of the link queue
        self._current_link_post_title = None # Tracks current post title for grouping links in "Only Links" mode
        self.extracted_links_cache = [] # Cache of all extracted links for "Only Links" mode display and export

        # UI and Logging related attributes
        self.basic_log_mode = False # Flag for toggling basic/full log verbosity
        self.log_verbosity_button = None # Button to toggle log verbosity
        self.manga_rename_toggle_button = None # Button to toggle manga filename style

        self.main_log_output = None # QTextEdit for main progress log
        self.external_log_output = None # QTextEdit for external links log
        self.log_splitter = None # QSplitter for main and external logs
        self.main_splitter = None # Main QSplitter for left (controls) and right (logs) panels
        self.reset_button = None # Button to reset application state
        self.progress_log_label = None # Label above the main log area

        self.link_search_input = None # QLineEdit for searching in extracted links
        self.link_search_button = None # QPushButton to trigger link search/filter
        self.export_links_button = None # QPushButton to export extracted links

        self.manga_mode_checkbox = None # QCheckBox for enabling Manga/Comic mode
        self.radio_only_links = None # QRadioButton for "Only Links" filter mode
        self.radio_only_archives = None # QRadioButton for "Only Archives" filter mode
        
        self.skip_scope_toggle_button = None # Button to cycle skip words scope

        # List to store filenames that kept their original names (for manga mode logging)
        self.all_kept_original_filenames = []

        # Load persistent settings or use defaults
        self.manga_filename_style = self.settings.value(MANGA_FILENAME_STYLE_KEY, STYLE_POST_TITLE, type=str)
        self.skip_words_scope = self.settings.value(SKIP_WORDS_SCOPE_KEY, SKIP_SCOPE_FILES, type=str)


        self.load_known_names_from_util() # Load known names from config file
        self.setWindowTitle("Kemono Downloader v3.1.0") # Update version number
        self.setGeometry(150, 150, 1050, 820) # Set initial window size and position
        self.setStyleSheet(self.get_dark_theme()) # Apply a dark theme stylesheet
        self.init_ui() # Initialize the user interface elements
        self._connect_signals() # Connect signals to their respective slots

        # Initial log messages
        self.log_signal.emit("ℹ️ Local API server functionality has been removed.")
        self.log_signal.emit("ℹ️ 'Skip Current File' button has been removed.")
        if hasattr(self, 'character_input'): # Set tooltip for character input if it exists
            self.character_input.setToolTip("Enter one or more character names, separated by commas (e.g., yor, makima)")
        self.log_signal.emit(f"ℹ️ Manga filename style loaded: '{self.manga_filename_style}'")
        self.log_signal.emit(f"ℹ️ Skip words scope loaded: '{self.skip_words_scope}'")


    def _connect_signals(self):
        """Connects various signals from UI elements and worker threads to their handler methods."""
        # Worker signals (from PostProcessorWorker via PostProcessorSignals)
        if hasattr(self.worker_signals, 'progress_signal'):
             self.worker_signals.progress_signal.connect(self.handle_main_log)
        if hasattr(self.worker_signals, 'file_progress_signal'):
            self.worker_signals.file_progress_signal.connect(self.update_file_progress_display)
        if hasattr(self.worker_signals, 'external_link_signal'):
            self.worker_signals.external_link_signal.connect(self.handle_external_link_signal)

        # Internal app signals
        self.log_signal.connect(self.handle_main_log)
        self.add_character_prompt_signal.connect(self.prompt_add_character)
        self.character_prompt_response_signal.connect(self.receive_add_character_result)
        self.overall_progress_signal.connect(self.update_progress_display)
        self.finished_signal.connect(self.download_finished)
        self.external_link_signal.connect(self.handle_external_link_signal) # Also connect direct app signal
        self.file_progress_signal.connect(self.update_file_progress_display) # Also connect direct app signal

        # UI element signals
        if hasattr(self, 'character_search_input'): self.character_search_input.textChanged.connect(self.filter_character_list)
        if hasattr(self, 'external_links_checkbox'): self.external_links_checkbox.toggled.connect(self.update_external_links_setting)
        if hasattr(self, 'thread_count_input'): self.thread_count_input.textChanged.connect(self.update_multithreading_label)
        if hasattr(self, 'use_subfolder_per_post_checkbox'): self.use_subfolder_per_post_checkbox.toggled.connect(self.update_ui_for_subfolders)
        if hasattr(self, 'use_multithreading_checkbox'): self.use_multithreading_checkbox.toggled.connect(self._handle_multithreading_toggle)

        # Radio button group for file filters
        if hasattr(self, 'radio_group') and self.radio_group:
            # Connect only once to the buttonToggled signal of the QButtonGroup
            self.radio_group.buttonToggled.connect(self._handle_filter_mode_change)

        # Button clicks
        if self.reset_button: self.reset_button.clicked.connect(self.reset_application_state)
        if self.log_verbosity_button: self.log_verbosity_button.clicked.connect(self.toggle_log_verbosity)

        # Link search UI signals (for "Only Links" mode)
        if self.link_search_button: self.link_search_button.clicked.connect(self._filter_links_log)
        if self.link_search_input:
            self.link_search_input.returnPressed.connect(self._filter_links_log) # Filter on Enter
            self.link_search_input.textChanged.connect(self._filter_links_log) # Live filtering as text changes
        if self.export_links_button: self.export_links_button.clicked.connect(self._export_links_to_file)

        # Manga mode UI signals
        if self.manga_mode_checkbox: self.manga_mode_checkbox.toggled.connect(self.update_ui_for_manga_mode)
        if self.manga_rename_toggle_button: self.manga_rename_toggle_button.clicked.connect(self._toggle_manga_filename_style)

        # URL input text change (affects manga mode UI and page range)
        if hasattr(self, 'link_input'):
            self.link_input.textChanged.connect(lambda: self.update_ui_for_manga_mode(self.manga_mode_checkbox.isChecked() if self.manga_mode_checkbox else False))
        
        # Skip words scope toggle button
        if self.skip_scope_toggle_button:
            self.skip_scope_toggle_button.clicked.connect(self._cycle_skip_scope)


    def load_known_names_from_util(self):
        """Loads known character/show names from the config file into the global KNOWN_NAMES list."""
        global KNOWN_NAMES # Access the global list (potentially shared with downloader_utils)
        if os.path.exists(self.config_file):
            try:
                with open(self.config_file, 'r', encoding='utf-8') as f:
                    raw_names = [line.strip() for line in f]
                    # Update KNOWN_NAMES in-place to ensure shared references (like in downloader_utils) are updated
                    KNOWN_NAMES[:] = sorted(list(set(filter(None, raw_names)))) # Unique, sorted, non-empty names
                log_msg = f"ℹ️ Loaded {len(KNOWN_NAMES)} known names from {self.config_file}"
            except Exception as e:
                log_msg = f"❌ Error loading config '{self.config_file}': {e}"
                QMessageBox.warning(self, "Config Load Error", f"Could not load list from {self.config_file}:\n{e}")
                KNOWN_NAMES[:] = [] # Reset to empty if loading fails
        else:
            log_msg = f"ℹ️ Config file '{self.config_file}' not found. Starting empty."
            KNOWN_NAMES[:] = [] # Ensure it's empty if file doesn't exist

        if hasattr(self, 'log_signal'): self.log_signal.emit(log_msg) # Log loading status
        
        # Update the QListWidget in the UI with the loaded names
        if hasattr(self, 'character_list'):
            self.character_list.clear()
            self.character_list.addItems(KNOWN_NAMES)

    def save_known_names(self):
        """Saves the current list of known names to the config file."""
        global KNOWN_NAMES # Access the global (potentially shared) list
        try:
            # Ensure KNOWN_NAMES itself is updated to the unique sorted list before saving
            unique_sorted_names = sorted(list(set(filter(None, KNOWN_NAMES))))
            KNOWN_NAMES[:] = unique_sorted_names # Modify in-place

            with open(self.config_file, 'w', encoding='utf-8') as f:
                for name in unique_sorted_names:
                    f.write(name + '\n')
            if hasattr(self, 'log_signal'): self.log_signal.emit(f"💾 Saved {len(unique_sorted_names)} known names to {self.config_file}")
        except Exception as e:
            log_msg = f"❌ Error saving config '{self.config_file}': {e}"
            if hasattr(self, 'log_signal'): self.log_signal.emit(log_msg)
            QMessageBox.warning(self, "Config Save Error", f"Could not save list to {self.config_file}:\n{e}")

    def closeEvent(self, event):
        """Handles the application close event. Saves settings and manages active downloads."""
        # Save known names and other persistent settings
        self.save_known_names()
        self.settings.setValue(MANGA_FILENAME_STYLE_KEY, self.manga_filename_style)
        self.settings.setValue(SKIP_WORDS_SCOPE_KEY, self.skip_words_scope)
        self.settings.sync() # Ensure settings are written to disk

        should_exit = True
        is_downloading = self._is_download_active() # Check if any download is currently active

        if is_downloading:
             # Confirm with the user if they want to exit while a download is in progress
             reply = QMessageBox.question(self, "Confirm Exit",
                                          "Download in progress. Are you sure you want to exit and cancel?",
                                          QMessageBox.Yes | QMessageBox.No, QMessageBox.No) # Default to No
             if reply == QMessageBox.Yes:
                 self.log_signal.emit("⚠️ Cancelling active download due to application exit...")
                 self.cancel_download() # Signal cancellation to active threads/pool
                 self.log_signal.emit("   Waiting briefly for threads to acknowledge cancellation...")
                 
                 # Wait for threads to finish, with a timeout
                 if self.download_thread and self.download_thread.isRunning():
                     self.download_thread.wait(3000) # Wait up to 3 seconds for single thread
                     if self.download_thread.isRunning():
                         self.log_signal.emit("   ⚠️ Single download thread did not terminate gracefully.")
                 if self.thread_pool:
                     # Shutdown with cancel_futures=True. The wait=True here might block,
                     # but cancel_download should have already signaled futures.
                     self.thread_pool.shutdown(wait=True, cancel_futures=True)
                     self.log_signal.emit("   Thread pool shutdown complete.")
                     self.thread_pool = None # Clear the reference
             else:
                 should_exit = False # User chose not to exit
                 self.log_signal.emit("ℹ️ Application exit cancelled.")
                 event.ignore() # Ignore the close event
                 return # Don't proceed to exit

        if should_exit:
            self.log_signal.emit("ℹ️ Application closing.")
            # Ensure any remaining pool is shut down if not already handled
            if self.thread_pool:
                 self.log_signal.emit("   Final thread pool check: Shutting down...")
                 self.cancellation_event.set() # Ensure cancellation event is set
                 self.thread_pool.shutdown(wait=True, cancel_futures=True) # Wait for shutdown
                 self.thread_pool = None
            self.log_signal.emit("👋 Exiting application.")
            event.accept() # Accept the close event


    def init_ui(self):
        """Initializes all UI elements and layouts."""
        # Main layout splitter (divides window into left controls panel and right logs panel)
        self.main_splitter = QSplitter(Qt.Horizontal)
        left_panel_widget = QWidget() # Container widget for the left panel
        right_panel_widget = QWidget() # Container widget for the right panel
        left_layout = QVBoxLayout(left_panel_widget) # Main vertical layout for the left panel
        right_layout = QVBoxLayout(right_panel_widget) # Main vertical layout for the right panel
        left_layout.setContentsMargins(10, 10, 10, 10) # Add some padding around left panel contents
        right_layout.setContentsMargins(10, 10, 10, 10) # Add padding around right panel contents

        # --- Left Panel (Controls) ---

        # URL and Page Range Input Section
        url_page_layout = QHBoxLayout() # Horizontal layout for URL and page range inputs
        url_page_layout.setContentsMargins(0,0,0,0) # No internal margins for this specific QHBoxLayout
        url_page_layout.addWidget(QLabel("🔗 Kemono Creator/Post URL:"))
        self.link_input = QLineEdit()
        self.link_input.setPlaceholderText("e.g., https://kemono.su/patreon/user/12345 or .../post/98765")
        self.link_input.textChanged.connect(self.update_custom_folder_visibility) # Connect to update custom folder UI
        url_page_layout.addWidget(self.link_input, 1) # Allow URL input to stretch

        # Page range inputs (Start and End)
        self.page_range_label = QLabel("Page Range:")
        self.page_range_label.setStyleSheet("font-weight: bold; padding-left: 10px;") # Style for emphasis
        self.start_page_input = QLineEdit()
        self.start_page_input.setPlaceholderText("Start")
        self.start_page_input.setFixedWidth(50) # Fixed width for small input
        self.start_page_input.setValidator(QIntValidator(1, 99999)) # Allow only positive integers
        self.to_label = QLabel("to") # Simple "to" label between inputs
        self.end_page_input = QLineEdit()
        self.end_page_input.setPlaceholderText("End")
        self.end_page_input.setFixedWidth(50)
        self.end_page_input.setValidator(QIntValidator(1, 99999))
        # Add page range widgets to the horizontal layout
        url_page_layout.addWidget(self.page_range_label)
        url_page_layout.addWidget(self.start_page_input)
        url_page_layout.addWidget(self.to_label)
        url_page_layout.addWidget(self.end_page_input)
        left_layout.addLayout(url_page_layout) # Add URL/Page layout to the main left layout

        # Download Directory Input Section
        left_layout.addWidget(QLabel("📁 Download Location:"))
        self.dir_input = QLineEdit()
        self.dir_input.setPlaceholderText("Select folder where downloads will be saved")
        self.dir_button = QPushButton("Browse...") # Button to open file dialog
        self.dir_button.clicked.connect(self.browse_directory)
        dir_layout = QHBoxLayout() # Horizontal layout for directory input and browse button
        dir_layout.addWidget(self.dir_input, 1) # Allow directory input to stretch
        dir_layout.addWidget(self.dir_button)
        left_layout.addLayout(dir_layout)


        # Container for Character Filter and Custom Folder (to manage visibility together)
        self.filters_and_custom_folder_container_widget = QWidget()
        filters_and_custom_folder_layout = QHBoxLayout(self.filters_and_custom_folder_container_widget)
        filters_and_custom_folder_layout.setContentsMargins(0, 5, 0, 0) # Top margin, no others
        filters_and_custom_folder_layout.setSpacing(10) # Spacing between filter and custom folder

        # Character Filter (will be added to the container)
        self.character_filter_widget = QWidget() # Dedicated widget for character filter
        character_filter_v_layout = QVBoxLayout(self.character_filter_widget)
        character_filter_v_layout.setContentsMargins(0,0,0,0) # No internal margins for this VBox
        character_filter_v_layout.setSpacing(2) # Minimal spacing between label and input
        self.character_label = QLabel("🎯 Filter by Character(s) (comma-separated):")
        self.character_input = QLineEdit()
        self.character_input.setPlaceholderText("e.g., yor, Tifa, Reyna")
        character_filter_v_layout.addWidget(self.character_label)
        character_filter_v_layout.addWidget(self.character_input)

        # Custom Folder Name (will be added to the container)
        self.custom_folder_widget = QWidget() # Dedicated widget for custom folder input
        custom_folder_v_layout = QVBoxLayout(self.custom_folder_widget)
        custom_folder_v_layout.setContentsMargins(0,0,0,0) # No internal margins
        custom_folder_v_layout.setSpacing(2)
        self.custom_folder_label = QLabel("🗄️ Custom Folder Name (Single Post Only):")
        self.custom_folder_input = QLineEdit()
        self.custom_folder_input.setPlaceholderText("Optional: Save this post to specific folder")
        custom_folder_v_layout.addWidget(self.custom_folder_label)
        custom_folder_v_layout.addWidget(self.custom_folder_input)
        self.custom_folder_widget.setVisible(False) # Initially hidden, shown based on URL and settings

        # Add character filter and custom folder widgets to their container layout
        filters_and_custom_folder_layout.addWidget(self.character_filter_widget, 1) # Allow stretch
        filters_and_custom_folder_layout.addWidget(self.custom_folder_widget, 1)  # Allow stretch

        # Add the container widget to the main left layout
        left_layout.addWidget(self.filters_and_custom_folder_container_widget)


        # Skip Words Input Section
        left_layout.addWidget(QLabel("🚫 Skip with Words (comma-separated):"))
        skip_input_and_button_layout = QHBoxLayout() # Horizontal layout for skip words input and scope button
        skip_input_and_button_layout.setContentsMargins(0, 0, 0, 0)
        skip_input_and_button_layout.setSpacing(10)
        self.skip_words_input = QLineEdit()
        self.skip_words_input.setPlaceholderText("e.g., WM, WIP, sketch, preview")
        skip_input_and_button_layout.addWidget(self.skip_words_input, 3) # Give more space to input
        self.skip_scope_toggle_button = QPushButton() # Text set by _update_skip_scope_button_text
        self._update_skip_scope_button_text() # Set initial text based on loaded/default scope
        self.skip_scope_toggle_button.setToolTip("Click to cycle skip scope (Files -> Posts -> Both)")
        self.skip_scope_toggle_button.setStyleSheet("padding: 6px 10px;") # Ensure consistent padding
        self.skip_scope_toggle_button.setMinimumWidth(100) # Ensure button is wide enough for text
        skip_input_and_button_layout.addWidget(self.skip_scope_toggle_button, 1) # Add scope button
        left_layout.addLayout(skip_input_and_button_layout)


        # File Filter Radio Buttons Section
        file_filter_layout = QVBoxLayout() # Vertical layout for the file filter section
        file_filter_layout.setContentsMargins(0,10,0,0) # Add some top margin for separation
        file_filter_layout.addWidget(QLabel("Filter Files:")) # Section label
        radio_button_layout = QHBoxLayout() # Horizontal layout for the radio buttons themselves
        radio_button_layout.setSpacing(10) # Adjusted spacing between radio buttons
        self.radio_group = QButtonGroup(self) # Group to ensure only one radio button is selected
        # Define radio buttons
        self.radio_all = QRadioButton("All")
        self.radio_images = QRadioButton("Images/GIFs")
        self.radio_videos = QRadioButton("Videos")
        self.radio_only_archives = QRadioButton("📦 Only Archives") # New radio button for archives
        self.radio_only_links = QRadioButton("🔗 Only Links")
        self.radio_all.setChecked(True) # Default selection
        # Add buttons to the group
        self.radio_group.addButton(self.radio_all)
        self.radio_group.addButton(self.radio_images)
        self.radio_group.addButton(self.radio_videos)
        self.radio_group.addButton(self.radio_only_archives) # Add new button to group
        self.radio_group.addButton(self.radio_only_links)
        # Add buttons to the horizontal layout
        radio_button_layout.addWidget(self.radio_all)
        radio_button_layout.addWidget(self.radio_images)
        radio_button_layout.addWidget(self.radio_videos)
        radio_button_layout.addWidget(self.radio_only_archives) # Add new button to layout
        radio_button_layout.addWidget(self.radio_only_links)
        radio_button_layout.addStretch(1) # Push buttons to the left, filling remaining space
        file_filter_layout.addLayout(radio_button_layout) # Add radio button layout to section layout
        left_layout.addLayout(file_filter_layout) # Add section layout to main left layout

        # Checkboxes Group Section (for various download options)
        checkboxes_group_layout = QVBoxLayout() # Vertical layout for checkbox groups
        checkboxes_group_layout.setSpacing(10) # Spacing between rows of checkboxes
        
        # Row 1 of Checkboxes (Skip ZIP/RAR, Thumbnails, Compress)
        row1_layout = QHBoxLayout() # Horizontal layout for the first row of checkboxes
        row1_layout.setSpacing(10)
        self.skip_zip_checkbox = QCheckBox("Skip .zip")
        self.skip_zip_checkbox.setChecked(True) # Default to skipping ZIPs
        row1_layout.addWidget(self.skip_zip_checkbox)
        self.skip_rar_checkbox = QCheckBox("Skip .rar")
        self.skip_rar_checkbox.setChecked(True) # Default to skipping RARs
        row1_layout.addWidget(self.skip_rar_checkbox)
        self.download_thumbnails_checkbox = QCheckBox("Download Thumbnails Only")
        self.download_thumbnails_checkbox.setChecked(False) # Default to not downloading only thumbnails
        self.download_thumbnails_checkbox.setToolTip("Thumbnail download functionality is currently limited without the API.")
        row1_layout.addWidget(self.download_thumbnails_checkbox)
        self.compress_images_checkbox = QCheckBox("Compress Large Images (to WebP)")
        self.compress_images_checkbox.setChecked(False) # Default to not compressing images
        self.compress_images_checkbox.setToolTip("Compress images > 1.5MB to WebP format (requires Pillow).")
        row1_layout.addWidget(self.compress_images_checkbox)
        row1_layout.addStretch(1) # Push checkboxes to the left
        checkboxes_group_layout.addLayout(row1_layout) # Add row to the group layout

        # Advanced Settings Label and Checkboxes
        advanced_settings_label = QLabel("⚙️ Advanced Settings:") # Label for advanced settings section
        checkboxes_group_layout.addWidget(advanced_settings_label)
        
        # Advanced Row 1 (Subfolders)
        advanced_row1_layout = QHBoxLayout() # Horizontal layout for first row of advanced checkboxes
        advanced_row1_layout.setSpacing(10)
        self.use_subfolders_checkbox = QCheckBox("Separate Folders by Name/Title")
        self.use_subfolders_checkbox.setChecked(True) # Default to using subfolders
        self.use_subfolders_checkbox.toggled.connect(self.update_ui_for_subfolders) # Connect to update UI
        advanced_row1_layout.addWidget(self.use_subfolders_checkbox)
        self.use_subfolder_per_post_checkbox = QCheckBox("Subfolder per Post")
        self.use_subfolder_per_post_checkbox.setChecked(False) # Default to not using subfolder per post
        self.use_subfolder_per_post_checkbox.setToolTip("Creates a subfolder for each post inside the character/title folder.")
        self.use_subfolder_per_post_checkbox.toggled.connect(self.update_ui_for_subfolders) # Connect to update UI
        advanced_row1_layout.addWidget(self.use_subfolder_per_post_checkbox)
        advanced_row1_layout.addStretch(1) # Push to left
        checkboxes_group_layout.addLayout(advanced_row1_layout)

        # Advanced Row 2 (Multithreading, External Links, Manga Mode)
        advanced_row2_layout = QHBoxLayout() # Horizontal layout for second row of advanced checkboxes
        advanced_row2_layout.setSpacing(10)
        
        # Multithreading specific layout (checkbox, label, input)
        multithreading_layout = QHBoxLayout()
        multithreading_layout.setContentsMargins(0,0,0,0) # No internal margins for this group
        self.use_multithreading_checkbox = QCheckBox("Use Multithreading")
        self.use_multithreading_checkbox.setChecked(True) # Default to using multithreading
        self.use_multithreading_checkbox.setToolTip( # Updated tooltip explaining thread count usage
            "Enables concurrent operations. See 'Threads' input for details."
        )
        multithreading_layout.addWidget(self.use_multithreading_checkbox)
        self.thread_count_label = QLabel("Threads:") # Label for thread count input
        multithreading_layout.addWidget(self.thread_count_label)
        self.thread_count_input = QLineEdit() # Input for number of threads
        self.thread_count_input.setFixedWidth(40) # Small fixed width
        self.thread_count_input.setText("4") # Default thread count
        self.thread_count_input.setToolTip( # Updated tooltip explaining thread usage contexts
            f"Number of concurrent operations.\n"
            f"- Single Post: Concurrent file downloads (1-{MAX_FILE_THREADS_PER_POST_OR_WORKER} recommended).\n"
            f"- Creator Feed: Concurrent post processing (1-{MAX_THREADS}).\n"
            f"  File downloads per post worker also use this value (1-{MAX_FILE_THREADS_PER_POST_OR_WORKER} recommended)."
        )
        self.thread_count_input.setValidator(QIntValidator(1, MAX_THREADS)) # Validate input (1 to MAX_THREADS)
        multithreading_layout.addWidget(self.thread_count_input)
        advanced_row2_layout.addLayout(multithreading_layout) # Add multithreading group to advanced row 2

        # External Links Checkbox
        self.external_links_checkbox = QCheckBox("Show External Links in Log")
        self.external_links_checkbox.setChecked(False) # Default to not showing external links log separately
        advanced_row2_layout.addWidget(self.external_links_checkbox)

        # Manga Mode Checkbox
        self.manga_mode_checkbox = QCheckBox("Manga/Comic Mode")
        self.manga_mode_checkbox.setToolTip("Downloads posts from oldest to newest and renames files based on post title (for creator feeds only).")
        self.manga_mode_checkbox.setChecked(False) # Default to manga mode off
        advanced_row2_layout.addWidget(self.manga_mode_checkbox)
        advanced_row2_layout.addStretch(1) # Push to left
        checkboxes_group_layout.addLayout(advanced_row2_layout) # Add advanced row 2 to group layout
        left_layout.addLayout(checkboxes_group_layout) # Add checkbox group layout to main left layout


        # Download and Cancel Buttons Section
        btn_layout = QHBoxLayout() # Horizontal layout for main action buttons
        btn_layout.setSpacing(10)
        self.download_btn = QPushButton("⬇️ Start Download")
        self.download_btn.setStyleSheet("padding: 8px 15px; font-weight: bold;") # Make download button prominent
        self.download_btn.clicked.connect(self.start_download) # Connect to start download logic
        self.cancel_btn = QPushButton("❌ Cancel")
        self.cancel_btn.setEnabled(False) # Initially disabled, enabled when download is active
        self.cancel_btn.clicked.connect(self.cancel_download) # Connect to cancel download logic
        btn_layout.addWidget(self.download_btn)
        btn_layout.addWidget(self.cancel_btn)
        left_layout.addLayout(btn_layout) # Add button layout to main left layout
        left_layout.addSpacing(10) # Add some space after buttons

        # Known Characters/Shows List Section
        known_chars_label_layout = QHBoxLayout() # Layout for label and search input for known characters
        known_chars_label_layout.setSpacing(10)
        self.known_chars_label = QLabel("🎭 Known Shows/Characters (for Folder Names):")
        self.character_search_input = QLineEdit() # Input to filter the character list
        self.character_search_input.setPlaceholderText("Search characters...")
        known_chars_label_layout.addWidget(self.known_chars_label, 1) # Allow label to take space
        known_chars_label_layout.addWidget(self.character_search_input)
        left_layout.addLayout(known_chars_label_layout)

        self.character_list = QListWidget() # List to display known characters
        self.character_list.setSelectionMode(QListWidget.ExtendedSelection) # Allow multiple selections for deletion
        left_layout.addWidget(self.character_list, 1) # Allow list to stretch vertically

        # Character Management Buttons Section (Add/Delete)
        char_manage_layout = QHBoxLayout() # Layout for adding/deleting characters from the list
        char_manage_layout.setSpacing(10)
        self.new_char_input = QLineEdit() # Input for new character name
        self.new_char_input.setPlaceholderText("Add new show/character name")
        self.add_char_button = QPushButton("➕ Add") # Button to add new character
        self.delete_char_button = QPushButton("🗑️ Delete Selected") # Button to delete selected characters
        self.add_char_button.clicked.connect(self.add_new_character) # Connect add button
        self.new_char_input.returnPressed.connect(self.add_char_button.click) # Allow adding on Enter key press
        self.delete_char_button.clicked.connect(self.delete_selected_character) # Connect delete button
        char_manage_layout.addWidget(self.new_char_input, 2) # Give more space to input field
        char_manage_layout.addWidget(self.add_char_button, 1)
        char_manage_layout.addWidget(self.delete_char_button, 1)
        left_layout.addLayout(char_manage_layout) # Add management buttons layout to main left layout
        left_layout.addStretch(0) # Prevent excessive stretching at the bottom of left panel

        # --- Right Panel (Logs) ---
        log_title_layout = QHBoxLayout() # Layout for log title and utility buttons (verbosity, reset)
        self.progress_log_label = QLabel("📜 Progress Log:") # Main label for the log area
        log_title_layout.addWidget(self.progress_log_label)
        log_title_layout.addStretch(1) # Push utility buttons to the right

        # Link Search Input and Button (initially hidden, for "Only Links" mode)
        self.link_search_input = QLineEdit()
        self.link_search_input.setPlaceholderText("Search Links...")
        self.link_search_input.setVisible(False) # Hidden by default
        self.link_search_input.setFixedWidth(150)
        log_title_layout.addWidget(self.link_search_input)
        self.link_search_button = QPushButton("🔍") # Search icon button
        self.link_search_button.setToolTip("Filter displayed links")
        self.link_search_button.setVisible(False) # Hidden by default
        self.link_search_button.setFixedWidth(30)
        self.link_search_button.setStyleSheet("padding: 4px 4px;") # Compact padding
        log_title_layout.addWidget(self.link_search_button)

        # Manga Rename Toggle Button (initially hidden, for Manga Mode)
        self.manga_rename_toggle_button = QPushButton() # Text set by _update_manga_filename_style_button_text
        self.manga_rename_toggle_button.setVisible(False) # Hidden by default
        self.manga_rename_toggle_button.setFixedWidth(140) # Adjusted width for text
        self.manga_rename_toggle_button.setStyleSheet("padding: 4px 8px;")
        self._update_manga_filename_style_button_text() # Set initial text based on loaded style
        log_title_layout.addWidget(self.manga_rename_toggle_button)

        # Log Verbosity Toggle Button
        self.log_verbosity_button = QPushButton("Show Basic Log") # Button to toggle log detail
        self.log_verbosity_button.setToolTip("Toggle between full and basic log details.")
        self.log_verbosity_button.setFixedWidth(110) # Fixed width
        self.log_verbosity_button.setStyleSheet("padding: 4px 8px;")
        log_title_layout.addWidget(self.log_verbosity_button)

        # Reset Button
        self.reset_button = QPushButton("🔄 Reset") # Button to reset application state
        self.reset_button.setToolTip("Reset all inputs and logs to default state (only when idle).")
        self.reset_button.setFixedWidth(80)
        self.reset_button.setStyleSheet("padding: 4px 8px;")
        log_title_layout.addWidget(self.reset_button)
        right_layout.addLayout(log_title_layout) # Add log title/utility layout to main right layout

        # Log Output Areas (Splitter for Main and External Logs)
        self.log_splitter = QSplitter(Qt.Vertical) # Vertical splitter for two log areas
        self.main_log_output = QTextEdit() # Main log display
        self.main_log_output.setReadOnly(True) # Make it read-only
        self.main_log_output.setLineWrapMode(QTextEdit.NoWrap) # No wrap for better log readability
        self.main_log_output.setStyleSheet("""
            QTextEdit { background-color: #3C3F41; border: 1px solid #5A5A5A; padding: 5px;
                         color: #F0F0F0; border-radius: 4px; font-family: Consolas, Courier New, monospace; font-size: 9.5pt; }""")
        self.external_log_output = QTextEdit() # External links log display
        self.external_log_output.setReadOnly(True)
        self.external_log_output.setLineWrapMode(QTextEdit.NoWrap)
        self.external_log_output.setStyleSheet("""
            QTextEdit { background-color: #3C3F41; border: 1px solid #5A5A5A; padding: 5px;
                         color: #F0F0F0; border-radius: 4px; font-family: Consolas, Courier New, monospace; font-size: 9.5pt; }""")
        self.external_log_output.hide() # Initially hidden, shown when "Show External Links" is checked
        self.log_splitter.addWidget(self.main_log_output) # Add main log to splitter
        self.log_splitter.addWidget(self.external_log_output) # Add external log to splitter
        self.log_splitter.setSizes([self.height(), 0]) # Main log takes all space initially
        right_layout.addWidget(self.log_splitter, 1) # Allow splitter to stretch vertically

        # Export Links Button (initially hidden, for "Only Links" mode)
        export_button_layout = QHBoxLayout() # Layout to push button to the right
        export_button_layout.addStretch(1) # Push to right
        self.export_links_button = QPushButton("Export Links")
        self.export_links_button.setToolTip("Export all extracted links to a .txt file.")
        self.export_links_button.setFixedWidth(100)
        self.export_links_button.setStyleSheet("padding: 4px 8px; margin-top: 5px;")
        self.export_links_button.setEnabled(False) # Initially disabled
        self.export_links_button.setVisible(False) # Initially hidden
        export_button_layout.addWidget(self.export_links_button)
        right_layout.addLayout(export_button_layout)


        # Progress Labels (Overall and Individual File)
        self.progress_label = QLabel("Progress: Idle") # Label for overall download progress
        self.progress_label.setStyleSheet("padding-top: 5px; font-style: italic;")
        right_layout.addWidget(self.progress_label)
        self.file_progress_label = QLabel("") # Label for individual file download progress
        self.file_progress_label.setWordWrap(True) # Allow text to wrap if long
        self.file_progress_label.setStyleSheet("padding-top: 2px; font-style: italic; color: #A0A0A0;")
        right_layout.addWidget(self.file_progress_label)


        # Add left and right panels to the main splitter
        self.main_splitter.addWidget(left_panel_widget)
        self.main_splitter.addWidget(right_panel_widget)
        # Set initial splitter sizes (e.g., 35% for left controls, 65% for right logs)
        initial_width = self.width()
        left_width = int(initial_width * 0.35)
        right_width = initial_width - left_width
        self.main_splitter.setSizes([left_width, right_width])

        # Set main layout for the window
        top_level_layout = QHBoxLayout(self) # Top-level layout for the main window
        top_level_layout.setContentsMargins(0,0,0,0) # No margins for the top-level layout itself
        top_level_layout.addWidget(self.main_splitter) # Add the main splitter to the window's layout

        # Initial UI state updates based on defaults and loaded settings
        self.update_ui_for_subfolders(self.use_subfolders_checkbox.isChecked())
        self.update_external_links_setting(self.external_links_checkbox.isChecked())
        self.update_multithreading_label(self.thread_count_input.text())
        self.update_page_range_enabled_state() # Call after link_input is created
        if self.manga_mode_checkbox: # Ensure checkbox exists before accessing
            self.update_ui_for_manga_mode(self.manga_mode_checkbox.isChecked()) # Call after manga_mode_checkbox created
        if hasattr(self, 'link_input'): self.link_input.textChanged.connect(self.update_page_range_enabled_state) # Connect page range update
        self.load_known_names_from_util() # Load known names into the list widget
        self._handle_multithreading_toggle(self.use_multithreading_checkbox.isChecked()) # Set initial state of thread count input
        if hasattr(self, 'radio_group') and self.radio_group.checkedButton(): # Ensure radio group and a checked button exist
            self._handle_filter_mode_change(self.radio_group.checkedButton(), True) # Set initial UI based on default radio selection
        self._update_manga_filename_style_button_text() # Set initial text for manga rename button
        self._update_skip_scope_button_text() # Set initial text for skip scope button


    def get_dark_theme(self):
        """Returns a string containing CSS for a dark theme."""
        return """
        QWidget { background-color: #2E2E2E; color: #E0E0E0; font-family: Segoe UI, Arial, sans-serif; font-size: 10pt; }
        QLineEdit, QListWidget { background-color: #3C3F41; border: 1px solid #5A5A5A; padding: 5px; color: #F0F0F0; border-radius: 4px; }
        QTextEdit { background-color: #3C3F41; border: 1px solid #5A5A5A; padding: 5px; color: #F0F0F0; border-radius: 4px; }
        QPushButton { background-color: #555; color: #F0F0F0; border: 1px solid #6A6A6A; padding: 6px 12px; border-radius: 4px; min-height: 22px; }
        QPushButton:hover { background-color: #656565; border: 1px solid #7A7A7A; }
        QPushButton:pressed { background-color: #4A4A4A; }
        QPushButton:disabled { background-color: #404040; color: #888; border-color: #555; }
        QLabel { font-weight: bold; padding-top: 4px; padding-bottom: 2px; color: #C0C0C0; }
        QRadioButton, QCheckBox { spacing: 5px; color: #E0E0E0; padding-top: 4px; padding-bottom: 4px; }
        QRadioButton::indicator, QCheckBox::indicator { width: 14px; height: 14px; }
        QListWidget { alternate-background-color: #353535; border: 1px solid #5A5A5A; }
        QListWidget::item:selected { background-color: #007ACC; color: #FFFFFF; }
        QToolTip { background-color: #4A4A4A; color: #F0F0F0; border: 1px solid #6A6A6A; padding: 4px; border-radius: 3px; }
        QSplitter::handle { background-color: #5A5A5A; /* Thicker handle for easier grabbing */ }
        QSplitter::handle:horizontal { width: 5px; }
        QSplitter::handle:vertical { height: 5px; }
        /* Style for QFrame used as a separator or container if needed */
        QFrame[frameShape="4"], QFrame[frameShape="5"] { /* HLine, VLine */
            border: 1px solid #4A4A4A; /* Darker line for subtle separation */
            border-radius: 3px;
        }
        """

    def browse_directory(self):
        """Opens a dialog to select the download directory."""
        # Get current directory from input if valid, otherwise use home directory or last used
        current_dir = self.dir_input.text() if os.path.isdir(self.dir_input.text()) else ""
        folder = QFileDialog.getExistingDirectory(self, "Select Download Folder", current_dir)
        if folder: # If a folder was selected
            self.dir_input.setText(folder) # Update the directory input field

    def handle_main_log(self, message):
        """Appends a message to the main log output area, handling HTML and basic log mode."""
        is_html_message = message.startswith(HTML_PREFIX) # Check if message is flagged as HTML
        display_message = message
        use_html = False

        if is_html_message:
             display_message = message[len(HTML_PREFIX):] # Remove HTML prefix
             use_html = True
        elif self.basic_log_mode: # If basic log mode is active, filter messages
            # Keywords that indicate a message should be shown in basic mode
            basic_keywords = [
                '🚀 starting download', '🏁 download finished', '🏁 download cancelled', # Start/End messages
                '❌', '⚠️', '✅ all posts processed', '✅ reached end of posts', # Errors, Warnings, Key Milestones
                'summary:', 'progress:', '[fetcher]', # Summaries, Progress, Fetcher logs
                'critical error', 'import error', 'error', 'fail', 'timeout', # Specific error types
                'unsupported url', 'invalid url', 'no posts found', 'could not create directory', # Common operational issues
                'missing dependency', 'high thread count', 'manga mode filter warning', # Configuration/Setup warnings
                'duplicate name', 'potential name conflict', 'invalid filter name', # Known list issues
                'no valid character filters' # Filter issues
            ]
            message_lower = message.lower() # For case-insensitive keyword check
            if not any(keyword in message_lower for keyword in basic_keywords):
                 # Allow specific success messages even in basic mode if they are not too verbose
                 if not message.strip().startswith("✅ Saved:") and \
                    not message.strip().startswith("✅ Added") and \
                    not message.strip().startswith("✅ Application reset complete"):
                    return # Skip message if not matching keywords and not an allowed specific success message
        
        try:
             # Sanitize null characters that can crash QTextEdit
             safe_message = str(display_message).replace('\x00', '[NULL]')
             if use_html:
                 self.main_log_output.insertHtml(safe_message) # Insert as HTML
             else:
                 self.main_log_output.append(safe_message) # Append as plain text

             # Auto-scroll if the scrollbar is near the bottom
             scrollbar = self.main_log_output.verticalScrollBar()
             if scrollbar.value() >= scrollbar.maximum() - 30: # Threshold for auto-scroll
                 scrollbar.setValue(scrollbar.maximum()) # Scroll to the bottom
        except Exception as e:
             # Fallback print if GUI logging fails for some reason
             print(f"GUI Main Log Error: {e}\nOriginal Message: {message}")


    def _is_download_active(self):
        """Checks if any download process (single or multi-threaded for posts) is currently active."""
        single_thread_active = self.download_thread and self.download_thread.isRunning()
        # Check if thread_pool exists and has any non-done futures
        pool_active = self.thread_pool is not None and any(not f.done() for f in self.active_futures if f is not None)
        return single_thread_active or pool_active


    def handle_external_link_signal(self, post_title, link_text, link_url, platform):
        """Handles external links found by worker threads by adding them to a queue for processing."""
        link_data = (post_title, link_text, link_url, platform)
        self.external_link_queue.append(link_data) # Add to queue
        if self.radio_only_links and self.radio_only_links.isChecked():
            self.extracted_links_cache.append(link_data) # Also add to cache for "Only Links" mode display
        self._try_process_next_external_link() # Attempt to process immediately or schedule

    def _try_process_next_external_link(self):
        """Processes the next external link from the queue with appropriate delays to avoid flooding the UI."""
        if self._is_processing_external_link_queue or not self.external_link_queue:
             # Already processing or queue is empty, so return
             return

        # Determine if links should be displayed in the external log or main log (for "Only Links" mode)
        is_only_links_mode = self.radio_only_links and self.radio_only_links.isChecked()
        should_display_in_external_log = self.show_external_links and not is_only_links_mode

        if not (is_only_links_mode or should_display_in_external_log):
             # Neither "Only Links" mode nor "Show External Links" is active for displaying this link now.
             # It's queued, but we don't need to display it immediately.
             self._is_processing_external_link_queue = False # Ensure flag is reset
             if self.external_link_queue: # If there are still items, try again later (e.g., if settings change)
                 QTimer.singleShot(0, self._try_process_next_external_link) # Check again soon
             return

        self._is_processing_external_link_queue = True # Set flag that we are processing one
        link_data = self.external_link_queue.popleft() # Get the next link from the queue

        # Apply different delays based on context to manage UI updates
        if is_only_links_mode:
            # Shorter delay for "Only Links" mode as it's the primary output
            delay_ms = 80 # milliseconds
            QTimer.singleShot(delay_ms, lambda data=link_data: self._display_and_schedule_next(data))
        elif self._is_download_active(): # If a download is active, use a longer, randomized delay
            delay_ms = random.randint(4000, 8000) # 4-8 seconds
            QTimer.singleShot(delay_ms, lambda data=link_data: self._display_and_schedule_next(data))
        else: # No download active, process with minimal delay
            QTimer.singleShot(0, lambda data=link_data: self._display_and_schedule_next(data))


    def _display_and_schedule_next(self, link_data):
        """Displays a single external link and schedules the processing of the next one from the queue."""
        post_title, link_text, link_url, platform = link_data
        is_only_links_mode = self.radio_only_links and self.radio_only_links.isChecked()

        # Format link for display (truncate long link text)
        max_link_text_len = 35
        display_text = link_text[:max_link_text_len].strip() + "..." if len(link_text) > max_link_text_len else link_text
        formatted_link_info = f"{display_text} - {link_url} - {platform}"
        separator = "-" * 45 # Separator for visual grouping by post in "Only Links" mode

        if is_only_links_mode:
            # In "Only Links" mode, display in the main log
            if post_title != self._current_link_post_title: # If it's a new post title
                self.log_signal.emit(HTML_PREFIX + "<br>" + separator + "<br>") # Add separator and space using HTML
                title_html = f'<b style="color: #87CEEB;">{post_title}</b><br>' # Make post title prominent
                self.log_signal.emit(HTML_PREFIX + title_html) # Emit title as HTML
                self._current_link_post_title = post_title # Update current title tracker
            self.log_signal.emit(formatted_link_info) # Emit the link info as plain text
        elif self.show_external_links: # If "Show External Links" is checked (and not "Only Links" mode)
            # Display in the dedicated external links log
             self._append_to_external_log(formatted_link_info, separator) # Pass separator for consistency if needed

        # Reset flag and try to process the next link in the queue
        self._is_processing_external_link_queue = False
        self._try_process_next_external_link()


    def _append_to_external_log(self, formatted_link_text, separator):
        """Appends a formatted link to the external log output if it's visible."""
        if not (self.external_log_output and self.external_log_output.isVisible()):
            return # Don't append if log area is hidden

        try:
            # Append the formatted link text
            self.external_log_output.append(formatted_link_text)
            self.external_log_output.append("") # Add a blank line for spacing between links

            # Auto-scroll if near the bottom
            scrollbar = self.external_log_output.verticalScrollBar()
            if scrollbar.value() >= scrollbar.maximum() - 50: # Threshold for auto-scroll
                scrollbar.setValue(scrollbar.maximum()) # Scroll to bottom
        except Exception as e:
             # Fallback if GUI logging fails
             self.log_signal.emit(f"GUI External Log Append Error: {e}\nOriginal Message: {formatted_link_text}") # Log to main log as fallback
             print(f"GUI External Log Error (Append): {e}\nOriginal Message: {formatted_link_text}")


    def update_file_progress_display(self, filename, downloaded_bytes, total_bytes):
        """Updates the label showing individual file download progress."""
        if not filename and total_bytes == 0 and downloaded_bytes == 0: # Clear signal
            self.file_progress_label.setText("") # Clear the progress label
            return

        max_filename_len = 25 # Max length for filename part of the string for display
        display_filename = filename
        if len(filename) > max_filename_len: # Truncate if too long
            display_filename = filename[:max_filename_len-3].strip() + "..." 

        # Format progress text
        if total_bytes > 0: # If total size is known
            downloaded_mb = downloaded_bytes / (1024 * 1024)
            total_mb = total_bytes / (1024 * 1024)
            progress_text = f"Downloading '{display_filename}' ({downloaded_mb:.1f}MB / {total_mb:.1f}MB)"
        else: # If total size is unknown
             downloaded_mb = downloaded_bytes / (1024 * 1024)
             progress_text = f"Downloading '{display_filename}' ({downloaded_mb:.1f}MB)"

        # Further shorten if the whole string is too long for the UI label
        if len(progress_text) > 75: # Heuristic length limit for the label
             # Shorter truncate for filename if the whole string is still too long
             display_filename = filename[:15].strip() + "..." if len(filename) > 18 else display_filename 
             if total_bytes > 0: progress_text = f"DL '{display_filename}' ({downloaded_mb:.1f}/{total_mb:.1f}MB)"
             else: progress_text = f"DL '{display_filename}' ({downloaded_mb:.1f}MB)"

        self.file_progress_label.setText(progress_text) # Update the label text


    def update_external_links_setting(self, checked):
        """Handles changes to the 'Show External Links in Log' checkbox, updating UI visibility."""
        is_only_links_mode = self.radio_only_links and self.radio_only_links.isChecked()
        is_only_archives_mode = self.radio_only_archives and self.radio_only_archives.isChecked() # Check new mode

        # External links log is not shown for "Only Links" or "Only Archives" mode, regardless of checkbox state
        if is_only_links_mode or is_only_archives_mode:
             if self.external_log_output: self.external_log_output.hide() # Hide external log
             if self.log_splitter: self.log_splitter.setSizes([self.height(), 0]) # Main log takes all space
             # self.show_external_links should ideally be false if these modes are active,
             # and the checkbox should be disabled by _handle_filter_mode_change.
             return # Exit early, no further action needed for these modes

        self.show_external_links = checked # Update the internal flag based on checkbox state
        if checked:
            # Show the external log area
            if self.external_log_output: self.external_log_output.show()
            if self.log_splitter: self.log_splitter.setSizes([self.height() // 2, self.height() // 2]) # Split space between logs
            if self.main_log_output: self.main_log_output.setMinimumHeight(50) # Ensure some min height for main log
            if self.external_log_output: self.external_log_output.setMinimumHeight(50) # Ensure min height for external log
            self.log_signal.emit("\n" + "="*40 + "\n🔗 External Links Log Enabled\n" + "="*40) # Log change
            if self.external_log_output: # Clear and add title if showing external log
                self.external_log_output.clear()
                self.external_log_output.append("🔗 External Links Found:")
            self._try_process_next_external_link() # Process any queued links now that log is visible
        else:
            # Hide the external log area
            if self.external_log_output: self.external_log_output.hide()
            if self.log_splitter: self.log_splitter.setSizes([self.height(), 0]) # Main log takes all space
            if self.main_log_output: self.main_log_output.setMinimumHeight(0) # Reset min height
            if self.external_log_output: self.external_log_output.setMinimumHeight(0) # Reset min height
            if self.external_log_output: self.external_log_output.clear() # Clear content when hiding
            self.log_signal.emit("\n" + "="*40 + "\n🔗 External Links Log Disabled\n" + "="*40) # Log change


    def _handle_filter_mode_change(self, button, checked):
        """Handles changes in the file filter radio buttons, updating UI accordingly."""
        if not button or not checked: # Only act on the button that was toggled to 'checked'
            return

        filter_mode_text = button.text() # Get text of the selected radio button
        is_only_links = (filter_mode_text == "🔗 Only Links")
        is_only_archives = (filter_mode_text == "📦 Only Archives") # Check for "Only Archives" mode

        # --- Visibility of Link-Specific UI (Search, Export) ---
        if self.link_search_input: self.link_search_input.setVisible(is_only_links)
        if self.link_search_button: self.link_search_button.setVisible(is_only_links)
        if self.export_links_button:
            self.export_links_button.setVisible(is_only_links)
            # Enable export button only if in links mode and there are cached links
            self.export_links_button.setEnabled(is_only_links and bool(self.extracted_links_cache))
        if not is_only_links and self.link_search_input: self.link_search_input.clear() # Clear search if not in links mode

        # --- Enable/Disable State of General Download-Related Widgets ---
        # File download mode is active if NOT "Only Links" mode
        file_download_mode_active = not is_only_links

        # Widgets generally active for file downloads (All, Images, Videos, Archives)
        if self.dir_input: self.dir_input.setEnabled(file_download_mode_active)
        if self.dir_button: self.dir_button.setEnabled(file_download_mode_active)
        if self.use_subfolders_checkbox: self.use_subfolders_checkbox.setEnabled(file_download_mode_active)
        # Skip words input and scope button are relevant if downloading files
        if self.skip_words_input: self.skip_words_input.setEnabled(file_download_mode_active)
        if self.skip_scope_toggle_button: self.skip_scope_toggle_button.setEnabled(file_download_mode_active)
        
        # --- Skip Archive Checkboxes Logic ---
        # Enabled if NOT "Only Links" AND NOT "Only Archives"
        # Unchecked and disabled if "Only Archives" mode is selected
        if self.skip_zip_checkbox:
            can_skip_zip = not is_only_links and not is_only_archives
            self.skip_zip_checkbox.setEnabled(can_skip_zip)
            if is_only_archives:
                self.skip_zip_checkbox.setChecked(False) # Ensure unchecked in "Only Archives" mode
        
        if self.skip_rar_checkbox:
            can_skip_rar = not is_only_links and not is_only_archives
            self.skip_rar_checkbox.setEnabled(can_skip_rar)
            if is_only_archives:
                self.skip_rar_checkbox.setChecked(False) # Ensure unchecked in "Only Archives" mode

        # --- Other File Processing Checkboxes (Thumbnails, Compression) ---
        # Enabled if NOT "Only Links" AND NOT "Only Archives"
        other_file_proc_enabled = not is_only_links and not is_only_archives
        if self.download_thumbnails_checkbox: self.download_thumbnails_checkbox.setEnabled(other_file_proc_enabled)
        if self.compress_images_checkbox: self.compress_images_checkbox.setEnabled(other_file_proc_enabled)
        
        # --- External Links Checkbox Logic ---
        # Enabled if NOT "Only Links" AND NOT "Only Archives"
        if self.external_links_checkbox: 
            can_show_external_log_option = not is_only_links and not is_only_archives
            self.external_links_checkbox.setEnabled(can_show_external_log_option)
            if not can_show_external_log_option: # If disabled due to current mode
                 self.external_links_checkbox.setChecked(False) # Uncheck it


        # --- Log Area and Specific Mode UI Updates ---
        if is_only_links: # "Only Links" mode specific UI
            self.progress_log_label.setText("📜 Extracted Links Log:") # Change log label
            if self.external_log_output: self.external_log_output.hide() # Hide separate external log area
            if self.log_splitter: self.log_splitter.setSizes([self.height(), 0]) # Main log takes all space
            if self.main_log_output: self.main_log_output.clear(); self.main_log_output.setMinimumHeight(0) # Clear main log
            if self.external_log_output: self.external_log_output.clear(); self.external_log_output.setMinimumHeight(0) # Clear external log
            self.log_signal.emit("="*20 + " Mode changed to: Only Links " + "="*20) # Log mode change
            self._filter_links_log() # Refresh link log display based on current cache and search
            self._try_process_next_external_link() # Process any queued links for this mode
        elif is_only_archives: # "Only Archives" mode specific UI
            self.progress_log_label.setText("📜 Progress Log (Archives Only):") # Change log label
            if self.external_log_output: self.external_log_output.hide() # Hide external links log for archives mode
            if self.log_splitter: self.log_splitter.setSizes([self.height(), 0]) # Main log takes all space
            if self.main_log_output: self.main_log_output.clear() # Clear main log for new mode
            self.log_signal.emit("="*20 + " Mode changed to: Only Archives " + "="*20) # Log mode change
        else: # All, Images, Videos modes
            self.progress_log_label.setText("📜 Progress Log:") # Default log label
            # For these modes, the external links log visibility depends on its checkbox state
            self.update_external_links_setting(self.external_links_checkbox.isChecked() if self.external_links_checkbox else False)
            self.log_signal.emit(f"="*20 + f" Mode changed to: {filter_mode_text} " + "="*20) # Log mode change

        # --- Common UI Updates based on current states (called after mode-specific changes) ---
        # Update subfolder related UI (character filter, per-post subfolder checkbox, custom folder input)
        if self.use_subfolders_checkbox: # Ensure it exists
             self.update_ui_for_subfolders(self.use_subfolders_checkbox.isChecked())
        
        # Update visibility of custom folder input (depends on single post URL and subfolder settings)
        self.update_custom_folder_visibility()


    def _filter_links_log(self):
        """Filters and displays links in the main log when 'Only Links' mode is active, based on search input."""
        if not (self.radio_only_links and self.radio_only_links.isChecked()): return # Only run in "Only Links" mode

        search_term = self.link_search_input.text().lower().strip() if self.link_search_input else ""
        self.main_log_output.clear() # Clear previous content from the main log
        current_title_for_display = None # To group links by post title in the display
        separator = "-" * 45 # Visual separator between post sections

        # Iterate through the cached extracted links
        for post_title, link_text, link_url, platform in self.extracted_links_cache:
            # Check if any part of the link data matches the search term (case-insensitive)
            matches_search = (
                not search_term or # Show all if no search term is provided
                search_term in link_text.lower() or
                search_term in link_url.lower() or
                search_term in platform.lower()
            )
            if matches_search: # If the link matches the search criteria
                if post_title != current_title_for_display: # If it's a new post section
                    self.main_log_output.insertHtml("<br>" + separator + "<br>") # Add separator and space using HTML
                    title_html = f'<b style="color: #87CEEB;">{post_title}</b><br>' # Format post title
                    self.main_log_output.insertHtml(title_html) # Insert title as HTML
                    current_title_for_display = post_title # Update current title tracker
                
                # Format and display the link information
                max_link_text_len = 35 # Truncate long link text for display
                display_text = link_text[:max_link_text_len].strip() + "..." if len(link_text) > max_link_text_len else link_text
                formatted_link_info = f"{display_text} - {link_url} - {platform}"
                self.main_log_output.append(formatted_link_info) # Append link info as plain text

        if self.main_log_output.toPlainText().strip(): # Add a final newline if content was added
            self.main_log_output.append("")
        self.main_log_output.verticalScrollBar().setValue(0) # Scroll to top of the log


    def _export_links_to_file(self):
        """Exports extracted links to a text file when in 'Only Links' mode."""
        if not (self.radio_only_links and self.radio_only_links.isChecked()):
            QMessageBox.information(self, "Export Links", "Link export is only available in 'Only Links' mode.")
            return
        if not self.extracted_links_cache:
            QMessageBox.information(self, "Export Links", "No links have been extracted yet.")
            return

        # Suggest a default filename for the export
        default_filename = "extracted_links.txt"
        filepath, _ = QFileDialog.getSaveFileName(self, "Save Links", default_filename, "Text Files (*.txt);;All Files (*)")

        if filepath: # If a filepath was chosen
            try:
                with open(filepath, 'w', encoding='utf-8') as f:
                    current_title_for_export = None # To group links by post title in the file
                    separator = "-" * 60 + "\n" # Separator for file content
                    for post_title, link_text, link_url, platform in self.extracted_links_cache:
                        if post_title != current_title_for_export: # If it's a new post section
                            if current_title_for_export is not None: # Add separator before new post section (if not the first)
                                f.write("\n" + separator + "\n")
                            f.write(f"Post Title: {post_title}\n\n") # Write post title
                            current_title_for_export = post_title # Update current title tracker
                        # Write link details
                        f.write(f"  {link_text} - {link_url} - {platform}\n")
                self.log_signal.emit(f"✅ Links successfully exported to: {filepath}")
                QMessageBox.information(self, "Export Successful", f"Links exported to:\n{filepath}")
            except Exception as e:
                self.log_signal.emit(f"❌ Error exporting links: {e}")
                QMessageBox.critical(self, "Export Error", f"Could not export links: {e}")


    def get_filter_mode(self):
        """Determines the backend filter mode ('all', 'image', 'video', 'archive') based on radio button selection."""
        if self.radio_only_links and self.radio_only_links.isChecked():
            # Backend expects 'all' for link extraction, even if UI says "Only Links",
            # as the worker will then be told to extract_links_only.
            return 'all' 
        elif self.radio_images.isChecked():
            return 'image'
        elif self.radio_videos.isChecked():
            return 'video'
        elif self.radio_only_archives and self.radio_only_archives.isChecked(): # Check for "Only Archives" mode
            return 'archive'
        elif self.radio_all.isChecked(): # Explicitly check for 'All' if others aren't matched
            return 'all'
        return 'all' # Default if somehow no button is checked (should not happen with QButtonGroup)


    def get_skip_words_scope(self):
        """Returns the current scope for skip words (files, posts, or both) from the internal attribute."""
        return self.skip_words_scope


    def _update_skip_scope_button_text(self):
        """Updates the text of the skip scope toggle button based on the current self.skip_words_scope."""
        if self.skip_scope_toggle_button: # Ensure button exists
            if self.skip_words_scope == SKIP_SCOPE_FILES:
                self.skip_scope_toggle_button.setText("Scope: Files")
            elif self.skip_words_scope == SKIP_SCOPE_POSTS:
                self.skip_scope_toggle_button.setText("Scope: Posts")
            elif self.skip_words_scope == SKIP_SCOPE_BOTH:
                self.skip_scope_toggle_button.setText("Scope: Both")
            else: # Should not happen if logic is correct
                self.skip_scope_toggle_button.setText("Scope: Unknown")


    def _cycle_skip_scope(self):
        """Cycles through the available skip word scopes (Files -> Posts -> Both -> Files) and updates UI and settings."""
        if self.skip_words_scope == SKIP_SCOPE_FILES:
            self.skip_words_scope = SKIP_SCOPE_POSTS
        elif self.skip_words_scope == SKIP_SCOPE_POSTS:
            self.skip_words_scope = SKIP_SCOPE_BOTH
        elif self.skip_words_scope == SKIP_SCOPE_BOTH:
            self.skip_words_scope = SKIP_SCOPE_FILES
        else: # Default to files if current state is unknown (should not occur)
            self.skip_words_scope = SKIP_SCOPE_FILES
        
        self._update_skip_scope_button_text() # Update button text to reflect new scope
        self.settings.setValue(SKIP_WORDS_SCOPE_KEY, self.skip_words_scope) # Save the new scope to settings
        self.log_signal.emit(f"ℹ️ Skip words scope changed to: '{self.skip_words_scope}'") # Log the change


    def add_new_character(self):
        """Adds a new character/show name to the known list, with validation and conflict checks."""
        global KNOWN_NAMES, clean_folder_name # Ensure we use the potentially shared KNOWN_NAMES and utility function
        name_to_add = self.new_char_input.text().strip() # Get name from input and strip whitespace
        if not name_to_add: # Check for empty input
             QMessageBox.warning(self, "Input Error", "Name cannot be empty."); return False # Indicate failure

        name_lower = name_to_add.lower() # For case-insensitive comparisons
        # Check for exact duplicates (case-insensitive)
        if any(existing.lower() == name_lower for existing in KNOWN_NAMES):
             QMessageBox.warning(self, "Duplicate Name", f"The name '{name_to_add}' (case-insensitive) already exists."); return False

        # Check for potential conflicts (substrings or superstrings)
        similar_names_details = []
        for existing_name in KNOWN_NAMES:
            existing_name_lower = existing_name.lower()
            # Check if new name is in existing OR existing is in new name (but not identical)
            if name_lower != existing_name_lower and (name_lower in existing_name_lower or existing_name_lower in name_lower):
                similar_names_details.append((name_to_add, existing_name)) # Store pair for message

        if similar_names_details: # If potential conflicts found
            first_similar_new, first_similar_existing = similar_names_details[0]
            # Determine which name is shorter for the example message to illustrate potential grouping issue
            shorter, longer = sorted([first_similar_new, first_similar_existing], key=len)

            # Warn user about potential conflict and ask for confirmation
            msg_box = QMessageBox(self)
            msg_box.setIcon(QMessageBox.Warning)
            msg_box.setWindowTitle("Potential Name Conflict")
            msg_box.setText(
                f"The name '{first_similar_new}' is very similar to an existing name: '{first_similar_existing}'.\n\n"
                f"This could lead to files being grouped into less specific folders (e.g., under '{clean_folder_name(shorter)}' instead of a more specific '{clean_folder_name(longer)}').\n\n"
                "Do you want to change the name you are adding, or proceed anyway?"
            )
            change_button = msg_box.addButton("Change Name", QMessageBox.RejectRole) # Option to change
            proceed_button = msg_box.addButton("Proceed Anyway", QMessageBox.AcceptRole) # Option to proceed
            msg_box.setDefaultButton(proceed_button) # Default to proceed
            msg_box.setEscapeButton(change_button) # Escape cancels/changes
            msg_box.exec_()

            if msg_box.clickedButton() == change_button: # If user chose to change
                self.log_signal.emit(f"ℹ️ User chose to change '{first_similar_new}' due to similarity with '{first_similar_existing}'.")
                return False # Indicate user chose to change, so don't add this one

            # If user chose to proceed, log it
            self.log_signal.emit(f"⚠️ User proceeded with adding '{first_similar_new}' despite similarity with '{first_similar_existing}'.")

        # If no conflict or user chose to proceed, add the name to KNOWN_NAMES
        KNOWN_NAMES.append(name_to_add)
        KNOWN_NAMES.sort(key=str.lower) # Keep the list sorted case-insensitively

        # Update UI list (QListWidget)
        self.character_list.clear()
        self.character_list.addItems(KNOWN_NAMES)
        self.filter_character_list(self.character_search_input.text()) # Re-apply search filter if any

        self.log_signal.emit(f"✅ Added '{name_to_add}' to known names list.")
        self.new_char_input.clear() # Clear input field after adding
        self.save_known_names() # Persist changes to the config file
        return True # Indicate success


    def delete_selected_character(self):
        """Deletes selected character/show names from the known list and UI."""
        global KNOWN_NAMES # Ensure we use the potentially shared KNOWN_NAMES
        selected_items = self.character_list.selectedItems() # Get selected items from QListWidget
        if not selected_items: # If no items selected
             QMessageBox.warning(self, "Selection Error", "Please select one or more names to delete."); return

        names_to_remove = {item.text() for item in selected_items} # Get unique names to remove
        # Confirm deletion with the user
        confirm = QMessageBox.question(self, "Confirm Deletion",
                                       f"Are you sure you want to delete {len(names_to_remove)} name(s)?",
                                       QMessageBox.Yes | QMessageBox.No, QMessageBox.No) # Default to No
        if confirm == QMessageBox.Yes:
            original_count = len(KNOWN_NAMES)
            # Filter out the names to remove from KNOWN_NAMES (modify in-place)
            KNOWN_NAMES[:] = [n for n in KNOWN_NAMES if n not in names_to_remove]
            removed_count = original_count - len(KNOWN_NAMES)

            if removed_count > 0: # If names were actually removed
                 self.log_signal.emit(f"🗑️ Removed {removed_count} name(s).")
                 # Update UI list
                 self.character_list.clear()
                 self.character_list.addItems(KNOWN_NAMES)
                 self.filter_character_list(self.character_search_input.text()) # Re-apply search filter
                 self.save_known_names() # Persist changes to config file
            else: # Should not happen if items were selected, but good to handle
                 self.log_signal.emit("ℹ️ No names were removed (they might not have been in the list).")


    def update_custom_folder_visibility(self, url_text=None):
        """Shows or hides the custom folder input based on URL type (single post) and subfolder settings."""
        if url_text is None: # If called without arg (e.g., from other UI changes that affect this)
            url_text = self.link_input.text() # Get current URL from input

        _, _, post_id = extract_post_info(url_text.strip()) # Check if it's a single post URL
        
        is_single_post_url = bool(post_id) # True if a post ID was extracted
        # Subfolders must be generally enabled for custom folder to be relevant
        subfolders_enabled = self.use_subfolders_checkbox.isChecked() if self.use_subfolders_checkbox else False
        
        # Custom folder input is NOT relevant if in "Only Links" or "Only Archives" mode,
        # as these modes might not use folder structures in the same way or at all.
        not_only_links_or_archives_mode = not (
            (self.radio_only_links and self.radio_only_links.isChecked()) or
            (self.radio_only_archives and self.radio_only_archives.isChecked())
        )

        # Show custom folder input if all conditions are met:
        # 1. It's a single post URL.
        # 2. "Separate Folders by Name/Title" (main subfolder option) is checked.
        # 3. It's NOT "Only Links" or "Only Archives" mode.
        should_show_custom_folder = is_single_post_url and subfolders_enabled and not_only_links_or_archives_mode
        
        if self.custom_folder_widget: # Ensure custom folder widget exists
            self.custom_folder_widget.setVisible(should_show_custom_folder) # Set visibility

        # If the custom folder input is hidden, clear its content
        if not (self.custom_folder_widget and self.custom_folder_widget.isVisible()):
            if self.custom_folder_input: self.custom_folder_input.clear()


    def update_ui_for_subfolders(self, checked): 
        """Updates UI elements related to subfolder settings (character filter, per-post subfolder checkbox)."""
        # "Only Links" and "Only Archives" modes generally don't use character-based subfolders or per-post subfolders.
        is_only_links = self.radio_only_links and self.radio_only_links.isChecked()
        is_only_archives = self.radio_only_archives and self.radio_only_archives.isChecked()

        # Character filter and per-post subfolder options are relevant if:
        # 1. The main "Separate Folders by Name/Title" (passed as 'checked' arg) is ON.
        # 2. It's NOT "Only Links" mode AND NOT "Only Archives" mode.
        enable_char_and_post_subfolder_options = checked and not is_only_links and not is_only_archives

        # Character filter widget visibility
        if self.character_filter_widget: # Ensure widget exists
            self.character_filter_widget.setVisible(enable_char_and_post_subfolder_options)
            if not self.character_filter_widget.isVisible() and self.character_input: 
                self.character_input.clear() # Clear character input if hidden

        # "Subfolder per Post" checkbox enabled state
        if self.use_subfolder_per_post_checkbox: # Ensure checkbox exists
            self.use_subfolder_per_post_checkbox.setEnabled(enable_char_and_post_subfolder_options)
            if not enable_char_and_post_subfolder_options: # If disabled by current conditions
                self.use_subfolder_per_post_checkbox.setChecked(False) # Also uncheck it
        
        # Update custom folder visibility, as it depends on subfolder settings too
        self.update_custom_folder_visibility()


    def update_page_range_enabled_state(self):
        """Enables/disables page range inputs based on URL type (creator feed vs single post) and Manga Mode."""
        url_text = self.link_input.text().strip() if self.link_input else ""
        _, _, post_id = extract_post_info(url_text) # Check if it's a single post URL

        is_creator_feed = not post_id if url_text else False # True if URL is present and not a post URL
        # Manga mode overrides page range (downloads all posts, sorted oldest first)
        manga_mode_active = self.manga_mode_checkbox.isChecked() if self.manga_mode_checkbox else False

        # Enable page range if it's a creator feed AND Manga Mode is OFF
        enable_page_range = is_creator_feed and not manga_mode_active

        # Enable/disable page range UI elements
        for widget in [self.page_range_label, self.start_page_input, self.to_label, self.end_page_input]:
            if widget: widget.setEnabled(enable_page_range)

        # If page range is disabled, clear the input fields
        if not enable_page_range:
            if self.start_page_input: self.start_page_input.clear()
            if self.end_page_input: self.end_page_input.clear()


    def _update_manga_filename_style_button_text(self):
        """Updates the text and tooltip of the manga filename style toggle button based on current style."""
        if self.manga_rename_toggle_button: # Ensure button exists
            if self.manga_filename_style == STYLE_POST_TITLE:
                self.manga_rename_toggle_button.setText("Name: Post Title")
                self.manga_rename_toggle_button.setToolTip(
                    "Manga files: First file named by post title. Subsequent files in same post keep original names.\n"
                    "Click to change to original file names for all files."
                )
            elif self.manga_filename_style == STYLE_ORIGINAL_NAME:
                self.manga_rename_toggle_button.setText("Name: Original File")
                self.manga_rename_toggle_button.setToolTip(
                    "Manga files will keep their original names as provided by the site (e.g., 001.jpg, page_01.png).\n"
                    "Click to change to post title based naming for the first file."
                )
            else: # Fallback for unknown style (should not happen)
                self.manga_rename_toggle_button.setText("Name: Unknown Style")
                self.manga_rename_toggle_button.setToolTip("Manga filename style is in an unknown state.")


    def _toggle_manga_filename_style(self):
        """Toggles the manga filename style between 'post_title' and 'original_name', updates UI and settings."""
        current_style = self.manga_filename_style
        new_style = ""

        if current_style == STYLE_POST_TITLE: # If current is Post Title, switch to Original Name
            new_style = STYLE_ORIGINAL_NAME
            # Optional: Warn user if they switch away from the recommended style for manga
            reply = QMessageBox.information(self, "Manga Filename Preference",
                                           "Using 'Name: Post Title' (first file by title, others original) is recommended for Manga Mode.\n\n"
                                           "Using 'Name: Original File' for all files might lead to less organized downloads if original names are inconsistent or non-sequential.\n\n"
                                           "Proceed with using 'Name: Original File' for all files?",
                                           QMessageBox.Yes | QMessageBox.No, QMessageBox.No) # Default to No
            if reply == QMessageBox.No: # If user cancels the change
                self.log_signal.emit("ℹ️ Manga filename style change to 'Original File' cancelled by user.")
                return # Don't change if user cancels
        elif current_style == STYLE_ORIGINAL_NAME: # If current is Original Name, switch to Post Title
            new_style = STYLE_POST_TITLE
        else: # If current style is unknown (e.g., corrupted setting), reset to default
            self.log_signal.emit(f"⚠️ Unknown current manga filename style: {current_style}. Resetting to default ('{STYLE_POST_TITLE}').")
            new_style = STYLE_POST_TITLE

        self.manga_filename_style = new_style # Update internal attribute
        self.settings.setValue(MANGA_FILENAME_STYLE_KEY, self.manga_filename_style) # Save new style to settings
        self.settings.sync() # Ensure setting is written to disk
        self._update_manga_filename_style_button_text() # Update button UI text and tooltip
        self.log_signal.emit(f"ℹ️ Manga filename style changed to: '{self.manga_filename_style}'") # Log the change


    def update_ui_for_manga_mode(self, checked): # 'checked' is the state of the manga_mode_checkbox
        """Updates UI elements based on Manga Mode state (checkbox state and URL type)."""
        url_text = self.link_input.text().strip() if self.link_input else ""
        _, _, post_id = extract_post_info(url_text) # Check if it's a single post URL

        # Manga mode is only applicable to creator feeds (not single posts)
        is_creator_feed = not post_id if url_text else False

        # Enable/disable the Manga Mode checkbox itself based on whether it's a creator feed
        if self.manga_mode_checkbox: # Ensure checkbox exists
            self.manga_mode_checkbox.setEnabled(is_creator_feed)
            if not is_creator_feed and self.manga_mode_checkbox.isChecked(): # If URL changes to single post, uncheck manga mode
                self.manga_mode_checkbox.setChecked(False)
                # 'checked' variable (passed in) might now be stale, so re-evaluate based on checkbox's current state
                checked = self.manga_mode_checkbox.isChecked() 

        # Manga mode is effectively ON if the checkbox is checked AND it's a creator feed
        manga_mode_effectively_on = is_creator_feed and checked # Use the potentially updated 'checked' value

        # Show/hide the manga filename style toggle button
        if self.manga_rename_toggle_button: # Ensure button exists
            self.manga_rename_toggle_button.setVisible(manga_mode_effectively_on)

        # If manga mode is on, page range is disabled (as it downloads all posts, sorted)
        if manga_mode_effectively_on:
            if self.page_range_label: self.page_range_label.setEnabled(False)
            if self.start_page_input: self.start_page_input.setEnabled(False); self.start_page_input.clear()
            if self.to_label: self.to_label.setEnabled(False)
            if self.end_page_input: self.end_page_input.setEnabled(False); self.end_page_input.clear()
        else: # If manga mode is off (or not applicable), re-evaluate page range normally
            self.update_page_range_enabled_state()


    def filter_character_list(self, search_text):
        """Filters the QListWidget of known characters based on the provided search text."""
        search_text_lower = search_text.lower() # For case-insensitive search
        for i in range(self.character_list.count()): # Iterate through all items in the list
            item = self.character_list.item(i)
            # Hide item if search text is not in item text (case-insensitive)
            item.setHidden(search_text_lower not in item.text().lower())


    def update_multithreading_label(self, text): # 'text' is the current text of thread_count_input
        """Updates the multithreading checkbox text to show the current thread count if enabled."""
        if self.use_multithreading_checkbox.isChecked(): # If multithreading is enabled
            try:
                num_threads_val = int(text) # Convert input text to integer
                if num_threads_val > 0 : self.use_multithreading_checkbox.setText(f"Use Multithreading ({num_threads_val} Threads)")
                else: self.use_multithreading_checkbox.setText("Use Multithreading (Invalid: >0)") # Should be caught by validator
            except ValueError: # If text is not a valid integer
                self.use_multithreading_checkbox.setText("Use Multithreading (Invalid Input)")
        else: # If multithreading is unchecked, it implies 1 thread (main thread operation)
            self.use_multithreading_checkbox.setText("Use Multithreading (1 Thread)")


    def _handle_multithreading_toggle(self, checked): # 'checked' is the state of use_multithreading_checkbox
        """Enables/disables the thread count input based on the multithreading checkbox state."""
        if not checked: # Multithreading disabled (checkbox unchecked)
            self.thread_count_input.setEnabled(False) # Disable thread count input
            self.thread_count_label.setEnabled(False) # Disable thread count label
            # Update checkbox text to reflect single-threaded operation
            self.use_multithreading_checkbox.setText("Use Multithreading (1 Thread)")
        else: # Multithreading enabled (checkbox checked)
            self.thread_count_input.setEnabled(True) # Enable thread count input
            self.thread_count_label.setEnabled(True) # Enable thread count label
            # Update checkbox text based on current value in thread_count_input
            self.update_multithreading_label(self.thread_count_input.text())


    def update_progress_display(self, total_posts, processed_posts):
        """Updates the overall progress label in the UI."""
        if total_posts > 0: # If total number of posts is known
            progress_percent = (processed_posts / total_posts) * 100
            self.progress_label.setText(f"Progress: {processed_posts} / {total_posts} posts ({progress_percent:.1f}%)")
        elif processed_posts > 0 : # If total is unknown but some posts are processed (e.g., single post mode)
             self.progress_label.setText(f"Progress: Processing post {processed_posts}...")
        else: # Initial state or no posts found yet
            self.progress_label.setText("Progress: Starting...")
        
        # Clear individual file progress when overall progress updates (unless it's a clear signal for file progress)
        if total_posts > 0 or processed_posts > 0 :
            self.file_progress_label.setText("") # Clear individual file progress label


    def start_download(self):
        """Initiates the download process based on current UI settings and validations."""
        # Ensure access to global/utility functions and classes from downloader_utils
        global KNOWN_NAMES, BackendDownloadThread, PostProcessorWorker, extract_post_info, clean_folder_name, MAX_FILE_THREADS_PER_POST_OR_WORKER
        
        if self._is_download_active(): # Prevent multiple concurrent downloads from starting
            QMessageBox.warning(self, "Busy", "A download is already running."); return

        # --- Gather all settings from UI ---
        api_url = self.link_input.text().strip()
        output_dir = self.dir_input.text().strip()
        
        use_subfolders = self.use_subfolders_checkbox.isChecked()
        # Per-post subfolders only make sense if main subfolders are also enabled
        use_post_subfolders = self.use_subfolder_per_post_checkbox.isChecked() and use_subfolders
        compress_images = self.compress_images_checkbox.isChecked()
        download_thumbnails = self.download_thumbnails_checkbox.isChecked()
        
        use_multithreading_enabled_by_checkbox = self.use_multithreading_checkbox.isChecked()
        try: # Get and validate thread count from GUI
            num_threads_from_gui = int(self.thread_count_input.text().strip())
            if num_threads_from_gui < 1: num_threads_from_gui = 1 # Ensure at least 1 thread
        except ValueError: # If input is not a valid integer
            QMessageBox.critical(self, "Thread Count Error", "Invalid number of threads. Please enter a positive number.")
            self.set_ui_enabled(True) # Re-enable UI if error occurs before download starts
            return
            
        raw_skip_words = self.skip_words_input.text().strip() # Get raw skip words string
        # Parse skip words into a list of lowercase, stripped words
        skip_words_list = [word.strip().lower() for word in raw_skip_words.split(',') if word.strip()]
        current_skip_words_scope = self.get_skip_words_scope() # Get current scope for skip words
        manga_mode_is_checked = self.manga_mode_checkbox.isChecked() if self.manga_mode_checkbox else False
        
        # Determine filter mode and if only links are being extracted
        extract_links_only = (self.radio_only_links and self.radio_only_links.isChecked())
        backend_filter_mode = self.get_filter_mode() # This will be 'archive' if that radio button is selected
        # Get text of the selected filter radio button for logging purposes
        user_selected_filter_text = self.radio_group.checkedButton().text() if self.radio_group.checkedButton() else "All"

        # Determine effective skip_zip and skip_rar based on the selected filter mode
        # If "Only Archives" mode is selected, we want to download archives, so skip flags must be False.
        if backend_filter_mode == 'archive':
            effective_skip_zip = False
            effective_skip_rar = False
        else: # For other modes (All, Images, Videos, Only Links), respect the checkbox states
            effective_skip_zip = self.skip_zip_checkbox.isChecked()
            effective_skip_rar = self.skip_rar_checkbox.isChecked()

        # --- Validations ---
        if not api_url: QMessageBox.critical(self, "Input Error", "URL is required."); return
        # Output directory is required unless only extracting links
        if not extract_links_only and not output_dir:
             QMessageBox.critical(self, "Input Error", "Download Directory is required when not in 'Only Links' mode."); return
        
        service, user_id, post_id_from_url = extract_post_info(api_url) # Extract info from URL
        if not service or not user_id: # Basic URL validation (must have service and user ID)
            QMessageBox.critical(self, "Input Error", "Invalid or unsupported URL format."); return

        # Create output directory if it doesn't exist (and not in links-only mode)
        if not extract_links_only and not os.path.isdir(output_dir):
            reply = QMessageBox.question(self, "Create Directory?",
                                         f"The directory '{output_dir}' does not exist.\nCreate it now?",
                                         QMessageBox.Yes | QMessageBox.No, QMessageBox.Yes) # Default to Yes
            if reply == QMessageBox.Yes:
                try: os.makedirs(output_dir, exist_ok=True); self.log_signal.emit(f"ℹ️ Created directory: {output_dir}")
                except Exception as e: QMessageBox.critical(self, "Directory Error", f"Could not create directory: {e}"); return
            else: self.log_signal.emit("❌ Download cancelled: Output directory does not exist and was not created."); return

        # Check for Pillow library if image compression is enabled
        if compress_images and Image is None: # Image is None if Pillow import failed
            QMessageBox.warning(self, "Missing Dependency", "Pillow library (for image compression) not found. Compression will be disabled.")
            compress_images = False; self.compress_images_checkbox.setChecked(False) # Update UI and flag

        # Manga mode is only applicable for creator feeds (not single posts)
        manga_mode = manga_mode_is_checked and not post_id_from_url


        # Page range validation (only if not manga mode and it's a creator feed)
        start_page_str, end_page_str = self.start_page_input.text().strip(), self.end_page_input.text().strip()
        start_page, end_page = None, None # Initialize to None
        is_creator_feed = bool(not post_id_from_url) # True if URL is present and not a single post URL
        if is_creator_feed and not manga_mode: # Page range applies only to creator feeds not in manga mode
            try: # Validate page range inputs
                if start_page_str: start_page = int(start_page_str)
                if end_page_str: end_page = int(end_page_str)
                if start_page is not None and start_page <= 0: raise ValueError("Start page must be positive.")
                if end_page is not None and end_page <= 0: raise ValueError("End page must be positive.")
                if start_page and end_page and start_page > end_page: raise ValueError("Start page cannot be greater than end page.")
            except ValueError as e: QMessageBox.critical(self, "Page Range Error", f"Invalid page range: {e}"); return
        elif manga_mode: # In manga mode, ignore page range inputs (downloads all)
            start_page, end_page = None, None 

        # --- Reset state for new download ---
        self.external_link_queue.clear(); self.extracted_links_cache = []; self._is_processing_external_link_queue = False; self._current_link_post_title = None
        self.all_kept_original_filenames = [] # Reset list of filenames that kept their original names

        # Character filter validation and prompt (if subfolders enabled and not links only mode)
        raw_character_filters_text = self.character_input.text().strip()
        # Parse character filters from comma-separated string
        parsed_character_list = [name.strip() for name in raw_character_filters_text.split(',') if name.strip()] if raw_character_filters_text else None
        filter_character_list_to_pass = None # This will be passed to the backend download logic

        # Validate character filters if subfolders are used, it's a creator feed, and not extracting only links
        if use_subfolders and parsed_character_list and not post_id_from_url and not extract_links_only:
            self.log_signal.emit(f"ℹ️ Validating character filters for subfolder naming: {', '.join(parsed_character_list)}")
            valid_filters_for_backend = [] # List of filters confirmed to be valid
            user_cancelled_validation = False # Flag if user cancels during validation
            for char_name in parsed_character_list:
                cleaned_name_test = clean_folder_name(char_name) # Test if name is valid for a folder name
                if not cleaned_name_test: # If cleaning results in empty or invalid name
                    QMessageBox.warning(self, "Invalid Filter Name", f"Filter name '{char_name}' is invalid for a folder and will be skipped.")
                    self.log_signal.emit(f"⚠️ Skipping invalid filter for folder: '{char_name}'"); continue

                # Check if name is in known list (Known.txt), prompt to add if not
                if char_name.lower() not in {kn.lower() for kn in KNOWN_NAMES}:
                    reply = QMessageBox.question(self, "Add Filter Name to Known List?",
                                               f"Filter '{char_name}' is not in known names list.\nAdd it now?",
                                               QMessageBox.Yes | QMessageBox.No | QMessageBox.Cancel, QMessageBox.Yes)
                    if reply == QMessageBox.Yes: # User wants to add
                        self.new_char_input.setText(char_name) # Pre-fill input for user convenience
                        if self.add_new_character(): # Try to add it (this calls save_known_names)
                            self.log_signal.emit(f"✅ Added '{char_name}' to known names via filter prompt.")
                            valid_filters_for_backend.append(char_name) # Add to list to pass if successful
                        else: # Add failed (e.g., user cancelled sub-prompt or conflict during add_new_character)
                            self.log_signal.emit(f"⚠️ Failed to add '{char_name}' via filter prompt (might have been a conflict or cancellation).")
                            # Still add if it was a valid folder name, even if not added to known list, for this run
                            if cleaned_name_test: valid_filters_for_backend.append(char_name)
                    elif reply == QMessageBox.Cancel: # User cancelled the whole download process
                        self.log_signal.emit(f"❌ Download cancelled during filter validation for '{char_name}'."); user_cancelled_validation = True; break
                    else: # User chose No (don't add to known list, but proceed with filter for this run)
                        self.log_signal.emit(f"ℹ️ Proceeding with filter '{char_name}' without adding to known list.")
                        if cleaned_name_test: valid_filters_for_backend.append(char_name) # Add if valid folder name
                else: # Already in known list
                    if cleaned_name_test: valid_filters_for_backend.append(char_name) # Add if valid folder name

            if user_cancelled_validation: return # Stop if user cancelled during prompt

            if valid_filters_for_backend: # If there are valid filters after validation
                filter_character_list_to_pass = valid_filters_for_backend
                self.log_signal.emit(f"   Using validated character filters for subfolders: {', '.join(filter_character_list_to_pass)}")
            else: # If no valid filters remain
                self.log_signal.emit("⚠️ No valid character filters remaining for subfolder naming (after validation).")
        elif parsed_character_list : # If not using subfolders or it's a single post, still pass the list for other filtering purposes (e.g., file content filtering)
            filter_character_list_to_pass = parsed_character_list
            self.log_signal.emit(f"ℹ️ Character filters provided: {', '.join(filter_character_list_to_pass)} (Subfolder rules may differ or not apply).")


        # Manga mode warning if no character filter is provided (as filter is used for naming/folder)
        if manga_mode and not filter_character_list_to_pass and not extract_links_only:
            msg_box = QMessageBox(self)
            msg_box.setIcon(QMessageBox.Warning)
            msg_box.setWindowTitle("Manga Mode Filter Warning")
            msg_box.setText(
                "Manga Mode is enabled, but 'Filter by Character(s)' is empty.\n\n"
                "For best results (correct file naming and folder organization if subfolders are on), "
                "please enter the Manga/Series title into the filter field.\n\n"
                "Proceed without a filter (names might be generic, folder might be less specific)?"
            )
            proceed_button = msg_box.addButton("Proceed Anyway", QMessageBox.AcceptRole)
            cancel_button = msg_box.addButton("Cancel Download", QMessageBox.RejectRole)
            msg_box.exec_()
            if msg_box.clickedButton() == cancel_button: # If user cancels
                self.log_signal.emit("❌ Download cancelled due to Manga Mode filter warning."); return
            else: # User proceeds
                self.log_signal.emit("⚠️ Proceeding with Manga Mode without a specific title filter.")


        # Custom folder name for single post downloads
        custom_folder_name_cleaned = None # Initialize
        # Check if custom folder input is relevant and visible
        if use_subfolders and post_id_from_url and self.custom_folder_widget and self.custom_folder_widget.isVisible() and not extract_links_only: 
            raw_custom_name = self.custom_folder_input.text().strip() # Get raw custom folder name
            if raw_custom_name: # If a name was provided
                 cleaned_custom = clean_folder_name(raw_custom_name) # Clean it for folder usage
                 if cleaned_custom: custom_folder_name_cleaned = cleaned_custom # Use if valid
                 else: self.log_signal.emit(f"⚠️ Invalid custom folder name ignored: '{raw_custom_name}' (resulted in empty string after cleaning).")


        # --- Clear logs and reset progress counters ---
        self.main_log_output.clear() # Clear main log
        if extract_links_only: self.main_log_output.append("🔗 Extracting Links..."); # Initial message for links mode
        elif backend_filter_mode == 'archive': self.main_log_output.append("📦 Downloading Archives Only...") # Log for new archive mode
        
        if self.external_log_output: self.external_log_output.clear() # Clear external log
        # Show external log title only if it's relevant for the current mode and setting
        if self.show_external_links and not extract_links_only and backend_filter_mode != 'archive': 
            self.external_log_output.append("🔗 External Links Found:")
        
        self.file_progress_label.setText(""); self.cancellation_event.clear(); self.active_futures = [] # Reset progress and cancellation
        self.total_posts_to_process = self.processed_posts_count = self.download_counter = self.skip_counter = 0 # Reset counters
        self.progress_label.setText("Progress: Initializing...") # Initial progress message

        # Determine effective number of threads for posts and files based on settings
        effective_num_post_workers = 1 # Default for single post or non-multithreaded creator feed
        effective_num_file_threads_per_worker = 1 # Default number of file download threads per worker
        
        if post_id_from_url: # Single post URL
            if use_multithreading_enabled_by_checkbox: # Use GUI thread count for file downloads for this single post
                effective_num_file_threads_per_worker = max(1, min(num_threads_from_gui, MAX_FILE_THREADS_PER_POST_OR_WORKER))
        else: # Creator feed URL
            if use_multithreading_enabled_by_checkbox: # If multithreading is enabled for creator feed
                effective_num_post_workers = max(1, min(num_threads_from_gui, MAX_THREADS)) # For concurrent post processing
                # The same GUI thread count is also used as the *max* for files per worker, capped appropriately
                effective_num_file_threads_per_worker = max(1, min(num_threads_from_gui, MAX_FILE_THREADS_PER_POST_OR_WORKER))


        # --- Log initial download parameters to the main log ---
        log_messages = ["="*40, f"🚀 Starting {'Link Extraction' if extract_links_only else ('Archive Download' if backend_filter_mode == 'archive' else 'Download')} @ {time.strftime('%Y-%m-%d %H:%M:%S')}", f"   URL: {api_url}"]
        if not extract_links_only: log_messages.append(f"   Save Location: {output_dir}")
        
        if post_id_from_url: # Logging for Single Post download
            log_messages.append(f"   Mode: Single Post")
            log_messages.append(f"     ↳ File Downloads: Up to {effective_num_file_threads_per_worker} concurrent file(s)")
        else: # Logging for Creator Feed download
            log_messages.append(f"   Mode: Creator Feed")
            log_messages.append(f"   Post Processing: {'Multi-threaded (' + str(effective_num_post_workers) + ' workers)' if effective_num_post_workers > 1 else 'Single-threaded (1 worker)'}")
            log_messages.append(f"     ↳ File Downloads per Worker: Up to {effective_num_file_threads_per_worker} concurrent file(s)")
            if is_creator_feed: # Only log page range for creator feeds
                if manga_mode: log_messages.append("   Page Range: All (Manga Mode - Oldest Posts Processed First)")
                else: # Construct a readable page range string for logging
                    pr_log = "All" # Default if no pages specified
                    if start_page or end_page: 
                        pr_log = f"{f'From {start_page} ' if start_page else ''}{'to ' if start_page and end_page else ''}{f'{end_page}' if end_page else (f'Up to {end_page}' if end_page else (f'From {start_page}' if start_page else 'Specific Range'))}".strip()
                    log_messages.append(f"   Page Range: {pr_log if pr_log else 'All'}")


        if not extract_links_only: # Settings relevant to file downloading
            log_messages.append(f"   Subfolders: {'Enabled' if use_subfolders else 'Disabled'}")
            if use_subfolders: # Log subfolder naming details
                 if custom_folder_name_cleaned: log_messages.append(f"   Custom Folder (Post): '{custom_folder_name_cleaned}'")
                 elif filter_character_list_to_pass and not post_id_from_url: log_messages.append(f"   Character Filters for Folders: {', '.join(filter_character_list_to_pass)}")
                 else: log_messages.append(f"   Folder Naming: Automatic (based on title/known names)")
                 log_messages.append(f"   Subfolder per Post: {'Enabled' if use_post_subfolders else 'Disabled'}")

            log_messages.extend([
                f"   File Type Filter: {user_selected_filter_text} (Backend processing as: {backend_filter_mode})",
                f"   Skip Archives: {'.zip' if effective_skip_zip else ''}{', ' if effective_skip_zip and effective_skip_rar else ''}{'.rar' if effective_skip_rar else ''}{'None (Archive Mode)' if backend_filter_mode == 'archive' else ('None' if not (effective_skip_zip or effective_skip_rar) else '')}", # Clarify for archive mode
                f"   Skip Words (posts/files): {', '.join(skip_words_list) if skip_words_list else 'None'}",
                f"   Skip Words Scope: {current_skip_words_scope.capitalize()}",
                f"   Compress Images: {'Enabled' if compress_images else 'Disabled'}",
                f"   Thumbnails Only: {'Enabled' if download_thumbnails else 'Disabled'}"
            ])
        else: # Link extraction mode logging
            log_messages.append(f"   Mode: Extracting Links Only")

        # Log external links setting (relevant unless in "Only Links" or "Only Archives" mode where it's forced off)
        log_messages.append(f"   Show External Links: {'Enabled' if self.show_external_links and not extract_links_only and backend_filter_mode != 'archive' else 'Disabled'}")
        
        if manga_mode: # Manga mode specific logs
            log_messages.append(f"   Manga Mode (File Renaming by Post Title): Enabled")
            log_messages.append(f"     ↳ Manga Filename Style: {'Post Title Based' if self.manga_filename_style == STYLE_POST_TITLE else 'Original File Name'}")

        # Determine if multithreading for posts is actually used for logging
        # It's used if checkbox is checked AND it's a creator feed (not single post)
        should_use_multithreading_for_posts = use_multithreading_enabled_by_checkbox and not post_id_from_url
        log_messages.append(f"   Threading: {'Multi-threaded (posts)' if should_use_multithreading_for_posts else 'Single-threaded (posts)'}")
        if should_use_multithreading_for_posts: # Log number of post workers only if actually using them
            log_messages.append(f"   Number of Post Worker Threads: {effective_num_post_workers}")
        log_messages.append("="*40) # End of parameter logging
        for msg in log_messages: self.log_signal.emit(msg) # Emit all log messages

        # --- Disable UI and prepare for download ---
        self.set_ui_enabled(False) # Disable UI elements during download

        unwanted_keywords_for_folders = {'spicy', 'hd', 'nsfw', '4k', 'preview', 'teaser', 'clip'} # Example set of keywords to avoid in folder names
        
        # --- Prepare arguments dictionary for backend thread/worker ---
        # This template holds all possible arguments that might be needed by either single or multi-threaded download logic
        args_template = {
            'api_url_input': api_url,
            'download_root': output_dir, # Used by PostProcessorWorker if it creates folders
            'output_dir': output_dir, # Passed to DownloadThread for consistency (though it might use download_root)
            'known_names': list(KNOWN_NAMES), # Pass a copy of the current known names
            'known_names_copy': list(KNOWN_NAMES), # Legacy, ensure it's there if used by older parts of backend
            'filter_character_list': filter_character_list_to_pass,
            'filter_mode': backend_filter_mode, # 'all', 'image', 'video', or 'archive'
            'skip_zip': effective_skip_zip, # Use the determined effective value based on mode
            'skip_rar': effective_skip_rar, # Use the determined effective value based on mode
            'use_subfolders': use_subfolders,
            'use_post_subfolders': use_post_subfolders,
            'compress_images': compress_images,
            'download_thumbnails': download_thumbnails,
            'service': service, # Extracted from URL
            'user_id': user_id, # Extracted from URL
            'downloaded_files': self.downloaded_files, # Pass shared set for session-based skip
            'downloaded_files_lock': self.downloaded_files_lock, # Pass shared lock
            'downloaded_file_hashes': self.downloaded_file_hashes, # Pass shared set for hash-based skip
            'downloaded_file_hashes_lock': self.downloaded_file_hashes_lock, # Pass shared lock
            'skip_words_list': skip_words_list,
            'skip_words_scope': current_skip_words_scope,
            'show_external_links': self.show_external_links, # For worker to know if it should emit external_link_signal
            'extract_links_only': extract_links_only, # For worker to know if it should only extract links
            'start_page': start_page, # Validated start page
            'end_page': end_page, # Validated end page
            'target_post_id_from_initial_url': post_id_from_url, # The specific post ID if a single post URL was given
            'custom_folder_name': custom_folder_name_cleaned, # Cleaned custom folder name for single post
            'manga_mode_active': manga_mode, # Flag for manga mode
            'unwanted_keywords': unwanted_keywords_for_folders, # For folder naming logic in worker
            'cancellation_event': self.cancellation_event, # Shared cancellation event for all threads/workers
            'signals': self.worker_signals, # Signals object for PostProcessorWorker instances to communicate back to GUI
            'manga_filename_style': self.manga_filename_style, # Current manga filename style
            # Pass the effective number of file threads for the worker/post processor to use internally
            'num_file_threads_for_worker': effective_num_file_threads_per_worker
        }

        # --- Start download (single-threaded for posts or multi-threaded for posts) ---
        try:
            if should_use_multithreading_for_posts: # Multi-threaded for posts (creator feed with multithreading enabled)
                self.log_signal.emit(f"   Initializing multi-threaded {'link extraction' if extract_links_only else 'download'} with {effective_num_post_workers} post workers...")
                self.start_multi_threaded_download(num_post_workers=effective_num_post_workers, **args_template)
            else: # Single-threaded for posts (either single post URL or creator feed with multithreading off)
                self.log_signal.emit(f"   Initializing single-threaded {'link extraction' if extract_links_only else 'download'}...")
                # Define keys expected by BackendDownloadThread constructor for clarity and to avoid passing unexpected args
                dt_expected_keys = [
                    'api_url_input', 'output_dir', 'known_names_copy', 'cancellation_event',
                    'filter_character_list', 'filter_mode', 'skip_zip', 'skip_rar',
                    'use_subfolders', 'use_post_subfolders', 'custom_folder_name',
                    'compress_images', 'download_thumbnails', 'service', 'user_id',
                    'downloaded_files', 'downloaded_file_hashes',
                    'downloaded_files_lock', 'downloaded_file_hashes_lock',
                    'skip_words_list', 'skip_words_scope', 'show_external_links', 'extract_links_only',
                    'num_file_threads_for_worker', # This is for the PostProcessorWorker that BackendDownloadThread might create
                    'skip_current_file_flag', # Event for skipping a single file (if feature existed)
                    'start_page', 'end_page', 'target_post_id_from_initial_url',
                    'manga_mode_active', 'unwanted_keywords', 'manga_filename_style'
                ]
                # For single threaded (post) download, the 'num_file_threads_for_worker' from args_template
                # will be used by the PostProcessorWorker if it needs to download multiple files for that single post.
                args_template['skip_current_file_flag'] = None # Ensure this is explicitly set (or passed if it were a feature)
                # Filter args_template to only include keys expected by BackendDownloadThread constructor
                single_thread_args = {key: args_template[key] for key in dt_expected_keys if key in args_template}
                self.start_single_threaded_download(**single_thread_args) # Start the single download thread
        except Exception as e: # Catch any errors during the preparation/start of download
            self.log_signal.emit(f"❌ CRITICAL ERROR preparing download: {e}\n{traceback.format_exc()}")
            QMessageBox.critical(self, "Start Error", f"Failed to start process:\n{e}")
            self.download_finished(0,0,False, []) # Ensure UI is re-enabled and state is reset


    def start_single_threaded_download(self, **kwargs):
        """Starts the download process in a single QThread (BackendDownloadThread).
           This thread handles post fetching and then processes each post sequentially (though file downloads within a post can be multi-threaded by PostProcessorWorker).
        """
        global BackendDownloadThread # The class imported from downloader_utils
        try:
            self.download_thread = BackendDownloadThread(**kwargs) # Instantiate with all necessary arguments
            # Connect signals from the backend thread to GUI handler methods
            if hasattr(self.download_thread, 'progress_signal'): self.download_thread.progress_signal.connect(self.handle_main_log)
            if hasattr(self.download_thread, 'add_character_prompt_signal'): self.download_thread.add_character_prompt_signal.connect(self.add_character_prompt_signal)
            if hasattr(self.download_thread, 'finished_signal'): self.download_thread.finished_signal.connect(self.download_finished)
            # For character prompt response flowing back from GUI to the backend thread
            if hasattr(self.download_thread, 'receive_add_character_result'): self.character_prompt_response_signal.connect(self.download_thread.receive_add_character_result)
            if hasattr(self.download_thread, 'external_link_signal'): self.download_thread.external_link_signal.connect(self.handle_external_link_signal)
            if hasattr(self.download_thread, 'file_progress_signal'): self.download_thread.file_progress_signal.connect(self.update_file_progress_display)

            self.download_thread.start() # Start the QThread
            self.log_signal.emit("✅ Single download thread (for posts) started.")
        except Exception as e: # Catch errors during thread instantiation or start
            self.log_signal.emit(f"❌ CRITICAL ERROR starting single-thread: {e}\n{traceback.format_exc()}")
            QMessageBox.critical(self, "Thread Start Error", f"Failed to start download process: {e}")
            self.download_finished(0,0,False, []) # Ensure UI is re-enabled and state is reset


    def start_multi_threaded_download(self, num_post_workers, **kwargs):
        """Starts the download process using a ThreadPoolExecutor for fetching and processing posts concurrently."""
        global PostProcessorWorker # The worker class from downloader_utils
        # Ensure thread pool is created if it doesn't exist or was previously shut down
        if self.thread_pool is None:
            self.thread_pool = ThreadPoolExecutor(max_workers=num_post_workers, thread_name_prefix='PostWorker_')
        
        self.active_futures = [] # Reset list of active futures for this download run
        # Reset progress counters for this run
        self.processed_posts_count = 0; self.total_posts_to_process = 0; self.download_counter = 0; self.skip_counter = 0
        self.all_kept_original_filenames = [] # Reset list of kept original filenames for this run

        # 'num_file_threads_for_worker' is already in kwargs from the main start_download logic.
        # This will be passed to each PostProcessorWorker instance created by _fetch_and_queue_posts.

        # Start a separate Python thread (not QThread) to fetch post data and submit tasks to the pool.
        # This prevents the GUI from freezing during the initial API calls to get all post data,
        # especially for large creator feeds.
        fetcher_thread = threading.Thread(
            target=self._fetch_and_queue_posts, # Method to run in the new thread
            args=(kwargs['api_url_input'], kwargs, num_post_workers), # Pass API URL, base args, and worker count
            daemon=True, # Daemon thread will exit when the main application exits
            name="PostFetcher" # Name for the thread (useful for debugging)
        )
        fetcher_thread.start() # Start the fetcher thread
        self.log_signal.emit(f"✅ Post fetcher thread started. {num_post_workers} post worker threads initializing...")


    def _fetch_and_queue_posts(self, api_url_input_for_fetcher, worker_args_template, num_post_workers):
        """
        (This method runs in a separate Python thread, not the main GUI thread)
        Fetches all post data using download_from_api and submits each post as a task to the ThreadPoolExecutor.
        """
        global PostProcessorWorker, download_from_api # Ensure access to these from downloader_utils
        all_posts_data = [] # List to store all fetched post data
        fetch_error_occurred = False # Flag to track if an error occurs during fetching
        manga_mode_active_for_fetch = worker_args_template.get('manga_mode_active', False) # Get manga mode status

        # Ensure signals object is available for workers (it's created in DownloaderApp.__init__)
        signals_for_worker = worker_args_template.get('signals')
        if not signals_for_worker: # This should not happen if setup is correct
             self.log_signal.emit("❌ CRITICAL ERROR: Signals object missing for worker in _fetch_and_queue_posts.");
             self.finished_signal.emit(0,0,True, []); # Signal failure to GUI
             return

        try: # Fetch post data from API
            self.log_signal.emit("   Fetching post data from API (this may take a moment for large feeds)...")
            post_generator = download_from_api( # Call the API fetching function from downloader_utils
                api_url_input_for_fetcher,
                logger=lambda msg: self.log_signal.emit(f"[Fetcher] {msg}"), # Prefix fetcher logs for clarity
                start_page=worker_args_template.get('start_page'),
                end_page=worker_args_template.get('end_page'),
                manga_mode=manga_mode_active_for_fetch, # Pass manga mode for correct fetching order
                cancellation_event=self.cancellation_event # Pass shared cancellation event
            )

            for posts_batch in post_generator: # download_from_api yields batches of posts
                if self.cancellation_event.is_set(): # Check for cancellation
                    fetch_error_occurred = True; self.log_signal.emit("   Post fetching cancelled by user."); break
                if isinstance(posts_batch, list): # Ensure API returned a list
                    all_posts_data.extend(posts_batch) # Add fetched posts to the list
                    self.total_posts_to_process = len(all_posts_data) # Update total post count
                    # Log progress periodically for very large feeds to show activity
                    if self.total_posts_to_process > 0 and self.total_posts_to_process % 100 == 0 : # e.g., log every 100 posts
                        self.log_signal.emit(f"   Fetched {self.total_posts_to_process} posts so far...")
                else: # Should not happen if download_from_api is implemented correctly
                    fetch_error_occurred = True; self.log_signal.emit(f"❌ API fetcher returned non-list type: {type(posts_batch)}"); break
            
            if not fetch_error_occurred and not self.cancellation_event.is_set(): # If fetching completed without error/cancellation
                self.log_signal.emit(f"✅ Post fetching complete. Total posts to process: {self.total_posts_to_process}")

        except TypeError as te: # Error in calling download_from_api (e.g., wrong arguments)
            self.log_signal.emit(f"❌ TypeError calling download_from_api: {te}\n   Check 'downloader_utils.py' signature.\n{traceback.format_exc(limit=2)}"); fetch_error_occurred = True
        except RuntimeError as re_err: # Typically from cancellation within fetch_posts_paginated or API errors
            self.log_signal.emit(f"ℹ️ Post fetching runtime error (likely cancellation or API issue): {re_err}"); fetch_error_occurred = True
        except Exception as e: # Other unexpected errors during fetching
            self.log_signal.emit(f"❌ Error during post fetching: {e}\n{traceback.format_exc(limit=2)}"); fetch_error_occurred = True


        if self.cancellation_event.is_set() or fetch_error_occurred:
            # If fetching was cancelled or failed, signal completion to GUI and clean up thread pool
            self.finished_signal.emit(self.download_counter, self.skip_counter, self.cancellation_event.is_set(), self.all_kept_original_filenames)
            if self.thread_pool: self.thread_pool.shutdown(wait=False, cancel_futures=True); self.thread_pool = None # Don't wait if already cancelling
            return

        if self.total_posts_to_process == 0: # No posts found or fetched
            self.log_signal.emit("😕 No posts found or fetched to process.");
            self.finished_signal.emit(0,0,False, []); # Signal completion with zero counts
            return

        # --- Submit fetched posts to the thread pool for processing ---
        self.log_signal.emit(f"   Submitting {self.total_posts_to_process} post processing tasks to thread pool...")
        self.processed_posts_count = 0 # Reset counter for this run
        self.overall_progress_signal.emit(self.total_posts_to_process, 0) # Update GUI progress bar/label
        
        # 'num_file_threads_for_worker' should be in worker_args_template from start_download,
        # this is the number of file download threads each PostProcessorWorker will use.
        num_file_dl_threads_for_each_worker = worker_args_template.get('num_file_threads_for_worker', 1)


        # Define keys expected by PostProcessorWorker constructor for clarity and safety when preparing arguments
        ppw_expected_keys = [
            'post_data', 'download_root', 'known_names', 'filter_character_list', 'unwanted_keywords',
            'filter_mode', 'skip_zip', 'skip_rar', 'use_subfolders', 'use_post_subfolders',
            'target_post_id_from_initial_url', 'custom_folder_name', 'compress_images',
            'download_thumbnails', 'service', 'user_id', 'api_url_input',
            'cancellation_event', 'signals', 'downloaded_files', 'downloaded_file_hashes',
            'downloaded_files_lock', 'downloaded_file_hashes_lock',
            'skip_words_list', 'skip_words_scope', 'show_external_links', 'extract_links_only',
            'num_file_threads', # This will be num_file_dl_threads_for_each_worker for the worker's internal pool
            'skip_current_file_flag', # Event for skipping a single file within a worker (if feature existed)
            'manga_mode_active', 'manga_filename_style'
        ]
        # Keys that are optional for PostProcessorWorker or have defaults defined there
        ppw_optional_keys_with_defaults = {
            'skip_words_list', 'skip_words_scope', 'show_external_links', 'extract_links_only',
            'num_file_threads', 'skip_current_file_flag', 'manga_mode_active', 'manga_filename_style'
            # Note: 'unwanted_keywords' also has a default in the worker if not provided in args
        }


        for post_data_item in all_posts_data: # Iterate through each fetched post data
            if self.cancellation_event.is_set(): break # Stop submitting new tasks if cancellation is requested
            if not isinstance(post_data_item, dict): # Sanity check on post data type
                self.log_signal.emit(f"⚠️ Skipping invalid post data item (not a dict): {type(post_data_item)}");
                self.processed_posts_count += 1; # Count as processed to not hang progress if this happens
                continue

            # Prepare arguments for this specific PostProcessorWorker instance
            worker_init_args = {}; missing_keys = [] # To store args for worker and track any missing ones
            for key in ppw_expected_keys: # Iterate through expected keys for the worker
                if key == 'post_data': worker_init_args[key] = post_data_item # Set the current post's data
                elif key == 'num_file_threads': worker_init_args[key] = num_file_dl_threads_for_each_worker # Set file threads for this worker
                elif key == 'signals': worker_init_args[key] = signals_for_worker # Use the shared signals object for this batch of workers
                elif key in worker_args_template: worker_init_args[key] = worker_args_template[key] # Get from template if available
                elif key in ppw_optional_keys_with_defaults: pass # Worker has a default, so no need to pass if not in template
                else: missing_keys.append(key) # Should not happen if ppw_expected_keys is correct and covers all mandatory args

            if missing_keys: # If any mandatory arguments are missing
                self.log_signal.emit(f"❌ CRITICAL ERROR: Missing keys for PostProcessorWorker: {', '.join(missing_keys)}");
                self.cancellation_event.set(); break # Stop everything if critical args are missing

            try: # Submit the worker task to the thread pool
                worker_instance = PostProcessorWorker(**worker_init_args) # Create worker instance
                if self.thread_pool: # Ensure pool still exists and is active
                    future = self.thread_pool.submit(worker_instance.process) # Submit the worker's process method as a task
                    future.add_done_callback(self._handle_future_result) # Add callback for when this task finishes
                    self.active_futures.append(future) # Keep track of the submitted future
                else: # Pool was shut down or never created (should not happen if logic is correct)
                    self.log_signal.emit("⚠️ Thread pool not available. Cannot submit more tasks."); break
            except TypeError as te: self.log_signal.emit(f"❌ TypeError creating PostProcessorWorker: {te}\n   Passed Args: [{', '.join(sorted(worker_init_args.keys()))}]\n{traceback.format_exc(limit=5)}"); self.cancellation_event.set(); break
            except RuntimeError: self.log_signal.emit("⚠️ Runtime error submitting task (pool likely shutting down)."); break
            except Exception as e: self.log_signal.emit(f"❌ Error submitting post {post_data_item.get('id','N/A')} to worker: {e}"); break

        if not self.cancellation_event.is_set(): self.log_signal.emit(f"   {len(self.active_futures)} post processing tasks submitted to pool.")
        else:
            self.finished_signal.emit(self.download_counter, self.skip_counter, True, self.all_kept_original_filenames)
            if self.thread_pool: self.thread_pool.shutdown(wait=False, cancel_futures=True); self.thread_pool = None

    def _handle_future_result(self, future: Future):
        self.processed_posts_count += 1
        downloaded_files_from_future, skipped_files_from_future = 0, 0
        kept_originals_from_future = []
        try:
            if future.cancelled(): self.log_signal.emit("   A post processing task was cancelled.")
            elif future.exception(): self.log_signal.emit(f"❌ Post processing worker error: {future.exception()}")
            else:
                downloaded_files_from_future, skipped_files_from_future, kept_originals_from_future = future.result()

            with self.downloaded_files_lock:
                self.download_counter += downloaded_files_from_future
                self.skip_counter += skipped_files_from_future

            if kept_originals_from_future:
                self.all_kept_original_filenames.extend(kept_originals_from_future)

            self.overall_progress_signal.emit(self.total_posts_to_process, self.processed_posts_count)
        except Exception as e: self.log_signal.emit(f"❌ Error in _handle_future_result callback: {e}\n{traceback.format_exc(limit=2)}")

        if self.total_posts_to_process > 0 and self.processed_posts_count >= self.total_posts_to_process:
            if all(f.done() for f in self.active_futures):
                QApplication.processEvents()
                self.log_signal.emit("🏁 All submitted post tasks have completed or failed.")
                self.finished_signal.emit(self.download_counter, self.skip_counter, self.cancellation_event.is_set(), self.all_kept_original_filenames)

    def set_ui_enabled(self, enabled):
        widgets_to_toggle = [ self.download_btn, self.link_input, self.radio_all, self.radio_images, self.radio_videos, self.radio_only_links,
            self.skip_zip_checkbox, self.skip_rar_checkbox, self.use_subfolders_checkbox, self.compress_images_checkbox,
            self.download_thumbnails_checkbox, self.use_multithreading_checkbox, self.skip_words_input, self.character_search_input,
            self.new_char_input, self.add_char_button, self.delete_char_button, self.start_page_input, self.end_page_input,
            self.page_range_label, self.to_label, self.character_input, self.custom_folder_input, self.custom_folder_label,
            self.reset_button, self.manga_mode_checkbox, self.manga_rename_toggle_button,
            self.skip_scope_toggle_button # Ensure the new button is in this list
        ]
        
        for widget in widgets_to_toggle:
            if widget: widget.setEnabled(enabled)
        
        if enabled:
            # When re-enabling UI, ensure skip scope button is correctly enabled/disabled by _handle_filter_mode_change
            self._handle_filter_mode_change(self.radio_group.checkedButton(), True)
        # else: # When disabling, the loop above handles the skip_scope_toggle_button

        if self.external_links_checkbox:
            is_only_links = self.radio_only_links and self.radio_only_links.isChecked()
            self.external_links_checkbox.setEnabled(enabled and not is_only_links)

        if self.log_verbosity_button: self.log_verbosity_button.setEnabled(True)

        multithreading_currently_on = self.use_multithreading_checkbox.isChecked()
        self.thread_count_input.setEnabled(enabled and multithreading_currently_on)
        self.thread_count_label.setEnabled(enabled and multithreading_currently_on)

        subfolders_currently_on = self.use_subfolders_checkbox.isChecked()
        self.use_subfolder_per_post_checkbox.setEnabled(enabled and subfolders_currently_on)

        self.cancel_btn.setEnabled(not enabled)

        if enabled:
            # _handle_filter_mode_change is already called above, which should handle the button's enabled state
            self._handle_multithreading_toggle(multithreading_currently_on)
            self.update_ui_for_manga_mode(self.manga_mode_checkbox.isChecked() if self.manga_mode_checkbox else False)

    def cancel_download(self):
        if not self.cancel_btn.isEnabled() and not self.cancellation_event.is_set(): self.log_signal.emit("ℹ️ No active download to cancel or already cancelling."); return
        self.log_signal.emit("⚠️ Requesting cancellation of download process..."); self.cancellation_event.set()
        if self.download_thread and self.download_thread.isRunning(): self.download_thread.requestInterruption(); self.log_signal.emit("   Signaled single download thread to interrupt.")
        if self.thread_pool: self.log_signal.emit("   Initiating immediate shutdown and cancellation of worker pool tasks..."); self.thread_pool.shutdown(wait=False, cancel_futures=True)
        self.external_link_queue.clear(); self._is_processing_external_link_queue = False; self._current_link_post_title = None
        self.cancel_btn.setEnabled(False); self.progress_label.setText("Progress: Cancelling..."); self.file_progress_label.setText("")

    def download_finished(self, total_downloaded, total_skipped, cancelled_by_user, kept_original_names_list=None):
        if kept_original_names_list is None:
            kept_original_names_list = self.all_kept_original_filenames if hasattr(self, 'all_kept_original_filenames') else []
        if kept_original_names_list is None:
            kept_original_names_list = []


        status_message = "Cancelled by user" if cancelled_by_user else "Finished"

        summary_log = "="*40
        summary_log += f"\n🏁 Download {status_message}!\n   Summary: Downloaded Files={total_downloaded}, Skipped Files={total_skipped}\n"
        summary_log += "="*40
        self.log_signal.emit(summary_log)

        if kept_original_names_list:
            intro_msg = (
                HTML_PREFIX +
                "<p>ℹ️ The following files from multi-file manga posts "
                "(after the first file) kept their <b>original names</b>:</p>"
            )
            self.log_signal.emit(intro_msg)

            html_list_items = "<ul>"
            for name in kept_original_names_list:
                html_list_items += f"<li><b>{name}</b></li>"
            html_list_items += "</ul>"

            self.log_signal.emit(HTML_PREFIX + html_list_items)
            self.log_signal.emit("="*40)


        self.progress_label.setText(f"{status_message}: {total_downloaded} downloaded, {total_skipped} skipped."); self.file_progress_label.setText("")
        if not cancelled_by_user: self._try_process_next_external_link()

        if self.download_thread:
            try:
                if hasattr(self.download_thread, 'progress_signal'): self.download_thread.progress_signal.disconnect(self.handle_main_log)
                if hasattr(self.download_thread, 'add_character_prompt_signal'): self.download_thread.add_character_prompt_signal.disconnect(self.add_character_prompt_signal)
                if hasattr(self.download_thread, 'finished_signal'): self.download_thread.finished_signal.disconnect(self.download_finished)
                if hasattr(self.download_thread, 'receive_add_character_result'): self.character_prompt_response_signal.disconnect(self.download_thread.receive_add_character_result)
                if hasattr(self.download_thread, 'external_link_signal'): self.download_thread.external_link_signal.disconnect(self.handle_external_link_signal)
                if hasattr(self.download_thread, 'file_progress_signal'): self.download_thread.file_progress_signal.disconnect(self.update_file_progress_display)
            except (TypeError, RuntimeError) as e: self.log_signal.emit(f"ℹ️ Note during single-thread signal disconnection: {e}")
            self.download_thread = None
        if self.thread_pool: self.log_signal.emit("   Ensuring worker thread pool is shut down..."); self.thread_pool.shutdown(wait=True, cancel_futures=True); self.thread_pool = None
        self.active_futures = []

        self.set_ui_enabled(True); self.cancel_btn.setEnabled(False)

    def toggle_log_verbosity(self):
        self.basic_log_mode = not self.basic_log_mode
        if self.basic_log_mode: self.log_verbosity_button.setText("Show Full Log"); self.log_signal.emit("="*20 + " Basic Log Mode Enabled " + "="*20)
        else: self.log_verbosity_button.setText("Show Basic Log"); self.log_signal.emit("="*20 + " Full Log Mode Enabled " + "="*20)

    def reset_application_state(self):
        if self._is_download_active(): QMessageBox.warning(self, "Reset Error", "Cannot reset while a download is in progress. Please cancel first."); return
        self.log_signal.emit("🔄 Resetting application state to defaults..."); self._reset_ui_to_defaults()
        self.main_log_output.clear(); self.external_log_output.clear()
        if self.show_external_links and not (self.radio_only_links and self.radio_only_links.isChecked()): self.external_log_output.append("🔗 External Links Found:")
        self.external_link_queue.clear(); self.extracted_links_cache = []; self._is_processing_external_link_queue = False; self._current_link_post_title = None
        self.progress_label.setText("Progress: Idle"); self.file_progress_label.setText("")

        with self.downloaded_files_lock: count = len(self.downloaded_files); self.downloaded_files.clear();
        if count > 0: self.log_signal.emit(f"   Cleared {count} downloaded filename(s) from session memory.")
        with self.downloaded_file_hashes_lock: count = len(self.downloaded_file_hashes); self.downloaded_file_hashes.clear();
        if count > 0: self.log_signal.emit(f"   Cleared {count} downloaded file hash(es) from session memory.")

        self.total_posts_to_process = 0; self.processed_posts_count = 0; self.download_counter = 0; self.skip_counter = 0
        self.all_kept_original_filenames = []
        self.cancellation_event.clear(); self.basic_log_mode = False
        if self.log_verbosity_button: self.log_verbosity_button.setText("Show Basic Log")

        self.manga_filename_style = STYLE_POST_TITLE
        self.settings.setValue(MANGA_FILENAME_STYLE_KEY, self.manga_filename_style)
        
        self.skip_words_scope = SKIP_SCOPE_FILES # Reset to default "Files"
        self.settings.setValue(SKIP_WORDS_SCOPE_KEY, self.skip_words_scope)
        self._update_skip_scope_button_text() # Update button text

        self.settings.sync()
        self._update_manga_filename_style_button_text()
        self.update_ui_for_manga_mode(self.manga_mode_checkbox.isChecked() if self.manga_mode_checkbox else False)

        self.log_signal.emit("✅ Application reset complete.")

    def _reset_ui_to_defaults(self):
        self.link_input.clear(); self.dir_input.clear(); self.custom_folder_input.clear(); self.character_input.clear();
        self.skip_words_input.clear(); self.start_page_input.clear(); self.end_page_input.clear(); self.new_char_input.clear();
        self.character_search_input.clear(); self.thread_count_input.setText("4"); self.radio_all.setChecked(True);
        self.skip_zip_checkbox.setChecked(True); self.skip_rar_checkbox.setChecked(True); self.download_thumbnails_checkbox.setChecked(False);
        self.compress_images_checkbox.setChecked(False); self.use_subfolders_checkbox.setChecked(True);
        self.use_subfolder_per_post_checkbox.setChecked(False); self.use_multithreading_checkbox.setChecked(True);
        self.external_links_checkbox.setChecked(False)
        if self.manga_mode_checkbox: self.manga_mode_checkbox.setChecked(False)
        
        self.skip_words_scope = SKIP_SCOPE_FILES # Reset scope variable
        self._update_skip_scope_button_text() # Update button text


        self._handle_filter_mode_change(self.radio_all, True)
        self._handle_multithreading_toggle(self.use_multithreading_checkbox.isChecked())
        self.filter_character_list("")

        self.download_btn.setEnabled(True); self.cancel_btn.setEnabled(False)
        if self.reset_button: self.reset_button.setEnabled(True)
        if self.log_verbosity_button: self.log_verbosity_button.setText("Show Basic Log")

        self._update_manga_filename_style_button_text()
        self.update_ui_for_manga_mode(False)

    def prompt_add_character(self, character_name):
        global KNOWN_NAMES
        reply = QMessageBox.question(self, "Add Filter Name to Known List?", f"The name '{character_name}' was encountered or used as a filter.\nIt's not in your known names list (used for folder suggestions).\nAdd it now?", QMessageBox.Yes | QMessageBox.No, QMessageBox.Yes)
        result = (reply == QMessageBox.Yes)
        if result:
              self.new_char_input.setText(character_name)
              if self.add_new_character(): self.log_signal.emit(f"✅ Added '{character_name}' to known names via background prompt.")
              else: result = False; self.log_signal.emit(f"ℹ️ Adding '{character_name}' via background prompt was declined or failed.")
        self.character_prompt_response_signal.emit(result)

    def receive_add_character_result(self, result):
        with QMutexLocker(self.prompt_mutex): self._add_character_response = result
        self.log_signal.emit(f"   Main thread received character prompt response: {'Action resulted in addition/confirmation' if result else 'Action resulted in no addition/declined'}")


if __name__ == '__main__':
    import traceback
    try:
        qt_app = QApplication(sys.argv)
        if getattr(sys, 'frozen', False): base_dir = sys._MEIPASS
        else: base_dir = os.path.dirname(os.path.abspath(__file__))
        icon_path = os.path.join(base_dir, 'Kemono.ico')
        if os.path.exists(icon_path): qt_app.setWindowIcon(QIcon(icon_path))
        else: print(f"Warning: Application icon 'Kemono.ico' not found at {icon_path}")

        downloader_app_instance = DownloaderApp()
        downloader_app_instance.show()

        if TourDialog:
            tour_result = TourDialog.run_tour_if_needed(downloader_app_instance)
            if tour_result == QDialog.Accepted: print("Tour completed by user.")
            elif tour_result == QDialog.Rejected: print("Tour skipped or was already shown.")

        exit_code = qt_app.exec_()
        print(f"Application finished with exit code: {exit_code}")
        sys.exit(exit_code)
    except SystemExit: pass
    except Exception as e:
        print("--- CRITICAL APPLICATION ERROR ---")
        print(f"An unhandled exception occurred: {e}")
        traceback.print_exc()
        print("--- END CRITICAL ERROR ---")
        sys.exit(1)