use tauri::ipc::Channel;

use crate::{
    letta::{types::LettaCompletionMessage, LettaAgentInfo, LettaConfigKey},
    state::AppState,
};

#[tauri::command]
pub async fn list_agents(state: tauri::State<'_, AppState>) -> Result<Vec<LettaAgentInfo>, ()> {
    match state.letta_manager.list_agents().await {
        Ok(res) => Ok(res),
        Err(err) => {
            eprintln!("failed to list agents: {}", err);
            Ok(Vec::new())
        }
    }
}

#[tauri::command]
pub async fn get_letta_base_url(state: tauri::State<'_, AppState>) -> Result<String, ()> {
    Ok(state.letta_manager.base_url.lock().await.clone())
}

#[tauri::command]
pub async fn set_letta_base_url(
    state: tauri::State<'_, AppState>,
    url: String,
) -> Result<String, ()> {
    {
        let mut base_url = state.letta_manager.base_url.lock().await;
        *base_url = url.clone();
    }

    state
        .letta_manager
        .store
        .set(LettaConfigKey::BaseUrl.to_string(), url.clone());

    Ok(url)
}

#[tauri::command]
pub async fn get_letta_agent_id(state: tauri::State<'_, AppState>) -> Result<String, ()> {
    Ok(state.letta_manager.agent_id.lock().await.clone())
}

#[tauri::command]
pub async fn set_letta_agent_id(
    state: tauri::State<'_, AppState>,
    id: String,
) -> Result<String, ()> {
    {
        let mut agent_id = state.letta_manager.agent_id.lock().await;
        *agent_id = id.clone();
    }

    state
        .letta_manager
        .store
        .set(LettaConfigKey::AgentId.to_string(), id.clone());

    Ok(id)
}

#[tauri::command]
pub async fn start_llm_completion(
    state: tauri::State<'_, AppState>,
    message: String,
    on_event: Channel<LettaCompletionMessage>,
) -> Result<(), ()> {
    match state.letta_manager.start_completion(message).await {
        Ok(mut rx) => {
            while let Some(ev) = rx.recv().await {
                on_event
                    .send(ev)
                    .expect("failed to forward event to channel");
            }

            Ok(())
        }
        Err(err) => {
            eprintln!("failed to start completion: {}", err);

            Ok(())
        }
    }
}