// ================================================================================================
// Audio Backend - 通信系统使用示例
// ================================================================================================
// 描述: 演示通信系统的基本使用方法
// ================================================================================================

#include "communication.h"
#include <iostream>
#include <thread>
#include <chrono>
#include <memory>
#include <string>

using namespace audio_backend;

// ================================================================================================
// 示例消息类型
// ================================================================================================
class AudioControlMessage : public communication::Message {
public:
    enum class Command { Start, Stop, Pause, Resume, SetVolume };
    
    AudioControlMessage(Command cmd, float value = 0.0f) 
        : Message("AudioControl"), command_(cmd), value_(value) {}
    
    Command command() const { return command_; }
    float value() const { return value_; }
    
    size_t estimated_size() const override {
        return sizeof(*this);
    }
    
    Priority priority() const override { 
        return command_ == Command::Stop ? Priority::High : Priority::Normal; 
    }
    
    TransportChannel preferred_channel() const override { 
        return TransportChannel::ZeroMQ; 
    }
    
private:
    Command command_;
    float value_;
};

// ================================================================================================
// 音频数据缓冲区消息
// ================================================================================================
class AudioBufferMessage : public communication::Message {
public:
    AudioBufferMessage(const std::vector<float>& samples) 
        : Message("AudioBuffer"), samples_(samples) {}
    
    const std::vector<float>& samples() const { return samples_; }
    
    size_t estimated_size() const override {
        return sizeof(float) * samples_.size();
    }
    
    Priority priority() const override { return Priority::High; }
    
    TransportChannel preferred_channel() const override { 
        // 大音频缓冲区使用共享内存
        return samples_.size() > 1024 ? TransportChannel::SharedMemory : TransportChannel::ZeroMQ;
    }
    
private:
    std::vector<float> samples_;
};

// ================================================================================================
// 通信事件监听器
// ================================================================================================
class DemoEventListener : public ICommunicationEventListener {
public:
    void on_message_sent(const std::string& message_type, size_t size, const std::string& transport) override {
        std::cout << "[EVENT] 消息已发送: " << message_type 
                  << " (大小: " << size << " 字节, 传输: " << transport << ")\n";
    }
    
    void on_message_received(const std::string& message_type, size_t size, const std::string& transport) override {
        std::cout << "[EVENT] 消息已接收: " << message_type 
                  << " (大小: " << size << " 字节, 传输: " << transport << ")\n";
    }
    
    void on_transport_connected(const std::string& transport_name) override {
        std::cout << "[EVENT] 传输已连接: " << transport_name << "\n";
    }
    
    void on_transport_disconnected(const std::string& transport_name) override {
        std::cout << "[EVENT] 传输已断开: " << transport_name << "\n";
    }
    
    void on_communication_error(CommError error, const std::string& description) override {
        std::cout << "[ERROR] 通信错误: " << description 
                  << " (错误代码: " << static_cast<int>(error) << ")\n";
    }
    
    void on_statistics_updated(const CommunicationStatistics& stats) override {
        std::cout << "[STATS] 统计更新 - 发送: " << stats.total_messages_sent.load() 
                  << ", 接收: " << stats.total_messages_received.load() << "\n";
    }
};

// ================================================================================================
// 共享内存演示
// ================================================================================================
void shared_memory_demo() {
    std::cout << "\n=== 共享内存演示 ===\n";
    
    // 配置共享内存
    ShmConfig config;
    config.segment_name = "demo_shm";
    config.segment_size = 1024 * 1024;  // 1MB
    config.create_if_not_exists = true;
    config.remove_on_destroy = true;
    
    // 创建共享内存管理器
    auto shm_manager = std::make_unique<ShmManager>(config);
    if (shm_manager->initialize() != ShmError::Success) {
        std::cerr << "共享内存初始化失败\n";
        return;
    }
    
    std::cout << "共享内存初始化成功\n";
    
    // 创建环形缓冲区用于音频数据
    const size_t buffer_size = 1024;
    RingBuffer<float> audio_ring(*shm_manager, "audio_samples", buffer_size);
    
    // 模拟生产者
    std::thread producer([&audio_ring]() {
        std::cout << "生产者开始工作...\n";
        for (int i = 0; i < 100; ++i) {
            float sample = std::sin(2.0f * 3.14159f * 440.0f * i / 44100.0f);
            while (!audio_ring.try_push(sample)) {
                std::this_thread::sleep_for(std::chrono::microseconds(1));
            }
            if (i % 20 == 0) {
                std::cout << "生产者已产生 " << (i + 1) << " 个样本\n";
            }
        }
        std::cout << "生产者完成\n";
    });
    
    // 模拟消费者
    std::thread consumer([&audio_ring]() {
        std::cout << "消费者开始工作...\n";
        float sample;
        int consumed = 0;
        while (consumed < 100) {
            if (audio_ring.try_pop(sample)) {
                consumed++;
                if (consumed % 20 == 0) {
                    std::cout << "消费者已消费 " << consumed << " 个样本\n";
                }
            } else {
                std::this_thread::sleep_for(std::chrono::microseconds(1));
            }
        }
        std::cout << "消费者完成\n";
    });
    
    producer.join();
    consumer.join();
    
    // 打印统计信息
    auto stats = shm_manager->get_statistics();
    std::cout << "共享内存统计:\n";
    std::cout << "  总大小: " << stats.total_size << " 字节\n";
    std::cout << "  已用大小: " << stats.used_size << " 字节\n";
    std::cout << "  空闲大小: " << stats.free_size << " 字节\n";
    
    shm_manager->shutdown();
    std::cout << "共享内存演示完成\n";
}

// ================================================================================================
// 主函数
// ================================================================================================
int main() {
    std::cout << "====================================\n";
    std::cout << "Audio Backend 通信系统演示\n";
    std::cout << "====================================\n";
    
    try {
        // 初始化通信系统
        communication_init::initialize_communication_system();
        
        std::cout << "\n1. 基础通信演示\n";
        std::cout << "====================\n";
        
        // 创建和测试基础通信功能
        auto manager = communication_utils::create_communication_manager("demo_main");
        
        if (manager->initialize() == CommError::Success) {
            std::cout << "通信管理器初始化成功\n";
            std::cout << "进程名称: " << manager->config().process_name << "\n";
            std::cout << "路由策略: " << static_cast<int>(manager->config().routing_strategy) << "\n";
            std::cout << "ZeroMQ支持: " << (manager->config().enable_zmq ? "是" : "否") << "\n";
            std::cout << "共享内存支持: " << (manager->config().enable_shm ? "是" : "否") << "\n";
            
            manager->shutdown();
        } else {
            std::cerr << "通信管理器初始化失败\n";
        }
        
        std::cout << "\n2. 工厂方法演示\n";
        std::cout << "====================\n";
        
        // 演示不同类型的通信管理器
        auto zmq_manager = CommManagerFactory::create_zmq_only("zmq_demo", {});
        if (zmq_manager) {
            std::cout << "ZeroMQ专用管理器创建成功\n";
        }
        
        ShmConfig shm_config;
        shm_config.segment_name = "demo_segment";
        shm_config.segment_size = 1024 * 1024;
        
        auto shm_manager = CommManagerFactory::create_shm_only("shm_demo", shm_config);
        if (shm_manager) {
            std::cout << "共享内存专用管理器创建成功\n";
        }
        
        auto hybrid_manager = CommManagerFactory::create_hybrid("hybrid_demo", {}, shm_config);
        if (hybrid_manager) {
            std::cout << "混合模式管理器创建成功\n";
        }
        
        std::cout << "\n3. 共享内存演示\n";
        std::cout << "====================\n";
        
        // 运行共享内存演示
        shared_memory_demo();
        
        // 关闭通信系统
        communication_init::shutdown_communication_system();
        
        std::cout << "\n====================================\n";
        std::cout << "演示完成\n";
        std::cout << "====================================\n";
        
    } catch (const std::exception& e) {
        std::cerr << "演示过程中发生错误: " << e.what() << "\n";
        return 1;
    }
    
    return 0;
}