use crate::App;
use serde::{Deserialize, Serialize};
use std::collections::HashMap;
use std::path::PathBuf;
use std::sync::Arc;
use std::time::Instant;
use tauri::{AppHandle, Emitter, State};
use tokio::sync::RwLock;
use xianren_api::ApiState;
use xianren_core::models as models_db;
use xianren_core::sessions as sessions_db;
use xianren_core::settings as settings_db;
use xianren_core::{CoreApp, ModelInfo, Message};
use xianren_engine::{ChatMessage, ChatRequest, EngineConfig, EngineManager};
use xianren_engine::remote::RemoteConfig;

#[derive(Serialize)]
pub struct AppInfo {
    pub version: String,
    pub platform: String,
    pub models_dir: String,
    pub logs_dir: String,
    pub engine_bin: Option<String>,
    pub engine_exists: bool,
    pub db_path: String,
}

#[derive(Deserialize, Clone)]
pub struct ChatParams {
    pub temperature: f32,
    pub top_p: f32,
    pub max_tokens: u32,
    pub ctx_size: usize,
    pub ngl: i32,
}

#[derive(Deserialize)]
pub struct ChatSendPayload {
    pub conversation_id: String,
    pub model_id: String,
    pub content: String,
    pub params: ChatParams,
    #[serde(default)]
    pub images: Vec<String>,
}

#[derive(Serialize, Clone)]
pub struct ChatTokenEvent {
    pub conversation_id: String,
    pub text: String,
}

#[derive(Serialize, Clone)]
pub struct ChatDoneEvent {
    pub conversation_id: String,
    pub message_id: String,
    pub content: String,
    pub tokens_in: Option<i64>,
    pub tokens_out: Option<i64>,
    pub tokens_estimated: bool,
    pub elapsed_ms: u64,
    pub first_token_ms: Option<u64>,
}

#[derive(Deserialize)]
pub struct RegeneratePayload {
    pub conversation_id: String,
    pub message_id: String,
    pub params: ChatParams,
}

#[derive(Deserialize)]
pub struct EditMessagePayload {
    pub conversation_id: String,
    pub message_id: String,
    pub content: String,
    pub params: ChatParams,
}

#[derive(Serialize, Clone)]
pub struct ChatMessageUpdatedEvent {
    pub conversation_id: String,
    pub message: Message,
}

#[derive(Serialize, Clone)]
pub struct ChatErrorEvent {
    pub conversation_id: String,
    pub message: String,
}

#[derive(Serialize, Clone)]
pub struct EngineDeployEvent {
    pub model_id: String,
    pub file_name: String,
    pub state: String,
    pub message: Option<String>,
}

#[derive(Serialize, Clone)]
pub struct EngineDeployProgressEvent {
    pub model_id: String,
    pub file_name: String,
    pub percent: u32,
    pub stage: String,
}

#[derive(Deserialize, Clone)]
pub struct DownloadPayload {
    pub url: String,
    pub file_name: String,
    pub sha256: Option<String>,
    pub repo_id: Option<String>,
    pub source: Option<String>,
}

#[derive(Serialize, Clone)]
pub struct DownloadProgressEvent {
    pub id: String,
    pub url: String,
    pub file_name: String,
    pub downloaded: u64,
    pub total: Option<u64>,
    pub percent: Option<f64>,
    pub speed_bps: u64,
    pub status: String,
}

#[tauri::command]
pub fn app_info(state: State<'_, App>) -> AppInfo {
    let db = state.core.db.lock().unwrap();
    let engine_bin = settings_db::get(&db, "engine_bin").ok().flatten();
    AppInfo {
        version: env!("CARGO_PKG_VERSION").to_string(),
        platform: std::env::consts::OS.to_string(),
        models_dir: state.core.models_dir.to_string_lossy().to_string(),
        logs_dir: state.core.logs_dir.to_string_lossy().to_string(),
        engine_exists: engine_bin
            .as_ref()
            .is_some_and(|p| PathBuf::from(p).exists()),
        engine_bin,
        db_path: state
            .core
            .data_dir
            .join("xianren.db")
            .to_string_lossy()
            .to_string(),
    }
}

#[tauri::command]
pub fn list_models(state: State<'_, App>) -> Result<Vec<ModelInfo>, String> {
    let db = state.core.db.lock().unwrap();
    models_db::list(&db).map_err(|e| e.to_string())
}

#[tauri::command]
pub fn import_model(state: State<'_, App>, path: String) -> Result<ModelInfo, String> {
    let p = PathBuf::from(&path);
    if !p.exists() {
        return Err(format!("file not found: {path}"));
    }
    let name = p
        .file_name()
        .map(|s| s.to_string_lossy().to_string())
        .unwrap_or_default();
    let size = std::fs::metadata(&p).map(|m| m.len() as i64).unwrap_or(0);
    let db = state.core.db.lock().unwrap();
    let id = models_db::insert(
        &db,
        &name,
        "local",
        "local",
        &name,
        &path,
        size,
        models_db::guess_quant(&name).as_deref(),
        None,
        None,
        None,
        None,
        None,
        serde_json::json!({}),
    )
    .map_err(|e| e.to_string())?;
    models_db::get(&db, &id)
        .map_err(|e| e.to_string())?
        .ok_or_else(|| "model not found after insert".to_string())
}

#[tauri::command]
pub fn remove_model(state: State<'_, App>, id: String) -> Result<(), String> {
    let db = state.core.db.lock().unwrap();
    models_db::remove(&db, &id).map_err(|e| e.to_string())
}

#[tauri::command]
pub fn settings_get(state: State<'_, App>) -> Result<HashMap<String, String>, String> {
    let db = state.core.db.lock().unwrap();
    let pairs = settings_db::all(&db).map_err(|e| e.to_string())?;
    Ok(pairs.into_iter().collect())
}

#[tauri::command]
pub fn settings_set(state: State<'_, App>, key: String, value: String) -> Result<(), String> {
    let db = state.core.db.lock().unwrap();
    settings_db::set(&db, &key, &value).map_err(|e| e.to_string())
}

#[tauri::command]
pub fn list_conversations(state: State<'_, App>) -> Result<Vec<xianren_core::Conversation>, String> {
    let db = state.core.db.lock().unwrap();
    sessions_db::list_conversations(&db).map_err(|e| e.to_string())
}

#[tauri::command]
pub fn create_conversation(
    state: State<'_, App>,
    title: String,
    model_id: Option<String>,
) -> Result<xianren_core::Conversation, String> {
    let id = uuid::Uuid::new_v4().to_string();
    let db = state.core.db.lock().unwrap();
    sessions_db::create_conversation(&db, &id, &title, model_id.as_deref(), None)
        .map_err(|e| e.to_string())?;
    sessions_db::get_conversation(&db, &id)
        .map_err(|e| e.to_string())?
        .ok_or_else(|| "conversation not found".to_string())
}

#[tauri::command]
pub fn delete_conversation(state: State<'_, App>, id: String) -> Result<(), String> {
    let db = state.core.db.lock().unwrap();
    sessions_db::delete_conversation(&db, &id).map_err(|e| e.to_string())
}

#[tauri::command]
pub fn get_messages(state: State<'_, App>, conversation_id: String) -> Result<Vec<Message>, String> {
    let db = state.core.db.lock().unwrap();
    sessions_db::list_messages(&db, &conversation_id).map_err(|e| e.to_string())
}

#[tauri::command]
pub async fn engine_start(
    app: AppHandle,
    state: State<'_, App>,
    model_id: String,
    params: ChatParams,
) -> Result<xianren_engine::EngineStatus, String> {
    let core = state.core.clone();
    let engine = state.engine.clone();
    let base = state.engine_base.clone();

    let (model, engine_bin) = {
        let db = core.db.lock().unwrap();
        let model = models_db::get(&db, &model_id)
            .map_err(|e| e.to_string())?
            .ok_or_else(|| "model not found".to_string())?;
        let bin = settings_db::get(&db, "engine_bin")
            .map_err(|e| e.to_string())?
            .unwrap_or_default();
        (model, bin)
    };

    let bin = PathBuf::from(engine_bin);
    if !bin.exists() {
        return Err(format!(
            "engine binary not found: {}，请先在设置页配置 llama-server 路径",
            bin.display()
        ));
    }
    if engine.status().await.running {
        return Err("engine already running".into());
    }

    let cfg = EngineConfig {
        binary_path: bin,
        model_path: PathBuf::from(model.file_path),
        host: "127.0.0.1".into(),
        ctx_size: params.ctx_size,
        ngl: params.ngl,
        threads: None,
        log_file: core.logs_dir.join(format!("engine-{}.log", model.file_name)),
    };
    engine.start(cfg).await.map_err(|e| e.to_string())?;
    *base.write().await = engine.base_url().await;
    let status = engine.status().await;
    let _ = app.emit("engine://status", status.clone());
    Ok(status)
}

#[tauri::command]
pub async fn engine_stop(app: AppHandle, state: State<'_, App>) -> Result<(), String> {
    state.engine.stop().await.map_err(|e| e.to_string())?;
    *state.engine_base.write().await = None;
    let _ = app.emit("engine://status", state.engine.status().await);
    Ok(())
}

#[tauri::command]
pub async fn engine_status(
    state: State<'_, App>,
) -> Result<xianren_engine::EngineStatus, String> {
    Ok(state.engine.status().await)
}

/// 后台部署（加载）本地模型：启动 llama-server 并等待就绪，通过事件广播进度。
#[tauri::command]
pub async fn deploy_model(
    app: AppHandle,
    state: State<'_, App>,
    model_id: String,
    params: ChatParams,
) -> Result<(), String> {
    let core = state.core.clone();
    let engine = state.engine.clone();
    let base = state.engine_base.clone();

    let (model, engine_bin) = {
        let db = core.db.lock().unwrap();
        let model = models_db::get(&db, &model_id)
            .map_err(|e| e.to_string())?
            .ok_or_else(|| "model not found".to_string())?;
        if model.kind != "local" {
            return Err("在线 API 模型无需部署".into());
        }
        let bin = settings_db::get(&db, "engine_bin")
            .map_err(|e| e.to_string())?
            .unwrap_or_default();
        (model, bin)
    };

    let file_name = model.file_name.clone();
    let emit_deploy = |state_name: &str, message: Option<String>| {
        let _ = app.emit(
            "engine://deploy",
            EngineDeployEvent {
                model_id: model_id.clone(),
                file_name: file_name.clone(),
                state: state_name.into(),
                message,
            },
        );
    };

    let current = engine.status().await;
    if current.running {
        if current.model.as_deref() == Some(file_name.as_str()) {
            emit_deploy("ready", None);
            return Ok(());
        }
        // 部署另一个模型前，先停掉当前引擎
        let _ = engine.stop().await;
        *base.write().await = None;
        let _ = app.emit("engine://status", engine.status().await);
    }

    let bin = PathBuf::from(engine_bin);
    if !bin.exists() {
        emit_deploy(
            "error",
            Some(format!(
                "引擎文件不存在：{}，请到设置页配置 llama-server 路径",
                bin.display()
            )),
        );
        return Ok(());
    }

    emit_deploy("loading", None);
    let app2 = app.clone();
    let core2 = core.clone();
    let engine2 = engine.clone();
    let base2 = base.clone();
    let model_id2 = model_id.clone();
    let file_name2 = file_name.clone();

    tokio::spawn(async move {
        let cfg = EngineConfig {
            binary_path: bin,
            model_path: PathBuf::from(model.file_path),
            host: "127.0.0.1".into(),
            ctx_size: params.ctx_size,
            ngl: params.ngl,
            threads: None,
            log_file: core2.logs_dir.join(format!("engine-{}.log", model.file_name)),
        };
        // 后台轮询引擎日志，解析模型加载进度并广播
        let log_path = cfg.log_file.clone();
        let progress_app = app2.clone();
        let progress_model = model_id2.clone();
        let progress_name = file_name2.clone();
        let progress_task = tokio::spawn(async move {
            let mut last_size = 0u64;
            loop {
                if let Ok(meta) = tokio::fs::metadata(&log_path).await {
                    let size = meta.len();
                    if size != last_size {
                        last_size = size;
                        if let Ok(bytes) = tokio::fs::read(&log_path).await {
                            let text = String::from_utf8_lossy(&bytes);
                            let (percent, stage) = estimate_load_progress(&text);
                            let _ = progress_app.emit(
                                "engine://deploy-progress",
                                EngineDeployProgressEvent {
                                    model_id: progress_model.clone(),
                                    file_name: progress_name.clone(),
                                    percent,
                                    stage: stage.to_string(),
                                },
                            );
                        }
                    }
                }
                tokio::time::sleep(std::time::Duration::from_millis(250)).await;
            }
        });

        match engine2.start(cfg).await {
            Ok(()) => {
                progress_task.abort();
                *base2.write().await = engine2.base_url().await;
                let _ = app2.emit(
                    "engine://deploy",
                    EngineDeployEvent {
                        model_id: model_id2.clone(),
                        file_name: file_name2.clone(),
                        state: "ready".into(),
                        message: None,
                    },
                );
                let _ = app2.emit(
                    "engine://deploy-progress",
                    EngineDeployProgressEvent {
                        model_id: model_id2.clone(),
                        file_name: file_name2.clone(),
                        percent: 100,
                        stage: "服务已就绪".into(),
                    },
                );
            }
            Err(e) => {
                progress_task.abort();
                let _ = app2.emit(
                    "engine://deploy",
                    EngineDeployEvent {
                        model_id: model_id2,
                        file_name: file_name2,
                        state: "error".into(),
                        message: Some(e.to_string()),
                    },
                );
            }
        }
        let _ = app2.emit("engine://status", engine2.status().await);
    });
    Ok(())
}

#[tauri::command]
pub async fn chat_send(
    app: AppHandle,
    state: State<'_, App>,
    payload: ChatSendPayload,
) -> Result<serde_json::Value, String> {
    let core = state.core.clone();
    let engine = state.engine.clone();
    let base = state.engine_base.clone();

    let (history, model, engine_bin, user_message_id) = {
        let db = core.db.lock().unwrap();
        if sessions_db::get_conversation(&db, &payload.conversation_id)
            .map_err(|e| e.to_string())?
            .is_none()
        {
            let title: String = payload.content.chars().take(30).collect();
            sessions_db::create_conversation(
                &db,
                &payload.conversation_id,
                &title,
                Some(&payload.model_id),
                None,
            )
            .map_err(|e| e.to_string())?;
        }
        // 始终把当前使用的模型写回会话，编辑/重新生成依赖它
        sessions_db::update_conversation_model(&db, &payload.conversation_id, &payload.model_id)
            .map_err(|e| e.to_string())?;
        let user_message_id = sessions_db::add_message(
            &db,
            &payload.conversation_id,
            "user",
            &payload.content,
            None,
            None,
            None,
            None,
            &payload.images,
        )
        .map_err(|e| e.to_string())?;

        let history = sessions_db::list_messages(&db, &payload.conversation_id)
            .map_err(|e| e.to_string())?
            .into_iter()
            .map(|m| ChatMessage {
                role: m.role,
                content: m.content,
                images: m.images,
            })
            .collect::<Vec<_>>();

        let model = models_db::get(&db, &payload.model_id)
            .map_err(|e| e.to_string())?
            .ok_or_else(|| "model not found".to_string())?;
        let bin = settings_db::get(&db, "engine_bin")
            .map_err(|e| e.to_string())?
            .unwrap_or_default();
        (history, model, bin, user_message_id)
    };

    let conversation_id = payload.conversation_id.clone();
    let history = if model.kind == "local" {
        sanitize_history_for_local(history)
    } else {
        history
    };

    tokio::spawn(run_generation_and_stream(
        app,
        core,
        engine,
        base,
        conversation_id.clone(),
        history,
        model,
        engine_bin,
        payload.params,
    ));
    Ok(serde_json::json!({
        "conversation_id": conversation_id,
        "message_id": user_message_id,
    }))
}

/// 统一的生成与流式转发：支持本地引擎 / 远程 API，统计首字延迟、token 数与耗时。
async fn run_generation_and_stream(
    app: AppHandle,
    core: Arc<CoreApp>,
    engine: EngineManager,
    base: Arc<RwLock<Option<String>>>,
    conversation_id: String,
    history: Vec<ChatMessage>,
    model: ModelInfo,
    engine_bin: String,
    params: ChatParams,
) {
    // 本地模型：确保引擎已运行
    if model.kind == "local" && !engine.status().await.running {
        let bin = PathBuf::from(&engine_bin);
        if !bin.exists() {
            let _ = app.emit(
                "chat://error",
                ChatErrorEvent {
                    conversation_id: conversation_id.clone(),
                    message: format!("engine binary not found: {}，请先在设置页配置", bin.display()),
                },
            );
            return;
        }
        let cfg = EngineConfig {
            binary_path: bin,
            model_path: PathBuf::from(model.file_path),
            host: "127.0.0.1".into(),
            ctx_size: params.ctx_size,
            ngl: params.ngl,
            threads: None,
            log_file: core.logs_dir.join(format!("engine-{}.log", model.file_name)),
        };
        if let Err(e) = engine.start(cfg).await {
            let _ = app.emit(
                "chat://error",
                ChatErrorEvent {
                    conversation_id: conversation_id.clone(),
                    message: e.to_string(),
                },
            );
            return;
        }
        *base.write().await = engine.base_url().await;
    }

    let upstream_model = if model.kind == "remote" {
        model
            .api_model
            .clone()
            .unwrap_or_else(|| model.repo_id.clone())
    } else {
        model.repo_id.clone()
    };
    let req = ChatRequest {
        model: upstream_model.clone(),
        messages: history,
        temperature: Some(params.temperature),
        top_p: Some(params.top_p),
        max_tokens: Some(params.max_tokens),
        stream: true,
    };

    let stream_result = if model.kind == "remote" {
        let cfg = RemoteConfig {
            base_url: model.base_url.clone().unwrap_or_default(),
            api_key: model.api_key.clone(),
            model: upstream_model,
        };
        xianren_engine::stream_chat_remote(&cfg, req).await
    } else {
        engine.stream_chat(req).await
    };

    let mut stream = match stream_result {
        Ok(s) => s,
        Err(e) => {
            let _ = app.emit(
                "chat://error",
                ChatErrorEvent {
                    conversation_id: conversation_id.clone(),
                    message: e.to_string(),
                },
            );
            return;
        }
    };

    use futures::StreamExt;
    let started = Instant::now();
    let mut first_token_ms: Option<u64> = None;
    let mut prompt_tokens: Option<i64> = None;
    let mut completion_tokens: Option<i64> = None;
    let mut full = String::new();

    while let Some(item) = stream.next().await {
        match item {
            Ok(xianren_engine::ChatStreamEvent::Text(text)) => {
                if first_token_ms.is_none() {
                    first_token_ms = Some(started.elapsed().as_millis() as u64);
                }
                full.push_str(&text);
                let _ = app.emit(
                    "chat://token",
                    ChatTokenEvent {
                        conversation_id: conversation_id.clone(),
                        text,
                    },
                );
            }
            Ok(xianren_engine::ChatStreamEvent::Usage {
                prompt_tokens: p,
                completion_tokens: c,
            }) => {
                prompt_tokens = Some(p as i64);
                completion_tokens = Some(c as i64);
            }
            Err(e) => {
                let _ = app.emit(
                    "chat://error",
                    ChatErrorEvent {
                        conversation_id: conversation_id.clone(),
                        message: e.to_string(),
                    },
                );
                return;
            }
        }
    }

    let elapsed_ms = started.elapsed().as_millis() as u64;
    let tokens_estimated = completion_tokens.is_none();
    let tokens_out = completion_tokens.or_else(|| Some(estimate_tokens(&full) as i64));
    let db = core.db.lock().unwrap();
    let message_id = sessions_db::add_message(
        &db,
        &conversation_id,
        "assistant",
        &full,
        prompt_tokens,
        tokens_out,
        Some(elapsed_ms as i64),
        first_token_ms.map(|v| v as i64),
        &[],
    )
    .unwrap_or_default();
    let _ = sessions_db::touch_conversation(&db, &conversation_id);
    drop(db);
    let _ = app.emit(
        "chat://done",
        ChatDoneEvent {
            conversation_id,
            message_id,
            content: full,
            tokens_in: prompt_tokens,
            tokens_out,
            tokens_estimated,
            elapsed_ms,
            first_token_ms,
        },
    );
}

/// 本地文本模型不支持图片：把图片替换为占位说明。
fn sanitize_history_for_local(mut history: Vec<ChatMessage>) -> Vec<ChatMessage> {
    for message in &mut history {
        if !message.images.is_empty() {
            for _ in &message.images {
                message
                    .content
                    .push_str("\n[图片：本地文本模型暂不支持视觉输入]");
            }
            message.images.clear();
        }
    }
    history
}

fn estimate_tokens(text: &str) -> usize {
    let mut score = 0usize;
    for ch in text.chars() {
        score += if ch.is_ascii() { 1 } else { 2 };
    }
    score / 4 + 1
}

/// 解析会话使用的模型：优先会话记录；未记录时若本地只有一个模型则自动使用，否则提示。
fn resolve_conversation_model(
    db: &rusqlite::Connection,
    conversation: &xianren_core::Conversation,
) -> Result<String, String> {
    if let Some(id) = &conversation.model_id {
        return Ok(id.clone());
    }
    let all = models_db::list(db).map_err(|e| e.to_string())?;
    if all.len() == 1 {
        return Ok(all[0].id.clone());
    }
    Err("会话未记录模型：请先在该会话发送一条消息，或重新选择模型后重试".into())
}

/// 重新生成某条助手回复：旧内容存入版本历史，截断后重新生成。
#[tauri::command]
pub async fn regenerate_message(
    app: AppHandle,
    state: State<'_, App>,
    payload: RegeneratePayload,
) -> Result<(), String> {
    let core = state.core.clone();
    let engine = state.engine.clone();
    let base = state.engine_base.clone();

    let (history, model, engine_bin, conversation_id) = {
        let db = core.db.lock().unwrap();
        let conversation = sessions_db::get_conversation(&db, &payload.conversation_id)
            .map_err(|e| e.to_string())?
            .ok_or_else(|| "conversation not found".to_string())?;
        let messages = sessions_db::list_messages(&db, &payload.conversation_id)
            .map_err(|e| e.to_string())?;
        let idx = messages
            .iter()
            .position(|m| m.id == payload.message_id && m.role == "assistant")
            .ok_or_else(|| "assistant message not found".to_string())?;
        let target = &messages[idx];
        let _ = sessions_db::save_message_version(
            &db,
            &target.id,
            &target.content,
            target.tokens_out,
            target.elapsed_ms,
            target.first_token_ms,
        );
        let (rowid, _) = sessions_db::get_message_with_rowid(&db, &target.id)
            .map_err(|e| e.to_string())?
            .ok_or_else(|| "message not found".to_string())?;
        sessions_db::delete_messages_after(&db, &payload.conversation_id, rowid)
            .map_err(|e| e.to_string())?;
        let history = messages[..idx]
            .iter()
            .map(|m| ChatMessage {
                role: m.role.clone(),
                content: m.content.clone(),
                images: m.images.clone(),
            })
            .collect::<Vec<_>>();
        let model_id = resolve_conversation_model(&db, &conversation)?;
        let model = models_db::get(&db, &model_id)
            .map_err(|e| e.to_string())?
            .ok_or_else(|| "model not found".to_string())?;
        let bin = settings_db::get(&db, "engine_bin")
            .map_err(|e| e.to_string())?
            .unwrap_or_default();
        (history, model, bin, payload.conversation_id.clone())
    };

    let history = if model.kind == "local" {
        sanitize_history_for_local(history)
    } else {
        history
    };
    tokio::spawn(run_generation_and_stream(
        app,
        core,
        engine,
        base,
        conversation_id,
        history,
        model,
        engine_bin,
        payload.params,
    ));
    Ok(())
}

/// 编辑用户提问并重新提交：清空该问题之后的所有生成内容。
#[tauri::command]
pub async fn edit_message(
    app: AppHandle,
    state: State<'_, App>,
    payload: EditMessagePayload,
) -> Result<(), String> {
    let core = state.core.clone();
    let engine = state.engine.clone();
    let base = state.engine_base.clone();

    let (history, model, engine_bin, conversation_id) = {
        let db = core.db.lock().unwrap();
        let conversation = sessions_db::get_conversation(&db, &payload.conversation_id)
            .map_err(|e| e.to_string())?
            .ok_or_else(|| "conversation not found".to_string())?;
        let (rowid, msg) = sessions_db::get_message_with_rowid(&db, &payload.message_id)
            .map_err(|e| e.to_string())?
            .ok_or_else(|| "message not found".to_string())?;
        if msg.role != "user" {
            return Err("只能编辑用户消息".into());
        }
        sessions_db::update_message_content(&db, &payload.message_id, &payload.content)
            .map_err(|e| e.to_string())?;
        sessions_db::delete_messages_after(&db, &payload.conversation_id, rowid)
            .map_err(|e| e.to_string())?;
        let history = sessions_db::list_messages(&db, &payload.conversation_id)
            .map_err(|e| e.to_string())?
            .into_iter()
            .map(|m| ChatMessage {
                role: m.role,
                content: m.content,
                images: m.images,
            })
            .collect::<Vec<_>>();
        let model_id = resolve_conversation_model(&db, &conversation)?;
        let model = models_db::get(&db, &model_id)
            .map_err(|e| e.to_string())?
            .ok_or_else(|| "model not found".to_string())?;
        let bin = settings_db::get(&db, "engine_bin")
            .map_err(|e| e.to_string())?
            .unwrap_or_default();
        (history, model, bin, payload.conversation_id.clone())
    };

    let history = if model.kind == "local" {
        sanitize_history_for_local(history)
    } else {
        history
    };
    tokio::spawn(run_generation_and_stream(
        app,
        core,
        engine,
        base,
        conversation_id,
        history,
        model,
        engine_bin,
        payload.params,
    ));
    Ok(())
}

#[tauri::command]
pub fn list_message_versions(
    state: State<'_, App>,
    message_id: String,
) -> Result<Vec<xianren_core::sessions::MessageVersion>, String> {
    let db = state.core.db.lock().unwrap();
    sessions_db::list_message_versions(&db, &message_id).map_err(|e| e.to_string())
}

#[tauri::command]
pub fn apply_message_version(
    app: AppHandle,
    state: State<'_, App>,
    conversation_id: String,
    message_id: String,
    version_id: String,
) -> Result<(), String> {
    let db = state.core.db.lock().unwrap();
    let version = sessions_db::get_message_version(&db, &version_id)
        .map_err(|e| e.to_string())?
        .ok_or_else(|| "version not found".to_string())?;
    sessions_db::apply_message_version(
        &db,
        &message_id,
        &version.content,
        version.tokens_out,
        version.elapsed_ms,
        version.first_token_ms,
    )
    .map_err(|e| e.to_string())?;
    let message = sessions_db::get_message(&db, &message_id)
        .map_err(|e| e.to_string())?
        .ok_or_else(|| "message not found".to_string())?;
    let _ = app.emit(
        "chat://message-updated",
        ChatMessageUpdatedEvent {
            conversation_id,
            message,
        },
    );
    Ok(())
}

#[tauri::command]
pub fn download_enqueue(
    app: AppHandle,
    state: State<'_, App>,
    payload: DownloadPayload,
) -> Result<String, String> {
    let id = uuid::Uuid::new_v4().to_string();
    let core = state.core.clone();
    // 模型按 <models_dir>/<owner>/<repo>/<file> 组织，不直接放模型目录根
    let subdir = derive_repo_subdir(&payload);
    let dest_dir = core.models_dir.join(&subdir);
    std::fs::create_dir_all(&dest_dir)
        .map_err(|e| format!("failed to create model directory {}: {e}", dest_dir.display()))?;
    let dest = dest_dir.join(&payload.file_name);
    let opts = xianren_download::DownloadOptions {
        url: payload.url.clone(),
        dest,
        expected_sha256: payload.sha256.clone(),
        chunk_size: 8 * 1024 * 1024,
    };
    let pid = payload;
    let app2 = app.clone();
    let task_id = id.clone();
    let progress_url = pid.url.clone();
    let progress_name = pid.file_name.clone();

    tokio::spawn(async move {
        let tid = task_id.clone();
        let progress = move |pr: xianren_download::DownloadProgress| {
            let _ = app2.emit(
                "download://progress",
                DownloadProgressEvent {
                    id: tid.clone(),
                    url: progress_url.clone(),
                    file_name: progress_name.clone(),
                    downloaded: pr.downloaded,
                    total: pr.total,
                    percent: pr.percent,
                    speed_bps: pr.speed_bps,
                    status: "downloading".into(),
                },
            );
        };
        match xianren_download::download(opts, progress).await {
            Ok(path) => {
                let size = std::fs::metadata(&path)
                    .map(|m| m.len() as i64)
                    .unwrap_or(0);
                let repo_id = pid.repo_id.clone().unwrap_or_else(|| pid.url.clone());
                let source = pid.source.clone().unwrap_or_else(|| "download".to_string());
                let db = core.db.lock().unwrap();
                let _ = models_db::insert(
                    &db,
                    &repo_id,
                    &source,
                    "local",
                    &pid.file_name,
                    &path.to_string_lossy(),
                    size,
                    models_db::guess_quant(&pid.file_name).as_deref(),
                    None,
                    pid.sha256.as_deref(),
                    None,
                    None,
                    None,
                    serde_json::json!({ "url": pid.url.clone() }),
                );
                let _ = app.emit("models://updated", serde_json::json!({}));
                let _ = app.emit(
                    "download://done",
                    DownloadProgressEvent {
                        id: task_id.clone(),
                        url: pid.url,
                        file_name: pid.file_name,
                        downloaded: size as u64,
                        total: Some(size as u64),
                        percent: Some(100.0),
                        speed_bps: 0,
                        status: "done".into(),
                    },
                );
            }
            Err(e) => {
                let _ = app.emit(
                    "download://error",
                    DownloadProgressEvent {
                        id: task_id.clone(),
                        url: pid.url,
                        file_name: pid.file_name,
                        downloaded: 0,
                        total: None,
                        percent: None,
                        speed_bps: 0,
                        status: format!("error: {e}"),
                    },
                );
            }
        }
    });
    Ok(id)
}

/// 扫描设置中的模型目录（自动 + 手动共用），并广播模型列表更新。
#[tauri::command]
pub fn scan_models(app: AppHandle, state: State<'_, App>) -> Result<Vec<ModelInfo>, String> {
    let core = state.core.clone();
    let db = core.db.lock().unwrap();
    let dir = settings_db::get(&db, "model_dir")
        .ok()
        .flatten()
        .map(PathBuf::from)
        .unwrap_or_else(|| core.models_dir.clone());
    let result = models_db::scan_directory(&db, &dir).map_err(|e| e.to_string())?;
    let list = models_db::list(&db).map_err(|e| e.to_string())?;
    let _ = app.emit(
        "models://updated",
        serde_json::json!({
            "added": result.added,
            "updated": result.updated,
            "missing": result.missing,
        }),
    );
    Ok(list)
}

/// 手动添加一个 OpenAI 兼容的在线 API 模型。
#[tauri::command]
pub fn add_remote_model(
    state: State<'_, App>,
    name: String,
    base_url: String,
    api_key: String,
    api_model: String,
) -> Result<ModelInfo, String> {
    let name = name.trim();
    let base_url = base_url.trim();
    let api_model = api_model.trim();
    if name.is_empty() || base_url.is_empty() || api_model.is_empty() {
        return Err("名称、Base URL、模型 ID 均不能为空".into());
    }
    let db = state.core.db.lock().unwrap();
    let id = models_db::insert(
        &db,
        name,
        "remote",
        "remote",
        name,
        base_url,
        0,
        None,
        None,
        None,
        Some(base_url),
        if api_key.trim().is_empty() {
            None
        } else {
            Some(api_key.trim())
        },
        Some(api_model),
        serde_json::json!({}),
    )
    .map_err(|e| e.to_string())?;
    models_db::get(&db, &id)
        .map_err(|e| e.to_string())?
        .ok_or_else(|| "model not found after insert".to_string())
}

/// 在模型广场搜索模型仓库（HuggingFace / ModelScope）。
#[tauri::command]
pub async fn search_models(
    query: String,
    source: String,
) -> Result<Vec<serde_json::Value>, String> {
    let client = reqwest::Client::new();
    let mut results = Vec::new();

    match source.as_str() {
        "modelscope" => {
            let body = serde_json::json!({
                "page_number": 1,
                "page_size": 30,
                "search": query.trim(),
            });
            let resp = client
                .put("https://www.modelscope.cn/api/v1/models")
                .json(&body)
                .send()
                .await
                .map_err(|e| e.to_string())?;
            if !resp.status().is_success() {
                return Err(format!(
                    "ModelScope API {}: {}",
                    resp.status(),
                    resp.text().await.unwrap_or_default()
                ));
            }
            let value: serde_json::Value = resp.json().await.map_err(|e| e.to_string())?;
            let arr = value
                .pointer("/Data/Model/Models")
                .or_else(|| value.pointer("/Data/Models"))
                .or_else(|| value.get("Models"))
                .and_then(|v| v.as_array());
            if let Some(arr) = arr {
                for item in arr {
                    let repo_id = item
                        .get("Path")
                        .or_else(|| item.get("Id"))
                        .and_then(|v| v.as_str())
                        .unwrap_or_default()
                        .to_string();
                    if repo_id.is_empty() {
                        continue;
                    }
                    let author = repo_id.split('/').next().unwrap_or("").to_string();
                    let name = item
                        .get("Name")
                        .and_then(|v| v.as_str())
                        .map(String::from)
                        .unwrap_or_else(|| {
                            repo_id.split('/').nth(1).unwrap_or(&repo_id).to_string()
                        });
                    results.push(serde_json::json!({
                        "repo_id": repo_id,
                        "author": author,
                        "name": name,
                        "downloads": item.get("Downloads").and_then(|v| v.as_i64()),
                        "likes": item.get("Likes").and_then(|v| v.as_i64()),
                        "tags": [],
                    }));
                }
            }
        }
        _ => {
            let url = reqwest::Url::parse_with_params(
                "https://huggingface.co/api/models",
                &[
                    ("search", query.trim()),
                    ("limit", "30"),
                    ("library", "gguf"),
                    ("sort", "downloads"),
                    ("direction", "-1"),
                ],
            )
            .map_err(|e| e.to_string())?;
            let resp = client
                .get(url)
                .header("User-Agent", "xianren-studio")
                .send()
                .await
                .map_err(|e| e.to_string())?;
            if !resp.status().is_success() {
                return Err(format!(
                    "HuggingFace API {}: {}",
                    resp.status(),
                    resp.text().await.unwrap_or_default()
                ));
            }
            let value: serde_json::Value = resp.json().await.map_err(|e| e.to_string())?;
            if let Some(arr) = value.as_array() {
                for item in arr {
                    let repo_id = item
                        .get("id")
                        .and_then(|v| v.as_str())
                        .unwrap_or_default()
                        .to_string();
                    if repo_id.is_empty() {
                        continue;
                    }
                    let author = repo_id.split('/').next().unwrap_or("").to_string();
                    let name = repo_id
                        .split('/')
                        .nth(1)
                        .unwrap_or(&repo_id)
                        .to_string();
                    results.push(serde_json::json!({
                        "repo_id": repo_id,
                        "author": author,
                        "name": name,
                        "downloads": item.get("downloads").and_then(|v| v.as_i64()),
                        "likes": item.get("likes").and_then(|v| v.as_i64()),
                        "tags": item
                            .get("tags")
                            .and_then(|v| v.as_array())
                            .map(|a| {
                                a.iter()
                                    .filter_map(|t| t.as_str().map(String::from))
                                    .collect::<Vec<_>>()
                            })
                            .unwrap_or_default(),
                    }));
                }
            }
        }
    }
    Ok(results)
}

/// 列出模型仓库中的 GGUF 文件（用于模型广场选择量化版本）。
#[tauri::command]
pub async fn list_model_files(
    repo_id: String,
    source: String,
) -> Result<Vec<serde_json::Value>, String> {
    let client = reqwest::Client::new();
    let mut files = Vec::new();

    match source.as_str() {
        "modelscope" => {
            let url = format!(
                "https://modelscope.cn/api/v1/models/{repo_id}/repo/files?Revision=master&Recursive=false"
            );
            let resp = client.get(&url).send().await.map_err(|e| e.to_string())?;
            if !resp.status().is_success() {
                return Err(format!(
                    "ModelScope API {}: {}",
                    resp.status(),
                    resp.text().await.unwrap_or_default()
                ));
            }
            let value: serde_json::Value = resp.json().await.map_err(|e| e.to_string())?;
            let arr = value
                .get("Data")
                .and_then(|d| d.get("Files"))
                .and_then(|v| v.as_array())
                .cloned()
                .or_else(|| value.as_array().cloned())
                .unwrap_or_default();
            for item in arr {
                let path = item
                    .get("Path")
                    .or_else(|| item.get("path"))
                    .and_then(|v| v.as_str())
                    .unwrap_or_default()
                    .to_string();
                if !path.to_lowercase().ends_with(".gguf") {
                    continue;
                }
                let size = item
                    .get("Size")
                    .or_else(|| item.get("size"))
                    .and_then(|v| v.as_i64())
                    .unwrap_or(0);
                let sha256 = item.get("Sha256").and_then(|v| v.as_str());
                files.push(serde_json::json!({
                    "path": path,
                    "size": size,
                    "sha256": sha256,
                }));
            }
        }
        _ => {
            let url = format!("https://huggingface.co/api/models/{repo_id}/tree/main?recursive=false");
            let resp = client
                .get(&url)
                .header("User-Agent", "xianren-studio")
                .send()
                .await
                .map_err(|e| e.to_string())?;
            if !resp.status().is_success() {
                return Err(format!(
                    "HuggingFace API {}: {}",
                    resp.status(),
                    resp.text().await.unwrap_or_default()
                ));
            }
            let value: serde_json::Value = resp.json().await.map_err(|e| e.to_string())?;
            if let Some(arr) = value.as_array() {
                for item in arr {
                    let path = item
                        .get("path")
                        .and_then(|v| v.as_str())
                        .unwrap_or_default()
                        .to_string();
                    if !path.to_lowercase().ends_with(".gguf") {
                        continue;
                    }
                    let size = item
                        .get("size")
                        .and_then(|v| v.as_i64())
                        .unwrap_or(0);
                    files.push(serde_json::json!({ "path": path, "size": size }));
                }
            }
        }
    }
    files.sort_by(|a, b| {
        a["size"]
            .as_i64()
            .unwrap_or(0)
            .cmp(&b["size"].as_i64().unwrap_or(0))
    });
    Ok(files)
}

/// 根据 repo_id 或 URL 推断下载模型应存放的子目录（owner/repo）。
fn derive_repo_subdir(payload: &DownloadPayload) -> String {
    if let Some(repo_id) = &payload.repo_id {
        let parts: Vec<&str> = repo_id.split('/').collect();
        if parts.len() >= 2 && !parts[0].trim().is_empty() && !parts[1].trim().is_empty() {
            return format!("{}/{}", parts[0].trim(), parts[1].trim());
        }
    }
    if let Some(rest) = payload.url.split("://").nth(1) {
        let segments: Vec<&str> = rest.split('/').collect();
        let start = if segments.get(1) == Some(&"models") {
            2
        } else {
            1
        };
        if segments.len() >= start + 2
            && !segments[start].trim().is_empty()
            && !segments[start + 1].trim().is_empty()
        {
            return format!("{}/{}", segments[start].trim(), segments[start + 1].trim());
        }
    }
    "manual".to_string()
}

/// 根据引擎日志内容估算模型加载进度。
fn estimate_load_progress(log: &str) -> (u32, &'static str) {
    if log.contains("listening on http")
        || log.contains("server is listening")
        || log.contains("HTTP server listening")
    {
        (100, "服务已就绪")
    } else if log.contains("model loaded") || log.contains("llama_new_context_with_model") {
        (90, "推理上下文就绪")
    } else if log.contains("load_model: initializing") {
        (70, "初始化推理上下文")
    } else if log.contains("load_tensors") || log.contains("model size") {
        (55, "加载模型权重")
    } else if log.contains("load_model: loading model")
        || log.contains("llama_model_load")
        || log.contains("loading model")
    {
        (25, "读取模型文件")
    } else {
        (8, "启动引擎进程")
    }
}

#[tauri::command]
pub async fn server_start(
    state: State<'_, App>,
    port: u16,
    api_key: String,
) -> Result<serde_json::Value, String> {
    let mut guard = state.server.lock().await;
    if guard.is_some() {
        return Err("server already running".into());
    }
    let api_state = ApiState::new(
        state.engine_base.clone(),
        {
            let core = state.core.clone();
            move || {
                let db = core.db.lock().unwrap();
                models_db::list(&db)
                    .unwrap_or_default()
                    .into_iter()
                    .map(|m| {
                        serde_json::json!({
                            "id": m.repo_id,
                            "object": "model",
                            "created": 0,
                            "owned_by": m.source,
                        })
                    })
                    .collect()
            }
        },
        if api_key.is_empty() {
            None
        } else {
            Some(api_key)
        },
    );
    let server = xianren_api::start(port, api_state)
        .await
        .map_err(|e| e.to_string())?;
    let addr = server.addr;
    *guard = Some(server);
    Ok(serde_json::json!({ "running": true, "port": addr.port() }))
}

#[tauri::command]
pub async fn server_stop(state: State<'_, App>) -> Result<(), String> {
    let mut guard = state.server.lock().await;
    if let Some(server) = guard.take() {
        server.shutdown();
    }
    Ok(())
}

#[tauri::command]
pub async fn server_status(state: State<'_, App>) -> Result<serde_json::Value, String> {
    let guard = state.server.lock().await;
    Ok(match guard.as_ref() {
        Some(s) => serde_json::json!({ "running": true, "port": s.addr.port() }),
        None => serde_json::json!({ "running": false, "port": null }),
    })
}

#[tauri::command]
pub fn open_path(path: String) -> Result<(), String> {
    tauri_plugin_opener::open_path(path, None::<&str>).map_err(|e| e.to_string())
}

/// 前端上报运行时错误：写入本地日志便于排查。
#[tauri::command]
pub fn report_error(source: String, message: String) -> Result<(), String> {
    tracing::error!(source = %source, error = %message, "frontend reported error");
    Ok(())
}