QuickFFSync.py

# IMPORTS

# Standard library
import ctypes.wintypes
import os
from shutil import move
import subprocess
import sys
import tempfile
import time
import wave
import tkinter as tk
from collections import OrderedDict
from datetime import datetime
from io import BytesIO
from json import dump, load
from re import sub, search, compile, IGNORECASE
from shlex import split
from threading import Event, Thread, Timer
from tkinter import filedialog, messagebox, simpledialog
from winsound import MB_ICONASTERISK, MessageBeep

# Third-party
import customtkinter as ctk
from CTkToolTip import CTkToolTip
from PIL import Image
import pyaudiowpatch as pyaudio

# Win32 constants
GWL_WNDPROC = -4
WM_DROPFILES = 0x0233
CF_UNICODETEXT = 13
GMEM_MOVEABLE = 0x0002

# Tray icon Win32 constants
WM_USER_TRAY = 0x8000
NIF_MESSAGE = 0x01
NIF_ICON = 0x02
NIF_TIP = 0x04
NIM_ADD = 0x00
NIM_DELETE = 0x02
MF_STRING = 0x00
MF_SEPARATOR = 0x800
TPM_RIGHTBUTTON = 0x02
TPM_RETURNCMD = 0x0100
IDM_START_RECORDING = 1001
IDM_STOP_RECORDING = 1002
IDM_OPEN_APP = 1003
IDM_EXIT = 1004

# Process snapshot constants for killing only our ffmpeg.exe
TH32CS_SNAPPROCESS = 0x00000002
PROCESS_QUERY_INFORMATION = 0x0400
PROCESS_VM_READ = 0x0010
PROCESS_TERMINATE = 0x0001


class PROCESSENTRY32W(ctypes.Structure):
    _fields_ = [
        ("dwSize", ctypes.wintypes.DWORD),
        ("cntUsage", ctypes.wintypes.DWORD),
        ("th32ProcessID", ctypes.wintypes.DWORD),
        ("th32DefaultHeapID", ctypes.c_size_t),
        ("th32ModuleID", ctypes.wintypes.DWORD),
        ("cntThreads", ctypes.wintypes.DWORD),
        ("th32ParentProcessID", ctypes.wintypes.DWORD),
        ("pcPriClassBase", ctypes.c_long),
        ("dwFlags", ctypes.wintypes.DWORD),
        ("szExeFile", ctypes.c_wchar * 260),
    ]


# Hotkey Win32 constants
WM_HOTKEY = 0x0312
MOD_ALT = 0x0001
VK_F8 = 0x77
VK_F9 = 0x78
HOTKEY_START_ID = 1003
HOTKEY_STOP_ID = 1004

# Tray icon Win32 constants
NIM_ADD = 0x00
NIM_MODIFY = 0x01
NIM_DELETE = 0x02
NIF_MESSAGE = 0x01
NIF_ICON = 0x02
NIF_TIP = 0x04
NIF_INFO = 0x10

# Win32 callback type for window procedures
WNDPROC = ctypes.WINFUNCTYPE(
    ctypes.c_long,
    ctypes.wintypes.HWND,
    ctypes.wintypes.UINT,
    ctypes.wintypes.WPARAM,
    ctypes.wintypes.LPARAM,
)

# Shell32 — Drag-and-Drop
_shell32 = ctypes.windll.shell32
_shell32.DragAcceptFiles.argtypes = [ctypes.wintypes.HWND, ctypes.wintypes.BOOL]
_shell32.Shell_NotifyIconW.argtypes = [ctypes.wintypes.DWORD, ctypes.c_void_p]
_shell32.Shell_NotifyIconW.restype = ctypes.wintypes.BOOL
_shell32.DragAcceptFiles.restype = None
_shell32.DragFinish.argtypes = [ctypes.wintypes.HANDLE]
_shell32.DragFinish.restype = None
_shell32.DragQueryFileW.argtypes = [
    ctypes.wintypes.HANDLE,
    ctypes.wintypes.UINT,
    ctypes.wintypes.LPWSTR,
    ctypes.wintypes.UINT,
]
_shell32.DragQueryFileW.restype = ctypes.wintypes.UINT

# User32 — Window Proc & Clipboard
_user32 = ctypes.windll.user32
_user32.SetWindowLongPtrW.argtypes = [
    ctypes.wintypes.HWND,
    ctypes.c_int,
    ctypes.c_void_p,
]
_user32.SetWindowLongPtrW.restype = ctypes.c_void_p
_user32.CallWindowProcW.argtypes = [
    ctypes.c_void_p,
    ctypes.wintypes.HWND,
    ctypes.wintypes.UINT,
    ctypes.wintypes.WPARAM,
    ctypes.wintypes.LPARAM,
]
_user32.CallWindowProcW.restype = ctypes.c_long
_user32.OpenClipboard.argtypes = [ctypes.wintypes.HWND]
_user32.OpenClipboard.restype = ctypes.wintypes.BOOL
_user32.CloseClipboard.argtypes = []
_user32.CloseClipboard.restype = ctypes.wintypes.BOOL
_user32.EmptyClipboard.argtypes = []
_user32.EmptyClipboard.restype = ctypes.wintypes.BOOL
_user32.SetClipboardData.argtypes = [ctypes.wintypes.UINT, ctypes.wintypes.HANDLE]
_user32.SetClipboardData.restype = ctypes.wintypes.HANDLE

# Kernel32 — GlobalAlloc for clipboard
_kernel32 = ctypes.windll.kernel32
_kernel32.GlobalAlloc.argtypes = [ctypes.wintypes.UINT, ctypes.c_size_t]
_kernel32.GlobalAlloc.restype = ctypes.wintypes.HANDLE
_kernel32.GlobalLock.argtypes = [ctypes.wintypes.HANDLE]
_kernel32.GlobalLock.restype = ctypes.c_void_p
_kernel32.GlobalUnlock.argtypes = [ctypes.wintypes.HANDLE]
_kernel32.GlobalUnlock.restype = ctypes.wintypes.BOOL
_kernel32.GlobalFree.argtypes = [ctypes.wintypes.HANDLE]
_kernel32.GlobalFree.restype = ctypes.wintypes.HANDLE


def _set_clipboard_text(text: str) -> bool:
    """Copy Unicode text to the Windows clipboard using ctypes."""
    encoded = text.encode("utf-16-le") + b"\x00\x00"

    # Allocate global movable memory
    h_mem = _kernel32.GlobalAlloc(GMEM_MOVEABLE, len(encoded))
    if not h_mem:
        return False

    ptr = _kernel32.GlobalLock(h_mem)
    if not ptr:
        _kernel32.GlobalFree(h_mem)
        return False

    try:
        ctypes.memmove(ptr, encoded, len(encoded))
    finally:
        _kernel32.GlobalUnlock(h_mem)

    if not _user32.OpenClipboard(None):
        _kernel32.GlobalFree(h_mem)
        return False

    try:
        _user32.EmptyClipboard()

        # If SetClipboardData succeeds, ownership of h_mem
        # transfers to the system. We must NOT free it.
        if not _user32.SetClipboardData(CF_UNICODETEXT, h_mem):
            _kernel32.GlobalFree(h_mem)
            return False

    finally:
        _user32.CloseClipboard()

    return True


def get_icon_path():
    if getattr(sys, "frozen", False):
        base_path = os.path.dirname(sys.executable)
    else:
        base_path = os.path.dirname(__file__)
    return os.path.join(base_path, "qff.ico")


def get_real_dpi():
    """Get the actual DPI taking system scaling into account"""
    user32 = ctypes.windll.user32
    shcore = ctypes.windll.shcore

    try:
        awareness = ctypes.c_int(2)
        user32.SetProcessDpiAwarenessContext(awareness)
    except Exception:
        try:
            shcore.SetProcessDpiAwareness(2)
        except Exception:
            user32.SetProcessDPIAware()

    try:
        hwnd = user32.GetForegroundWindow()
        dpi = user32.GetDpiForWindow(hwnd)
        if dpi == 0:
            dpi = user32.GetDpiForSystem()
    except Exception:
        gdi32 = ctypes.windll.gdi32
        hdc = user32.GetDC(0)
        dpi = gdi32.GetDeviceCaps(hdc, 88)
        user32.ReleaseDC(0, hdc)

    return dpi


def is_us_english_layout():
    """Return True if the current keyboard layout is US English (0x0409)."""
    try:
        user32 = ctypes.windll.user32
        # Get keyboard layout for the current thread
        hkl = user32.GetKeyboardLayout(0)
        # Language ID is the low 16 bits
        lang_id = hkl & 0xFFFF
        return lang_id == 0x0409  # 0x0409 = US English
    except Exception:
        return False  # On error, assume not English (or fall back to default)


# UI THEME
# ctk.ThemeManager.theme["CTkFont"].update({"family": "Segoe UI", "size": 12})
# ctk.set_window_scaling(2.0)
# ctk.set_widget_scaling(2.0)
ctk.set_appearance_mode("dark")
PRIMARY_BG = "#151f43"
SECONDARY_BG = "#202e5d"
ACCENT_BLUE = "#0d9fea"
HOVER_BLUE = "#096cad"
ACCENT_DEEPBLUE = "#070d2d"
HOVER_DEEPBLUE = "#172e9f"
ACCENT_RED = "#FF5555"
HOVER_RED = "#d83636"
TEXT_COLOR_W = "#FFFFFF"
TEXT_COLOR_B = "#000000"
PLACEHOLDER_COLOR = "#A0A0A0"

# Supported video extensions (used for drag-and-drop and file dialog filters)
VIDEO_EXTENSIONS = (
    ".mp4",
    ".mkv",
    ".avi",
    ".mov",
    ".flv",
    ".wmv",
    ".webm",
    ".ts",
    ".m4v",
    ".mpg",
    ".mpeg",
    ".m2ts",
    ".mts",
    ".3gp",
    ".ogv",
    ".ogm",
    ".vob",
    ".f4v",
    ".asf",
    ".divx",
)
VIDEO_EXTENSIONS_FILTER = (
    "Video Files",
    "*.mp4 *.mkv *.avi *.mov *.flv *.wmv *.webm *.ts *.m4v"
    " *.mpg *.mpeg *.m2ts *.mts *.3gp *.ogv *.ogm *.vob *.f4v *.asf *.divx",
)


class TextCheckbox(ctk.CTkFrame):
    def __init__(self, master=None, text="", variable=None, command=None, **kwargs):
        super().__init__(master, **kwargs)
        self.configure(fg_color="transparent")

        self.var = variable if variable is not None else ctk.BooleanVar()
        self.command = command

        self.unchecked_char = "▼"
        self.checked_char = "▲"

        # Main container for checkbox and text
        self.container = ctk.CTkFrame(self, fg_color="transparent")
        self.container.pack(anchor="w", fill="x")

        # Checkbox as a label
        self.checkbox_label = ctk.CTkLabel(
            self.container,
            text=self.unchecked_char,
            width=24,
            height=24,
            corner_radius=6,
            fg_color=ACCENT_BLUE,
            text_color=TEXT_COLOR_W,
            cursor="hand2",
        )
        self.checkbox_label.pack(side="left", padx=(0, 8))

        # Text label
        self.text_label = ctk.CTkLabel(
            self.container,
            text=text,
            cursor="hand2",
        )
        self.text_label.pack(side="left", fill="x", expand=True)

        # Bind click events to both labels
        self.checkbox_label.bind("<Button-1>", self.toggle)
        self.text_label.bind("<Button-1>", self.toggle)

        # Add hover effects
        self.checkbox_label.bind("<Enter>", self._on_hover)
        self.checkbox_label.bind("<Leave>", self._on_leave)
        self.text_label.bind("<Enter>", self._on_hover)
        self.text_label.bind("<Leave>", self._on_leave)

        self.var.trace_add("write", self.update_display)

    def _on_hover(self, event):
        self.checkbox_label.configure(fg_color=HOVER_BLUE)

    def _on_leave(self, event):
        self.checkbox_label.configure(fg_color=ACCENT_BLUE)

    def toggle(self, event=None):
        self.var.set(not self.var.get())
        if self.command:
            self.command()

    def update_display(self, *args):
        if self.var.get():
            self.checkbox_label.configure(text=self.checked_char)
        else:
            self.checkbox_label.configure(text=self.unchecked_char)


class CTkContextMenu(ctk.CTkToplevel):
    def __init__(self, master, target_widget, app_instance, **kwargs):
        super().__init__(master, **kwargs)
        self.target_widget = target_widget
        self.app_instance = app_instance

        self.withdraw()  # Hide right away while configuring

        # Hide from taskbar securely on Windows
        self.transient(master)
        self.overrideredirect(True)
        if sys.platform == "win32":
            self.attributes("-toolwindow", True)

        self.attributes("-topmost", True)

        # Create a true transparent color for the surrounding corners
        transparent_color = "#000001" if sys.platform == "win32" else PRIMARY_BG
        self.configure(fg_color=transparent_color)

        # Apply transparency to the corners (Win32)
        if sys.platform == "win32":
            self.attributes("-transparentcolor", transparent_color)

        # Frame to hold buttons, with corner_radius=10
        self.frame = ctk.CTkFrame(
            self,
            fg_color=ACCENT_DEEPBLUE,
            bg_color=transparent_color,
            corner_radius=10,
            border_width=0,
        )
        self.frame.pack(fill="both", expand=True)

        self._add_button("Cut", self._cut)
        self._add_button("Copy", self._copy)
        self._add_button("Paste", self._paste)
        self._add_button("Delete", self._delete)
        self._add_button("Select All", self._select_all)

        self.bind("<FocusOut>", self._on_focus_out)

    def _on_focus_out(self, event=None):
        self.withdraw()

    def _add_button(self, text, command):
        btn = ctk.CTkButton(
            self.frame,
            text=text,
            fg_color="transparent",
            hover_color=HOVER_DEEPBLUE,
            text_color=TEXT_COLOR_W,
            anchor="w",
            corner_radius=6,
            height=28,
            width=120,
            command=command,
        )
        # Extra padding to ensure buttons don't clip the corners
        btn.pack(fill="x", padx=3, pady=3)

    def _execute_action(self, action_func):
        if not self.target_widget or not self.target_widget.winfo_exists():
            self.withdraw()
            return
        self.target_widget.focus_set()
        # Delay the action to allow FocusIn events to clear the placeholder text
        self.target_widget.after(50, action_func)
        self.withdraw()

    def _select_all(self):
        self._execute_action(self.app_instance._select_all)

    def _copy(self):
        self._execute_action(self.app_instance._copy_text)

    def _cut(self):
        self._execute_action(self.app_instance._cut_text)

    def _paste(self):
        self._execute_action(self.app_instance._paste_text)

    def _delete(self):
        self._execute_action(self.app_instance._delete_text)

    def destroy(self):
        self.target_widget = None
        self.app_instance = None
        self.frame = None
        super().destroy()


# DRAG N DROP FILES
class DropTarget:
    def __init__(self, hwnd, callback):
        self.hwnd = hwnd
        self.callback = callback
        _shell32.DragAcceptFiles(self.hwnd, True)

        # Wrap _wnd_proc in WNDPROC and keep a reference to prevent GC
        self._wndproc_func = WNDPROC(self._wnd_proc)
        self.old_wnd_proc = _user32.SetWindowLongPtrW(
            self.hwnd,
            GWL_WNDPROC,
            ctypes.cast(self._wndproc_func, ctypes.c_void_p).value,
        )
        self._self_ref = self  # important

    def _wnd_proc(self, hwnd, msg, wparam, lparam):
        if msg == WM_DROPFILES:
            try:
                hdrop = wparam

                # Get number of files dropped
                file_count = _shell32.DragQueryFileW(hdrop, 0xFFFFFFFF, None, 0)

                for i in range(file_count):
                    # Get required length
                    length = _shell32.DragQueryFileW(hdrop, i, None, 0)

                    # Allocate buffer dynamically
                    buffer = ctypes.create_unicode_buffer(length + 1)

                    _shell32.DragQueryFileW(hdrop, i, buffer, length + 1)
                    file_path = buffer.value

                    if self.callback:
                        self.callback(file_path)

                _shell32.DragFinish(hdrop)

            except Exception as e:
                print(f"Error handling drop: {e}")

            return 0

        return _user32.CallWindowProcW(self.old_wnd_proc, hwnd, msg, wparam, lparam)

    def cleanup(self):
        """Clean up the drop target - call this before destroying the window"""
        try:
            if hasattr(self, "old_wnd_proc") and self.old_wnd_proc:
                _user32.SetWindowLongPtrW(self.hwnd, GWL_WNDPROC, self.old_wnd_proc)
        except Exception:
            # Silently ignore cleanup errors — not critical
            pass


class TrayIcon:
    """System tray icon with a right-click context menu for screen recording control."""

    class _NOTIFYICONDATA(ctypes.Structure):
        _fields_ = [
            ("cbSize", ctypes.wintypes.DWORD),
            ("hWnd", ctypes.wintypes.HWND),
            ("uID", ctypes.wintypes.UINT),
            ("uFlags", ctypes.wintypes.UINT),
            ("uCallbackMessage", ctypes.wintypes.UINT),
            ("hIcon", ctypes.wintypes.HANDLE),
            ("szTip", ctypes.c_wchar * 128),
            ("dwState", ctypes.wintypes.DWORD),
            ("dwStateMask", ctypes.wintypes.DWORD),
            ("szInfo", ctypes.c_wchar * 256),
            ("uTimeout", ctypes.wintypes.UINT),
            ("szInfoTitle", ctypes.c_wchar * 64),
            ("dwInfoFlags", ctypes.wintypes.DWORD),
        ]

    def __init__(
        self,
        hwnd,
        icon_path,
        on_start_callback,
        on_stop_callback,
        on_open_callback,
        on_exit_callback,
        version="",
    ):
        self.hwnd = hwnd
        self.on_start = on_start_callback
        self.on_stop = on_stop_callback
        self.on_open = on_open_callback
        self.on_exit = on_exit_callback
        self.version = version
        self._active = False

        _user32.LoadImageW.restype = ctypes.wintypes.HANDLE
        _user32.LoadImageW.argtypes = [
            ctypes.wintypes.HINSTANCE,
            ctypes.wintypes.LPCWSTR,
            ctypes.wintypes.UINT,
            ctypes.c_int,
            ctypes.c_int,
            ctypes.wintypes.UINT,
        ]
        LR_LOADFROMFILE = 0x0010
        IMAGE_ICON = 1
        self._hicon = _user32.LoadImageW(
            None, icon_path, IMAGE_ICON, 16, 16, LR_LOADFROMFILE
        )
        if not self._hicon:
            self._hicon = _user32.LoadIconW(None, ctypes.wintypes.LPCWSTR(32512))

        self._prev_wndproc = None
        self._wndproc_ref = WNDPROC(self._wnd_proc)
        self._prev_wndproc = _user32.SetWindowLongPtrW(
            self.hwnd,
            GWL_WNDPROC,
            ctypes.cast(self._wndproc_ref, ctypes.c_void_p).value,
        )

        # Register global hotkeys
        _user32.RegisterHotKey(self.hwnd, HOTKEY_START_ID, MOD_ALT, VK_F8)
        _user32.RegisterHotKey(self.hwnd, HOTKEY_STOP_ID, MOD_ALT, VK_F9)

    def _nid(self):
        nid = self._NOTIFYICONDATA()
        nid.cbSize = ctypes.sizeof(self._NOTIFYICONDATA)
        nid.hWnd = self.hwnd
        nid.uID = 1
        nid.uFlags = NIF_MESSAGE | NIF_ICON | NIF_TIP
        nid.uCallbackMessage = WM_USER_TRAY
        nid.hIcon = self._hicon
        nid.szTip = f"QuickFFSync {self.version}"
        return nid

    def show(self):
        if self._active:
            return
        nid = self._nid()
        _shell32.Shell_NotifyIconW(NIM_ADD, ctypes.byref(nid))
        self._active = True

    def show_balloon(self, title, message):
        """Show a Windows balloon notification from the tray icon."""
        if not self._active:
            self.show()
        nid = self._nid()
        nid.uFlags |= NIF_INFO
        nid.szInfo = message
        nid.szInfoTitle = title
        nid.dwInfoFlags = 1  # NIIF_INFO
        _shell32.Shell_NotifyIconW(NIM_MODIFY, ctypes.byref(nid))

    def hide(self):
        if not self._active:
            return
        nid = self._nid()
        _shell32.Shell_NotifyIconW(NIM_DELETE, ctypes.byref(nid))
        self._active = False

    def _show_context_menu(self):
        hmenu = _user32.CreatePopupMenu()
        _user32.AppendMenuW(
            hmenu, MF_STRING, IDM_START_RECORDING, "Start Recording (Alt + F8)"
        )
        _user32.AppendMenuW(
            hmenu, MF_STRING, IDM_STOP_RECORDING, "Stop Recording (Alt + F9)"
        )
        _user32.AppendMenuW(hmenu, MF_SEPARATOR, 0, None)
        _user32.AppendMenuW(hmenu, MF_STRING, IDM_OPEN_APP, "Open QuickFFSync")
        _user32.AppendMenuW(hmenu, MF_STRING, IDM_EXIT, "Exit")
        _user32.SetForegroundWindow(self.hwnd)
        pt = ctypes.wintypes.POINT()
        _user32.GetCursorPos(ctypes.byref(pt))
        cmd = _user32.TrackPopupMenu(
            hmenu, TPM_RIGHTBUTTON | TPM_RETURNCMD, pt.x, pt.y, 0, self.hwnd, None
        )
        _user32.DestroyMenu(hmenu)
        if cmd == IDM_START_RECORDING:
            Thread(target=self.on_start, daemon=True).start()
        elif cmd == IDM_STOP_RECORDING:
            Thread(target=self.on_stop, daemon=True).start()
        elif cmd == IDM_OPEN_APP:
            Thread(target=self.on_open, daemon=True).start()
        elif cmd == IDM_EXIT:
            Thread(target=self.on_exit, daemon=True).start()

    def _wnd_proc(self, hwnd, msg, wparam, lparam):
        if msg == WM_HOTKEY:
            if wparam == HOTKEY_START_ID:
                Thread(target=self.on_start, daemon=True).start()
                return 0
            elif wparam == HOTKEY_STOP_ID:
                Thread(target=self.on_stop, daemon=True).start()
                return 0
        if msg == WM_USER_TRAY:
            # WM_RBUTTONUP = 0x0205, WM_CONTEXTMENU = 0x007B
            if lparam in (0x0205, 0x007B):
                self._show_context_menu()
            # WM_LBUTTONDBLCLK = 0x0203
            elif lparam == 0x0203:
                Thread(target=self.on_open, daemon=True).start()
            return 0
        if self._prev_wndproc:
            return _user32.CallWindowProcW(
                self._prev_wndproc, hwnd, msg, wparam, lparam
            )
        return _user32.DefWindowProcW(hwnd, msg, wparam, lparam)

    def destroy(self):
        _user32.UnregisterHotKey(self.hwnd, HOTKEY_START_ID)
        _user32.UnregisterHotKey(self.hwnd, HOTKEY_STOP_ID)
        self.hide()
        if self._prev_wndproc:
            _user32.SetWindowLongPtrW(self.hwnd, GWL_WNDPROC, self._prev_wndproc)
            self._prev_wndproc = None


class BatchConverterWindow:
    def __init__(self, master, main_app):
        self.master = master
        self.main_app = main_app
        self.is_converting = False
        self.current_file_index = 0
        self.files = main_app.batch_files.copy()
        self._saved_input_file = ""
        self._saved_output_file = ""
        self.current_file_index = 0

        # Use persistent variables from main app
        self.batch_output_folder = main_app.batch_output_folder
        self.change_container_var = main_app.batch_change_container
        self.output_container_var = main_app.batch_output_container

        # Create window
        self.window = ctk.CTkToplevel(master)
        self.window.title("Batch Converter")
        self.window.geometry("600x400")
        self.window.minsize(600, 400)
        self.window.configure(fg_color=SECONDARY_BG)

        # Center window
        master.update_idletasks()
        master_x = master.winfo_x()
        master_y = master.winfo_y()
        master_width = master.winfo_width()
        master_height = master.winfo_height()

        window_width = 600
        window_height = 400

        x = master_x + (master_width - window_width) // 2
        y = master_y + (master_height - window_height) // 2

        self.window.geometry(f"{window_width}x{window_height}+{x}+{y}")
        self.window.after(100, self.window.focus_force)

        # Set icon
        if os.path.exists(icon_path):
            self.window.after(201, lambda: self.window.iconbitmap(icon_path))

        # Create UI
        self._create_widgets()
        self._setup_drag_drop()
        self._update_files_display()
        self._update_path_label()
        self._toggle_container_menu()

        # Update main window convert button
        self._update_main_convert_button()

        self.window.protocol("WM_DELETE_WINDOW", self._on_close)

    def _create_widgets(self):
        # Main container
        main_frame = ctk.CTkFrame(self.window, fg_color=SECONDARY_BG)
        main_frame.pack(fill="both", expand=True, padx=10, pady=10)

        # Files list frame
        list_frame = ctk.CTkFrame(main_frame, fg_color=SECONDARY_BG)
        list_frame.pack(fill="both", expand=True, pady=(0, 5))

        # Scrollable frame for files
        self.scrollable_frame = ctk.CTkScrollableFrame(
            list_frame,
            fg_color=PRIMARY_BG,
            scrollbar_button_color=HOVER_BLUE,
            scrollbar_button_hover_color=ACCENT_BLUE,
        )
        self.scrollable_frame.pack(
            fill="both",
            expand=True,
            padx=0,
            pady=(5, 0),
        )

        # Output path label frame
        self.output_path_frame = ctk.CTkFrame(main_frame, fg_color="transparent")
        self.output_path_frame.pack(fill="x", pady=(0, 5))

        self.output_prefix_label = ctk.CTkLabel(
            self.output_path_frame,
            text="Output: ",
            font=("Segoe UI", 13),
            text_color=ACCENT_BLUE,
        )
        self.output_prefix_label.pack(side="left")

        self.output_path_display = ctk.CTkLabel(
            self.output_path_frame,
            text="Original folder(s)",
            font=("Segoe UI", 13),
            text_color=TEXT_COLOR_W,
        )
        self.output_path_display.pack(side="left")

        # Container options frame
        container_frame = ctk.CTkFrame(main_frame, fg_color="transparent")
        container_frame.pack(fill="x", pady=(0, 10))

        container_frame.columnconfigure(0, weight=1, uniform="group1")
        container_frame.columnconfigure(1, weight=1, uniform="group1")
        container_frame.columnconfigure(2, weight=1, uniform="group1")

        self.output_folder_btn = ctk.CTkButton(
            container_frame,
            text="Output Folder",
            command=self._select_output_folder,
            fg_color=ACCENT_BLUE,
            hover_color=HOVER_BLUE,
            text_color=TEXT_COLOR_B,
        )
        self.output_folder_btn.grid(row=0, column=0, sticky="ew", padx=(0, 5))

        self.change_container_checkbox = ctk.CTkCheckBox(
            container_frame,
            text="Change output container",
            variable=self.change_container_var,
            command=self._toggle_container_menu,
            fg_color=ACCENT_BLUE,
            hover_color=HOVER_BLUE,
        )
        self.change_container_checkbox.grid(row=0, column=1, sticky="w", padx=(0, 5))

        self.container_menu = ctk.CTkOptionMenu(
            container_frame,
            values=["mp4", "mkv", "mov"],
            variable=self.output_container_var,
            state="disabled",
            fg_color=ACCENT_DEEPBLUE,
            button_color=ACCENT_DEEPBLUE,
            button_hover_color=HOVER_BLUE,
            dropdown_fg_color=SECONDARY_BG,
            dropdown_hover_color=ACCENT_BLUE,
            text_color=TEXT_COLOR_W,
        )
        self.container_menu.grid(row=0, column=2, sticky="ew", padx=(0, 0))

        # Buttons frame
        buttons_frame = ctk.CTkFrame(main_frame, fg_color=SECONDARY_BG)
        buttons_frame.pack(fill="x", pady=5)

        # Buttons
        self.add_btn = ctk.CTkButton(
            buttons_frame,
            text="Add Files",
            command=self._add_files,
            fg_color=ACCENT_BLUE,
            hover_color=HOVER_BLUE,
            text_color=TEXT_COLOR_B,
        )
        self.add_btn.pack(side="left", expand=True, fill="x", padx=(0, 5))

        self.close_btn = ctk.CTkButton(
            buttons_frame,
            text="Close",
            command=self._on_close,
            fg_color=ACCENT_DEEPBLUE,
            hover_color=HOVER_DEEPBLUE,
            text_color=TEXT_COLOR_W,
        )
        self.close_btn.pack(side="left", expand=True, fill="x", padx=(0, 5))

        self.remove_all_btn = ctk.CTkButton(
            buttons_frame,
            text="Remove All",
            command=self._remove_all_files,
            fg_color=ACCENT_RED,
            hover_color=HOVER_RED,
            text_color=TEXT_COLOR_B,
        )
        self.remove_all_btn.pack(side="left", expand=True, fill="x")

    def _toggle_container_menu(self):
        if self.change_container_var.get():
            self.container_menu.configure(
                state="normal", fg_color=PRIMARY_BG, button_color=ACCENT_BLUE
            )
        else:
            self.container_menu.configure(
                state="disabled", fg_color=ACCENT_DEEPBLUE, button_color=ACCENT_DEEPBLUE
            )

    def _select_output_folder(self):
        initial_dir = (
            self.batch_output_folder.get()
            or self.main_app.last_output_dir.get()
            or os.getcwd()
        )
        folder = filedialog.askdirectory(
            parent=self.window, initialdir=initial_dir, title="Select Output Folder"
        )

        self.window.lift()
        self.window.focus_force()

        if folder:
            normalized_folder = os.path.normpath(folder)
            self.batch_output_folder.set(normalized_folder)
            self._update_path_label()

    def _update_path_label(self):
        if not hasattr(self, "output_path_display"):
            return

        batch_folder = self.batch_output_folder.get()
        main_folder = self.main_app.last_output_dir.get()

        if batch_folder:
            path_text = batch_folder
        elif main_folder and os.path.exists(main_folder):
            path_text = main_folder
        else:
            path_text = "Original folder(s)"

        # Truncate path if too long
        if len(path_text) > 85:
            path_text = path_text[:82] + "..."

        self.output_path_display.configure(text=path_text)

    def _setup_drag_drop(self):
        # Enable drag and drop for the window
        self.drop_target = DropTarget(
            self.window.winfo_id(), self._handle_dropped_files
        )

    def _handle_dropped_files(self, file_path):
        """Handle files dropped into the batch converter window"""
        # Process in separate thread like main window
        Thread(
            target=self._process_dropped_file, args=(file_path,), daemon=True
        ).start()

    def _process_dropped_file(self, file_path):
        """Process dropped file in separate thread"""
        if file_path.lower().endswith(VIDEO_EXTENSIONS):
            normalized_path = os.path.normpath(file_path)

            # Update GUI from main thread
            self.window.after(0, lambda: self._add_file_to_list(normalized_path))
        else:
            # Show warning in main thread
            self.window.after(
                0,
                lambda: messagebox.showwarning(
                    "Unsupported File",
                    "Please drop a video file (.mp4, .mkv, .avi, etc.)",
                ),
            )

    def _add_files(self):
        initial_dir = (
            self.main_app.last_input_dir.get()
            if self.main_app.last_input_dir.get()
            else os.getcwd()
        )

        filenames = filedialog.askopenfilenames(
            parent=self.window,
            title="Select Video Files",
            initialdir=initial_dir,
            filetypes=(
                VIDEO_EXTENSIONS_FILTER,
                ("All Files", "*.*"),
            ),
        )

        self.window.lift()
        self.window.focus_force()

        if not filenames:
            return

        for filename in filenames:
            normalized_path = os.path.normpath(filename)
            self._add_file_to_list(normalized_path)

    def _add_file_to_list(self, file_path):
        # Check if file already exists in list
        for existing_file in self.files:
            if existing_file["path"] == file_path:
                return

        # Add to list
        file_info = {
            "path": file_path,
            "status": "Ready",  # Ready, Converting, Done, Failed
            "widgets": None,
        }
        self.files.append(file_info)
        self._update_files_display()
        self._update_main_convert_button()
        self.main_app.batch_files = self.files.copy()
        self.window.lift()

    # Remove from list
    def _remove_file(self, index):
        if 0 <= index < len(self.files):
            self.files.pop(index)
            self._update_files_display()
            self._update_main_convert_button()
            self.main_app.batch_files = self.files.copy()

    def _remove_all_files(self):
        if self.files:
            self.files.clear()
            self._update_files_display()
            self._update_main_convert_button()
            self.main_app.batch_files = self.files.copy()

    # Clear current display
    def _update_files_display(self):
        for widget in self.scrollable_frame.winfo_children():
            widget.destroy()

        # Recreate file entries
        for i, file_info in enumerate(self.files):
            self._create_file_entry(i, file_info)

    def _create_file_entry(self, index, file_info):
        file_frame = ctk.CTkFrame(self.scrollable_frame, fg_color=PRIMARY_BG)
        file_frame.pack(fill="x", pady=2)

        # Number
        num_label = ctk.CTkLabel(file_frame, text=f"{index + 1}.", width=30)
        num_label.pack(side="left", padx=(5, 0))

        # Filename (truncated if too long)
        filename = os.path.basename(file_info["path"])
        if len(filename) > 40:
            filename = filename[:37] + "..."

        name_label = ctk.CTkLabel(file_frame, text=filename, width=300, anchor="w")
        name_label.pack(side="left", padx=5, fill="x", expand=True)

        # Status
        status_label = ctk.CTkLabel(file_frame, text=file_info["status"], width=80)
        status_label.pack(side="left", padx=5)

        # Remove button
        remove_btn = ctk.CTkButton(
            file_frame,
            text="×",
            width=20,
            height=20,
            command=lambda idx=index: self._remove_file(idx),
            fg_color=ACCENT_RED,
            hover_color=HOVER_RED,
            text_color=TEXT_COLOR_B,
            # font=("", 24, "bold"),
        )
        remove_btn.pack(side="right", padx=(0, 5))

        # Store widgets for later updates
        file_info["widgets"] = {"status_label": status_label}

    def _update_file_status(self, index, status):
        if not self.window.winfo_exists():
            return

        if 0 <= index < len(self.files):
            self.files[index]["status"] = status
            if self.files[index]["widgets"]:
                try:
                    self.files[index]["widgets"]["status_label"].configure(text=status)
                except Exception:
                    pass

    def _update_main_convert_button(self):
        if hasattr(self.main_app, "convert_button"):
            if self.is_converting:
                self.main_app.convert_button.configure(
                    text="Cancel", fg_color=ACCENT_RED, hover_color=HOVER_DEEPBLUE
                )
            elif self.files:
                self.main_app.convert_button.configure(
                    text="Batch Convert", fg_color=ACCENT_BLUE, hover_color=HOVER_BLUE
                )
            else:
                self.main_app.convert_button.configure(
                    text="Convert", fg_color=ACCENT_BLUE, hover_color=HOVER_BLUE
                )

    def start_batch_conversion(self):
        if not self.files or self.is_converting:
            return

        self.is_converting = True
        self.current_file_index = 0

        # Save original input/output so we can restore after batch
        self._saved_input_file = self.main_app.input_file.get()
        self._saved_output_file = self.main_app.output_file.get()

        self.main_app.progress_frame.grid()
        self.main_app.progress_value.set(0.0)
        self.main_app.progress_label.configure(text="0%")
        self.main_app.status_text.set("Conversion in progress...")
        self.main_app.convert_button.configure(
            text="Cancel", fg_color=ACCENT_RED, hover_color=HOVER_RED
        )

        self._convert_next_file()

    def _convert_next_file(self):
        if not self.window.winfo_exists():
            self.is_converting = False
            self._restore_input_output()
            return
        if self.current_file_index >= len(self.files) or not self.is_converting:
            self.is_converting = False
            self.main_app.progress_frame.grid_remove()
            self.main_app.ffmpeg_output.set("")
            self.main_app.status_text.set("Batch conversion completed!")
            self._update_main_convert_button()
            self._restore_input_output()
            return

        current_file = self.files[self.current_file_index]
        self._update_file_status(self.current_file_index, "Converting")

        # Set up conversion for current file
        input_path = current_file["path"]

        # Generate output filename based on main app settings
        base_name = os.path.splitext(os.path.basename(input_path))[0]
        codec_suffix = (
            "_hevc"
            if self.main_app.video_codec.get() == "hevc"
            else "_h264"
            if self.main_app.video_codec.get() == "h264"
            else "_av1"
            if self.main_app.video_codec.get() == "av1"
            else "_vp9"
        )

        # Get output directory
        if self.batch_output_folder.get():
            output_dir = self.batch_output_folder.get()
        elif self.main_app.last_output_dir.get() and os.path.exists(
            self.main_app.last_output_dir.get()
        ):
            output_dir = self.main_app.last_output_dir.get()
        else:
            output_dir = os.path.dirname(input_path)

        # Determine extension: either use override from dropdown or preserve original input extension
        if self.change_container_var.get():
            original_extension = "." + self.output_container_var.get()
        else:
            original_extension = os.path.splitext(input_path)[1] or ".mp4"

        output_path = os.path.normpath(
            os.path.join(
                output_dir, f"{base_name}{codec_suffix}_custom{original_extension}"
            )
        )

        try:
            # Set current file for conversion
            self.main_app.input_file.set(input_path)
            self.main_app.output_file.set(output_path)
            self.main_app._get_video_duration()

            # Build and execute command
            command = self.main_app._build_ffmpeg_command()

            # Run conversion in thread
            conversion_thread = Thread(
                target=self._run_single_conversion,
                args=(command, self.current_file_index),
                daemon=True,
            )
            conversion_thread.start()

        except Exception as e:
            self._update_file_status(self.current_file_index, f"Failed: {str(e)}")
            self.current_file_index += 1
            self.master.after(100, self._convert_next_file)

    def _run_single_conversion(self, command, file_index):
        startupinfo = None
        creationflags = 0

        if os.name == "nt":
            startupinfo = subprocess.STARTUPINFO()
            startupinfo.dwFlags |= subprocess.STARTF_USESHOWWINDOW
            startupinfo.wShowWindow = subprocess.SW_HIDE
            creationflags = subprocess.CREATE_NO_WINDOW

        try:
            process = subprocess.Popen(
                command,
                stdout=subprocess.PIPE,
                stderr=subprocess.STDOUT,
                text=True,
                bufsize=1,
                startupinfo=startupinfo,
                creationflags=creationflags,
                encoding="utf-8",
                errors="replace",
            )

            for line in process.stdout:
                if not self.is_converting:
                    process.terminate()
                    try:
                        process.wait(timeout=5)
                    except subprocess.TimeoutExpired:
                        process.kill()
                    break

                if line:
                    self.master.after(
                        0,
                        lambda line_text=line: self.main_app.ffmpeg_output.set(
                            line_text
                        ),
                    )
                    self.master.after(
                        0,
                        lambda line_text=line: self.main_app._update_progress(
                            line_text
                        ),
                    )

            process.wait()

            if process.returncode == 0 and self.is_converting:
                self.master.after(
                    0, lambda: self._update_file_status(file_index, "Done")
                )
            elif self.is_converting:
                self.master.after(
                    0, lambda: self._update_file_status(file_index, "Failed")
                )
            else:
                self.master.after(
                    0, lambda: self._update_file_status(file_index, "Cancelled")
                )

        except Exception as e:
            error_msg = str(e)
            status = "Cancelled" if not self.is_converting else f"Failed: {error_msg}"
            self.master.after(0, lambda: self._update_file_status(file_index, status))

        finally:
            if self.is_converting:
                self.current_file_index += 1
                self.master.after(100, self._convert_next_file)
            else:
                self.master.after(0, lambda: self.main_app.ffmpeg_output.set(""))

    def cancel_batch_conversion(self):
        self.is_converting = False
        if 0 <= self.current_file_index < len(self.files):
            self._update_file_status(self.current_file_index, "Cancelled")
        self.main_app.ffmpeg_output.set("")
        self.main_app.status_text.set("Batch conversion cancelled")
        self._update_main_convert_button()
        self.main_app.progress_frame.grid_remove()
        self.main_app.progress_value.set(0.0)
        self._restore_input_output()

    def _restore_input_output(self):
        """Restore original input/output file paths after batch conversion"""
        if hasattr(self, "_saved_input_file") and self._saved_input_file:
            self.main_app.input_file.set(self._saved_input_file)
        if hasattr(self, "_saved_output_file") and self._saved_output_file:
            self.main_app.output_file.set(self._saved_output_file)

    def _on_close(self):
        if self.is_converting:
            self.window.withdraw()
        else:
            self._update_main_convert_button()
            self.main_app.progress_frame.grid_remove()
            self.main_app.batch_files = self.files
            # Clean up drop target before destroying window
            if hasattr(self, "drop_target"):
                self.drop_target.cleanup()
            self.window.destroy()
            # Clear reference in main app so _open_batch_converter creates a new one
            self.main_app.batch_converter_window = None
            self.main_app = None
            self.files = None
            self.window = None


# MAIN
class VideoConverterApp:
    # INITIALIZATION
    def __init__(self, master):
        self.preview_job = None  # used for debouncing preview creation
        self.batch_converter_window = None
        self.batch_files = []
        self.video_metadata_cache = {}
        self.map_window = None
        self.map_selection_cache = {}
        self.master = master
        self.version = "1.3.1"
        master.title(f"QuickFFSync {self.version}")

        dpi = get_real_dpi()
        scaling = int(round((dpi / 96) * 100))
        self.scaling = scaling

        if scaling >= 200:
            h, min_h, max_h = 600, 600, 650
        elif scaling >= 125:
            h, min_h, max_h = 650, 650, 800
        else:
            h, min_h, max_h = 700, 700, 900

        master.geometry(f"820x{h}")
        master.minsize(820, min_h)
        master.maxsize(820, max_h)
        master.resizable(False, True)
        master.configure(fg_color=PRIMARY_BG)

        # Main container
        self.main_container = ctk.CTkScrollableFrame(
            master,
            fg_color=PRIMARY_BG,
            scrollbar_button_color=HOVER_BLUE,
            scrollbar_button_hover_color=ACCENT_BLUE,
        )
        self.main_container.pack(fill="both", expand=True, padx=10, pady=10)

        # Content frame
        self.content_frame = ctk.CTkFrame(self.main_container, fg_color=PRIMARY_BG)
        self.content_frame.pack(fill="x", expand=False)

        # Convert frame
        self.button_frame = ctk.CTkFrame(master, fg_color=PRIMARY_BG)
        self.button_frame.pack(fill="x", padx=15, pady=(0, 15))

        # Create presets directory
        self.presets_dir = os.path.join(
            os.path.dirname(os.path.abspath(__file__)), "presets"
        )
        if not os.path.exists(self.presets_dir):
            os.makedirs(self.presets_dir)

        self._setup_variables()
        self._create_widgets()

        # Find FFmpeg executables (critical dependency)
        self.ffmpeg_path = self._find_executable("ffmpeg.exe")
        self.ffprobe_path = None

        # Load saved settings (updates ffmpeg_custom_path)
        self._load_settings()

        # Determine the actual ffmpeg path to use
        custom_ffmpeg = self.ffmpeg_custom_path.get()
        if (
            custom_ffmpeg
            and custom_ffmpeg != self.ffmpeg_path_placeholder
            and os.path.exists(custom_ffmpeg)
        ):
            actual_ffmpeg = custom_ffmpeg
        else:
            actual_ffmpeg = self.ffmpeg_path

        # Update self.ffmpeg_path to the actual one (so it's consistent)
        self.ffmpeg_path = actual_ffmpeg

        # Determine ffprobe path based on actual ffmpeg
        if self.ffmpeg_path:
            ffprobe_path = os.path.join(
                os.path.dirname(self.ffmpeg_path), "ffprobe.exe"
            )
            if os.path.exists(ffprobe_path):
                self.ffprobe_path = ffprobe_path
            else:
                self.ffprobe_path = self._find_executable("ffprobe.exe")
        else:
            self.ffprobe_path = self._find_executable("ffprobe.exe")

        self._update_codec_settings()

        # Set the FFmpeg path in the UI if found
        if self.ffmpeg_path:
            self.ffmpeg_custom_path.set(self.ffmpeg_path)

        if self.ffmpeg_path:
            self.ffmpeg_path_entry.configure(text_color=TEXT_COLOR_W)

        # JSON Trace changes
        self.video_codec.trace_add("write", self._update_output_filename)

        self.conversion_process = None
        self.conversion_thread = None
        self.is_converting = False
        self._create_trim_slider()
        self._center_window()
        self.drop_target = DropTarget(self.master.winfo_id(), self._handle_dropped_file)
        self._create_thumbnail_preview()
        self._setup_keyboard_shortcuts()
        self._toggle_custom_abitrate()
        self._toggle_custom_fps_entry()
        self._toggle_custom_video_width_entry()

        if len(sys.argv) > 1:
            self._handle_dropped_file(sys.argv[1])
        self.preview_temp_files = []  # Add list for preview temporary files
        self.trim_streamcopy.trace_add(
            "write", lambda *args: self._update_preview_button_state()
        )

        # Create tray icon (always visible)
        icon_path = get_icon_path()
        self._tray_icon = TrayIcon(
            self.master.winfo_id(),
            icon_path,
            lambda: self.master.after(0, self._start_recording),
            lambda: self.master.after(0, self._stop_recording),
            lambda: self.master.after(0, self._restore_app),
            lambda: self.master.after(0, self._on_close),
            version=self.version,
        )
        self._tray_icon.show()

        # Help windows
        self.output_window_open = False
        self.open_help_windows = {}

        # JSON Settings
        self.ffmpeg_custom_path.trace_add(
            "write", lambda *args: self._on_setting_changed()
        )
        self.last_input_dir.trace_add("write", lambda *args: self._on_setting_changed())
        self.last_output_dir.trace_add(
            "write", lambda *args: self._on_setting_changed()
        )
        self.video_codec.trace_add("write", lambda *args: self._on_setting_changed())
        self.icq_mode.trace_add("write", lambda *args: self._on_setting_changed())
        self.global_quality_level.trace_add(
            "write", lambda *args: self._on_setting_changed()
        )
        self.bitrate.trace_add("write", lambda *args: self._on_setting_changed())
        self.audio_option.trace_add("write", lambda *args: self._on_setting_changed())
        self._toggle_icq_mode()  # Enabled ICQ by default

        # Encoder Settings
        self.async_depth.trace_add("write", lambda *args: self._on_setting_changed())
        self.preset.trace_add("write", lambda *args: self._on_setting_changed())
        self.profile.trace_add("write", lambda *args: self._on_setting_changed())
        self.scenario.trace_add("write", lambda *args: self._on_setting_changed())
        self.threads.trace_add("write", lambda *args: self._on_setting_changed())
        self.hwaccel.trace_add("write", lambda *args: self._on_setting_changed())
        self.rc.trace_add("write", lambda *args: self._on_setting_changed())
        self.tier.trace_add("write", lambda *args: self._on_setting_changed())
        self.look_ahead_depth.trace_add(
            "write", lambda *args: self._on_setting_changed()
        )
        self.extbrc.trace_add("write", lambda *args: self._on_setting_changed())
        self.rdo.trace_add("write", lambda *args: self._on_setting_changed())
        self.mbbrc.trace_add("write", lambda *args: self._on_setting_changed())

        self.custom_abitrate.trace_add(
            "write", lambda *args: self._on_setting_changed()
        )

        # FPS and Scaling Settings
        self.fps_option.trace_add("write", lambda *args: self._on_setting_changed())
        self.custom_fps.trace_add("write", lambda *args: self._on_setting_changed())
        self.fps_mode.trace_add("write", lambda *args: self._on_setting_changed())
        self.video_format_option.trace_add(
            "write", lambda *args: self._on_setting_changed()
        )
        self.custom_video_width.trace_add(
            "write", lambda *args: self._on_setting_changed()
        )
        # Load new added custom preset at next start
        self.selected_preset.trace_add(
            "write", lambda *args: self._on_setting_changed()
        )
        self.custom_preset_name.trace_add(
            "write", lambda *args: self._on_setting_changed()
        )

        # Batch Converter Settings
        self.batch_output_folder.trace_add(
            "write", lambda *args: self._on_setting_changed()
        )
        self.batch_change_container.trace_add(
            "write", lambda *args: self._on_setting_changed()
        )
        self.batch_output_container.trace_add(
            "write", lambda *args: self._on_setting_changed()
        )

    def _setup_variables(self):
        # Initialize all Tkinter control variables
        self.ffprobe_cache = OrderedDict()
        self.input_file_tooltip = None
        self._tooltip_generation = 0
        self._tooltip_cancel = Event()
        self.input_path_placeholder = (
            "Drag and drop a video file here or use the 'Browse' button."
        )
        self.input_file = ctk.StringVar()
        self.output_file = ctk.StringVar()
        self.bitrate = ctk.StringVar(value="6000")
        self.ffmpeg_output = ctk.StringVar(value="")
        self.audio_option = ctk.StringVar(value="copy")
        self.custom_abitrate = ctk.StringVar(value="160")
        self.enable_audio_options = ctk.BooleanVar(value=False)
        self.enable_encoder_options = ctk.BooleanVar(value=False)
        self.threads = ctk.StringVar(value="4")
        self.async_depth = ctk.StringVar(value="auto")
        self.preset = ctk.StringVar(value="medium")
        self.scenario = ctk.StringVar(value="auto")
        self.profile = ctk.StringVar(value="main")
        self.tier = ctk.StringVar(value="auto")
        self.hwaccel = ctk.StringVar(value="auto")
        self.rdo = ctk.BooleanVar(value=True)
        self.mbbrc = ctk.BooleanVar(value=False)
        self.extbrc = ctk.BooleanVar(value=True)
        self.look_ahead_depth = ctk.StringVar(value="40")
        self.rc = ctk.StringVar(value="vbr")
        self.rc_locked = ctk.BooleanVar(value=False)
        self.enable_fps_scale_options = ctk.BooleanVar(value=False)
        self.fps_option = ctk.StringVar(value="source")
        self.custom_fps = ctk.StringVar(value="30")
        self.fps_mode = ctk.StringVar(value="auto")
        self.video_format_option = ctk.StringVar(value="source")
        self.custom_video_width = ctk.StringVar(value="1920")
        self.interpolation_algo = ctk.StringVar(value="bicubic")
        self.enable_additional_options = ctk.BooleanVar(value=False)
        self.additional_options = ctk.StringVar(value="")
        self.additional_filter_options = ctk.StringVar(value="")
        self.additional_audio_filter_options = ctk.StringVar(value="")
        self.additional_options_placeholder = (
            "e.g. -aq-strength 8; -cq 0; -bf 0 or -bf 4;"
            " -intra-refresh 1; -forced-idr 1"
        )
        self.additional_filter_options_placeholder = (
            "e.g.setpts=0.5*PTS - speed up video x2; crop=iw:min(ih\\,iw*9/16)"
        )
        self.additional_audio_filter_options_placeholder = "e.g. atempo=2.0, volume=1.5"
        self.status_text = ctk.StringVar(value="Ready for conversion")
        self.estimated_file_size = ctk.StringVar(value="")
        self.progress_value = ctk.DoubleVar(value=0.0)
        self.selected_preset = ctk.StringVar(value="none")
        self.enable_presets = ctk.BooleanVar(value=False)
        self.ffmpeg_custom_path = ctk.StringVar(value="")
        self.ffmpeg_path_placeholder = "Path to ffmpeg.exe (required)"
        self.bitrate.trace_add("write", lambda *args: self._calculate_estimated_size())
        self.audio_option.trace_add(
            "write", lambda *args: self._calculate_estimated_size()
        )
        self.custom_abitrate.trace_add(
            "write", lambda *args: self._calculate_estimated_size()
        )
        self.video_codec = ctk.StringVar(value="hevc")
        self.trim_start = ctk.StringVar(value="00:00:00")
        self.trim_end = ctk.StringVar(value="00:00:00")
        self.trim_streamcopy = ctk.BooleanVar(value=False)
        self.icq_mode = ctk.BooleanVar(value=True)  # Enabled ICQ by default
        self.global_quality_level = ctk.StringVar(value="30")
        self.global_quality_level.trace_add(
            "write", lambda *args: self._calculate_estimated_size()
        )
        self.extbrc.trace_add("write", self._toggle_la_depth_state)
        self.is_creating_preview = False
        self.custom_command = None
        self.last_input_dir = ctk.StringVar(value="")
        self.last_output_dir = ctk.StringVar(value="")
        self.precise_trim = ctk.BooleanVar(value=False)
        # Screen recording variables
        self.is_recording = False
        self.recording_process = None
        # Preview 10s
        self.preview_process = None
        # Custom presets
        self.custom_preset_name = ctk.StringVar(value="")
        self.custom_preset_selected = ctk.StringVar(value="")
        self.loading_preset = False

        # Batch converter persistent variables
        self.batch_output_folder = ctk.StringVar(value="")
        self.batch_change_container = ctk.BooleanVar(value=False)
        self.batch_output_container = ctk.StringVar(value="mp4")

    def _create_widgets(self):
        # Build the entire GUI interface
        main_frame = ctk.CTkFrame(
            self.content_frame, fg_color=PRIMARY_BG, corner_radius=25
        )
        main_frame.pack(fill="both", expand=True, padx=15, pady=15)

        # Input File
        ctk.CTkLabel(main_frame, text="Input File:").grid(
            row=0, column=0, sticky="w", padx=10, pady=5
        )
        self.input_file_entry = ctk.CTkEntry(
            main_frame,
            textvariable=self.input_file,
            width=350,
            fg_color=SECONDARY_BG,
            text_color=TEXT_COLOR_W,
            border_color=HOVER_BLUE,
        )
        self.input_file_entry.grid(row=0, column=1, padx=5, pady=5)
        self.input_file_entry.insert(0, self.input_path_placeholder)
        self.input_file_entry.configure(text_color=PLACEHOLDER_COLOR)
        self.input_file_entry.bind("<FocusIn>", self._on_input_file_focus_in)
        self.input_file_entry.bind("<FocusOut>", self._on_input_file_focus_out)
        self.input_file.trace_add("write", self._on_input_file_change)

        # Browse button
        self.btn_browse = ctk.CTkButton(
            main_frame,
            text="Browse",
            command=self._browse_input,
            fg_color=ACCENT_BLUE,
            hover_color=HOVER_BLUE,
            text_color=TEXT_COLOR_B,
        )
        self.btn_browse.grid(row=0, column=2, padx=5, pady=5)
        self.btn_browse.bind(
            "<Button-3>", lambda e: self._explore_path(e, self.input_file.get())
        )
        CTkToolTip(
            self.btn_browse,
            message="Right-click to open containing folder",
            bg_color=SECONDARY_BG,
            text_color=TEXT_COLOR_W,
            alpha=1.0,
            corner_radius=6,
            delay=0.3,
        )

        # Output File
        ctk.CTkLabel(main_frame, text="Output File:").grid(
            row=1, column=0, sticky="w", padx=10, pady=5
        )
        self.output_file_placeholder = (
            "Also used as the destination file for screen recordings"
        )
        self.output_file_entry = ctk.CTkEntry(
            main_frame,
            textvariable=self.output_file,
            width=350,
            fg_color=SECONDARY_BG,
            text_color=TEXT_COLOR_W,
            border_color=HOVER_BLUE,
        )
        self.output_file_entry.grid(row=1, column=1, padx=5, pady=5)
        self.output_file_entry.insert(0, self.output_file_placeholder)
        self.output_file_entry.configure(text_color=PLACEHOLDER_COLOR)
        self.output_file_entry.bind("<FocusIn>", self._on_output_file_focus_in)
        self.output_file_entry.bind("<FocusOut>", self._on_output_file_focus_out)
        self.output_file.trace_add("write", self._on_output_file_change)

        # Save As button
        self.btn_save_as = ctk.CTkButton(
            main_frame,
            text="Save As",
            command=self._browse_output,
            fg_color=ACCENT_BLUE,
            hover_color=HOVER_BLUE,
            text_color=TEXT_COLOR_B,
        )
        self.btn_save_as.grid(row=1, column=2, padx=5, pady=5)
        self.btn_save_as.bind(
            "<Button-3>", lambda e: self._explore_path(e, self.output_file.get())
        )
        CTkToolTip(
            self.btn_save_as,
            message="Right-click to open containing folder",
            bg_color=SECONDARY_BG,
            text_color=TEXT_COLOR_W,
            alpha=1.0,
            corner_radius=6,
            delay=0.3,
        )

        # FFmpeg Path
        ctk.CTkLabel(main_frame, text="FFmpeg Path:").grid(
            row=2, column=0, sticky="w", padx=10, pady=5
        )
        self.ffmpeg_path_entry = ctk.CTkEntry(
            main_frame,
            textvariable=self.ffmpeg_custom_path,
            width=350,
            fg_color=SECONDARY_BG,
            text_color=TEXT_COLOR_W,
            border_color=HOVER_BLUE,
        )
        self.ffmpeg_path_entry.grid(row=2, column=1, padx=5, pady=5)
        self.ffmpeg_path_entry.insert(0, self.ffmpeg_path_placeholder)
        self.ffmpeg_path_entry.configure(text_color=PLACEHOLDER_COLOR)
        self.ffmpeg_path_entry.bind("<FocusIn>", self._on_ffmpeg_path_focus_in)
        self.ffmpeg_path_entry.bind("<FocusOut>", self._on_ffmpeg_path_focus_out)

        # Browse button for FFmpeg
        self.btn_ffmpeg = ctk.CTkButton(
            main_frame,
            text="FFmpeg",
            command=self._browse_ffmpeg,
            fg_color=ACCENT_DEEPBLUE,
            hover_color=HOVER_DEEPBLUE,
            text_color=TEXT_COLOR_W,
        )
        self.btn_ffmpeg.grid(row=2, column=2, padx=5, pady=5)
        self.btn_ffmpeg.bind(
            "<Button-3>", lambda e: self._explore_path(e, self.ffmpeg_custom_path.get())
        )
        CTkToolTip(
            self.btn_ffmpeg,
            message="Right-click to open containing folder",
            bg_color=SECONDARY_BG,
            text_color=TEXT_COLOR_W,
            alpha=1.0,
            corner_radius=6,
            delay=0.3,
        )

        # Video Bitrate/Quality Level
        self.bitrate_label = ctk.CTkLabel(main_frame, text="Video Bitrate (k):")
        self.bitrate_label.grid(row=3, column=0, sticky="w", padx=10, pady=5)

        # Frame for bitrate/quality controls
        bitrate_frame = ctk.CTkFrame(main_frame, fg_color="transparent")
        bitrate_frame.grid(row=3, column=1, sticky="w", padx=5, pady=5)

        self.bitrate_entry = ctk.CTkEntry(
            bitrate_frame,
            textvariable=self.bitrate,
            width=80,
            justify="center",
            fg_color=SECONDARY_BG,
            text_color=TEXT_COLOR_W,
            border_color=HOVER_BLUE,
        )
        self.bitrate_entry.pack(side="left")

        # Intelligent Constant Quality checkbox
        self.icq_checkbox = ctk.CTkCheckBox(
            bitrate_frame,
            text="Intelligent Constant Quality",
            variable=self.icq_mode,
            command=self._toggle_icq_mode,
            fg_color=ACCENT_BLUE,
            hover_color=HOVER_BLUE,
        )
        self.icq_checkbox.pack(side="left", padx=(10, 0))

        self.btn_output = ctk.CTkButton(
            main_frame,
            text="Output",
            command=self._show_output_command,
            fg_color=ACCENT_DEEPBLUE,
            hover_color=HOVER_DEEPBLUE,
            text_color=TEXT_COLOR_W,
        )
        self.btn_output.grid(row=3, column=2, sticky="w", padx=5, pady=5)
        self.btn_output.bind("<Button-3>", lambda e: self._copy_command_to_clipboard())
        CTkToolTip(
            self.btn_output,
            message="Right-click to copy command to clipboard",
            bg_color=SECONDARY_BG,
            text_color=TEXT_COLOR_W,
            alpha=1.0,
            corner_radius=6,
            delay=0.3,
        )

        ctk.CTkButton(
            main_frame,
            text="Help",
            command=self._show_main_help,
            fg_color=ACCENT_DEEPBLUE,
            hover_color=HOVER_DEEPBLUE,
            text_color=TEXT_COLOR_W,
        ).grid(row=4, column=2, sticky="w", padx=5, pady=5)

        # Video Codec Selection
        ctk.CTkLabel(main_frame, text="Video Codec:").grid(
            row=4, column=0, sticky="w", padx=10, pady=5
        )
        codec_frame = ctk.CTkFrame(main_frame, fg_color="transparent")
        codec_frame.grid(row=4, column=1, sticky="w", padx=5, pady=5)

        hevc_rb = ctk.CTkRadioButton(
            codec_frame,
            text="HEVC",
            variable=self.video_codec,
            value="hevc",
            command=self._update_codec_settings,
            fg_color=ACCENT_BLUE,
            hover_color=HOVER_BLUE,
            width=75,
        )
        hevc_rb.pack(side="left", padx=5)

        h264_rb = ctk.CTkRadioButton(
            codec_frame,
            text="H.264",
            variable=self.video_codec,
            value="h264",
            command=self._update_codec_settings,
            fg_color=ACCENT_BLUE,
            hover_color=HOVER_BLUE,
            width=75,
        )
        h264_rb.pack(side="left", padx=5)

        av1_rb = ctk.CTkRadioButton(
            codec_frame,
            text="AV1",
            variable=self.video_codec,
            value="av1",
            command=self._update_codec_settings,
            fg_color=ACCENT_BLUE,
            hover_color=HOVER_BLUE,
            width=75,
        )
        av1_rb.pack(side="left", padx=5)

        vp9_rb = ctk.CTkRadioButton(
            codec_frame,
            text="VP9",
            variable=self.video_codec,
            value="vp9",
            command=self._update_codec_settings,
            fg_color=ACCENT_BLUE,
            hover_color=HOVER_BLUE,
            width=75,
        )
        vp9_rb.pack(side="left", padx=5)

        # Encoder Options
        encoder_options_frame_toggle = TextCheckbox(
            main_frame,
            text="Advanced Encoder Settings",
            variable=self.enable_encoder_options,
            command=self._toggle_encoder_options_frame,
        )
        encoder_options_frame_toggle.grid(row=5, column=0, sticky="w", padx=10, pady=5)

        # Auto button
        self.auto_button = ctk.CTkButton(
            main_frame,
            text="Auto",
            command=self._apply_auto_encoder_settings,
            fg_color=ACCENT_BLUE,
            hover_color=HOVER_BLUE,
            text_color=TEXT_COLOR_B,
            width=80,
        )
        self.auto_button.grid(row=5, column=1, sticky="w", padx=5)
        self.auto_button.grid_remove()

        # Default button
        self.default_button = ctk.CTkButton(
            main_frame,
            text="Default",
            command=lambda: self._apply_preset("none"),
            fg_color=ACCENT_BLUE,
            hover_color=HOVER_BLUE,
            text_color=TEXT_COLOR_B,
            width=80,
        )
        self.default_button.grid(row=5, column=1, sticky="w", padx=95)
        self.default_button.grid_remove()

        self.encoder_options_frame = ctk.CTkFrame(main_frame, fg_color=SECONDARY_BG)

        left_column_frame = ctk.CTkFrame(
            self.encoder_options_frame, fg_color="transparent"
        )
        left_column_frame.grid(
            row=1, column=0, columnspan=2, padx=5, pady=5, sticky="nsew"
        )

        # Async Depth
        ctk.CTkLabel(left_column_frame, text="Async Depth:").grid(
            row=0, column=0, sticky="w", padx=5, pady=2
        )
        async_depth_option_menu = ctk.CTkOptionMenu(
            left_column_frame,
            variable=self.async_depth,
            values=["auto"] + [str(i) for i in range(1, 17)],
            fg_color=PRIMARY_BG,
            button_color=ACCENT_BLUE,
            button_hover_color=HOVER_BLUE,
            dropdown_fg_color=SECONDARY_BG,
            dropdown_hover_color=ACCENT_BLUE,
        )
        async_depth_option_menu.grid(row=0, column=1, sticky="ew", padx=5, pady=2)
        self.async_depth_option_menu = async_depth_option_menu

        # Preset
        ctk.CTkLabel(left_column_frame, text="Preset:").grid(
            row=1, column=0, sticky="w", padx=5, pady=2
        )
        preset_option_menu = ctk.CTkOptionMenu(
            left_column_frame,
            variable=self.preset,
            values=[
                "auto",
                "veryslow",
                "slower",
                "slow",
                "medium",
                "fast",
                "faster",
                "veryfast",
            ],
            fg_color=PRIMARY_BG,
            button_color=ACCENT_BLUE,
            button_hover_color=HOVER_BLUE,
            dropdown_fg_color=SECONDARY_BG,
            dropdown_hover_color=ACCENT_BLUE,
        )
        preset_option_menu.grid(row=1, column=1, sticky="ew", padx=5, pady=2)

        # Profile
        self.profile_label = ctk.CTkLabel(left_column_frame, text="Profile:")
        self.profile_label.grid(row=2, column=0, sticky="w", padx=5, pady=2)

        # Profile Option Menu
        self.profile_option_menu = ctk.CTkOptionMenu(
            left_column_frame,
            variable=self.profile,
            values=["auto", "main", "main10", "mainsp", "rext", "scc"],
            fg_color=PRIMARY_BG,
            button_color=ACCENT_BLUE,
            button_hover_color=HOVER_BLUE,
            dropdown_fg_color=SECONDARY_BG,
            dropdown_hover_color=ACCENT_BLUE,
        )
        self.profile_option_menu.grid(row=2, column=1, sticky="ew", padx=5, pady=2)

        # Scenario
        self.scenario_label = ctk.CTkLabel(left_column_frame, text="Scenario:")
        self.scenario_label.grid(row=3, column=0, sticky="w", padx=5, pady=2)

        # Scenario Option Menu
        self.scenario_option_menu = ctk.CTkOptionMenu(
            left_column_frame,
            variable=self.scenario,
            values=[
                "auto",
                "displayremoting",
                "videoconference",
                "archive",
                "livestreaming",
                "cameracapture",
                "videosurveillance",
                "gamestreaming",
                "remotegaming",
            ],
            fg_color=PRIMARY_BG,
            button_color=ACCENT_BLUE,
            button_hover_color=HOVER_BLUE,
            dropdown_fg_color=SECONDARY_BG,
            dropdown_hover_color=ACCENT_BLUE,
        )
        self.scenario_option_menu.grid(row=3, column=1, sticky="ew", padx=5, pady=2)

        right_column_frame = ctk.CTkFrame(
            self.encoder_options_frame, fg_color="transparent"
        )
        right_column_frame.grid(
            row=1, column=2, columnspan=2, padx=5, pady=5, sticky="nsew"
        )

        # FF Threads
        ctk.CTkLabel(right_column_frame, text="FF Threads:").grid(
            row=0, column=0, sticky="w", padx=5, pady=2
        )
        preset_option_menu = ctk.CTkOptionMenu(
            right_column_frame,
            variable=self.threads,
            values=["auto"] + [str(i) for i in range(1, 17)],
            fg_color=PRIMARY_BG,
            button_color=ACCENT_BLUE,
            button_hover_color=HOVER_BLUE,
            dropdown_fg_color=SECONDARY_BG,
            dropdown_hover_color=ACCENT_BLUE,
        )
        preset_option_menu.grid(row=0, column=1, sticky="w", padx=5, pady=2)

        # HW Accel
        ctk.CTkLabel(right_column_frame, text="HW Accel:").grid(
            row=1, column=0, sticky="w", padx=5, pady=2
        )
        hwaccel_option_menu = ctk.CTkOptionMenu(
            right_column_frame,
            variable=self.hwaccel,
            values=[
                "auto",
                "qsv",
                "dxva2",
                "d3d11va",
                "d3d12va",
                "opencl",
                "vulkan",
            ],
            fg_color=PRIMARY_BG,
            button_color=ACCENT_BLUE,
            button_hover_color=HOVER_BLUE,
            dropdown_fg_color=SECONDARY_BG,
            dropdown_hover_color=ACCENT_BLUE,
        )
        hwaccel_option_menu.grid(row=1, column=1, sticky="ew", padx=5, pady=2)

        # Rate-Control
        ctk.CTkLabel(right_column_frame, text="Rate-Control:").grid(
            row=2, column=0, sticky="w", padx=5, pady=2
        )
        self.rc_option_menu = ctk.CTkOptionMenu(
            right_column_frame,
            variable=self.rc,
            values=["vbr", "cbr"],
            fg_color=PRIMARY_BG,
            button_color=ACCENT_BLUE,
            button_hover_color=HOVER_BLUE,
            dropdown_fg_color=SECONDARY_BG,
            dropdown_hover_color=ACCENT_BLUE,
        )
        self.rc_option_menu.grid(row=2, column=1, sticky="ew", padx=5, pady=2)

        # Tier Label (only for HEVC)
        self.tier_label = ctk.CTkLabel(right_column_frame, text="Tier:")
        self.tier_label.grid(row=3, column=0, sticky="w", padx=5, pady=2)

        # Tier Option Menu
        self.tier_option_menu = ctk.CTkOptionMenu(
            right_column_frame,
            variable=self.tier,
            values=["auto", "main", "high"],
            fg_color=PRIMARY_BG,
            button_color=ACCENT_BLUE,
            button_hover_color=HOVER_BLUE,
            dropdown_fg_color=SECONDARY_BG,
            dropdown_hover_color=ACCENT_BLUE,
        )
        self.tier_option_menu.grid(row=3, column=1, sticky="ew", padx=5, pady=2)

        # Checkboxes

        self.extbrc_checkbox = ctk.CTkCheckBox(
            right_column_frame,
            text="Extended Control",
            variable=self.extbrc,
            fg_color=ACCENT_BLUE,
            hover_color=HOVER_BLUE,
        )
        self.extbrc_checkbox.grid(
            row=0, column=2, columnspan=2, sticky="w", padx=5, pady=2
        )

        # Look Ahead Depth
        self.la_depth_label = ctk.CTkLabel(right_column_frame, text="LA Depth:")
        self.la_depth_label.grid(row=1, column=2, sticky="w", padx=5, pady=2)
        la_depth_option_menu = ctk.CTkOptionMenu(
            right_column_frame,
            variable=self.look_ahead_depth,
            values=["auto"] + [str(i) for i in range(0, 101, 10)],
            fg_color=PRIMARY_BG,
            button_color=ACCENT_BLUE,
            button_hover_color=HOVER_BLUE,
            dropdown_fg_color=SECONDARY_BG,
            dropdown_hover_color=ACCENT_BLUE,
        )
        la_depth_option_menu.grid(row=1, column=3, sticky="ew", padx=5, pady=2)
        self.la_depth_option_menu = la_depth_option_menu

        self.rdo_checkbox = ctk.CTkCheckBox(
            right_column_frame,
            text="RD Optimization",
            variable=self.rdo,
            fg_color=ACCENT_BLUE,
            hover_color=HOVER_BLUE,
        )
        self.rdo_checkbox.grid(
            row=2, column=2, columnspan=2, sticky="w", padx=5, pady=2
        )

        self.mbbrc_checkbox = ctk.CTkCheckBox(
            right_column_frame,
            text="MB level",
            variable=self.mbbrc,
            fg_color=ACCENT_BLUE,
            hover_color=HOVER_BLUE,
        )
        self.mbbrc_checkbox.grid(
            row=3, column=2, columnspan=2, sticky="w", padx=5, pady=2
        )

        # FPS and Scaling
        fps_scale_frame_toggle = TextCheckbox(
            main_frame,
            text="FPS and Scaling Settings",
            variable=self.enable_fps_scale_options,
            command=self._toggle_fps_scale_options_frame,
        )
        fps_scale_frame_toggle.grid(row=7, column=0, sticky="w", padx=10, pady=5)

        self.fps_scale_options_frame = ctk.CTkFrame(main_frame, fg_color=SECONDARY_BG)

        # FPS
        ctk.CTkLabel(self.fps_scale_options_frame, text="FPS:").grid(
            row=1, column=0, sticky="w", padx=10, pady=5
        )
        fps_options = [
            ("Source", "source"),
            ("60", "60"),
            ("50", "50"),
            ("30", "30"),
            ("23.976", "24000/1001"),
        ]

        for i, (text, value) in enumerate(fps_options):
            rb = ctk.CTkRadioButton(
                self.fps_scale_options_frame,
                text=text,
                variable=self.fps_option,
                value=value,
                command=self._toggle_custom_fps_entry,
                fg_color=ACCENT_BLUE,
                hover_color=HOVER_BLUE,
            )
            rb.grid(row=1, column=i + 1, sticky="w", padx=2)

        # Custom FPS
        rb_custom = ctk.CTkRadioButton(
            self.fps_scale_options_frame,
            text="Custom",
            variable=self.fps_option,
            value="custom",
            command=self._toggle_custom_fps_entry,
            fg_color=ACCENT_BLUE,
            hover_color=HOVER_BLUE,
        )
        rb_custom.grid(row=2, column=1, sticky="w", padx=2, pady=(10, 10))

        self.custom_fps_entry = ctk.CTkEntry(
            self.fps_scale_options_frame,
            textvariable=self.custom_fps,
            width=80,
            justify="center",
            fg_color=SECONDARY_BG,
            text_color=PLACEHOLDER_COLOR,
            border_color=ACCENT_DEEPBLUE,
        )
        self.custom_fps_entry.grid(row=2, column=0, sticky="w", padx=20)
        self.custom_fps_entry.configure(state="disabled")

        # FPS Mode
        ctk.CTkLabel(self.fps_scale_options_frame, text="FPS Mode:").grid(
            row=3, column=0, sticky="w", padx=10, pady=5
        )

        fps_mode_options = [
            ("Auto", "auto"),
            ("Constant", "cfr"),
            ("Variable", "vfr"),
            ("Passthrough", "passthrough"),
        ]

        for i, (text, value) in enumerate(fps_mode_options):
            rb = ctk.CTkRadioButton(
                self.fps_scale_options_frame,
                text=text,
                variable=self.fps_mode,
                value=value,
                fg_color=ACCENT_BLUE,
                hover_color=HOVER_BLUE,
            )
            rb.grid(row=3, column=i + 1, sticky="w", padx=2)

        # Video Format
        ctk.CTkLabel(self.fps_scale_options_frame, text="Video Format:").grid(
            row=4, column=0, sticky="w", padx=10, pady=2
        )
        video_format_options = [
            ("Source", "source"),
            ("HD", "1280"),
            ("FHD", "1920"),
            ("QHD", "2560"),
            ("4K", "3840"),
        ]

        for i, (text, value) in enumerate(video_format_options):
            rb = ctk.CTkRadioButton(
                self.fps_scale_options_frame,
                text=text,
                variable=self.video_format_option,
                value=value,
                command=self._toggle_custom_video_width_entry,
                fg_color=ACCENT_BLUE,
                hover_color=HOVER_BLUE,
            )
            rb.grid(row=4, column=i + 1, sticky="w", padx=2)

        # Custom Video Format
        rb_custom_video = ctk.CTkRadioButton(
            self.fps_scale_options_frame,
            text="Custom",
            variable=self.video_format_option,
            value="custom",
            command=self._toggle_custom_video_width_entry,
            fg_color=ACCENT_BLUE,
            hover_color=HOVER_BLUE,
        )
        rb_custom_video.grid(row=5, column=1, sticky="w", padx=2, pady=10)

        self.custom_video_width_entry = ctk.CTkEntry(
            self.fps_scale_options_frame,
            textvariable=self.custom_video_width,
            width=80,
            justify="center",
            fg_color=SECONDARY_BG,
            text_color=PLACEHOLDER_COLOR,
            border_color=ACCENT_DEEPBLUE,
        )
        self.custom_video_width_entry.grid(row=5, column=0, sticky="w", padx=20)
        self.custom_video_width_entry.configure(state="disabled")

        # Interpolation
        ctk.CTkLabel(self.fps_scale_options_frame, text="Interpolation Algo:").grid(
            row=6, column=0, sticky="w", padx=10, pady=10
        )

        self.interpolation_description = ctk.StringVar(
            value="Smooth and balanced quality."
        )
        self.interpolation_algo.trace_add(
            "write", lambda *args: self._update_interpolation_description()
        )

        interp_option_menu = ctk.CTkOptionMenu(
            self.fps_scale_options_frame,
            variable=self.interpolation_algo,
            values=["bilinear", "bicubic", "neighbor", "area", "lanczos", "spline"],
            fg_color=PRIMARY_BG,
            button_color=ACCENT_BLUE,
            button_hover_color=HOVER_BLUE,
            dropdown_fg_color=SECONDARY_BG,
            dropdown_hover_color=ACCENT_BLUE,
        )
        interp_option_menu.grid(row=6, column=1, sticky="ew", padx=5, pady=2)

        ctk.CTkLabel(
            self.fps_scale_options_frame,
            textvariable=self.interpolation_description,
            text_color=PLACEHOLDER_COLOR,
            wraplength=100,
            anchor="w",
            justify="left",
        ).grid(row=6, column=2, sticky="w", padx=5)

        # Audio Settings Toggle
        audio_frame_toggle = TextCheckbox(
            main_frame,
            text="Audio Settings",
            variable=self.enable_audio_options,
            command=self._toggle_audio_options_frame,
        )
        audio_frame_toggle.grid(row=9, column=0, sticky="w", padx=10, pady=5)

        # Audio Frame
        self.audio_frame = ctk.CTkFrame(main_frame, fg_color=SECONDARY_BG)
        audio_options_subframe = ctk.CTkFrame(self.audio_frame, fg_color="transparent")
        audio_options_subframe.pack(fill="x", padx=10, pady=5)

        first_row_options = [
            ("Disable", "disable"),
            ("Source", "copy"),
            ("AAC 96", "aac_96k"),
            ("AAC 160", "aac_160k"),
            ("AAC 256", "aac_256k"),
        ]

        second_row_options = [
            ("Opus 96", "opus_96k"),
            ("Opus 160", "opus_160k"),
            ("Opus 256", "opus_256k"),
        ]

        # AAC row
        for i, (text, value) in enumerate(first_row_options):
            rb = ctk.CTkRadioButton(
                audio_options_subframe,
                text=text,
                variable=self.audio_option,
                value=value,
                command=self._toggle_custom_abitrate,
                fg_color=ACCENT_BLUE,
                hover_color=HOVER_BLUE,
            )
            rb.grid(row=0, column=i, sticky="w", padx=15, pady=10)

        # Custom AAC bitrate
        self.custom_audio_rb = ctk.CTkRadioButton(
            audio_options_subframe,
            text="Custom",
            variable=self.audio_option,
            value="custom",
            command=self._toggle_custom_abitrate,
            fg_color=ACCENT_BLUE,
            hover_color=HOVER_BLUE,
        )
        self.custom_audio_rb.grid(row=1, column=1, sticky="w", padx=15, pady=2)

        self.custom_abitrate_entry = ctk.CTkEntry(
            audio_options_subframe,
            textvariable=self.custom_abitrate,
            width=80,
            justify="center",
            fg_color=ACCENT_DEEPBLUE,
            text_color=PLACEHOLDER_COLOR,
            border_color=ACCENT_DEEPBLUE,
        )
        self.custom_abitrate_entry.grid(row=1, column=0, sticky="w", padx=20)
        self.custom_abitrate_entry.configure(state="disabled")

        # Opus row
        for i, (text, value) in enumerate(second_row_options):
            rb = ctk.CTkRadioButton(
                audio_options_subframe,
                text=text,
                variable=self.audio_option,
                value=value,
                command=self._toggle_custom_abitrate,
                fg_color=ACCENT_BLUE,
                hover_color=HOVER_BLUE,
            )
            rb.grid(row=1, column=i + 2, sticky="w", padx=15, pady=10)

        # Additional Options
        additional_options_toggle = TextCheckbox(
            main_frame,
            text="Additional Options (Trimming)",
            variable=self.enable_additional_options,
            command=self._toggle_additional_options_frame,
        )
        additional_options_toggle.grid(row=11, column=0, sticky="w", padx=10, pady=5)
        self.additional_options_frame = ctk.CTkFrame(main_frame, fg_color=SECONDARY_BG)

        # Trimming controls
        trim_frame = ctk.CTkFrame(self.additional_options_frame, fg_color="transparent")
        trim_frame.grid(row=1, column=0, columnspan=3, sticky="w")

        ctk.CTkLabel(trim_frame, text="Trimming:").grid(
            row=1, column=1, sticky="w", padx=10, pady=10
        )

        # Start time
        ctk.CTkLabel(trim_frame, text="From:").grid(row=1, column=2, padx=(85, 5))
        start_entry = ctk.CTkEntry(
            trim_frame,
            textvariable=self.trim_start,
            width=65,
            justify="center",
            fg_color=SECONDARY_BG,
            text_color=TEXT_COLOR_W,
            border_color=HOVER_BLUE,
        )
        start_entry.grid(row=1, column=3)
        start_entry.bind(
            "<Return>",
            lambda e: self._validate_and_update_trim_time(self.trim_start, True),
        )

        # End time
        ctk.CTkLabel(trim_frame, text="To:").grid(row=1, column=4, padx=(10, 5))
        end_entry = ctk.CTkEntry(
            trim_frame,
            textvariable=self.trim_end,
            width=65,
            justify="center",
            fg_color=SECONDARY_BG,
            text_color=TEXT_COLOR_W,
            border_color=HOVER_BLUE,
        )
        end_entry.grid(row=1, column=5)
        end_entry.bind(
            "<Return>",
            lambda e: self._validate_and_update_trim_time(self.trim_end, False),
        )

        # Add validation on focus out
        start_entry.bind(
            "<FocusOut>", lambda e: self._validate_trim_time(self.trim_start, True)
        )
        end_entry.bind(
            "<FocusOut>", lambda e: self._validate_trim_time(self.trim_end, False)
        )

        # Trim button
        ctk.CTkButton(
            trim_frame,
            text="Trim",
            command=self._add_trim_options,
            fg_color=ACCENT_BLUE,
            hover_color=HOVER_BLUE,
            text_color=TEXT_COLOR_B,
            width=80,
        ).grid(row=1, column=6, padx=10)

        # Streamcopy checkbox
        ctk.CTkCheckBox(
            trim_frame,
            text="Copy",
            command=lambda: self.audio_option.set("copy"),
            variable=self.trim_streamcopy,
            width=70,
            fg_color=ACCENT_BLUE,
            hover_color=HOVER_BLUE,
        ).grid(row=1, column=7)

        # Precise trim checkbox
        ctk.CTkCheckBox(
            trim_frame,
            text="Precise",
            variable=self.precise_trim,
            fg_color=ACCENT_BLUE,
            hover_color=HOVER_BLUE,
        ).grid(row=1, column=8)

        # FF Options
        ctk.CTkLabel(self.additional_options_frame, text="Add FF Options:").grid(
            row=2, column=0, sticky="w", padx=10, pady=10
        )
        self.additional_options_entry = ctk.CTkEntry(
            self.additional_options_frame,
            textvariable=self.additional_options,
            fg_color=SECONDARY_BG,
            text_color=TEXT_COLOR_W,
            border_color=HOVER_BLUE,
        )
        self.additional_options_entry.grid(row=2, column=1, sticky="ew", padx=5, pady=2)
        self.additional_options_entry.insert(0, self.additional_options_placeholder)
        self.additional_options_entry.configure(text_color=PLACEHOLDER_COLOR)
        self.additional_options_entry.bind("<FocusIn>", self._on_options_entry_focus_in)
        self.additional_options_entry.bind(
            "<FocusOut>", self._on_options_entry_focus_out
        )

        ctk.CTkButton(
            self.additional_options_frame,
            text="?",
            width=30,
            fg_color=ACCENT_DEEPBLUE,
            hover_color=HOVER_DEEPBLUE,
            command=lambda: self._show_help_window(
                "Quick Sync Encoder Options", "encoder"
            ),
        ).grid(row=2, column=2, padx=(0, 10))

        # Video Filters
        ctk.CTkLabel(
            self.additional_options_frame, text="Add Video Filters (-vf):"
        ).grid(row=3, column=0, sticky="w", padx=10, pady=2)
        self.additional_filter_options_entry = ctk.CTkEntry(
            self.additional_options_frame,
            textvariable=self.additional_filter_options,
            fg_color=SECONDARY_BG,
            text_color=TEXT_COLOR_W,
            border_color=HOVER_BLUE,
        )
        self.additional_filter_options_entry.grid(
            row=3, column=1, sticky="ew", padx=5, pady=10
        )
        self.additional_filter_options_entry.insert(
            0, self.additional_filter_options_placeholder
        )
        self.additional_filter_options_entry.configure(text_color=PLACEHOLDER_COLOR)
        self.additional_filter_options_entry.bind(
            "<FocusIn>", self._on_filters_entry_focus_in
        )
        self.additional_filter_options_entry.bind(
            "<FocusOut>", self._on_filters_entry_focus_out
        )

        ctk.CTkButton(
            self.additional_options_frame,
            text="?",
            width=30,
            fg_color=ACCENT_DEEPBLUE,
            hover_color=HOVER_DEEPBLUE,
            command=lambda: self._show_help_window("FFmpeg Video Filters", "filters"),
        ).grid(row=3, column=2, padx=(0, 10))

        # Audio Filters
        ctk.CTkLabel(
            self.additional_options_frame, text="Add Audio Filters (-af):"
        ).grid(row=4, column=0, sticky="w", padx=10, pady=2)
        self.additional_audio_filter_options_entry = ctk.CTkEntry(
            self.additional_options_frame,
            textvariable=self.additional_audio_filter_options,
            fg_color=SECONDARY_BG,
            text_color=TEXT_COLOR_W,
            border_color=HOVER_BLUE,
        )
        self.additional_audio_filter_options_entry.grid(
            row=4, column=1, sticky="ew", padx=5, pady=10
        )
        self.additional_audio_filter_options_entry.insert(
            0, self.additional_audio_filter_options_placeholder
        )
        self.additional_audio_filter_options_entry.configure(
            text_color=PLACEHOLDER_COLOR
        )
        self.additional_audio_filter_options_entry.bind(
            "<FocusIn>", self._on_audio_filters_entry_focus_in
        )
        self.additional_audio_filter_options_entry.bind(
            "<FocusOut>", self._on_audio_filters_entry_focus_out
        )

        # Quick filter buttons
        quick_buttons_frame = ctk.CTkFrame(
            self.additional_options_frame, fg_color="transparent"
        )
        quick_buttons_frame.grid(
            row=5, column=0, columnspan=3, sticky="w", padx=10, pady=(0, 10)
        )
        self.additional_options_frame.grid_columnconfigure(1, weight=1)

        ctk.CTkButton(
            quick_buttons_frame,
            text="Brightness",
            command=lambda: self._add_video_filter("eq=brightness=-0.15"),
            fg_color=ACCENT_BLUE,
            hover_color=HOVER_BLUE,
            text_color=TEXT_COLOR_B,
            width=106,
        ).pack(side="left", padx=(0, 10))

        ctk.CTkButton(
            quick_buttons_frame,
            text="Sharpness",
            command=lambda: self._add_video_filter("unsharp=5:5:1.0:3:3:0.0"),
            fg_color=ACCENT_BLUE,
            hover_color=HOVER_BLUE,
            text_color=TEXT_COLOR_B,
            width=106,
        ).pack(side="left", padx=(0, 10))

        ctk.CTkButton(
            quick_buttons_frame,
            text="H-Flip",
            command=lambda: self._add_video_filter("hflip"),
            fg_color=ACCENT_BLUE,
            hover_color=HOVER_BLUE,
            text_color=TEXT_COLOR_B,
            width=106,
        ).pack(side="left", padx=(0, 10))

        ctk.CTkButton(
            quick_buttons_frame,
            text="Speed up X2",
            command=lambda: self._set_speed_filter("2.0"),
            fg_color=ACCENT_BLUE,
            hover_color=HOVER_BLUE,
            text_color=TEXT_COLOR_B,
            width=106,
        ).pack(side="left", padx=(0, 10))

        ctk.CTkButton(
            quick_buttons_frame,
            text="Audio fix",
            command=lambda: self._add_audio_filter("loudnorm=I=-16:TP=-1.5:LRA=11"),
            fg_color=ACCENT_BLUE,
            hover_color=HOVER_BLUE,
            text_color=TEXT_COLOR_B,
            width=106,
        ).pack(side="left", padx=(0, 10))

        # Reset button
        ctk.CTkButton(
            quick_buttons_frame,
            text="Clear",
            command=self._clear_all_filters,
            fg_color=ACCENT_RED,
            hover_color=HOVER_RED,
            text_color=TEXT_COLOR_B,
            width=106,
        ).pack(side="left")

        quick_buttons_frame_2 = ctk.CTkFrame(
            self.additional_options_frame, fg_color="transparent"
        )
        quick_buttons_frame_2.grid(
            row=6, column=0, columnspan=3, sticky="w", padx=10, pady=(0, 10)
        )

        ctk.CTkButton(
            quick_buttons_frame_2,
            text="Saturation",
            command=lambda: self._add_video_filter("eq=saturation=1.15"),
            fg_color=ACCENT_BLUE,
            hover_color=HOVER_BLUE,
            text_color=TEXT_COLOR_B,
            width=106,
        ).pack(side="left", padx=(0, 10))

        ctk.CTkButton(
            quick_buttons_frame_2,
            text="Denoise",
            command=lambda: self._add_video_filter("hqdn3d=2:1.5:3:2.25"),
            fg_color=ACCENT_BLUE,
            hover_color=HOVER_BLUE,
            text_color=TEXT_COLOR_B,
            width=106,
        ).pack(side="left", padx=(0, 10))

        ctk.CTkButton(
            quick_buttons_frame_2,
            text="V-Flip",
            command=lambda: self._add_video_filter("vflip"),
            fg_color=ACCENT_BLUE,
            hover_color=HOVER_BLUE,
            text_color=TEXT_COLOR_B,
            width=106,
        ).pack(side="left", padx=(0, 10))

        ctk.CTkButton(
            quick_buttons_frame_2,
            text="Slow down X2",
            command=lambda: self._set_speed_filter("0.5"),
            fg_color=ACCENT_BLUE,
            hover_color=HOVER_BLUE,
            text_color=TEXT_COLOR_B,
            width=106,
        ).pack(side="left", padx=(0, 10))

        ctk.CTkButton(
            quick_buttons_frame_2,
            text="Stereo out",
            command=self._set_stereo_out,
            fg_color=ACCENT_BLUE,
            hover_color=HOVER_BLUE,
            text_color=TEXT_COLOR_B,
            width=106,
        ).pack(side="left", padx=(0, 10))

        ctk.CTkButton(
            quick_buttons_frame_2,
            text="Streams",
            command=self._open_map_window,
            fg_color=ACCENT_DEEPBLUE,
            hover_color=HOVER_DEEPBLUE,
            text_color=TEXT_COLOR_W,
            width=106,
        ).pack(side="left")

        quick_buttons_frame_3 = ctk.CTkFrame(
            self.additional_options_frame, fg_color="transparent"
        )
        quick_buttons_frame_3.grid(
            row=7, column=0, columnspan=3, sticky="w", padx=10, pady=(0, 10)
        )

        ctk.CTkButton(
            quick_buttons_frame_3,
            text="Gamma RGB",
            command=lambda: self._add_video_filter(
                "eq=gamma_r=1.0:gamma_g=1.0:gamma_b=1.0:gamma_weight=1.0"
            ),
            fg_color=ACCENT_BLUE,
            hover_color=HOVER_BLUE,
            text_color=TEXT_COLOR_B,
            width=106,
        ).pack(side="left", padx=(0, 10))

        ctk.CTkButton(
            quick_buttons_frame_3,
            text="Deshake",
            command=lambda: self._add_video_filter(
                "deshake=rx=32:ry=32:edge=3:blocksize=32:contrast=200:search=0"
            ),
            fg_color=ACCENT_BLUE,
            hover_color=HOVER_BLUE,
            text_color=TEXT_COLOR_B,
            width=106,
        ).pack(side="left", padx=(0, 10))

        ctk.CTkButton(
            quick_buttons_frame_3,
            text="Rotate 90°",
            command=lambda: self._add_video_filter("transpose=1"),
            fg_color=ACCENT_BLUE,
            hover_color=HOVER_BLUE,
            text_color=TEXT_COLOR_B,
            width=106,
        ).pack(side="left", padx=(0, 10))

        ctk.CTkButton(
            quick_buttons_frame_3,
            text="Crop to 16:9",
            command=lambda: self._add_video_filter(
                "crop=iw:min(ih\\,iw*9/16):0:(ih-min(ih\\,iw*9/16))/2"
            ),
            fg_color=ACCENT_BLUE,
            hover_color=HOVER_BLUE,
            text_color=TEXT_COLOR_B,
            width=106,
        ).pack(side="left", padx=(0, 10))

        ctk.CTkButton(
            quick_buttons_frame_3,
            text="HDR to SDR",
            command=lambda: self._add_video_filter(
                "zscale=transfer=linear:npl=100,"
                "tonemap=tonemap=hable:desat=0,"
                "zscale=transfer=bt709:matrix=bt709:primaries=bt709"
            ),
            fg_color=ACCENT_BLUE,
            hover_color=HOVER_BLUE,
            text_color=TEXT_COLOR_B,
            width=106,
        ).pack(side="left", padx=(0, 10))

        # ctk.CTkButton(
        #     quick_buttons_frame_3,
        #     text="Free button",
        #     command=None,
        #     fg_color=ACCENT_BLUE,
        #     hover_color=HOVER_BLUE,
        #     text_color=TEXT_COLOR_B,
        #     width=106,
        # ).pack(side="left")

        # Presets Section
        presets_frame_toggle = TextCheckbox(
            main_frame,
            text="Presets",
            variable=self.enable_presets,
            command=self._toggle_presets_frame,
        )
        presets_frame_toggle.grid(row=13, column=0, sticky="w", padx=10, pady=5)
        self.presets_frame = ctk.CTkFrame(main_frame, fg_color=SECONDARY_BG)

        preset_options = [
            ("Default (Reset)", "none"),
            ("FHD Fast", "fhdf"),
            ("FHD Quality", "fhdq"),
            ("HD Fast", "hdf"),
            ("HD Quality", "hdq"),
        ]

        for i, (text, value) in enumerate(preset_options):
            rb = ctk.CTkRadioButton(
                self.presets_frame,
                text=text,
                variable=self.selected_preset,
                value=value,
                command=lambda v=value: self._apply_preset(v),
                fg_color=ACCENT_BLUE,
                hover_color=HOVER_BLUE,
            )
            rb.grid(row=1, column=i, padx=10, pady=5, sticky="w")

        custom_row_frame = ctk.CTkFrame(self.presets_frame, fg_color="transparent")
        custom_row_frame.grid(
            row=2, column=0, columnspan=5, sticky="ew", padx=0, pady=5
        )

        # Custom Radio Button
        self.custom_preset_rb = ctk.CTkRadioButton(
            custom_row_frame,
            text="Custom",
            variable=self.selected_preset,
            value="custom",
            command=self._on_custom_preset_selected,
            fg_color=ACCENT_BLUE,
            hover_color=HOVER_BLUE,
        )
        self.custom_preset_rb.pack(side="left", padx=(10, 5))

        # Preset Label
        ctk.CTkLabel(custom_row_frame, text="Preset:").pack(side="left", padx=(30, 5))

        # Preset dropdown
        self.custom_preset_dropdown = ctk.CTkOptionMenu(
            custom_row_frame,
            variable=self.custom_preset_name,
            values=self._get_preset_list(),
            command=self._load_custom_preset,
            fg_color=PRIMARY_BG,
            button_color=ACCENT_BLUE,
            button_hover_color=HOVER_BLUE,
            dropdown_fg_color=SECONDARY_BG,
            dropdown_hover_color=HOVER_BLUE,
            width=170,
            dynamic_resizing=False,
        )
        self.custom_preset_dropdown.pack(side="left", padx=5)

        self.save_as_preset_btn = ctk.CTkButton(
            custom_row_frame,
            text="Save As",
            command=self._save_preset_as,
            fg_color=ACCENT_BLUE,
            hover_color=HOVER_BLUE,
            text_color=TEXT_COLOR_B,
            width=70,
        )
        self.save_as_preset_btn.pack(side="left", padx=(15, 5))

        self.save_preset_btn = ctk.CTkButton(
            custom_row_frame,
            text="Save",
            command=self._save_preset,
            fg_color=ACCENT_BLUE,
            hover_color=HOVER_BLUE,
            text_color=TEXT_COLOR_B,
            width=60,
        )
        self.save_preset_btn.pack(side="left", padx=5)

        self.delete_preset_btn = ctk.CTkButton(
            custom_row_frame,
            text="Delete",
            command=self._delete_preset,
            fg_color=ACCENT_RED,
            hover_color=HOVER_RED,
            text_color=TEXT_COLOR_B,
            width=60,
        )
        self.delete_preset_btn.pack(side="left", padx=5)

        # Preset Indicator
        self.preset_indicator = ctk.CTkLabel(
            self.presets_frame, text="No preset selected", text_color=PLACEHOLDER_COLOR
        )
        self.preset_indicator.grid(
            row=3, column=0, columnspan=6, padx=10, pady=5, sticky="w"
        )

        ctk.CTkLabel(main_frame, textvariable=self.estimated_file_size).grid(
            row=16, column=0, sticky="w", padx=5, pady=2
        )

        # Output
        ctk.CTkLabel(
            main_frame, textvariable=self.ffmpeg_output, wraplength=600, justify="left"
        ).grid(row=18, column=0, columnspan=4, pady=(10, 0), padx=10)

        # Progress
        self.progress_frame = ctk.CTkFrame(main_frame, fg_color="transparent")
        self.progress_frame.grid(
            row=17, column=0, columnspan=4, pady=(10, 0), padx=10, sticky="ew"
        )
        self.progress_bar = ctk.CTkProgressBar(
            self.progress_frame,
            variable=self.progress_value,
            fg_color=SECONDARY_BG,
            progress_color=ACCENT_BLUE,
        )
        self.progress_bar.pack(fill="x", expand=True)
        self.progress_label = ctk.CTkLabel(self.progress_frame, text="0%")
        self.progress_label.pack()
        self.progress_frame.grid_remove()
        # Fix for combination: ctk.deactivate_automatic_dpi_awareness() + windows 125%+ scale
        self.master.after(0, self._startup_ui_fix)

        # Play buttons
        self.play_buttons_frame = ctk.CTkFrame(self.button_frame, fg_color=PRIMARY_BG)
        self.play_buttons_frame.pack(fill="x", pady=(0, 5))

        self.play_input_button = ctk.CTkButton(
            self.play_buttons_frame,
            text="Play Input File",
            fg_color=ACCENT_DEEPBLUE,
            hover_color=HOVER_DEEPBLUE,
            text_color=TEXT_COLOR_W,
            height=40,
        )
        self.play_input_button.pack(side="left", expand=True, fill="x", padx=(0, 2))
        self.play_input_button.configure(command=self._play_input_file)

        self.play_output_button = ctk.CTkButton(
            self.play_buttons_frame,
            text="Play Output File",
            fg_color=ACCENT_DEEPBLUE,
            hover_color=HOVER_DEEPBLUE,
            text_color=TEXT_COLOR_W,
            height=40,
        )
        self.play_output_button.pack(side="left", expand=True, fill="x", padx=(2, 2))
        self.play_output_button.configure(command=self._play_output_file)
        self.play_output_button.bind("<Button-3>", self._on_vmaf_right_click)
        CTkToolTip(
            self.play_output_button,
            message="Right-click to run VMAF analysis",
            bg_color=SECONDARY_BG,
            text_color=TEXT_COLOR_W,
            alpha=1.0,
            corner_radius=6,
            delay=0.3,
        )

        self.play10s_button = ctk.CTkButton(
            self.play_buttons_frame,
            text="Play 10s Preview",
            fg_color=ACCENT_DEEPBLUE,
            hover_color=HOVER_DEEPBLUE,
            text_color=TEXT_COLOR_W,
            height=40,
        )
        self.play10s_button.pack(side="left", expand=True, fill="x", padx=(2, 2))
        self.play10s_button.configure(command=self._create_10s_preview)

        self.batch_convert_button = ctk.CTkButton(
            self.play_buttons_frame,
            text="Batch Convert",
            fg_color=ACCENT_DEEPBLUE,
            hover_color=HOVER_DEEPBLUE,
            text_color=TEXT_COLOR_W,
            height=40,
        )
        self.batch_convert_button.pack(side="left", expand=True, fill="x", padx=(2, 2))
        self.batch_convert_button.configure(command=self._open_batch_converter)

        self.screen_record_button = ctk.CTkButton(
            self.play_buttons_frame,
            text="Screen Record",
            fg_color=ACCENT_DEEPBLUE,
            hover_color=HOVER_DEEPBLUE,
            text_color=TEXT_COLOR_W,
            height=40,
        )
        self.screen_record_button.pack(side="left", expand=True, fill="x", padx=(2, 0))
        self.screen_record_button.configure(command=self._screen_record)

        # Convert Button
        self.convert_button = ctk.CTkButton(
            self.button_frame,
            text="Convert",
            command=self._toggle_conversion,
            fg_color=ACCENT_BLUE,
            hover_color=HOVER_BLUE,
            text_color=TEXT_COLOR_B,
            height=40,
            font=("", 14, "bold"),
        )
        self.convert_button.pack(fill="x", pady=5)

        # Status
        ctk.CTkLabel(main_frame, textvariable=self.status_text).grid(
            row=16, column=0, columnspan=4, pady=5
        )

        # Initialize
        self._toggle_encoder_options_frame()
        self._toggle_fps_scale_options_frame()
        self._toggle_audio_options_frame()
        self._toggle_additional_options_frame()
        self._toggle_presets_frame()

    # Fix for combination: ctk.deactivate_automatic_dpi_awareness() + windows 125%+ scale
    def _startup_ui_fix(self):
        self.progress_frame.grid_remove()
        self.progress_value.set(0.0)
        self.auto_button.grid_remove()
        self.default_button.grid_remove()

    # CUSTOM PRESET METHODS
    def _get_preset_list(self):
        """Get list of saved presets"""
        try:
            files = os.listdir(self.presets_dir)
            presets = [os.path.splitext(f)[0] for f in files if f.endswith(".json")]
            return presets
        except Exception:
            return []

    def _update_preset_dropdown(self):
        """Update the preset dropdown list"""
        presets = self._get_preset_list()
        self.custom_preset_dropdown.configure(values=presets)

    def _on_custom_preset_selected(self):
        """Handle selection of custom preset radio button"""
        if self.selected_preset.get() == "custom":
            preset_name = self.custom_preset_name.get()
            if preset_name:
                self.custom_preset_selected.set(preset_name)
                self._load_custom_preset(preset_name)

    def _load_custom_preset(self, preset_name):
        """Load a custom preset"""
        try:
            preset_file = os.path.join(self.presets_dir, f"{preset_name}.json")
            if os.path.exists(preset_file):
                with open(preset_file, "r", encoding="utf-8") as file:
                    settings = load(file)

                self.loading_preset = True
                self._apply_settings_dict(settings)
                self.custom_preset_name.set(preset_name)
                self.custom_preset_selected.set(preset_name)
                self.loading_preset = False

                self.custom_preset_selected.set(preset_name)
                if self.selected_preset.get() != "custom":
                    self.selected_preset.set("custom")
                self.preset_indicator.configure(
                    text=f"Loaded preset: {preset_name}", text_color=ACCENT_BLUE
                )
                self._save_settings()
            else:
                messagebox.showerror("Error", f"Preset file not found: {preset_file}")
        except Exception as e:
            messagebox.showerror("Error", f"Failed to load preset: {str(e)}")

    def _save_preset_as(self):
        """Save current settings as a new preset"""
        preset_name = simpledialog.askstring("Save Preset", "Enter preset name:")
        if not preset_name:
            return

        # Check if preset already exists
        preset_file = os.path.join(self.presets_dir, f"{preset_name}.json")
        if os.path.exists(preset_file):
            if not messagebox.askyesno(
                "Overwrite", f"Preset '{preset_name}' already exists. Overwrite?"
            ):
                return

        self._save_preset_to_file(preset_name)
        self._update_preset_dropdown()
        self.custom_preset_name.set(preset_name)
        self.custom_preset_selected.set(preset_name)
        self.selected_preset.set("custom")
        self.preset_indicator.configure(
            text=f"Preset saved: {preset_name}", text_color=ACCENT_BLUE
        )

    def _on_vmaf_right_click(self, event=None):
        """Handle right-click on Play Output File button for VMAF analysis"""
        # Cancel if already running
        if getattr(self, "_vmaf_running", False):
            self._cancel_vmaf()
            return

        input_f = self.input_file.get()
        output_f = self.output_file.get()

        if not input_f or input_f.startswith("Drag and drop") or not output_f:
            messagebox.showwarning(
                "Warning", "Please specify both Input and Output files."
            )
            return

        if not os.path.exists(input_f) or not os.path.exists(output_f):
            messagebox.showwarning("Warning", "Input or Output file does not exist.")
            return

        # Start analysis in a separate thread
        self._vmaf_running = True
        Thread(target=self._run_vmaf_analysis, daemon=True).start()

    def _cancel_vmaf(self):
        """Cancel running VMAF analysis"""
        self._vmaf_running = False
        if hasattr(self, "_vmaf_process") and self._vmaf_process:
            try:
                self._vmaf_process.terminate()
            except Exception:
                pass
        self.status_text.set("VMAF analysis cancelled")
        self.ffmpeg_output.set("")

    def _run_vmaf_analysis(self):
        try:
            input_f = self.input_file.get()
            output_f = self.output_file.get()

            if not os.path.exists(input_f) or not os.path.exists(output_f):
                self.master.after(
                    0,
                    lambda: messagebox.showwarning(
                        "Warning", "Input or Output file does not exist."
                    ),
                )
                return

            n_threads = os.cpu_count()  # use os.cpu_count() instead of multiprocessing
            ffmpeg_path = (
                self.ffmpeg_custom_path.get()
                if self.ffmpeg_custom_path.get()
                and self.ffmpeg_custom_path.get() != self.ffmpeg_path_placeholder
                else self.ffmpeg_path
            )

            if not ffmpeg_path:
                self.master.after(
                    0,
                    lambda: messagebox.showerror(
                        "Error", "FFmpeg path is not specified"
                    ),
                )
                return

            # Get resolutions of both videos
            in_w, in_h = self._get_video_resolution(input_f)
            out_w, out_h = self._get_video_resolution(output_f)

            if None in (in_w, in_h, out_w, out_h):
                self.master.after(
                    0,
                    lambda: messagebox.showerror(
                        "Error", "Could not determine video resolution"
                    ),
                )
                return

            need_scaling = (in_w != out_w) or (in_h != out_h)
            scale_flag = self.interpolation_algo.get()  # scaling algorithm from GUI

            if need_scaling:
                # Scale first input (output) to match the size of the second input (original)
                lavfi_filter = (
                    f"[0:v]scale={in_w}:{in_h}:flags={scale_flag}[dist];"
                    f"[1:v]null[ref];"
                    f"[dist][ref]libvmaf=n_threads={n_threads}:n_subsample=10"
                )
                score_label = "VMAF score (with scaling)"
            else:
                lavfi_filter = f"libvmaf=n_threads={n_threads}:n_subsample=10"
                score_label = "VMAF score"

            command = [
                ffmpeg_path,
                "-t",
                "30",
                "-i",
                output_f,  # distorted video
                "-t",
                "30",
                "-i",
                input_f,  # original video
                "-lavfi",
                lavfi_filter,
                "-f",
                "null",
                "-",
            ]

            self.master.after(
                0, lambda: self.status_text.set("VMAF Analysis in progress...")
            )
            self.master.after(
                0, lambda: self.ffmpeg_output.set("Calculating VMAF score...")
            )

            # Pass the label to _execute_vmaf
            self._execute_vmaf(command, score_label)

        except Exception as e:
            self.master.after(
                0,
                lambda msg=f"VMAF Analysis failed: {str(e)}": messagebox.showerror(
                    "Error", msg
                ),
            )

    def _execute_vmaf(self, command, score_label="VMAF score"):
        """Execute the FFmpeg command and parse VMAF score"""
        startupinfo = None
        creationflags = 0
        if os.name == "nt":
            startupinfo = subprocess.STARTUPINFO()
            startupinfo.dwFlags |= subprocess.STARTF_USESHOWWINDOW
            startupinfo.wShowWindow = subprocess.SW_HIDE
            creationflags = subprocess.CREATE_NO_WINDOW

        try:
            self._vmaf_process = subprocess.Popen(
                command,
                stdout=subprocess.PIPE,
                stderr=subprocess.STDOUT,
                universal_newlines=True,
                startupinfo=startupinfo,
                creationflags=creationflags,
                encoding="utf-8",
                errors="replace",
            )

            vmaf_score = None
            for line in self._vmaf_process.stdout:
                if not self._vmaf_running:
                    self._vmaf_process.terminate()
                    break

                line = line.strip()
                if line:
                    self.master.after(0, lambda l=line: self.ffmpeg_output.set(l))
                    # Look for VMAF score
                    match = search(r"VMAF score:\s*([\d.]+)", line)
                    if match:
                        vmaf_score = match.group(1)

            self._vmaf_process.wait()

            if vmaf_score and self._vmaf_running:
                try:
                    score_float = float(vmaf_score)
                    formatted_score = f"{score_label}: {score_float:.2f}"
                    self.master.after(
                        0, lambda s=formatted_score: self.status_text.set(s)
                    )
                    self.master.after(0, lambda: MessageBeep(MB_ICONASTERISK))
                except ValueError:
                    self.master.after(
                        0, lambda: self.status_text.set("Error parsing VMAF score")
                    )
            elif self._vmaf_running:
                self.master.after(
                    0, lambda: self.status_text.set("VMAF score not found in output")
                )

        except Exception as e:
            self.master.after(
                0,
                lambda msg=f"Error executing VMAF: {str(e)}": self.status_text.set(msg),
            )
        finally:
            self._vmaf_running = False
            self._vmaf_process = None
            self.master.after(0, lambda: self.ffmpeg_output.set(""))

    def _save_preset(self):
        """Save current settings to selected preset"""
        preset_name = self.custom_preset_name.get()
        if not preset_name:
            # If no preset selected, act like Save As
            self._save_preset_as()
            return

        preset_file = os.path.join(self.presets_dir, f"{preset_name}.json")
        if not os.path.exists(preset_file):
            messagebox.showwarning(
                "Warning",
                f"Preset '{preset_name}' does not exist. Saving as new preset.",
            )
            self._save_preset_as()
            return

        self._save_preset_to_file(preset_name)
        self.selected_preset.set("custom")
        self.preset_indicator.configure(
            text=f"Preset saved: {preset_name}", text_color=ACCENT_BLUE
        )

    def _save_preset_to_file(self, preset_name):
        """Save current settings to preset file"""
        try:
            preset_file = os.path.join(self.presets_dir, f"{preset_name}.json")
            settings = self._get_current_settings()

            with open(preset_file, "w", encoding="utf-8") as file:
                dump(settings, file, indent=4, ensure_ascii=False)
        except Exception as e:
            messagebox.showerror("Error", f"Failed to save preset: {str(e)}")

    def _delete_preset(self):
        """Delete selected preset"""
        preset_name = self.custom_preset_name.get()
        if not preset_name:
            messagebox.showinfo("Info", "No preset selected to delete.")
            return

        preset_file = os.path.join(self.presets_dir, f"{preset_name}.json")
        if not os.path.exists(preset_file):
            messagebox.showerror("Error", f"Preset file not found: {preset_file}")
            return

        if messagebox.askyesno(
            "Confirm Delete", f"Are you sure you want to delete preset '{preset_name}'?"
        ):
            try:
                os.remove(preset_file)
                self._update_preset_dropdown()
                self.custom_preset_name.set("")
                self.custom_preset_selected.set("")
                self.selected_preset.set("none")
                self.preset_indicator.configure(
                    text=f"Preset deleted: {preset_name}", text_color=ACCENT_BLUE
                )
            except Exception as e:
                messagebox.showerror("Error", f"Failed to delete preset: {str(e)}")

    def _apply_settings_dict(self, settings_dict):
        """Apply settings from dictionary to variables"""
        # FFmpeg path
        ffmpeg_path = settings_dict.get("ffmpeg_path", "")
        if ffmpeg_path and os.path.exists(ffmpeg_path):
            self.ffmpeg_custom_path.set(ffmpeg_path)

        # Last directories
        last_input_dir = settings_dict.get("last_input_dir", "")
        if last_input_dir:
            self.last_input_dir.set(last_input_dir)

        last_output_dir = settings_dict.get("last_output_dir", "")
        if last_output_dir:
            self.last_output_dir.set(last_output_dir)

        # Codec
        codec = settings_dict.get("codec", "")
        if codec in ["hevc", "h264", "av1", "vp9"]:
            self.video_codec.set(codec)

        # ICQ mode
        icq_mode = settings_dict.get("icq_mode")
        if icq_mode is not None:
            self.icq_mode.set(icq_mode)

        # Global quality level
        global_quality_level = settings_dict.get("global_quality_level", "")
        if global_quality_level:
            self.global_quality_level.set(global_quality_level)

        # Bitrate
        bitrate = settings_dict.get("bitrate", "")
        if bitrate:
            self.bitrate.set(bitrate)

        # Audio option
        audio_option = settings_dict.get("audio_option", "")
        if audio_option:
            self.audio_option.set(audio_option)

        # Custom audio bitrate
        custom_abitrate = settings_dict.get("custom_abitrate", "")
        if custom_abitrate:
            self.custom_abitrate.set(custom_abitrate)

        # Encoder settings
        encoder_async_depth = settings_dict.get("encoder_async_depth", "")
        if encoder_async_depth:
            self.async_depth.set(encoder_async_depth)

        encoder_preset = settings_dict.get("encoder_preset", "")
        if encoder_preset:
            self.preset.set(encoder_preset)

        encoder_profile = settings_dict.get("encoder_profile", "")
        if encoder_profile:
            self.profile.set(encoder_profile)

        encoder_scenario = settings_dict.get("encoder_scenario", "")
        if encoder_scenario:
            self.scenario.set(encoder_scenario)

        encoder_threads = settings_dict.get("encoder_threads", "")
        if encoder_threads:
            self.threads.set(encoder_threads)

        encoder_hwaccel = settings_dict.get("encoder_hwaccel", "")
        if encoder_hwaccel:
            self.hwaccel.set(encoder_hwaccel)

        encoder_rc = settings_dict.get("encoder_rc", "")
        if encoder_rc:
            self.rc.set(encoder_rc)

        encoder_tier = settings_dict.get("encoder_tier", "")
        if encoder_tier:
            self.tier.set(encoder_tier)

        encoder_look_ahead_depth = settings_dict.get("encoder_look_ahead_depth", "")
        if encoder_look_ahead_depth:
            self.look_ahead_depth.set(encoder_look_ahead_depth)

        # Boolean encoder settings
        encoder_extbrc = settings_dict.get("encoder_extbrc")
        if encoder_extbrc is not None:
            self.extbrc.set(encoder_extbrc)

        encoder_rdo = settings_dict.get("encoder_rdo")
        if encoder_rdo is not None:
            self.rdo.set(encoder_rdo)

        encoder_mbbrc = settings_dict.get("encoder_mbbrc")
        if encoder_mbbrc is not None:
            self.mbbrc.set(encoder_mbbrc)

        # FPS and scaling
        fps_option = settings_dict.get("fps_option", "")
        if fps_option:
            self.fps_option.set(fps_option)

        custom_fps = settings_dict.get("custom_fps", "")
        if custom_fps:
            self.custom_fps.set(custom_fps)

        fps_mode = settings_dict.get("fps_mode", "")
        if fps_mode:
            self.fps_mode.set(fps_mode)

        video_format_option = settings_dict.get("video_format_option", "")
        if video_format_option:
            self.video_format_option.set(video_format_option)

        custom_video_width = settings_dict.get("custom_video_width", "")
        if custom_video_width:
            self.custom_video_width.set(custom_video_width)

        interpolation_algo = settings_dict.get("interpolation_algo", "")
        if interpolation_algo:
            self.interpolation_algo.set(interpolation_algo)

        # Trimming Settings
        trim_start = settings_dict.get("trim_start", "")
        if trim_start:
            self.trim_start.set(trim_start)

        trim_end = settings_dict.get("trim_end", "")
        if trim_end:
            self.trim_end.set(trim_end)

        trim_streamcopy = settings_dict.get("trim_streamcopy")
        if trim_streamcopy is not None:
            self.trim_streamcopy.set(trim_streamcopy)

        precise_trim = settings_dict.get("precise_trim")
        if precise_trim is not None:
            self.precise_trim.set(precise_trim)

        # Additional Options
        additional_options = settings_dict.get("additional_options", "")
        if additional_options:
            self.additional_options.set(additional_options)
            self.additional_options_entry.configure(text_color=TEXT_COLOR_W)
        else:
            self.additional_options.set(self.additional_options_placeholder)
            self.additional_options_entry.configure(text_color=PLACEHOLDER_COLOR)

        additional_filter_options = settings_dict.get("additional_filter_options", "")
        if additional_filter_options:
            self.additional_filter_options.set(additional_filter_options)
            self.additional_filter_options_entry.configure(text_color=TEXT_COLOR_W)
        else:
            self.additional_filter_options.set(
                self.additional_filter_options_placeholder
            )
            self.additional_filter_options_entry.configure(text_color=PLACEHOLDER_COLOR)

        additional_audio_filter_options = settings_dict.get(
            "additional_audio_filter_options", ""
        )
        if additional_audio_filter_options:
            self.additional_audio_filter_options.set(additional_audio_filter_options)
            self.additional_audio_filter_options_entry.configure(
                text_color=TEXT_COLOR_W
            )
        else:
            self.additional_audio_filter_options.set(
                self.additional_audio_filter_options_placeholder
            )
            self.additional_audio_filter_options_entry.configure(
                text_color=PLACEHOLDER_COLOR
            )

        # Selected preset
        selected_preset = settings_dict.get("selected_preset", "")
        if selected_preset:
            self.selected_preset.set(selected_preset)

        # Custom preset selected
        custom_preset_selected = settings_dict.get("custom_preset_selected", "")
        if custom_preset_selected:
            self.custom_preset_selected.set(custom_preset_selected)
            self._update_preset_dropdown()
            self.custom_preset_name.set(custom_preset_selected)

        # Batch Converter Settings
        batch_output_folder = settings_dict.get("batch_output_folder", "")
        if batch_output_folder and os.path.exists(batch_output_folder):
            self.batch_output_folder.set(batch_output_folder)

        batch_change_container = settings_dict.get("batch_change_container")
        if batch_change_container is not None:
            self.batch_change_container.set(batch_change_container)

        batch_output_container = settings_dict.get("batch_output_container", "")
        if batch_output_container:
            self.batch_output_container.set(batch_output_container)

        # Check if preset's preset file still exists
        if selected_preset == "custom" and custom_preset_selected:
            preset_file = os.path.join(
                self.presets_dir, f"{custom_preset_selected}.json"
            )
            if not os.path.exists(preset_file):
                # Preset file missing → reset selection
                self.selected_preset.set("none")
                self.custom_preset_selected.set("")
                self.custom_preset_name.set("")
                print(
                    f"Preset file '{custom_preset_selected}.json' not found. Preset selection reset."
                )

        # Update UI elements
        self._update_codec_settings()
        self._toggle_icq_mode()
        self._toggle_custom_abitrate()
        self._toggle_custom_fps_entry()
        self._toggle_custom_video_width_entry()
        self._update_interpolation_description()

        # Update trim slider if it exists
        if hasattr(self, "trim_canvas"):
            self.master.after(100, self._draw_trim_slider)

        # Update preset indicator using current variable values
        self._update_preset_indicator()

    def _get_current_settings(self):
        """Get current settings as dictionary"""
        settings = {
            # Main Settings
            "ffmpeg_path": self.ffmpeg_custom_path.get()
            if self.ffmpeg_custom_path.get() != self.ffmpeg_path_placeholder
            else "",
            "last_input_dir": self.last_input_dir.get(),
            "last_output_dir": self.last_output_dir.get(),
            "codec": self.video_codec.get(),
            "bitrate": self.bitrate.get(),
            "icq_mode": self.icq_mode.get(),
            "global_quality_level": self.global_quality_level.get(),
            "audio_option": self.audio_option.get(),
            "custom_abitrate": self.custom_abitrate.get(),
            # Advanced Encoder Settings
            "encoder_async_depth": self.async_depth.get(),
            "encoder_preset": self.preset.get(),
            "encoder_profile": self.profile.get(),
            "encoder_scenario": self.scenario.get(),
            "encoder_threads": self.threads.get(),
            "encoder_hwaccel": self.hwaccel.get(),
            "encoder_rc": self.rc.get(),
            "encoder_tier": self.tier.get(),
            "encoder_look_ahead_depth": self.look_ahead_depth.get(),
            # Encoder Flags
            "encoder_extbrc": self.extbrc.get(),
            "encoder_rdo": self.rdo.get(),
            "encoder_mbbrc": self.mbbrc.get(),
            # FPS and scaling settings
            "fps_option": self.fps_option.get(),
            "custom_fps": self.custom_fps.get(),
            "fps_mode": self.fps_mode.get(),
            "video_format_option": self.video_format_option.get(),
            "custom_video_width": self.custom_video_width.get(),
            "interpolation_algo": self.interpolation_algo.get(),
            # Trimming Settings
            "trim_start": self.trim_start.get(),
            "trim_end": self.trim_end.get(),
            "trim_streamcopy": self.trim_streamcopy.get(),
            "precise_trim": self.precise_trim.get(),
            # Additional Options Fields
            "additional_options": self.additional_options.get()
            if self.additional_options.get() != self.additional_options_placeholder
            else "",
            "additional_filter_options": self.additional_filter_options.get()
            if self.additional_filter_options.get()
            != self.additional_filter_options_placeholder
            else "",
            "additional_audio_filter_options": self.additional_audio_filter_options.get()
            if self.additional_audio_filter_options.get()
            != self.additional_audio_filter_options_placeholder
            else "",
            # Saved custom filters
            "selected_preset": self.selected_preset.get(),
            "custom_preset_selected": self.custom_preset_name.get()
            if self.selected_preset.get() == "custom"
            else "",
            # Batch Converter Settings
            "batch_output_folder": self.batch_output_folder.get(),
            "batch_change_container": self.batch_change_container.get(),
            "batch_output_container": self.batch_output_container.get(),
            "version": self.version,
        }
        return settings

    def _update_preset_indicator(self):
        """Update the preset indicator label based on current preset selection."""
        selected_preset = self.selected_preset.get()
        custom_preset_selected = self.custom_preset_selected.get()

        if not selected_preset or selected_preset == "none":
            self.preset_indicator.configure(
                text="No preset selected", text_color=PLACEHOLDER_COLOR
            )
        elif selected_preset == "custom" and custom_preset_selected:
            self.preset_indicator.configure(
                text=f"Loaded preset: {custom_preset_selected}", text_color=ACCENT_BLUE
            )
        elif selected_preset == "custom":
            self.preset_indicator.configure(
                text="Custom preset (unnamed)", text_color=ACCENT_BLUE
            )
        else:
            preset_display_names = {
                "fhdf": "FHD Fast",
                "fhdq": "FHD Quality",
                "hdf": "HD Fast",
                "hdq": "HD Quality",
            }
            display_name = preset_display_names.get(selected_preset, selected_preset)
            self.preset_indicator.configure(
                text=f"{display_name} preset applied", text_color=ACCENT_BLUE
            )

    # INTERFACE / CONVERSION CONTROL
    def _start_conversion(self):
        try:
            command = self._build_ffmpeg_command()
        except Exception as e:
            messagebox.showerror("Error", str(e))
            return

        self.progress_value.set(0.0)
        self.progress_label.configure(text="0%")
        self.progress_frame.grid()
        self.convert_button.configure(
            text="Cancel", fg_color=ACCENT_RED, hover_color=HOVER_RED
        )
        self.is_converting = True

        self.status_text.set("Conversion in progress...")
        self.ffmpeg_output.set("Starting conversion...")
        self.conversion_thread = Thread(target=self._run_ffmpeg, args=(command,))
        self.conversion_thread.start()

    def _cancel_conversion(self):
        # Cancel single conversion — just set the flag, _run_ffmpeg handles UI
        if self.is_converting:
            self.is_converting = False

        # Also cancel batch conversion if active
        if (
            hasattr(self, "batch_converter_window")
            and self.batch_converter_window
            and self.batch_converter_window.window.winfo_exists()
            and self.batch_converter_window.is_converting
        ):
            self.batch_converter_window.cancel_batch_conversion()

    def _cancel_preview(self):
        """Cancel preview creation"""
        if self.is_creating_preview and self.preview_process:
            try:
                self.preview_process.terminate()
                self.preview_process.wait(timeout=2)
            except (subprocess.TimeoutExpired, Exception):
                try:
                    self.preview_process.kill()
                except Exception:
                    pass

            self.is_creating_preview = False
            self.preview_process = None
            self.status_text.set("Preview creation cancelled")
            self.ffmpeg_output.set("")
            self.progress_frame.grid_remove()
            self.play10s_button.configure(
                text="Play 10s Preview", fg_color=ACCENT_BLUE, hover_color=HOVER_BLUE
            )

    def _open_batch_converter(self, show_window: bool = True):
        if (
            not hasattr(self, "batch_converter_window")
            or not self.batch_converter_window
            or not self.batch_converter_window.window.winfo_exists()
        ):
            self.batch_converter_window = BatchConverterWindow(self.master, self)
            if not show_window:
                self.batch_converter_window.window.withdraw()
        else:
            if not self.batch_converter_window.is_converting:
                self.batch_converter_window.files = self.batch_files.copy()
            self.batch_converter_window._update_files_display()
            if show_window:
                self.batch_converter_window.window.deiconify()
                self.batch_converter_window.window.lift()
                self.batch_converter_window.window.focus_force()

    def _restore_app(self):
        """Restore window from tray"""
        self.master.deiconify()
        self.master.lift()
        self.master.focus_force()

    def _screen_record(self):
        if self.is_recording:
            # Stop recording
            self._stop_recording()
        else:
            # Start recording
            self._start_recording()

    def _start_recording(self):
        if not hasattr(self, "original_title"):
            self.original_title = self.master.title()

        self.master.title("Screen is recording now - QuickFFSync")
        if not self.ffmpeg_path:
            messagebox.showerror("Error", "FFmpeg path is not specified.")
            return

        now = datetime.now()
        date_str = now.strftime("%d_%m_%y-%H_%M_%S")

        # Get output file path
        output_file = self.output_file.get().strip()
        if not output_file or output_file == getattr(
            self, "output_file_placeholder", ""
        ):
            # Generate default filename on desktop
            desktop = os.path.join(os.path.expanduser("~"), "Desktop")
            output_file = os.path.join(desktop, f"screen_record-{date_str}.mp4")

        # Set up temporary files for video and audio
        self.final_record_file = output_file
        self.temp_video_file = os.path.join(
            tempfile.gettempdir(), f"temp_vid_{date_str}.mp4"
        )
        self.temp_audio_file = os.path.join(
            tempfile.gettempdir(), f"temp_aud_{date_str}.wav"
        )

        # Get FPS - use 60 if source or not specified
        fps = self.fps_option.get()
        if fps == "source" or not fps:
            fps = "60"
        elif fps == "custom":
            fps = self.custom_fps.get()

        # Build screen recording command
        command = [
            self.ffmpeg_path,
            "-y",
            "-thread_queue_size",
            "4096",
            "-use_wallclock_as_timestamps",
            "1",
            "-init_hw_device",
            "d3d11va",
            "-filter_complex",
            f"ddagrab=0:framerate={fps},hwmap=mode=direct:derive_device=qsv,format=qsv",
        ]

        # Encoder settings - only h264 works now
        command.extend(["-c:v", "h264_qsv"])

        # Preset settings
        if self.preset.get() != "auto":
            command.extend(["-preset:v", self.preset.get()])

        # Quality settings
        if self.icq_mode.get():
            command.extend(["-global_quality:v", self.global_quality_level.get()])
        else:
            command.extend(["-rc:v", self.rc.get(), "-b:v", f"{self.bitrate.get()}k"])

        # Add custom additional options if enabled
        if self.enable_additional_options.get():
            val = self.additional_options.get().strip()
            if val and val != self.additional_options_placeholder:
                try:
                    command.extend(split(val))
                except Exception:
                    command.extend(val.split())

        # Constant FPS + No audio
        command.extend(["-fps_mode", self.fps_mode.get(), "-an", self.temp_video_file])

        # PRINT THE COMMAND TO CONSOLE
        print("Screen recording command:")
        print(" ".join(command))

        try:
            # Update UI first
            self.is_recording = True
            self.screen_record_button.configure(
                text="Stop Recording", fg_color=ACCENT_RED, hover_color=HOVER_RED
            )
            self.status_text.set("Screen is recording now...")
            self.ffmpeg_output.set("Screen recording starting...")

            # Notify user
            if hasattr(self, "_tray_icon") and self._tray_icon:
                self._tray_icon.show_balloon(
                    "Recording Started", "Screen is being captured..."
                )

            # Minimize window after 1 second
            self._iconify_job = self.master.after(1000, self.master.iconify)

            # Start recording process after 1 second delay using Timer
            def start_recording():
                if not self.is_recording:
                    return
                try:
                    startupinfo = None
                    creationflags = 0
                    if os.name == "nt":
                        startupinfo = subprocess.STARTUPINFO()
                        startupinfo.dwFlags |= subprocess.STARTF_USESHOWWINDOW
                        startupinfo.wShowWindow = subprocess.SW_HIDE
                        creationflags = subprocess.CREATE_NO_WINDOW

                    self.recording_process = subprocess.Popen(
                        command,
                        stdin=subprocess.PIPE,
                        stdout=subprocess.PIPE,
                        stderr=subprocess.STDOUT,
                        text=True,
                        bufsize=1,
                        startupinfo=startupinfo,
                        creationflags=creationflags,
                        encoding="utf-8",
                        errors="replace",
                    )

                    self.ffmpeg_output.set("Screen recording started...")

                    # Start audio recording thread if not disabled
                    if (
                        getattr(self, "audio_option", None)
                        and self.audio_option.get() != "disable"
                    ):
                        self.audio_thread = Thread(target=self._record_audio_loop)
                        self.audio_thread.daemon = True
                        self.audio_thread.start()

                    # Start monitoring thread
                    recording_thread = Thread(
                        target=self._monitor_recording, daemon=True
                    )
                    recording_thread.start()
                except Exception as e:
                    self.master.after(
                        0,
                        lambda: self._handle_recording_error(str(e)),
                    )

            # Use Timer to delay the recording start by 2 seconds
            self._recording_timer = Timer(2.0, start_recording)
            self._recording_timer.daemon = True
            self._recording_timer.start()

        except Exception as e:
            messagebox.showerror("Error", f"Failed to start screen recording: {str(e)}")

    def _handle_recording_error(self, error_msg):
        """Reset UI after a failed recording start (called from Timer thread)."""
        if hasattr(self, "original_title"):
            self.master.title(self.original_title)
        self.is_recording = False
        self.recording_process = None
        self.screen_record_button.configure(
            text="Screen Record", fg_color=ACCENT_DEEPBLUE, hover_color=HOVER_DEEPBLUE
        )
        self.status_text.set("Screen recording failed")
        self.ffmpeg_output.set("")
        self.master.deiconify()
        messagebox.showerror("Error", f"Failed to start screen recording: {error_msg}")

    def _record_audio_loop(self):
        try:
            with pyaudio.PyAudio() as p:
                try:
                    wasapi_info = p.get_host_api_info_by_type(pyaudio.paWASAPI)
                except OSError:
                    print("Error: WASAPI is not supported.")
                    return

                default_speakers = p.get_device_info_by_index(
                    wasapi_info["defaultOutputDevice"]
                )
                if not default_speakers["isLoopbackDevice"]:
                    found = False
                    for loopback in p.get_loopback_device_info_generator():
                        if default_speakers["name"] in loopback["name"]:
                            default_speakers = loopback
                            found = True
                            break
                    if not found:
                        print("Audio error: loopback device not found.")
                        return

                wave_file = wave.open(self.temp_audio_file, "wb")
                try:
                    wave_file.setnchannels(default_speakers["maxInputChannels"])
                    wave_file.setsampwidth(pyaudio.get_sample_size(pyaudio.paInt16))
                    wave_file.setframerate(int(default_speakers["defaultSampleRate"]))

                    def callback(in_data, frame_count, time_info, status):
                        try:
                            wave_file.writeframes(in_data)
                        except Exception as e:
                            print(f"Audio write error: {e}")
                        return (in_data, pyaudio.paContinue)

                    with p.open(
                        format=pyaudio.paInt16,
                        channels=default_speakers["maxInputChannels"],
                        rate=int(default_speakers["defaultSampleRate"]),
                        frames_per_buffer=512,
                        input=True,
                        input_device_index=default_speakers["index"],
                        stream_callback=callback,
                    ) as stream:
                        while self.is_recording:
                            time.sleep(0.1)
                finally:
                    wave_file.close()
        except Exception as e:
            print(f"Audio recording error: {e}")

    def _stop_recording(self):
        self.is_recording = False
        if hasattr(self, "original_title"):
            self.master.title(self.original_title)

        # Cancel pending timer if recording hasn't started yet
        if hasattr(self, "_recording_timer") and self._recording_timer is not None:
            self._recording_timer.cancel()
            self._recording_timer = None

        # Cancel pending iconify if window hasn't minimized yet
        if hasattr(self, "_iconify_job") and self._iconify_job is not None:
            self.master.after_cancel(self._iconify_job)
            self._iconify_job = None

        if not self.recording_process:
            # Timer was cancelled before FFmpeg started — just reset UI
            self.screen_record_button.configure(
                text="Screen Record",
                fg_color=ACCENT_DEEPBLUE,
                hover_color=HOVER_DEEPBLUE,
            )
            self.status_text.set("Screen recording cancelled")
            self.ffmpeg_output.set("")
            return

        try:
            # Send 'q' to gracefully stop FFmpeg
            self.recording_process.stdin.write("q")
            self.recording_process.stdin.flush()
        except (BrokenPipeError, OSError, IOError) as e:
            # If stdin fails, terminate the process
            print(f"Failed to send stop signal via stdin: {e}")
            self.recording_process.terminate()

        # Start finalization in a background thread to avoid freezing UI
        Thread(target=self._finalize_recording, daemon=True).start()

    def _finalize_recording(self):
        try:
            # Wait for process to finish
            try:
                self.recording_process.wait(timeout=5)
            except subprocess.TimeoutExpired:
                self.recording_process.kill()

            # Ensure audio thread is finished
            if hasattr(self, "audio_thread") and self.audio_thread:
                self.audio_thread.join(timeout=2)
                self.audio_thread = None

            self.recording_process = None
            self.master.after(
                0,
                lambda: self.screen_record_button.configure(
                    text="Screen Record",
                    fg_color=ACCENT_DEEPBLUE,
                    hover_color=HOVER_DEEPBLUE,
                ),
            )

            # --- CHECK: Ensure video file was actually created ---
            if (
                not os.path.exists(self.temp_video_file)
                or os.path.getsize(self.temp_video_file) == 0
            ):
                raise Exception(
                    "FFmpeg failed to generate the video file. Check encoder settings."
                )

            self.master.after(
                0, lambda: self.status_text.set("Muxing audio and video...")
            )
            self.master.after(
                0,
                lambda: self.ffmpeg_output.set(
                    "Muxing audio and video... please wait."
                ),
            )

            startupinfo = None
            creationflags = 0
            if os.name == "nt":
                startupinfo = subprocess.STARTUPINFO()
                startupinfo.dwFlags |= subprocess.STARTF_USESHOWWINDOW
                startupinfo.wShowWindow = subprocess.SW_HIDE
                creationflags = subprocess.CREATE_NO_WINDOW

            has_audio = (
                getattr(self, "audio_option", None)
                and self.audio_option.get() != "disable"
                and os.path.exists(getattr(self, "temp_audio_file", ""))
                and os.path.getsize(self.temp_audio_file) > 100
            )

            if has_audio:
                mux_cmd = [
                    self.ffmpeg_path,
                    "-y",
                    "-i",
                    self.temp_video_file,
                    "-i",
                    self.temp_audio_file,
                    "-c:v",
                    "copy",
                ]
                # Apply user's Audio Settings (codec, bitrate)
                self._append_audio_options(mux_cmd)
                mux_cmd.extend(
                    ["-map", "0:v:0", "-map", "1:a:0", self.final_record_file]
                )

                # Run muxing and check for success
                result = subprocess.run(
                    mux_cmd, startupinfo=startupinfo, creationflags=creationflags
                )
                if result.returncode != 0 or not os.path.exists(self.final_record_file):
                    raise Exception("Failed to mux audio and video streams.")
            else:
                move(self.temp_video_file, self.final_record_file)

            # Cleanup
            for f in [self.temp_video_file, self.temp_audio_file]:
                try:
                    if os.path.exists(f):
                        os.remove(f)
                except Exception:
                    pass

            self.master.after(
                0, lambda: self.status_text.set("Screen recording stopped")
            )
            filename = os.path.basename(getattr(self, "final_record_file", "output"))
            self.master.after(0, lambda: self.ffmpeg_output.set(f"Saved to {filename}"))

            # Notify user
            MessageBeep(MB_ICONASTERISK)
            if hasattr(self, "_tray_icon") and self._tray_icon:
                self.master.after(
                    0,
                    lambda: self._tray_icon.show_balloon(
                        "Recording Saved", f"File: {filename}"
                    ),
                )

        except Exception as e:
            print(f"Finalization failed: {e}")
            self.master.after(
                0, lambda: self.status_text.set("Error finishing recording")
            )
            self.master.after(0, lambda msg=str(e): self.ffmpeg_output.set(msg))

    def _monitor_recording(self):
        """Monitor the recording process output"""
        while self.is_recording and self.recording_process:
            try:
                line = self.recording_process.stdout.readline()
                if not line:
                    break

                if self.is_recording:  # Check again in case it changed
                    self.master.after(
                        0, lambda l=line: self.ffmpeg_output.set(l.strip())
                    )

            except Exception:
                break

        # If we get here and still recording, process ended unexpectedly
        if self.is_recording:
            self.master.after(0, self._stop_recording)

    def _toggle_conversion(self):
        # Check if single conversion is in progress
        single_running = self.is_converting

        # Check if batch conversion is in progress
        batch_running = (
            hasattr(self, "batch_converter_window")
            and self.batch_converter_window
            and self.batch_converter_window.is_converting
        )

        if batch_running or single_running:
            # If any conversion is running, cancel both
            self._cancel_conversion()
        else:
            # Otherwise, start conversion
            if self.batch_files:
                self._open_batch_converter(show_window=False)
                self.batch_converter_window.start_batch_conversion()
            else:
                if self.is_creating_preview:
                    messagebox.showerror(
                        "Error", "Please wait until preview creation completes"
                    )
                    return

                self._start_conversion()

    def _create_10s_preview(self):
        """Create a 10-second preview with current settings"""
        if self.is_creating_preview:
            # If preview is being created, cancel it
            self._cancel_preview()
            return

        self.preview_process = None

        if self.trim_streamcopy.get():
            messagebox.showerror("Error", "Preview is not available in Streamcopy mode")
            return

        if self.is_converting:
            messagebox.showerror("Error", "Please wait until current process completes")
            return

        if not self.input_file.get() or self.input_file.get().startswith(
            "Drag and drop"
        ):
            messagebox.showerror("Error", "Please select input file first")
            return

        # Get video duration
        if not hasattr(self, "total_duration") or self.total_duration <= 0:
            self._get_video_duration()

        if not hasattr(self, "total_duration") or self.total_duration <= 0:
            messagebox.showerror("Error", "Could not get video duration")
            return

        # Calculate video midpoint
        duration = self.total_duration
        mid_point = max(0, (duration - 10) / 2)

        # Create temporary files
        input_path = self.input_file.get()
        base_name = os.path.splitext(os.path.basename(input_path))[0]
        temp_dir = tempfile.gettempdir()

        # Clean up previous temporary files
        self._cleanup_preview_files()

        # Get input file extension
        input_ext = os.path.splitext(input_path)[1] or ".mp4"

        # Get output file extension (if user specified different format)
        output_file = self.output_file.get()
        output_ext = os.path.splitext(output_file)[1] if output_file else input_ext
        if not output_ext:
            output_ext = input_ext

        # Temporary file for streamcopy (use input file extension)
        temp_streamcopy = os.path.join(
            temp_dir, f"{base_name}_streamcopy10s{input_ext}"
        )
        self.preview_temp_files.append(temp_streamcopy)

        # Temporary file for encoded preview (use output file extension if specified, otherwise input extension)
        temp_encoded = os.path.join(temp_dir, f"{base_name}_encoded10s{output_ext}")
        self.preview_temp_files.append(temp_encoded)

        # Command to create streamcopy (preserving all streams)
        streamcopy_cmd = [
            self.ffmpeg_path,
            "-ss",
            str(mid_point),
            "-i",
            input_path,
            "-map",
            "0",
            "-ignore_unknown",
            "-t",
            "10",
            "-c",
            "copy",
            "-y",
            temp_streamcopy,
        ]

        # Execute streamcopy
        try:
            subprocess.run(
                streamcopy_cmd, check=True, creationflags=subprocess.CREATE_NO_WINDOW
            )
        except subprocess.CalledProcessError as e:
            messagebox.showerror("Error", f"Streamcopy failed: {e}")
            return

        # Build encoding command
        try:
            # if custom command exists
            if self.custom_command is not None:
                encode_cmd = self.custom_command.copy()

                # Remove any existing -ss and -to parameters from custom command
                filtered_cmd = []
                i = 0
                while i < len(encode_cmd):
                    if encode_cmd[i] in ["-ss", "-to"]:
                        i += 2  # Skip the parameter and its value
                    else:
                        filtered_cmd.append(encode_cmd[i])
                        i += 1
                encode_cmd = filtered_cmd

                # Replace input file and output file
                try:
                    i_index = encode_cmd.index("-i")
                    if i_index + 1 < len(encode_cmd):
                        encode_cmd[i_index + 1] = temp_streamcopy
                except ValueError:
                    encode_cmd.extend(["-i", temp_streamcopy])

                if len(encode_cmd) > 0:
                    encode_cmd[-1] = temp_encoded
            else:
                # Build command using GUI settings but remove trim options
                original_input = self.input_file.get()
                original_output = self.output_file.get()

                self.input_file.set(temp_streamcopy)
                self.output_file.set(temp_encoded)

                # Build the command and remove -ss and -to parameters
                encode_cmd = self._build_ffmpeg_command(preview=True)

                # Remove any -ss and -to parameters from the built command
                filtered_cmd = []
                i = 0
                while i < len(encode_cmd):
                    if encode_cmd[i] in ["-ss", "-to"]:
                        i += 2  # Skip the parameter and its value
                    else:
                        filtered_cmd.append(encode_cmd[i])
                        i += 1
                encode_cmd = filtered_cmd

                self.input_file.set(original_input)
                self.output_file.set(original_output)

            # Add -map 0 after -i for preview encoding if not already present
            # and if user didn't manually add -map in additional options
            additional_opts = self.additional_options.get()
            has_user_map = (
                additional_opts
                and additional_opts != self.additional_options_placeholder
                and "-map" in additional_opts
            )

            if not has_user_map:
                try:
                    i_index = encode_cmd.index("-i")
                    if i_index + 1 < len(encode_cmd):
                        # Check if -map is not already present right after -i
                        if (
                            i_index + 2 < len(encode_cmd)
                            and encode_cmd[i_index + 2] != "-map"
                        ):
                            encode_cmd.insert(i_index + 2, "-ignore_unknown")
                            encode_cmd.insert(i_index + 2, "0")
                            encode_cmd.insert(i_index + 2, "-map")
                except ValueError:
                    pass

            # Start preview encoding with progress
            self.is_creating_preview = True
            self.status_text.set("Creating 10-second preview...")
            self.ffmpeg_output.set("Starting preview encoding...")
            self.progress_value.set(0.0)
            self.progress_label.configure(text="0%")
            self.progress_frame.grid()

            # Update button to show cancel state
            self.play10s_button.configure(
                text="Cancel Preview", fg_color=ACCENT_RED, hover_color=HOVER_RED
            )

            # Start encoding in separate thread
            preview_thread = Thread(
                target=self._run_preview_encoding, args=(encode_cmd, temp_encoded)
            )
            preview_thread.daemon = True
            preview_thread.start()

        except Exception as e:
            messagebox.showerror("Error", f"Preview encoding failed: {e}")
            self.is_creating_preview = False

    # INPUT & DROP HANDLING
    def _handle_dropped_file(self, file_path):
        # run another thread
        Thread(
            target=self._process_dropped_file, args=(file_path,), daemon=True
        ).start()

    def _process_dropped_file(self, file_path):
        if file_path.lower().endswith(VIDEO_EXTENSIONS):
            normalized_path = os.path.normpath(file_path)

            # refresh GUI from main thread
            self.master.after(0, lambda: self.input_file.set(normalized_path))
            self.master.after(
                0, lambda: self.input_file_entry.configure(text_color=TEXT_COLOR_W)
            )

            self.master.after(
                0, lambda: self.last_input_dir.set(os.path.dirname(normalized_path))
            )
            base_name = os.path.splitext(os.path.basename(normalized_path))[0]
            codec_suffix = (
                "_hevc"
                if self.video_codec.get() == "hevc"
                else "_h264"
                if self.video_codec.get() == "h264"
                else "_av1"
                if self.video_codec.get() == "av1"
                else "_vp9"
            )

            if self.last_output_dir.get() and os.path.exists(
                self.last_output_dir.get()
            ):
                output_dir = self.last_output_dir.get()
            else:
                output_dir = os.path.dirname(normalized_path)

            # Use input file extension as default
            input_ext = os.path.splitext(normalized_path)[1] or ".mp4"
            output_path = os.path.normpath(
                os.path.join(
                    output_dir,
                    f"{base_name}{codec_suffix}_custom{input_ext}",
                )
            )

            self.master.after(0, lambda: self.output_file.set(output_path))
            self.master.after(0, lambda: self.trim_start.set("00:00:00"))
            self.master.after(0, lambda: setattr(self, "total_duration", 0))
            self.master.after(
                0, lambda: self.status_text.set("File selected. Ready for conversion.")
            )
            self.master.after(0, self._calculate_estimated_size)
            self.master.after(0, self._set_trim_end_to_duration)

        else:
            self.master.after(
                0,
                lambda: messagebox.showwarning(
                    "Unsupported File",
                    "Please drop a video file (.mp4, .mkv, .avi, etc.)",
                ),
            )

    def _on_input_file_change(self, *args):
        # Triggered whenever self.input_file changes

        # Prevent tooltip and ffprobe during batch conversion or regular conversion
        if getattr(self, "is_converting", False) or (
            getattr(self, "batch_converter_window", None)
            and getattr(self.batch_converter_window, "is_converting", False)
        ):
            return

        input_file = self.input_file.get()
        if not input_file or input_file.startswith("Drag and drop"):
            # Hide/remove tooltip
            if getattr(self, "input_file_tooltip", None) is not None:
                self.input_file_tooltip.hide()
            return

        # Valid file: show tooltip
        if getattr(self, "input_file_tooltip", None) is None:
            self.input_file_tooltip = CTkToolTip(
                self.input_file_entry,
                delay=0.5,
                message="Loading metadata...",
                font=("Consolas", 14),
                justify="left",
                bg_color=ACCENT_DEEPBLUE,
                wraplength=600,
                alpha=1.0,
                padding=(10, 10),
            )
        else:
            self.input_file_tooltip.configure(message="Loading metadata...")

        # Cancel any previous tooltip thread and start a new one
        self._tooltip_cancel.set()
        self._tooltip_cancel = Event()
        self._tooltip_generation += 1
        Thread(
            target=self._update_tooltip_async,
            args=(input_file, self._tooltip_generation, self._tooltip_cancel),
            daemon=True,
        ).start()

    def _update_tooltip_async(self, file_path, generation, cancel_event):
        if cancel_event.is_set():
            return

        if not getattr(self, "ffprobe_path", None):
            self.master.after(0, lambda: self._set_tooltip_message("ffprobe not found"))
            return

        if file_path in self.ffprobe_cache:
            self.ffprobe_cache.move_to_end(file_path)
            self.master.after(
                0, lambda: self._set_tooltip_message(self.ffprobe_cache[file_path])
            )
            return

        command = [self.ffprobe_path, "-hide_banner", file_path]

        try:
            result = subprocess.run(
                command,
                capture_output=True,
                text=True,
                encoding="utf-8",
                errors="replace",
                timeout=10,
                creationflags=subprocess.CREATE_NO_WINDOW if os.name == "nt" else 0,
            )

            if cancel_event.is_set():
                return

            # ffprobe output is usually in stderr
            output = (result.stderr or "").strip()
            if not output:
                output = (result.stdout or "").strip()

            # Filter out verbose metadata tags and chapters to keep tooltip compact
            if output:
                lines = output.splitlines()
                filtered = []
                metadata_indent = -1
                chapters_indent = -1
                for line in lines:
                    stripped = line.strip()
                    indent = len(line) - len(line.lstrip()) if stripped else 0

                    # Detect "Metadata:" header and remember its indent level
                    if stripped == "Metadata:":
                        metadata_indent = indent
                        continue
                    # Inside a metadata block: skip lines indented deeper
                    if metadata_indent >= 0:
                        if stripped and indent > metadata_indent:
                            continue
                        # Line at same or lesser indent → metadata block ended
                        metadata_indent = -1

                    # Detect "Chapters:" header and remember its indent level
                    if stripped == "Chapters:":
                        chapters_indent = indent
                        continue
                    # Inside a chapters block: skip lines indented deeper
                    if chapters_indent >= 0:
                        if stripped and indent > chapters_indent:
                            continue
                        chapters_indent = -1

                    filtered.append(line)
                output = "\n".join(filtered).strip()

            # Limit cache to 50 entries
            if len(self.ffprobe_cache) >= 50:
                self.ffprobe_cache.popitem(last=False)
            self.ffprobe_cache[file_path] = output

            # Check if this thread is still the latest one
            if self._tooltip_generation == generation:
                self.master.after(0, lambda: self._set_tooltip_message(output))
        except subprocess.TimeoutExpired:
            if self._tooltip_generation == generation:
                self.master.after(
                    0,
                    lambda: self._set_tooltip_message("Timeout: ffprobe took too long"),
                )
        except Exception as e:
            error_msg = f"Error reading metadata:\n{str(e)}"
            if self._tooltip_generation == generation:
                self.master.after(0, lambda: self._set_tooltip_message(error_msg))
    def _set_tooltip_message(self, message):
        if getattr(self, "input_file_tooltip", None) is not None:
            self.input_file_tooltip.configure(message=message)

            # Override on_enter to clamp tooltip within screen bounds vertically
            tooltip = self.input_file_tooltip
            original_on_enter = (
                tooltip.on_enter.__func__
                if hasattr(tooltip.on_enter, "__func__")
                else None
            )

            def _clamped_on_enter(event, _self=tooltip):
                if _self.disable:
                    return
                _self.last_moved = __import__("time").time()
                if _self.status == "outside":
                    _self.status = "inside"
                if not _self.follow:
                    if _self.status == "visible":
                        return
                    else:
                        _self.status = "inside"

                screen_w = _self.winfo_screenwidth()
                screen_h = _self.winfo_screenheight()
                text_w = _self.message_label.winfo_reqwidth()
                text_h = _self.message_label.winfo_reqheight()

                # Horizontal clamping
                x = event.x_root + _self.x_offset
                if screen_w - event.x_root < text_w + 20:
                    x = event.x_root - text_w - 20

                # Vertical clamping — keep tooltip within screen
                y = event.y_root + _self.y_offset
                if y + text_h + 20 > screen_h:
                    y = event.y_root - text_h - 10
                if y < 0:
                    y = 0

                _self.geometry(f"+{x}+{y}")
                _self.after(int(_self.delay * 1000), _self._show)

            tooltip.on_enter = _clamped_on_enter

    def _explore_path(self, event, path_str):
        if (
            not path_str
            or "Drag and drop" in path_str
            or path_str == getattr(self, "ffmpeg_path_placeholder", "")
        ):
            return

        path_str = path_str.strip("\"' ")
        if not path_str or not os.path.exists(path_str):
            folder = os.path.dirname(path_str)
            if not folder or not os.path.exists(folder):
                return
            path_str = folder

        if os.path.isfile(path_str):
            subprocess.run(["explorer", "/select,", os.path.normpath(path_str)])
        elif os.path.isdir(path_str):
            os.startfile(path_str)

    def _browse_input(self):
        initial_dir = (
            self.last_input_dir.get() if self.last_input_dir.get() else os.getcwd()
        )

        filename = filedialog.askopenfilename(
            title="Select Video File",
            initialdir=initial_dir,
            filetypes=(
                VIDEO_EXTENSIONS_FILTER,
                ("All Files", "*.*"),
            ),
        )
        if filename:
            normalized_path = os.path.normpath(filename)
            self.input_file.set(normalized_path)
            self.input_file_entry.configure(text_color=TEXT_COLOR_W)
            self.last_input_dir.set(os.path.dirname(normalized_path))
            base_name = os.path.splitext(os.path.basename(normalized_path))[0]
            codec_suffix = (
                "_hevc"
                if self.video_codec.get() == "hevc"
                else "_h264"
                if self.video_codec.get() == "h264"
                else "_av1"
                if self.video_codec.get() == "av1"
                else "_vp9"
            )
            if self.last_output_dir.get() and os.path.exists(
                self.last_output_dir.get()
            ):
                output_dir = self.last_output_dir.get()
            else:
                output_dir = os.path.dirname(normalized_path)

            # Use input file extension as default
            input_ext = os.path.splitext(normalized_path)[1] or ".mp4"
            output_path = os.path.normpath(
                os.path.join(
                    output_dir,
                    f"{base_name}{codec_suffix}_custom{input_ext}",
                )
            )
            self.output_file.set(output_path)
            self.trim_start.set("00:00:00")
            self.total_duration = 0
            self.status_text.set("File selected. Ready for conversion.")
            self._calculate_estimated_size()
            self._set_trim_end_to_duration()
            self.custom_command = None

    def _browse_output(self):
        codec_suffix = (
            "_hevc"
            if self.video_codec.get() == "hevc"
            else "_h264"
            if self.video_codec.get() == "h264"
            else "_av1"
            if self.video_codec.get() == "av1"
            else "_vp9"
        )

        # Get default extension: prefer current output file ext, then input file ext, then .mp4
        output_value_ext = ""
        output_value_raw = self.output_file.get()
        if output_value_raw and output_value_raw != getattr(
            self, "output_file_placeholder", ""
        ):
            output_value_ext = os.path.splitext(output_value_raw)[1]

        input_file = self.input_file.get()
        if output_value_ext:
            default_ext = output_value_ext
        elif input_file and not input_file.startswith("Drag and drop"):
            default_ext = os.path.splitext(input_file)[1] or ".mp4"
        else:
            default_ext = ".mp4"

        output_value = self.output_file.get()
        if output_value and output_value != getattr(
            self, "output_file_placeholder", ""
        ):
            default_name = output_value
        else:
            default_name = f"output{codec_suffix}_custom{default_ext}"

        if self.last_output_dir.get() and os.path.exists(self.last_output_dir.get()):
            initial_dir = self.last_output_dir.get()
        elif os.path.dirname(default_name) and os.path.exists(
            os.path.dirname(default_name)
        ):
            initial_dir = os.path.dirname(default_name)
        else:
            initial_dir = os.getcwd()

        initialfile = os.path.splitext(os.path.basename(default_name))[0]

        # Reorder filetypes to put current extension first
        filetypes_list = [
            ("MP4 Files", "*.mp4"),
            ("MKV Files", "*.mkv"),
            ("MOV Files", "*.mov"),
            ("All Files", "*.*"),
        ]

        # Move matching extension to the front
        ext_map = {".mp4": 0, ".mkv": 1, ".mov": 2}
        if default_ext in ext_map:
            idx = ext_map[default_ext]
            filetypes_list = [filetypes_list[idx]] + [
                f for i, f in enumerate(filetypes_list) if i != idx
            ]

        filename = filedialog.asksaveasfilename(
            title="Save As...",
            defaultextension=default_ext,
            initialfile=initialfile,
            initialdir=initial_dir,
            filetypes=tuple(filetypes_list),
        )
        if filename:
            normalized_path = os.path.normpath(filename)
            self.output_file.set(normalized_path)
            self.last_output_dir.set(os.path.dirname(normalized_path))
            self.custom_command = None

    def _browse_ffmpeg(self):
        filename = filedialog.askopenfilename(
            title="Select FFmpeg Executable",
            filetypes=(("Executable Files", "*.exe"), ("All Files", "*.*")),
        )
        if filename:
            normalized_path = os.path.normpath(filename)
            self.ffmpeg_custom_path.set(normalized_path)
            self.ffmpeg_path_entry.configure(text_color=TEXT_COLOR_W)
            self.ffmpeg_path = normalized_path

            self._save_settings()

            ffprobe_path = os.path.join(os.path.dirname(normalized_path), "ffprobe.exe")
            if os.path.exists(ffprobe_path):
                self.ffprobe_path = ffprobe_path
            else:
                self.ffprobe_path = None

    # LOAD AND SAVE SETTINGS
    def _find_executable(self, name):
        script_dir = os.path.dirname(os.path.abspath(__file__))
        exe_in_script_dir = os.path.join(script_dir, name)
        if os.path.exists(exe_in_script_dir):
            return exe_in_script_dir
        try:
            result = subprocess.run(
                ["where", name],
                check=True,
                capture_output=True,
                text=True,
                encoding="utf-8",
                errors="replace",
                creationflags=subprocess.CREATE_NO_WINDOW if os.name == "nt" else 0,
            )
            return result.stdout.strip().split("\n")[0]
        except subprocess.CalledProcessError:
            return None
        except FileNotFoundError:
            return None

    def _load_settings(self):
        """Load settings from JSON file"""
        try:
            script_dir = os.path.dirname(os.path.abspath(__file__))
            settings_file = os.path.join(script_dir, "qff_settings.json")

            if os.path.exists(settings_file):
                with open(settings_file, "r", encoding="utf-8") as file:
                    settings = load(file)

                # Apply settings from dictionary
                self._apply_settings_dict(settings)
        except Exception as e:
            print(f"Error loading settings: {e}")

    def _save_settings(self):
        """Save all settings to JSON file"""
        try:
            script_dir = os.path.dirname(os.path.abspath(__file__))
            settings_file = os.path.join(script_dir, "qff_settings.json")

            settings = self._get_current_settings()

            with open(settings_file, "w", encoding="utf-8") as file:
                dump(settings, file, indent=4, ensure_ascii=False)
        except Exception as e:
            print(f"Error saving settings: {e}")

    def _on_setting_changed(self):
        """Handle any setting change - debounced to avoid too frequent saves"""
        if self.loading_preset:
            return

        self._update_output_filename()

        if hasattr(self, "_save_settings_job"):
            self.master.after_cancel(self._save_settings_job)

        self._save_settings_job = self.master.after(1000, self._save_settings)

    # FFMPEG & COMMAND EXECUTION
    def _get_video_duration(self, update_ui=True):
        """Get video duration with optional UI updates"""
        if not self.ffprobe_path:
            return 0

        input_file = self.input_file.get()
        if not input_file or input_file.startswith("Drag and drop"):
            return 0

        # Check cache first
        if input_file in self.video_metadata_cache:
            duration = self.video_metadata_cache[input_file]
        else:
            command = [
                self.ffprobe_path,
                "-v",
                "error",
                "-show_entries",
                "format=duration",
                "-of",
                "default=noprint_wrappers=1:nokey=1",
                input_file,
            ]

            try:
                result = subprocess.run(
                    command,
                    check=True,
                    capture_output=True,
                    text=True,
                    encoding="utf-8",
                    errors="replace",
                    creationflags=subprocess.CREATE_NO_WINDOW if os.name == "nt" else 0,
                )
                duration = float(result.stdout.strip())
                self.video_metadata_cache[input_file] = duration
            except Exception:
                duration = 0

        # Update instance variable and UI if requested
        self.total_duration = duration

        if update_ui and hasattr(self, "trim_canvas"):
            self.master.after(100, self._update_trim_slider)

        return duration

    def _get_video_resolution(self, file_path):
        """Return (width, height) of video or (None, None) on error."""
        if not self.ffprobe_path or not file_path:
            return None, None
        cmd = [
            self.ffprobe_path,
            "-v",
            "error",
            "-select_streams",
            "v:0",
            "-show_entries",
            "stream=width,height",
            "-of",
            "csv=p=0",
            file_path,
        ]
        try:
            result = subprocess.run(
                cmd,
                capture_output=True,
                text=True,
                encoding="utf-8",
                errors="replace",
                check=True,
                creationflags=subprocess.CREATE_NO_WINDOW if os.name == "nt" else 0,
                timeout=10,
            )
            output = result.stdout.strip()
            if output and "," in output:
                w, h = output.split(",")
                return int(w), int(h)
        except Exception:
            pass
        return None, None

    def _build_ffmpeg_command(self, preview=False):
        # Force bitrate mode for VP9
        if self.video_codec.get() == "vp9" and self.icq_mode.get():
            # If somehow ICQ is still enabled for VP9, force switch to bitrate mode
            self.icq_mode.set(False)
            self._toggle_icq_mode()
        if self.custom_command is not None:
            if preview:
                command = self.custom_command.copy()
                try:
                    i_index = command.index("-i")
                    if i_index + 1 < len(command):
                        command[i_index + 1] = self.input_file.get()
                except ValueError:
                    pass

                if len(command) > 0:
                    command[-1] = self.output_file.get()
                return command
            else:
                return self.custom_command

        # Use custom path if specified, otherwise use found path
        ffmpeg_path = (
            self.ffmpeg_custom_path.get()
            if self.ffmpeg_custom_path.get()
            and self.ffmpeg_custom_path.get() != self.ffmpeg_path_placeholder
            else self.ffmpeg_path
        )
        if not ffmpeg_path:
            raise ValueError("FFmpeg path is not specified")

        input_f = self.input_file.get()
        if not self.output_file.get():
            raise ValueError("Please set an output file")
        output_f = self.output_file.get()

        if not input_f or not output_f:
            raise ValueError("Please fill in all main fields.")

        # Basic command structure
        command = [ffmpeg_path, "-hide_banner"]

        # Handle Streamcopy option
        if self.trim_streamcopy.get():
            # Extract trim options from additional_options if not in precise mode
            trim_options = []
            other_additional_options = []

            if not self.precise_trim.get():
                add_val = self.additional_options.get().strip()
                if add_val and add_val != self.additional_options_placeholder:
                    # Split the additional options string
                    parts = add_val.split()
                    i = 0
                    while i < len(parts):
                        if parts[i] == "-ss" and i + 1 < len(parts):
                            trim_options.extend([parts[i], parts[i + 1]])
                            i += 2
                        elif parts[i] == "-to" and i + 1 < len(parts):
                            trim_options.extend([parts[i], parts[i + 1]])
                            i += 2
                        else:
                            other_additional_options.append(parts[i])
                            i += 1
            else:
                # In precise mode, use all additional options as-is
                add_val = self.additional_options.get().strip()
                if add_val and add_val != self.additional_options_placeholder:
                    other_additional_options.extend(add_val.split())

            # Add trim options at the beginning if we have any
            if trim_options:
                command.extend(trim_options)

            command.extend(["-y", "-i", input_f])

            # Add -map 0 and -ignore_unknown if not manually specified
            if "-map" not in " ".join(other_additional_options):
                command.extend(["-map", "0", "-ignore_unknown"])

            # Add other additional options (excluding trim options that were already added)
            if other_additional_options:
                command.extend(other_additional_options)

            # Video stream copy
            command.extend(["-c:v", "copy"])

            # Audio handling
            self._append_audio_options(command)

            command.append(output_f)
            return command

        # Check if we need to change hwaccel_output_format
        hwaccel_output_format = self.hwaccel.get()

        # Check if video filters are used
        has_video_filters = False

        # Check for scaling/FPS filters
        vf_filters = []
        fps_num = self.fps_option.get()
        if fps_num == "custom":
            fps_num = self.custom_fps.get()
            if not fps_num:
                raise ValueError("Please specify custom FPS.")
        if fps_num != "source":
            vf_filters.append(f"fps={fps_num}")
            has_video_filters = True
        scale_width = self.video_format_option.get()
        if scale_width == "custom":
            scale_width = self.custom_video_width.get()
            if not scale_width:
                raise ValueError("Please specify custom video width.")
        if scale_width != "source":
            interp_flag = self.interpolation_algo.get()
            vf_filters.append(f"scale={scale_width}:-2:flags={interp_flag}")
            has_video_filters = True

        # Check for additional video filters
        addvf_val = self.additional_filter_options.get().strip()
        if addvf_val and addvf_val != self.additional_filter_options_placeholder:
            vf_filters.append(addvf_val)
            has_video_filters = True

        # Check for specific pixel formats in additional options
        if self.enable_additional_options.get():
            add_val = self.additional_options.get().strip()
            if add_val and add_val != self.additional_options_placeholder:
                # Check for -pix_fmt:v nv12 or -pix_fmt:v p010le
                if "-pix_fmt:v nv12" in add_val:
                    has_video_filters = True
                    hwaccel_output_format = "nv12"
                elif "-pix_fmt:v p010le" in add_val:
                    has_video_filters = True
                    hwaccel_output_format = "p010le"
                elif "-pix_fmt:v" in add_val:
                    # If other pix_fmt is specified, still mark as having filters
                    has_video_filters = True

        # If video filters or specific pixel formats are used, change hwaccel_output_format
        if has_video_filters and hwaccel_output_format == "qsv":
            # If format wasn't changed to nv12 or p010le above, set to nv12 by default
            hwaccel_output_format = "nv12"

        # Initialize variables for trim options and other additional options
        trim_options = []
        other_additional_options = []

        # Extract trim options from additional_options if not in precise mode
        if not self.precise_trim.get() and not self.trim_streamcopy.get():
            add_val = self.additional_options.get().strip()
            if add_val and add_val != self.additional_options_placeholder:
                # Split the additional options string
                parts = add_val.split()
                i = 0
                while i < len(parts):
                    if parts[i] == "-ss" and i + 1 < len(parts):
                        trim_options.extend([parts[i], parts[i + 1]])
                        i += 2
                    elif parts[i] == "-to" and i + 1 < len(parts):
                        trim_options.extend([parts[i], parts[i + 1]])
                        i += 2
                    else:
                        other_additional_options.append(parts[i])
                        i += 1
        else:
            # In precise mode or when additional options are disabled, use all additional options as-is
            if self.enable_additional_options.get():
                add_val = self.additional_options.get().strip()
                if add_val and add_val != self.additional_options_placeholder:
                    other_additional_options.extend(add_val.split())

        # Add trim options at the beginning if we have any
        if trim_options:
            command.extend(trim_options)

        # Continue with hardware acceleration and threads
        if self.hwaccel.get() != "auto":
            command.extend(["-hwaccel:v", self.hwaccel.get()])
            command.extend(["-hwaccel_output_format:v", hwaccel_output_format])

        command.extend(["-extra_hw_frames", "16"])

        if self.threads.get() != "auto":
            command.extend(["-threads", self.threads.get()])

        command.extend(["-y", "-i", input_f])

        # Add -map 0 and -ignore_unknown if not manually specified
        if "-map" not in " ".join(other_additional_options):
            command.extend(["-map", "0", "-ignore_unknown"])

        # Normal encoding path
        if self.icq_mode.get():
            # Intelligent Constant Quality
            quality_val = self.global_quality_level.get()
            try:
                quality_int = int(quality_val)
                if not (0 <= quality_int <= 51):
                    raise ValueError("Quality level must be between 0 and 51")
            except ValueError:
                raise ValueError("Quality level must be a number between 0 and 51")
        else:
            # Normal VBR/CBR mode
            bitrate_val = self.bitrate.get()
            try:
                bitrate_int = int(bitrate_val)
                if self.rc.get() == "cbr":
                    maxrate_val = bitrate_int
                    bufsize_val = bitrate_int * 2
                else:  # vbr
                    maxrate_val = (bitrate_int * 12 + 9) // 10
                    bufsize_val = maxrate_val * 2
            except ValueError:
                raise ValueError("Video bitrate must be a number.")

        # Skip -vf if user specified -filter_complex in Additional Options
        has_filter_complex = "-filter_complex" in (other_additional_options or [])

        if vf_filters and not has_filter_complex:
            command.extend(["-vf", ",".join(vf_filters)])

        if self.fps_mode.get() != "auto":
            command.extend(["-fps_mode", self.fps_mode.get()])

        # Add encoder settings based on mode
        codec_map = {"hevc": "hevc_qsv", "av1": "av1_qsv", "vp9": "vp9_qsv"}
        command.extend(["-c:v", "copy", "-c:v:0", codec_map.get(self.video_codec.get(), "h264_qsv")])

        if self.async_depth.get() != "auto":
            command.extend(["-async_depth:v", self.async_depth.get()])

        if self.preset.get() != "auto":
            command.extend(["-preset:v", self.preset.get()])

        if self.scenario.get() != "auto" and self.video_codec.get() in ("hevc", "h264"):
            command.extend(["-scenario:v", self.scenario.get()])

        if self.profile.get() != "auto":
            command.extend(["-profile:v", self.profile.get()])

        if self.rdo.get() and self.video_codec.get() in ("hevc", "h264"):
            command.extend(["-rdo:v", "1"])

        if self.mbbrc.get() and self.video_codec.get() in ("hevc", "h264"):
            command.extend(["-mbbrc:v", "1"])

        if self.extbrc.get() and self.video_codec.get() != "vp9":
            command.extend(["-extbrc:v", "1"])

        if (
            self.extbrc.get()
            and self.look_ahead_depth.get() != "auto"
            and self.video_codec.get() in ("hevc", "h264", "av1")
        ):
            command.extend(["-look_ahead_depth:v", self.look_ahead_depth.get()])

        if self.tier.get() != "auto" and self.video_codec.get() in ("hevc"):
            command.extend(["-tier:v", self.tier.get()])

        # Add rate control parameters based on mode
        if self.icq_mode.get():
            command.extend(["-global_quality:v", quality_val])
        else:
            command.extend(
                [
                    "-rc:v",
                    self.rc.get(),
                    "-b:v",
                    f"{bitrate_val}k",
                    "-maxrate:v",
                    f"{maxrate_val}k",
                    "-bufsize:v",
                    f"{bufsize_val}k",
                ]
            )

        # Add other additional options (excluding trim options that were already added)
        if other_additional_options:
            command.extend(other_additional_options)

        # Add audio filters if any
        add_af_val = self.additional_audio_filter_options.get().strip()
        if (
            add_af_val
            and add_af_val != self.additional_audio_filter_options_placeholder
        ):
            command.extend(["-af", add_af_val])

        # Audio settings
        self._append_audio_options(command)

        command.append(output_f)

        # Post-process: target video encoder options to the first video stream (:v:0)
        # to avoid applying them to copied streams (like cover art/attached pics).
        v0_targets = {
            "-preset:v", "-profile:v", "-level:v", "-tier:v",
            "-async_depth:v", "-scenario:v", "-rdo:v", "-mbbrc:v", "-extbrc:v",
            "-look_ahead_depth:v", "-global_quality:v",
            "-rc:v", "-b:v", "-maxrate:v", "-bufsize:v"
        }
        for idx in range(len(command)):
            if command[idx] in v0_targets:
                command[idx] = command[idx] + ":0"

        return command

    def _append_audio_options(self, command):
        """Append audio codec/bitrate flags to the command list."""
        audio_opt = self.audio_option.get()
        if audio_opt == "disable":
            command.append("-an")
        elif audio_opt == "copy":
            command.extend(["-c:a", "copy"])
        elif audio_opt == "aac_96k":
            command.extend(["-c:a", "aac", "-b:a", "96k"])
        elif audio_opt == "aac_160k":
            command.extend(["-c:a", "aac", "-b:a", "160k"])
        elif audio_opt == "aac_256k":
            command.extend(["-c:a", "aac", "-b:a", "256k"])
        elif audio_opt == "opus_96k":
            command.extend(["-c:a", "libopus", "-b:a", "96k"])
        elif audio_opt == "opus_160k":
            command.extend(["-c:a", "libopus", "-b:a", "160k"])
        elif audio_opt == "opus_256k":
            command.extend(["-c:a", "libopus", "-b:a", "256k"])
        elif audio_opt == "custom":
            abitrate_val = self.custom_abitrate.get()
            try:
                int(abitrate_val)
                command.extend(["-c:a", "aac", "-b:a", f"{abitrate_val}k"])
            except ValueError:
                raise ValueError("Custom audio bitrate must be a number.")

    def _run_ffmpeg(self, command):
        startupinfo = None
        creationflags = 0
        if os.name == "nt":
            startupinfo = subprocess.STARTUPINFO()
            startupinfo.dwFlags |= subprocess.STARTF_USESHOWWINDOW
            startupinfo.wShowWindow = subprocess.SW_HIDE
            creationflags = subprocess.CREATE_NO_WINDOW
        try:
            self.conversion_process = subprocess.Popen(
                command,
                stdout=subprocess.PIPE,
                stderr=subprocess.STDOUT,
                text=True,
                bufsize=1,
                startupinfo=startupinfo,
                creationflags=creationflags,
                encoding="utf-8",
                errors="replace",
            )
            last_line = ""
            for line in self.conversion_process.stdout:
                if not self.is_converting:
                    self.conversion_process.terminate()
                    try:
                        self.conversion_process.wait(timeout=5)
                    except subprocess.TimeoutExpired:
                        self.conversion_process.kill()
                    break

                line = line.strip()
                if line:
                    last_line = line
                    self.master.after(0, lambda l=line: self.ffmpeg_output.set(l))
                    self.master.after(0, lambda l=line: self._update_progress(l))
            self.conversion_process.wait()
            if self.conversion_process.returncode == 0:
                self.master.after(
                    0, lambda: self.status_text.set("Conversion complete!")
                )
                self.master.after(0, lambda: self.ffmpeg_output.set(""))
                self.master.after(0, lambda: self.progress_frame.grid_remove())
                self.master.after(
                    0,
                    lambda: self.convert_button.configure(
                        text="Convert", fg_color=ACCENT_BLUE, hover_color=HOVER_BLUE
                    ),
                )
                self.master.after(0, lambda: MessageBeep(MB_ICONASTERISK))
            elif not self.is_converting:
                self.master.after(
                    0, lambda: self.status_text.set("Conversion cancelled by user")
                )
                self.master.after(0, lambda: self.ffmpeg_output.set(""))
                self.master.after(0, lambda: self.progress_frame.grid_remove())
                self.master.after(
                    0,
                    lambda: self.convert_button.configure(
                        text="Convert", fg_color=ACCENT_BLUE, hover_color=HOVER_BLUE
                    ),
                )
                self.master.after(
                    0,
                    lambda: messagebox.showinfo(
                        "Cancelled", "Conversion was cancelled"
                    ),
                )
            else:
                self.master.after(0, lambda: self.status_text.set("Conversion error!"))
                self.master.after(0, lambda: self.ffmpeg_output.set(""))
                self.master.after(0, lambda: self.progress_frame.grid_remove())
                self.master.after(
                    0,
                    lambda: self.convert_button.configure(
                        text="Convert", fg_color=ACCENT_BLUE, hover_color=HOVER_BLUE
                    ),
                )
                self.master.after(
                    0,
                    lambda: messagebox.showerror(
                        "Error",
                        (
                            f"FFmpeg exited with error code "
                            f"{self.conversion_process.returncode}.\n"
                            f"Last output: {last_line}"
                        ),
                    ),
                )
            self.is_converting = False
        except FileNotFoundError:
            self.master.after(
                0, lambda: self.status_text.set("Error: ffmpeg.exe not found.")
            )
            self.master.after(0, lambda: self.ffmpeg_output.set(""))
            self.master.after(0, lambda: self.progress_frame.grid_remove())
            self.master.after(
                0,
                lambda: self.convert_button.configure(
                    text="Convert", fg_color=ACCENT_BLUE, hover_color=HOVER_BLUE
                ),
            )
            self.master.after(
                0,
                lambda: messagebox.showerror(
                    "Error",
                    (
                        "ffmpeg.exe not found. Ensure it's in the program folder "
                        "or system PATH."
                    ),
                ),
            )
            self.is_converting = False
        except Exception:
            self.master.after(
                0,
                lambda: self.status_text.set(
                    "An unexpected error occurred during conversion"
                ),
            )
            self.master.after(0, lambda: self.ffmpeg_output.set(""))
            self.master.after(0, lambda: self.progress_frame.grid_remove())
            self.master.after(
                0,
                lambda: self.convert_button.configure(
                    text="Convert", fg_color=ACCENT_BLUE, hover_color=HOVER_BLUE
                ),
            )
            self.master.after(
                0,
                lambda: messagebox.showerror(
                    "Unexpected Error", "An unexpected error occurred during conversion"
                ),
            )
            self.is_converting = False

    def _run_ffprobe_for_size(
        self, input_f, bitrate_int, audio_option, custom_abitrate
    ):
        command = [
            self.ffprobe_path,
            "-v",
            "error",
            "-show_entries",
            "format=duration",
            "-of",
            "default=noprint_wrappers=1:nokey=1",
            input_f,
        ]
        startupinfo = None
        creationflags = 0
        if os.name == "nt":
            startupinfo = subprocess.STARTUPINFO()
            startupinfo.dwFlags |= subprocess.STARTF_USESHOWWINDOW
            startupinfo.wShowWindow = subprocess.SW_HIDE
            creationflags = subprocess.CREATE_NO_WINDOW
        try:
            process = subprocess.Popen(
                command,
                stdout=subprocess.PIPE,
                stderr=subprocess.STDOUT,
                text=True,
                bufsize=1,
                startupinfo=startupinfo,
                creationflags=creationflags,
                encoding="utf-8",
                errors="replace",
            )
            duration_str = process.stdout.read().strip()
            process.wait()
            if process.returncode == 0 and duration_str:
                try:
                    duration = float(duration_str)
                    audio_bitrate_for_estimation = 160

                    if audio_option == "custom":
                        try:
                            audio_bitrate_for_estimation = int(custom_abitrate)
                        except ValueError:
                            pass
                    elif audio_option == "aac_256k" or audio_option == "opus_256k":
                        audio_bitrate_for_estimation = 256
                    elif audio_option == "aac_160k" or audio_option == "opus_160k":
                        audio_bitrate_for_estimation = 160
                    elif audio_option == "aac_96k" or audio_option == "opus_96k":
                        audio_bitrate_for_estimation = 96
                    elif audio_option == "disable":
                        audio_bitrate_for_estimation = 0

                    filesize_mb = (
                        (bitrate_int + audio_bitrate_for_estimation)
                        * duration
                        / 8
                        / 1024
                    )
                    self.master.after(
                        0,
                        lambda: self.estimated_file_size.set(
                            f"Estimated size: {filesize_mb:.2f} MB"
                        ),
                    )
                except ValueError:
                    self.master.after(0, lambda: self.estimated_file_size.set(""))
            else:
                self.master.after(
                    0,
                    lambda: self.estimated_file_size.set(
                        "Estimated size: Could not get duration"
                    ),
                )
                self.master.after(
                    0, lambda: self.status_text.set("Ready for conversion")
                )
        except FileNotFoundError:
            self.master.after(
                0, lambda: self.status_text.set("Error: ffprobe.exe not found.")
            )
            self.master.after(
                0,
                lambda: messagebox.showerror(
                    "Error",
                    "ffprobe.exe not found. Ensure it's in the program folder "
                    "or system PATH.",
                ),
            )
        except Exception:
            self.master.after(
                0,
                lambda: self.status_text.set(
                    "Error estimating size: Could not get duration"
                ),
            )
            self.master.after(
                0,
                lambda: messagebox.showerror(
                    "Unexpected Error",
                    "An unexpected error occurred during size estimation",
                ),
            )

    # PROGRES & UI UPDATES
    def _update_progress(self, line):
        if "time=" in line:
            time_pos = line.find("time=")
            time_str = line[time_pos + 5 :].split()[0]
            try:
                h, m, s = time_str.split(":")
                total_seconds = int(h) * 3600 + int(m) * 60 + float(s)
                if not hasattr(self, "total_duration"):
                    self._get_video_duration()
                if hasattr(self, "total_duration") and self.total_duration > 0:
                    progress = total_seconds / self.total_duration
                    self.progress_value.set(progress)
                    self.progress_label.configure(text=f"{progress * 100:.1f}%")
            except Exception:
                pass

    def _calculate_estimated_size(self):
        if self.icq_mode.get():
            self.estimated_file_size.set("Estimated size: Not available for ICQ")
            return

        input_f = self.input_file.get()
        bitrate_val = self.bitrate.get()

        if not self.ffprobe_path:
            self.estimated_file_size.set("")
            return

        if not input_f or not os.path.exists(input_f):
            self.estimated_file_size.set("")
            return

        try:
            bitrate_int = int(bitrate_val)
        except ValueError:
            self.estimated_file_size.set("")
            return

        audio_opt = self.audio_option.get()
        custom_ab = self.custom_abitrate.get()

        Thread(
            target=self._run_ffprobe_for_size,
            args=(input_f, bitrate_int, audio_opt, custom_ab),
        ).start()

    def _update_output_filename(self, *args):
        if self.input_file.get() and not self.input_file.get().startswith(
            "Drag and drop"
        ):
            current_output = self.output_file.get()

            # Only update if the current filename follows the pattern with codec suffix
            if (
                "_hevc_custom." in current_output
                or "_h264_custom." in current_output
                or "_av1_custom." in current_output
                or "_vp9_custom." in current_output
            ):
                base = (
                    current_output.split("_hevc_custom.")[0]
                    .split("_h264_custom.")[0]
                    .split("_av1_custom.")[0]
                    .split("_vp9_custom.")[0]
                )
                base_name = os.path.basename(base)
            else:
                # If the filename doesn't follow the pattern, don't auto-update it
                # This preserves manually selected extensions like .mkv, .mov, etc.
                return

            if os.path.isdir(os.path.dirname(current_output)):
                dir_name = os.path.dirname(current_output)
            else:
                dir_name = os.path.dirname(self.input_file.get())

            codec_suffix = (
                "_hevc"
                if self.video_codec.get() == "hevc"
                else "_h264"
                if self.video_codec.get() == "h264"
                else "_av1"
                if self.video_codec.get() == "av1"
                else "_vp9"
            )

            # Preserve the original file extension
            original_extension = os.path.splitext(current_output)[1]
            if not original_extension:  # If no extension, default to .mp4
                original_extension = ".mp4"

            new_filename = f"{base_name}{codec_suffix}_custom{original_extension}"
            new_output = os.path.normpath(os.path.join(dir_name, new_filename))

            self.output_file.set(new_output)

    def _update_codec_settings(self):
        # First hide all codec-specific elements
        self.tier_label.grid_remove()
        self.tier_option_menu.grid_remove()

        # Reset checkboxes for all codecs
        self.rdo_checkbox.grid_remove()
        self.mbbrc_checkbox.grid_remove()
        self.extbrc_checkbox.grid_remove()

        # Hide scenario for all codecs initially
        self.scenario_label.grid_remove()
        self.scenario_option_menu.grid_remove()

        # Disable ICQ for VP9 by default
        if self.video_codec.get() == "vp9":
            # VP9 doesn't support ICQ - switch to bitrate mode
            if self.icq_mode.get():
                self.icq_mode.set(False)
                self._toggle_icq_mode()

            # Disable ICQ checkbox for VP9
            self.icq_checkbox.configure(state="disabled")
        else:
            # Enable ICQ checkbox for other codecs
            self.icq_checkbox.configure(state="normal")

        if self.video_codec.get() == "hevc":
            # HEVC settings
            self.profile.set("auto")
            self.profile_option_menu.configure(
                values=["auto", "main", "main10", "mainsp", "rext", "scc"]
            )
            self.scenario_option_menu.configure(
                values=[
                    "auto",
                    "displayremoting",
                    "videoconference",
                    "archive",
                    "livestreaming",
                    "cameracapture",
                    "videosurveillance",
                    "gamestreaming",
                    "remotegaming",
                ]
            )
            # Show only HEVC-specific elements
            self.tier_label.grid()
            self.tier_option_menu.grid()
            self.rdo_checkbox.grid()
            self.mbbrc_checkbox.grid()
            self.extbrc_checkbox.grid()
            # Show scenario for HEVC
            self.scenario_label.grid()
            self.scenario_option_menu.grid()
            # LA Depth always visible for HEVC
            if hasattr(self, "la_depth_label"):
                self.la_depth_label.grid()

        elif self.video_codec.get() == "av1":
            # AV1 settings
            self.profile.set("auto")
            self.profile_option_menu.configure(values=["auto", "main"])
            # AV1 doesn't use scenario - keep it hidden
            # Show only AV1-specific elements
            self.extbrc_checkbox.grid()
            # LA Depth always visible for AV1
            if hasattr(self, "la_depth_label"):
                self.la_depth_label.grid()

        elif self.video_codec.get() == "vp9":
            # VP9 settings
            self.profile.set("auto")
            self.profile_option_menu.configure(
                values=["auto", "profile0", "profile1", "profile2", "profile3"]
            )
            # VP9 doesn't use scenario - keep it hidden
            # VP9 doesn't show additional checkboxes
            # Hide LA Depth for VP9
            if hasattr(self, "la_depth_label"):
                self.la_depth_label.grid_remove()

        else:
            # H.264 settings
            self.profile.set("auto")
            self.scenario_option_menu.configure(
                values=[
                    "auto",
                    "displayremoting",
                    "videoconference",
                    "archive",
                    "livestreaming",
                    "cameracapture",
                    "videosurveillance",
                    "gamestreaming",
                    "remotegaming",
                ]
            )
            self.profile_option_menu.configure(
                values=["auto", "baseline", "main", "high"]
            )
            # Show only H.264-specific elements
            self.rdo_checkbox.grid()
            self.mbbrc_checkbox.grid()
            self.extbrc_checkbox.grid()
            # Show scenario for H.264
            self.scenario_label.grid()
            self.scenario_option_menu.grid()
            # LA Depth always visible for H264
            if hasattr(self, "la_depth_label"):
                self.la_depth_label.grid()

        # Always show Profile for all codecs
        if hasattr(self, "profile_label"):
            self.profile_label.grid()
        self.profile_option_menu.grid()

        if self.video_codec.get() == "vp9":
            # Hide LA Depth for VP9
            if hasattr(self, "la_depth_label"):
                self.la_depth_label.grid_remove()
            if hasattr(self, "la_depth_option_menu"):
                self.la_depth_option_menu.grid_remove()
            # Also disable extbrc for VP9 since it's not supported
            self.extbrc.set(False)
            self.extbrc_checkbox.configure(state="disabled")
        else:
            # Show LA Depth for HEVC, AV1, H264
            if hasattr(self, "la_depth_label"):
                self.la_depth_label.grid()
            if hasattr(self, "la_depth_option_menu"):
                self.la_depth_option_menu.grid()
            # Enable extbrc checkbox for supported codecs
            self.extbrc_checkbox.configure(state="normal")

            # Apply current extbrc state to LA Depth controls
            self._toggle_la_depth_state()

        self.custom_command = None

    def _update_preview_button_state(self):
        """Update preview button state based on streamcopy setting"""
        if self.trim_streamcopy.get():
            self.play10s_button.configure(state="disabled", fg_color=SECONDARY_BG)
        else:
            self.play10s_button.configure(state="normal", fg_color=ACCENT_DEEPBLUE)

    def _show_output_command(self):
        if getattr(self, "output_window_open", False):
            if hasattr(self, "output_window") and self.output_window.winfo_exists():
                self.output_window.lift()
                self.output_window.focus_force()
                return
            else:
                self.output_window_open = False

        if not self.input_file.get():
            messagebox.showerror("Error", "Please select an input file first.")
            self.output_window_open = False
            return

        try:
            command = self._build_ffmpeg_command(preview=True)
            output_window = ctk.CTkToplevel(self.master)
            output_window.title("FFmpeg Command Preview - Editable")
            output_window.geometry("850x550")
            output_window.after(100, output_window.focus_force)
            output_window.configure(fg_color=SECONDARY_BG)

            def on_close():
                self.output_window_open = False
                if hasattr(self, "output_window"):
                    self.output_window.destroy()
                    del self.output_window

            if os.path.exists(icon_path):
                output_window.after(201, lambda: output_window.iconbitmap(icon_path))
            else:
                print(f"icon not found: {icon_path}")

            output_window.protocol("WM_DELETE_WINDOW", on_close)
            self.output_window = output_window
            self.output_window_open = True

            text_frame = ctk.CTkFrame(output_window)
            text_frame.pack(fill="both", expand=True, padx=10, pady=10)

            ctk.CTkLabel(
                text_frame,
                text="You can edit the command below:",
            ).pack(pady=(0, 5))
            text_frame.configure(fg_color=SECONDARY_BG)

            self.command_textbox = ctk.CTkTextbox(
                text_frame,
                wrap="word",
                font=("Consolas", 14),
                height=300,
                fg_color=PRIMARY_BG,
            )
            self.command_textbox.pack(fill="both", expand=True, padx=5, pady=5)
            self.command_textbox.insert("1.0", " ".join(command))

            button_frame = ctk.CTkFrame(text_frame)
            button_frame.pack(fill="x", pady=10)
            button_frame.configure(fg_color=SECONDARY_BG)

            ctk.CTkButton(
                button_frame,
                text="Copy to Clipboard",
                command=self._copy_command_to_clipboard,
                fg_color=ACCENT_BLUE,
                hover_color=HOVER_BLUE,
                text_color=TEXT_COLOR_B,
                width=150,
            ).pack(side="left", padx=5)

            ctk.CTkButton(
                button_frame,
                text="Apply Changes",
                command=lambda: self._apply_command_changes(output_window),
                fg_color=ACCENT_BLUE,
                hover_color=HOVER_BLUE,
                text_color=TEXT_COLOR_B,
                width=150,
            ).pack(side="left", padx=5)

            ctk.CTkButton(
                button_frame,
                text="Reset to Default",
                command=self._reset_custom_command,
                fg_color=ACCENT_RED,
                hover_color=HOVER_RED,
                text_color=TEXT_COLOR_B,
                width=150,
            ).pack(side="left", padx=5)

            ctk.CTkButton(
                button_frame,
                text="Close",
                command=on_close,
                fg_color=ACCENT_DEEPBLUE,
                hover_color=HOVER_DEEPBLUE,
                text_color=TEXT_COLOR_W,
                width=106,
            ).pack(side="right", padx=5)

        except Exception as e:
            messagebox.showerror("Error", f"Could not generate command: {str(e)}")
            self.output_window_open = False

    def _update_window_size(self):
        self.master.update_idletasks()
        current_height = self.master.winfo_height()
        required_height = 700

        if self.enable_audio_options.get():
            required_height += self.audio_frame.winfo_reqheight() + 10

        if self.enable_encoder_options.get():
            required_height += self.encoder_options_frame.winfo_reqheight() + 10

        if self.enable_fps_scale_options.get():
            required_height += self.fps_scale_options_frame.winfo_reqheight() + 10

        if self.enable_additional_options.get():
            required_height += self.additional_options_frame.winfo_reqheight() + 10

        if self.enable_presets.get():
            required_height += self.presets_frame.winfo_reqheight() + 10

        if required_height != current_height:
            self.master.geometry(f"820x{required_height}")

    # App window position
    def _center_window(self):
        self.master.update_idletasks()
        width = self.master.winfo_width()
        screen_width = self.master.winfo_screenwidth()
        x = (screen_width // 2) - (width // 2)
        y = 50
        self.master.geometry(f"+{x}+{y}")

    # TRIM & TIME LOGIC
    def _create_trim_slider(self):
        """Create a slider for visual video trimming"""
        # Frame for the trim slider
        self.trim_slider_frame = ctk.CTkFrame(
            self.additional_options_frame, fg_color="transparent"
        )
        self.trim_slider_frame.grid(
            row=0, column=0, columnspan=3, sticky="ew", padx=10, pady=(10, 0)
        )

        # Container for canvas and button in one line
        slider_container = ctk.CTkFrame(self.trim_slider_frame, fg_color="transparent")
        slider_container.pack(fill="x", expand=True)

        # Canvas for slider (takes main space)
        self.trim_canvas = ctk.CTkCanvas(
            slider_container, height=30, bg=SECONDARY_BG, highlightthickness=0
        )
        self.trim_canvas.pack(side="left", fill="x", expand=True, padx=(0, 10))

        # Reset button (fixed width)
        self.trim_reset_btn = ctk.CTkButton(
            slider_container,
            text="⟲",
            width=30,
            height=30,
            command=self._reset_trim_slider,
            fg_color=ACCENT_DEEPBLUE,
            hover_color=HOVER_DEEPBLUE,
            text_color=TEXT_COLOR_W,
        )
        self.trim_reset_btn.pack(side="right", padx=(0, 4))

        # Draw the initial slider
        self._draw_trim_slider()

        # Bind mouse events
        self.trim_canvas.bind("<Button-1>", self._on_slider_click)
        self.trim_canvas.bind("<B1-Motion>", self._on_slider_drag)

        # Add preview bindings
        self.trim_canvas.bind("<ButtonRelease-1>", self._on_slider_release)
        self.trim_canvas.bind("<Leave>", lambda e: self._hide_thumbnail_preview())

    def _time_str_to_seconds(self, time_str):
        """Convert HH:MM:SS to seconds"""
        try:
            parts = time_str.split(":")
            if len(parts) != 3:
                return 0
            hours = int(parts[0])
            minutes = int(parts[1])
            seconds = int(parts[2])
            return hours * 3600 + minutes * 60 + seconds
        except Exception:
            return 0

    def _seconds_to_time_str(self, seconds):
        """Convert seconds to HH:MM:SS"""
        hours = int(seconds // 3600)
        minutes = int((seconds % 3600) // 60)
        seconds = int(seconds % 60)
        return f"{hours:02d}:{minutes:02d}:{seconds:02d}"

    def _set_trim_end_to_duration(self):
        duration = self._get_video_duration(update_ui=False)
        if duration > 0:
            self.trim_end.set(self._seconds_to_time_str(duration))
            if hasattr(self, "trim_canvas"):
                self.master.after(100, self._update_trim_slider)

    def _time_to_slider_positions(self):
        """Convert time values to slider positions"""
        try:
            # Get total duration
            if not hasattr(self, "total_duration") or self.total_duration <= 0:
                self._get_video_duration()

            if not hasattr(self, "total_duration") or self.total_duration <= 0:
                return 10, (
                    self.trim_canvas.winfo_width() - 10
                    if self.trim_canvas.winfo_width() > 20
                    else 290
                )

            # Convert current time strings to seconds
            start_seconds = self._time_str_to_seconds(self.trim_start.get())
            end_seconds = self._time_str_to_seconds(self.trim_end.get())

            # Calculate positions
            width = self.trim_canvas.winfo_width()
            if width < 20:
                width = 400

            start_pos = 10 + (start_seconds / self.total_duration) * (width - 20)
            end_pos = 10 + (end_seconds / self.total_duration) * (width - 20)

            return max(10, min(width - 10, start_pos)), max(
                10, min(width - 10, end_pos)
            )

        except Exception:
            return 10, (
                self.trim_canvas.winfo_width() - 10
                if self.trim_canvas.winfo_width() > 20
                else 290
            )

    def _draw_trim_slider(self):
        """Draw the trim slider with current positions"""
        self.trim_canvas.delete("all")
        width = self.trim_canvas.winfo_width()
        if width < 10:  # Minimum width
            width = 820

        # Draw the track
        self.trim_canvas.create_line(10, 15, width - 10, 15, fill="#555555", width=3)

        # Calculate handle positions based on current time values
        start_pos, end_pos = self._time_to_slider_positions()

        # Draw handles
        self.trim_canvas.create_oval(
            start_pos - 8, 15 - 8, start_pos + 8, 15 + 8, fill=ACCENT_BLUE, outline=""
        )
        self.trim_canvas.create_oval(
            end_pos - 8, 15 - 8, end_pos + 8, 15 + 8, fill=ACCENT_BLUE, outline=""
        )

        # Draw current selection
        if start_pos < end_pos:
            self.trim_canvas.create_rectangle(
                start_pos, 12, end_pos, 18, fill=ACCENT_BLUE, outline=""
            )

    def _on_slider_click(self, event):
        """Handle click on slider"""
        x, y = event.x, event.y

        # Check if click is near start handle
        start_pos, end_pos = self._time_to_slider_positions()
        if abs(x - start_pos) < 10 and abs(y - 15) < 10:
            self.dragging_handle = "start"
        elif abs(x - end_pos) < 10 and abs(y - 15) < 10:
            self.dragging_handle = "end"
        else:
            self.dragging_handle = None

        # Show preview immediately
        fraction = (x - 10) / (self.trim_canvas.winfo_width() - 20)
        time_seconds = fraction * (getattr(self, "total_duration", 0) or 0)
        self._show_thumbnail_preview(x, time_seconds)

    def _on_slider_drag(self, event):
        """Handle drag on slider"""
        if not hasattr(self, "dragging_handle") or not self.dragging_handle:
            return

        if not hasattr(self, "total_duration") or self.total_duration <= 0:
            return

        x = max(10, min(self.trim_canvas.winfo_width() - 10, event.x))
        width = self.trim_canvas.winfo_width()
        if width < 20:
            return

        # Calculate new time value
        fraction = (x - 10) / (width - 20)
        new_seconds = fraction * self.total_duration

        # Fix for the end (No frame)
        if new_seconds >= self.total_duration:
            new_seconds = max(0, self.total_duration - 0.1)

        # Show preview
        self._schedule_thumbnail_preview(x, new_seconds)

        if self.dragging_handle == "start":
            # Ensure start doesn't go past end
            end_seconds = self._time_str_to_seconds(self.trim_end.get())
            new_seconds = min(new_seconds, end_seconds - 1)  # At least 1 second gap
            self.trim_start.set(self._seconds_to_time_str(new_seconds))
        else:
            # Ensure end doesn't go before start
            start_seconds = self._time_str_to_seconds(self.trim_start.get())
            new_seconds = max(new_seconds, start_seconds + 1)  # At least 1 second gap
            self.trim_end.set(self._seconds_to_time_str(new_seconds))

        # Redraw slider and update trim options
        self._draw_trim_slider()

    def _on_slider_release(self, event):
        # Cancel any scheduled preview job
        if getattr(self, "preview_job", None):
            try:
                self.master.after_cancel(self.preview_job)
            except Exception:
                pass
            self.preview_job = None

        # Hide preview popup
        self._hide_thumbnail_preview()

    def _reset_trim_slider(self):
        """Reset trim slider to full duration"""
        self.trim_start.set("00:00:00")

        if self.input_file.get() and not self.input_file.get().startswith(
            "Drag and drop"
        ):
            self._set_trim_end_to_duration()
        else:
            self.trim_end.set("00:00:00")

        self._draw_trim_slider()

    def _update_trim_slider(self):
        """Update slider when video duration changes"""
        if hasattr(self, "trim_canvas"):
            self._draw_trim_slider()

    def _validate_time_format(self, time_str):
        """Simple validation for HH:MM:SS format"""
        if not time_str or not isinstance(time_str, str):
            return False

        parts = time_str.split(":")
        if len(parts) != 3:
            return False

        try:
            hours = int(parts[0])
            minutes = int(parts[1])
            seconds = int(parts[2])
            return 0 <= hours < 24 and 0 <= minutes < 60 and 0 <= seconds < 60
        except ValueError:
            return False

    def _validate_trim_time(self, time_var, is_start):
        """Validate time input only when field loses focus"""
        time_str = time_var.get()

        # Skip validation if field is empty or doesn't contain colons
        if not time_str or ":" not in time_str:
            return True

        # Validate time format
        if not self._validate_time_format(time_str):
            messagebox.showerror("Error", "Time format should be HH:MM:SS")
            return False

        # Convert to seconds
        time_seconds = max(0, self._time_str_to_seconds(time_str))

        # Get video duration
        duration = self._get_video_duration(update_ui=False)

        # Check if time exceeds video duration
        if duration > 0 and time_seconds > duration:
            messagebox.showerror(
                "Error",
                f"Time exceeds video duration ({self._seconds_to_time_str(duration)})",
            )
            return False

        # Get the other time value
        other_time_str = self.trim_end.get() if is_start else self.trim_start.get()

        # Only validate against other time if it's also valid
        if (
            other_time_str
            and ":" in other_time_str
            and self._validate_time_format(other_time_str)
        ):
            other_time_seconds = self._time_str_to_seconds(other_time_str)

            if is_start and time_seconds >= other_time_seconds:
                messagebox.showerror("Error", "Start time must be before end time")
                return False
            elif not is_start and time_seconds <= other_time_seconds:
                messagebox.showerror("Error", "End time must be after start time")
                return False

        # Update slider if it exists
        if hasattr(self, "trim_canvas"):
            self.master.after(100, self._draw_trim_slider)

        return True

    def _validate_and_update_trim_time(self, time_var, is_start):
        """Validate time input when Enter is pressed and update slider"""
        time_str = time_var.get()

        # Skip validation if field is empty or doesn't contain colons
        if not time_str or ":" not in time_str:
            return

        # Validate time format
        if not self._validate_time_format(time_str):
            messagebox.showerror("Error", "Time format should be HH:MM:SS")
            return

        # Convert to seconds
        time_seconds = max(0, self._time_str_to_seconds(time_str))

        # Get video duration
        duration = self._get_video_duration(update_ui=False)

        # Check if time exceeds video duration
        if duration > 0 and time_seconds > duration:
            messagebox.showerror(
                "Error",
                f"Time exceeds video duration ({self._seconds_to_time_str(duration)})",
            )
            return

        # Get the other time value
        other_time_str = self.trim_end.get() if is_start else self.trim_start.get()

        # Only validate against other time if it's also valid
        if (
            other_time_str
            and ":" in other_time_str
            and self._validate_time_format(other_time_str)
        ):
            other_time_seconds = self._time_str_to_seconds(other_time_str)

            if is_start and time_seconds >= other_time_seconds:
                messagebox.showerror("Error", "Start time must be before end time")
                return
            elif not is_start and time_seconds <= other_time_seconds:
                messagebox.showerror("Error", "End time must be after start time")
                return

        # Update slider if it exists
        if hasattr(self, "trim_canvas"):
            self.master.after(100, self._draw_trim_slider)

    def _add_trim_options(self):
        """Add trim options to the additional options field"""
        # Validate both times first
        if not self._validate_trim_time(
            self.trim_start, True
        ) or not self._validate_trim_time(self.trim_end, False):
            return

        start_time = self.trim_start.get()
        end_time = self.trim_end.get()

        trim_options = f"-ss {start_time} -to {end_time}"

        current_options = self.additional_options.get()
        if current_options == self.additional_options_placeholder:
            current_options = ""

        current_options = self._remove_existing_trim_options(current_options)

        if current_options:
            new_options = f"{current_options} {trim_options}"
        else:
            new_options = trim_options

        self.additional_options.set(new_options)
        self.additional_options_entry.configure(text_color=TEXT_COLOR_W)

    def _remove_existing_trim_options(self, options_str):
        """Remove any existing trim-related options from the string"""
        options_str = sub(r"-ss\s+\S+", "", options_str)
        options_str = sub(r"-to\s+\S+", "", options_str)
        options_str = sub(r"-c\s+copy", "", options_str)
        options_str = " ".join(options_str.split())
        return options_str.strip()

    # PREVIEW & THUMBNAILS
    def _create_thumbnail_preview(self):
        """Create a thumbnail preview window"""
        self.preview_window = None
        self.preview_label = None
        self.preview_visible = False

    def _run_preview_encoding(self, command, output_path):
        """Run preview encoding with progress tracking"""
        startupinfo = None
        creationflags = 0
        if os.name == "nt":
            startupinfo = subprocess.STARTUPINFO()
            startupinfo.dwFlags |= subprocess.STARTF_USESHOWWINDOW
            startupinfo.wShowWindow = subprocess.SW_HIDE
            creationflags = subprocess.CREATE_NO_WINDOW

        try:
            process = subprocess.Popen(
                command,
                stdout=subprocess.PIPE,
                stderr=subprocess.STDOUT,
                text=True,
                bufsize=1,
                startupinfo=startupinfo,
                creationflags=creationflags,
                encoding="utf-8",
                errors="replace",
            )
            self.preview_process = process

            # Process output in real-time
            for line in process.stdout:
                if not self.is_creating_preview:  # Check if cancelled
                    process.terminate()
                    break

                if line:
                    self.master.after(
                        0, lambda line_text=line: self.ffmpeg_output.set(line_text)
                    )
                    self.master.after(
                        0,
                        lambda line_text=line: self._update_preview_progress(line_text),
                    )

            process.wait()

            if process.returncode == 0 and self.is_creating_preview:
                self.master.after(
                    0, lambda: self.status_text.set("Preview created successfully!")
                )
                self.master.after(0, lambda: self.ffmpeg_output.set(""))
                # Play the result
                if os.path.exists(output_path):
                    os.startfile(output_path)
            elif not self.is_creating_preview:
                self.master.after(
                    0, lambda: self.status_text.set("Preview creation cancelled")
                )
            else:
                self.master.after(
                    0, lambda: self.status_text.set("Preview creation failed!")
                )

        except Exception as e:
            error_message = f"Preview error: {str(e)}"
            self.master.after(0, lambda: self.status_text.set(error_message))
        finally:
            self.master.after(0, lambda: self.progress_frame.grid_remove())
            self.is_creating_preview = False
            self.preview_process = None
            # Reset button to normal state
            self.master.after(
                0,
                lambda: self.play10s_button.configure(
                    text="Play 10s Preview",
                    fg_color=ACCENT_BLUE,
                    hover_color=HOVER_BLUE,
                ),
            )

    def _update_preview_progress(self, line):
        """Update progress for preview encoding"""
        if "time=" in line:
            time_pos = line.find("time=")
            time_str = line[time_pos + 5 :].split()[0]
            try:
                h, m, s = time_str.split(":")
                total_seconds = int(h) * 3600 + int(m) * 60 + float(s)
                # Preview is always 10 seconds long
                progress = min(1.0, total_seconds / 10.0)
                self.progress_value.set(progress)
                self.progress_label.configure(text=f"{progress * 100:.1f}%")
            except Exception:
                pass

    def _cleanup_preview_files(self):
        """Clean up preview temporary files"""
        for file_path in self.preview_temp_files:
            try:
                if os.path.exists(file_path):
                    os.remove(file_path)
            except Exception as e:
                print(f"Error deleting temp file {file_path}: {e}")
        self.preview_temp_files = []

    def _show_thumbnail_preview(self, x_pos, time_seconds):
        """Show thumbnail preview at specified position and time"""
        self.preview_job = None
        if not self.input_file.get() or self.input_file.get().startswith(
            "Drag and drop"
        ):
            return

        if not self.ffmpeg_path:
            return

        # Fix for the end (No frame)
        duration = self._get_video_duration(update_ui=False)
        if duration > 0 and time_seconds > duration:
            time_seconds = max(0, duration - 0.1)

        # Create preview window if it doesn't exist
        if not self.preview_window:
            self.preview_window = ctk.CTkToplevel(self.master)
            self.preview_window.title("Preview")
            self.preview_window.overrideredirect(True)
            self.preview_window.attributes("-topmost", True)
            self.preview_window.configure(fg_color=PRIMARY_BG)

            self.preview_label = ctk.CTkLabel(
                self.preview_window,
                text="",
                width=352,
                height=198,
                fg_color=SECONDARY_BG,
                corner_radius=0,
            )
            self.preview_label.pack(padx=0, pady=0)
            self.preview_window.geometry("352x198")

        process = None
        success = False

        # Generate thumbnail in memory
        try:
            cmd_qsv = [
                self.ffmpeg_path,
                "-hwaccel",
                "qsv",
                "-hwaccel_output_format",
                "qsv",
                "-ss",
                str(time_seconds),
                "-i",
                self.input_file.get(),
                "-vframes",
                "1",
                "-vf",
                "vpp_qsv=w=352:h=198",
                "-q:v",
                "2",
                "-an",
                "-f",
                "mjpeg",
                "pipe:1",
            ]
            print(cmd_qsv)
            try:
                process = subprocess.run(
                    cmd_qsv,
                    stdout=subprocess.PIPE,
                    stderr=subprocess.PIPE,
                    timeout=5,
                    creationflags=subprocess.CREATE_NO_WINDOW if os.name == "nt" else 0,
                )
                if process.returncode == 0 and process.stdout:
                    print("QSV Success")
                    success = True
                else:
                    raise Exception(f"QSV failed with return code {process.returncode}")
            except (subprocess.TimeoutExpired, Exception) as e:
                print(f"QSV Failed: {e}")

            # CPU fallback if QSV failed
            if not success:
                cmd_cpu = [
                    self.ffmpeg_path,
                    "-ss",
                    str(time_seconds),
                    "-i",
                    self.input_file.get(),
                    "-vframes",
                    "1",
                    "-vf",
                    "scale=352:-1",
                    "-q:v",
                    "2",
                    "-an",
                    "-f",
                    "mjpeg",
                    "pipe:1",
                ]

                process = subprocess.run(
                    cmd_cpu,
                    stdout=subprocess.PIPE,
                    stderr=subprocess.PIPE,
                    timeout=5,
                    creationflags=subprocess.CREATE_NO_WINDOW if os.name == "nt" else 0,
                )
                if process.returncode == 0 and process.stdout:
                    print("CPU Success")
                    success = True
                else:
                    print(f"CPU failed with return code {process.returncode}")

            # Process result
            if success and process and process.stdout:
                img_buffer = BytesIO(process.stdout)
                thumb_image = Image.open(img_buffer)
                ctk_thumb = ctk.CTkImage(light_image=thumb_image, size=(352, 198))
                self.preview_label.configure(image=ctk_thumb, text="")

                if self.scaling > 100:
                    # Position preview in the top-left corner of the screen with 10px offset
                    screen_x = 50
                    screen_y = 50
                    self.preview_window.geometry(f"352x198+{screen_x}+{screen_y}")

                else:
                    # Position preview above slider handle
                    slider_x = self.trim_canvas.winfo_rootx() + x_pos - 176
                    slider_y = self.trim_canvas.winfo_rooty() - 208

                    self.preview_window.geometry(f"352x198+{slider_x}+{slider_y}")

                self.preview_window.deiconify()
                self.preview_visible = True
            else:
                self.preview_label.configure(text="Preview\nunavailable")

        except Exception as e:
            print(f"Error generating preview: {e}")
            self.preview_label.configure(text="Preview\nunavailable")

    def _schedule_thumbnail_preview(self, x_pos, time_seconds, delay=200):
        """Debounce thumbnail generation: cancel previous and schedule new one."""
        try:
            # cancel any pending scheduled preview
            if getattr(self, "preview_job", None):
                self.master.after_cancel(self.preview_job)
        except Exception:
            pass

        # schedule a new preview after `delay` ms
        self.preview_job = self.master.after(
            delay, lambda: self._show_thumbnail_preview(x_pos, time_seconds)
        )

    def _hide_thumbnail_preview(self):
        """Hide the thumbnail preview"""
        if self.preview_window and self.preview_visible:
            self.preview_window.withdraw()
            self.preview_visible = False

    # PRESETS & UI TOGGLES
    def _apply_preset(self, preset_name):

        # Clear Additional Options (Trimming)
        self._clear_all_filters()
        self._reset_trim_slider()
        self.trim_streamcopy.set(False)
        self.precise_trim.set(False)

        # Default (Reset)
        if preset_name == "none":
            # Reset all settings to their initial values
            self.bitrate.set("6000")
            # VP9 doesn't support ICQ - don't enable it for VP9
            if self.video_codec.get() != "vp9":
                self.icq_mode.set(True)
            else:
                self.icq_mode.set(False)
            self.global_quality_level.set("30")
            self.audio_option.set("copy")
            self.custom_abitrate.set("160")

            # Reset encoder options
            self.threads.set("4")
            self.hwaccel.set("auto")
            self.preset.set("medium")
            self.scenario.set("auto")
            self.profile.set("auto")
            self.tier.set("auto")
            self.rc.set("vbr")

            # Flags
            self.rdo.set(True)
            self.mbbrc.set(False)
            self.extbrc.set(True)
            self.look_ahead_depth.set("40")

            # Reset FPS and scaling options
            self.fps_option.set("source")
            self.custom_fps.set("30")
            self.video_format_option.set("source")
            self.custom_video_width.set("1920")
            self.interpolation_algo.set("bicubic")

            self.preset_indicator.configure(
                text="Default settings applied", text_color=ACCENT_BLUE
            )
            self._toggle_icq_mode()
            self._save_settings()
            self.selected_preset.set("none")

        # FHD Fast preset
        elif preset_name == "fhdf":
            # Video settings
            self.bitrate.set("6000")
            self.icq_mode.set(True)
            self.global_quality_level.set("30")
            self.video_format_option.set("1920")
            self.interpolation_algo.set("bicubic")

            # Encoder settings
            self.preset.set("medium")
            self.scenario.set("archive")
            self.tier.set("high")
            self.rc.set("vbr")

            # Flags
            self.rdo.set(False)
            self.mbbrc.set(False)
            self.extbrc.set(False)
            self.look_ahead_depth.set("auto")

            # Audio
            self.audio_option.set("aac_160k")

            self.preset_indicator.configure(
                text="FHD Fast preset applied", text_color=ACCENT_BLUE
            )
            self._save_settings()
            self.selected_preset.set("fhdf")

        # FHD Quality preset
        elif preset_name == "fhdq":
            # Video settings
            self.bitrate.set("8000")
            self.icq_mode.set(True)
            self.global_quality_level.set("27")
            self.video_format_option.set("1920")
            self.interpolation_algo.set("spline")

            # Encoder settings
            self.preset.set("slower")
            self.scenario.set("archive")
            self.tier.set("high")
            self.rc.set("vbr")

            # Flags
            self.rdo.set(True)
            self.mbbrc.set(False)
            self.extbrc.set(True)
            self.look_ahead_depth.set("40")

            # Audio
            self.audio_option.set("aac_160k")

            self.preset_indicator.configure(
                text="FHD Quality preset applied", text_color=ACCENT_BLUE
            )
            self._save_settings()
            self.selected_preset.set("fhdq")

        # HD Fast preset
        elif preset_name == "hdf":
            # Video settings
            self.bitrate.set("5000")
            self.icq_mode.set(True)
            self.global_quality_level.set("30")
            self.video_format_option.set("1280")
            self.interpolation_algo.set("bicubic")

            # Encoder settings
            self.preset.set("medium")
            self.scenario.set("archive")
            self.tier.set("high")
            self.rc.set("vbr")

            # Flags
            self.rdo.set(False)
            self.mbbrc.set(False)
            self.extbrc.set(False)
            self.look_ahead_depth.set("auto")

            # Audio
            self.audio_option.set("aac_160k")

            self.preset_indicator.configure(
                text="HD Fast preset applied", text_color=ACCENT_BLUE
            )
            self._save_settings()
            self.selected_preset.set("hdf")

        # HD Quality preset
        elif preset_name == "hdq":
            # Video settings
            self.bitrate.set("6000")
            self.icq_mode.set(True)
            self.global_quality_level.set("27")
            self.video_format_option.set("1280")
            self.interpolation_algo.set("spline")

            # Encoder settings
            self.preset.set("slower")
            self.scenario.set("archive")
            self.tier.set("high")
            self.rc.set("vbr")

            # Flags
            self.rdo.set(True)
            self.mbbrc.set(False)
            self.extbrc.set(True)
            self.look_ahead_depth.set("40")

            # Audio
            self.audio_option.set("aac_160k")

            self.preset_indicator.configure(
                text="HD Quality preset applied", text_color=ACCENT_BLUE
            )
            self._save_settings()
            self.selected_preset.set("hdq")

    def _apply_auto_encoder_settings(self):
        """Set all option menus with 'auto' to auto and uncheck all checkboxes."""
        for child in self.encoder_options_frame.winfo_children():
            # Recursively go through subframes
            for (
                sub_child
            ) in child.winfo_children():  # Renamed from 'sub' to 'sub_child'
                # OptionMenus
                if isinstance(sub_child, ctk.CTkOptionMenu):
                    try:
                        if "auto" in sub_child._values:
                            sub_child._variable.set("auto")
                    except Exception:
                        pass

                # CheckBoxes
                if isinstance(sub_child, ctk.CTkCheckBox):
                    try:
                        sub_child._variable.set(False)
                    except Exception:
                        pass

    def _toggle_icq_mode(self):
        if self.icq_mode.get():
            # Switch to Intelligent Constant Quality mode - replace bitrate with quality
            self.bitrate_label.configure(text="Quality Level:")
            self.bitrate_entry.configure(textvariable=self.global_quality_level)

            current_quality = self.global_quality_level.get()
            self.bitrate_entry.delete(0, "end")
            self.bitrate_entry.insert(0, current_quality)

            # Disable Rate-Control selection
            # Note: rc_locked variable might also need to be defined if it doesn't exist
            if hasattr(self, "rc_locked"):
                self.rc_locked.set(True)
            if hasattr(self, "rc_option_menu"):
                self.rc_option_menu.configure(
                    state="disabled",
                    fg_color=ACCENT_DEEPBLUE,
                    button_color=ACCENT_DEEPBLUE,
                )

            # Disable file size estimation
            self.estimated_file_size.set("Estimated size: Not available for ICQ")
        else:
            # Switch back to normal mode - replace quality with bitrate
            self.bitrate_label.configure(text="Video Bitrate (k):")
            self.bitrate_entry.configure(textvariable=self.bitrate)

            current_bitrate = self.bitrate.get()
            self.bitrate_entry.delete(0, "end")
            self.bitrate_entry.insert(0, current_bitrate)

            # Enable Rate-Control selection
            if hasattr(self, "rc_locked"):
                self.rc_locked.set(False)
            if hasattr(self, "rc_option_menu"):
                self.rc_option_menu.configure(
                    state="normal", fg_color=PRIMARY_BG, button_color=ACCENT_BLUE
                )

            # Enable file size estimation
            self._calculate_estimated_size()

    def _toggle_la_depth_state(self, *args):
        """LA Depth / Extended Control toggle"""
        if self.extbrc.get():
            # Extended Control on - LA Depth enabled
            state = "normal"
            fg_color = PRIMARY_BG
            button_color = ACCENT_BLUE
        else:
            # Extended Control off - LA Depth disabled
            state = "disabled"
            fg_color = ACCENT_DEEPBLUE
            button_color = ACCENT_DEEPBLUE

        # Apply to LA Depth option menu
        if hasattr(self, "la_depth_option_menu"):
            self.la_depth_option_menu.configure(
                state=state, fg_color=fg_color, button_color=button_color
            )

    def _toggle_encoder_options_frame(self):
        if self.enable_encoder_options.get():
            self.encoder_options_frame.grid(
                row=6, column=0, columnspan=3, padx=10, pady=5, sticky="ew"
            )
            self.auto_button.grid()
            self.default_button.grid()
        else:
            self.encoder_options_frame.grid_remove()
            self.auto_button.grid_remove()
            self.default_button.grid_remove()
        self._update_window_size()

    def _toggle_audio_options_frame(self):
        if self.enable_audio_options.get():
            self.audio_frame.grid(
                row=10, column=0, columnspan=4, sticky="ew", padx=10, pady=10
            )
        else:
            self.audio_frame.grid_forget()
        self._update_window_size()

    def _toggle_fps_scale_options_frame(self):
        if self.enable_fps_scale_options.get():
            self.fps_scale_options_frame.grid(
                row=8, column=0, columnspan=4, sticky="ew", padx=10, pady=10
            )
        else:
            self.fps_scale_options_frame.grid_forget()
        self._update_window_size()

    def _toggle_additional_options_frame(self):
        if self.enable_additional_options.get():
            self.additional_options_frame.grid(
                row=12, column=0, columnspan=4, sticky="ew", padx=10, pady=10
            )
            if hasattr(self, "trim_canvas"):
                self.master.after(100, self._update_trim_slider)
        else:
            self.additional_options_frame.grid_forget()
        self._update_window_size()

    def _toggle_presets_frame(self):
        if self.enable_presets.get():
            self.presets_frame.grid(
                row=14, column=0, columnspan=4, sticky="ew", padx=10, pady=10
            )
        else:
            self.presets_frame.grid_forget()
        self._update_window_size()

    def _toggle_custom_fps_entry(self):
        if self.fps_option.get() == "custom":
            self.custom_fps_entry.configure(
                state="normal",
                fg_color=SECONDARY_BG,
                text_color=TEXT_COLOR_W,
                border_color=HOVER_BLUE,
            )
            self.custom_fps_entry.focus()
        else:
            self.custom_fps_entry.configure(
                state="disabled",
                fg_color=ACCENT_DEEPBLUE,
                text_color=PLACEHOLDER_COLOR,
                border_color=ACCENT_DEEPBLUE,
            )

    def _toggle_custom_video_width_entry(self):
        if self.video_format_option.get() == "custom":
            self.custom_video_width_entry.configure(
                state="normal",
                fg_color=SECONDARY_BG,
                text_color=TEXT_COLOR_W,
                border_color=HOVER_BLUE,
            )
            self.custom_video_width_entry.focus()
        else:
            self.custom_video_width_entry.configure(
                state="disabled",
                fg_color=ACCENT_DEEPBLUE,
                text_color=PLACEHOLDER_COLOR,
                border_color=ACCENT_DEEPBLUE,
            )

    def _toggle_custom_abitrate(self):
        if self.audio_option.get() == "custom":
            self.custom_abitrate_entry.configure(
                state="normal",
                fg_color=SECONDARY_BG,
                text_color=TEXT_COLOR_W,
                border_color=HOVER_BLUE,
            )
            self.custom_abitrate_entry.focus()
        else:
            self.custom_abitrate_entry.configure(
                state="disabled",
                fg_color=ACCENT_DEEPBLUE,
                text_color=PLACEHOLDER_COLOR,
                border_color=ACCENT_DEEPBLUE,
            )

    def _update_interpolation_description(self):
        descriptions = {
            "bilinear": "Fast, low-quality scaling.",
            "bicubic": "Smooth and balanced quality.",
            "neighbor": "Blocky, pixelated output.",
            "area": "Soft result for downscaling.",
            "lanczos": "Sharp and high-quality.",
            "spline": "Visually best in theory.",
        }
        current = self.interpolation_algo.get()
        self.interpolation_description.set(descriptions.get(current, ""))

    def _apply_command_changes(self, window):
        new_command = self.command_textbox.get("1.0", "end-1c").strip()
        if not new_command:
            messagebox.showwarning("Warning", "Command is empty!")
            return

        try:
            args = split(new_command, posix=False)

            i = 0
            while i < len(args):
                if (":" in args[i] and "\\" in args[i]) or args[i].startswith("\\\\"):
                    path_parts = [args[i]]
                    j = i + 1
                    while j < len(args) and not args[j].startswith("-"):
                        path_parts.append(args[j])
                        j += 1

                    full_path = " ".join(path_parts)
                    if full_path.startswith('"') and full_path.endswith('"'):
                        full_path = full_path[1:-1]

                    args = args[:i] + [full_path] + args[j:]
                    i += 1
                else:
                    i += 1

            if len(args) < 3:
                raise ValueError("Command too short - not a valid FFmpeg command")

            has_input = False
            input_file = None
            output_file = None

            for i, arg in enumerate(args):
                if arg == "-i" and i < len(args) - 1:
                    has_input = True
                    input_file = args[i + 1]

            # Output file is the last non-flag argument (skip values of known options)
            skip_next = False
            for i in range(1, len(args)):
                if skip_next:
                    skip_next = False
                    continue
                if args[i].startswith("-"):
                    # Most ffmpeg flags take one value argument after them
                    skip_next = True
                    continue
                output_file = args[i]

            if not has_input:
                raise ValueError("Missing input file (-i option)")
            if not output_file:
                raise ValueError("Missing output file")
            if not input_file:
                raise ValueError("Input file not specified after -i option")

            self.custom_command = args
            self.ffmpeg_output.set("Custom command applied: " + " ".join(args))
            self.output_window_open = False
            window.destroy()

        except Exception as e:
            messagebox.showerror(
                "Error",
                f"Invalid command: {str(e)}\n\nPlease check:\n"
                "1. Input file (-i option)\n"
                "2. Output file path\n"
                "3. Valid FFmpeg arguments\n\n"
                f"Command: {new_command}",
            )

    def _reset_custom_command(self):
        self.custom_command = None
        self.ffmpeg_output.set("Custom command cleared – GUI settings are active again")
        messagebox.showinfo(
            "Reset", "Custom command has been cleared.\nGUI settings are now active."
        )

    # WINDOW & FOCUS MANAGEMENT
    def _on_input_file_focus_in(self, event):
        current_text = self.input_file.get()
        if (
            current_text
            == "Drag and drop a video file here or use the 'Browse' button."
        ):
            self.input_file_entry.delete(0, "end")
            self.input_file_entry.configure(text_color=TEXT_COLOR_W)

    def _on_input_file_focus_out(self, event):
        current_text = self.input_file.get()
        if not current_text.strip():
            self.input_file_entry.insert(
                0, "Drag and drop a video file here or use the 'Browse' button."
            )
            self.input_file_entry.configure(text_color=PLACEHOLDER_COLOR)

    def _on_output_file_focus_in(self, event):
        current_text = self.output_file.get()
        if current_text == getattr(self, "output_file_placeholder", ""):
            self.output_file_entry.delete(0, "end")
            self.output_file_entry.configure(text_color=TEXT_COLOR_W)

    def _on_output_file_focus_out(self, event):
        current_text = self.output_file.get()
        if not current_text.strip():
            self.output_file_entry.insert(
                0, getattr(self, "output_file_placeholder", "")
            )
            self.output_file_entry.configure(text_color=PLACEHOLDER_COLOR)

    def _on_output_file_change(self, *args):
        if not hasattr(self, "output_file_entry") or not hasattr(
            self, "output_file_placeholder"
        ):
            return
        current_text = self.output_file.get()
        if current_text == self.output_file_placeholder:
            self.output_file_entry.configure(text_color=PLACEHOLDER_COLOR)
        else:
            self.output_file_entry.configure(text_color=TEXT_COLOR_W)

    def _on_ffmpeg_path_focus_in(self, event):
        current_text = self.ffmpeg_custom_path.get()
        if current_text == self.ffmpeg_path_placeholder:
            self.ffmpeg_path_entry.delete(0, "end")
            self.ffmpeg_path_entry.configure(text_color=TEXT_COLOR_W)

    def _on_ffmpeg_path_focus_out(self, event):
        current_text = self.ffmpeg_custom_path.get()
        if not current_text.strip():
            self.ffmpeg_path_entry.insert(0, self.ffmpeg_path_placeholder)
            self.ffmpeg_path_entry.configure(text_color=PLACEHOLDER_COLOR)
        elif current_text == self.ffmpeg_path_placeholder:
            self.ffmpeg_path_entry.configure(text_color=PLACEHOLDER_COLOR)
        else:
            self.ffmpeg_path_entry.configure(text_color=TEXT_COLOR_W)
            # Save the path if it exists
            if os.path.exists(current_text) and os.path.isfile(current_text):
                self._save_settings()
                self.ffmpeg_path = current_text
                # Look for ffprobe.exe in the same directory
                ffprobe_path = os.path.join(
                    os.path.dirname(current_text), "ffprobe.exe"
                )
                if os.path.exists(ffprobe_path):
                    self.ffprobe_path = ffprobe_path
                    self.status_text.set("FFmpeg and FFprobe found successfully")
                else:
                    self.ffprobe_path = None
                    self.status_text.set(
                        "FFmpeg found but FFprobe not found in the same directory"
                    )

    def _on_options_entry_focus_in(self, event):
        current_text = self.additional_options.get()
        if current_text == self.additional_options_placeholder:
            self.additional_options_entry.delete(0, "end")
            self.additional_options_entry.configure(text_color=TEXT_COLOR_W)

    def _on_options_entry_focus_out(self, event):
        current_text = self.additional_options.get()
        if not current_text.strip():
            self.additional_options_entry.insert(0, self.additional_options_placeholder)
            self.additional_options_entry.configure(text_color=PLACEHOLDER_COLOR)

    def _on_filters_entry_focus_in(self, event):
        current_text = self.additional_filter_options.get()
        if current_text == self.additional_filter_options_placeholder:
            self.additional_filter_options_entry.delete(0, "end")
            self.additional_filter_options_entry.configure(text_color=TEXT_COLOR_W)

    def _on_filters_entry_focus_out(self, event):
        current_text = self.additional_filter_options.get()
        if not current_text.strip():
            self.additional_filter_options_entry.insert(
                0, self.additional_filter_options_placeholder
            )
            self.additional_filter_options_entry.configure(text_color=PLACEHOLDER_COLOR)

    def _on_audio_filters_entry_focus_in(self, event):
        current_text = self.additional_audio_filter_options.get()
        if current_text == self.additional_audio_filter_options_placeholder:
            self.additional_audio_filter_options_entry.delete(0, "end")
            self.additional_audio_filter_options_entry.configure(
                text_color=TEXT_COLOR_W
            )

    def _on_audio_filters_entry_focus_out(self, event):
        current_text = self.additional_audio_filter_options.get()
        if not current_text.strip():
            self.additional_audio_filter_options_entry.insert(
                0, self.additional_audio_filter_options_placeholder
            )
            self.additional_audio_filter_options_entry.configure(
                text_color=PLACEHOLDER_COLOR
            )

    # KEYBOARD & CLIPBOARD

    def _setup_keyboard_shortcuts(self):
        self.context_menu = None
        self.master.bind_all("<Control-KeyPress>", self._handle_key_press)
        self.master.bind_all("<Button-3>", self._show_context_menu)
        self.master.bind_all("<Button-1>", self._hide_context_menu, add="+")
        self.master.bind("<FocusOut>", self._hide_context_menu_on_focus_loss)
        self.master.bind("<Configure>", self._on_master_configure)

    def _show_context_menu(self, event):
        if not isinstance(event.widget, (tk.Entry, tk.Text)):
            return

        if (
            not hasattr(self, "context_menu")
            or not self.context_menu
            or not self.context_menu.winfo_exists()
        ):
            self.context_menu = CTkContextMenu(self.master, event.widget, self)
            self.context_menu.update()  # force initialization to fix first click
        else:
            self.context_menu.target_widget = event.widget

        # Position menu at mouse cursor
        x = event.x_root
        y = event.y_root

        # Show window
        self.context_menu.geometry(f"+{x}+{y}")
        self.context_menu.deiconify()
        self.context_menu.focus_set()

    def _hide_context_menu(self, event):
        if (
            hasattr(self, "context_menu")
            and self.context_menu
            and self.context_menu.winfo_exists()
        ):
            try:
                # event.widget can be a string if the widget was recently destroyed
                if isinstance(event.widget, str):
                    self.context_menu.withdraw()
                    return

                # Only hide if clicked outside the context menu
                if event.widget.winfo_toplevel() != self.context_menu:
                    self.context_menu.withdraw()
            except (AttributeError, tk.TclError):
                # If the widget is invalid or doesn't have winfo_toplevel, hide for safety
                self.context_menu.withdraw()

    def _hide_context_menu_on_focus_loss(self, event):
        if event.widget == self.master:
            # Delay the check slightly to see if focus moved to the context menu
            self.master.after(50, self._check_focus_loss)

    def _check_focus_loss(self):
        if (
            hasattr(self, "context_menu")
            and self.context_menu
            and self.context_menu.winfo_exists()
        ):
            # If the current focused widget is None, then the whole application lost OS focus
            current_focus = self.master.focus_displayof()
            # If focus is still somewhere within our app (even the main window), keep the menu open.
            # The <Button-1> binding handles clicks inside the app to close the menu.
            if current_focus is None:
                self.context_menu.withdraw()

    def _on_master_configure(self, event):
        if event.widget == self.master:
            if hasattr(self, "_configure_after_id") and self._configure_after_id:
                self.master.after_cancel(self._configure_after_id)
            self._configure_after_id = self.master.after(
                50, self._deferred_hide_context_menu
            )

    def _deferred_hide_context_menu(self):
        self._configure_after_id = None
        if (
            hasattr(self, "context_menu")
            and self.context_menu
            and self.context_menu.winfo_exists()
        ):
            self.context_menu.withdraw()

    def _handle_key_press(self, event):
        # Check if Ctrl is pressed (0x0004 is the Control modifier)
        if not (event.state & 0x0004):
            return

        # If US English layout is active, let the system handle the shortcut
        if is_us_english_layout():
            return

        # Map keycodes to their handler methods
        handlers = {
            65: self._select_all,  # A
            67: self._copy_text,  # C
            86: self._paste_text,  # V
            88: self._cut_text,  # X
        }

        handler = handlers.get(event.keycode)
        if handler:
            handler()
            return "break"  # Prevent further event propagation

    def _select_all(self):
        """Select all text in the currently focused widget."""
        widget = self.master.focus_get()
        if widget is None:
            return

        try:
            if isinstance(widget, (ctk.CTkTextbox, tk.Text)):
                widget.tag_add("sel", "1.0", "end")
            elif isinstance(widget, ctk.CTkEntry):
                # CTkEntry contains an internal tk.Entry
                entry = widget._entry if hasattr(widget, "_entry") else widget
                entry.select_range(0, tk.END)
            elif isinstance(widget, tk.Entry):
                widget.select_range(0, tk.END)
            else:
                # Fallback for other widgets that might support selection
                if hasattr(widget, "select_range"):
                    widget.select_range(0, tk.END)
                elif hasattr(widget, "selection_range"):
                    widget.selection_range(0, tk.END)
        except Exception as e:
            print(f"Error selecting all: {e}")

    def _copy_text(self):
        widget = self.master.focus_get()
        try:
            if isinstance(widget, (ctk.CTkTextbox, tk.Text)):
                try:
                    if widget.tag_ranges("sel"):
                        text = widget.get("sel.first", "sel.last")
                    else:
                        text = widget.get("1.0", "end-1c")
                except Exception:
                    text = widget.get("1.0", "end-1c")
            elif isinstance(widget, ctk.CTkEntry):
                try:
                    entry = widget._entry
                    if entry.selection_present():
                        text = entry.selection_get()
                    else:
                        text = widget.get()
                except Exception:
                    text = widget.get()
            elif hasattr(widget, "get"):
                try:
                    text = widget.selection_get()
                except Exception:
                    text = widget.get()
            else:
                text = ""
        except Exception as e:
            print(f"Error copying text: {e}")
            text = ""

        if text:
            try:
                _set_clipboard_text(text)
            except Exception as e:
                print(f"Error setting clipboard: {e}")

    def _cut_text(self):
        """Cut the selected text: copy to clipboard and delete the selection."""
        widget = self.master.focus_get()
        if widget is None:
            return

        has_selection = False

        if isinstance(widget, (ctk.CTkTextbox, tk.Text)):
            has_selection = bool(widget.tag_ranges("sel"))

        elif isinstance(widget, ctk.CTkEntry):
            try:
                has_selection = widget.selection_present()
            except AttributeError:
                try:
                    has_selection = widget._entry.selection_present()
                except Exception:  # ← fixed
                    has_selection = False

        elif hasattr(widget, "selection_present"):
            try:
                has_selection = widget.selection_present()
            except Exception:  # ← fixed
                has_selection = False

        if not has_selection:
            return

        # Copy
        self._copy_text()

        # Delete selection directly
        try:
            if isinstance(widget, (ctk.CTkTextbox, tk.Text)):
                widget.delete("sel.first", "sel.last")

            elif isinstance(widget, ctk.CTkEntry):
                try:
                    widget.delete("sel.first", "sel.last")
                except Exception:  # ← fixed
                    widget._entry.delete("sel.first", "sel.last")

            elif hasattr(widget, "delete"):
                widget.delete("sel.first", "sel.last")

        except Exception as e:
            print(f"Error deleting text after cut: {e}")

    def _paste_text(self):
        widget = self.master.focus_get()
        if hasattr(widget, "insert"):
            try:
                text = self.master.clipboard_get()
                if hasattr(widget, "selection_present") and widget.selection_present():
                    widget.delete("sel.first", "sel.last")
                widget.insert("insert", text)
            except tk.TclError:
                pass

    def _delete_text(self):
        """Delete the selected text without copying to clipboard."""
        widget = self.master.focus_get()
        if widget is None:
            return

        has_selection = False

        if isinstance(widget, (ctk.CTkTextbox, tk.Text)):
            has_selection = bool(widget.tag_ranges("sel"))

        elif isinstance(widget, ctk.CTkEntry):
            try:
                has_selection = widget.selection_present()
            except AttributeError:
                try:
                    has_selection = widget._entry.selection_present()
                except Exception:
                    has_selection = False

        elif hasattr(widget, "selection_present"):
            try:
                has_selection = widget.selection_present()
            except Exception:
                has_selection = False

        if not has_selection:
            return

        # Delete selection directly
        try:
            if isinstance(widget, (ctk.CTkTextbox, tk.Text)):
                widget.delete("sel.first", "sel.last")

            elif isinstance(widget, ctk.CTkEntry):
                try:
                    widget.delete("sel.first", "sel.last")
                except Exception:
                    widget._entry.delete("sel.first", "sel.last")

            elif hasattr(widget, "delete"):
                widget.delete("sel.first", "sel.last")

        except Exception as e:
            print(f"Error deleting text: {e}")

    def _copy_command_to_clipboard(self):
        try:
            command = self.command_textbox.get("1.0", "end-1c").strip()
        except Exception:
            try:
                command = " ".join(self._build_ffmpeg_command(preview=True))
            except Exception:
                return

        # break the command into words, but combine those that are clearly parts of the same path
        words = command.split()
        result = []
        i = 0

        while i < len(words):
            word = words[i]

            # if a word starts with a drive letter (C:, D:, etc.) and contains \
            if len(word) >= 2 and word[1] == ":" and "\\" in word:
                path_parts = [word]
                j = i + 1

                while j < len(words) and not words[j].startswith("-"):
                    path_parts.append(words[j])
                    j += 1

                full_path = " ".join(path_parts)

                if full_path.startswith('"') and full_path.endswith('"'):
                    full_path = full_path[1:-1]

                # spaces handling
                if " " in full_path:
                    result.append(f'"{full_path}"')
                else:
                    result.append(full_path)

                i = j
            else:
                # not a path = return as is
                result.append(word)
                i += 1

        final_command = " ".join(result)

        try:
            _set_clipboard_text(final_command)
            self.ffmpeg_output.set("Command copied to clipboard!")
        except Exception as e:
            print(f"Error setting clipboard: {e}")

    # FILTERS & OPTIONS MANAGEMENT
    def _set_speed_filter(self, speed_factor):
        try:
            speed = float(speed_factor)
            if speed <= 0:
                raise ValueError("Speed factor must be positive")

            video_filter = f"setpts={1 / speed}*PTS"
            self.additional_filter_options.set(video_filter)
            self.additional_filter_options_entry.configure(text_color=TEXT_COLOR_W)
            if self.audio_option.get() in ("disable", "copy"):
                self.audio_option.set("aac_96k")

            if self.audio_option.get() != "disable":
                audio_filter = f"atempo={speed}"
                self.additional_audio_filter_options.set(audio_filter)
                self.additional_audio_filter_options_entry.configure(
                    text_color=TEXT_COLOR_W
                )

        except ValueError as e:
            messagebox.showerror("Error", f"Invalid speed value: {e}")

    def _add_video_filter(self, filter_str):
        current_filters = self.additional_filter_options.get()
        if current_filters == self.additional_filter_options_placeholder:
            current_filters = ""

        existing_filters = [f.strip() for f in current_filters.split(",") if f.strip()]

        if filter_str in existing_filters:
            return

        if existing_filters:
            new_filters = ",".join(existing_filters + [filter_str])
        else:
            new_filters = filter_str

        self.additional_filter_options.set(new_filters)
        self.additional_filter_options_entry.configure(text_color=TEXT_COLOR_W)

    def _add_audio_filter(self, filter_str):
        if self.audio_option.get() in ("disable", "copy"):
            self.audio_option.set("aac_160k")

        current_filters = self.additional_audio_filter_options.get()
        if current_filters == self.additional_audio_filter_options_placeholder:
            current_filters = ""

        existing_filters = [f.strip() for f in current_filters.split(",") if f.strip()]

        if filter_str in existing_filters:
            return

        if existing_filters:
            new_filters = ",".join(existing_filters + [filter_str])
        else:
            new_filters = filter_str

        self.additional_audio_filter_options.set(new_filters)
        self.additional_audio_filter_options_entry.configure(text_color=TEXT_COLOR_W)

    def _add_additional_option(self, option_str):
        current_options = self.additional_options.get()

        if current_options == self.additional_options_placeholder:
            current_options = ""

        existing_options = current_options.split()

        option_name = option_str.split()[0]
        for i, opt in enumerate(existing_options):
            if opt == option_name:
                existing_options[i : i + 2] = option_str.split()
                break
        else:
            existing_options.extend(option_str.split())

        new_options = " ".join(existing_options).strip()
        self.additional_options.set(new_options)
        self.additional_options_entry.configure(text_color=TEXT_COLOR_W)

    def _clear_all_filters(self):
        self.additional_options.set("")
        self.additional_filter_options.set("")
        self.additional_audio_filter_options.set("")

        self.additional_options_entry.delete(0, "end")
        self.additional_options_entry.insert(0, self.additional_options_placeholder)
        self.additional_options_entry.configure(text_color=PLACEHOLDER_COLOR)

        self.additional_filter_options_entry.delete(0, "end")
        self.additional_filter_options_entry.insert(
            0, self.additional_filter_options_placeholder
        )
        self.additional_filter_options_entry.configure(text_color=PLACEHOLDER_COLOR)

        self.additional_audio_filter_options_entry.delete(0, "end")
        self.additional_audio_filter_options_entry.insert(
            0, self.additional_audio_filter_options_placeholder
        )
        self.additional_audio_filter_options_entry.configure(
            text_color=PLACEHOLDER_COLOR
        )

    # PLAYBACK CONTROL
    def _play_input_file(self):
        input_path = self.input_file.get()

        # Check if file is selected
        if (
            not input_path
            or input_path
            == "Drag and drop a video file here or use the 'Browse' button."
        ):
            messagebox.showerror(
                "Error", "Please select input file using Browse button"
            )
            return

        # Normalize path and check if file exists
        normalized_path = os.path.normpath(input_path)
        if not os.path.exists(normalized_path):
            messagebox.showerror("Error", "Input file does not exist")
            return

        try:
            # Open file in system default player
            os.startfile(normalized_path)
        except Exception as e:
            messagebox.showerror("Error", f"Could not play file: {str(e)}")

    def _play_output_file(self):
        output_path = self.output_file.get()

        # Check if output file is specified
        if not output_path:
            messagebox.showerror("Error", "Output file is not specified")
            return

        # Normalize path and check if file exists
        normalized_path = os.path.normpath(output_path)
        if not os.path.exists(normalized_path):
            messagebox.showerror("Error", "Output file does not exist")
            return

        try:
            # Open file in system default player
            os.startfile(normalized_path)
        except Exception as e:
            messagebox.showerror("Error", f"Could not play file: {str(e)}")

    # HELP WINDOWS & INFO
    def _show_main_help(self):
        if self.open_help_windows.get("main_help", False):
            return

        self.open_help_windows["main_help"] = True

        # Create window
        main_help_window = ctk.CTkToplevel(self.master)
        main_help_window.title("QuickFFSync Help")
        main_help_window.geometry("800x700")
        main_help_window.after(100, main_help_window.focus_force)
        main_help_window.configure(fg_color=SECONDARY_BG)

        def on_close():
            self.open_help_windows["main_help"] = False
            main_help_window.destroy()

        if os.path.exists(icon_path):
            main_help_window.after(201, lambda: main_help_window.iconbitmap(icon_path))

        main_help_window.protocol("WM_DELETE_WINDOW", on_close)

        # Tabs frame
        tabs_frame = ctk.CTkFrame(main_help_window, fg_color=SECONDARY_BG)
        tabs_frame.pack(fill="x", padx=20, pady=(20, 0))

        # Content frame
        content_frame = ctk.CTkFrame(main_help_window, fg_color=SECONDARY_BG)
        content_frame.pack(fill="both", expand=True, padx=10, pady=10)

        # Text widget
        text_frame = ctk.CTkFrame(content_frame, fg_color=PRIMARY_BG)
        text_frame.pack(fill="both", expand=True, padx=5, pady=5)

        textbox = ctk.CTkTextbox(
            text_frame,
            wrap="word",
            font=("Consolas", 14),
            fg_color=PRIMARY_BG,
            scrollbar_button_color=HOVER_BLUE,
            scrollbar_button_hover_color=ACCENT_BLUE,
        )
        textbox.pack(fill="both", expand=True, padx=5, pady=5)
        textbox.tag_config("heading_color", foreground=ACCENT_BLUE)

        # Tab management
        tabs = [
            ("Manual", "manual", "qff-help.txt"),
            ("About", "about", "qff-about.txt"),
            ("License", "license", "qff-license.txt"),
        ]

        tab_buttons = {}
        current_tab = ctk.StringVar(value="manual")

        def switch_tab(tab_name):
            current_tab.set(tab_name)
            load_tab_content(tab_name)

            # Update all button colors
            for name, btn in tab_buttons.items():
                if name == tab_name:
                    btn.configure(
                        fg_color=ACCENT_BLUE,
                        hover_color=HOVER_BLUE,
                        text_color=TEXT_COLOR_B,
                    )
                else:
                    btn.configure(
                        fg_color=ACCENT_DEEPBLUE,
                        hover_color=HOVER_DEEPBLUE,
                        text_color=TEXT_COLOR_W,
                    )

        def load_tab_content(tab_name):
            textbox.configure(state="normal")
            textbox.delete("1.0", "end")

            # Get file path
            if getattr(sys, "frozen", False):
                base_path = os.path.dirname(sys.executable)
            else:
                base_path = os.path.dirname(os.path.abspath(__file__))
            file_name = next(tab[2] for tab in tabs if tab[1] == tab_name)
            file_path = os.path.join(base_path, file_name)

            try:
                with open(file_path, "r", encoding="utf-8") as f:
                    content = f.read()

                if tab_name == "manual":
                    # Parse headings for manual tab
                    lines = content.split("\n")
                    for line in lines:
                        if line.startswith("#"):
                            textbox.insert("end", line[1:] + "\n", "heading_color")
                        else:
                            textbox.insert("end", line + "\n")
                else:
                    textbox.insert("end", content)

            except Exception as e:
                textbox.insert("end", f"File not found: {file_path}\nError: {str(e)}")

            textbox.configure(state="disabled")

        # Create tab buttons
        for tab_name, tab_id, _ in tabs:
            btn = ctk.CTkButton(
                tabs_frame,
                text=tab_name,
                command=lambda id=tab_id: switch_tab(id),
                fg_color=ACCENT_DEEPBLUE,
                hover_color=HOVER_DEEPBLUE,
                text_color=TEXT_COLOR_W,
                width=106,
            )
            btn.pack(side="left", padx=(0, 5))
            tab_buttons[tab_id] = btn

        # Close button
        close_btn = ctk.CTkButton(
            content_frame,
            text="Close",
            command=on_close,
            fg_color=ACCENT_DEEPBLUE,
            hover_color=HOVER_DEEPBLUE,
            text_color=TEXT_COLOR_W,
        )
        close_btn.pack(pady=10)

        # Show initial tab
        switch_tab("manual")

    def _show_help_window(self, title, help_type):
        if self.open_help_windows.get(help_type, False):
            return

        self.open_help_windows[help_type] = True

        help_window = ctk.CTkToplevel(self.master)
        help_window.title(title)
        help_window.geometry("800x600")
        help_window.after(100, help_window.focus_force)
        help_window.configure(
            fg_color=SECONDARY_BG,
        )

        def on_close():
            self.open_help_windows[help_type] = False
            help_window.destroy()

        if os.path.exists(icon_path):
            help_window.after(201, lambda: help_window.iconbitmap(icon_path))
        else:
            print(f"icon not found: {icon_path}")

        help_window.protocol("WM_DELETE_WINDOW", on_close)

        content_frame = ctk.CTkFrame(help_window, fg_color=SECONDARY_BG)
        content_frame.pack(fill="both", expand=True, padx=10, pady=10)

        text_scroll = ctk.CTkScrollableFrame(
            content_frame,
            fg_color=PRIMARY_BG,
            scrollbar_button_color=HOVER_BLUE,
            scrollbar_button_hover_color=ACCENT_BLUE,
        )
        text_scroll.pack(fill="both", expand=True, padx=5, pady=5)

        help_text = ctk.CTkLabel(
            text_scroll,
            text="Loading help information...",
            justify="left",
            anchor="nw",
            font=("Consolas", 14),
        )
        help_text.pack(fill="both", expand=True, padx=10, pady=10)

        close_btn = ctk.CTkButton(
            content_frame,
            text="Close",
            command=on_close,
            fg_color=ACCENT_DEEPBLUE,
            hover_color=HOVER_DEEPBLUE,
            text_color=TEXT_COLOR_W,
        )
        close_btn.pack(pady=10)

        Thread(
            target=self._fetch_help_info,
            args=(help_type, help_text, help_window),
            daemon=True,
        ).start()

    def _fetch_help_info(self, help_type, text_widget, window):
        try:
            if help_type == "encoder":
                encoder_name = (
                    "h264_qsv"
                    if self.video_codec.get() == "h264"
                    else (
                        "hevc_qsv"
                        if self.video_codec.get() == "hevc"
                        else (
                            "av1_qsv" if self.video_codec.get() == "av1" else "vp9_qsv"
                        )
                    )
                )
                cmd = [self.ffmpeg_path, "-h", f"encoder={encoder_name}"]
            elif help_type == "filters":
                cmd = [self.ffmpeg_path, "-filters"]
            else:
                cmd = [self.ffmpeg_path, "-h"]

            startupinfo = None
            if os.name == "nt":
                startupinfo = subprocess.STARTUPINFO()
                startupinfo.dwFlags |= subprocess.STARTF_USESHOWWINDOW
                startupinfo.wShowWindow = subprocess.SW_HIDE
            result = subprocess.run(
                cmd,
                capture_output=True,
                text=True,
                encoding="utf-8",
                errors="replace",
                startupinfo=startupinfo,
                creationflags=subprocess.CREATE_NO_WINDOW if os.name == "nt" else 0,
            )
            output = result.stdout or result.stderr
            window.after(0, lambda: text_widget.configure(text=output))
        except Exception as e:
            error_msg = f"Error retrieving help information:\n{str(e)}"
            window.after(0, lambda: text_widget.configure(text=error_msg))

    def _set_stereo_out(self):
        self._add_additional_option("-ac 2")
        self.audio_option.set("aac_160k")

    # SHUTDOWN & CLEANUP
    def _kill_our_ffmpeg_processes(self):
        """Synchronous version: terminate only ffmpeg.exe matching self.ffmpeg_path."""
        if not self.ffmpeg_path:
            return

        target_path = os.path.normpath(self.ffmpeg_path).lower()
        kernel32 = ctypes.windll.kernel32
        pids_to_kill = []
        h_snapshot = None

        try:
            h_snapshot = kernel32.CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0)
            if h_snapshot in (0, -1, None):
                return

            pe32 = PROCESSENTRY32W()
            pe32.dwSize = ctypes.sizeof(PROCESSENTRY32W)

            if not kernel32.Process32FirstW(h_snapshot, ctypes.byref(pe32)):
                return

            while True:
                if pe32.szExeFile.lower() == "ffmpeg.exe":
                    h_process = kernel32.OpenProcess(
                        PROCESS_QUERY_INFORMATION | PROCESS_VM_READ,
                        False,
                        pe32.th32ProcessID,
                    )
                    if h_process:
                        exe_path = ctypes.create_unicode_buffer(260)
                        size = ctypes.c_uint(260)
                        if kernel32.QueryFullProcessImageNameW(
                            h_process, 0, exe_path, ctypes.byref(size)
                        ):
                            current_path = os.path.normpath(exe_path.value).lower()
                            if current_path == target_path:
                                pids_to_kill.append(pe32.th32ProcessID)
                        kernel32.CloseHandle(h_process)

                if not kernel32.Process32NextW(h_snapshot, ctypes.byref(pe32)):
                    break

        except Exception:
            return
        finally:
            if h_snapshot and h_snapshot not in (0, -1):
                kernel32.CloseHandle(h_snapshot)

        for pid in pids_to_kill:
            h_process = None
            try:
                h_process = kernel32.OpenProcess(PROCESS_TERMINATE, False, pid)
                if h_process:
                    kernel32.TerminateProcess(h_process, 0)
            except Exception:
                pass
            finally:
                if h_process:
                    kernel32.CloseHandle(h_process)

    def _open_map_window(self):
        """Open a window to visually select streams for mapping"""
        if self.map_window and self.map_window.winfo_exists():
            self.map_window.lift()
            self.map_window.focus_force()
            return

        input_file = self.input_file.get()
        if not input_file or input_file.startswith("Drag and drop"):
            messagebox.showwarning("Warning", "Please select an input file first.")
            return

        if not os.path.exists(input_file):
            messagebox.showwarning("Error", "Input file does not exist.")
            return

        if not self.ffprobe_path:
            messagebox.showerror("Error", "ffprobe.exe not found.")
            return

        # Show map window
        self.map_window = self._create_stream_map_window(input_file)

    def _create_stream_map_window(self, input_file):
        """Create and show the stream selection window"""
        map_window = ctk.CTkToplevel(self.master)
        map_window.title(f"Stream Selection - {os.path.basename(input_file)}")
        map_window.geometry("600x600")
        map_window.minsize(600, 550)

        # Center relative to parent
        self.master.update_idletasks()
        x = self.master.winfo_x() + (self.master.winfo_width() - 600) // 2
        y = self.master.winfo_y() + (self.master.winfo_height() - 600) // 2
        map_window.geometry(f"+{x}+{y}")
        map_window.configure(fg_color=SECONDARY_BG)

        # Ensure window is on top without blocking
        map_window.after(100, map_window.lift)
        map_window.after(110, map_window.focus_force)

        # Set window icon
        icon_path = get_icon_path()
        if os.path.exists(icon_path):
            map_window.after(200, lambda: map_window.iconbitmap(icon_path))

        # Main frame
        main_frame = ctk.CTkFrame(map_window, fg_color=SECONDARY_BG)
        main_frame.pack(fill="both", expand=True, padx=20, pady=20)

        header_label = ctk.CTkLabel(
            main_frame,
            text="Select streams to include in the output file:",
            font=("Segoe UI", 16),
            text_color=TEXT_COLOR_W,
        )
        header_label.pack(pady=(0, 10))

        # Scrollable area for checkboxes
        scroll_frame = ctk.CTkScrollableFrame(
            main_frame,
            fg_color=PRIMARY_BG,
            scrollbar_button_color=HOVER_BLUE,
            scrollbar_button_hover_color=ACCENT_BLUE,
        )
        scroll_frame.pack(fill="both", expand=True, pady=(0, 10))

        # Dictionary to store checkboxes: {idx: {"var": var, "map_code": map_code}}
        stream_vars = {}

        def add_stream_section(title, streams):
            if not streams:
                return

            section_label = ctk.CTkLabel(
                scroll_frame,
                text=title,
                font=("Segoe UI", 13),
                text_color=TEXT_COLOR_W,
            )
            section_label.pack(anchor="w", pady=(10, 5), padx=10)

            for s in streams:
                idx = s["index"]
                label_text = s["text"]
                map_code = s["map_code"]

                # Restore previous selection if available for this file
                saved_selection = self.map_selection_cache.get(input_file, {})
                default_val = saved_selection.get(idx, True)

                var = ctk.BooleanVar(value=default_val)
                stream_vars[idx] = {"var": var, "map_code": map_code}

                cb = ctk.CTkCheckBox(
                    scroll_frame,
                    text=label_text,
                    variable=var,
                    font=("Segoe UI", 13),
                    fg_color=ACCENT_BLUE,
                    hover_color=HOVER_BLUE,
                    text_color=TEXT_COLOR_W,
                )
                cb.pack(anchor="w", padx=25, pady=2)

        loading_label = ctk.CTkLabel(
            scroll_frame,
            text="Analyzing file, please wait...",
            font=("Segoe UI", 13),
            text_color=ACCENT_BLUE,
        )
        loading_label.pack(pady=40)

        def fetch_and_populate():
            try:
                cmd = [self.ffprobe_path, "-hide_banner", input_file]
                result = subprocess.run(
                    cmd,
                    capture_output=True,
                    text=True,
                    encoding="utf-8",
                    errors="replace",
                    creationflags=subprocess.CREATE_NO_WINDOW if os.name == "nt" else 0,
                )

                # ffprobe output is in stderr for standard info
                output = result.stderr or result.stdout

                v_streams = []
                p_streams = []
                a_streams = []
                s_streams = []

                v_count = 0
                a_count = 0
                s_count = 0

                # Robust regex to handle technical IDs like [0x1], languages (und), etc.
                stream_pattern = compile(
                    r"Stream #0:(\d+)(.*?)\s*:\s*(Video|Audio|Subtitle)\s*:\s*(.*)",
                    IGNORECASE,
                )

                for line in output.splitlines():
                    match = stream_pattern.search(line)
                    if match:
                        idx = int(match.group(1))
                        extra = match.group(2).strip()
                        s_type = match.group(3).capitalize()
                        desc = match.group(4).strip()

                        full_text = f"Stream #{idx}{extra}: {desc}"

                        if s_type == "Video":
                            map_code = f"0:v:{v_count}"
                            v_count += 1
                            if "attached pic" in desc.lower():
                                p_streams.append(
                                    {
                                        "index": idx,
                                        "text": full_text,
                                        "map_code": map_code,
                                    }
                                )
                            else:
                                v_streams.append(
                                    {
                                        "index": idx,
                                        "text": full_text,
                                        "map_code": map_code,
                                    }
                                )
                        elif s_type == "Audio":
                            map_code = f"0:a:{a_count}"
                            a_count += 1
                            a_streams.append(
                                {"index": idx, "text": full_text, "map_code": map_code}
                            )
                        elif s_type == "Subtitle":
                            map_code = f"0:s:{s_count}"
                            s_count += 1
                            s_streams.append(
                                {"index": idx, "text": full_text, "map_code": map_code}
                            )

                def update_ui():
                    if loading_label.winfo_exists():
                        loading_label.destroy()

                    if not (v_streams or a_streams or s_streams or p_streams):
                        error_label = ctk.CTkLabel(
                            scroll_frame,
                            text="No streams found or error parsing output",
                            text_color=ACCENT_RED,
                        )
                        error_label.pack(pady=20)
                    else:
                        add_stream_section("Video", v_streams)
                        add_stream_section("Audio", a_streams)
                        add_stream_section("Subtitle", s_streams)
                        add_stream_section("Pictures", p_streams)

                    # Enable buttons now that streams are loaded
                    apply_btn.configure(state="normal")
                    check_btn.configure(state="normal")
                    uncheck_btn.configure(state="normal")

                map_window.after(0, update_ui)

            except Exception as e:

                def show_error():
                    if loading_label.winfo_exists():
                        loading_label.destroy()
                    error_label = ctk.CTkLabel(
                        scroll_frame, text=f"Error: {str(e)}", text_color=ACCENT_RED
                    )
                    error_label.pack(pady=20)

                map_window.after(0, show_error)

        # Buttons frame
        btn_frame = ctk.CTkFrame(main_frame, fg_color="transparent")
        btn_frame.pack(fill="x", pady=(0, 5))

        def save_selection():
            self.map_selection_cache[input_file] = {
                idx: data["var"].get() for idx, data in stream_vars.items()
            }

        def apply_map():
            selected_vars = [data["var"].get() for data in stream_vars.values()]
            all_selected = all(selected_vars)

            if not any(selected_vars):
                messagebox.showwarning(
                    "Warning", "At least one stream must be selected."
                )
                return

            save_selection()

            current_options = self.additional_options.get()
            if current_options == self.additional_options_placeholder:
                current_options = ""

            # Remove old -map and -ignore_unknown
            cleaned_options = sub(r"-map\s+\S+", "", current_options)
            cleaned_options = sub(r"-ignore_unknown\s*", "", cleaned_options).strip()

            if all_selected:
                # If everything is selected, we don't need explicit -map 0:x
                # FFmpeg's default or our default _build_ffmpeg_command logic will handle it
                new_options = cleaned_options
            else:
                selected_codes = [
                    data["map_code"]
                    for data in stream_vars.values()
                    if data["var"].get()
                ]
                map_str = "-ignore_unknown " + " ".join(
                    [f"-map {code}" for code in selected_codes]
                )
                new_options = f"{cleaned_options} {map_str}".strip()

            if not new_options:
                self.additional_options.set(self.additional_options_placeholder)
                self.additional_options_entry.configure(text_color=PLACEHOLDER_COLOR)
            else:
                self.additional_options.set(new_options)
                self.additional_options_entry.configure(text_color=TEXT_COLOR_W)

            self.map_window = None
            map_window.destroy()

        def on_close():
            if stream_vars:
                save_selection()
            self.map_window = None
            map_window.destroy()

        def check_all():
            for data in stream_vars.values():
                data["var"].set(True)

        def uncheck_all():
            for data in stream_vars.values():
                data["var"].set(False)

        apply_btn = ctk.CTkButton(
            btn_frame,
            text="Apply",
            command=apply_map,
            fg_color=ACCENT_BLUE,
            hover_color=HOVER_BLUE,
            text_color=TEXT_COLOR_B,
            state="disabled",
        )
        apply_btn.pack(side="left", expand=True, fill="x", padx=(0, 5))

        check_btn = ctk.CTkButton(
            btn_frame,
            text="Check All",
            command=check_all,
            fg_color=ACCENT_DEEPBLUE,
            hover_color=HOVER_DEEPBLUE,
            text_color=TEXT_COLOR_W,
            state="disabled",
        )
        check_btn.pack(side="left", expand=True, fill="x", padx=(0, 5))

        uncheck_btn = ctk.CTkButton(
            btn_frame,
            text="Uncheck All",
            command=uncheck_all,
            fg_color=ACCENT_DEEPBLUE,
            hover_color=HOVER_DEEPBLUE,
            text_color=TEXT_COLOR_W,
            state="disabled",
        )
        uncheck_btn.pack(side="left", expand=True, fill="x", padx=(0, 5))

        close_btn = ctk.CTkButton(
            btn_frame,
            text="Close",
            command=on_close,
            fg_color=ACCENT_DEEPBLUE,
            hover_color=HOVER_DEEPBLUE,
            text_color=TEXT_COLOR_W,
        )
        close_btn.pack(side="left", expand=True, fill="x")

        # Start analysis in background thread now that everything is initialized
        Thread(target=fetch_and_populate, daemon=True).start()

        map_window.protocol("WM_DELETE_WINDOW", on_close)
        map_window.lift()
        map_window.focus_force()
        return map_window

    def _on_close(self):
        """Application close handler"""

        # Terminate all active FFmpeg processes to prevent zombie processes
        if getattr(self, "is_recording", False):
            self._stop_recording()

        if getattr(self, "is_converting", False):
            self._cancel_conversion()

        if getattr(self, "is_creating_preview", False):
            self._cancel_preview()

        if getattr(self, "_vmaf_running", False):
            self._cancel_vmaf()

        # Clean up temporary preview files
        self._cleanup_preview_files()

        # Clear batch files list
        self.batch_files = []

        # Save current settings
        self._save_settings()

        # Clean up tray icon if it was created
        if hasattr(self, "_tray_icon") and self._tray_icon:
            self._tray_icon.destroy()
            self._tray_icon = None

        # Properly release Windows API resources for Drag-and-Drop
        if hasattr(self, "drop_target") and getattr(self, "drop_target", None):
            self.drop_target.cleanup()

        # Kill only our ffmpeg.exe processes
        self._kill_our_ffmpeg_processes()

        # Close the application
        self.master.quit()


icon_path = get_icon_path()
root = ctk.CTk()
app = VideoConverterApp(root)
# ctk.deactivate_automatic_dpi_awareness()
if os.path.exists(icon_path):
    root.after(201, lambda: root.iconbitmap(icon_path))
else:
    print(f"icon not found: {icon_path}")

root.protocol("WM_DELETE_WINDOW", app._on_close)
root.mainloop()