Fly‑zip

import os
import sys
import stat
import time
import tkinter as tk
from tkinter import filedialog, messagebox, ttk
import zipfile
import tarfile
import pathlib
import threading
import queue

class ArchiverApp:
    def __init__(self, root):
        self.root = root
        self.root.title("Fly-zip")
        self.root.geometry("650x420")
        self.root.minsize(600, 380)

        # 界面变量
        self.source_path = tk.StringVar()
        self.dest_path = tk.StringVar()
        self.format_var = tk.StringVar(value="zip")
        self.mode_var = tk.StringVar(value="compress")
        self.status_text = tk.StringVar(value="就绪")
        self.progress_var = tk.DoubleVar(value=0)
        self.progress_label = tk.StringVar(value="0%")

        # 后台控制
        self._thread = None
        self._cancel_flag = False
        self._overwrite_all = True  # 解压覆盖策略

        self._create_widgets()
        self._on_mode_change()

        # 窗口关闭协议
        self.root.protocol("WM_DELETE_WINDOW", self._on_closing)

    # ---------- 界面构建 ----------
    def _create_widgets(self):
        main_frame = ttk.Frame(self.root, padding=10)
        main_frame.pack(fill=tk.BOTH, expand=True)

        # 模式选择
        mode_frame = ttk.LabelFrame(main_frame, text="操作模式", padding=5)
        mode_frame.pack(fill=tk.X, pady=5)
        ttk.Radiobutton(mode_frame, text="压缩文件夹", variable=self.mode_var,
                        value="compress", command=self._on_mode_change).grid(row=0, column=0, padx=10)
        ttk.Radiobutton(mode_frame, text="解压文件", variable=self.mode_var,
                        value="extract", command=self._on_mode_change).grid(row=0, column=1, padx=10)

        # 源路径
        src_frame = ttk.LabelFrame(main_frame, text="源路径", padding=5)
        src_frame.pack(fill=tk.X, pady=5)
        self.src_label = ttk.Label(src_frame, text="文件夹:")
        self.src_label.grid(row=0, column=0, sticky=tk.W)
        ttk.Entry(src_frame, textvariable=self.source_path, width=50).grid(row=0, column=1, padx=5)
        ttk.Button(src_frame, text="浏览...", command=self._browse_source).grid(row=0, column=2)

        # 目标路径
        dest_frame = ttk.LabelFrame(main_frame, text="目标路径", padding=5)
        dest_frame.pack(fill=tk.X, pady=5)
        self.dest_label = ttk.Label(dest_frame, text="输出文件:")
        self.dest_label.grid(row=0, column=0, sticky=tk.W)
        ttk.Entry(dest_frame, textvariable=self.dest_path, width=50).grid(row=0, column=1, padx=5)
        ttk.Button(dest_frame, text="浏览...", command=self._browse_dest).grid(row=0, column=2)

        # 压缩格式（仅压缩模式）
        format_frame = ttk.LabelFrame(main_frame, text="压缩格式", padding=5)
        format_frame.pack(fill=tk.X, pady=5)
        self.zip_radio = ttk.Radiobutton(format_frame, text="ZIP (deflate)", variable=self.format_var, value="zip")
        self.zip_radio.grid(row=0, column=0, padx=10)
        self.tgz_radio = ttk.Radiobutton(format_frame, text="TAR.GZ (gzip)", variable=self.format_var, value="tar.gz")
        self.tgz_radio.grid(row=0, column=1, padx=10)

        # 进度条与百分比
        prog_frame = ttk.Frame(main_frame)
        prog_frame.pack(fill=tk.X, pady=5)
        self.progress = ttk.Progressbar(prog_frame, variable=self.progress_var, maximum=100)
        self.progress.pack(side=tk.LEFT, fill=tk.X, expand=True)
        ttk.Label(prog_frame, textvariable=self.progress_label, width=6).pack(side=tk.RIGHT, padx=5)

        # 按钮
        btn_frame = ttk.Frame(main_frame)
        btn_frame.pack(fill=tk.X, pady=10)
        self.execute_btn = ttk.Button(btn_frame, text="开始压缩", command=self._execute)
        self.execute_btn.pack(side=tk.LEFT, padx=5)
        self.cancel_btn = ttk.Button(btn_frame, text="取消", command=self._cancel, state=tk.DISABLED)
        self.cancel_btn.pack(side=tk.LEFT, padx=5)
        ttk.Button(btn_frame, text="退出", command=self._on_closing).pack(side=tk.RIGHT, padx=5)

        # 状态栏
        status_frame = ttk.Frame(main_frame)
        status_frame.pack(fill=tk.X, side=tk.BOTTOM)
        ttk.Label(status_frame, textvariable=self.status_text, relief=tk.SUNKEN, anchor=tk.W).pack(fill=tk.X)

    # ---------- UI 逻辑 ----------
    def _on_mode_change(self):
        # 切换模式时清空路径
        self.source_path.set("")
        self.dest_path.set("")
        if self.mode_var.get() == "compress":
            self.src_label.config(text="文件夹:")
            self.dest_label.config(text="输出文件:")
            self.execute_btn.config(text="开始压缩")
            self.zip_radio.config(state=tk.NORMAL)
            self.tgz_radio.config(state=tk.NORMAL)
        else:
            self.src_label.config(text="压缩包:")
            self.dest_label.config(text="解压到:")
            self.execute_btn.config(text="开始解压")
            self.zip_radio.config(state=tk.DISABLED)
            self.tgz_radio.config(state=tk.DISABLED)

    def _browse_source(self):
        if self.mode_var.get() == "compress":
            path = filedialog.askdirectory(title="选择要压缩的文件夹")
        else:
            path = filedialog.askopenfilename(
                title="选择压缩文件",
                filetypes=[("压缩文件", "*.zip;*.tar.gz;*.tgz"), ("所有文件", "*.*")]
            )
        if path:
            self.source_path.set(path)

    def _browse_dest(self):
        if self.mode_var.get() == "compress":
            fmt = self.format_var.get()
            if fmt == "zip":
                def_ext = ".zip"
                ftypes = [("ZIP 文件", "*.zip")]
            else:
                def_ext = ".tar.gz"
                ftypes = [("TAR.GZ 文件", "*.tar.gz;*.tgz")]
            path = filedialog.asksaveasfilename(
                title="保存压缩包",
                defaultextension=def_ext,
                filetypes=ftypes
            )
        else:
            path = filedialog.askdirectory(title="选择解压目标文件夹")
        if path:
            self.dest_path.set(path)

    def _execute(self):
        src = self.source_path.get().strip()
        dest = self.dest_path.get().strip()
        if not src:
            messagebox.showerror("错误", "请选择源路径")
            return
        if not dest:
            messagebox.showerror("错误", "请选择目标路径")
            return

        # 解压时提前询问覆盖策略
        if self.mode_var.get() == "extract":
            dest_dir = pathlib.Path(dest).resolve()
            if dest_dir.exists() and any(dest_dir.iterdir()):
                self._overwrite_all = messagebox.askyesno(
                    "确认覆盖",
                    "目标目录不为空，是否覆盖所有已存在的文件？\n选择“否”将跳过已存在的文件。"
                )
        else:
            # 压缩前规范化输出文件名后缀
            fmt = self.format_var.get()
            dest_path = pathlib.Path(dest)
            if fmt == "zip":
                if dest_path.suffix.lower() != ".zip":
                    dest_path = dest_path.with_suffix(".zip")
            else:  # tar.gz
                if not (dest_path.name.endswith('.tar.gz') or dest_path.name.endswith('.tgz')):
                    # 避免重复后缀：若已有后缀，先去除
                    while dest_path.suffix in ('.gz', '.tar', '.tgz'):
                        dest_path = dest_path.with_suffix('')
                    dest_path = dest_path.with_name(dest_path.name + ".tar.gz")
            self.dest_path.set(str(dest_path))
            dest = str(dest_path)

        self.execute_btn.config(state=tk.DISABLED)
        self.cancel_btn.config(state=tk.NORMAL)
        self.progress_var.set(0)
        self.progress_label.set("0%")
        self.status_text.set("准备中...")
        self._cancel_flag = False

        # 启动工作线程
        self._thread = threading.Thread(target=self._run_task, args=(src, dest), daemon=True)
        self._thread.start()

    def _cancel(self):
        self._cancel_flag = True
        self.status_text.set("正在取消...")
        self.cancel_btn.config(state=tk.DISABLED)

    def _on_closing(self):
        if self._thread and self._thread.is_alive():
            if messagebox.askyesno("退出确认", "正在处理文件，确定要退出吗？\n退出可能导致压缩包损坏。"):
                self._cancel_flag = True
                self.root.destroy()
        else:
            self.root.destroy()

    def _run_task(self, src, dest):
        try:
            if self.mode_var.get() == "compress":
                self._compress(src, dest)
            else:
                self._extract(src, dest)
            if self._cancel_flag:
                self.root.after(0, self._task_done, "已取消")
            else:
                self.root.after(0, self._task_done, "操作完成！")
        except Exception as e:
            self.root.after(0, self._task_done, f"错误: {str(e)}")

    def _task_done(self, msg):
        self._thread = None
        self.execute_btn.config(state=tk.NORMAL)
        self.cancel_btn.config(state=tk.DISABLED)
        self.status_text.set(msg)
        self.progress_var.set(100)
        self.progress_label.set("100%")
        if "错误" in msg:
            messagebox.showerror("失败", msg)
        elif "取消" in msg:
            messagebox.showwarning("取消", msg)
        else:
            messagebox.showinfo("成功", msg)

    # ---------- 压缩核心 ----------
    def _compress(self, folder, output):
        folder_path = pathlib.Path(folder).resolve()
        if not folder_path.is_dir():
            raise ValueError("源路径不是文件夹")

        output_path = pathlib.Path(output).resolve()
        fmt = self.format_var.get()

        # 第一遍：统计总文件数和总大小（不存储路径，内存友好）
        file_count = 0
        total_bytes = 0
        try:
            for root, dirs, files in os.walk(folder_path):
                for name in files:
                    fpath = os.path.join(root, name)
                    try:
                        total_bytes += os.path.getsize(fpath)
                        file_count += 1
                    except OSError:
                        pass
        except PermissionError:
            raise PermissionError(f"无法访问目录: {folder_path}")

        # 第二遍：压缩，使用体积进度
        processed_bytes = 0
        self._update_progress(0, total_bytes, "开始压缩...", force=True)

        if fmt == "zip":
            with zipfile.ZipFile(output_path, 'w', zipfile.ZIP_DEFLATED) as zf:
                # 先添加根目录（空文件夹）
                self._add_empty_dirs_zip(zf, folder_path, folder_path)
                # 再添加文件
                for root, dirs, files in os.walk(folder_path):
                    if self._cancel_flag:
                        break
                    for name in files:
                        if self._cancel_flag:
                            break
                        fpath = pathlib.Path(root) / name
                        try:
                            arcname = fpath.relative_to(folder_path)
                            zf.write(fpath, arcname)
                            processed_bytes += fpath.stat().st_size
                            self._update_progress(processed_bytes, total_bytes, f"压缩: {arcname}")
                        except Exception as e:
                            # 跳过单个文件错误
                            self._log_error(f"跳过文件 {fpath}: {e}")

                # 确保空目录被写入
                self._add_empty_dirs_zip(zf, folder_path, folder_path)
        else:  # tar.gz
            with tarfile.open(output_path, 'w:gz') as tar:
                def add_items(current_path):
                    if self._cancel_flag:
                        return
                    try:
                        for entry in os.scandir(current_path):
                            if self._cancel_flag:
                                return
                            arcname = pathlib.Path(entry.path).relative_to(folder_path)
                            try:
                                if entry.is_dir():
                                    tar.add(entry.path, arcname=arcname, recursive=False)
                                    # 空目录会作为目录条目添加
                                    add_items(entry.path)
                                elif entry.is_file():
                                    tar.add(entry.path, arcname=arcname)
                                    processed_bytes_local = entry.stat().st_size
                                    nonlocal processed_bytes
                                    processed_bytes += processed_bytes_local
                                    self._update_progress(processed_bytes, total_bytes, f"压缩: {arcname}")
                            except Exception as e:
                                self._log_error(f"跳过 {entry.path}: {e}")
                    except PermissionError:
                        self._log_error(f"无权限访问目录: {current_path}")

                # 先添加根目录自身（确保最外层文件夹被记录）
                tar.add(folder_path, arcname=folder_path.name, recursive=False)
                add_items(folder_path)

        if self._cancel_flag and output_path.exists():
            output_path.unlink()  # 删除未完成的输出

    def _add_empty_dirs_zip(self, zf, base_dir, current_dir):
        """将空目录添加到 ZIP 包中"""
        for root, dirs, files in os.walk(current_dir):
            for d in dirs:
                dir_path = pathlib.Path(root) / d
                # 检查该目录是否为空（或仅包含空目录）
                if not any(dir_path.iterdir()):
                    arcname = dir_path.relative_to(base_dir)
                    # 创建目录条目（末尾带 '/'）
                    info = zipfile.ZipInfo(str(arcname) + '/')
                    info.external_attr = (stat.S_IFDIR | 0o755) << 16  # 目录权限
                    zf.writestr(info, '')

    # ---------- 解压核心 ----------
    def _extract(self, archive, dest):
        archive_path = pathlib.Path(archive).resolve()
        if not archive_path.is_file():
            raise ValueError("压缩文件不存在")

        dest_path = pathlib.Path(dest).resolve()
        dest_path.mkdir(parents=True, exist_ok=True)

        if archive_path.suffix.lower() == '.zip':
            self._extract_zip(archive_path, dest_path)
        elif archive_path.name.endswith('.tar.gz') or archive_path.name.endswith('.tgz'):
            self._extract_tar(archive_path, dest_path)
        else:
            try:
                self._extract_zip(archive_path, dest_path)
            except zipfile.BadZipFile:
                self._extract_tar(archive_path, dest_path)

    def _extract_zip(self, archive, dest):
        with zipfile.ZipFile(archive, 'r') as zf:
            members = zf.infolist()
            total_size = sum(m.file_size for m in members)
            processed = 0

            for member in members:
                if self._cancel_flag:
                    break

                # 修复乱码文件名
                filename = self._fix_zip_filename(member)

                # 路径穿越保护（兼容 Python 3.6+）
                target = (dest / filename).resolve()
                if not str(target).startswith(str(dest.resolve()) + os.sep) and target != dest.resolve():
                    self._log_error(f"警告: 跳过危险路径 {filename}")
                    continue

                # 覆盖检查
                if target.exists() and not self._overwrite_all:
                    continue
                if target.exists() and member.is_dir():
                    continue  # 目录已存在，无需处理

                try:
                    zf.extract(member, dest)
                    processed += member.file_size
                    self._update_progress(processed, total_size, f"解压: {filename}")
                except Exception as e:
                    self._log_error(f"解压失败 {filename}: {e}")

    def _extract_tar(self, archive, dest):
        with tarfile.open(archive, 'r:*') as tar:
            members = tar.getmembers()
            total_size = sum(m.size for m in members)
            processed = 0

            for member in members:
                if self._cancel_flag:
                    break

                # tarfile 不会自动防止路径穿越，需手动检查
                target = (dest / member.name).resolve()
                if not str(target).startswith(str(dest.resolve()) + os.sep) and target != dest.resolve():
                    self._log_error(f"警告: 跳过危险路径 {member.name}")
                    continue

                # 覆盖检查
                if target.exists() and not self._overwrite_all:
                    continue

                try:
                    tar.extract(member, dest, set_attrs=True)  # 保留时间戳和权限
                    processed += member.size
                    self._update_progress(processed, total_size, f"解压: {member.name}")
                except Exception as e:
                    self._log_error(f"解压失败 {member.name}: {e}")

    def _fix_zip_filename(self, member):
        """修复 ZIP 中的非 UTF-8 文件名（中文乱码）"""
        try:
            # 如果文件名为 UTF-8 标志位，直接返回
            if member.flag_bits & 0x800:
                return member.filename
            # 否则尝试用 cp437 解码再用 gbk 编码恢复
            raw = member.filename.encode('cp437')
            try:
                return raw.decode('gbk')
            except UnicodeDecodeError:
                return member.filename  # 回退
        except Exception:
            return member.filename

    # ---------- 工具方法 ----------
    def _update_progress(self, current, total, message, force=False):
        """线程安全、节流更新进度条（按体积百分比）"""
        now = time.time()
        if not hasattr(self, '_last_update'):
            self._last_update = 0
        # 节流：每 0.1 秒最多更新一次，但完成时强制更新
        if not force and (now - self._last_update < 0.1):
            return
        self._last_update = now

        if total == 0:
            percent = 100
        else:
            percent = min(int((current / total) * 100), 100)
        self.root.after(0, self._set_progress, percent, message)

    def _set_progress(self, percent, message):
        self.progress_var.set(percent)
        self.progress_label.set(f"{percent}%")
        self.status_text.set(message)

    def _log_error(self, msg):
        """将错误信息通过队列安全地打印到状态栏（仅显示最新一条）"""
        self.root.after(0, lambda: self.status_text.set(msg))

    # 兼容 Python 3.7/3.8 的 path 归属检查（安全函数，已在逻辑中直接使用字符串比较）


if __name__ == "__main__":
    root = tk.Tk()
    app = ArchiverApp(root)
    root.mainloop()