settings_page.py

"""设置页：默认 profile / WebSocket 端口 / API 开关 + 资源同步 + 更新检查。

网络操作（同步干员/地图、检查更新）放后台线程，避免卡 UI；进度/结果经信号回。
设置项持久化到 config/settings.json（运行时读取，下次启动生效）。
"""

from __future__ import annotations

import json
import threading
from pathlib import Path
from typing import TYPE_CHECKING, Any

from PySide6.QtCore import QObject, Qt, QThread, QTimer, Signal
from PySide6.QtWidgets import (
    QCheckBox,
    QComboBox,
    QFileDialog,
    QFormLayout,
    QGroupBox,
    QHBoxLayout,
    QLabel,
    QLineEdit,
    QListWidget,
    QListWidgetItem,
    QMessageBox,
    QPushButton,
    QSlider,
    QVBoxLayout,
    QWidget,
)

from aao import __version__
from aao.resources.syncer import sync_all
from aao.resources.updater import ReleaseInfo, UpdateChecker
from aao.ui import theme
from aao.ui.collapsible_box import CollapsibleBox
from aao.ui.scrollbar_style import apply_themed_scrollbar
from aao.utils.logger import logger
from aao.utils.runtime_paths import project_root

if TYPE_CHECKING:
    from PySide6.QtGui import QImage, QShowEvent


def _settings_path():
    return project_root() / "config" / "settings.json"


def load_settings() -> dict[str, Any]:
    p = _settings_path()
    if not p.exists():
        return {}
    try:
        return json.loads(p.read_text(encoding="utf-8"))
    except (OSError, ValueError):
        return {}


def save_settings(data: dict[str, Any]) -> None:
    p = _settings_path()
    p.parent.mkdir(parents=True, exist_ok=True)
    p.write_text(json.dumps(data, indent=2, ensure_ascii=False), encoding="utf-8")


def _fmt_size(n: int) -> str:
    """字节数 → 人话（如 12.3 MB）。"""
    size: float = float(n)
    for unit in ("B", "KB", "MB", "GB"):
        if size < 1024 or unit == "GB":
            return f"{size:.1f} {unit}".replace(".0 ", " ")
        size /= 1024
    return f"{size:.1f} GB"


class _ResourceWorker(QObject):
    """后台跑资源同步/更新检查/软件下载。"""

    log = Signal(str)
    finished_ok = Signal(str)  # 总结消息
    failed = Signal(str)
    # check_update: 检查到有新版本时发 (ReleaseInfo)；无更新/失败走 finished_ok/failed
    update_found = Signal(object)
    # download: 字节进度 (downloaded, total)
    download_progress = Signal(int, int)
    # download: 下载成功，发 zip 路径；失败/取消走 finished_ok/failed
    download_ready = Signal(object)

    def __init__(self, mode: str, info: Any = None):
        super().__init__()
        self._mode = mode  # "sync" | "check_update" | "download"
        self._info = info  # download 模式: ReleaseInfo
        # 取消信号：跨线程 Event，主线程 set() 即可让 sync_all/下载在检查点退出。
        self._cancel = threading.Event()

    def cancel(self) -> None:
        """主线程调用：请求中止正在进行的同步/下载。"""
        self._cancel.set()

    def run(self) -> None:
        try:
            if self._mode == "sync":
                self.log.emit("开始同步资源（干员名 + 地图）...")
                results = sync_all(
                    progress_cb=lambda m: self.log.emit(m),
                    cancel=self._cancel,
                )
                summary = "；".join(r.message for r in results)
                if all(r.ok for r in results):
                    self.finished_ok.emit(f"资源同步完成（{summary}）")
                else:
                    # 部分失败/取消也走 finished_ok——结果消息里已包含失败/取消信息，
                    # 这里不弹 failed 信号以免 UI 显示成" fatal exception"。
                    self.finished_ok.emit(summary)
            elif self._mode == "check_update":
                self.log.emit("检查 GitHub 最新版本...")
                info = UpdateChecker().check_software()
                if info is None:
                    self.finished_ok.emit("检查更新失败（网络错误）")
                elif info.has_update:
                    self.update_found.emit(info)
                else:
                    self.finished_ok.emit(f"已是最新版本 (v{__version__})")
            elif self._mode == "download":
                info = self._info
                if info is None or info.asset is None:
                    self.failed.emit("无可下载的更新包")
                    return
                # 下载到 %TEMP%，文件名带版本避免混淆
                import tempfile

                dest = Path(tempfile.gettempdir()) / f"aao_update_v{info.version}.zip"
                self.log.emit(f"下载更新包 v{info.version}…")

                ok = UpdateChecker().download_update(
                    info,
                    dest,
                    progress_cb=lambda d, t: self.download_progress.emit(d, t),
                    cancel=self._cancel,
                )
                if self._cancel.is_set():
                    self.finished_ok.emit("更新下载已取消")
                elif ok:
                    self.download_ready.emit(dest)
                else:
                    self.failed.emit("更新包下载失败（见日志）")
        except Exception as e:  # noqa: BLE001
            logger.exception("资源/更新操作失败")
            self.failed.emit(str(e))


class _PreviewWorker(QObject):
    """后台连指定 hwnd 截一张图，转 QPixmap 发回。"""

    got_image = Signal(object)  # QImage
    failed = Signal(str)

    def __init__(self, hwnd: Any):
        super().__init__()
        self._hwnd = hwnd

    def run(self) -> None:
        try:
            from maa.toolkit import Toolkit

            from aao.ui.runtime import connect_hwnd

            ctrl = connect_hwnd(Toolkit, self._hwnd)
            if ctrl is None:
                self.failed.emit("连接窗口失败")
                return
            img = ctrl.post_screencap().wait().get()
            if img is None:  # pyright: ignore[reportUnnecessaryComparison]  # MAA .get() 运行时可能 None（截图失败），存根未标 Optional
                self.failed.emit("截图失败")
                return
            # MAA 截图返回 numpy HxWxC(BGR)；转 QImage
            h, w = img.shape[:2]
            from PySide6.QtGui import QImage

            qimg = QImage(img.tobytes(), w, h, w * 3, QImage.Format.Format_BGR888)
            self.got_image.emit(qimg.copy())
        except Exception as e:  # noqa: BLE001
            logger.exception("预览截图失败")
            self.failed.emit(str(e))


class SettingsPage(QWidget):
    """设置页。"""

    settings_changed = Signal()  # 保存后通知 MainWindow（端口/profile 变更需重启生效）
    window_configured = Signal()  # 设为默认窗口后（新手引导用：连完窗口 → 校准）
    background_changed = Signal(str, float)  # 背景图路径 + 透明度(0-1)，即时应用

    def __init__(self):
        super().__init__()
        self._worker: _ResourceWorker | None = None
        self._thread: QThread | None = None
        self._res_mode: str | None = None  # 当前后台资源操作类型（用于取消按钮判断）
        self._pending_update: ReleaseInfo | None = None  # 检查到的新版本（待下载）
        self._auto_preview_done = False
        self._collapsibles: dict[str, CollapsibleBox] = {}
        self._build_ui()
        self._load()

    def _add_collapsible(
        self, root: QVBoxLayout, key: str, title: str, widget: QWidget, summary: str = ""
    ) -> CollapsibleBox:
        box = CollapsibleBox(title)
        box.set_summary(summary)
        box.add_widget(widget)
        box.toggled.connect(lambda expanded, k=key: self._save_collapsible_state(k, expanded))
        self._collapsibles[key] = box
        root.addWidget(box)
        return box

    def _save_collapsible_state(self, key: str, expanded: bool) -> None:
        s = load_settings()
        states = s.get("collapsible_sections", {})
        if not isinstance(states, dict):
            states = {}
        states[key] = expanded
        s["collapsible_sections"] = states
        save_settings(s)

    def showEvent(self, event: QShowEvent) -> None:  # noqa: D401
        # 切到设置页自动刷新窗口列表 + profile 下拉（新校准的立即可见）
        self._refresh_windows()
        self._load_profiles()
        # 默认窗口存在时，首次进入设置页自动截一次预览；后续由用户点“刷新截图”更新
        if not self._auto_preview_done and self._selected_window() is not None:
            self._auto_preview_done = True
            self._preview_window()
        super().showEvent(event)

    def _build_ui(self) -> None:
        root = QVBoxLayout(self)

        # --- 游戏窗口选择 ---
        win_box = QGroupBox("游戏窗口（多个「明日方舟」窗口时需指定）")
        win_layout = QHBoxLayout(win_box)

        # 左侧：截图预览
        self.lbl_preview = QLabel("未预览")
        self.lbl_preview.setAlignment(Qt.AlignmentFlag.AlignCenter)
        self.lbl_preview.setMinimumSize(320, 180)
        self.lbl_preview.setStyleSheet("background:#1f1f1f; color:#9aa0a6; border:1px solid #444;")
        win_layout.addWidget(self.lbl_preview, 1)

        # 右侧：窗口列表 + 操作按钮 + 状态
        right = QVBoxLayout()
        self.list_windows = QListWidget()
        apply_themed_scrollbar(self.list_windows, "QListWidget { background: transparent; }")
        self.list_windows.setMinimumWidth(320)
        self.list_windows.setMaximumHeight(140)
        right.addWidget(self.list_windows)

        win_btn_row = QHBoxLayout()
        self.btn_refresh_win = QPushButton("🔄 刷新列表")
        self.btn_preview = QPushButton("📸 刷新截图")
        self.btn_save_win = QPushButton("✓ 设为默认")
        for b in (self.btn_refresh_win, self.btn_preview, self.btn_save_win):
            win_btn_row.addWidget(b)
        win_btn_row.addStretch()
        right.addLayout(win_btn_row)
        self.lbl_win_status = QLabel("未选择")
        right.addWidget(self.lbl_win_status)
        right.addStretch()

        win_layout.addLayout(right, 2)
        self._add_collapsible(root, "settings_window", "游戏窗口", win_box, "选择/预览默认游戏窗口")

        # --- 运行设置 ---
        run_box = QGroupBox("运行设置")
        form = QFormLayout(run_box)
        self.cb_profile = QComboBox()
        self.cb_profile.setEditable(True)
        self._load_profiles()
        form.addRow("默认 profile:", self.cb_profile)

        self.edit_port = QLineEdit("2606")
        self.edit_port.setMaximumWidth(80)
        form.addRow("WebSocket 端口:", self.edit_port)

        self.chk_api = QCheckBox("启动 WebSocket API（实时帧广播）")
        self.chk_api.setChecked(True)
        form.addRow(self.chk_api)

        self.btn_save = QPushButton("💾 保存设置")
        form.addRow(self.btn_save)
        root.addWidget(run_box)

        # --- 资源 ---
        res_box = QGroupBox("资源（干员名 / 地图）")
        rl = QVBoxLayout(res_box)
        self.lbl_res_status = QLabel(self._res_status_text())
        rl.addWidget(self.lbl_res_status)
        proxy_form = QFormLayout()
        self.edit_proxy = QLineEdit()
        self.edit_proxy.setPlaceholderText("可选，如 http://127.0.0.1:7890（资源同步/更新使用）")
        proxy_form.addRow("下载代理:", self.edit_proxy)
        token_row = QHBoxLayout()
        self.edit_github_token = QLineEdit()
        self.edit_github_token.setPlaceholderText("可选，GitHub token（本机 DPAPI 加密保存）")
        self.edit_github_token.setEchoMode(QLineEdit.EchoMode.Password)
        self.btn_token_eye = QPushButton("👁")
        self.btn_token_eye.setMaximumWidth(40)
        token_row.addWidget(self.edit_github_token)
        token_row.addWidget(self.btn_token_eye)
        proxy_form.addRow("GitHub Token:", token_row)
        rl.addLayout(proxy_form)
        btn_row = QHBoxLayout()
        self.btn_sync = QPushButton("🔄 同步资源")
        self.btn_check = QPushButton("🔍 检查更新")
        for b in (self.btn_sync, self.btn_check):
            btn_row.addWidget(b)
        btn_row.addStretch()
        rl.addLayout(btn_row)
        self._add_collapsible(root, "settings_resources", "资源", res_box, self._res_status_text())

        # --- 软件设置 ---
        ui_box = QGroupBox("软件设置")
        ui_form = QFormLayout(ui_box)
        self.cb_theme = QComboBox()
        self.cb_theme.addItems([theme.label(m) for m in theme.MODES])
        ui_form.addRow("主题:", self.cb_theme)

        self.cb_close_action = QComboBox()
        self.cb_close_action.addItems(["每次询问", "最小化到托盘", "退出程序"])
        ui_form.addRow("关闭窗口时:", self.cb_close_action)

        self.cb_check_update_on_start = QCheckBox("启动时自动检查软件更新")
        self.cb_check_update_on_start.setChecked(True)
        ui_form.addRow("更新:", self.cb_check_update_on_start)

        self._add_collapsible(root, "settings_software", "软件设置", ui_box, "主题 / 关闭 / 更新")

        # --- 背景图 ---
        bg_box = QGroupBox("背景图")
        bg_form = QFormLayout(bg_box)
        self.edit_bg = QLineEdit()
        self.edit_bg.setPlaceholderText("可选，留空 = 无背景图")
        self.btn_bg_pick = QPushButton("📂 选择")
        self.btn_bg_clear = QPushButton("✕ 清除")
        bg_file_row = QHBoxLayout()
        bg_file_row.addWidget(self.edit_bg, 1)
        bg_file_row.addWidget(self.btn_bg_pick)
        bg_file_row.addWidget(self.btn_bg_clear)
        bg_form.addRow("图片:", bg_file_row)
        self.slider_bg = QSlider(Qt.Orientation.Horizontal)
        self.slider_bg.setRange(0, 100)
        self.slider_bg.setValue(25)
        self.lbl_bg_val = QLabel("25%")
        bg_op_row = QHBoxLayout()
        bg_op_row.addWidget(self.slider_bg, 1)
        bg_op_row.addWidget(self.lbl_bg_val)
        bg_form.addRow("透明度:", bg_op_row)
        self._add_collapsible(root, "settings_background", "背景图", bg_box, "设置主控台背景图片")

        # --- 日志 ---
        log_box = QGroupBox("日志")
        log_layout = QVBoxLayout(log_box)
        log_layout.addWidget(QLabel("导出全部日志，便于反馈排查。"))
        self.btn_export_log = QPushButton("📦 导出日志")
        log_row = QHBoxLayout()
        log_row.addWidget(self.btn_export_log)
        log_row.addStretch()
        log_layout.addLayout(log_row)
        self._add_collapsible(root, "settings_log", "日志", log_box, "导出运行时日志")

        root.addStretch()

        # 日志
        self.lbl_op = QLabel("")
        root.addWidget(self.lbl_op)

        # 信号
        self.btn_save.clicked.connect(self._on_save)
        self.cb_theme.currentIndexChanged.connect(self._on_theme_changed)
        self.btn_bg_pick.clicked.connect(self._on_bg_pick)
        self.btn_bg_clear.clicked.connect(self._on_bg_clear)
        self.slider_bg.valueChanged.connect(self._on_bg_opacity)
        self.btn_sync.clicked.connect(self._on_sync_clicked)
        self.btn_check.clicked.connect(lambda: self._run_resource("check_update"))
        self.btn_refresh_win.clicked.connect(self._refresh_windows)
        self.btn_preview.clicked.connect(self._preview_window)
        self.btn_save_win.clicked.connect(self._save_window)
        self.btn_token_eye.clicked.connect(self._toggle_token_visible)
        self.btn_export_log.clicked.connect(self._on_export_log)

        self._windows: list[Any] = []  # DesktopWindow 列表（与 list_windows 行对应）
        self._preview_thread: QThread | None = None
        self._preview_worker: _PreviewWorker | None = None

    def _load_profiles(self) -> None:
        cur = self.cb_profile.currentText()
        self.cb_profile.clear()
        d = project_root() / "config" / "calibration"
        for p in sorted(d.glob("*.json")):
            self.cb_profile.addItem(p.name)
        if cur:
            self.cb_profile.setCurrentText(cur)

    def _res_status_text(self) -> str:
        from aao.core.geometry.map_loader import list_codes

        names_p = project_root() / "data" / "operator_names.json"
        n_oper = 0
        if names_p.exists():
            try:
                n_oper = len(json.loads(names_p.read_text(encoding="utf-8")))
            except (OSError, ValueError):
                pass
        try:
            n_maps = len(list_codes())
        except Exception:  # noqa: BLE001
            n_maps = 0
        return f"干员名: {n_oper} 个  |  地图: {n_maps} 关"

    # --- 游戏窗口选择 ---

    def _refresh_windows(self) -> None:
        """刷新候选窗口列表（名字含「明日方舟」）。"""
        from maa.toolkit import Toolkit

        self.list_windows.clear()
        self._windows = []
        try:
            from aao.ui.runtime import list_game_windows

            wins = list_game_windows(Toolkit)
        except Exception as e:  # noqa: BLE001
            self.lbl_win_status.setText(f"刷新失败: {e}")
            return
        if not wins:
            self.lbl_win_status.setText("未找到「明日方舟」窗口")
            return
        saved = load_settings()
        saved_name = saved.get("window_name")
        saved_class = saved.get("window_class")
        saved_row = -1
        for i, w in enumerate(wins):
            text = f"{w.window_name}  [类: {w.class_name}]"
            item = QListWidgetItem(text)
            if w.window_name == saved_name and (not saved_class or w.class_name == saved_class):
                # 标记当前默认
                item.setText("★ " + text)
                saved_row = i
            self.list_windows.addItem(item)
            self._windows.append(w)
        if saved_row >= 0:
            self.list_windows.setCurrentRow(saved_row)
        self.lbl_win_status.setText(f"找到 {len(wins)} 个窗口，选中后可预览/设为默认")

    def _selected_window(self):
        row = self.list_windows.currentRow()
        if row < 0 or row >= len(self._windows):
            return None
        return self._windows[row]

    def _preview_window(self) -> None:
        """对选中窗口截图，并嵌入显示在游戏窗口设置区（后台线程避免卡 UI）。"""
        w = self._selected_window()
        if w is None:
            self.lbl_win_status.setText("请先在列表选中一个窗口")
            return
        if self._preview_thread is not None:
            self.lbl_win_status.setText("上一次预览还在进行…")
            return
        self.lbl_win_status.setText(f"正在截图预览: {w.window_name}…")
        self._preview_worker = _PreviewWorker(w.hwnd)
        self._preview_thread = QThread()
        self._preview_worker.moveToThread(self._preview_thread)
        self._preview_thread.started.connect(self._preview_worker.run)
        self._preview_worker.got_image.connect(self._show_preview)
        self._preview_worker.failed.connect(self._on_preview_failed)
        self._preview_worker.got_image.connect(self._preview_thread.quit)
        self._preview_worker.failed.connect(self._preview_thread.quit)
        self._preview_thread.finished.connect(self._cleanup_preview_thread)
        self._preview_thread.start()

    def _show_preview(self, qimg: QImage) -> None:
        from PySide6.QtGui import QPixmap

        pix = QPixmap.fromImage(qimg)
        target_w = max(320, self.lbl_preview.width() - 12)
        if pix.width() > target_w:
            pix = pix.scaledToWidth(target_w, Qt.TransformationMode.SmoothTransformation)
        self.lbl_preview.setPixmap(pix)
        self.lbl_preview.setText("")
        self.lbl_win_status.setText("预览已更新，确认是对的画面后可设为默认")

    def _on_preview_failed(self, msg: str) -> None:
        from PySide6.QtGui import QPixmap

        self.lbl_preview.setPixmap(QPixmap())
        self.lbl_preview.setText("预览失败")
        self.lbl_win_status.setText(f"预览失败: {msg}")

    def _save_window(self) -> None:
        """把选中窗口的 name/class 存入 settings.json（启动时优先连它）。"""
        w = self._selected_window()
        if w is None:
            self.lbl_win_status.setText("请先在列表选中一个窗口")
            return
        s = load_settings()
        s["window_name"] = w.window_name
        s["window_class"] = w.class_name
        save_settings(s)
        self.lbl_win_status.setText(f"已设为默认: {w.window_name}（重启生效）")
        self.settings_changed.emit()
        self.window_configured.emit()
        self._refresh_windows()  # 刷新★标记

    def _cleanup_preview_thread(self) -> None:
        if self._preview_thread is not None:
            self._preview_thread.wait()
        self._preview_worker = None
        self._preview_thread = None

    def _toggle_token_visible(self) -> None:
        if self.edit_github_token.echoMode() == QLineEdit.EchoMode.Password:
            self.edit_github_token.setEchoMode(QLineEdit.EchoMode.Normal)
            self.btn_token_eye.setText("🙈")
        else:
            self.edit_github_token.setEchoMode(QLineEdit.EchoMode.Password)
            self.btn_token_eye.setText("👁")

    def _on_export_log(self) -> None:
        """导出 debug/ 全部日志为 zip：弹保存对话框 → 打包 → 打开所在文件夹。"""
        from datetime import datetime

        from aao.utils.logger import export_logs

        default_name = f"aao-logs-{datetime.now().strftime('%Y%m%d-%H%M%S')}.zip"
        dest, _ = QFileDialog.getSaveFileName(self, "导出日志", default_name, "ZIP 压缩包 (*.zip)")
        if not dest:
            return
        try:
            n = export_logs(Path(dest))
        except Exception as e:  # noqa: BLE001
            logger.exception("导出日志失败")
            QMessageBox.warning(self, "导出失败", f"导出日志失败：{e}")
            return
        if n == 0:
            self.lbl_op.setText("无日志可导出（debug/ 不存在）")
            return
        self.lbl_op.setText(f"已导出 {n} 个日志文件到 {dest}")
        # 打开所在文件夹并选中（Windows explorer /select）
        from aao.utils.runtime_paths import is_frozen

        if is_frozen():
            import subprocess

            subprocess.Popen(["explorer", "/select,", str(Path(dest).resolve())])
        else:
            from PySide6.QtCore import QUrl
            from PySide6.QtGui import QDesktopServices

            QDesktopServices.openUrl(QUrl.fromLocalFile(str(Path(dest).parent)))

    def _on_theme_changed(self, idx: int) -> None:
        """主题下拉切换：即时应用 + 持久化（纯 UI 偏好，无需重启或点保存按钮）。"""
        mode = theme.MODES[idx]
        theme.apply_theme(mode)
        # 背景层是自绘的：主题切换后在下一轮事件循环刷新一次，等 Qt 完成 palette 传播。
        QTimer.singleShot(0, lambda: self._emit_background(save=False))
        s = load_settings()
        s["theme"] = mode
        save_settings(s)
        self.lbl_op.setText(f"主题已切换为：{theme.label(mode)}")

    def _on_bg_pick(self) -> None:
        path, _ = QFileDialog.getOpenFileName(
            self, "选择背景图", "", "图片 (*.png *.jpg *.jpeg *.bmp *.webp)"
        )
        if not path:
            return
        self.edit_bg.setText(path)
        self._emit_background()

    def _on_bg_clear(self) -> None:
        self.edit_bg.clear()
        self._emit_background()

    def _on_bg_opacity(self, value: int) -> None:
        self.lbl_bg_val.setText(f"{value}%")
        self._emit_background()

    def _emit_background(self, save: bool = True) -> None:
        """即时应用背景（发信号给 MainWindow）；默认同时持久化。"""
        path = self.edit_bg.text().strip()
        opacity = self.slider_bg.value() / 100.0
        self.background_changed.emit(path, opacity)
        if not save:
            return
        s = load_settings()
        s["background_image"] = path
        s["background_opacity"] = self.slider_bg.value()
        save_settings(s)

    def _load(self) -> None:
        s = load_settings()
        # 主题：静默选中（启动时已由 app.py 应用，这里只同步下拉），切换时才即时生效
        self.cb_theme.blockSignals(True)
        mode = s.get("theme", theme.AUTO)
        self.cb_theme.setCurrentIndex(theme.MODES.index(mode) if mode in theme.MODES else 0)
        self.cb_theme.blockSignals(False)
        # 背景图：同步控件（启动时由 app.py 应用，这里静默，切换时才 emit）
        self.edit_bg.setText(s.get("background_image", ""))
        self.slider_bg.blockSignals(True)
        self.slider_bg.setValue(int(s.get("background_opacity", 25)))
        self.slider_bg.blockSignals(False)
        self.lbl_bg_val.setText(f"{self.slider_bg.value()}%")
        states = s.get("collapsible_sections", {})
        if isinstance(states, dict):
            for key, box in self._collapsibles.items():
                if key in states:
                    box.set_expanded(bool(states[key]))
        if s.get("profile"):
            self.cb_profile.setCurrentText(s["profile"])
        if s.get("port"):
            self.edit_port.setText(str(s["port"]))
        self.chk_api.setChecked(s.get("api", True))
        close_map = {"": 0, "minimize": 1, "exit": 2}
        self.cb_close_action.setCurrentIndex(close_map.get(s.get("close_action", ""), 0))
        self.cb_check_update_on_start.setChecked(s.get("check_update_on_start", True))
        if s.get("proxy"):
            self.edit_proxy.setText(str(s["proxy"]))
        if s.get("github_token_enc"):
            try:
                from aao.utils.secure_store import decrypt_text

                self.edit_github_token.setText(decrypt_text(str(s["github_token_enc"])))
            except Exception:  # noqa: BLE001
                self.edit_github_token.clear()
                self.lbl_op.setText("GitHub Token 解密失败，可重新填写")

    def _on_save(self) -> None:
        try:
            port = int(self.edit_port.text())
        except ValueError:
            QMessageBox.warning(self, "端口无效", "WebSocket 端口必须是整数")
            return
        data = load_settings()
        data.update(
            {
                "profile": self.cb_profile.currentText(),
                "port": port,
                "api": self.chk_api.isChecked(),
                "proxy": self.edit_proxy.text().strip(),
                "close_action": ["", "minimize", "exit"][self.cb_close_action.currentIndex()],
                "check_update_on_start": self.cb_check_update_on_start.isChecked(),
            }
        )
        token = self.edit_github_token.text().strip()
        if token:
            try:
                from aao.utils.secure_store import encrypt_text

                data["github_token_enc"] = encrypt_text(token)
            except Exception as e:  # noqa: BLE001
                QMessageBox.warning(self, "Token 保存失败", f"GitHub Token 加密失败：{e}")
                return
        else:
            data.pop("github_token_enc", None)
        save_settings(data)
        self.lbl_op.setText("设置已保存（端口/profile/代理/Token 变更需重启或下次同步生效）")
        self.settings_changed.emit()

    def _on_sync_clicked(self) -> None:
        """同步按钮：未在跑 → 启动同步；正在同步/下载 → 请求取消。"""
        if (
            self._thread is not None
            and self._res_mode in ("sync", "download")
            and self._worker is not None
        ):
            self._worker.cancel()
            self.btn_sync.setText("取消中…")
            self.btn_sync.setEnabled(False)
            return
        self._run_resource("sync")

    def _run_resource(self, mode: str, info: ReleaseInfo | None = None) -> None:
        if self._thread is not None:
            self.lbl_op.setText("上一次操作还在进行中…")
            return
        self._res_mode = mode
        self.lbl_op.setText("进行中…")
        self._worker = _ResourceWorker(mode, info=info)
        self._thread = QThread()
        self._worker.moveToThread(self._thread)
        self._thread.started.connect(self._worker.run)
        self._worker.log.connect(self.lbl_op.setText)
        self._worker.update_found.connect(self._on_update_found)
        self._worker.download_progress.connect(self._on_download_progress)
        self._worker.download_ready.connect(self._on_download_ready)
        self._worker.finished_ok.connect(self._on_res_done)
        self._worker.failed.connect(self._on_res_done)
        self._worker.finished_ok.connect(self._thread.quit)
        self._worker.failed.connect(self._thread.quit)
        self._thread.finished.connect(self._cleanup_thread)
        if mode == "sync":
            # 同步可取消：检查按钮禁用，同步按钮复用为取消入口。
            self.btn_check.setEnabled(False)
            self.btn_sync.setText("✕ 取消同步")
        elif mode == "download":
            # 下载可取消：检查按钮禁用，同步按钮复用为取消入口。
            self.btn_check.setEnabled(False)
            self.btn_sync.setText("✕ 取消下载")
        else:
            self._set_res_buttons(False)
        self._thread.start()

    def _on_update_found(self, info: ReleaseInfo) -> None:
        """check_update 发现新版本：弹窗询问是否立即更新。

        源码模式（非 frozen）下自更新不适用——中转 bat 的 robocopy 布局针对
        打包后的 aao.app/，对源码树会破坏 .git/aao 等目录。故源码模式只提示
        用 git pull 更新，不进入下载流程。
        """
        # check_update 的 worker 已 emit 完结果，线程无事可做——主动结束并清理。
        # 它只 emit 了 update_found（没走 finished_ok/failed），QThread 不会自动退出，
        # self._thread 也不会被 _cleanup_thread 清空。若不在此清理，弹窗里点「立即更新」
        # 触发的 _run_resource("download") 会被守卫挡住（“上一次操作还在进行中…”），
        # 下载线程根本起不来。模态弹窗会阻塞主线程事件循环，故必须在弹窗前同步清理。
        self._finalize_current_resource()

        from aao.utils.runtime_paths import is_frozen

        self._pending_update = info

        if not is_frozen():
            box = QMessageBox(self)
            box.setWindowTitle("发现新版本")
            box.setIcon(QMessageBox.Icon.Information)
            box.setText(
                f"新版本 v{info.version} 已发布（当前 v{__version__}）。\n"
                f"你正在从源码运行，自动更新不适用。\n"
                f"请用 git pull && uv sync 更新代码与依赖。"
            )
            btn_open = box.addButton("打开 Release 页", QMessageBox.ButtonRole.AcceptRole)
            box.addButton("关闭", QMessageBox.ButtonRole.RejectRole)
            box.exec()
            if box.clickedButton() is btn_open and info.html_url:
                from PySide6.QtCore import QUrl
                from PySide6.QtGui import QDesktopServices

                QDesktopServices.openUrl(QUrl(info.html_url))
            self.lbl_op.setText(f"新版本 v{info.version} 可用（源码模式：git pull 更新）")
            return

        asset_note = ""
        if info.asset:
            asset_note = f"\n大小: {_fmt_size(info.asset.size)}"
        box = QMessageBox(self)
        box.setWindowTitle("发现新版本")
        box.setIcon(QMessageBox.Icon.Information)
        box.setText(
            f"新版本 v{info.version} 已发布（当前 v{__version__}）。{asset_note}\n"
            f"更新将下载完整安装包并替换当前版本（配置/校准/日志保留）。"
        )
        btn_now = box.addButton("立即更新", QMessageBox.ButtonRole.AcceptRole)
        box.addButton("稍后", QMessageBox.ButtonRole.RejectRole)
        box.exec()
        if box.clickedButton() is btn_now:
            self._start_download()
        else:
            self.lbl_op.setText(f"新版本 v{info.version} 可用，点「检查更新」再试")

    def _start_download(self) -> None:
        info = self._pending_update
        if info is None:
            return
        self._run_resource("download", info=info)

    def _on_download_progress(self, downloaded: int, total: int) -> None:
        if total > 0:
            pct = downloaded * 100 // total
            self.lbl_op.setText(f"下载更新包… {pct}%  ({_fmt_size(downloaded)}/{_fmt_size(total)})")
        else:
            self.lbl_op.setText(f"下载更新包… {_fmt_size(downloaded)}")

    def _on_download_ready(self, zip_path: Path) -> None:
        """下载完成：弹重启确认 → apply_update → 退出 app 让中转 bat 接管。"""
        from aao.resources.updater import UpdateChecker

        box = QMessageBox(self)
        box.setWindowTitle("更新就绪")
        box.setIcon(QMessageBox.Icon.Question)
        box.setText("更新包已下载完成。重启应用以完成安装？（配置/校准/日志会保留）")
        btn_restart = box.addButton("重启并安装", QMessageBox.ButtonRole.AcceptRole)
        box.addButton("稍后", QMessageBox.ButtonRole.RejectRole)
        box.exec()
        if box.clickedButton() is not btn_restart:
            self.lbl_op.setText("更新已下载，下次启动可手动安装")
            return

        # 生成中转 bat 并启动；随后退出当前进程，bat 等 exe 退出后替换+重启。
        try:
            UpdateChecker().apply_update(Path(zip_path))
        except Exception as e:  # noqa: BLE001
            logger.exception("启动自更新失败")
            self.lbl_op.setText(f"启动更新失败: {e}")
            return
        logger.info("自更新中转已启动，退出主进程以完成安装")
        # 触发真退出：必须走 MainWindow 的强制退出路径（设 _force_quit + 停 worker + quit），
        # 不能只调 QApplication.quit()——后者不设 _force_quit，closeEvent 会弹"关闭行为选择"
        # 对话框，且 minimize 偏好下 exe 不真退出，bat 的等退出循环永远等不到，更新卡死。
        from PySide6.QtWidgets import QApplication

        app = QApplication.instance()
        if app is None:
            return
        # topLevelWidgets 是 QApplication 的静态方法；app 实例类型标注为 QCoreApplication，
        # 故通过类名调用，绕过类型窄化。
        for w in QApplication.topLevelWidgets():
            quit_fn = getattr(w, "_quit_from_tray", None)
            if callable(quit_fn):
                quit_fn()
                return
        # 兜底（找不到 MainWindow）：直接 quit
        app.quit()

    def _on_res_done(self, msg: str) -> None:
        self.lbl_op.setText(msg)
        self._set_res_buttons(True)
        self.btn_sync.setText("🔄 同步资源")
        self.lbl_res_status.setText(self._res_status_text())

    def _set_res_buttons(self, enabled: bool) -> None:
        for b in (self.btn_sync, self.btn_check):
            b.setEnabled(enabled)

    def _cleanup_thread(self) -> None:
        if self._thread is not None:
            self._thread.wait()
        self._worker = None
        self._thread = None
        self._res_mode = None

    def _finalize_current_resource(self) -> None:
        """主动结束并清理当前资源 worker 线程。

        用于 check_update 发现更新后：worker 只 emit 了 update_found，QThread 不会
        自动退出，self._thread 不会被 _cleanup_thread 清空，导致后续下载被
        _run_resource 的“上一次操作还在进行中”守卫挡住。此处同步 quit+wait 清理，
        并恢复按钮状态（update_found 不走 _on_res_done，按钮不会自行恢复）。

        _cleanup_thread 仍会由 thread.finished 触发一次，但此时 self._thread 已为 None，
        其逻辑幂等，不会重复出错。
        """
        if self._thread is not None:
            self._thread.quit()
            self._thread.wait()
        self._worker = None
        self._thread = None
        self._res_mode = None
        self._set_res_buttons(True)
        self.btn_sync.setText("🔄 同步资源")