// ================================================================================================
// Audio Backend - 沙盒工厂测试
// ================================================================================================

#include <gtest/gtest.h>
#include <gmock/gmock.h>
#include "plugin_host/sandbox/sandbox_interface.h"
#include "tests/common/test_fixtures.h"

using namespace audio_backend;
using namespace audio_backend::plugin_host;

// 沙盒工厂测试固定装置
class SandboxFactoryTest : public test::PluginSandboxTest {
protected:
    void SetUp() override {
        test::PluginSandboxTest::SetUp();
    }
    
    void TearDown() override {
        test::PluginSandboxTest::TearDown();
    }
    
    // 创建基础沙盒配置
    SandboxConfig create_basic_config() {
        SandboxConfig config;
        config.sandbox_type = SandboxType::ProcessLevelIsolation;
        config.process_creation_timeout = 5000;
        config.enable_heartbeat = true;
        config.heartbeat_interval_ms = 1000;
        config.heartbeat_timeout_ms = 5000;
        config.enable_resource_monitoring = true;
        config.resource_monitoring_interval_ms = 1000;
        return config;
    }
};

// 测试获取支持的沙盒类型
TEST_F(SandboxFactoryTest, GetSupportedSandboxTypes) {
    // 获取支持的沙盒类型
    auto types = SandboxFactory::get_supported_sandbox_types();
    
    // 验证至少支持一种类型
    EXPECT_FALSE(types.empty());
    
    // 验证支持的类型是有效的
    for (auto type : types) {
        EXPECT_NE(type, SandboxType::Unknown);
    }
    
    // 验证ProcessLevelIsolation类型应该被大多数平台支持
    EXPECT_TRUE(std::find(types.begin(), types.end(), SandboxType::ProcessLevelIsolation) != types.end());
}

// 测试检查特定沙盒类型是否被支持
TEST_F(SandboxFactoryTest, IsSandboxTypeSupported) {
    // 检查ProcessLevelIsolation类型应该被支持
    EXPECT_TRUE(SandboxFactory::is_sandbox_type_supported(SandboxType::ProcessLevelIsolation));
    
    // 检查Unknown类型应该不被支持
    EXPECT_FALSE(SandboxFactory::is_sandbox_type_supported(SandboxType::Unknown));
    
    // 检查所有支持的类型
    auto supported_types = SandboxFactory::get_supported_sandbox_types();
    for (auto type : supported_types) {
        EXPECT_TRUE(SandboxFactory::is_sandbox_type_supported(type));
    }
}

// 测试获取推荐的沙盒类型
TEST_F(SandboxFactoryTest, GetRecommendedSandboxType) {
    // 获取推荐的沙盒类型
    auto recommended_type = SandboxFactory::get_recommended_sandbox_type();
    
    // 验证推荐的类型是有效的
    EXPECT_NE(recommended_type, SandboxType::Unknown);
    
    // 验证推荐的类型是被支持的
    EXPECT_TRUE(SandboxFactory::is_sandbox_type_supported(recommended_type));
}

// 测试创建平台特定的沙盒
TEST_F(SandboxFactoryTest, CreatePlatformSandbox) {
    // 创建基础配置
    SandboxConfig config = create_basic_config();
    
    // 创建平台特定的沙盒
    auto sandbox = SandboxFactory::create_platform_sandbox(config);
    
    // 验证沙盒创建成功
    EXPECT_NE(sandbox, nullptr);
    
    // 验证沙盒类型
    EXPECT_NE(sandbox->get_sandbox_type(), SandboxType::Unknown);
    
    // 验证沙盒配置
    EXPECT_EQ(sandbox->get_config().sandbox_type, sandbox->get_sandbox_type());
    EXPECT_EQ(sandbox->get_config().process_creation_timeout, config.process_creation_timeout);
    EXPECT_EQ(sandbox->get_config().enable_heartbeat, config.enable_heartbeat);
}

// 测试创建指定类型的沙盒
TEST_F(SandboxFactoryTest, CreateSpecificTypeSandbox) {
    // 创建基础配置
    SandboxConfig config = create_basic_config();
    
    // 获取支持的沙盒类型
    auto supported_types = SandboxFactory::get_supported_sandbox_types();
    if (supported_types.empty()) {
        GTEST_SKIP() << "No supported sandbox types available on this platform";
    }
    
    // 选择第一个支持的类型
    SandboxType type = supported_types[0];
    config.sandbox_type = type;
    
    // 创建指定类型的沙盒
    auto sandbox = SandboxFactory::create_sandbox(type, config);
    
    // 验证沙盒创建成功
    EXPECT_NE(sandbox, nullptr);
    
    // 验证沙盒类型
    EXPECT_EQ(sandbox->get_sandbox_type(), type);
    
    // 验证沙盒配置
    EXPECT_EQ(sandbox->get_config().sandbox_type, type);
    EXPECT_EQ(sandbox->get_config().process_creation_timeout, config.process_creation_timeout);
    EXPECT_EQ(sandbox->get_config().enable_heartbeat, config.enable_heartbeat);
}

// 测试创建不支持的沙盒类型
TEST_F(SandboxFactoryTest, CreateUnsupportedSandboxType) {
    // 创建基础配置
    SandboxConfig config = create_basic_config();
    
    // 设置不支持的类型
    config.sandbox_type = SandboxType::Unknown;
    
    // 尝试创建不支持的类型
    auto sandbox = SandboxFactory::create_sandbox(SandboxType::Unknown, config);
    
    // 应该返回nullptr
    EXPECT_EQ(sandbox, nullptr);
}

// 测试创建沙盒并验证初始化
TEST_F(SandboxFactoryTest, CreateAndInitializeSandbox) {
    // 创建基础配置
    SandboxConfig config = create_basic_config();
    
    // 创建平台特定的沙盒
    auto sandbox = SandboxFactory::create_platform_sandbox(config);
    ASSERT_NE(sandbox, nullptr);
    
    // 初始化沙盒
    auto result = sandbox->initialize(config);
    EXPECT_EQ(result, common::ErrorCode::Success);
    EXPECT_TRUE(sandbox->is_initialized());
    
    // 关闭沙盒
    result = sandbox->shutdown();
    EXPECT_EQ(result, common::ErrorCode::Success);
    EXPECT_FALSE(sandbox->is_initialized());
}

// 测试创建多个不同类型的沙盒
TEST_F(SandboxFactoryTest, CreateMultipleSandboxTypes) {
    // 获取支持的沙盒类型
    auto supported_types = SandboxFactory::get_supported_sandbox_types();
    if (supported_types.size() < 2) {
        GTEST_SKIP() << "Fewer than 2 supported sandbox types available on this platform";
    }
    
    // 创建基础配置
    SandboxConfig config = create_basic_config();
    
    // 创建不同类型的沙盒
    std::vector<std::unique_ptr<ISandbox>> sandboxes;
    for (auto type : supported_types) {
        config.sandbox_type = type;
        auto sandbox = SandboxFactory::create_sandbox(type, config);
        
        if (sandbox) {
            EXPECT_EQ(sandbox->get_sandbox_type(), type);
            sandboxes.push_back(std::move(sandbox));
        }
    }
    
    // 验证创建的沙盒类型
    EXPECT_GE(sandboxes.size(), 1);
    
    // 验证创建的沙盒类型各不相同
    std::set<SandboxType> unique_types;
    for (const auto& sandbox : sandboxes) {
        unique_types.insert(sandbox->get_sandbox_type());
    }
    EXPECT_EQ(unique_types.size(), sandboxes.size());
}

// 测试沙盒类型的字符串转换
TEST_F(SandboxFactoryTest, SandboxTypeStringConversion) {
    // 定义沙盒类型和对应的字符串
    const std::vector<std::pair<SandboxType, std::string>> type_strings = {
        {SandboxType::Unknown, "Unknown"},
        {SandboxType::ProcessLevelIsolation, "ProcessLevelIsolation"},
        {SandboxType::ContainerBased, "ContainerBased"},
        {SandboxType::VirtualMachine, "VirtualMachine"},
        {SandboxType::WindowsAppContainer, "WindowsAppContainer"},
        {SandboxType::LinuxNamespace, "LinuxNamespace"},
        {SandboxType::MacOSSandbox, "MacOSSandbox"},
        {SandboxType::BrowserIsolation, "BrowserIsolation"},
        {SandboxType::Emulation, "Emulation"}
    };
    
    // 为沙盒类型到字符串的函数声明一个函数指针类型
    using SandboxTypeToStringFunc = std::string (*)(SandboxType);
    
    // 获取所有支持的沙盒类型
    auto supported_types = SandboxFactory::get_supported_sandbox_types();
    
    // 遍历所有类型
    for (const auto& [type, expected_str] : type_strings) {
        // 检查类型是否被支持
        bool is_supported = std::find(supported_types.begin(), supported_types.end(), type) != supported_types.end();
        
        // 如果有实现获取类型字符串的函数，可以使用它
        // (这里假设有这样的函数，实际上可能没有，但这是单元测试，所以我们可以测试预期的行为)
        
        // 创建一个简单的检查，验证类型和字符串的一致性
        if (is_supported) {
            // 这是一种方法来检查类型的字符串表示，取决于实际实现
            std::stringstream ss;
            ss << "检查沙盒类型: " << static_cast<int>(type);
            EXPECT_FALSE(expected_str.empty()) << ss.str();
        }
    }
}

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