#include <gtest/gtest.h>
#include "core/event.hpp"
#include <string>
#include <vector>
#include <stdexcept>
#include <memory>

namespace battlefield {

class EventProcessorTest : public ::testing::Test {
protected:
    void SetUp() override {
        processor_ = std::make_unique<EventProcessor>();
    }

    void TearDown() override {
        processor_.reset();
    }

    std::unique_ptr<EventProcessor> processor_;
};

// ================= ReceiveEvent 测试用例 =================

TEST_F(EventProcessorTest, testReceiveEventNormalInput) {
    std::string rawJson = "ABCD1234,extra_data";
    EXPECT_TRUE(processor_->ReceiveEvent(rawJson));
    auto pending = processor_->GetPendingEvents();
    EXPECT_EQ(pending.size(), 1);
    EXPECT_EQ(pending[0].id, "EVT-ABCD");
}

TEST_F(EventProcessorTest, testReceiveEventEmptyBoundary) {
    std::string rawJson = "";
    EXPECT_THROW(processor_->ReceiveEvent(rawJson), std::out_of_range);
}

TEST_F(EventProcessorTest, testReceiveEventShortException) {
    std::string rawJson = "ABC,data";
    EXPECT_THROW(processor_->ReceiveEvent(rawJson), std::out_of_range);
}

// ================= TransformEvent 测试用例 =================

TEST_F(EventProcessorTest, testTransformEventNormalInput) {
    std::string raw = "WXYZ,metadata";
    Event evt = processor_->TransformEvent(raw);
    EXPECT_EQ(evt.id, "EVT-WXYZ");
    EXPECT_EQ(evt.type, EventType::INTEL);
    EXPECT_EQ(evt.priority, 5);
    EXPECT_EQ(evt.location, "zone-alpha");
    EXPECT_EQ(evt.status, EventStatus::PENDING);
}

TEST_F(EventProcessorTest, testTransformEventBoundaryInput) {
    std::string raw = "1234";
    Event evt = processor_->TransformEvent(raw);
    EXPECT_EQ(evt.id, "EVT-1234");
}

TEST_F(EventProcessorTest, testTransformEventShortException) {
    std::string raw = "123";
    EXPECT_THROW(processor_->TransformEvent(raw), std::out_of_range);
}

// ================= GetPendingEvents 测试用例 =================

TEST_F(EventProcessorTest, testGetPendingEventsEmptyBoundary) {
    auto pending = processor_->GetPendingEvents();
    EXPECT_TRUE(pending.empty());
}

TEST_F(EventProcessorTest, testGetPendingEventsNormalFilter) {
    processor_->ReceiveEvent("AAAA,data");
    processor_->ReceiveEvent("BBBB,data");
    auto pending = processor_->GetPendingEvents();
    EXPECT_EQ(pending.size(), 2);
    EXPECT_EQ(pending[0].id, "EVT-AAAA");
    EXPECT_EQ(pending[1].id, "EVT-BBBB");
}

// ================= SortEventsByPriority 测试用例 =================

TEST_F(EventProcessorTest, testSortEventsByPriorityAscendingNormal) {
    processor_->ReceiveEvent("AAAA,data");
    processor_->ReceiveEvent("BBBB,data");
    processor_->SortEventsByPriority(true);
    auto events = processor_->GetPendingEvents();
    EXPECT_EQ(events.size(), 2);
}

TEST_F(EventProcessorTest, testSortEventsByPriorityDescendingNormal) {
    processor_->ReceiveEvent("CCCC,data");
    processor_->SortEventsByPriority(false);
    auto events = processor_->GetPendingEvents();
    EXPECT_EQ(events.size(), 1);
}

TEST_F(EventProcessorTest, testSortEventsByPriorityEmptyBoundary) {
    processor_->SortEventsByPriority(true);
    auto events = processor_->GetPendingEvents();
    EXPECT_TRUE(events.empty());
}

} // namespace battlefield