#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
VideoSnapper — 视频截图工具
============================
- 选择视频 → 展示基本信息 → 截图 → 预览
- 两种截图模式：按平均张数 / 按时间间隔
- 截图以时间命名 (52s.png / 10m.png / 2m28s.png)
- 使用 OpenCV 处理视频 (零外部二进制依赖)
- 预览支持：网格/列表模式、小/中/大三档尺寸、双击放大、右键菜单

打包：PyInstaller 一键打包 (见 build.bat)
"""

import os
import sys
import subprocess
import tkinter as tk
from pathlib import Path
from threading import Thread
from tkinter import (
    Tk, ttk, StringVar, IntVar, filedialog, messagebox, Menu, Toplevel,
)
from tkinter.scrolledtext import ScrolledText

import cv2
from PIL import Image, ImageTk

# ═══════════════════════════════════════════════════════════════
#  工具函数
# ═══════════════════════════════════════════════════════════════

def sec2hms(seconds: float) -> str:
    s = int(round(seconds))
    h, r = divmod(s, 3600)
    m, s_ = divmod(r, 60)
    return f"{h:02d}:{m:02d}:{s_:02d}"


def fmt_size(b: int) -> str:
    for unit in ("B", "KB", "MB", "GB"):
        if b < 1024:
            return f"{b:.1f} {unit}"
        b /= 1024
    return f"{b:.1f} TB"


def format_ts(total_seconds: float) -> str:
    ts = int(round(total_seconds))
    m, s_ = divmod(ts, 60)
    if m == 0:
        return f"{s_}s"
    if s_ == 0:
        return f"{m}m"
    return f"{m}m{s_}s"


# ═══════════════════════════════════════════════════════════════
#  视频处理
# ═══════════════════════════════════════════════════════════════

class VideoReader:
    """基于 OpenCV 的视频读取封装。"""

    def __init__(self, path: str) -> None:
        self.path = path
        self.cap = cv2.VideoCapture(path)
        if not self.cap.isOpened():
            raise ValueError(f"无法打开视频: {path}")

        self.total_frames = int(self.cap.get(cv2.CAP_PROP_FRAME_COUNT))
        self.fps = self.cap.get(cv2.CAP_PROP_FPS)
        self.width = int(self.cap.get(cv2.CAP_PROP_FRAME_WIDTH))
        self.height = int(self.cap.get(cv2.CAP_PROP_FRAME_HEIGHT))

        if self.fps > 0:
            self.duration = self.total_frames / self.fps
        else:
            self.cap.set(cv2.CAP_PROP_POS_AVI_RATIO, 1)
            ms = self.cap.get(cv2.CAP_PROP_POS_MSEC)
            self.duration = ms / 1000.0 if ms > 0 else 0
            self.cap.set(cv2.CAP_PROP_POS_AVI_RATIO, 0)

    def meta(self) -> dict:
        return {
            "文件名": Path(self.path).name,
            "完整路径": self.path,
            "时长": sec2hms(self.duration),
            "时长_秒": round(self.duration, 2),
            "分辨率": f"{self.width}×{self.height}",
            "帧率": f"{self.fps:.2f} fps",
            "总帧数": self.total_frames,
            "大小": fmt_size(os.path.getsize(self.path)),
        }

    def extract_frame(self, timestamp: float, out_path: str) -> bool:
        frame_idx = int(timestamp * self.fps)
        if frame_idx >= self.total_frames:
            frame_idx = self.total_frames - 1
        if frame_idx < 0:
            frame_idx = 0
        self.cap.set(cv2.CAP_PROP_POS_FRAMES, frame_idx)
        ret, frame = self.cap.read()
        if not ret:
            return False
        rgb = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
        img = Image.fromarray(rgb)
        img.save(out_path, "PNG")
        return True

    def close(self) -> None:
        self.cap.release()


def calc_timestamps(duration_s: float, mode: str, param) -> list[float]:
    if duration_s <= 0:
        return []
    if mode == "interval":
        step = float(param)
        return [i * step for i in range(int(duration_s // step) + 1)]
    count = max(1, int(param))
    if count == 1:
        return [duration_s / 2]
    return [duration_s * i / (count - 1) for i in range(count)]


def batch_extract(
    video_reader: VideoReader,
    timestamps: list[float],
    out_dir: str,
    on_progress=None,
) -> list[dict]:
    results = []
    total = len(timestamps)
    for idx, ts in enumerate(timestamps):
        name = format_ts(ts) + ".png"
        dst = os.path.join(out_dir, name)
        ok = video_reader.extract_frame(ts, dst)
        results.append({"ts": ts, "name": name, "path": dst, "ok": ok})
        if on_progress:
            on_progress(idx + 1, total)
    return results


# ═══════════════════════════════════════════════════════════════
#  大图预览窗口
# ═══════════════════════════════════════════════════════════════

class PreviewWindow:
    """双击缩略图弹出的原图预览窗口。"""

    def __init__(self, parent, image_path: str):
        self.win = Toplevel(parent)
        self.win.title(Path(image_path).name)
        self.win.geometry("900x650")
        self.win.minsize(400, 300)

        self.img_path = image_path
        self._zoom = 1.0
        self._orig_size = None

        # 菜单栏
        bar = Menu(self.win)
        self.win.config(menu=bar)
        file_m = Menu(bar, tearoff=False)
        file_m.add_command(label="用系统程序打开", command=self._open_system)
        file_m.add_command(label="打开文件所在位置", command=self._open_location)
        file_m.add_separator()
        file_m.add_command(label="关闭", command=self.win.destroy)
        bar.add_cascade(label="文件", menu=file_m)

        # 缩放控件
        zoom_frame = ttk.Frame(self.win)
        zoom_frame.pack(fill="x", padx=8, pady=4)
        ttk.Button(zoom_frame, text="─ 缩小", command=lambda: self._zoom_to(self._zoom * 0.8)).pack(side="left")
        self._zoom_label = ttk.Label(zoom_frame, text="100%")
        self._zoom_label.pack(side="left", padx=8)
        ttk.Button(zoom_frame, text="+ 放大", command=lambda: self._zoom_to(self._zoom * 1.25)).pack(side="left")
        ttk.Button(zoom_frame, text="适应窗口", command=self._fit_to_window).pack(side="left", padx=(12, 0))
        ttk.Button(zoom_frame, text="原始大小", command=self._original_size).pack(side="left", padx=(4, 0))

        # 图片展示区（可滚动）
        canvas_frame = ttk.Frame(self.win)
        canvas_frame.pack(fill="both", expand=True, padx=4, pady=4)

        self._canvas = tk.Canvas(canvas_frame, bg="#2b2b2b", highlightthickness=0)
        hbar = ttk.Scrollbar(canvas_frame, orient="horizontal", command=self._canvas.xview)
        vbar = ttk.Scrollbar(canvas_frame, orient="vertical", command=self._canvas.yview)
        self._canvas.configure(xscrollcommand=hbar.set, yscrollcommand=vbar.set)

        hbar.pack(side="bottom", fill="x")
        vbar.pack(side="right", fill="y")
        self._canvas.pack(side="left", fill="both", expand=True)

        self._canvas.bind("<ButtonPress-1>", self._drag_start)
        self._canvas.bind("<B1-Motion>", self._drag_move)
        self._canvas.bind("<MouseWheel>", self._on_wheel)      # Windows
        self._canvas.bind("<Button-4>", self._on_wheel_linux)  # Linux up
        self._canvas.bind("<Button-5>", self._on_wheel_linux)  # Linux down

        self._img_on_canvas = None
        self._pil_img = None
        self._tk_img = None
        self._drag_data = {"x": 0, "y": 0}

        self._load_image()
        self._fit_to_window()

    def _load_image(self):
        try:
            self._pil_img = Image.open(self.img_path)
            self._orig_size = self._pil_img.size
        except Exception as e:
            ttk.Label(self._canvas, text=f"加载失败: {e}").pack()
            self._pil_img = None

    def _render(self):
        if self._pil_img is None:
            return
        w = max(1, int(self._orig_size[0] * self._zoom))
        h = max(1, int(self._orig_size[1] * self._zoom))
        resized = self._pil_img.resize((w, h), Image.LANCZOS)
        self._tk_img = ImageTk.PhotoImage(resized)
        self._canvas.delete("img")
        self._img_on_canvas = self._canvas.create_image(0, 0, anchor="nw", image=self._tk_img, tags="img")
        self._canvas.configure(scrollregion=self._canvas.bbox("all"))
        self._zoom_label.config(text=f"{int(self._zoom * 100)}%")

    def _zoom_to(self, factor):
        if self._pil_img is None:
            return
        factor = max(0.05, min(factor, 20.0))
        self._zoom = factor
        self._render()

    def _fit_to_window(self):
        if self._pil_img is None:
            return
        cw = self._canvas.winfo_width() or 800
        ch = self._canvas.winfo_height() or 600
        iw, ih = self._orig_size
        if iw == 0 or ih == 0:
            return
        sx = cw / iw
        sy = ch / ih
        self._zoom = min(sx, sy) * 0.95
        self._render()

    def _original_size(self):
        self._zoom = 1.0
        self._render()

    def _open_system(self):
        p = self.img_path
        try:
            os.startfile(p)
        except AttributeError:
            subprocess.run(["open" if sys.platform == "darwin" else "xdg-open", p])

    def _open_location(self):
        p = os.path.abspath(self.img_path)
        try:
            subprocess.run(["explorer", "/select,", p])
        except Exception:
            try:
                os.startfile(os.path.dirname(p))
            except AttributeError:
                subprocess.run(["open" if sys.platform == "darwin" else "xdg-open", os.path.dirname(p)])

    def _drag_start(self, e):
        self._drag_data["x"] = e.x
        self._drag_data["y"] = e.y

    def _drag_move(self, e):
        dx = e.x - self._drag_data["x"]
        dy = e.y - self._drag_data["y"]
        self._canvas.xview_scroll(-dx, "units")
        self._canvas.yview_scroll(-dy, "units")
        self._drag_data["x"] = e.x
        self._drag_data["y"] = e.y

    def _on_wheel(self, e):
        self._zoom_to(self._zoom * (1.1 if e.delta > 0 else 0.9))

    def _on_wheel_linux(self, e):
        self._zoom_to(self._zoom * (1.1 if e.num == 4 else 0.9))


# ═══════════════════════════════════════════════════════════════
#  主窗口
# ═══════════════════════════════════════════════════════════════

class App:
    # 缩略图尺寸三档
    SIZES = {
        "small":  (180, 101),
        "medium": (320, 180),
        "large":  (480, 270),
    }
    # 缩略图尺寸定义（列数改为动态计算）

    def __init__(self) -> None:
        self.root = Tk()
        self.root.title("VideoSnapper — 视频截图工具")
        self.root.geometry("1000x800")
        self.root.minsize(800, 600)

        # ── 状态 ──
        self.meta: dict = {}
        self._results: list[dict] = []          # 最近截图结果
        self._thumb_cells: list[dict] = []       # 预览区单元格引用
        self._last_outdir: str | None = None
        self._busy = False
        # 列表排序状态
        self._list_sort_col = 'name'
        self._list_sort_rev = False

        # tk 变量
        self.path_var = StringVar()
        self.mode_var = StringVar(value="average")
        self.iv_val = IntVar(value=10)
        self.iv_unit = StringVar(value="秒")
        self.av_count = IntVar(value=12)
        self.view_mode = StringVar(value="grid")    # "grid" | "list"
        self.thumb_size = StringVar(value="small")  # "small" | "medium" | "large"

        self._build_ui()
        self._bind_events()

    # ── 构建界面 ──────────────────────────────────────────────

    def _build_ui(self) -> None:
        root = self.root
        style = ttk.Style()
        style.theme_use("vista" if "vista" in style.theme_names() else "clam")

        # ───── 顶部：视频选择 ─────────────────────────────────
        f_top = ttk.Frame(root, padding=(12, 8))
        f_top.pack(fill="x")

        ttk.Label(f_top, text="视频文件：").pack(side="left")
        self._entry_path = ttk.Entry(f_top, textvariable=self.path_var)
        self._entry_path.pack(side="left", fill="x", expand=True, padx=4)
        ttk.Button(f_top, text="浏览…", command=self._pick_video).pack(side="left")
        ttk.Button(f_top, text="加载", command=self._load_video).pack(side="left", padx=(4, 0))

        # ───── 视频信息 ───────────────────────────────────────
        self._info_frame = ttk.LabelFrame(root, text="视频信息", padding=(8, 4))
        self._info_frame.pack(fill="x", padx=12, pady=(6, 0))
        self._info_text = ScrolledText(
            self._info_frame, height=5, font=("Consolas", 10),
            wrap="word", state="disabled",
        )
        self._info_text.pack(fill="both", expand=True)

        # ───── 截图配置 ───────────────────────────────────────
        f_cfg = ttk.LabelFrame(root, text="截图配置", padding=(8, 4))
        f_cfg.pack(fill="x", padx=12, pady=(6, 0))

        fm = ttk.Frame(f_cfg)
        fm.pack(fill="x", pady=2)
        ttk.Radiobutton(fm, text="平均截图", variable=self.mode_var,
                         value="average", command=self._toggle_mode).pack(side="left", padx=(0, 12))
        ttk.Radiobutton(fm, text="按间隔截图", variable=self.mode_var,
                         value="interval", command=self._toggle_mode).pack(side="left")

        self._f_avg = ttk.Frame(f_cfg)
        self._f_avg.pack(fill="x", pady=2)
        ttk.Label(self._f_avg, text="平均截取").pack(side="left")
        self._e_avg = ttk.Entry(self._f_avg, textvariable=self.av_count, width=6)
        self._e_avg.pack(side="left", padx=4)
        ttk.Label(self._f_avg, text="张（含首尾）").pack(side="left")

        self._f_int = ttk.Frame(f_cfg)
        ttk.Label(self._f_int, text="每隔").pack(side="left")
        self._e_int = ttk.Entry(self._f_int, textvariable=self.iv_val, width=6)
        self._e_int.pack(side="left", padx=4)
        unit_combo = ttk.Combobox(self._f_int, textvariable=self.iv_unit,
                                   values=["秒", "分", "小时"], state="readonly", width=6)
        unit_combo.pack(side="left")
        ttk.Label(self._f_int, text="截一张").pack(side="left", padx=(4, 0))
        self._f_int.pack_forget()

        # ───── 操作按钮 + 视图控制 ────────────────────────────
        f_btn = ttk.Frame(root, padding=(12, 6))
        f_btn.pack(fill="x")

        self._btn_start = ttk.Button(f_btn, text="▶ 开始截图", command=self._start_screenshot)
        self._btn_start.pack(side="left")
        self._btn_open = ttk.Button(f_btn, text="📁 打开输出文件夹",
                                     command=self._open_outdir, state="disabled")
        self._btn_open.pack(side="left", padx=(8, 0))
        ttk.Button(f_btn, text="清空预览", command=self._clear_preview).pack(side="left", padx=(8, 0))

        # ─── 视图控制（右侧） ─────────────────────────────────
        f_view = ttk.Frame(f_btn)
        f_view.pack(side="right")

        ttk.Label(f_view, text="视图：").pack(side="left")
        view_combo = ttk.Combobox(f_view, textvariable=self.view_mode,
                                   values=["grid", "list"], state="readonly", width=6)
        view_combo.pack(side="left", padx=(0, 8))
        view_combo.bind("<<ComboboxSelected>>", lambda _: self._rebuild_preview())

        ttk.Label(f_view, text="大小：").pack(side="left")
        size_combo = ttk.Combobox(f_view, textvariable=self.thumb_size,
                                   values=["small", "medium", "large"],
                                   state="readonly", width=8)
        size_combo.pack(side="left")
        size_combo.bind("<<ComboboxSelected>>", lambda _: self._rebuild_preview())

        # ───── 进度 ───────────────────────────────────────────
        self._progress = ttk.Progressbar(root, mode="determinate")
        self._progress.pack(fill="x", padx=12)
        self._status_var = StringVar(value="就绪")
        ttk.Label(root, textvariable=self._status_var).pack(fill="x", padx=12, pady=(0, 4))

        # ───── 截图预览 ───────────────────────────────────────
        f_preview = ttk.LabelFrame(root, text="截图预览", padding=(6, 4))
        f_preview.pack(fill="both", expand=True, padx=12, pady=(0, 8))

        # 可滚动容器（仅垂直滚动）
        self._preview_canvas = tk.Canvas(f_preview, highlightthickness=0, bg="#f0f0f0")
        vbar = ttk.Scrollbar(f_preview, orient="vertical", command=self._preview_canvas.yview)
        self._preview_canvas.configure(yscrollcommand=vbar.set)

        vbar.pack(side="right", fill="y")
        self._preview_canvas.pack(side="left", fill="both", expand=True)

        self._preview_container = ttk.Frame(self._preview_canvas)
        self._preview_canvas.create_window(0, 0, window=self._preview_container, anchor="nw")

        self._preview_container.bind("<Configure>", self._on_container_configure)
        self._preview_canvas.bind("<Configure>", self._on_canvas_configure)

    def _on_container_configure(self, _=None):
        self._preview_canvas.configure(scrollregion=self._preview_canvas.bbox("all"))

    def _on_canvas_configure(self, e):
        # 网格模式下：容器宽度跟随 canvas
        if self._preview_container.winfo_children():
            old_w = self._preview_container.winfo_width()
            new_w = e.width
            self._preview_container.configure(width=new_w)
            # 宽度变化超过 20px 才触发重排（防止无穷循环）
            if self.view_mode.get() == "grid" and abs(new_w - old_w) > 20:
                self._rebuild_preview()

    def _bind_events(self) -> None:
        self.path_var.trace_add("write", lambda *_: self._clear_preview())
        self.root.bind("<Control-o>", lambda _: self._pick_video())
        self.root.protocol("WM_DELETE_WINDOW", self._on_close)

    def _toggle_mode(self) -> None:
        if self.mode_var.get() == "average":
            self._f_int.pack_forget()
            self._f_avg.pack(fill="x", pady=2)
        else:
            self._f_avg.pack_forget()
            self._f_int.pack(fill="x", pady=2)

    # ── 事件 ──────────────────────────────────────────────────

    def _pick_video(self) -> None:
        p = filedialog.askopenfilename(
            title="选择视频文件",
            filetypes=[
                ("视频文件", "*.mp4 *.avi *.mov *.mkv *.wmv *.flv *.webm *.ts *.mts *.m4v"),
                ("所有文件", "*.*"),
            ],
        )
        if p:
            self.path_var.set(p)
            self._load_video()

    def _load_video(self) -> None:
        p = self.path_var.get().strip()
        if not p or not os.path.isfile(p):
            messagebox.showerror("错误", f"文件不存在：{p}")
            return
        self._set_info("正在分析视频…")
        self.root.update()
        try:
            reader = VideoReader(p)
            self.meta = reader.meta()
            reader.close()
        except Exception as e:
            self._set_info(f"打开视频失败：{e}")
            return
        lines = [
            f"文件名：{self.meta.get('文件名', '?')}",
            f"时长：{self.meta.get('时长', '?')}  （{self.meta.get('时长_秒', 0)} 秒）",
            f"分辨率：{self.meta.get('分辨率', '?')}",
            f"大小：{self.meta.get('大小', '?')}",
            f"帧率：{self.meta.get('帧率', '?')}  总帧数：{self.meta.get('总帧数', '?')}",
        ]
        self._set_info("\n".join(lines))
        self._clear_preview()
        self._status_var.set(f"已加载：{Path(p).name}")
        self.meta["_path"] = p

    def _set_info(self, text: str) -> None:
        self._info_text.configure(state="normal")
        self._info_text.delete("1.0", "end")
        self._info_text.insert("1.0", text)
        self._info_text.configure(state="disabled")

    # ── 截图 ──────────────────────────────────────────────────

    def _start_screenshot(self) -> None:
        if self._busy:
            return
        path = self.meta.get("_path", "")
        if not path or not os.path.isfile(path):
            messagebox.showerror("错误", "请先加载有效的视频文件")
            return
        dur = self.meta.get("时长_秒", 0)
        if dur <= 0:
            messagebox.showerror("错误", "无法获取视频时长")
            return

        mode = self.mode_var.get()
        if mode == "average":
            count = self.av_count.get()
            if count < 1:
                messagebox.showerror("错误", "截图张数必须 ≥ 1")
                return
            param = count
            mode_label = f"平均{count}张"
        else:
            val = self.iv_val.get()
            if val < 1:
                messagebox.showerror("错误", "间隔值必须 ≥ 1")
                return
            unit_map = {"秒": 1, "分": 60, "小时": 3600}
            step = val * unit_map.get(self.iv_unit.get(), 1)
            param = step
            mode_label = f"每{val}{self.iv_unit.get()}"

        timestamps = calc_timestamps(dur, mode, param)
        if not timestamps:
            messagebox.showinfo("提示", "未计算出截图时间点")
            return

        video_stem = Path(path).stem
        out_dir = os.path.join(Path(path).parent, f"{video_stem}_截图")
        os.makedirs(out_dir, exist_ok=True)
        self._last_outdir = out_dir

        self._busy = True
        self._btn_start.configure(state="disabled")
        self._progress["maximum"] = len(timestamps)
        self._progress["value"] = 0
        self._clear_preview()

        def on_prog(done, total):
            self.root.after(0, lambda: self._progress.configure(value=done))
            self.root.after(0, lambda: self._status_var.set(f"截图中… {done}/{total}  ({mode_label})"))

        def worker():
            try:
                reader = VideoReader(path)
                results = batch_extract(reader, timestamps, out_dir, on_progress=on_prog)
                reader.close()
                self._results = results
                self.root.after(0, lambda: self._on_done(results, out_dir))
            except Exception as e:
                self.root.after(0, lambda: self._on_error(str(e)))

        Thread(target=worker, daemon=True).start()

    def _on_done(self, results: list[dict], out_dir: str) -> None:
        self._busy = False
        self._btn_start.configure(state="normal")
        self._btn_open.configure(state="normal")
        ok = sum(1 for r in results if r["ok"])
        self._status_var.set(f"完成：成功 {ok}/{len(results)} 张  →  {out_dir}")
        self._results = results
        self._show_thumbnails(results)

    def _on_error(self, msg: str) -> None:
        self._busy = False
        self._btn_start.configure(state="normal")
        messagebox.showerror("截图出错", msg)

    # ══════════════════════════════════════════════════════════
    #  预览区（核心改动）
    # ══════════════════════════════════════════════════════════

    def _rebuild_preview(self):
        """在切换视图模式／尺寸后重建预览。"""
        if self._results:
            self._show_thumbnails(self._results)

    def _get_thumb_size(self):
        """返回当前尺寸设置的 (宽, 高) 像素。"""
        return self.SIZES.get(self.thumb_size.get(), self.SIZES["small"])

    def _get_cols(self):
        """网格模式下列数，留作未来可能需要，现改为动态计算。"""
        return 4  # fallback，实际由动态计算覆盖

    # ── 缩略图展示 ────────────────────────────────────────────

    def _show_thumbnails(self, results: list[dict]) -> None:
        """根据当前视图模式展示缩略图。"""
        # 清空旧内容
        for w in self._preview_container.winfo_children():
            w.destroy()
        self._thumb_cells.clear()
        self._preview_container.configure(width=None)

        ok_list = [r for r in results if r["ok"]]
        if not ok_list:
            ttk.Label(self._preview_container, text="（无成功的截图）").pack()
            self._on_container_configure()
            return

        mode = self.view_mode.get()
        if mode == "list":
            self._render_list(ok_list)
        else:
            self._render_grid(ok_list)

        self._on_container_configure()

    def _render_grid(self, items: list[dict]):
        """网格模式：图片平铺填满整行 + 垂直滚动。"""
        # 第一步：先显示出内容，等 canvas 布局完成再重新计算列数并刷新
        # 直接使用 grid 布局，依据 canvas 可用宽度动态计算列数
        cw = self._preview_canvas.winfo_width()
        if cw < 100:
            cw = 800  # fallback 宽
        pad_outer = 6   # preview_container padx 总消耗
        pad_cell_x = 8  # 单元格之间的水平间距
        padding_inner = 4  # 单元格 border 左右各 1px

        tw, th = self._get_thumb_size()
        # 每单元格占宽 = 缩略图宽 + 额外 padding
        cell_w = tw + pad_cell_x + 2
        usable = cw - pad_outer
        cols = max(1, usable // cell_w)
        # 重新计算实际每个单元格宽度，使它们均匀撑满整行
        actual_cell_w = usable // cols
        # 缩略图在单元格内的水平居中偏移
        img_w = actual_cell_w - pad_cell_x - 2

        # 使用 grid 布局
        for i, r in enumerate(items):
            row_idx = i // cols
            col_idx = i % cols

            # 创建缩略图（用 img_w 宽度，高度保持比例缩放）
            cell = self._make_thumb_cell_inner(
                self._preview_container, r, img_w, th,
                show_caption=True,
            )
            cell.grid(row=row_idx, column=col_idx, padx=1, pady=2, sticky="nsew")

            # 绑定双击/右键
            self._bind_cell_events(cell, r["path"])

        # 让每列等宽扩展
        for c in range(cols):
            self._preview_container.columnconfigure(c, weight=1, uniform="thumb_col")

    def _make_thumb_cell_inner(self, parent, result: dict, w: int, h: int,
                                show_caption: bool = True) -> ttk.Frame:
        """创建单个缩略图 frame，图片宽度撑满单元格，高度等比缩放。"""
        cell = ttk.Frame(parent, relief="solid", borderwidth=1)
        try:
            img = Image.open(result["path"])
            iw, ih = img.size
            # 宽度撑满，高度等比（不限制高度）
            ratio = w / iw if iw > 0 else 1.0
            nw = max(1, int(iw * ratio))
            nh = max(1, int(ih * ratio))
            resized = img.resize((nw, nh), Image.LANCZOS)
            photo = ImageTk.PhotoImage(resized)
            lbl = ttk.Label(cell, image=photo)
            lbl.image = photo
            lbl.pack()
        except Exception:
            lbl = ttk.Label(cell, text="(加载失败)")
            lbl.pack()

        if show_caption:
            cap = result["name"].replace(".png", "")
            ttk.Label(cell, text=cap, font=("Consolas", 8)).pack()

        return cell

    def _bind_cell_events(self, cell, path: str):
        """为单元格及其所有子组件绑定交互事件。"""
        for child in [cell] + list(cell.children.values()):
            child.bind("<Double-Button-1>", lambda e, p=path: self._open_preview(p))
            child.bind("<Button-3>", lambda e, p=path: self._show_context_menu(e, p))

    def _render_list(self, items: list[dict]):
        """列表模式：表格展示，支持按列排序（名称/分辨率/大小）。"""
        sort_col = self._list_sort_col
        sort_rev = self._list_sort_rev

        # ── 构建行数据 ──
        rows = []
        for r in items:
            p = r["path"]
            try:
                img = Image.open(p)
                res_text = f"{img.width} × {img.height}"
                pixels = img.width * img.height
            except Exception:
                res_text = "?"
                pixels = 0
            try:
                size_bytes = os.path.getsize(p)
            except Exception:
                size_bytes = 0
            rows.append({
                "name": r["name"],
                "resolution": res_text,
                "pixels": pixels,
                "size_str": self._format_size(size_bytes),
                "size_bytes": size_bytes,
                "path": p,
            })

        # ── 排序 ──
        if sort_col == "name":
            rows.sort(key=lambda x: x["name"], reverse=sort_rev)
        elif sort_col == "resolution":
            rows.sort(key=lambda x: x["pixels"], reverse=sort_rev)
        elif sort_col == "size":
            rows.sort(key=lambda x: x["size_bytes"], reverse=sort_rev)

        # ── 表头 ──
        columns = [("name", "名称"), ("resolution", "分辨率"), ("size", "大小")]
        header = ttk.Frame(self._preview_container)
        header.pack(fill="x", pady=(0, 2))

        for col_idx, (key, text) in enumerate(columns):
            arrow = (" ▼" if sort_rev else " ▲") if sort_col == key else ""
            lbl = ttk.Label(header, text=text + arrow,
                            font=("Consolas", 9, "bold"),
                            relief="raised", padding=(6, 3), anchor="center")
            lbl.bind("<Button-1>", lambda e, k=key: self._sort_list(k))
            lbl.grid(row=0, column=col_idx, sticky="ew", padx=1)

        header.columnconfigure(0, weight=4)  # 名称
        header.columnconfigure(1, weight=3)  # 分辨率
        header.columnconfigure(2, weight=2)  # 大小

        # ── 分隔线 ──
        ttk.Separator(self._preview_container, orient="horizontal").pack(fill="x", pady=(0, 2))

        # ── 数据行 ──
        for row_data in rows:
            row = ttk.Frame(self._preview_container, relief="solid", borderwidth=1)
            row.pack(fill="x", pady=1, padx=1)

            # 名称
            name_lbl = ttk.Label(row, text=row_data["name"], font=("Consolas", 9))
            name_lbl.grid(row=0, column=0, sticky="w", padx=(6, 2), pady=4)

            # 分辨率
            ttk.Label(row, text=row_data["resolution"],
                      font=("Consolas", 9)).grid(row=0, column=1, sticky="w", padx=2, pady=4)

            # 大小
            ttk.Label(row, text=row_data["size_str"],
                      font=("Consolas", 9)).grid(row=0, column=2, sticky="w", padx=2, pady=4)

            # 操作按钮
            btn_frame = ttk.Frame(row)
            btn_frame.grid(row=0, column=3, sticky="e", padx=(4, 2))
            ttk.Button(btn_frame, text="📂",
                       command=lambda p=row_data["path"]: self._open_location_system(p)).pack(side="left", padx=1)

            # 列权重
            row.columnconfigure(0, weight=4)
            row.columnconfigure(1, weight=3)
            row.columnconfigure(2, weight=2)
            row.columnconfigure(3, weight=0)

            # 交互绑定（双击大图 / 右键菜单）
            for child in [row] + list(row.children.values()):
                child.bind("<Double-Button-1>",
                           lambda e, p=row_data["path"]: self._open_preview(p))
                child.bind("<Button-3>",
                           lambda e, p=row_data["path"]: self._show_context_menu(e, p))

    @staticmethod
    def _format_size(size_bytes: int) -> str:
        """将字节数转为人类可读的字符串。"""
        if size_bytes <= 0:
            return "0 B"
        s = float(size_bytes)
        for unit in ("B", "KB", "MB", "GB"):
            if s < 1024:
                return f"{s:.1f} {unit}"
            s /= 1024
        return f"{s:.1f} TB"

    def _sort_list(self, col: str):
        """切换排序状态并重建列表视图。"""
        if self._list_sort_col == col:
            self._list_sort_rev = not self._list_sort_rev
        else:
            self._list_sort_col = col
            self._list_sort_rev = False
        self._rebuild_preview()

    # ── 双击放大 ──────────────────────────────────────────────

    def _open_preview(self, path: str):
        """双击打开大图预览窗口。"""
        PreviewWindow(self.root, path)

    # ── 右键菜单 ──────────────────────────────────────────────

    def _show_context_menu(self, event, path: str):
        """右键弹出操作菜单。"""
        menu = Menu(self.root, tearoff=False)
        menu.add_command(label="打开 (系统默认)", command=lambda: self._open_file_system(path))
        menu.add_command(label="打开文件所在位置", command=lambda: self._open_location_system(path))
        menu.add_separator()
        menu.add_command(label="复制文件路径", command=lambda: self._copy_path(path))
        menu.add_separator()
        menu.add_command(label="查看大图", command=lambda: self._open_preview(path))
        menu.tk_popup(event.x_root, event.y_root)

    @staticmethod
    def _open_file_system(path: str):
        """用系统默认程序打开文件。"""
        try:
            os.startfile(path)
        except AttributeError:
            subprocess.run(["open" if sys.platform == "darwin" else "xdg-open", path])

    @staticmethod
    def _open_location_system(path: str):
        """打开文件所在文件夹并选中文件。"""
        p = os.path.abspath(path)
        try:
            subprocess.run(["explorer", "/select,", p])
        except Exception:
            try:
                os.startfile(os.path.dirname(p))
            except AttributeError:
                subprocess.run(["open" if sys.platform == "darwin" else "xdg-open", os.path.dirname(p)])

    @staticmethod
    def _copy_path(path: str) -> None:
        """复制文件路径到剪贴板。"""
        cmd = path.replace("/", "\\") if sys.platform == "win32" else path
        r = tk.Tk()
        r.withdraw()
        r.clipboard_clear()
        r.clipboard_append(cmd)
        r.update()
        r.destroy()

    # ── 打开输出文件夹 ───────────────────────────────────────

    def _open_outdir(self) -> None:
        if self._last_outdir and os.path.isdir(self._last_outdir):
            try:
                os.startfile(self._last_outdir)
            except AttributeError:
                subprocess.run(["open" if sys.platform == "darwin" else "xdg-open", self._last_outdir])

    def _clear_preview(self) -> None:
        """清空预览区。"""
        for w in self._preview_container.winfo_children():
            w.destroy()
        self._thumb_cells.clear()
        self._on_container_configure()

    # ── 关闭 ──────────────────────────────────────────────────

    def _on_close(self) -> None:
        self.root.destroy()

    def run(self) -> None:
        self.root.mainloop()


# ═══════════════════════════════════════════════════════════════
#  入口
# ═══════════════════════════════════════════════════════════════

if __name__ == "__main__":
    App().run()