"""
Retranslation GUI Module
Force retranslation functionality for EPUB, text, and image files
"""

import os
import sys
import json
import re
from PySide6.QtWidgets import (QWidget, QDialog, QLabel, QFrame, QListWidget, 
                                QPushButton, QVBoxLayout, QHBoxLayout, QGridLayout,
                                QMessageBox, QFileDialog, QTabWidget, QListWidgetItem,
                                QScrollArea, QSizePolicy, QMenu)
from PySide6.QtCore import Qt, Signal, QTimer, QPropertyAnimation, QEasingCurve, Property, QEventLoop, QUrl
from PySide6.QtGui import QFont, QColor, QTransform, QIcon, QPixmap, QDesktopServices
import xml.etree.ElementTree as ET
import zipfile
import shutil
import traceback
import subprocess

# WindowManager and UIHelper removed - not needed in PySide6
# Qt handles window management and UI utilities automatically


class AnimatedRefreshButton(QPushButton):
    """Custom QPushButton with rotation animation for refresh action using Halgakos.ico"""
    
    def __init__(self, text="Refresh", parent=None):
        super().__init__(text, parent)
        self._rotation = 0
        self._animation = None
        self._original_text = text
        self._timer = None
        self._animation_step = 0
        self._original_icon = None
        
        # Try to load Halgakos.ico
        try:
            # Get base directory
            base_dir = getattr(sys, '_MEIPASS', os.path.dirname(os.path.abspath(__file__)))
            ico_path = os.path.join(base_dir, 'Halgakos.ico')
            if os.path.isfile(ico_path):
                self._original_icon = QIcon(ico_path)
                self.setIcon(self._original_icon)
                self.setIconSize(self.iconSize() * 1.2)  # Make icon slightly larger
        except Exception as e:
            print(f"Could not load Halgakos.ico for refresh button: {e}")
        
    def get_rotation(self):
        return self._rotation
    
    def set_rotation(self, angle):
        self._rotation = angle
        self.update()  # Trigger repaint
    
    # Define rotation as a Qt Property for animation
    rotation = Property(float, get_rotation, set_rotation)
    
    def start_animation(self):
        """Start the spinning animation"""
        if self._timer and self._timer.isActive():
            return  # Already animating
        
        # Update stylesheet to show active state
        current_style = self.styleSheet()
        if "background-color: #17a2b8" in current_style:
            self.setStyleSheet(current_style.replace(
                "background-color: #17a2b8",
                "background-color: #138496"
            ))
        
        # Start timer-based animation for icon rotation
        self._animation_step = 0
        self._timer = QTimer(self)
        self._timer.timeout.connect(self._update_animation_frame)
        self._timer.start(50)  # Update every 50ms for smooth rotation
    
    def _update_animation_frame(self):
        """Update animation frame by rotating the icon"""
        if self._original_icon:
            # Increment rotation angle (30 degrees per frame for smooth spinning)
            self._rotation = (self._rotation + 30) % 360
            
            # Create a rotated version of the icon
            pixmap = self._original_icon.pixmap(self.iconSize())
            transform = QTransform().rotate(self._rotation)
            rotated_pixmap = pixmap.transformed(transform, Qt.SmoothTransformation)
            
            # Set the rotated icon
            self.setIcon(QIcon(rotated_pixmap))
    
    def stop_animation(self):
        """Stop the spinning animation"""
        if self._timer:
            self._timer.stop()
            self._timer = None
            self._rotation = 0
            self._animation_step = 0
            
            # Restore original icon (unrotated)
            if self._original_icon:
                self.setIcon(self._original_icon)
            
            # Restore original stylesheet
            current_style = self.styleSheet()
            if "background-color: #138496" in current_style:
                self.setStyleSheet(current_style.replace(
                    "background-color: #138496",
                    "background-color: #17a2b8"
                ))
            
            self.update()


class RetranslationMixin:
    """Mixin class containing retranslation methods for TranslatorGUI"""
    
    def _ui_yield(self, ms=5):
        """Let the Qt event loop process pending events briefly."""
        try:
            if getattr(self, '_suspend_yield', False):
                return
            from PySide6.QtWidgets import QApplication
            QApplication.processEvents(QEventLoop.AllEvents, ms)
        except Exception:
            pass
    
    def _clear_layout(self, layout):
        """Safely clear all items from a layout"""
        if layout is None:
            return
        while layout.count():
            item = layout.takeAt(0)
            if item:
                widget = item.widget()
                if widget:
                    widget.setParent(None)
                    widget.deleteLater()
                elif item.layout():
                    self._clear_layout(item.layout())
    
    def _get_dialog_size(self, width_ratio=0.5, height_ratio=0.5):
        """Calculate dialog size as a ratio of screen size (default 50% width, 50% height)"""
        try:
            from PySide6.QtWidgets import QApplication
            from PySide6.QtGui import QScreen
            
            # Get primary screen
            screen = QApplication.primaryScreen()
            if screen:
                geometry = screen.availableGeometry()
                width = int(geometry.width() * width_ratio)
                height = int(geometry.height() * height_ratio)
                return width, height
        except:
            pass
        
        # Fallback to reasonable defaults if screen info unavailable
        return int(1920 * width_ratio), int(1080 * height_ratio)
    
    def _show_message(self, msg_type, title, message, parent=None):
        """Show message using PySide6 QMessageBox with Halgakos icon"""
        try:
            # Create message box
            msg_box = QMessageBox(parent)
            msg_box.setWindowTitle(title)
            msg_box.setText(message)
            
            # Set icon based on message type
            if msg_type == 'info':
                msg_box.setIcon(QMessageBox.Information)
            elif msg_type == 'warning':
                msg_box.setIcon(QMessageBox.Warning)
            elif msg_type == 'error':
                msg_box.setIcon(QMessageBox.Critical)
            elif msg_type == 'question':
                msg_box.setIcon(QMessageBox.Question)
                msg_box.setStandardButtons(QMessageBox.Yes | QMessageBox.No)
            
            # Try to set Halgakos window icon
            try:
                from PySide6.QtGui import QIcon
                if hasattr(self, 'base_dir'):
                    base_dir = self.base_dir
                else:
                    import sys
                    base_dir = getattr(sys, '_MEIPASS', os.path.dirname(os.path.abspath(__file__)))
                ico_path = os.path.join(base_dir, 'Halgakos.ico')
                if os.path.isfile(ico_path):
                    msg_box.setWindowIcon(QIcon(ico_path))
            except:
                pass
            
            # Show message box
            if msg_type == 'question':
                # Ensure dialog stays on top if it's a critical question
                msg_box.setWindowFlags(msg_box.windowFlags() | Qt.WindowStaysOnTopHint)
                return msg_box.exec() == QMessageBox.Yes
            else:
                msg_box.setWindowFlags(msg_box.windowFlags() | Qt.WindowStaysOnTopHint)
                msg_box.exec()
                return True
                
        except Exception as e:
            # Fallback to console if dialog fails
            print(f"{title}: {message}")
            if msg_type == 'question':
                return False
            return False
 
    def force_retranslation(self):
        """Force retranslation of specific chapters or images with improved display"""
        
        # Check for multiple file selection first
        if hasattr(self, 'selected_files') and len(self.selected_files) > 1:
            self._force_retranslation_multiple_files()
            return
        
        # Check if it's a folder selection (for images)
        if hasattr(self, 'selected_files') and len(self.selected_files) > 0:
            # Check if the first selected file is actually a folder
            first_item = self.selected_files[0]
            if os.path.isdir(first_item):
                self._force_retranslation_images_folder(first_item)
                return
        
        # Original logic for single files
        # Get input path from QLineEdit widget
        if hasattr(self.entry_epub, 'text'):
            # PySide6 QLineEdit widget
            input_path = self.entry_epub.text()
        else:
            input_path = ""
        
        if not input_path or not os.path.isfile(input_path):
            self._show_message('error', "Error", "Please select a valid EPUB, text file, or image folder first.")
            return
        
        # Check if it's an image file
        image_extensions = ('.png', '.jpg', '.jpeg', '.gif', '.bmp', '.webp')
        if input_path.lower().endswith(image_extensions):
            # For single image, pass the image file path itself
            self._force_retranslation_images_folder(input_path)
            return
        
        # Check if dialog already exists for this file and is just hidden
        file_key = os.path.abspath(input_path)
        if hasattr(self, '_retranslation_dialog_cache') and file_key in self._retranslation_dialog_cache:
            # Reuse existing dialog - just show it and refresh data
            cached_data = self._retranslation_dialog_cache[file_key]
            if cached_data and cached_data.get('dialog'):
                # Recompute output directory (override path can change, or cache can be stale)
                epub_base = os.path.splitext(os.path.basename(input_path))[0]
                override_dir = (os.environ.get('OUTPUT_DIRECTORY') or os.environ.get('OUTPUT_DIR'))
                if not override_dir and hasattr(self, 'config'):
                    try:
                        override_dir = self.config.get('output_directory')
                    except Exception:
                        override_dir = None
                expected_output_dir = os.path.join(override_dir, epub_base) if override_dir else epub_base

                output_dir = cached_data.get('output_dir')
                progress_file = cached_data.get('progress_file')

                # If cache points at a different location than current override, force a rebuild.
                if output_dir and expected_output_dir and os.path.abspath(output_dir) != os.path.abspath(expected_output_dir):
                    del self._retranslation_dialog_cache[file_key]
                else:
                    # Check if output folder still exists before trying to refresh
                    if not output_dir:
                        output_dir = expected_output_dir
                        cached_data['output_dir'] = output_dir
                        cached_data['progress_file'] = os.path.join(output_dir, "translation_progress.json")
                        progress_file = cached_data['progress_file']

                    if not os.path.exists(output_dir):
                        # Output folder was deleted - show message and remove from cache
                        self._show_message('info', "Info", "No translation output found for this file.")
                        del self._retranslation_dialog_cache[file_key]
                        return

                    if not progress_file or not os.path.exists(progress_file):
                        # Progress file was deleted - show message and remove from cache,
                        # but DO NOT return. Fall through so we rebuild the dialog and
                        # auto-discover completed chapters in a single click.
                        self._show_message('info', "Info", "No progress tracking found. Existing translations will be auto-discovered.")
                        del self._retranslation_dialog_cache[file_key]
                    else:
                        dialog = cached_data['dialog']
                        # Refresh the data before showing
                        self._refresh_retranslation_data(cached_data)
                        dialog.show()
                        dialog.raise_()
                        dialog.activateWindow()
                        return
        
        # For EPUB/text files, use the shared logic
        # Get current toggle state if it exists, or default based on file type
        # Default to True for .txt, .pdf, .csv, and .json files, False for .epub
        show_special_extensions = ('.txt', '.pdf', '.csv', '.json')
        show_special = input_path.lower().endswith(show_special_extensions)
        
        if hasattr(self, '_retranslation_dialog_cache') and file_key in self._retranslation_dialog_cache:
            cached_data = self._retranslation_dialog_cache[file_key]
            if cached_data:
                show_special = cached_data.get('show_special_files_state', show_special)
        
        self._force_retranslation_epub_or_text(input_path, show_special_files_state=show_special)


    def _force_retranslation_epub_or_text(self, file_path, parent_dialog=None, tab_frame=None, show_special_files_state=False):
        """
        Shared logic for force retranslation of EPUB/text files with OPF support
        Can be used standalone or embedded in a tab
        
        Args:
            file_path: Path to the EPUB/text file
            parent_dialog: If provided, won't create its own dialog
            tab_frame: If provided, will render into this frame instead of creating dialog
            show_special_files_state: Initial state for showing special files toggle
        
        Returns:
            dict: Contains all the UI elements and data for external access
        """
        
        epub_base = os.path.splitext(os.path.basename(file_path))[0]
        
        # Check for output directory override
        override_dir = (os.environ.get('OUTPUT_DIRECTORY') or os.environ.get('OUTPUT_DIR'))
        if not override_dir and hasattr(self, 'config'):
            override_dir = self.config.get('output_directory')
            
        if override_dir:
            output_dir = os.path.join(override_dir, epub_base)
        else:
            output_dir = epub_base
        
        if not os.path.exists(output_dir):
            if not parent_dialog:
                self._show_message('info', "Info", "No translation output found for this file.")
            return None
        
        progress_file = os.path.join(output_dir, "translation_progress.json")
        if not os.path.exists(progress_file):
            # No progress file - create empty progress structure
            # This allows fuzzy matching to discover existing files
            print("⚠️ No progress file found - will attempt to discover existing translations")
            prog = {
                "chapters": {},
                "chapter_chunks": {},
                "version": "2.1"
            }
        else:
            with open(progress_file, 'r', encoding='utf-8') as f:
                prog = json.load(f)

        # Helper: auto-discover completed files when no OPF is available
        def _auto_discover_from_output_dir(output_dir, prog):
            updated = False
            try:
                files = [
                    f for f in os.listdir(output_dir)
                    if os.path.isfile(os.path.join(output_dir, f))
                    # accept any extension except .epub
                    and not f.lower().endswith("_translated.txt")
                    and f != "translation_progress.json"
                    and not f.lower().endswith(".epub")
                ]
                for fname in files:
                    base = os.path.basename(fname)
                    # Normalize by stripping response_ and all extensions
                    if base.startswith("response_"):
                        base = base[len("response_"):]
                    while True:
                        new_base, ext = os.path.splitext(base)
                        if not ext:
                            break
                        base = new_base

                    import re
                    m = re.findall(r"(\d+)", base)
                    chapter_num = int(m[-1]) if m else None
                    key = str(chapter_num) if chapter_num is not None else f"special_{base}"
                    actual_num = chapter_num if chapter_num is not None else 0

                    if key in prog.get("chapters", {}):
                        continue

                    prog.setdefault("chapters", {})[key] = {
                        "actual_num": actual_num,
                        "content_hash": "",
                        "output_file": fname,
                        "status": "completed",
                        "last_updated": os.path.getmtime(os.path.join(output_dir, fname)),
                        "auto_discovered": True,
                        "original_basename": fname
                    }
                    updated = True
            except Exception as e:
                print(f"⚠️ Auto-discovery (no OPF) failed: {e}")
            return updated
        
        # Clean up missing files and merged children when opening the GUI
        # This handles the case where parent files were manually deleted
        from TransateKRtoEN import ProgressManager
        temp_progress = ProgressManager(os.path.dirname(progress_file))
        temp_progress.prog = prog
        temp_progress.cleanup_missing_files(output_dir)
        prog = temp_progress.prog
        
        # Save the cleaned progress back to file
        with open(progress_file, 'w', encoding='utf-8') as f:
            json.dump(prog, f, ensure_ascii=False, indent=2)
        
        # =====================================================
        # PARSE CONTENT.OPF FOR CHAPTER MANIFEST
        # =====================================================
        
        # State variable for special files toggle (will be set later by checkbox)
        show_special_files = [show_special_files_state]  # Use list to allow modification in nested function
        
        spine_chapters = []
        opf_chapter_order = {}
        is_epub = file_path.lower().endswith('.epub')
        opf_parsed = False

        if is_epub and os.path.exists(file_path):
            try:
                import xml.etree.ElementTree as ET
                import zipfile
                
                with zipfile.ZipFile(file_path, 'r') as zf:
                    # Find content.opf file
                    opf_path = None
                    opf_content = None
                    
                    # First try to find via container.xml
                    try:
                        container_content = zf.read('META-INF/container.xml')
                        container_root = ET.fromstring(container_content)
                        rootfile = container_root.find('.//{urn:oasis:names:tc:opendocument:xmlns:container}rootfile')
                        if rootfile is not None:
                            opf_path = rootfile.get('full-path')
                    except:
                        pass
                    
                    # Fallback: search for content.opf
                    if not opf_path:
                        for name in zf.namelist():
                            if name.endswith('content.opf'):
                                opf_path = name
                                break
                    
                    if opf_path:
                        opf_content = zf.read(opf_path)
                        
                        # Parse OPF
                        root = ET.fromstring(opf_content)
                        
                        # Handle namespaces
                        ns = {'opf': 'http://www.idpf.org/2007/opf'}
                        if root.tag.startswith('{'):
                            default_ns = root.tag[1:root.tag.index('}')]
                            ns = {'opf': default_ns}
                        
                        # Get manifest - all chapter files
                        manifest_chapters = {}
                        
                        for item in root.findall('.//opf:manifest/opf:item', ns):
                            item_id = item.get('id')
                            href = item.get('href')
                            media_type = item.get('media-type', '')
                            
                            if item_id and href and ('html' in media_type.lower() or href.endswith(('.html', '.xhtml', '.htm'))):
                                filename = os.path.basename(href)
                                
                                # Detect special files (files without numbers)
                                import re
                                # Check if filename contains any digits
                                has_numbers = bool(re.search(r'\d', filename))
                                is_special = not has_numbers
                                
                                # Add all files - UI will handle filtering based on toggle
                                manifest_chapters[item_id] = {
                                    'filename': filename,
                                    'href': href,
                                    'media_type': media_type,
                                    'is_special': is_special
                                }
                        
                        # Get spine order - the reading order
                        spine = root.find('.//opf:spine', ns)
                        
                        if spine is not None:
                            for itemref in spine.findall('opf:itemref', ns):
                                idref = itemref.get('idref')
                                if idref and idref in manifest_chapters:
                                    chapter_info = manifest_chapters[idref]
                                    filename = chapter_info['filename']
                                    is_special = chapter_info.get('is_special', False)
                                    
                                    # Extract chapter number from filename
                                    import re
                                    matches = re.findall(r'(\d+)', filename)
                                    if matches:
                                        file_chapter_num = int(matches[-1])
                                    elif is_special:
                                        # Special files without numbers should be chapter 0
                                        file_chapter_num = 0
                                    else:
                                        file_chapter_num = len(spine_chapters)
                                    
                                    # Add all files - UI will handle filtering based on toggle
                                    spine_chapters.append({
                                        'id': idref,
                                        'filename': filename,
                                        'position': len(spine_chapters),
                                        'file_chapter_num': file_chapter_num,
                                        'status': 'unknown',  # Will be updated
                                        'output_file': None,    # Will be updated
                                        'is_special': is_special
                                    })
                                    
                                    # Store the order for later use
                                    opf_chapter_order[filename] = len(spine_chapters) - 1
                                    
                                    # Also store without extension for matching
                                    filename_noext = os.path.splitext(filename)[0]
                                    opf_chapter_order[filename_noext] = len(spine_chapters) - 1
                                    opf_parsed = True
                        
            except Exception as e:
                print(f"Warning: Could not parse OPF: {e}")

        # If no OPF/spine, fall back to auto-discovery from output_dir
        if not opf_parsed or len(spine_chapters) == 0:
            if _auto_discover_from_output_dir(output_dir, prog):
                try:
                    with open(progress_file, 'w', encoding='utf-8') as f:
                        json.dump(prog, f, ensure_ascii=False, indent=2)
                    print("💾 Saved auto-discovered progress (no OPF available)")
                except Exception as e:
                    print(f"⚠️ Failed to save auto-discovered progress: {e}")
        else:
            # OPF-AWARE AUTO-DISCOVERY: Use OPF filenames as original_basename
            # This ensures correct mapping between OPF entries and response files
            progress_updated = False
            for spine_ch in spine_chapters:
                opf_filename = spine_ch['filename']  # e.g., "0009_10_.xhtml"
                base_name = os.path.splitext(opf_filename)[0]  # e.g., "0009_10_"
                
                # Look for corresponding response file on disk
                response_file = f"response_{base_name}.html"
                response_path = os.path.join(output_dir, response_file)
                
                if os.path.exists(response_path):
                    # Check if we already have a progress entry with correct original_basename
                    already_tracked = False
                    for ch_info in prog.get("chapters", {}).values():
                        if ch_info.get("original_basename") == opf_filename:
                            already_tracked = True
                            break
                        # Also check by output_file
                        if ch_info.get("output_file") == response_file:
                            # Update original_basename if missing or wrong
                            if ch_info.get("original_basename") != opf_filename:
                                ch_info["original_basename"] = opf_filename
                                progress_updated = True
                            already_tracked = True
                            break
                    
                    if not already_tracked:
                        # Create new progress entry with correct original_basename
                        chapter_num = spine_ch['file_chapter_num']
                        key = str(chapter_num) if chapter_num else f"special_{base_name}"
                        
                        # Avoid duplicate keys
                        if key not in prog.get("chapters", {}):
                            prog.setdefault("chapters", {})[key] = {
                                "actual_num": chapter_num,
                                "content_hash": "",
                                "output_file": response_file,
                                "status": "completed",
                                "last_updated": os.path.getmtime(response_path),
                                "auto_discovered": True,
                                "original_basename": opf_filename  # CORRECT: OPF filename
                            }
                            progress_updated = True
                            print(f"✅ OPF-aware discovery: {opf_filename} -> {response_file}")
            
            if progress_updated:
                try:
                    with open(progress_file, 'w', encoding='utf-8') as f:
                        json.dump(prog, f, ensure_ascii=False, indent=2)
                    #print("💾 Saved OPF-aware auto-discovered progress")
                except Exception as e:
                    print(f"⚠️ Failed to save progress: {e}")
        
        # =====================================================
        # MATCH OPF CHAPTERS WITH TRANSLATION PROGRESS
        # =====================================================
        
        # Helper: normalize filenames for OPF / progress matching
        # We intentionally strip a leading "response_" prefix so that
        # files like "chapter001.xhtml" and "response_chapter001.xhtml"
        # are treated as referring to the same logical entry.
        def _normalize_opf_match_name(name: str) -> str:
            if not name:
                return ""
            base = os.path.basename(name)
            # Remove response_ prefix
            if base.startswith("response_"):
                base = base[len("response_"):]
            # Remove all extensions so that .html, .xhtml, .htm, etc. all match
            # and double extensions like .html.xhtml collapse to the stem.
            while True:
                new_base, ext = os.path.splitext(base)
                if not ext:
                    break
                base = new_base
            return base

        def _opf_names_equal(a: str, b: str) -> bool:
            return _normalize_opf_match_name(a) == _normalize_opf_match_name(b)

        # Build a map of original basenames to progress entries (normalized)
        basename_to_progress = {}
        for chapter_key, chapter_info in prog.get("chapters", {}).items():
            original_basename = chapter_info.get("original_basename", "")
            if original_basename:
                norm_key = _normalize_opf_match_name(original_basename)
                if norm_key not in basename_to_progress:
                    basename_to_progress[norm_key] = []
                basename_to_progress[norm_key].append((chapter_key, chapter_info))
        
        # Also build a map of response files (include both exact and normalized keys)
        response_file_to_progress = {}
        for chapter_key, chapter_info in prog.get("chapters", {}).items():
            output_file = chapter_info.get("output_file", "")
            if output_file:
                # Exact key
                if output_file not in response_file_to_progress:
                    response_file_to_progress[output_file] = []
                response_file_to_progress[output_file].append((chapter_key, chapter_info))
                # Normalized key (ignoring response_ prefix)
                norm_key = _normalize_opf_match_name(output_file)
                if norm_key != output_file:
                    if norm_key not in response_file_to_progress:
                        response_file_to_progress[norm_key] = []
                    response_file_to_progress[norm_key].append((chapter_key, chapter_info))
        
        # Update spine chapters with translation status
        for idx, spine_ch in enumerate(spine_chapters):
            if idx % 80 == 0:
                self._ui_yield()
            filename = spine_ch['filename']
            chapter_num = spine_ch['file_chapter_num']
            is_special = spine_ch.get('is_special', False)
            
            # Find the actual response file that exists
            base_name = os.path.splitext(filename)[0]
            expected_response = None
            
            # Special files need to check what actually exists on disk
            if is_special:
                # Check for response_ prefix version
                response_with_prefix = f"response_{base_name}.html"
                retain = os.getenv('RETAIN_SOURCE_EXTENSION', '0') == '1' or self.config.get('retain_source_extension', False)
                
                if retain:
                    expected_response = filename
                elif os.path.exists(os.path.join(output_dir, response_with_prefix)):
                    expected_response = response_with_prefix
                else:
                    # Fallback to original filename
                    expected_response = filename
            else:
                # Use OPF filename directly to avoid mismatching
                retain = os.getenv('RETAIN_SOURCE_EXTENSION', '0') == '1' or self.config.get('retain_source_extension', False)
                if retain:
                    expected_response = filename
                else:
                    # Handle .htm.html -> .html conversion
                    stripped_base_name = base_name
                    if base_name.endswith('.htm'):
                        stripped_base_name = base_name[:-4]  # Remove .htm suffix
                    expected_response = filename  # Use exact OPF filename
            
            response_path = os.path.join(output_dir, expected_response)
            
            # Check various ways to find the translation progress info
            matched_info = None
            
            # Method 1: Check by original basename (ignoring response_ prefix)
            basename_key = _normalize_opf_match_name(filename)
            if basename_key in basename_to_progress:
                entries = basename_to_progress[basename_key]
                if entries:
                    _, chapter_info = entries[0]
                    # For in_progress/failed/qa_failed/pending, also verify actual_num matches
                    status = chapter_info.get('status', '')
                    if status in ['in_progress', 'failed', 'qa_failed', 'pending']:
                        if chapter_info.get('actual_num') == chapter_num:
                            matched_info = chapter_info
                    else:
                        matched_info = chapter_info
            
            # Method 2: Check by response file (with corrected extension)
            if not matched_info and expected_response in response_file_to_progress:
                entries = response_file_to_progress[expected_response]
                if entries:
                    _, chapter_info = entries[0]
                    # For in_progress/failed/qa_failed/pending, also verify actual_num matches
                    status = chapter_info.get('status', '')
                    if status in ['in_progress', 'failed', 'qa_failed', 'pending']:
                        if chapter_info.get('actual_num') == chapter_num:
                            matched_info = chapter_info
                    else:
                        matched_info = chapter_info
            
            # Method 3: Search through all progress entries for matching output file
            if not matched_info:
                for chapter_key, chapter_info in prog.get("chapters", {}).items():
                    out_file = chapter_info.get('output_file')
                    if out_file == expected_response or _opf_names_equal(out_file, expected_response):
                        # For in_progress/failed/qa_failed/pending, also verify actual_num matches
                        status = chapter_info.get('status', '')
                        if status in ['in_progress', 'failed', 'qa_failed', 'pending']:
                            if chapter_info.get('actual_num') == chapter_num:
                                matched_info = chapter_info
                                break
                        else:
                            matched_info = chapter_info
                            break
            
            # Method 4: CRUCIAL - Match by chapter number (actual_num vs file_chapter_num)
            # Also check composite keys for special files (e.g., "0_message", "0_TOC")
            if not matched_info:
                # First try simple chapter number key
                simple_key = str(chapter_num)
                if simple_key in prog.get("chapters", {}):
                    chapter_info = prog["chapters"][simple_key]
                    out_file = chapter_info.get('output_file')
                    status = chapter_info.get('status', '')
                    orig_base = chapter_info.get('original_basename', '')
                    if orig_base:
                        orig_base = os.path.basename(orig_base)
                    
                    # Merged chapters: check if parent exists AND original_basename matches
                    if status == 'merged':
                        parent_num = chapter_info.get('merged_parent_chapter')
                        # For merged chapters, match by original_basename (not output_file)
                        # because output_file points to parent's file, not this chapter's source file
                        # Strip extension for comparison since orig_base may not have it
                        filename_noext = os.path.splitext(filename)[0]
                        if parent_num is not None and (
                            _opf_names_equal(orig_base, filename)
                            or _opf_names_equal(orig_base, filename_noext)
                            or not orig_base
                        ):
                            parent_key = str(parent_num)
                            if parent_key in prog.get("chapters", {}):
                                # Just verify parent exists, don't enforce 'completed' status
                                # This ensures we show 'merged' even if parent is completed_empty or other states
                                matched_info = chapter_info
                    # In-progress/failed/pending chapters: require BOTH actual_num AND output_file
                    # to match to avoid cross-matching files.
                    elif status in ['in_progress', 'failed', 'pending']:
                        if chapter_info.get('actual_num') == chapter_num and (
                            out_file == expected_response or _opf_names_equal(out_file, expected_response)
                        ):
                            matched_info = chapter_info
                    # qa_failed chapters: match by chapter number only so they are always visible
                    elif status == 'qa_failed':
                        if chapter_info.get('actual_num') == chapter_num:
                            matched_info = chapter_info
                    # Normal match: output file matches expected (ignoring response_ prefix)
                    elif out_file == expected_response or _opf_names_equal(out_file, expected_response):
                        matched_info = chapter_info
                
                # If not found, check for composite key (chapter_num + filename)
                if not matched_info and is_special:
                    # For special files, try composite key format: "{chapter_num}_{filename_without_extension}"
                    base_name = os.path.splitext(filename)[0]
                    # Remove "response_" prefix if present in the filename
                    if base_name.startswith("response_"):
                        base_name = base_name[9:]
                    composite_key = f"{chapter_num}_{base_name}"
                    
                    if composite_key in prog.get("chapters", {}):
                        matched_info = prog["chapters"][composite_key]
                
                # Fallback: iterate through all entries matching chapter number,
                # but only accept when it clearly refers to the same source file.
                # This prevents files like "000_information.xhtml" and "0153_0.xhtml"
                # (both parsed as chapter 0) from being conflated.
                if not matched_info:
                    for chapter_key, chapter_info in prog.get("chapters", {}).items():
                        actual_num = chapter_info.get('actual_num')
                        # Also check 'chapter_num' as fallback
                        if actual_num is None:
                            actual_num = chapter_info.get('chapter_num')
                        
                        if actual_num is not None and actual_num == chapter_num:
                            orig_base = chapter_info.get('original_basename', '')
                            if orig_base:
                                orig_base = os.path.basename(orig_base)
                            out_file = chapter_info.get('output_file')
                            status = chapter_info.get('status', '')
                            qa_issues = chapter_info.get('qa_issues_found', [])
                            
                            # Merged chapters: match by actual_num AND original_basename
                            # For merged, output_file points to parent so we must match by source filename
                            if status == 'merged':
                                parent_num = chapter_info.get('merged_parent_chapter')
                                # Match by original_basename (the source file), not output_file (parent's file)
                                # Strip extension for comparison since orig_base may not have it
                                filename_noext = os.path.splitext(filename)[0]
                                if parent_num is not None and (
                                    _opf_names_equal(orig_base, filename)
                                    or _opf_names_equal(orig_base, filename_noext)
                                    or not orig_base
                                ):
                                    # Check if parent chapter exists
                                    parent_key = str(parent_num)
                                    if parent_key in prog.get("chapters", {}):
                                        # Just verify parent exists, don't enforce 'completed' status
                                        matched_info = chapter_info
                                        break
                            
                            # In-progress/failed/pending chapters: require BOTH actual_num AND output_file
                            # to match to avoid cross-matching files.
                            if status in ['in_progress', 'failed', 'pending']:
                                if actual_num == chapter_num and (
                                    out_file == expected_response or _opf_names_equal(out_file, expected_response)
                                ):
                                    matched_info = chapter_info
                                    break
                            # qa_failed chapters: match by chapter number only so they are always visible,
                            # even when filenames don't line up perfectly.
                            elif status == 'qa_failed':
                                if actual_num == chapter_num:
                                    matched_info = chapter_info
                                    break
                            
                            # Only treat as a match for other statuses if the original basename matches
                            # this filename, or, when original_basename is missing, the output_file matches
                            # what we expect.
                            if status not in ['in_progress', 'failed', 'qa_failed', 'pending']:
                                if (
                                    orig_base and _opf_names_equal(orig_base, filename)
                                ) or (
                                    not orig_base and out_file and (
                                        out_file == expected_response or _opf_names_equal(out_file, expected_response)
                                    )
                                ):
                                    matched_info = chapter_info
                                    break
            
            # Determine if translation file exists
            file_exists = os.path.exists(response_path)
            
            # Set status and output file based on findings
            if matched_info:
                # We found progress tracking info - use its status
                status = matched_info.get('status', 'unknown')
                spine_ch['progress_key'] = matched_info.get('_key')
                
                # CRITICAL: For failed/in_progress/qa_failed/pending, ALWAYS use progress status
                # Never let file existence override these statuses
                if status in ['failed', 'in_progress', 'qa_failed', 'pending']:
                    spine_ch['status'] = status
                    spine_ch['output_file'] = matched_info.get('output_file') or expected_response
                    spine_ch['progress_entry'] = matched_info
                    # Skip all other logic - don't check file existence
                    continue
                
                # For other statuses (completed, merged, etc.)
                spine_ch['status'] = status
                
                # For special files, always use the original filename (ignore what's in progress JSON)
                if is_special:
                    spine_ch['output_file'] = expected_response
                else:
                    spine_ch['output_file'] = matched_info.get('output_file', expected_response)
                
                spine_ch['progress_entry'] = matched_info
                
                # Handle null output_file
                if not spine_ch['output_file']:
                    spine_ch['output_file'] = expected_response
                
                # Verify file actually exists for completed status
                if status == 'completed':
                    output_path = os.path.join(output_dir, spine_ch['output_file'])
                    if not os.path.exists(output_path):
                        # If the expected_response file exists, prefer that and
                        # transparently update the progress entry.
                        if file_exists and expected_response:
                            fixed_output_path = os.path.join(output_dir, expected_response)
                            if os.path.exists(fixed_output_path):
                                spine_ch['output_file'] = expected_response

                                # If this spine chapter is tied to a concrete
                                # progress entry, keep it consistent.
                                if 'progress_entry' in spine_ch and spine_ch['progress_entry'] is not None:
                                    spine_ch['progress_entry']['output_file'] = expected_response

                                    # Also update the master prog dict so the
                                    # corrected value is written back later.
                                    for ch_key, ch_info in prog.get('chapters', {}).items():
                                        if ch_info is spine_ch['progress_entry']:
                                            prog['chapters'][ch_key]['output_file'] = expected_response
                                            break
                            else:
                                # No matching file anywhere – mark as missing.
                                spine_ch['status'] = 'not_translated'
                        else:
                            # Legacy behaviour: nothing on disk for this entry.
                            spine_ch['status'] = 'not_translated'
            
            elif file_exists:
                # File exists but no progress tracking - mark as completed
                spine_ch['status'] = 'completed'
                spine_ch['output_file'] = expected_response
            
            else:
                # No file and no progress tracking - LAST RESORT: Try exact filename matching
                # This handles the case where progress file was deleted but files exist
                # Match by filename only (ignore response_ prefix and all extensions)
                
                def normalize_filename(fname):
                    """Remove response_ prefix and all extensions for exact comparison"""
                    base = os.path.basename(fname)
                    # Remove response_ prefix
                    if base.startswith('response_'):
                        base = base[9:]
                    # Remove all extensions (including double extensions like .html.xhtml)
                    while True:
                        new_base, ext = os.path.splitext(base)
                        if not ext:
                            break
                        base = new_base
                    return base
                
                # Normalize the OPF filename
                normalized_opf = normalize_filename(filename)
                
                # Search for exact matching file in output directory
                matched_file = None
                if os.path.exists(output_dir):
                    try:
                        for existing_file in os.listdir(output_dir):
                            if os.path.isfile(os.path.join(output_dir, existing_file)):
                                normalized_existing = normalize_filename(existing_file)
                                # Exact match only - no fuzzy logic
                                if normalized_existing == normalized_opf:
                                    matched_file = existing_file
                                    break
                    except Exception as e:
                        print(f"Warning: Error scanning output directory for match: {e}")
                
                if matched_file:
                    # Found an exact matching file by normalized name - mark as completed
                    spine_ch['status'] = 'completed'
                    spine_ch['output_file'] = matched_file
                    print(f"📁 Matched: {filename} -> {matched_file}")
                else:
                    # No file and no progress tracking - not translated
                    spine_ch['status'] = 'not_translated'
                    spine_ch['output_file'] = expected_response
        
        # =====================================================
        # SAVE AUTO-DISCOVERED FILES TO PROGRESS
        # =====================================================
        
        # Check if we discovered any new completed files (exact matched by normalized filename)
        # and add them to the progress file
        progress_updated = False
        for spine_ch in spine_chapters:
            # Only add entries that were marked as completed but have no progress entry
            if spine_ch['status'] == 'completed' and 'progress_entry' not in spine_ch:
                chapter_num = spine_ch['file_chapter_num']
                output_file = spine_ch['output_file']
                filename = spine_ch['filename']
                
                # Create a progress entry for this auto-discovered file
                chapter_key = str(chapter_num)
                
                # Check if key already exists (avoid duplicates)
                if chapter_key not in prog.get("chapters", {}):
                    prog.setdefault("chapters", {})[chapter_key] = {
                        "actual_num": chapter_num,
                        "content_hash": "",  # Unknown since we don't have the source
                        "output_file": output_file,
                        "status": "completed",
                        "last_updated": os.path.getmtime(os.path.join(output_dir, output_file)),
                        "auto_discovered": True,
                        "original_basename": filename
                    }
                    progress_updated = True
                    print(f"✅ Auto-discovered and tracked: {filename} -> {output_file}")
        
        # Save progress file if we added new entries
        if progress_updated:
            try:
                with open(progress_file, 'w', encoding='utf-8') as f:
                    json.dump(prog, f, ensure_ascii=False, indent=2)
                print(f"💾 Saved {sum(1 for ch in spine_chapters if ch['status'] == 'completed' and 'progress_entry' not in ch)} auto-discovered files to progress file")
            except Exception as e:
                print(f"⚠️ Warning: Failed to save progress file: {e}")
        
        # =====================================================
        # BUILD DISPLAY INFO
        # =====================================================
        
        chapter_display_info = []
        
        if spine_chapters:
            # Use OPF order
            for spine_ch in spine_chapters:
                display_info = {
                    'key': spine_ch.get('filename', ''),
                    'num': spine_ch['file_chapter_num'],
                    'info': spine_ch.get('progress_entry', {}),
                    'output_file': spine_ch['output_file'],
                    'status': spine_ch['status'],
                    'duplicate_count': 1,
                    'entries': [],
                    'opf_position': spine_ch['position'],
                    'original_filename': spine_ch['filename'],
                    'is_special': spine_ch.get('is_special', False)
                }
                chapter_display_info.append(display_info)
        else:
            # Fallback to original logic if no OPF
            files_to_entries = {}
            for chapter_key, chapter_info in prog.get("chapters", {}).items():
                output_file = chapter_info.get("output_file", "")
                status = chapter_info.get("status", "")
                
                # Include chapters with output files OR transient statuses with null output file (legacy)
                # (composite keys like "0_TOC" should still be represented in the UI)
                if output_file or status in ["in_progress", "pending", "failed", "qa_failed"]:
                    # For merged chapters, use a unique key (chapter_key) instead of output_file
                    # This ensures merged chapters appear as separate entries in the list
                    if status == "merged":
                        file_key = f"_merged_{chapter_key}"
                    elif output_file:
                        file_key = output_file
                    elif status == "in_progress":
                        file_key = f"_in_progress_{chapter_key}"
                    elif status == "pending":
                        file_key = f"_pending_{chapter_key}"
                    elif status == "qa_failed":
                        file_key = f"_qa_failed_{chapter_key}"
                    else:  # failed
                        file_key = f"_failed_{chapter_key}"
                    
                    if file_key not in files_to_entries:
                        files_to_entries[file_key] = []
                    files_to_entries[file_key].append((chapter_key, chapter_info))
            
            for output_file, entries in files_to_entries.items():
                chapter_key, chapter_info = entries[0]
                
                # Get the actual output file (strip placeholder prefix if present)
                actual_output_file = output_file
                if (
                    output_file.startswith("_merged_")
                    or output_file.startswith("_in_progress_")
                    or output_file.startswith("_pending_")
                    or output_file.startswith("_failed_")
                    or output_file.startswith("_qa_failed_")
                ):
                    # For merged/in_progress/pending/failed/qa_failed, get the actual output_file from chapter_info
                    actual_output_file = chapter_info.get("output_file", "")
                    if not actual_output_file:
                        # Generate expected filename based on actual_num
                        actual_num = chapter_info.get("actual_num")
                        if actual_num is not None:
                            # Use .txt extension for text files, .html for EPUB
                            ext = ".txt" if file_path.endswith(".txt") else ".html"
                            actual_output_file = f"response_section_{actual_num}{ext}"
                
                # Check if this is a special file (files without numbers)
                original_basename = chapter_info.get("original_basename", "")
                filename_to_check = original_basename if original_basename else actual_output_file
                
                # Check if filename contains any digits
                import re
                has_numbers = bool(re.search(r'\d', filename_to_check))
                is_special = not has_numbers
                
                # Extract chapter number - prioritize stored values
                chapter_num = None
                if 'actual_num' in chapter_info and chapter_info['actual_num'] is not None:
                    chapter_num = chapter_info['actual_num']
                elif 'chapter_num' in chapter_info and chapter_info['chapter_num'] is not None:
                    chapter_num = chapter_info['chapter_num']
                
                # Fallback: extract from filename
                if chapter_num is None:
                    import re
                    matches = re.findall(r'(\d+)', actual_output_file)
                    if matches:
                        chapter_num = int(matches[-1])
                    else:
                        chapter_num = 999999
                
                status = chapter_info.get("status", "unknown")
                if status == "completed_empty":
                    status = "completed"
                
                # Check file existence
                if status == "completed":
                    output_path = os.path.join(output_dir, actual_output_file)
                    if not os.path.exists(output_path):
                        status = "file_missing"
                
                chapter_display_info.append({
                    'key': chapter_key,
                    'num': chapter_num,
                    'info': chapter_info,
                    'output_file': actual_output_file,  # Use actual output file, not placeholder
                    'status': status,
                    'duplicate_count': len(entries),
                    'entries': entries,
                    'is_special': is_special
                })
            
            # Sort by chapter number
            chapter_display_info.sort(key=lambda x: x['num'] if x['num'] is not None else 999999)
        
        # =====================================================
        # CREATE UI
        # =====================================================
        
        # If no parent dialog or tab frame, create standalone dialog
        if not parent_dialog and not tab_frame:
            # Ensure QApplication exists for standalone PySide6 dialog
            from PySide6.QtWidgets import QApplication
            if not QApplication.instance():
                # Create QApplication if it doesn't exist
                import sys
                QApplication(sys.argv)

            # Create standalone PySide6 dialog.
            # IMPORTANT: If created without a parent, it will NOT inherit the main window's
            # dark stylesheet and will fall back to the OS theme (white on some Win10 setups).
            parent_widget = self if isinstance(self, QWidget) else None
            dialog = QDialog(parent_widget)
            dialog.setWindowTitle("Progress Manager - OPF Based" if spine_chapters else "Progress Manager")
            # Keep above the translator window but allow interaction with it
            dialog.setWindowFlag(Qt.WindowStaysOnTopHint, True)
            dialog.setWindowModality(Qt.NonModal)
            # Use 38% width, 40% height for 1920x1080
            width, height = self._get_dialog_size(0.38, 0.4)
            dialog.resize(width, height)

            # Inherit/copy the main window stylesheet when available (ensures consistent dark theme).
            try:
                if parent_widget is not None:
                    ss = parent_widget.styleSheet()
                    if ss:
                        dialog.setStyleSheet(ss)
            except Exception:
                pass
            
            # Set icon
            try:
                from PySide6.QtGui import QIcon
                # Try to get base_dir from self (TranslatorGUI), fallback to calculating it
                if hasattr(self, 'base_dir'):
                    base_dir = self.base_dir
                else:
                    base_dir = getattr(sys, '_MEIPASS', os.path.dirname(os.path.abspath(__file__)))
                ico_path = os.path.join(base_dir, 'Halgakos.ico')
                if os.path.isfile(ico_path):
                    dialog.setWindowIcon(QIcon(ico_path))
            except Exception as e:
                print(f"Failed to load icon: {e}")
            dialog_layout = QVBoxLayout(dialog)
            container = QWidget(dialog)
            container_layout = QVBoxLayout(container)
            dialog_layout.addWidget(container)
        else:
            container = tab_frame or parent_dialog
            if not hasattr(container, 'layout') or container.layout() is None:
                container_layout = QVBoxLayout(container)
            else:
                container_layout = container.layout()
            dialog = parent_dialog
        
        # Title and toggle row
        title_row = QWidget()
        title_layout = QHBoxLayout(title_row)
        title_layout.setContentsMargins(0, 0, 0, 0)
        
        title_text = "Chapters from content.opf (in reading order):" if spine_chapters else "Select chapters to retranslate:"
        title_label = QLabel(title_text)
        title_font = QFont('Arial', 12 if not tab_frame else 11)
        title_font.setBold(True)
        title_label.setFont(title_font)
        title_layout.addWidget(title_label)
        
        title_layout.addStretch()
        
        # Add toggle for showing special files
        from PySide6.QtWidgets import QCheckBox
        show_special_files_cb = QCheckBox("Show special files (cover, nav, toc)")
        show_special_files_cb.setChecked(show_special_files[0])  # Preserve the current state
        show_special_files_cb.setToolTip("When enabled, shows special files (files without chapter numbers like cover, nav, toc, info, message, etc.)")
        
        # Register this checkbox and checkmark with parent dialog for cross-tab syncing
        if parent_dialog and not hasattr(parent_dialog, '_all_toggle_checkboxes'):
            parent_dialog._all_toggle_checkboxes = []
            parent_dialog._all_checkmark_labels = []
            parent_dialog._tab_file_paths = {}  # Map file_path to index
        if parent_dialog:
            # Store the index for this file
            file_key = os.path.abspath(file_path)
            if file_key not in parent_dialog._tab_file_paths:
                parent_dialog._tab_file_paths[file_key] = len(parent_dialog._all_toggle_checkboxes)
                parent_dialog._all_toggle_checkboxes.append(show_special_files_cb)
            else:
                # Replace the old checkbox at this index
                idx = parent_dialog._tab_file_paths[file_key]
                if idx < len(parent_dialog._all_toggle_checkboxes):
                    parent_dialog._all_toggle_checkboxes[idx] = show_special_files_cb
        
        # Apply blue checkbox stylesheet (matching Other Settings dialog)
        show_special_files_cb.setStyleSheet("""
            QCheckBox {
                color: white;
                spacing: 6px;
            }
            QCheckBox::indicator {
                width: 14px;
                height: 14px;
                border: 1px solid #5a9fd4;
                border-radius: 2px;
                background-color: #2d2d2d;
            }
            QCheckBox::indicator:checked {
                background-color: #5a9fd4;
                border-color: #5a9fd4;
            }
            QCheckBox::indicator:hover {
                border-color: #7bb3e0;
            }
            QCheckBox:disabled {
                color: #666666;
            }
            QCheckBox::indicator:disabled {
                background-color: #1a1a1a;
                border-color: #3a3a3a;
            }
        """)
        
        # Create checkmark overlay for the check symbol
        checkmark = QLabel("✓", show_special_files_cb)
        checkmark.setStyleSheet("""
            QLabel {
                color: white;
                background: transparent;
                font-weight: bold;
                font-size: 11px;
            }
        """)
        checkmark.setAlignment(Qt.AlignCenter)
        checkmark.hide()
        checkmark.setAttribute(Qt.WA_TransparentForMouseEvents)
        
        def position_checkmark():
            try:
                if checkmark:
                    checkmark.setGeometry(2, 1, 14, 14)
            except RuntimeError:
                pass
        
        def update_checkmark():
            try:
                if show_special_files_cb and checkmark:
                    if show_special_files_cb.isChecked():
                        position_checkmark()
                        checkmark.show()
                    else:
                        checkmark.hide()
            except RuntimeError:
                pass
        
        show_special_files_cb.stateChanged.connect(update_checkmark)
        
        def safe_init():
            try:
                position_checkmark()
                update_checkmark()
            except RuntimeError:
                pass
        
        QTimer.singleShot(0, safe_init)
        
        # Register checkmark for cross-tab syncing
        if parent_dialog:
            file_key = os.path.abspath(file_path)
            if file_key in parent_dialog._tab_file_paths:
                idx = parent_dialog._tab_file_paths[file_key]
                # Append if new, replace if exists
                if idx >= len(parent_dialog._all_checkmark_labels):
                    parent_dialog._all_checkmark_labels.append(checkmark)
                else:
                    parent_dialog._all_checkmark_labels[idx] = checkmark
        
        title_layout.addWidget(show_special_files_cb)
        
        container_layout.addWidget(title_row)
        
        # Store reference to the listbox (will be created later)
        listbox_ref = [None]
        
        # Function to handle toggle change - will be defined after UI is created
        def on_toggle_special_files(state):
            """Filter the chapter list when the special files toggle is changed"""
            # Update the state variable
            show_special_files[0] = show_special_files_cb.isChecked()
            
            # Store the state persistently
            file_key = os.path.abspath(file_path)
            if not hasattr(self, '_retranslation_dialog_cache'):
                self._retranslation_dialog_cache = {}
            if file_key not in self._retranslation_dialog_cache:
                self._retranslation_dialog_cache[file_key] = {}
            self._retranslation_dialog_cache[file_key]['show_special_files_state'] = show_special_files[0]
            
            # For tabs in multi-file dialog, sync toggle state across tabs
            if tab_frame and parent_dialog:
                # Update cache for all files in the current selection
                if hasattr(parent_dialog, '_epub_files_in_dialog'):
                    for f_path in parent_dialog._epub_files_in_dialog:
                        f_key = os.path.abspath(f_path)
                        if f_key not in self._retranslation_dialog_cache:
                            self._retranslation_dialog_cache[f_key] = {}
                        self._retranslation_dialog_cache[f_key]['show_special_files_state'] = show_special_files[0]
                
                # Sync ALL toggle checkboxes and checkmarks in ALL tabs
                if hasattr(parent_dialog, '_all_toggle_checkboxes'):
                    for idx, other_checkbox in enumerate(parent_dialog._all_toggle_checkboxes):
                        if other_checkbox is None or other_checkbox == show_special_files_cb:
                            continue
                        
                        try:
                            other_checkbox.isChecked()
                            other_checkbox.blockSignals(True)
                            other_checkbox.setChecked(show_special_files[0])
                            other_checkbox.blockSignals(False)
                            
                            if hasattr(parent_dialog, '_all_checkmark_labels') and idx < len(parent_dialog._all_checkmark_labels):
                                other_checkmark = parent_dialog._all_checkmark_labels[idx]
                                if other_checkmark is not None:
                                    try:
                                        other_checkmark.isVisible()
                                        if show_special_files[0]:
                                            other_checkmark.setGeometry(2, 1, 14, 14)
                                            other_checkmark.show()
                                        else:
                                            other_checkmark.hide()
                                    except RuntimeError:
                                        parent_dialog._all_checkmark_labels[idx] = None
                        except (RuntimeError, AttributeError):
                            parent_dialog._all_toggle_checkboxes[idx] = None
            
            # Filter list items instead of rebuilding entire UI
            if listbox_ref[0]:
                listbox = listbox_ref[0]
                for i in range(listbox.count()):
                    item = listbox.item(i)
                    if item:
                        # Check if this item is marked as special
                        item_data = item.data(Qt.UserRole)
                        if item_data and isinstance(item_data, dict):
                            is_special = item_data.get('is_special', False)
                            # Show all items if toggle is on, hide special files if toggle is off
                            item.setHidden(is_special and not show_special_files[0])
        
        # Connect the checkbox to the handler
        show_special_files_cb.stateChanged.connect(on_toggle_special_files)
        
        # Statistics - always show for both OPF and non-OPF files
        stats_frame = QWidget()
        stats_layout = QHBoxLayout(stats_frame)
        stats_layout.setContentsMargins(0, 5, 0, 5)
        container_layout.addWidget(stats_frame)
        
        # Calculate stats from the appropriate source
        if spine_chapters:
            total_chapters = len(spine_chapters)
            completed = sum(1 for ch in spine_chapters if ch['status'] == 'completed')
            merged = sum(1 for ch in spine_chapters if ch['status'] == 'merged')
            in_progress = sum(1 for ch in spine_chapters if ch['status'] == 'in_progress')
            pending = sum(1 for ch in spine_chapters if ch['status'] == 'pending')
            missing = sum(1 for ch in spine_chapters if ch['status'] == 'not_translated')
            failed = sum(1 for ch in spine_chapters if ch['status'] in ['failed', 'qa_failed'])
        else:
            # For non-OPF files, calculate from chapter_display_info
            total_chapters = len(chapter_display_info)
            completed = sum(1 for ch in chapter_display_info if ch['status'] == 'completed')
            merged = sum(1 for ch in chapter_display_info if ch['status'] == 'merged')
            in_progress = sum(1 for ch in chapter_display_info if ch['status'] == 'in_progress')
            pending = sum(1 for ch in chapter_display_info if ch['status'] == 'pending')
            missing = sum(1 for ch in chapter_display_info if ch['status'] == 'not_translated')
            failed = sum(1 for ch in chapter_display_info if ch['status'] in ['failed', 'qa_failed'])
        
        # Create labels (outside the if/else so they always appear)
        stats_font = QFont('Arial', 10)
        
        lbl_total = QLabel(f"Total: {total_chapters} | ")
        lbl_total.setFont(stats_font)
        stats_layout.addWidget(lbl_total)
        
        lbl_completed = QLabel(f"✅ Completed: {completed} | ")
        lbl_completed.setFont(stats_font)
        lbl_completed.setStyleSheet("color: green;")
        lbl_completed.setCursor(Qt.PointingHandCursor)
        stats_layout.addWidget(lbl_completed)
        
        # Merged: chapters combined into parent request (always create, hide if 0)
        lbl_merged = QLabel(f"🔗 Merged: {merged} | ")
        lbl_merged.setFont(stats_font)
        lbl_merged.setStyleSheet("color: #17a2b8;")  # Cyan/teal
        stats_layout.addWidget(lbl_merged)
        if merged == 0:
            lbl_merged.setVisible(False)
        
        # In Progress: currently being translated (always create, hide if 0)
        lbl_in_progress = QLabel(f"🔄 In Progress: {in_progress} | ")
        lbl_in_progress.setFont(stats_font)
        lbl_in_progress.setStyleSheet("color: orange;")
        lbl_in_progress.setCursor(Qt.PointingHandCursor)
        stats_layout.addWidget(lbl_in_progress)
        if in_progress == 0:
            lbl_in_progress.setVisible(False)
        
        # Pending: marked for retranslation (always create, hide if 0)
        lbl_pending = QLabel(f"❓ Pending: {pending} | ")
        lbl_pending.setFont(stats_font)
        lbl_pending.setStyleSheet("color: white;")
        lbl_pending.setCursor(Qt.PointingHandCursor)
        stats_layout.addWidget(lbl_pending)
        if pending == 0:
            lbl_pending.setVisible(False)
        
        # Not Translated: unique emoji/color (distinct from failures)
        lbl_missing = QLabel(f"⬜ Not Translated: {missing} | ")
        lbl_missing.setFont(stats_font)
        lbl_missing.setStyleSheet("color: #2b6cb0;")
        lbl_missing.setCursor(Qt.PointingHandCursor)
        stats_layout.addWidget(lbl_missing)
        
        # Match list status: failed/qa_failed use ❌ and red (clickable — jumps to next failure)
        lbl_failed = QLabel(f"❌ Failed: {failed} | ")
        lbl_failed.setFont(stats_font)
        lbl_failed.setStyleSheet("color: red;")
        lbl_failed.setCursor(Qt.PointingHandCursor)
        stats_layout.addWidget(lbl_failed)
        
        
        stats_layout.addStretch()
        
        # Main frame for listbox
        main_frame = QWidget()
        main_layout = QVBoxLayout(main_frame)
        main_layout.setContentsMargins(10 if not tab_frame else 5, 5, 10 if not tab_frame else 5, 5)
        container_layout.addWidget(main_frame)
        
        # Create listbox (QListWidget has built-in scrollbars)
        listbox = QListWidget()
        listbox.setSelectionMode(QListWidget.ExtendedSelection)
        listbox_font = QFont('Courier', 10)  # Fixed-width font for better alignment
        listbox.setFont(listbox_font)
        listbox.setSpacing(0)
        listbox.setUniformItemSizes(True)
        listbox.setStyleSheet("QListWidget::item { padding: 1px 2px; margin: 0px; }")
        # Use 36% of screen width
        min_width, _ = self._get_dialog_size(0.36, 0)
        listbox.setMinimumWidth(min_width)
        main_layout.addWidget(listbox)
        
        # Store listbox reference for toggle handler
        listbox_ref[0] = listbox
        
        # Helper: cycle to next item matching given statuses
        def _make_cycle_handler(statuses):
            def _handler(_event=None):
                lb = listbox_ref[0]
                if not lb:
                    return
                indices = [
                    i for i in range(lb.count())
                    if not lb.item(i).isHidden()
                    and (lb.item(i).data(Qt.UserRole) or {}).get('info', {}).get('status') in statuses
                ]
                if not indices:
                    return
                current = lb.currentRow()
                nxt = next((i for i in indices if i > current), indices[0])
                lb.setCurrentRow(nxt)
                lb.scrollToItem(lb.item(nxt), QListWidget.PositionAtCenter)
            return _handler

        lbl_completed.mousePressEvent   = _make_cycle_handler(('completed',))
        lbl_in_progress.mousePressEvent = _make_cycle_handler(('in_progress',))
        lbl_pending.mousePressEvent     = _make_cycle_handler(('pending',))
        lbl_missing.mousePressEvent     = _make_cycle_handler(('not_translated',))
        lbl_failed.mousePressEvent      = _make_cycle_handler(('failed', 'qa_failed'))
        
        # Populate listbox with dynamic column widths
        status_icons = {
            'completed': '✅',
            'merged': '🔗',
            'failed': '❌',
            'qa_failed': '❌',
            'in_progress': '🔄',
            'pending': '❓',
            'not_translated': '⬜',
            'unknown': '❓'
        }
        
        status_labels = {
            'completed': 'Completed',
            'merged': 'Merged',
            'failed': 'Failed',
            'qa_failed': 'QA Failed',
            'in_progress': 'In Progress',
            'pending': 'Pending',
            'not_translated': 'Not Translated',
            'unknown': 'Unknown'
        }
        
        # Calculate maximum widths for dynamic column sizing
        max_original_len = 0
        max_output_len = 0
        
        for info in chapter_display_info:
            if 'opf_position' in info:
                original_file = info.get('original_filename', '')
                output_file = info['output_file']
                max_original_len = max(max_original_len, len(original_file))
                max_output_len = max(max_output_len, len(output_file))
        
        # Set minimum widths to prevent too narrow columns
        max_original_len = max(max_original_len, 20)
        max_output_len = max(max_output_len, 25)
        
        for info in chapter_display_info:
            chapter_num = info['num']
            status = info['status']
            output_file = info['output_file']
            icon = status_icons.get(status, '❓')
            status_label = status_labels.get(status, status)
            
            # Format display with OPF info if available
            if 'opf_position' in info:
                # OPF-based display with dynamic widths
                original_file = info.get('original_filename', '')
                opf_pos = info['opf_position'] + 1  # 1-based for display
                
                # Format: [OPF Position] Chapter Number | Status | Original File -> Response File
                if isinstance(chapter_num, float) and chapter_num.is_integer():
                    display = f"[{opf_pos:03d}] Ch.{int(chapter_num):03d} | {icon} {status_label:11s} | {original_file:<{max_original_len}} -> {output_file}"
                else:
                    display = f"[{opf_pos:03d}] Ch.{chapter_num:03d} | {icon} {status_label:11s} | {original_file:<{max_original_len}} -> {output_file}"
            else:
                # Original format
                if isinstance(chapter_num, float) and chapter_num.is_integer():
                    display = f"Chapter {int(chapter_num):03d} | {icon} {status_label:11s} | {output_file}"
                elif isinstance(chapter_num, float):
                    display = f"Chapter {chapter_num:06.1f} | {icon} {status_label:11s} | {output_file}"
                else:
                    display = f"Chapter {chapter_num:03d} | {icon} {status_label:11s} | {output_file}"
            
            # Add QA issues if status is qa_failed
            if status == 'qa_failed':
                chapter_info = info.get('info', {})
                qa_issues = chapter_info.get('qa_issues_found', [])
                if qa_issues:
                    # Format issues for display (show first 2)
                    issues_display = ', '.join(qa_issues[:2])
                    if len(qa_issues) > 2:
                        issues_display += f' (+{len(qa_issues)-2} more)'
                    display += f" | {issues_display}"
            
            # Add parent chapter info if status is merged
            if status == 'merged':
                chapter_info = info.get('info', {})
                parent_chapter = chapter_info.get('merged_parent_chapter')
                if parent_chapter:
                    display += f" | → Ch.{parent_chapter}"
            
            if info.get('duplicate_count', 1) > 1:
                display += f" | ({info['duplicate_count']} entries)"
            
            item = QListWidgetItem(display)
            
            # Color code based on status
            if status == 'completed':
                item.setForeground(QColor('green'))
            elif status == 'merged':
                item.setForeground(QColor('#17a2b8'))  # Cyan/teal for merged
            elif status in ['failed', 'qa_failed']:
                item.setForeground(QColor('red'))
            elif status == 'not_translated':
                item.setForeground(QColor('#2b6cb0'))
            elif status == 'in_progress':
                item.setForeground(QColor('orange'))
            elif status == 'pending':
                item.setForeground(QColor('white'))  # White for pending
            
            # Store metadata in item for filtering
            is_special = info.get('is_special', False)
            item.setData(Qt.UserRole, {'is_special': is_special, 'info': info})
            
            # Add item to listbox first
            listbox.addItem(item)
            
            # Then hide special files if toggle is off (must be done after adding to listbox)
            if is_special and not show_special_files[0]:
                item.setHidden(True)
        
        # Selection count label
        selection_count_label = QLabel("Selected: 0")
        selection_font = QFont('Arial', 10 if not tab_frame else 9)
        selection_count_label.setFont(selection_font)
        container_layout.addWidget(selection_count_label)
        
        def update_selection_count():
            count = len(listbox.selectedItems())
            selection_count_label.setText(f"Selected: {count}")
        
        listbox.itemSelectionChanged.connect(update_selection_count)
        
        # Return data structure for external access
        result = {
            'file_path': file_path,
            'output_dir': output_dir,
            'progress_file': progress_file,
            'prog': prog,
            'spine_chapters': spine_chapters,
            'opf_chapter_order': opf_chapter_order,
            'chapter_display_info': chapter_display_info,
            'listbox': listbox,
            'selection_count_label': selection_count_label,
            'dialog': dialog,
            'container': container,
            'show_special_files_state': show_special_files[0],  # Store current toggle state
            'show_special_files_cb': show_special_files_cb  # Store checkbox reference
        }
        
        # If standalone (no parent), add buttons and show dialog
        if not parent_dialog and not tab_frame:
            self._add_retranslation_buttons_opf(result)
            
            # Override close event to hide instead of destroy
            def closeEvent(event):
                event.ignore()  # Ignore the close event
                dialog.hide()   # Just hide the dialog
            
            dialog.closeEvent = closeEvent
            
            # Cache the dialog for reuse
            if not hasattr(self, '_retranslation_dialog_cache'):
                self._retranslation_dialog_cache = {}
            
            file_key = os.path.abspath(file_path)
            self._retranslation_dialog_cache[file_key] = result
            
            # Show the dialog (non-modal to allow interaction with other windows)
            dialog.show()
        elif not parent_dialog or tab_frame:
            # Embedded in tab - just add buttons
            self._add_retranslation_buttons_opf(result)
        
        return result


    def _add_retranslation_buttons_opf(self, data, button_frame=None):
        """Add the standard button set for retranslation dialogs with OPF support"""
        
        if not button_frame:
            button_frame = QWidget()
            button_layout = QGridLayout(button_frame)
            # Get container layout and add button frame
            container = data['container']
            if hasattr(container, 'layout') and container.layout():
                container.layout().addWidget(button_frame)
        else:
            button_layout = button_frame.layout() if button_frame.layout() else QGridLayout(button_frame)
        
        # Helper functions that work with the data dict
        def select_all():
            data['listbox'].selectAll()
            data['selection_count_label'].setText(f"Selected: {data['listbox'].count()}")
        
        def clear_selection():
            data['listbox'].clearSelection()
            data['selection_count_label'].setText("Selected: 0")
        
        def select_status(status_to_select):
            data['listbox'].clearSelection()
            for idx, info in enumerate(data['chapter_display_info']):
                if status_to_select == 'failed':
                    if info['status'] in ['failed', 'qa_failed']:
                        data['listbox'].item(idx).setSelected(True)
                elif status_to_select == 'qa_failed':
                    if info['status'] == 'qa_failed':
                        data['listbox'].item(idx).setSelected(True)
                else:
                    if info['status'] == status_to_select:
                        data['listbox'].item(idx).setSelected(True)
            count = len(data['listbox'].selectedItems())
            data['selection_count_label'].setText(f"Selected: {count}")

        def _normalize_filename(name: str) -> str:
            if not name:
                return ""
            base = os.path.basename(name)
            if base.startswith("response_"):
                base = base[len("response_"):]
            while True:
                new_base, ext = os.path.splitext(base)
                if not ext:
                    break
                base = new_base
            return base

        def _find_progress_entry(chapter_info, prog):
            """Strict: match only identical output_file string."""
            target_out = chapter_info.get('output_file')
            if not target_out:
                return None
            for key, ch in prog.get("chapters", {}).items():
                if ch.get('output_file') == target_out:
                    return key, ch
            return None
        
        def remove_qa_failed_mark():
            selected_items = data['listbox'].selectedItems()
            if not selected_items:
                QMessageBox.warning(data.get('dialog', self), "No Selection", "Please select at least one chapter.")
                return

            # Skip dedup here to avoid merging distinct chapters that share filenames
            

            selected_indices = [data['listbox'].row(item) for item in selected_items]
            selected_chapters = [data['chapter_display_info'][i] for i in selected_indices]
            failed_chapters = [ch for ch in selected_chapters if ch['status'] in ['qa_failed', 'failed']]
            
            if not failed_chapters:
                QMessageBox.warning(data.get('dialog', self), "No Failed Chapters", 
                                     "None of the selected chapters have 'qa_failed' or 'failed' status.")
                return
            
            count = len(failed_chapters)
            reply = QMessageBox.question(data.get('dialog', self), "Confirm Remove Failed Mark", 
                                      f"Remove failed mark from {count} chapters?",
                                      QMessageBox.Yes | QMessageBox.No)
            if reply != QMessageBox.Yes:
                return
            
            # Remove marks
            cleared_count = 0
            progress_updated = False
            for info in failed_chapters:
                match = None
                progress_key = info.get('progress_key')
                if progress_key and progress_key in data['prog'].get("chapters", {}):
                    match = (progress_key, data['prog']["chapters"][progress_key])
                else:
                    match = _find_progress_entry(info, data['prog'])

                # Normalize target output for multi-entry cleanup
                target_out = info.get('output_file')
                target_norm = _normalize_filename(target_out)
                if match:
                    # Clear failed/qa_failed on ALL entries sharing this output file (normalized)
                    fields_to_remove = ["qa_issues", "qa_timestamp", "qa_issues_found", "duplicate_confidence", "failure_reason", "error_message"]
                    for key, entry in data['prog'].get("chapters", {}).items():
                        entry_out = entry.get('output_file')
                        if not entry_out:
                            continue
                        if _normalize_filename(entry_out) == target_norm:
                            if entry.get('status') in ['qa_failed', 'failed']:
                                entry["status"] = "completed"
                                for field in fields_to_remove:
                                    entry.pop(field, None)
                                cleared_count += 1
                                progress_updated = True
                else:
                    print(f"WARNING: Could not find chapter entry for {info.get('num')} ({info.get('output_file')})")
            
            # Save the updated progress
            if progress_updated:
                with open(data['progress_file'], 'w', encoding='utf-8') as f:
                    json.dump(data['prog'], f, ensure_ascii=False, indent=2)
            
            # Auto-refresh the display
            self._refresh_retranslation_data(data)
            
            QMessageBox.information(data.get('dialog', self), "Success", f"Removed failed mark from {cleared_count} chapters.")
        
        def retranslate_selected():
            selected_items = data['listbox'].selectedItems()
            if not selected_items:
                QMessageBox.warning(data.get('dialog', self), "No Selection", "Please select at least one chapter.")
                return

            # Do NOT dedup here; it can collapse distinct chapters sharing filenames
            
            selected_indices = [data['listbox'].row(item) for item in selected_items]
            selected_chapters = [data['chapter_display_info'][i] for i in selected_indices]
            
            # Count different types
            missing_count = sum(1 for ch in selected_chapters if ch['status'] == 'not_translated')
            existing_count = sum(1 for ch in selected_chapters if ch['status'] != 'not_translated')
            
            count = len(selected_chapters)
            if count > 10:
                if missing_count > 0 and existing_count > 0:
                    confirm_msg = f"This will:\n• Mark {missing_count} missing chapters for translation\n• Delete and retranslate {existing_count} existing chapters\n\nTotal: {count} chapters\n\nContinue?"
                elif missing_count > 0:
                    confirm_msg = f"This will mark {missing_count} missing chapters for translation.\n\nContinue?"
                else:
                    confirm_msg = f"This will delete {existing_count} translated chapters and mark them for retranslation.\n\nContinue?"
            else:
                chapters = [f"Ch.{ch['num']}" for ch in selected_chapters]
                confirm_msg = f"This will process:\n\n{', '.join(chapters)}\n\n"
                if missing_count > 0:
                    confirm_msg += f"• {missing_count} missing chapters will be marked for translation\n"
                if existing_count > 0:
                    confirm_msg += f"• {existing_count} existing chapters will be deleted and retranslated\n"
                confirm_msg += "\nContinue?"
            
            reply = QMessageBox.question(data.get('dialog', self), "Confirm Retranslation", confirm_msg,
                                       QMessageBox.Yes | QMessageBox.No)
            if reply != QMessageBox.Yes:
                return
            
            # Process chapters - DELETE FILES AND UPDATE PROGRESS
            deleted_count = 0
            marked_count = 0
            status_reset_count = 0
            merged_cleared_count = 0
            progress_updated = False

            for ch_info in selected_chapters:
                output_file = ch_info['output_file']
                actual_num = ch_info['num']
                progress_key = ch_info.get('progress_key')
                
                if ch_info['status'] != 'not_translated':
                    # Reset status to pending for ALL non-not_translated chapters, but only if we can match the exact progress entry
                    match = None
                    if progress_key and progress_key in data['prog']["chapters"]:
                        match = (progress_key, data['prog']["chapters"][progress_key])
                    else:
                        match = _find_progress_entry(ch_info, data['prog'])
                    old_status = ch_info['status']
                    
                    if match:
                        # Delete existing file only after we know which entry to update
                        if output_file:
                            output_path = os.path.join(data['output_dir'], output_file)
                            try:
                                if os.path.exists(output_path):
                                    os.remove(output_path)
                                    deleted_count += 1
                                    print(f"Deleted: {output_path}")
                            except Exception as e:
                                print(f"Failed to delete {output_path}: {e}")
                        chapter_key, ch_entry = match
                        target_output_file = ch_entry.get('output_file') or ch_info['output_file']
                        print(f"Resetting {old_status} status to pending for chapter {actual_num} (key: {chapter_key}, output file: {target_output_file})")
                        ch_entry["status"] = "pending"
                        ch_entry["failure_reason"] = ""
                        ch_entry["error_message"] = ""
                        progress_updated = True
                        status_reset_count += 1
                    else:
                        print(f"WARNING: Could not find exact progress entry for {output_file}; skipped deletion and status reset")
                    
                    # MERGED CHILDREN FIX: Clear any merged children of this chapter
                    # ONLY clear children that still have "merged" status
                    # If split-the-merge succeeded, children will have their own status (completed/qa_failed)
                    # and should NOT be deleted when parent is retranslated
                    for child_key, child_data in list(data['prog']["chapters"].items()):
                        child_status = child_data.get("status")
                        if child_status == "merged" and child_data.get("merged_parent_chapter") == actual_num:
                            child_actual_num = child_data.get("actual_num")
                            print(f"🔓 Clearing merged status for child chapter {child_actual_num} (parent {actual_num} being retranslated)")
                            del data['prog']["chapters"][child_key]
                            merged_cleared_count += 1
                            progress_updated = True
                else:
                    # Just marking for translation (no file to delete)
                    marked_count += 1
            
            # Save the updated progress if we made changes
            if progress_updated:
                try:
                    with open(data['progress_file'], 'w', encoding='utf-8') as f:
                        json.dump(data['prog'], f, ensure_ascii=False, indent=2)
                    print(f"Updated progress tracking file - reset {status_reset_count} chapter statuses to pending")
                except Exception as e:
                    print(f"Failed to update progress file: {e}")
            
            # Auto-refresh the display to show updated status
            data['skip_cleanup'] = True  # Disable cleanup for this dialog after retranslate to avoid deleting pending/failed
            self._refresh_retranslation_data(data)
            
            # Build success message
            success_parts = []
            if deleted_count > 0:
                success_parts.append(f"Deleted {deleted_count} files")
            if marked_count > 0:
                success_parts.append(f"marked {marked_count} missing chapters for translation")
            if status_reset_count > 0:
                success_parts.append(f"reset {status_reset_count} chapter statuses to pending")
            if merged_cleared_count > 0:
                success_parts.append(f"cleared {merged_cleared_count} merged child chapters")
            
            if success_parts:
                success_msg = "Successfully " + ", ".join(success_parts) + "."
                if deleted_count > 0 or marked_count > 0 or merged_cleared_count > 0:
                    total_to_translate = len(selected_indices) + merged_cleared_count
                    success_msg += f"\n\nTotal {total_to_translate} chapters ready for translation."
                QMessageBox.information(data.get('dialog', self), "Success", success_msg)
            else:
                QMessageBox.information(data.get('dialog', self), "Info", "No changes made.")
        
        # Add buttons - First row
        btn_select_all = QPushButton("Select All")
        btn_select_all.setMinimumHeight(32)
        btn_select_all.setStyleSheet("QPushButton { background-color: #17a2b8; color: white; padding: 6px 16px; font-weight: bold; font-size: 10pt; }")
        btn_select_all.clicked.connect(select_all)
        button_layout.addWidget(btn_select_all, 0, 0)
        
        btn_clear = QPushButton("Clear")
        btn_clear.setMinimumHeight(32)
        btn_clear.setStyleSheet("QPushButton { background-color: #6c757d; color: white; padding: 6px 16px; font-weight: bold; font-size: 10pt; }")
        btn_clear.clicked.connect(clear_selection)
        button_layout.addWidget(btn_clear, 0, 1)
        
        btn_select_completed = QPushButton("Select Completed")
        btn_select_completed.setMinimumHeight(32)
        btn_select_completed.setStyleSheet("QPushButton { background-color: #28a745; color: white; padding: 6px 16px; font-weight: bold; font-size: 10pt; }")
        btn_select_completed.clicked.connect(lambda: select_status('completed'))
        button_layout.addWidget(btn_select_completed, 0, 2)
        
        btn_select_qa_failed = QPushButton("Select QA Failed")
        btn_select_qa_failed.setMinimumHeight(32)
        # Use red for QA Failed
        btn_select_qa_failed.setStyleSheet("QPushButton { background-color: #dc3545; color: white; padding: 6px 16px; font-weight: bold; font-size: 10pt; }")
        btn_select_qa_failed.clicked.connect(lambda: select_status('qa_failed'))
        button_layout.addWidget(btn_select_qa_failed, 0, 3)
        
        btn_select_failed = QPushButton("Select Failed")
        btn_select_failed.setMinimumHeight(32)
        # Use red for Failed / QA Failed
        btn_select_failed.setStyleSheet("QPushButton { background-color: #dc3545; color: white; padding: 6px 16px; font-weight: bold; font-size: 10pt; }")
        btn_select_failed.clicked.connect(lambda: select_status('failed'))
        button_layout.addWidget(btn_select_failed, 0, 4)
        
        # Second row
        btn_retranslate = QPushButton("Retranslate Selected")
        btn_retranslate.setMinimumHeight(32)
        btn_retranslate.setStyleSheet("QPushButton { background-color: #d39e00; color: white; padding: 6px 16px; font-weight: bold; font-size: 10pt; }")
        btn_retranslate.clicked.connect(retranslate_selected)
        button_layout.addWidget(btn_retranslate, 1, 0, 1, 2)
        
        btn_remove_qa = QPushButton("Remove QA Failed Mark")
        btn_remove_qa.setMinimumHeight(32)
        btn_remove_qa.setStyleSheet("QPushButton { background-color: #28a745; color: white; padding: 6px 16px; font-weight: bold; font-size: 10pt; }")
        btn_remove_qa.clicked.connect(remove_qa_failed_mark)
        button_layout.addWidget(btn_remove_qa, 1, 2, 1, 1)
        
        # Add animated refresh button
        btn_refresh = AnimatedRefreshButton("  Refresh")  # Double space for icon padding
        btn_refresh.setMinimumHeight(32)
        btn_refresh.setStyleSheet(
            "QPushButton { "
            "background-color: #17a2b8; "
            "color: white; "
            "padding: 6px 16px; "
            "font-weight: bold; "
            "font-size: 10pt; "
            "}"
        )
        
        # Create refresh handler with animation
        def animated_refresh():
            import time

            btn_refresh.start_animation()
            btn_refresh.setEnabled(False)

            # Track start time for minimum animation duration
            start_time = time.time()
            min_animation_duration = 0.8  # 800ms minimum

            # A token to prevent older timers from firing after a newer refresh click
            refresh_token = time.time()
            data['_last_refresh_token'] = refresh_token

            def _rebuild_gui_from_refresh():
                """Recreate the retranslation GUI if refresh appears to have failed to render."""
                try:
                    dlg = data.get('dialog')

                    # Best-effort capture current toggle state
                    show_special = data.get('show_special_files_state', False)
                    cb = data.get('show_special_files_cb')
                    if cb:
                        try:
                            show_special = cb.isChecked()
                        except RuntimeError:
                            pass

                    # Multi-file dialog: destroy and recreate the whole multi-tab window
                    if dlg and hasattr(dlg, '_tab_data'):
                        selection = None
                        if hasattr(self, '_multi_file_selection_key') and self._multi_file_selection_key:
                            try:
                                selection = list(self._multi_file_selection_key)
                            except Exception:
                                selection = None

                        def do_multi_rebuild():
                            try:
                                # Clear cached multi-file dialog so the recreate path is taken
                                if hasattr(self, '_multi_file_retranslation_dialog'):
                                    self._multi_file_retranslation_dialog = None
                                if hasattr(self, '_multi_file_selection_key'):
                                    self._multi_file_selection_key = None

                                try:
                                    dlg.hide()
                                except Exception:
                                    pass
                                try:
                                    dlg.deleteLater()
                                except Exception:
                                    pass

                                if selection is not None:
                                    self.selected_files = selection
                                    self._force_retranslation_multiple_files()
                            except Exception as e:
                                print(f"Error during multi-file rebuild: {e}")

                        QTimer.singleShot(0, do_multi_rebuild)
                        return

                    # Single-file dialog: remove cached entry and recreate
                    file_path = data.get('file_path')
                    if not file_path:
                        return

                    file_key = os.path.abspath(file_path)
                    if hasattr(self, '_retranslation_dialog_cache') and file_key in self._retranslation_dialog_cache:
                        try:
                            del self._retranslation_dialog_cache[file_key]
                        except Exception:
                            pass

                    old_dlg = dlg

                    def do_single_rebuild():
                        try:
                            if old_dlg:
                                try:
                                    old_dlg.hide()
                                except Exception:
                                    pass
                                try:
                                    old_dlg.deleteLater()
                                except Exception:
                                    pass
                            self._force_retranslation_epub_or_text(file_path, show_special_files_state=show_special)
                        except Exception as e:
                            print(f"Error during rebuild: {e}")

                    QTimer.singleShot(0, do_single_rebuild)

                except Exception as e:
                    print(f"Error during rebuild: {e}")

            # Use QTimer to run refresh after animation starts
            def do_refresh():
                try:
                    # Check if this is part of a multi-tab dialog and refresh all tabs, otherwise just refresh current
                    if data.get('dialog') and hasattr(data['dialog'], '_tab_data'):
                        self._refresh_all_tabs(data['dialog']._tab_data)
                    else:
                        self._refresh_retranslation_data(data)

                    # Schedule watchdog: if after 3 seconds there are still no visible entries,
                    # but our data says there should be, rebuild the GUI.
                    def watchdog_check():
                        try:
                            if data.get('_last_refresh_token') != refresh_token:
                                return  # superseded by a newer refresh

                            expected_total = len(data.get('chapter_display_info', []) or [])
                            if expected_total <= 0:
                                return

                            listbox = data.get('listbox')
                            if not listbox:
                                _rebuild_gui_from_refresh()
                                return

                            try:
                                count = listbox.count()
                            except RuntimeError:
                                _rebuild_gui_from_refresh()
                                return

                            visible = 0
                            try:
                                for i in range(count):
                                    item = listbox.item(i)
                                    if item is not None and not item.isHidden():
                                        visible += 1
                            except RuntimeError:
                                _rebuild_gui_from_refresh()
                                return

                            if visible > 0:
                                return

                            # Don't rebuild if everything is hidden purely due to the special-files filter.
                            try:
                                show_special = data.get('show_special_files_state', False)
                                cb = data.get('show_special_files_cb')
                                if cb:
                                    show_special = cb.isChecked()
                                if not show_special:
                                    infos = data.get('chapter_display_info', []) or []
                                    if infos and all(bool(info.get('is_special', False)) for info in infos):
                                        return
                            except Exception:
                                pass

                            _rebuild_gui_from_refresh()
                        except Exception as e:
                            print(f"Watchdog check error: {e}")

                    QTimer.singleShot(3000, watchdog_check)

                    # Calculate remaining time to meet minimum animation duration
                    elapsed = time.time() - start_time
                    remaining = max(0, min_animation_duration - elapsed)

                    # Schedule animation stop after remaining time
                    def finish_animation():
                        btn_refresh.stop_animation()
                        btn_refresh.setEnabled(True)

                    if remaining > 0:
                        QTimer.singleShot(int(remaining * 1000), finish_animation)
                    else:
                        finish_animation()

                except Exception as e:
                    print(f"Error during refresh: {e}")
                    btn_refresh.stop_animation()
                    btn_refresh.setEnabled(True)

            QTimer.singleShot(50, do_refresh)  # Small delay to let animation start
        
        btn_refresh.clicked.connect(animated_refresh)
        button_layout.addWidget(btn_refresh, 1, 3, 1, 1)

        # Expose refresh handler for external triggers (e.g., Progress Manager reopen)
        data['refresh_func'] = animated_refresh
        if data.get('dialog'):
            setattr(data['dialog'], '_refresh_func', animated_refresh)

        # ==== Context menu on listbox ====
        listbox = data['listbox']
        listbox.setContextMenuPolicy(Qt.CustomContextMenu)

        def _open_file_for_item(item):
            info_meta = item.data(Qt.UserRole) or {}
            meta = info_meta.get('info', info_meta) or {}
            output_file = meta.get('output_file')
            if not output_file:
                self._show_message('error', "File Missing", "No output file recorded for this entry.", parent=data.get('dialog', self))
                return
            path = os.path.join(data['output_dir'], output_file)
            if not os.path.exists(path):
                self._show_message('error', "File Missing", f"File not found:\n{path}", parent=data.get('dialog', self))
                return
            try:
                QDesktopServices.openUrl(QUrl.fromLocalFile(path))
            except Exception as e:
                self._show_message('error', "Open Failed", str(e), parent=data.get('dialog', self))

        def show_context_menu(pos):
            item = listbox.itemAt(pos)
            if not item:
                return
            
            # Check for missing images in QA issues
            info_wrapper = item.data(Qt.UserRole)
            display_info = info_wrapper.get('info', {})
            # The actual progress entry is nested inside 'info' key of display_info
            progress_entry = display_info.get('info', {})
            
            # qa_issues is a boolean flag; the actual list is qa_issues_found
            qa_issues = progress_entry.get('qa_issues_found', [])
            if not isinstance(qa_issues, list):
                qa_issues = []
                
            has_missing_images = any('missing_images' in str(issue) for issue in qa_issues)
            
            # Fallback: Check item text directly as it definitely contains the issue if visible
            if not has_missing_images and item and 'missing_images' in item.text():
                has_missing_images = True
                print("DEBUG: Detected missing_images via list item text")
            
            # Determine file path for Notepad action
            _output_file = display_info.get('output_file')
            qa_file_path = os.path.join(data['output_dir'], _output_file) if _output_file else None
            
            menu = QMenu(listbox)
            # Remove extra left gutter reserved for icons to avoid empty space
            menu.setStyleSheet(
                "QMenu {"
                "  padding: 4px;"
                "  background-color: #2b2b2b;"
                "  color: white;"
                "  border: 1px solid #5a9fd4;"
                "} "
                "QMenu::icon { width: 0px; } "
                "QMenu::item {"
                "  padding: 6px 12px;"
                "  background-color: transparent;"
                "} "
                "QMenu::item:selected {"
                "  background-color: #17a2b8;"
                "  color: white;"
                "} "
                "QMenu::item:pressed {"
                "  background-color: #138496;"
                "}"
            )
            act_open = menu.addAction("📂 Open File")
            act_notepad_qa = None
            if qa_file_path:
                _label = "✏️ Edit File (find QA issue)" if qa_issues else "✏️ Edit File"
                act_notepad_qa = menu.addAction(_label)
            act_retranslate = menu.addAction("🔁 Retranslate Selected")
            
            act_insert_img = None
            if has_missing_images:
                act_insert_img = menu.addAction("🖼️ Insert Missing Image")
                
            act_remove_qa = menu.addAction("🧹 Remove QA Failed Mark")
            chosen = menu.exec(listbox.mapToGlobal(pos))
            if chosen == act_open:
                _open_file_for_item(item)
            elif chosen == act_retranslate:
                retranslate_selected()
            elif act_insert_img and chosen == act_insert_img:
                # IN-PLACE RESTORATION LOGIC
                try:
                    from bs4 import BeautifulSoup
                    import zipfile
                    import scan_html_folder  # Use the helper module
                    
                    # Helper function for restoration (local version to ensure self-contained logic)
                    def emergency_restore_images_local(text, original_html):
                        if not original_html or not text: return text
                        try:
                            soup_orig = BeautifulSoup(original_html, 'html.parser')
                            soup_text = BeautifulSoup(text, 'html.parser')
                            orig_images = soup_orig.find_all('img')
                            text_images = soup_text.find_all('img')
                            
                            if not orig_images or len(text_images) >= len(orig_images):
                                return text
                                
                            present_srcs = set(img.get('src') for img in text_images if img.get('src'))
                            missing_images = []
                            for img in orig_images:
                                src = img.get('src')
                                if src and src not in present_srcs:
                                    missing_images.append((src, img))
                            
                            if not missing_images: return text
                            
                            source_str = str(original_html)
                            text_str = str(text)
                            text_chars = list(text_str)
                            offset = 0
                            
                            # Sort by position in source
                            missing_images.sort(key=lambda x: source_str.find(x[0]) if x[0] in source_str else -1)
                            
                            for src, orig_img in missing_images:
                                img_tag_str = str(orig_img)
                                source_pos = source_str.find(img_tag_str)
                                if source_pos == -1: source_pos = source_str.find(src)
                                
                                if source_pos != -1:
                                    relative_pos = source_pos / len(source_str)
                                    target_pos = int(len(text_str) * relative_pos)
                                    
                                    # Find paragraph break
                                    best_pos = target_pos
                                    min_dist = len(text_str)
                                    # Use simpler regex search
                                    for match in re.finditer(r'</p>|<br/?>|\n\n', text_str):
                                        end_pos = match.end()
                                        dist = abs(end_pos - target_pos)
                                        if dist < min_dist:
                                            min_dist = dist
                                            best_pos = end_pos
                                    
                                    insert_pos = best_pos + offset
                                    if insert_pos > len(text_chars): insert_pos = len(text_chars)
                                    
                                    insertion = f"\n<p>{img_tag_str}</p>\n"
                                    text_chars[insert_pos:insert_pos] = list(insertion)
                                    offset += len(insertion)
                            
                            return "".join(text_chars)
                        except Exception as e:
                            print(f"Restoration error: {e}")
                            return text

                    # 1. Get Source Content
                    epub_path = data['file_path']
                    # Use filename matching locally since scan_html_folder helper isn't available
                    original_filename = display_info.get('original_filename')
                    source_html = None
                    
                    if original_filename:
                        try:
                            def normalize_name(n):
                                base = os.path.basename(n)
                                if base.startswith('response_'):
                                    base = base[9:]
                                return os.path.splitext(base)[0].lower()
                                
                            target_base = normalize_name(original_filename)
                            
                            with zipfile.ZipFile(epub_path, 'r') as zf:
                                for fname in zf.namelist():
                                    if normalize_name(fname) == target_base:
                                        source_html = zf.read(fname).decode('utf-8', errors='ignore')
                                        break
                        except Exception as ex:
                            print(f"Extraction error: {ex}")
                    
                    if not source_html:
                        self._show_message('error', "Error", "Could not extract source HTML for this chapter.")
                    else:
                        # 2. Get Translated Content
                        output_file = display_info.get('output_file')
                        output_path = os.path.join(data['output_dir'], output_file)
                        
                        if os.path.exists(output_path):
                            with open(output_path, 'r', encoding='utf-8') as f:
                                translated_html = f.read()
                                
                            # 3. Restore
                            restored_html = emergency_restore_images_local(translated_html, source_html)
                            
                            if restored_html != translated_html:
                                # 4. Save
                                with open(output_path, 'w', encoding='utf-8') as f:
                                    f.write(restored_html)
                                    
                                # 5. Update Progress (Clear QA flags)
                                # Search for the entry by filename to ensure persistence
                                # This avoids relying on internal _key injection if it's unreliable
                                found_key = None
                                target_out = display_info.get('output_file')
                                
                                if target_out:
                                    for k, v in data['prog'].get('chapters', {}).items():
                                        if v.get('output_file') == target_out:
                                            found_key = k
                                            break
                                
                                if found_key:
                                    real_entry = data['prog']['chapters'][found_key]
                                    real_entry['status'] = 'completed'
                                    for key in ['qa_issues', 'qa_issues_found', 'qa_timestamp', 'failure_reason', 'error_message']:
                                        real_entry.pop(key, None)
                                    print(f"DEBUG: Updated progress entry {found_key} (matched by filename)")
                                else:
                                    # Fallback: modify the object we have
                                    print(f"DEBUG: Could not find entry by filename '{target_out}', modifying object directly")
                                    progress_entry['status'] = 'completed'
                                    for key in ['qa_issues', 'qa_issues_found', 'qa_timestamp', 'failure_reason', 'error_message']:
                                        progress_entry.pop(key, None)
                                
                                # Save progress
                                with open(data['progress_file'], 'w', encoding='utf-8') as f:
                                    json.dump(data['prog'], f, ensure_ascii=False, indent=2)
                                    
                                # 6. Refresh
                                self._refresh_retranslation_data(data)
                                self._show_message('info', "Success", "Images restored and QA flags cleared.")
                            else:
                                self._show_message('info', "Info", "No missing images could be automatically restored.")
                        else:
                            self._show_message('error', "Error", "Output file not found.")
                            
                except Exception as e:
                    self._show_message('error', "Error", f"Failed to restore images: {e}")
                    import traceback
                    traceback.print_exc()
            elif chosen == act_remove_qa:
                remove_qa_failed_mark()
            elif act_notepad_qa and chosen == act_notepad_qa:
                search_term = None
                _line_num = 1
                if qa_issues:
                    # Extract a meaningful search term from the QA issue strings
                    # Try all common delimiter styles in order
                    _QUOTE_PATTERNS = [
                        r"'([^']+)'",                    # single quotes: 'text'
                        r'"([^"]+)"',                   # double quotes: "text"
                        r"\u201c([^\u201d]+)\u201d",    # curly double quotes: “text”
                        r"\u2018([^\u2019]+)\u2019",    # curly single quotes: ‘text’
                        r"\u300c([^\u300d]+)\u300d",    # Japanese corner brackets: 「text」
                        r"\u300e([^\u300f]+)\u300f",    # Japanese white corner brackets: 『text』
                        r"\uff62([^\uff63]+)\uff63",    # Halfwidth corner brackets
                        r"\[([^\]]+)\]",              # square brackets: [text]
                        r"\(([^)]+)\)",               # parentheses: (text)
                    ]
                    for _issue in qa_issues:
                        _s = str(_issue)
                        for _pat in _QUOTE_PATTERNS:
                            _m = re.search(_pat, _s)
                            if _m and _m.group(1).strip():
                                search_term = _m.group(1)
                                break
                        if search_term:
                            break
                    # Fallback: scan file for any non-ASCII sequence
                    if not search_term:
                        try:
                            with open(qa_file_path, 'r', encoding='utf-8', errors='ignore') as _f:
                                _content = _f.read()
                            _m = re.search(r'[^\x00-\x7f]{1,30}', _content)
                            if _m:
                                search_term = _m.group(0)
                        except Exception:
                            pass
                    # Find line number of search term in file
                    # Try progressively shorter prefixes in case the QA term is truncated
                    if search_term and os.path.exists(qa_file_path):
                        try:
                            with open(qa_file_path, 'r', encoding='utf-8', errors='ignore') as _f:
                                _lines = _f.readlines()
                            # Strip surrounding quote/bracket chars so we search raw content
                            _STRIP_QUOTES = '\'"「」『』“”‘’｢｣《》〈〉（）'
                            _bare = search_term.strip(_STRIP_QUOTES)
                            _base = _bare if _bare else search_term
                            # Build candidates: full bare term, then shrinking prefixes (min 1 char)
                            _candidates = [_base[:_l] for _l in range(len(_base), 0, -1)]
                            for _cand in _candidates:
                                for _i, _ln in enumerate(_lines, 1):
                                    if _cand in _ln:
                                        _line_num = _i
                                        break
                                if _line_num > 1:
                                    break
                        except Exception:
                            pass
                    # Copy search term to clipboard
                    if search_term:
                        from PySide6.QtWidgets import QApplication
                        QApplication.clipboard().setText(search_term)
                # Open file in best available editor, jumping to line if supported
                try:
                    if sys.platform == 'win32':
                        _npp_paths = [
                            r'C:\Program Files\Notepad++\notepad++.exe',
                            r'C:\Program Files (x86)\Notepad++\notepad++.exe',
                        ]
                        _npp = next((p for p in _npp_paths if os.path.exists(p)), None)
                        if _npp:
                            subprocess.Popen([_npp, f'-n{_line_num}', qa_file_path])
                        else:
                            subprocess.Popen(['notepad.exe', qa_file_path])
                    elif sys.platform == 'darwin':
                        # Try TextEdit alternatives that support line jumping
                        if shutil.which('code'):
                            subprocess.Popen(['code', '--goto', f'{qa_file_path}:{_line_num}'])
                        else:
                            subprocess.Popen(['open', '-t', qa_file_path])
                    else:
                        # Linux: try editors with line-jump support first
                        if shutil.which('gedit'):
                            subprocess.Popen(['gedit', f'+{_line_num}', qa_file_path])
                        elif shutil.which('kate'):
                            subprocess.Popen(['kate', '-l', str(_line_num), qa_file_path])
                        elif shutil.which('code'):
                            subprocess.Popen(['code', '--goto', f'{qa_file_path}:{_line_num}'])
                        else:
                            _linux_editors = ['mousepad', 'xed', 'pluma', 'nano', 'xdg-open']
                            _editor = next((e for e in _linux_editors if shutil.which(e)), 'xdg-open')
                            subprocess.Popen([_editor, qa_file_path])
                except Exception as _e:
                    self._show_message('error', "Open Failed", f"Could not open editor:\n{_e}",
                                       parent=data.get('dialog', self))

        listbox.customContextMenuRequested.connect(show_context_menu)
        
        btn_cancel = QPushButton("Cancel")
        btn_cancel.setMinimumHeight(32)
        btn_cancel.setStyleSheet("QPushButton { background-color: #6c757d; color: white; padding: 6px 16px; font-weight: bold; font-size: 10pt; }")
        btn_cancel.clicked.connect(lambda: data['dialog'].close() if data.get('dialog') else None)
        button_layout.addWidget(btn_cancel, 1, 4, 1, 1)

        # Automatically refresh once when dialog is opened
        animated_refresh()

    def _refresh_all_tabs(self, tab_data_list):
        """Refresh all tabs in a multi-file retranslation dialog"""
        try:
            print(f"🔄 Refreshing all {len(tab_data_list)} tabs...")
            
            refreshed_count = 0
            skipped_count = 0
            for idx, data in enumerate(tab_data_list):
                if data and data.get('type') != 'image_folder' and data.get('type') != 'individual_images':
                    # Only refresh EPUB/text tabs
                    try:
                        # Check if widgets are still valid before attempting refresh
                        if not self._is_data_valid(data):
                            print(f"[DEBUG] Skipping tab {idx + 1}/{len(tab_data_list)} - widgets deleted")
                            skipped_count += 1
                            continue
                        
                        print(f"[DEBUG] Refreshing tab {idx + 1}/{len(tab_data_list)}")
                        self._refresh_retranslation_data(data)
                        refreshed_count += 1
                    except RuntimeError as e:
                        # Widget was deleted
                        print(f"[WARN] Skipping tab {idx + 1} - widget deleted: {e}")
                        skipped_count += 1
                    except Exception as e:
                        print(f"[ERROR] Failed to refresh tab {idx + 1}: {e}")
            
            if skipped_count > 0:
                print(f"✅ Successfully refreshed {refreshed_count} tab(s), skipped {skipped_count} deleted tab(s)")
            else:
                print(f"✅ Successfully refreshed {refreshed_count} tab(s)")
            
        except Exception as e:
            print(f"❌ Failed to refresh all tabs: {e}")
            import traceback
            traceback.print_exc()
    
    def _is_data_valid(self, data):
        """Check if the data structure has valid (non-deleted) widgets"""
        try:
            if not data:
                return False
            
            # Check if listbox exists and is still valid
            listbox = data.get('listbox')
            if not listbox:
                return False
            
            # Try to access a simple property to check if widget is still alive
            # This will raise RuntimeError if the C++ object was deleted
            listbox.count()
            return True
            
        except (RuntimeError, AttributeError):
            return False
    
    def _refresh_retranslation_data(self, data):
        """Refresh the retranslation dialog data by reloading progress and updating display"""
        try:
            # First check if widgets are still valid
            if not self._is_data_valid(data):
                print("⚠️ Cannot refresh - widgets have been deleted")
                return

            # If the output override directory changed while the dialog is open,
            # re-resolve output_dir/progress_file so we don't keep reading the old progress JSON.
            try:
                file_path = data.get('file_path')
                if file_path:
                    epub_base = os.path.splitext(os.path.basename(file_path))[0]
                    override_dir = (os.environ.get('OUTPUT_DIRECTORY') or os.environ.get('OUTPUT_DIR'))
                    if not override_dir and hasattr(self, 'config'):
                        try:
                            override_dir = self.config.get('output_directory')
                        except Exception:
                            override_dir = None

                    expected_output_dir = os.path.join(override_dir, epub_base) if override_dir else epub_base
                    expected_progress_file = os.path.join(expected_output_dir, "translation_progress.json")

                    # Update in-place if changed
                    if expected_output_dir and data.get('output_dir') != expected_output_dir:
                        data['output_dir'] = expected_output_dir
                    if expected_progress_file and data.get('progress_file') != expected_progress_file:
                        data['progress_file'] = expected_progress_file

                    # Keep cache consistent too (if present)
                    try:
                        file_key = os.path.abspath(file_path)
                        if hasattr(self, '_retranslation_dialog_cache') and file_key in self._retranslation_dialog_cache:
                            cached = self._retranslation_dialog_cache[file_key]
                            if isinstance(cached, dict):
                                cached['output_dir'] = data.get('output_dir')
                                cached['progress_file'] = data.get('progress_file')
                    except Exception:
                        pass
            except Exception as e:
                print(f"[WARN] Could not re-resolve output override on refresh: {e}")
            
            # Save current scroll position (and first visible row/offset) to restore after refresh
            saved_scroll = None
            updates_were_enabled = True
            signals_were_blocked = False
            self._suspend_yield = True
            first_visible_row = None
            first_visible_offset = 0
            if 'listbox' in data and data['listbox']:
                try:
                    from PySide6.QtCore import QPoint
                    saved_scroll = data['listbox'].verticalScrollBar().value()
                    updates_were_enabled = data['listbox'].updatesEnabled()
                    signals_were_blocked = data['listbox'].signalsBlocked()
                    idx = data['listbox'].indexAt(QPoint(0, 0))
                    if idx and idx.isValid():
                        first_visible_row = idx.row()
                        rect = data['listbox'].visualItemRect(data['listbox'].item(first_visible_row))
                        first_visible_offset = -rect.top()
                    data['listbox'].blockSignals(True)
                    data['listbox'].setUpdatesEnabled(False)
                except Exception:
                    saved_scroll = None
            
            # Save current selections to restore after refresh
            selected_indices = []
            try:
                selected_indices = [data['listbox'].row(item) for item in data['listbox'].selectedItems()]
            except RuntimeError:
                print("⚠️ Could not save selection state - widget was deleted")
                return
            
            # Reload progress file - check if it exists first
            if not os.path.exists(data['progress_file']):
                print(f"⚠️ Progress file not found: {data['progress_file']}")
                # Recreate a minimal progress file and auto-discover completed files from output_dir
                prog = {
                    "chapters": {},
                    "chapter_chunks": {},
                    "version": "2.1"
                }

                def _auto_discover_from_output_dir(output_dir, prog):
                    updated = False
                    try:
                        files = [
                            f for f in os.listdir(output_dir)
                            if os.path.isfile(os.path.join(output_dir, f))
                            # accept any extension except .epub
                            and not f.lower().endswith("_translated.txt")
                            and f != "translation_progress.json"
                            and not f.lower().endswith(".epub")
                        ]
                        for fname in files:
                            base = os.path.basename(fname)
                            if base.startswith("response_"):
                                base = base[len("response_"):]
                            while True:
                                new_base, ext = os.path.splitext(base)
                                if not ext:
                                    break
                                base = new_base
                            import re
                            m = re.findall(r"(\\d+)", base)
                            chapter_num = int(m[-1]) if m else None
                            key = str(chapter_num) if chapter_num is not None else f"special_{base}"
                            actual_num = chapter_num if chapter_num is not None else 0
                            if key in prog.get("chapters", {}):
                                continue
                            prog.setdefault("chapters", {})[key] = {
                                "actual_num": actual_num,
                                "content_hash": "",
                                "output_file": fname,
                                "status": "completed",
                                "last_updated": os.path.getmtime(os.path.join(output_dir, fname)),
                                "auto_discovered": True,
                                "original_basename": fname
                            }
                            updated = True
                    except Exception as e:
                        print(f"⚠️ Auto-discovery (refresh no OPF) failed: {e}")
                    return updated

                if _auto_discover_from_output_dir(data['output_dir'], prog):
                    print("💾 Recreated progress file via auto-discovery (refresh)")
                try:
                    # Ensure the output directory exists (it may have been deleted)
                    progress_dir = os.path.dirname(data['progress_file'])
                    if progress_dir:
                        os.makedirs(progress_dir, exist_ok=True)
                    with open(data['progress_file'], 'w', encoding='utf-8') as f:
                        json.dump(prog, f, ensure_ascii=False, indent=2)
                except Exception as e:
                    QMessageBox.warning(data.get('dialog', self), "Progress File Error",
                                        f"Could not recreate progress file:\n{e}")
                    return
            
            with open(data['progress_file'], 'r', encoding='utf-8') as f:
                data['prog'] = json.load(f)
            
            # Clean up missing files and merged children before display unless disabled
            if not data.get('skip_cleanup', False):
                from TransateKRtoEN import ProgressManager
                temp_progress = ProgressManager(os.path.dirname(data['progress_file']))
                temp_progress.prog = data['prog']
                temp_progress.cleanup_missing_files(data['output_dir'])
                data['prog'] = temp_progress.prog
                
                # Save the cleaned progress back to file
                with open(data['progress_file'], 'w', encoding='utf-8') as f:
                    json.dump(data['prog'], f, ensure_ascii=False, indent=2)
            
            # Check if we're using OPF-based display or fallback
            if data.get('spine_chapters'):
                # OPF-based: Re-run full matching logic to update merged status correctly
                # We need to re-match spine chapters against the updated progress JSON
                self._rematch_spine_chapters(data)
            else:
                # Fallback mode: REBUILD chapter_display_info from scratch to pick up new entries
                # This is necessary for text files or EPUBs without OPF
                self._rebuild_chapter_display_info(data)
            
            # Note: chapter_display_info is already rebuilt/updated above
            # For OPF mode: _update_chapter_status_info updated existing entries
            # For fallback mode: _rebuild_chapter_display_info rebuilt from scratch
            
            # Update the listbox display
            self._update_listbox_display(data)
            
            # Update statistics if available
            self._update_statistics_display(data)

            # Ensure the special-files toggle is applied after every refresh.
            try:
                show_special = data.get('show_special_files_state', False)
                cb = data.get('show_special_files_cb')
                if cb:
                    show_special = cb.isChecked()
                listbox = data.get('listbox')
                if listbox:
                    for i in range(listbox.count()):
                        item = listbox.item(i)
                        if not item:
                            continue
                        meta = item.data(Qt.UserRole) or {}
                        is_special = meta.get('is_special', False)
                        item.setHidden(is_special and not show_special)
                data['show_special_files_state'] = show_special
            except Exception:
                pass
            
            # Restore scroll position and repaint immediately after rebuild
            if 'listbox' in data and data['listbox']:
                try:
                    sb = data['listbox'].verticalScrollBar()
                    if first_visible_row is not None and first_visible_row < data['listbox'].count():
                        item = data['listbox'].item(first_visible_row)
                        data['listbox'].scrollToItem(item, data['listbox'].PositionAtTop)
                        sb.setValue(sb.value() - first_visible_offset)
                    elif saved_scroll is not None:
                        target = min(saved_scroll, sb.maximum())
                        if sb.value() != target:
                            sb.setValue(target)
                    data['listbox'].setUpdatesEnabled(updates_were_enabled)
                    data['listbox'].blockSignals(signals_were_blocked)
                    data['listbox'].viewport().update()
                except Exception:
                    try:
                        data['listbox'].setUpdatesEnabled(updates_were_enabled)
                        data['listbox'].blockSignals(signals_were_blocked)
                    except Exception:
                        pass
            self._suspend_yield = False
            
            # Restore selections
            try:
                if selected_indices:
                    for idx in selected_indices:
                        if idx < data['listbox'].count():
                            data['listbox'].item(idx).setSelected(True)
                    # Update selection count
                    if 'selection_count_label' in data and data['selection_count_label']:
                        data['selection_count_label'].setText(f"Selected: {len(selected_indices)}")
                else:
                    # Clear selections if there were none
                    data['listbox'].clearSelection()
                    if 'selection_count_label' in data and data['selection_count_label']:
                        data['selection_count_label'].setText("Selected: 0")

                # Re-apply scroll AFTER selections (since selecting can auto-scroll)
                if saved_scroll is not None and 'listbox' in data and data['listbox']:
                    from PySide6.QtCore import QTimer
                    def _restore_scroll_again():
                        try:
                            sb = data['listbox'].verticalScrollBar()
                            target = min(saved_scroll, sb.maximum())
                            if sb.value() != target:
                                sb.setValue(target)
                        except Exception:
                            pass
                    QTimer.singleShot(0, _restore_scroll_again)
            except RuntimeError:
                print("⚠️ Could not restore selection state - widget was deleted during refresh")
            
            # print("✅ Retranslation data refreshed successfully")
            
        except RuntimeError as e:
            print(f"❌ Failed to refresh data - widget deleted: {e}")
        except FileNotFoundError as e:
            print(f"❌ Failed to refresh data - file not found: {e}")
            try:
                QMessageBox.information(data.get('dialog', self), "Output Folder Not Found", 
                                      f"The output folder appears to have been deleted or moved.\n\n"
                                      f"File not found: {os.path.basename(str(e))}")
            except (RuntimeError, AttributeError):
                print(f"[WARN] Could not show error dialog - dialog was deleted")
        except Exception as e:
            print(f"❌ Failed to refresh data: {e}")
            import traceback
            traceback.print_exc()
            try:
                # Show friendlier error message for common cases
                error_msg = str(e)
                if "No such file or directory" in error_msg or "cannot find the path" in error_msg:
                    QMessageBox.information(data.get('dialog', self), "Output Folder Not Found", 
                                          f"The output folder appears to have been deleted or moved.\n\n"
                                          f"Error: {error_msg}")
                else:
                    QMessageBox.warning(data.get('dialog', self), "Refresh Failed", 
                                      f"Failed to refresh data: {error_msg}")
            except (RuntimeError, AttributeError):
                # Dialog was also deleted, just print to console
                print(f"[WARN] Could not show error dialog - dialog was deleted")
    
    def _rematch_spine_chapters(self, data):
        """Re-run the full spine chapter matching logic against updated progress JSON"""
        prog = data['prog']
        output_dir = data['output_dir']
        spine_chapters = data['spine_chapters']

        def _normalize_opf_match_name(name: str) -> str:
            if not name:
                return ""
            base = os.path.basename(name)
            if base.startswith("response_"):
                base = base[len("response_"):]
            while True:
                new_base, ext = os.path.splitext(base)
                if not ext:
                    break
                base = new_base
            return base

        def _opf_names_equal(a: str, b: str) -> bool:
            return _normalize_opf_match_name(a) == _normalize_opf_match_name(b)

        # Build indexes once (O(n))
        basename_to_progress = {}
        response_to_progress = {}
        actualnum_to_progress = {}
        composite_to_progress = {}

        chapters_dict = prog.get("chapters", {})
        for ch in chapters_dict.values():
            orig = ch.get("original_basename", "")
            out = ch.get("output_file", "")
            actual_num = ch.get("actual_num")

            if orig:
                basename_to_progress.setdefault(_normalize_opf_match_name(orig), []).append(ch)
            if out:
                response_to_progress.setdefault(out, []).append(ch)
                norm_out = _normalize_opf_match_name(out)
                if norm_out != out:
                    response_to_progress.setdefault(norm_out, []).append(ch)
            if actual_num is not None:
                actualnum_to_progress.setdefault(actual_num, []).append(ch)

            fname_for_comp = orig or out
            if fname_for_comp and actual_num is not None:
                filename_noext = os.path.splitext(_normalize_opf_match_name(fname_for_comp))[0]
                composite_to_progress[f"{actual_num}_{filename_noext}"] = ch

        # Cache directory listing to avoid thousands of exists calls
        try:
            existing_files = {f for f in os.listdir(output_dir) if os.path.isfile(os.path.join(output_dir, f))}
        except Exception:
            existing_files = set()

        def file_exists_fast(fname: str) -> bool:
            return fname in existing_files

        for spine_ch in spine_chapters:
            filename = spine_ch['filename']
            chapter_num = spine_ch['file_chapter_num']
            is_special = spine_ch.get('is_special', False)

            base_name = os.path.splitext(filename)[0]
            retain = os.getenv('RETAIN_SOURCE_EXTENSION', '0') == '1' or self.config.get('retain_source_extension', False)

            if is_special:
                response_with_prefix = f"response_{base_name}.html"
                if retain:
                    expected_response = filename
                elif file_exists_fast(response_with_prefix):
                    expected_response = response_with_prefix
                else:
                    expected_response = filename
            else:
                expected_response = filename if retain else filename

            matched_info = None
            basename_key = _normalize_opf_match_name(filename)

            # 1) original basename map
            lst = basename_to_progress.get(basename_key)
            if lst:
                for ch in lst:
                    status = ch.get('status', '')
                    if status in ['in_progress', 'failed', 'qa_failed', 'pending']:
                        if ch.get('actual_num') == chapter_num:
                            matched_info = ch
                            break
                    else:
                        matched_info = ch
                        break

            # 2) response map (choose highest severity, prefer matching chapter_num)
            if not matched_info:
                lookup_keys = [
                    expected_response,
                    _normalize_opf_match_name(expected_response),
                    f"response_{expected_response}" if not expected_response.startswith("response_") else expected_response,
                    basename_key
                ]
                lst = None
                for k in lookup_keys:
                    if k in response_to_progress:
                        lst = response_to_progress[k]
                        break
                if lst:
                    has_qa = any(ch.get('status') == 'qa_failed' for ch in lst)
                    if has_qa:
                        lst = [ch for ch in lst if ch.get('status') != 'pending']
                    severity = {'qa_failed': 4, 'failed': 3, 'pending': 2, 'in_progress': 1, 'completed': 0}
                    best = None
                    best_score = -1
                    for ch in lst:
                        status = ch.get('status', '')
                        score = severity.get(status, -1)
                        matches_num = ch.get('actual_num') == chapter_num
                        if score > best_score or (score == best_score and matches_num):
                            best = ch
                            best_score = score
                            # If exact chapter match and highest severity, keep going in case of even higher severity
                    if best:
                        matched_info = best

            # 3) composite key
            if not matched_info:
                filename_noext = base_name
                if filename_noext.startswith("response_"):
                    filename_noext = filename_noext[len("response_"):]
                comp_key = f"{chapter_num}_{filename_noext}"
                matched_info = composite_to_progress.get(comp_key)

            # 4) actual_num map fallback (avoid mis-matching special files)
            if not matched_info and chapter_num in actualnum_to_progress:
                for ch in actualnum_to_progress[chapter_num]:
                    status = ch.get('status', '')
                    out_file = ch.get('output_file')
                    orig_base = os.path.basename(ch.get('original_basename', '') or '')

                    # If this spine entry is a special file (no digits), require filename match to avoid hijacking by other chapter 0 entries
                    if is_special:
                        fname_matches = (
                            (orig_base and _opf_names_equal(orig_base, filename)) or
                            (out_file and (_opf_names_equal(out_file, expected_response) or out_file == expected_response))
                        )
                        if not fname_matches:
                            continue

                    if status == 'merged':
                        if _opf_names_equal(orig_base, filename) or not orig_base:
                            matched_info = ch
                            break
                    elif status in ['in_progress', 'failed', 'pending', 'qa_failed']:
                        if out_file and (_opf_names_equal(out_file, expected_response) or out_file == expected_response):
                            matched_info = ch
                            break
                    else:
                        if (orig_base and _opf_names_equal(orig_base, filename)) or (out_file and (_opf_names_equal(out_file, expected_response) or out_file == expected_response)):
                            matched_info = ch
                            break

            file_exists = file_exists_fast(expected_response)

            if matched_info:
                status = matched_info.get('status', 'unknown')

                if status in ['failed', 'in_progress', 'qa_failed', 'pending']:
                    spine_ch['status'] = status
                    spine_ch['output_file'] = matched_info.get('output_file') or expected_response
                    spine_ch['progress_entry'] = matched_info
                    continue

                spine_ch['status'] = status
                spine_ch['output_file'] = expected_response if is_special else matched_info.get('output_file', expected_response)
                spine_ch['progress_entry'] = matched_info
                if not spine_ch['output_file']:
                    spine_ch['output_file'] = expected_response

                if status == 'completed':
                    output_file = spine_ch['output_file']
                    if not file_exists_fast(output_file):
                        if file_exists and expected_response:
                            spine_ch['output_file'] = expected_response
                            matched_info['output_file'] = expected_response
                        else:
                            spine_ch['status'] = 'not_translated'

            elif file_exists:
                spine_ch['status'] = 'completed'
                spine_ch['output_file'] = expected_response

            else:
                norm_target = _normalize_opf_match_name(filename)
                matched_file = None
                for f in existing_files:
                    if _normalize_opf_match_name(f) == norm_target:
                        matched_file = f
                        break
                if matched_file:
                    spine_ch['status'] = 'completed'
                    spine_ch['output_file'] = matched_file
                else:
                    spine_ch['status'] = 'not_translated'
                    spine_ch['output_file'] = expected_response
        
        # =====================================================
        # SAVE AUTO-DISCOVERED FILES TO PROGRESS (refresh path)
        # =====================================================
        
        progress_updated = False
        for spine_ch in spine_chapters:
            # Only add entries that were marked as completed but have no progress entry
            if spine_ch['status'] == 'completed' and 'progress_entry' not in spine_ch:
                chapter_num = spine_ch['file_chapter_num']
                output_file = spine_ch['output_file']
                filename = spine_ch['filename']

                # Require normalized filename match between spine file and output file, and the file must exist
                norm_spine = _normalize_opf_match_name(filename)
                norm_out = _normalize_opf_match_name(output_file)
                file_exists = os.path.exists(os.path.join(output_dir, output_file))
                if norm_spine != norm_out or not file_exists:
                    continue

                # Create a progress entry for this auto-discovered file
                chapter_key = str(chapter_num)
                
                # Check if key already exists (avoid duplicates)
                if chapter_key not in prog.get("chapters", {}):
                    prog.setdefault("chapters", {})[chapter_key] = {
                        "actual_num": chapter_num,
                        "content_hash": "",  # Unknown since we don't have the source
                        "output_file": output_file,
                        "status": "completed",
                        "last_updated": os.path.getmtime(os.path.join(output_dir, output_file)),
                        "auto_discovered": True,
                        "original_basename": filename
                    }
                    progress_updated = True
                    print(f"✅ Auto-discovered and tracked (refresh): {filename} -> {output_file}")
        
        # Save progress file if we added new entries
        if progress_updated:
            try:
                with open(data['progress_file'], 'w', encoding='utf-8') as f:
                    json.dump(prog, f, ensure_ascii=False, indent=2)
                print(f"💾 Saved {sum(1 for ch in spine_chapters if ch['status'] == 'completed' and 'progress_entry' not in ch)} auto-discovered files to progress file (refresh)")
            except Exception as e:
                print(f"⚠️ Warning: Failed to save progress file during refresh: {e}")
        
        # Rebuild chapter_display_info from updated spine_chapters
        chapter_display_info = []
        for spine_ch in spine_chapters:
            display_info = {
                'key': spine_ch.get('filename', ''),
                'num': spine_ch['file_chapter_num'],
                'info': spine_ch.get('progress_entry', {}),
                'output_file': spine_ch['output_file'],
                'status': spine_ch['status'],
                'duplicate_count': 1,
                'entries': [],
                'opf_position': spine_ch['position'],
                'original_filename': spine_ch['filename'],
                'is_special': spine_ch.get('is_special', False),
                'progress_key': spine_ch.get('progress_key')
            }
            chapter_display_info.append(display_info)
        
        data['chapter_display_info'] = chapter_display_info
    
    def _rebuild_chapter_display_info(self, data):
        """Rebuild chapter_display_info from scratch (for fallback mode without OPF)"""
        # This is the same logic as the initial build in _force_retranslation_epub_or_text
        # but extracted here so refresh can use it
        
        prog = data['prog']
        output_dir = data['output_dir']
        file_path = data.get('file_path', '')
        show_special = data.get('show_special_files_state', False)
        
        files_to_entries = {}
        for chapter_key, chapter_info in prog.get("chapters", {}).items():
            output_file = chapter_info.get("output_file", "")
            status = chapter_info.get("status", "")
            
            # Include chapters with output files OR in_progress/failed/qa_failed with null output file (legacy)
            if output_file or status in ["in_progress", "failed", "qa_failed"]:
                # For merged chapters, use a unique key (chapter_key) instead of output_file
                # This ensures merged chapters appear as separate entries in the list
                if status == "merged":
                    file_key = f"_merged_{chapter_key}"
                elif output_file:
                    file_key = output_file
                elif status == "in_progress":
                    file_key = f"_in_progress_{chapter_key}"
                elif status == "qa_failed":
                    file_key = f"_qa_failed_{chapter_key}"
                else:  # failed
                    file_key = f"_failed_{chapter_key}"
                
                if file_key not in files_to_entries:
                    files_to_entries[file_key] = []
                files_to_entries[file_key].append((chapter_key, chapter_info))
        
        chapter_display_info = []
        
        for output_file, entries in files_to_entries.items():
            chapter_key, chapter_info = entries[0]
            
            # Get the actual output file (strip placeholder prefix if present)
            actual_output_file = output_file
            if output_file.startswith("_merged_") or output_file.startswith("_in_progress_") or output_file.startswith("_failed_") or output_file.startswith("_qa_failed_"):
                # For merged/in_progress/failed/qa_failed, get the actual output_file from chapter_info
                actual_output_file = chapter_info.get("output_file", "")
                if not actual_output_file:
                    # Generate expected filename based on actual_num
                    actual_num = chapter_info.get("actual_num")
                    if actual_num is not None:
                        # Use .txt extension for text files, .html for EPUB
                        ext = ".txt" if file_path.endswith(".txt") else ".html"
                        actual_output_file = f"response_section_{actual_num}{ext}"
            
            # Check if this is a special file (files without numbers)
            original_basename = chapter_info.get("original_basename", "")
            filename_to_check = original_basename if original_basename else actual_output_file
            
            # Check if filename contains any digits
            import re
            has_numbers = bool(re.search(r'\d', filename_to_check))
            is_special = not has_numbers
            
            # Don't skip special files here - let the display logic handle hiding them
            # This ensures chapter_display_info contains all items, and the listbox
            # will properly hide/show items based on the toggle state
            
            # Extract chapter number - prioritize stored values
            chapter_num = None
            if 'actual_num' in chapter_info and chapter_info['actual_num'] is not None:
                chapter_num = chapter_info['actual_num']
            elif 'chapter_num' in chapter_info and chapter_info['chapter_num'] is not None:
                chapter_num = chapter_info['chapter_num']
            
            # Fallback: extract from filename
            if chapter_num is None:
                import re
                matches = re.findall(r'(\d+)', actual_output_file)
                if matches:
                    chapter_num = int(matches[-1])
                else:
                    chapter_num = 999999
            
            status = chapter_info.get("status", "unknown")
            if status == "completed_empty":
                status = "completed"
            
            # Check file existence
            if status == "completed":
                output_path = os.path.join(output_dir, actual_output_file)
                if not os.path.exists(output_path):
                    status = "not_translated"
            
            chapter_display_info.append({
                'key': chapter_key,
                'num': chapter_num,
                'info': chapter_info,
                'output_file': actual_output_file,  # Use actual output file, not placeholder
                'status': status,
                'duplicate_count': len(entries),
                'entries': entries,
                'is_special': is_special,
                'progress_key': chapter_key
            })
        
        # Sort by chapter number
        chapter_display_info.sort(key=lambda x: x['num'] if x['num'] is not None else 999999)
        
        # Update data with rebuilt list
        data['chapter_display_info'] = chapter_display_info
    
    def _update_chapter_status_info(self, data):
        """Update chapter status information after refresh"""
        # Re-check file existence and update status for each chapter
        for info in data['chapter_display_info']:
            output_file = info['output_file']
            output_path = os.path.join(data['output_dir'], output_file)
            
            # Find matching progress entry
            matched_info = None
            
            # PRIORITY 1: Match by BOTH actual_num AND output_file
            # This prevents cross-matching between files with same chapter number but different filenames
            for chapter_key, chapter_info in data['prog'].get("chapters", {}).items():
                actual_num = chapter_info.get('actual_num') or chapter_info.get('chapter_num')
                ch_output = chapter_info.get('output_file')
                
                # BOTH must match - no fallback
                if actual_num is not None and actual_num == info['num'] and ch_output == output_file:
                    matched_info = chapter_info
                    break
            
            # PRIORITY 2: Fall back to output_file matching if no actual_num match
            if not matched_info:
                # Prefer completed over failed/pending/in_progress; keep qa_failed highest
                severity = {'qa_failed': 5, 'completed': 4, 'failed': 3, 'pending': 2, 'in_progress': 1}
                best = None
                best_score = -1
                for chapter_key, chapter_info in data['prog'].get("chapters", {}).items():
                    if chapter_info.get('output_file') == output_file:
                        status = chapter_info.get('status', 'unknown')
                        score = severity.get(status, -1)
                        # Prefer higher severity; tie-breaker: matching actual_num if present
                        matches_num = (chapter_info.get('actual_num') or chapter_info.get('chapter_num')) == info['num']
                        if score > best_score or (score == best_score and matches_num):
                            best_score = score
                            best = chapter_info
                if best:
                    matched_info = best
            
            # Update status based on current state from progress file
            if matched_info:
                new_status = matched_info.get('status', 'unknown')
                # Handle completed_empty as completed for display
                if new_status == 'completed_empty':
                    new_status = 'completed'
                # Verify file actually exists for completed status (but NOT for merged - merged chapters
                # don't have their own output files, they point to parent's file)
                if new_status == 'completed' and not os.path.exists(output_path):
                    new_status = 'not_translated'
                info['status'] = new_status
                info['info'] = matched_info
            elif os.path.exists(output_path):
                # Before marking as completed based on file existence, check if this chapter
                # is actually marked as merged in the progress file (by actual_num lookup)
                # This handles the case where old output files exist from before merging was enabled
                is_merged_chapter = False
                for chapter_key, chapter_info in data['prog'].get("chapters", {}).items():
                    actual_num = chapter_info.get('actual_num') or chapter_info.get('chapter_num')
                    if actual_num is not None and actual_num == info['num']:
                        if chapter_info.get('status') == 'merged':
                            is_merged_chapter = True
                            info['status'] = 'merged'
                            info['info'] = chapter_info
                            break
                
                if not is_merged_chapter:
                    info['status'] = 'completed'
            else:
                info['status'] = 'not_translated'
    
    def _update_listbox_display(self, data):
        """Update the listbox display with current chapter information"""
        # Add a check to ensure widgets are still valid before proceeding
        if not self._is_data_valid(data):
            print("⚠️ Cannot update listbox display - widgets have been deleted")
            return
            
        listbox = data['listbox']
        
        # Clear existing items
        listbox.clear()
        
        # Status icons and labels
        status_icons = {
            'completed': '✅',
            'merged': '🔗',
            'failed': '❌',
            'qa_failed': '❌',
            'in_progress': '🔄',
            'not_translated': '⬜',
            'unknown': '❓'
        }
        
        status_labels = {
            'completed': 'Completed',
            'merged': 'Merged',
            'failed': 'Failed',
            'qa_failed': 'QA Failed',
            'in_progress': 'In Progress',
            'not_translated': 'Not Translated',
            'unknown': 'Unknown'
        }
        
        # Calculate maximum widths for dynamic column sizing
        max_original_len = 0
        max_output_len = 0
        
        for info in data['chapter_display_info']:
            if 'opf_position' in info:
                original_file = info.get('original_filename', '')
                output_file = info['output_file']
                max_original_len = max(max_original_len, len(original_file))
                max_output_len = max(max_output_len, len(output_file))
        
        # Set minimum widths to prevent too narrow columns
        max_original_len = max(max_original_len, 20)
        max_output_len = max(max_output_len, 25)
        
        # Rebuild listbox items with updates/signals disabled to avoid flicker
        listbox.setUpdatesEnabled(False)
        listbox.blockSignals(True)

        count_existing = listbox.count()
        count_new = len(data['chapter_display_info'])

        def build_display(info, max_original_len, max_output_len):
            chapter_num = info['num']
            status = info['status']
            output_file = info['output_file']
            icon = status_icons.get(status, '❓')
            status_label = status_labels.get(status, status)
            if 'opf_position' in info:
                original_file = info.get('original_filename', '')
                opf_pos = info['opf_position'] + 1
                if isinstance(chapter_num, float):
                    if chapter_num.is_integer():
                        display = f"[{opf_pos:03d}] Ch.{int(chapter_num):03d} | {icon} {status_label:11s} | {original_file:<{max_original_len}} -> {output_file}"
                    else:
                        display = f"[{opf_pos:03d}] Ch.{chapter_num:06.1f} | {icon} {status_label:11s} | {original_file:<{max_original_len}} -> {output_file}"
                else:
                    display = f"[{opf_pos:03d}] Ch.{chapter_num:03d} | {icon} {status_label:11s} | {original_file:<{max_original_len}} -> {output_file}"
            else:
                if isinstance(chapter_num, float) and chapter_num.is_integer():
                    display = f"Chapter {int(chapter_num):03d} | {icon} {status_label:11s} | {output_file}"
                elif isinstance(chapter_num, float):
                    display = f"Chapter {chapter_num:06.1f} | {icon} {status_label:11s} | {output_file}"
                else:
                    display = f"Chapter {chapter_num:03d} | {icon} {status_label:11s} | {output_file}"
            if status == 'qa_failed':
                chapter_info = info.get('info', {})
                qa_issues = chapter_info.get('qa_issues_found', [])
                if qa_issues:
                    issues_display = ', '.join(qa_issues[:2])
                    if len(qa_issues) > 2:
                        issues_display += f' (+{len(qa_issues)-2} more)'
                    display += f" | {issues_display}"
            if status == 'merged':
                chapter_info = info.get('info', {})
                parent_chapter = chapter_info.get('merged_parent_chapter')
                if parent_chapter:
                    display += f" | → Ch.{parent_chapter}"
            if info.get('duplicate_count', 1) > 1:
                display += f" | ({info['duplicate_count']} entries)"
            return display

        def apply_item_visuals(item, status):
            from PySide6.QtGui import QColor
            if status == 'completed':
                item.setForeground(QColor('green'))
            elif status == 'merged':
                item.setForeground(QColor('#17a2b8'))
            elif status in ['failed', 'qa_failed']:
                item.setForeground(QColor('red'))
            elif status == 'not_translated':
                item.setForeground(QColor('#2b6cb0'))
            elif status == 'in_progress':
                item.setForeground(QColor('orange'))

        show_special_files = data.get('show_special_files_state', False)
        if 'show_special_files_cb' in data and data['show_special_files_cb']:
            try:
                show_special_files = data['show_special_files_cb'].isChecked()
            except RuntimeError:
                pass

        if count_existing == count_new:
            # Update in place to keep scroll stable
            for idx, info in enumerate(data['chapter_display_info']):
                if idx % 120 == 0:
                    self._ui_yield()
                item = listbox.item(idx)
                if not item:
                    continue
                item.setText(build_display(info, max_original_len, max_output_len))
                apply_item_visuals(item, info['status'])
                is_special = info.get('is_special', False)
                item.setData(Qt.UserRole, {'is_special': is_special, 'info': info, 'progress_key': info.get('progress_key')})
                item.setHidden(is_special and not show_special_files)
        else:
            # Recreate items
            listbox.clear()
            from PySide6.QtWidgets import QListWidgetItem
            from PySide6.QtCore import Qt
            for idx, info in enumerate(data['chapter_display_info']):
                if idx % 120 == 0:
                    self._ui_yield()
                item = QListWidgetItem(build_display(info, max_original_len, max_output_len))
                apply_item_visuals(item, info['status'])
                is_special = info.get('is_special', False)
                item.setData(Qt.UserRole, {'is_special': is_special, 'info': info, 'progress_key': info.get('progress_key')})
                item.setHidden(is_special and not show_special_files)
                listbox.addItem(item)

        listbox.blockSignals(False)
        listbox.setUpdatesEnabled(True)
    
    def _update_statistics_display(self, data):
        """Update statistics display for both OPF and non-OPF files"""
        # Find statistics labels in the container
        container = data['container']
        
        # Search for statistics labels by traversing the widget hierarchy
        def find_stats_labels(widget):
            labels = {}
            if hasattr(widget, 'children'):
                for child in widget.children():
                    if hasattr(child, 'text'):
                        text = child.text()
                        if text.startswith('Total:'):
                            labels['total'] = child
                        elif text.startswith('✅ Completed:'):
                            labels['completed'] = child
                        elif text.startswith('🔗 Merged:'):
                            labels['merged'] = child
                        elif text.startswith('🔄 In Progress:'):
                            labels['in_progress'] = child
                        elif text.startswith('❓ Pending:'):
                            labels['pending'] = child
                        elif text.startswith('⬜ Not Translated:'):
                            labels['missing'] = child
                        elif text.startswith('❌ Failed:'):
                            labels['failed'] = child
                    
                    # Recursively search children
                    labels.update(find_stats_labels(child))
            return labels
        
        stats_labels = find_stats_labels(container)
        
        if stats_labels:
            # Recalculate statistics from chapter_display_info (works for both OPF and non-OPF)
            chapter_display_info = data.get('chapter_display_info', [])
            total_chapters = len(chapter_display_info)
            completed = sum(1 for info in chapter_display_info if info['status'] == 'completed')
            merged = sum(1 for info in chapter_display_info if info['status'] == 'merged')
            in_progress = sum(1 for info in chapter_display_info if info['status'] == 'in_progress')
            pending = sum(1 for info in chapter_display_info if info['status'] == 'pending')
            missing = sum(1 for info in chapter_display_info if info['status'] == 'not_translated')
            failed = sum(1 for info in chapter_display_info if info['status'] in ['failed', 'qa_failed'])
            
            # Update labels
            if 'total' in stats_labels:
                stats_labels['total'].setText(f"Total: {total_chapters} | ")
            if 'completed' in stats_labels:
                stats_labels['completed'].setText(f"✅ Completed: {completed} | ")
            if 'merged' in stats_labels:
                if merged > 0:
                    stats_labels['merged'].setText(f"🔗 Merged: {merged} | ")
                    stats_labels['merged'].setVisible(True)
                else:
                    stats_labels['merged'].setVisible(False)
            if 'in_progress' in stats_labels:
                if in_progress > 0:
                    stats_labels['in_progress'].setText(f"🔄 In Progress: {in_progress} | ")
                    stats_labels['in_progress'].setVisible(True)
                else:
                    stats_labels['in_progress'].setVisible(False)
            if 'pending' in stats_labels:
                if pending > 0:
                    stats_labels['pending'].setText(f"❓ Pending: {pending} | ")
                    stats_labels['pending'].setVisible(True)
                else:
                    stats_labels['pending'].setVisible(False)
            if 'missing' in stats_labels:
                stats_labels['missing'].setText(f"⬜ Not Translated: {missing} | ")
            if 'failed' in stats_labels:
                stats_labels['failed'].setText(f"❌ Failed: {failed} | ")

    def _refresh_image_folder_data(self, data):
        """Refresh the image folder retranslation dialog data by rescanning files"""
        try:
            # Validate that widgets still exist
            if not self._is_data_valid(data):
                print("⚠️ Cannot refresh - widgets have been deleted")
                return
            
            # Save current selections to restore after refresh
            selected_indices = []
            try:
                selected_indices = [data['listbox'].row(item) for item in data['listbox'].selectedItems()]
            except RuntimeError:
                print("⚠️ Could not save selection state - widget was deleted")
                return
            
            output_dir = data['output_dir']
            progress_file = data['progress_file']
            folder_path = data['folder_path']
            
            # ALWAYS reload progress data from file to catch deletions
            progress_data = None
            html_files = []
            has_progress_tracking = os.path.exists(progress_file)
            
            if has_progress_tracking:
                try:
                    with open(progress_file, 'r', encoding='utf-8') as f:
                        progress_data = json.load(f)
                    print(f"🔄 Reloaded progress file from disk")
                    
                    # Extract files from progress data (primary source)
                    # Check if this is the newer nested structure with 'images' key
                    images_dict = progress_data.get('images', {})
                    if images_dict:
                        # Newer structure: progress_data['images'][hash] = {entry}
                        for key, value in images_dict.items():
                            if isinstance(value, dict) and 'output_file' in value:
                                output_file = value['output_file']
                                # Handle both forward and backslashes in paths
                                output_file = output_file.replace('\\', '/')
                                if '/' in output_file:
                                    output_file = os.path.basename(output_file)
                                
                                # Only include if file actually exists on disk
                                if output_file and output_file not in html_files:
                                    full_path = os.path.join(output_dir, output_file)
                                    if os.path.exists(full_path):
                                        html_files.append(output_file)
                                    else:
                                        print(f"⚠️ File in progress but not on disk: {output_file}")
                    else:
                        # Older structure: progress_data[hash] = {entry}
                        for key, value in progress_data.items():
                            if isinstance(value, dict) and 'output_file' in value:
                                output_file = value['output_file']
                                # Handle both forward and backslashes in paths
                                output_file = output_file.replace('\\', '/')
                                if '/' in output_file:
                                    output_file = os.path.basename(output_file)
                                
                                # Only include if file actually exists on disk
                                if output_file and output_file not in html_files:
                                    full_path = os.path.join(output_dir, output_file)
                                    if os.path.exists(full_path):
                                        html_files.append(output_file)
                                    else:
                                        print(f"⚠️ File in progress but not on disk: {output_file}")
                except Exception as e:
                    print(f"Failed to load progress file: {e}")
                    has_progress_tracking = False
            
            # Also scan directory for any HTML files not in progress (fallback)
            if os.path.exists(output_dir):
                try:
                    for file in os.listdir(output_dir):
                        file_path = os.path.join(output_dir, file)
                        if (os.path.isfile(file_path) and 
                            file.lower().endswith(('.html', '.xhtml', '.htm')) and 
                            file not in html_files):
                            html_files.append(file)
                except Exception as e:
                    print(f"Error scanning directory: {e}")
            
            # Rescan cover images
            image_files = []
            images_dir = os.path.join(output_dir, "images")
            if os.path.exists(images_dir):
                try:
                    for file in os.listdir(images_dir):
                        if file.lower().endswith(('.png', '.jpg', '.jpeg', '.gif', '.bmp', '.webp')):
                            image_files.append(file)
                except Exception as e:
                    print(f"Error scanning images directory: {e}")
            
            # Rebuild file_info list
            file_info = []
            
            # Add translated files (both HTML and generated images)
            for html_file in sorted(set(html_files)):
                # Determine file type and extract info
                is_html = html_file.lower().endswith(('.html', '.xhtml', '.htm'))
                is_image = html_file.lower().endswith(('.png', '.jpg', '.jpeg', '.webp', '.gif'))
                
                if is_html:
                    match = re.match(r'response_(\d+)_(.+)\.html', html_file)
                    if match:
                        index = match.group(1)
                        base_name = match.group(2)
                elif is_image:
                    # For generated images, just use the filename
                    base_name = os.path.splitext(html_file)[0]
                
                # Find hash key if progress tracking exists
                hash_key = None
                if progress_data:
                    # Check nested structure first
                    images_dict = progress_data.get('images', {})
                    if images_dict:
                        for key, value in images_dict.items():
                            if isinstance(value, dict) and 'output_file' in value:
                                if html_file in value['output_file']:
                                    hash_key = key
                                    break
                    else:
                        # Check flat structure
                        for key, value in progress_data.items():
                            if isinstance(value, dict) and 'output_file' in value:
                                if html_file in value['output_file']:
                                    hash_key = key
                                    break
                
                file_info.append({
                    'type': 'translated',
                    'file': html_file,
                    'path': os.path.join(output_dir, html_file),
                    'hash_key': hash_key,
                    'output_dir': output_dir
                })
            
            # Add cover images
            for img_file in sorted(image_files):
                file_info.append({
                    'type': 'cover',
                    'file': img_file,
                    'path': os.path.join(images_dir, img_file),
                    'hash_key': None,
                    'output_dir': output_dir
                })
            
            # Update data dictionary with fresh data
            data['file_info'] = file_info
            data['progress_data'] = progress_data
            
            # IMPORTANT: Also update the original refresh_data dict so future operations use fresh data
            # This ensures delete operations after refresh work with current state
            if 'progress_data' in data:
                # Update the reference in the closure
                data['progress_data'] = progress_data
            
            # Clear and rebuild listbox
            listbox = data['listbox']
            listbox.clear()
            
            # Add all tracked files to display
            for info in file_info:
                if info['type'] == 'translated':
                    file_name = info['file']
                    # Check if it's an HTML file or a generated image
                    is_html = file_name.lower().endswith(('.html', '.xhtml', '.htm'))
                    is_image = file_name.lower().endswith(('.png', '.jpg', '.jpeg', '.webp', '.gif'))
                    
                    if is_html:
                        match = re.match(r'response_(\d+)_(.+)\.html', file_name)
                        if match:
                            index = match.group(1)
                            base_name = match.group(2)
                            display = f"📄 Image {index} | {base_name} | ✅ Completed"
                        else:
                            display = f"📄 {file_name} | ✅ Completed"
                    elif is_image:
                        # Generated image file (e.g., Test1.png from imagen)
                        base_name = os.path.splitext(file_name)[0]
                        display = f"🖼️ {base_name} | ✅ Completed"
                    else:
                        display = f"📄 {file_name} | ✅ Completed"
                elif info['type'] == 'cover':
                    display = f"🖼️ Cover | {info['file']} | ⏭️ Skipped (cover)"
                else:
                    display = f"📄 {info['file']}"
                
                listbox.addItem(display)
            
            # Restore selections
            try:
                if selected_indices:
                    for idx in selected_indices:
                        if idx < listbox.count():
                            listbox.item(idx).setSelected(True)
                    # Update selection count
                    if 'selection_count_label' in data and data['selection_count_label']:
                        data['selection_count_label'].setText(f"Selected: {len(selected_indices)}")
                else:
                    listbox.clearSelection()
                    if 'selection_count_label' in data and data['selection_count_label']:
                        data['selection_count_label'].setText("Selected: 0")
            except RuntimeError:
                print("⚠️ Could not restore selection state - widget was deleted during refresh")
            
            print(f"✅ Image folder data refreshed: {len(html_files)} HTML files, {len(image_files)} cover images")
            
        except Exception as e:
            print(f"❌ Failed to refresh image folder data: {e}")
            import traceback
            traceback.print_exc()

    def _force_retranslation_multiple_files(self):
        """Handle force retranslation when multiple files are selected - now uses shared logic"""
        try:
            print(f"[DEBUG] _force_retranslation_multiple_files called with {len(self.selected_files)} files")
            
            # First, check if all selected files are images from the same folder
            # This handles the case where folder selection results in individual file selections
            if len(self.selected_files) > 1:
                all_images = True
                parent_dirs = set()
                
                image_extensions = ('.png', '.jpg', '.jpeg', '.gif', '.bmp', '.webp')
                
                for file_path in self.selected_files:
                    if os.path.isfile(file_path) and file_path.lower().endswith(image_extensions):
                        parent_dirs.add(os.path.dirname(file_path))
                    else:
                        all_images = False
                        break
                
                # If all files are images from the same directory, treat it as a folder selection
                if all_images and len(parent_dirs) == 1:
                    folder_path = parent_dirs.pop()
                    print(f"[DEBUG] Detected {len(self.selected_files)} images from same folder: {folder_path}")
                    print(f"[DEBUG] Treating as folder selection")
                    self._force_retranslation_images_folder(folder_path)
                    return
            
            # Otherwise, continue with normal categorization
            epub_files = []
            text_files = []
            image_files = []
            folders = []
            
            image_extensions = ('.png', '.jpg', '.jpeg', '.gif', '.bmp', '.webp')
            
            for file_path in self.selected_files:
                if os.path.isdir(file_path):
                    folders.append(file_path)
                elif file_path.lower().endswith('.epub'):
                    epub_files.append(file_path)
                elif file_path.lower().endswith('.txt'):
                    text_files.append(file_path)
                elif file_path.lower().endswith(image_extensions):
                    image_files.append(file_path)
            
            # Build summary
            summary_parts = []
            if epub_files:
                summary_parts.append(f"{len(epub_files)} EPUB file(s)")
            if text_files:
                summary_parts.append(f"{len(text_files)} text file(s)")
            if image_files:
                summary_parts.append(f"{len(image_files)} image file(s)")
            if folders:
                summary_parts.append(f"{len(folders)} folder(s)")
            
            if not summary_parts:
                QMessageBox.information(self, "Info", "No valid files selected.")
                return
            
            # Create a unique key for the current selection
            selection_key = tuple(sorted(self.selected_files))
            
            # Check if we already have a cached dialog for this exact selection
            if (hasattr(self, '_multi_file_retranslation_dialog') and 
                self._multi_file_retranslation_dialog and 
                hasattr(self, '_multi_file_selection_key') and 
                self._multi_file_selection_key == selection_key):
                # Reuse existing dialog - refresh all tabs before showing
                cached_dialog = self._multi_file_retranslation_dialog
                if hasattr(cached_dialog, '_tab_data') and cached_dialog._tab_data:
                    print(f"[DEBUG] Refreshing all {len(cached_dialog._tab_data)} tabs in cached dialog...")
                    self._refresh_all_tabs(cached_dialog._tab_data)
                cached_dialog.show()
                cached_dialog.raise_()
                cached_dialog.activateWindow()
                return
            
            # If there's an existing dialog for a different selection, destroy it first
            if hasattr(self, '_multi_file_retranslation_dialog') and self._multi_file_retranslation_dialog:
                self._multi_file_retranslation_dialog.close()
                self._multi_file_retranslation_dialog.deleteLater()
                self._multi_file_retranslation_dialog = None
            
            # Create main dialog
            dialog = QDialog(self)
            dialog.setWindowTitle("Progress Manager - Multiple Files")
            dialog.setWindowFlag(Qt.WindowStaysOnTopHint, True)
            dialog.setWindowModality(Qt.NonModal)
            # Store the list of EPUBs in the dialog for cross-tab state updates
            dialog._epub_files_in_dialog = epub_files + text_files
            # Increased height from 18% to 25% for better visibility
            width, height = self._get_dialog_size(0.25, 0.45)
            dialog.resize(width, height)
            
            # Set icon
            try:
                from PySide6.QtGui import QIcon
                if hasattr(self, 'base_dir'):
                    base_dir = self.base_dir
                else:
                    base_dir = getattr(sys, '_MEIPASS', os.path.dirname(os.path.abspath(__file__)))
                ico_path = os.path.join(base_dir, 'Halgakos.ico')
                if os.path.isfile(ico_path):
                    dialog.setWindowIcon(QIcon(ico_path))
            except Exception as e:
                print(f"Failed to load icon: {e}")
            
            dialog_layout = QVBoxLayout(dialog)
            
            # Summary label
            summary_label = QLabel(f"Selected: {', '.join(summary_parts)}")
            summary_font = QFont('Arial', 12)
            summary_font.setBold(True)
            summary_label.setFont(summary_font)
            dialog_layout.addWidget(summary_label)
            
            # Create tab widget with custom styling
            notebook = QTabWidget()
            notebook.setStyleSheet("""
                QTabWidget::pane {
                    border: 2px solid #5a9fd4;
                    border-radius: 4px;
                    background-color: #2d2d2d;
                }
                QTabBar::tab {
                    background-color: #3a3a3a;
                    color: white;
                    padding: 8px 16px;
                    margin-right: 2px;
                    border: 1px solid #5a9fd4;
                    border-bottom: none;
                    border-top-left-radius: 4px;
                    border-top-right-radius: 4px;
                    font-weight: bold;
                    font-size: 11pt;
                }
                QTabBar::tab:selected {
                    background-color: #5a9fd4;
                    color: white;
                }
                QTabBar::tab:hover {
                    background-color: #4a8fc4;
                }
            """)
            dialog_layout.addWidget(notebook)
            
            # Track all tab data
            tab_data = []
            tabs_created = False
            
            # Store tab_data reference on the dialog for cross-tab operations
            dialog._tab_data = tab_data
            
            # Get the global show_special state from the first file that has it cached
            # Default to True if any text files are present, False otherwise
            global_show_special = True if text_files else False
            
            for file_path in epub_files + text_files:
                file_key = os.path.abspath(file_path)
                if hasattr(self, '_retranslation_dialog_cache') and file_key in self._retranslation_dialog_cache:
                    cached_data = self._retranslation_dialog_cache[file_key]
                    if cached_data and 'show_special_files_state' in cached_data:
                        global_show_special = cached_data['show_special_files_state']
                        break  # Use the first one we find
            
            # Determine output directory override (matches single-file logic)
            override_dir = (os.environ.get('OUTPUT_DIRECTORY') or os.environ.get('OUTPUT_DIR'))
            if not override_dir and hasattr(self, 'config'):
                try:
                    override_dir = self.config.get('output_directory')
                except Exception:
                    override_dir = None

            # Create tabs for EPUB/text files using shared logic
            for file_path in epub_files + text_files:
                file_base = os.path.splitext(os.path.basename(file_path))[0]
                
                print(f"[DEBUG] Checking EPUB/text: {file_base}")
                
                # Quick check if output exists (respect override output directory)
                output_dir = os.path.join(override_dir, file_base) if override_dir else file_base
                if not os.path.exists(output_dir):
                    print(f"[DEBUG] Skipping {file_base} - output folder doesn't exist: {output_dir}")
                    continue
                
                print(f"[DEBUG] Creating tab for {file_base}")
                
                # Create tab
                tab_frame = QWidget()
                tab_layout = QVBoxLayout(tab_frame)
                tab_name = file_base[:20] + "..." if len(file_base) > 20 else file_base
                
                # Use shared logic to populate the tab with global state
                tab_result = self._force_retranslation_epub_or_text(
                    file_path, 
                    parent_dialog=dialog, 
                    tab_frame=tab_frame,
                    show_special_files_state=global_show_special
                )
                
                # Only add the tab if content was successfully created
                if tab_result:
                    notebook.addTab(tab_frame, tab_name)
                    tab_data.append(tab_result)
                    tabs_created = True
                    print(f"[DEBUG] Successfully created tab for {file_base}")
                else:
                    print(f"[DEBUG] Failed to create content for {file_base}")
            
            # Create tabs for image folders (keeping existing logic for now)
            for folder_path in folders:
                folder_result = self._create_image_folder_tab(
                    folder_path, 
                    notebook, 
                    dialog
                )
                if folder_result:
                    tab_data.append(folder_result)
                    tabs_created = True
            
            # If only individual image files selected and no tabs created yet
            if image_files and not tabs_created:
                # Create a single tab for all individual images
                image_tab_result = self._create_individual_images_tab(
                    image_files,
                    notebook,
                    dialog
                )
                if image_tab_result:
                    tab_data.append(image_tab_result)
                    tabs_created = True
            
            # If no tabs were created from folders, try scanning folders for individual images
            if not tabs_created and folders:
                # Scan folders for individual image files
                scanned_images = []
                for folder_path in folders:
                    if os.path.isdir(folder_path):
                        try:
                            for file in os.listdir(folder_path):
                                file_path = os.path.join(folder_path, file)
                                if os.path.isfile(file_path) and file.lower().endswith(('.png', '.jpg', '.jpeg', '.gif', '.bmp', '.webp')):
                                    scanned_images.append(file_path)
                        except:
                            pass
                
                # If we found images, create a tab for them
                if scanned_images:
                    image_tab_result = self._create_individual_images_tab(
                        scanned_images,
                        notebook,
                        dialog
                    )
                    if image_tab_result:
                        tab_data.append(image_tab_result)
                        tabs_created = True
            
            # If still no tabs were created, show error
            if not tabs_created:
                QMessageBox.information(self, "Info", 
                    "No translation output found for any of the selected files.\n\n"
                    "Make sure the output folders exist in your script directory.")
                dialog.close()
                return
        
            # Add unified button bar that works across all tabs
            self._add_multi_file_buttons(dialog, notebook, tab_data)
            
            # Override close event to minimize instead of destroy
            def closeEvent(event):
                event.ignore()  # Ignore the close event
                dialog.hide()   # Just hide (minimize) the dialog
            
            dialog.closeEvent = closeEvent
            
            # Cache the dialog and selection key for reuse
            self._multi_file_retranslation_dialog = dialog
            self._multi_file_selection_key = selection_key
            
            # Refresh all tabs before showing the dialog
            if tab_data:
                print(f"[DEBUG] Refreshing all {len(tab_data)} tabs on dialog open...")
                self._refresh_all_tabs(tab_data)
            else:
                print(f"[WARN] No tab data to refresh on dialog open")
            
            # Show the dialog (non-modal to allow interaction with other windows)
            dialog.show()
            
        except Exception as e:
            print(f"[ERROR] _force_retranslation_multiple_files failed: {e}")
            import traceback
            traceback.print_exc()
            QMessageBox.critical(self, "Error", f"Failed to open retranslation dialog:\n{str(e)}")

    def _add_multi_file_buttons(self, dialog, notebook, tab_data):
        """Placeholder for future multi-file button functionality"""
        # No buttons needed - dialog has standard close button
        pass
              
    def _create_individual_images_tab(self, image_files, notebook, parent_dialog):
        """Create a tab for individual image files"""
        # Create tab
        tab_frame = QWidget()
        tab_layout = QVBoxLayout(tab_frame)
        notebook.addTab(tab_frame, "Individual Images")
        
        # Instructions
        instruction_label = QLabel(f"Selected {len(image_files)} individual image(s):")
        instruction_font = QFont('Arial', 11)
        instruction_label.setFont(instruction_font)
        tab_layout.addWidget(instruction_label)
        
        # Listbox (QListWidget has built-in scrolling)
        listbox = QListWidget()
        listbox.setSelectionMode(QListWidget.ExtendedSelection)
        # Use 16% of screen width (half of original ~31% for 1920px screen)
        min_width, _ = self._get_dialog_size(0.16, 0)
        listbox.setMinimumWidth(min_width)
        tab_layout.addWidget(listbox)
        
        # File info
        file_info = []
        script_dir = os.getcwd()
        
        # Check each image for translations
        for img_path in sorted(image_files):
            img_name = os.path.basename(img_path)
            base_name = os.path.splitext(img_name)[0]
            
            # Look for translations in various possible locations
            found_translations = []
            
            # Check in script directory with base name
            possible_dirs = [
                os.path.join(script_dir, base_name),
                os.path.join(script_dir, f"{base_name}_translated"),
                base_name,
                f"{base_name}_translated"
            ]
            
            for output_dir in possible_dirs:
                if os.path.exists(output_dir) and os.path.isdir(output_dir):
                    # Look for HTML files
                    for file in os.listdir(output_dir):
                        if file.lower().endswith(('.html', '.xhtml', '.htm')) and base_name in file:
                            found_translations.append((output_dir, file))
            
            if found_translations:
                for output_dir, html_file in found_translations:
                    display = f"📄 {img_name} → {html_file} | ✅ Translated"
                    listbox.addItem(display)
                    
                    file_info.append({
                        'type': 'translated',
                        'source_image': img_path,
                        'output_dir': output_dir,
                        'file': html_file,
                        'path': os.path.join(output_dir, html_file)
                    })
            else:
                display = f"🖼️ {img_name} | ❌ No translation found"
                listbox.addItem(display)
        
        # Selection count
        selection_count_label = QLabel("Selected: 0")
        selection_font = QFont('Arial', 9)
        selection_count_label.setFont(selection_font)
        tab_layout.addWidget(selection_count_label)
        
        def update_selection_count():
            count = len(listbox.selectedItems())
            selection_count_label.setText(f"Selected: {count}")
        
        listbox.itemSelectionChanged.connect(update_selection_count)

        # Right-click context menu to open translated/cover files
        def _open_file_for_row(row):
            if row < 0 or row >= len(file_info):
                return
            info = file_info[row]
            path = info.get('path')
            if not path or not os.path.exists(path):
                self._show_message('error', "File Missing", f"File not found:\n{path}", parent=parent_dialog)
                return
            try:
                QDesktopServices.openUrl(QUrl.fromLocalFile(path))
            except Exception as e:
                self._show_message('error', "Open Failed", str(e), parent=parent_dialog)

        def _show_context_menu(pos):
            item = listbox.itemAt(pos)
            if not item:
                return
            row = listbox.row(item)
            menu = QMenu(listbox)
            menu.setStyleSheet(
                "QMenu {"
                "  padding: 4px;"
                "  background-color: #2b2b2b;"
                "  color: white;"
                "  border: 1px solid #5a9fd4;"
                "} "
                "QMenu::icon { width: 0px; } "
                "QMenu::item {"
                "  padding: 6px 12px;"
                "  background-color: transparent;"
                "} "
                "QMenu::item:selected {"
                "  background-color: #17a2b8;"
                "  color: white;"
                "} "
                "QMenu::item:pressed {"
                "  background-color: #138496;"
                "}"
            )
            act_open = menu.addAction("📂 Open File")
            chosen = menu.exec(listbox.mapToGlobal(pos))
            if chosen == act_open:
                _open_file_for_row(row)

        listbox.setContextMenuPolicy(Qt.CustomContextMenu)
        listbox.customContextMenuRequested.connect(_show_context_menu)
        
        return {
            'type': 'individual_images',
            'listbox': listbox,
            'file_info': file_info,
            'selection_count_label': selection_count_label
        }


    def _create_image_folder_tab(self, folder_path, notebook, parent_dialog):
        """Create a tab for image folder retranslation"""
        folder_name = os.path.basename(folder_path)
        output_dir = f"{folder_name}_translated"
        
        if not os.path.exists(output_dir):
            return None
        
        # Create tab
        tab_frame = QWidget()
        tab_layout = QVBoxLayout(tab_frame)
        tab_name = "📁 " + (folder_name[:17] + "..." if len(folder_name) > 17 else folder_name)
        notebook.addTab(tab_frame, tab_name)
        
        # Instructions
        instruction_label = QLabel("Select images to retranslate:")
        instruction_font = QFont('Arial', 11)
        instruction_label.setFont(instruction_font)
        tab_layout.addWidget(instruction_label)
        
        # Listbox (QListWidget has built-in scrolling)
        listbox = QListWidget()
        listbox.setSelectionMode(QListWidget.ExtendedSelection)
        # Use 16% of screen width (half of original ~31% for 1920px screen)
        min_width, _ = self._get_dialog_size(0.16, 0)
        listbox.setMinimumWidth(min_width)
        tab_layout.addWidget(listbox)
        
        # Find files
        file_info = []
        
        # Add HTML files (any .html/.xhtml/.htm, not just response_*)
        for file in os.listdir(output_dir):
            if file.lower().endswith(('.html', '.xhtml', '.htm')):
                match = re.match(r'^response_(\d+)_([^.]*).(?:html?|xhtml|htm)(?:\.xhtml)?$', file, re.IGNORECASE)
                if match:
                    index = match.group(1)
                    base_name = match.group(2)
                    display = f"📄 Image {index} | {base_name} | ✅ Completed"
                else:
                    display = f"📄 {file} | ✅ Completed"
                
                listbox.addItem(display)
                file_info.append({
                    'type': 'translated',
                    'file': file,
                    'path': os.path.join(output_dir, file)
                })
        
        # Add cover images
        images_dir = os.path.join(output_dir, "images")
        if os.path.exists(images_dir):
            for file in sorted(os.listdir(images_dir)):
                if file.lower().endswith(('.png', '.jpg', '.jpeg', '.gif', '.bmp', '.webp')):
                    display = f"🖼️ Cover | {file} | ⏭️ Skipped"
                    listbox.addItem(display)
                    file_info.append({
                        'type': 'cover',
                        'file': file,
                        'path': os.path.join(images_dir, file)
                    })
        
        # Selection count
        selection_count_label = QLabel("Selected: 0")
        selection_font = QFont('Arial', 9)
        selection_count_label.setFont(selection_font)
        tab_layout.addWidget(selection_count_label)
        
        def update_selection_count():
            count = len(listbox.selectedItems())
            selection_count_label.setText(f"Selected: {count}")
        
        listbox.itemSelectionChanged.connect(update_selection_count)

        # Right-click context menu (Open File)
        def _open_file_for_row(row):
            if row < 0 or row >= len(file_info):
                return
            info = file_info[row]
            path = info.get('path')
            if not path or not os.path.exists(path):
                self._show_message('error', "File Missing", f"File not found:\n{path}", parent=parent_dialog)
                return
            try:
                QDesktopServices.openUrl(QUrl.fromLocalFile(path))
            except Exception as e:
                self._show_message('error', "Open Failed", str(e), parent=parent_dialog)

        def _show_context_menu(pos):
            item = listbox.itemAt(pos)
            if not item:
                return
            row = listbox.row(item)
            menu = QMenu(listbox)
            menu.setStyleSheet(
                "QMenu {"
                "  padding: 4px;"
                "  background-color: #2b2b2b;"
                "  color: white;"
                "  border: 1px solid #5a9fd4;"
                "} "
                "QMenu::icon { width: 0px; } "
                "QMenu::item {"
                "  padding: 6px 12px;"
                "  background-color: transparent;"
                "} "
                "QMenu::item:selected {"
                "  background-color: #17a2b8;"
                "  color: white;"
                "} "
                "QMenu::item:pressed {"
                "  background-color: #138496;"
                "}"
            )
            act_open = menu.addAction("📂 Open File")
            chosen = menu.exec(listbox.mapToGlobal(pos))
            if chosen == act_open:
                _open_file_for_row(row)

        listbox.setContextMenuPolicy(Qt.CustomContextMenu)
        listbox.customContextMenuRequested.connect(_show_context_menu)
        
        return {
            'type': 'image_folder',
            'folder_path': folder_path,
            'output_dir': output_dir,
            'listbox': listbox,
            'file_info': file_info,
            'selection_count_label': selection_count_label
        }


    def _force_retranslation_images_folder(self, folder_path):
        """Handle force retranslation for image folders"""
        # If folder_path is actually a file (single image), get its directory
        if os.path.isfile(folder_path):
            # Single image file - use basename without extension
            folder_name = os.path.splitext(os.path.basename(folder_path))[0]
        else:
            # Folder - use folder name as-is
            folder_name = os.path.basename(folder_path)
        
        # Check if we already have a cached dialog for this folder
        folder_key = os.path.abspath(folder_path)
        if hasattr(self, '_image_retranslation_dialog_cache') and folder_key in self._image_retranslation_dialog_cache:
            cached_dialog = self._image_retranslation_dialog_cache[folder_key]
            if cached_dialog:
                # Reuse existing dialog - just show it
                try:
                    # Click stored refresh button or call stored refresh func on reuse
                    if hasattr(cached_dialog, '_refresh_button') and cached_dialog._refresh_button:
                        QTimer.singleShot(0, cached_dialog._refresh_button.click)
                    elif hasattr(cached_dialog, '_refresh_func'):
                        QTimer.singleShot(0, cached_dialog._refresh_func)
                except Exception:
                    pass
                cached_dialog.show()
                cached_dialog.raise_()
                cached_dialog.activateWindow()
                return
        
        # Look for output folder in the SCRIPT'S directory, not relative to the selected folder
        script_dir = os.getcwd()  # Current working directory where the script is running
        
        # Check multiple possible output folder patterns IN THE SCRIPT DIRECTORY
        possible_output_dirs = [
            os.path.join(script_dir, folder_name),  # Script dir + folder name (without extension)
            os.path.join(script_dir, f"{folder_name}_translated"),  # Script dir + folder_translated
            folder_name,  # Just the folder name in current directory
            f"{folder_name}_translated",  # folder_translated in current directory
        ]
        
        # Check for output directory override
        override_dir = os.environ.get('OUTPUT_DIRECTORY')
        if not override_dir and hasattr(self, 'config'):
            override_dir = self.config.get('output_directory')
            
        if override_dir:
            # If override is set, check inside it for the folder name
            possible_output_dirs.insert(0, os.path.join(override_dir, folder_name))
            possible_output_dirs.insert(1, os.path.join(override_dir, f"{folder_name}_translated"))
        
        output_dir = None
        for possible_dir in possible_output_dirs:
            print(f"Checking: {possible_dir}")
            if os.path.exists(possible_dir):
                # Check if it has translation_progress.json or HTML files
                if os.path.exists(os.path.join(possible_dir, "translation_progress.json")):
                    output_dir = possible_dir
                    print(f"Found output directory with progress tracker: {output_dir}")
                    break
                # Check if it has any HTML files
                elif os.path.isdir(possible_dir):
                    try:
                        files = os.listdir(possible_dir)
                        if any(f.lower().endswith(('.html', '.xhtml', '.htm')) for f in files):
                            output_dir = possible_dir
                            print(f"Found output directory with HTML files: {output_dir}")
                            break
                    except:
                        pass
        
        if not output_dir:
            QMessageBox.information(self, "Info", 
                f"No translation output found for '{folder_name}'.\n\n"
                f"Selected folder: {folder_path}\n"
                f"Script directory: {script_dir}\n\n"
                f"Checked locations:\n" + "\n".join(f"- {d}" for d in possible_output_dirs))
            return
        
        print(f"Using output directory: {output_dir}")
        
        # Check for progress tracking file
        progress_file = os.path.join(output_dir, "translation_progress.json")
        has_progress_tracking = os.path.exists(progress_file)
        
        print(f"Progress tracking: {has_progress_tracking} at {progress_file}")
        
        # Find all HTML files in the output directory
        html_files = []
        image_files = []
        progress_data = None
        
        if has_progress_tracking:
            # Load progress data for image translations
            try:
                with open(progress_file, 'r', encoding='utf-8') as f:
                    progress_data = json.load(f)
                    print(f"Loaded progress data with {len(progress_data)} entries")
                    
                # Extract files from progress data
                # The structure appears to use hash keys at the root level
                for key, value in progress_data.items():
                    if isinstance(value, dict) and 'output_file' in value:
                        output_file = value['output_file']
                        # Handle both forward and backslashes in paths
                        output_file = output_file.replace('\\', '/')
                        if '/' in output_file:
                            output_file = os.path.basename(output_file)
                        html_files.append(output_file)
                        print(f"Found tracked file: {output_file}")
            except Exception as e:
                print(f"Error loading progress file: {e}")
                import traceback
                traceback.print_exc()
                has_progress_tracking = False
        
            # Also scan directory for any HTML files not in progress
            # Include all .html/.xhtml/.htm files plus generated image files
        try:
            for file in os.listdir(output_dir):
                file_path = os.path.join(output_dir, file)
                # Include HTML files (any name)
                if (os.path.isfile(file_path) and 
                    file.lower().endswith(('.html', '.xhtml', '.htm')) and 
                    file not in html_files):
                    html_files.append(file)
                    print(f"Found HTML file: {file}")
                # Also include generated image files (not in images/ subdirectory)
                elif (os.path.isfile(file_path) and 
                      file.lower().endswith(('.png', '.jpg', '.jpeg', '.webp', '.gif')) and
                      file not in html_files):
                    html_files.append(file)  # Add to html_files for now, will be handled separately
                    print(f"Found generated image file: {file}")
        except Exception as e:
            print(f"Error scanning directory: {e}")
        
        # Check for images subdirectory (cover images)
        images_dir = os.path.join(output_dir, "images")
        if os.path.exists(images_dir):
            try:
                for file in os.listdir(images_dir):
                    if file.lower().endswith(('.png', '.jpg', '.jpeg', '.gif', '.bmp', '.webp')):
                        image_files.append(file)
            except Exception as e:
                print(f"Error scanning images directory: {e}")
        
        print(f"Total files found: {len(html_files)} HTML, {len(image_files)} images")
        
        if not html_files and not image_files:
            QMessageBox.information(self, "Info", 
                f"No translated files found in: {output_dir}\n\n"
                f"Progress tracking: {'Yes' if has_progress_tracking else 'No'}")
            return
        
        # Create dialog
        dialog = QDialog(self)
        dialog.setWindowTitle("Progress Manager - Images")
        dialog.setWindowFlag(Qt.WindowStaysOnTopHint, True)
        dialog.setWindowModality(Qt.NonModal)
        # Decreased width to 18%, increased height to 25% for better vertical space
        width, height = self._get_dialog_size(0.18, 0.25)
        dialog.resize(width, height)
        
        # Set icon
        try:
            from PySide6.QtGui import QIcon
            if hasattr(self, 'base_dir'):
                base_dir = self.base_dir
            else:
                base_dir = getattr(sys, '_MEIPASS', os.path.dirname(os.path.abspath(__file__)))
            ico_path = os.path.join(base_dir, 'Halgakos.ico')
            if os.path.isfile(ico_path):
                dialog.setWindowIcon(QIcon(ico_path))
        except Exception as e:
            print(f"Failed to load icon: {e}")
        
        dialog_layout = QVBoxLayout(dialog)
        
        # Create listbox (QListWidget has built-in scrolling)
        listbox = QListWidget()
        listbox.setSelectionMode(QListWidget.ExtendedSelection)
        # Use 16% of screen width (half of original ~31% for 1920px screen)
        min_width, _ = self._get_dialog_size(0.16, 0)
        listbox.setMinimumWidth(min_width)
        dialog_layout.addWidget(listbox)
        
        # Keep track of file info
        file_info = []
        
        # Add translated HTML files
        for html_file in sorted(set(html_files)):  # Use set to avoid duplicates
            # Extract original image name from HTML filename
            # Expected format: response_001_imagename.html
            match = re.match(r'response_(\d+)_(.+)\.html', html_file)
            if match:
                index = match.group(1)
                base_name = match.group(2)
                display = f"📄 Image {index} | {base_name} | ✅ Completed"
            else:
                display = f"📄 {html_file} | ✅ Completed"
            
            listbox.addItem(display)
            
            # Find the hash key for this file if progress tracking exists
            hash_key = None
            if progress_data:
                for key, value in progress_data.items():
                    if isinstance(value, dict) and 'output_file' in value:
                        if html_file in value['output_file']:
                            hash_key = key
                            break
            
            file_info.append({
                'type': 'translated',
                'file': html_file,
                'path': os.path.join(output_dir, html_file),
                'hash_key': hash_key,
                'output_dir': output_dir  # Store for later use
            })
        
        # Add cover images
        for img_file in sorted(image_files):
            display = f"🖼️ Cover | {img_file} | ⏭️ Skipped (cover)"
            listbox.addItem(display)
            file_info.append({
                'type': 'cover',
                'file': img_file,
                'path': os.path.join(images_dir, img_file),
                'hash_key': None,
                'output_dir': output_dir
            })
        
        # Selection count label
        selection_count_label = QLabel("Selected: 0")
        selection_font = QFont('Arial', 10)
        selection_count_label.setFont(selection_font)
        dialog_layout.addWidget(selection_count_label)
        
        def update_selection_count():
            count = len(listbox.selectedItems())
            selection_count_label.setText(f"Selected: {count}")
        
        listbox.itemSelectionChanged.connect(update_selection_count)

        # ==== Context menu for image list ====
        def _open_file_for_index(idx):
            info_list = refresh_data.get('file_info', file_info)
            if idx < 0 or idx >= len(info_list):
                return
            info = info_list[idx]
            path = info.get('path')
            if not path or not os.path.exists(path):
                self._show_message('error', "File Missing", f"File not found:\n{path}", parent=dialog)
                return
            try:
                QDesktopServices.openUrl(QUrl.fromLocalFile(path))
            except Exception as e:
                self._show_message('error', "Open Failed", str(e), parent=dialog)

        def _show_context_menu(pos):
            item = listbox.itemAt(pos)
            if not item:
                return
            row = listbox.row(item)
            menu = QMenu(listbox)
            menu.setStyleSheet(
                "QMenu {"
                "  padding: 4px;"
                "  background-color: #2b2b2b;"
                "  color: white;"
                "  border: 1px solid #5a9fd4;"
                "} "
                "QMenu::icon { width: 0px; } "
                "QMenu::item {"
                "  padding: 6px 12px;"
                "  background-color: transparent;"
                "} "
                "QMenu::item:selected {"
                "  background-color: #17a2b8;"
                "  color: white;"
                "} "
                "QMenu::item:pressed {"
                "  background-color: #138496;"
                "}"
            )
            act_open = menu.addAction("📂 Open File")
            act_delete = menu.addAction("🔁 Delete / Retranslate")
            chosen = menu.exec(listbox.mapToGlobal(pos))
            if chosen == act_open:
                _open_file_for_index(row)
            elif chosen == act_delete:
                retranslate_selected()

        listbox.setContextMenuPolicy(Qt.CustomContextMenu)
        listbox.customContextMenuRequested.connect(_show_context_menu)
        
        # Button frame
        button_frame = QWidget()
        button_layout = QGridLayout(button_frame)
        dialog_layout.addWidget(button_frame)
        
        def select_all():
            listbox.selectAll()
            update_selection_count()
        
        def clear_selection():
            listbox.clearSelection()
            update_selection_count()
        
        def select_translated():
            listbox.clearSelection()
            for idx, info in enumerate(file_info):
                if info['type'] == 'translated':
                    listbox.item(idx).setSelected(True)
            update_selection_count()
        
        def mark_as_skipped():
            """Move selected images to the images folder to be skipped"""
            selected_items = listbox.selectedItems()
            if not selected_items:
                QMessageBox.warning(self, "No Selection", "Please select at least one image to mark as skipped.")
                return
            
            # Get all selected items
            selected_indices = [listbox.row(item) for item in selected_items]
            items_with_info = [(i, file_info[i]) for i in selected_indices]
            
            # Filter out items already in images folder (covers)
            items_to_move = [(i, item) for i, item in items_with_info if item['type'] != 'cover']
            
            if not items_to_move:
                QMessageBox.information(self, "Info", "Selected items are already in the images folder (skipped).")
                return
            
            count = len(items_to_move)
            reply = QMessageBox.question(self, "Confirm Mark as Skipped", 
                                      f"Move {count} translated image(s) to the images folder?\n\n"
                                      "This will:\n"
                                      "• Delete the translated HTML files\n"
                                      "• Copy source images to the images folder\n"
                                      "• Skip these images in future translations",
                                      QMessageBox.Yes | QMessageBox.No)
            if reply != QMessageBox.Yes:
                return
            
            # Create images directory if it doesn't exist
            images_dir = os.path.join(output_dir, "images")
            os.makedirs(images_dir, exist_ok=True)
            
            moved_count = 0
            failed_count = 0
            
            for idx, item in items_to_move:
                try:
                    # Extract the original image name from the HTML filename
                    # Expected format: response_001_imagename.html (also accept compound extensions)
                    html_file = item['file']
                    match = re.match(r'^response_\d+_([^\.]*)\.(?:html?|xhtml|htm)(?:\.xhtml)?$', html_file, re.IGNORECASE)
                    
                    if match:
                        base_name = match.group(1)
                        # Try to find the original image with common extensions
                        original_found = False
                        
                        # Look for the source image in multiple locations
                        search_paths = [
                            folder_path,  # Original folder path
                            os.path.dirname(folder_path),  # Parent of folder path
                            os.getcwd(),  # Script directory
                        ]
                        
                        for ext in ['.png', '.jpg', '.jpeg', '.gif', '.bmp', '.webp']:
                            for search_path in search_paths:
                                if not search_path or not os.path.exists(search_path):
                                    continue
                                    
                                # Check in the search path
                                possible_source = os.path.join(search_path, base_name + ext)
                                if os.path.exists(possible_source) and os.path.isfile(possible_source):
                                    # Copy to images folder
                                    dest_path = os.path.join(images_dir, base_name + ext)
                                    if not os.path.exists(dest_path):
                                        import shutil
                                        shutil.copy2(possible_source, dest_path)
                                        print(f"Copied {base_name + ext} from {possible_source} to images folder")
                                    original_found = True
                                    break
                            if original_found:
                                break
                        
                        if not original_found:
                            print(f"Warning: Could not find original image for {html_file} in: {search_paths}")
                            # Even if source not found, we can still delete the HTML and mark it
                    
                    # Delete the HTML translation file
                    if os.path.exists(item['path']):
                        os.remove(item['path'])
                        print(f"Deleted translation: {item['path']}")
                        
                        # Remove from progress tracking if applicable
                        if progress_data and item.get('hash_key'):
                            hash_key = item['hash_key']
                            # Check nested structure first
                            if 'images' in progress_data and hash_key in progress_data['images']:
                                del progress_data['images'][hash_key]
                            # Check flat structure
                            elif hash_key in progress_data:
                                del progress_data[hash_key]
                    
                    # Update the listbox display
                    display = f"🖼️ Skipped | {base_name if match else item['file']} | ⏭️ Moved to images folder"
                    listbox.item(idx).setText(display)
                    
                    # Update file_info
                    file_info[idx] = {
                        'type': 'cover',  # Treat as cover type since it's in images folder
                        'file': base_name + ext if match and original_found else item['file'],
                        'path': os.path.join(images_dir, base_name + ext if match and original_found else item['file']),
                        'hash_key': None,
                        'output_dir': output_dir
                    }
                    
                    moved_count += 1
                    
                except Exception as e:
                    print(f"Failed to process {item['file']}: {e}")
                    failed_count += 1
            
            # Save updated progress if modified
            if progress_data:
                try:
                    with open(progress_file, 'w', encoding='utf-8') as f:
                        json.dump(progress_data, f, ensure_ascii=False, indent=2)
                    print(f"Updated progress tracking file")
                except Exception as e:
                    print(f"Failed to update progress file: {e}")
            
            # Auto-refresh the display to show updated status
            if 'refresh_data' in locals():
                self._refresh_image_folder_data(refresh_data)
            
            # Update selection count
            update_selection_count()
            
            # Show result
            if failed_count > 0:
                QMessageBox.warning(self, "Partial Success", 
                    f"Moved {moved_count} image(s) to be skipped.\n"
                    f"Failed to process {failed_count} item(s).")
            else:
                QMessageBox.information(self, "Success", 
                    f"Moved {moved_count} image(s) to the images folder.\n"
                    "They will be skipped in future translations.")
        
        def retranslate_selected():
            selected_items = listbox.selectedItems()
            if not selected_items:
                QMessageBox.warning(self, "No Selection", "Please select at least one file.")
                return
            
            selected_indices = [listbox.row(item) for item in selected_items]
            
            # Count types
            translated_count = sum(1 for i in selected_indices if file_info[i]['type'] == 'translated')
            cover_count = sum(1 for i in selected_indices if file_info[i]['type'] == 'cover')
            
            # Build confirmation message
            msg_parts = []
            if translated_count > 0:
                msg_parts.append(f"{translated_count} translated image(s)")
            if cover_count > 0:
                msg_parts.append(f"{cover_count} cover image(s)")
            
            confirm_msg = f"This will delete {' and '.join(msg_parts)}.\n\nContinue?"
            
            reply = QMessageBox.question(self, "Confirm Deletion", confirm_msg,
                                       QMessageBox.Yes | QMessageBox.No)
            if reply != QMessageBox.Yes:
                return
            
            # Delete selected files
            deleted_count = 0
            
            for idx in selected_indices:
                info = file_info[idx]
                try:
                    if os.path.exists(info['path']):
                        os.remove(info['path'])
                        deleted_count += 1
                        print(f"Deleted: {info['path']}")
                        
                        # Remove from progress tracking if applicable
                        if progress_data and info.get('hash_key'):
                            hash_key = info['hash_key']
                            # Check nested structure first
                            if 'images' in progress_data and hash_key in progress_data['images']:
                                del progress_data['images'][hash_key]
                                print(f"Removed {hash_key} from progress_data['images']")
                            # Check flat structure
                            elif hash_key in progress_data:
                                del progress_data[hash_key]
                                print(f"Removed {hash_key} from progress_data")
                            
                except Exception as e:
                    print(f"Failed to delete {info['path']}: {e}")
            
            # ALWAYS save progress file after any deletions
            if deleted_count > 0 and progress_data:
                try:
                    with open(progress_file, 'w', encoding='utf-8') as f:
                        json.dump(progress_data, f, ensure_ascii=False, indent=2)
                    print(f"Updated progress tracking file")
                except Exception as e:
                    print(f"Failed to update progress file: {e}")
            
            # Auto-refresh the display to show updated status
            if 'refresh_data' in locals():
                self._refresh_image_folder_data(refresh_data)
            
            QMessageBox.information(self, "Success", 
                f"Deleted {deleted_count} file(s).\n\n"
                "They will be retranslated on the next run.")
            
            dialog.close()
        
        # Add buttons in grid layout (similar to EPUB/text retranslation)
        # Row 0: Selection buttons
        btn_select_all = QPushButton("Select All")
        btn_select_all.setStyleSheet("QPushButton { background-color: #17a2b8; color: white; padding: 5px 15px; font-weight: bold; }")
        btn_select_all.clicked.connect(select_all)
        button_layout.addWidget(btn_select_all, 0, 0)
        
        btn_clear_selection = QPushButton("Clear Selection")
        btn_clear_selection.setStyleSheet("QPushButton { background-color: #6c757d; color: white; padding: 5px 15px; font-weight: bold; }")
        btn_clear_selection.clicked.connect(clear_selection)
        button_layout.addWidget(btn_clear_selection, 0, 1)
        
        btn_select_translated = QPushButton("Select Translated")
        btn_select_translated.setStyleSheet("QPushButton { background-color: #28a745; color: white; padding: 5px 15px; font-weight: bold; }")
        btn_select_translated.clicked.connect(select_translated)
        button_layout.addWidget(btn_select_translated, 0, 2)
        
        btn_mark_skipped = QPushButton("Mark as Skipped")
        btn_mark_skipped.setStyleSheet("QPushButton { background-color: #e0a800; color: white; padding: 5px 15px; font-weight: bold; }")
        btn_mark_skipped.clicked.connect(mark_as_skipped)
        button_layout.addWidget(btn_mark_skipped, 0, 3)
        
        # Row 1: Action buttons
        btn_delete = QPushButton("Delete Selected")
        btn_delete.setStyleSheet("QPushButton { background-color: #dc3545; color: white; padding: 5px 15px; font-weight: bold; }")
        btn_delete.clicked.connect(retranslate_selected)
        button_layout.addWidget(btn_delete, 1, 0, 1, 1)
        
        # Add animated refresh button
        btn_refresh = AnimatedRefreshButton("  Refresh")  # Double space for icon padding
        btn_refresh.setStyleSheet(
            "QPushButton { "
            "background-color: #17a2b8; "
            "color: white; "
            "padding: 5px 15px; "
            "font-weight: bold; "
            "}"
        )
        
        # Create data dict for refresh function
        refresh_data = {
            'type': 'image_folder',
            'listbox': listbox,
            'file_info': file_info,
            'progress_file': progress_file,
            'progress_data': progress_data,
            'output_dir': output_dir,
            'folder_path': folder_path,
            'selection_count_label': selection_count_label,
            'dialog': dialog
        }
        
        # Create refresh handler with animation
        def animated_refresh():
            import time
            btn_refresh.start_animation()
            btn_refresh.setEnabled(False)
            
            # Track start time for minimum animation duration
            start_time = time.time()
            min_animation_duration = 0.8  # 800ms minimum
            
            # Use QTimer to run refresh after animation starts
            def do_refresh():
                try:
                    self._refresh_image_folder_data(refresh_data)
                    
                    # Calculate remaining time to meet minimum animation duration
                    elapsed = time.time() - start_time
                    remaining = max(0, min_animation_duration - elapsed)
                    
                    # Schedule animation stop after remaining time
                    def finish_animation():
                        btn_refresh.stop_animation()
                        btn_refresh.setEnabled(True)
                    
                    if remaining > 0:
                        QTimer.singleShot(int(remaining * 1000), finish_animation)
                    else:
                        finish_animation()
                        
                except Exception as e:
                    print(f"Error during refresh: {e}")
                    btn_refresh.stop_animation()
                    btn_refresh.setEnabled(True)
            
            QTimer.singleShot(50, do_refresh)  # Small delay to let animation start
        
        btn_refresh.clicked.connect(animated_refresh)
        button_layout.addWidget(btn_refresh, 1, 1, 1, 1)
        # Store for reuse-trigger
        dialog._refresh_button = btn_refresh
        
        btn_cancel = QPushButton("Cancel")
        btn_cancel.setStyleSheet("QPushButton { background-color: #6c757d; color: white; padding: 5px 15px; font-weight: bold; }")
        btn_cancel.clicked.connect(dialog.close)
        button_layout.addWidget(btn_cancel, 1, 2, 1, 2)
        
        # Override close event to hide instead of destroy
        def closeEvent(event):
            event.ignore()  # Ignore the close event
            dialog.hide()   # Just hide the dialog
        
        dialog.closeEvent = closeEvent
        
        # Cache the dialog for reuse
        if not hasattr(self, '_image_retranslation_dialog_cache'):
            self._image_retranslation_dialog_cache = {}
        
        folder_key = os.path.abspath(folder_path)
        self._image_retranslation_dialog_cache[folder_key] = dialog
        
        # Programmatically click the Refresh button once on open to ensure latest data (fires same slot)
        QTimer.singleShot(0, btn_refresh.click)

        # Show the dialog (non-modal to allow interaction with other windows)
        dialog.show()