use crate::core::context::{
    add_assistant_message, add_tool_message, add_user_message, snapshot_context,
};
use ai::core::send_message;
use common::queue::QueueMessage;
use serde_json::error;
use tokio::sync::{mpsc::Receiver, mpsc::Sender};
use wechat::manager::WeChatMultiAccountManager;

pub async fn create_queue(
    sender: Sender<QueueMessage>,
    mut receiver: Receiver<QueueMessage>,
    manager: WeChatMultiAccountManager,
) -> Result<(), error::Error> {
    tokio::spawn(async move {
        while let Some(msg) = receiver.recv().await {
            let queue_sender = sender.clone();
            match msg {
                QueueMessage::Aissitant(channel, assistant) => {
                    let content = assistant.content.clone();
                    let reasoning = assistant.reasoning.clone().unwrap_or_default();
                    println!("\n\n收到llm回复：\n{}\n-------\n{}", reasoning, content);
                    if !content.trim().is_empty() || !reasoning.trim().is_empty() {
                        let text = if !content.trim().is_empty() {
                            content.trim()
                        } else {
                            reasoning.trim()
                        };
                        manager
                            .send_text(
                                &channel.account_id,
                                &channel.from_user_id,
                                &text,
                                channel.context.as_deref(),
                            )
                            .await
                            .unwrap();
                    }
                    add_assistant_message(assistant.content, assistant.tool_calls).await;
                }
                QueueMessage::Channel(bundle) => {
                    println!(
                        "\n\n收到来自{}消息：\n{}",
                        bundle.from_user_id.clone(),
                        bundle.content.clone()
                    );
                    // todo 目前按单用户处理
                    add_user_message(bundle.content.clone()).await;
                    send_message(queue_sender, snapshot_context().await, bundle)
                        .await
                        .unwrap();
                }
                QueueMessage::Tool(channel, tool_call_id, name, result) => {
                    println!("\n\n调用{}工具的结果:\n{}", name, result);
                    add_tool_message(tool_call_id, result).await;
                    send_message(queue_sender, snapshot_context().await, channel)
                        .await
                        .unwrap();
                }
            }
        }
    });
    Ok(())
}

// pub async fn send_to_queue(
//     State(state): State<Arc<AppState>>,
//     Json(body): Json<ChannelMessageBundle>,
// ) -> Json<serde_json::Value> {
// match state
//     .sender
//     .send(QueueMessage::Channel(body.channel, body.content))
//     .await
// {
//     Ok(_) => Json(serde_json::json!({
//         "success":true,
//         "message":"queued"
//     })),
//     Err(_) => Json(serde_json::json!({
//         "success":true,
//         "message":"queue closed"
//     })),
// }
// }