ui/app.py

# -*- coding: utf-8 -*-
"""
Gradio 界面 - RVC AI 翻唱
"""
import os
import json
import re
import tempfile
import gradio as gr
from pathlib import Path
from typing import Optional, Tuple, Dict

from lib.logger import log

# 项目根目录
ROOT_DIR = Path(__file__).parent.parent

# 加载语言包
def load_i18n(lang: str = "zh_CN") -> dict:
    """加载语言包"""
    i18n_path = ROOT_DIR / "i18n" / f"{lang}.json"
    if i18n_path.exists():
        with open(i18n_path, "r", encoding="utf-8") as f:
            return json.load(f)
    return {}

# 加载配置
def load_config() -> dict:
    """加载配置"""
    config_path = ROOT_DIR / "configs" / "config.json"
    if config_path.exists():
        with open(config_path, "r", encoding="utf-8") as f:
            return json.load(f)
    return {}


def normalize_config(config: dict) -> dict:
    """Normalize legacy path keys to top-level entries."""
    if not config:
        return {}

    paths = config.get("paths", {})
    if "hubert_path" not in config and "hubert" in paths:
        config["hubert_path"] = paths["hubert"]
    if "rmvpe_path" not in config and "rmvpe" in paths:
        config["rmvpe_path"] = paths["rmvpe"]
    if "weights_dir" not in config and "weights" in paths:
        config["weights_dir"] = paths["weights"]
    if "output_dir" not in config and "outputs" in paths:
        config["output_dir"] = paths["outputs"]
    elif config.get("output_dir") == "output" and "outputs" in paths:
        config["output_dir"] = paths["outputs"]
    if "temp_dir" not in config and "temp" in paths:
        config["temp_dir"] = paths["temp"]

    return config

# 全局变量
i18n = load_i18n()
config = normalize_config(load_config())
pipeline = None


def t(key: str, section: str = None) -> str:
    """获取翻译文本"""
    if section:
        return i18n.get(section, {}).get(key, key)
    return i18n.get(key, key)


def _to_int(value, fallback: int) -> int:
    try:
        return int(value)
    except (TypeError, ValueError):
        return fallback


def _to_float(value, fallback: float) -> float:
    try:
        return float(value)
    except (TypeError, ValueError):
        return fallback


def get_cover_mix_defaults() -> Dict[str, int]:
    """获取翻唱混音默认值"""
    cover_cfg = config.get("cover", {})
    return {
        "vocals_volume": _to_int(cover_cfg.get("default_vocals_volume", 100), 100),
        "accompaniment_volume": _to_int(cover_cfg.get("default_accompaniment_volume", 100), 100),
        "reverb": _to_int(cover_cfg.get("default_reverb", 10), 10),
    }


def get_cover_mix_presets() -> Tuple[Dict[str, Dict[str, int]], str]:
    """获取混音预设与默认预设名称"""
    defaults = get_cover_mix_defaults()

    presets = {
        t("mix_preset_universal", "cover"): defaults.copy(),
        t("mix_preset_vocal", "cover"): {
            "vocals_volume": min(200, defaults["vocals_volume"] + 15),
            "accompaniment_volume": max(0, defaults["accompaniment_volume"] - 10),
            "reverb": max(0, defaults["reverb"] - 5),
        },
        t("mix_preset_accompaniment", "cover"): {
            "vocals_volume": max(0, defaults["vocals_volume"] - 10),
            "accompaniment_volume": min(200, defaults["accompaniment_volume"] + 15),
            "reverb": max(0, defaults["reverb"] - 5),
        },
        t("mix_preset_live", "cover"): {
            "vocals_volume": defaults["vocals_volume"],
            "accompaniment_volume": defaults["accompaniment_volume"],
            "reverb": min(100, defaults["reverb"] + 10),
        },
    }

    default_name = t("mix_preset_universal", "cover")
    return presets, default_name


def apply_cover_mix_preset(preset_name: str) -> Tuple[int, int, int]:
    """根据预设名称返回混音参数"""
    presets, default_name = get_cover_mix_presets()
    preset = presets.get(preset_name) or presets[default_name]
    return preset["vocals_volume"], preset["accompaniment_volume"], preset["reverb"]



def get_vc_preprocess_option_maps() -> Tuple[Dict[str, str], Dict[str, str]]:
    """Build VC preprocess dropdown option maps."""
    label_to_value = {
        t("vc_preprocess_auto", "cover"): "auto",
        t("vc_preprocess_direct", "cover"): "direct",
        t("vc_preprocess_uvr_deecho", "cover"): "uvr_deecho",
        t("vc_preprocess_legacy", "cover"): "legacy",
    }
    value_to_label = {value: label for label, value in label_to_value.items()}
    return label_to_value, value_to_label


def get_source_constraint_option_maps() -> Tuple[Dict[str, str], Dict[str, str]]:
    """Build source constraint dropdown option maps."""
    label_to_value = {
        t("source_constraint_auto", "cover"): "auto",
        t("source_constraint_off", "cover"): "off",
        t("source_constraint_on", "cover"): "on",
    }
    value_to_label = {value: label for label, value in label_to_value.items()}
    return label_to_value, value_to_label


def get_vc_pipeline_mode_option_maps() -> Tuple[Dict[str, str], Dict[str, str]]:
    """Build VC pipeline mode dropdown option maps."""
    label_to_value = {
        t("vc_pipeline_mode_current", "cover"): "current",
        t("vc_pipeline_mode_official", "cover"): "official",
    }
    value_to_label = {value: label for label, value in label_to_value.items()}
    return label_to_value, value_to_label


def update_singing_repair_visibility(vc_pipeline_mode: str):
    """Only show singing repair option for official mode."""
    pipeline_label_to_value, _ = get_vc_pipeline_mode_option_maps()
    normalized = pipeline_label_to_value.get(
        str(vc_pipeline_mode),
        str(vc_pipeline_mode or "").strip().lower(),
    )
    return gr.update(visible=(normalized == "official"))


def init_pipeline():
    """初始化推理管道"""
    global pipeline

    if pipeline is not None:
        return pipeline

    from infer.pipeline import VoiceConversionPipeline

    device = config.get("device", "cuda")
    pipeline = VoiceConversionPipeline(device=device)
    pipeline.hubert_layer = config.get("hubert_layer", 12)

    # 加载 HuBERT
    hubert_path = ROOT_DIR / config.get("hubert_path", "assets/hubert/hubert_base.pt")
    if hubert_path.exists():
        pipeline.load_hubert(str(hubert_path))

    # 加载 F0 提取器
    rmvpe_path = ROOT_DIR / config.get("rmvpe_path", "assets/rmvpe/rmvpe.pt")
    if rmvpe_path.exists():
        pipeline.load_f0_extractor("rmvpe", str(rmvpe_path))

    return pipeline


def download_base_models() -> str:
    """下载基础模型"""
    from tools.download_models import download_required_models

    try:
        success = download_required_models()
        if success:
            return t("download_complete", "messages")
        else:
            return "下载过程中出现错误，请检查网络连接"
    except Exception as e:
        return f"{t('download_failed', 'messages')}: {str(e)}"


# ===== 翻唱功能相关函数 =====

def get_downloaded_character_list() -> list:
    """获取已下载的角色列表"""
    from tools.character_models import list_downloaded_characters
    return list_downloaded_characters()


def get_downloaded_character_series() -> list:
    """获取已下载角色的系列列表"""
    characters = get_downloaded_character_list()
    series = sorted({c.get("series", "未知") for c in characters})
    return ["全部"] + series


def get_available_character_list() -> list:
    """获取可下载的角色列表"""
    from tools.character_models import list_available_characters
    return list_available_characters()


def get_available_character_series() -> list:
    """获取可用系列列表"""
    from tools.character_models import list_available_series
    return list_available_series()


def format_character_label(char_info: dict) -> str:
    """格式化角色展示名称：【语言】角色名(中/英/日) · 出处 · 内部名"""
    display = char_info.get("display") or char_info.get("description") or char_info.get("name", "")
    source = char_info.get("source", "未知")
    name = char_info.get("name", "")
    lang_tag = get_character_language_tag(char_info)
    return f"【{lang_tag}】{display}（出自：{source}）[{name}]"


def get_character_language_tag(char_info: dict) -> str:
    """推断语言类型，用于下拉前缀标签"""
    lang = char_info.get("lang")
    if lang:
        return lang
    text = " ".join(
        str(char_info.get(k, "")) for k in ("display", "description", "name")
    ).lower()
    if "韩" in text or "kr" in text or "korean" in text:
        return "韩文"
    if "日" in text or "jp" in text or "japanese" in text:
        return "日文"
    if "中" in text or "cn" in text or "chinese" in text:
        return "中文"
    if "en" in text or "english" in text:
        return "英文"

    source = char_info.get("source", "")
    if source.startswith("Love Live!") or "ホロライブ" in source or "偶像大师" in source or "赛马娘" in source:
        return "日文"
    if "原神" in source or "崩坏" in source or "明日方舟" in source or "碧蓝航线" in source:
        return "中文"
    if "VOCALOID" in source or "Project SEKAI" in source:
        return "日文"
    if "Hololive" in source:
        return "日文"
    if "蔚蓝档案" in source or "绝区零" in source:
        return "日文"
    return "中文"


def get_downloaded_character_choices(series: str = "全部", keyword: str = "") -> list:
    """获取已下载角色的下拉选项"""
    chars = get_downloaded_character_list()
    if series and series != "全部":
        chars = [c for c in chars if c.get("series") == series]
    if keyword:
        kw = keyword.strip().lower()
        if kw:
            chars = [
                c for c in chars
                if kw in c.get("name", "").lower()
                or kw in c.get("display", "").lower()
                or kw in c.get("source", "").lower()
            ]
    return [(format_character_label(c), c["name"]) for c in chars]


def resolve_character_name(selection: str) -> str:
    """将下拉显示文本解析为实际角色名"""
    if not selection:
        return selection
    from tools.character_models import list_downloaded_characters
    for c in list_downloaded_characters():
        if selection == c.get("name") or selection == format_character_label(c):
            return c.get("name")
    if " · " in selection:
        return selection.split(" · ")[-1].strip()
    parts = selection.strip().split()
    return parts[-1] if parts else selection


def get_available_character_choices(series: str = "全部", keyword: str = "") -> list:
    """获取可下载角色的下拉选项"""
    chars = get_available_character_list()
    if series and series != "全部":
        chars = [c for c in chars if c.get("series") == series]
    if keyword:
        kw = keyword.strip().lower()
        if kw:
            chars = [
                c for c in chars
                if kw in c.get("name", "").lower()
                or kw in c.get("display", "").lower()
                or kw in c.get("source", "").lower()
            ]
    return [(format_character_label(c), c["name"]) for c in chars]


def _refresh_downloaded_updates(series: str, keyword: str) -> Tuple[Dict, Dict]:
    series_choices = get_downloaded_character_series()
    if series not in series_choices:
        series = "全部"
    return (
        gr.update(choices=series_choices, value=series),
        gr.update(choices=get_downloaded_character_choices(series, keyword))
    )


def download_character(name: str, selected_series: str = "全部", keyword: str = "") -> Tuple[str, Dict, Dict]:
    """下载角色模型"""
    from tools.character_models import download_character_model

    if not name:
        series_update, choices_update = _refresh_downloaded_updates(selected_series, keyword)
        return "请选择要下载的角色", choices_update, series_update

    try:
        success = download_character_model(name)
        series_update, choices_update = _refresh_downloaded_updates(selected_series, keyword)
        if success:
            return (
                f"✅ {name} 模型下载完成",
                choices_update,
                series_update
            )
        else:
            return (
                f"❌ {name} 模型下载失败",
                choices_update,
                series_update
            )
    except Exception as e:
        series_update, choices_update = _refresh_downloaded_updates(selected_series, keyword)
        return (
            f"❌ 下载失败: {str(e)}",
            choices_update,
            series_update
        )


def download_all_characters(series: str = "全部", selected_series: str = "全部", keyword: str = "") -> Tuple[str, Dict, Dict]:
    """批量下载角色模型"""
    from tools.character_models import download_all_character_models

    try:
        result = download_all_character_models(series=series)
        ok = result.get("success", [])
        failed = result.get("failed", [])
        status = f"✅ 完成: 成功 {len(ok)} 个"
        if failed:
            status += f"，失败 {len(failed)} 个: {', '.join(failed)}"
        series_update, choices_update = _refresh_downloaded_updates(selected_series, keyword)
        return status, choices_update, series_update
    except Exception as e:
        series_update, choices_update = _refresh_downloaded_updates(selected_series, keyword)
        return f"❌ 批量下载失败: {str(e)}", choices_update, series_update


def update_download_choices(series: str, keyword: str) -> Dict:
    """更新下载下拉列表"""
    return gr.update(choices=get_available_character_choices(series, keyword))


def update_downloaded_choices(series: str, keyword: str) -> Dict:
    """更新已下载角色下拉列表"""
    return gr.update(choices=get_downloaded_character_choices(series, keyword))


def refresh_downloaded_controls(series: str, keyword: str) -> Tuple[Dict, Dict]:
    """刷新已下载角色的筛选和列表"""
    return _refresh_downloaded_updates(series, keyword)


def process_cover(
    audio_path: str,
    character_name: str,
    pitch_shift: int,
    index_ratio: float,
    speaker_id: float,
    karaoke_separation: bool,
    karaoke_merge_backing_into_accompaniment: bool,
    vc_preprocess_mode: str,
    source_constraint_mode: str,
    vc_pipeline_mode: str,
    singing_repair: bool,
    vocals_volume: float,
    accompaniment_volume: float,
    reverb_amount: float,
    rms_mix_rate: float,
    backing_mix: float,
    progress=gr.Progress()
) -> Tuple[Optional[str], Optional[str], Optional[str], Optional[str], Optional[str], Optional[str], str]:
    """
    处理翻唱

    Returns:
        Tuple[cover, converted_vocals, original_vocals, lead_vocals, backing_vocals, accompaniment, status]
    """
    _none6 = (None, None, None, None, None, None)
    if audio_path is None:
        return *_none6, "请上传歌曲文件"

    if not character_name:
        return *_none6, "请选择角色"

    try:
        from tools.character_models import get_character_model_path
        from infer.cover_pipeline import get_cover_pipeline

        # 获取角色模型路径
        resolved_name = resolve_character_name(character_name)
        model_info = get_character_model_path(resolved_name)
        if model_info is None:
            return *_none6, f"角色模型不存在: {resolved_name}"

        # 进度回调
        def progress_callback(msg: str, step: int, total: int):
            if total > 0:
                progress(step / total, desc=msg)

        # 获取流水线
        device = config.get("device", "cuda")
        pipeline = get_cover_pipeline(device)

        cover_cfg = config.get("cover", {})
        demucs_model = cover_cfg.get("demucs_model", "htdemucs")
        demucs_shifts = int(cover_cfg.get("demucs_shifts", 2))
        demucs_overlap = float(cover_cfg.get("demucs_overlap", 0.25))
        demucs_split = bool(cover_cfg.get("demucs_split", True))
        separator = cover_cfg.get("separator", "roformer")
        uvr5_model = cover_cfg.get("uvr5_model")
        uvr5_agg = int(cover_cfg.get("uvr5_agg", 10))
        uvr5_format = cover_cfg.get("uvr5_format", "wav")
        use_official = bool(cover_cfg.get("use_official", True))
        f0_method = cover_cfg.get("f0_method", config.get("f0_method", "rmvpe"))
        filter_radius = cover_cfg.get("filter_radius", config.get("filter_radius", 3))
        protect = cover_cfg.get("protect", config.get("protect", 0.33))
        silence_gate = cover_cfg.get("silence_gate", True)
        silence_threshold_db = cover_cfg.get("silence_threshold_db", -40.0)
        silence_smoothing_ms = cover_cfg.get("silence_smoothing_ms", 50.0)
        silence_min_duration_ms = cover_cfg.get("silence_min_duration_ms", 200.0)
        hubert_layer = cover_cfg.get("hubert_layer", config.get("hubert_layer", 12))
        karaoke_model = cover_cfg.get("karaoke_model", "mel_band_roformer_karaoke_gabox.ckpt")
        default_vc_preprocess_mode = str(cover_cfg.get("vc_preprocess_mode", "auto"))
        default_source_constraint_mode = str(cover_cfg.get("source_constraint_mode", "auto"))
        default_vc_pipeline_mode = str(cover_cfg.get("vc_pipeline_mode", "current"))
        default_singing_repair = bool(cover_cfg.get("singing_repair", False))
        vc_label_to_value, vc_value_to_label = get_vc_preprocess_option_maps()
        source_label_to_value, source_value_to_label = get_source_constraint_option_maps()
        pipeline_label_to_value, pipeline_value_to_label = get_vc_pipeline_mode_option_maps()

        vc_preprocess_mode = vc_label_to_value.get(str(vc_preprocess_mode), str(vc_preprocess_mode or default_vc_preprocess_mode).strip().lower())
        if vc_preprocess_mode not in {"auto", "direct", "uvr_deecho", "legacy"}:
            vc_preprocess_mode = default_vc_preprocess_mode
        source_constraint_mode = source_label_to_value.get(str(source_constraint_mode), str(source_constraint_mode or default_source_constraint_mode).strip().lower())
        if source_constraint_mode not in {"auto", "off", "on"}:
            source_constraint_mode = default_source_constraint_mode
        vc_pipeline_mode = pipeline_label_to_value.get(str(vc_pipeline_mode), str(vc_pipeline_mode or default_vc_pipeline_mode).strip().lower())
        if vc_pipeline_mode not in {"current", "official"}:
            vc_pipeline_mode = default_vc_pipeline_mode
        singing_repair = bool(singing_repair if singing_repair is not None else default_singing_repair)

        index_ratio = max(0.0, min(1.0, float(index_ratio) / 100.0))
        speaker_id = int(max(0, round(float(speaker_id))))
        rms_mix_rate = max(0.0, min(1.0, float(rms_mix_rate) / 100.0))
        backing_mix = max(0.0, min(1.0, float(backing_mix) / 100.0))

        # 输出目录
        output_dir = ROOT_DIR / config.get("paths", {}).get(
            "outputs",
            config.get("output_dir", "outputs")
        )

        # 执行翻唱
        result = pipeline.process(
            input_audio=audio_path,
            model_path=model_info["model_path"],
            index_path=model_info.get("index_path"),
            pitch_shift=pitch_shift,
            index_ratio=index_ratio,
            filter_radius=filter_radius,
            rms_mix_rate=rms_mix_rate,
            protect=protect,
            speaker_id=speaker_id,
            f0_method=f0_method,
            demucs_model=demucs_model,
            demucs_shifts=demucs_shifts,
            demucs_overlap=demucs_overlap,
            demucs_split=demucs_split,
            separator=separator,
            uvr5_model=uvr5_model,
            uvr5_agg=uvr5_agg,
            uvr5_format=uvr5_format,
            use_official=use_official,
            hubert_layer=hubert_layer,
            silence_gate=silence_gate,
            silence_threshold_db=silence_threshold_db,
            silence_smoothing_ms=silence_smoothing_ms,
            silence_min_duration_ms=silence_min_duration_ms,
            vocals_volume=vocals_volume / 100,  # 转换为 0-2 范围
            accompaniment_volume=accompaniment_volume / 100,
            reverb_amount=reverb_amount / 100,
            backing_mix=backing_mix,
            karaoke_separation=bool(karaoke_separation),
            karaoke_model=karaoke_model,
            karaoke_merge_backing_into_accompaniment=bool(karaoke_merge_backing_into_accompaniment),
            vc_preprocess_mode=vc_preprocess_mode,
            source_constraint_mode=source_constraint_mode,
            vc_pipeline_mode=vc_pipeline_mode,
            singing_repair=singing_repair,
            output_dir=str(output_dir),
            model_display_name=resolved_name,
            progress_callback=progress_callback
        )

        status_msg = "\u2705 \u7ffb\u5531\u5b8c\u6210!"
        status_msg += f"\n{get_cover_vc_route_status(vc_preprocess_mode, vc_pipeline_mode).splitlines()[0]}"
        status_msg += f"\nVC\u7ba1\u7ebf\u6a21\u5f0f: {pipeline_value_to_label.get(vc_pipeline_mode, vc_pipeline_mode)}"
        status_msg += f"\n唱歌修复: {'开启' if singing_repair else '关闭'}"
        status_msg += f"\n\u6e90\u7ea6\u675f\u7b56\u7565: {source_value_to_label.get(source_constraint_mode, source_constraint_mode)}"
        if result.get("all_files_dir"):
            status_msg += f"\n\u5168\u90e8\u6587\u4ef6\u76ee\u5f55: {result['all_files_dir']}"

        return (
            result["cover"],
            result["converted_vocals"],
            result.get("vocals"),
            result.get("lead_vocals"),
            result.get("backing_vocals"),
            result["accompaniment"],
            status_msg
        )

    except Exception as e:
        import traceback
        error_msg = str(e) if str(e) else traceback.format_exc()
        log.error(f"处理失败: {error_msg}")
        return None, None, None, None, None, None, f"❌ 处理失败: {error_msg}"


def check_mature_deecho_status() -> str:
    """Check mature DeEcho model availability."""
    from tools.download_models import MATURE_DEECHO_MODELS, check_model, get_preferred_mature_deecho_model

    status_lines = []
    preferred = get_preferred_mature_deecho_model()
    for name in MATURE_DEECHO_MODELS:
        exists = check_model(name)
        icon = "✅" if exists else "❌"
        suffix = "  ← 当前自动模式优先使用" if preferred == name else ""
        status_lines.append(f"{icon} {name}{suffix}")

    if preferred:
        status_lines.append("")
        status_lines.append(f"当前可用学习型 DeEcho: {preferred}")
    else:
        status_lines.append("")
        status_lines.append("当前未检测到学习型 DeEcho 模型；翻唱自动模式将回退为主唱直通 RVC")

    return "\n".join(status_lines)


def download_mature_deecho_models_ui() -> str:
    """Download mature DeEcho models."""
    from tools.download_models import download_mature_deecho_models

    try:
        success = download_mature_deecho_models()
        status = check_mature_deecho_status()
        prefix = "✅ 下载完成" if success else "⚠️ 下载过程中存在失败项"
        return f"{prefix}\n\n{status}"
    except Exception as e:
        return f"❌ 下载失败: {str(e)}"


def get_cover_vc_route_status(
    vc_preprocess_mode: Optional[str] = None,
    vc_pipeline_mode: Optional[str] = None,
) -> str:
    """Return the active VC route shown in the cover UI."""
    from tools.download_models import get_preferred_mature_deecho_model

    mode = str(vc_preprocess_mode or config.get("cover", {}).get("vc_preprocess_mode", "auto")).strip().lower()
    pipeline_mode = str(vc_pipeline_mode or config.get("cover", {}).get("vc_pipeline_mode", "current")).strip().lower()
    vc_label_to_value, _ = get_vc_preprocess_option_maps()
    pipeline_label_to_value, _ = get_vc_pipeline_mode_option_maps()
    mode = vc_label_to_value.get(mode, mode)
    pipeline_mode = pipeline_label_to_value.get(pipeline_mode, pipeline_mode)
    preferred = get_preferred_mature_deecho_model()
    newline = chr(10)

    if pipeline_mode == "official":
        return newline.join([
            "当前使用内置官方 RVC 实现",
            "流程：主唱分离 → 官方音频加载 / 官方 VC → 混音",
            "说明：跳过本项目自定义 VC 预处理、源约束与静音门限后处理",
        ])

    if mode == "direct":
        return newline.join([
            "ℹ️ 当前固定为主唱直通 RVC",
            "流程: 主唱分离 → 直接进入 RVC → 混音",
            "说明: 不使用学习型 DeEcho，也不走旧版手工链",
        ])
    if mode == "legacy":
        return newline.join([
            "⚠️ 当前固定为旧版手工链",
            "流程: 主唱分离 → 手工去回声链 → RVC → 混音",
            "说明: 仅用于对比，不是默认推荐路径",
        ])
    if mode == "uvr_deecho":
        if preferred:
            return newline.join([
                "✅ 当前固定优先使用学习型 DeEcho / DeReverb",
                f"当前命中模型: {preferred}",
                "流程: 主唱分离 → UVR DeEcho/DeReverb → RVC → 混音",
            ])
        return newline.join([
            "⚠️ 当前设为官方 DeEcho 优先，但本地缺少模型",
            "当前将回退流程: 主唱分离 → 直接进入 RVC → 混音",
            "建议: 先在模型管理页下载成熟 DeEcho 模型",
        ])

    if preferred:
        return newline.join([
            "✅ 自动模式当前会优先使用学习型 DeEcho / DeReverb",
            f"当前命中模型: {preferred}",
            "流程: 主唱分离 → UVR DeEcho/DeReverb → RVC → 混音",
        ])
    return newline.join([
        "ℹ️ 自动模式当前会回退为主唱直通 RVC",
        "原因: 本地未检测到成熟 DeEcho / DeReverb 模型",
        "流程: 主唱分离 → 直接进入 RVC → 混音",
    ])


def check_models_status() -> str:
    """检查模型状态"""
    from tools.download_models import check_model, REQUIRED_MODELS

    status_lines = []
    for name in REQUIRED_MODELS:
        exists = check_model(name)
        icon = "✅" if exists else "❌"
        status_lines.append(f"{icon} {name}")

    return "\n".join(status_lines)


def get_device_info() -> str:
    """获取设备信息"""
    import torch
    from lib.device import get_device_info as _get_info, _is_rocm, _has_xpu, _has_directml, _has_mps

    lines = []
    lines.append(f"PyTorch 版本: {torch.__version__}")

    info = _get_info()
    lines.append(f"可用后端: {', '.join(info['backends'])}")

    for dev in info["devices"]:
        mem = f"{dev['total_memory_gb']} GB" if dev.get("total_memory_gb") else "N/A"
        lines.append(f"GPU: {dev['name']} ({dev['backend']}) - 显存: {mem}")

    if torch.cuda.is_available():
        ver = torch.version.hip if _is_rocm() else torch.version.cuda
        label = "ROCm" if _is_rocm() else "CUDA"
        lines.append(f"{label} 版本: {ver}")

    if not info["devices"]:
        lines.append("未检测到 GPU，将使用 CPU")

    return "\n".join(lines)


# 自定义 CSS - 深灰 + 橙色强调配色
CUSTOM_CSS = """
/* 深色主题基础 - 纯色背景 */
.gradio-container {
    background: #121212 !important;
    min-height: 100vh;
}

.main-title {
    text-align: center;
    margin-bottom: 1rem;
    color: #e0e0e0 !important;
}

/* 状态框样式 */
.status-box {
    font-family: 'Consolas', 'Monaco', monospace;
    white-space: pre-wrap;
    background: #1e1e1e !important;
    border: 1px solid #404040 !important;
    color: #9e9e9e !important;
}

/* 提示框 */
.model-hint {
    padding: 1rem;
    background: #1e1e1e !important;
    border: 1px solid #404040 !important;
    border-radius: 8px;
    margin: 1rem 0;
    color: #e0e0e0 !important;
}

/* 成功/错误消息 */
.success-msg {
    color: #4caf50 !important;
    font-weight: bold;
}
.error-msg {
    color: #f44336 !important;
    font-weight: bold;
}

/* 标签页样式 */
.tabs > .tab-nav {
    background: #1e1e1e !important;
    border-bottom: 1px solid #404040 !important;
}
.tabs > .tab-nav > button {
    color: #9e9e9e !important;
    background: transparent !important;
    border: none !important;
    padding: 12px 24px !important;
    transition: color 0.2s ease !important;
}
.tabs > .tab-nav > button:hover {
    color: #e0e0e0 !important;
}
.tabs > .tab-nav > button.selected {
    color: #ff9800 !important;
    border-bottom: 2px solid #ff9800 !important;
    background: transparent !important;
}

/* 输入框和下拉框 */
.gr-input, .gr-dropdown, textarea, input[type="text"] {
    background: #2d2d2d !important;
    border: 1px solid #404040 !important;
    color: #e0e0e0 !important;
}
.gr-input:focus, .gr-dropdown:focus, textarea:focus, input[type="text"]:focus {
    border-color: #ff9800 !important;
    outline: none !important;
}

/* 滑块 */
.gr-slider input[type="range"] {
    background: #404040 !important;
}
.gr-slider input[type="range"]::-webkit-slider-thumb {
    background: #ff9800 !important;
}
.gr-slider input[type="range"]::-moz-range-thumb {
    background: #ff9800 !important;
}
input[type="range"]::-webkit-slider-runnable-track {
    background: #404040 !important;
}
input[type="range"]::-moz-range-track {
    background: #404040 !important;
}

/* 按钮样式 - 主按钮橙色 */
.gr-button-primary, button.primary {
    background: #ff9800 !important;
    border: none !important;
    color: #121212 !important;
    font-weight: 600 !important;
    transition: all 0.2s ease !important;
}
.gr-button-primary:hover, button.primary:hover {
    background: #ffa726 !important;
    transform: translateY(-1px) !important;
    box-shadow: 0 4px 12px rgba(255, 152, 0, 0.3) !important;
}
.gr-button-primary:active, button.primary:active {
    background: #f57c00 !important;
    transform: translateY(0) !important;
}

/* 次要按钮 */
.gr-button-secondary, button.secondary {
    background: #404040 !important;
    border: none !important;
    color: #e0e0e0 !important;
    transition: all 0.2s ease !important;
}
.gr-button-secondary:hover, button.secondary:hover {
    background: #4a4a4a !important;
}

/* 音频播放器 */
.gr-audio {
    background: #1e1e1e !important;
    border: 1px solid #404040 !important;
    border-radius: 8px !important;
}
.gr-audio audio {
    background: #1e1e1e !important;
    color: #e0e0e0 !important;
    accent-color: #ff9800 !important;
}
.gr-audio audio::-webkit-media-controls-panel {
    background: #1e1e1e !important;
}
.gr-audio audio::-webkit-media-controls-enclosure {
    background: #1e1e1e !important;
}
.gr-audio audio::-webkit-media-controls-timeline {
    background: #404040 !important;
}
.gr-audio audio::-webkit-media-controls-current-time-display,
.gr-audio audio::-webkit-media-controls-time-remaining-display {
    color: #e0e0e0 !important;
}
.gr-audio audio::-webkit-media-controls-play-button,
.gr-audio audio::-webkit-media-controls-mute-button,
.gr-audio audio::-webkit-media-controls-volume-slider {
    filter: invert(1) sepia(1) saturate(5) hue-rotate(10deg) !important;
}

/* 折叠面板 */
.gr-accordion {
    background: #1e1e1e !important;
    border: 1px solid #404040 !important;
    border-radius: 8px !important;
}
.gr-accordion > .label-wrap {
    background: #1e1e1e !important;
}

/* 表格 */
.gr-dataframe {
    background: #1e1e1e !important;
}
.gr-dataframe table {
    color: #e0e0e0 !important;
}
.gr-dataframe th {
    background: #2d2d2d !important;
    color: #9e9e9e !important;
}
.gr-dataframe td {
    background: #1e1e1e !important;
    border-color: #404040 !important;
}
.gr-dataframe tr:hover td {
    background: #333333 !important;
}
/* Gradio v4 Dataframe */
div[data-testid="dataframe"] {
    background: #1e1e1e !important;
    color: #e0e0e0 !important;
    border: 1px solid #404040 !important;
}
div[data-testid="dataframe"] table {
    color: #e0e0e0 !important;
}
div[data-testid="dataframe"] thead th {
    background: #2d2d2d !important;
    color: #9e9e9e !important;
    border-color: #404040 !important;
}
div[data-testid="dataframe"] tbody td {
    background: #1e1e1e !important;
    color: #e0e0e0 !important;
    border-color: #404040 !important;
}
div[data-testid="dataframe"] tbody tr:hover td {
    background: #333333 !important;
}
div[data-testid="dataframe"] input,
div[data-testid="dataframe"] textarea {
    background: #1e1e1e !important;
    color: #e0e0e0 !important;
    border: 1px solid #404040 !important;
}

/* Markdown 文本 */
.prose {
    color: #e0e0e0 !important;
}
.prose h1, .prose h2, .prose h3, .prose h4 {
    color: #e0e0e0 !important;
}
.prose a {
    color: #ff9800 !important;
}
.prose a:hover {
    color: #ffa726 !important;
}
.prose code {
    background: #2d2d2d !important;
    color: #ff9800 !important;
    padding: 2px 6px !important;
    border-radius: 4px !important;
}
.prose blockquote {
    border-left: 3px solid #ff9800 !important;
    background: #1e1e1e !important;
    padding: 8px 16px !important;
    color: #9e9e9e !important;
}

/* 单选按钮和复选框 */
.gr-radio label, .gr-checkbox label {
    color: #e0e0e0 !important;
}
input[type="radio"]:checked + label, input[type="checkbox"]:checked + label {
    color: #ff9800 !important;
}

/* 进度条 */
.progress-bar {
    background: #404040 !important;
}
.progress-bar > div {
    background: #ff9800 !important;
}

/* 分隔线 */
hr {
    border-color: #404040 !important;
}

/* 标签 */
label {
    color: #9e9e9e !important;
}

/* 信息文本 */
.gr-info {
    color: #9e9e9e !important;
}

/* 块/面板背景 */
.gr-block, .gr-box, .gr-panel {
    background: #1e1e1e !important;
    border-color: #404040 !important;
}

/* 下拉菜单选项 */
.gr-dropdown option, select option {
    background: #2d2d2d !important;
    color: #e0e0e0 !important;
}

/* Gradio 下拉选择器完整样式 */
.gr-dropdown, .gr-dropdown select,
div[data-testid="dropdown"],
.dropdown-container,
.svelte-select,
.wrap-inner,
.secondary-wrap {
    background: #2d2d2d !important;
    border: 1px solid #404040 !important;
    color: #e0e0e0 !important;
}

/* 下拉选择器输入框 */
.gr-dropdown input,
div[data-testid="dropdown"] input,
.svelte-select input {
    background: #2d2d2d !important;
    color: #e0e0e0 !important;
    border: none !important;
}

/* 下拉菜单列表 */
.gr-dropdown ul,
.gr-dropdown .options,
div[data-testid="dropdown"] ul,
.svelte-select .listContainer,
.dropdown-menu,
ul[role="listbox"] {
    background: #2d2d2d !important;
    border: 1px solid #404040 !important;
    color: #e0e0e0 !important;
}

/* 下拉菜单选项 */
.gr-dropdown li,
.gr-dropdown .option,
div[data-testid="dropdown"] li,
.svelte-select .listItem,
li[role="option"] {
    background: #2d2d2d !important;
    color: #e0e0e0 !important;
}

/* 下拉菜单选项悬停 */
.gr-dropdown li:hover,
.gr-dropdown .option:hover,
div[data-testid="dropdown"] li:hover,
.svelte-select .listItem:hover,
.svelte-select .listItem.hover,
li[role="option"]:hover {
    background: #404040 !important;
    color: #ff9800 !important;
}

/* 下拉菜单选中项 */
.gr-dropdown li.selected,
.gr-dropdown .option.selected,
.svelte-select .listItem.active,
li[role="option"][aria-selected="true"] {
    background: #333333 !important;
    color: #ff9800 !important;
}

/* 下拉箭头图标 */
.gr-dropdown svg,
div[data-testid="dropdown"] svg,
.svelte-select .indicator svg {
    fill: #9e9e9e !important;
    color: #9e9e9e !important;
}

/* Gradio 3.x 特定选择器样式 */
.wrap.svelte-1m1zvyj,
.wrap-inner.svelte-1m1zvyj,
.secondary-wrap.svelte-1m1zvyj {
    background: #2d2d2d !important;
    border-color: #404040 !important;
}

.dropdown.svelte-1m1zvyj,
.options.svelte-1m1zvyj {
    background: #2d2d2d !important;
    border: 1px solid #404040 !important;
}

.item.svelte-1m1zvyj {
    background: #2d2d2d !important;
    color: #e0e0e0 !important;
}

.item.svelte-1m1zvyj:hover,
.item.svelte-1m1zvyj.active {
    background: #404040 !important;
    color: #ff9800 !important;
}

/* 单选按钮组样式 */
.gr-radio,
.gr-radio-group,
div[data-testid="radio"] {
    background: transparent !important;
}

.gr-radio label span,
div[data-testid="radio"] label span {
    color: #e0e0e0 !important;
}

.gr-radio input[type="radio"],
div[data-testid="radio"] input[type="radio"] {
    accent-color: #ff9800 !important;
}

/* Radio 按钮容器 */
.radio-group,
.gr-radio-row {
    background: #1e1e1e !important;
}

.radio-group label,
.gr-radio-row label {
    background: #2d2d2d !important;
    border: 1px solid #404040 !important;
    color: #e0e0e0 !important;
}

.radio-group label:hover,
.gr-radio-row label:hover {
    background: #333333 !important;
}

.radio-group label.selected,
.gr-radio-row label.selected,
.radio-group input:checked + label,
.gr-radio-row input:checked + label {
    background: #333333 !important;
    border-color: #ff9800 !important;
    color: #ff9800 !important;
}

/* 滚动条样式 */
::-webkit-scrollbar {
    width: 8px;
    height: 8px;
}
::-webkit-scrollbar-track {
    background: #1e1e1e;
}
::-webkit-scrollbar-thumb {
    background: #404040;
    border-radius: 4px;
}
::-webkit-scrollbar-thumb:hover {
    background: #4a4a4a;
}

/* Dataframe 表头修复 - 强制深色主题 */
table thead th,
table thead td,
.table-wrap thead th,
.table-wrap thead td,
[data-testid="table"] thead th,
[data-testid="table"] thead td {
    background: #2d2d2d !important;
    color: #ff9800 !important;
    border-color: #404040 !important;
}

/* Gradio 4.x Dataframe 表头 */
.svelte-1kcgrqr thead th,
.svelte-1kcgrqr thead td,
.cell-wrap span,
th .cell-wrap,
th span.svelte-1kcgrqr {
    background: #2d2d2d !important;
    color: #ff9800 !important;
}

/* 音频播放器进度条修复 */
audio::-webkit-media-controls-timeline {
    background: linear-gradient(to right, #ff9800 var(--buffered-width, 0%), #404040 var(--buffered-width, 0%)) !important;
    border-radius: 4px !important;
    height: 4px !important;
}

/* 音频播放器 - Gradio 组件内部 */
.audio-container input[type="range"],
.waveform-container input[type="range"],
div[data-testid="audio"] input[type="range"],
div[data-testid="waveform"] input[type="range"] {
    accent-color: #ff9800 !important;
}

/* WaveSurfer 波形进度条 */
.wavesurfer-region,
.wavesurfer-handle,
wave > wave {
    background: #ff9800 !important;
}

/* Gradio Audio 组件进度条 */
.audio-player input[type="range"]::-webkit-slider-runnable-track {
    background: linear-gradient(to right, #ff9800 0%, #ff9800 var(--value, 0%), #404040 var(--value, 0%), #404040 100%) !important;
}

.audio-player input[type="range"]::-moz-range-track {
    background: linear-gradient(to right, #ff9800 0%, #ff9800 var(--value, 0%), #404040 var(--value, 0%), #404040 100%) !important;
}

.audio-player input[type="range"]::-webkit-slider-thumb {
    background: #ff9800 !important;
}

.audio-player input[type="range"]::-moz-range-thumb {
    background: #ff9800 !important;
}

/* 通用 range input 进度样式 */
input[type="range"] {
    accent-color: #ff9800 !important;
}

/* Gradio 4.x 音频波形 */
.waveform-container,
.audio-container {
    --waveform-color: #ff9800 !important;
    --progress-color: #ff9800 !important;
}
"""


def create_ui() -> gr.Blocks:
    """创建 Gradio 界面"""

    with gr.Blocks(
        title=i18n.get("app_title", "RVC AI 翻唱"),
        theme=gr.themes.Base(
            primary_hue="orange",
            secondary_hue="gray",
            neutral_hue="gray",
        ).set(
            # 背景色
            body_background_fill="#121212",
            body_background_fill_dark="#121212",
            # 面板/卡片背景
            block_background_fill="#1e1e1e",
            block_background_fill_dark="#1e1e1e",
            # 边框
            block_border_color="#404040",
            block_border_color_dark="#404040",
            # 标签背景
            block_label_background_fill="#2d2d2d",
            block_label_background_fill_dark="#2d2d2d",
            # 标签文字
            block_label_text_color="#9e9e9e",
            block_label_text_color_dark="#9e9e9e",
            # 标题文字
            block_title_text_color="#e0e0e0",
            block_title_text_color_dark="#e0e0e0",
            # 输入框
            input_background_fill="#2d2d2d",
            input_background_fill_dark="#2d2d2d",
            input_border_color="#404040",
            input_border_color_dark="#404040",
            # 主按钮 - 橙色
            button_primary_background_fill="#ff9800",
            button_primary_background_fill_dark="#ff9800",
            button_primary_background_fill_hover="#ffa726",
            button_primary_background_fill_hover_dark="#ffa726",
            button_primary_text_color="#121212",
            button_primary_text_color_dark="#121212",
            # 次要按钮 - 深灰
            button_secondary_background_fill="#404040",
            button_secondary_background_fill_dark="#404040",
            button_secondary_background_fill_hover="#4a4a4a",
            button_secondary_background_fill_hover_dark="#4a4a4a",
            button_secondary_text_color="#e0e0e0",
            button_secondary_text_color_dark="#e0e0e0",
            # 文字颜色
            body_text_color="#e0e0e0",
            body_text_color_dark="#e0e0e0",
            body_text_color_subdued="#9e9e9e",
            body_text_color_subdued_dark="#9e9e9e",
            # 链接颜色 - 橙色
            link_text_color="#ff9800",
            link_text_color_dark="#ff9800",
            link_text_color_hover="#ffa726",
            link_text_color_hover_dark="#ffa726",
            # 滑块颜色
            slider_color="#ff9800",
            slider_color_dark="#ff9800",
            # 复选框/单选框
            checkbox_background_color="#2d2d2d",
            checkbox_background_color_dark="#2d2d2d",
            checkbox_border_color="#404040",
            checkbox_border_color_dark="#404040",
            checkbox_label_text_color="#e0e0e0",
            checkbox_label_text_color_dark="#e0e0e0",
        ),
        css=CUSTOM_CSS
    ) as app:

        # 标题
        gr.Markdown(
            f"# 🎤 {i18n.get('app_title', 'RVC AI 翻唱')}",
            elem_classes=["main-title"]
        )
        gr.Markdown(
            f"<center>{i18n.get('app_description', '基于 RVC v2 的 AI 翻唱系统')}</center>"
        )

        with gr.Tabs():
            # ===== 模型管理标签页 =====
            with gr.Tab(t("models", "tabs")):
                gr.Markdown(f"### 📦 {t('base_models', 'models')}")
                gr.Markdown(t("base_models_desc", "models"))

                with gr.Row():
                    check_btn = gr.Button(
                        f"🔍 {t('check_status', 'models')}",
                        variant="secondary"
                    )
                    download_btn = gr.Button(
                        f"⬇️ {t('download_required', 'models')}",
                        variant="primary"
                    )

                model_status = gr.Textbox(
                    label=t("model_status", "models"),
                    interactive=False,
                    lines=6,
                    elem_classes=["status-box"]
                )

                check_btn.click(
                    fn=check_models_status,
                    outputs=[model_status]
                )

                download_btn.click(
                    fn=download_base_models,
                    outputs=[model_status]
                )

                gr.Markdown("---")
                gr.Markdown(f"### 🎛️ {t('mature_deecho_models', 'models')}")
                gr.Markdown(t("mature_deecho_models_desc", "models"))

                with gr.Row():
                    mature_deecho_check_btn = gr.Button(
                        f"🔍 {t('mature_deecho_check', 'models')}",
                        variant="secondary"
                    )
                    mature_deecho_download_btn = gr.Button(
                        f"⬇️ {t('download_mature_deecho', 'models')}",
                        variant="primary"
                    )

                mature_deecho_status = gr.Textbox(
                    label=t("mature_deecho_status", "models"),
                    interactive=False,
                    lines=7,
                    value=check_mature_deecho_status(),
                    elem_classes=["status-box"]
                )

                gr.Markdown("---")

                gr.Markdown(f"### 🎤 {t('voice_models', 'models')}")
                gr.Markdown(t("voice_models_desc", "models"))

                def get_model_table():
                    from infer.pipeline import list_voice_models
                    weights_dir = ROOT_DIR / config.get("weights_dir", "assets/weights")
                    models = list_voice_models(str(weights_dir))
                    if not models:
                        return [["(无模型)", "", ""]]
                    return [[m["name"], m["model_path"], m.get("index_path", "无")] for m in models]

                model_table = gr.Dataframe(
                    headers=["模型名称", "模型路径", "索引路径"],
                    value=get_model_table(),
                    interactive=False
                )

                refresh_table_btn = gr.Button(
                    f"🔄 刷新模型列表",
                    variant="secondary"
                )

                refresh_table_btn.click(
                    fn=get_model_table,
                    outputs=[model_table]
                )

            # ===== 歌曲翻唱标签页 =====
            with gr.Tab(t("cover", "tabs")):
                gr.Markdown(f"### 🎵 {t('song_cover', 'cover')}")
                gr.Markdown(
                    """
                    **一键 AI 翻唱**：上传歌曲 → 自动分离人声 → 转换音色 → 混合伴奏 → 输出翻唱

                    **使用步骤：**
                    1. 先下载角色模型（展开下方「下载角色模型」）
                    2. 上传歌曲文件（支持 MP3/WAV/FLAC）
                    3. 选择已下载的角色
                    4. 调整参数后点击「开始翻唱」

                    > ⚠️ 首次运行会自动下载 Mel-Band Roformer 人声分离模型（约 200MB），请耐心等待
                    """
                )

                with gr.Row():
                    # 左侧：输入和角色选择
                    with gr.Column(scale=1):
                        gr.Markdown(f"#### 📁 {t('upload_song', 'cover')}")
                        cover_input_audio = gr.Audio(
                            label=t("input_song", "cover"),
                            type="filepath"
                        )

                        gr.Markdown(f"#### 🎭 {t('select_character', 'cover')}")

                        downloaded_series = gr.Dropdown(
                            label="作品/分类",
                            choices=get_downloaded_character_series(),
                            value="全部",
                            interactive=True
                        )

                        downloaded_keyword = gr.Textbox(
                            label="关键词搜索",
                            placeholder="输入角色名/作品名",
                            interactive=True
                        )

                        character_dropdown = gr.Dropdown(
                            label="选择角色",
                            choices=get_downloaded_character_choices("全部", ""),
                            interactive=True,
                            info="括号中的信息为模型训练参数：epochs=训练轮数(越大通常越成熟)，数字+k=训练采样率(如40k=40000Hz)"
                        )

                        with gr.Row():
                            refresh_char_btn = gr.Button(
                                "🔄 刷新",
                                size="sm",
                                variant="secondary"
                            )

                        # 角色下载区域
                        with gr.Accordion("下载角色模型", open=False):
                            series_choices = ["全部"] + get_available_character_series()
                            download_series = gr.Dropdown(
                                label="作品/分类",
                                choices=series_choices,
                                value="全部",
                                interactive=True
                            )

                            download_keyword = gr.Textbox(
                                label="关键词搜索",
                                placeholder="输入角色名/作品名",
                                interactive=True
                            )

                            download_char_dropdown = gr.Dropdown(
                                label="选择角色",
                                choices=get_available_character_choices("全部", ""),
                                interactive=True
                            )

                            download_char_btn = gr.Button(
                                "⬇️ 下载选中角色",
                                variant="primary"
                            )

                            download_all_series_btn = gr.Button(
                                "⬇️ 下载该分类全部",
                                variant="secondary"
                            )

                            download_all_btn = gr.Button(
                                "⬇️ 下载全部角色模型",
                                variant="secondary"
                            )

                            download_char_status = gr.Textbox(
                                label="下载状态",
                                interactive=False
                            )

                    # 右侧：参数设置
                    with gr.Column(scale=1):
                        gr.Markdown(f"#### ⚙️ {t('conversion_settings', 'cover')}")
                        cover_cfg = config.get("cover", {})

                        cover_pitch_shift = gr.Slider(
                            label=t("pitch_shift", "cover"),
                            minimum=-12,
                            maximum=12,
                            value=0,
                            step=1,
                            info="正数升调，负数降调"
                        )

                        cover_index_rate = gr.Slider(
                            label=t("index_rate", "cover"),
                            minimum=0,
                            maximum=100,
                            value=_to_int(
                                round(
                                    _to_float(
                                        cover_cfg.get("index_rate", config.get("index_rate", 0.35)),
                                        0.35,
                                    ) * 100
                                ),
                                35,
                            ),
                            step=5,
                            info=t("index_rate_info", "cover"),
                        )

                        cover_speaker_id = gr.Slider(
                            label=t("speaker_id", "cover"),
                            minimum=0,
                            maximum=255,
                            value=_to_int(cover_cfg.get("speaker_id", 0), 0),
                            step=1,
                            info=t("speaker_id_info", "cover"),
                        )

                        gr.Markdown(f"#### 🎚️ {t('mix_settings', 'cover')}")
                        cover_karaoke = gr.Checkbox(
                            label=t("karaoke_separation", "cover"),
                            value=bool(cover_cfg.get("karaoke_separation", True)),
                            info=t("karaoke_separation_info", "cover")
                        )
                        cover_karaoke_merge_backing = gr.Checkbox(
                            label=t("karaoke_merge_backing", "cover"),
                            value=bool(
                                cover_cfg.get(
                                    "karaoke_merge_backing_into_accompaniment",
                                    True
                                )
                            ),
                            info=t("karaoke_merge_backing_info", "cover")
                        )

                        vc_label_to_value, vc_value_to_label = get_vc_preprocess_option_maps()
                        source_label_to_value, source_value_to_label = get_source_constraint_option_maps()
                        pipeline_label_to_value, pipeline_value_to_label = get_vc_pipeline_mode_option_maps()

                        cover_vc_preprocess_mode = gr.Dropdown(
                            label=t("vc_preprocess_mode", "cover"),
                            choices=list(vc_label_to_value.keys()),
                            value=vc_value_to_label.get(str(cover_cfg.get("vc_preprocess_mode", "auto")), list(vc_label_to_value.keys())[0]),
                            info=t("vc_preprocess_mode_info", "cover"),
                        )

                        cover_source_constraint_mode = gr.Dropdown(
                            label=t("source_constraint_mode", "cover"),
                            choices=list(source_label_to_value.keys()),
                            value=source_value_to_label.get(str(cover_cfg.get("source_constraint_mode", "auto")), list(source_label_to_value.keys())[0]),
                            info=t("source_constraint_mode_info", "cover"),
                        )
                        cover_vc_pipeline_mode = gr.Dropdown(
                            label=t("vc_pipeline_mode", "cover"),
                            choices=list(pipeline_label_to_value.keys()),
                            value=pipeline_value_to_label.get(str(cover_cfg.get("vc_pipeline_mode", "current")), list(pipeline_label_to_value.keys())[0]),
                            info=t("vc_pipeline_mode_info", "cover"),
                        )
                        cover_singing_repair = gr.Checkbox(
                            label=t("singing_repair", "cover"),
                            value=bool(cover_cfg.get("singing_repair", False)),
                            info=t("singing_repair_info", "cover"),
                            visible=str(cover_cfg.get("vc_pipeline_mode", "current")).strip().lower() == "official",
                        )

                        cover_vc_route_status = gr.Textbox(
                            label=t("vc_preprocess_status", "cover"),
                            value=get_cover_vc_route_status(
                                cover_cfg.get("vc_preprocess_mode", "auto"),
                                cover_cfg.get("vc_pipeline_mode", "current"),
                            ),
                            info=t("vc_preprocess_status_info", "cover"),
                            interactive=False,
                            lines=3,
                            elem_classes=["status-box"]
                        )

                        mix_presets, default_mix_preset = get_cover_mix_presets()
                        default_mix = mix_presets[default_mix_preset]

                        cover_mix_preset = gr.Dropdown(
                            label=t("mix_preset", "cover"),
                            choices=list(mix_presets.keys()),
                            value=default_mix_preset,
                            info=t("mix_preset_info", "cover"),
                            interactive=True
                        )

                        cover_vocals_volume = gr.Slider(
                            label=t("vocals_volume", "cover"),
                            minimum=0,
                            maximum=200,
                            value=default_mix["vocals_volume"],
                            step=5,
                            info="100% 为原始音量"
                        )

                        cover_accompaniment_volume = gr.Slider(
                            label=t("accompaniment_volume", "cover"),
                            minimum=0,
                            maximum=200,
                            value=default_mix["accompaniment_volume"],
                            step=5,
                            info="100% 为原始音量"
                        )

                        cover_reverb = gr.Slider(
                            label=t("vocals_reverb", "cover"),
                            minimum=0,
                            maximum=100,
                            value=default_mix["reverb"],
                            step=5,
                            info="为人声添加混响效果"
                        )

                        cover_rms_mix_rate = gr.Slider(
                            label=t("rms_mix_rate", "cover"),
                            minimum=0,
                            maximum=100,
                            value=_to_int(
                                round(
                                    _to_float(
                                        cover_cfg.get(
                                            "rms_mix_rate",
                                            config.get("rms_mix_rate", 0.15),
                                        ),
                                        0.15,
                                    ) * 100
                                ),
                                15,
                            ),
                            step=5,
                            info=t("rms_mix_rate_info", "cover"),
                        )

                        cover_backing_mix = gr.Slider(
                            label=t("backing_mix", "cover"),
                            minimum=0,
                            maximum=100,
                            value=_to_int(
                                round(_to_float(cover_cfg.get("backing_mix", 0.0), 0.0) * 100),
                                0,
                            ),
                            step=5,
                            info=t("backing_mix_info", "cover"),
                        )

                # 开始按钮
                cover_btn = gr.Button(
                    f"🚀 {t('start_cover', 'cover')}",
                    variant="primary",
                    size="lg"
                )

                # 状态显示
                cover_status = gr.Textbox(
                    label=t("progress", "cover"),
                    interactive=False,
                    elem_classes=["status-box"]
                )

                # 输出区域
                gr.Markdown(f"#### 🎵 {t('results', 'cover')}")

                with gr.Row():
                    cover_output = gr.Audio(
                        label=t("final_cover", "cover"),
                        type="filepath",
                        interactive=False
                    )

                with gr.Row():
                    cover_converted_vocals_output = gr.Audio(
                        label=t("converted_vocals", "cover"),
                        type="filepath",
                        interactive=False
                    )
                    cover_original_vocals_output = gr.Audio(
                        label=t("original_vocals", "cover"),
                        type="filepath",
                        interactive=False
                    )

                with gr.Row():
                    cover_lead_vocals_output = gr.Audio(
                        label=t("lead_vocals", "cover"),
                        type="filepath",
                        interactive=False
                    )
                    cover_backing_vocals_output = gr.Audio(
                        label=t("backing_vocals", "cover"),
                        type="filepath",
                        interactive=False
                    )

                with gr.Row():
                    cover_accompaniment_output = gr.Audio(
                        label=t("accompaniment", "cover"),
                        type="filepath",
                        interactive=False
                    )

                # 事件绑定
                refresh_char_btn.click(
                    fn=refresh_downloaded_controls,
                    inputs=[downloaded_series, downloaded_keyword],
                    outputs=[downloaded_series, character_dropdown]
                )

                downloaded_series.change(
                    fn=update_downloaded_choices,
                    inputs=[downloaded_series, downloaded_keyword],
                    outputs=[character_dropdown]
                )

                downloaded_keyword.change(
                    fn=update_downloaded_choices,
                    inputs=[downloaded_series, downloaded_keyword],
                    outputs=[character_dropdown]
                )

                download_series.change(
                    fn=update_download_choices,
                    inputs=[download_series, download_keyword],
                    outputs=[download_char_dropdown]
                )

                download_keyword.change(
                    fn=update_download_choices,
                    inputs=[download_series, download_keyword],
                    outputs=[download_char_dropdown]
                )

                download_char_btn.click(
                    fn=download_character,
                    inputs=[download_char_dropdown, downloaded_series, downloaded_keyword],
                    outputs=[download_char_status, character_dropdown, downloaded_series]
                )

                download_all_series_btn.click(
                    fn=download_all_characters,
                    inputs=[download_series, downloaded_series, downloaded_keyword],
                    outputs=[download_char_status, character_dropdown, downloaded_series]
                )

                download_all_btn.click(
                    fn=lambda series, keyword: download_all_characters("全部", series, keyword),
                    inputs=[downloaded_series, downloaded_keyword],
                    outputs=[download_char_status, character_dropdown, downloaded_series]
                )

                cover_mix_preset.change(
                    fn=apply_cover_mix_preset,
                    inputs=[cover_mix_preset],
                    outputs=[
                        cover_vocals_volume,
                        cover_accompaniment_volume,
                        cover_reverb
                    ]
                )

                mature_deecho_check_btn.click(
                    fn=check_mature_deecho_status,
                    outputs=[mature_deecho_status]
                )
                mature_deecho_check_btn.click(
                    fn=get_cover_vc_route_status,
                    inputs=[cover_vc_preprocess_mode, cover_vc_pipeline_mode],
                    outputs=[cover_vc_route_status]
                )

                mature_deecho_download_btn.click(
                    fn=download_mature_deecho_models_ui,
                    outputs=[mature_deecho_status]
                )
                mature_deecho_download_btn.click(
                    fn=get_cover_vc_route_status,
                    inputs=[cover_vc_preprocess_mode, cover_vc_pipeline_mode],
                    outputs=[cover_vc_route_status]
                )

                cover_vc_preprocess_mode.change(
                    fn=get_cover_vc_route_status,
                    inputs=[cover_vc_preprocess_mode, cover_vc_pipeline_mode],
                    outputs=[cover_vc_route_status]
                )

                cover_vc_pipeline_mode.change(
                    fn=get_cover_vc_route_status,
                    inputs=[cover_vc_preprocess_mode, cover_vc_pipeline_mode],
                    outputs=[cover_vc_route_status]
                )
                cover_vc_pipeline_mode.change(
                    fn=update_singing_repair_visibility,
                    inputs=[cover_vc_pipeline_mode],
                    outputs=[cover_singing_repair]
                )

                cover_btn.click(
                    fn=process_cover,
                    inputs=[
                        cover_input_audio,
                        character_dropdown,
                        cover_pitch_shift,
                        cover_index_rate,
                        cover_speaker_id,
                        cover_karaoke,
                        cover_karaoke_merge_backing,
                        cover_vc_preprocess_mode,
                        cover_source_constraint_mode,
                        cover_vc_pipeline_mode,
                        cover_singing_repair,
                        cover_vocals_volume,
                        cover_accompaniment_volume,
                        cover_reverb,
                        cover_rms_mix_rate,
                        cover_backing_mix,
                    ],
                    outputs=[
                        cover_output,
                        cover_converted_vocals_output,
                        cover_original_vocals_output,
                        cover_lead_vocals_output,
                        cover_backing_vocals_output,
                        cover_accompaniment_output,
                        cover_status
                    ]
                )

            # ===== 设置标签页 =====
            with gr.Tab(t("settings", "tabs")):
                gr.Markdown(f"### 💻 {t('device_info', 'settings')}")

                device_info = gr.Textbox(
                    label=t("current_device", "settings"),
                    value=get_device_info(),
                    interactive=False,
                    lines=5,
                    elem_classes=["status-box"]
                )

                refresh_device_btn = gr.Button(
                    f"🔄 {t('refresh_device', 'settings')}",
                    variant="secondary"
                )

                refresh_device_btn.click(
                    fn=get_device_info,
                    outputs=[device_info]
                )

                gr.Markdown("---")

                gr.Markdown(f"### ⚙️ 运行设置")

                def _build_device_choices():
                    from lib.device import _has_xpu, _has_directml, _has_mps, _is_rocm
                    import torch
                    choices = []
                    if torch.cuda.is_available():
                        label = "ROCm (AMD GPU)" if _is_rocm() else "CUDA (NVIDIA GPU)"
                        choices.append((label, "cuda"))
                    if _has_xpu():
                        choices.append(("XPU (Intel GPU)", "xpu"))
                    if _has_directml():
                        choices.append(("DirectML (AMD/Intel GPU)", "directml"))
                    if _has_mps():
                        choices.append(("MPS (Apple GPU)", "mps"))
                    choices.append(("CPU (较慢)", "cpu"))
                    return choices

                device_radio = gr.Radio(
                    label="计算设备",
                    choices=_build_device_choices(),
                    value=config.get("device", "cuda")
                )

                save_settings_btn = gr.Button(
                    "💾 保存设置",
                    variant="primary"
                )

                settings_status = gr.Textbox(
                    label="状态",
                    interactive=False
                )

                def save_settings(device):
                    global config
                    config["device"] = device

                    config_path = ROOT_DIR / "configs" / "config.json"
                    with open(config_path, "w", encoding="utf-8") as f:
                        json.dump(config, f, indent=4, ensure_ascii=False)

                    return "✅ 设置已保存，重启后生效"

                save_settings_btn.click(
                    fn=save_settings,
                    inputs=[device_radio],
                    outputs=[settings_status]
                )

                gr.Markdown("---")

                gr.Markdown(f"### ℹ️ {t('about', 'settings')}")
                gr.Markdown(
                    """
                    **RVC AI 翻唱系统**

                    - 基于 RVC v2 + Mel-Band Roformer
                    - 使用 RMVPE 进行高质量 F0 提取
                    - 支持 CUDA GPU 加速

                    [GitHub](https://github.com/RVC-Project/Retrieval-based-Voice-Conversion-WebUI)
                    """
                )

                gr.Markdown("---")

                gr.Markdown(
                    """
                    ### 📥 角色模型来源

                    以下是本项目角色模型的 HuggingFace 仓库来源，你也可以手动下载模型后放入 `assets/weights/characters/<角色名>/` 目录使用：

                    **Love Live! 系列**
                    - [trioskosmos/rvc_models](https://huggingface.co/trioskosmos/rvc_models) — μ's / Aqours / 虹咲 / Liella! 多角色
                    - [Icchan/LoveLive](https://huggingface.co/Icchan/LoveLive) — 千歌、梨子、绘里、曜
                    - [0xMifune/LoveLive](https://huggingface.co/0xMifune/LoveLive) — 虹咲 / Liella! / 莲之空
                    - [Swordsmagus/Love-Live-RVC](https://huggingface.co/Swordsmagus/Love-Live-RVC) — 花丸、雪菜、小鸟、A-RISE 等
                    - [Zurakichi/RVC](https://huggingface.co/Zurakichi/RVC) — 妮可、彼方、雪菜、花丸
                    - [Phos252/RVCmodels](https://huggingface.co/Phos252/RVCmodels) — 涩谷香音
                    - [ChocoKat/Mari_Ohara](https://huggingface.co/ChocoKat/Mari_Ohara) — 小原鞠莉
                    - [HarunaKasuga/YoshikoTsushima](https://huggingface.co/HarunaKasuga/YoshikoTsushima) — 津岛善子
                    - [thebuddyadrian/RVC_Models](https://huggingface.co/thebuddyadrian/RVC_Models) — 鹿角姐妹

                    **原神 / 崩坏 / 绝区零 (米哈游)**
                    - [makiligon/RVC-Models](https://huggingface.co/makiligon/RVC-Models) — 芙宁娜、绫华、芙卡洛斯
                    - [kohaku12/RVC-MODELS](https://huggingface.co/kohaku12/RVC-MODELS) — 纳西妲、黑塔、流萤、停云、星见雅 等
                    - [jarari/RVC-v2](https://huggingface.co/jarari/RVC-v2) — 芙宁娜(韩语)、银狼(韩语)
                    - [mrmocciai/genshin-impact](https://huggingface.co/mrmocciai/genshin-impact) — 原神 50+ 角色（需手动下载）

                    **VOCALOID**
                    - [javinfamous/infamous_miku_v2](https://huggingface.co/javinfamous/infamous_miku_v2) — 初音未来 (1000 epochs)

                    **Hololive / VTuber**
                    - [megaaziib/my-rvc-models-collection](https://huggingface.co/megaaziib/my-rvc-models-collection) — 佩克拉、樱巫女、大空昴、Kobo、Kaela 等
                    - [Kit-Lemonfoot/kitlemonfoot_rvc_models](https://huggingface.co/Kit-Lemonfoot/kitlemonfoot_rvc_models) — Hololive JP/EN 多角色

                    **偶像大师 / 赛马娘**
                    - [trioskosmos/rvc_models](https://huggingface.co/trioskosmos/rvc_models) — 神崎兰子、梦见莉亚梦
                    - [makiligon/RVC-Models](https://huggingface.co/makiligon/RVC-Models) — 四条贵音、米浴

                    **Project SEKAI**
                    - [kohaku12/RVC-MODELS](https://huggingface.co/kohaku12/RVC-MODELS) — 草薙宁宁

                    > 💡 手动下载后，将 `.pth` 和 `.index` 文件放入 `assets/weights/characters/<角色名>/` 目录，刷新即可使用。
                    """
                )

    return app


def _patch_gradio_file_download(blocks):
    """
    Patch Gradio v3 的 /file= 路由，为文件添加 Content-Disposition header，
    使浏览器下载时使用干净的文件名而非完整路径。
    """
    try:
        from starlette.responses import FileResponse
        from urllib.parse import quote
        import fastapi

        def _clean_download_name(response: FileResponse, path_or_url: str) -> str:
            candidates = [
                getattr(response, "filename", None),
                getattr(response, "path", None),
                path_or_url,
            ]
            for candidate in candidates:
                if not candidate:
                    continue
                name = Path(str(candidate)).name
                if not name:
                    continue
                name = re.sub(
                    r"^[A-Za-z]__.*?_gradio_[0-9a-f]{8,}_",
                    "",
                    name,
                    flags=re.IGNORECASE,
                )
                if name:
                    return name
            return "download"

        fastapi_app = getattr(blocks, "server_app", None)
        if fastapi_app is None:
            return

        for route in fastapi_app.routes:
            if hasattr(route, "path") and route.path == "/file={path_or_url:path}":
                original_endpoint = route.endpoint

                async def patched_file(
                    path_or_url: str,
                    request: fastapi.Request,
                    _orig=original_endpoint,
                ):
                    response = await _orig(path_or_url, request=request)
                    if isinstance(response, FileResponse) and "content-disposition" not in response.headers:
                        basename = _clean_download_name(response, path_or_url)
                        encoded = quote(basename)
                        if encoded != basename:
                            cd = f"inline; filename*=utf-8''{encoded}"
                        else:
                            cd = f'inline; filename="{basename}"'
                        response.headers["content-disposition"] = cd
                    return response

                route.endpoint = patched_file
                break
    except Exception as e:
        log.warning(f"Patch Gradio file download failed: {e}")


def launch(host: str = "127.0.0.1", port: int = 7860, share: bool = False):
    """启动 Gradio 界面"""
    app = create_ui()
    app.queue()  # 启用队列以支持进度跟踪
    app.launch(
        server_name=host,
        server_port=port,
        share=share,
        inbrowser=True,
        prevent_thread_lock=True
    )
    _patch_gradio_file_download(app)
    app.block_thread()


if __name__ == "__main__":
    launch()