MCE.OLED.GALLERY.py

#!/usr/bin/env python3
"""
# MCE OLED Toolset [Gallery]
"""
import os, sys, glob, threading, math, shutil, re, json, subprocess, platform
import datetime
import tkinter as tk
from tkinter import filedialog, ttk, messagebox
import numpy as np
from PIL import Image, ImageTk

# ── Format constants ─────────────────────────────────────────────────────────
OUT_W, OUT_H    = 128, 64
COLOR_TABLE_LEN = 8
BITMAP_BYTES    = OUT_W * OUT_H // 8
BIN_SIZE        = COLOR_TABLE_LEN + BITMAP_BYTES

THUMB_SCALE    = 2
THUMB_W        = OUT_W * THUMB_SCALE
THUMB_H        = OUT_H * THUMB_SCALE
CARD_PAD       = 12
CARD_W         = THUMB_W + CARD_PAD * 2
ITEMS_PER_PAGE = 60
SCAN_GLOB      = "**/*.bin"

PREVIEW_SCALE  = 5
PW             = OUT_W * PREVIEW_SCALE
PH             = OUT_H * PREVIEW_SCALE

_HW_FRAME_CANDIDATES = ["gcmcepr.png", "gcmepr.png"]
SPLASH_Y_OFFSET = 182

SDBUILDER_NAME = "SDBuilder"   # local fallback folder name


def resource_path(relative):
    base = getattr(sys, '_MEIPASS', os.path.dirname(os.path.abspath(__file__)))
    return os.path.join(base, relative)

def _find_hw_frame_png():
    for name in _HW_FRAME_CANDIDATES:
        rp = resource_path(name)
        if os.path.exists(rp):
            return rp
    return None

# ── File/path constants ───────────────────────────────────────────────────────
CACHE_DIR   = os.path.join(os.getcwd(), ".gallery_cache")
REPORT_FILE = os.path.join(os.getcwd(), "missing_raw_report.json")
CONFIG_FILE = os.path.join(os.getcwd(), "gallery_config.json")
os.makedirs(CACHE_DIR, exist_ok=True)

# ── Colour palette ────────────────────────────────────────────────────────────
BG            = "#1e1e2e"
BG2           = "#252537"
CARD_BG       = "#2a2a40"
ACCENT        = "#7c5bc8"
ACCENT2       = "#9d7de8"
FG            = "#dde0f0"
FG_DIM        = "#8888aa"
FG_ID         = "#e8c07d"
BORDER        = "#35354a"
GREEN_REG     = "#4CAF50"
RAW_GREEN     = "#3ecf6e"
MISSING_RED   = "#e07070"
UNMATCHED_CLR = "#e0a840"
BUILDER_CLR   = "#5bc8c0"   # teal — SDBuilder

PREVIEW_COLOR     = (225, 240, 255)
PREVIEW_COLOR_HEX = "#{:02x}{:02x}{:02x}".format(*PREVIEW_COLOR)

FONT    = "Arial"
F_TITLE = (FONT, 13, "bold")
F_HEAD  = (FONT, 10, "bold")
F_BODY  = (FONT,  9, "bold")
F_SMALL = (FONT,  8)
F_TINY  = (FONT,  7)


# ── SD path resolution ────────────────────────────────────────────────────────
def resolve_sd_gc(selected_path: str) -> str:
    """
    Normalise *any* path the user picks to the MemoryCards/GC subfolder.

    Accepted inputs (case-insensitive suffix match):
      .../MemoryCards/GC/  →  used as-is
      .../MemoryCards/     →  appends GC/
      anything else        →  appends MemoryCards/GC/
    """
    p = os.path.normpath(selected_path)
    parts = p.replace("\\", "/").split("/")
    lo    = [x.lower() for x in parts]

    if len(lo) >= 2 and lo[-2] == "memorycards" and lo[-1] == "gc":
        return p
    if lo[-1] == "memorycards":
        return os.path.join(p, "GC")
    return os.path.join(p, "MemoryCards", "GC")


def sdbuilder_gc() -> str:
    """Return the local SDBuilder MemoryCards/GC path (always in cwd)."""
    return os.path.join(os.getcwd(), SDBUILDER_NAME, "MemoryCards", "GC")


def _next_serial_filename(dest_dir: str, serial: str) -> str:
    """serial.bin → serial-1.bin → serial-2.bin … (first free name)."""
    candidate = f"{serial}.bin"
    if not os.path.exists(os.path.join(dest_dir, candidate)):
        return candidate
    n = 1
    while True:
        candidate = f"{serial}-{n}.bin"
        if not os.path.exists(os.path.join(dest_dir, candidate)):
            return candidate
        n += 1


# ── Pixel / image helpers ─────────────────────────────────────────────────────
def _data_to_rgba(raw_bytes) -> np.ndarray:
    raw  = np.frombuffer(raw_bytes, dtype=np.uint8)
    bits = np.unpackbits(raw, bitorder='big')
    vals = np.where(bits == 1, 255, 0).astype(np.uint8).reshape((OUT_H, OUT_W))
    rgba = np.zeros((OUT_H, OUT_W, 4), dtype=np.uint8)
    rgba[..., 3] = 255
    on_mask = vals == 255
    rgba[on_mask]  = (*PREVIEW_COLOR, 255)
    rgba[~on_mask] = (0, 0, 0, 255)
    return rgba


def get_base_image(path: str):
    base_name  = os.path.basename(path)
    cache_path = os.path.join(CACHE_DIR, base_name + ".png")
    if os.path.exists(cache_path) and \
       os.path.getmtime(cache_path) >= os.path.getmtime(path):
        try:
            return Image.open(cache_path).convert("RGBA")
        except Exception:
            pass
    try:
        with open(path, "rb") as f:
            data = f.read()
        if len(data) != BIN_SIZE:
            return None
        rgba = _data_to_rgba(data[COLOR_TABLE_LEN:])
        img  = Image.fromarray(rgba, "RGBA")
        img.save(cache_path)
        return img
    except Exception:
        return None


def make_thumb(path: str):
    img = get_base_image(path)
    if img is None:
        return None
    return ImageTk.PhotoImage(img.resize((THUMB_W, THUMB_H), Image.NEAREST))


# ── Raw channel helpers ───────────────────────────────────────────────────────
def _find_raw_files(bin_path: str):
    folder = os.path.dirname(bin_path)
    raws   = sorted(glob.glob(os.path.join(folder, "*.raw")))
    if not raws:
        return []
    groups = {}
    for r in raws:
        name = os.path.basename(r)
        stem = os.path.splitext(name)[0]
        m    = re.search(r'^(.*)-(\d+)$', stem)
        if m:
            base, num = m.group(1), int(m.group(2))
        else:
            base, num = stem, None
        groups.setdefault(base, []).append((num, name))
    result = []
    for base, entries in groups.items():
        entries.sort(key=lambda x: (-1 if x[0] is None else x[0]))
        has_base = any(n is None for n, _ in entries)
        for i, (num, name) in enumerate(entries):
            channel = (1 if num is None else num + 1) if has_base else (i + 1)
            result.append((channel, name))
    result.sort(key=lambda x: x[0])
    return result


# ── Misc helpers ──────────────────────────────────────────────────────────────
def open_file_location(path: str) -> None:
    folder = os.path.dirname(os.path.abspath(path))
    try:
        system = platform.system()
        if system == "Windows":
            subprocess.Popen(["explorer", "/select,", os.path.abspath(path)])
        elif system == "Darwin":
            subprocess.Popen(["open", folder])
        else:
            subprocess.Popen(["xdg-open", folder])
    except OSError as e:
        messagebox.showerror("Open Location", f"Could not open folder:\n{e}")


# ── Main Application ──────────────────────────────────────────────────────────
class BinGallery(tk.Tk):
    def __init__(self):
        super().__init__()
        self.title("MCE Splash Gallery")
        self.geometry("1200x900")
        self.minsize(900, 600)
        self.configure(bg=BG)

        self._cfg = {}
        self._load_config()

        self._scan_root    = tk.StringVar(value=self._cfg.get(
            "scan_root", os.path.join(os.getcwd(), "MemoryCards", "GC")))
        self._sd_root_last = self._cfg.get("sd_card_root", "")

        self._filter_var = tk.StringVar()
        self._filter_var.trace_add("write", lambda *_: self._apply_filter())

        self._hide_alts      = tk.BooleanVar(value=True)
        self._filter_has_raw = tk.BooleanVar(value=False)
        self._filter_has_raw.trace_add("write", lambda *_: self._apply_filter())
        self._current_region = "ALL"
        self._current_letter = "ALL"

        self.game_db    = {}
        # (path, rel, core_serial, db, raw_name, is_alt, has_raw, is_unmatched)
        self._all_items = []
        self._shown     = []
        self._thumbs    = {}
        self._thumb_lock = threading.Lock()

        self.current_page = 0
        self.total_pages  = 1
        self._loading     = False
        self._cols        = 4

        # Build list: path → {serial, db, raw_name, is_unmatched}
        self._build_list: dict = {}

        self._load_json_db()
        self._build_ui()
        self.protocol("WM_DELETE_WINDOW", self._on_close)

    # ── Config ────────────────────────────────────────────────────────────────
    def _load_config(self):
        try:
            with open(CONFIG_FILE, encoding="utf-8") as f:
                self._cfg = json.load(f)
        except (FileNotFoundError, json.JSONDecodeError):
            self._cfg = {}
        raw_col = self._cfg.get("preview_color")
        if isinstance(raw_col, list) and len(raw_col) == 3:
            global PREVIEW_COLOR, PREVIEW_COLOR_HEX
            PREVIEW_COLOR     = tuple(int(c) for c in raw_col)
            PREVIEW_COLOR_HEX = "#{:02x}{:02x}{:02x}".format(*PREVIEW_COLOR)

    def _save_config(self):
        self._cfg["scan_root"]    = self._scan_root.get()
        self._cfg["sd_card_root"] = self._sd_root_last
        self._cfg["preview_color"] = list(PREVIEW_COLOR)
        try:
            with open(CONFIG_FILE, "w", encoding="utf-8") as f:
                json.dump(self._cfg, f, indent=2)
        except Exception as ex:
            print(f"Config save failed: {ex}")

    def _on_close(self):
        self._save_config()
        self.destroy()

    # ── Database ──────────────────────────────────────────────────────────────
    def _load_json_db(self):
        json_path = self._cfg.get("db_path",
                                  resource_path("database.json"))
        if not os.path.exists(json_path):
            json_path = resource_path("database.json")
        if not os.path.exists(json_path):
            print("Notice: database.json not found. Running without titles.")
            return
        try:
            with open(json_path, "r", encoding="utf-8") as f:
                try:
                    data = json.load(f)
                except json.JSONDecodeError:
                    f.seek(0)
                    data = [json.loads(line) for line in f if line.strip()]
            for item in data:
                serial = str(item.get("serial", "")).strip()
                if serial and serial != "-":
                    self.game_db[serial] = {
                        "title":  str(item.get("title",  "")).strip(),
                        "id":     str(item.get("id",     "")).strip(),
                        "region": str(item.get("region", "")).strip(),
                    }
            print(f"Loaded {len(self.game_db)} entries from database.json")
        except Exception as e:
            print(f"Error parsing JSON: {e}")

    # ── Treeview style helper ─────────────────────────────────────────────────
    def _configure_dark_treeview(self, style_name: str = "Dark.Treeview"):
        s = ttk.Style()
        s.configure(style_name,
            background=BG2, foreground=FG, fieldbackground=BG2,
            rowheight=24, font=(FONT, 8), borderwidth=0, relief="flat")
        s.configure(f"{style_name}.Heading",
            background=BG, foreground=FG_DIM, relief="flat",
            font=(FONT, 8, "bold"))
        s.map(style_name,
            background=[("selected", ACCENT)],
            foreground=[("selected", "white")])

    # ── UI Build ──────────────────────────────────────────────────────────────
    def _build_ui(self):
        style = ttk.Style()
        style.theme_use("clam")
        style.configure("TEntry",     fieldbackground=BG2, foreground=FG,
                        insertcolor=FG, bordercolor=BORDER)
        style.configure("TScrollbar", background=BG2, troughcolor=BG,
                        arrowcolor=FG_DIM, bordercolor=BG)
        self._configure_dark_treeview()

        # ── Top bar ───────────────────────────────────────────────────────────
        top = tk.Frame(self, bg=BG, pady=8, padx=12)
        top.pack(fill="x")
        tk.Label(top, text="MCE Splash Gallery", font=F_TITLE,
                 fg=ACCENT2, bg=BG).pack(side="left")

        btn_frame = tk.Frame(top, bg=BG)
        btn_frame.pack(side="right")
        self.btn_alt_toggle = self._btn(btn_frame, "Hide Alternatives", self._toggle_alts)
        self.btn_alt_toggle.pack(side="left", padx=4)
        self._update_alt_btn_ui()
        self._btn(btn_frame, "Missing Splash Files", self._show_missing_bins,
                  color=BG2, fg=MISSING_RED).pack(side="left", padx=4)
        self._btn(btn_frame, "Missing RAW Files", self._show_missing_raw,
                  color=BG2, fg=MISSING_RED).pack(side="left", padx=4)
        self._btn(btn_frame, "Compare to SD", self._compare_to_sd,
                  color=BG2, fg=ACCENT2).pack(side="left", padx=4)
        self._btn(btn_frame, "Auto Fill SD", self._auto_fill_sd).pack(side="left", padx=4)
        self.btn_build_list = self._btn(btn_frame, "📋 Build List (0)",
                                        self._open_build_list,
                                        color=BG2, fg=BUILDER_CLR)
        self.btn_build_list.pack(side="left", padx=4)
        self._btn(btn_frame, "Choose Folder", self._pick_folder).pack(side="left", padx=4)
        self._btn(btn_frame, "Rescan",        self._start_scan).pack(side="left", padx=4)
        self._btn(btn_frame, "⚙ Settings",   self._open_settings,
                  color=BG2, fg=FG_DIM).pack(side="left", padx=4)

        # ── Filter bar ────────────────────────────────────────────────────────
        bar = tk.Frame(self, bg=BG2, padx=12, pady=6)
        bar.pack(fill="x")
        tk.Label(bar, text="DIR:", fg=FG_DIM, bg=BG2, font=F_SMALL).pack(side="left")
        tk.Label(bar, textvariable=self._scan_root, fg=FG, bg=BG2,
                 font=F_SMALL, anchor="w").pack(side="left", padx=(4, 10))
        tk.Label(bar, text="Search:", fg=FG_DIM, bg=BG2, font=F_SMALL).pack(side="left")
        self._filter_entry = tk.Entry(
            bar, textvariable=self._filter_var, bg=BG, fg=FG,
            relief="flat", font=F_SMALL,
            highlightthickness=1, highlightcolor=ACCENT,
            highlightbackground=BORDER, width=20)
        self._filter_entry.pack(side="left", padx=6)

        reg_frame = tk.Frame(bar, bg=BG2)
        reg_frame.pack(side="left", padx=10)
        for r in ["ALL", "USA", "EUR", "JAP"]:
            b = tk.Button(reg_frame, text=r, font=(FONT, 8, "bold"), bg=BG, fg=FG_DIM,
                          relief="flat", padx=6, command=lambda x=r: self._set_region(x))
            b.pack(side="left", padx=2)
            setattr(self, f"reg_btn_{r}", b)
        self._update_region_ui()

        self.btn_has_raw = tk.Button(
            bar, text="Has RAW file", font=(FONT, 8, "bold"),
            bg=BG, fg=FG_DIM, relief="flat", padx=8,
            cursor="hand2", command=self._toggle_has_raw)
        self.btn_has_raw.pack(side="left", padx=(6, 2))
        self._update_has_raw_ui()

        self._status_var = tk.StringVar(value="No scan yet")
        tk.Label(bar, textvariable=self._status_var, fg=FG_ID, bg=BG2,
                 font=F_SMALL).pack(side="right")

        # ── Alpha bar ─────────────────────────────────────────────────────────
        alpha_bar = tk.Frame(self, bg=BG, padx=12, pady=2)
        alpha_bar.pack(fill="x")
        chars = ["ALL", "#"] + [chr(i) for i in range(ord('A'), ord('Z') + 1)] + ["?"]
        for c in chars:
            fg_col  = UNMATCHED_CLR if c == "?" else FG_DIM
            display = "Unmatched" if c == "?" else c
            b = tk.Button(alpha_bar, text=display, font=(FONT, 7, "bold"),
                          bg=BG, fg=fg_col, relief="flat", padx=2,
                          command=lambda x=c: self._set_letter(x))
            b.pack(side="left", expand=True)
            setattr(self, f"let_btn_{c}", b)
        self._update_letter_ui()

        # ── Pagination bar (bottom) ───────────────────────────────────────────
        page_bar = tk.Frame(self, bg=BG2, pady=8)
        page_bar.pack(fill="x", side="bottom")
        self.btn_prev = self._btn(page_bar, "< Previous", self._prev_page)
        self.btn_prev.pack(side="left", padx=20)
        self.lbl_page = tk.Label(page_bar, text="Page 1 / 1", fg=FG, bg=BG2,
                                 font=(FONT, 10, "bold"))
        self.lbl_page.pack(side="left", expand=True)
        self.btn_next = self._btn(page_bar, "Next >", self._next_page)
        self.btn_next.pack(side="right", padx=20)

        # ── Scrollable grid ───────────────────────────────────────────────────
        container = tk.Frame(self, bg=BG)
        container.pack(fill="both", expand=True, padx=8, pady=6)
        self._vscroll = ttk.Scrollbar(container, orient="vertical")
        self._vscroll.pack(side="right", fill="y")
        self._canvas = tk.Canvas(container, bg=BG, highlightthickness=0,
                                 yscrollcommand=self._vscroll.set)
        self._canvas.pack(side="left", fill="both", expand=True)
        self._vscroll.config(command=self._canvas.yview)
        self._grid_frame = tk.Frame(self._canvas, bg=BG)
        self._canvas_window = self._canvas.create_window(
            (0, 0), window=self._grid_frame, anchor="nw")

        self._grid_frame.bind("<Configure>",
            lambda e: self._canvas.configure(scrollregion=self._canvas.bbox("all")))
        self._canvas.bind("<Configure>", self._on_canvas_resize)
        self._canvas.bind("<MouseWheel>",
            lambda e: self._canvas.yview_scroll(-1 * (e.delta // 120), "units"))
        self._canvas.bind("<Button-4>",
            lambda e: self._canvas.yview_scroll(-1, "units"))
        self._canvas.bind("<Button-5>",
            lambda e: self._canvas.yview_scroll(1, "units"))

    def _btn(self, parent, text, cmd, color=BG2, fg=FG):
        return tk.Button(parent, text=text, command=cmd,
                         bg=color, fg=fg,
                         activebackground=ACCENT, activeforeground="white",
                         relief="flat", font=F_BODY, padx=12, pady=4,
                         cursor="hand2")

    def _pick_folder(self):
        d = filedialog.askdirectory(initialdir=self._scan_root.get())
        if d:
            self._scan_root.set(d)
            self._save_config()

    # ── Filter toggles ────────────────────────────────────────────────────────
    def _toggle_alts(self):
        self._hide_alts.set(not self._hide_alts.get())
        self._update_alt_btn_ui()
        self._apply_filter()

    def _update_alt_btn_ui(self):
        self.btn_alt_toggle.config(
            text="Hidden Alts"  if self._hide_alts.get() else "Showing Alts",
            fg=FG_DIM           if self._hide_alts.get() else ACCENT2)

    def _toggle_has_raw(self):
        self._filter_has_raw.set(not self._filter_has_raw.get())
        self._update_has_raw_ui()
        self._apply_filter()

    def _update_has_raw_ui(self):
        if self._filter_has_raw.get():
            self.btn_has_raw.config(fg=RAW_GREEN, bg=CARD_BG)
        else:
            self.btn_has_raw.config(fg=FG_DIM, bg=BG)

    def _set_region(self, r):
        self._current_region = r
        self._update_region_ui()
        self._apply_filter()

    def _update_region_ui(self):
        for r in ["ALL", "USA", "EUR", "JAP"]:
            btn = getattr(self, f"reg_btn_{r}")
            btn.config(fg=ACCENT2 if r == self._current_region else FG_DIM,
                       bg=CARD_BG if r == self._current_region else BG)

    def _set_letter(self, c):
        self._current_letter = c
        self._update_letter_ui()
        self._apply_filter()

    def _update_letter_ui(self):
        chars = ["ALL", "#"] + [chr(i) for i in range(ord('A'), ord('Z') + 1)] + ["?"]
        for c in chars:
            btn = getattr(self, f"let_btn_{c}", None)
            if btn is None:
                continue
            active = (c == self._current_letter)
            if c == "?":
                btn.config(fg=UNMATCHED_CLR, bg=CARD_BG if active else BG)
            else:
                btn.config(fg=ACCENT2 if active else FG_DIM,
                           bg=CARD_BG if active else BG)

    # ── Build List management ─────────────────────────────────────────────────
    def _add_to_build_list(self, path, serial, db, raw_name, is_unmatched):
        self._build_list[path] = {
            "serial": serial, "db": db,
            "raw_name": raw_name, "is_unmatched": is_unmatched,
        }
        count = len(self._build_list)
        self.btn_build_list.config(text=f"📋 Build List ({count})")

    def _remove_from_build_list(self, path):
        self._build_list.pop(path, None)
        count = len(self._build_list)
        self.btn_build_list.config(text=f"📋 Build List ({count})")

    def _in_build_list(self, path) -> bool:
        return path in self._build_list

    # ── SD destination picker ─────────────────────────────────────────────────
    def _pick_destination(self, parent=None) -> tuple:
        """
        Show a small dialog asking whether to target an SD card or the local
        SDBuilder folder.  Returns (gc_path, label) or (None, None) if cancelled.
        """
        result = [None, None]

        dlg = tk.Toplevel(parent or self)
        dlg.title("Choose Destination")
        dlg.geometry("520x240")
        dlg.configure(bg=BG)
        dlg.resizable(False, False)
        dlg.transient(parent or self)

        tk.Label(dlg, text="WHERE TO COPY?", font=F_HEAD,
                 fg=ACCENT2, bg=BG, padx=20, pady=14).pack(anchor="w")

        info = tk.Frame(dlg, bg=BG2, padx=20, pady=10)
        info.pack(fill="x")
        dest_var = tk.StringVar(value="")
        tk.Label(info, textvariable=dest_var, fg=ACCENT2, bg=BG2,
                 font=F_SMALL, wraplength=460, justify="left").pack(anchor="w")

        def _set_sd():
            d = filedialog.askdirectory(
                title="Select SD Card (or MemoryCards or MemoryCards/GC folder)",
                initialdir=self._sd_root_last or os.getcwd(),
                parent=dlg)
            if not d:
                return
            gc = resolve_sd_gc(d)
            dest_var.set(f"SD Card → {gc}")
            result[0] = gc
            result[1] = "SD"

        def _set_builder():
            gc = sdbuilder_gc()
            dest_var.set(f"SDBuilder → {gc}")
            result[0] = gc
            result[1] = "SDBuilder"

        btns = tk.Frame(dlg, bg=BG, pady=10, padx=20)
        btns.pack(fill="x")
        self._btn(btns, "💾  Select SD Card",
                  _set_sd, color=ACCENT, fg="white").pack(side="left", padx=(0, 8))
        self._btn(btns, f"🗂  Use {SDBUILDER_NAME}/ folder",
                  _set_builder, color=BG2, fg=BUILDER_CLR).pack(side="left")

        confirm_row = tk.Frame(dlg, bg=BG, pady=6, padx=20)
        confirm_row.pack(fill="x")
        tk.Label(confirm_row,
                 text="Select a destination above, then click Confirm.",
                 fg=FG_DIM, bg=BG, font=F_TINY).pack(side="left")

        def _confirm():
            if result[0] is None:
                messagebox.showwarning("No Destination",
                    "Please select a destination first.", parent=dlg)
                return
            if result[1] == "SD":
                self._sd_root_last = result[0]
                self._save_config()
            dlg.destroy()

        self._btn(confirm_row, "Confirm", _confirm,
                  color=ACCENT, fg="white").pack(side="right")
        self._btn(confirm_row, "Cancel",
                  lambda: (result.__setitem__(0, None), dlg.destroy()),
                  color=BG2).pack(side="right", padx=(0, 6))

        dlg.grab_set()
        dlg.wait_window()
        return result[0], result[1]

    # ── Unified file-copy helper ──────────────────────────────────────────────
    def _collect_copy_pairs(self, src_path: str, serial: str, raw_name: str,
                            gc_root: str,
                            include_alts: bool,
                            include_raw: bool,
                            include_ini: bool) -> list:
        """
        Build a list of (src, dst) pairs for one game entry.

        Always copies the main .bin.
        Optionally copies -1/-2/… .bin alts, .raw, and .ini files.
        Destination is gc_root/<serial>/<filename>.
        """
        dest_dir = os.path.join(gc_root, serial)
        src_dir  = os.path.dirname(src_path)
        pairs    = []

        def _add(src, dst_name):
            pairs.append((src, os.path.join(dest_dir, dst_name)))

        # Main .bin
        _add(src_path, raw_name)

        if include_alts:
            # Every other .bin in the same folder whose stem starts with the serial
            for f in sorted(os.listdir(src_dir)):
                if f == raw_name:
                    continue
                if f.upper().startswith(serial.upper()) and \
                   f.lower().endswith(".bin"):
                    _add(os.path.join(src_dir, f), f)

        if include_ini:
            # serial.ini or raw_name.ini companion
            for ini_name in [raw_name.replace(".bin", ".ini"),
                             serial + ".ini"]:
                ini_path = os.path.join(src_dir, ini_name)
                if os.path.exists(ini_path):
                    _add(ini_path, ini_name)
                    break

        if include_raw:
            for f in sorted(os.listdir(src_dir)):
                if f.lower().endswith(".raw"):
                    _add(os.path.join(src_dir, f), f)

        return pairs

    # ── Scanning ──────────────────────────────────────────────────────────────
    def _start_scan(self):
        if self._loading:
            return
        self._loading = True
        self._status_var.set("Scanning...")
        self._all_items.clear()
        threading.Thread(target=self._scan_thread, daemon=True).start()

    def _scan_thread(self):
        root    = self._scan_root.get()
        pattern = os.path.join(root, SCAN_GLOB)
        found   = []
        try:
            for p in glob.glob(pattern, recursive=True):
                if os.path.isfile(p) and os.path.getsize(p) == BIN_SIZE:
                    rel          = os.path.relpath(p, root)
                    base_name    = os.path.basename(p)
                    raw_serial   = base_name.replace(".bin", "").upper()
                    match        = re.search(r'-(\d+)$', raw_serial)
                    core_serial  = re.sub(r'-\d+$', '', raw_serial)
                    is_alt       = bool(match)
                    has_raw      = bool(_find_raw_files(p))
                    is_unmatched = core_serial not in self.game_db
                    db_info      = dict(self.game_db.get(core_serial, {}))
                    alt_tag      = f" (Alt {match.group(1)})" if match else ""
                    if "title" in db_info:
                        db_info["title"] += alt_tag
                    else:
                        db_info["title"] = base_name
                    found.append((p, rel, core_serial, db_info,
                                  base_name, is_alt, has_raw, is_unmatched))
        except Exception as e:
            self.after(0, lambda: self._status_var.set(f"Error: {e}"))
            self._loading = False
            return

        found.sort(key=lambda x: x[3].get("title", x[1]).lower())
        self._all_items = found
        self.after(0, self._apply_filter)
        self.after(0, lambda: self._prune_cache(found))
        self._loading = False

    def _apply_filter(self):
        q        = self._filter_var.get().lower()
        reg      = self._current_region
        let      = self._current_letter
        hide     = self._hide_alts.get()
        need_raw = self._filter_has_raw.get()

        self._shown = []
        hidden_count = 0

        for item in self._all_items:
            path, rel, serial, db, raw_name, is_alt, has_raw, is_unmatched = item
            title   = db.get("title",  "").lower()
            game_id = db.get("id",     "").lower()
            region  = db.get("region", "Unknown").upper()

            if hide and is_alt:
                hidden_count += 1
                continue
            if need_raw and not has_raw:
                continue
            if reg != "ALL" and reg not in region:
                continue
            if let == "?":
                if not is_unmatched:
                    continue
            elif let != "ALL":
                first_char = title[0].upper() if title else ""
                if let == "#":
                    if not first_char.isdigit():
                        continue
                elif first_char != let:
                    continue
            if q and not (q in rel.lower() or q in serial.lower()
                          or q in raw_name.lower() or q in title or q in game_id):
                continue
            self._shown.append(item)

        self.total_pages  = max(1, math.ceil(len(self._shown) / ITEMS_PER_PAGE))
        self.current_page = 0
        unmatched_count = sum(1 for i in self._all_items if i[7])
        raw_suffix = "  [Has RAW]" if need_raw else ""
        self._status_var.set(
            f"{len(self._shown)} files  (hidden: {hidden_count})"
            f"  |  unmatched: {unmatched_count}{raw_suffix}")
        self._rebuild_grid()

    # ── Build List window ─────────────────────────────────────────────────────
    def _open_build_list(self):
        win = tk.Toplevel(self)
        win.title(f"Build List  —  {len(self._build_list)} items")
        win.geometry("1060x700")
        win.configure(bg=BG)

        hdr = tk.Frame(win, bg=BG, padx=16, pady=10)
        hdr.pack(fill="x")
        tk.Label(hdr, text="BUILD LIST", font=F_HEAD, fg=BUILDER_CLR, bg=BG).pack(side="left")
        self._btn(hdr, "Close", win.destroy).pack(side="right")
        tk.Label(hdr,
                 text="  Select items then copy to SD card or local SDBuilder folder.",
                 fg=FG_DIM, bg=BG, font=F_SMALL).pack(side="left")

        # ── Options bar ───────────────────────────────────────────────────────
        opts = tk.Frame(win, bg=BG2, padx=16, pady=8)
        opts.pack(fill="x")

        inc_alts = tk.BooleanVar(value=False)
        inc_raw  = tk.BooleanVar(value=True)
        inc_ini  = tk.BooleanVar(value=True)

        for var, label in [(inc_alts, "Include Alt .bin (-1/-2…)"),
                           (inc_raw,  "Include .raw channels"),
                           (inc_ini,  "Include .ini companion")]:
            tk.Checkbutton(opts, text=label, variable=var,
                           bg=BG2, fg=FG, selectcolor=BG,
                           activebackground=BG2, activeforeground=FG,
                           font=F_SMALL).pack(side="left", padx=(0, 12))

        # ── Treeview ──────────────────────────────────────────────────────────
        self._configure_dark_treeview("BL.Treeview")
        cols = ("sel", "title", "serial", "region", "path")
        tv_frame = tk.Frame(win, bg=BG)
        tv_frame.pack(fill="both", expand=True, padx=8, pady=4)

        vsb = ttk.Scrollbar(tv_frame, orient="vertical")
        vsb.pack(side="right", fill="y")
        tree = ttk.Treeview(tv_frame, columns=cols, show="headings",
                            style="BL.Treeview", selectmode="extended",
                            yscrollcommand=vsb.set)
        tree.pack(side="left", fill="both", expand=True)
        vsb.config(command=tree.yview)

        tree.heading("sel",    text="✓")
        tree.heading("title",  text="Title")
        tree.heading("serial", text="Serial")
        tree.heading("region", text="Region")
        tree.heading("path",   text="Source Path")
        tree.column("sel",    width=30,  anchor="c", stretch=False)
        tree.column("title",  width=300, anchor="w")
        tree.column("serial", width=180, anchor="w")
        tree.column("region", width=120, anchor="w")
        tree.column("path",   width=0,   anchor="w", stretch=True)

        tree.tag_configure("odd",  background=BG)
        tree.tag_configure("even", background=BG2)
        tree.tag_configure("checked",   foreground=RAW_GREEN)
        tree.tag_configure("unchecked", foreground=FG)

        checked = set()   # iids that are checked

        def _refresh_tree():
            for iid in tree.get_children():
                tree.delete(iid)
            checked.clear()
            for i, (path, info) in enumerate(self._build_list.items()):
                serial = info["serial"]
                db     = info["db"]
                tag    = "odd" if i % 2 == 0 else "even"
                iid    = str(i)
                tree.insert("", "end", iid=iid, tags=(tag,), values=(
                    "☑", db.get("title", info["raw_name"]),
                    serial, db.get("region", "-"), path))
                checked.add(iid)

            win.title(f"Build List  —  {len(self._build_list)} items")

        def _toggle_check(event):
            iid = tree.identify_row(event.y)
            if not iid:
                return
            if iid in checked:
                checked.discard(iid)
                tree.set(iid, "sel", "☐")
            else:
                checked.add(iid)
                tree.set(iid, "sel", "☑")

        tree.bind("<Button-1>", _toggle_check)
        tree.bind("<MouseWheel>",
            lambda e: tree.yview_scroll(-1 * (e.delta // 120), "units"))
        tree.bind("<Button-4>", lambda e: tree.yview_scroll(-1, "units"))
        tree.bind("<Button-5>", lambda e: tree.yview_scroll(1, "units"))

        # Double-click → open preview
        def _on_double(event):
            iid = tree.identify_row(event.y)
            if not iid:
                return
            vals = tree.item(iid, "values")
            if not vals:
                return
            src_path = vals[4]
            info = self._build_list.get(src_path)
            if info:
                self._open_preview(src_path, info["serial"],
                                   info["db"], info["raw_name"],
                                   info["is_unmatched"])

        tree.bind("<Double-Button-1>", _on_double)

        # ── Bottom controls ───────────────────────────────────────────────────
        ctrl = tk.Frame(win, bg=BG2, padx=16, pady=8)
        ctrl.pack(fill="x")

        def _get_checked_items():
            items = []
            for iid in list(tree.get_children()):
                if iid in checked:
                    vals = tree.item(iid, "values")
                    if vals:
                        src_path = vals[4]
                        info = self._build_list.get(src_path)
                        if info:
                            items.append((src_path, info))
            return items

        def _remove_selected():
            iids = sorted(checked, key=lambda x: int(x), reverse=True)
            paths_to_remove = []
            for iid in iids:
                vals = tree.item(iid, "values")
                if vals:
                    paths_to_remove.append(vals[4])
            for p in paths_to_remove:
                self._remove_from_build_list(p)
            _refresh_tree()

        def _copy_checked(gc_root, label):
            items = _get_checked_items()
            if not items:
                messagebox.showwarning("Nothing Selected",
                    "Check at least one item first.", parent=win)
                return
            pairs = []
            for src_path, info in items:
                pairs += self._collect_copy_pairs(
                    src_path, info["serial"], info["raw_name"],
                    gc_root,
                    include_alts=inc_alts.get(),
                    include_raw=inc_raw.get(),
                    include_ini=inc_ini.get())

            def _done(n, errors):
                msg = f"Copied {n} file(s) to {label}."
                if errors:
                    msg += "\n\nErrors:\n" + "\n".join(errors[:10])
                messagebox.showinfo("Copy Complete", msg, parent=win)

            self._run_copy_async(pairs, win, _done)

        def _copy_to_dest():
            gc_root, label = self._pick_destination(win)
            if gc_root is None:
                return
            _copy_checked(gc_root, label)

        def _select_all():
            for iid in tree.get_children():
                checked.add(iid)
                tree.set(iid, "sel", "☑")

        def _select_none():
            checked.clear()
            for iid in tree.get_children():
                tree.set(iid, "sel", "☐")

        def _clear_list():
            if not self._build_list:
                return
            if messagebox.askyesno("Clear List",
                    "Remove all items from the build list?", parent=win):
                self._build_list.clear()
                self.btn_build_list.config(text="📋 Build List (0)")
                _refresh_tree()

        self._btn(ctrl, "✔ Copy Checked to SD / Builder",
                  _copy_to_dest, color=ACCENT, fg="white").pack(side="left", padx=(0, 8))
        self._btn(ctrl, "🗑 Remove Selected", _remove_selected,
                  color=BG2, fg=MISSING_RED).pack(side="left", padx=(0, 8))
        self._btn(ctrl, "Clear All", _clear_list,
                  color=BG2, fg=FG_DIM).pack(side="left")

        self._btn(ctrl, "None",  _select_none, color=BG2).pack(side="right", padx=2)
        self._btn(ctrl, "All",   _select_all,  color=BG2).pack(side="right", padx=2)
        tk.Label(ctrl, text="Select:", fg=FG_DIM, bg=BG2,
                 font=F_SMALL).pack(side="right", padx=(8, 0))

        _refresh_tree()
        win.grab_set()

    # ── Missing BINs window ───────────────────────────────────────────────────
    def _show_missing_bins(self):
        win = tk.Toplevel(self)
        win.title("Missing Splash Files")
        win.geometry("1060x720")
        win.configure(bg=BG)

        hdr = tk.Frame(win, bg=BG, padx=16, pady=10)
        hdr.pack(fill="x")
        tk.Label(hdr, text="MISSING SPLASH FILES", font=F_HEAD,
                 fg=MISSING_RED, bg=BG).pack(side="left")
        self._btn(hdr, "Close", win.destroy).pack(side="right")

        # SD cross-reference bar
        sd_bar = tk.Frame(win, bg=BG2, padx=16, pady=6)
        sd_bar.pack(fill="x")
        sd_gc_var = tk.StringVar(value="")
        tk.Label(sd_bar, text="SD card (optional cross-check):",
                 fg=FG_DIM, bg=BG2, font=F_SMALL).pack(side="left")
        sd_lbl = tk.Label(sd_bar, textvariable=sd_gc_var, fg=ACCENT2, bg=BG2,
                          font=F_SMALL, anchor="w")
        sd_lbl.pack(side="left", padx=(6, 12))

        def _pick_sd():
            d = filedialog.askdirectory(
                title="Select SD Card for cross-check",
                initialdir=self._sd_root_last or os.getcwd(),
                parent=win)
            if d:
                sd_gc_var.set(resolve_sd_gc(d))
                _populate()

        self._btn(sd_bar, "Pick SD…", _pick_sd, color=BG2, fg=ACCENT2).pack(side="left")

        sub = tk.Frame(win, bg=BG, padx=16, pady=4)
        sub.pack(fill="x")
        count_var = tk.StringVar(value="")
        tk.Label(sub, textvariable=count_var, fg=FG_DIM, bg=BG,
                 font=F_SMALL).pack(side="left")
        self._btn(sub, "⟳  Refresh", lambda: _populate(),
                  color=BG2, fg=ACCENT2).pack(side="right")

        # Treeview
        self._configure_dark_treeview("MBin.Treeview")
        columns = ("title", "serial", "id", "region", "on_sd", "expected")
        tv_frame = tk.Frame(win, bg=BG)
        tv_frame.pack(fill="both", expand=True, padx=8, pady=(4, 8))

        vsb = ttk.Scrollbar(tv_frame, orient="vertical")
        vsb.pack(side="right", fill="y")
        hsb = ttk.Scrollbar(tv_frame, orient="horizontal")
        hsb.pack(side="bottom", fill="x")
        tree = ttk.Treeview(tv_frame, columns=columns, show="headings",
                            style="MBin.Treeview", selectmode="browse",
                            yscrollcommand=vsb.set, xscrollcommand=hsb.set)
        tree.pack(side="left", fill="both", expand=True)
        vsb.config(command=tree.yview)
        hsb.config(command=tree.xview)

        tree.tag_configure("odd",    background=BG)
        tree.tag_configure("even",   background=BG2)
        tree.tag_configure("on_sd",  foreground=RAW_GREEN)

        _sort_state = {"col": None, "rev": False}

        COL_LABELS = {"title": "Title", "serial": "Serial", "id": "Game ID",
                      "region": "Region", "on_sd": "On SD?", "expected": "Expected Folder"}
        COL_WIDTHS = {"title": 280, "serial": 160, "id": 70,
                      "region": 120, "on_sd": 60, "expected": 0}

        def _sort(col):
            items = [(tree.set(iid, col), iid) for iid in tree.get_children("")]
            rev = _sort_state["rev"] if _sort_state["col"] == col else False
            items.sort(key=lambda x: x[0].lower(), reverse=rev)
            for idx, (_, iid) in enumerate(items):
                tree.move(iid, "", idx)
                existing_tags = list(tree.item(iid, "tags"))
                row_tag = "odd" if idx % 2 == 0 else "even"
                other_tags = [t for t in existing_tags
                              if t not in ("odd", "even")]
                tree.item(iid, tags=[row_tag] + other_tags)
            _sort_state["col"] = col
            _sort_state["rev"] = not rev
            for c in columns:
                arrow = (" ↑" if c == col and not rev else
                         " ↓" if c == col and rev else "")
                tree.heading(c, text=COL_LABELS[c] + arrow)

        for c in columns:
            tree.heading(c, text=COL_LABELS[c], command=lambda x=c: _sort(x))
            tree.column(c, width=COL_WIDTHS[c], anchor="w",
                        stretch=(c == "expected"))

        tree.bind("<MouseWheel>",
            lambda e: tree.yview_scroll(-1 * (e.delta // 120), "units"))
        tree.bind("<Button-4>", lambda e: tree.yview_scroll(-1, "units"))
        tree.bind("<Button-5>", lambda e: tree.yview_scroll(1, "units"))

        def _populate():
            for iid in tree.get_children():
                tree.delete(iid)

            scan_root = self._scan_root.get()
            sd_gc     = sd_gc_var.get()

            # Collect serials present in local source
            found_serials = set()
            if os.path.isdir(scan_root):
                for sd in os.listdir(scan_root):
                    sp = os.path.join(scan_root, sd)
                    if os.path.isdir(sp) and glob.glob(os.path.join(sp, "*.bin")):
                        found_serials.add(sd.upper())
            for item in self._all_items:
                found_serials.add(item[2])

            missing = []
            for serial, info in self.game_db.items():
                if serial not in found_serials:
                    expected = os.path.join(scan_root, serial)
                    # Cross-check SD
                    on_sd = False
                    if sd_gc and os.path.isdir(sd_gc):
                        sd_serial_dir = os.path.join(sd_gc, serial)
                        on_sd = bool(glob.glob(os.path.join(sd_serial_dir, "*.bin")))
                    missing.append((serial, info, expected, on_sd))

            missing.sort(key=lambda x: x[1].get("title", x[0]).lower())
            count_var.set(f"  {len(missing)} DB entries have no matching .bin in scan folder")
            win.title(f"Missing Splash Files  —  {len(missing)} entries")

            for i, (serial, info, expected, on_sd) in enumerate(missing):
                row_tag  = "odd" if i % 2 == 0 else "even"
                tags     = (row_tag, "on_sd") if on_sd else (row_tag,)
                sd_text  = "✓ Yes" if on_sd else ("—" if not sd_gc else "No")
                tree.insert("", "end", iid=f"row_{i}",
                            values=(info.get("title", "-"), serial,
                                    info.get("id", "-"), info.get("region", "-"),
                                    sd_text, expected),
                            tags=tags)

        _populate()
        win.grab_set()

    # ── Missing RAW window ────────────────────────────────────────────────────
    def _show_missing_raw(self):
        ENC_COLOR = {"JPN": "#e8c07d", "World": "#7dc8e8"}

        def _encoding(region: str) -> str:
            r = region.lower()
            return "JPN" if any(k in r for k in ("japan", "asia", "korea")) else "World"

        win = tk.Toplevel(self)
        win.title("Missing RAW Files")
        win.geometry("1020x700")
        win.configure(bg=BG)

        hdr = tk.Frame(win, bg=BG, padx=16, pady=10)
        hdr.pack(fill="x")
        tk.Label(hdr, text="MISSING RAW FILES", font=F_HEAD,
                 fg=MISSING_RED, bg=BG).pack(side="left")
        self._btn(hdr, "Close", win.destroy).pack(side="right")

        sub = tk.Frame(win, bg=BG2, padx=16, pady=6)
        sub.pack(fill="x")
        info_var = tk.StringVar(value="  Click Scan to check folders for missing .raw files")
        tk.Label(sub, textvariable=info_var, fg=FG_DIM, bg=BG2,
                 font=F_SMALL).pack(side="left")
        self._btn(sub, "⟳  Scan / Refresh", lambda: _generate(),
                  color=BG, fg=ACCENT2).pack(side="right")
        self._btn(sub, "💾  Save Report", lambda: _save_report(),
                  color=BG, fg=FG_DIM).pack(side="right", padx=(0, 6))

        self._configure_dark_treeview("MRaw.Treeview")
        columns = ("title", "serial", "region", "encoding")
        tv_frame = tk.Frame(win, bg=BG)
        tv_frame.pack(fill="both", expand=True, padx=8, pady=(4, 8))

        vsb = ttk.Scrollbar(tv_frame, orient="vertical")
        vsb.pack(side="right", fill="y")
        hsb = ttk.Scrollbar(tv_frame, orient="horizontal")
        hsb.pack(side="bottom", fill="x")
        tree = ttk.Treeview(tv_frame, columns=columns, show="headings",
                            style="MRaw.Treeview", selectmode="browse",
                            yscrollcommand=vsb.set, xscrollcommand=hsb.set)
        tree.pack(side="left", fill="both", expand=True)
        vsb.config(command=tree.yview)
        hsb.config(command=tree.xview)

        tree.tag_configure("odd",  background=BG)
        tree.tag_configure("even", background=BG2)
        tree.tag_configure("JPN",   foreground=ENC_COLOR["JPN"])
        tree.tag_configure("World", foreground=ENC_COLOR["World"])

        _sort_state = {"col": None, "rev": False}

        def _col_label_raw(c):
            return {"title": "Title", "serial": "Serial",
                    "region": "Region", "encoding": "Encoding"}[c]

        def _sort(col):
            items = [(tree.set(iid, col), iid) for iid in tree.get_children("")]
            rev = _sort_state["rev"] if _sort_state["col"] == col else False
            items.sort(key=lambda x: x[0].lower(), reverse=rev)
            for idx, (_, iid) in enumerate(items):
                tree.move(iid, "", idx)
                enc = tree.set(iid, "encoding")
                tree.item(iid, tags=("odd" if idx % 2 == 0 else "even", enc))
            _sort_state["col"] = col
            _sort_state["rev"] = not rev
            for c in columns:
                arrow = (" ↑" if c == col and not rev else
                         " ↓" if c == col and rev else "")
                tree.heading(c, text=_col_label_raw(c) + arrow)

        for c in columns:
            tree.heading(c, text=_col_label_raw(c), command=lambda x=c: _sort(x))
            tree.column(c, width={"title": 360, "serial": 200,
                                  "region": 180, "encoding": 80}[c],
                        anchor="w", stretch=(c == "title"))

        tree.bind("<MouseWheel>",
            lambda e: tree.yview_scroll(-1 * (e.delta // 120), "units"))
        tree.bind("<Button-4>", lambda e: tree.yview_scroll(-1, "units"))
        tree.bind("<Button-5>", lambda e: tree.yview_scroll(1, "units"))

        _cached_entries = []

        def _render(entries):
            for iid in tree.get_children():
                tree.delete(iid)
            for i, e in enumerate(entries):
                enc = e["encoding"]
                tree.insert("", "end", iid=f"raw_{i}",
                            values=(e["title"], e["serial"], e["region"], enc),
                            tags=("odd" if i % 2 == 0 else "even", enc))

        def _generate():
            gc_root = self._scan_root.get()
            if not os.path.isdir(gc_root):
                messagebox.showerror("Error",
                    f"Scan folder not found:\n{gc_root}", parent=win)
                return
            info_var.set("  Scanning…")
            win.update_idletasks()
            entries = []
            for serial, info in self.game_db.items():
                folder = os.path.join(gc_root, serial)
                if os.path.isdir(folder) and \
                   not glob.glob(os.path.join(folder, "*.raw")):
                    enc = _encoding(info.get("region", ""))
                    entries.append({"serial": serial,
                                    "title": info.get("title", "-"),
                                    "region": info.get("region", "-"),
                                    "encoding": enc, "folder": folder})
            entries.sort(key=lambda x: x["title"].lower())
            _cached_entries.clear()
            _cached_entries.extend(entries)
            _render(entries)
            win.title(f"Missing RAW Files  —  {len(entries)} folders")
            info_var.set(
                f"  {len(entries)} serial folders exist but have no .raw"
                f"  |  scanned: {datetime.datetime.now():%Y-%m-%d %H:%M:%S}")

        def _save_report():
            if not _cached_entries:
                messagebox.showinfo("Save Report",
                    "No data to save — run Scan first.", parent=win)
                return
            report = {"generated": datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S"),
                      "scan_root": self._scan_root.get(),
                      "count": len(_cached_entries), "entries": _cached_entries}
            try:
                with open(REPORT_FILE, "w", encoding="utf-8") as f:
                    json.dump(report, f, indent=2)
                messagebox.showinfo("Saved",
                    f"Report saved to:\n{REPORT_FILE}", parent=win)
            except Exception as ex:
                messagebox.showerror("Save Failed", str(ex), parent=win)

        if os.path.exists(REPORT_FILE):
            try:
                with open(REPORT_FILE, encoding="utf-8") as f:
                    cached = json.load(f)
                entries = cached.get("entries", [])
                _cached_entries.extend(entries)
                _render(entries)
                win.title(f"Missing RAW Files  —  {cached.get('count', 0)} (cached)")
                info_var.set(
                    f"  Cached  |  {cached.get('count', 0)} folders without .raw"
                    f"  |  Generated: {cached.get('generated', 'unknown')}"
                    f"  |  Click Scan to refresh")
            except Exception:
                info_var.set("  Cached report unreadable — click Scan to generate.")
        else:
            info_var.set("  No cached report — click Scan to generate.")

        win.grab_set()

    # ── Compare Source → SD Card ──────────────────────────────────────────────
    def _compare_to_sd(self):
        source_gc = self._scan_root.get()
        if not os.path.isdir(source_gc):
            messagebox.showerror("Compare to SD",
                f"Source folder not found:\n{source_gc}\n\nSet a valid folder first.")
            return

        raw = filedialog.askdirectory(
            title="Select SD Card (root, MemoryCards, or MemoryCards/GC)",
            initialdir=self._sd_root_last or os.getcwd())
        if not raw:
            return
        self._sd_root_last = raw
        self._save_config()

        target_gc = resolve_sd_gc(raw)
        if not os.path.isdir(target_gc):
            messagebox.showerror("Compare to SD",
                f"Resolved target path not found:\n{target_gc}\n\n"
                "Ensure the SD card has a MemoryCards/GC folder.")
            return

        missing = []
        for serial_dir in sorted(os.listdir(source_gc)):
            src_folder = os.path.join(source_gc, serial_dir)
            dst_folder = os.path.join(target_gc, serial_dir)

            if not os.path.isdir(src_folder) or not os.path.isdir(dst_folder):
                continue
            if glob.glob(os.path.join(dst_folder, "*.bin")):
                continue

            serial  = serial_dir.upper()
            db_info = self.game_db.get(serial,
                          {"title": serial, "id": "-", "region": "-"})
            all_src  = glob.glob(os.path.join(src_folder, "*.bin"))
            src_main = [b for b in all_src
                        if not re.search(r'-\d+\.bin$',
                                         os.path.basename(b), re.IGNORECASE)]
            src_alts = [b for b in all_src
                        if re.search(r'-\d+\.bin$',
                                     os.path.basename(b), re.IGNORECASE)]
            missing.append({"serial": serial, "db": db_info,
                             "src_folder": src_folder, "dst_folder": dst_folder,
                             "src_main": sorted(src_main),
                             "src_alts": sorted(src_alts)})

        win = tk.Toplevel(self)
        win.title(f"Compare to SD  —  {len(missing)} missing")
        win.geometry("1050x750")
        win.configure(bg=BG)

        hdr = tk.Frame(win, bg=BG, padx=16, pady=10)
        hdr.pack(fill="x")
        tk.Label(hdr, text="COMPARE: Source → SD Card",
                 font=F_HEAD, fg=ACCENT2, bg=BG).pack(side="left")
        self._btn(hdr, "Close", win.destroy).pack(side="right")

        paths = tk.Frame(win, bg=BG2, padx=16, pady=5)
        paths.pack(fill="x")
        for label, val in [("Source:", source_gc), ("Target:", target_gc)]:
            row = tk.Frame(paths, bg=BG2)
            row.pack(fill="x", pady=1)
            tk.Label(row, text=label, fg=FG_DIM, bg=BG2,
                     font=(FONT, 8, "bold"), width=8, anchor="w").pack(side="left")
            tk.Label(row, text=val, fg=FG, bg=BG2,
                     font=(FONT, 8), anchor="w").pack(side="left")

        summary = tk.Frame(win, bg=BG, padx=16, pady=6)
        summary.pack(fill="x")
        clr = MISSING_RED if missing else RAW_GREEN
        tk.Label(summary,
                 text=f"{len(missing)} folder(s) are missing a .bin on the SD card",
                 fg=clr, bg=BG, font=(FONT, 9, "bold")).pack(side="left")

        if not missing:
            tk.Label(win,
                     text="✓  All matching serial folders already have a .bin on the SD card.",
                     fg=RAW_GREEN, bg=BG, font=(FONT, 10)).pack(pady=60)
            win.grab_set()
            return

        ctrl = tk.Frame(win, bg=BG2, padx=16, pady=8)
        ctrl.pack(fill="x")

        include_alts_var = tk.BooleanVar(value=False)
        include_raw_var  = tk.BooleanVar(value=False)
        include_ini_var  = tk.BooleanVar(value=True)
        tk.Checkbutton(ctrl, text="Include alt .bin (-1/-2…)",
                       variable=include_alts_var,
                       bg=BG2, fg=FG, selectcolor=BG,
                       activebackground=BG2, activeforeground=FG,
                       font=F_SMALL).pack(side="left")
        tk.Checkbutton(ctrl, text="Include .raw",
                       variable=include_raw_var,
                       bg=BG2, fg=FG, selectcolor=BG,
                       activebackground=BG2, activeforeground=FG,
                       font=F_SMALL).pack(side="left", padx=(8, 0))
        tk.Checkbutton(ctrl, text="Include .ini",
                       variable=include_ini_var,
                       bg=BG2, fg=FG, selectcolor=BG,
                       activebackground=BG2, activeforeground=FG,
                       font=F_SMALL).pack(side="left", padx=(8, 0))

        row_vars = {}

        def _build_pairs_cmp(entries):
            pairs = []
            for e in entries:
                for src in e["src_main"]:
                    serial   = e["serial"]
                    raw_name = os.path.basename(src)
                    pairs += self._collect_copy_pairs(
                        src, serial, raw_name, os.path.dirname(e["dst_folder"]),
                        include_alts=include_alts_var.get(),
                        include_raw=include_raw_var.get(),
                        include_ini=include_ini_var.get())
                    break  # one main per entry
            return pairs

        def _copy_entries(entries):
            pairs = _build_pairs_cmp(entries)
            if not pairs:
                messagebox.showwarning("Nothing to copy",
                    "No source .bin files found.", parent=win)
                return
            def _done(n, errors):
                msg = f"Copied {n} file(s)."
                if errors:
                    msg += "\n\nErrors:\n" + "\n".join(errors[:10])
                messagebox.showinfo("Copy Complete", msg, parent=win)
            self._run_copy_async(pairs, win, _done)

        def _copy_selected():
            selected = [missing[i] for i, v in row_vars.items() if v.get()]
            if not selected:
                messagebox.showwarning("Nothing selected",
                    "Tick at least one entry.", parent=win)
                return
            _copy_entries(selected)

        def _copy_all():
            if messagebox.askyesno("Copy All",
                    f"Copy .bin files for all {len(missing)} missing entries?",
                    parent=win):
                _copy_entries(missing)

        self._btn(ctrl, "Copy Selected", _copy_selected).pack(side="right", padx=4)
        self._btn(ctrl, "Copy All", _copy_all,
                  color=ACCENT, fg="white").pack(side="right", padx=4)

        def _select_all():
            for v in row_vars.values(): v.set(True)
        def _select_none():
            for v in row_vars.values(): v.set(False)

        self._btn(ctrl, "None", _select_none, color=BG2).pack(side="right", padx=2)
        self._btn(ctrl, "All",  _select_all,  color=BG2).pack(side="right", padx=2)
        tk.Label(ctrl, text="Select:", fg=FG_DIM, bg=BG2,
                 font=F_SMALL).pack(side="right", padx=(8, 0))

        col_hdr = tk.Frame(win, bg=BG, padx=16, pady=4)
        col_hdr.pack(fill="x")
        tk.Label(col_hdr, text="✓", fg=FG_DIM, bg=BG,
                 font=(FONT, 8), width=3).pack(side="left")
        for txt, w in [("Title", 38), ("Serial / (ID)", 26),
                       ("Region", 18), ("Source files", 0)]:
            tk.Label(col_hdr, text=txt, fg=FG_DIM, bg=BG,
                     font=(FONT, 8, "bold"), width=w, anchor="w").pack(side="left")

        outer = tk.Frame(win, bg=BG)
        outer.pack(fill="both", expand=True, padx=8, pady=(0, 8))

        vscroll = ttk.Scrollbar(outer, orient="vertical")
        vscroll.pack(side="right", fill="y")
        list_cv = tk.Canvas(outer, bg=BG, highlightthickness=0,
                            yscrollcommand=vscroll.set)
        list_cv.pack(side="left", fill="both", expand=True)
        vscroll.config(command=list_cv.yview)

        inner     = tk.Frame(list_cv, bg=BG)
        inner_win = list_cv.create_window((0, 0), window=inner, anchor="nw")

        inner.bind("<Configure>",
            lambda e: list_cv.configure(scrollregion=list_cv.bbox("all")))
        list_cv.bind("<Configure>",
            lambda e: list_cv.itemconfig(inner_win, width=e.width))
        list_cv.bind("<MouseWheel>",
            lambda e: list_cv.yview_scroll(-1 * (e.delta // 120), "units"))
        list_cv.bind("<Button-4>", lambda e: list_cv.yview_scroll(-1, "units"))
        list_cv.bind("<Button-5>", lambda e: list_cv.yview_scroll(1, "units"))

        for i, entry in enumerate(missing):
            row_bg = BG if i % 2 == 0 else BG2
            db     = entry["db"]
            title_text = db.get("title", entry["serial"])
            if len(title_text) > 38:
                title_text = title_text[:35] + "..."
            game_id = db.get("id", "-")
            region  = db.get("region", "-")
            n_main  = len(entry["src_main"])
            n_alts  = len(entry["src_alts"])
            files_note = (f"{n_main} main" +
                          (f" + {n_alts} alt(s)" if n_alts else ""))

            row = tk.Frame(inner, bg=row_bg, padx=8, pady=4)
            row.pack(fill="x")

            var = tk.BooleanVar(value=False)
            row_vars[i] = var
            tk.Checkbutton(row, variable=var, bg=row_bg,
                           activebackground=row_bg,
                           selectcolor=BG).pack(side="left", padx=(0, 4))
            tk.Label(row, text=title_text, fg=ACCENT2, bg=row_bg,
                     font=(FONT, 8, "bold"), width=38, anchor="w").pack(side="left")
            tk.Label(row, text=f"{entry['serial']} / ({game_id})",
                     fg=FG_DIM, bg=row_bg,
                     font=(FONT, 8), width=26, anchor="w").pack(side="left")
            tk.Label(row, text=region, fg=GREEN_REG, bg=row_bg,
                     font=(FONT, 8), width=18, anchor="w").pack(side="left")
            tk.Label(row, text=files_note, fg=FG_ID, bg=row_bg,
                     font=(FONT, 7), anchor="w").pack(side="left", fill="x")

        win.grab_set()

    # ── Cache pruning ─────────────────────────────────────────────────────────
    def _prune_cache(self, found_items):
        known = {os.path.basename(p) for p, *_ in found_items}
        pruned = 0
        try:
            for cache_png in glob.glob(os.path.join(CACHE_DIR, "*.bin.png")):
                bin_name = os.path.basename(cache_png)[:-4]
                if bin_name not in known:
                    try:
                        os.remove(cache_png)
                        pruned += 1
                    except OSError:
                        pass
        except Exception:
            pass
        if pruned:
            print(f"Cache: pruned {pruned} stale thumbnail(s).")

    # ── Async copy helper ─────────────────────────────────────────────────────
    def _run_copy_async(self, file_pairs, parent_win, on_complete):
        # Deduplicate pairs keeping last writer wins
        seen = {}
        for src, dst in file_pairs:
            seen[dst] = src
        file_pairs = [(src, dst) for dst, src in seen.items()]
        total = len(file_pairs)
        if total == 0:
            on_complete(0, [])
            return

        prog = tk.Toplevel(parent_win)
        prog.title("Copying Files…")
        prog.geometry("520x160")
        prog.configure(bg=BG)
        prog.resizable(False, False)
        prog.transient(parent_win)

        hdr = tk.Frame(prog, bg=BG, padx=20, pady=10)
        hdr.pack(fill="x")
        tk.Label(hdr, text="Copying Files", font=F_HEAD,
                 fg=ACCENT2, bg=BG).pack(side="left")

        status_var = tk.StringVar(value="Preparing…")
        tk.Label(prog, textvariable=status_var, fg=FG_DIM, bg=BG,
                 font=F_SMALL, anchor="w").pack(fill="x", padx=20)

        s = ttk.Style()
        s.configure("Copy.Horizontal.TProgressbar",
                    troughcolor=BG2, background=ACCENT2,
                    bordercolor=BORDER, darkcolor=ACCENT2, lightcolor=ACCENT2)
        bar_var = tk.IntVar(value=0)
        bar = ttk.Progressbar(prog, variable=bar_var, maximum=total,
                               mode="determinate", length=480,
                               style="Copy.Horizontal.TProgressbar")
        bar.pack(padx=20, pady=(4, 6))

        count_var = tk.StringVar(value=f"0 / {total}")
        tk.Label(prog, textvariable=count_var, fg=FG, bg=BG,
                 font=(FONT, 8)).pack()

        cancel_flag = [False]
        self._btn(prog, "Cancel",
                  lambda: cancel_flag.__setitem__(0, True),
                  color=BG2, fg=MISSING_RED).pack(pady=8)

        errors = []

        def _update(n, name):
            bar_var.set(n)
            status_var.set(f"→  {name}")
            count_var.set(f"{n} / {total}")

        def _work():
            n = 0
            for src, dst in file_pairs:
                if cancel_flag[0]:
                    break
                try:
                    os.makedirs(os.path.dirname(dst), exist_ok=True)
                    shutil.copy2(src, dst)
                    n += 1
                except Exception as ex:
                    errors.append(f"{os.path.basename(src)}: {ex}")
                self.after(0, lambda i=n, s=os.path.basename(src): _update(i, s))
            self.after(0, lambda nd=n: _finish(nd))

        def _finish(n_done):
            prog.destroy()
            on_complete(n_done, errors)

        threading.Thread(target=_work, daemon=True).start()
        prog.grab_set()

    # ── Settings window ───────────────────────────────────────────────────────
    def _open_settings(self):
        win = tk.Toplevel(self)
        win.title("Settings")
        win.geometry("680x380")
        win.configure(bg=BG)
        win.resizable(False, False)

        tk.Label(win, text="SETTINGS", font=F_HEAD, fg=ACCENT2, bg=BG,
                 padx=20, pady=12).pack(anchor="w")

        form = tk.Frame(win, bg=BG, padx=20)
        form.pack(fill="both", expand=True)
        form.columnconfigure(1, weight=1)

        def _row(label, row):
            tk.Label(form, text=label, fg=FG_DIM, bg=BG,
                     font=(FONT, 8, "bold"), anchor="e",
                     width=18).grid(row=row, column=0, sticky="e",
                                    pady=6, padx=(0, 8))

        def _entry(row, default):
            var = tk.StringVar(value=default)
            e = tk.Entry(form, textvariable=var, bg=BG2, fg=FG,
                         relief="flat", font=(FONT, 8),
                         highlightthickness=1, highlightcolor=ACCENT,
                         highlightbackground=BORDER)
            e.grid(row=row, column=1, sticky="ew", pady=6)
            return var

        def _browse_dir(var):
            d = filedialog.askdirectory(initialdir=var.get() or os.getcwd())
            if d:
                var.set(d)

        def _browse_file(var, filetypes):
            p = filedialog.askopenfilename(
                initialdir=os.path.dirname(var.get()) or os.getcwd(),
                filetypes=filetypes)
            if p:
                var.set(p)

        def _browse_btn(row, col, callback):
            self._btn(form, "Browse…", callback,
                      color=BG2).grid(row=row, column=col, padx=(6, 0), pady=6)

        _row("Scan Root (GC/):", 0)
        scan_var = _entry(0, self._scan_root.get())
        _browse_btn(0, 2, lambda: _browse_dir(scan_var))

        _row("Default SD Root:", 1)
        sd_var = _entry(1, self._sd_root_last)
        _browse_btn(1, 2, lambda: _browse_dir(sd_var))

        _row("database.json:", 2)
        default_db = self._cfg.get("db_path",
                                   resource_path("database.json"))
        db_var = _entry(2, default_db)
        _browse_btn(2, 2, lambda: _browse_file(
            db_var, [("JSON files", "*.json"), ("All files", "*.*")]))

        _row("Preview Pixel Colour:", 3)
        col_var = _entry(3, PREVIEW_COLOR_HEX)
        col_preview = tk.Label(form, text="  ████  ", bg=PREVIEW_COLOR_HEX,
                               fg=PREVIEW_COLOR_HEX, font=(FONT, 8), relief="flat")
        col_preview.grid(row=3, column=2, padx=(6, 0))

        def _preview_colour(*_):
            h = col_var.get().strip()
            try:
                col_preview.config(bg=h, fg=h)
            except tk.TclError:
                pass
        col_var.trace_add("write", _preview_colour)

        tk.Frame(win, bg=BORDER, height=1).pack(fill="x", padx=20, pady=(8, 0))
        tk.Label(win,
                 text="Preview colour change takes effect immediately.  "
                      "Rescan to regenerate thumbnails with the new colour.",
                 fg=FG_DIM, bg=BG, font=(FONT, 7), padx=20,
                 wraplength=600, justify="left").pack(anchor="w", pady=(4, 0))

        btns = tk.Frame(win, bg=BG, padx=20, pady=10)
        btns.pack(fill="x")

        def _apply():
            global PREVIEW_COLOR, PREVIEW_COLOR_HEX
            hex_val = col_var.get().strip()
            try:
                r = int(hex_val.lstrip("#")[0:2], 16)
                g = int(hex_val.lstrip("#")[2:4], 16)
                b = int(hex_val.lstrip("#")[4:6], 16)
                PREVIEW_COLOR     = (r, g, b)
                PREVIEW_COLOR_HEX = f"#{r:02x}{g:02x}{b:02x}"
            except (ValueError, IndexError):
                messagebox.showwarning("Invalid colour",
                    f"Could not parse '{hex_val}'.  Use format #rrggbb.",
                    parent=win)
                return
            self._scan_root.set(scan_var.get())
            self._sd_root_last   = sd_var.get()
            self._cfg["db_path"] = db_var.get()
            self._save_config()
            if PREVIEW_COLOR != tuple(self._cfg.get("preview_color", [])):
                try:
                    for f in glob.glob(os.path.join(CACHE_DIR, "*.png")):
                        os.remove(f)
                    print("Cache cleared for colour change.")
                except Exception:
                    pass
            win.destroy()

        self._btn(btns, "Apply & Save", _apply,
                  color=ACCENT, fg="white").pack(side="right", padx=(8, 0))
        self._btn(btns, "Cancel", win.destroy).pack(side="right")
        win.grab_set()

    # ── Auto Fill ─────────────────────────────────────────────────────────────
    def _auto_fill_sd(self):
        raw = filedialog.askdirectory(
            title="Select SD Card (root, MemoryCards, or MemoryCards/GC)",
            initialdir=self._sd_root_last or os.getcwd())
        if not raw:
            return
        self._sd_root_last = raw
        self._save_config()

        sd_gc = resolve_sd_gc(raw)
        if not os.path.exists(sd_gc):
            messagebox.showerror("Error",
                f"Resolved path not found:\n{sd_gc}\n\n"
                "Ensure the SD card has a MemoryCards/GC folder.")
            return

        local_bins = {}
        for path, rel, core_serial, db, raw_name, is_alt, has_raw, is_unmatched \
                in self._all_items:
            if core_serial not in local_bins or not is_alt:
                local_bins[core_serial] = (path, raw_name)

        file_pairs = []
        for folder_name in os.listdir(sd_gc):
            folder_path = os.path.join(sd_gc, folder_name)
            if not os.path.isdir(folder_path):
                continue
            serial_key = folder_name.upper()
            if glob.glob(os.path.join(folder_path, "*.bin")):
                continue
            if serial_key not in local_bins:
                continue
            src_bin, raw_name = local_bins[serial_key]
            file_pairs += self._collect_copy_pairs(
                src_bin, serial_key, raw_name,
                os.path.dirname(folder_path),
                include_alts=False, include_raw=False, include_ini=True)

        if not file_pairs:
            messagebox.showinfo("Auto Fill",
                "Nothing to copy — all folders already have a .bin.")
            return

        def _done(n, errors):
            msg = f"Auto Fill complete.\nCopied {n} file(s)."
            if errors:
                msg += "\n\nErrors:\n" + "\n".join(errors[:10])
            messagebox.showinfo("Auto Fill Complete", msg)

        self._run_copy_async(file_pairs, self, _done)

    # ── Pagination & Grid ─────────────────────────────────────────────────────
    def _prev_page(self):
        if self.current_page > 0:
            self.current_page -= 1
            self._rebuild_grid()

    def _next_page(self):
        if self.current_page < self.total_pages - 1:
            self.current_page += 1
            self._rebuild_grid()

    def _update_pagination_ui(self):
        self.lbl_page.config(
            text=f"Page {self.current_page + 1} of {self.total_pages}")
        self.btn_prev.config(
            state="normal" if self.current_page > 0 else "disabled")
        self.btn_next.config(
            state="normal" if self.current_page < self.total_pages - 1
            else "disabled")

    def _on_canvas_resize(self, event):
        new_cols = max(1, event.width // (CARD_W + 8))
        if new_cols != self._cols:
            self._cols = new_cols
            self._rebuild_grid()
        self._canvas.itemconfig(self._canvas_window, width=event.width)

    def _rebuild_grid(self):
        for w in self._grid_frame.winfo_children():
            w.destroy()
        self._thumbs.clear()

        if not self._shown:
            msg = ("No unmatched .bin files found."
                   if self._current_letter == "?" else "No matches.")
            tk.Label(self._grid_frame, text=msg, font=F_BODY,
                     fg=FG_DIM, bg=BG).pack(pady=80)
            self._update_pagination_ui()
            return

        self._update_pagination_ui()
        start_idx  = self.current_page * ITEMS_PER_PAGE
        page_items = self._shown[start_idx: start_idx + ITEMS_PER_PAGE]

        canvas_w   = self._canvas.winfo_width() or 900
        self._cols = max(1, canvas_w // (CARD_W + 8))

        for idx, item in enumerate(page_items):
            path, rel, serial, db, raw_name, is_alt, has_raw, is_unmatched = item
            row, col = divmod(idx, self._cols)
            card = self._make_card(path, serial, db, raw_name, is_unmatched)
            card.grid(row=row, column=col, padx=6, pady=6, sticky="nw")

        threading.Thread(target=self._preload_page_thumbs,
                         args=(page_items,), daemon=True).start()

    def _make_card(self, path, serial, db, raw_name, is_unmatched=False):
        raw_channels = _find_raw_files(path)
        border_color = UNMATCHED_CLR if is_unmatched else BORDER
        in_list      = self._in_build_list(path)

        card = tk.Frame(self._grid_frame, bg=CARD_BG, cursor="hand2",
                        width=CARD_W)

        img_cv = tk.Canvas(card, width=THUMB_W, height=THUMB_H, bg="#000000",
                           highlightthickness=1,
                           highlightbackground=border_color)
        img_cv.pack(padx=CARD_PAD, pady=(CARD_PAD, 4))
        placeholder_id = img_cv.create_text(
            THUMB_W // 2, THUMB_H // 2,
            text="...", fill=FG_DIM, font=(FONT, 14))

        display_title = db.get("title", raw_name)
        if len(display_title) > 35:
            display_title = display_title[:32] + "..."

        title_color = UNMATCHED_CLR if is_unmatched else ACCENT2
        lbl_title = tk.Label(card, text=display_title,
                             fg=title_color, bg=CARD_BG,
                             font=("Arial", 9, "bold"),
                             wraplength=CARD_W - 8)
        lbl_title.pack(padx=4, pady=(0, 2))

        if is_unmatched:
            lbl_badge = tk.Label(card, text="⚠ UNMATCHED",
                                 fg=UNMATCHED_CLR, bg=CARD_BG,
                                 font=(FONT, 6, "bold"))
            lbl_badge.pack()
        else:
            lbl_badge = None

        id_reg_frame = tk.Frame(card, bg=CARD_BG)
        id_reg_frame.pack()
        lbl_id_tag = tk.Label(id_reg_frame, text="ID:",
                              fg=FG_DIM, bg=CARD_BG, font=(FONT, 7))
        lbl_id_tag.pack(side="left")
        lbl_id_val = tk.Label(id_reg_frame, text=db.get("id", "N/A"),
                              fg=FG_ID, bg=CARD_BG, font=(FONT, 7, "bold"))
        lbl_id_val.pack(side="left", padx=(1, 6))
        lbl_reg_tag = tk.Label(id_reg_frame, text="Region:",
                               fg=FG_DIM, bg=CARD_BG, font=(FONT, 7))
        lbl_reg_tag.pack(side="left")
        lbl_reg_val = tk.Label(id_reg_frame, text=db.get("region", "N/A"),
                               fg=GREEN_REG, bg=CARD_BG, font=(FONT, 7, "bold"))
        lbl_reg_val.pack(side="left", padx=(1, 0))

        lbl_serial = tk.Label(card, text=serial, fg=FG_DIM, bg=CARD_BG,
                              font=(FONT, 7))
        lbl_serial.pack(pady=(1, 2))

        # Build-list indicator
        list_fg = BUILDER_CLR if in_list else FG_DIM
        lbl_list = tk.Label(card,
                            text="📋 In List" if in_list else "  + Add to List",
                            fg=list_fg, bg=CARD_BG, font=(FONT, 6, "bold"),
                            cursor="hand2")
        lbl_list.pack(pady=(0, 2))

        raw_widgets = []
        if raw_channels:
            sep = tk.Frame(card, bg=BORDER, height=1)
            sep.pack(fill="x", padx=CARD_PAD, pady=(2, 3))
            raw_widgets.append(sep)
            hdr_frame = tk.Frame(card, bg=CARD_BG)
            hdr_frame.pack(anchor="w", padx=CARD_PAD)
            raw_widgets.append(hdr_frame)
            lbl_check = tk.Label(hdr_frame, text="✓", fg=RAW_GREEN,
                                 bg=CARD_BG, font=(FONT, 8, "bold"))
            lbl_check.pack(side="left", padx=(0, 2))
            raw_widgets.append(lbl_check)
            for ch_num, ch_name in raw_channels:
                lbl_ch = tk.Label(card,
                                  text=f"  Channel {ch_num}: {ch_name}",
                                  fg=RAW_GREEN, bg=CARD_BG, font=(FONT, 6),
                                  anchor="w")
                lbl_ch.pack(fill="x", padx=CARD_PAD)
                raw_widgets.append(lbl_ch)

        tk.Frame(card, bg=CARD_BG, height=4).pack()

        base_widgets = [card, img_cv, lbl_title, id_reg_frame,
                        lbl_id_tag, lbl_id_val, lbl_reg_tag, lbl_reg_val,
                        lbl_serial, lbl_list]
        if lbl_badge:
            base_widgets.append(lbl_badge)
        all_widgets = base_widgets + raw_widgets

        card_str = str(card)

        def _apply_bg(bg, border_col):
            try:
                card.config(bg=bg)
                img_cv.config(highlightbackground=border_col)
                for w in all_widgets[1:]:
                    try:
                        w.config(bg=bg)
                    except tk.TclError:
                        pass
            except tk.TclError:
                pass

        def on_enter(_):
            _apply_bg(BG2, UNMATCHED_CLR if is_unmatched else ACCENT)

        def on_leave(event):
            try:
                widget_under = event.widget.winfo_containing(
                    event.x_root, event.y_root)
                if widget_under is not None:
                    wu = str(widget_under)
                    if wu == card_str or wu.startswith(card_str + "."):
                        return
            except tk.TclError:
                pass
            _apply_bg(CARD_BG, border_color)

        def on_click(_):
            self._open_preview(path, serial, db, raw_name, is_unmatched)

        def on_list_click(event):
            event.widget.after(1, lambda: None)  # suppress bubble
            if self._in_build_list(path):
                self._remove_from_build_list(path)
                lbl_list.config(text="  + Add to List", fg=FG_DIM)
            else:
                self._add_to_build_list(path, serial, db, raw_name, is_unmatched)
                lbl_list.config(text="📋 In List", fg=BUILDER_CLR)
            return "break"

        lbl_list.bind("<Button-1>", on_list_click)

        for w in all_widgets:
            try:
                w.bind("<Enter>",    on_enter)
                w.bind("<Leave>",    on_leave)
            except tk.TclError:
                pass

        # Cards themselves open preview; list button intercepts its own click
        for w in [card, img_cv, lbl_title, id_reg_frame,
                  lbl_id_tag, lbl_id_val, lbl_reg_tag, lbl_reg_val,
                  lbl_serial] + ([lbl_badge] if lbl_badge else []) + raw_widgets:
            try:
                w.bind("<Button-1>", on_click)
            except tk.TclError:
                pass

        card._img_canvas     = img_cv
        card._placeholder_id = placeholder_id
        card._path           = path
        return card

    def _preload_page_thumbs(self, page_items):
        for item in page_items:
            path = item[0]
            if path not in self._thumbs:
                thumb = make_thumb(path)
                with self._thumb_lock:
                    self._thumbs[path] = thumb
                self.after(0, lambda p=path: self._put_thumb(p))

    def _put_thumb(self, path):
        for card in self._grid_frame.winfo_children():
            if getattr(card, "_path", None) == path:
                thumb = self._thumbs.get(path)
                cv    = card._img_canvas
                cv.delete(card._placeholder_id)
                if thumb:
                    cv.create_image(THUMB_W // 2, THUMB_H // 2,
                                    image=thumb, anchor="center")
                    cv.image = thumb
                break

    # ── Preview Window ────────────────────────────────────────────────────────
    def _open_preview(self, path: str, core_serial: str, db: dict,
                      raw_name: str, is_unmatched: bool = False):
        win = tk.Toplevel(self)
        win.title("Preview: " + db.get("title", raw_name))
        win.configure(bg=BG)
        win.resizable(False, False)

        try:
            with open(path, "rb") as f:
                bin_data = f.read()
        except Exception as e:
            tk.Label(win, text=f"Could not load file:\n{e}",
                     fg="red", bg=BG, font=F_SMALL).pack(padx=30, pady=30)
            win.grab_set()
            return

        if len(bin_data) != BIN_SIZE:
            tk.Label(win,
                     text=f"Bad file size: {len(bin_data)} bytes (expected {BIN_SIZE})",
                     fg="red", bg=BG, font=F_SMALL).pack(padx=30, pady=30)
            win.grab_set()
            return

        splash_rgba = _data_to_rgba(bin_data[COLOR_TABLE_LEN:])

        # Header
        header = tk.Frame(win, bg=BG, padx=16, pady=10)
        header.pack(fill="x")
        title_color = UNMATCHED_CLR if is_unmatched else ACCENT2
        tk.Label(header, text="PREVIEW", font=F_HEAD,
                 fg=title_color, bg=BG).pack(side="left")
        if is_unmatched:
            tk.Label(header, text="  ⚠ Unmatched — not in database",
                     fg=UNMATCHED_CLR, bg=BG, font=F_SMALL).pack(side="left")

        # Two-panel image row
        content_row = tk.Frame(win, bg=BG)
        content_row.pack(padx=16, pady=4)

        scaled_outer = tk.LabelFrame(
            content_row, text=f"Scaled Preview ({PREVIEW_SCALE}x)",
            bg=BG, fg=ACCENT, font=(FONT, 9, "bold"), padx=4, pady=4)
        scaled_outer.pack(side="left", anchor="n")

        scaled_cv = tk.Canvas(scaled_outer, width=PW, height=PH,
                              bg="#000000", highlightthickness=2,
                              highlightbackground=ACCENT)
        scaled_cv.pack()
        win._tk_scaled = ImageTk.PhotoImage(
            Image.fromarray(splash_rgba, "RGBA").resize((PW, PH), Image.NEAREST))
        scaled_cv.create_image(0, 0, image=win._tk_scaled, anchor="nw")

        # 1:1 hardware frame
        hw_frame_path = _find_hw_frame_png()
        hw_loaded = False
        if hw_frame_path:
            try:
                hw_bg         = Image.open(hw_frame_path).convert("RGBA")
                fw, fh        = hw_bg.size
                win._hw_bg_tk = ImageTk.PhotoImage(hw_bg)
                hw_loaded = True
            except Exception:
                hw_loaded = False

        if not hw_loaded:
            fw, fh        = OUT_W + 40, OUT_H + 40
            win._hw_bg_tk = None

        hw_outer = tk.LabelFrame(
            content_row, text="Hardware Preview (1:1)",
            bg=BG, fg=ACCENT, font=(FONT, 9, "bold"), padx=6, pady=6)
        hw_outer.pack(side="left", anchor="n", padx=(12, 0))

        hw_cv = tk.Canvas(hw_outer, width=fw, height=fh,
                          bg="#0d0d1a", highlightthickness=1,
                          highlightbackground=BORDER)
        hw_cv.pack()

        if hw_loaded and win._hw_bg_tk:
            hw_cv.create_image(0, 0, image=win._hw_bg_tk, anchor="nw")

        splash_x = (fw - OUT_W) // 2
        splash_y = (SPLASH_Y_OFFSET
                    if (hw_loaded and fh > SPLASH_Y_OFFSET + OUT_H)
                    else (fh - OUT_H) // 2)

        win._tk_hw = ImageTk.PhotoImage(Image.fromarray(splash_rgba, "RGBA"))
        hw_cv.create_image(splash_x, splash_y, image=win._tk_hw, anchor="nw")

        if not hw_loaded:
            tk.Label(hw_outer,
                     text="gcmcepr.png / gcmepr.png not found\nin working directory",
                     fg=FG_DIM, bg=BG, font=(FONT, 7), justify="center").pack(
                         pady=(4, 0))

        # Info section
        info = tk.Frame(win, bg=BG, padx=16, pady=8)
        info.pack(fill="x")

        tk.Label(info, text=db.get("title", raw_name),
                 fg=title_color, font=("Arial", 11, "bold"), bg=BG,
                 wraplength=PW + fw + 20, justify="left").pack(
                     anchor="w", pady=(0, 6))

        stats = tk.Frame(info, bg=BG)
        stats.pack(fill="x")
        for row_i, (lbl_text, key, color) in enumerate([
            ("Game ID:",     "id",     FG_ID),
            ("Region:",      "region", GREEN_REG),
            ("Serial:", None,          FG),
        ]):
            tk.Label(stats, text=lbl_text, fg=FG_DIM, bg=BG,
                     font=(FONT, 8)).grid(row=row_i, column=0, sticky="e")
            val = db.get(key, "N/A") if key else core_serial
            tk.Label(stats, text=val, fg=color, bg=BG,
                     font=(FONT, 8, "bold")).grid(
                         row=row_i, column=1, sticky="w", padx=5)

        raw_channels = _find_raw_files(path)
        if raw_channels:
            tk.Frame(info, bg=BORDER, height=1).pack(fill="x", pady=(8, 4))
            hdr_f = tk.Frame(info, bg=BG)
            hdr_f.pack(anchor="w")
            tk.Label(hdr_f, text="  Memory Channels",
                     fg=RAW_GREEN, bg=BG, font=(FONT, 8, "bold")).pack(side="left")
            for ch_num, ch_name in raw_channels:
                tk.Label(info, text=f"   Channel {ch_num}: {ch_name}",
                         fg=RAW_GREEN, bg=BG, font=(FONT, 8)).pack(
                             anchor="w", pady=(1, 0))

        tk.Label(info, text=path, fg="#55556a", font=(FONT, 7),
                 bg=BG, wraplength=PW + fw + 20, justify="left").pack(
                     anchor="w", pady=(10, 0))

        # ── Copy to SD controls ───────────────────────────────────────────────
        copy_opts = tk.Frame(win, bg=BG2, padx=16, pady=8)
        copy_opts.pack(fill="x")

        copy_alts_var = tk.BooleanVar(value=False)
        copy_raw_var  = tk.BooleanVar(value=bool(raw_channels))
        copy_ini_var  = tk.BooleanVar(value=True)

        tk.Label(copy_opts, text="Copy options:", fg=FG_DIM, bg=BG2,
                 font=F_SMALL).pack(side="left")
        for var, label in [(copy_alts_var, "Include Alt .bin (-1/-2…)"),
                           (copy_raw_var,  "Include .raw"),
                           (copy_ini_var,  "Include .ini")]:
            tk.Checkbutton(copy_opts, text=label, variable=var,
                           bg=BG2, fg=FG, selectcolor=BG,
                           activebackground=BG2, activeforeground=FG,
                           font=F_SMALL).pack(side="left", padx=(8, 0))

        def execute_copy_to_sd():
            gc_root, label = self._pick_destination(win)
            if gc_root is None:
                return
            pairs = self._collect_copy_pairs(
                path, core_serial, raw_name, gc_root,
                include_alts=copy_alts_var.get(),
                include_raw=copy_raw_var.get(),
                include_ini=copy_ini_var.get())

            # Check for overwrite
            final_pairs = []
            for src, dst in pairs:
                if os.path.exists(dst):
                    if not messagebox.askyesno("Overwrite?",
                            f"Overwrite {os.path.basename(dst)}?", parent=win):
                        continue
                final_pairs.append((src, dst))

            if not final_pairs:
                return

            def _done(n, errors):
                msg = f"Copied {n} file(s) to {label}:\n{gc_root}"
                if errors:
                    msg += "\n\nErrors:\n" + "\n".join(errors[:10])
                messagebox.showinfo("Success", msg, parent=win)

            self._run_copy_async(final_pairs, win, _done)

        # Buttons row
        btn_row = tk.Frame(win, bg=BG, pady=8, padx=16)
        btn_row.pack(fill="x")

        self._btn(btn_row, "💾 Copy to SD / Builder",
                  execute_copy_to_sd, color=ACCENT, fg="white").pack(
                      side="left", padx=(0, 4))

        # Build List toggle
        in_list = self._in_build_list(path)
        list_btn_text = "📋 Remove from List" if in_list else "📋 Add to List"
        list_btn_color = BG2 if not in_list else CARD_BG

        def _toggle_list():
            if self._in_build_list(path):
                self._remove_from_build_list(path)
                list_btn.config(text="📋 Add to List",
                                fg=BUILDER_CLR, bg=BG2)
            else:
                self._add_to_build_list(path, core_serial, db,
                                        raw_name, is_unmatched)
                list_btn.config(text="📋 Remove from List",
                                fg=BUILDER_CLR, bg=CARD_BG)

        list_btn = self._btn(btn_row, list_btn_text, _toggle_list,
                             color=list_btn_color, fg=BUILDER_CLR)
        list_btn.pack(side="left", padx=4)

        # Assign to serial (unmatched only)
        if is_unmatched:
            self._btn(btn_row, "🔗  Assign to Serial…",
                      lambda: self._open_assign_dialog(path, raw_name, win),
                      color=UNMATCHED_CLR, fg="#1e1e2e").pack(side="left", padx=4)

        self._btn(btn_row, "Close [Esc]",
                  win.destroy).pack(side="right", padx=(4, 0))
        self._btn(btn_row, "Copy Path",
                  lambda: (win.clipboard_clear(),
                           win.clipboard_append(path))).pack(side="right", padx=4)
        self._btn(btn_row, "Open Location",
                  lambda: open_file_location(path)).pack(side="right", padx=4)

        win.bind("<Escape>", lambda _: win.destroy())
        win.grab_set()

    # ── Assign Unmatched .bin to a DB serial ──────────────────────────────────
    def _open_assign_dialog(self, src_path: str, raw_name: str,
                            parent_win: tk.Toplevel):
        dlg = tk.Toplevel(parent_win)
        dlg.title("Assign to Serial")
        dlg.geometry("760x560")
        dlg.configure(bg=BG)
        dlg.resizable(True, True)

        hdr = tk.Frame(dlg, bg=BG, padx=16, pady=10)
        hdr.pack(fill="x")
        tk.Label(hdr, text="ASSIGN TO SERIAL", font=F_HEAD,
                 fg=UNMATCHED_CLR, bg=BG).pack(side="left")
        self._btn(hdr, "Cancel", dlg.destroy).pack(side="right")

        info_bar = tk.Frame(dlg, bg=BG2, padx=16, pady=6)
        info_bar.pack(fill="x")
        tk.Label(info_bar, text="File:", fg=FG_DIM, bg=BG2, font=F_SMALL).pack(side="left")
        tk.Label(info_bar, text=raw_name, fg=UNMATCHED_CLR, bg=BG2,
                 font=(FONT, 8, "bold")).pack(side="left", padx=(4, 16))
        tk.Label(info_bar, text="Source:", fg=FG_DIM, bg=BG2, font=F_SMALL).pack(side="left")
        tk.Label(info_bar, text=src_path, fg=FG_DIM, bg=BG2,
                 font=(FONT, 7), anchor="w").pack(side="left", padx=4)

        dest_var = tk.StringVar(value="— select a serial below —")
        dest_bar = tk.Frame(dlg, bg=BG, padx=16, pady=4)
        dest_bar.pack(fill="x")
        tk.Label(dest_bar, text="Destination:", fg=FG_DIM, bg=BG,
                 font=F_SMALL).pack(side="left")
        tk.Label(dest_bar, textvariable=dest_var, fg=ACCENT2, bg=BG,
                 font=(FONT, 8), anchor="w").pack(side="left", padx=4)

        search_row = tk.Frame(dlg, bg=BG, padx=16, pady=6)
        search_row.pack(fill="x")
        tk.Label(search_row, text="Search title / serial / ID:",
                 fg=FG_DIM, bg=BG, font=F_SMALL).pack(side="left")
        search_var = tk.StringVar()
        search_entry = tk.Entry(
            search_row, textvariable=search_var, bg=BG2, fg=FG,
            relief="flat", font=F_SMALL,
            highlightthickness=1, highlightcolor=ACCENT,
            highlightbackground=BORDER, width=40)
        search_entry.pack(side="left", padx=8)
        tk.Label(search_row, text="(double-click or Assign to confirm)",
                 fg=FG_DIM, bg=BG, font=(FONT, 7)).pack(side="left")

        self._configure_dark_treeview("Assign.Treeview")
        tv_columns = ("title", "serial", "id", "region")
        tv_outer = tk.Frame(dlg, bg=BG)
        tv_outer.pack(fill="both", expand=True, padx=8, pady=(0, 4))

        vsb = ttk.Scrollbar(tv_outer, orient="vertical")
        vsb.pack(side="right", fill="y")
        hsb = ttk.Scrollbar(tv_outer, orient="horizontal")
        hsb.pack(side="bottom", fill="x")
        tree = ttk.Treeview(tv_outer, columns=tv_columns, show="headings",
                            style="Assign.Treeview", selectmode="browse",
                            yscrollcommand=vsb.set, xscrollcommand=hsb.set)
        tree.pack(side="left", fill="both", expand=True)
        vsb.config(command=tree.yview)
        hsb.config(command=tree.xview)

        tree.tag_configure("odd",  background=BG)
        tree.tag_configure("even", background=BG2)
        tree.heading("title",  text="Title")
        tree.heading("serial", text="Serial")
        tree.heading("id",     text="Game ID")
        tree.heading("region", text="Region")
        tree.column("title",  width=330, anchor="w", stretch=True)
        tree.column("serial", width=180, anchor="w")
        tree.column("id",     width=80,  anchor="w")
        tree.column("region", width=130, anchor="w")

        tree.bind("<MouseWheel>",
            lambda e: tree.yview_scroll(-1 * (e.delta // 120), "units"))
        tree.bind("<Button-4>", lambda e: tree.yview_scroll(-1, "units"))
        tree.bind("<Button-5>", lambda e: tree.yview_scroll(1, "units"))

        def _update_dest(*_):
            sel = tree.selection()
            if not sel:
                dest_var.set("— select a serial below —")
                return
            target_serial = sel[0]
            dest_dir  = os.path.join(self._scan_root.get(), target_serial)
            filename  = _next_serial_filename(dest_dir, target_serial)
            dest_var.set(os.path.join(dest_dir, filename))

        tree.bind("<<TreeviewSelect>>", _update_dest)

        def _populate(q: str = ""):
            for iid in tree.get_children():
                tree.delete(iid)
            q = q.strip().lower()
            idx = 0
            for serial, info in sorted(self.game_db.items(),
                                        key=lambda x: x[1].get("title", "").lower()):
                title  = info.get("title",  "")
                id_    = info.get("id",     "")
                region = info.get("region", "")
                if q and not (q in title.lower() or q in serial.lower()
                              or q in id_.lower()):
                    continue
                tag = "odd" if idx % 2 == 0 else "even"
                tree.insert("", "end", iid=serial,
                            values=(title, serial, id_, region),
                            tags=(tag,))
                idx += 1

        search_var.trace_add("write", lambda *_: _populate(search_var.get()))
        _populate()
        search_entry.focus_set()

        assign_row = tk.Frame(dlg, bg=BG2, padx=16, pady=8)
        assign_row.pack(fill="x", side="bottom")

        def _do_assign():
            sel = tree.selection()
            if not sel:
                messagebox.showwarning("No Selection",
                    "Please click a serial in the list to select it.",
                    parent=dlg)
                return
            target_serial = sel[0]
            dest_dir  = os.path.join(self._scan_root.get(), target_serial)
            filename  = _next_serial_filename(dest_dir, target_serial)
            dest      = os.path.join(dest_dir, filename)
            info      = self.game_db.get(target_serial, {})
            confirm   = messagebox.askyesno(
                "Confirm Assignment",
                f"Assign  '{raw_name}'\n"
                f"   →  {dest}\n\n"
                f"Title:  {info.get('title', '(unknown)')}\n"
                f"Serial: {target_serial}\n\n"
                "The file will be MOVED (not copied). Continue?",
                parent=dlg)
            if not confirm:
                return
            try:
                os.makedirs(dest_dir, exist_ok=True)
                shutil.move(src_path, dest)
            except Exception as ex:
                messagebox.showerror("Move Failed", str(ex), parent=dlg)
                return
            messagebox.showinfo("Assigned",
                f"File moved successfully:\n{dest}\n\nGallery will rescan now.",
                parent=dlg)
            dlg.destroy()
            parent_win.destroy()
            self._start_scan()

        tree.bind("<Double-Button-1>",
            lambda e: _do_assign() if tree.identify_row(e.y) else None)

        self._btn(assign_row, "🔗  Assign & Move", _do_assign,
                  color=UNMATCHED_CLR, fg="#1e1e2e").pack(side="right")
        tk.Label(assign_row,
                 text="The file will be moved to the destination shown above.",
                 fg=FG_DIM, bg=BG2, font=(FONT, 7)).pack(side="left")

        dlg.grab_set()


# ── Entry point ───────────────────────────────────────────────────────────────
if __name__ == "__main__":
    app = BinGallery()
    app.mainloop()