other_settings.py

"""Other Settings Dialog Methods for Glossarion

This module contains all the methods related to the "Other Settings" dialog.
These methods are dynamically injected into the TranslatorGUI class.
"""

# Standard library imports
import os
import json
import re
import tkinter as tk
from tkinter import ttk, messagebox, filedialog

# Third-party imports
import ttkbootstrap as tb

# Local imports - these will be available through the TranslatorGUI instance
# Import UIHelper and CONFIG_FILE from translator_gui for use in the methods
from translator_gui import UIHelper, CONFIG_FILE
from ai_hunter_enhanced import AIHunterConfigGUI


def setup_other_settings_methods(gui_instance):
    """Inject all other settings methods into the GUI instance"""
    import types
    import sys
    
    # Get this module
    current_module = sys.modules[__name__]
    
    # List of all method names to bind
    methods_to_bind = [
        # Core profile methods (needed at GUI init)
        'on_profile_select', 'save_profile', 'delete_profile', 'save_profiles',
        'import_profiles', 'export_profiles',
        # Other settings methods
        'configure_rolling_summary_prompts', 'toggle_thinking_budget', 
        'toggle_gpt_reasoning_controls', 'open_other_settings',
        'open_multi_api_key_manager', 'show_ai_hunter_settings',
        'delete_translated_headers_file', 'validate_epub_structure_gui',
        'on_extraction_method_change', 'on_extraction_mode_change',
        # Toggle methods
        'toggle_extraction_workers', 'toggle_gemini_endpoint', 'toggle_ai_hunter',
        'toggle_custom_endpoint_ui', 'toggle_more_endpoints',
        '_toggle_multi_key_setting', '_toggle_http_tuning_controls',
        '_toggle_anti_duplicate_controls',
        # Provider autocomplete methods
        '_setup_provider_combobox_bindings', '_on_provider_combo_keyrelease',
        '_commit_provider_autocomplete', '_scroll_provider_list_to_value',
        '_validate_provider_selection',
        # Section creation methods
        '_create_context_management_section', '_create_response_handling_section',
        '_create_prompt_management_section', '_create_processing_options_section',
        '_create_image_translation_section', '_create_anti_duplicate_section',
        '_create_custom_api_endpoints_section', '_create_settings_buttons',
        # Helper methods
        '_create_multi_key_row', '_create_manual_config_backup', '_manual_restore_config',
        '_check_azure_endpoint', '_update_azure_api_version_env',
        '_reset_anti_duplicate_defaults', '_get_ai_hunter_status_text',
        'create_ai_hunter_section', 'test_api_connections'
    ]
    
    # Bind each method to the GUI instance
    for method_name in methods_to_bind:
        if hasattr(current_module, method_name):
            method = getattr(current_module, method_name)
            if callable(method):
                setattr(gui_instance, method_name, types.MethodType(method, gui_instance))


def configure_rolling_summary_prompts(self):
   """Configure rolling summary prompts"""
   dialog = self.wm.create_simple_dialog(
       self.master,
       "Configure Memory System Prompts",
       width=800,
       height=1050
   )
   
   main_frame = tk.Frame(dialog, padx=20, pady=20)
   main_frame.pack(fill=tk.BOTH, expand=True)
   
   tk.Label(main_frame, text="Memory System Configuration", 
           font=('TkDefaultFont', 14, 'bold')).pack(anchor=tk.W, pady=(0, 5))
   
   tk.Label(main_frame, text="Configure how the AI creates and maintains translation memory/context summaries.",
           font=('TkDefaultFont', 10), fg='gray').pack(anchor=tk.W, pady=(0, 15))
   
   system_frame = tk.LabelFrame(main_frame, text="System Prompt (Role Definition)", padx=10, pady=10)
   system_frame.pack(fill=tk.BOTH, expand=True, pady=(0, 10))
   
   tk.Label(system_frame, text="Defines the AI's role and behavior when creating summaries",
           font=('TkDefaultFont', 9), fg='blue').pack(anchor=tk.W, pady=(0, 5))
   
   self.summary_system_text = self.ui.setup_scrollable_text(
       system_frame, height=5, wrap=tk.WORD
   )
   self.summary_system_text.pack(fill=tk.BOTH, expand=True)
   self.summary_system_text.insert('1.0', self.rolling_summary_system_prompt)
   
   user_frame = tk.LabelFrame(main_frame, text="User Prompt Template", padx=10, pady=10)
   user_frame.pack(fill=tk.BOTH, expand=True, pady=(0, 10))
   
   tk.Label(user_frame, text="Template for summary requests. Use {translations} for content placeholder",
           font=('TkDefaultFont', 9), fg='blue').pack(anchor=tk.W, pady=(0, 5))
   
   self.summary_user_text = self.ui.setup_scrollable_text(
       user_frame, height=12, wrap=tk.WORD
   )
   self.summary_user_text.pack(fill=tk.BOTH, expand=True)
   self.summary_user_text.insert('1.0', self.rolling_summary_user_prompt)
   
   button_frame = tk.Frame(main_frame)
   button_frame.pack(fill=tk.X, pady=(10, 0))
   
   def save_prompts():
       self.rolling_summary_system_prompt = self.summary_system_text.get('1.0', tk.END).strip()
       self.rolling_summary_user_prompt = self.summary_user_text.get('1.0', tk.END).strip()
       
       self.config['rolling_summary_system_prompt'] = self.rolling_summary_system_prompt
       self.config['rolling_summary_user_prompt'] = self.rolling_summary_user_prompt
       
       os.environ['ROLLING_SUMMARY_SYSTEM_PROMPT'] = self.rolling_summary_system_prompt
       os.environ['ROLLING_SUMMARY_USER_PROMPT'] = self.rolling_summary_user_prompt
       
       messagebox.showinfo("Success", "Memory prompts saved!")
       dialog.destroy()
   
   def reset_prompts():
       if messagebox.askyesno("Reset Prompts", "Reset memory prompts to defaults?"):
           self.summary_system_text.delete('1.0', tk.END)
           self.summary_system_text.insert('1.0', self.default_rolling_summary_system_prompt)
           self.summary_user_text.delete('1.0', tk.END)
           self.summary_user_text.insert('1.0', self.default_rolling_summary_user_prompt)
   
   tb.Button(button_frame, text="Save", command=save_prompts, 
            bootstyle="success", width=15).pack(side=tk.LEFT, padx=5)
   tb.Button(button_frame, text="Reset to Defaults", command=reset_prompts, 
            bootstyle="warning", width=15).pack(side=tk.LEFT, padx=5)
   tb.Button(button_frame, text="Cancel", command=dialog.destroy, 
            bootstyle="secondary", width=15).pack(side=tk.LEFT, padx=5)
   
   dialog.deiconify()

def toggle_thinking_budget(self):
    """Enable/disable thinking budget entry based on checkbox state"""
    if hasattr(self, 'thinking_budget_entry'):
        if self.enable_gemini_thinking_var.get():
            self.thinking_budget_entry.config(state='normal')
        else:
            self.thinking_budget_entry.config(state='disabled')

def toggle_gpt_reasoning_controls(self):
    """Enable/disable GPT reasoning controls based on toggle state"""
    enabled = self.enable_gpt_thinking_var.get()
    # Tokens entry
    if hasattr(self, 'gpt_reasoning_tokens_entry'):
        self.gpt_reasoning_tokens_entry.config(state='normal' if enabled else 'disabled')
    # Effort combo
    if hasattr(self, 'gpt_effort_combo'):
        try:
            self.gpt_effort_combo.config(state='readonly' if enabled else 'disabled')
        except Exception:
            # Fallback for ttk on some platforms
            self.gpt_effort_combo.configure(state='readonly' if enabled else 'disabled')

def open_other_settings(self):
    """Open the Other Settings dialog"""
    dialog, scrollable_frame, canvas = self.wm.setup_scrollable(
        self.master,
        "Other Settings",
        width=0,
        height=None,
        max_width_ratio=0.7,
        max_height_ratio=0.8
    )
    
    scrollable_frame.grid_columnconfigure(0, weight=1, uniform="column")
    scrollable_frame.grid_columnconfigure(1, weight=1, uniform="column")
    
    # Section 1: Context Management
    self._create_context_management_section(scrollable_frame)
    
    # Section 2: Response Handling
    self._create_response_handling_section(scrollable_frame)
    
    # Section 3: Prompt Management
    self._create_prompt_management_section(scrollable_frame)
    
    # Section 4: Processing Options
    self._create_processing_options_section(scrollable_frame)
    
    # Section 5: Image Translation
    self._create_image_translation_section(scrollable_frame)
    
    # Section 6: Anti-Duplicate Parameters
    self._create_anti_duplicate_section(scrollable_frame)
    
    # Section 7: Custom API Endpoints (NEW)
    self._create_custom_api_endpoints_section(scrollable_frame)
    
    # Save & Close buttons
    self._create_settings_buttons(scrollable_frame, dialog, canvas)
    
    # Persist toggle change on dialog close
    def _persist_settings():
        self.config['retain_source_extension'] = self.retain_source_extension_var.get()
        os.environ['RETAIN_SOURCE_EXTENSION'] = '1' if self.retain_source_extension_var.get() else '0'
        # Save without user-facing message when closing Other Settings
        self.save_config(show_message=False)
        dialog._cleanup_scrolling()
        dialog.destroy()
    dialog.protocol("WM_DELETE_WINDOW", _persist_settings)
    
    # Auto-resize and show
    self.wm.auto_resize_dialog(dialog, canvas, max_width_ratio=0.78, max_height_ratio=1.82)

def _create_context_management_section(self, parent):
    """Create context management section"""
    section_frame = tk.LabelFrame(parent, text="Context Management & Memory", padx=10, pady=10)
    section_frame.grid(row=0, column=1, sticky="nsew", padx=(5, 10), pady=(10, 5))
       
    content_frame = tk.Frame(section_frame)
    content_frame.pack(anchor=tk.NW, fill=tk.BOTH, expand=True)

    tb.Checkbutton(content_frame, text="Use Rolling Summary (Memory)", 
                 variable=self.rolling_summary_var,
                 bootstyle="round-toggle").pack(anchor=tk.W)

    tk.Label(content_frame, text="AI-powered memory system that maintains story context",
           font=('TkDefaultFont', 10), fg='gray', justify=tk.LEFT).pack(anchor=tk.W, padx=20, pady=(0, 10))

    settings_frame = tk.Frame(content_frame)
    settings_frame.pack(anchor=tk.W, padx=20, fill=tk.X, pady=(5, 10))

    row1 = tk.Frame(settings_frame)
    row1.pack(fill=tk.X, pady=(0, 10))

    tk.Label(row1, text="Role:").pack(side=tk.LEFT, padx=(0, 5))
    role_combo = ttk.Combobox(row1, textvariable=self.summary_role_var,
               values=["user", "system"], state="readonly", width=10)
    role_combo.pack(side=tk.LEFT, padx=(0, 30))
    # Prevent accidental changes from mouse wheel while scrolling
    UIHelper.disable_spinbox_mousewheel(role_combo)

    tk.Label(row1, text="Mode:").pack(side=tk.LEFT, padx=(0, 5))
    mode_combo = ttk.Combobox(row1, textvariable=self.rolling_summary_mode_var,
               values=["append", "replace"], state="readonly", width=10)
    mode_combo.pack(side=tk.LEFT, padx=(0, 10))
    # Prevent accidental changes from mouse wheel while scrolling
    UIHelper.disable_spinbox_mousewheel(mode_combo)

    row2 = tk.Frame(settings_frame)
    row2.pack(fill=tk.X, pady=(0, 10))

    tk.Label(row2, text="Summarize last").pack(side=tk.LEFT, padx=(0, 5))
    tb.Entry(row2, width=5, textvariable=self.rolling_summary_exchanges_var).pack(side=tk.LEFT, padx=(0, 5))
    tk.Label(row2, text="exchanges").pack(side=tk.LEFT)

    # Spacer
    tk.Label(row2, text="   ").pack(side=tk.LEFT)
    # New controls: Retain last N summaries (append mode)
    tk.Label(row2, text="Retain").pack(side=tk.LEFT, padx=(10, 5))
    tb.Entry(row2, width=5, textvariable=self.rolling_summary_max_entries_var).pack(side=tk.LEFT, padx=(0, 5))
    tk.Label(row2, text="entries").pack(side=tk.LEFT)

    tb.Button(content_frame, text="⚙️ Configure Memory Prompts", 
            command=self.configure_rolling_summary_prompts,
            bootstyle="info-outline", width=30).pack(anchor=tk.W, padx=20, pady=(10, 10))

    ttk.Separator(section_frame, orient='horizontal').pack(fill=tk.X, pady=(10, 10))
    
    tk.Label(section_frame, text="💡 Memory Mode:\n"
           "• Append: Keeps adding summaries (longer context)\n"
           "• Replace: Only keeps latest summary (concise)",
           font=('TkDefaultFont', 11), fg='#666', justify=tk.LEFT).pack(anchor=tk.W, padx=5, pady=(0, 5))       

    ttk.Separator(section_frame, orient='horizontal').pack(fill=tk.X, pady=(10, 10))
           
    
    tk.Label(section_frame, text="Application Updates:", font=('TkDefaultFont', 11, 'bold')).pack(anchor=tk.W, pady=(5, 5))
    
    # Create a frame for update-related controls
    update_frame = tk.Frame(section_frame)
    update_frame.pack(anchor=tk.W, fill=tk.X)

    tb.Button(update_frame, text="🔄 Check for Updates", 
             command=lambda: self.check_for_updates_manual(), 
             bootstyle="info-outline",
             width=25).pack(side=tk.LEFT, pady=2)

    # Add auto-update checkbox
    tb.Checkbutton(update_frame, text="Check on startup", 
                 variable=self.auto_update_check_var, 
                 bootstyle="round-toggle").pack(side=tk.LEFT, padx=(10, 0))

    tk.Label(section_frame, text="Check GitHub for new Glossarion releases\nand download updates",
            font=('TkDefaultFont', 10), fg='gray', justify=tk.LEFT).pack(anchor=tk.W, pady=(0, 5))
                 
    ttk.Separator(section_frame, orient='horizontal').pack(fill=tk.X, pady=(10, 10))
    
    tk.Label(section_frame, text="Config Backup Management:", font=('TkDefaultFont', 11, 'bold')).pack(anchor=tk.W, pady=(5, 5))
    
    # Create a frame for backup-related controls
    backup_frame = tk.Frame(section_frame)
    backup_frame.pack(anchor=tk.W, fill=tk.X)

    tb.Button(backup_frame, text="💾 Create Backup", 
             command=lambda: self._create_manual_config_backup(), 
             bootstyle="success-outline",
             width=20).pack(side=tk.LEFT, pady=2, padx=(0, 10))
             
    tb.Button(backup_frame, text="↶ Restore Backup", 
             command=lambda: self._manual_restore_config(), 
             bootstyle="warning-outline",
             width=20).pack(side=tk.LEFT, pady=2)

    tk.Label(section_frame, text="Automatic backups are created before each config save.",
           font=('TkDefaultFont', 10), fg='gray', justify=tk.LEFT).pack(anchor=tk.W, padx=5, pady=(5, 0))

def _create_response_handling_section(self, parent):
    """Create response handling section with AI Hunter additions"""
    section_frame = tk.LabelFrame(parent, text="Response Handling & Retry Logic", padx=10, pady=10)
    section_frame.grid(row=1, column=0, sticky="nsew", padx=(10, 5), pady=5)
    
    # GPT-5/OpenAI Reasoning Toggle (NEW)
    tk.Label(section_frame, text="GPT-5 Thinking (OpenRouter/OpenAI-style)", 
            font=('TkDefaultFont', 11, 'bold')).pack(anchor=tk.W)

    gpt_frame = tk.Frame(section_frame)
    gpt_frame.pack(anchor=tk.W, padx=20, pady=(5, 0))

    tb.Checkbutton(gpt_frame, text="Enable GPT / OR Thinking", 
                  variable=self.enable_gpt_thinking_var,
                  bootstyle="round-toggle",
                  command=self.toggle_gpt_reasoning_controls).pack(side=tk.LEFT)

    tk.Label(gpt_frame, text="Effort:").pack(side=tk.LEFT, padx=(20, 5))
    self.gpt_effort_combo = ttk.Combobox(gpt_frame, textvariable=self.gpt_effort_var,
                                         values=["low", "medium", "high"], state="readonly", width=8)
    self.gpt_effort_combo.pack(side=tk.LEFT, padx=5)
    UIHelper.disable_spinbox_mousewheel(self.gpt_effort_combo)

    # Second row for OpenRouter-specific token budget
    gpt_row2 = tk.Frame(section_frame)
    gpt_row2.pack(anchor=tk.W, padx=40, pady=(5, 0))
    tk.Label(gpt_row2, text="OR Thinking Tokens:").pack(side=tk.LEFT)
    self.gpt_reasoning_tokens_entry = tb.Entry(gpt_row2, width=8, textvariable=self.gpt_reasoning_tokens_var)
    self.gpt_reasoning_tokens_entry.pack(side=tk.LEFT, padx=5)
    tk.Label(gpt_row2, text="tokens").pack(side=tk.LEFT)

    # Initialize enabled state for GPT controls
    self.toggle_gpt_reasoning_controls()

    tk.Label(section_frame, text="Controls GPT-5 and OpenRouter reasoning. \nProvide Tokens to force a max token budget for other models; GPT-5 only uses Effort (low/medium/high).",
           font=('TkDefaultFont', 10), fg='gray', justify=tk.LEFT).pack(anchor=tk.W, padx=20, pady=(0, 10))

    # Add Thinking Tokens Toggle with Budget Control (NEW)
    tk.Label(section_frame, text="Gemini Thinking Mode", 
            font=('TkDefaultFont', 11, 'bold')).pack(anchor=tk.W)
    
    thinking_frame = tk.Frame(section_frame)
    thinking_frame.pack(anchor=tk.W, padx=20, pady=(5, 0))
    
    tb.Checkbutton(thinking_frame, text="Enable Gemini Thinking", 
                  variable=self.enable_gemini_thinking_var,
                  bootstyle="round-toggle",
                  command=self.toggle_thinking_budget).pack(side=tk.LEFT)
    
    tk.Label(thinking_frame, text="Budget:").pack(side=tk.LEFT, padx=(20, 5))
    self.thinking_budget_entry = tb.Entry(thinking_frame, width=8, textvariable=self.thinking_budget_var)
    self.thinking_budget_entry.pack(side=tk.LEFT, padx=5)
    tk.Label(thinking_frame, text="tokens").pack(side=tk.LEFT)
    
    tk.Label(section_frame, text="Control Gemini's thinking process. 0 = disabled,\n512-24576 = limited thinking, -1 = dynamic (auto)",
           font=('TkDefaultFont', 10), fg='gray', justify=tk.LEFT).pack(anchor=tk.W, padx=20, pady=(0, 10))
    
    # Add separator after thinking toggle
    ttk.Separator(section_frame, orient='horizontal').pack(fill='x', pady=10)
    
    # ADD EXTRACTION WORKERS CONFIGURATION HERE
    tk.Label(section_frame, text="Parallel Extraction", 
            font=('TkDefaultFont', 11, 'bold')).pack(anchor=tk.W)
    
    extraction_frame = tk.Frame(section_frame)
    extraction_frame.pack(anchor=tk.W, padx=20, pady=(5, 0))
    
    tb.Checkbutton(extraction_frame, text="Enable Parallel Processing", 
                  variable=self.enable_parallel_extraction_var,
                  bootstyle="round-toggle",
                  command=self.toggle_extraction_workers).pack(side=tk.LEFT)
    
    tk.Label(extraction_frame, text="Workers:").pack(side=tk.LEFT, padx=(20, 5))
    self.extraction_workers_entry = tb.Entry(extraction_frame, width=6, textvariable=self.extraction_workers_var)
    self.extraction_workers_entry.pack(side=tk.LEFT, padx=5)
    tk.Label(extraction_frame, text="threads").pack(side=tk.LEFT)
    
    tk.Label(section_frame, text="Speed up EPUB extraction using multiple threads.\nRecommended: 4-8 workers (set to 1 to disable)",
           font=('TkDefaultFont', 10), fg='gray', justify=tk.LEFT).pack(anchor=tk.W, padx=20, pady=(0, 10))
    
    # GUI Yield Toggle (below parallel extraction)
    gui_yield_frame = tk.Frame(section_frame)
    gui_yield_frame.pack(anchor=tk.W, padx=20, pady=(5, 0))
    
    tb.Checkbutton(gui_yield_frame, text="Enable GUI Responsiveness Yield", 
                  variable=self.enable_gui_yield_var,
                  bootstyle="round-toggle").pack(side=tk.LEFT)
    
    tk.Label(section_frame, text="Adds small delays during extraction to keep GUI responsive.\n⚠️ Disable for maximum extraction speed (GUI may freeze temporarily)",
           font=('TkDefaultFont', 10), fg='gray', justify=tk.LEFT).pack(anchor=tk.W, padx=20, pady=(5, 10))
    
    # Add separator after extraction workers
    ttk.Separator(section_frame, orient='horizontal').pack(fill='x', pady=10)
    
    # Multi API Key Management Section
    multi_key_frame = tk.Frame(section_frame)
    multi_key_frame.pack(anchor=tk.W, fill=tk.X, pady=(0, 15))
    
    # Multi-key indicator and button in same row
    multi_key_row = tk.Frame(multi_key_frame)
    multi_key_row.pack(fill=tk.X)
    
    # Show status if multi-key is enabled
    if self.config.get('use_multi_api_keys', False):
        multi_keys = self.config.get('multi_api_keys', [])
        active_keys = sum(1 for k in multi_keys if k.get('enabled', True))
        
        status_frame = tk.Frame(multi_key_row)
        status_frame.pack(side=tk.LEFT, fill=tk.X, expand=True)
        
        tk.Label(status_frame, text="🔑 Multi-Key Mode:", 
                font=('TkDefaultFont', 11, 'bold')).pack(side=tk.LEFT)
        
        tk.Label(status_frame, text=f"ACTIVE ({active_keys}/{len(multi_keys)} keys)", 
                font=('TkDefaultFont', 11, 'bold'), fg='green').pack(side=tk.LEFT, padx=(5, 0))
    else:
        tk.Label(multi_key_row, text="🔑 Multi-Key Mode: DISABLED", 
                font=('TkDefaultFont', 11), fg='gray').pack(side=tk.LEFT)
    
    # Multi API Key Manager button
    tb.Button(multi_key_row, text="Configure API Keys", 
              command=self.open_multi_api_key_manager,
              bootstyle="primary-outline",
              width=20).pack(side=tk.RIGHT)
    
    tk.Label(section_frame, text="Manage multiple API keys with automatic rotation and rate limit handling",
             font=('TkDefaultFont', 10), fg='gray', justify=tk.LEFT).pack(anchor=tk.W, padx=20, pady=(0, 10))
    
    # Add separator after Multi API Key section
    ttk.Separator(section_frame, orient='horizontal').pack(fill='x', pady=10)
 
    # Retry Truncated
    tb.Checkbutton(section_frame, text="Auto-retry Truncated Responses", 
                      variable=self.retry_truncated_var,
                      bootstyle="round-toggle").pack(anchor=tk.W)
    retry_frame = tk.Frame(section_frame)
    retry_frame.pack(anchor=tk.W, padx=20, pady=(5, 5))
    tk.Label(retry_frame, text="Token constraint:").pack(side=tk.LEFT)
    tb.Entry(retry_frame, width=8, textvariable=self.max_retry_tokens_var).pack(side=tk.LEFT, padx=5)
    tk.Label(section_frame, text="Retry when truncated. Acts as min/max constraint:\nbelow value = minimum, above value = maximum",
               font=('TkDefaultFont', 10), fg='gray', justify=tk.LEFT).pack(anchor=tk.W, padx=20, pady=(0, 10))
    # Compression Factor
    # Add separator line for clarity
    ttk.Separator(section_frame, orient='horizontal').pack(fill='x', pady=10)
    
    # Compression Factor
    tk.Label(section_frame, text="Translation Compression Factor", 
                font=('TkDefaultFont', 11, 'bold')).pack(anchor=tk.W)
    
    compression_frame = tk.Frame(section_frame)
    compression_frame.pack(anchor=tk.W, padx=20, pady=(5, 0))
    tk.Label(compression_frame, text="CJK→English compression:").pack(side=tk.LEFT)
    tb.Entry(compression_frame, width=6, textvariable=self.compression_factor_var).pack(side=tk.LEFT, padx=5)
    tk.Label(compression_frame, text="(0.7-1.0)", font=('TkDefaultFont', 11)).pack(side=tk.LEFT)
    
    # TODO: Implement configure_translation_chunk_prompt method
    # tb.Button(compression_frame, text=" Chunk Prompt", 
    #              command=self.configure_translation_chunk_prompt,
    #              bootstyle="info-outline", width=15).pack(side=tk.LEFT, padx=(15, 0))
    tk.Label(section_frame, text="Ratio for chunk sizing based on output limits\n",
               font=('TkDefaultFont', 10), fg='gray', justify=tk.LEFT).pack(anchor=tk.W, padx=20, pady=(0, 10))
   
    # Add separator after compression factor
    ttk.Separator(section_frame, orient='horizontal').pack(fill='x', pady=10)
    
    # Retry Duplicate
    tb.Checkbutton(section_frame, text="Auto-retry Duplicate Content", 
                     variable=self.retry_duplicate_var,
                     bootstyle="round-toggle").pack(anchor=tk.W)
    duplicate_frame = tk.Frame(section_frame)
    duplicate_frame.pack(anchor=tk.W, padx=20, pady=(5, 0))
    tk.Label(duplicate_frame, text="Check last").pack(side=tk.LEFT)
    tb.Entry(duplicate_frame, width=4, textvariable=self.duplicate_lookback_var).pack(side=tk.LEFT, padx=3)
    tk.Label(duplicate_frame, text="chapters").pack(side=tk.LEFT)
    tk.Label(section_frame, text="Detects when AI returns same content\nfor different chapters",
               font=('TkDefaultFont', 10), fg='gray', justify=tk.LEFT).pack(anchor=tk.W, padx=20, pady=(5, 10))
    # Container for detection-related options (to show/hide based on toggle)
    self.detection_options_container = tk.Frame(section_frame)
    
    # Update thinking budget entry state based on initial toggle state
    self.toggle_thinking_budget()

    # Function to show/hide detection options based on auto-retry toggle
    def update_detection_visibility():
        try:
            # Check if widgets still exist before manipulating them
            if (hasattr(self, 'detection_options_container') and 
                self.detection_options_container.winfo_exists() and
                duplicate_frame.winfo_exists()):
                
                if self.retry_duplicate_var.get():
                    self.detection_options_container.pack(fill='x', after=duplicate_frame)
                else:
                    self.detection_options_container.pack_forget()
        except tk.TclError:
            # Widget has been destroyed, ignore
            pass

    # Add trace to update visibility when toggle changes
    self.retry_duplicate_var.trace('w', lambda *args: update_detection_visibility())

    # Detection Method subsection (now inside the container)
    method_label = tk.Label(self.detection_options_container, text="Detection Method:", 
                           font=('TkDefaultFont', 10, 'bold'))
    method_label.pack(anchor=tk.W, padx=20, pady=(10, 5))

    methods = [
       ("basic", "Basic (Fast) - Original 85% threshold, 1000 chars"),
       ("ai-hunter", "AI Hunter - Multi-method semantic analysis"),
       ("cascading", "Cascading - Basic first, then AI Hunter")
    ]

    # Container for AI Hunter config (will be shown/hidden based on selection)
    self.ai_hunter_container = tk.Frame(self.detection_options_container)

    # Function to update AI Hunter visibility based on detection mode
    def update_ai_hunter_visibility(*args):
        """Update AI Hunter section visibility based on selection"""
        # Clear existing widgets
        for widget in self.ai_hunter_container.winfo_children():
            widget.destroy()
        
        # Show AI Hunter config for both ai-hunter and cascading modes
        if self.duplicate_detection_mode_var.get() in ['ai-hunter', 'cascading']:
            self.create_ai_hunter_section(self.ai_hunter_container)
        
        # Update status if label exists and hasn't been destroyed
        if hasattr(self, 'ai_hunter_status_label'):
            try:
                # Check if the widget still exists before updating
                self.ai_hunter_status_label.winfo_exists()
                self.ai_hunter_status_label.config(text=self._get_ai_hunter_status_text())
            except tk.TclError:
                # Widget has been destroyed, remove the reference
                delattr(self, 'ai_hunter_status_label')

    # Create radio buttons (inside detection container) - ONLY ONCE
    for value, text in methods:
       rb = tb.Radiobutton(self.detection_options_container, text=text, 
                          variable=self.duplicate_detection_mode_var, 
                          value=value, bootstyle="primary")
       rb.pack(anchor=tk.W, padx=40, pady=2)

    # Pack the AI Hunter container
    self.ai_hunter_container.pack(fill='x')

    # Add trace to detection mode variable - ONLY ONCE
    self.duplicate_detection_mode_var.trace('w', update_ai_hunter_visibility)

    # Initial visibility updates
    update_detection_visibility()
    update_ai_hunter_visibility()
    
    # Retry Slow
    tb.Checkbutton(section_frame, text="Auto-retry Slow Chunks", 
                  variable=self.retry_timeout_var,
                  bootstyle="round-toggle").pack(anchor=tk.W, pady=(15, 0))

    timeout_frame = tk.Frame(section_frame)
    timeout_frame.pack(anchor=tk.W, padx=20, pady=(5, 0))
    tk.Label(timeout_frame, text="Timeout after").pack(side=tk.LEFT)
    tb.Entry(timeout_frame, width=6, textvariable=self.chunk_timeout_var).pack(side=tk.LEFT, padx=5)
    tk.Label(timeout_frame, text="seconds").pack(side=tk.LEFT)

    tk.Label(section_frame, text="Retry chunks/images that take too long\n(reduces tokens for faster response)",
            font=('TkDefaultFont', 10), fg='gray', justify=tk.LEFT).pack(anchor=tk.W, padx=20, pady=(0, 5))

    # Separator
    ttk.Separator(section_frame, orient='horizontal').pack(fill='x', pady=10)

    # HTTP Timeouts & Connection Pooling
    title_http = tk.Label(section_frame, text="HTTP Timeouts & Connection Pooling", 
                          font=('TkDefaultFont', 11, 'bold'))
    title_http.pack(anchor=tk.W)

    http_frame = tk.Frame(section_frame)
    http_frame.pack(anchor=tk.W, padx=20, pady=(5, 0), fill=tk.X)

    # Master toggle to enable/disable all HTTP tuning fields (disabled by default)
    if not hasattr(self, 'enable_http_tuning_var'):
        self.enable_http_tuning_var = tk.BooleanVar(value=self.config.get('enable_http_tuning', False))
    self.http_tuning_checkbox = tb.Checkbutton(
        http_frame,
        text="Enable HTTP timeout/pooling overrides",
        variable=self.enable_http_tuning_var,
        command=getattr(self, '_toggle_http_tuning_controls', None) or (lambda: None),
        bootstyle="round-toggle"
    )
    self.http_tuning_checkbox.pack(anchor=tk.W, pady=(0, 6))

    # Build a compact grid so fields align nicely
    http_grid = tk.Frame(http_frame)
    http_grid.pack(anchor=tk.W, fill=tk.X)

    if not hasattr(self, 'connect_timeout_var'):
        self.connect_timeout_var = tk.StringVar(value=str(self.config.get('connect_timeout', os.environ.get('CONNECT_TIMEOUT', '10'))))
    if not hasattr(self, 'read_timeout_var'):
        # Default to READ_TIMEOUT, fallback to CHUNK_TIMEOUT if provided, else 180
        self.read_timeout_var = tk.StringVar(value=str(self.config.get('read_timeout', os.environ.get('READ_TIMEOUT', os.environ.get('CHUNK_TIMEOUT', '180')))))
    if not hasattr(self, 'http_pool_connections_var'):
        self.http_pool_connections_var = tk.StringVar(value=str(self.config.get('http_pool_connections', os.environ.get('HTTP_POOL_CONNECTIONS', '20'))))
    if not hasattr(self, 'http_pool_maxsize_var'):
        self.http_pool_maxsize_var = tk.StringVar(value=str(self.config.get('http_pool_maxsize', os.environ.get('HTTP_POOL_MAXSIZE', '50'))))

    # Layout columns
    http_grid.grid_columnconfigure(0, weight=0)
    http_grid.grid_columnconfigure(1, weight=0)
    http_grid.grid_columnconfigure(2, weight=1)  # spacer
    http_grid.grid_columnconfigure(3, weight=0)
    http_grid.grid_columnconfigure(4, weight=0)

    # Optional toggle: ignore server Retry-After header
    if not hasattr(self, 'ignore_retry_after_var'):
        self.ignore_retry_after_var = tk.BooleanVar(value=bool(self.config.get('ignore_retry_after', str(os.environ.get('IGNORE_RETRY_AFTER', '0')) == '1')))
    self.ignore_retry_after_checkbox = tb.Checkbutton(
        http_frame,
        text="Ignore server Retry-After header (use local backoff)", 
        variable=self.ignore_retry_after_var,
        bootstyle="round-toggle"
    )
    self.ignore_retry_after_checkbox.pack(anchor=tk.W, pady=(6, 0))

    # Row 0: Timeouts
    tk.Label(http_grid, text="Connect timeout (s):").grid(row=0, column=0, sticky='w', padx=(0, 6), pady=2)
    self.connect_timeout_entry = tb.Entry(http_grid, width=6, textvariable=self.connect_timeout_var)
    self.connect_timeout_entry.grid(row=0, column=1, sticky='w', pady=2)
    tk.Label(http_grid, text="Read timeout (s):").grid(row=0, column=3, sticky='w', padx=(12, 6), pady=2)
    self.read_timeout_entry = tb.Entry(http_grid, width=6, textvariable=self.read_timeout_var)
    self.read_timeout_entry.grid(row=0, column=4, sticky='w', pady=2)

    # Row 1: Pool sizes
    tk.Label(http_grid, text="Pool connections:").grid(row=1, column=0, sticky='w', padx=(0, 6), pady=2)
    self.http_pool_connections_entry = tb.Entry(http_grid, width=6, textvariable=self.http_pool_connections_var)
    self.http_pool_connections_entry.grid(row=1, column=1, sticky='w', pady=2)
    tk.Label(http_grid, text="Pool max size:").grid(row=1, column=3, sticky='w', padx=(12, 6), pady=2)
    self.http_pool_maxsize_entry = tb.Entry(http_grid, width=6, textvariable=self.http_pool_maxsize_var)
    self.http_pool_maxsize_entry.grid(row=1, column=4, sticky='w', pady=2)

    # Apply initial enable/disable state
    if hasattr(self, '_toggle_http_tuning_controls'):
        self._toggle_http_tuning_controls()

    tk.Label(section_frame, text="Controls network behavior to reduce 500/503s: connection establishment timeout, read timeout,\nHTTP connection pool sizes.",
            font=('TkDefaultFont', 10), fg='gray', justify=tk.LEFT).pack(anchor=tk.W, padx=20, pady=(2, 5))
    
    # Separator
    ttk.Separator(section_frame, orient='horizontal').pack(fill='x', pady=10)
    
    # Max Retries Configuration
    title_retries = tk.Label(section_frame, text="API Request Retries", 
                            font=('TkDefaultFont', 11, 'bold'))
    title_retries.pack(anchor=tk.W)
    
    retries_frame = tk.Frame(section_frame)
    retries_frame.pack(anchor=tk.W, padx=20, pady=(5, 0))
    
    # Create MAX_RETRIES variable if it doesn't exist
    if not hasattr(self, 'max_retries_var'):
        self.max_retries_var = tk.StringVar(value=str(self.config.get('max_retries', os.environ.get('MAX_RETRIES', '7'))))
    
    tk.Label(retries_frame, text="Maximum retry attempts:").pack(side=tk.LEFT)
    tb.Entry(retries_frame, width=4, textvariable=self.max_retries_var).pack(side=tk.LEFT, padx=5)
    tk.Label(retries_frame, text="(default: 7)").pack(side=tk.LEFT)
    
    tk.Label(section_frame, text="Number of times to retry failed API requests before giving up.\nApplies to all API providers (OpenAI, Gemini, Anthropic, etc.)",
            font=('TkDefaultFont', 10), fg='gray', justify=tk.LEFT).pack(anchor=tk.W, padx=20, pady=(2, 10))
    
    # Enable/disable combobox based on toggle
    def _toggle_scan_mode_state(*args):
        try:
            if self.scan_phase_enabled_var.get():
                scan_mode_combo.config(state="readonly")
            else:
                scan_mode_combo.config(state="disabled")
        except Exception:
            pass
    _toggle_scan_mode_state()
    self.scan_phase_enabled_var.trace('w', lambda *a: _toggle_scan_mode_state())
    
    # Indefinite Rate Limit Retry toggle
    tb.Checkbutton(section_frame, text="Indefinite Rate Limit Retry", 
                  variable=self.indefinite_rate_limit_retry_var,
                  bootstyle="round-toggle").pack(anchor=tk.W, padx=20)
    
    tk.Label(section_frame, text="When enabled, rate limit errors (429) will retry indefinitely with exponential backoff.\nWhen disabled, rate limits count against the maximum retry attempts above.",
            font=('TkDefaultFont', 10), fg='gray', justify=tk.LEFT).pack(anchor=tk.W, padx=40, pady=(2, 5))
    
            
def toggle_gemini_endpoint(self):
    """Enable/disable Gemini endpoint entry based on toggle"""
    if self.use_gemini_openai_endpoint_var.get():
        self.gemini_endpoint_entry.config(state='normal')
    else:
        self.gemini_endpoint_entry.config(state='disabled')

def open_multi_api_key_manager(self):
    """Open the multi API key manager dialog"""
    # Import here to avoid circular imports
    try:
        from multi_api_key_manager import MultiAPIKeyDialog
        
        # Create and show dialog
        dialog = MultiAPIKeyDialog(self.master, self)
        
        # Wait for dialog to close
        self.master.wait_window(dialog.dialog)
        
        # Refresh the settings display if in settings dialog
        if hasattr(self, 'current_settings_dialog'):
            # Close and reopen settings to refresh
            self.current_settings_dialog.destroy()
            self.show_settings()  # or open_other_settings()
            
    except ImportError as e:
        messagebox.showerror("Error", f"Failed to load Multi API Key Manager: {str(e)}")
    except Exception as e:
        messagebox.showerror("Error", f"Error opening Multi API Key Manager: {str(e)}")
        import traceback
        traceback.print_exc()

def _create_multi_key_row(self, parent):
    """Create a compact multi-key configuration row"""
    frame = tk.Frame(parent)
    frame.pack(fill=tk.X, pady=5)
    
    # Status indicator
    if self.config.get('use_multi_api_keys', False):
        keys = self.config.get('multi_api_keys', [])
        active = sum(1 for k in keys if k.get('enabled', True))
        
        # Checkbox to enable/disable
        tb.Checkbutton(frame, text="Multi API Key Mode", 
                      variable=self.use_multi_api_keys_var,
                      bootstyle="round-toggle",
                      command=self._toggle_multi_key_setting).pack(side=tk.LEFT)
        
        # Status
        tk.Label(frame, text=f"({active}/{len(keys)} active)", 
                font=('TkDefaultFont', 10), fg='green').pack(side=tk.LEFT, padx=(5, 0))
    else:
        tb.Checkbutton(frame, text="Multi API Key Mode", 
                      variable=self.use_multi_api_keys_var,
                      bootstyle="round-toggle",
                      command=self._toggle_multi_key_setting).pack(side=tk.LEFT)
    
    # Configure button
    tb.Button(frame, text="Configure Keys...", 
              command=self.open_multi_api_key_manager,
              bootstyle="primary-outline").pack(side=tk.LEFT, padx=(20, 0))
    
    return frame
            
def _toggle_multi_key_setting(self):
    """Toggle multi-key mode from settings dialog"""
    self.config['use_multi_api_keys'] = self.use_multi_api_keys_var.get()
    # Don't save immediately, let the dialog's save button handle it

def toggle_extraction_workers(self):
    """Enable/disable extraction workers entry based on toggle"""
    if self.enable_parallel_extraction_var.get():
        self.extraction_workers_entry.config(state='normal')
        # Set environment variable
        os.environ["EXTRACTION_WORKERS"] = str(self.extraction_workers_var.get())
    else:
        self.extraction_workers_entry.config(state='disabled')
        # Set to 1 worker (sequential) when disabled
        os.environ["EXTRACTION_WORKERS"] = "1"
    
    # Ensure executor reflects current worker setting
    try:
        self._ensure_executor()
    except Exception:
        pass

def _setup_provider_combobox_bindings(self):
    """Setup bindings for OpenRouter provider combobox with autocomplete"""
    try:
        # Bind to key release events for live filtering and autofill
        self.openrouter_provider_combo.bind('<KeyRelease>', self._on_provider_combo_keyrelease)
        # Commit best match on Enter
        self.openrouter_provider_combo.bind('<Return>', self._commit_provider_autocomplete)
        # Also bind to FocusOut to validate selection
        self.openrouter_provider_combo.bind('<FocusOut>', lambda e: self._validate_provider_selection())
    except Exception:
        pass  # Silently fail if combo doesn't exist

def _on_provider_combo_keyrelease(self, event=None):
    """Provider combobox type-to-search with autocomplete (reuses model dropdown logic)"""
    try:
        combo = self.openrouter_provider_combo
        typed = combo.get()
        prev = getattr(self, '_provider_prev_text', '')
        keysym = (getattr(event, 'keysym', '') or '').lower()

        # Navigation/commit keys: don't interfere
        if keysym in {'up', 'down', 'left', 'right', 'return', 'escape', 'tab'}:
            return

        # Ensure we have the full source list
        source = getattr(self, '_provider_all_values', [])
        if not source:
            return

        # Compute match set
        first_match = None
        if typed:
            lowered = typed.lower()
            # Prefix matches first
            pref = [v for v in source if v.lower().startswith(lowered)]
            # Contains matches second
            cont = [v for v in source if lowered in v.lower() and v not in pref]
            if pref:
                first_match = pref[0]
            elif cont:
                first_match = cont[0]

        # Decide whether to autofill
        grew = len(typed) > len(prev) and typed.startswith(prev)
        is_deletion = keysym in {'backspace', 'delete'} or len(typed) < len(prev)
        try:
            at_end = combo.index(tk.INSERT) == len(typed)
        except Exception:
            at_end = True
        try:
            has_selection = combo.selection_present()
        except Exception:
            has_selection = False

        # Gentle autofill only when appending at the end
        do_autofill_text = first_match is not None and grew and at_end and not has_selection and not is_deletion

        if do_autofill_text:
            # Only complete if it's a true prefix match
            if first_match.lower().startswith(typed.lower()) and first_match != typed:
                combo.set(first_match)
                try:
                    combo.icursor(len(typed))
                    combo.selection_range(len(typed), len(first_match))
                except Exception:
                    pass

        # If we have a match and the dropdown is open, scroll/highlight it
        if first_match:
            self._scroll_provider_list_to_value(first_match)

        # Remember current text for next event
        self._provider_prev_text = typed
    except Exception:
        pass  # Silently handle errors

def _commit_provider_autocomplete(self, event=None):
    """On Enter, commit to the best matching provider"""
    try:
        combo = self.openrouter_provider_combo
        typed = combo.get()
        source = getattr(self, '_provider_all_values', [])
        match = None
        if typed:
            lowered = typed.lower()
            pref = [v for v in source if v.lower().startswith(lowered)]
            cont = [v for v in source if lowered in v.lower()] if not pref else []
            match = pref[0] if pref else (cont[0] if cont else None)
        if match and match != typed:
            combo.set(match)
        # Move cursor to end and clear any selection
        try:
            combo.icursor('end')
            try:
                combo.selection_clear()
            except Exception:
                combo.selection_range(0, 0)
        except Exception:
            pass
        # Update prev text
        self._provider_prev_text = combo.get()
    except Exception:
        pass
    return "break"

def _scroll_provider_list_to_value(self, value: str):
    """If the provider combobox dropdown is open, scroll to and highlight the given value"""
    try:
        values = getattr(self, '_provider_all_values', [])
        if value not in values:
            return
        index = values.index(value)
        # Resolve the internal popdown listbox for this combobox
        popdown = self.openrouter_provider_combo.tk.eval(
            f'ttk::combobox::PopdownWindow {self.openrouter_provider_combo._w}'
        )
        listbox = f'{popdown}.f.l'
        tkobj = self.openrouter_provider_combo.tk
        # Scroll and highlight the item
        tkobj.call(listbox, 'see', index)
        tkobj.call(listbox, 'selection', 'clear', 0, 'end')
        tkobj.call(listbox, 'selection', 'set', index)
        tkobj.call(listbox, 'activate', index)
    except Exception:
        pass  # Dropdown may be closed or internals unavailable

def _validate_provider_selection(self):
    """Validate that the provider selection is from the list or default to Auto"""
    try:
        typed = self.openrouter_preferred_provider_var.get()
        source = getattr(self, '_provider_all_values', [])
        if typed and typed not in source:
            # Find closest match or default to Auto
            lowered = typed.lower()
            matches = [v for v in source if lowered in v.lower()]
            if matches:
                self.openrouter_preferred_provider_var.set(matches[0])
            else:
                self.openrouter_preferred_provider_var.set('Auto')
    except Exception:
        pass
    
def create_ai_hunter_section(self, parent_frame):
    """Create the AI Hunter configuration section - without redundant toggle"""
    # AI Hunter Configuration
    config_frame = tk.Frame(parent_frame)
    config_frame.pack(anchor=tk.W, padx=20, pady=(10, 5))
    
    # Status label
    ai_config = self.config.get('ai_hunter_config', {})
    self.ai_hunter_status_label = tk.Label(
        config_frame, 
        text=self._get_ai_hunter_status_text(),
        font=('TkDefaultFont', 10)
    )
    self.ai_hunter_status_label.pack(side=tk.LEFT)
    
    # Configure button
    tb.Button(
        config_frame, 
        text="Configure AI Hunter", 
        command=self.show_ai_hunter_settings,
        bootstyle="info"
    ).pack(side=tk.LEFT, padx=(10, 0))
    
    # Info text
    tk.Label(
        parent_frame,  # Use parent_frame instead of section_frame
        text="AI Hunter uses multiple detection methods to identify duplicate content\n"
             "with configurable thresholds and detection modes",
        font=('TkDefaultFont', 10), 
        fg='gray', 
        justify=tk.LEFT
    ).pack(anchor=tk.W, padx=20, pady=(0, 10))

def _get_ai_hunter_status_text(self):
    """Get status text for AI Hunter configuration"""
    ai_config = self.config.get('ai_hunter_config', {})
    
    # AI Hunter is shown when the detection mode is set to 'ai-hunter' or 'cascading'
    if self.duplicate_detection_mode_var.get() not in ['ai-hunter', 'cascading']:
        return "AI Hunter: Not Selected"
    
    if not ai_config.get('enabled', True):
        return "AI Hunter: Disabled in Config"
    
    mode_text = {
        'single_method': 'Single Method',
        'multi_method': 'Multi-Method',
        'weighted_average': 'Weighted Average'
    }
    
    mode = mode_text.get(ai_config.get('detection_mode', 'multi_method'), 'Unknown')
    thresholds = ai_config.get('thresholds', {})
    
    if thresholds:
        avg_threshold = sum(thresholds.values()) / len(thresholds)
    else:
        avg_threshold = 85
    
    return f"AI Hunter: {mode} mode, Avg threshold: {int(avg_threshold)}%"

def show_ai_hunter_settings(self):
    """Open AI Hunter configuration window"""
    def on_config_saved():
        # Save the entire configuration
        self.save_config()
        # Update status label if it still exists
        if hasattr(self, 'ai_hunter_status_label'):
            try:
                self.ai_hunter_status_label.winfo_exists()
                self.ai_hunter_status_label.config(text=self._get_ai_hunter_status_text())
            except tk.TclError:
                # Widget has been destroyed
                pass
        if hasattr(self, 'ai_hunter_enabled_var'):
            self.ai_hunter_enabled_var.set(self.config.get('ai_hunter_config', {}).get('enabled', True))
    
    gui = AIHunterConfigGUI(self.master, self.config, on_config_saved)
    gui.show_ai_hunter_config()

def toggle_ai_hunter(self):
    """Toggle AI Hunter enabled state"""
    if 'ai_hunter_config' not in self.config:
        self.config['ai_hunter_config'] = {}
    
    self.config['ai_hunter_config']['enabled'] = self.ai_hunter_enabled_var.get()
    self.save_config()
    self.ai_hunter_status_label.config(text=self._get_ai_hunter_status_text())

def _create_prompt_management_section(self, parent):
    """Create meta data section (formerly prompt management)"""
    section_frame = tk.LabelFrame(parent, text="Meta Data", padx=10, pady=10)
    section_frame.grid(row=0, column=0, sticky="nsew", padx=(10, 5), pady=(10, 5))
    
    title_frame = tk.Frame(section_frame)
    title_frame.pack(anchor=tk.W, pady=(10, 10))
    
    tb.Checkbutton(title_frame, text="Translate Book Title", 
                  variable=self.translate_book_title_var,
                  bootstyle="round-toggle").pack(side=tk.LEFT)
    
    # CHANGED: New button text and command
    tb.Button(title_frame, text="Configure All", 
             command=self.metadata_batch_ui.configure_translation_prompts,
             bootstyle="info-outline", width=12).pack(side=tk.LEFT, padx=(10, 5))
    
    # NEW: Custom Metadata Fields button
    tb.Button(title_frame, text="Custom Metadata", 
             command=self.metadata_batch_ui.configure_metadata_fields,
             bootstyle="info-outline", width=15).pack(side=tk.LEFT, padx=(5, 0))
    
    tk.Label(section_frame, text="When enabled: Book titles and selected metadata will be translated",
                font=('TkDefaultFont', 11), fg='gray', justify=tk.LEFT).pack(anchor=tk.W, padx=20, pady=(0, 10))
    
    # NEW: Batch Header Translation Section
    ttk.Separator(section_frame, orient='horizontal').pack(fill=tk.X, pady=(5, 10))
    
    tk.Label(section_frame, text="Chapter Header Translation:", 
            font=('TkDefaultFont', 11, 'bold')).pack(anchor=tk.W, pady=(5, 5))
    
    header_frame = tk.Frame(section_frame)
    header_frame.pack(anchor=tk.W, fill=tk.X, pady=(5, 10))
    
    # Master toggle for batch header translation
    def _toggle_header_controls():
        enabled = bool(self.batch_translate_headers_var.get())
        new_state = tk.NORMAL if enabled else tk.DISABLED
        update_cb.configure(state=new_state)
        save_cb.configure(state=new_state)
        ignore_header_cb.configure(state=new_state)
        ignore_title_cb.configure(state=new_state)
        delete_btn.configure(state=new_state)
    
    batch_toggle = tb.Checkbutton(header_frame, text="Batch Translate Headers", 
                  variable=self.batch_translate_headers_var,
                  bootstyle="round-toggle",
                  command=_toggle_header_controls)
    batch_toggle.pack(side=tk.LEFT)
    
    tk.Label(header_frame, text="Headers per batch:").pack(side=tk.LEFT, padx=(20, 5))
    
    batch_entry = tk.Entry(header_frame, textvariable=self.headers_per_batch_var, width=10)
    batch_entry.pack(side=tk.LEFT)
    
    # Options for header translation
    update_frame = tk.Frame(section_frame)
    update_frame.pack(anchor=tk.W, fill=tk.X, padx=20)
    
    update_cb = tb.Checkbutton(update_frame, text="Update headers in HTML files", 
                  variable=self.update_html_headers_var,
                  bootstyle="round-toggle")
    update_cb.pack(side=tk.LEFT)
    
    save_cb = tb.Checkbutton(update_frame, text="Save translations to .txt", 
                  variable=self.save_header_translations_var,
                  bootstyle="round-toggle")
    save_cb.pack(side=tk.LEFT, padx=(20, 0))
    
    # Additional ignore header option
    ignore_frame = tk.Frame(section_frame)
    ignore_frame.pack(anchor=tk.W, fill=tk.X, padx=20, pady=(5, 0))
    
    ignore_header_cb = tb.Checkbutton(ignore_frame, text="Ignore header", 
                  variable=self.ignore_header_var,
                  bootstyle="round-toggle")
    ignore_header_cb.pack(side=tk.LEFT)
    
    ignore_title_cb = tb.Checkbutton(ignore_frame, text="Ignore title", 
                  variable=self.ignore_title_var,
                  bootstyle="round-toggle")
    ignore_title_cb.pack(side=tk.LEFT, padx=(15, 0))
    
    # Delete translated_headers.txt button
    delete_btn = tb.Button(ignore_frame, text="🗑️Delete Header Files", 
             command=self.delete_translated_headers_file,
             bootstyle="danger-outline", width=21)
    delete_btn.pack(side=tk.LEFT, padx=(20, 0))
    
    # Initialize disabled state when batch headers is OFF
    _toggle_header_controls()
    
    tk.Label(section_frame, 
            text="• OFF: Use existing headers from translated chapters\n"
                 "• ON: Extract all headers → Translate in batch → Update files\n"
                 "• Ignore header: Skip h1/h2/h3 tags (prevents re-translation of visible headers)\n"
                 "• Ignore title: Skip <title> tag (prevents re-translation of document titles)\n"
                 "• Delete button: Removes translated_headers.txt files for all selected EPUBs",
            font=('TkDefaultFont', 10), fg='gray', justify=tk.LEFT).pack(anchor=tk.W, padx=20, pady=(5, 10))
    
    # EPUB Validation (keep existing)
    ttk.Separator(section_frame, orient='horizontal').pack(fill=tk.X, pady=(10, 10))
    
    tk.Label(section_frame, text="EPUB Utilities:", font=('TkDefaultFont', 11, 'bold')).pack(anchor=tk.W, pady=(5, 5))
    
    tb.Button(section_frame, text="🔍 Validate EPUB Structure", 
             command=self.validate_epub_structure_gui, 
             bootstyle="success-outline",
             width=25).pack(anchor=tk.W, pady=2)
    
    tk.Label(section_frame, text="Check if all required EPUB files are present for compilation",
            font=('TkDefaultFont', 10), fg='gray', justify=tk.LEFT).pack(anchor=tk.W, pady=(0, 5))
    
    # NCX-only navigation toggle
    tb.Checkbutton(section_frame, text="Use NCX-only Navigation (Compatibility Mode)", 
                  variable=self.force_ncx_only_var,
                  bootstyle="round-toggle").pack(anchor=tk.W, pady=(5, 5))
                  
    # CSS Attachment toggle - NEW!
    tb.Checkbutton(section_frame, text="Attach CSS to Chapters (Fixes styling issues)", 
                  variable=self.attach_css_to_chapters_var,
          bootstyle="round-toggle").pack(anchor=tk.W, pady=(5, 5))      
    
    # Output file naming
    tb.Checkbutton(section_frame, text="Retain source extension (no 'response_' prefix)", 
                  variable=self.retain_source_extension_var,
                  bootstyle="round-toggle").pack(anchor=tk.W, pady=(5, 5))

def _create_processing_options_section(self, parent):
    """Create processing options section"""
    section_frame = tk.LabelFrame(parent, text="Processing Options", padx=10, pady=10)
    section_frame.grid(row=1, column=1, sticky="nsew", padx=(5, 10), pady=5)
    
    # Reinforce messages option
    reinforce_frame = tk.Frame(section_frame)
    reinforce_frame.pack(anchor=tk.W, pady=(0, 10))
    tk.Label(reinforce_frame, text="Reinforce every").pack(side=tk.LEFT)
    tb.Entry(reinforce_frame, width=6, textvariable=self.reinforcement_freq_var).pack(side=tk.LEFT, padx=5)
    tk.Label(reinforce_frame, text="messages").pack(side=tk.LEFT)
    
    tb.Checkbutton(section_frame, text="Emergency Paragraph Restoration", 
                  variable=self.emergency_restore_var,
                  bootstyle="round-toggle").pack(anchor=tk.W, pady=2)
    
    tk.Label(section_frame, text="Fixes AI responses that lose paragraph\nstructure (wall of text)",
            font=('TkDefaultFont', 10), fg='gray', justify=tk.LEFT).pack(anchor=tk.W, padx=20, pady=(0, 5))
            
    tb.Checkbutton(section_frame, text="Enable Decimal Chapter Detection (EPUBs)", 
          variable=self.enable_decimal_chapters_var,
          bootstyle="round-toggle").pack(anchor=tk.W, pady=2)

    tk.Label(section_frame, text="Detect chapters like 1.1, 1.2 in EPUB files\n(Text files always use decimal chapters when split)",
            font=('TkDefaultFont', 10), fg='gray', justify=tk.LEFT).pack(anchor=tk.W, padx=20, pady=(0, 10))
    
    # === CHAPTER EXTRACTION SETTINGS ===
    # Main extraction frame
    extraction_frame = tk.LabelFrame(section_frame, text="Chapter Extraction Settings", padx=10, pady=5)
    extraction_frame.pack(fill=tk.X, pady=(0, 10))
    
    # Initialize variables if not exists
    if not hasattr(self, 'text_extraction_method_var'):
        # Check if using old enhanced mode
        if self.config.get('extraction_mode') == 'enhanced':
            self.text_extraction_method_var = tk.StringVar(value='enhanced')
            # Set filtering from enhanced_filtering or default to smart
            self.file_filtering_level_var = tk.StringVar(
                value=self.config.get('enhanced_filtering', 'smart')
            )
        else:
            self.text_extraction_method_var = tk.StringVar(value='standard')
            self.file_filtering_level_var = tk.StringVar(
                value=self.config.get('extraction_mode', 'smart')
            )
    
    if not hasattr(self, 'enhanced_preserve_structure_var'):
        self.enhanced_preserve_structure_var = tk.BooleanVar(
            value=self.config.get('enhanced_preserve_structure', True)
        )
    
    # --- Text Extraction Method Section ---
    method_frame = tk.Frame(extraction_frame)
    method_frame.pack(fill=tk.X, pady=(0, 15))
    
    tk.Label(method_frame, text="Text Extraction Method:", 
            font=('TkDefaultFont', 10, 'bold')).pack(anchor=tk.W, pady=(0, 5))
    
    # Standard extraction
    tb.Radiobutton(method_frame, text="Standard (BeautifulSoup)", 
                  variable=self.text_extraction_method_var, value="standard",
                  bootstyle="round-toggle",
                  command=self.on_extraction_method_change).pack(anchor=tk.W, pady=2)
    
    tk.Label(method_frame, text="Traditional HTML parsing - fast and reliable",
            font=('TkDefaultFont', 9), fg='gray', justify=tk.LEFT).pack(anchor=tk.W, padx=20, pady=(0, 5))
    
    # Enhanced extraction
    tb.Radiobutton(method_frame, text="🚀 Enhanced (html2text)", 
                  variable=self.text_extraction_method_var, value="enhanced",
                  bootstyle="success-round-toggle",
                  command=self.on_extraction_method_change).pack(anchor=tk.W, pady=2)

    tk.Label(method_frame, text="Superior Unicode handling, cleaner text extraction",
            font=('TkDefaultFont', 9), fg='dark green', justify=tk.LEFT).pack(anchor=tk.W, padx=20, pady=(0, 5))
    
    # Enhanced options (shown when enhanced is selected)
    self.enhanced_options_frame = tk.Frame(method_frame)
    self.enhanced_options_frame.pack(fill=tk.X, padx=20, pady=(5, 0))
    
    # Structure preservation
    tb.Checkbutton(self.enhanced_options_frame, text="Preserve Markdown Structure", 
                  variable=self.enhanced_preserve_structure_var,
                  bootstyle="round-toggle").pack(anchor=tk.W, pady=2)
    
    tk.Label(self.enhanced_options_frame, text="Keep formatting (bold, headers, lists) for better AI context",
            font=('TkDefaultFont', 8), fg='gray', justify=tk.LEFT).pack(anchor=tk.W, padx=20, pady=(0, 3))
    
    # Requirements note
    requirements_frame = tk.Frame(self.enhanced_options_frame)
    requirements_frame.pack(anchor=tk.W, pady=(5, 0))
    
    # Separator
    ttk.Separator(method_frame, orient='horizontal').pack(fill=tk.X, pady=(10, 10))
    
    # --- File Filtering Level Section ---
    filtering_frame = tk.Frame(extraction_frame)
    filtering_frame.pack(fill=tk.X, pady=(0, 10))
    
    tk.Label(filtering_frame, text="File Filtering Level:", 
            font=('TkDefaultFont', 10, 'bold')).pack(anchor=tk.W, pady=(0, 5))
    
    # Smart filtering
    tb.Radiobutton(filtering_frame, text="Smart (Aggressive Filtering)", 
                  variable=self.file_filtering_level_var, value="smart",
                  bootstyle="round-toggle").pack(anchor=tk.W, pady=2)
    
    tk.Label(filtering_frame, text="Skips navigation, TOC, copyright files\nBest for clean EPUBs with clear chapter structure",
            font=('TkDefaultFont', 9), fg='gray', justify=tk.LEFT).pack(anchor=tk.W, padx=20, pady=(0, 5))
    
    # Comprehensive filtering
    tb.Radiobutton(filtering_frame, text="Comprehensive (Moderate Filtering)", 
                  variable=self.file_filtering_level_var, value="comprehensive",
                  bootstyle="round-toggle").pack(anchor=tk.W, pady=2)
    
    tk.Label(filtering_frame, text="Only skips obvious navigation files\nGood when Smart mode misses chapters",
            font=('TkDefaultFont', 9), fg='gray', justify=tk.LEFT).pack(anchor=tk.W, padx=20, pady=(0, 5))
    
    # Full extraction
    tb.Radiobutton(filtering_frame, text="Full (No Filtering)", 
                  variable=self.file_filtering_level_var, value="full",
                  bootstyle="round-toggle").pack(anchor=tk.W, pady=2)
    
    tk.Label(filtering_frame, text="Extracts ALL HTML/XHTML files\nUse when other modes skip important content",
            font=('TkDefaultFont', 9), fg='gray', justify=tk.LEFT).pack(anchor=tk.W, padx=20, pady=(0, 5))
    
    # NEW: Force BeautifulSoup for Traditional APIs toggle
    if not hasattr(self, 'force_bs_for_traditional_var'):
        self.force_bs_for_traditional_var = tk.BooleanVar(
            value=self.config.get('force_bs_for_traditional', True)
        )
    tb.Checkbutton(extraction_frame, text="Force BeautifulSoup for DeepL / Google Translate / Google Free",
                  variable=self.force_bs_for_traditional_var,
                  bootstyle="round-toggle").pack(anchor=tk.W, pady=(0, 5))
    tk.Label(extraction_frame, text="When enabled, DeepL/Google Translate/Google Free always use BeautifulSoup extraction even if Enhanced is selected.",
             font=('TkDefaultFont', 8), fg='gray', justify=tk.LEFT).pack(anchor=tk.W, padx=20, pady=(0, 5))
    
    # Chapter merging option
    ttk.Separator(extraction_frame, orient='horizontal').pack(fill=tk.X, pady=(10, 10))
    
    # Initialize disable_chapter_merging_var if not exists
    if not hasattr(self, 'disable_chapter_merging_var'):
        self.disable_chapter_merging_var = tk.BooleanVar(
            value=self.config.get('disable_chapter_merging', False)
        )
    
    tb.Checkbutton(extraction_frame, text="Disable Chapter Merging", 
                  variable=self.disable_chapter_merging_var,
                  bootstyle="round-toggle").pack(anchor=tk.W, pady=2)
    
    tk.Label(extraction_frame, text="Disable automatic merging of Section/Chapter pairs.\nEach file will be treated as a separate chapter.",
            font=('TkDefaultFont', 9), fg='gray', justify=tk.LEFT).pack(anchor=tk.W, padx=20, pady=(0, 5))
    
    # === REMAINING OPTIONS ===
    tb.Checkbutton(section_frame, text="Disable Image Gallery in EPUB", 
                  variable=self.disable_epub_gallery_var,
                  bootstyle="round-toggle").pack(anchor=tk.W, pady=2)
    
    tk.Label(section_frame, text="Skip creating image gallery page in EPUB",
            font=('TkDefaultFont', 10), fg='gray', justify=tk.LEFT).pack(anchor=tk.W, padx=20, pady=(0, 10))

    # New: Disable Automatic Cover Creation
    tb.Checkbutton(section_frame, text="Disable Automatic Cover Creation", 
                  variable=self.disable_automatic_cover_creation_var,
                  bootstyle="round-toggle").pack(anchor=tk.W, pady=2)
    
    tk.Label(section_frame, text="When enabled: no auto-generated cover page is created.",
            font=('TkDefaultFont', 10), fg='gray', justify=tk.LEFT).pack(anchor=tk.W, padx=20, pady=(0, 10))

    # New: Translate cover.html (Skip Override)
    tb.Checkbutton(section_frame, text="Translate cover.html (Skip Override)", 
                  variable=self.translate_cover_html_var,
                  bootstyle="round-toggle").pack(anchor=tk.W, pady=2)
    
    tk.Label(section_frame, text="When enabled: existing cover.html/cover.xhtml will be included and translated (not skipped).",
            font=('TkDefaultFont', 10), fg='gray', justify=tk.LEFT).pack(anchor=tk.W, padx=20, pady=(0, 10))
    
    tb.Checkbutton(section_frame, text="Disable 0-based Chapter Detection", 
                  variable=self.disable_zero_detection_var,
                  bootstyle="round-toggle").pack(anchor=tk.W, pady=2)
    
    tk.Label(section_frame, text="Always use chapter ranges as specified\n(don't force adjust to chapter 1)",
            font=('TkDefaultFont', 10), fg='gray', justify=tk.LEFT).pack(anchor=tk.W, padx=20, pady=(0, 10))
            
    tb.Checkbutton(section_frame, text="Use Header as Output Name", 
                  variable=self.use_header_as_output_var,
                  bootstyle="round-toggle").pack(anchor=tk.W, pady=2)

    tk.Label(section_frame, text="Use chapter headers/titles as output filenames",
            font=('TkDefaultFont', 10), fg='gray', justify=tk.LEFT).pack(anchor=tk.W, padx=20, pady=(0, 10))
            
    # Chapter number offset
    ttk.Separator(section_frame, orient='horizontal').pack(fill=tk.X, pady=(10, 10))
    
    offset_frame = tk.Frame(section_frame)
    offset_frame.pack(anchor=tk.W, pady=5)
    
    tk.Label(offset_frame, text="Chapter Number Offset:").pack(side=tk.LEFT)
    
    # Create variable if not exists
    if not hasattr(self, 'chapter_number_offset_var'):
        self.chapter_number_offset_var = tk.StringVar(
            value=str(self.config.get('chapter_number_offset', '0'))
        )
    
    tb.Entry(offset_frame, width=6, textvariable=self.chapter_number_offset_var).pack(side=tk.LEFT, padx=5)
    
    tk.Label(offset_frame, text="(+/- adjustment)").pack(side=tk.LEFT)
    
    tk.Label(section_frame, text="Adjust all chapter numbers by this amount.\nUseful for matching file numbers to actual chapters.",
            font=('TkDefaultFont', 10), fg='gray', justify=tk.LEFT).pack(anchor=tk.W, padx=20, pady=(0, 10))    
            
    # Add separator before API safety settings
    ttk.Separator(section_frame, orient='horizontal').pack(fill=tk.X, pady=(15, 10))

    # Post-Translation Scanning Phase
    scan_phase_frame = tk.Frame(section_frame)
    scan_phase_frame.pack(anchor=tk.W, fill=tk.X, pady=(10, 0))
    
    tb.Checkbutton(scan_phase_frame, text="Enable post-translation Scanning phase",
                  variable=self.scan_phase_enabled_var,
                  bootstyle="round-toggle").pack(side=tk.LEFT)
    
    # Mode selector
    tk.Label(scan_phase_frame, text="Mode:").pack(side=tk.LEFT, padx=(15, 5))
    scan_modes = ["quick-scan", "aggressive", "ai-hunter", "custom"]
    scan_mode_combo = ttk.Combobox(scan_phase_frame, textvariable=self.scan_phase_mode_var, values=scan_modes, state="readonly", width=12)
    scan_mode_combo.pack(side=tk.LEFT)
    # Prevent accidental changes from mouse wheel while scrolling
    UIHelper.disable_spinbox_mousewheel(scan_mode_combo)
    
    tk.Label(section_frame, text="Automatically run QA Scanner after translation completes",
           font=('TkDefaultFont', 10), fg='gray', justify=tk.LEFT).pack(anchor=tk.W, padx=20, pady=(0, 10))
    
    # Conservative Batching Toggle
    tb.Checkbutton(section_frame, text="Use Conservative Batching",
                  variable=self.conservative_batching_var,
                  bootstyle="round-toggle").pack(anchor=tk.W, pady=(10, 0))
    
    tk.Label(section_frame, text="When enabled: Groups chapters in batches of 3x batch size for memory management\nWhen disabled (default): Uses direct batch size for faster processing",
           font=('TkDefaultFont', 10), fg='gray', justify=tk.LEFT).pack(anchor=tk.W, padx=20, pady=(0, 10))
    
    ttk.Separator(section_frame, orient='horizontal').pack(fill=tk.X, pady=(15, 10))
    
    # API Safety Settings subsection
    tk.Label(section_frame, text="API Safety Settings", 
             font=('TkDefaultFont', 11, 'bold')).pack(anchor=tk.W, pady=(5, 5))
    
    # Create the Gemini safety checkbox
    if not hasattr(self, 'disable_gemini_safety_var'):
        self.disable_gemini_safety_var = tk.BooleanVar(
            value=self.config.get('disable_gemini_safety', False)
        )
    
    tb.Checkbutton(
        section_frame,
        text="Disable API Safety Filters (Gemini, Groq, Fireworks, etc.)",
        variable=self.disable_gemini_safety_var,
        bootstyle="round-toggle"
    ).pack(anchor=tk.W, pady=(5, 0))
    
    # Add warning text
    warning_text = ("⚠️ Disables content safety filters for supported providers.\n"
                   "Gemini: Sets all harm categories to BLOCK_NONE.\n"
                   "Groq/Fireworks: Disables moderation parameter.\n")
    tk.Label(
        section_frame,
        text=warning_text,
        font=('TkDefaultFont', 9),
        fg='#ff6b6b',
        justify=tk.LEFT
    ).pack(anchor=tk.W, padx=(20, 0), pady=(0, 5))
    
    # Add note about affected models
    tk.Label(
        section_frame,
        text="Does NOT affect ElectronHub Gemini models (eh/gemini-*) or Together AI",
        font=('TkDefaultFont', 8),
        fg='gray',
        justify=tk.LEFT
    ).pack(anchor=tk.W, padx=(20, 0), pady=(0, 8))

    # New: OpenRouter Transport Preference
    # Toggle to force HTTP-only path for OpenRouter (SDK bypass)
    if not hasattr(self, 'openrouter_http_only_var'):
        self.openrouter_http_only_var = tk.BooleanVar(
            value=self.config.get('openrouter_use_http_only', False)
        )
    
    tb.Checkbutton(
        section_frame,
        text="Use HTTP-only for OpenRouter (bypass SDK)",
        variable=self.openrouter_http_only_var,
        bootstyle="round-toggle"
    ).pack(anchor=tk.W, pady=(8, 0))
    
    tk.Label(
        section_frame,
        text="When enabled, requests to OpenRouter use direct HTTP POST with explicit headers (Accept, Referer, X-Title).",
        font=('TkDefaultFont', 9),
        fg='gray',
        justify=tk.LEFT
    ).pack(anchor=tk.W, padx=(20, 0), pady=(0, 5))

    # OpenRouter: Disable compression (Accept-Encoding: identity)
    if not hasattr(self, 'openrouter_accept_identity_var'):
        self.openrouter_accept_identity_var = tk.BooleanVar(
            value=self.config.get('openrouter_accept_identity', False)
        )
    tb.Checkbutton(
        section_frame,
        text="Disable compression for OpenRouter (Accept-Encoding)",
        variable=self.openrouter_accept_identity_var,
        bootstyle="round-toggle"
    ).pack(anchor=tk.W, pady=(4, 0))
    tk.Label(
        section_frame,
        text="Sends Accept-Encoding: identity to request uncompressed responses.\n"
             "Use if proxies/CDNs cause corrupted or non-JSON compressed bodies.",
        font=('TkDefaultFont', 8),
        fg='gray',
        justify=tk.LEFT
    ).pack(anchor=tk.W, padx=(20, 0), pady=(0, 8))

    # OpenRouter: Provider preference
    provider_frame = tk.Frame(section_frame)
    provider_frame.pack(anchor=tk.W, fill=tk.X, pady=(4, 0))
    
    tk.Label(provider_frame, text="Preferred OpenRouter Provider:").pack(side=tk.LEFT)
    
    if not hasattr(self, 'openrouter_preferred_provider_var'):
        self.openrouter_preferred_provider_var = tk.StringVar(
            value=self.config.get('openrouter_preferred_provider', 'Auto')
        )
    
    # Comprehensive list of OpenRouter providers (alphabetically sorted, with Auto first)
    provider_options = [
        'Auto',
        'AI21',
        'AionLabs',
        'Alibaba Cloud Int.',
        'Amazon Bedrock',
        'Anthropic',
        'AtlasCloud',
        'Atoma',
        'Avian.io',
        'Azure',
        'Baseten',
        'Cerebras',
        'Chutes',
        'Cloudflare',
        'Cohere',
        'CrofAI',
        'Crusoe',
        'DeepInfra',
        'DeepSeek',
        'Enfer',
        'Featherless',
        'Fireworks',
        'Friendli',
        'GMICloud',
        'Google AI Studio',
        'Google Vertex',
        'Groq',
        'Hyperbolic',
        'Inception',
        'inference.net',
        'Infermatic',
        'Inflection',
        'kluster.ai',
        'Lambda',
        'Lepton',
        'Leschde',
        'Liquid',
        'Mancer (private)',
        'Meta',
        'Minimax',
        'Mistral',
        'Moonshot AI',
        'Morph',
        'nCompass',
        'Nebius AI Studio',
        'NextBit',
        'Nineteen',
        'NovitAI',
        'NVIDIA',
        'OpenAI',
        'OpenInference',
        'Parasail',
        'Perplexity',
        'Phala',
        'Relace',
        'SambaNova',
        'SiliconFlow',
        'Stealth',
        'Switchpoint',
        'Targon',
        'Together',
        'Ubicloud',
        'Venice',
        'Weights & Biases',
        'xAI',
        'Z.AI'
    ]
    
    # Create combobox with autocomplete support (not readonly)
    provider_combo = ttk.Combobox(
        provider_frame,
        textvariable=self.openrouter_preferred_provider_var,
        values=provider_options,
        state="normal",  # Changed from readonly to support typing
        width=20
    )
    provider_combo.pack(side=tk.LEFT, padx=(10, 0))
    
    # Store reference and full list for autocomplete
    self.openrouter_provider_combo = provider_combo
    self._provider_all_values = provider_options
    self._provider_prev_text = self.openrouter_preferred_provider_var.get()
    
    # Setup autocomplete bindings (reusing model dropdown logic)
    self._setup_provider_combobox_bindings()
    
    # Prevent accidental changes from mouse wheel while scrolling
    UIHelper.disable_spinbox_mousewheel(provider_combo)
    
    tk.Label(
        section_frame,
        text="Specify which upstream provider OpenRouter should prefer for your requests.\n"
             "'Auto' lets OpenRouter choose. Specific providers may have different availability.",
        font=('TkDefaultFont', 8),
        fg='gray',
        justify=tk.LEFT
    ).pack(anchor=tk.W, padx=(20, 0), pady=(0, 8))
    
    # Initial state - show/hide enhanced options
    self.on_extraction_method_change()

def on_extraction_method_change(self):
    """Handle extraction method changes and show/hide Enhanced options"""
    if hasattr(self, 'text_extraction_method_var') and hasattr(self, 'enhanced_options_frame'):
        if self.text_extraction_method_var.get() == 'enhanced':
            self.enhanced_options_frame.pack(fill=tk.X, padx=20, pady=(5, 0))
        else:
            self.enhanced_options_frame.pack_forget()
            
def _create_image_translation_section(self, parent):
    """Create image translation section"""
    section_frame = tk.LabelFrame(parent, text="Image Translation", padx=10, pady=8)
    section_frame.grid(row=2, column=0, columnspan=2, sticky="nsew", padx=10, pady=(5, 10))
    
    left_column = tk.Frame(section_frame)
    left_column.pack(side=tk.LEFT, fill=tk.BOTH, expand=True, padx=(0, 20))
    
    right_column = tk.Frame(section_frame)
    right_column.pack(side=tk.LEFT, fill=tk.BOTH, expand=True)
    
    # Left column
    enable_frame = tk.Frame(left_column)
    enable_frame.pack(fill=tk.X, pady=(0, 10))
    
    tb.Checkbutton(enable_frame, text="Enable Image Translation", 
                  variable=self.enable_image_translation_var,
                  bootstyle="round-toggle").pack(anchor=tk.W)
    
    tk.Label(left_column, text="Extracts and translates text from images using vision models",
            font=('TkDefaultFont', 10), fg='gray').pack(anchor=tk.W, pady=(0, 10))
    
    tb.Checkbutton(left_column, text="Process Long Images (Web Novel Style)", 
                  variable=self.process_webnovel_images_var,
                  bootstyle="round-toggle").pack(anchor=tk.W)
    
    tk.Label(left_column, text="Include tall images often used in web novels",
            font=('TkDefaultFont', 10), fg='gray').pack(anchor=tk.W, padx=20, pady=(0, 10))
    
    tb.Checkbutton(left_column, text="Hide labels and remove OCR images", 
                  variable=self.hide_image_translation_label_var,
                  bootstyle="round-toggle").pack(anchor=tk.W)
    
    tk.Label(left_column, text="Clean mode: removes image and shows only translated text",
            font=('TkDefaultFont', 10), fg='gray').pack(anchor=tk.W, padx=20, pady=(0, 10))

    # Add some spacing
    tk.Frame(left_column, height=10).pack()

    # Watermark removal toggle
    tb.Checkbutton(left_column, text="Enable Watermark Removal", 
                  variable=self.enable_watermark_removal_var,
                  bootstyle="round-toggle").pack(anchor=tk.W)

    tk.Label(left_column, text="Advanced preprocessing to remove watermarks from images",
            font=('TkDefaultFont', 10), fg='gray').pack(anchor=tk.W, padx=20, pady=(0, 10))

    # Save cleaned images toggle - create with reference
    self.save_cleaned_checkbox = tb.Checkbutton(left_column, text="Save Cleaned Images", 
                                               variable=self.save_cleaned_images_var,
                                               bootstyle="round-toggle")
    self.save_cleaned_checkbox.pack(anchor=tk.W, padx=(20, 0))

    tk.Label(left_column, text="Keep watermark-removed images in translated_images/cleaned/",
            font=('TkDefaultFont', 10), fg='gray').pack(anchor=tk.W, padx=40, pady=(0, 10))

    # Advanced watermark removal toggle - create with reference
    self.advanced_watermark_checkbox = tb.Checkbutton(left_column, text="Advanced Watermark Removal", 
                                                     variable=self.advanced_watermark_removal_var,
                                                     bootstyle="round-toggle")
    self.advanced_watermark_checkbox.pack(anchor=tk.W, padx=(20, 0))

    tk.Label(left_column, text="Use FFT-based pattern detection for stubborn watermarks",
            font=('TkDefaultFont', 10), fg='gray').pack(anchor=tk.W, padx=40)
    
    # Right column
    settings_frame = tk.Frame(right_column)
    settings_frame.pack(fill=tk.X)

    settings_frame.grid_columnconfigure(1, minsize=80)

    settings = [
        ("Min Image height (px):", self.webnovel_min_height_var),
        ("Max Images per chapter:", self.max_images_per_chapter_var),
        ("Chunk height:", self.image_chunk_height_var),
        ("Chunk overlap (%):", self.image_chunk_overlap_var)  # Add this new setting
    ]

    for row, (label, var) in enumerate(settings):
        tk.Label(settings_frame, text=label).grid(row=row, column=0, sticky=tk.W, pady=3)
        entry = tb.Entry(settings_frame, width=10, textvariable=var)
        entry.grid(row=row, column=1, sticky=tk.W, pady=3)
        
        # Add tooltip for the overlap setting
        if "overlap" in label.lower():
            tk.Label(settings_frame, text="1-10% recommended", 
                    font=('TkDefaultFont', 8), fg='gray').grid(row=row, column=2, sticky=tk.W, padx=(5, 0))

    # Buttons for prompts and compression
    # TODO: Implement configure_image_chunk_prompt method
    # tb.Button(settings_frame, text="Image Chunk Prompt", 
    #          command=self.configure_image_chunk_prompt,
    #          bootstyle="info-outline", width=20).grid(row=4, column=0, columnspan=2, sticky=tk.W, pady=(10, 0))
    
    # Add Image Compression button
    # TODO: Implement configure_image_compression method
    # tb.Button(settings_frame, text="🗜️ Image Compression", 
    #          command=self.configure_image_compression,
    #          bootstyle="info-outline", width=25).grid(row=5, column=0, columnspan=2, sticky=tk.W, pady=(5, 0))

    # Add the toggle here in the right column with some spacing
    tk.Frame(right_column, height=15).pack()  # Add some spacing

    tb.Checkbutton(right_column, text="Send tall image chunks in single API call (NOT RECOMMENDED)", 
                  variable=self.single_api_image_chunks_var,
                  bootstyle="round-toggle").pack(anchor=tk.W)

    tk.Label(right_column, text="All image chunks sent to 1 API call (Most AI models don't like this)",
            font=('TkDefaultFont', 10), fg='gray').pack(anchor=tk.W, padx=20, pady=(0, 10))

    tk.Label(right_column, text="💡 Supported models:\n"
            "• Gemini 1.5 Pro/Flash, 2.0 Flash\n"
            "• GPT-4V, GPT-4o, o4-mini",
            font=('TkDefaultFont', 10), fg='#666', justify=tk.LEFT).pack(anchor=tk.W, pady=(10, 0))
        
            
    # Set up the dependency logic
    def toggle_watermark_options(*args):
        if self.enable_watermark_removal_var.get():
            # Enable both sub-options
            self.save_cleaned_checkbox.config(state=tk.NORMAL)
            self.advanced_watermark_checkbox.config(state=tk.NORMAL)
        else:
            # Disable both sub-options and turn them off
            self.save_cleaned_checkbox.config(state=tk.DISABLED)
            self.advanced_watermark_checkbox.config(state=tk.DISABLED)
            self.save_cleaned_images_var.set(False)
            self.advanced_watermark_removal_var.set(False)

    # Bind the trace to the watermark removal variable
    self.enable_watermark_removal_var.trace('w', toggle_watermark_options)
    
    # Call once to set initial state
    toggle_watermark_options()
    
def on_extraction_mode_change(self):
    """Handle extraction mode changes and show/hide Enhanced options"""
    if self.extraction_mode_var.get() == 'enhanced':
        # Show enhanced options
        if hasattr(self, 'enhanced_options_separator'):
            self.enhanced_options_separator.pack(fill=tk.X, pady=(5, 5))
        if hasattr(self, 'enhanced_options_frame'):
            self.enhanced_options_frame.pack(fill=tk.X, padx=20)
    else:
        # Hide enhanced options
        if hasattr(self, 'enhanced_options_separator'):
            self.enhanced_options_separator.pack_forget()
        if hasattr(self, 'enhanced_options_frame'):
            self.enhanced_options_frame.pack_forget()
            
def _create_anti_duplicate_section(self, parent):
    """Create comprehensive anti-duplicate parameter controls with tabs"""
    # Anti-Duplicate Parameters section
    ad_frame = tk.LabelFrame(parent, text="🎯 Anti-Duplicate Parameters", padx=15, pady=10)
    ad_frame.grid(row=6, column=0, columnspan=2, sticky="ew", padx=20, pady=(0, 15))
    
    # Description
    desc_label = tk.Label(ad_frame, 
        text="Configure parameters to reduce duplicate translations across all AI providers.",
        font=('TkDefaultFont', 9), fg='gray', wraplength=520)
    desc_label.pack(anchor=tk.W, pady=(0, 10))
    
    # Enable/Disable toggle
    self.enable_anti_duplicate_var = tk.BooleanVar(value=self.config.get('enable_anti_duplicate', False))
    enable_cb = tb.Checkbutton(ad_frame, text="Enable Anti-Duplicate Parameters", 
                              variable=self.enable_anti_duplicate_var,
                              command=self._toggle_anti_duplicate_controls)
    enable_cb.pack(anchor=tk.W, pady=(0, 10))
    
    # Create notebook for organized parameters
    self.anti_duplicate_notebook = ttk.Notebook(ad_frame)
    self.anti_duplicate_notebook.pack(fill=tk.BOTH, expand=True, pady=5)
    
    # Tab 1: Core Parameters
    core_frame = tk.Frame(self.anti_duplicate_notebook)
    self.anti_duplicate_notebook.add(core_frame, text="Core Parameters")
    
    # Top-P (Nucleus Sampling)
    top_p_frame = tk.Frame(core_frame)
    top_p_frame.pack(fill=tk.X, pady=5)
    
    tk.Label(top_p_frame, text="Top-P (Nucleus Sampling):", width=25, anchor='w').pack(side=tk.LEFT)
    self.top_p_var = tk.DoubleVar(value=self.config.get('top_p', 1.0))
    top_p_scale = tk.Scale(top_p_frame, from_=0.1, to=1.0, resolution=0.01, 
                          orient=tk.HORIZONTAL, variable=self.top_p_var, length=200)
    top_p_scale.pack(side=tk.LEFT, padx=5)
    self.top_p_value_label = tk.Label(top_p_frame, text="", width=8)
    self.top_p_value_label.pack(side=tk.LEFT, padx=5)
    
    def update_top_p_label(*args):
        val = self.top_p_var.get()
        self.top_p_value_label.config(text=f"{val:.2f}")
    self.top_p_var.trace('w', update_top_p_label)
    update_top_p_label()
    
    # Top-K (Vocabulary Limit)
    top_k_frame = tk.Frame(core_frame)
    top_k_frame.pack(fill=tk.X, pady=5)
    
    tk.Label(top_k_frame, text="Top-K (Vocabulary Limit):", width=25, anchor='w').pack(side=tk.LEFT)
    self.top_k_var = tk.IntVar(value=self.config.get('top_k', 0))
    top_k_scale = tk.Scale(top_k_frame, from_=0, to=100, orient=tk.HORIZONTAL, 
                          variable=self.top_k_var, length=200)
    top_k_scale.pack(side=tk.LEFT, padx=5)
    self.top_k_value_label = tk.Label(top_k_frame, text="", width=8)
    self.top_k_value_label.pack(side=tk.LEFT, padx=5)
    
    def update_top_k_label(*args):
        val = self.top_k_var.get()
        self.top_k_value_label.config(text=f"{val}" if val > 0 else "OFF")
    self.top_k_var.trace('w', update_top_k_label)
    update_top_k_label()
    
    # Frequency Penalty
    freq_penalty_frame = tk.Frame(core_frame)
    freq_penalty_frame.pack(fill=tk.X, pady=5)
    
    tk.Label(freq_penalty_frame, text="Frequency Penalty:", width=25, anchor='w').pack(side=tk.LEFT)
    self.frequency_penalty_var = tk.DoubleVar(value=self.config.get('frequency_penalty', 0.0))
    freq_scale = tk.Scale(freq_penalty_frame, from_=0.0, to=2.0, resolution=0.1, 
                         orient=tk.HORIZONTAL, variable=self.frequency_penalty_var, length=200)
    freq_scale.pack(side=tk.LEFT, padx=5)
    self.freq_penalty_value_label = tk.Label(freq_penalty_frame, text="", width=8)
    self.freq_penalty_value_label.pack(side=tk.LEFT, padx=5)
    
    def update_freq_label(*args):
        val = self.frequency_penalty_var.get()
        self.freq_penalty_value_label.config(text=f"{val:.1f}" if val > 0 else "OFF")
    self.frequency_penalty_var.trace('w', update_freq_label)
    update_freq_label()
    
    # Presence Penalty
    pres_penalty_frame = tk.Frame(core_frame)
    pres_penalty_frame.pack(fill=tk.X, pady=5)
    
    tk.Label(pres_penalty_frame, text="Presence Penalty:", width=25, anchor='w').pack(side=tk.LEFT)
    self.presence_penalty_var = tk.DoubleVar(value=self.config.get('presence_penalty', 0.0))
    pres_scale = tk.Scale(pres_penalty_frame, from_=0.0, to=2.0, resolution=0.1, 
                         orient=tk.HORIZONTAL, variable=self.presence_penalty_var, length=200)
    pres_scale.pack(side=tk.LEFT, padx=5)
    self.pres_penalty_value_label = tk.Label(pres_penalty_frame, text="", width=8)
    self.pres_penalty_value_label.pack(side=tk.LEFT, padx=5)
    
    def update_pres_label(*args):
        val = self.presence_penalty_var.get()
        self.pres_penalty_value_label.config(text=f"{val:.1f}" if val > 0 else "OFF")
    self.presence_penalty_var.trace('w', update_pres_label)
    update_pres_label()
    
    # Tab 2: Advanced Parameters
    advanced_frame = tk.Frame(self.anti_duplicate_notebook)
    self.anti_duplicate_notebook.add(advanced_frame, text="Advanced")
    
    # Repetition Penalty
    rep_penalty_frame = tk.Frame(advanced_frame)
    rep_penalty_frame.pack(fill=tk.X, pady=5)
    
    tk.Label(rep_penalty_frame, text="Repetition Penalty:", width=25, anchor='w').pack(side=tk.LEFT)
    self.repetition_penalty_var = tk.DoubleVar(value=self.config.get('repetition_penalty', 1.0))
    rep_scale = tk.Scale(rep_penalty_frame, from_=1.0, to=2.0, resolution=0.05, 
                        orient=tk.HORIZONTAL, variable=self.repetition_penalty_var, length=200)
    rep_scale.pack(side=tk.LEFT, padx=5)
    self.rep_penalty_value_label = tk.Label(rep_penalty_frame, text="", width=8)
    self.rep_penalty_value_label.pack(side=tk.LEFT, padx=5)
    
    def update_rep_label(*args):
        val = self.repetition_penalty_var.get()
        self.rep_penalty_value_label.config(text=f"{val:.2f}" if val > 1.0 else "OFF")
    self.repetition_penalty_var.trace('w', update_rep_label)
    update_rep_label()
    
    # Candidate Count (Gemini)
    candidate_frame = tk.Frame(advanced_frame)
    candidate_frame.pack(fill=tk.X, pady=5)
    
    tk.Label(candidate_frame, text="Candidate Count (Gemini):", width=25, anchor='w').pack(side=tk.LEFT)
    self.candidate_count_var = tk.IntVar(value=self.config.get('candidate_count', 1))
    candidate_scale = tk.Scale(candidate_frame, from_=1, to=4, orient=tk.HORIZONTAL, 
                              variable=self.candidate_count_var, length=200)
    candidate_scale.pack(side=tk.LEFT, padx=5)
    self.candidate_value_label = tk.Label(candidate_frame, text="", width=8)
    self.candidate_value_label.pack(side=tk.LEFT, padx=5)
    
    def update_candidate_label(*args):
        val = self.candidate_count_var.get()
        self.candidate_value_label.config(text=f"{val}")
    self.candidate_count_var.trace('w', update_candidate_label)
    update_candidate_label()
    
    # Tab 3: Stop Sequences
    stop_frame = tk.Frame(self.anti_duplicate_notebook)
    self.anti_duplicate_notebook.add(stop_frame, text="Stop Sequences")
    
    # Custom Stop Sequences
    stop_seq_frame = tk.Frame(stop_frame)
    stop_seq_frame.pack(fill=tk.X, pady=5)
    
    tk.Label(stop_seq_frame, text="Custom Stop Sequences:", width=25, anchor='w').pack(side=tk.LEFT)
    self.custom_stop_sequences_var = tk.StringVar(value=self.config.get('custom_stop_sequences', ''))
    stop_entry = tb.Entry(stop_seq_frame, textvariable=self.custom_stop_sequences_var, width=30)
    stop_entry.pack(side=tk.LEFT, padx=5)
    tk.Label(stop_seq_frame, text="(comma-separated)", font=('TkDefaultFont', 8), fg='gray').pack(side=tk.LEFT)
    
    # Tab 4: Logit Bias (OpenAI)
    bias_frame = tk.Frame(self.anti_duplicate_notebook)
    self.anti_duplicate_notebook.add(bias_frame, text="Logit Bias")
    
    # Logit Bias Enable
    self.logit_bias_enabled_var = tk.BooleanVar(value=self.config.get('logit_bias_enabled', False))
    bias_cb = tb.Checkbutton(bias_frame, text="Enable Logit Bias (OpenAI only)", 
                            variable=self.logit_bias_enabled_var)
    bias_cb.pack(anchor=tk.W, pady=5)
    
    # Logit Bias Strength
    bias_strength_frame = tk.Frame(bias_frame)
    bias_strength_frame.pack(fill=tk.X, pady=5)
    
    tk.Label(bias_strength_frame, text="Bias Strength:", width=25, anchor='w').pack(side=tk.LEFT)
    self.logit_bias_strength_var = tk.DoubleVar(value=self.config.get('logit_bias_strength', -0.5))
    bias_scale = tk.Scale(bias_strength_frame, from_=-2.0, to=2.0, resolution=0.1, 
                         orient=tk.HORIZONTAL, variable=self.logit_bias_strength_var, length=200)
    bias_scale.pack(side=tk.LEFT, padx=5)
    self.bias_strength_value_label = tk.Label(bias_strength_frame, text="", width=8)
    self.bias_strength_value_label.pack(side=tk.LEFT, padx=5)
    
    def update_bias_strength_label(*args):
        val = self.logit_bias_strength_var.get()
        self.bias_strength_value_label.config(text=f"{val:.1f}")
    self.logit_bias_strength_var.trace('w', update_bias_strength_label)
    update_bias_strength_label()
    
    # Preset bias targets
    preset_frame = tk.Frame(bias_frame)
    preset_frame.pack(fill=tk.X, pady=5)
    
    tk.Label(preset_frame, text="Preset Bias Targets:", font=('TkDefaultFont', 9, 'bold')).pack(anchor=tk.W)
    
    self.bias_common_words_var = tk.BooleanVar(value=self.config.get('bias_common_words', False))
    tb.Checkbutton(preset_frame, text="Bias against common words (the, and, said)", 
                  variable=self.bias_common_words_var).pack(anchor=tk.W)
    
    self.bias_repetitive_phrases_var = tk.BooleanVar(value=self.config.get('bias_repetitive_phrases', False))
    tb.Checkbutton(preset_frame, text="Bias against repetitive phrases", 
                  variable=self.bias_repetitive_phrases_var).pack(anchor=tk.W)
    
    # Provider compatibility info
    compat_frame = tk.Frame(ad_frame)
    compat_frame.pack(fill=tk.X, pady=(15, 0))

    tk.Label(compat_frame, text="Parameter Compatibility:", 
            font=('TkDefaultFont', 9, 'bold')).pack(anchor=tk.W)

    compat_text = tk.Label(compat_frame, 
        text="• Core: Most providers • Advanced: DeepSeek, Mistral, Groq • Logit Bias: OpenAI only",
        font=('TkDefaultFont', 8), fg='gray', justify=tk.LEFT)
    compat_text.pack(anchor=tk.W, pady=(5, 0))

    # Reset button
    reset_frame = tk.Frame(ad_frame)
    reset_frame.pack(fill=tk.X, pady=(10, 0))

    tb.Button(reset_frame, text="🔄 Reset to Defaults", 
             command=self._reset_anti_duplicate_defaults,
             bootstyle="secondary", width=20).pack(side=tk.LEFT)

    tk.Label(reset_frame, text="Reset all anti-duplicate parameters to default values", 
            font=('TkDefaultFont', 8), fg='gray').pack(side=tk.LEFT, padx=(10, 0))

    # Store all tab frames for enable/disable
    self.anti_duplicate_tabs = [core_frame, advanced_frame, stop_frame, bias_frame]

    # Initial state
    self._toggle_anti_duplicate_controls()

def _toggle_anti_duplicate_controls(self):
    """Enable/disable anti-duplicate parameter controls"""
    state = tk.NORMAL if self.enable_anti_duplicate_var.get() else tk.DISABLED
    
    # Disable/enable the notebook itself
    if hasattr(self, 'anti_duplicate_notebook'):
        try:
            self.anti_duplicate_notebook.config(state=state)
        except tk.TclError:
            pass
    
    # Disable/enable all controls in tabs
    if hasattr(self, 'anti_duplicate_tabs'):
        for tab_frame in self.anti_duplicate_tabs:
            for widget in tab_frame.winfo_children():
                for child in widget.winfo_children():
                    if hasattr(child, 'config'):
                        try:
                            child.config(state=state)
                        except tk.TclError:
                            pass

def _toggle_http_tuning_controls(self):
    """Enable/disable the HTTP timeout/pooling controls as a group"""
    enabled = bool(self.enable_http_tuning_var.get()) if hasattr(self, 'enable_http_tuning_var') else False
    state = 'normal' if enabled else 'disabled'
    # Entries
    for attr in ['connect_timeout_entry', 'read_timeout_entry', 'http_pool_connections_entry', 'http_pool_maxsize_entry']:
        widget = getattr(self, attr, None)
        if widget is not None:
            try:
                widget.configure(state=state)
            except tk.TclError:
                pass
    # Retry-After checkbox
    if hasattr(self, 'ignore_retry_after_checkbox') and self.ignore_retry_after_checkbox is not None:
        try:
            self.ignore_retry_after_checkbox.configure(state=state)
        except tk.TclError:
            pass
                            
def _reset_anti_duplicate_defaults(self):
    """Reset all anti-duplicate parameters to their default values"""
    import tkinter.messagebox as messagebox
    
    # Ask for confirmation
    if not messagebox.askyesno("Reset Anti-Duplicate Parameters", 
                              "Are you sure you want to reset all anti-duplicate parameters to their default values?"):
        return
    
    # Reset all variables to defaults
    if hasattr(self, 'enable_anti_duplicate_var'):
        self.enable_anti_duplicate_var.set(False)
    
    if hasattr(self, 'top_p_var'):
        self.top_p_var.set(1.0)  # Default = no effect
    
    if hasattr(self, 'top_k_var'):
        self.top_k_var.set(0)  # Default = disabled
    
    if hasattr(self, 'frequency_penalty_var'):
        self.frequency_penalty_var.set(0.0)  # Default = no penalty
    
    if hasattr(self, 'presence_penalty_var'):
        self.presence_penalty_var.set(0.0)  # Default = no penalty
    
    if hasattr(self, 'repetition_penalty_var'):
        self.repetition_penalty_var.set(1.0)  # Default = no penalty
    
    if hasattr(self, 'candidate_count_var'):
        self.candidate_count_var.set(1)  # Default = single response
    
    if hasattr(self, 'custom_stop_sequences_var'):
        self.custom_stop_sequences_var.set("")  # Default = empty
    
    if hasattr(self, 'logit_bias_enabled_var'):
        self.logit_bias_enabled_var.set(False)  # Default = disabled
    
    if hasattr(self, 'logit_bias_strength_var'):
        self.logit_bias_strength_var.set(-0.5)  # Default strength
    
    if hasattr(self, 'bias_common_words_var'):
        self.bias_common_words_var.set(False)  # Default = disabled
    
    if hasattr(self, 'bias_repetitive_phrases_var'):
        self.bias_repetitive_phrases_var.set(False)  # Default = disabled
    
    # Update enable/disable state
    self._toggle_anti_duplicate_controls()
    
    # Show success message
    messagebox.showinfo("Reset Complete", "All anti-duplicate parameters have been reset to their default values.")
    
    # Log the reset
    if hasattr(self, 'append_log'):
        self.append_log("🔄 Anti-duplicate parameters reset to defaults")        

def _create_custom_api_endpoints_section(self, parent_frame):
    """Create the Custom API Endpoints section"""
    # Custom API Endpoints Section
    endpoints_frame = tb.LabelFrame(parent_frame, text="Custom API Endpoints", padding=10)
    endpoints_frame.grid(row=7, column=0, columnspan=2, sticky=tk.NSEW, padx=5, pady=5)
    
    # Checkbox to enable/disable custom endpoint (MOVED TO TOP)
    custom_endpoint_checkbox_frame = tb.Frame(endpoints_frame)
    custom_endpoint_checkbox_frame.pack(fill=tk.X, padx=5, pady=(0, 5))

    self.use_custom_endpoint_checkbox = tb.Checkbutton(
        custom_endpoint_checkbox_frame,
        text="Enable Custom OpenAI Endpoint",
        variable=self.use_custom_openai_endpoint_var,
        command=self.toggle_custom_endpoint_ui,
        bootstyle="primary"
    )
    self.use_custom_endpoint_checkbox.pack(side=tk.LEFT)

    # Main OpenAI Base URL
    openai_url_frame = tb.Frame(endpoints_frame)
    openai_url_frame.pack(fill=tk.X, padx=5, pady=5)

    tb.Label(openai_url_frame, text="Override API Endpoint:").pack(side=tk.LEFT, padx=(0, 5))
    self.openai_base_url_var = tk.StringVar(value=self.config.get('openai_base_url', ''))
    self.openai_base_url_entry = tb.Entry(openai_url_frame, textvariable=self.openai_base_url_var, width=50)
    self.openai_base_url_var.trace('w', self._check_azure_endpoint)
    self.openai_base_url_entry.pack(side=tk.LEFT, fill=tk.X, expand=True, padx=(0, 5))
    
    # Clear button
    self.openai_clear_button = tb.Button(openai_url_frame, text="Clear", 
             command=lambda: self.openai_base_url_var.set(""),
             bootstyle="secondary", width=8)
    self.openai_clear_button.pack(side=tk.LEFT)
    
    # Set initial state based on checkbox
    if not self.use_custom_openai_endpoint_var.get():
        self.openai_base_url_entry.configure(state='disabled')
        self.openai_clear_button.configure(state='disabled')

    # Help text for main field
    help_text = tb.Label(endpoints_frame, 
                        text="Enable checkbox to use custom endpoint. For Ollama: http://localhost:11434/v1",
                        font=('TkDefaultFont', 8), foreground='gray')
    help_text.pack(anchor=tk.W, padx=5, pady=(0, 10))
    
    # ADD AZURE VERSION FRAME HERE (initially hidden):
    self.azure_version_frame = tb.Frame(endpoints_frame)
    # Don't pack it yet - it will be shown/hidden dynamically
    
    tb.Label(self.azure_version_frame, text="Azure API Version:").pack(side=tk.LEFT, padx=(5, 5))
    
    # Update the existing azure_api_version_var with current config and add trace
    self.azure_api_version_var.set(self.config.get('azure_api_version', '2024-08-01-preview'))
    # Add trace to update env var immediately when changed
    self.azure_api_version_var.trace('w', self._update_azure_api_version_env)
    versions = [
        '2025-01-01-preview',  # Latest preview
        '2024-12-01-preview',
        '2024-10-01-preview', 
        '2024-08-01-preview',  # Current default
        '2024-06-01',         # Stable release
        '2024-05-01-preview',
        '2024-04-01-preview',
        '2024-02-01',         # Older stable
        '2023-12-01-preview',
        '2023-10-01-preview',
        '2023-05-15'          # Legacy
    ]
    self.azure_version_combo = ttk.Combobox(
        self.azure_version_frame, 
        textvariable=self.azure_api_version_var,
        values=versions,
        width=20,
        state='normal'
    )
    self.azure_version_combo.pack(side=tk.LEFT, padx=(0, 5))

    # Show More Fields button
    self.show_more_endpoints = False
    self.more_fields_button = tb.Button(endpoints_frame, 
                                       text="▼ Show More Fields", 
                                       command=self.toggle_more_endpoints,
                                       bootstyle="link")
    self.more_fields_button.pack(anchor=tk.W, padx=5, pady=5)

    # Container for additional fields (initially hidden)
    self.additional_endpoints_frame = tb.Frame(endpoints_frame)
    # Don't pack it initially - it's hidden

    # Inside the additional_endpoints_frame:
    # Groq/Local Base URL
    groq_url_frame = tb.Frame(self.additional_endpoints_frame)
    groq_url_frame.pack(fill=tk.X, padx=5, pady=5)

    tb.Label(groq_url_frame, text="Groq/Local Base URL:").pack(side=tk.LEFT, padx=(0, 5))
    self.groq_base_url_var = tk.StringVar(value=self.config.get('groq_base_url', ''))
    self.groq_base_url_entry = tb.Entry(groq_url_frame, textvariable=self.groq_base_url_var, width=50)
    self.groq_base_url_entry.pack(side=tk.LEFT, fill=tk.X, expand=True, padx=(0, 5))
    tb.Button(groq_url_frame, text="Clear", 
             command=lambda: self.groq_base_url_var.set(""),
             bootstyle="secondary", width=8).pack(side=tk.LEFT)

    groq_help = tb.Label(self.additional_endpoints_frame, 
                        text="For vLLM: http://localhost:8000/v1 | For LM Studio: http://localhost:1234/v1",
                        font=('TkDefaultFont', 8), foreground='gray')
    groq_help.pack(anchor=tk.W, padx=5, pady=(0, 5))

    # Fireworks Base URL
    fireworks_url_frame = tb.Frame(self.additional_endpoints_frame)
    fireworks_url_frame.pack(fill=tk.X, padx=5, pady=5)

    tb.Label(fireworks_url_frame, text="Fireworks Base URL:").pack(side=tk.LEFT, padx=(0, 5))
    self.fireworks_base_url_var = tk.StringVar(value=self.config.get('fireworks_base_url', ''))
    self.fireworks_base_url_entry = tb.Entry(fireworks_url_frame, textvariable=self.fireworks_base_url_var, width=50)
    self.fireworks_base_url_entry.pack(side=tk.LEFT, fill=tk.X, expand=True, padx=(0, 5))
    tb.Button(fireworks_url_frame, text="Clear", 
             command=lambda: self.fireworks_base_url_var.set(""),
             bootstyle="secondary", width=8).pack(side=tk.LEFT)

    # Info about multiple endpoints
    info_frame = tb.Frame(self.additional_endpoints_frame)
    info_frame.pack(fill=tk.X, padx=5, pady=10)

    info_text = """💡 Advanced: Use multiple endpoints to run different local LLM servers simultaneously.
    • Use model prefix 'groq/' to route through Groq endpoint
    • Use model prefix 'fireworks/' to route through Fireworks endpoint
    • Most users only need the main OpenAI endpoint above"""

    tb.Label(info_frame, text=info_text, 
            font=('TkDefaultFont', 8), foreground='#0dcaf0',  # Light blue color
            wraplength=600, justify=tk.LEFT).pack(anchor=tk.W)

    # Test Connection button (always visible)
    test_button = tb.Button(endpoints_frame, text="Test Connection", 
                           command=self.test_api_connections,
                           bootstyle="info")
    test_button.pack(pady=10)

    # Gemini OpenAI-Compatible Endpoint (inside additional_endpoints_frame)
    gemini_frame = tb.Frame(self.additional_endpoints_frame)
    gemini_frame.pack(fill=tk.X, padx=5, pady=5)

    # Checkbox for enabling Gemini endpoint
    self.gemini_checkbox = tb.Checkbutton(
        gemini_frame,
        text="Enable Gemini OpenAI-Compatible Endpoint",
        variable=self.use_gemini_openai_endpoint_var,
        command=self.toggle_gemini_endpoint,  # Add the command
        bootstyle="primary"
    )
    self.gemini_checkbox.pack(anchor=tk.W, pady=(5, 5))

    # Gemini endpoint URL input
    gemini_url_frame = tb.Frame(self.additional_endpoints_frame)
    gemini_url_frame.pack(fill=tk.X, padx=5, pady=5)

    tb.Label(gemini_url_frame, text="Gemini OpenAI Endpoint:").pack(side=tk.LEFT, padx=(0, 5))
    self.gemini_endpoint_entry = tb.Entry(gemini_url_frame, textvariable=self.gemini_openai_endpoint_var, width=50)
    self.gemini_endpoint_entry.pack(side=tk.LEFT, fill=tk.X, expand=True, padx=(0, 5))
    self.gemini_clear_button = tb.Button(gemini_url_frame, text="Clear", 
             command=lambda: self.gemini_openai_endpoint_var.set(""),
             bootstyle="secondary", width=8)
    self.gemini_clear_button.pack(side=tk.LEFT)

    # Help text
    gemini_help = tb.Label(self.additional_endpoints_frame, 
                          text="For Gemini rate limit optimization with proxy services (e.g., OpenRouter, LiteLLM)",
                          font=('TkDefaultFont', 8), foreground='gray')
    gemini_help.pack(anchor=tk.W, padx=5, pady=(0, 5))

    # Set initial state based on checkbox
    if not self.use_gemini_openai_endpoint_var.get():
        self.gemini_endpoint_entry.configure(state='disabled')
        self.gemini_clear_button.configure(state='disabled')

def _check_azure_endpoint(self, *args):
    """Check if endpoint is Azure and update UI"""
    if not self.use_custom_openai_endpoint_var.get():
        if hasattr(self, 'azure_version_frame'):
            self.azure_version_frame.pack_forget()
        return
        
    url = self.openai_base_url_var.get()
    if '.azure.com' in url or '.cognitiveservices' in url:
        self.api_key_label.config(text="Azure Key:")
        
        # Show Azure version frame in settings dialog
        if hasattr(self, 'azure_version_frame'):
            self.azure_version_frame.pack(before=self.more_fields_button, pady=(0, 10))
    else:
        self.api_key_label.config(text="OpenAI/Gemini/... API Key:")
        
        # Hide Azure version frame
        if hasattr(self, 'azure_version_frame'):
            self.azure_version_frame.pack_forget()
            
def _update_azure_api_version_env(self, *args):
    """Update the AZURE_API_VERSION environment variable when the setting changes"""
    try:
        api_version = self.azure_api_version_var.get()
        if api_version:
            os.environ['AZURE_API_VERSION'] = api_version
            #print(f"✅ Updated Azure API Version in environment: {api_version}")
    except Exception as e:
        print(f"❌ Error updating Azure API Version environment variable: {e}")

def toggle_gemini_endpoint(self):
    """Enable/disable Gemini endpoint entry based on toggle"""
    if self.use_gemini_openai_endpoint_var.get():
        self.gemini_endpoint_entry.configure(state='normal')
        self.gemini_clear_button.configure(state='normal')
    else:
        self.gemini_endpoint_entry.configure(state='disabled')
        self.gemini_clear_button.configure(state='disabled')
    
def toggle_custom_endpoint_ui(self):
    """Enable/disable the OpenAI base URL entry and detect Azure"""
    if self.use_custom_openai_endpoint_var.get():
        self.openai_base_url_entry.configure(state='normal')
        self.openai_clear_button.configure(state='normal')
        
        # Check if it's Azure
        url = self.openai_base_url_var.get()
        if '.azure.com' in url or '.cognitiveservices' in url:
            self.api_key_label.config(text="Azure Key:")
        else:
            self.api_key_label.config(text="OpenAI/Gemini/... API Key:")
            
        print("✅ Custom OpenAI endpoint enabled")
    else:
        self.openai_base_url_entry.configure(state='disabled')
        self.openai_clear_button.configure(state='disabled')
        self.api_key_label.config(text="OpenAI/Gemini/... API Key:")
        print("❌ Custom OpenAI endpoint disabled - using default OpenAI API")

def toggle_more_endpoints(self):
    """Toggle visibility of additional endpoint fields"""
    self.show_more_endpoints = not self.show_more_endpoints
    
    if self.show_more_endpoints:
        self.additional_endpoints_frame.pack(fill=tk.BOTH, expand=True, after=self.more_fields_button)
        self.more_fields_button.configure(text="▲ Show Fewer Fields")
    else:
        self.additional_endpoints_frame.pack_forget()
        self.more_fields_button.configure(text="▼ Show More Fields")
    
    # Update dialog scrolling if needed
    if hasattr(self, 'current_dialog') and self.current_dialog:
        self.current_dialog.update_idletasks()
        self.current_dialog.canvas.configure(scrollregion=self.current_dialog.canvas.bbox("all"))
             
def test_api_connections(self):
    """Test all configured API connections"""
    # Show immediate feedback
    progress_dialog = tk.Toplevel(self.current_dialog if hasattr(self, 'current_dialog') else self.master)
    progress_dialog.title("Testing Connections...")
    
    # Set icon
    try:
        progress_dialog.iconbitmap("halgakos.ico")
    except:
        pass  # Icon setting failed, continue without icon
    
    # Center the dialog
    progress_dialog.update_idletasks()
    width = 300
    height = 150
    x = (progress_dialog.winfo_screenwidth() // 2) - (width // 2)
    y = (progress_dialog.winfo_screenheight() // 2) - (height // 2)
    progress_dialog.geometry(f"{width}x{height}+{x}+{y}")
    
    # Add progress message
    progress_label = tb.Label(progress_dialog, text="Testing API connections...\nPlease wait...", 
                             font=('TkDefaultFont', 10))
    progress_label.pack(pady=50)
    
    # Force update to show dialog immediately
    progress_dialog.update()
    
    try:
        # Ensure we have the openai module
        import openai
    except ImportError:
        progress_dialog.destroy()
        messagebox.showerror("Error", "OpenAI library not installed")
        return
    
    # Get API key from the main GUI
    api_key = self.api_key_entry.get() if hasattr(self, 'api_key_entry') else self.config.get('api_key', '')
    if not api_key:
        api_key = "sk-dummy-key"  # For local models
    
    # Collect all configured endpoints
    endpoints_to_test = []
    
    # OpenAI endpoint - only test if checkbox is enabled
    if self.use_custom_openai_endpoint_var.get():
        openai_url = self.openai_base_url_var.get()
        if openai_url:
            # Check if it's Azure
            if '.azure.com' in openai_url or '.cognitiveservices' in openai_url:
                # Azure endpoint
                deployment = self.model_var.get() if hasattr(self, 'model_var') else "gpt-35-turbo"
                api_version = self.azure_api_version_var.get() if hasattr(self, 'azure_api_version_var') else "2024-08-01-preview"
                
                # Format Azure URL
                if '/openai/deployments/' not in openai_url:
                    azure_url = f"{openai_url.rstrip('/')}/openai/deployments/{deployment}/chat/completions?api-version={api_version}"
                else:
                    azure_url = openai_url
                
                endpoints_to_test.append(("Azure OpenAI", azure_url, deployment, "azure"))
            else:
                # Regular custom endpoint
                endpoints_to_test.append(("OpenAI (Custom)", openai_url, self.model_var.get() if hasattr(self, 'model_var') else "gpt-3.5-turbo"))
        else:
            # Use default OpenAI endpoint if checkbox is on but no custom URL provided
            endpoints_to_test.append(("OpenAI (Default)", "https://api.openai.com/v1", self.model_var.get() if hasattr(self, 'model_var') else "gpt-3.5-turbo"))
    
    # Groq endpoint
    if hasattr(self, 'groq_base_url_var'):
        groq_url = self.groq_base_url_var.get()
        if groq_url:
            # For Groq, we need a groq-prefixed model
            current_model = self.model_var.get() if hasattr(self, 'model_var') else "llama-3-70b"
            groq_model = current_model if current_model.startswith('groq/') else current_model.replace('groq/', '')
            endpoints_to_test.append(("Groq/Local", groq_url, groq_model))
    
    # Fireworks endpoint
    if hasattr(self, 'fireworks_base_url_var'):
        fireworks_url = self.fireworks_base_url_var.get()
        if fireworks_url:
            # For Fireworks, we need the accounts/ prefix
            current_model = self.model_var.get() if hasattr(self, 'model_var') else "llama-v3-70b-instruct"
            fw_model = current_model if current_model.startswith('accounts/') else f"accounts/fireworks/models/{current_model.replace('fireworks/', '')}"
            endpoints_to_test.append(("Fireworks", fireworks_url, fw_model))
    
    # Gemini OpenAI-Compatible endpoint
    if hasattr(self, 'use_gemini_openai_endpoint_var') and self.use_gemini_openai_endpoint_var.get():
        gemini_url = self.gemini_openai_endpoint_var.get()
        if gemini_url:
            # Ensure the endpoint ends with /openai/ for compatibility
            if not gemini_url.endswith('/openai/'):
                if gemini_url.endswith('/'):
                    gemini_url = gemini_url + 'openai/'
                else:
                    gemini_url = gemini_url + '/openai/'
            
            # For Gemini OpenAI-compatible endpoints, use the current model or a suitable default
            current_model = self.model_var.get() if hasattr(self, 'model_var') else "gemini-2.0-flash-exp"
            # Remove any 'gemini/' prefix for the OpenAI-compatible endpoint
            gemini_model = current_model.replace('gemini/', '') if current_model.startswith('gemini/') else current_model
            endpoints_to_test.append(("Gemini (OpenAI-Compatible)", gemini_url, gemini_model))
    
    if not endpoints_to_test:
        messagebox.showinfo("Info", "No custom endpoints configured. Using default API endpoints.")
        return
    
    # Test each endpoint
    # Test each endpoint
    results = []
    for endpoint_info in endpoints_to_test:
        if len(endpoint_info) == 4 and endpoint_info[3] == "azure":
            # Azure endpoint
            name, base_url, model, endpoint_type = endpoint_info
            try:
                # Azure uses different headers
                import requests
                headers = {
                    "api-key": api_key,
                    "Content-Type": "application/json"
                }
                
                response = requests.post(
                    base_url,
                    headers=headers,
                    json={
                        "messages": [{"role": "user", "content": "Hi"}],
                        "max_tokens": 5
                    },
                    timeout=5.0
                )
                
                if response.status_code == 200:
                    results.append(f"✅ {name}: Connected successfully! (Deployment: {model})")
                else:
                    results.append(f"❌ {name}: {response.status_code} - {response.text[:100]}")
                    
            except Exception as e:
                error_msg = str(e)[:100]
                results.append(f"❌ {name}: {error_msg}")
        else:
            # Regular OpenAI-compatible endpoint
            name, base_url, model = endpoint_info[:3]
            try:
                # Create client for this endpoint
                test_client = openai.OpenAI(
                    api_key=api_key,
                    base_url=base_url,
                    timeout=5.0  # Short timeout for testing
                )
                
                # Try a minimal completion
                response = test_client.chat.completions.create(
                    model=model,
                    messages=[{"role": "user", "content": "Hi"}],
                    max_tokens=5
                )
                
                results.append(f"✅ {name}: Connected successfully! (Model: {model})")
            except Exception as e:
                error_msg = str(e)
                # Simplify common error messages
                if "404" in error_msg:
                    error_msg = "404 - Endpoint not found. Check URL and model name."
                elif "401" in error_msg or "403" in error_msg:
                    error_msg = "Authentication failed. Check API key."
                elif "model" in error_msg.lower() and "not found" in error_msg.lower():
                    error_msg = f"Model '{model}' not found at this endpoint."
                
                results.append(f"❌ {name}: {error_msg}")
    
    # Show results
    result_message = "Connection Test Results:\n\n" + "\n\n".join(results)
    
    # Close progress dialog
    progress_dialog.destroy()
    
    # Determine if all succeeded
    all_success = all("✅" in r for r in results)
    
    if all_success:
        messagebox.showinfo("Success", result_message)
    else:
        messagebox.showwarning("Test Results", result_message)
    
def _create_settings_buttons(self, parent, dialog, canvas):
    """Create save and close buttons for settings dialog"""
    button_frame = tk.Frame(parent)
    button_frame.grid(row=3, column=0, columnspan=2, pady=(10, 10))
    
    button_container = tk.Frame(button_frame)
    button_container.pack(expand=True)

    def save_and_close():
        try:
            # Use the main save_config method which handles all config AND environment variables
            # This ensures consistency and reduces duplicate code
            self.save_config(show_message=False)
            
            # Log success and close dialog
            self.append_log("✅ Other Settings saved successfully")
            dialog.destroy()
            
        except Exception as e:
            print(f"❌ Failed to save Other Settings: {e}")
            messagebox.showerror("Error", f"Failed to save settings: {e}")

    tb.Button(button_container, text="💾 Save Settings", command=save_and_close, 
             bootstyle="success", width=20).pack(side=tk.LEFT, padx=5)

    tb.Button(button_container, text="❌ Cancel", command=lambda: [dialog._cleanup_scrolling(), dialog.destroy()], 
             bootstyle="secondary", width=20).pack(side=tk.LEFT, padx=5)       

def delete_translated_headers_file(self):
    """Delete the translated_headers.txt file from the output directory for all selected EPUBs"""
    try:
        # Get all selected EPUB files using the same logic as QA scanner
        epub_files_to_process = []
        
        # First check if current selection actually contains EPUBs
        if hasattr(self, 'selected_files') and self.selected_files:
            current_epub_files = [f for f in self.selected_files if f.lower().endswith('.epub')]
            if current_epub_files:
                epub_files_to_process = current_epub_files
                self.append_log(f"📚 Found {len(epub_files_to_process)} EPUB files in current selection")
        
        # If no EPUBs in selection, try single EPUB methods
        if not epub_files_to_process:
            epub_path = self.get_current_epub_path()
            if not epub_path:
                entry_path = self.entry_epub.get().strip()
                if entry_path and entry_path != "No file selected" and os.path.exists(entry_path):
                    epub_path = entry_path
            
            if epub_path:
                epub_files_to_process = [epub_path]
        
        if not epub_files_to_process:
            messagebox.showerror("Error", "No EPUB file(s) selected. Please select EPUB file(s) first.")
            return
        
        # Process each EPUB file to find and delete translated_headers.txt
        files_found = []
        files_not_found = []
        files_deleted = []
        errors = []
        
        current_dir = os.getcwd()
        script_dir = os.path.dirname(os.path.abspath(__file__))
        
        # First pass: scan for files
        for epub_path in epub_files_to_process:
            try:
                epub_base = os.path.splitext(os.path.basename(epub_path))[0]
                self.append_log(f"🔍 Processing EPUB: {epub_base}")
                
                # Check the most common locations in order of priority (same as QA scanner)
                candidates = [
                    os.path.join(current_dir, epub_base),        # current working directory
                    os.path.join(script_dir, epub_base),         # src directory (where output typically goes)
                    os.path.join(current_dir, 'src', epub_base), # src subdirectory from current dir
                ]
                
                output_dir = None
                for candidate in candidates:
                    if os.path.isdir(candidate):
                        # Verify the folder actually contains HTML/XHTML files
                        try:
                            files = os.listdir(candidate)
                            html_files = [f for f in files if f.lower().endswith(('.html', '.xhtml', '.htm'))]
                            if html_files:
                                output_dir = candidate
                                break
                        except Exception:
                            continue
                
                if not output_dir:
                    self.append_log(f"  ⚠️ No output directory found for {epub_base}")
                    files_not_found.append((epub_base, "No output directory found"))
                    continue
                
                # Look for translated_headers.txt in the output directory
                headers_file = os.path.join(output_dir, "translated_headers.txt")
                
                if os.path.exists(headers_file):
                    files_found.append((epub_base, headers_file))
                    self.append_log(f"  ✓ Found translated_headers.txt in {os.path.basename(output_dir)}")
                else:
                    files_not_found.append((epub_base, "translated_headers.txt not found"))
                    self.append_log(f"  ⚠️ No translated_headers.txt in {os.path.basename(output_dir)}")
                    
            except Exception as e:
                epub_base = os.path.splitext(os.path.basename(epub_path))[0]
                errors.append((epub_base, str(e)))
                self.append_log(f"  ❌ Error processing {epub_base}: {e}")
        
        # Show summary and get user confirmation
        if not files_found and not files_not_found and not errors:
            messagebox.showinfo("No Files", "No EPUB files were processed.")
            return
        
        summary_text = f"Summary for {len(epub_files_to_process)} EPUB file(s):\n\n"
        
        if files_found:
            summary_text += f"✅ Files to delete ({len(files_found)}):\n"
            for epub_base, file_path in files_found:
                summary_text += f"  • {epub_base}\n"
            summary_text += "\n"
        
        if files_not_found:
            summary_text += f"⚠️ Files not found ({len(files_not_found)}):\n"
            for epub_base, reason in files_not_found:
                summary_text += f"  • {epub_base}: {reason}\n"
            summary_text += "\n"
        
        if errors:
            summary_text += f"❌ Errors ({len(errors)}):\n"
            for epub_base, error in errors:
                summary_text += f"  • {epub_base}: {error}\n"
            summary_text += "\n"
        
        if files_found:
            summary_text += "This will allow headers to be re-translated on the next run."
            
            # Confirm deletion
            result = messagebox.askyesno("Confirm Deletion", summary_text)
            
            if result:
                # Delete the files
                for epub_base, headers_file in files_found:
                    try:
                        os.remove(headers_file)
                        files_deleted.append(epub_base)
                        self.append_log(f"✅ Deleted translated_headers.txt from {epub_base}")
                    except Exception as e:
                        errors.append((epub_base, f"Delete failed: {e}"))
                        self.append_log(f"❌ Failed to delete translated_headers.txt from {epub_base}: {e}")
                
                # Show final results
                if files_deleted:
                    success_msg = f"Successfully deleted {len(files_deleted)} file(s):\n"
                    success_msg += "\n".join([f"• {epub_base}" for epub_base in files_deleted])
                    if errors:
                        success_msg += f"\n\nErrors: {len(errors)} file(s) failed to delete."
                    messagebox.showinfo("Success", success_msg)
                else:
                    messagebox.showerror("Error", "No files were successfully deleted.")
        else:
            # No files to delete
            messagebox.showinfo("No Files to Delete", summary_text)
        
    except Exception as e:
        self.append_log(f"❌ Error deleting translated_headers.txt: {e}")
        messagebox.showerror("Error", f"Failed to delete file: {e}")

def validate_epub_structure_gui(self):
    """GUI wrapper for EPUB structure validation"""
    input_path = self.entry_epub.get()
    if not input_path:
        messagebox.showerror("Error", "Please select a file first.")
        return
    
    if input_path.lower().endswith('.txt'):
        messagebox.showinfo("Info", "Structure validation is only available for EPUB files.")
        return
    
    epub_base = os.path.splitext(os.path.basename(input_path))[0]
    output_dir = epub_base
    
    if not os.path.exists(output_dir):
        messagebox.showinfo("Info", f"No output directory found: {output_dir}")
        return
    
    self.append_log("🔍 Validating EPUB structure...")
    
    try:
        from TransateKRtoEN import validate_epub_structure, check_epub_readiness
        
        structure_ok = validate_epub_structure(output_dir)
        readiness_ok = check_epub_readiness(output_dir)
        
        if structure_ok and readiness_ok:
            self.append_log("✅ EPUB validation PASSED - Ready for compilation!")
            messagebox.showinfo("Validation Passed", 
                              "✅ All EPUB structure files are present!\n\n"
                              "Your translation is ready for EPUB compilation.")
        elif structure_ok:
            self.append_log("⚠️ EPUB structure OK, but some issues found")
            messagebox.showwarning("Validation Warning", 
                                 "⚠️ EPUB structure is mostly OK, but some issues were found.\n\n"
                                 "Check the log for details.")
        else:
            self.append_log("❌ EPUB validation FAILED - Missing critical files")
            messagebox.showerror("Validation Failed", 
                               "❌ Missing critical EPUB files!\n\n"
                               "container.xml and/or OPF files are missing.\n"
                               "Try re-running the translation to extract them.")
    
    except ImportError as e:
        self.append_log(f"❌ Could not import validation functions: {e}")
        messagebox.showerror("Error", "Validation functions not available.")
    except Exception as e:
        self.append_log(f"❌ Validation error: {e}")
        messagebox.showerror("Error", f"Validation failed: {e}")

def on_profile_select(self, event=None):
    """Load the selected profile's prompt into the text area."""
    name = self.profile_var.get()
    prompt = self.prompt_profiles.get(name, "")
    self.prompt_text.delete("1.0", tk.END)
    self.prompt_text.insert("1.0", prompt)
    self.config['active_profile'] = name

def save_profile(self):
    """Save current prompt under selected profile and persist."""
    name = self.profile_var.get().strip()
    if not name:
        messagebox.showerror("Error", "Profile cannot be empty.")
        return
    content = self.prompt_text.get('1.0', tk.END).strip()
    self.prompt_profiles[name] = content
    self.config['prompt_profiles'] = self.prompt_profiles
    self.config['active_profile'] = name
    self.profile_menu['values'] = list(self.prompt_profiles.keys())
    messagebox.showinfo("Saved", f"Profile '{name}' saved.")
    self.save_profiles()

def delete_profile(self):
    """Delete the selected profile."""
    name = self.profile_var.get()
    if name not in self.prompt_profiles:
        messagebox.showerror("Error", f"Profile '{name}' not found.")
        return
    if messagebox.askyesno("Delete", f"Are you sure you want to delete language '{name}'?"):
        del self.prompt_profiles[name]
        self.config['prompt_profiles'] = self.prompt_profiles
        if self.prompt_profiles:
            new = next(iter(self.prompt_profiles))
            self.profile_var.set(new)
            self.on_profile_select()
        else:
            self.profile_var.set("")
            self.prompt_text.delete('1.0', tk.END)
        self.profile_menu['values'] = list(self.prompt_profiles.keys())
        self.save_profiles()

def save_profiles(self):
    """Persist only the prompt profiles and active profile."""
    try:
        data = {}
        if os.path.exists(CONFIG_FILE):
            with open(CONFIG_FILE, 'r', encoding='utf-8') as f:
                data = json.load(f)
        data['prompt_profiles'] = self.prompt_profiles
        data['active_profile'] = self.profile_var.get()
        with open(CONFIG_FILE, 'w', encoding='utf-8') as f:
            json.dump(data, f, ensure_ascii=False, indent=2)
    except Exception as e:
        messagebox.showerror("Error", f"Failed to save profiles: {e}")

def import_profiles(self):
    """Import profiles from a JSON file, merging into existing ones."""
    path = filedialog.askopenfilename(title="Import Profiles", filetypes=[("JSON files","*.json")])
    if not path:
        return
    try:
        with open(path, 'r', encoding='utf-8') as f:
            data = json.load(f)
        self.prompt_profiles.update(data)
        self.config['prompt_profiles'] = self.prompt_profiles
        self.profile_menu['values'] = list(self.prompt_profiles.keys())
        messagebox.showinfo("Imported", f"Imported {len(data)} profiles.")
    except Exception as e:
        messagebox.showerror("Error", f"Failed to import profiles: {e}")

def export_profiles(self):
    """Export all profiles to a JSON file."""
    path = filedialog.asksaveasfilename(title="Export Profiles", defaultextension=".json", 
                                      filetypes=[("JSON files","*.json")])
    if not path:
        return
    try:
        with open(path, 'w', encoding='utf-8') as f:
            json.dump(self.prompt_profiles, f, ensure_ascii=False, indent=2)
        messagebox.showinfo("Exported", f"Profiles exported to {path}.")
    except Exception as e:
        messagebox.showerror("Error", f"Failed to export profiles: {e}")