gui.py

import json
import os
import sys

from PySide6.QtCore import QObject, QThread, Signal, Slot
from PySide6.QtWidgets import (
    QApplication,
    QButtonGroup,
    QCheckBox,
    QFileDialog,
    QGroupBox,
    QHBoxLayout,
    QLabel,
    QLineEdit,
    QMessageBox,
    QPlainTextEdit,
    QPushButton,
    QRadioButton,
    QSplitter,
    QTextEdit,
    QVBoxLayout,
    QWidget,
)

from run import SKIP_EXT_PRESETS, diff_dirs, get_skip_extensions, scan_source, sync_target


class Worker(QObject):
    log = Signal(str)
    finished = Signal(bool)
    diff_result = Signal(dict)

    def __init__(self, mode, src_dir, dst_dir, map_path, dry_run, verbose=False, skip_extensions=None, scan_mode="hash"):
        super().__init__()
        self.mode = mode
        self.src_dir = src_dir
        self.dst_dir = dst_dir
        self.map_path = map_path
        self.dry_run = dry_run
        self.verbose = verbose
        self.skip_extensions = skip_extensions
        self.scan_mode = scan_mode

    @Slot()
    def run(self):
        try:
            def logger(message):
                self.log.emit(str(message))

            if self.mode == "scan":
                scan_source(self.src_dir, self.map_path, log_fn=logger, verbose=self.verbose, skip_extensions=self.skip_extensions, scan_mode=self.scan_mode)
            elif self.mode == "sync":
                sync_target(self.dst_dir, self.map_path, dry_run=self.dry_run, log_fn=logger, verbose=self.verbose, skip_extensions=self.skip_extensions)
            else:
                result = diff_dirs(self.src_dir, self.dst_dir, log_fn=logger, verbose=self.verbose, skip_extensions=self.skip_extensions, scan_mode=self.scan_mode)
                self.diff_result.emit(result)
            self.finished.emit(True)
        except Exception as exc:
            self.log.emit(f"[错误] {exc}")
            self.finished.emit(False)


class MainWindow(QWidget):
    def __init__(self):
        super().__init__()
        self.setWindowTitle("File-Structure-Sync")
        self.resize(960, 560)

        self.mode_scan = QRadioButton("扫描")
        self.mode_sync = QRadioButton("同步")
        self.mode_diff = QRadioButton("找差异")
        self.mode_scan.setChecked(True)
        self.mode_group = QButtonGroup(self)
        self.mode_group.addButton(self.mode_scan)
        self.mode_group.addButton(self.mode_sync)
        self.mode_group.addButton(self.mode_diff)

        self.scan_mode_hash = QRadioButton("深度扫描 (MD5)")
        self.scan_mode_name = QRadioButton("简易扫描 (仅文件名)")
        self.scan_mode_hash.setChecked(True)
        self.scan_mode_group = QButtonGroup(self)
        self.scan_mode_group.addButton(self.scan_mode_hash)
        self.scan_mode_group.addButton(self.scan_mode_name)

        self.src_edit = QLineEdit()
        self.src_btn = QPushButton("选择目录")
        self.dst_edit = QLineEdit()
        self.dst_btn = QPushButton("选择目录")
        self.map_edit = QLineEdit("file_map.json")
        self.map_btn = QPushButton("选择文件")
        self.dry_run_chk = QCheckBox("预览模式（不实际移动）")
        self.verbose_chk = QCheckBox("详细模式（输出每个文件）")
        # 跳过文件类型：多选预设 + 自定义扩展名
        self.skip_group = QGroupBox("跳过文件类型")
        skip_layout = QVBoxLayout()
        self.skip_preset_boxes = {}
        preset_row = QHBoxLayout()
        for name in SKIP_EXT_PRESETS:
            chk = QCheckBox(name)
            self.skip_preset_boxes[name] = chk
            preset_row.addWidget(chk)
        preset_row.addStretch()
        skip_layout.addLayout(preset_row)
        self.skip_custom_edit = QLineEdit()
        self.skip_custom_edit.setPlaceholderText("自定义扩展名，逗号分隔，如: .bak, .tmp")
        skip_layout.addLayout(self._row("自定义", self.skip_custom_edit))
        self.skip_group.setLayout(skip_layout)
        self.run_btn = QPushButton("开始")

        self.log_view = QTextEdit()
        self.log_view.setReadOnly(True)

        self.json_preview = QPlainTextEdit()
        self.json_preview.setReadOnly(True)
        self.json_preview.setPlaceholderText("映射文件 JSON 预览（选择映射文件或扫描完成后自动加载）")
        self.json_label = QLabel("JSON 预览：")
        self.json_load_btn = QPushButton("加载映射")
        self.json_export_btn = QPushButton("导出结果")
        self.json_export_btn.setVisible(False)

        left_layout = QVBoxLayout()
        mode_row = QHBoxLayout()
        mode_row.addWidget(QLabel("模式"))
        mode_row.addWidget(self.mode_scan)
        mode_row.addWidget(self.mode_sync)
        mode_row.addWidget(self.mode_diff)
        mode_row.addStretch()
        left_layout.addLayout(mode_row)
        scan_mode_row = QHBoxLayout()
        scan_mode_row.addWidget(QLabel("扫描方式"))
        scan_mode_row.addWidget(self.scan_mode_hash)
        scan_mode_row.addWidget(self.scan_mode_name)
        scan_mode_row.addStretch()
        left_layout.addLayout(scan_mode_row)
        left_layout.addLayout(self._row("源目录", self.src_edit, self.src_btn))
        left_layout.addLayout(self._row("目标目录", self.dst_edit, self.dst_btn))
        self.map_row = QWidget()
        map_row_layout = QHBoxLayout(self.map_row)
        map_row_layout.setContentsMargins(0, 0, 0, 0)
        map_row_layout.addLayout(self._row("映射文件", self.map_edit, self.map_btn))
        left_layout.addWidget(self.map_row)
        left_layout.addWidget(self.skip_group)
        left_layout.addWidget(self.dry_run_chk)
        left_layout.addWidget(self.verbose_chk)
        left_layout.addWidget(self.run_btn)
        left_layout.addWidget(QLabel("日志输出："))
        left_layout.addWidget(self.log_view)

        left_widget = QWidget()
        left_widget.setLayout(left_layout)

        right_layout = QVBoxLayout()
        right_layout.addWidget(self.json_label)
        right_layout.addWidget(self.json_preview)
        right_btns = QHBoxLayout()
        right_btns.addWidget(self.json_load_btn)
        right_btns.addWidget(self.json_export_btn)
        right_btns.addStretch()
        right_layout.addLayout(right_btns)

        right_widget = QWidget()
        right_widget.setLayout(right_layout)

        splitter = QSplitter()
        splitter.addWidget(left_widget)
        splitter.addWidget(right_widget)
        splitter.setSizes([480, 480])

        layout = QHBoxLayout()
        layout.setContentsMargins(0, 0, 0, 0)
        layout.addWidget(splitter)
        self.setLayout(layout)

        self.mode_scan.toggled.connect(lambda c: c and self._on_mode_changed("scan"))
        self.mode_sync.toggled.connect(lambda c: c and self._on_mode_changed("sync"))
        self.mode_diff.toggled.connect(lambda c: c and self._on_mode_changed("diff"))
        self.src_btn.clicked.connect(self._choose_src)
        self.dst_btn.clicked.connect(self._choose_dst)
        self.map_btn.clicked.connect(self._choose_map)
        self.run_btn.clicked.connect(self._start)
        self.json_load_btn.clicked.connect(self._load_json_preview)
        self.json_export_btn.clicked.connect(self._export_result)

        self._on_mode_changed("scan")

        self.worker_thread = None
        self.worker = None

    def _row(self, label, *widgets):
        row = QHBoxLayout()
        row.addWidget(QLabel(label))
        for w in widgets:
            row.addWidget(w)
        return row

    def _mode(self):
        if self.mode_scan.isChecked():
            return "scan"
        if self.mode_sync.isChecked():
            return "sync"
        return "diff"

    def _on_mode_changed(self, mode):
        is_scan = mode == "scan"
        is_sync = mode == "sync"
        is_diff = mode == "diff"
        self.src_edit.setEnabled(is_scan or is_diff)
        self.src_btn.setEnabled(is_scan or is_diff)
        self.dst_edit.setEnabled(is_sync or is_diff)
        self.dst_btn.setEnabled(is_sync or is_diff)
        self.dry_run_chk.setEnabled(is_sync)
        self.map_row.setVisible(not is_diff)
        if is_diff:
            self.json_label.setText("差异结果：")
            self.json_preview.setPlaceholderText("运行「找差异」后显示：源多了 / 少了哪些文件")
            self.json_load_btn.setVisible(False)
            self.json_export_btn.setVisible(True)
        else:
            self.json_label.setText("JSON 预览：")
            self.json_preview.setPlaceholderText("映射文件 JSON 预览（选择映射文件或扫描完成后自动加载）")
            self.json_load_btn.setVisible(True)
            self.json_export_btn.setVisible(False)
        if is_scan and not self.map_edit.text().strip():
            self.map_edit.setText("file_map.json")

    def _choose_src(self):
        path = QFileDialog.getExistingDirectory(self, "选择源目录")
        if path:
            self.src_edit.setText(path)

    def _choose_dst(self):
        path = QFileDialog.getExistingDirectory(self, "选择目标目录")
        if path:
            self.dst_edit.setText(path)

    def _choose_map(self):
        mode = self._mode()
        if mode == "scan":
            path, _ = QFileDialog.getSaveFileName(
                self, "保存映射文件", self.map_edit.text() or "file_map.json", "JSON 文件 (*.json)"
            )
        else:
            path, _ = QFileDialog.getOpenFileName(
                self, "选择映射文件", self.map_edit.text() or "", "JSON 文件 (*.json)"
            )
        if path:
            self.map_edit.setText(path)
            self._load_json_preview()

    def _validate_inputs(self):
        mode = self._mode()
        src_dir = self.src_edit.text().strip()
        dst_dir = self.dst_edit.text().strip()
        map_path = self.map_edit.text().strip()

        if mode == "diff":
            if not src_dir or not dst_dir:
                QMessageBox.warning(self, "提示", "找差异需同时指定源目录与目标目录。")
                return None
            if not os.path.isdir(src_dir):
                QMessageBox.warning(self, "提示", "源目录不存在。")
                return None
            if not os.path.isdir(dst_dir):
                QMessageBox.warning(self, "提示", "目标目录不存在。")
                return None
            return mode, src_dir, dst_dir, ""

        if not map_path:
            QMessageBox.warning(self, "提示", "请指定映射文件路径。")
            return None

        if mode == "scan":
            if not src_dir:
                QMessageBox.warning(self, "提示", "请指定源目录。")
                return None
            if not os.path.isdir(src_dir):
                QMessageBox.warning(self, "提示", "源目录不存在。")
                return None
        else:
            if not dst_dir:
                QMessageBox.warning(self, "提示", "请指定目标目录。")
                return None
            if not os.path.isdir(dst_dir):
                QMessageBox.warning(self, "提示", "目标目录不存在。")
                return None
            if not os.path.isfile(map_path):
                QMessageBox.warning(self, "提示", "映射文件不存在。")
                return None

        return mode, src_dir, dst_dir, map_path

    def _set_running(self, running):
        mode = self._mode()
        self.run_btn.setEnabled(not running)
        self.mode_scan.setEnabled(not running)
        self.mode_sync.setEnabled(not running)
        self.mode_diff.setEnabled(not running)
        self.scan_mode_hash.setEnabled(not running)
        self.scan_mode_name.setEnabled(not running)
        self.src_edit.setEnabled(not running and (mode == "scan" or mode == "diff"))
        self.src_btn.setEnabled(not running and (mode == "scan" or mode == "diff"))
        self.dst_edit.setEnabled(not running and (mode == "sync" or mode == "diff"))
        self.dst_btn.setEnabled(not running and (mode == "sync" or mode == "diff"))
        self.map_edit.setEnabled(not running)
        self.map_btn.setEnabled(not running)
        self.dry_run_chk.setEnabled(not running and mode == "sync")
        self.verbose_chk.setEnabled(not running)
        self.skip_group.setEnabled(not running)
        self.json_load_btn.setEnabled(not running)
        self.json_export_btn.setEnabled(not running)
        self.run_btn.setText("运行中..." if running else "开始")

    def _load_json_preview(self):
        path = self.map_edit.text().strip()
        if not path or not os.path.isfile(path):
            self.json_preview.setPlainText("")
            return
        try:
            with open(path, "r", encoding="utf-8") as f:
                data = json.load(f)
            self.json_preview.setPlainText(json.dumps(data, ensure_ascii=False, indent=4))
        except Exception as e:
            self.json_preview.setPlainText(f"[加载失败] {e}")

    def _export_result(self):
        path, _ = QFileDialog.getSaveFileName(
            self, "导出差异结果", "diff_result.json", "JSON 文件 (*.json)"
        )
        if not path:
            return
        try:
            text = self.json_preview.toPlainText()
            if not text.strip():
                QMessageBox.warning(self, "提示", "无可导出内容，请先运行「找差异」。")
                return
            with open(path, "w", encoding="utf-8") as f:
                f.write(text)
            QMessageBox.information(self, "完成", f"已保存至 {path}")
        except Exception as e:
            QMessageBox.warning(self, "提示", f"导出失败：{e}")

    def _start(self):
        inputs = self._validate_inputs()
        if not inputs:
            return
        mode, src_dir, dst_dir, map_path = inputs
        dry_run = self.dry_run_chk.isChecked()
        verbose = self.verbose_chk.isChecked()
        preset_names = [name for name, chk in self.skip_preset_boxes.items() if chk.isChecked()]
        custom_text = self.skip_custom_edit.text().strip()
        extra_ext = [x.strip() for x in custom_text.split(",") if x.strip()] if custom_text else None
        skip_ext = get_skip_extensions(preset_names=preset_names or None, extra_extensions=extra_ext) or None
        scan_mode = "name" if self.scan_mode_name.isChecked() else "hash"

        self.log_view.clear()
        if mode == "diff":
            self.json_preview.setPlainText("")
        self._set_running(True)

        self.worker_thread = QThread()
        self.worker = Worker(mode, src_dir, dst_dir, map_path, dry_run, verbose=verbose, skip_extensions=skip_ext, scan_mode=scan_mode)
        self.worker.moveToThread(self.worker_thread)
        self.worker_thread.started.connect(self.worker.run)
        self.worker.log.connect(self._append_log)
        self.worker.finished.connect(self._on_finished)
        self.worker.finished.connect(self.worker_thread.quit)
        self.worker_thread.finished.connect(self.worker_thread.deleteLater)
        if mode == "diff":
            self.worker.diff_result.connect(self._show_diff_result)
        self.worker_thread.start()

    def _append_log(self, message):
        self.log_view.append(message)

    def _show_diff_result(self, data):
        self.json_preview.setPlainText(json.dumps(data, ensure_ascii=False, indent=4))

    def _on_finished(self, ok):
        self._set_running(False)
        if ok:
            if self._mode() != "diff":
                self._load_json_preview()
            QMessageBox.information(self, "完成", "操作已完成。")
        else:
            QMessageBox.warning(self, "提示", "操作未成功完成，请查看日志。")


def main():
    app = QApplication(sys.argv)
    window = MainWindow()
    window.show()
    sys.exit(app.exec())


if __name__ == "__main__":
    main()