// 消息路由系统测试示例
// 这些代码展示了如何测试各个组件

#[cfg(test)]
mod integration_tests {
    use serde_json::json;
    use std::sync::{Arc, Mutex};
    use tokio::sync::mpsc;

    // 导入被测试的模块
    use crate::plugins::{MessagePlugin, TextMessagePlugin, FileMessagePlugin};
    use crate::router::MessageRouter;
    use crate::handlers::TauriMessageHandler;

    /// 集成测试：完整的消息发送流程
    #[tokio::test]
    async fn test_full_message_flow() {
        // 1. 创建 channel
        let (sender, mut receiver) = mpsc::channel(100);
        
        // 2. 记录接收到的消息
        let received_messages = Arc::new(Mutex::new(Vec::new()));
        let received_clone = Arc::clone(&received_messages);

        // 3. 创建路由器
        let router = MessageRouter::builder()
            .register_plugin(TextMessagePlugin::new())
            .on_message(move |msg| {
                received_clone.lock().unwrap().push(msg);
            })
            .with_iroh_sender(sender)
            .build();

        // 4. 发送消息
        let message = json!({
            "type": "text",
            "to": "user123",
            "from": "user456",
            "content": "Integration test message"
        });

        let result = router.send(message.clone()).await;
        assert!(result.is_ok());

        // 5. 验证消息被发送到 channel
        let sent_data = receiver.recv().await.unwrap();
        let sent_json: serde_json::Value = serde_json::from_slice(&sent_data).unwrap();
        assert_eq!(sent_json["type"], "text");
        assert_eq!(sent_json["content"], "Integration test message");

        // 6. 模拟接收消息
        let binary_data = serde_json::to_vec(&sent_json).unwrap();
        let result = router.handle_received_message(binary_data);
        assert!(result.is_ok());

        // 7. 验证回调被调用
        let messages = received_messages.lock().unwrap();
        assert_eq!(messages.len(), 1);
        assert_eq!(messages[0]["content"], "Integration test message");
    }

    /// 测试多插件协作
    #[tokio::test]
    async fn test_multiple_plugins() {
        let (sender, _receiver) = mpsc::channel(100);
        
        let router = MessageRouter::builder()
            .register_plugin(TextMessagePlugin::new())
            .register_plugin(FileMessagePlugin::new())
            .with_iroh_sender(sender)
            .build();

        // 发送文本消息
        let text_msg = json!({
            "type": "text",
            "to": "user1",
            "from": "user2",
            "content": "Text"
        });
        assert!(router.send(text_msg).await.is_ok());

        // 发送文件消息
        let file_msg = json!({
            "type": "file",
            "to": "user1",
            "from": "user2"
        });
        assert!(router.send(file_msg).await.is_ok());
    }

    /// 测试错误处理
    #[tokio::test]
    async fn test_error_handling() {
        let (sender, _receiver) = mpsc::channel(100);
        
        let router = MessageRouter::builder()
            .register_plugin(TextMessagePlugin::new())
            .with_iroh_sender(sender)
            .build();

        // 测试缺失必要字段
        let invalid_msg = json!({
            "type": "text",
            "content": "Missing to and from"
        });
        let result = router.send(invalid_msg).await;
        assert!(result.is_err());

        // 测试未知消息类型
        let unknown_type = json!({
            "type": "unknown_type",
            "to": "user1",
            "from": "user2"
        });
        let result = router.send(unknown_type).await;
        assert!(result.is_err());
    }

    /// 测试 Handler 层
    #[tokio::test]
    async fn test_handler_layer() {
        let (sender, _receiver) = mpsc::channel(100);
        
        let router = MessageRouter::builder()
            .register_plugin(TextMessagePlugin::new())
            .with_iroh_sender(sender)
            .build();

        let handler = TauriMessageHandler::new(router);

        // 测试成功的命令调用
        let message = json!({
            "type": "text",
            "to": "user1",
            "from": "user2",
            "content": "Handler test"
        });
        
        let result = handler.send_message(message).await;
        assert!(result.is_ok());
        assert_eq!(result.unwrap(), "Message sent successfully");

        // 测试获取支持的消息类型
        let types = handler.get_supported_message_types().unwrap();
        assert!(types.contains(&"text".to_string()));
    }

    /// 性能测试：大量消息发送
    #[tokio::test]
    async fn test_performance_many_messages() {
        let (sender, mut receiver) = mpsc::channel(1000);
        
        let router = MessageRouter::builder()
            .register_plugin(TextMessagePlugin::new())
            .with_iroh_sender(sender)
            .build();

        // 发送 100 条消息
        for i in 0..100 {
            let message = json!({
                "type": "text",
                "to": "user1",
                "from": "user2",
                "content": format!("Message {}", i)
            });
            
            let result = router.send(message).await;
            assert!(result.is_ok());
        }

        // 验证所有消息都被发送
        let mut count = 0;
        while let Ok(_) = receiver.try_recv() {
            count += 1;
        }
        assert_eq!(count, 100);
    }

    /// 测试并发安全性
    #[tokio::test]
    async fn test_concurrent_safety() {
        let (sender, _receiver) = mpsc::channel(100);
        
        let router = Arc::new(
            MessageRouter::builder()
                .register_plugin(TextMessagePlugin::new())
                .with_iroh_sender(sender)
                .build()
        );

        // 创建多个并发任务
        let mut handles = vec![];
        for i in 0..10 {
            let router_clone = Arc::clone(&router);
            let handle = tokio::spawn(async move {
                let message = json!({
                    "type": "text",
                    "to": "user1",
                    "from": "user2",
                    "content": format!("Concurrent message {}", i)
                });
                router_clone.send(message).await
            });
            handles.push(handle);
        }

        // 等待所有任务完成
        for handle in handles {
            let result = handle.await.unwrap();
            assert!(result.is_ok());
        }
    }
}