//! 应用配置：服务端 `desktop_configs` + SQLite 本地配置，同名键**本地优先**。
//! 合并结果供 `get_app_config` 与 Node 环境变量 `AICLIENT_CFG_*`。

use std::collections::HashMap;
use std::path::PathBuf;
use std::sync::Arc;

use serde_json::Value;
use thiserror::Error;
use tokio::sync::RwLock;

use crate::local_config::LocalConfigDb;

/// Node 子进程环境变量前缀，与 `scripts/nodejs/desktop_config.js` 一致。
pub const NODE_ENV_PREFIX: &str = "AICLIENT_CFG_";

#[derive(Debug, Error)]
pub enum AppConfigError {
    #[error("拉取配置失败: {0}")]
    Fetch(String),
}

#[derive(Debug, Default)]
struct Inner {
    server_entries: HashMap<String, String>,
    local_entries: HashMap<String, String>,
    last_message: String,
    local_db: Option<Arc<LocalConfigDb>>,
}

#[derive(Debug, Default)]
pub struct AppConfig {
    inner: Arc<RwLock<Inner>>,
}
fn is_dev() -> bool {
    cfg!(debug_assertions)
}
pub fn api_base() -> String {
    std::env::var("AICLIENT_API_BASE").unwrap_or_else(|_| {
        if is_dev() {
            "http://127.0.0.1:8001".to_string()
        } else {
            "http://81.71.163.140:8001".to_string()
        }
    })
}   

/// 将库表 `name` 转为 Node 环境变量名（不含前缀），如 `llm.api_key` → `LLM_API_KEY`。
pub fn normalize_config_key(name: &str) -> String {
    let mut out = String::new();
    let mut prev_underscore = false;
    for c in name.trim().chars() {
        if c.is_ascii_alphanumeric() {
            out.push(c.to_ascii_uppercase());
            prev_underscore = false;
        } else if !prev_underscore {
            out.push('_');
            prev_underscore = true;
        }
    }
    while out.starts_with('_') {
        out.remove(0);
    }
    while out.ends_with('_') {
        out.pop();
    }
    out
}

/// 完整环境变量名：`AICLIENT_CFG_LLM_API_KEY`
pub fn node_env_var_name(db_name: &str) -> String {
    format!("{}{}", NODE_ENV_PREFIX, normalize_config_key(db_name))
}

fn merged_entries(server: &HashMap<String, String>, local: &HashMap<String, String>) -> HashMap<String, String> {
    let mut map = server.clone();
    for (k, v) in local {
        map.insert(k.clone(), v.clone());
    }
    map
}

impl AppConfig {
    pub fn new() -> Self {
        Self {
            inner: Arc::new(RwLock::new(Inner::default())),
        }
    }

    /// 应用启动时初始化 SQLite 并加载本地配置。
    pub async fn init_local_store(&self, db_path: PathBuf) -> Result<(), String> {
        let entries = tokio::task::spawn_blocking(move || -> Result<(Arc<LocalConfigDb>, HashMap<String, String>), String> {
            let db = LocalConfigDb::open(db_path).map_err(|e| e.to_string())?;
            let map = db.list_all_map().map_err(|e| e.to_string())?;
            Ok((Arc::new(db), map))
        })
        .await
        .map_err(|e| e.to_string())?
        .map_err(|e| e)?;

        let (db, map) = entries;
        let mut g = self.inner.write().await;
        g.local_db = Some(db);
        g.local_entries = map;
        log::info!(
            target: "app_config",
            "本地配置已加载，共 {} 项",
            g.local_entries.len()
        );
        Ok(())
    }

    async fn with_db<F, T>(&self, f: F) -> Result<T, String>
    where
        F: FnOnce(Arc<LocalConfigDb>) -> Result<T, String> + Send + 'static,
        T: Send + 'static,
    {
        let db = self
            .inner
            .read()
            .await
            .local_db
            .clone()
            .ok_or_else(|| "本地配置数据库未初始化".to_string())?;
        tokio::task::spawn_blocking(move || f(db))
            .await
            .map_err(|e| e.to_string())?
    }

    /// 合并后的有效配置（本地覆盖服务端同名键）。
    pub async fn entries(&self) -> HashMap<String, String> {
        let g = self.inner.read().await;
        merged_entries(&g.server_entries, &g.local_entries)
    }

    pub async fn server_entries(&self) -> HashMap<String, String> {
        self.inner.read().await.server_entries.clone()
    }

    pub async fn local_entries(&self) -> HashMap<String, String> {
        self.inner.read().await.local_entries.clone()
    }

    pub async fn get(&self, name: &str) -> Option<String> {
        let g = self.inner.read().await;
        if let Some(v) = g.local_entries.get(name) {
            return Some(v.clone());
        }
        g.server_entries.get(name).cloned()
    }

    pub async fn last_message(&self) -> String {
        self.inner.read().await.last_message.clone()
    }

    pub async fn clear_server(&self) {
        let mut g = self.inner.write().await;
        g.server_entries.clear();
        g.last_message.clear();
    }

    pub async fn reload_local_from_db(&self) -> Result<(), String> {
        let map = self
            .with_db(|db| db.list_all_map().map_err(|e| e.to_string()))
            .await?;
        self.inner.write().await.local_entries = map;
        Ok(())
    }

    pub async fn set_local(&self, name: String, value: String, mark: Option<String>) -> Result<(), String> {
        let name_trim = name.trim().to_string();
        if name_trim.is_empty() {
            return Err("配置键名不能为空".into());
        }
        let value_owned = value;
        let mark_owned = mark.clone();
        self.with_db({
            let name = name_trim.clone();
            let value = value_owned.clone();
            move |db| db.upsert(&name, &value, mark_owned.as_deref()).map_err(|e| e.to_string())
        })
        .await?;
        let mut g = self.inner.write().await;
        g.local_entries.insert(name_trim, value_owned);
        Ok(())
    }

    pub async fn delete_local(&self, name: &str) -> Result<(), String> {
        let key = name.trim().to_string();
        if key.is_empty() {
            return Err("配置键名不能为空".into());
        }
        self.with_db({
            let key = key.clone();
            move |db| db.delete(&key).map_err(|e| e.to_string())
        })
        .await?;
        self.inner.write().await.local_entries.remove(name.trim());
        Ok(())
    }

    pub async fn list_local_items(&self) -> Result<Vec<crate::local_config::LocalConfigItem>, String> {
        self.with_db(|db| db.list_items().map_err(|e| e.to_string()))
            .await
    }

    /// 供 Node 子进程 `Command::env` 使用（已合并，本地优先）。
    pub async fn env_for_node(&self) -> HashMap<String, String> {
        let g = self.inner.read().await;
        let merged = merged_entries(&g.server_entries, &g.local_entries);
        merged
            .iter()
            .map(|(name, value)| (node_env_var_name(name), value.clone()))
            .collect()
    }

    pub async fn refresh_after_auth(&self, token: &str) -> Result<(), AppConfigError> {
        if token.trim().is_empty() {
            self.clear_server().await;
            return Ok(());
        }
  
        match fetch_from_server(token).await {
            Ok(map) => {
                let mut g = self.inner.write().await;
                g.server_entries = map;
                g.last_message.clear();
                let merged_len =
                    merged_entries(&g.server_entries, &g.local_entries).len();
                log::info!(
                    target: "app_config",
                    "服务端配置已更新；合并后共 {} 项（本地 {} 项可覆盖同名键）",
                    merged_len,
                    g.local_entries.len()
                );
                Ok(())
            }
            Err(e) => {
                let mut g = self.inner.write().await;
                g.last_message = e.to_string();
                log::warn!(target: "app_config", "拉取应用配置失败: {}", e);
                Err(e)
            }
        }
    }
}

async fn fetch_from_server(token: &str) -> Result<HashMap<String, String>, AppConfigError> {
    let mut headers = HashMap::new();
    headers.insert(
        "Authorization".to_string(),
        format!("Bearer {}", token.trim()),
    );

    let (status, v) = match crate::api_client::request_json("GET", "/appConfig", None, headers).await
    {
        Ok(pair) => pair,
        Err(e) => {
            log::warn!(target: "app_config", "GET /appConfig 请求失败（未拿到响应体）: {e}");
            println!("GET /appConfig 请求失败（未拿到响应体）: {e}");
            return Err(AppConfigError::Fetch(e));
        }
    };
    if status == 401 {
        return Err(AppConfigError::Fetch("未认证或令牌已失效".into()));
    }

    let ok = v.get("ok").and_then(|x| x.as_bool()).unwrap_or(false);
    if !ok {
        let msg = v
            .get("message")
            .and_then(|x| x.as_str())
            .unwrap_or("未知错误");
        return Err(AppConfigError::Fetch(msg.to_string()));
    }

    let data = v
        .get("data")
        .ok_or_else(|| AppConfigError::Fetch("响应缺少 data".into()))?;

    match data {
        Value::Object(obj) => {
            let mut map = HashMap::new();
            for (k, val) in obj {
                let s = match val {
                    Value::String(s) => s.clone(),
                    Value::Null => String::new(),
                    other => other.to_string(),
                };
                map.insert(k.clone(), s);
            }
            Ok(map)
        }
        _ => Err(AppConfigError::Fetch("data 应为 JSON 对象".into())),
    }
}