#include <gtest/gtest.h>
#include <vector>
#include <string>
#include <algorithm>
#include <ctime>

// 模拟 app.hpp 中的类型定义，确保测试文件可独立编译
namespace etms {
enum class EventStatus { Received, Processed, PendingTask, Rejected, TaskGenerated, Unknown };
struct Event {
    int id; std::string event_id; std::string event_type; std::time_t timestamp;
    int level; double longitude; double latitude; std::string description;
    EventStatus status; std::time_t create_time;
};
struct KbVersion { std::string version_id; std::string description; std::time_t release_time; std::string status; };
struct TaskTemplate { std::string template_id; std::string name; std::string kb_version_id; std::string path; std::string applicable_type; std::time_t create_time; };

// 声明被测函数
std::vector<KbVersion> GetAvailableKbVersions();
std::vector<TaskTemplate> GetAvailableTemplates();
bool AdvanceEventStatus(Event& evt);
void SortEventsByLevelDesc(std::vector<Event>& events);
void SortEventsByTimeAsc(std::vector<Event>& events);
} // namespace etms

// ================= 测试用例实现 =================

// 1. GetAvailableKbVersions
TEST(testGetAvailableKbVersions, NormalInput_ReturnsThreeVersions) {
    auto versions = etms::GetAvailableKbVersions();
    EXPECT_EQ(versions.size(), 3);
    EXPECT_EQ(versions[0].version_id, "KB-V1.0");
    EXPECT_EQ(versions[1].version_id, "KB-V1.1");
    EXPECT_EQ(versions[2].version_id, "KB-V2.0");
}

TEST(testGetAvailableKbVersions, Boundary_CheckStatusField) {
    auto versions = etms::GetAvailableKbVersions();
    EXPECT_EQ(versions[0].status, "Active");
    EXPECT_EQ(versions[2].status, "Deprecated");
}

// 2. GetAvailableTemplates
TEST(testGetAvailableTemplates, NormalInput_ReturnsThreeTemplates) {
    auto templates = etms::GetAvailableTemplates();
    EXPECT_EQ(templates.size(), 3);
    EXPECT_EQ(templates[0].template_id, "TMPL-RECON-001");
    EXPECT_EQ(templates[1].template_id, "TMPL-STRIKE-001");
    EXPECT_EQ(templates[2].template_id, "TMPL-WARN-001");
}

TEST(testGetAvailableTemplates, Boundary_CheckApplicableType) {
    auto templates = etms::GetAvailableTemplates();
    EXPECT_EQ(templates[0].applicable_type, "侦察");
    EXPECT_EQ(templates[1].applicable_type, "打击");
    EXPECT_EQ(templates[2].applicable_type, "预警");
}

// 3. AdvanceEventStatus
TEST(testAdvanceEventStatus, Normal_ReceivedToProcessed) {
    etms::Event evt{};
    evt.status = etms::EventStatus::Received;
    EXPECT_TRUE(etms::AdvanceEventStatus(evt));
    EXPECT_EQ(evt.status, etms::EventStatus::Processed);
}

TEST(testAdvanceEventStatus, Normal_ProcessedToPendingTask) {
    etms::Event evt{};
    evt.status = etms::EventStatus::Processed;
    EXPECT_TRUE(etms::AdvanceEventStatus(evt));
    EXPECT_EQ(evt.status, etms::EventStatus::PendingTask);
}

TEST(testAdvanceEventStatus, Normal_PendingTaskToTaskGenerated) {
    etms::Event evt{};
    evt.status = etms::EventStatus::PendingTask;
    EXPECT_TRUE(etms::AdvanceEventStatus(evt));
    EXPECT_EQ(evt.status, etms::EventStatus::TaskGenerated);
}

TEST(testAdvanceEventStatus, Abnormal_RejectedStateReturnsFalse) {
    etms::Event evt{};
    evt.status = etms::EventStatus::Rejected;
    EXPECT_FALSE(etms::AdvanceEventStatus(evt));
    EXPECT_EQ(evt.status, etms::EventStatus::Rejected);
}

TEST(testAdvanceEventStatus, Abnormal_TaskGeneratedStateReturnsFalse) {
    etms::Event evt{};
    evt.status = etms::EventStatus::TaskGenerated;
    EXPECT_FALSE(etms::AdvanceEventStatus(evt));
    EXPECT_EQ(evt.status, etms::EventStatus::TaskGenerated);
}

TEST(testAdvanceEventStatus, Abnormal_UnknownStateReturnsFalse) {
    etms::Event evt{};
    evt.status = etms::EventStatus::Unknown;
    EXPECT_FALSE(etms::AdvanceEventStatus(evt));
    EXPECT_EQ(evt.status, etms::EventStatus::Unknown);
}

// 4. SortEventsByLevelDesc
TEST(testSortEventsByLevelDesc, Normal_UnsortedToDescending) {
    std::vector<etms::Event> events = {
        {1, "", "", 0, 5, 0, 0, "", etms::EventStatus::Received, 0},
        {2, "", "", 0, 9, 0, 0, "", etms::EventStatus::Received, 0},
        {3, "", "", 0, 7, 0, 0, "", etms::EventStatus::Received, 0}
    };
    etms::SortEventsByLevelDesc(events);
    EXPECT_EQ(events[0].level, 9);
    EXPECT_EQ(events[1].level, 7);
    EXPECT_EQ(events[2].level, 5);
}

TEST(testSortEventsByLevelDesc, Boundary_EmptyVector) {
    std::vector<etms::Event> events;
    etms::SortEventsByLevelDesc(events);
    EXPECT_TRUE(events.empty());
}

TEST(testSortEventsByLevelDesc, Special_DuplicateLevels) {
    std::vector<etms::Event> events = {
        {1, "", "", 0, 8, 0, 0, "", etms::EventStatus::Received, 0},
        {2, "", "", 0, 8, 0, 0, "", etms::EventStatus::Received, 0},
        {3, "", "", 0, 6, 0, 0, "", etms::EventStatus::Received, 0}
    };
    etms::SortEventsByLevelDesc(events);
    EXPECT_EQ(events[0].level, 8);
    EXPECT_EQ(events[1].level, 8);
    EXPECT_EQ(events[2].level, 6);
}

// 5. SortEventsByTimeAsc
TEST(testSortEventsByTimeAsc, Normal_UnsortedToAscending) {
    std::vector<etms::Event> events = {
        {1, "", "", 100, 0, 0, 0, "", etms::EventStatus::Received, 0},
        {2, "", "", 50, 0, 0, 0, "", etms::EventStatus::Received, 0},
        {3, "", "", 150, 0, 0, 0, "", etms::EventStatus::Received, 0}
    };
    etms::SortEventsByTimeAsc(events);
    EXPECT_EQ(events[0].timestamp, 50);
    EXPECT_EQ(events[1].timestamp, 100);
    EXPECT_EQ(events[2].timestamp, 150);
}

TEST(testSortEventsByTimeAsc, Boundary_SingleElement) {
    std::vector<etms::Event> events = {
        {1, "", "", 100, 0, 0, 0, "", etms::EventStatus::Received, 0}
    };
    etms::SortEventsByTimeAsc(events);
    EXPECT_EQ(events.size(), 1);
    EXPECT_EQ(events[0].timestamp, 100);
}

TEST(testSortEventsByTimeAsc, Special_AlreadySorted) {
    std::vector<etms::Event> events = {
        {1, "", "", 10, 0, 0, 0, "", etms::EventStatus::Received, 0},
        {2, "", "", 20, 0, 0, 0, "", etms::EventStatus::Received, 0}
    };
    etms::SortEventsByTimeAsc(events);
    EXPECT_EQ(events[0].timestamp, 10);
    EXPECT_EQ(events[1].timestamp, 20);
}