// ================================================================================================
// Audio Backend - 引擎通信集成测试
// ================================================================================================
// 描述: 测试音频引擎与通信系统的集成
// ================================================================================================

#include "fixtures/integration_test_fixtures.h"
#include "communication/communication.h"
#include "engine/audio_buffer.h"
#include <thread>
#include <chrono>
#include <atomic>
#include <mutex>
#include <condition_variable>

using namespace audio_backend;
using namespace audio_backend::test;
using namespace std::chrono_literals;

// 测试消息类型
class TestAudioMessage : public communication::Message {
public:
    TestAudioMessage(uint32_t sequence_number = 0, const std::string& content = "")
        : communication::Message("TestAudioMessage"), 
          sequence_number_(sequence_number), 
          content_(content) {}
    
    TestAudioMessage(const TestAudioMessage& other)
        : communication::Message(other),
          sequence_number_(other.sequence_number_),
          content_(other.content_) {}
    
    uint32_t sequence_number() const { return sequence_number_; }
    const std::string& content() const { return content_; }
    
    // 实现虚函数
    size_t estimated_size() const override { return sizeof(*this) + content_.size(); }
    Priority priority() const override { return Priority::Normal; }
    TransportChannel preferred_channel() const override { return TransportChannel::ZeroMQ; }
    
    std::unique_ptr<communication::IMessage> clone() const override {
        return std::make_unique<TestAudioMessage>(*this);
    }
    
private:
    uint32_t sequence_number_;
    std::string content_;
};

// 音频数据消息类型
class AudioBufferMessage : public communication::Message {
public:
    AudioBufferMessage()
        : communication::Message("AudioBufferMessage") {}
    
    AudioBufferMessage(const engine::AudioBuffer& buffer)
        : communication::Message("AudioBufferMessage"), buffer_(buffer) {}
    
    AudioBufferMessage(const AudioBufferMessage& other)
        : communication::Message(other), buffer_(other.buffer_) {}
    
    const engine::AudioBuffer& buffer() const { return buffer_; }
    
    // 实现虚函数
    size_t estimated_size() const override { 
        return sizeof(*this) + buffer_.total_bytes();
    }
    
    Priority priority() const override { return Priority::High; }
    
    TransportChannel preferred_channel() const override { 
        // 小缓冲区使用ZeroMQ，大缓冲区使用共享内存
        return buffer_.total_bytes() > 32 * 1024 
            ? TransportChannel::SharedMemory 
            : TransportChannel::ZeroMQ;
    }
    
    std::unique_ptr<communication::IMessage> clone() const override {
        return std::make_unique<AudioBufferMessage>(*this);
    }
    
private:
    engine::AudioBuffer buffer_;
};

// 引擎通信测试类
class EngineCommunicationIntegrationTest : public EngineCommunicationTest {
protected:
    void initialize_communication() override {
        // 创建通信配置
        communication::CommunicationConfig config;
        config.process_name = "engine_comm_test";
        config.routing_strategy = communication::RoutingStrategy::Auto;
        config.enable_zmq = true;
        config.enable_shm = true;
        
        // ZeroMQ配置
        communication::ZmqConfig zmq_config;
        zmq_config.endpoint = comm_endpoint_;
        zmq_config.socket_type = ZMQ_REP;
        zmq_config.bind_instead_of_connect = true;
        config.zmq_configs.push_back(zmq_config);
        
        // 共享内存配置
        config.shm_config.segment_name = shm_segment_;
        config.shm_config.segment_size = 1024 * 1024 * 10; // 10MB
        config.shm_config.create_if_not_exists = true;
        
        // 创建通信管理器
        comm_manager_ = std::make_unique<communication::CommunicationManager>(config);
        
        // 注册消息类型
        message_factory_.register_message<TestAudioMessage>("TestAudioMessage");
        message_factory_.register_message<AudioBufferMessage>("AudioBufferMessage");
        
        // 初始化通信管理器
        ASSERT_EQ(comm_manager_->initialize(), common::ErrorCode::Success);
        
        // 注册消息处理器
        comm_manager_->register_message_handler("TestAudioMessage", 
            [this](std::unique_ptr<communication::IMessage> message) {
                auto* test_message = dynamic_cast<TestAudioMessage*>(message.get());
                if (test_message) {
                    handle_test_message(*test_message);
                }
            });
        
        comm_manager_->register_message_handler("AudioBufferMessage", 
            [this](std::unique_ptr<communication::IMessage> message) {
                auto* buffer_message = dynamic_cast<AudioBufferMessage*>(message.get());
                if (buffer_message) {
                    handle_audio_buffer_message(*buffer_message);
                }
            });
    }
    
    void shutdown_communication() override {
        if (comm_manager_) {
            ASSERT_EQ(comm_manager_->shutdown(), common::ErrorCode::Success);
        }
    }
    
    void initialize_engine() override {
        // 在实际系统中，这里会初始化音频引擎组件
        // 但在此测试中，我们主要测试通信部分，因此创建模拟音频缓冲区
        test_buffer_ = create_test_audio_buffer(1024, 2, engine::AudioFormat::FLOAT32, true);
    }
    
    void shutdown_engine() override {
        // 清理资源
    }
    
    // 处理测试消息
    void handle_test_message(const TestAudioMessage& message) {
        std::lock_guard<std::mutex> lock(mutex_);
        received_messages_.push_back(message.sequence_number());
        
        // 发送响应
        auto response = std::make_unique<TestAudioMessage>(
            message.sequence_number(), "响应: " + message.content());
        
        comm_manager_->send_message(*response);
        cv_.notify_one();
    }
    
    // 处理音频缓冲区消息
    void handle_audio_buffer_message(const AudioBufferMessage& message) {
        std::lock_guard<std::mutex> lock(mutex_);
        received_buffers_++;
        
        // 比较接收的缓冲区与测试缓冲区
        if (compare_audio_buffers(message.buffer(), test_buffer_)) {
            matching_buffers_++;
        }
        
        // 创建处理后的响应缓冲区
        engine::AudioBuffer processed_buffer = message.buffer();
        
        // 执行一些简单的处理 - 增益调整
        float gain = 0.8f;
        if (processed_buffer.format() == engine::AudioFormat::FLOAT32) {
            float* data = processed_buffer.interleaved_data<float>();
            for (size_t i = 0; i < processed_buffer.num_frames() * processed_buffer.num_channels(); ++i) {
                data[i] *= gain;
            }
        }
        
        // 发送处理后的响应
        auto response = std::make_unique<AudioBufferMessage>(processed_buffer);
        comm_manager_->send_message(*response);
        
        cv_.notify_one();
    }
    
    // 等待特定数量的消息
    bool wait_for_message_count(size_t count, std::chrono::milliseconds timeout = 5s) {
        std::unique_lock<std::mutex> lock(mutex_);
        return cv_.wait_for(lock, timeout, [this, count] {
            return received_messages_.size() >= count;
        });
    }
    
    // 等待特定数量的缓冲区
    bool wait_for_buffer_count(size_t count, std::chrono::milliseconds timeout = 5s) {
        std::unique_lock<std::mutex> lock(mutex_);
        return cv_.wait_for(lock, timeout, [this, count] {
            return received_buffers_ >= count;
        });
    }

protected:
    communication::MessageFactory message_factory_;
    engine::AudioBuffer test_buffer_;
    
    // 同步变量
    std::mutex mutex_;
    std::condition_variable cv_;
    std::vector<uint32_t> received_messages_;
    size_t received_buffers_ = 0;
    size_t matching_buffers_ = 0;
};

// ================================================================================================
// 基本通信测试
// ================================================================================================
TEST_F(EngineCommunicationIntegrationTest, BasicCommunication) {
    // 创建客户端配置
    communication::CommunicationConfig client_config;
    client_config.process_name = "test_client";
    client_config.routing_strategy = communication::RoutingStrategy::Auto;
    client_config.enable_zmq = true;
    
    // ZeroMQ配置
    communication::ZmqConfig zmq_config;
    zmq_config.endpoint = comm_endpoint_;
    zmq_config.socket_type = ZMQ_REQ;
    zmq_config.bind_instead_of_connect = false;
    client_config.zmq_configs.push_back(zmq_config);
    
    // 创建客户端管理器
    auto client_manager = std::make_unique<communication::CommunicationManager>(
        client_config, message_factory_);
    
    // 初始化客户端
    ASSERT_EQ(client_manager->initialize(), common::ErrorCode::Success);
    
    // 创建测试消息
    auto message = std::make_unique<TestAudioMessage>(1, "测试消息");
    
    // 发送消息
    ASSERT_EQ(client_manager->send_message(*message), common::ErrorCode::Success);
    
    // 等待接收消息
    ASSERT_TRUE(wait_for_message_count(1));
    
    // 验证消息已收到
    EXPECT_EQ(received_messages_.size(), 1);
    EXPECT_EQ(received_messages_[0], 1);
    
    // 接收响应
    std::unique_ptr<communication::IMessage> response;
    auto result = client_manager->receive_message(response, 1000);
    
    // 验证响应
    ASSERT_EQ(result, common::ErrorCode::Success);
    ASSERT_NE(response, nullptr);
    EXPECT_EQ(response->message_type(), "TestAudioMessage");
    
    auto* typed_response = dynamic_cast<TestAudioMessage*>(response.get());
    ASSERT_NE(typed_response, nullptr);
    EXPECT_EQ(typed_response->sequence_number(), 1);
    EXPECT_EQ(typed_response->content(), "响应: 测试消息");
    
    // 关闭客户端
    client_manager->shutdown();
}

// ================================================================================================
// 音频缓冲区传输测试
// ================================================================================================
TEST_F(EngineCommunicationIntegrationTest, AudioBufferTransfer) {
    // 创建客户端配置，启用共享内存
    communication::CommunicationConfig client_config;
    client_config.process_name = "audio_client";
    client_config.routing_strategy = communication::RoutingStrategy::Auto;
    client_config.enable_zmq = true;
    client_config.enable_shm = true;
    
    // ZeroMQ配置
    communication::ZmqConfig zmq_config;
    zmq_config.endpoint = comm_endpoint_;
    zmq_config.socket_type = ZMQ_REQ;
    zmq_config.bind_instead_of_connect = false;
    client_config.zmq_configs.push_back(zmq_config);
    
    // 共享内存配置
    client_config.shm_config.segment_name = shm_segment_;
    client_config.shm_config.create_if_not_exists = false;
    
    // 创建客户端管理器
    auto client_manager = std::make_unique<communication::CommunicationManager>(
        client_config, message_factory_);
    
    // 初始化客户端
    ASSERT_EQ(client_manager->initialize(), common::ErrorCode::Success);
    
    // 创建测试音频缓冲区消息
    auto message = std::make_unique<AudioBufferMessage>(test_buffer_);
    
    // 发送缓冲区
    ASSERT_EQ(client_manager->send_message(*message), common::ErrorCode::Success);
    
    // 等待接收缓冲区
    ASSERT_TRUE(wait_for_buffer_count(1));
    
    // 验证缓冲区已收到且匹配
    EXPECT_EQ(received_buffers_, 1);
    EXPECT_EQ(matching_buffers_, 1);
    
    // 接收响应
    std::unique_ptr<communication::IMessage> response;
    auto result = client_manager->receive_message(response, 1000);
    
    // 验证响应
    ASSERT_EQ(result, common::ErrorCode::Success);
    ASSERT_NE(response, nullptr);
    EXPECT_EQ(response->message_type(), "AudioBufferMessage");
    
    auto* typed_response = dynamic_cast<AudioBufferMessage*>(response.get());
    ASSERT_NE(typed_response, nullptr);
    
    // 验证处理后的缓冲区 - 应该已应用0.8的增益
    const auto& processed_buffer = typed_response->buffer();
    EXPECT_EQ(processed_buffer.num_frames(), test_buffer_.num_frames());
    EXPECT_EQ(processed_buffer.num_channels(), test_buffer_.num_channels());
    EXPECT_EQ(processed_buffer.format(), test_buffer_.format());
    
    // 检查增益是否正确应用
    if (processed_buffer.format() == engine::AudioFormat::FLOAT32) {
        const float* original_data = test_buffer_.interleaved_data<float>();
        const float* processed_data = processed_buffer.interleaved_data<float>();
        
        for (size_t i = 0; i < processed_buffer.num_frames() * processed_buffer.num_channels(); i += 100) {
            EXPECT_NEAR(processed_data[i], original_data[i] * 0.8f, 0.0001f);
        }
    }
    
    // 关闭客户端
    client_manager->shutdown();
}

// ================================================================================================
// 大量消息传输测试
// ================================================================================================
TEST_F(EngineCommunicationIntegrationTest, HighVolumeMessageTransfer) {
    // 创建客户端配置
    communication::CommunicationConfig client_config;
    client_config.process_name = "high_volume_client";
    client_config.routing_strategy = communication::RoutingStrategy::Auto;
    client_config.enable_zmq = true;
    
    // ZeroMQ配置
    communication::ZmqConfig zmq_config;
    zmq_config.endpoint = comm_endpoint_;
    zmq_config.socket_type = ZMQ_REQ;
    zmq_config.bind_instead_of_connect = false;
    client_config.zmq_configs.push_back(zmq_config);
    
    // 创建客户端管理器
    auto client_manager = std::make_unique<communication::CommunicationManager>(
        client_config, message_factory_);
    
    // 初始化客户端
    ASSERT_EQ(client_manager->initialize(), common::ErrorCode::Success);
    
    // 发送多个消息
    const int message_count = 20;
    
    for (int i = 0; i < message_count; ++i) {
        // 创建测试消息
        auto message = std::make_unique<TestAudioMessage>(i, "批量测试消息 " + std::to_string(i));
        
        // 发送消息
        ASSERT_EQ(client_manager->send_message(*message), common::ErrorCode::Success);
        
        // 接收响应
        std::unique_ptr<communication::IMessage> response;
        auto result = client_manager->receive_message(response, 1000);
        
        // 验证响应
        ASSERT_EQ(result, common::ErrorCode::Success);
        ASSERT_NE(response, nullptr);
        
        auto* typed_response = dynamic_cast<TestAudioMessage*>(response.get());
        ASSERT_NE(typed_response, nullptr);
        EXPECT_EQ(typed_response->sequence_number(), i);
    }
    
    // 等待所有消息处理完成
    std::this_thread::sleep_for(100ms);
    
    // 验证接收到的消息数量
    EXPECT_EQ(received_messages_.size(), message_count);
    
    // 关闭客户端
    client_manager->shutdown();
}

// ================================================================================================
// 并发通信测试
// ================================================================================================
TEST_F(EngineCommunicationIntegrationTest, ConcurrentCommunication) {
    // 创建多个客户端管理器
    const int client_count = 5;
    std::vector<std::unique_ptr<communication::CommunicationManager>> clients;
    
    for (int i = 0; i < client_count; ++i) {
        // 创建客户端配置
        communication::CommunicationConfig client_config;
        client_config.process_name = "concurrent_client_" + std::to_string(i);
        client_config.routing_strategy = communication::RoutingStrategy::Auto;
        client_config.enable_zmq = true;
        
        // ZeroMQ配置
        communication::ZmqConfig zmq_config;
        zmq_config.endpoint = comm_endpoint_;
        zmq_config.socket_type = ZMQ_REQ;
        zmq_config.bind_instead_of_connect = false;
        client_config.zmq_configs.push_back(zmq_config);
        
        // 创建客户端管理器
        auto client = std::make_unique<communication::CommunicationManager>(
            client_config, message_factory_);
        
        // 初始化客户端
        ASSERT_EQ(client->initialize(), common::ErrorCode::Success);
        
        clients.push_back(std::move(client));
    }
    
    // 使用多线程同时发送消息
    std::vector<std::thread> threads;
    std::atomic<int> successful_messages(0);
    
    for (int i = 0; i < client_count; ++i) {
        threads.emplace_back([&, i]() {
            // 每个客户端发送5条消息
            for (int j = 0; j < 5; ++j) {
                // 创建测试消息
                auto message = std::make_unique<TestAudioMessage>(
                    i * 100 + j, 
                    "并发客户端 " + std::to_string(i) + " 消息 " + std::to_string(j));
                
                // 发送消息
                if (clients[i]->send_message(*message) == common::ErrorCode::Success) {
                    // 接收响应
                    std::unique_ptr<communication::IMessage> response;
                    auto result = clients[i]->receive_message(response, 1000);
                    
                    if (result == common::ErrorCode::Success && response) {
                        successful_messages++;
                    }
                }
                
                // 随机延迟
                std::this_thread::sleep_for(std::chrono::milliseconds(rand() % 50));
            }
        });
    }
    
    // 等待所有线程完成
    for (auto& thread : threads) {
        thread.join();
    }
    
    // 验证成功消息数
    EXPECT_EQ(successful_messages, client_count * 5);
    
    // 关闭所有客户端
    for (auto& client : clients) {
        client->shutdown();
    }
}

int main(int argc, char** argv) {
    ::testing::InitGoogleTest(&argc, argv);
    return RUN_ALL_TESTS();
}