04-GUI.py

"""
Fun-ASR-GGUF PyQt6 GUI

目标：
- 覆盖原项目推理全部设置项（引擎 + 转写）
- 支持模型下载位置 / 导出位置
- 支持音频/视频文件（视频自动抽取音频后处理）
- 支持递归遍历文件夹批处理
- 导出模型时检测已有文件，避免重复工作（由导出脚本的 skip-existing 支持保障）
"""

from __future__ import annotations

import io
import os
import sys
import json
import time
import shutil
import tempfile
import subprocess
import re
import threading
import wave
from datetime import datetime
from dataclasses import dataclass, asdict, field
from pathlib import Path
from typing import Optional, List, Tuple

# 关键：Windows 下如果先 import PyQt6，再 import onnxruntime，
# 可能触发 onnxruntime 的 DLL 初始化失败。
# 先行导入 onnxruntime 可规避该冲突（你遇到的报错就属于这一类）。
try:
    import onnxruntime  # noqa: F401
except Exception:
    # 允许 UI 继续启动，后续在真正开始推理时再提示缺失/错误
    pass

from PyQt6.QtCore import Qt, QSettings, QThread, pyqtSignal
from PyQt6.QtGui import QFont
from PyQt6.QtWidgets import (
    QApplication,
    QMainWindow,
    QWidget,
    QTabWidget,
    QVBoxLayout,
    QHBoxLayout,
    QFormLayout,
    QGroupBox,
    QLabel,
    QLineEdit,
    QPushButton,
    QFileDialog,
    QCheckBox,
    QSpinBox,
    QDoubleSpinBox,
    QTextEdit,
    QPlainTextEdit,
    QMessageBox,
    QProgressBar,
    QComboBox,
    QDockWidget,
    QListWidget,
    QListWidgetItem,
    QTableWidget,
    QTableWidgetItem,
    QHeaderView,
    QSplitter,
    QAbstractItemView,
)

from fun_asr_gguf import create_asr_engine
from fun_asr_gguf.srt_utils import generate_srt_file


AUDIO_EXTS = {
    ".wav", ".mp3", ".flac", ".m4a", ".aac", ".ogg", ".opus", ".wma", ".aiff", ".aif", ".alac"
}
VIDEO_EXTS = {
    ".mp4", ".mkv", ".avi", ".mov", ".flv", ".wmv", ".webm", ".m4v", ".ts", ".mts", ".m2ts"
}


def repo_root() -> Path:
    return Path(__file__).resolve().parent


def today_dir() -> Path:
    """根目录下按日期创建文件夹：YYYY-MM-DD"""
    d = repo_root() / datetime.now().strftime("%Y-%m-%d")
    d.mkdir(parents=True, exist_ok=True)
    return d


def new_run_dir(prefix: str) -> Path:
    """在当天目录下创建一次运行目录（避免冲突自动加序号）"""
    base = today_dir()
    ts = datetime.now().strftime("%H%M%S")
    cand = base / f"{prefix}-{ts}"
    if not cand.exists():
        cand.mkdir(parents=True, exist_ok=True)
        return cand
    for i in range(1, 1000):
        cand2 = base / f"{prefix}-{ts}-{i:03d}"
        if not cand2.exists():
            cand2.mkdir(parents=True, exist_ok=True)
            return cand2
    cand.mkdir(parents=True, exist_ok=True)
    return cand


def find_ffmpeg() -> Optional[str]:
    # 1) env override
    env = os.environ.get("FFMPEG_BINARY")
    if env and Path(env).exists():
        return env

    # 2) PATH
    p = shutil.which("ffmpeg") or shutil.which("ffmpeg.exe")
    if p:
        return p

    # 3) local repo root
    local = repo_root() / "ffmpeg.exe"
    if local.exists():
        return str(local)
    return None


def is_video(path: str) -> bool:
    return Path(path).suffix.lower() in VIDEO_EXTS


def is_audio(path: str) -> bool:
    return Path(path).suffix.lower() in AUDIO_EXTS


def extract_audio_to_wav(
    input_path: str,
    out_wav_path: str,
    sample_rate: int = 16000,
    start_second: Optional[float] = None,
    duration: Optional[float] = None,
) -> None:
    ffmpeg = find_ffmpeg()
    if not ffmpeg:
        raise RuntimeError("未找到 ffmpeg。请安装 ffmpeg，或把 ffmpeg.exe 放到项目根目录，或设置环境变量 FFMPEG_BINARY。")

    cmd: List[str] = [ffmpeg, "-y"]
    # 尽量把裁剪放在输入前，减少解码量
    if start_second is not None:
        cmd += ["-ss", str(float(start_second))]
    if duration is not None:
        cmd += ["-t", str(float(duration))]
    cmd += [
        "-i", input_path,
        "-vn",
        "-ac", "1",
        "-ar", str(int(sample_rate)),
        "-c:a", "pcm_s16le",
        out_wav_path,
    ]

    # Windows 控制台编码可能导致 text 解码异常，这里用 errors=replace 保证不崩溃
    p = subprocess.run(cmd, capture_output=True, text=True, errors="replace")
    if p.returncode != 0:
        raise RuntimeError(f"ffmpeg 抽取音频失败：{p.stderr.strip() or p.stdout.strip()}")


def _ffmpeg_filter_for_mode(mode: str) -> Optional[str]:
    """
    返回 ffmpeg -af 的滤镜链（不改变时长/时间轴）。
    说明：
    - denoise：背景降噪（afftdn）
    - enhance：人声增强（高通/低通 + 轻度压缩 + 降噪）
    """
    mode = (mode or "none").strip().lower()
    if mode in ("none", ""):
        return None
    if mode == "denoise":
        # 先降噪（不改变时长/时间轴）
        return "afftdn=nf=-25"
    if mode == "enhance":
        # 先轻度降噪，再做带通/压缩，提升人声清晰度
        return "afftdn=nf=-25,highpass=f=80,lowpass=f=8000,acompressor=threshold=-18dB:ratio=3:attack=5:release=50"
    if mode in ("denoise+enhance", "enhance+denoise"):
        return "afftdn=nf=-25,highpass=f=80,lowpass=f=8000,acompressor=threshold=-18dB:ratio=3:attack=5:release=50"
    return None


def convert_media_to_wav(
    input_path: str,
    out_wav_path: str,
    sample_rate: int = 16000,
    start_second: Optional[float] = None,
    duration: Optional[float] = None,
    ffmpeg_af: Optional[str] = None,
) -> None:
    """
    使用 ffmpeg 将音频/视频转为 16k 单声道 wav，可选降噪/增强。
    注意：如果传入 start_second/duration，会裁剪时间轴（输出从 0 开始）。
    """
    ffmpeg = find_ffmpeg()
    if not ffmpeg:
        raise RuntimeError("未找到 ffmpeg。请安装 ffmpeg，或把 ffmpeg.exe 放到项目根目录，或设置环境变量 FFMPEG_BINARY。")

    cmd: List[str] = [ffmpeg, "-y"]
    if start_second is not None:
        cmd += ["-ss", str(float(start_second))]
    if duration is not None:
        cmd += ["-t", str(float(duration))]

    cmd += ["-i", input_path, "-vn"]
    if ffmpeg_af:
        cmd += ["-af", ffmpeg_af]
    cmd += ["-ac", "1", "-ar", str(int(sample_rate)), "-c:a", "pcm_s16le", out_wav_path]

    p = subprocess.run(cmd, capture_output=True, text=True, errors="replace")
    if p.returncode != 0:
        raise RuntimeError(f"ffmpeg 转换失败：{p.stderr.strip() or p.stdout.strip()}")


def prepare_wav_for_asr(
    input_path: str,
    sample_rate: int,
    start_second: Optional[float],
    duration: Optional[float],
    preprocess_mode: str,
    external_cmd_tpl: str,
    log_fn,
    work_dir: Optional[str] = None,
) -> tuple[str, float, Optional[tempfile.TemporaryDirectory]]:
    """
    固定管线（按用户需求）：
    1) 抽取/转码音频为 wav（可裁剪）
    2) 对抽取出的 wav 进行降噪/增强（或 external 工具）
    3) 返回用于识别的最终 wav 路径

    Returns:
      (wav_path_for_asr, clip_offset_seconds, temp_dir_or_none)
    """
    tmp: Optional[tempfile.TemporaryDirectory] = None
    if work_dir:
        base_dir = Path(work_dir)
        base_dir.mkdir(parents=True, exist_ok=True)
    else:
        tmp = tempfile.TemporaryDirectory(prefix="fun_asr_pipe_")
        base_dir = Path(tmp.name)
    clip_offset = float(start_second or 0.0) if start_second not in (None, 0, 0.0) else 0.0

    extracted = str(base_dir / (Path(input_path).stem + ".extracted.wav"))
    log_fn(f"[预处理] 输入: {input_path}")
    log_fn(f"[预处理] 裁剪: start_second={start_second}, duration={duration}")
    log_fn(f"[预处理] 抽取音频 -> wav: {extracted}")
    # 第一步：无滤镜抽取（对音频/视频统一处理），必要时在这里裁剪
    convert_media_to_wav(
        input_path=input_path,
        out_wav_path=extracted,
        sample_rate=sample_rate,
        start_second=start_second if clip_offset else None,
        duration=duration,
        ffmpeg_af=None,
    )
    d_ex = try_get_wav_duration_seconds(extracted)
    if d_ex is not None:
        log_fn(f"[预处理] extracted.wav 时长: {d_ex:.2f}s")

    mode = (preprocess_mode or "none").strip().lower()
    if mode in ("none", ""):
        return extracted, clip_offset, tmp

    if mode == "external":
        cmd_tpl = (external_cmd_tpl or "").strip()
        if not cmd_tpl:
            # 没配置 external 命令则退化为不处理
            log_fn("[预处理] external 未配置命令，跳过预处理")
            return extracted, clip_offset, tmp

        processed = str(base_dir / (Path(input_path).stem + ".processed.wav"))
        cmd = cmd_tpl.format(**{"in": extracted, "out": processed})
        log_fn(f"[预处理] external: {cmd}")
        p = subprocess.run(cmd, shell=True, capture_output=True, text=True, errors="replace")
        if p.stdout.strip():
            log_fn(p.stdout)
        if p.stderr.strip():
            log_fn(p.stderr)
        if p.returncode != 0:
            raise RuntimeError(f"外部预处理失败，退出码 {p.returncode}")
        d_p = try_get_wav_duration_seconds(processed)
        if d_p is not None:
            log_fn(f"[预处理] processed.wav 时长: {d_p:.2f}s")
            if d_ex is not None and abs(d_p - d_ex) > 0.5:
                log_fn(f"[预处理][警告] processed 时长({d_p:.2f}s) 与 extracted({d_ex:.2f}s) 差异较大，可能导致只识别前一段。")
        return processed, clip_offset, tmp

    # ffmpeg 降噪/增强
    af = _ffmpeg_filter_for_mode(mode)
    if not af:
        return extracted, clip_offset, tmp

    processed = str(base_dir / (Path(input_path).stem + ".processed.wav"))
    log_fn(f"[预处理] ffmpeg af={af} -> {processed}")
    # 第二步：对已抽取的 wav 做滤镜（不再裁剪，不改变时长）
    convert_media_to_wav(
        input_path=extracted,
        out_wav_path=processed,
        sample_rate=sample_rate,
        start_second=None,
        duration=None,
        ffmpeg_af=af,
    )
    d_p = try_get_wav_duration_seconds(processed)
    if d_p is not None:
        log_fn(f"[预处理] processed.wav 时长: {d_p:.2f}s")
        if d_ex is not None and abs(d_p - d_ex) > 0.5:
            log_fn(f"[预处理][警告] processed 时长({d_p:.2f}s) 与 extracted({d_ex:.2f}s) 差异较大，可能导致只识别前一段。")
    return processed, clip_offset, tmp


def read_hotword_files(paths: List[str]) -> List[str]:
    """
    读取多个热词文件并合并（去重、保持顺序）。
    规则：
    - 忽略空行
    - 忽略以 # 开头的注释行
    """
    seen = set()
    out: List[str] = []
    for p in paths:
        try:
            with open(p, "r", encoding="utf-8", errors="ignore") as f:
                for line in f:
                    s = line.strip()
                    if not s:
                        continue
                    if s.startswith("#"):
                        continue
                    if s not in seen:
                        seen.add(s)
                        out.append(s)
        except Exception:
            continue
    return out


def try_get_wav_duration_seconds(wav_path: str) -> Optional[float]:
    """读取 WAV 头估算时长（调试/提示用途）。"""
    try:
        with wave.open(wav_path, "rb") as wf:
            frames = wf.getnframes()
            rate = wf.getframerate()
            if rate <= 0:
                return None
            return float(frames) / float(rate)
    except Exception:
        return None


@dataclass
class EngineSettings:
    # 模型路径
    model_output_dir: str = str(repo_root() / "model")
    encoder_onnx: str = str(repo_root() / "model" / "Fun-ASR-Nano-Encoder-Adaptor.fp32.onnx")
    ctc_onnx: str = str(repo_root() / "model" / "Fun-ASR-Nano-CTC.int8.onnx")
    decoder_gguf: str = str(repo_root() / "model" / "Fun-ASR-Nano-Decoder.q8_0.gguf")
    tokens: str = str(repo_root() / "model" / "tokens.txt")
    # 兼容：保留单文件字段；GUI 会优先使用 hotwords_files（可多选）
    hotwords: str = str(repo_root() / "hot.txt")
    hotwords_files: List[str] = field(default_factory=list)

    # 引擎设置（来自 FunASREngine / ASREngineConfig）
    enable_ctc: bool = True
    n_predict: int = 512
    n_threads: int = 0  # 0 表示自动
    n_threads_batch: int = 0  # 0 表示自动
    n_ubatch: int = 512
    similar_threshold: float = 0.6
    max_hotwords: int = 10

    # Vulkan/llama.cpp 环境开关（与 README/示例一致）
    disable_vulkan: bool = False              # VK_ICD_FILENAMES=none
    force_igpu: bool = False                  # GGML_VK_VISIBLE_DEVICES=0
    disable_vulkan_f16: bool = False          # GGML_VK_DISABLE_F16=1


@dataclass
class TranscribeSettings:
    language: str = ""  # 空=自动
    context: str = ""
    verbose: bool = False
    segment_size: float = 60.0
    overlap: float = 4.0
    start_second: Optional[float] = 0.0
    duration: Optional[float] = None

    export_srt: bool = True
    max_chars_per_line: int = 30
    srt_max_gap_seconds: float = 0.8

    # 音频预处理（不改变时间轴；仅改善音质/人声占比）
    # none / denoise / enhance / denoise+enhance / external
    preprocess_mode: str = "none"
    external_preprocess_cmd: str = ""

    # 输出
    output_dir: str = str(repo_root() / "outputs")
    skip_existing: bool = True
    keep_folder_structure: bool = True


class BaseWorker(QThread):
    log = pyqtSignal(str)
    progress = pyqtSignal(int, int, str)  # current, total, item
    done = pyqtSignal(bool, str)

    def __init__(self):
        super().__init__()
        self._cancel = False

    def cancel(self):
        self._cancel = True

    def cancelled(self) -> bool:
        return self._cancel

    def _emit_log(self, s: str):
        self.log.emit(s.rstrip("\n") + "\n")


class _QtLogStream:
    """
    将 sys.stdout/sys.stderr 重定向到 GUI 日志，并实时解析“阶段/分段”进度。
    DisplayReporter 可能在后台线程写 stdout，因此这里必须线程安全。
    """

    _re_seg_prefix = re.compile(r"^\[(\d+)\s*/\s*(\d+)\]\s*$")
    _re_seg_inline = re.compile(r"^\[(\d+)\s*/\s*(\d+)\]\s+(.*)$")
    _re_stage = re.compile(r"^\[(\d+)\]\s+(.*)$")

    def __init__(self, emit_line, emit_progress):
        self._emit_line = emit_line
        self._emit_progress = emit_progress
        self._buf = ""
        self._lock = threading.Lock()
        self._seg_i = 0
        self._seg_total = 0

    def write(self, s: str):
        if not s:
            return
        with self._lock:
            self._buf += s
            while "\n" in self._buf:
                line, self._buf = self._buf.split("\n", 1)
                self._handle_line(line.rstrip("\r"))

    def flush(self):
        with self._lock:
            if self._buf.strip():
                self._handle_line(self._buf.strip("\r"))
            self._buf = ""

    def isatty(self):
        return False

    def _handle_line(self, line: str):
        if line.strip():
            self._emit_line(line)

        # 分段前缀（可能单独成行）
        m = self._re_seg_prefix.match(line.strip())
        if m:
            self._seg_i = int(m.group(1))
            self._seg_total = int(m.group(2))
            self._emit_progress(self._seg_i, self._seg_total, f"分段 {self._seg_i}/{self._seg_total}")
            return

        # 分段前缀（带正文）
        m = self._re_seg_inline.match(line.strip())
        if m:
            self._seg_i = int(m.group(1))
            self._seg_total = int(m.group(2))
            self._emit_progress(self._seg_i, self._seg_total, m.group(3).strip())
            return

        # 阶段：[1] 加载音频... / [6] 时间戳对齐
        m = self._re_stage.match(line.strip())
        if m:
            stage = int(m.group(1))
            name = m.group(2).strip()
            if self._seg_total and self._seg_i:
                total = self._seg_total * 6
                cur = (self._seg_i - 1) * 6 + min(stage, 6)
                self._emit_progress(cur, total, f"分段 {self._seg_i}/{self._seg_total} - {name}")
            else:
                self._emit_progress(min(stage, 6), 6, name)


class DownloadModelWorker(BaseWorker):
    def __init__(self, model_id: str, local_dir: str):
        super().__init__()
        self.model_id = model_id
        self.local_dir = local_dir

    def run(self):
        try:
            self._emit_log(f"[下载] model_id={self.model_id}")
            self._emit_log(f"[下载] local_dir={self.local_dir}")
            os.makedirs(self.local_dir, exist_ok=True)

            # 优先用 Python API，失败再用 CLI
            try:
                from modelscope.hub.snapshot_download import snapshot_download
                snapshot_download(
                    self.model_id,
                    local_dir=self.local_dir,
                    local_dir_use_symlinks=False,
                )
            except Exception as e:
                self._emit_log(f"[下载] Python API 失败，尝试 CLI：{e}")
                cmd = ["modelscope", "download", "--model", self.model_id, "--local_dir", self.local_dir]
                p = subprocess.run(cmd, capture_output=True, text=True, errors="replace")
                if p.returncode != 0:
                    raise RuntimeError(p.stderr.strip() or p.stdout.strip())

            self.done.emit(True, "模型下载完成。")
        except Exception as e:
            self.done.emit(False, f"模型下载失败：{e}")


class RunScriptWorker(BaseWorker):
    def __init__(self, args: List[str], cwd: Optional[str] = None):
        super().__init__()
        self.args = args
        self.cwd = cwd

    def run(self):
        try:
            self._emit_log("[脚本] " + " ".join(self.args))
            p = subprocess.Popen(
                self.args,
                cwd=self.cwd,
                stdout=subprocess.PIPE,
                stderr=subprocess.STDOUT,
                text=True,
                errors="replace",
                bufsize=1,
                universal_newlines=True,
            )
            assert p.stdout is not None
            for line in p.stdout:
                if self.cancelled():
                    p.kill()
                    self.done.emit(False, "已取消。")
                    return
                self._emit_log(line.rstrip("\n"))
            rc = p.wait()
            if rc != 0:
                raise RuntimeError(f"脚本退出码：{rc}")
            self.done.emit(True, "执行完成。")
        except Exception as e:
            self.done.emit(False, f"执行失败：{e}")


class TranscribeSingleWorker(BaseWorker):
    result_ready = pyqtSignal(str, str, str)  # text, out_txt, out_srt

    def __init__(self, engine_s: EngineSettings, tr_s: TranscribeSettings, input_path: str):
        super().__init__()
        self.engine_s = engine_s
        self.tr_s = tr_s
        self.input_path = input_path

    def _apply_runtime_env(self):
        if self.engine_s.disable_vulkan:
            os.environ["VK_ICD_FILENAMES"] = "none"
        else:
            os.environ.pop("VK_ICD_FILENAMES", None)

        if self.engine_s.force_igpu:
            os.environ["GGML_VK_VISIBLE_DEVICES"] = "0"
        else:
            os.environ.pop("GGML_VK_VISIBLE_DEVICES", None)

        if self.engine_s.disable_vulkan_f16:
            os.environ["GGML_VK_DISABLE_F16"] = "1"
        else:
            os.environ.pop("GGML_VK_DISABLE_F16", None)

    def run(self):
        engine = None
        run_dir = None
        try:
            self._apply_runtime_env()
            os.makedirs(self.tr_s.output_dir, exist_ok=True)

            # 运行目录：根目录/日期/单次运行
            run_dir = new_run_dir("single")
            self._emit_log(f"[运行目录] {run_dir}")

            # 合并多热词文件（如果配置了）
            hotwords_path = (self.engine_s.hotwords or "").strip() or None
            if self.engine_s.hotwords_files:
                merged = read_hotword_files(self.engine_s.hotwords_files)
                merged_path = str(Path(run_dir) / "hotwords_merged.txt")
                with open(merged_path, "w", encoding="utf-8") as f:
                    for w in merged:
                        f.write(w + "\n")
                hotwords_path = merged_path
                self._emit_log(f"[热词] 已合并 {len(self.engine_s.hotwords_files)} 个文件，共 {len(merged)} 条：{merged_path}")

            # 1) 构建引擎
            self._emit_log("[推理] 初始化引擎...")
            engine = create_asr_engine(
                encoder_onnx_path=self.engine_s.encoder_onnx,
                ctc_onnx_path=self.engine_s.ctc_onnx,
                decoder_gguf_path=self.engine_s.decoder_gguf,
                tokens_path=self.engine_s.tokens,
                hotwords_path=hotwords_path,
                enable_ctc=self.engine_s.enable_ctc,
                n_predict=self.engine_s.n_predict,
                n_threads=self.engine_s.n_threads or None,
                n_threads_batch=self.engine_s.n_threads_batch or None,
                n_ubatch=self.engine_s.n_ubatch,
                similar_threshold=self.engine_s.similar_threshold,
                max_hotwords=self.engine_s.max_hotwords,
                verbose=False,
            )

            # 2) 固定管线：抽取 wav -> 降噪/增强 -> 识别
            use_start = self.tr_s.start_second if self.tr_s.start_second not in (None, 0, 0.0) else None
            use_dur = self.tr_s.duration
            work_dir = str(Path(run_dir) / "media")
            in_path, clip_offset, pipe_tmp = prepare_wav_for_asr(
                input_path=self.input_path,
                sample_rate=16000,
                start_second=use_start,
                duration=use_dur,
                preprocess_mode=self.tr_s.preprocess_mode,
                external_cmd_tpl=self.tr_s.external_preprocess_cmd,
                log_fn=self._emit_log,
                work_dir=work_dir,
            )
            # 抽取阶段已裁剪，所以推理阶段不再重复裁剪
            use_start = None
            use_dur = None

            # 3) 推理
            self._emit_log(f"[推理] 处理：{self.input_path}")
            t0 = time.perf_counter()

            # 将底层输出实时重定向到 GUI log，并解析进度
            old_out, old_err = sys.stdout, sys.stderr
            stream = _QtLogStream(
                emit_line=lambda ln: self._emit_log(ln),
                emit_progress=lambda c, t, it: self.progress.emit(int(c), int(t), str(it)),
            )
            try:
                sys.stdout = stream
                sys.stderr = stream

                result = engine.transcribe(
                    in_path,
                    language=self.tr_s.language or None,
                    context=self.tr_s.context or None,
                    # 为了在日志里显示阶段/分段进度：强制 verbose=True，
                    # 同时关闭吐字/Prompt/整段文本输出，避免日志爆炸。
                    verbose=True,
                    segment_size=float(self.tr_s.segment_size),
                    overlap=float(self.tr_s.overlap),
                    start_second=use_start,
                    duration=use_dur,
                    srt=False,  # GUI 自己控制输出路径
                    stream_output=False,
                    show_prompt=False,
                    show_ctc=False,
                    print_final_text=False,
                )
            finally:
                sys.stdout, sys.stderr = old_out, old_err

            # 识别覆盖范围诊断（帮助定位“只出前十几秒字幕”）
            try:
                if result.segments:
                    max_ts = max(float(s.get("start", 0.0)) for s in result.segments)
                    min_ts = min(float(s.get("start", 0.0)) for s in result.segments)
                    self._emit_log(f"[诊断] segments 数量: {len(result.segments)}, ts范围: {min_ts:.2f}s ~ {max_ts:.2f}s")
                else:
                    self._emit_log("[诊断] segments 为空（无时间戳对齐结果）")
            except Exception:
                pass

            # 4) 保存输出
            stem = Path(self.input_path).stem
            out_txt = str(Path(self.tr_s.output_dir) / f"{stem}.txt")
            out_srt = str(Path(self.tr_s.output_dir) / f"{stem}.srt")

            with open(out_txt, "w", encoding="utf-8") as f:
                f.write(result.text or "")

            if self.tr_s.export_srt and result.segments:
                # 如果音频被裁剪成从 0 开始的临时 wav，则把时间戳平移回原时间轴
                if clip_offset:
                    for seg in result.segments:
                        seg["start"] = float(seg["start"]) + clip_offset
                generate_srt_file(
                    result.segments,
                    out_srt,
                    max_chars_per_line=int(self.tr_s.max_chars_per_line),
                    max_gap_seconds=float(self.tr_s.srt_max_gap_seconds),
                )
            else:
                out_srt = ""

            dt = time.perf_counter() - t0
            self._emit_log(f"[推理] 完成，用时 {dt:.2f}s")
            self.progress.emit(1, 1, "完成")

            # temp 文件已落盘到运行目录，不清理（便于排查）

            self.result_ready.emit(result.text or "", out_txt, out_srt)
            self.done.emit(True, "转写完成。")
        except Exception as e:
            self.done.emit(False, f"转写失败：{e}")
        finally:
            try:
                if engine is not None:
                    engine.cleanup()
            except Exception:
                pass
            # 不清理运行目录


class BatchWorker(BaseWorker):
    def __init__(self, engine_s: EngineSettings, tr_s: TranscribeSettings, input_dir: str):
        super().__init__()
        self.engine_s = engine_s
        self.tr_s = tr_s
        self.input_dir = input_dir

    def _apply_runtime_env(self):
        if self.engine_s.disable_vulkan:
            os.environ["VK_ICD_FILENAMES"] = "none"
        else:
            os.environ.pop("VK_ICD_FILENAMES", None)

        if self.engine_s.force_igpu:
            os.environ["GGML_VK_VISIBLE_DEVICES"] = "0"
        else:
            os.environ.pop("GGML_VK_VISIBLE_DEVICES", None)

        if self.engine_s.disable_vulkan_f16:
            os.environ["GGML_VK_DISABLE_F16"] = "1"
        else:
            os.environ.pop("GGML_VK_DISABLE_F16", None)

    def _collect_files(self) -> List[str]:
        files: List[str] = []
        base = Path(self.input_dir)
        for root, _, fnames in os.walk(base):
            for n in fnames:
                p = Path(root) / n
                ext = p.suffix.lower()
                if ext in AUDIO_EXTS or ext in VIDEO_EXTS:
                    files.append(str(p))
        files.sort()
        return files

    def run(self):
        engine = None
        run_dir = None
        try:
            self._apply_runtime_env()
            os.makedirs(self.tr_s.output_dir, exist_ok=True)

            run_dir = new_run_dir("batch")
            self._emit_log(f"[运行目录] {run_dir}")

            files = self._collect_files()
            if not files:
                self.done.emit(False, "未找到可处理的音/视频文件。")
                return

            self._emit_log(f"[批处理] 共 {len(files)} 个文件")
            self.progress.emit(0, len(files), "")

            # 引擎只初始化一次
            self._emit_log("[批处理] 初始化引擎...")

            hotwords_path = (self.engine_s.hotwords or "").strip() or None
            if self.engine_s.hotwords_files:
                merged = read_hotword_files(self.engine_s.hotwords_files)
                merged_path = str(Path(run_dir) / "hotwords_merged.txt")
                with open(merged_path, "w", encoding="utf-8") as f:
                    for w in merged:
                        f.write(w + "\n")
                hotwords_path = merged_path
                self._emit_log(f"[热词] 已合并 {len(self.engine_s.hotwords_files)} 个文件，共 {len(merged)} 条：{merged_path}")

            engine = create_asr_engine(
                encoder_onnx_path=self.engine_s.encoder_onnx,
                ctc_onnx_path=self.engine_s.ctc_onnx,
                decoder_gguf_path=self.engine_s.decoder_gguf,
                tokens_path=self.engine_s.tokens,
                hotwords_path=hotwords_path,
                enable_ctc=self.engine_s.enable_ctc,
                n_predict=self.engine_s.n_predict,
                n_threads=self.engine_s.n_threads or None,
                n_threads_batch=self.engine_s.n_threads_batch or None,
                n_ubatch=self.engine_s.n_ubatch,
                similar_threshold=self.engine_s.similar_threshold,
                max_hotwords=self.engine_s.max_hotwords,
                verbose=False,
            )

            base = Path(self.input_dir)
            out_base = Path(self.tr_s.output_dir)

            use_start = self.tr_s.start_second if self.tr_s.start_second not in (None, 0, 0.0) else None
            use_dur = self.tr_s.duration

            for i, fpath in enumerate(files, start=1):
                if self.cancelled():
                    self.done.emit(False, "已取消。")
                    return

                rel = Path(fpath).relative_to(base)
                rel_no_ext = rel.with_suffix("")
                if self.tr_s.keep_folder_structure:
                    out_prefix = out_base / rel_no_ext
                else:
                    out_prefix = out_base / rel_no_ext.name

                out_txt = str(out_prefix.with_suffix(".txt"))
                out_srt = str(out_prefix.with_suffix(".srt"))
                os.makedirs(str(Path(out_txt).parent), exist_ok=True)

                if self.tr_s.skip_existing and os.path.exists(out_txt):
                    self.progress.emit(i, len(files), f"[跳过] {rel}")
                    continue

                self.progress.emit(i, len(files), str(rel))
                self._emit_log(f"[批处理] 开始：{rel}")

                # 固定管线：先抽取 wav -> 再降噪/增强 -> 再识别（对音频/视频统一）
                safe_name = str(rel).replace("\\", "__").replace("/", "__")
                work_dir = str(Path(run_dir) / "media" / safe_name)
                in_path, clip_offset, _ = prepare_wav_for_asr(
                    input_path=fpath,
                    sample_rate=16000,
                    start_second=use_start,
                    duration=use_dur,
                    preprocess_mode=self.tr_s.preprocess_mode,
                    external_cmd_tpl=self.tr_s.external_preprocess_cmd,
                    log_fn=self._emit_log,
                    work_dir=work_dir,
                )
                local_start = None
                local_dur = None

                # 推理（实时日志+进度解析）
                old_out, old_err = sys.stdout, sys.stderr
                stream = _QtLogStream(
                    emit_line=lambda ln: self._emit_log(ln),
                    emit_progress=lambda c, t, it: self.progress.emit(int(c), int(t), str(it)),
                )
                try:
                    sys.stdout = stream
                    sys.stderr = stream
                    result = engine.transcribe(
                        in_path,
                        language=self.tr_s.language or None,
                        context=self.tr_s.context or None,
                        verbose=True,
                        segment_size=float(self.tr_s.segment_size),
                        overlap=float(self.tr_s.overlap),
                        start_second=local_start,
                        duration=local_dur,
                        srt=False,
                        stream_output=False,
                        show_prompt=False,
                        show_ctc=False,
                        print_final_text=False,
                    )
                finally:
                    sys.stdout, sys.stderr = old_out, old_err

                with open(out_txt, "w", encoding="utf-8") as fp:
                    fp.write(result.text or "")

                if self.tr_s.export_srt and result.segments:
                    if clip_offset:
                        for seg in result.segments:
                            seg["start"] = float(seg["start"]) + clip_offset
                    generate_srt_file(
                        result.segments,
                        out_srt,
                        max_chars_per_line=int(self.tr_s.max_chars_per_line),
                        max_gap_seconds=float(self.tr_s.srt_max_gap_seconds),
                    )
                # temp 文件已落盘到运行目录，不清理

            self.done.emit(True, "批处理完成。")
        except Exception as e:
            self.done.emit(False, f"批处理失败：{e}")
        finally:
            try:
                if engine is not None:
                    engine.cleanup()
            except Exception:
                pass
            # 不清理运行目录


# ============================================================================
# 逻辑层拆分：
# - UI 仍在本文件（MainWindow）
# - 推理/批处理/媒体预处理等逻辑集中在 gui_logic.py
# 这里显式导入并覆盖同名定义，确保运行时使用拆分后的逻辑实现。
# ============================================================================
from gui_logic import (  # noqa: E402
    AUDIO_EXTS,
    VIDEO_EXTS,
    repo_root,
    today_dir,
    new_run_dir,
    EngineSettings,
    TranscribeSettings,
    BaseWorker,
    DownloadModelWorker,
    RunScriptWorker,
    TranscribeListWorker,
    BenchmarkWorker,
)

class MainWindow(QMainWindow):
    def __init__(self):
        super().__init__()
        self.setWindowTitle("Fun-ASR-GGUF GUI (PyQt6)")
        self.resize(1100, 760)

        self.settings = QSettings("Fun-ASR-GGUF", "Fun-ASR-GGUF-GUI")
        self.engine_s = EngineSettings()
        self.tr_s = TranscribeSettings()
        self._load_settings()

        self._current_worker: Optional[BaseWorker] = None

        # 根目录日志文件（追加写）
        self._log_file_path = repo_root() / "asr_gui.log"
        self._log_file = open(self._log_file_path, "a", encoding="utf-8", errors="replace")
        self._log_file.write("\n" + "=" * 80 + "\n")
        self._log_file.write(f"[{datetime.now().isoformat(timespec='seconds')}] GUI started\n")
        self._log_file.flush()

        self.tabs = QTabWidget()
        self.setCentralWidget(self.tabs)

        self.log_view = QPlainTextEdit()
        self.log_view.setReadOnly(True)
        self.log_view.setFont(QFont("Consolas", 10))

        # 统一管理：哪些按钮属于“启动任务按钮”，运行时禁用
        self._action_buttons: List[QPushButton] = []

        # 底部常驻日志窗口（不用切换 tab）
        self._init_log_dock()

        # 状态栏：运行中提示 + 转圈进度条 + 取消按钮
        self._init_status_bar()

        self._build_tab_tasks()
        self._build_tab_settings()

    # ---------------- Settings ----------------
    def _load_settings(self):
        try:
            eng = self.settings.value("engine_json", "")
            tr = self.settings.value("transcribe_json", "")
            if eng:
                data = json.loads(eng)
                # 兼容旧版本字段（例如曾经存在的 uvr5_*）：过滤掉 dataclass 不认识的键
                from dataclasses import fields as _dc_fields
                allow = {f.name for f in _dc_fields(EngineSettings)}
                self.engine_s = EngineSettings(**{k: v for k, v in (data or {}).items() if k in allow})
            if tr:
                data = json.loads(tr)
                from dataclasses import fields as _dc_fields
                allow = {f.name for f in _dc_fields(TranscribeSettings)}
                self.tr_s = TranscribeSettings(**{k: v for k, v in (data or {}).items() if k in allow})
        except Exception:
            # 容错：读取失败就用默认
            self.engine_s = EngineSettings()
            self.tr_s = TranscribeSettings()

    def _save_settings(self):
        self.settings.setValue("engine_json", json.dumps(asdict(self.engine_s), ensure_ascii=False))
        self.settings.setValue("transcribe_json", json.dumps(asdict(self.tr_s), ensure_ascii=False))

    # ---------------- UI Helpers ----------------
    def _append_log(self, s: str):
        line = s.rstrip("\n")
        self.log_view.appendPlainText(line)
        # 自动滚动到末尾
        sb = self.log_view.verticalScrollBar()
        sb.setValue(sb.maximum())
        # 同步写入根目录日志文件
        try:
            ts = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
            for ln in line.splitlines():
                self._log_file.write(f"[{ts}] {ln}\n")
            self._log_file.flush()
        except Exception:
            pass

    def closeEvent(self, event):
        try:
            if hasattr(self, "_log_file") and self._log_file:
                self._log_file.write(f"[{datetime.now().isoformat(timespec='seconds')}] GUI closed\n")
                self._log_file.flush()
                self._log_file.close()
        except Exception:
            pass
        super().closeEvent(event)

    def _tt(self, widget: QWidget, text: str):
        # Qt ToolTip 支持多行纯文本
        widget.setToolTip(text.strip())

    def _parse_hotword_paths(self, text: str) -> List[str]:
        # 支持用 ; 或 换行 分隔多个文件路径
        raw = []
        for part in text.replace("\n", ";").split(";"):
            p = part.strip().strip('"')
            if p:
                raw.append(p)
        # 去重且保序
        seen = set()
        out = []
        for p in raw:
            if p in seen:
                continue
            seen.add(p)
            out.append(p)
        return out

    def _select_hotword_files(self):
        files, _ = QFileDialog.getOpenFileNames(
            self,
            "选择热词文件（可多选）",
            str(repo_root()),
            "Text Files (*.txt);;All Files (*.*)",
        )
        if files:
            self.set_hot_multi.setText(";".join(files))

    def _clear_hotword_files(self):
        self.set_hot_multi.setText("")

    def _init_log_dock(self):
        dock = QDockWidget("日志", self)
        dock.setObjectName("log_dock")
        dock.setAllowedAreas(
            Qt.DockWidgetArea.BottomDockWidgetArea
            | Qt.DockWidgetArea.LeftDockWidgetArea
            | Qt.DockWidgetArea.RightDockWidgetArea
        )
        dock.setFeatures(
            QDockWidget.DockWidgetFeature.DockWidgetMovable
            | QDockWidget.DockWidgetFeature.DockWidgetFloatable
            | QDockWidget.DockWidgetFeature.DockWidgetClosable
        )

        w = QWidget()
        layout = QVBoxLayout(w)
        layout.setContentsMargins(6, 6, 6, 6)
        layout.addWidget(self.log_view, 1)

        btn_row = QHBoxLayout()
        self.btn_log_clear = QPushButton("清空日志")
        self.btn_log_clear.clicked.connect(self.log_view.clear)
        self.btn_log_cancel = QPushButton("取消当前任务")
        self.btn_log_cancel.clicked.connect(self._cancel_worker)
        self.btn_log_cancel.setEnabled(False)
        btn_row.addWidget(self.btn_log_clear)
        btn_row.addWidget(self.btn_log_cancel)
        btn_row.addStretch(1)
        layout.addLayout(btn_row)

        dock.setWidget(w)
        self.addDockWidget(Qt.DockWidgetArea.BottomDockWidgetArea, dock)
        dock.setMinimumHeight(220)
        self.log_dock = dock

    def _init_status_bar(self):
        sb = self.statusBar()
        self.status_label = QLabel("就绪")
        self.status_busy = QProgressBar()
        self.status_busy.setFixedWidth(160)
        self.status_busy.setRange(0, 0)  # 转圈（不确定进度）
        self.status_busy.setVisible(False)

        self.btn_status_cancel = QPushButton("取消")
        self.btn_status_cancel.clicked.connect(self._cancel_worker)
        self.btn_status_cancel.setEnabled(False)

        sb.addWidget(self.status_label, 1)
        sb.addPermanentWidget(self.status_busy)
        sb.addPermanentWidget(self.btn_status_cancel)

    def _set_running(self, running: bool, title: str = ""):
        if running:
            self.status_label.setText(f"运行中：{title}")
            self.status_busy.setVisible(True)
            self.btn_status_cancel.setEnabled(True)
            self.btn_log_cancel.setEnabled(True)
            for b in self._action_buttons:
                b.setEnabled(False)
            # 确保用户能看到日志
            self.log_dock.setVisible(True)
            self.log_dock.raise_()
        else:
            self.status_label.setText("就绪")
            self.status_busy.setVisible(False)
            self.btn_status_cancel.setEnabled(False)
            self.btn_log_cancel.setEnabled(False)
            for b in self._action_buttons:
                b.setEnabled(True)

    def _bind_worker(self, w: BaseWorker, title: str):
        self._set_running(True, title)
        self._append_log(f"[开始] {title}")
        self._current_worker = w
        w.log.connect(self._append_log)
        w.done.connect(lambda ok, msg: self._on_worker_done(ok, msg, title))
        w.start()

    def _on_worker_done(self, ok: bool, msg: str, title: str):
        self._set_running(False, title)
        self._append_log(f"[完成] {title}: {msg}")
        if ok:
            QMessageBox.information(self, title, msg)
        else:
            QMessageBox.critical(self, title, msg)
        self._current_worker = None

    def _pick_file(self, line_edit: QLineEdit, caption: str, filter_str: str = "All Files (*.*)"):
        p, _ = QFileDialog.getOpenFileName(self, caption, line_edit.text() or str(repo_root()), filter_str)
        if p:
            line_edit.setText(p)

    def _pick_dir(self, line_edit: QLineEdit, caption: str):
        p = QFileDialog.getExistingDirectory(self, caption, line_edit.text() or str(repo_root()))
        if p:
            line_edit.setText(p)

    # ---------------- Tabs ----------------
    def _build_tab_tasks(self):
        """
        统一“单文件 + 多文件/文件夹批处理”为一个任务页：
        - 左侧：已选文件列表（可添加文件/文件夹递归）
        - 右侧：参数/结果（用子选项卡保持窗口大小）
        """
        tab = QWidget()
        root = QVBoxLayout(tab)
        root.setContentsMargins(8, 8, 8, 8)

        self._task_base_dirs: List[str] = []

        splitter = QSplitter(Qt.Orientation.Horizontal)
        root.addWidget(splitter, 1)

        # 左侧：文件列表
        left = QWidget()
        left_l = QVBoxLayout(left)
        left_l.setContentsMargins(0, 0, 0, 0)

        gb_files = QGroupBox("已选择的文件（音频/视频）")
        gb_l = QVBoxLayout(gb_files)
        # 改为表格：支持“状态”列
        self.task_list = QTableWidget()
        self.task_list.setColumnCount(2)
        self.task_list.setHorizontalHeaderLabels(["文件", "状态"])
        self.task_list.setSelectionBehavior(QAbstractItemView.SelectionBehavior.SelectRows)
        self.task_list.setSelectionMode(QAbstractItemView.SelectionMode.ExtendedSelection)
        self.task_list.setEditTriggers(QAbstractItemView.EditTrigger.NoEditTriggers)
        self.task_list.horizontalHeader().setSectionResizeMode(0, QHeaderView.ResizeMode.Stretch)
        self.task_list.horizontalHeader().setSectionResizeMode(1, QHeaderView.ResizeMode.ResizeToContents)
        self.task_list.verticalHeader().setVisible(False)
        self._tt(self.task_list, "将要处理的音频/视频文件列表\n- 可添加文件\n- 可添加文件夹（递归扫描）\n- 可移除/清空\n\n状态：准备就绪 / 处理中 / 已完成 / 已跳过 / 失败")
        gb_l.addWidget(self.task_list, 1)

        btn_row = QHBoxLayout()
        self.btn_task_add_files = QPushButton("添加文件…")
        self.btn_task_add_files.clicked.connect(self._task_add_files)
        self.btn_task_add_folder = QPushButton("添加文件夹…")
        self.btn_task_add_folder.clicked.connect(self._task_add_folder)
        self.btn_task_remove = QPushButton("移除选中")
        self.btn_task_remove.clicked.connect(self._task_remove_selected)
        self.btn_task_clear = QPushButton("清空")
        self.btn_task_clear.clicked.connect(self._task_clear)
        btn_row.addWidget(self.btn_task_add_files)
        btn_row.addWidget(self.btn_task_add_folder)
        btn_row.addWidget(self.btn_task_remove)
        btn_row.addWidget(self.btn_task_clear)
        btn_row.addStretch(1)
        gb_l.addLayout(btn_row)

        left_l.addWidget(gb_files, 1)
        splitter.addWidget(left)

        # 右侧：参数/结果（子选项卡）
        right = QWidget()
        right_l = QVBoxLayout(right)
        right_l.setContentsMargins(0, 0, 0, 0)
        self.task_tabs = QTabWidget()
        right_l.addWidget(self.task_tabs, 1)
        splitter.addWidget(right)

        splitter.setStretchFactor(0, 3)
        splitter.setStretchFactor(1, 4)

        # 右侧-参数
        w_params = QWidget()
        fl = QFormLayout(w_params)

        self.task_out_dir = QLineEdit(self.tr_s.output_dir)
        self._tt(self.task_out_dir, "输出目录\n会生成 .txt（转写文本）和可选的 .srt（字幕）")
        btn_out = QPushButton("选择…")
        btn_out.clicked.connect(lambda: self._pick_dir(self.task_out_dir, "选择输出目录"))
        row_out = QHBoxLayout()
        row_out.addWidget(self.task_out_dir)
        row_out.addWidget(btn_out)
        fl.addRow("输出目录", row_out)

        self.task_skip = QCheckBox("跳过已处理（存在 .txt 则跳过）")
        self.task_skip.setChecked(bool(self.tr_s.skip_existing))
        self._tt(self.task_skip, "skip_existing\n如果输出 .txt 已存在，则跳过该文件（避免重复转写）")
        self.task_keep = QCheckBox("保持目录结构（对“文件夹添加”尤其有用）")
        self.task_keep.setChecked(bool(self.tr_s.keep_folder_structure))
        self._tt(self.task_keep, "keep_folder_structure\n输出时保持与添加的文件夹相同的子目录结构（若无文件夹基准则回退为文件名）")
        self.task_export_srt = QCheckBox("导出 SRT")
        self.task_export_srt.setChecked(bool(self.tr_s.export_srt))
        self._tt(self.task_export_srt, "是否导出 .srt 字幕文件（基于字符级时间戳）")

        fl.addRow(self.task_skip)
        fl.addRow(self.task_keep)
        fl.addRow(self.task_export_srt)

        self.task_language = QComboBox()
        self.task_language.addItems(["自动", "中文", "英文", "日文"])
        self._tt(self.task_language, "language 参数\n自动：由模型自动判断；也可以手动指定中文/英文/日文")
        lang0 = (self.tr_s.language or "").strip()
        self.task_language.setCurrentText("自动" if not lang0 else lang0)

        self.task_context = QLineEdit(self.tr_s.context)
        self._tt(self.task_context, "context 参数（上下文提示）\n用于提升识别准确率，例如节目名/专有名词/人物信息等")

        self.task_segment = QDoubleSpinBox()
        self.task_segment.setRange(5.0, 600.0)
        self.task_segment.setValue(float(self.tr_s.segment_size))
        self._tt(self.task_segment, "segment_size（秒）\n超过该长度会自动分段识别")

        self.task_overlap = QDoubleSpinBox()
        self.task_overlap.setRange(0.0, 30.0)
        self.task_overlap.setValue(float(self.tr_s.overlap))
        self._tt(self.task_overlap, "overlap（秒）\n分段之间的重叠时长，用于提升拼接稳定性")

        self.task_start = QDoubleSpinBox()
        self.task_start.setRange(0.0, 10_000_000.0)
        self.task_start.setDecimals(2)
        self.task_start.setValue(float(self.tr_s.start_second or 0.0))
        self._tt(self.task_start, "start_second（秒）\n从指定秒数开始识别（对每个文件生效）")

        self.task_duration = QDoubleSpinBox()
        self.task_duration.setRange(0.0, 10_000_000.0)
        self.task_duration.setDecimals(2)
        self.task_duration.setValue(float(self.tr_s.duration or 0.0))
        self.task_use_duration = QCheckBox("启用 duration（秒）")
        self.task_use_duration.setChecked(self.tr_s.duration is not None)
        self._tt(self.task_duration, "duration（秒）\n识别指定时长（从 start_second 起算，对每个文件生效）")
        self._tt(self.task_use_duration, "是否启用 duration 参数\n不启用则识别到文件结束")

        self.task_srt_gap = QDoubleSpinBox()
        self.task_srt_gap.setRange(0.1, 10.0)
        self.task_srt_gap.setDecimals(2)
        self.task_srt_gap.setSingleStep(0.1)
        self.task_srt_gap.setValue(float(self.tr_s.srt_max_gap_seconds))
        self._tt(self.task_srt_gap, "SRT 静音分句阈值（秒）\n相邻字符时间戳间隔超过该值时，强制结束上一条字幕")

        self.task_max_chars = QSpinBox()
        self.task_max_chars.setRange(5, 200)
        self.task_max_chars.setValue(int(self.tr_s.max_chars_per_line))
        self._tt(self.task_max_chars, "SRT 单行最大字符数\n用于字幕自动换行（中英混排会尽量避免拆开英文单词）")

        fl.addRow("language", self.task_language)
        fl.addRow("context", self.task_context)
        fl.addRow("segment_size (s)", self.task_segment)
        fl.addRow("overlap (s)", self.task_overlap)
        fl.addRow("start_second (s)", self.task_start)
        dur_row = QHBoxLayout()
        dur_row.addWidget(self.task_duration)
        dur_row.addWidget(self.task_use_duration)
        fl.addRow("duration (s)", dur_row)
        fl.addRow("SRT 静音分句阈值 (s)", self.task_srt_gap)
        fl.addRow("SRT 单行最大字符数", self.task_max_chars)

        self.task_tabs.addTab(w_params, "参数")

        # 右侧-结果
        w_res = QWidget()
        res_l = QVBoxLayout(w_res)
        self.task_last_info = QLabel("")
        self.task_last_info.setTextInteractionFlags(Qt.TextInteractionFlag.TextSelectableByMouse)
        self.task_result = QTextEdit()
        self.task_result.setReadOnly(True)
        self.task_result.setFont(QFont("Microsoft YaHei UI", 10))
        res_l.addWidget(self.task_last_info)
        res_l.addWidget(self.task_result, 1)
        self.task_tabs.addTab(w_res, "结果")

        # 底部：开始/取消 + 进度
        action_row = QHBoxLayout()
        self.btn_tasks_start = QPushButton("开始处理")
        self.btn_tasks_start.clicked.connect(self._start_tasks)
        self.btn_tasks_cancel = QPushButton("取消")
        self.btn_tasks_cancel.clicked.connect(self._cancel_worker)
        self.btn_tasks_cancel.setEnabled(False)
        action_row.addWidget(self.btn_tasks_start)
        action_row.addWidget(self.btn_tasks_cancel)
        action_row.addStretch(1)
        root.addLayout(action_row)

        self.tasks_prog = QProgressBar()
        self.tasks_prog.setRange(0, 100)
        self.tasks_prog.setValue(0)
        self.tasks_label = QLabel("")
        self.tasks_stage = QLabel("")
        root.addWidget(self.tasks_prog)
        root.addWidget(self.tasks_label)
        root.addWidget(self.tasks_stage)

        # 运行时需要禁用的按钮
        self._action_buttons.extend([
            self.btn_task_add_files,
            self.btn_task_add_folder,
            self.btn_task_remove,
            self.btn_task_clear,
            self.btn_tasks_start,
        ])

        self.tabs.addTab(tab, "任务")

    def _task_add_files(self):
        files, _ = QFileDialog.getOpenFileNames(
            self,
            "选择音频/视频文件（可多选）",
            str(repo_root()),
            "Media Files (*.*);;All Files (*.*)",
        )
        if files:
            self._task_add_paths(files, base_dir=None)

    def _task_add_folder(self):
        d = QFileDialog.getExistingDirectory(self, "选择文件夹（递归扫描音频/视频）", str(repo_root()))
        if not d:
            return
        self._task_base_dirs.append(d)
        files = self._collect_media_files(d)
        self._append_log(f"[任务] 已扫描文件夹：{d}，找到 {len(files)} 个音/视频文件")
        self._task_add_paths(files, base_dir=d)

    def _collect_media_files(self, base_dir: str) -> List[str]:
        base = Path(base_dir)
        out: List[str] = []
        for root, _, fnames in os.walk(base):
            for n in fnames:
                p = Path(root) / n
                ext = p.suffix.lower()
                if ext in AUDIO_EXTS or ext in VIDEO_EXTS:
                    out.append(str(p))
        out.sort()
        return out

    def _task_add_paths(self, paths: List[str], base_dir: Optional[str]):
        # 去重：以绝对路径为准
        existing = set()
        for r in range(self.task_list.rowCount()):
            it = self.task_list.item(r, 0)
            if it:
                existing.add(it.data(Qt.ItemDataRole.UserRole) or it.text())
        added = 0
        for p in paths:
            if not p:
                continue
            try:
                ap = str(Path(p).resolve())
            except Exception:
                ap = p
            if ap in existing:
                continue
            r = self.task_list.rowCount()
            self.task_list.insertRow(r)
            it_path = QTableWidgetItem(Path(ap).as_posix() if os.name != "nt" else ap)
            it_path.setToolTip(ap)
            # 用 UserRole 保存“绝对路径”（避免显示文本被截断/变形）
            it_path.setData(Qt.ItemDataRole.UserRole, ap)
            it_status = QTableWidgetItem("准备就绪")
            it_status.setToolTip("准备就绪：等待开始处理")
            self.task_list.setItem(r, 0, it_path)
            self.task_list.setItem(r, 1, it_status)
            existing.add(ap)
            added += 1
        if added:
            self.tasks_label.setText(f"已选文件：{self.task_list.rowCount()}（本次新增 {added}）")

    def _task_remove_selected(self):
        rows = sorted({idx.row() for idx in self.task_list.selectedIndexes()}, reverse=True)
        for r in rows:
            self.task_list.removeRow(r)
        self.tasks_label.setText(f"已选文件：{self.task_list.rowCount()}")

    def _task_clear(self):
        self.task_list.setRowCount(0)
        self._task_base_dirs = []
        self.tasks_label.setText("已选文件：0")
        self.tasks_stage.setText("")
        self.tasks_prog.setValue(0)

    def _start_tasks(self):
        # 收集文件
        files: List[str] = []
        self._task_row_by_path = {}
        for r in range(self.task_list.rowCount()):
            it = self.task_list.item(r, 0)
            if not it:
                continue
            ap = (it.data(Qt.ItemDataRole.UserRole) or it.text() or "").strip()
            if ap:
                files.append(ap)
                self._task_row_by_path[ap] = r
            # 每次启动时重置状态，方便用户观察
            st = self.task_list.item(r, 1)
            if st:
                st.setText("准备就绪")
        if not files:
            QMessageBox.warning(self, "任务", "请先添加要处理的文件或文件夹。")
            return

        outd = self.task_out_dir.text().strip()
        if not outd:
            QMessageBox.warning(self, "任务", "请选择输出目录。")
            return

        # 写回设置
        self.tr_s.output_dir = outd
        self.tr_s.skip_existing = bool(self.task_skip.isChecked())
        self.tr_s.keep_folder_structure = bool(self.task_keep.isChecked())
        self.tr_s.export_srt = bool(self.task_export_srt.isChecked())

        self.tr_s.context = self.task_context.text()
        self.tr_s.segment_size = float(self.task_segment.value())
        self.tr_s.overlap = float(self.task_overlap.value())
        self.tr_s.start_second = float(self.task_start.value())
        self.tr_s.duration = float(self.task_duration.value()) if self.task_use_duration.isChecked() else None
        self.tr_s.srt_max_gap_seconds = float(self.task_srt_gap.value())
        self.tr_s.max_chars_per_line = int(self.task_max_chars.value())

        lang = self.task_language.currentText()
        self.tr_s.language = "" if lang == "自动" else lang

        self._save_settings()

        w = TranscribeListWorker(engine_s=self.engine_s, tr_s=self.tr_s, input_files=files, base_dirs=self._task_base_dirs)
        w.log.connect(self._append_log)
        w.file_progress.connect(self._on_tasks_file_progress)
        w.stage_progress.connect(self._on_tasks_stage_progress)
        w.file_started.connect(self._on_tasks_file_started)
        w.file_skipped.connect(self._on_tasks_file_skipped)
        w.file_done.connect(self._on_tasks_file_done)
        w.done.connect(lambda ok, msg: self._on_tasks_done(ok, msg))

        self._current_worker = w
        self._set_running(True, "任务处理")
        self.btn_tasks_cancel.setEnabled(True)
        self._append_log("[开始] 任务处理")
        w.start()

    def _on_tasks_file_progress(self, cur: int, total: int, item: str):
        if total <= 0:
            self.tasks_prog.setValue(0)
            self.tasks_label.setText(item)
            return
        self.tasks_prog.setValue(int(cur * 100 / total))
        self.tasks_label.setText(f"{cur}/{total}  {item}")

    def _on_tasks_stage_progress(self, cur: int, total: int, item: str):
        if total <= 0:
            self.tasks_stage.setText(item)
            return
        # UI 仅展示步骤，用于“当前进展”提示
        self.tasks_stage.setText(item)

    def _set_task_status(self, input_path: str, status: str):
        try:
            r = getattr(self, "_task_row_by_path", {}).get(input_path)
            if r is None:
                return
            it = self.task_list.item(int(r), 1)
            if it:
                it.setText(status)
        except Exception:
            pass

    def _on_tasks_file_started(self, input_path: str):
        self._set_task_status(input_path, "处理中")

    def _on_tasks_file_skipped(self, input_path: str):
        self._set_task_status(input_path, "已跳过")

    def _on_tasks_file_done(self, input_path: str, out_txt: str, out_srt: str):
        self._set_task_status(input_path, "已完成")
        info = f"最近完成：{input_path}\nTXT：{out_txt}"
        if out_srt:
            info += f"\nSRT：{out_srt}"
        self.task_last_info.setText(info)
        # 展示最近一次输出文本（可选）
        try:
            with open(out_txt, "r", encoding="utf-8", errors="ignore") as f:
                self.task_result.setPlainText(f.read())
        except Exception:
            pass

    def _on_tasks_done(self, ok: bool, msg: str):
        self.btn_tasks_cancel.setEnabled(False)
        self._on_worker_done(ok, msg, "任务处理")

    def _build_tab_models(self):
        tab = QWidget()
        layout = QVBoxLayout(tab)

        # 下载
        gb_dl = QGroupBox("模型下载")
        fl = QFormLayout(gb_dl)
        self.dl_model_id = QLineEdit(self.settings.value("dl_model_id", "FunAudioLLM/Fun-ASR-Nano-2512"))
        self.dl_dir = QLineEdit(self.settings.value("dl_dir", str(repo_root() / "Fun-ASR-Nano-2512")))
        self._tt(self.dl_model_id, "ModelScope 模型 ID\n例如：FunAudioLLM/Fun-ASR-Nano-2512")
        self._tt(self.dl_dir, "模型下载到的本地目录\n应包含下载后的 model.pt、Qwen3-0.6B/ 等文件")
        btn_dl_dir = QPushButton("选择…")
        btn_dl_dir.clicked.connect(lambda: self._pick_dir(self.dl_dir, "选择模型下载目录"))
        row = QHBoxLayout()
        row.addWidget(self.dl_dir)
        row.addWidget(btn_dl_dir)
        fl.addRow("Model ID", self.dl_model_id)
        fl.addRow("下载到目录", row)

        self.btn_dl = QPushButton("开始下载")
        self.btn_dl.clicked.connect(self._start_download)
        self._action_buttons.append(self.btn_dl)
        fl.addRow(self.btn_dl)

        # 导出
        gb_exp = QGroupBox("模型导出（检测已存在文件并跳过）")
        fl2 = QFormLayout(gb_exp)

        self.src_model_dir = QLineEdit(self.settings.value("src_model_dir", str(repo_root() / "Fun-ASR-Nano-2512")))
        self._tt(self.src_model_dir, "源模型目录（原始 Fun-ASR-Nano-2512）\n需要包含：model.pt、multilingual.tiktoken、Qwen3-0.6B/config.json 等")
        btn_src = QPushButton("选择…")
        btn_src.clicked.connect(lambda: self._pick_dir(self.src_model_dir, "选择源模型目录"))
        row2 = QHBoxLayout()
        row2.addWidget(self.src_model_dir)
        row2.addWidget(btn_src)

        self.out_model_dir = QLineEdit(self.engine_s.model_output_dir)
        self._tt(self.out_model_dir, "导出目录（生成可推理的 model/ 文件）\n会生成：Encoder ONNX、CTC ONNX、tokens.txt、Decoder GGUF 等")
        btn_out = QPushButton("选择…")
        btn_out.clicked.connect(lambda: self._pick_dir(self.out_model_dir, "选择导出目录"))
        row3 = QHBoxLayout()
        row3.addWidget(self.out_model_dir)
        row3.addWidget(btn_out)

        fl2.addRow("源模型目录", row2)
        fl2.addRow("导出目录", row3)

        self.btn_exp1 = QPushButton("导出 Encoder + CTC（ONNX）")
        self.btn_exp2 = QPushButton("导出 Decoder（GGUF）")
        self.btn_exp1.clicked.connect(self._start_export_encoder_ctc)
        self.btn_exp2.clicked.connect(self._start_export_decoder)
        self._action_buttons.append(self.btn_exp1)
        self._action_buttons.append(self.btn_exp2)
        row_btn = QHBoxLayout()
        row_btn.addWidget(self.btn_exp1)
        row_btn.addWidget(self.btn_exp2)
        fl2.addRow(row_btn)

        self.model_status = QLabel()
        self.model_status.setTextInteractionFlags(Qt.TextInteractionFlag.TextSelectableByMouse)
        fl2.addRow("导出文件状态", self.model_status)

        self.btn_refresh_model = QPushButton("刷新状态")
        self.btn_refresh_model.clicked.connect(self._refresh_export_status)
        self._action_buttons.append(self.btn_refresh_model)
        fl2.addRow(self.btn_refresh_model)

        layout.addWidget(gb_dl)
        layout.addWidget(gb_exp)
        layout.addStretch(1)

        self.tabs.addTab(tab, "模型")
        self._refresh_export_status()

    def _build_tab_single(self):
        tab = QWidget()
        layout = QVBoxLayout(tab)

        gb_in = QGroupBox("单文件转写（音频/视频）")
        fl = QFormLayout(gb_in)
        self.single_in = QLineEdit(self.settings.value("single_in", ""))
        self._tt(self.single_in, "输入音频或视频文件路径\n支持视频：会自动用 ffmpeg 抽取音频后再识别")
        btn_in = QPushButton("选择…")
        btn_in.clicked.connect(lambda: self._pick_file(self.single_in, "选择音频/视频文件", "Media Files (*.*)"))
        row = QHBoxLayout()
        row.addWidget(self.single_in)
        row.addWidget(btn_in)

        self.single_out = QLineEdit(self.tr_s.output_dir)
        self._tt(self.single_out, "输出目录\n会生成 .txt（转写文本）和可选的 .srt（字幕）")
        btn_out = QPushButton("选择…")
        btn_out.clicked.connect(lambda: self._pick_dir(self.single_out, "选择输出目录"))
        row2 = QHBoxLayout()
        row2.addWidget(self.single_out)
        row2.addWidget(btn_out)

        fl.addRow("输入文件", row)
        fl.addRow("输出目录", row2)

        # 参数
        self.single_language = QComboBox()
        self.single_language.addItems(["自动", "中文", "英文", "日文"])
        self._tt(self.single_language, "language 参数\n自动：由模型自动判断；也可以手动指定中文/英文/日文")
        self.single_context = QLineEdit(self.tr_s.context)
        self._tt(self.single_context, "context 参数（上下文提示）\n用于提升识别准确率，例如节目名/专有名词/人物信息等")
        self.single_verbose = QCheckBox("详细日志（会输出 CTC/Prompt/解码细节）")
        self.single_verbose.setChecked(bool(self.tr_s.verbose))
        self._tt(self.single_verbose, "verbose 参数（控制是否输出详细推理日志）\n注意：详细日志会显著变大")
        self.single_segment = QDoubleSpinBox()
        self.single_segment.setRange(5.0, 600.0)
        self.single_segment.setValue(float(self.tr_s.segment_size))
        self.single_overlap = QDoubleSpinBox()
        self.single_overlap.setRange(0.0, 30.0)
        self.single_overlap.setValue(float(self.tr_s.overlap))
        self.single_start = QDoubleSpinBox()
        self.single_start.setRange(0.0, 10_000_000.0)
        self.single_start.setDecimals(2)
        self.single_start.setValue(float(self.tr_s.start_second or 0.0))
        self.single_duration = QDoubleSpinBox()
        self.single_duration.setRange(0.0, 10_000_000.0)
        self.single_duration.setDecimals(2)
        self.single_duration.setValue(float(self.tr_s.duration or 0.0))
        self.single_use_duration = QCheckBox("启用 duration（秒）")
        self.single_use_duration.setChecked(self.tr_s.duration is not None)

        self.single_srt = QCheckBox("导出 SRT")
        self.single_srt.setChecked(bool(self.tr_s.export_srt))
        self._tt(self.single_segment, "segment_size 参数（秒）\n超过该长度会自动分段识别")
        self._tt(self.single_overlap, "overlap 参数（秒）\n分段之间的重叠时长，用于提升拼接稳定性")
        self._tt(self.single_start, "start_second 参数（秒）\n从指定秒数开始识别（支持音频/视频）")
        self._tt(self.single_duration, "duration 参数（秒）\n识别指定时长（从 start_second 起算）")
        self._tt(self.single_use_duration, "是否启用 duration 参数\n不启用则识别到文件结束")
        self._tt(self.single_srt, "是否导出 .srt 字幕文件\n字幕基于字符级时间戳生成")

        fl.addRow("language", self.single_language)
        fl.addRow("context", self.single_context)
        fl.addRow(self.single_verbose)
        fl.addRow("segment_size (s)", self.single_segment)
        fl.addRow("overlap (s)", self.single_overlap)
        fl.addRow("start_second (s)", self.single_start)
        dur_row = QHBoxLayout()
        dur_row.addWidget(self.single_duration)
        dur_row.addWidget(self.single_use_duration)
        fl.addRow("duration (s)", dur_row)
        fl.addRow(self.single_srt)

        self.single_srt_gap = QDoubleSpinBox()
        self.single_srt_gap.setRange(0.1, 10.0)
        self.single_srt_gap.setDecimals(2)
        self.single_srt_gap.setSingleStep(0.1)
        self.single_srt_gap.setValue(float(self.tr_s.srt_max_gap_seconds))
        self._tt(self.single_srt_gap, "SRT 静音分句阈值（秒）\n相邻字符时间戳间隔超过该值时，强制结束上一条字幕\n用于避免长静音被包含在字幕时间戳里")
        fl.addRow("SRT 静音分句阈值 (s)", self.single_srt_gap)

        self.btn_single_run = QPushButton("开始转写")
        self.btn_single_run.clicked.connect(self._start_single_transcribe)
        self._action_buttons.append(self.btn_single_run)
        fl.addRow(self.btn_single_run)

        self.single_prog = QProgressBar()
        self.single_prog.setRange(0, 100)
        self.single_prog.setValue(0)
        self.single_label = QLabel("")
        fl.addRow(self.single_prog)
        fl.addRow(self.single_label)

        self.single_result = QTextEdit()
        self.single_result.setReadOnly(True)
        self.single_result.setFont(QFont("Microsoft YaHei UI", 10))

        layout.addWidget(gb_in)
        layout.addWidget(QLabel("识别结果"))
        layout.addWidget(self.single_result, 1)

        self.tabs.addTab(tab, "单文件")

    def _build_tab_batch(self):
        tab = QWidget()
        layout = QVBoxLayout(tab)

        gb = QGroupBox("递归批处理（音频/视频）")
        fl = QFormLayout(gb)

        self.batch_in_dir = QLineEdit(self.settings.value("batch_in_dir", ""))
        self._tt(self.batch_in_dir, "输入目录\n会递归遍历子文件夹，处理其中的音频/视频文件")
        btn_in = QPushButton("选择…")
        btn_in.clicked.connect(lambda: self._pick_dir(self.batch_in_dir, "选择待处理目录"))
        row = QHBoxLayout()
        row.addWidget(self.batch_in_dir)
        row.addWidget(btn_in)

        self.batch_out_dir = QLineEdit(self.tr_s.output_dir)
        self._tt(self.batch_out_dir, "输出目录\n默认保持子目录结构输出 .txt/.srt")
        btn_out = QPushButton("选择…")
        btn_out.clicked.connect(lambda: self._pick_dir(self.batch_out_dir, "选择输出目录"))
        row2 = QHBoxLayout()
        row2.addWidget(self.batch_out_dir)
        row2.addWidget(btn_out)

        self.batch_skip = QCheckBox("跳过已处理（存在 .txt 则跳过）")
        self.batch_skip.setChecked(bool(self.tr_s.skip_existing))
        self._tt(self.batch_skip, "skip_existing\n如果输出 .txt 已存在，则跳过该文件（避免重复转写）")
        self.batch_keep = QCheckBox("保持子目录结构")
        self.batch_keep.setChecked(bool(self.tr_s.keep_folder_structure))
        self._tt(self.batch_keep, "keep_folder_structure\n输出时保持与输入目录相同的子目录结构")
        self.batch_srt = QCheckBox("导出 SRT")
        self.batch_srt.setChecked(bool(self.tr_s.export_srt))
        self._tt(self.batch_srt, "是否导出 .srt 字幕文件（基于字符级时间戳）")
        self.batch_verbose = QCheckBox("详细日志（会显著变慢且日志很大）")
        self.batch_verbose.setChecked(bool(self.tr_s.verbose))
        self._tt(self.batch_verbose, "是否输出详细日志\n一般批处理建议关闭，避免日志过大")

        fl.addRow("输入目录", row)
        fl.addRow("输出目录", row2)
        fl.addRow(self.batch_skip)
        fl.addRow(self.batch_keep)
        fl.addRow(self.batch_srt)
        fl.addRow(self.batch_verbose)

        self.batch_srt_gap = QDoubleSpinBox()
        self.batch_srt_gap.setRange(0.1, 10.0)
        self.batch_srt_gap.setDecimals(2)
        self.batch_srt_gap.setSingleStep(0.1)
        self.batch_srt_gap.setValue(float(self.tr_s.srt_max_gap_seconds))
        self._tt(self.batch_srt_gap, "SRT 静音分句阈值（秒）\n相邻字符时间戳间隔超过该值时，强制结束上一条字幕")
        fl.addRow("SRT 静音分句阈值 (s)", self.batch_srt_gap)

        # 参数（与单文件一致的关键项）
        self.batch_language = QComboBox()
        self.batch_language.addItems(["自动", "中文", "英文", "日文"])
        self._tt(self.batch_language, "language 参数\n自动：由模型判断；也可指定中文/英文/日文")
        self.batch_context = QLineEdit(self.tr_s.context)
        self._tt(self.batch_context, "context 参数\n对整个批处理生效的上下文提示")
        self.batch_segment = QDoubleSpinBox()
        self.batch_segment.setRange(5.0, 600.0)
        self.batch_segment.setValue(float(self.tr_s.segment_size))
        self.batch_overlap = QDoubleSpinBox()
        self.batch_overlap.setRange(0.0, 30.0)
        self.batch_overlap.setValue(float(self.tr_s.overlap))
        self.batch_start = QDoubleSpinBox()
        self.batch_start.setRange(0.0, 10_000_000.0)
        self.batch_start.setDecimals(2)
        self.batch_start.setValue(float(self.tr_s.start_second or 0.0))
        self.batch_duration = QDoubleSpinBox()
        self.batch_duration.setRange(0.0, 10_000_000.0)
        self.batch_duration.setDecimals(2)
        self.batch_duration.setValue(float(self.tr_s.duration or 0.0))
        self.batch_use_duration = QCheckBox("启用 duration（秒）")
        self.batch_use_duration.setChecked(self.tr_s.duration is not None)
        self._tt(self.batch_segment, "segment_size（秒）\n超过该长度会自动分段识别")
        self._tt(self.batch_overlap, "overlap（秒）\n分段重叠时长，用于提升拼接稳定性")
        self._tt(self.batch_start, "start_second（秒）\n从指定秒数开始识别（对每个文件生效）")
        self._tt(self.batch_duration, "duration（秒）\n识别指定时长（从 start_second 起算，对每个文件生效）")
        self._tt(self.batch_use_duration, "是否启用 duration 参数")

        fl.addRow("language", self.batch_language)
        fl.addRow("context", self.batch_context)
        fl.addRow("segment_size (s)", self.batch_segment)
        fl.addRow("overlap (s)", self.batch_overlap)
        fl.addRow("start_second (s)", self.batch_start)
        dur_row = QHBoxLayout()
        dur_row.addWidget(self.batch_duration)
        dur_row.addWidget(self.batch_use_duration)
        fl.addRow("duration (s)", dur_row)

        # 按钮 + 进度
        btn_row = QHBoxLayout()
        self.batch_btn_start = QPushButton("开始批处理")
        self.batch_btn_cancel = QPushButton("取消")
        self.batch_btn_cancel.setEnabled(False)
        self.batch_btn_start.clicked.connect(self._start_batch)
        self.batch_btn_cancel.clicked.connect(self._cancel_worker)
        btn_row.addWidget(self.batch_btn_start)
        btn_row.addWidget(self.batch_btn_cancel)
        fl.addRow(btn_row)
        self._action_buttons.append(self.batch_btn_start)

        self.batch_prog = QProgressBar()
        self.batch_prog.setRange(0, 100)
        self.batch_label = QLabel("")
        fl.addRow(self.batch_prog)
        fl.addRow(self.batch_label)

        layout.addWidget(gb)
        layout.addStretch(1)

        self.tabs.addTab(tab, "批处理")

    def _build_tab_settings(self):
        tab = QWidget()
        layout = QVBoxLayout(tab)
        layout.setContentsMargins(8, 8, 8, 8)

        self.settings_tabs = QTabWidget()
        layout.addWidget(self.settings_tabs, 1)

        self.settings_tabs.addTab(self._build_settings_models_tab(), "模型")
        self.settings_tabs.addTab(self._build_settings_engine_tab(), "引擎")
        self.settings_tabs.addTab(self._build_settings_transcribe_tab(), "转写默认")

        btn_save = QPushButton("保存设置")
        btn_save.clicked.connect(self._save_from_ui)
        layout.addWidget(btn_save)

        self.tabs.addTab(tab, "设置")

        # 初始化时刷新模型导出状态
        try:
            self._refresh_export_status()
        except Exception:
            pass

    def _build_settings_models_tab(self) -> QWidget:
        w = QWidget()
        layout = QVBoxLayout(w)

        # 下载
        gb_dl = QGroupBox("模型下载")
        fl = QFormLayout(gb_dl)
        self.dl_model_id = QLineEdit(self.settings.value("dl_model_id", "FunAudioLLM/Fun-ASR-Nano-2512"))
        self.dl_dir = QLineEdit(self.settings.value("dl_dir", str(repo_root() / "Fun-ASR-Nano-2512")))
        self._tt(self.dl_model_id, "ModelScope 模型 ID\n例如：FunAudioLLM/Fun-ASR-Nano-2512")
        self._tt(self.dl_dir, "模型下载到的本地目录\n应包含下载后的 model.pt、Qwen3-0.6B/ 等文件")
        btn_dl_dir = QPushButton("选择…")
        btn_dl_dir.clicked.connect(lambda: self._pick_dir(self.dl_dir, "选择模型下载目录"))
        row = QHBoxLayout()
        row.addWidget(self.dl_dir)
        row.addWidget(btn_dl_dir)
        fl.addRow("Model ID", self.dl_model_id)
        fl.addRow("下载到目录", row)

        self.btn_dl = QPushButton("开始下载")
        self.btn_dl.clicked.connect(self._start_download)
        self._action_buttons.append(self.btn_dl)
        fl.addRow(self.btn_dl)

        # 导出
        gb_exp = QGroupBox("模型导出（检测已存在文件并跳过）")
        fl2 = QFormLayout(gb_exp)

        self.src_model_dir = QLineEdit(self.settings.value("src_model_dir", str(repo_root() / "Fun-ASR-Nano-2512")))
        self._tt(self.src_model_dir, "源模型目录（原始 Fun-ASR-Nano-2512）\n需要包含：model.pt、multilingual.tiktoken、Qwen3-0.6B/config.json 等")
        btn_src = QPushButton("选择…")
        btn_src.clicked.connect(lambda: self._pick_dir(self.src_model_dir, "选择源模型目录"))
        row2 = QHBoxLayout()
        row2.addWidget(self.src_model_dir)
        row2.addWidget(btn_src)

        self.out_model_dir = QLineEdit(self.engine_s.model_output_dir)
        self._tt(self.out_model_dir, "导出目录（生成可推理的 model/ 文件）\n会生成：Encoder ONNX、CTC ONNX、tokens.txt、Decoder GGUF 等")
        btn_out = QPushButton("选择…")
        btn_out.clicked.connect(lambda: self._pick_dir(self.out_model_dir, "选择导出目录"))
        row3 = QHBoxLayout()
        row3.addWidget(self.out_model_dir)
        row3.addWidget(btn_out)

        fl2.addRow("源模型目录", row2)
        fl2.addRow("导出目录", row3)

        self.btn_exp1 = QPushButton("导出 Encoder + CTC（ONNX）")
        self.btn_exp2 = QPushButton("导出 Decoder（GGUF）")
        self.btn_exp1.clicked.connect(self._start_export_encoder_ctc)
        self.btn_exp2.clicked.connect(self._start_export_decoder)
        self._action_buttons.append(self.btn_exp1)
        self._action_buttons.append(self.btn_exp2)
        row_btn = QHBoxLayout()
        row_btn.addWidget(self.btn_exp1)
        row_btn.addWidget(self.btn_exp2)
        fl2.addRow(row_btn)

        self.model_status = QLabel()
        self.model_status.setTextInteractionFlags(Qt.TextInteractionFlag.TextSelectableByMouse)
        fl2.addRow("导出文件状态", self.model_status)

        self.btn_refresh_model = QPushButton("刷新状态")
        self.btn_refresh_model.clicked.connect(self._refresh_export_status)
        self._action_buttons.append(self.btn_refresh_model)
        fl2.addRow(self.btn_refresh_model)

        layout.addWidget(gb_dl)
        layout.addWidget(gb_exp)
        layout.addStretch(1)
        return w

    def _build_settings_engine_tab(self) -> QWidget:
        w = QWidget()
        layout = QVBoxLayout(w)

        gb = QGroupBox("引擎设置（与原项目参数一致）")
        fl = QFormLayout(gb)

        # 模型文件
        self.set_encoder = QLineEdit(self.engine_s.encoder_onnx)
        self.set_ctc = QLineEdit(self.engine_s.ctc_onnx)
        self.set_decoder = QLineEdit(self.engine_s.decoder_gguf)
        self.set_tokens = QLineEdit(self.engine_s.tokens)
        self.set_hot = QLineEdit(self.engine_s.hotwords)
        self._tt(self.set_encoder, "encoder_onnx_path\nEncoder + Adaptor 的 ONNX（通常为 FP32）")
        self._tt(self.set_ctc, "ctc_onnx_path\nCTC Head 的 ONNX（通常为 INT8）")
        self._tt(self.set_decoder, "decoder_gguf_path\nLLM Decoder 的 GGUF（推荐 q8_0）")
        self._tt(self.set_tokens, "tokens_path\nCTC token 映射文件 tokens.txt")
        self._tt(self.set_hot, "hotwords_path（单文件，兼容）\n热词文件（每行一个热词）\n如果下方选择了多个热词文件，则会优先使用“多文件合并”结果")

        self.set_hot_multi = QLineEdit(";".join(self.engine_s.hotwords_files))
        self._tt(self.set_hot_multi, "热词文件（可多选）\n用于按软件/项目拆分热词：识别时会把这些文件合并去重后使用")

        def file_row(le: QLineEdit, caption: str) -> QHBoxLayout:
            b = QPushButton("选择…")
            b.clicked.connect(lambda: self._pick_file(le, caption))
            r = QHBoxLayout()
            r.addWidget(le)
            r.addWidget(b)
            return r

        fl.addRow("Encoder ONNX", file_row(self.set_encoder, "选择 Encoder ONNX"))
        fl.addRow("CTC ONNX", file_row(self.set_ctc, "选择 CTC ONNX"))
        fl.addRow("Decoder GGUF", file_row(self.set_decoder, "选择 Decoder GGUF"))
        fl.addRow("Tokens", file_row(self.set_tokens, "选择 tokens.txt"))
        fl.addRow("Hotwords (单文件)", file_row(self.set_hot, "选择热词文件 hot.txt"))

        row_hot_multi = QHBoxLayout()
        row_hot_multi.addWidget(self.set_hot_multi)
        btn_hot_multi = QPushButton("选择多个…")
        btn_hot_multi.clicked.connect(self._select_hotword_files)
        btn_hot_clear = QPushButton("清空")
        btn_hot_clear.clicked.connect(self._clear_hotword_files)
        row_hot_multi.addWidget(btn_hot_multi)
        row_hot_multi.addWidget(btn_hot_clear)
        fl.addRow("Hotwords (多文件)", row_hot_multi)

        # 引擎参数
        self.set_enable_ctc = QCheckBox("启用 CTC（时间戳/热词召回）")
        self.set_enable_ctc.setChecked(bool(self.engine_s.enable_ctc))
        self._tt(self.set_enable_ctc, "enable_ctc\n开启后会运行 CTC：用于时间戳对齐与热词召回")
        self.set_n_predict = QSpinBox()
        self.set_n_predict.setRange(1, 4096)
        self.set_n_predict.setValue(int(self.engine_s.n_predict))
        self.set_n_threads = QSpinBox()
        self.set_n_threads.setRange(0, 256)
        self.set_n_threads.setValue(int(self.engine_s.n_threads))
        self.set_n_threads_batch = QSpinBox()
        self.set_n_threads_batch.setRange(0, 256)
        self.set_n_threads_batch.setValue(int(self.engine_s.n_threads_batch))
        self.set_n_ubatch = QSpinBox()
        self.set_n_ubatch.setRange(1, 4096)
        self.set_n_ubatch.setValue(int(self.engine_s.n_ubatch))
        self.set_n_gpu_layers = QSpinBox()
        self.set_n_gpu_layers.setRange(0, 999)
        self.set_n_gpu_layers.setValue(int(getattr(self.engine_s, "n_gpu_layers", 0) or 0))
        self.set_similar = QDoubleSpinBox()
        self.set_similar.setRange(0.0, 1.0)
        self.set_similar.setSingleStep(0.05)
        self.set_similar.setValue(float(self.engine_s.similar_threshold))
        self.set_max_hw = QSpinBox()
        self._tt(self.set_n_predict, "n_predict\nLLM 最多生成 token 数（过小可能截断，过大可能变慢）")
        self._tt(self.set_n_threads, "n_threads\nllama.cpp 推理线程数（0=自动）")
        self._tt(self.set_n_threads_batch, "n_threads_batch\nllama.cpp batch 线程数（0=自动）")
        self._tt(self.set_n_ubatch, "n_ubatch\nllama.cpp 内部 micro-batch 大小（影响性能/内存）")
        self._tt(self.set_n_gpu_layers, "n_gpu_layers\nllama.cpp GPU offload 层数（0=CPU）\n使用 Vulkan 时建议先试 999（尽可能全部层），可显著提高 GPU 占用")
        self._tt(self.set_similar, "similar_threshold\n热词模糊匹配阈值（越大越严格）")
        self._tt(self.set_max_hw, "max_hotwords\n最多提供给 LLM 的热词数量")
        self.set_max_hw.setRange(0, 200)
        self.set_max_hw.setValue(int(self.engine_s.max_hotwords))

        fl.addRow(self.set_enable_ctc)

        # 紧凑布局：短参数尽量横向排列
        row_threads = QHBoxLayout()
        row_threads.addWidget(QLabel("n_threads"))
        row_threads.addWidget(self.set_n_threads)
        row_threads.addSpacing(10)
        row_threads.addWidget(QLabel("n_threads_batch"))
        row_threads.addWidget(self.set_n_threads_batch)
        row_threads.addStretch(1)

        row_misc = QHBoxLayout()
        row_misc.addWidget(QLabel("n_predict"))
        row_misc.addWidget(self.set_n_predict)
        row_misc.addSpacing(10)
        row_misc.addWidget(QLabel("n_ubatch"))
        row_misc.addWidget(self.set_n_ubatch)
        row_misc.addSpacing(10)
        row_misc.addWidget(QLabel("n_gpu_layers"))
        row_misc.addWidget(self.set_n_gpu_layers)
        row_misc.addStretch(1)

        row_hw = QHBoxLayout()
        row_hw.addWidget(QLabel("similar_threshold"))
        row_hw.addWidget(self.set_similar)
        row_hw.addSpacing(10)
        row_hw.addWidget(QLabel("max_hotwords"))
        row_hw.addWidget(self.set_max_hw)
        row_hw.addStretch(1)

        fl.addRow("线程", row_threads)
        fl.addRow("解码", row_misc)
        fl.addRow("热词", row_hw)

        # ORT 线程/执行模式（用于提升 Encoder/CTC CPU 利用率）
        gb_ort = QGroupBox("ONNX Runtime（Encoder/CTC）并行设置")
        flort = QFormLayout(gb_ort)
        self.set_ort_intra = QSpinBox()
        self.set_ort_intra.setRange(0, 256)
        self.set_ort_intra.setValue(int(getattr(self.engine_s, "ort_intra_threads", 0) or 0))
        self.set_ort_inter = QSpinBox()
        self.set_ort_inter.setRange(0, 256)
        self.set_ort_inter.setValue(int(getattr(self.engine_s, "ort_inter_threads", 0) or 0))
        self.set_ort_mode = QComboBox()
        self.set_ort_mode.addItems(["auto", "sequential", "parallel"])
        mode0 = (getattr(self.engine_s, "ort_execution_mode", "auto") or "auto").strip().lower()
        if mode0 not in ("auto", "sequential", "parallel"):
            mode0 = "auto"
        self.set_ort_mode.setCurrentText(mode0)
        self._tt(self.set_ort_intra, "ort_intra_threads\nONNXRuntime intra-op 线程数（0=默认）\n一般设置为 CPU 核心数可提升占用/速度")
        self._tt(self.set_ort_inter, "ort_inter_threads\nONNXRuntime inter-op 线程数（0=默认）\n通常保持 0 或 1；想更激进可尝试 2~4")
        self._tt(self.set_ort_mode, "ort_execution_mode\nauto: 使用 ORT 默认\nsequential: 顺序执行（更稳定）\nparallel: 并行执行（更高 CPU 占用，少数环境可能更慢）")
        row_ort = QHBoxLayout()
        row_ort.addWidget(QLabel("intra"))
        row_ort.addWidget(self.set_ort_intra)
        row_ort.addSpacing(10)
        row_ort.addWidget(QLabel("inter"))
        row_ort.addWidget(self.set_ort_inter)
        row_ort.addSpacing(10)
        row_ort.addWidget(QLabel("mode"))
        row_ort.addWidget(self.set_ort_mode)
        row_ort.addStretch(1)
        flort.addRow("ORT", row_ort)

        self.set_enc_workers = QSpinBox()
        self.set_enc_workers.setRange(0, 16)
        self.set_enc_workers.setValue(int(getattr(self.engine_s, "enc_ctc_workers", 0) or 0))
        self._tt(self.set_enc_workers, "enc_ctc_workers\n长音频并行：Encoder/CTC 预处理并行段数（0=关闭）\n推荐 2~4；注意与 ORT 线程数配合，避免线程过量")
        row_workers = QHBoxLayout()
        row_workers.addWidget(QLabel("enc_ctc_workers"))
        row_workers.addWidget(self.set_enc_workers)
        row_workers.addStretch(1)
        flort.addRow("并行", row_workers)

        gb_bench = QGroupBox("Benchmark（性能自检）")
        flb = QFormLayout(gb_bench)
        self.btn_benchmark = QPushButton("运行 Benchmark（benchmark.mp4）")
        self._tt(self.btn_benchmark, "使用根目录 benchmark.mp4 跑一次基准测试（全片）\n会采样 CPU/内存（如有 nvidia-smi 则采样 GPU）\n完成后会给出并写回推荐的线程/并行参数")
        self.btn_benchmark.clicked.connect(self._start_benchmark)
        self._action_buttons.append(self.btn_benchmark)
        self.benchmark_info = QLabel("未运行")
        flb.addRow(self.btn_benchmark)
        flb.addRow("最近结果", self.benchmark_info)

        # Vulkan 环境
        gb_vk = QGroupBox("Vulkan / llama.cpp 环境变量")
        flvk = QFormLayout(gb_vk)
        self.set_disable_vk = QCheckBox("禁用 Vulkan（VK_ICD_FILENAMES=none）")
        self.set_disable_vk.setChecked(bool(self.engine_s.disable_vulkan))
        self.set_force_igpu = QCheckBox("强制使用集显（GGML_VK_VISIBLE_DEVICES=0）")
        self.set_force_igpu.setChecked(bool(self.engine_s.force_igpu))
        self.set_disable_f16 = QCheckBox("禁用 Vulkan FP16（GGML_VK_DISABLE_F16=1）")
        self.set_disable_f16.setChecked(bool(self.engine_s.disable_vulkan_f16))
        self._tt(self.set_disable_vk, "设置 VK_ICD_FILENAMES=none\n用于完全禁用 Vulkan")
        self._tt(self.set_force_igpu, "设置 GGML_VK_VISIBLE_DEVICES=0\n强制 Vulkan 使用集显（按需）")
        self._tt(self.set_disable_f16, "设置 GGML_VK_DISABLE_F16=1\n解决部分 Intel 集显 FP16 溢出导致输出 !!!!! 问题")
        flvk.addRow(self.set_disable_vk)
        flvk.addRow(self.set_force_igpu)
        flvk.addRow(self.set_disable_f16)

        layout.addWidget(gb)
        layout.addWidget(gb_ort)
        layout.addWidget(gb_bench)
        layout.addWidget(gb_vk)
        layout.addStretch(1)
        return w

    def _build_settings_transcribe_tab(self) -> QWidget:
        w = QWidget()
        layout = QVBoxLayout(w)

        gb = QGroupBox("转写默认参数（任务页会默认读取这里的值）")
        fl = QFormLayout(gb)

        self.tr_out_dir = QLineEdit(self.tr_s.output_dir)
        btn_out = QPushButton("选择…")
        btn_out.clicked.connect(lambda: self._pick_dir(self.tr_out_dir, "选择默认输出目录"))
        row_out = QHBoxLayout()
        row_out.addWidget(self.tr_out_dir)
        row_out.addWidget(btn_out)
        fl.addRow("默认输出目录", row_out)

        self.tr_skip = QCheckBox("默认跳过已处理（存在 .txt 则跳过）")
        self.tr_skip.setChecked(bool(self.tr_s.skip_existing))
        self.tr_keep = QCheckBox("默认保持目录结构")
        self.tr_keep.setChecked(bool(self.tr_s.keep_folder_structure))
        self.tr_export_srt = QCheckBox("默认导出 SRT")
        self.tr_export_srt.setChecked(bool(self.tr_s.export_srt))
        row_flags = QHBoxLayout()
        row_flags.addWidget(self.tr_skip)
        row_flags.addWidget(self.tr_keep)
        row_flags.addWidget(self.tr_export_srt)
        row_flags.addStretch(1)
        fl.addRow("默认选项", row_flags)

        self.tr_language = QComboBox()
        self.tr_language.addItems(["自动", "中文", "英文", "日文"])
        lang0 = (self.tr_s.language or "").strip()
        self.tr_language.setCurrentText("自动" if not lang0 else lang0)
        self.tr_context = QLineEdit(self.tr_s.context)
        self.tr_segment = QDoubleSpinBox()
        self.tr_segment.setRange(5.0, 600.0)
        self.tr_segment.setValue(float(self.tr_s.segment_size))
        self.tr_overlap = QDoubleSpinBox()
        self.tr_overlap.setRange(0.0, 30.0)
        self.tr_overlap.setValue(float(self.tr_s.overlap))
        self.tr_start = QDoubleSpinBox()
        self.tr_start.setRange(0.0, 10_000_000.0)
        self.tr_start.setDecimals(2)
        self.tr_start.setValue(float(self.tr_s.start_second or 0.0))
        self.tr_duration = QDoubleSpinBox()
        self.tr_duration.setRange(0.0, 10_000_000.0)
        self.tr_duration.setDecimals(2)
        self.tr_duration.setValue(float(self.tr_s.duration or 0.0))
        self.tr_use_duration = QCheckBox("启用 duration（秒）")
        self.tr_use_duration.setChecked(self.tr_s.duration is not None)

        self.tr_srt_gap = QDoubleSpinBox()
        self.tr_srt_gap.setRange(0.1, 10.0)
        self.tr_srt_gap.setDecimals(2)
        self.tr_srt_gap.setSingleStep(0.1)
        self.tr_srt_gap.setValue(float(self.tr_s.srt_max_gap_seconds))
        self.tr_max_chars = QSpinBox()
        self.tr_max_chars.setRange(5, 200)
        self.tr_max_chars.setValue(int(self.tr_s.max_chars_per_line))

        fl.addRow("language", self.tr_language)
        fl.addRow("context", self.tr_context)

        row_seg = QHBoxLayout()
        row_seg.addWidget(QLabel("segment_size(s)"))
        row_seg.addWidget(self.tr_segment)
        row_seg.addSpacing(10)
        row_seg.addWidget(QLabel("overlap(s)"))
        row_seg.addWidget(self.tr_overlap)
        row_seg.addStretch(1)
        fl.addRow("分段", row_seg)

        fl.addRow("start_second (s)", self.tr_start)
        dur_row = QHBoxLayout()
        dur_row.addWidget(self.tr_duration)
        dur_row.addWidget(self.tr_use_duration)
        fl.addRow("duration (s)", dur_row)

        row_srt = QHBoxLayout()
        row_srt.addWidget(QLabel("max_gap(s)"))
        row_srt.addWidget(self.tr_srt_gap)
        row_srt.addSpacing(10)
        row_srt.addWidget(QLabel("max_chars"))
        row_srt.addWidget(self.tr_max_chars)
        row_srt.addStretch(1)
        fl.addRow("SRT", row_srt)

        layout.addWidget(gb)
        layout.addStretch(1)
        return w

    # 日志已改为底部 Dock 常驻窗口（见 _init_log_dock）

    # ---------------- Actions ----------------
    def _save_from_ui(self):
        # 引擎设置
        if hasattr(self, "set_encoder"):
            self.engine_s.encoder_onnx = self.set_encoder.text().strip()
        if hasattr(self, "set_ctc"):
            self.engine_s.ctc_onnx = self.set_ctc.text().strip()
        if hasattr(self, "set_decoder"):
            self.engine_s.decoder_gguf = self.set_decoder.text().strip()
        if hasattr(self, "set_tokens"):
            self.engine_s.tokens = self.set_tokens.text().strip()
        if hasattr(self, "set_hot"):
            self.engine_s.hotwords = self.set_hot.text().strip()
        if hasattr(self, "set_hot_multi"):
            try:
                self.engine_s.hotwords_files = self._parse_hotword_paths(self.set_hot_multi.text())
            except Exception:
                self.engine_s.hotwords_files = []

        if hasattr(self, "set_enable_ctc"):
            self.engine_s.enable_ctc = bool(self.set_enable_ctc.isChecked())
        if hasattr(self, "set_n_predict"):
            self.engine_s.n_predict = int(self.set_n_predict.value())
        if hasattr(self, "set_n_threads"):
            self.engine_s.n_threads = int(self.set_n_threads.value())
        if hasattr(self, "set_n_threads_batch"):
            self.engine_s.n_threads_batch = int(self.set_n_threads_batch.value())
        if hasattr(self, "set_n_ubatch"):
            self.engine_s.n_ubatch = int(self.set_n_ubatch.value())
        if hasattr(self, "set_n_gpu_layers"):
            self.engine_s.n_gpu_layers = int(self.set_n_gpu_layers.value())
        if hasattr(self, "set_similar"):
            self.engine_s.similar_threshold = float(self.set_similar.value())
        if hasattr(self, "set_max_hw"):
            self.engine_s.max_hotwords = int(self.set_max_hw.value())

        if hasattr(self, "set_ort_intra"):
            self.engine_s.ort_intra_threads = int(self.set_ort_intra.value())
        if hasattr(self, "set_ort_inter"):
            self.engine_s.ort_inter_threads = int(self.set_ort_inter.value())
        if hasattr(self, "set_ort_mode"):
            self.engine_s.ort_execution_mode = str(self.set_ort_mode.currentText() or "auto").strip().lower()
        if hasattr(self, "set_enc_workers"):
            self.engine_s.enc_ctc_workers = int(self.set_enc_workers.value())

        if hasattr(self, "set_disable_vk"):
            self.engine_s.disable_vulkan = bool(self.set_disable_vk.isChecked())
        if hasattr(self, "set_force_igpu"):
            self.engine_s.force_igpu = bool(self.set_force_igpu.isChecked())
        if hasattr(self, "set_disable_f16"):
            self.engine_s.disable_vulkan_f16 = bool(self.set_disable_f16.isChecked())

        # 同步模型导出目录
        if hasattr(self, "out_model_dir"):
            self.engine_s.model_output_dir = self.out_model_dir.text().strip() or self.engine_s.model_output_dir

        # 转写默认
        if hasattr(self, "tr_out_dir"):
            self.tr_s.output_dir = self.tr_out_dir.text().strip() or self.tr_s.output_dir
        if hasattr(self, "tr_skip"):
            self.tr_s.skip_existing = bool(self.tr_skip.isChecked())
        if hasattr(self, "tr_keep"):
            self.tr_s.keep_folder_structure = bool(self.tr_keep.isChecked())
        if hasattr(self, "tr_export_srt"):
            self.tr_s.export_srt = bool(self.tr_export_srt.isChecked())

        if hasattr(self, "tr_language"):
            lang = self.tr_language.currentText()
            self.tr_s.language = "" if lang == "自动" else lang
        if hasattr(self, "tr_context"):
            self.tr_s.context = self.tr_context.text()
        if hasattr(self, "tr_segment"):
            self.tr_s.segment_size = float(self.tr_segment.value())
        if hasattr(self, "tr_overlap"):
            self.tr_s.overlap = float(self.tr_overlap.value())
        if hasattr(self, "tr_start"):
            self.tr_s.start_second = float(self.tr_start.value())
        if hasattr(self, "tr_duration") and hasattr(self, "tr_use_duration"):
            self.tr_s.duration = float(self.tr_duration.value()) if self.tr_use_duration.isChecked() else None
        if hasattr(self, "tr_srt_gap"):
            self.tr_s.srt_max_gap_seconds = float(self.tr_srt_gap.value())
        if hasattr(self, "tr_max_chars"):
            self.tr_s.max_chars_per_line = int(self.tr_max_chars.value())

        self._save_settings()

        # 同步任务页控件（如果已创建）
        if hasattr(self, "task_out_dir"):
            self.task_out_dir.setText(self.tr_s.output_dir)
        if hasattr(self, "task_skip"):
            self.task_skip.setChecked(bool(self.tr_s.skip_existing))
        if hasattr(self, "task_keep"):
            self.task_keep.setChecked(bool(self.tr_s.keep_folder_structure))
        if hasattr(self, "task_export_srt"):
            self.task_export_srt.setChecked(bool(self.tr_s.export_srt))
        if hasattr(self, "task_language"):
            self.task_language.setCurrentText("自动" if not (self.tr_s.language or "").strip() else self.tr_s.language)
        if hasattr(self, "task_context"):
            self.task_context.setText(self.tr_s.context)
        if hasattr(self, "task_segment"):
            self.task_segment.setValue(float(self.tr_s.segment_size))
        if hasattr(self, "task_overlap"):
            self.task_overlap.setValue(float(self.tr_s.overlap))
        if hasattr(self, "task_start"):
            self.task_start.setValue(float(self.tr_s.start_second or 0.0))
        if hasattr(self, "task_duration") and hasattr(self, "task_use_duration"):
            self.task_duration.setValue(float(self.tr_s.duration or 0.0))
            self.task_use_duration.setChecked(self.tr_s.duration is not None)
        if hasattr(self, "task_srt_gap"):
            self.task_srt_gap.setValue(float(self.tr_s.srt_max_gap_seconds))
        if hasattr(self, "task_max_chars"):
            self.task_max_chars.setValue(int(self.tr_s.max_chars_per_line))

        QMessageBox.information(self, "保存设置", "已保存。")
        try:
            self._refresh_export_status()
        except Exception:
            pass

    def _start_download(self):
        model_id = self.dl_model_id.text().strip()
        local_dir = self.dl_dir.text().strip()
        self.settings.setValue("dl_model_id", model_id)
        self.settings.setValue("dl_dir", local_dir)
        w = DownloadModelWorker(model_id=model_id, local_dir=local_dir)
        self._bind_worker(w, "模型下载")

    def _start_export_encoder_ctc(self):
        src = self.src_model_dir.text().strip()
        outd = self.out_model_dir.text().strip()
        self.settings.setValue("src_model_dir", src)
        self.engine_s.model_output_dir = outd

        script = str(repo_root() / "01-Export-Encoder-Adaptor-CTC.py")
        args = [
            sys.executable,
            script,
            "--source_model_dir", src,
            "--output_dir", outd,
        ]
        w = RunScriptWorker(args=args, cwd=str(repo_root()))
        w.done.connect(lambda ok, msg: self._refresh_export_status())
        self._bind_worker(w, "导出 Encoder/CTC")

    def _start_export_decoder(self):
        src = self.src_model_dir.text().strip()
        outd = self.out_model_dir.text().strip()
        self.settings.setValue("src_model_dir", src)
        self.engine_s.model_output_dir = outd

        script = str(repo_root() / "02-Export-Decoder-GGUF.py")
        args = [
            sys.executable,
            script,
            "--source_model_dir", src,
            "--output_dir", outd,
            "--q8_0",
        ]
        w = RunScriptWorker(args=args, cwd=str(repo_root()))
        w.done.connect(lambda ok, msg: self._refresh_export_status())
        self._bind_worker(w, "导出 Decoder(GGUF)")

    def _refresh_export_status(self):
        outd = self.out_model_dir.text().strip() or self.engine_s.model_output_dir
        p = Path(outd)
        checks = [
            ("Encoder FP32", p / "Fun-ASR-Nano-Encoder-Adaptor.fp32.onnx"),
            ("CTC INT8", p / "Fun-ASR-Nano-CTC.int8.onnx"),
            ("tokens.txt", p / "tokens.txt"),
            ("Decoder q8_0", p / "Fun-ASR-Nano-Decoder.q8_0.gguf"),
        ]
        lines = []
        for name, fp in checks:
            lines.append(f"[{'OK' if fp.exists() else '缺失'}] {name}: {fp}")
        self.model_status.setText("\n".join(lines))

        # 同步设置页模型路径（让用户更少手动改）
        self.engine_s.model_output_dir = outd
        self.engine_s.encoder_onnx = str(p / "Fun-ASR-Nano-Encoder-Adaptor.fp32.onnx")
        self.engine_s.ctc_onnx = str(p / "Fun-ASR-Nano-CTC.int8.onnx")
        self.engine_s.decoder_gguf = str(p / "Fun-ASR-Nano-Decoder.q8_0.gguf")
        self.engine_s.tokens = str(p / "tokens.txt")

        # 如果设置页已创建控件，则同步文本（避免第一次打开时不一致）
        if hasattr(self, "set_encoder"):
            self.set_encoder.setText(self.engine_s.encoder_onnx)
            self.set_ctc.setText(self.engine_s.ctc_onnx)
            self.set_decoder.setText(self.engine_s.decoder_gguf)
            self.set_tokens.setText(self.engine_s.tokens)

    def _start_single_transcribe(self):
        inp = self.single_in.text().strip()
        outd = self.single_out.text().strip()
        if not inp or not Path(inp).exists():
            QMessageBox.warning(self, "单文件转写", "请输入有效的输入文件路径。")
            return
        if not outd:
            QMessageBox.warning(self, "单文件转写", "请选择输出目录。")
            return

        # 将 UI 参数写入 tr_s
        self.tr_s.output_dir = outd
        self.tr_s.context = self.single_context.text()
        self.tr_s.verbose = bool(self.single_verbose.isChecked())
        self.tr_s.segment_size = float(self.single_segment.value())
        self.tr_s.overlap = float(self.single_overlap.value())
        self.tr_s.start_second = float(self.single_start.value())
        self.tr_s.duration = float(self.single_duration.value()) if self.single_use_duration.isChecked() else None
        self.tr_s.export_srt = bool(self.single_srt.isChecked())
        self.tr_s.srt_max_gap_seconds = float(self.single_srt_gap.value())

        lang = self.single_language.currentText()
        self.tr_s.language = "" if lang == "自动" else lang

        self.settings.setValue("single_in", inp)
        self._save_settings()

        w = TranscribeSingleWorker(engine_s=self.engine_s, tr_s=self.tr_s, input_path=inp)
        w.log.connect(self._append_log)
        w.result_ready.connect(self._on_single_result)
        w.progress.connect(self._on_single_progress)
        self._set_running(True, "单文件转写")
        self._append_log("[开始] 单文件转写")
        w.done.connect(lambda ok, msg: self._on_worker_done(ok, msg, "单文件转写"))
        self._current_worker = w
        w.start()

    def _on_single_result(self, text: str, out_txt: str, out_srt: str):
        self.single_result.setPlainText(text)
        self._append_log(f"[输出] TXT: {out_txt}")
        if out_srt:
            self._append_log(f"[输出] SRT: {out_srt}")

    def _on_single_progress(self, cur: int, total: int, item: str):
        # total 为 6（短音频阶段）或 分段*6（长音频）或 (1,1)
        if total <= 0:
            self.single_prog.setRange(0, 0)
            self.single_label.setText(item)
            return

        self.single_prog.setRange(0, total)
        self.single_prog.setValue(max(0, min(cur, total)))
        # UI 仅展示步骤，用于“当前进展”提示
        self.single_label.setText(item)

    def _start_batch(self):
        in_dir = self.batch_in_dir.text().strip()
        out_dir = self.batch_out_dir.text().strip()
        if not in_dir or not Path(in_dir).exists():
            QMessageBox.warning(self, "批处理", "请选择有效的输入目录。")
            return
        if not out_dir:
            QMessageBox.warning(self, "批处理", "请选择输出目录。")
            return

        # 同步参数
        self.tr_s.output_dir = out_dir
        self.tr_s.skip_existing = bool(self.batch_skip.isChecked())
        self.tr_s.keep_folder_structure = bool(self.batch_keep.isChecked())
        self.tr_s.export_srt = bool(self.batch_srt.isChecked())
        self.tr_s.verbose = bool(self.batch_verbose.isChecked())
        self.tr_s.srt_max_gap_seconds = float(self.batch_srt_gap.value())
        self.tr_s.context = self.batch_context.text()
        self.tr_s.segment_size = float(self.batch_segment.value())
        self.tr_s.overlap = float(self.batch_overlap.value())
        self.tr_s.start_second = float(self.batch_start.value())
        self.tr_s.duration = float(self.batch_duration.value()) if self.batch_use_duration.isChecked() else None

        lang = self.batch_language.currentText()
        self.tr_s.language = "" if lang == "自动" else lang

        self.settings.setValue("batch_in_dir", in_dir)
        self._save_settings()

        w = BatchWorker(engine_s=self.engine_s, tr_s=self.tr_s, input_dir=in_dir)
        w.log.connect(self._append_log)
        w.progress.connect(self._on_batch_progress)
        w.done.connect(self._on_batch_done)
        self._current_worker = w
        self._set_running(True, "批处理")
        self._append_log("[开始] 批处理")
        self.batch_btn_start.setEnabled(False)
        self.batch_btn_cancel.setEnabled(True)
        w.start()

    def _on_batch_progress(self, cur: int, total: int, item: str):
        if total <= 0:
            self.batch_prog.setValue(0)
            self.batch_label.setText("")
            return
        self.batch_prog.setValue(int(cur * 100 / total))
        # 批处理页该 label 用于文件级进度展示
        self.batch_label.setText(f"{cur}/{total}  {item}")

    def _on_batch_done(self, ok: bool, msg: str):
        self.batch_btn_start.setEnabled(True)
        self.batch_btn_cancel.setEnabled(False)
        self._on_worker_done(ok, msg, "批处理")

    def _cancel_worker(self):
        if self._current_worker is not None:
            self._current_worker.cancel()
            self._append_log("[取消] 已请求取消（将在当前文件处理完后停止）")

    def _start_benchmark(self):
        # 先保存当前设置，确保 benchmark 写回时覆盖的是最新值
        self._save_from_ui()
        self._save_settings()

        mp4 = repo_root() / "benchmark.mp4"
        if not mp4.exists():
            QMessageBox.warning(self, "Benchmark", f"未找到 benchmark.mp4：{mp4}")
            return

        # 全片 benchmark：抽取全部音频以便更准确
        w = BenchmarkWorker(engine_s=self.engine_s, duration_seconds=None)
        w.log.connect(self._append_log)
        w.recommend.connect(self._on_benchmark_recommend)
        w.done.connect(lambda ok, msg: self._on_worker_done(ok, msg, "Benchmark"))

        self._current_worker = w
        self._set_running(True, "Benchmark")
        self._append_log("[开始] Benchmark")
        w.start()

    def _on_benchmark_recommend(self, payload):
        try:
            rec = (payload or {}).get("recommend") or {}
            summary = (payload or {}).get("summary") or {}

            # 写回到 EngineSettings
            for k in ["enc_ctc_workers", "ort_intra_threads", "ort_inter_threads", "ort_execution_mode", "n_threads", "n_threads_batch"]:
                if k in rec:
                    setattr(self.engine_s, k, rec[k])

            # 同步回 UI 控件
            if hasattr(self, "set_enc_workers"):
                self.set_enc_workers.setValue(int(getattr(self.engine_s, "enc_ctc_workers", 0) or 0))
            if hasattr(self, "set_ort_intra"):
                self.set_ort_intra.setValue(int(getattr(self.engine_s, "ort_intra_threads", 0) or 0))
            if hasattr(self, "set_ort_inter"):
                self.set_ort_inter.setValue(int(getattr(self.engine_s, "ort_inter_threads", 0) or 0))
            if hasattr(self, "set_ort_mode"):
                mode = str(getattr(self.engine_s, "ort_execution_mode", "auto") or "auto").strip().lower()
                if mode not in ("auto", "sequential", "parallel"):
                    mode = "auto"
                self.set_ort_mode.setCurrentText(mode)
            if hasattr(self, "set_n_threads"):
                self.set_n_threads.setValue(int(getattr(self.engine_s, "n_threads", 0) or 0))
            if hasattr(self, "set_n_threads_batch"):
                self.set_n_threads_batch.setValue(int(getattr(self.engine_s, "n_threads_batch", 0) or 0))

            # 展示摘要
            if hasattr(self, "benchmark_info"):
                wall = summary.get("wall_s")
                cpu_avg = summary.get("cpu_avg")
                rss = summary.get("rss_peak_mb")
                s = f"wall={wall:.2f}s" if isinstance(wall, (int, float)) else "完成"
                if isinstance(cpu_avg, (int, float)):
                    s += f", CPU avg={cpu_avg:.1f}%"
                if isinstance(rss, (int, float)):
                    s += f", RSS peak={rss:.0f}MB"
                self.benchmark_info.setText(s)

            self._save_settings()
            self._append_log("[Benchmark] 推荐参数已写回设置。")
        except Exception as e:
            self._append_log(f"[Benchmark] 写回推荐参数失败：{e}")


def main():
    app = QApplication(sys.argv)
    w = MainWindow()
    w.show()
    return app.exec()


if __name__ == "__main__":
    raise SystemExit(main())