#include <gtest/gtest.h>
#include <module/module_registry.h>
#include <module/imodule.h>
#include <types/const/priority.h>

using namespace extra2d;

// ============================================================================
// 测试用模块类
// ============================================================================

class TestModule : public IModule {
public:
    TestModule(const char* name, ModuleType type, int priority)
        : name_(name), type_(type), priority_(priority) {}

    const char* name() const override { return name_.c_str(); }
    ModuleType type() const override { return type_; }
    int priority() const override { return priority_; }

    bool init() override {
        initCalled = true;
        return initResult;
    }

    void shutdown() override {
        shutdownCalled = true;
    }

    std::string name_;
    ModuleType type_;
    int priority_;
    bool initCalled = false;
    bool shutdownCalled = false;
    bool initResult = true;
};

// ============================================================================
// ModuleRegistry 基础测试
// ============================================================================

TEST(ModuleRegistry, BasicOperations) {
    ModuleRegistry registry;

    TestModule module1("Module1", ModuleType::Feature, 0);
    TestModule module2("Module2", ModuleType::System, 10);

    // 注册模块
    registry.registerModule(&module1);
    EXPECT_EQ(1, registry.getModuleCount());
    EXPECT_TRUE(registry.hasModule("Module1"));

    registry.registerModule(&module2);
    EXPECT_EQ(2, registry.getModuleCount());
    EXPECT_TRUE(registry.hasModule("Module2"));

    // 获取模块
    EXPECT_EQ(&module1, registry.getModule("Module1"));
    EXPECT_EQ(&module2, registry.getModule("Module2"));
    EXPECT_EQ(nullptr, registry.getModule("NonExistent"));

    // 注销模块
    registry.unregisterModule("Module1");
    EXPECT_EQ(1, registry.getModuleCount());
    EXPECT_FALSE(registry.hasModule("Module1"));
    EXPECT_TRUE(registry.hasModule("Module2"));
}

TEST(ModuleRegistry, DuplicateRegistration) {
    ModuleRegistry registry;

    TestModule module1("SameName", ModuleType::Feature, 0);
    TestModule module2("SameName", ModuleType::System, 10);

    registry.registerModule(&module1);
    EXPECT_EQ(1, registry.getModuleCount());

    // 重复注册同名模块，后注册的应覆盖
    registry.registerModule(&module2);
    EXPECT_EQ(1, registry.getModuleCount());
    EXPECT_EQ(&module2, registry.getModule("SameName"));
}

TEST(ModuleRegistry, GetAllModules) {
    ModuleRegistry registry;

    TestModule module1("Module1", ModuleType::Feature, 0);
    TestModule module2("Module2", ModuleType::System, 10);
    TestModule module3("Module3", ModuleType::Core, 5);

    registry.registerModule(&module1);
    registry.registerModule(&module2);
    registry.registerModule(&module3);

    auto allModules = registry.getAllModules();
    EXPECT_EQ(3, allModules.size());
}

TEST(ModuleRegistry, GetModulesByType) {
    ModuleRegistry registry;

    TestModule coreModule("CoreModule", ModuleType::Core, 0);
    TestModule systemModule1("SystemModule1", ModuleType::System, 10);
    TestModule systemModule2("SystemModule2", ModuleType::System, 20);
    TestModule featureModule("FeatureModule", ModuleType::Feature, 5);

    registry.registerModule(&coreModule);
    registry.registerModule(&systemModule1);
    registry.registerModule(&systemModule2);
    registry.registerModule(&featureModule);

    auto coreModules = registry.getModulesByType(ModuleType::Core);
    EXPECT_EQ(1, coreModules.size());

    auto systemModules = registry.getModulesByType(ModuleType::System);
    EXPECT_EQ(2, systemModules.size());

    auto featureModules = registry.getModulesByType(ModuleType::Feature);
    EXPECT_EQ(1, featureModules.size());

    auto extensionModules = registry.getModulesByType(ModuleType::Extension);
    EXPECT_EQ(0, extensionModules.size());
}

// ============================================================================
// 初始化和关闭测试
// ============================================================================

TEST(ModuleRegistry, InitShutdown) {
    ModuleRegistry registry;

    TestModule module1("Module1", ModuleType::Feature, 0);
    TestModule module2("Module2", ModuleType::System, 10);

    registry.registerModule(&module1);
    registry.registerModule(&module2);

    // 初始化所有模块
    EXPECT_TRUE(registry.initAll());
    EXPECT_TRUE(module1.initCalled);
    EXPECT_TRUE(module2.initCalled);

    // 关闭所有模块
    registry.shutdownAll();
    EXPECT_TRUE(module1.shutdownCalled);
    EXPECT_TRUE(module2.shutdownCalled);
}

TEST(ModuleRegistry, InitFailure) {
    ModuleRegistry registry;

    TestModule module1("Module1", ModuleType::Feature, 0);
    TestModule module2("Module2", ModuleType::System, 10);
    module2.initResult = false; // 模拟初始化失败

    registry.registerModule(&module1);
    registry.registerModule(&module2);

    // 初始化应失败
    EXPECT_FALSE(registry.initAll());
    EXPECT_TRUE(module1.initCalled);
    EXPECT_TRUE(module2.initCalled);
}

TEST(ModuleRegistry, PriorityOrder) {
    ModuleRegistry registry;

    std::vector<std::string> initOrder;
    std::vector<std::string> shutdownOrder;

    class OrderTrackingModule : public IModule {
    public:
        OrderTrackingModule(const char* name, int priority,
                           std::vector<std::string>& initVec,
                           std::vector<std::string>& shutdownVec)
            : name_(name), priority_(priority),
              initOrder_(initVec), shutdownOrder_(shutdownVec) {}

        const char* name() const override { return name_.c_str(); }
        int priority() const override { return priority_; }

        bool init() override {
            initOrder_.push_back(name_);
            return true;
        }

        void shutdown() override {
            shutdownOrder_.push_back(name_);
        }

        std::string name_;
        int priority_;
        std::vector<std::string>& initOrder_;
        std::vector<std::string>& shutdownOrder_;
    };

    OrderTrackingModule module1("LowPriority", 100, initOrder, shutdownOrder);
    OrderTrackingModule module2("HighPriority", 10, initOrder, shutdownOrder);
    OrderTrackingModule module3("MediumPriority", 50, initOrder, shutdownOrder);

    registry.registerModule(&module1);
    registry.registerModule(&module2);
    registry.registerModule(&module3);

    registry.initAll();

    // 初始化应按优先级顺序（数值小的先初始化）
    EXPECT_EQ(3, initOrder.size());
    EXPECT_EQ("HighPriority", initOrder[0]);
    EXPECT_EQ("MediumPriority", initOrder[1]);
    EXPECT_EQ("LowPriority", initOrder[2]);

    registry.shutdownAll();

    // 关闭应按优先级逆序（数值大的先关闭）
    EXPECT_EQ(3, shutdownOrder.size());
    EXPECT_EQ("LowPriority", shutdownOrder[0]);
    EXPECT_EQ("MediumPriority", shutdownOrder[1]);
    EXPECT_EQ("HighPriority", shutdownOrder[2]);
}

// ============================================================================
// 空注册表测试
// ============================================================================

TEST(ModuleRegistry, EmptyRegistry) {
    ModuleRegistry registry;

    EXPECT_EQ(0, registry.getModuleCount());
    EXPECT_FALSE(registry.hasModule("AnyModule"));
    EXPECT_EQ(nullptr, registry.getModule("AnyModule"));

    auto allModules = registry.getAllModules();
    EXPECT_EQ(0, allModules.size());

    // 空注册表的初始化和关闭不应崩溃
    EXPECT_TRUE(registry.initAll());
    registry.shutdownAll();
}

TEST(ModuleRegistry, UnregisterNonExistent) {
    ModuleRegistry registry;

    // 注销不存在的模块不应崩溃
    EXPECT_NO_THROW(registry.unregisterModule("NonExistent"));
}

// ============================================================================
// 模块生命周期测试
// ============================================================================

TEST(ModuleRegistry, ModuleLifecycle) {
    ModuleRegistry registry;

    enum class State { Created, Initialized, Running, Shutdown };

    class LifecycleModule : public IModule {
    public:
        LifecycleModule(const char* name, State& state)
            : name_(name), state_(state) {
            state_ = State::Created;
        }

        const char* name() const override { return name_.c_str(); }

        bool init() override {
            state_ = State::Initialized;
            return true;
        }

        void shutdown() override {
            state_ = State::Shutdown;
        }

        std::string name_;
        State& state_;
    };

    State state = State::Created;
    LifecycleModule module("Lifecycle", state);

    EXPECT_EQ(State::Created, state);

    registry.registerModule(&module);
    registry.initAll();
    EXPECT_EQ(State::Initialized, state);

    registry.shutdownAll();
    EXPECT_EQ(State::Shutdown, state);
}

// ============================================================================
// 混合类型模块测试
// ============================================================================

TEST(ModuleRegistry, MixedModuleTypes) {
    ModuleRegistry registry;

    TestModule coreModule("Core", ModuleType::Core, Pri::System);
    TestModule systemModule("System", ModuleType::System, Pri::Window);
    TestModule featureModule("Feature", ModuleType::Feature, 0);
    TestModule extensionModule("Extension", ModuleType::Extension, 100);

    registry.registerModule(&coreModule);
    registry.registerModule(&systemModule);
    registry.registerModule(&featureModule);
    registry.registerModule(&extensionModule);

    EXPECT_EQ(4, registry.getModuleCount());

    EXPECT_TRUE(registry.initAll());
    EXPECT_TRUE(coreModule.initCalled);
    EXPECT_TRUE(systemModule.initCalled);
    EXPECT_TRUE(featureModule.initCalled);
    EXPECT_TRUE(extensionModule.initCalled);

    registry.shutdownAll();
    EXPECT_TRUE(coreModule.shutdownCalled);
    EXPECT_TRUE(systemModule.shutdownCalled);
    EXPECT_TRUE(featureModule.shutdownCalled);
    EXPECT_TRUE(extensionModule.shutdownCalled);
}