#include <gtest/gtest.h>
#include <gmock/gmock.h>
#include "app.hpp"
#include <string>
#include <vector>
#include <chrono>

using namespace testing;

// ============================================================================
// CmsEngine 测试套件
// ============================================================================

class CmsEngineTest : public Test {
protected:
    CmsEngine engine;

    void SetUp() override {
        // 每个测试用例开始前重置引擎状态
    }

    void TearDown() override {
        // 每个测试用例结束后清理
    }

    // 辅助函数：创建一个有效的事件记录（根据实际 EventRecord 结构定义）
    EventRecord createValidEvent(const std::string& id = "EVT-001", 
                                  uint32_t priority = 100,
                                  EventStatus status = EventStatus::Pending) {
        EventRecord event;
        event.id = id;
        event.priority = priority;
        event.status = status;
        // 注意：根据编译错误，EventRecord 没有 timestamp, source, type 成员
        // 因此这里只设置实际存在的成员
        return event;
    }

    // 辅助函数：创建多个事件并接入
    void ingestMultipleEvents(size_t count) {
        for (size_t i = 0; i < count; ++i) {
            EventRecord event = createValidEvent("EVT-" + std::to_string(i + 1), 100);
            engine.ingestEvent(event);
        }
    }
};

// ============================================================================
// CmsEngine 构造函数测试
// ============================================================================

TEST_F(CmsEngineTest, testCmsEngineDefaultConstructor) {
    // 正常输入测试：验证默认构造函数正确初始化
    const auto& context = engine.getSystemContext();
    EXPECT_EQ(context.currentMode, RunMode::Idle);
    EXPECT_EQ(context.consistencyMark, 0);
    EXPECT_EQ(context.contextSnapshot, R"({"mode":"Idle","version":"1.0.0"})");
    
    // 验证初始状态为空
    EXPECT_EQ(engine.getAllPlans().size(), 0);
    EXPECT_EQ(engine.getSummary().find("Events          : 0") != std::string::npos, true);
}

TEST_F(CmsEngineTest, testCmsEngineMultipleInstances) {
    // 正常输入测试：多个实例独立运行
    CmsEngine engine1;
    CmsEngine engine2;
    
    // 向 engine1 添加事件
    EventRecord event1 = createValidEvent("EVT-001", 100);
    engine1.ingestEvent(event1);
    
    // 验证 engine2 不受影响
    EXPECT_EQ(engine2.getSummary().find("Events          : 0") != std::string::npos, true);
    EXPECT_EQ(engine1.getSummary().find("Events          : 1") != std::string::npos, true);
}

TEST_F(CmsEngineTest, testCmsEngineConstructorIdGeneration) {
    // 特殊场景测试：验证构造函数后 ID 生成器从 0 开始
    // 通过 processPendingEvents 间接验证 ID 生成
    EventRecord event = createValidEvent("EVT-001", 100, EventStatus::Pending);
    engine.ingestEvent(event);
    
    size_t processed = engine.processPendingEvents();
    EXPECT_EQ(processed, 1);
    
    const auto& plans = engine.getAllPlans();
    EXPECT_EQ(plans.size(), 1);
    EXPECT_EQ(plans[0].id, "ID-00001");
}

// ============================================================================
// ingestEvent 函数测试
// ============================================================================

TEST_F(CmsEngineTest, testIngestEventValidEvent) {
    // 正常输入测试：接入有效事件
    EventRecord event = createValidEvent("EVT-001", 100);
    bool result = engine.ingestEvent(event);
    EXPECT_TRUE(result);
    
    // 验证事件已存储
    const EventRecord* found = engine.findEventById("EVT-001");
    ASSERT_NE(found, nullptr);
    EXPECT_EQ(found->priority, 100);
    EXPECT_EQ(found->status, EventStatus::Pending);
}

TEST_F(CmsEngineTest, testIngestEventEmptyId) {
    // 边界值测试：空 ID 事件
    EventRecord event = createValidEvent("", 100);
    bool result = engine.ingestEvent(event);
    EXPECT_FALSE(result);
    
    // 验证事件未被存储
    EXPECT_EQ(engine.findEventById(""), nullptr);
}

TEST_F(CmsEngineTest, testIngestEventMaxPriority) {
    // 边界值测试：最大优先级（255）
    EventRecord event = createValidEvent("EVT-001", 255);
    bool result = engine.ingestEvent(event);
    EXPECT_TRUE(result);
    
    const EventRecord* found = engine.findEventById("EVT-001");
    ASSERT_NE(found, nullptr);
    EXPECT_EQ(found->priority, 255);
}

TEST_F(CmsEngineTest, testIngestEventExceedMaxPriority) {
    // 异常输入测试：超过最大优先级
    EventRecord event = createValidEvent("EVT-001", 256);
    bool result = engine.ingestEvent(event);
    EXPECT_FALSE(result);
    
    // 验证事件未被存储
    EXPECT_EQ(engine.findEventById("EVT-001"), nullptr);
}

TEST_F(CmsEngineTest, testIngestEventZeroPriority) {
    // 边界值测试：零优先级
    EventRecord event = createValidEvent("EVT-001", 0);
    bool result = engine.ingestEvent(event);
    EXPECT_TRUE(result);
    
    const EventRecord* found = engine.findEventById("EVT-001");
    ASSERT_NE(found, nullptr);
    EXPECT_EQ(found->priority, 0);
}

TEST_F(CmsEngineTest, testIngestEventMultipleEvents) {
    // 正常输入测试：接入多个事件
    ingestMultipleEvents(5);
    
    for (size_t i = 0; i < 5; ++i) {
        std::string id = "EVT-" + std::to_string(i + 1);
        const EventRecord* found = engine.findEventById(id);
        ASSERT_NE(found, nullptr) << "Event " << id << " not found";
        EXPECT_EQ(found->priority, 100);
    }
}

TEST_F(CmsEngineTest, testIngestEventDuplicateId) {
    // 特殊场景测试：重复 ID 的事件
    EventRecord event1 = createValidEvent("EVT-001", 100);
    EventRecord event2 = createValidEvent("EVT-001", 200);
    
    EXPECT_TRUE(engine.ingestEvent(event1));
    EXPECT_TRUE(engine.ingestEvent(event2));  // 允许重复 ID
    
    // 验证两个事件都被存储
    const EventRecord* found = engine.findEventById("EVT-001");
    ASSERT_NE(found, nullptr);
    // findEventById 返回第一个匹配的事件
    EXPECT_EQ(found->priority, 100);
}

TEST_F(CmsEngineTest, testIngestEventSpecialCharacters) {
    // 边界值测试：特殊字符 ID
    EventRecord event = createValidEvent("EVT-@#$%^&*()", 100);
    bool result = engine.ingestEvent(event);
    EXPECT_TRUE(result);
    
    const EventRecord* found = engine.findEventById("EVT-@#$%^&*()");
    ASSERT_NE(found, nullptr);
}

TEST_F(CmsEngineTest, testIngestEventVeryLongId) {
    // 边界值测试：超长 ID
    std::string longId(1000, 'A');
    EventRecord event = createValidEvent(longId, 100);
    bool result = engine.ingestEvent(event);
    EXPECT_TRUE(result);
    
    const EventRecord* found = engine.findEventById(longId);
    ASSERT_NE(found, nullptr);
}

// ============================================================================
// processPendingEvents 函数测试
// ============================================================================

TEST_F(CmsEngineTest, testProcessPendingEventsNoEvents) {
    // 边界值测试：无事件
    size_t processed = engine.processPendingEvents();
    EXPECT_EQ(processed, 0);
    
    // 验证没有生成方案
    EXPECT_EQ(engine.getAllPlans().size(), 0);
}

TEST_F(CmsEngineTest, testProcessPendingEventsSingleEvent) {
    // 正常输入测试：处理单个待处理事件
    EventRecord event = createValidEvent("EVT-001", 100, EventStatus::Pending);
    engine.ingestEvent(event);
    
    size_t processed = engine.processPendingEvents();
    EXPECT_EQ(processed, 1);
    
    // 验证事件状态已更新
    const EventRecord* found = engine.findEventById("EVT-001");
    ASSERT_NE(found, nullptr);
    EXPECT_EQ(found->status, EventStatus::Generated);
    
    // 验证生成了对应的方案
    const auto& plans = engine.getAllPlans();
    EXPECT_EQ(plans.size(), 1);
    EXPECT_EQ(plans[0].name, "AutoPlan-EVT-001");
    EXPECT_EQ(plans[0].type, PlanType::Centralized);
    EXPECT_EQ(plans[0].status, PlanStatus::Drafting);
    EXPECT_EQ(plans[0].relatedEventId, "EVT-001");
    EXPECT_EQ(plans[0].resourceQuota, 0.5);
    EXPECT_EQ(plans[0].constraints, "自动生成约束");
}

TEST_F(CmsEngineTest, testProcessPendingEventsMultipleEvents) {
    // 正常输入测试：处理多个待处理事件
    ingestMultipleEvents(5);
    
    size_t processed = engine.processPendingEvents();
    EXPECT_EQ(processed, 5);
    
    // 验证所有事件状态已更新
    for (size_t i = 0; i < 5; ++i) {
        std::string id = "EVT-" + std::to_string(i + 1);
        const EventRecord* found = engine.findEventById(id);
        ASSERT_NE(found, nullptr);
        EXPECT_EQ(found->status, EventStatus::Generated);
    }
    
    // 验证生成了对应的方案
    const auto& plans = engine.getAllPlans();
    EXPECT_EQ(plans.size(), 5);
    for (size_t i = 0; i < 5; ++i) {
        EXPECT_EQ(plans[i].name, "AutoPlan-EVT-" + std::to_string(i + 1));
        EXPECT_EQ(plans[i].relatedEventId, "EVT-" + std::to_string(i + 1));
    }
}

TEST_F(CmsEngineTest, testProcessPendingEventsMixedStatus) {
    // 特殊场景测试：混合状态的事件
    EventRecord pendingEvent1 = createValidEvent("EVT-001", 100, EventStatus::Pending);
    EventRecord generatedEvent = createValidEvent("EVT-002", 100, EventStatus::Generated);
    EventRecord pendingEvent2 = createValidEvent("EVT-003", 100, EventStatus::Pending);
    
    engine.ingestEvent(pendingEvent1);
    engine.ingestEvent(generatedEvent);
    engine.ingestEvent(pendingEvent2);
    
    size_t processed = engine.processPendingEvents();
    EXPECT_EQ(processed, 2);  // 只处理 Pending 状态的事件
    
    // 验证 Pending 事件已处理
    const EventRecord* found1 = engine.findEventById("EVT-001");
    ASSERT_NE(found1, nullptr);
    EXPECT_EQ(found1->status, EventStatus::Generated);
    
    const EventRecord* found3 = engine.findEventById("EVT-003");
    ASSERT_NE(found3, nullptr);
    EXPECT_EQ(found3->status, EventStatus::Generated);
    
    // 验证 Generated 事件未改变
    const EventRecord* found2 = engine.findEventById("EVT-002");
    ASSERT_NE(found2, nullptr);
    EXPECT_EQ(found2->status, EventStatus::Generated);
    
    // 验证生成了 2 个方案
    EXPECT_EQ(engine.getAllPlans().size(), 2);
}

TEST_F(CmsEngineTest, testProcessPendingEventsIdGeneration) {
    // 特殊场景测试：验证 ID 生成顺序
    EventRecord event1 = createValidEvent("EVT-001", 100, EventStatus::Pending);
    EventRecord event2 = createValidEvent("EVT-002", 100, EventStatus::Pending);
    
    engine.ingestEvent(event1);
    engine.ingestEvent(event2);
    
    engine.processPendingEvents();
    
    const auto& plans = engine.getAllPlans();
    EXPECT_EQ(plans.size(), 2);
    EXPECT_EQ(plans[0].id, "ID-00001");
    EXPECT_EQ(plans[1].id, "ID-00002");
}

TEST_F(CmsEngineTest, testProcessPendingEventsMultipleCalls) {
    // 特殊场景测试：多次调用 processPendingEvents
    EventRecord event1 = createValidEvent("EVT-001", 100, EventStatus::Pending);
    engine.ingestEvent(event1);
    
    // 第一次调用
    size_t processed1 = engine.processPendingEvents();
    EXPECT_EQ(processed1, 1);
    
    // 第二次调用，没有新的 Pending 事件
    size_t processed2 = engine.processPendingEvents();
    EXPECT_EQ(processed2, 0);
    
    // 验证方案数量不变
    EXPECT_EQ(engine.getAllPlans().size(), 1);
}

TEST_F(CmsEngineTest, testProcessPendingEventsLargeNumberOfEvents) {
    // 边界值测试：大量事件
    const size_t NUM_EVENTS = 1000;
    for (size_t i = 0; i < NUM_EVENTS; ++i) {
        EventRecord event = createValidEvent("EVT-" + std::to_string(i + 1), 100, EventStatus::Pending);
        engine.ingestEvent(event);
    }
    
    size_t processed = engine.processPendingEvents();
    EXPECT_EQ(processed, NUM_EVENTS);
    
    // 验证所有事件已处理
    for (size_t i = 0; i < NUM_EVENTS; ++i) {
        std::string id = "EVT-" + std::to_string(i + 1);
        const EventRecord* found = engine.findEventById(id);
        ASSERT_NE(found, nullptr);
        EXPECT_EQ(found->status, EventStatus::Generated);
    }
    
    // 验证生成了对应数量的方案
    EXPECT_EQ(engine.getAllPlans().size(), NUM_EVENTS);
}

TEST_F(CmsEngineTest, testProcessPendingEventsPlanProperties) {
    // 正常输入测试：验证生成的方案属性
    EventRecord event = createValidEvent("EVT-001", 100, EventStatus::Pending);
    engine.ingestEvent(event);
    
    engine.processPendingEvents();
    
    const auto& plans = engine.getAllPlans();
    ASSERT_EQ(plans.size(), 1);
    
    // 验证方案时间戳不为空
    auto now = std::chrono::system_clock::now();
    auto timeDiff = std::chrono::duration_cast<std::chrono::seconds>(
        now - plans[0].createTime).count();
    EXPECT_LT(timeDiff, 5);  // 时间差小于 5 秒
    
    // 验证方案 ID 格式
    EXPECT_THAT(plans[0].id, testing::MatchesRegex("ID-\\d{5}"));
}