use std::sync::OnceLock;

use tokio::sync::Mutex;

use common::model::ai::{ChatCompletionRequestMessage, ChatCompletionToolCall};

static CHAT_CONTEXT: OnceLock<Mutex<Vec<ChatCompletionRequestMessage>>> = OnceLock::new();

fn chat_context() -> &'static Mutex<Vec<ChatCompletionRequestMessage>> {
    CHAT_CONTEXT.get_or_init(|| Mutex::new(Vec::new()))
}

pub async fn push_context_message(msg: ChatCompletionRequestMessage) {
    let mut context = chat_context().lock().await;
    context.push(msg);
}

pub async fn snapshot_context() -> Vec<ChatCompletionRequestMessage> {
    let context = chat_context().lock().await;
    context.clone()
}

pub async fn add_assistant_message(
    content: String,
    tool_calls: Option<Vec<ChatCompletionToolCall>>,
) {
    let message =
        ChatCompletionRequestMessage::assistant("assistant".to_string(), content, tool_calls);
    push_context_message(message).await;
}

pub async fn add_user_message(content: String) {
    let message = ChatCompletionRequestMessage::new("user".to_string(), content);
    push_context_message(message).await;
}

pub async fn add_tool_message(call_id: String, result: String) {
    let message = ChatCompletionRequestMessage::tool("tool".to_string(), result, call_id);
    push_context_message(message).await;
}