use tauri::AppHandle;
use tracing::error;

use crate::{
    core::{
        self,
        api::{self},
    },
    service,
    utils::get_config,
};
use paw_common::preclude::CoreConfig;

/// 前端调用 command 返回的错误,错误类型全部映射到字符串
type CommandResult<T = ()> = Result<T, String>;

/// 把`anyhow::Result<T>`转为 `Result<T, String>` 类型,
///
/// 接受一个表达式作为输入，该表达式通常是一个可能返回 `anyhow::Result<T>` 类型的操作，
/// 如果操作成功，则返回 `CommandResult::Ok(T)`，如果操作失败，则将错误转换为 `CommandResult::Err(错误信息字符串)`
fn cmd_result<T>(r: anyhow::Result<T>) -> CommandResult<T> {
    match r {
        Ok(v) => Ok(v),
        Err(e) => {
            error!(target: "app", "{:?}", e);
            Err(format!("{:?}", e))
        }
    }
}

/// 核心：获取节点列表，可测试核心是否可用
#[tauri::command]
#[specta::specta]
pub async fn get_nodes(app: AppHandle) -> CommandResult<Vec<api::ProxyNodeInfo>> {
    let config = cmd_result(get_config(&app))?;
    cmd_result(core::api::get_nodes(config).await)
}

/// 核心：获取节点列表，可测试核心是否可用
#[tauri::command]
#[specta::specta]
pub async fn get_nodes_update(app: AppHandle) -> CommandResult<Vec<api::ProxyNodeInfo>> {
    let config = cmd_result(get_config(&app))?;
    cmd_result(core::api::get_nodes_update(config).await)
}

/// 核心：开启代理
#[tauri::command]
#[specta::specta]
pub async fn enable_proxy(app: AppHandle) -> CommandResult {
    let config = cmd_result(get_config(&app))?;
    cmd_result(core::api::enable_sysproxy(config).await)
}

/// 核心：关闭代理
#[tauri::command]
#[specta::specta]
pub async fn disable_proxy(app: AppHandle) -> CommandResult {
    let config = cmd_result(get_config(&app))?;
    cmd_result(core::api::disable_sysproxy(config).await)
}

/// 核心：选择节点
#[tauri::command]
#[specta::specta]
pub async fn select_node(name: String, app: AppHandle) -> CommandResult {
    let config = cmd_result(get_config(&app))?;
    cmd_result(core::api::select_node(config, name).await)
}

/// 核心：设置电路规则
#[tauri::command]
#[specta::specta]
pub async fn create_circuit(
    circuit: core::api::CircuitRequest,
    app: AppHandle,
) -> CommandResult<Vec<String>> {
    let config = cmd_result(get_config(&app))?;
    cmd_result(core::api::create_circuit(config, circuit).await)
}

/// 核心：删除电路规则
#[tauri::command]
#[specta::specta]
pub async fn delete_circuit(path: String, is_prefix: bool, app: AppHandle) -> CommandResult {
    let config = cmd_result(get_config(&app))?;
    cmd_result(core::api::delete_circuit(config, path, is_prefix).await)
}

/// 获取代理服务状态
#[tauri::command]
#[specta::specta]
pub async fn get_proxy(app: AppHandle) -> CommandResult<String> {
    let config = cmd_result(get_config(&app))?;
    cmd_result(core::api::get_proxy(config).await)
}
/// 获取代理核心版本
#[tauri::command]
#[specta::specta]
pub async fn get_version(app: AppHandle) -> CommandResult<String> {
    let config = cmd_result(get_config(&app))?;
    cmd_result(core::api::get_version(config).await)
}

/// 服务安装器：安装系统服务
#[tauri::command]
#[specta::specta]
pub async fn install_service() -> CommandResult {
    cmd_result(service::install::install_service())
}

/// 服务安装器：卸载系统服务
#[tauri::command]
#[specta::specta]
pub async fn uninstall_service() -> CommandResult {
    cmd_result(service::install::uninstall_service())
}

/// 系统服务：终止服务
#[tauri::command]
#[specta::specta]
pub async fn stop_service() -> CommandResult {
    cmd_result(service::api::stop_service().await)
}

/// 系统服务：启动核心
#[tauri::command]
#[specta::specta]
pub async fn start_core(app: AppHandle) -> CommandResult {
    let config = cmd_result(get_config(&app))?;
    cmd_result(service::api::start_core(config).await)
}

/// 系统服务：停止核心
/// 先通过核心停止自身，再使用系统服务停止核心
#[tauri::command]
#[specta::specta]
pub async fn stop_core(app: AppHandle) -> CommandResult {
    // 先尝试让核心自己终止，不论成功与否，都继续尝试使用系统服务终止
    let config = cmd_result(get_config(&app))?;
    if let Err(e) = cmd_result(core::api::stop_core(config).await) {
        error!(target: "app", "{e}");
    }
    cmd_result(service::api::stop_core().await)
}

/// 系统服务：重启核心
#[tauri::command]
#[specta::specta]
pub async fn restart_core(app: AppHandle) -> CommandResult {
    let config = cmd_result(get_config(&app))?;
    cmd_result(service::api::restart_core(config).await)
}

/// 系统服务：获取系统服务版本号
#[tauri::command]
#[specta::specta]
pub async fn get_service_version() -> CommandResult<String> {
    cmd_result(service::api::service_version().await)
}

/// 核心：获取一份默认的核心配置文件
#[tauri::command]
#[specta::specta]
pub async fn get_default_core_config() -> CoreConfig {
    CoreConfig::default()
}

/// 获取动态路由端点
#[tauri::command]
#[specta::specta]
pub async fn get_dynamic_routing_endpoint() -> CommandResult<String> {
    std::env::var("DYNAMIC_ROUTING_SERVER_URL").map_err(|e| e.to_string())
}