//! 代理模块（mihomo 管理器）：按功能域拆分子模块。
//!
//! - [`MihomoManager`]：核心状态与目录/设置/配置/API 方法
//! - [`kernel`]：内核安装与更新
//! - [`profiles`]：订阅管理
//! - [`system_proxy`]：Windows 系统代理开关
//! - [`commands`]：Tauri 命令层

mod autoswitch;
mod commands;
mod kernel;
mod profiles;
mod pseudo;
mod system_proxy;
mod types;

pub use autoswitch::{pick_best, start_auto_switch_loop};
pub use pseudo::is_pseudo_node;
pub use system_proxy::get_system_proxy_windows;
pub use types::{InstallProgress, KernelInfo, KernelUpdateInfo, ProfileMeta, ProxySettings, ProxyStatus, TrafficSnapshot};
pub use commands::{
    proxy_activate_profile, proxy_apply_kernel_update, proxy_cancel_kernel_install, proxy_check_kernel_update, proxy_clear_system_proxy,
    proxy_close_connection, proxy_confirm_install, proxy_delete_profile, proxy_get_connections, proxy_get_proxies,
    proxy_get_settings, proxy_get_system_proxy, proxy_import_profile, proxy_kernel_info, proxy_traffic,
    proxy_patch_configs, proxy_restart, proxy_save_settings, proxy_select_proxy, proxy_set_system_proxy,
    proxy_start, proxy_status, proxy_stop, proxy_test_delay, proxy_update_profile, proxy_version,
};

use reqwest::Client;
use serde_yaml::Value as YamlValue;
use std::fs;
use std::path::PathBuf;
use std::sync::atomic::{AtomicBool, Ordering};
use std::sync::{Arc, Mutex};
use std::time::{Duration, Instant};
use tauri::AppHandle;

use crate::process_manager::{ProcessManager, StartProcessParams};

// ===================== MihomoManager =====================

/// settings 内存缓存条目（短时复用，避免高频状态轮询反复读盘）
struct SettingsCacheEntry {
    read_at: Instant,
    settings: ProxySettings,
}

/// 流量速率差分基线：记录上次采样的会话总量与时刻，用于计算实时速率
struct TrafficBaseline {
    download_total: u64,
    upload_total: u64,
    at: Instant,
}

pub struct MihomoManager {
    root: PathBuf,
    client: Client,
    settings_cache: Mutex<Option<SettingsCacheEntry>>,
    /// 流量速率差分基线：记录上次采样总量与时刻，由两次 /connections 总量差异计算实时速率
    traffic_baseline: Mutex<Option<TrafficBaseline>>,
    /// 内核安装/更新的取消标志（前端「停止下载」置位，下载循环轮询后中止）
    kernel_cancel: Arc<AtomicBool>,
    /// 取消唤醒通道：让停滞在流式读取（stream.next 最多等 30s）中的下载立即感知取消，
    /// 否则旧任务会残留最长 30s，期间可能与新任务并发写临时文件/互相重置取消标志
    kernel_cancel_tx: tokio::sync::watch::Sender<bool>,
    /// 下载完成后解压替换前的确认通道：mihomo 运行时下载不受影响，但解压替换前
    /// 必须等前端确认已停止 mihomo（否则 exe 文件被占用）。前端确认后通过
    /// proxy_confirm_install 命令发送信号唤醒等待。
    /// 用 std Mutex 而非 tokio Mutex：锁只短暂存取 sender，不跨 await 持有。
    install_confirm: std::sync::Mutex<Option<tokio::sync::oneshot::Sender<()>>>,
}

impl MihomoManager {
    pub fn new(app_data_dir: PathBuf) -> Self {
        let root = app_data_dir.join("proxy");
        for d in ["cores", "mihomo", "profiles", "logs"] {
            fs::create_dir_all(root.join(d)).ok();
        }
        Self {
            root,
            client: Client::builder()
                // 默认 30s 兜底超时，防止遗漏显式 timeout 的请求永久悬挂
                .timeout(std::time::Duration::from_secs(30))
                .build()
                .unwrap_or_else(|_| Client::new()),
            settings_cache: Mutex::new(None),
            traffic_baseline: Mutex::new(None),
            kernel_cancel: Arc::new(AtomicBool::new(false)),
            kernel_cancel_tx: tokio::sync::watch::channel(false).0,
            install_confirm: std::sync::Mutex::new(None),
        }
    }

    /// 请求取消内核安装/更新（由 proxy_cancel_kernel_install 命令调用）
    pub fn cancel_kernel_install(&self) {
        self.kernel_cancel.store(true, Ordering::SeqCst);
        // 唤醒停滞的流式下载循环，使其立即中止而不是等 30s 超时
        let _ = self.kernel_cancel_tx.send(true);
    }

    /// 前端确认 mihomo 已停止，唤醒等待中的安装流程继续解压替换（由 proxy_confirm_install 命令调用）
    pub fn confirm_install(&self) {
        if let Some(tx) = self.install_confirm.lock().unwrap().take() {
            let _ = tx.send(());
        }
    }

    fn cores_dir(&self) -> PathBuf {
        self.root.join("cores")
    }
    pub fn kernel_path(&self) -> PathBuf {
        self.cores_dir().join("mihomo.exe")
    }
    fn mihomo_dir(&self) -> PathBuf {
        self.root.join("mihomo")
    }
    fn config_path(&self) -> PathBuf {
        self.mihomo_dir().join("config.yaml")
    }
    fn profiles_dir(&self) -> PathBuf {
        self.root.join("profiles")
    }
    #[allow(dead_code)]
    fn logs_dir(&self) -> PathBuf {
        self.root.join("logs")
    }
    fn settings_path(&self) -> PathBuf {
        self.root.join("settings.json")
    }

    // ---------- 设置 ----------
    pub fn load_settings(&self) -> ProxySettings {
        // 内存缓存：500ms 内复用（高频调用如状态轮询/测速避免反复读盘）
        if let Ok(cache) = self.settings_cache.lock() {
            if let Some(entry) = cache.as_ref() {
                if entry.read_at.elapsed() < Duration::from_millis(500) {
                    return entry.settings.clone();
                }
            }
        }

        let mut settings = fs::read_to_string(self.settings_path())
            .ok()
            .and_then(|s| serde_json::from_str::<ProxySettings>(&s).ok())
            .unwrap_or_default();
        // 恢复机制：扫描磁盘 profile 文件，补全 settings.profiles
        // 防止 settings.json 损坏（如反序列化失败被 default 覆盖）导致订阅丢失
        if self.reconcile_profiles(&mut settings) {
            let _ = self.save_settings(&settings);
        }

        // 刷新缓存
        if let Ok(mut cache) = self.settings_cache.lock() {
            *cache = Some(SettingsCacheEntry {
                read_at: Instant::now(),
                settings: settings.clone(),
            });
        }

        settings
    }

    /// 扫描磁盘 profile 文件，补全 settings.profiles 中缺失的条目。
    /// 返回 true 表示有变化需要保存。
    fn reconcile_profiles(&self, settings: &mut ProxySettings) -> bool {
        let mut changed = false;
        let existing_ids: std::collections::HashSet<String> =
            settings.profiles.iter().map(|p| p.id.clone()).collect();

        if let Ok(entries) = fs::read_dir(self.profiles_dir()) {
            for entry in entries.flatten() {
                let path = entry.path();
                if path.extension().and_then(|e| e.to_str()) != Some("yaml") {
                    continue;
                }
                let Some(id) = path
                    .file_stem()
                    .and_then(|s| s.to_str())
                    .map(|s| s.to_string())
                else {
                    continue;
                };
                if existing_ids.contains(&id) {
                    continue;
                }
                let size = fs::metadata(&path).map(|m| m.len()).unwrap_or(0);
                let updated_at = fs::metadata(&path)
                    .and_then(|m| m.modified())
                    .ok()
                    .and_then(|t| t.duration_since(std::time::UNIX_EPOCH).ok())
                    .and_then(|d| chrono::DateTime::from_timestamp(d.as_secs() as i64, 0))
                    .map(|dt| dt.format("%Y-%m-%d %H:%M:%S").to_string())
                    .unwrap_or_default();
                settings.profiles.push(ProfileMeta {
                    added_at: updated_at.clone(),
                    id: id.clone(),
                    name: id,
                    url: String::new(),
                    updated_at,
                    size,
                });
                changed = true;
            }
        }

        // 如果 currentProfile 为 null 但有 profile，设置为第一个
        if settings.current_profile.is_none() && !settings.profiles.is_empty() {
            settings.current_profile = Some(settings.profiles[0].id.clone());
            changed = true;
        }

        changed
    }

    pub fn save_settings(&self, settings: &ProxySettings) -> Result<(), String> {
        let s = serde_json::to_string_pretty(settings).map_err(|e| e.to_string())?;
        fs::write(self.settings_path(), s).map_err(|e| e.to_string())?;
        // 写盘成功后同步刷新内存缓存（避免旧缓存被后续 load_settings 复用）
        if let Ok(mut cache) = self.settings_cache.lock() {
            *cache = Some(SettingsCacheEntry {
                read_at: Instant::now(),
                settings: settings.clone(),
            });
        }
        Ok(())
    }

    // ---------- 配置生成 ----------
    /// 合并 profile + 控制器设置，生成运行时 config.yaml
    pub fn generate_config(&self) -> Result<(), String> {
        let settings = self.load_settings();
        let mut value: YamlValue = if let Some(id) = &settings.current_profile {
            let path = self.profiles_dir().join(format!("{}.yaml", id));
            if path.exists() {
                let content = fs::read_to_string(&path).map_err(|e| e.to_string())?;
                serde_yaml::from_str(&content).unwrap_or(YamlValue::Mapping(serde_yaml::Mapping::new()))
            } else {
                YamlValue::Mapping(serde_yaml::Mapping::new())
            }
        } else {
            YamlValue::Mapping(serde_yaml::Mapping::new())
        };

        if !value.is_mapping() {
            value = YamlValue::Mapping(serde_yaml::Mapping::new());
        }
        let m = value.as_mapping_mut().unwrap();
        m.insert(YamlValue::String("mixed-port".into()), YamlValue::Number(settings.mixed_port.into()));
        m.insert(
            YamlValue::String("external-controller".into()),
            YamlValue::String(settings.external_controller.clone()),
        );
        if !settings.secret.is_empty() {
            m.insert(YamlValue::String("secret".into()), YamlValue::String(settings.secret.clone()));
        }
        m.insert(YamlValue::String("mode".into()), YamlValue::String(settings.mode.clone()));
        m.insert(
            YamlValue::String("log-level".into()),
            YamlValue::String(settings.log_level.clone()),
        );
        m.insert(YamlValue::String("allow-lan".into()), YamlValue::Bool(settings.allow_lan));

        // 日志写入文件，便于排查问题
        let log_file = self.logs_dir().join("mihomo.log");
        m.insert(
            YamlValue::String("log-file".into()),
            YamlValue::String(log_file.to_string_lossy().to_string()),
        );

        // Geo 数据库下载源（使用 jsdelivr 国内可访问镜像，避免无代理时 GitHub 超时）
        let mut geox = serde_yaml::Mapping::new();
        geox.insert(
            YamlValue::String("mmdb".into()),
            YamlValue::String("https://cdn.jsdelivr.net/gh/MetaCubeX/meta-rules-dat@release/country.mmdb".into()),
        );
        geox.insert(
            YamlValue::String("geosite".into()),
            YamlValue::String("https://cdn.jsdelivr.net/gh/MetaCubeX/meta-rules-dat@release/geosite.dat".into()),
        );
        geox.insert(
            YamlValue::String("asn".into()),
            YamlValue::String("https://cdn.jsdelivr.net/gh/xishang0128/bdg@master/GeoLite2-ASN.mmdb".into()),
        );
        m.insert(YamlValue::String("geox-url".into()), YamlValue::Mapping(geox));

        let yaml = serde_yaml::to_string(&value).map_err(|e| e.to_string())?;
        fs::write(self.config_path(), yaml).map_err(|e| e.to_string())?;
        Ok(())
    }

    /// 构建启动 mihomo 所需的进程参数（含 prepare + config 生成）
    pub fn prepare_for_start(&self, app: &AppHandle) -> Result<StartProcessParams, String> {
        let info = self.prepare_kernel(app)?;
        if !info.exists {
            return Err(format!(
                "mihomo 内核未安装。请将 mihomo.exe 放置到 src-tauri/binaries/ 后重新运行，或直接放到：\n{}",
                self.cores_dir().to_string_lossy()
            ));
        }
        self.generate_config()?;
        Ok(StartProcessParams {
            id: "proxy".into(),
            executable: self.kernel_path().to_string_lossy().to_string(),
            args: vec![
                "-d".into(),
                self.mihomo_dir().to_string_lossy().to_string(),
                "-f".into(),
                self.config_path().to_string_lossy().to_string(),
            ],
            cwd: Some(self.mihomo_dir().to_string_lossy().to_string()),
            name: "mihomo".into(),
            restart_on_crash: true,
            max_restarts: 3,
        })
    }

    /// mihomo 启动成功后，若配置了「启动时自动开启系统代理」且当前未开，则开启系统代理。
    /// 手动启动与 App 自启共用，保证设置语义一致（mihomo 运行期间自动跟随系统代理）。
    pub fn apply_auto_system_proxy(&self) {
        let settings = self.load_settings();
        if !settings.auto_system_proxy {
            return;
        }
        // 以注册表实际状态为准判断是否已开启：settings.system_proxy 是会话内标志，
        // 上次退出 cleanup_on_exit 只清注册表不会回写该标志，重启后会残留 true，
        // 若用它做守卫会导致「启动时自动开启系统代理」永远被短路而不生效。
        if system_proxy::get_system_proxy_windows() {
            return;
        }
        let addr = format!("127.0.0.1:{}", settings.mixed_port);
        if let Err(e) = system_proxy::set_system_proxy_windows(&addr) {
            crate::logger::log_warn("mihomo", &format!("自动开启系统代理失败: {}", e));
            return;
        }
        let mut s = settings;
        s.system_proxy = true;
        let _ = self.save_settings(&s);
    }

    /// 应用启动时检查是否需要自动启动 mihomo 和系统代理
    pub fn auto_start_on_launch(&self, app: &AppHandle, pm: &ProcessManager) {
        let settings = self.load_settings();
        if !settings.auto_start {
            return;
        }
        match self.prepare_for_start(app) {
            Ok(params) => {
                if let Err(e) = pm.start(params) {
                    crate::logger::log_error("mihomo", &format!("自动启动失败: {}", e));
                } else {
                    // 启动成功后按「启动时自动开启系统代理」设置决定是否开启系统代理
                    self.apply_auto_system_proxy();
                }
            }
            Err(e) => {
                crate::logger::log_warn("mihomo", &format!("自动启动跳过: {}", e));
            }
        }
    }

    /// 应用退出时清理：关闭系统代理
    pub fn cleanup_on_exit(&self) {
        let settings = self.load_settings();
        if settings.system_proxy || settings.auto_system_proxy {
            let _ = system_proxy::clear_system_proxy_windows();
        }
    }

    // ---------- mihomo API ----------
    fn api_url(&self, path: &str) -> String {
        let s = self.load_settings();
        format!("http://{}{}", s.external_controller, path)
    }

    fn api_bearer(&self) -> Option<String> {
        let s = self.load_settings();
        if s.secret.is_empty() {
            None
        } else {
            Some(format!("Bearer {}", s.secret))
        }
    }

    async fn api_get(&self, path: &str) -> Result<serde_json::Value, String> {
        let mut req = self.client.get(self.api_url(path));
        if let Some(b) = self.api_bearer() {
            req = req.header("Authorization", b);
        }
        // 显式超时：mihomo 卡死/未响应时命令立即返回，避免前端按钮永久转圈
        let resp = req
            .timeout(std::time::Duration::from_secs(10))
            .send()
            .await
            .map_err(|e| format!("请求 mihomo 失败: {}", e))?;
        if !resp.status().is_success() {
            return Err(format!("mihomo API 错误: {}", resp.status()));
        }
        resp.json().await.map_err(|e| e.to_string())
    }

    async fn api_request(
        &self,
        method: reqwest::Method,
        path: &str,
        body: Option<serde_json::Value>,
    ) -> Result<(), String> {
        let mut req = self.client.request(method, self.api_url(path));
        if let Some(b) = self.api_bearer() {
            req = req.header("Authorization", b);
        }
        if let Some(b) = body {
            req = req.json(&b);
        }
        let resp = req
            .timeout(std::time::Duration::from_secs(10))
            .send()
            .await
            .map_err(|e| format!("请求 mihomo 失败: {}", e))?;
        if !resp.status().is_success() {
            return Err(format!("mihomo API 错误: {}", resp.status()));
        }
        Ok(())
    }

    pub async fn get_version(&self) -> Result<serde_json::Value, String> {
        self.api_get("/version").await
    }

    pub async fn get_proxies(&self) -> Result<serde_json::Value, String> {
        self.api_get("/proxies").await
    }

    pub async fn select_proxy(&self, group: &str, name: &str) -> Result<(), String> {
        self.api_request(
            reqwest::Method::PUT,
            &format!("/proxies/{}", url_encode(group)),
            Some(serde_json::json!({ "name": name })),
        )
        .await
    }

    pub async fn test_delay(&self, name: &str, url: &str, timeout: u32) -> Result<u32, String> {
        let path = format!(
            "/proxies/{}/delay?timeout={}&url={}",
            url_encode(name),
            timeout,
            url_encode(url)
        );
        let v = self.api_get(&path).await?;
        v.get("delay")
            .and_then(|d| d.as_u64())
            .map(|d| d as u32)
            .ok_or_else(|| {
                v.get("message")
                    .and_then(|m| m.as_str())
                    .map(|s| s.to_string())
                    .unwrap_or_else(|| "测速失败".into())
            })
    }

    #[allow(dead_code)]
    pub async fn get_rules(&self) -> Result<serde_json::Value, String> {
        self.api_get("/rules").await
    }

    pub async fn get_connections(&self) -> Result<serde_json::Value, String> {
        self.api_get("/connections").await
    }

    /// 拉取 /connections 并计算实时流量快照。
    /// 速率由两次采样的会话总量差分得出；mihomo 重启导致总量回退时自动重置基线。
    pub async fn traffic_snapshot(&self) -> Result<TrafficSnapshot, String> {
        let conns = self.get_connections().await?;
        let upload_total = conns["uploadTotal"].as_u64().unwrap_or(0);
        let download_total = conns["downloadTotal"].as_u64().unwrap_or(0);
        let active_connections = conns["connections"].as_array().map(|a| a.len()).unwrap_or(0);

        let (upload_speed, download_speed) = {
            let base = self.traffic_baseline.lock().unwrap();
            match base.as_ref() {
                // 正常差分：总量单调递增才计算速率
                Some(b) if upload_total >= b.upload_total && download_total >= b.download_total => {
                    let dt = b.at.elapsed().as_secs_f64();
                    if dt > 0.0 {
                        let up = ((upload_total - b.upload_total) as f64 / dt).max(0.0) as u64;
                        let down = ((download_total - b.download_total) as f64 / dt).max(0.0) as u64;
                        (up, down)
                    } else {
                        (0, 0)
                    }
                }
                // 无基线或总量回退（mihomo 重启）：本帧速率为 0，下方重置基线
                _ => (0, 0),
            }
        };

        *self.traffic_baseline.lock().unwrap() = Some(TrafficBaseline {
            download_total,
            upload_total,
            at: Instant::now(),
        });

        Ok(TrafficSnapshot {
            download_total,
            upload_total,
            download_speed,
            upload_speed,
            active_connections,
        })
    }

    pub async fn close_connection(&self, id: &str) -> Result<(), String> {
        self.api_request(
            reqwest::Method::DELETE,
            &format!("/connections/{}", url_encode(id)),
            None,
        )
        .await
    }

    pub async fn patch_configs(&self, body: serde_json::Value) -> Result<(), String> {
        self.api_request(reqwest::Method::PATCH, "/configs", Some(body)).await
    }
}

fn url_encode(s: &str) -> String {
    // 仅对路径段做最小编码，避免引入额外依赖
    let mut out = String::with_capacity(s.len());
    for b in s.bytes() {
        match b {
            b'A'..=b'Z' | b'a'..=b'z' | b'0'..=b'9' | b'-' | b'_' | b'.' | b'~' => {
                out.push(b as char);
            }
            _ => out.push_str(&format!("%{:02X}", b)),
        }
    }
    out
}