main.py

"""
main.py

Disc Track Splitter - GUI entry point (v2.0 - three-pane dashboard).

Workflow:
    1. Pick (or watch) a folder containing a ripped Blu-ray disc structure
       (BDMV/PLAYLIST/*.mpls).
    2. Scan playlists, auto-select the best candidate (an Atmos track if
       the disc has one, based on the same scoring as before).
    3. Choose which audio track to keep - Atmos is pre-selected when
       present, otherwise the best lossless option is, but every track
       the playlist actually has (LPCM, DTS-HD MA, TrueHD, in whatever
       channel layouts/sample rates the disc offers) is listed and can be
       picked instead.
    4. Enter/paste song names for each chapter.
    5. Extract the chosen audio track + split into individually named files.

Layout note (v2.0): the window is a three-pane dashboard -
  Pane 1 (top-left card):  Source & Configuration - disc folder, playlist
                            pick, and audio track pick (this app's closest
                            equivalent to a "format" choice, since it
                            stream-copies rather than re-encoding).
  Pane 2 (top-right card): Track List & Naming - the four naming methods
                            plus the scrollable chapter table.
  Pane 3 (bottom card):    Execution & Progress - output folder, the
                            Extract/Cancel/Open Log controls, an
                            indeterminate progress bar while a job runs,
                            and a compact rolling status log.
All structural layout uses .grid() exclusively. This file only changes
presentation - every method that talks to extractor.py/settings.py is
unchanged from the previous version.
"""

from __future__ import annotations

import os
import re
import shutil
import threading
import tkinter as tk
import tkinter.filedialog as filedialog
import tkinter.messagebox as messagebox
import webbrowser
from pathlib import Path
from typing import Callable

import customtkinter as ctk

import extractor
import settings

ctk.set_appearance_mode("dark")
ctk.set_default_color_theme("blue")

# ---------------------------------------------------------------------------
# Style constants (Section 2 of the brief: global styling & layout rules)
# ---------------------------------------------------------------------------

PAD_SMALL = 5
PAD_MED = 12
PAD_LARGE = 20

COLOR_BG = "#1A1A1A"          # deep charcoal window background
COLOR_CARD = "#2B2B2B"        # lighter card overlay for each pane
COLOR_CARD_INSET = "#232323"  # slightly recessed box inside a card (e.g. the track picker box)
COLOR_BLUE = "#1F6AA5"        # focus / informational accent
COLOR_BLUE_HOVER = "#17527f"
COLOR_GREEN = "#2EA043"       # primary action accent
COLOR_GREEN_HOVER = "#268239"
COLOR_DANGER = "#a33"
COLOR_DANGER_HOVER = "#822"
COLOR_NEUTRAL = "#3a3a3a"
COLOR_NEUTRAL_HOVER = "#4a4a4a"
COLOR_INVALID_BORDER = "#e5484d"
COLOR_TEXT_MUTED = "gray70"

FONT_FAMILY = "Segoe UI"
FONT_TITLE = (FONT_FAMILY, 16, "bold")
FONT_HEADER = (FONT_FAMILY, 13, "normal")
FONT_BODY = (FONT_FAMILY, 11, "normal")


def enable_clipboard(
    widget: ctk.CTkEntry | ctk.CTkTextbox, on_change: "Callable[[], None] | None" = None
) -> None:
    """
    customtkinter's Entry/Textbox widgets don't reliably inherit the OS's
    default copy/cut/paste keyboard or right-click behaviour on every
    platform/version. This adds both explicitly so Ctrl+V and right-click
    -> Paste always work.

    on_change: if given, called (with a short delay so the widget's own
    insert/delete has already landed) after a paste or cut actually
    changes this widget's content. Used so pasting a tracklist auto-fills
    the chapter table without a separate "Fill" click, without this
    generic clipboard helper needing to know anything about that.
    """
    # The actual tkinter widget underneath is .entry for CTkEntry-like
    # widgets, or the CTkTextbox itself acts as a Text widget directly.
    target = getattr(widget, "_entry", None) or getattr(widget, "_textbox", None) or widget

    def _notify_change() -> None:
        if on_change is not None:
            widget.after(10, on_change)

    def paste(_event=None) -> str:
        try:
            clipboard_text = widget.clipboard_get()
        except tk.TclError:
            return "break"
        try:
            if isinstance(widget, ctk.CTkTextbox):
                widget.insert("insert", clipboard_text)
            else:
                widget.insert("insert", clipboard_text)
        except Exception:
            pass
        _notify_change()
        return "break"

    def copy(_event=None) -> str:
        try:
            if isinstance(widget, ctk.CTkTextbox):
                selected = widget.get("sel.first", "sel.last")
            else:
                selected = widget.get()
            widget.clipboard_clear()
            widget.clipboard_append(selected)
        except Exception:
            pass
        return "break"

    def cut(_event=None) -> str:
        copy(_event)
        try:
            if isinstance(widget, ctk.CTkTextbox):
                widget.delete("sel.first", "sel.last")
            else:
                widget.delete(0, "end")
        except Exception:
            pass
        _notify_change()
        return "break"

    def select_all(_event=None) -> str:
        try:
            if isinstance(widget, ctk.CTkTextbox):
                widget.tag_add("sel", "1.0", "end")
            else:
                widget.select_range(0, "end")
        except Exception:
            pass
        return "break"

    for seq in ("<Control-v>", "<Control-V>"):
        widget.bind(seq, paste)
    for seq in ("<Control-c>", "<Control-C>"):
        widget.bind(seq, copy)
    for seq in ("<Control-x>", "<Control-X>"):
        widget.bind(seq, cut)
    for seq in ("<Control-a>", "<Control-A>"):
        widget.bind(seq, select_all)

    menu = tk.Menu(widget, tearoff=0)
    menu.add_command(label="Cut", command=cut)
    menu.add_command(label="Copy", command=copy)
    menu.add_command(label="Paste", command=paste)
    menu.add_separator()
    menu.add_command(label="Select All", command=select_all)

    def show_menu(event) -> None:
        try:
            widget.focus_set()
            menu.tk_popup(event.x_root, event.y_root)
        finally:
            menu.grab_release()

    widget.bind("<Button-3>", show_menu)


REPO_URL = "https://github.com/quinnuk/DiscTrackSplitter"

HELP_TEXT = """DISC TRACK SPLITTER - TIPS & TROUBLESHOOTING

WORKFLOW
1. Point the source field at a folder containing a ripped Blu-ray disc
   (it needs the standard BDMV/PLAYLIST/*.mpls structure - not a
   flattened single MKV), by typing/pasting the path, hitting Enter, or
   using Browse. It scans automatically - no Scan button needed.
2. The app inspects every playlist and ranks them by likelihood of
   being "the" concert/album feature - has an Atmos track, has
   chapters, includes video, sensible duration. If there's only one
   plausible candidate it's picked automatically and the reasoning is
   shown right there; the playlist dropdown only appears when two or
   more candidates are genuinely close enough to be worth choosing
   between yourself.
3. Pick which audio track to keep. If the playlist has a Dolby Atmos
   track it's pre-selected automatically (matching the old behaviour);
   otherwise the best lossless option is pre-selected. Every audio
   track the playlist actually has - different codecs, channel layouts
   (2.0/5.1/7.1), sample rates, whatever the disc offers - is listed in
   the dropdown with its codec, channels, bitrate, and bit depth, so you
   can pick a different one if you'd rather have, say, the 2.0 mix
   instead of 5.1, or LPCM instead of DTS-HD MA.
4. Name each chapter, using whichever of the four methods below suits
   the disc, then click Extract & Split.

NAMING CHAPTERS - FOUR WAYS
- From disc: if the playlist has chapter names embedded on it, they're
  filled in automatically as soon as you select the playlist - no
  button needed. The "from disc" tag next to a field shows this
  happened; it flips to "edited" if you change that name yourself.
- Paste: paste a plain tracklist (one song per line, in the same order
  as the chapters) into the box - it fills the chapter fields
  automatically as you type or paste, no button to click. Leading
  numbering like "1." or "01 -" is stripped automatically.
- Import Tracklist...: reads a tracklist file. Handles plain .txt,
  .cue, .json, and disc-meta .nfo files. If the app found candidate
  files sitting in the disc folder (BDInfo.txt, Track Listing.txt,
  bdmt_*.xml etc), it'll mention them - these usually came bundled
  with the rip and are normally exactly the right tracklist.
- Search Online...: looks up the album on MusicBrainz, by artist/album
  text or by the disc's barcode (the UPC/EAN under the barcode lines on
  the case). The barcode identifies the exact edition, so it's worth
  using instead of artist/album when a release has multiple regional
  pressings or reissues with different bonus tracks. Good for
  well-known standard releases either way. LIMITED/BOUTIQUE EDITIONS
  (small-run audiophile Blu-ray Pure Audio / Surround Series discs,
  mail-order exclusives, etc) are very often missing from MusicBrainz
  entirely, or only the parent CD/digital release is indexed - if the
  track count shown looks nothing like your chapter count, that's the
  usual reason. Import Tracklist is more reliable for that kind of disc.

Whichever method you use, nothing is applied until you review and
accept the proposed matches - matched chapters are pre-checked,
mismatched/unmatched ones are left for you to decide.

COMMON ERRORS
- "mkvextract failed" / "Could not read chapters": usually means the
  selected file wasn't readable as-is (e.g. a corrupted or incomplete
  rip). Try re-scanning, or check the file plays correctly elsewhere.
- "X output file(s) already exist": the app never overwrites existing
  files silently - you'll be asked to confirm before anything in the
  output folder gets replaced.
- Tool not found on startup: mkvmerge, mkvextract, ffmpeg, and ffprobe
  all need to be installed and reachable - either on your system PATH,
  or pointed at directly via the Browse button in that dialog. MKVToolNix
  provides mkvmerge/mkvextract together; ffmpeg provides ffmpeg/ffprobe
  together, so locating one usually finds its pair automatically too.

IF AN EXTRACTION IS INTERRUPTED
If the app is closed, crashes, or a job is cancelled partway through,
just select the same source and output folders and click
Extract & Split again. The app detects the in-progress manifest in
the work folder and offers to resume exactly where it left off -
skipping the extraction step entirely if it already finished, and
skipping any chapters that were already split.
For advanced/manual recovery (e.g. the manifest was deleted, or
extraction finished but you want different track names), the
intermediate _audio_extracted.mkv is left in the work folder and can
be split directly from the command line with split_now.py - see the
README for the exact syntax.

SETTINGS & LOGS
Tool paths and last-used folders are remembered in
%USERPROFILE%\\.disc_track_splitter\\settings.json. Use "Open Log"
during/after a run to see exactly what each external tool was told to
do - the most useful thing to include if you're reporting a bug.

MORE HELP
Full README, known limitations, and issue tracker: see the other items
on this Help menu.
"""


class DiscTrackSplitterApp(ctk.CTk):
    def __init__(self) -> None:
        super().__init__()

        self.title("Disc Track Splitter")
        self.geometry("1180x760")
        self.minsize(980, 640)
        self.resizable(True, True)
        try:
            self.configure(fg_color=COLOR_BG)
        except Exception:
            pass

        self.cfg = settings.load()
        self.playlists: list[extractor.Playlist] = []
        self.playlist_scores: list[extractor.PlaylistScore] = []
        self.selected_playlist: extractor.Playlist | None = None
        self.selected_playlist_score: extractor.PlaylistScore | None = None
        self.selected_audio_track: extractor.Track | None = None
        self.selected_playlist_chapters: list[extractor.Chapter] = []
        self.disc_folder: Path | None = None
        self.chapter_name_vars: dict[int, ctk.StringVar] = {}
        self.chapter_source_labels: dict[int, ctk.CTkLabel] = {}
        self.chapter_duration_labels: dict[int, ctk.CTkLabel] = {}
        self.cancel_event: threading.Event | None = None
        self.current_log_path: Path | None = None
        self._resumable_manifest: extractor.JobManifest | None = None
        self._resumable_work_folder: Path | None = None
        self._source_debounce_id: str | None = None
        self._paste_debounce_id: str | None = None
        self._last_scanned_folder: Path | None = None
        self.output_var = ctk.StringVar(value=self.cfg.get("last_output_folder", ""))
        self._output_editing = not bool(self.cfg.get("last_output_folder"))

        self._apply_tool_paths()
        self._build_layout()
        self._build_menu_bar()
        self.after(200, self._check_tools_on_startup)
        self.after(200, self._refresh_resume_banner)

    def _apply_tool_paths(self) -> None:
        """
        Push any custom tool paths from settings.json into extractor.py.
        Without this, a custom mkvmerge_path/ffmpeg_path etc set in settings
        would be silently ignored and the bare command name used instead.
        """
        extractor.set_tool_path("mkvmerge", self.cfg.get("mkvmerge_path", "mkvmerge"))
        extractor.set_tool_path("mkvextract", self.cfg.get("mkvextract_path", "mkvextract"))
        extractor.set_tool_path("ffmpeg", self.cfg.get("ffmpeg_path", "ffmpeg"))
        extractor.set_tool_path("ffprobe", self.cfg.get("ffprobe_path", "ffprobe"))

    def _check_tools_on_startup(self) -> None:
        found = extractor.check_tools()
        missing = [name for name, ok in found.items() if not ok]
        if missing:
            self._show_missing_tools_dialog(missing)

    def _show_missing_tools_dialog(self, missing: list[str]) -> None:
        remaining = set(missing)

        dialog = ctk.CTkToplevel(self)
        dialog.title("Missing required tools")
        dialog.geometry("560x380")
        dialog.transient(self)
        dialog.grab_set()
        try:
            dialog.configure(fg_color=COLOR_BG)
        except Exception:
            pass
        dialog.grid_columnconfigure(0, weight=1)

        heading = ctk.CTkLabel(
            dialog,
            text="These required tools weren't found on your PATH:",
            font=(FONT_FAMILY, 12, "bold"),
            wraplength=500,
            justify="left",
        )
        heading.grid(row=0, column=0, sticky="w", padx=PAD_LARGE, pady=(PAD_LARGE, PAD_MED))

        rows_frame = ctk.CTkFrame(dialog, fg_color=COLOR_CARD, corner_radius=8)
        rows_frame.grid(row=1, column=0, sticky="ew", padx=PAD_LARGE)
        rows_frame.grid_columnconfigure(1, weight=1)

        row_widgets: dict[str, dict] = {}

        def mark_resolved(name: str, version_text: str) -> None:
            remaining.discard(name)
            widgets = row_widgets[name]
            widgets["status"].configure(text=f"OK ({version_text})", text_color=COLOR_GREEN)
            widgets["browse_btn"].configure(state="disabled")
            widgets["download_btn"].configure(state="disabled")
            if not remaining:
                heading.configure(text="All required tools are now available.")

        def browse_for(name: str) -> None:
            path_str = filedialog.askopenfilename(
                title=f"Locate {name}",
                filetypes=[
                    ("Executable", "*.exe"),
                    ("All files", "*.*"),
                ],
            )
            if not path_str:
                return

            ok, message = extractor.verify_tool_at_path(path_str, name)
            if not ok:
                messagebox.showerror(
                    "Not a working tool",
                    f"This doesn't look like a working {name}:\n\n{message}",
                    parent=dialog,
                )
                return

            extractor.set_tool_path(name, path_str)
            settings.update(**{f"{name}_path": path_str})
            mark_resolved(name, message)
            self.set_status(f"Using {name} at {path_str}")

            # ffmpeg/ffprobe and mkvmerge/mkvextract always ship together in
            # the same folder - if the other half of this pair is also
            # still missing, check right there before asking the user to
            # browse a second time for what's really one install.
            sibling_name = extractor.SIBLING_TOOL_NAMES.get(name)
            sibling_path = extractor.guess_sibling_tool_path(path_str, name)
            if sibling_path and sibling_name and sibling_name in remaining:
                sib_ok, sib_message = extractor.verify_tool_at_path(sibling_path, sibling_name)
                if sib_ok:
                    extractor.set_tool_path(sibling_name, sibling_path)
                    settings.update(**{f"{sibling_name}_path": sibling_path})
                    mark_resolved(sibling_name, sib_message)
                    self.set_status(f"Also found {sibling_name} alongside it at {sibling_path}")

        for i, name in enumerate(missing):
            row = ctk.CTkFrame(rows_frame, fg_color="transparent")
            row.grid(row=i, column=0, columnspan=4, sticky="ew", padx=PAD_SMALL, pady=PAD_SMALL)
            row.grid_columnconfigure(1, weight=1)

            ctk.CTkLabel(row, text=f"\u2022  {name}", width=110, anchor="w", font=FONT_BODY).grid(
                row=0, column=0, sticky="w"
            )

            status_label = ctk.CTkLabel(
                row, text="not found", anchor="w", text_color="gray60", font=FONT_BODY
            )
            status_label.grid(row=0, column=1, sticky="w", padx=(8, 8))

            url = extractor.TOOL_DOWNLOAD_URLS.get(name, "")
            download_btn = ctk.CTkButton(
                row, text="Download", width=90, font=FONT_BODY,
                fg_color=COLOR_NEUTRAL, hover_color=COLOR_NEUTRAL_HOVER,
                command=lambda u=url: webbrowser.open(u),
            )
            download_btn.grid(row=0, column=2, padx=(0, 4))

            browse_btn = ctk.CTkButton(
                row, text="Browse...", width=90, font=FONT_BODY,
                command=lambda n=name: browse_for(n),
            )
            browse_btn.grid(row=0, column=3)

            row_widgets[name] = {
                "status": status_label, "browse_btn": browse_btn, "download_btn": download_btn,
            }

        ctk.CTkLabel(
            dialog,
            text=(
                "Already have these installed? Click Browse and point at the "
                "actual .exe - it's checked and saved automatically, no need "
                "to edit settings.json by hand. Otherwise, install and make "
                "sure they're on your system PATH, then restart the app."
            ),
            wraplength=500,
            justify="left",
            font=FONT_BODY,
            text_color=COLOR_TEXT_MUTED,
        ).grid(row=2, column=0, sticky="w", padx=PAD_LARGE, pady=(PAD_MED, PAD_LARGE))

        ctk.CTkButton(dialog, text="Continue anyway", font=FONT_BODY, command=dialog.destroy).grid(
            row=3, column=0, pady=(0, PAD_LARGE)
        )

    # ------------------------------------------------------------------
    # Help menu
    # ------------------------------------------------------------------

    def _build_menu_bar(self) -> None:
        """
        A native Windows menu bar. customtkinter doesn't provide its own
        menu bar widget, so this uses plain tkinter's Menu directly - it
        renders as a normal top-of-window dropdown menu either way.
        Currently just a single Help menu: in-app tips/troubleshooting,
        plus links out to the README and issue tracker for anything not
        covered there.
        """
        menu_bar = tk.Menu(self)

        help_menu = tk.Menu(menu_bar, tearoff=0)
        help_menu.add_command(label="Tips & Troubleshooting", command=self._show_help_dialog)
        help_menu.add_separator()
        help_menu.add_command(
            label="View README on GitHub",
            command=lambda: webbrowser.open(f"{REPO_URL}#readme"),
        )
        help_menu.add_command(
            label="Report an Issue",
            command=lambda: webbrowser.open(f"{REPO_URL}/issues/new/choose"),
        )
        help_menu.add_separator()
        help_menu.add_command(label="About", command=self._show_about_dialog)
        menu_bar.add_cascade(label="Help", menu=help_menu)

        self.config(menu=menu_bar)

    def _show_help_dialog(self) -> None:
        dialog = ctk.CTkToplevel(self)
        dialog.title("Tips & Troubleshooting")
        dialog.geometry("640x560")
        dialog.transient(self)
        dialog.grab_set()
        try:
            dialog.configure(fg_color=COLOR_BG)
        except Exception:
            pass
        dialog.grid_columnconfigure(0, weight=1)
        dialog.grid_rowconfigure(0, weight=1)

        textbox = ctk.CTkTextbox(dialog, wrap="word", font=FONT_BODY, fg_color=COLOR_CARD)
        textbox.grid(row=0, column=0, sticky="nsew", padx=PAD_LARGE, pady=(PAD_LARGE, PAD_MED))
        textbox.insert("1.0", HELP_TEXT)
        # Left editable (rather than state="disabled") purely so normal
        # text selection/copy behaves exactly as expected on every
        # platform - nothing typed here is read back or saved anywhere,
        # so there's no real downside to it being technically editable.
        enable_clipboard(textbox)

        ctk.CTkButton(dialog, text="Close", font=FONT_BODY, command=dialog.destroy).grid(
            row=1, column=0, pady=(0, PAD_LARGE)
        )

    def _show_about_dialog(self) -> None:
        messagebox.showinfo(
            "About Disc Track Splitter",
            "Disc Track Splitter\n\n"
            "Split a ripped Blu-ray concert/music disc into individual, "
            "chapter-named song files, using whichever audio track you "
            "choose (Atmos, TrueHD, DTS-HD MA, LPCM...) - no re-encoding.\n\n"
            f"{REPO_URL}",
            parent=self,
        )

    # ------------------------------------------------------------------
    # Layout - three-pane dashboard, .grid() only
    # ------------------------------------------------------------------

    def _build_layout(self) -> None:
        self.grid_columnconfigure(0, weight=1)
        self.grid_rowconfigure(2, weight=1)  # the two-pane content row stretches

        # --- Title bar ---
        title_bar = ctk.CTkFrame(self, fg_color="transparent")
        title_bar.grid(row=0, column=0, sticky="ew", padx=PAD_LARGE, pady=(PAD_LARGE, PAD_SMALL))
        title_bar.grid_columnconfigure(0, weight=1)
        ctk.CTkLabel(title_bar, text="DiscTrackSplitter v2.0", font=FONT_TITLE).grid(
            row=0, column=0, sticky="w"
        )

        # --- Resume banner (hidden unless a paused/interrupted job is found) ---
        self.resume_banner = ctk.CTkFrame(self, fg_color=COLOR_BLUE, corner_radius=8)
        self.resume_banner.grid(row=1, column=0, sticky="ew", padx=PAD_LARGE, pady=(0, PAD_SMALL))
        self.resume_banner.grid_columnconfigure(0, weight=1)

        self.resume_banner_label = ctk.CTkLabel(
            self.resume_banner, text="", justify="left", wraplength=640, anchor="w",
            font=(FONT_FAMILY, 12, "bold"), text_color="white",
        )
        self.resume_banner_label.grid(row=0, column=0, sticky="w", padx=(PAD_MED, PAD_SMALL), pady=10)

        ctk.CTkButton(
            self.resume_banner, text="Resume Job", width=120, font=FONT_BODY,
            fg_color=COLOR_GREEN, hover_color=COLOR_GREEN_HOVER,
            command=self._resume_from_banner,
        ).grid(row=0, column=1, padx=(0, PAD_SMALL), pady=10)
        ctk.CTkButton(
            self.resume_banner, text="Discard & Start Fresh", width=180, font=FONT_BODY,
            fg_color=COLOR_DANGER, hover_color=COLOR_DANGER_HOVER,
            command=self._discard_resumable_job,
        ).grid(row=0, column=2, padx=(0, PAD_MED), pady=10)

        self.resume_banner.grid_remove()  # shown only once _refresh_resume_banner finds a job

        # --- Two-pane content row: Pane 1 (source/config) | Pane 2 (tracklist/naming) ---
        content = ctk.CTkFrame(self, fg_color="transparent")
        content.grid(row=2, column=0, sticky="nsew", padx=PAD_LARGE, pady=PAD_SMALL)
        content.grid_columnconfigure(0, weight=2)
        content.grid_columnconfigure(1, weight=3)
        content.grid_rowconfigure(0, weight=1)

        self._build_pane_source(content)
        self._build_pane_tracklist(content)

        # --- Pane 3: execution & progress (full width, bottom) ---
        self._build_pane_execution()

        # --- Status line ---
        self.status_label = ctk.CTkLabel(self, text="Ready.", anchor="w", font=FONT_BODY)
        self.status_label.grid(row=4, column=0, sticky="ew", padx=PAD_LARGE, pady=(0, PAD_LARGE))

    def _build_pane_source(self, parent: ctk.CTkFrame) -> None:
        """Pane 1 - Source & Configuration: disc folder, playlist pick, audio track pick."""
        card = ctk.CTkFrame(parent, fg_color=COLOR_CARD, corner_radius=10)
        card.grid(row=0, column=0, sticky="nsew", padx=(0, PAD_SMALL))
        card.grid_columnconfigure(0, weight=1)

        ctk.CTkLabel(card, text="Source & Configuration", font=FONT_HEADER).grid(
            row=0, column=0, sticky="w", padx=PAD_MED, pady=(PAD_MED, PAD_SMALL)
        )

        # --- Source folder row ---
        source_row = ctk.CTkFrame(card, fg_color="transparent")
        source_row.grid(row=1, column=0, sticky="ew", padx=PAD_MED, pady=PAD_SMALL)
        source_row.grid_columnconfigure(0, weight=1)

        self.source_entry = ctk.CTkEntry(
            source_row, placeholder_text="Path to ripped Blu-ray folder...", font=FONT_BODY
        )
        self.source_entry.grid(row=0, column=0, sticky="ew", padx=(0, PAD_SMALL))
        if self.cfg.get("last_source_folder"):
            self.source_entry.insert(0, self.cfg["last_source_folder"])
        enable_clipboard(self.source_entry)
        # No separate "Scan" button: typing/pasting a valid disc folder (or
        # picking one via Browse) scans it automatically, debounced so a
        # folder being typed out character-by-character doesn't trigger a
        # scan attempt on every keystroke. Enter forces it immediately.
        self.source_entry.bind("<KeyRelease>", self._on_source_entry_changed)
        self.source_entry.bind("<Return>", lambda _e: self.scan_folder())

        ctk.CTkButton(
            source_row, text="Browse...", width=90, font=FONT_BODY, command=self.browse_source
        ).grid(row=0, column=1)

        # --- Playlist selection ---
        self.playlist_select_label = ctk.CTkLabel(card, text="Playlist:", font=FONT_BODY)
        self.playlist_select_label.grid(row=2, column=0, sticky="w", padx=PAD_MED, pady=(PAD_SMALL, 0))
        self.playlist_option = ctk.CTkOptionMenu(
            card, values=["(scan a folder first)"], font=FONT_BODY,
            command=self.on_playlist_selected,
        )
        self.playlist_option.grid(row=3, column=0, sticky="ew", padx=PAD_MED, pady=(PAD_SMALL, 0))

        self.playlist_info_label = ctk.CTkLabel(
            card, text="", justify="left", wraplength=360, font=FONT_BODY, text_color=COLOR_TEXT_MUTED
        )
        self.playlist_info_label.grid(row=4, column=0, sticky="w", padx=PAD_MED, pady=(PAD_SMALL, PAD_SMALL))

        self.playlist_select_label.grid_remove()
        self.playlist_option.grid_remove()

        # --- Audio track selection (this app's "format" pick - which audio
        # stream is kept, since it stream-copies rather than re-encoding) ---
        ctk.CTkLabel(card, text="Audio Track", font=FONT_HEADER).grid(
            row=5, column=0, sticky="w", padx=PAD_MED, pady=(PAD_MED, PAD_SMALL)
        )
        track_box = ctk.CTkFrame(card, fg_color=COLOR_CARD_INSET, corner_radius=8)
        track_box.grid(row=6, column=0, sticky="ew", padx=PAD_MED, pady=(0, PAD_MED))
        track_box.grid_columnconfigure(0, weight=1)

        self.track_select_label = ctk.CTkLabel(track_box, text="Track:", font=FONT_BODY)
        self.track_select_label.grid(row=0, column=0, sticky="w", padx=PAD_SMALL, pady=(PAD_SMALL, 0))
        self.track_option = ctk.CTkOptionMenu(
            track_box, values=["(scan a folder first)"], font=FONT_BODY,
            command=self.on_audio_track_selected,
        )
        self.track_option.grid(row=1, column=0, sticky="ew", padx=PAD_SMALL, pady=PAD_SMALL)

        self.track_info_label = ctk.CTkLabel(
            track_box, text="", justify="left", wraplength=340, font=FONT_BODY, text_color=COLOR_TEXT_MUTED
        )
        self.track_info_label.grid(row=2, column=0, sticky="w", padx=PAD_SMALL, pady=(0, PAD_SMALL))

        self.track_select_label.grid_remove()
        self.track_option.grid_remove()

        card.grid_rowconfigure(7, weight=1)  # let the card stretch without leaving a dead gap

    def _build_pane_tracklist(self, parent: ctk.CTkFrame) -> None:
        """Pane 2 - Track List & Naming: the four naming methods + the chapter table."""
        card = ctk.CTkFrame(parent, fg_color=COLOR_CARD, corner_radius=10)
        card.grid(row=0, column=1, sticky="nsew", padx=(PAD_SMALL, 0))
        card.grid_columnconfigure(0, weight=1)
        card.grid_rowconfigure(2, weight=1)

        ctk.CTkLabel(card, text="Track List & Naming", font=FONT_HEADER).grid(
            row=0, column=0, sticky="w", padx=PAD_MED, pady=(PAD_MED, PAD_SMALL)
        )

        # --- Paste tracklist row ---
        paste_frame = ctk.CTkFrame(card, fg_color="transparent")
        paste_frame.grid(row=1, column=0, sticky="ew", padx=PAD_MED, pady=(0, PAD_SMALL))
        paste_frame.grid_columnconfigure(0, weight=1)

        ctk.CTkLabel(
            paste_frame,
            text="Paste tracklist (one song per line, in order) - fills the chapters below automatically:",
            font=FONT_BODY, wraplength=520, justify="left",
        ).grid(row=0, column=0, columnspan=2, sticky="w")

        self.paste_textbox = ctk.CTkTextbox(paste_frame, height=64, font=FONT_BODY, fg_color=COLOR_CARD_INSET)
        self.paste_textbox.grid(row=1, column=0, columnspan=2, sticky="ew", pady=(PAD_SMALL, PAD_SMALL))
        # Paste/cut (mouse or keyboard) and ordinary typing all funnel into
        # the same debounced auto-fill - no separate "Fill" click needed.
        enable_clipboard(self.paste_textbox, on_change=self._debounced_fill_from_paste)
        self.paste_textbox.bind("<KeyRelease>", lambda _e: self._debounced_fill_from_paste())

        btn_row = ctk.CTkFrame(paste_frame, fg_color="transparent")
        btn_row.grid(row=2, column=0, columnspan=2, sticky="ew")
        btn_row.grid_columnconfigure(0, weight=1)
        btn_row.grid_columnconfigure(1, weight=1)

        ctk.CTkButton(
            btn_row, text="Import Tracklist...", font=FONT_BODY,
            fg_color=COLOR_NEUTRAL, hover_color=COLOR_NEUTRAL_HOVER,
            command=self.import_tracklist,
        ).grid(row=0, column=0, sticky="ew", padx=(0, PAD_SMALL // 2 or 1))
        ctk.CTkButton(
            btn_row, text="Search Online...", font=FONT_BODY,
            fg_color=COLOR_NEUTRAL, hover_color=COLOR_NEUTRAL_HOVER,
            command=self.search_online_tracklist,
        ).grid(row=0, column=1, sticky="ew", padx=(PAD_SMALL // 2 or 1, 0))

        # --- Chapter/track name table (scrollable) ---
        self.chapter_scroll = ctk.CTkScrollableFrame(
            card, label_text="Chapters", fg_color=COLOR_CARD_INSET
        )
        self.chapter_scroll.grid(row=2, column=0, sticky="nsew", padx=PAD_MED, pady=(0, PAD_MED))
        self.chapter_scroll.grid_columnconfigure(1, weight=1)

    def _build_pane_execution(self) -> None:
        """Pane 3 - Execution & Progress: output folder, run controls, progress, rolling log."""
        card = ctk.CTkFrame(self, fg_color=COLOR_CARD, corner_radius=10)
        card.grid(row=3, column=0, sticky="ew", padx=PAD_LARGE, pady=PAD_SMALL)
        card.grid_columnconfigure(0, weight=1)

        ctk.CTkLabel(card, text="Execution & Progress", font=FONT_HEADER).grid(
            row=0, column=0, sticky="w", padx=PAD_MED, pady=(PAD_MED, PAD_SMALL)
        )

        # --- Output folder + run row ---
        bottom_frame = ctk.CTkFrame(card, fg_color="transparent")
        bottom_frame.grid(row=1, column=0, sticky="ew", padx=PAD_MED, pady=(0, PAD_SMALL))
        bottom_frame.grid_columnconfigure(0, weight=1)

        # The output folder rarely changes run to run, so once one is set
        # it's shown as a compact "Output: <path>  Change" line instead of
        # a full entry+browse row demanding review on every single run.
        # The full row only reappears on first run (nothing set yet) or
        # when "Change" is clicked.
        self.output_compact_frame = ctk.CTkFrame(bottom_frame, fg_color="transparent")
        self.output_compact_frame.grid(row=0, column=0, sticky="ew")
        self.output_compact_frame.grid_columnconfigure(0, weight=1)

        self.output_compact_label = ctk.CTkLabel(
            self.output_compact_frame, text="", anchor="w", justify="left", font=FONT_BODY
        )
        self.output_compact_label.grid(row=0, column=0, sticky="w", padx=(PAD_SMALL, PAD_SMALL), pady=PAD_SMALL)
        ctk.CTkButton(
            self.output_compact_frame, text="Change", width=80, font=FONT_BODY, fg_color="transparent",
            border_width=1, command=self._start_editing_output,
        ).grid(row=0, column=1, padx=(0, PAD_SMALL), pady=PAD_SMALL)

        self.output_edit_frame = ctk.CTkFrame(bottom_frame, fg_color="transparent")
        self.output_edit_frame.grid(row=0, column=0, sticky="ew")
        self.output_edit_frame.grid_columnconfigure(0, weight=1)

        self.output_entry = ctk.CTkEntry(
            self.output_edit_frame,
            textvariable=self.output_var,
            font=FONT_BODY,
            placeholder_text="Music library folder (an album subfolder is created automatically)...",
        )
        self.output_entry.grid(row=0, column=0, sticky="ew", padx=(PAD_SMALL, PAD_SMALL), pady=PAD_SMALL)
        enable_clipboard(self.output_entry)
        self.output_var.trace_add("write", self._on_output_var_changed)

        ctk.CTkButton(
            self.output_edit_frame, text="Browse...", width=100, font=FONT_BODY, command=self.browse_output
        ).grid(row=0, column=1, padx=(0, PAD_SMALL), pady=PAD_SMALL)
        ctk.CTkButton(
            self.output_edit_frame, text="Done", width=70, font=FONT_BODY, command=self._stop_editing_output,
        ).grid(row=0, column=2, padx=(0, PAD_SMALL), pady=PAD_SMALL)

        # --- Action buttons row: primary action gets the bright accent,
        # secondary actions stay neutral, destructive stays red. ---
        controls_row = ctk.CTkFrame(card, fg_color="transparent")
        controls_row.grid(row=2, column=0, sticky="ew", padx=PAD_MED, pady=(PAD_SMALL, 0))

        self.extract_button = ctk.CTkButton(
            controls_row, text="Extract & Split", width=150, font=(FONT_FAMILY, 12, "bold"),
            fg_color=COLOR_GREEN, hover_color=COLOR_GREEN_HOVER,
            command=self.start_extraction,
        )
        self.extract_button.grid(row=0, column=0, padx=(0, PAD_SMALL))

        self.cancel_button = ctk.CTkButton(
            controls_row, text="Cancel", width=90, font=FONT_BODY,
            fg_color=COLOR_DANGER, hover_color=COLOR_DANGER_HOVER,
            command=self.cancel_extraction, state="disabled",
        )
        self.cancel_button.grid(row=0, column=1, padx=(0, PAD_SMALL))

        self.open_log_button = ctk.CTkButton(
            controls_row, text="Open Log", width=100, font=FONT_BODY,
            fg_color=COLOR_NEUTRAL, hover_color=COLOR_NEUTRAL_HOVER,
            command=self.open_log, state="disabled",
        )
        self.open_log_button.grid(row=0, column=2)

        # --- Progress bar (indeterminate: the pipeline reports text
        # status, not a percentage, so this shows "something's running"
        # honestly rather than fabricating a fake completion percentage) ---
        self.progress_bar = ctk.CTkProgressBar(card, mode="indeterminate", progress_color=COLOR_GREEN)
        self.progress_bar.grid(row=3, column=0, sticky="ew", padx=PAD_MED, pady=(PAD_MED, PAD_SMALL))
        self.progress_bar.set(0)
        self.progress_bar.grid_remove()  # shown only while a job is running

        # --- Compact rolling log (mirrors set_status() calls; full detail
        # is still in the on-disk extraction.log via "Open Log") ---
        self._log_lines: list[str] = []
        self.log_view = ctk.CTkTextbox(
            card, height=70, font=(FONT_FAMILY, 10, "normal"), fg_color=COLOR_CARD_INSET,
        )
        self.log_view.grid(row=4, column=0, sticky="ew", padx=PAD_MED, pady=(0, PAD_MED))
        self.log_view.configure(state="disabled")

        self._refresh_output_display()

    # ------------------------------------------------------------------
    # Source folder / scanning
    # ------------------------------------------------------------------

    def browse_source(self) -> None:
        folder = filedialog.askdirectory(title="Select ripped Blu-ray disc folder")
        if folder:
            self._clear_invalid(self.source_entry)
            self.source_entry.delete(0, "end")
            self.source_entry.insert(0, folder)
            self._refresh_resume_banner()
            self.scan_folder()

    def _on_source_entry_changed(self, _event=None) -> None:
        if self.source_entry.get().strip():
            self._clear_invalid(self.source_entry)
        self._refresh_resume_banner()
        if self._source_debounce_id is not None:
            self.after_cancel(self._source_debounce_id)
        self._source_debounce_id = self.after(500, self._autoscan_if_valid)

    def _autoscan_if_valid(self) -> None:
        """
        Fires ~500ms after the source field stops changing. Silently does
        nothing if the folder isn't (yet) a valid disc folder - the user
        might still be mid-paste or mid-type - rather than popping an
        error dialog on every keystroke. Also skips re-scanning a folder
        that was just scanned, so finishing a paste doesn't trigger a
        second scan on top of the one Enter or Browse already started.
        """
        self._source_debounce_id = None
        folder_str = self.source_entry.get().strip()
        if not folder_str:
            return
        folder = Path(folder_str)
        if not (folder / "BDMV" / "PLAYLIST").is_dir():
            return
        if folder == self._last_scanned_folder:
            return
        self.scan_folder()

    def scan_folder(self) -> None:
        folder_str = self.source_entry.get().strip()
        if not folder_str:
            self._mark_invalid(self.source_entry)
            messagebox.showwarning("No folder", "Pick a folder first.")
            return

        folder = Path(folder_str)
        if not (folder / "BDMV" / "PLAYLIST").is_dir():
            self._mark_invalid(self.source_entry)
            messagebox.showerror(
                "Not a disc folder", "No BDMV/PLAYLIST found in that folder."
            )
            return

        self._clear_invalid(self.source_entry)
        self.disc_folder = folder
        self._last_scanned_folder = folder
        self.set_status(f"Scanning playlists in {folder.name}...")
        settings.update(last_source_folder=str(folder))

        def work() -> None:
            try:
                playlists = extractor.scan_disc_folder(folder)
            except Exception as exc:  # noqa: BLE001
                self.after(0, lambda: self._on_scan_failed(exc))
                return
            self.after(0, lambda: self._on_scan_complete(playlists))

        threading.Thread(target=work, daemon=True).start()

    def _on_scan_failed(self, exc: Exception) -> None:
        self.set_status("Scan failed - see error dialog.")
        messagebox.showerror(
            "Scan failed",
            f"{exc}\n\nCheck that mkvmerge is installed and on PATH "
            "(or its path is set correctly in settings).",
        )

    def _on_scan_complete(self, playlists: list[extractor.Playlist]) -> None:
        self._refresh_resume_banner()
        self.playlists = playlists
        if not playlists:
            self.set_status("No playlists found.")
            return

        # Score every playlist as a candidate instead of silently picking
        # whichever Atmos playlist has the most chapters - the dropdown
        # is sorted best-first and the reasons behind each score are
        # shown below it so the choice can actually be reviewed, not just
        # accepted on faith.
        self.playlist_scores = extractor.score_playlists(playlists)
        self.playlists = [s.playlist for s in self.playlist_scores]

        labels = [self._playlist_label(s) for s in self.playlist_scores]
        self.playlist_option.configure(values=labels)
        self.playlist_option.set(labels[0])
        self.on_playlist_selected(labels[0])

        # Only ask the user to choose when there's a real choice: 2+
        # playlists that both have at least one usable audio track and
        # aren't flagged as a duplicate/alternate angle of each other.
        # Otherwise the dropdown is a decision UI for a non-decision, so
        # it stays hidden - the reasoning label below it is never hidden
        # either way.
        real_candidates = [
            s for s in self.playlist_scores if s.playlist.audio_tracks and s.duplicate_of is None
        ]
        if len(real_candidates) > 1:
            self.playlist_select_label.grid()
            self.playlist_option.grid()
        else:
            self.playlist_select_label.grid_remove()
            self.playlist_option.grid_remove()

        top = self.playlist_scores[0]
        if not top.playlist.audio_tracks:
            status = "No audio tracks found in any playlist."
        elif top.playlist.has_atmos:
            status = f"Best candidate: {top.playlist.path.name} (score {top.score:.0f}) - review below."
        else:
            status = (
                f"Best candidate: {top.playlist.path.name} (score {top.score:.0f}) - "
                "no Atmos track, choose an audio track below."
            )

        if self.disc_folder is not None:
            sidecar_files = extractor.find_sidecar_tracklist_files(self.disc_folder)
            if sidecar_files:
                names = ", ".join(f.name for f in sidecar_files[:3])
                if len(sidecar_files) > 3:
                    names += f", +{len(sidecar_files) - 3} more"
                status += f" Possible tracklist file(s) found in the disc folder: {names} - use Import Tracklist to review."

        self.set_status(status)

    @staticmethod
    def _playlist_label(score: extractor.PlaylistScore) -> str:
        tag = " [possible duplicate]" if score.duplicate_of else ""
        atmos_note = ", atmos: yes" if score.playlist.has_atmos else ""
        return (
            f"{score.playlist.path.name}  -  score {score.score:.0f}  "
            f"(chapters: {score.playlist.chapter_count}, audio tracks: "
            f"{len(score.playlist.audio_tracks)}{atmos_note}){tag}"
        )

    def on_playlist_selected(self, label: str) -> None:
        idx = self.playlist_option.cget("values").index(label)
        score = self.playlist_scores[idx]
        self.selected_playlist_score = score
        self.selected_playlist = score.playlist
        pl = self.selected_playlist

        info_lines = [f"{len(pl.tracks)} tracks, {pl.chapter_count} chapters."]
        if pl.duration_seconds:
            info_lines[0] += f" Runs {pl.duration_seconds / 60:.0f} minutes."
        real_candidates = [
            s for s in self.playlist_scores if s.playlist.audio_tracks and s.duplicate_of is None
        ]
        if len(real_candidates) > 1:
            info_lines.append("Why this ranking:")
        else:
            info_lines.append("Why this one was picked automatically:")
        info_lines.extend(f"  - {r}" for r in score.reasons)
        self.playlist_info_label.configure(text="\n".join(info_lines))

        self._populate_audio_track_options(pl)

        # Preserve anything already typed for chapter numbers that still
        # exist in the new playlist, so switching between candidate
        # playlists (e.g. a different angle/cut with matching chapter
        # positions) doesn't throw away names entered by hand.
        preserved = {
            i: var.get() for i, var in self.chapter_name_vars.items() if var.get().strip()
        }
        self._rebuild_chapter_table(pl.chapter_count, preserve=preserved)
        self.selected_playlist_chapters = []  # stale until _load_embedded_chapter_names finishes for this playlist
        self._load_embedded_chapter_names(pl)

    # ------------------------------------------------------------------
    # Audio track selection
    # ------------------------------------------------------------------

    def _populate_audio_track_options(self, pl: extractor.Playlist) -> None:
        """
        Fill the audio track dropdown with every audio track this
        playlist actually has, pre-selecting the Atmos track if present
        (matching the old app's automatic behaviour exactly) or the best
        lossless alternative otherwise - see
        Playlist.best_default_audio_track(). The dropdown itself is
        shown whenever there's at least one audio track; it's only
        hidden entirely if the playlist somehow has none (nothing to
        pick, extraction can't proceed either way).
        """
        tracks = pl.audio_tracks
        if not tracks:
            self.track_select_label.grid_remove()
            self.track_option.grid_remove()
            self.track_info_label.configure(
                text="No audio tracks found on this playlist - it can't be extracted."
            )
            self.selected_audio_track = None
            return

        labels = [self._audio_track_label(t) for t in tracks]
        self.track_option.configure(values=labels)

        default_track = pl.best_default_audio_track()
        default_label = self._audio_track_label(default_track) if default_track else labels[0]
        self.track_option.set(default_label)
        self.track_select_label.grid()
        self.track_option.grid()
        self.on_audio_track_selected(default_label)

    @staticmethod
    def _audio_track_label(track: extractor.Track) -> str:
        prefix = "\u2b50 " if track.is_atmos else ""  # star the Atmos track so it stands out in the list
        return f"{prefix}{track.display_label}"

    def on_audio_track_selected(self, label: str) -> None:
        if not self.selected_playlist:
            return
        # Strip the star prefix _audio_track_label() may have added before
        # matching, since it isn't part of the track's own display_label.
        clean_label = label[2:] if label.startswith("\u2b50 ") else label
        for track in self.selected_playlist.audio_tracks:
            if track.display_label == clean_label:
                self.selected_audio_track = track
                break
        else:
            self.selected_audio_track = None
            return

        t = self.selected_audio_track
        note = ""
        if t.is_atmos:
            note = " (auto-selected: this is the Dolby Atmos track)"
        elif self.selected_playlist.has_atmos:
            note = " (Atmos is also available on this playlist - re-select it above if you'd rather have that)"
        self.track_info_label.configure(
            text=f"Track {t.track_id}: {t.display_label}{note}"
        )

    # ------------------------------------------------------------------
    # Chapter naming table
    # ------------------------------------------------------------------

    def _rebuild_chapter_table(
        self, chapter_count: int, preserve: dict[int, str] | None = None
    ) -> None:
        preserve = preserve or {}
        for widget in self.chapter_scroll.winfo_children():
            widget.destroy()
        self.chapter_name_vars.clear()
        self.chapter_source_labels.clear()
        self.chapter_duration_labels.clear()

        for i in range(1, chapter_count + 1):
            ctk.CTkLabel(self.chapter_scroll, text=f"Chapter {i:02d}", width=90, font=FONT_BODY).grid(
                row=i - 1, column=0, padx=(PAD_SMALL, PAD_SMALL), pady=4, sticky="w"
            )
            var = ctk.StringVar()
            if i in preserve:
                var.set(preserve[i])
            entry = ctk.CTkEntry(
                self.chapter_scroll, textvariable=var, font=FONT_BODY, placeholder_text=f"Track {i:02d}"
            )
            entry.grid(row=i - 1, column=1, padx=(0, PAD_SMALL), pady=4, sticky="ew")
            enable_clipboard(entry)
            self.chapter_name_vars[i] = var

            # Duration - filled in once embedded chapter data has loaded
            # (see _apply_embedded_chapter_names); blank until then, since
            # there's nothing real to show yet.
            duration_label = ctk.CTkLabel(
                self.chapter_scroll, text="", width=60, font=FONT_BODY, text_color=COLOR_TEXT_MUTED
            )
            duration_label.grid(row=i - 1, column=2, padx=(0, PAD_SMALL), pady=4, sticky="w")
            self.chapter_duration_labels[i] = duration_label

            # Shows where the current name came from - "from disc" once
            # prefilled from an embedded chapter title, flipping to
            # "edited" the moment the user changes it, blank if the user
            # typed the name themselves and nothing was ever auto-filled.
            source_label = ctk.CTkLabel(
                self.chapter_scroll, text="", width=80, font=FONT_BODY, text_color=COLOR_TEXT_MUTED
            )
            source_label.grid(row=i - 1, column=3, padx=(0, PAD_SMALL), pady=4, sticky="w")
            self.chapter_source_labels[i] = source_label

    def _load_embedded_chapter_names(self, pl: extractor.Playlist) -> None:
        """
        Read chapter names embedded in the playlist itself, if any, and
        use them to prefill blank naming fields. Runs off the UI thread:
        mkvextract can't read a .mpls playlist directly (only mkvmerge
        can), so this goes through read_chapters_from_source(), which
        remuxes just the chapter data via mkvmerge first - it isn't
        copying the video or audio streams, so it's normally quick,
        but a slow/network drive could still make it worth not blocking
        the UI for.
        """
        def work() -> None:
            try:
                chapters = extractor.read_chapters_from_source(pl.path)
            except Exception:
                return  # no embedded chapter names available - not fatal, nothing to prefill
            self.after(0, lambda: self._apply_embedded_chapter_names(pl, chapters))

        threading.Thread(target=work, daemon=True).start()

    def _apply_embedded_chapter_names(
        self, pl: extractor.Playlist, chapters: list[extractor.Chapter]
    ) -> None:
        if self.selected_playlist is not pl:
            return  # user already moved on to a different playlist selection
        self.selected_playlist_chapters = chapters
        for ch in chapters:
            duration_label = self.chapter_duration_labels.get(ch.index)
            if duration_label is not None and ch.end_seconds is not None:
                span = max(0.0, ch.end_seconds - ch.start_seconds)
                minutes, seconds = divmod(int(round(span)), 60)
                duration_label.configure(text=f"{minutes:02d}:{seconds:02d}")

            if ch.index not in self.chapter_name_vars or not ch.embedded_name:
                continue
            var = self.chapter_name_vars[ch.index]
            if var.get().strip():
                continue  # already has a name (preserved or hand-typed) - don't clobber it
            var.set(ch.embedded_name)
            self._mark_chapter_source(ch.index, ch.embedded_name)

    def _mark_chapter_source(self, index: int, baseline_value: str) -> None:
        """Label a chapter's name as auto-filled, and flip the label to 'edited' if the user changes it."""
        label = self.chapter_source_labels.get(index)
        var = self.chapter_name_vars.get(index)
        if label is None or var is None:
            return
        label.configure(text="from disc")

        def on_change(*_args, baseline=baseline_value, lbl=label, v=var) -> None:
            lbl.configure(text="edited" if v.get() != baseline else "from disc")

        var.trace_add("write", on_change)

    def _debounced_fill_from_paste(self) -> None:
        if self._paste_debounce_id is not None:
            self.after_cancel(self._paste_debounce_id)
        self._paste_debounce_id = self.after(300, self._do_fill_from_paste)

    def _do_fill_from_paste(self) -> None:
        self._paste_debounce_id = None
        self.fill_from_paste()

    def fill_from_paste(self) -> None:
        text = self.paste_textbox.get("1.0", "end").strip()
        if not text:
            return
        lines = [ln.strip() for ln in text.splitlines() if ln.strip()]

        for i, line in enumerate(lines, start=1):
            if i in self.chapter_name_vars:
                # Strip a leading "1.", "01 -", "1)" etc if present.
                cleaned = _strip_leading_number(line)
                self.chapter_name_vars[i].set(cleaned)
                # A pasted tracklist is an explicit user action - it should
                # read as user-entered, not linger as "from disc"/"edited"
                # from whatever was there before.
                label = self.chapter_source_labels.get(i)
                if label is not None:
                    label.configure(text="")

        if len(lines) != len(self.chapter_name_vars):
            self.set_status(
                f"Pasted {len(lines)} lines but there are {len(self.chapter_name_vars)} chapters - check alignment."
            )

    def import_tracklist(self) -> None:
        if not self.selected_playlist:
            messagebox.showwarning("No playlist selected", "Select a playlist first.")
            return

        initial_dir = str(self.disc_folder) if self.disc_folder else None
        path_str = filedialog.askopenfilename(
            title="Import tracklist",
            initialdir=initial_dir,
            filetypes=[
                ("Tracklist files", "*.txt *.nfo *.cue *.json"),
                ("All files", "*.*"),
            ],
        )
        if not path_str:
            return
        path = Path(path_str)

        try:
            entries = extractor.load_sidecar_tracklist(path)
        except ValueError as exc:
            messagebox.showerror("Could not read tracklist", str(exc))
            return

        chapters = self.selected_playlist_chapters
        if not chapters:
            # Embedded-chapter prefill hasn't finished loading yet - read
            # directly rather than making the user wait and retry.
            try:
                chapters = extractor.read_chapters_from_source(self.selected_playlist.path)
            except Exception as exc:  # noqa: BLE001
                messagebox.showerror("Could not read chapters", str(exc))
                return

        result = extractor.match_tracklist_to_chapters(chapters, entries)
        accepted = self._show_tracklist_review_dialog(path.name, result)
        if not accepted:
            return

        for index, name in accepted.items():
            if index not in self.chapter_name_vars:
                continue
            self.chapter_name_vars[index].set(name)
            label = self.chapter_source_labels.get(index)
            if label is not None:
                label.configure(text="imported")

        self.set_status(f"Imported {len(accepted)} track name(s) from {path.name}.")

    def _show_tracklist_review_dialog(
        self, source_name: str, result: extractor.TracklistMatchResult
    ) -> dict[int, str] | None:
        """
        Show the proposed chapter -> name mapping before anything is
        applied. Matched rows are pre-checked, mismatched rows are shown
        but unchecked so a duration mismatch has to be consciously
        accepted, and unmatched chapters can't be checked at all since
        there's no name to apply. Returns {chapter_index: name} for
        whatever the user accepts, or None if they cancel.
        """
        outcome: dict[str, dict[int, str] | None] = {"accepted": None}

        dialog = ctk.CTkToplevel(self)
        dialog.title(f"Review tracklist - {source_name}")
        dialog.geometry("580x500")
        dialog.transient(self)
        dialog.grab_set()
        try:
            dialog.configure(fg_color=COLOR_BG)
        except Exception:
            pass
        dialog.grid_columnconfigure(0, weight=1)
        dialog.grid_rowconfigure(1, weight=1)

        ctk.CTkLabel(
            dialog, text=result.summary, font=(FONT_FAMILY, 12, "bold"),
            wraplength=540, justify="left",
        ).grid(row=0, column=0, sticky="w", padx=PAD_LARGE, pady=(PAD_LARGE, PAD_MED))

        scroll = ctk.CTkScrollableFrame(dialog, fg_color=COLOR_CARD)
        scroll.grid(row=1, column=0, sticky="nsew", padx=PAD_LARGE, pady=(0, PAD_MED))
        scroll.grid_columnconfigure(1, weight=1)

        row_vars: dict[int, tuple[tk.BooleanVar, str]] = {}
        icon_for = {"matched": "OK", "duration_mismatch": "!", "no_match": "-"}

        for row_idx, m in enumerate(result.matches):
            var = tk.BooleanVar(value=(m.confidence == "matched"))
            checkbox = ctk.CTkCheckBox(scroll, text="", variable=var, width=20)
            checkbox.grid(row=row_idx, column=0, padx=(PAD_SMALL, PAD_SMALL), pady=2, sticky="w")
            if m.confidence == "no_match":
                checkbox.configure(state="disabled")

            label_text = f"[{icon_for[m.confidence]}] Chapter {m.chapter_index:02d}: {m.name or '(no match)'}"
            if m.detail:
                label_text += f"  -  {m.detail}"
            ctk.CTkLabel(scroll, text=label_text, anchor="w", font=FONT_BODY).grid(
                row=row_idx, column=1, sticky="w", pady=2
            )

            row_vars[m.chapter_index] = (var, m.name)

        button_row = ctk.CTkFrame(dialog, fg_color="transparent")
        button_row.grid(row=2, column=0, pady=(0, PAD_LARGE))
        button_row.grid_columnconfigure((0, 1, 2), weight=1)

        def accept_all() -> None:
            outcome["accepted"] = {i: name for i, (_var, name) in row_vars.items() if name}
            dialog.destroy()

        def accept_selected() -> None:
            outcome["accepted"] = {i: name for i, (var, name) in row_vars.items() if var.get() and name}
            dialog.destroy()

        def cancel() -> None:
            dialog.destroy()

        ctk.CTkButton(
            button_row, text="Cancel", width=100, font=FONT_BODY,
            fg_color=COLOR_NEUTRAL, hover_color=COLOR_NEUTRAL_HOVER, command=cancel,
        ).grid(row=0, column=0, padx=6)
        ctk.CTkButton(
            button_row, text="Accept Selected", width=150, font=FONT_BODY, command=accept_selected
        ).grid(row=0, column=1, padx=6)
        ctk.CTkButton(
            button_row, text="Accept All Matched", width=170, font=FONT_BODY,
            fg_color=COLOR_GREEN, hover_color=COLOR_GREEN_HOVER, command=accept_all,
        ).grid(row=0, column=2, padx=6)

        dialog.wait_window()
        return outcome["accepted"]

    def search_online_tracklist(self) -> None:
        if not self.selected_playlist:
            messagebox.showwarning("No playlist selected", "Select a playlist first.")
            return

        artist_guess, album_guess, year_guess = "", "", None
        if self.disc_folder is not None:
            artist_guess, album_guess, year_guess = extractor.guess_artist_album_year(self.disc_folder)

        search_input = self._show_musicbrainz_search_dialog(artist_guess, album_guess, year_guess)
        if search_input is None:
            return

        if search_input["mode"] == "barcode":
            barcode = search_input["barcode"]
            self.set_status(f"Searching MusicBrainz for barcode {barcode}...")

            def work() -> None:
                try:
                    candidates = extractor.search_musicbrainz_releases_by_barcode(barcode)
                except Exception as exc:  # noqa: BLE001
                    self.after(0, lambda: self._on_musicbrainz_error(exc))
                    return
                self.after(0, lambda: self._on_musicbrainz_search_complete(candidates))

        else:
            artist, album, year = search_input["artist"], search_input["album"], search_input["year"]
            self.set_status(f"Searching MusicBrainz for {artist} - {album}...")

            def work() -> None:
                try:
                    candidates = extractor.search_musicbrainz_releases(artist, album, year)
                except Exception as exc:  # noqa: BLE001
                    self.after(0, lambda: self._on_musicbrainz_error(exc))
                    return
                self.after(0, lambda: self._on_musicbrainz_search_complete(candidates))

        threading.Thread(target=work, daemon=True).start()

    def _on_musicbrainz_error(self, exc: Exception) -> None:
        self.set_status("MusicBrainz lookup failed.")
        messagebox.showerror("MusicBrainz lookup failed", str(exc))

    def _on_musicbrainz_search_complete(self, candidates: list[extractor.MusicBrainzCandidate]) -> None:
        if not candidates:
            self.set_status("No MusicBrainz results found.")
            messagebox.showinfo("No results", "No matching releases found on MusicBrainz.")
            return

        chosen = self._show_musicbrainz_results_dialog(candidates)
        if chosen is None:
            return

        self.set_status(f"Fetching tracklist for {chosen.title}...")

        def work() -> None:
            try:
                entries = extractor.fetch_musicbrainz_tracklist(chosen.release_id)
            except Exception as exc:  # noqa: BLE001
                self.after(0, lambda: self._on_musicbrainz_error(exc))
                return
            self.after(0, lambda: self._on_musicbrainz_tracklist_fetched(chosen, entries))

        threading.Thread(target=work, daemon=True).start()

    def _on_musicbrainz_tracklist_fetched(
        self, candidate: extractor.MusicBrainzCandidate, entries: list[extractor.TracklistEntry]
    ) -> None:
        if not entries:
            messagebox.showinfo(
                "Empty tracklist", f"MusicBrainz has no track titles for '{candidate.title}'."
            )
            self.set_status("Ready.")
            return

        chapters = self.selected_playlist_chapters
        if not chapters:
            try:
                chapters = extractor.read_chapters_from_source(self.selected_playlist.path)
            except Exception as exc:  # noqa: BLE001
                messagebox.showerror("Could not read chapters", str(exc))
                return

        # MusicBrainz's track count is summed across every medium on the
        # release, but fetch_musicbrainz_tracklist() only pulls the first
        # medium's tracks (a single Atmos playlist is one continuous
        # chapter set). A very different track count from this playlist's
        # chapter count usually means the wrong release/edition was
        # picked - flag it up front rather than letting a silent
        # mismatch fall through to the review dialog.
        if abs(len(entries) - len(chapters)) > max(2, len(chapters) // 4):
            proceed = messagebox.askyesno(
                "Track count mismatch",
                f"This playlist has {len(chapters)} chapter(s), but the "
                f"selected MusicBrainz release has {len(entries)} track(s) "
                f"on its first disc.\n\n"
                f"This usually means a different edition/release was "
                f"picked. Continue anyway and review the proposed match?",
            )
            if not proceed:
                self.set_status("Ready.")
                return

        result = extractor.match_tracklist_to_chapters(chapters, entries)
        accepted = self._show_tracklist_review_dialog(f"MusicBrainz: {candidate.title}", result)
        if not accepted:
            self.set_status("Ready.")
            return

        for index, name in accepted.items():
            if index not in self.chapter_name_vars:
                continue
            self.chapter_name_vars[index].set(name)
            label = self.chapter_source_labels.get(index)
            if label is not None:
                label.configure(text="MusicBrainz")

        self.set_status(f"Imported {len(accepted)} track name(s) from MusicBrainz.")

    def _show_musicbrainz_search_dialog(
        self, artist_guess: str, album_guess: str, year_guess: int | None
    ) -> dict | None:
        outcome: dict[str, dict | None] = {"result": None}

        dialog = ctk.CTkToplevel(self)
        dialog.title("Search MusicBrainz")
        dialog.geometry("460x420")
        dialog.transient(self)
        dialog.grab_set()
        try:
            dialog.configure(fg_color=COLOR_BG)
        except Exception:
            pass
        dialog.grid_columnconfigure(1, weight=1)

        ctk.CTkLabel(dialog, text="Artist:", font=FONT_BODY).grid(
            row=0, column=0, sticky="w", padx=PAD_LARGE, pady=(PAD_LARGE, PAD_SMALL)
        )
        artist_var = ctk.StringVar(value=artist_guess)
        artist_entry = ctk.CTkEntry(dialog, textvariable=artist_var, font=FONT_BODY, width=260)
        artist_entry.grid(row=0, column=1, padx=(0, PAD_LARGE), pady=(PAD_LARGE, PAD_SMALL), sticky="ew")
        enable_clipboard(artist_entry)

        ctk.CTkLabel(dialog, text="Album:", font=FONT_BODY).grid(
            row=1, column=0, sticky="w", padx=PAD_LARGE, pady=PAD_SMALL
        )
        album_var = ctk.StringVar(value=album_guess)
        album_entry = ctk.CTkEntry(dialog, textvariable=album_var, font=FONT_BODY, width=260)
        album_entry.grid(row=1, column=1, padx=(0, PAD_LARGE), pady=PAD_SMALL, sticky="ew")
        enable_clipboard(album_entry)

        ctk.CTkLabel(dialog, text="Year (optional):", font=FONT_BODY).grid(
            row=2, column=0, sticky="w", padx=PAD_LARGE, pady=PAD_SMALL
        )
        year_var = ctk.StringVar(value=str(year_guess) if year_guess else "")
        year_entry = ctk.CTkEntry(dialog, textvariable=year_var, font=FONT_BODY, width=100)
        year_entry.grid(row=2, column=1, sticky="w", padx=(0, PAD_LARGE), pady=PAD_SMALL)
        enable_clipboard(year_entry)

        separator = ctk.CTkFrame(dialog, height=2, fg_color="gray30")
        separator.grid(row=3, column=0, columnspan=2, sticky="ew", padx=PAD_LARGE, pady=(PAD_LARGE, PAD_SMALL))

        ctk.CTkLabel(dialog, text="\u2014 OR \u2014", text_color=COLOR_TEXT_MUTED, font=FONT_BODY).grid(
            row=4, column=0, columnspan=2, pady=(0, PAD_SMALL)
        )

        ctk.CTkLabel(dialog, text="Barcode:", font=FONT_BODY).grid(
            row=5, column=0, sticky="w", padx=PAD_LARGE, pady=PAD_SMALL
        )
        barcode_var = ctk.StringVar(value="")
        barcode_entry = ctk.CTkEntry(
            dialog, textvariable=barcode_var, font=FONT_BODY, width=260, placeholder_text="e.g. 5051890..."
        )
        barcode_entry.grid(row=5, column=1, padx=(0, PAD_LARGE), pady=PAD_SMALL, sticky="ew")
        enable_clipboard(barcode_entry)

        ctk.CTkLabel(
            dialog,
            text=(
                "The UPC/EAN number under the barcode lines on the disc case. "
                "Identifies the exact edition, so it's more precise than "
                "artist/album for reissues with different bonus tracks. "
                "If filled in, it's used instead of artist/album."
            ),
            text_color=COLOR_TEXT_MUTED, font=FONT_BODY, wraplength=400, justify="left",
        ).grid(row=6, column=0, columnspan=2, sticky="w", padx=PAD_LARGE, pady=(0, PAD_SMALL))

        ctk.CTkLabel(
            dialog, text="Searches musicbrainz.org - nothing is applied until you review results.",
            text_color=COLOR_TEXT_MUTED, font=FONT_BODY, wraplength=400, justify="left",
        ).grid(row=7, column=0, columnspan=2, sticky="w", padx=PAD_LARGE, pady=(PAD_SMALL, 0))

        button_row = ctk.CTkFrame(dialog, fg_color="transparent")
        button_row.grid(row=8, column=0, columnspan=2, pady=PAD_LARGE)
        button_row.grid_columnconfigure((0, 1), weight=1)

        def do_search() -> None:
            barcode = barcode_var.get().strip()
            if barcode:
                outcome["result"] = {"mode": "barcode", "barcode": barcode}
                dialog.destroy()
                return

            artist = artist_var.get().strip()
            album = album_var.get().strip()
            if not artist or not album:
                messagebox.showwarning(
                    "Missing info",
                    "Enter both artist and album, or a barcode, to search.",
                    parent=dialog,
                )
                return
            year_text = year_var.get().strip()
            year = int(year_text) if year_text.isdigit() else None
            outcome["result"] = {"mode": "artist_album", "artist": artist, "album": album, "year": year}
            dialog.destroy()

        def cancel() -> None:
            dialog.destroy()

        ctk.CTkButton(
            button_row, text="Cancel", width=100, font=FONT_BODY,
            fg_color=COLOR_NEUTRAL, hover_color=COLOR_NEUTRAL_HOVER, command=cancel,
        ).grid(row=0, column=0, padx=6)
        ctk.CTkButton(button_row, text="Search", width=100, font=FONT_BODY, command=do_search).grid(
            row=0, column=1, padx=6
        )

        dialog.wait_window()
        return outcome["result"]

    def _show_musicbrainz_results_dialog(
        self, candidates: list[extractor.MusicBrainzCandidate]
    ) -> extractor.MusicBrainzCandidate | None:
        outcome: dict[str, extractor.MusicBrainzCandidate | None] = {"chosen": None}

        dialog = ctk.CTkToplevel(self)
        dialog.title("MusicBrainz results")
        dialog.geometry("580x440")
        dialog.transient(self)
        dialog.grab_set()
        try:
            dialog.configure(fg_color=COLOR_BG)
        except Exception:
            pass
        dialog.grid_columnconfigure(0, weight=1)
        dialog.grid_rowconfigure(1, weight=1)

        ctk.CTkLabel(
            dialog, text=f"{len(candidates)} release(s) found - pick one:",
            font=(FONT_FAMILY, 12, "bold"),
        ).grid(row=0, column=0, sticky="w", padx=PAD_LARGE, pady=(PAD_LARGE, PAD_MED))

        scroll = ctk.CTkScrollableFrame(dialog, fg_color=COLOR_CARD)
        scroll.grid(row=1, column=0, sticky="nsew", padx=PAD_LARGE, pady=(0, PAD_MED))
        scroll.grid_columnconfigure(0, weight=1)

        selected_index = tk.IntVar(value=0)
        for i, c in enumerate(candidates):
            label = f"{c.artist} - {c.title}"
            if c.date:
                label += f" ({c.date})"
            if c.track_count:
                label += f", {c.track_count} tracks"
            if c.format_hint:
                label += f" [{c.format_hint}]"
            ctk.CTkRadioButton(scroll, text=label, font=FONT_BODY, variable=selected_index, value=i).grid(
                row=i, column=0, sticky="w", pady=4, padx=4
            )

        button_row = ctk.CTkFrame(dialog, fg_color="transparent")
        button_row.grid(row=2, column=0, pady=(0, PAD_LARGE))
        button_row.grid_columnconfigure((0, 1), weight=1)

        def use_selected() -> None:
            outcome["chosen"] = candidates[selected_index.get()]
            dialog.destroy()

        def cancel() -> None:
            dialog.destroy()

        ctk.CTkButton(
            button_row, text="Cancel", width=100, font=FONT_BODY,
            fg_color=COLOR_NEUTRAL, hover_color=COLOR_NEUTRAL_HOVER, command=cancel,
        ).grid(row=0, column=0, padx=6)
        ctk.CTkButton(
            button_row, text="Use Selected", width=140, font=FONT_BODY, command=use_selected
        ).grid(row=0, column=1, padx=6)

        dialog.wait_window()
        return outcome["chosen"]

    # ------------------------------------------------------------------
    # Output folder / extraction
    # ------------------------------------------------------------------

    def browse_output(self) -> None:
        folder = filedialog.askdirectory(title="Select output folder")
        if folder:
            self.output_var.set(folder)
            self._refresh_resume_banner()
            self._stop_editing_output()

    def _on_output_var_changed(self, *_args) -> None:
        if self.output_var.get().strip():
            self._clear_invalid(self.output_entry)
        self._refresh_resume_banner()

    def _refresh_output_display(self) -> None:
        """
        Show the compact "Output: <path>  Change" line whenever there's a
        remembered folder and the user isn't actively editing it; show the
        full entry+Browse row otherwise (first run, or "Change" clicked).
        """
        value = self.output_var.get().strip()
        if value and not self._output_editing:
            self.output_compact_label.configure(text=f"Output: {value}")
            self.output_edit_frame.grid_remove()
            self.output_compact_frame.grid()
        else:
            self.output_compact_frame.grid_remove()
            self.output_edit_frame.grid()

    def _start_editing_output(self) -> None:
        self._output_editing = True
        self._refresh_output_display()
        self.output_entry.focus_set()

    def _stop_editing_output(self) -> None:
        self._output_editing = False
        self._refresh_output_display()

    def start_extraction(self) -> None:
        if not self.selected_playlist or not self.selected_audio_track:
            messagebox.showerror("No audio track selected", "Selected playlist has no audio track to extract.")
            return

        if self.selected_playlist_score and self.selected_playlist_score.duplicate_of:
            proceed = messagebox.askyesno(
                "Possible duplicate playlist",
                f"{self.selected_playlist.path.name} looks like a duplicate or "
                f"alternate angle of {self.selected_playlist_score.duplicate_of.name} "
                "(same duration, chapter count, and tracks).\n\n"
                "Continue with this playlist anyway?",
            )
            if not proceed:
                return

        output_str = self.output_var.get().strip()
        if not output_str:
            self._start_editing_output()
            self._mark_invalid(self.output_entry)
            messagebox.showwarning("No output folder", "Pick an output folder first.")
            return
        self._clear_invalid(self.output_entry)

        library_folder = Path(output_str)
        settings.update(last_output_folder=str(library_folder))
        self._stop_editing_output()

        source_folder = Path(self.source_entry.get().strip())
        album_name = extractor.derive_album_folder_name(source_folder)
        output_folder = library_folder / album_name

        track_names = {
            idx: var.get().strip()
            for idx, var in self.chapter_name_vars.items()
            if var.get().strip()
        }

        resolution = self._resolve_output_collisions(output_folder, track_names)
        if resolution is None:
            return  # user cancelled out of the collision dialog
        output_folder, overwrite_paths = resolution

        work_folder = output_folder / "_work"
        resume_choice = self._resolve_resume_choice(work_folder)
        if resume_choice is None:
            return  # user backed out of the resume/clean-up prompt
        resume, do_cleanup_first = resume_choice
        if do_cleanup_first:
            shutil.rmtree(work_folder, ignore_errors=True)

        self._run_extraction_job(
            playlist=self.selected_playlist,
            audio_track=self.selected_audio_track,
            track_names=track_names,
            work_folder=work_folder,
            output_folder=output_folder,
            overwrite_paths=overwrite_paths,
            resume=resume,
        )

    def _run_extraction_job(
        self,
        playlist: extractor.Playlist,
        audio_track: extractor.Track,
        track_names: dict[int, str],
        work_folder: Path,
        output_folder: Path,
        overwrite_paths: set[Path],
        resume: bool,
    ) -> None:
        """
        Shared job-launch path for both a normal Extract & Split click and
        a Resume from the banner - both end up here so there's exactly one
        place that starts the worker thread and wires up progress/cancel/
        completion handling, instead of two copies that could drift apart.
        """
        self.cancel_event = threading.Event()
        self.current_log_path = output_folder / "extraction.log"
        self.extract_button.configure(state="disabled", text="Working...")
        self.cancel_button.configure(state="normal", text="Cancel")
        self.open_log_button.configure(state="normal")
        self.resume_banner.grid_remove()  # the job it referred to is now running
        self.progress_bar.grid()
        self.progress_bar.start()
        self.set_status(f"{'Resuming' if resume else 'Starting'} extraction -> {output_folder}")

        def progress(msg: str) -> None:
            self.after(0, lambda: self.set_status(msg))

        def work() -> None:
            try:
                results = extractor.run_full_pipeline(
                    playlist,
                    audio_track,
                    track_names,
                    work_folder=work_folder,
                    output_folder=output_folder,
                    container=self.cfg.get("output_container", "mkv"),
                    progress_cb=progress,
                    overwrite=overwrite_paths,
                    cancel_event=self.cancel_event,
                    resume=resume,
                    log_path=self.current_log_path,
                )
                self.after(0, lambda: self._on_extraction_complete(results))
            except extractor.JobCancelled:
                self.after(0, self._on_extraction_cancelled)
            except extractor.OutputCollisionError as exc:
                # Rare - preflight already checked - but the output folder
                # could change on disk between preflight and the actual
                # write (another process, another run). Handled the same
                # as any other extraction failure: nothing overwritten,
                # user told exactly what collided.
                self.after(0, lambda: self._on_extraction_failed(exc))
            except Exception as exc:  # noqa: BLE001
                self.after(0, lambda: self._on_extraction_failed(exc))

        threading.Thread(target=work, daemon=True).start()

    def cancel_extraction(self) -> None:
        if self.cancel_event is None:
            return
        self.cancel_event.set()
        self.cancel_button.configure(state="disabled", text="Cancelling...")
        self.set_status("Cancelling - waiting for the current step to stop...")

    def open_log(self) -> None:
        if self.current_log_path is None or not self.current_log_path.is_file():
            messagebox.showinfo("No log yet", "No log file is available yet.")
            return
        if hasattr(os, "startfile"):
            os.startfile(self.current_log_path)  # type: ignore[attr-defined]
        else:
            webbrowser.open(self.current_log_path.as_uri())

    def _resolve_resume_choice(self, work_folder: Path) -> tuple[bool, bool] | None:
        """
        Check whether work_folder holds a manifest from a previous job
        that didn't finish (crashed, was cancelled, or failed), and if so
        ask how to proceed. Returns (resume, clean_up_first):
          - (False, False): nothing to resume, proceed as a normal fresh job
          - (True, False):  resume - skip whatever the manifest says is already done
          - (False, True):  clean up the leftover _work folder, then start fresh
          - None:            user backed out - don't start any job

        Resume and "retry failed tracks" are the same action here: progress
        is tracked by which output files actually exist on disk, so there's
        nothing left to redo differently between "resume where it left off"
        and "retry whatever didn't finish" - both just mean "don't redo
        what's already done".
        """
        manifest = extractor.read_manifest(work_folder)
        if manifest is None or manifest.status == "complete":
            return False, False

        choice = messagebox.askyesnocancel(
            "Resume previous job?",
            f"A previous job for this output folder didn't finish "
            f"(status: {manifest.status}).\n\n"
            f"Yes = Resume - skip whatever was already completed\n"
            f"No = Clean up and start this job fresh\n"
            f"Cancel = Don't start a job right now",
        )
        if choice is None:
            return None
        return (True, False) if choice else (False, True)

    def _on_extraction_cancelled(self) -> None:
        self.extract_button.configure(state="normal", text="Extract & Split")
        self.cancel_button.configure(state="disabled", text="Cancel")
        self.progress_bar.stop()
        self.progress_bar.grid_remove()
        self.cancel_event = None
        self.set_status("Cancelled - paused job saved. See the Resume banner above.")
        self._refresh_resume_banner()

    def _resolve_output_collisions(
        self, output_folder: Path, track_names: dict[int, str]
    ) -> tuple[Path, set[Path]] | None:
        """
        Run the fast filename-planning check before starting the slow
        extraction pipeline, and get explicit user confirmation for any
        output file that would already exist. Returns
        (output_folder, approved_overwrite_paths), where output_folder may
        have been changed if the user picked a different one; or None if
        the user cancelled.
        """
        chapter_count = self.selected_playlist.chapter_count
        container = self.cfg.get("output_container", "mkv")

        warned_duplicates = False

        while True:
            planned = extractor.preflight_check(
                output_folder, chapter_count, track_names, container=container
            )

            duplicates = [p for p in planned if p.duplicate_name]
            if duplicates and not warned_duplicates:
                names = ", ".join(sorted({p.chapter.name for p in duplicates}))
                proceed = messagebox.askyesno(
                    "Duplicate track names",
                    f"More than one chapter is named the same thing ({names}). "
                    "This usually means a pasted tracklist got mis-aligned - "
                    "the chapter numbers stay separate either way, but you may "
                    "want to double check the names before continuing.\n\n"
                    "Continue anyway?",
                )
                if not proceed:
                    return None
                warned_duplicates = True  # don't re-ask if they loop back (e.g. after choosing a folder)

            colliding = [p for p in planned if p.exists]
            if not colliding:
                return output_folder, set()

            choice = self._show_collision_dialog(output_folder, colliding)
            if choice == "cancel":
                return None
            if choice == "choose_folder":
                new_library_folder = filedialog.askdirectory(
                    title="Select a different output folder"
                )
                if not new_library_folder:
                    continue  # back to the same dialog, nothing changed
                source_folder = Path(self.source_entry.get().strip())
                album_name = extractor.derive_album_folder_name(source_folder)
                output_folder = Path(new_library_folder) / album_name
                self.output_var.set(new_library_folder)
                continue
            if choice == "overwrite":
                return output_folder, {p.path for p in colliding}

    def _show_collision_dialog(self, output_folder: Path, colliding: list) -> str:
        """
        Modal dialog listing output files that already exist. Nothing is
        ever overwritten without the user explicitly choosing to here.
        Returns "cancel", "choose_folder", or "overwrite".
        """
        result = {"choice": "cancel"}

        dialog = ctk.CTkToplevel(self)
        dialog.title("Output files already exist")
        dialog.geometry("500x400")
        dialog.transient(self)
        dialog.grab_set()
        try:
            dialog.configure(fg_color=COLOR_BG)
        except Exception:
            pass
        dialog.grid_columnconfigure(0, weight=1)
        dialog.grid_rowconfigure(1, weight=1)

        ctk.CTkLabel(
            dialog,
            text=f"{len(colliding)} file(s) already exist in \"{output_folder.name}\":",
            font=(FONT_FAMILY, 12, "bold"),
            wraplength=460,
            justify="left",
        ).grid(row=0, column=0, sticky="w", padx=PAD_LARGE, pady=(PAD_LARGE, PAD_MED))

        listbox = ctk.CTkTextbox(dialog, font=FONT_BODY, fg_color=COLOR_CARD)
        listbox.grid(row=1, column=0, sticky="nsew", padx=PAD_LARGE, pady=(0, PAD_MED))
        listbox.insert("1.0", "\n".join(p.path.name for p in colliding))
        listbox.configure(state="disabled")

        ctk.CTkLabel(
            dialog,
            text="Nothing is overwritten automatically. Choose how to proceed:",
            font=FONT_BODY,
            wraplength=460,
            justify="left",
        ).grid(row=2, column=0, sticky="w", padx=PAD_LARGE, pady=(0, PAD_MED))

        button_row = ctk.CTkFrame(dialog, fg_color="transparent")
        button_row.grid(row=3, column=0, pady=(0, PAD_LARGE))
        button_row.grid_columnconfigure((0, 1, 2), weight=1)

        def pick(choice: str) -> None:
            result["choice"] = choice
            dialog.destroy()

        ctk.CTkButton(
            button_row, text="Cancel", width=100, font=FONT_BODY,
            fg_color=COLOR_NEUTRAL, hover_color=COLOR_NEUTRAL_HOVER,
            command=lambda: pick("cancel"),
        ).grid(row=0, column=0, padx=6)
        ctk.CTkButton(
            button_row,
            text="Choose another folder",
            width=180,
            font=FONT_BODY,
            command=lambda: pick("choose_folder"),
        ).grid(row=0, column=1, padx=6)
        ctk.CTkButton(
            button_row,
            text="Overwrite these files",
            width=180,
            font=FONT_BODY,
            fg_color=COLOR_DANGER,
            hover_color=COLOR_DANGER_HOVER,
            command=lambda: pick("overwrite"),
        ).grid(row=0, column=2, padx=6)

        dialog.wait_window()
        return result["choice"]

    def _on_extraction_complete(self, results: list[Path]) -> None:
        self.extract_button.configure(state="normal", text="Extract & Split")
        self.cancel_button.configure(state="disabled", text="Cancel")
        self.progress_bar.stop()
        self.progress_bar.grid_remove()
        self.cancel_event = None
        self.set_status(f"Done. Wrote {len(results)} files to {self.output_var.get()}")
        messagebox.showinfo("Done", f"Wrote {len(results)} track files.")
        self._refresh_resume_banner()

    def _on_extraction_failed(self, exc: Exception) -> None:
        self.extract_button.configure(state="normal", text="Extract & Split")
        self.cancel_button.configure(state="disabled", text="Cancel")
        self.progress_bar.stop()
        self.progress_bar.grid_remove()
        self.cancel_event = None
        self.set_status("Failed - paused job saved. See the Resume banner above.")
        messagebox.showerror("Extraction failed", str(exc))
        self._refresh_resume_banner()

    # ------------------------------------------------------------------
    # Resume banner
    # ------------------------------------------------------------------

    def _current_output_folder(self) -> Path | None:
        """
        Compute the album output folder the same way start_extraction does,
        from whatever's currently typed in the source/output fields - used
        to check for a resumable job before the user has clicked anything.
        Returns None if either field is empty or the folder name can't be
        derived (e.g. mid-typing).
        """
        output_str = self.output_var.get().strip()
        source_str = self.source_entry.get().strip()
        if not output_str or not source_str:
            return None
        try:
            album_name = extractor.derive_album_folder_name(Path(source_str))
        except Exception:
            return None
        return Path(output_str) / album_name

    def _refresh_resume_banner(self) -> None:
        """
        Check whether the current source+output folder combination has an
        interrupted job waiting in its _work folder, and show/hide the
        banner accordingly. Called after every action that could change
        which job is "current" - typing/browsing either folder field,
        finishing a scan, and after cancel/failure/completion - so the
        banner never depends on the user remembering to click anything
        first.
        """
        output_folder = self._current_output_folder()
        manifest = None
        work_folder = None
        if output_folder is not None:
            work_folder = output_folder / "_work"
            manifest = extractor.read_manifest(work_folder)
            if manifest is not None and manifest.status == "complete":
                manifest = None  # finished jobs clean up their own manifest; nothing to resume

        self._resumable_manifest = manifest
        self._resumable_work_folder = work_folder

        if manifest is None:
            self.resume_banner.grid_remove()
            return

        done = len(manifest.completed_outputs)
        total = len(manifest.chapters) if manifest.chapters else None
        if total:
            progress_txt = f"{done} of {total} tracks split"
        elif manifest.audio_extracted:
            label = getattr(manifest, "audio_track_label", "") or "audio"
            progress_txt = f"{label} extracted, splitting not started yet"
        else:
            progress_txt = "extraction not finished"

        status_txt = {
            "cancelled": "Paused",
            "failed": "Interrupted (error)",
            "extracting": "Interrupted mid-extraction",
            "splitting": "Interrupted mid-split",
            "pending": "Not started",
        }.get(manifest.status, manifest.status)

        album = Path(manifest.output_folder).name
        self.resume_banner_label.configure(
            text=f"\u23f8 {status_txt} job found for \u201c{album}\u201d \u2014 {progress_txt}."
        )
        self.resume_banner.grid()

    def _resume_from_banner(self) -> None:
        """
        Resume the job the banner is currently showing, without requiring
        the user to have re-scanned the disc or re-selected a playlist
        first - everything needed is pulled straight from the manifest,
        including re-inspecting the original playlist directly by path.
        """
        manifest = self._resumable_manifest
        work_folder = self._resumable_work_folder
        if manifest is None or work_folder is None:
            return

        try:
            playlist = extractor.inspect_playlist(Path(manifest.source_playlist))
        except Exception as exc:  # noqa: BLE001
            messagebox.showerror(
                "Can't resume",
                f"Couldn't re-read the original playlist to resume:\n{exc}\n\n"
                "The source disc folder may have moved, been unmounted, or "
                "been renamed since this job was started.",
            )
            return

        audio_track = next(
            (t for t in playlist.audio_tracks if t.track_id == manifest.audio_track_id), None
        )
        if audio_track is None:
            messagebox.showerror(
                "Can't resume",
                "The audio track this job was extracting no longer appears "
                "on the playlist - the disc rip may have changed since this "
                "job was started. Start a fresh job instead.",
            )
            return

        # Reflect what's being resumed back into the GUI fields, so the
        # rest of the window (chapter names, status, Cancel/Open Log) is
        # consistent with the job that's actually running - not left
        # showing whatever the user had typed before clicking Resume.
        track_names = {int(k): v for k, v in manifest.track_names.items()}
        for idx, var in self.chapter_name_vars.items():
            if idx in track_names:
                var.set(track_names[idx])

        self._run_extraction_job(
            playlist=playlist,
            audio_track=audio_track,
            track_names=track_names,
            work_folder=work_folder,
            output_folder=Path(manifest.output_folder),
            overwrite_paths=set(),
            resume=True,
        )

    def _discard_resumable_job(self) -> None:
        """Delete the leftover _work folder (manifest + intermediate file) and hide the banner."""
        work_folder = self._resumable_work_folder
        if work_folder is None:
            return
        proceed = messagebox.askyesno(
            "Discard paused job?",
            "This deletes the saved progress for this job, including the "
            "extracted audio track if that step already finished. Any "
            "track files already split are NOT deleted - only the "
            "in-progress checkpoint.\n\nDiscard and start fresh next time?",
        )
        if not proceed:
            return
        shutil.rmtree(work_folder, ignore_errors=True)
        self._refresh_resume_banner()

    # ------------------------------------------------------------------
    # Validation helpers (subtle red border on empty mandatory fields,
    # in addition to - not instead of - the confirming error dialogs
    # already used for hard stops elsewhere in this file)
    # ------------------------------------------------------------------

    def _mark_invalid(self, widget: ctk.CTkEntry) -> None:
        try:
            widget.configure(border_color=COLOR_INVALID_BORDER, border_width=2)
        except Exception:
            pass

    def _clear_invalid(self, widget: ctk.CTkEntry) -> None:
        try:
            widget.configure(border_color=COLOR_BLUE, border_width=1)
        except Exception:
            pass

    # ------------------------------------------------------------------

    def set_status(self, text: str) -> None:
        self.status_label.configure(text=text)
        self._append_log_line(text)

    def _append_log_line(self, text: str) -> None:
        """
        Mirror set_status() calls into the compact rolling log in Pane 3,
        capped to the last several lines so it stays a quick-glance strip
        rather than growing without bound - the full detail is always in
        the on-disk extraction.log via "Open Log".
        """
        if not hasattr(self, "log_view"):
            return
        self._log_lines.append(text)
        self._log_lines = self._log_lines[-8:]
        self.log_view.configure(state="normal")
        self.log_view.delete("1.0", "end")
        self.log_view.insert("1.0", "\n".join(self._log_lines))
        self.log_view.see("end")
        self.log_view.configure(state="disabled")


def _strip_leading_number(line: str) -> str:
    return extractor.strip_leading_number(line)


if __name__ == "__main__":
    app = DiscTrackSplitterApp()
    app.mainloop()