// ================================================================================================
// Audio Backend - 设备管理器测试
// ================================================================================================

#include <gtest/gtest.h>
#include <gmock/gmock.h>
#include "frontend/device/device_manager.h"
#include "tests/common/test_fixtures.h"
#include <thread>
#include <chrono>
#include <memory>
#include <vector>
#include <string>

using namespace audio_backend;
using namespace audio_backend::frontend;
using namespace std::chrono_literals;

// 创建模拟设备事件监听器
class MockDeviceEventListener : public IDeviceEventListener {
public:
    MOCK_METHOD(void, on_device_added, (const AudioDeviceInfo&), (override));
    MOCK_METHOD(void, on_device_removed, (const std::string&), (override));
    MOCK_METHOD(void, on_device_state_changed, (const std::string&, DeviceState, DeviceState), (override));
    MOCK_METHOD(void, on_default_device_changed, (DeviceType, const std::string&), (override));
    MOCK_METHOD(void, on_device_config_changed, (const std::string&, const DeviceConfiguration&), (override));
    MOCK_METHOD(void, on_audio_data_available, (const std::string&, const engine::AudioBuffer&), (override));
    MOCK_METHOD(void, on_device_error, (const std::string&, common::ErrorCode, const std::string&), (override));
};

// 前端设备管理器测试固定装置
class DeviceManagerTest : public test::FrontendTest {
protected:
    void SetUp() override {
        test::FrontendTest::SetUp();
        
        // 创建设备管理器配置
        DeviceManagerConfig config;
        config.auto_detect_devices = true;
        config.enable_hot_plug_detection = true;
        config.device_scan_interval_ms = 500; // 缩短扫描间隔用于测试
        config.default_buffer_size = 256;
        config.enable_device_monitoring = true;
        
        // 创建设备管理器
        device_manager_ = device_factory::create_device_manager(config);
        
        // 创建模拟事件监听器
        event_listener_ = std::make_shared<::testing::NiceMock<MockDeviceEventListener>>();
        
        // 添加事件监听器
        device_manager_->add_event_listener(event_listener_);
    }
    
    void TearDown() override {
        // 移除事件监听器
        if (event_listener_ && device_manager_) {
            device_manager_->remove_event_listener(event_listener_);
        }
        
        // 如果已初始化，则关闭设备管理器
        if (device_manager_ && device_manager_->is_initialized()) {
            device_manager_->shutdown();
        }
        
        device_manager_.reset();
        event_listener_.reset();
        
        test::FrontendTest::TearDown();
    }
    
    // 创建测试设备配置
    DeviceConfiguration create_test_config(const std::string& device_id) {
        DeviceConfiguration config;
        config.device_id = device_id;
        config.sample_rate = 48000;
        config.channels = 2;
        config.format = engine::AudioFormat::FLOAT32;
        config.buffer_size = 256;
        config.exclusive_mode = false;
        config.enable_monitoring = true;
        config.volume = 0.8;
        config.muted = false;
        return config;
    }
    
    // 等待设备扫描完成
    void wait_for_device_scan() {
        std::this_thread::sleep_for(1s);
    }

protected:
    std::unique_ptr<DeviceManager> device_manager_;
    std::shared_ptr<MockDeviceEventListener> event_listener_;
};

// 测试设备管理器初始化
TEST_F(DeviceManagerTest, Initialization) {
    // 初始化前状态
    EXPECT_FALSE(device_manager_->is_initialized());
    
    // 初始化
    auto result = device_manager_->initialize();
    
    // 验证初始化成功
    EXPECT_EQ(result, common::ErrorCode::Success);
    EXPECT_TRUE(device_manager_->is_initialized());
    
    // 关闭
    result = device_manager_->shutdown();
    
    // 验证关闭成功
    EXPECT_EQ(result, common::ErrorCode::Success);
    EXPECT_FALSE(device_manager_->is_initialized());
}

// 测试设备枚举
TEST_F(DeviceManagerTest, DeviceEnumeration) {
    // 初始化设备管理器
    ASSERT_EQ(device_manager_->initialize(), common::ErrorCode::Success);
    
    // 等待设备扫描完成
    wait_for_device_scan();
    
    // 获取所有设备
    auto all_devices = device_manager_->get_all_devices();
    
    // 获取输入设备
    auto input_devices = device_manager_->get_input_devices();
    
    // 获取输出设备
    auto output_devices = device_manager_->get_output_devices();
    
    // 验证设备列表
    EXPECT_GE(all_devices.size(), input_devices.size() + output_devices.size());
    
    // 验证输入设备类型
    for (const auto& device : input_devices) {
        EXPECT_TRUE(device.type == DeviceType::Input || device.type == DeviceType::Duplex);
    }
    
    // 验证输出设备类型
    for (const auto& device : output_devices) {
        EXPECT_TRUE(device.type == DeviceType::Output || device.type == DeviceType::Duplex);
    }
    
    // 获取默认输入设备
    std::string default_input = device_manager_->get_default_input_device();
    
    // 获取默认输出设备
    std::string default_output = device_manager_->get_default_output_device();
    
    // 如果有输入设备，默认输入设备不应为空
    if (!input_devices.empty()) {
        EXPECT_FALSE(default_input.empty());
    }
    
    // 如果有输出设备，默认输出设备不应为空
    if (!output_devices.empty()) {
        EXPECT_FALSE(default_output.empty());
    }
    
    // 检查设备详情
    if (!all_devices.empty()) {
        const auto& first_device = all_devices[0];
        
        // 通过ID获取设备信息
        auto device_info = device_manager_->get_device_info(first_device.id);
        EXPECT_TRUE(device_info.has_value());
        EXPECT_EQ(device_info->id, first_device.id);
        EXPECT_EQ(device_info->name, first_device.name);
    }
}

// 测试设备配置
TEST_F(DeviceManagerTest, DeviceConfiguration) {
    // 初始化设备管理器
    ASSERT_EQ(device_manager_->initialize(), common::ErrorCode::Success);
    
    // 等待设备扫描完成
    wait_for_device_scan();
    
    // 获取输出设备
    auto output_devices = device_manager_->get_output_devices();
    if (output_devices.empty()) {
        GTEST_SKIP() << "没有可用的输出设备，跳过测试";
    }
    
    // 获取第一个输出设备
    const auto& test_device = output_devices[0];
    
    // 创建配置
    DeviceConfiguration config = create_test_config(test_device.id);
    
    // 期望配置事件回调
    EXPECT_CALL(*event_listener_, on_device_config_changed(test_device.id, ::testing::_))
        .Times(::testing::AtLeast(0));
    
    // 配置设备
    auto result = device_manager_->configure_device(config);
    EXPECT_EQ(result, common::ErrorCode::Success);
    
    // 获取设备配置
    auto stored_config = device_manager_->get_device_configuration(test_device.id);
    EXPECT_TRUE(stored_config.has_value());
    
    // 验证配置
    if (stored_config) {
        EXPECT_EQ(stored_config->device_id, config.device_id);
        EXPECT_EQ(stored_config->sample_rate, config.sample_rate);
        EXPECT_EQ(stored_config->channels, config.channels);
        EXPECT_EQ(stored_config->format, config.format);
        EXPECT_EQ(stored_config->buffer_size, config.buffer_size);
        EXPECT_EQ(stored_config->exclusive_mode, config.exclusive_mode);
        EXPECT_FLOAT_EQ(stored_config->volume, config.volume);
        EXPECT_EQ(stored_config->muted, config.muted);
    }
    
    // 修改音量
    double new_volume = 0.5;
    result = device_manager_->set_device_volume(test_device.id, new_volume);
    EXPECT_EQ(result, common::ErrorCode::Success);
    
    // 获取音量
    double current_volume = 0.0;
    result = device_manager_->get_device_volume(test_device.id, current_volume);
    EXPECT_EQ(result, common::ErrorCode::Success);
    EXPECT_FLOAT_EQ(current_volume, new_volume);
    
    // 设置静音
    bool new_mute = true;
    result = device_manager_->set_device_mute(test_device.id, new_mute);
    EXPECT_EQ(result, common::ErrorCode::Success);
    
    // 获取静音状态
    bool current_mute = false;
    result = device_manager_->get_device_mute(test_device.id, current_mute);
    EXPECT_EQ(result, common::ErrorCode::Success);
    EXPECT_EQ(current_mute, new_mute);
}

// 测试音频流控制
TEST_F(DeviceManagerTest, AudioStreamControl) {
    // 初始化设备管理器
    ASSERT_EQ(device_manager_->initialize(), common::ErrorCode::Success);
    
    // 等待设备扫描完成
    wait_for_device_scan();
    
    // 获取输入和输出设备
    auto input_devices = device_manager_->get_input_devices();
    auto output_devices = device_manager_->get_output_devices();
    
    // 测试输入流
    if (!input_devices.empty()) {
        const auto& input_device = input_devices[0];
        
        // 配置设备
        DeviceConfiguration input_config = create_test_config(input_device.id);
        ASSERT_EQ(device_manager_->configure_device(input_config), common::ErrorCode::Success);
        
        // 期望音频数据回调
        EXPECT_CALL(*event_listener_, on_audio_data_available(input_device.id, ::testing::_))
            .Times(::testing::AtLeast(0));
        
        // 启动输入流
        auto result = device_manager_->start_input_stream(input_device.id);
        EXPECT_EQ(result, common::ErrorCode::Success);
        
        // 等待一些音频帧
        std::this_thread::sleep_for(500ms);
        
        // 读取音频数据
        engine::AudioBuffer buffer(512, 2, engine::AudioFormat::FLOAT32);
        result = device_manager_->read_audio_data(input_device.id, buffer, 100ms);
        
        // 停止输入流
        result = device_manager_->stop_input_stream(input_device.id);
        EXPECT_EQ(result, common::ErrorCode::Success);
    }
    
    // 测试输出流
    if (!output_devices.empty()) {
        const auto& output_device = output_devices[0];
        
        // 配置设备
        DeviceConfiguration output_config = create_test_config(output_device.id);
        ASSERT_EQ(device_manager_->configure_device(output_config), common::ErrorCode::Success);
        
        // 启动输出流
        auto result = device_manager_->start_output_stream(output_device.id);
        EXPECT_EQ(result, common::ErrorCode::Success);
        
        // 创建测试音频缓冲区
        engine::AudioBuffer test_buffer(512, 2, engine::AudioFormat::FLOAT32);
        
        // 填充音频数据
        float* data = test_buffer.interleaved_data<float>();
        for (size_t i = 0; i < 512 * 2; ++i) {
            data[i] = 0.1f * std::sin(2.0f * M_PI * i / 100.0f);
        }
        
        // 写入音频数据
        result = device_manager_->write_audio_data(output_device.id, test_buffer);
        EXPECT_EQ(result, common::ErrorCode::Success);
        
        // 等待一些音频帧
        std::this_thread::sleep_for(500ms);
        
        // 停止输出流
        result = device_manager_->stop_output_stream(output_device.id);
        EXPECT_EQ(result, common::ErrorCode::Success);
    }
}

// 测试默认设备变更
TEST_F(DeviceManagerTest, DefaultDeviceChanges) {
    // 初始化设备管理器
    ASSERT_EQ(device_manager_->initialize(), common::ErrorCode::Success);
    
    // 等待设备扫描完成
    wait_for_device_scan();
    
    // 获取输入和输出设备
    auto input_devices = device_manager_->get_input_devices();
    auto output_devices = device_manager_->get_output_devices();
    
    // 测试输入设备变更
    if (input_devices.size() >= 2) {
        // 获取当前默认输入设备
        std::string current_default = device_manager_->get_default_input_device();
        
        // 找到一个不是默认的输入设备
        std::string new_default;
        for (const auto& device : input_devices) {
            if (device.id != current_default) {
                new_default = device.id;
                break;
            }
        }
        
        // 设置期望回调
        EXPECT_CALL(*event_listener_, on_default_device_changed(DeviceType::Input, new_default))
            .Times(::testing::AtLeast(0));
        
        // 更改默认输入设备
        auto result = device_manager_->set_default_input_device(new_default);
        EXPECT_EQ(result, common::ErrorCode::Success);
        
        // 验证更改
        EXPECT_EQ(device_manager_->get_default_input_device(), new_default);
    }
    
    // 测试输出设备变更
    if (output_devices.size() >= 2) {
        // 获取当前默认输出设备
        std::string current_default = device_manager_->get_default_output_device();
        
        // 找到一个不是默认的输出设备
        std::string new_default;
        for (const auto& device : output_devices) {
            if (device.id != current_default) {
                new_default = device.id;
                break;
            }
        }
        
        // 设置期望回调
        EXPECT_CALL(*event_listener_, on_default_device_changed(DeviceType::Output, new_default))
            .Times(::testing::AtLeast(0));
        
        // 更改默认输出设备
        auto result = device_manager_->set_default_output_device(new_default);
        EXPECT_EQ(result, common::ErrorCode::Success);
        
        // 验证更改
        EXPECT_EQ(device_manager_->get_default_output_device(), new_default);
    }
}

// 测试设备统计信息
TEST_F(DeviceManagerTest, DeviceStatistics) {
    // 初始化设备管理器
    ASSERT_EQ(device_manager_->initialize(), common::ErrorCode::Success);
    
    // 等待设备扫描完成
    wait_for_device_scan();
    
    // 获取输出设备
    auto output_devices = device_manager_->get_output_devices();
    if (output_devices.empty()) {
        GTEST_SKIP() << "没有可用的输出设备，跳过测试";
    }
    
    const auto& output_device = output_devices[0];
    
    // 配置设备
    DeviceConfiguration output_config = create_test_config(output_device.id);
    ASSERT_EQ(device_manager_->configure_device(output_config), common::ErrorCode::Success);
    
    // 启动输出流
    ASSERT_EQ(device_manager_->start_output_stream(output_device.id), common::ErrorCode::Success);
    
    // 发送一些音频数据
    for (int i = 0; i < 10; i++) {
        // 创建测试音频缓冲区
        engine::AudioBuffer test_buffer(512, 2, engine::AudioFormat::FLOAT32);
        
        // 填充音频数据
        float* data = test_buffer.interleaved_data<float>();
        for (size_t j = 0; j < 512 * 2; ++j) {
            data[j] = 0.1f * std::sin(2.0f * M_PI * j / 100.0f);
        }
        
        // 写入音频数据
        ASSERT_EQ(device_manager_->write_audio_data(output_device.id, test_buffer), common::ErrorCode::Success);
        
        std::this_thread::sleep_for(50ms);
    }
    
    // 停止输出流
    ASSERT_EQ(device_manager_->stop_output_stream(output_device.id), common::ErrorCode::Success);
    
    // 获取全局统计信息
    const auto& stats = device_manager_->get_statistics();
    
    // 验证帧处理计数
    EXPECT_GT(stats.frames_processed.load(), 0);
    
    // 获取设备特定统计信息
    auto device_stats = device_manager_->get_device_statistics(output_device.id);
    EXPECT_TRUE(device_stats.has_value());
    
    if (device_stats) {
        EXPECT_GT(device_stats->frames_processed.load(), 0);
    }
    
    // 重置统计信息
    device_manager_->reset_statistics();
    
    // 验证统计信息已重置
    const auto& reset_stats = device_manager_->get_statistics();
    EXPECT_EQ(reset_stats.frames_processed.load(), 0);
    EXPECT_EQ(reset_stats.buffer_underruns.load(), 0);
    EXPECT_EQ(reset_stats.buffer_overruns.load(), 0);
}

// 测试设备管理器配置更新
TEST_F(DeviceManagerTest, ConfigUpdate) {
    // 初始化设备管理器
    ASSERT_EQ(device_manager_->initialize(), common::ErrorCode::Success);
    
    // 获取当前配置
    const auto& initial_config = device_manager_->config();
    
    // 创建新配置
    DeviceManagerConfig new_config = initial_config;
    new_config.default_buffer_size = 1024; // 修改缓冲区大小
    new_config.device_scan_interval_ms = 2000; // 修改扫描间隔
    
    // 更新配置
    auto result = device_manager_->update_config(new_config);
    EXPECT_EQ(result, common::ErrorCode::Success);
    
    // 验证配置更新
    const auto& updated_config = device_manager_->config();
    EXPECT_EQ(updated_config.default_buffer_size, 1024);
    EXPECT_EQ(updated_config.device_scan_interval_ms, 2000);
}

// 测试设备工厂方法
TEST_F(DeviceManagerTest, DeviceFactory) {
    // 获取系统推荐配置
    auto recommended_config = device_factory::get_recommended_config();
    
    // 验证推荐配置的合理性
    EXPECT_GE(recommended_config.default_buffer_size, 64);
    EXPECT_LE(recommended_config.default_buffer_size, 8192);
    
    // 获取可用的驱动
    auto available_drivers = device_factory::detect_available_drivers();
    
    // 验证至少有一个可用的驱动
    EXPECT_FALSE(available_drivers.empty());
    
    // 验证驱动类型有效
    for (auto driver : available_drivers) {
        EXPECT_NE(driver, DeviceDriver::Unknown);
    }
}

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