#include <gtest/gtest.h>
#include <gmock/gmock.h>
#include "core/event.hpp"
#include <fstream>

using namespace battlefield;

// ==================== EventType / EventStatus 枚举 ====================
TEST(EventEnumTest, EventTypeToString) {
    EXPECT_STREQ(EventTypeToString(EventType::UNKNOWN), "UNKNOWN");
    EXPECT_STREQ(EventTypeToString(EventType::INTEL), "INTEL");
    EXPECT_STREQ(EventTypeToString(EventType::THREAT), "THREAT");
    EXPECT_STREQ(EventTypeToString(EventType::MISSION), "MISSION");
    EXPECT_STREQ(EventTypeToString(EventType::LOGISTIC), "LOGISTIC");
}

TEST(EventEnumTest, EventStatusToString) {
    EXPECT_STREQ(EventStatusToString(EventStatus::PENDING), "PENDING");
    EXPECT_STREQ(EventStatusToString(EventStatus::PROCESSING), "PROCESSING");
    EXPECT_STREQ(EventStatusToString(EventStatus::RESOLVED), "RESOLVED");
    EXPECT_STREQ(EventStatusToString(EventStatus::ARCHIVED), "ARCHIVED");
}

// ==================== Event 结构体 ====================
TEST(EventStructTest, DefaultConstruction) {
    Event evt;
    EXPECT_EQ(evt.type, EventType::UNKNOWN);
    EXPECT_EQ(evt.priority, 0);
    EXPECT_EQ(evt.status, EventStatus::PENDING);
    EXPECT_TRUE(evt.id.empty());
    EXPECT_TRUE(evt.location.empty());
    EXPECT_TRUE(evt.source.empty());
    EXPECT_TRUE(evt.summary.empty());
}

// ==================== ReceiveEvent ====================
TEST(EventProcessorTest, ReceiveEventValidJson) {
    EventProcessor ep;
    bool ok = ep.ReceiveEvent(
        R"({"eventId":"evt_001","type":"intel","source":"drone","priority":7,"location":"zone-1","message":"test"})",
        "drone");
    EXPECT_TRUE(ok);
    EXPECT_EQ(ep.GetEventCount(), 1u);
}

TEST(EventProcessorTest, ReceiveEventMultiple) {
    EventProcessor ep;
    ep.ReceiveEvent(R"({"eventId":"e1","type":"intel","priority":5})");
    ep.ReceiveEvent(R"({"eventId":"e2","type":"threat","priority":9})");
    ep.ReceiveEvent(R"({"eventId":"e3","type":"logistic","priority":3})");
    EXPECT_EQ(ep.GetEventCount(), 3u);
}

TEST(EventProcessorTest, ReceiveEventInvalidJson) {
    EventProcessor ep;
    bool ok = ep.ReceiveEvent("not a json string{", "test");
    EXPECT_FALSE(ok);
    EXPECT_EQ(ep.GetEventCount(), 0u);
}

TEST(EventProcessorTest, ReceiveEventWithIdField) {
    EventProcessor ep;
    ep.ReceiveEvent(R"({"id":"alt_id","type":"mission","priority":5})");
    EXPECT_EQ(ep.GetEventCount(), 1u);
    auto events = ep.GetPendingEvents();
    EXPECT_EQ(events[0].id, "alt_id");
}

TEST(EventProcessorTest, ReceiveEventWithoutId) {
    EventProcessor ep;
    ep.ReceiveEvent(R"({"type":"threat","priority":8})");
    EXPECT_EQ(ep.GetEventCount(), 1u);
    auto events = ep.GetPendingEvents();
    EXPECT_TRUE(events[0].id.find("EVT-") != std::string::npos);
}

// ==================== TransformEvent ====================
TEST(EventProcessorTest, TransformEventFullFields) {
    EventProcessor ep;
    Event evt = ep.TransformEvent(
        R"({"eventId":"evt_full","type":"threat","source":"radar","priority":9,"location":"zone-alpha","message":"enemy detected","timestamp":1716700000})",
        "radar");
    EXPECT_EQ(evt.id, "evt_full");
    EXPECT_EQ(evt.type, EventType::THREAT);
    EXPECT_EQ(evt.priority, 9);
    EXPECT_EQ(evt.location, "zone-alpha");
    EXPECT_EQ(evt.source, "radar");
    EXPECT_EQ(evt.summary, "enemy detected");
}

TEST(EventProcessorTest, TransformEventFloatTimestamp) {
    EventProcessor ep;
    Event evt = ep.TransformEvent(
        R"({"eventId":"evt_ts","timestamp":1234567890.5})");
    EXPECT_EQ(evt.id, "evt_ts");
}

TEST(EventProcessorTest, TransformEventIntegerTimestamp) {
    EventProcessor ep;
    Event evt = ep.TransformEvent(
        R"({"eventId":"evt_int","timestamp":1716700000})");
    EXPECT_EQ(evt.id, "evt_int");
}

TEST(EventProcessorTest, TransformEventMapExternalIntel) {
    EventProcessor ep;
    Event evt = ep.TransformEvent(
        R"({"id":"e1","eventType":"analysis_started","domain":"codegen"})");
    EXPECT_EQ(evt.type, EventType::INTEL);
}

TEST(EventProcessorTest, TransformEventMapExternalThreat) {
    EventProcessor ep;
    Event evt = ep.TransformEvent(
        R"({"id":"e1","eventType":"error_occurred","domain":"generation"})");
    EXPECT_EQ(evt.type, EventType::THREAT);
}

TEST(EventProcessorTest, TransformEventMapExternalMission) {
    EventProcessor ep;
    Event evt = ep.TransformEvent(
        R"({"id":"e1","eventType":"generation_start","domain":"codegen"})");
    EXPECT_EQ(evt.type, EventType::MISSION);
}

TEST(EventProcessorTest, TransformEventMapExternalLogistic) {
    EventProcessor ep;
    Event evt = ep.TransformEvent(
        R"({"id":"e1","eventType":"done","domain":"generation","priority":3})");
    EXPECT_EQ(evt.type, EventType::LOGISTIC);
}

TEST(EventProcessorTest, TransformEventWithoutTimestamp) {
    EventProcessor ep;
    Event evt = ep.TransformEvent(R"({"eventId":"no_ts"})");
    EXPECT_EQ(evt.id, "no_ts");
    // timestamp 应被设为当前时间
}

TEST(EventProcessorTest, TransformEventClampPriorityLow) {
    EventProcessor ep;
    Event evt = ep.TransformEvent(R"({"eventId":"low","priority":-5})");
    EXPECT_EQ(evt.priority, 1);
}

TEST(EventProcessorTest, TransformEventClampPriorityHigh) {
    EventProcessor ep;
    Event evt = ep.TransformEvent(R"({"eventId":"high","priority":999})");
    EXPECT_EQ(evt.priority, 10);
}

TEST(EventProcessorTest, TransformEventWithStatus) {
    EventProcessor ep;
    Event evt = ep.TransformEvent(R"({"eventId":"s1","status":2})");
    EXPECT_EQ(evt.status, EventStatus::RESOLVED);
}

// ==================== ValidateEventData ====================
TEST(EventProcessorTest, ValidateEventDataValid) {
    EventProcessor ep;
    nlohmann::json valid1 = {{"eventId", "evt_001"}};
    EXPECT_TRUE(ep.ValidateEventData(valid1));

    nlohmann::json valid2 = {{"id", "evt_002"}};
    EXPECT_TRUE(ep.ValidateEventData(valid2));
}

TEST(EventProcessorTest, ValidateEventDataInvalidEmptyId) {
    EventProcessor ep;
    nlohmann::json invalid = {{"eventId", ""}};
    EXPECT_FALSE(ep.ValidateEventData(invalid));
}

TEST(EventProcessorTest, ValidateEventDataInvalidLongId) {
    EventProcessor ep;
    nlohmann::json invalid = {{"eventId", std::string(300, 'x')}};
    EXPECT_FALSE(ep.ValidateEventData(invalid));
}

TEST(EventProcessorTest, ValidateEventDataNoId) {
    EventProcessor ep;
    nlohmann::json invalid = {{"type", "threat"}};
    EXPECT_FALSE(ep.ValidateEventData(invalid));
}

// ==================== LoadEventsFromFile ====================
TEST(EventProcessorTest, LoadEventsFromFile) {
    EventProcessor ep;
    size_t loaded = ep.LoadEventsFromFile("events.ndjson", 10);
    if (loaded > 0) {
        EXPECT_LE(loaded, 10u);
        auto events = ep.GetPendingEvents();
        for (const auto& e : events) {
            EXPECT_FALSE(e.id.empty());
        }
    }
}

TEST(EventProcessorTest, LoadEventsFromFileAll) {
    EventProcessor ep;
    size_t loaded = ep.LoadEventsFromFile("events.ndjson");
    EXPECT_EQ(ep.GetEventCount(), loaded);
    auto events = ep.GetPendingEvents();
    for (const auto& e : events) {
        EXPECT_FALSE(e.id.empty());
        EXPECT_GE(e.priority, 1);
        EXPECT_LE(e.priority, 10);
    }
}

TEST(EventProcessorTest, LoadEventsFromFileNotFound) {
    EventProcessor ep;
    size_t loaded = ep.LoadEventsFromFile("nonexistent_file.ndjson");
    EXPECT_EQ(loaded, 0u);
    EXPECT_EQ(ep.GetEventCount(), 0u);
}

// ==================== 查询方法 ====================
TEST(EventProcessorTest, GetPendingEventsNew) {
    EventProcessor ep;
    ep.ReceiveEvent(R"({"eventId":"e1","type":"intel","priority":5})");
    ep.ReceiveEvent(R"({"eventId":"e2","type":"threat","priority":8})");
    auto pending = ep.GetPendingEvents();
    EXPECT_EQ(pending.size(), 2u);
}

TEST(EventProcessorTest, GetEventsByStatus) {
    EventProcessor ep;
    ep.ReceiveEvent(R"({"eventId":"e1","type":"intel","priority":5})");
    ep.ReceiveEvent(R"({"eventId":"e2","type":"threat","priority":8})");

    auto pending = ep.GetEventsByStatus(EventStatus::PENDING);
    EXPECT_EQ(pending.size(), 2u);

    auto resolved = ep.GetEventsByStatus(EventStatus::RESOLVED);
    EXPECT_EQ(resolved.size(), 0u);

    auto archived = ep.GetEventsByStatus(EventStatus::ARCHIVED);
    EXPECT_EQ(archived.size(), 0u);
}

// ==================== 排序 ====================
TEST(EventProcessorTest, SortByPriorityAscending) {
    EventProcessor ep;
    ep.ReceiveEvent(R"({"eventId":"e1","priority":3})");
    ep.ReceiveEvent(R"({"eventId":"e2","priority":9})");
    ep.ReceiveEvent(R"({"eventId":"e3","priority":5})");
    ep.SortEventsByPriority(true);
    auto events = ep.GetPendingEvents();
    EXPECT_EQ(events[0].priority, 3);
    EXPECT_EQ(events[1].priority, 5);
    EXPECT_EQ(events[2].priority, 9);
}

TEST(EventProcessorTest, SortByPriorityDescending) {
    EventProcessor ep;
    ep.ReceiveEvent(R"({"eventId":"e1","priority":3})");
    ep.ReceiveEvent(R"({"eventId":"e2","priority":9})");
    ep.ReceiveEvent(R"({"eventId":"e3","priority":5})");
    ep.SortEventsByPriority(false);
    auto events = ep.GetPendingEvents();
    EXPECT_EQ(events[0].priority, 9);
    EXPECT_EQ(events[1].priority, 5);
    EXPECT_EQ(events[2].priority, 3);
}

TEST(EventProcessorTest, SortByCustomComparator) {
    EventProcessor ep;
    ep.ReceiveEvent(R"({"eventId":"aaa","priority":5})");
    ep.ReceiveEvent(R"({"eventId":"bbb","priority":5})");
    ep.ReceiveEvent(R"({"eventId":"ccc","priority":5})");
    ep.SortEventsBy([](const Event& a, const Event& b) {
        return a.id > b.id; // 按 ID 降序
    });
    auto events = ep.GetPendingEvents();
    EXPECT_EQ(events[0].id, "ccc");
    EXPECT_EQ(events[1].id, "bbb");
    EXPECT_EQ(events[2].id, "aaa");
}

// ==================== 筛选 ====================
TEST(EventProcessorTest, FilterByType) {
    EventProcessor ep;
    ep.ReceiveEvent(R"({"eventId":"e1","type":"intel","priority":5})");
    ep.ReceiveEvent(R"({"eventId":"e2","type":"threat","priority":8})");
    ep.ReceiveEvent(R"({"eventId":"e3","type":"intel","priority":3})");

    auto intels = ep.FilterByType(EventType::INTEL);
    EXPECT_EQ(intels.size(), 2u);

    auto threats = ep.FilterByType(EventType::THREAT);
    EXPECT_EQ(threats.size(), 1u);

    auto missions = ep.FilterByType(EventType::MISSION);
    EXPECT_EQ(missions.size(), 0u);

    auto unknowns = ep.FilterByType(EventType::UNKNOWN);
    EXPECT_EQ(unknowns.size(), 0u);
}

TEST(EventProcessorTest, FilterByPriority) {
    EventProcessor ep;
    ep.ReceiveEvent(R"({"eventId":"e1","priority":1})");
    ep.ReceiveEvent(R"({"eventId":"e2","priority":5})");
    ep.ReceiveEvent(R"({"eventId":"e3","priority":10})");

    auto low = ep.FilterByPriority(1, 3);
    EXPECT_EQ(low.size(), 1u);

    auto mid = ep.FilterByPriority(4, 7);
    EXPECT_EQ(mid.size(), 1u);

    auto high = ep.FilterByPriority(8, 10);
    EXPECT_EQ(high.size(), 1u);

    auto all = ep.FilterByPriority(1, 10);
    EXPECT_EQ(all.size(), 3u);

    auto none = ep.FilterByPriority(11, 20);
    EXPECT_EQ(none.size(), 0u);
}

TEST(EventProcessorTest, FilterBySource) {
    EventProcessor ep;
    ep.ReceiveEvent(R"({"eventId":"e1"})", "radar_a");
    ep.ReceiveEvent(R"({"eventId":"e2"})", "radar_a");
    ep.ReceiveEvent(R"({"eventId":"e3"})", "drone_x");

    auto fromRadar = ep.FilterBySource("radar_a");
    EXPECT_EQ(fromRadar.size(), 2u);

    auto fromDrone = ep.FilterBySource("drone_x");
    EXPECT_EQ(fromDrone.size(), 1u);

    auto fromNone = ep.FilterBySource("nonexistent");
    EXPECT_EQ(fromNone.size(), 0u);
}

// ==================== 状态流转 ====================
TEST(EventProcessorTest, MarkProcessingValid) {
    EventProcessor ep;
    ep.ReceiveEvent(R"({"eventId":"e1","priority":5})");
    EXPECT_TRUE(ep.MarkProcessing("e1"));
    auto pending = ep.GetPendingEvents();
    EXPECT_EQ(pending.size(), 0u);
    auto processing = ep.GetEventsByStatus(EventStatus::PROCESSING);
    EXPECT_EQ(processing.size(), 1u);
}

TEST(EventProcessorTest, MarkProcessingInvalid) {
    EventProcessor ep;
    EXPECT_FALSE(ep.MarkProcessing("nonexistent"));
}

TEST(EventProcessorTest, MarkResolved) {
    EventProcessor ep;
    ep.ReceiveEvent(R"({"eventId":"e1","priority":5})");
    EXPECT_TRUE(ep.MarkResolved("e1"));
    auto resolved = ep.GetEventsByStatus(EventStatus::RESOLVED);
    EXPECT_EQ(resolved.size(), 1u);
}

TEST(EventProcessorTest, MarkResolvedInvalid) {
    EventProcessor ep;
    EXPECT_FALSE(ep.MarkResolved("nonexistent"));
}

TEST(EventProcessorTest, MarkArchived) {
    EventProcessor ep;
    ep.ReceiveEvent(R"({"eventId":"e1","priority":5})");
    EXPECT_TRUE(ep.MarkArchived("e1"));
    auto archived = ep.GetEventsByStatus(EventStatus::ARCHIVED);
    EXPECT_EQ(archived.size(), 1u);
}

TEST(EventProcessorTest, MarkArchivedInvalid) {
    EventProcessor ep;
    EXPECT_FALSE(ep.MarkArchived("nonexistent"));
}

TEST(EventProcessorTest, FullLifecycle) {
    EventProcessor ep;
    ep.ReceiveEvent(R"({"eventId":"lifecycle","priority":5})");

    // PENDING -> PROCESSING
    EXPECT_TRUE(ep.MarkProcessing("lifecycle"));
    EXPECT_EQ(ep.GetPendingEvents().size(), 0u);
    EXPECT_EQ(ep.GetEventsByStatus(EventStatus::PROCESSING).size(), 1u);

    // PROCESSING -> RESOLVED
    EXPECT_TRUE(ep.MarkResolved("lifecycle"));
    EXPECT_EQ(ep.GetEventsByStatus(EventStatus::RESOLVED).size(), 1u);

    // RESOLVED -> ARCHIVED
    EXPECT_TRUE(ep.MarkArchived("lifecycle"));
    EXPECT_EQ(ep.GetEventsByStatus(EventStatus::ARCHIVED).size(), 1u);
}

// ==================== Clear / GetEventCount ====================
TEST(EventProcessorTest, Clear) {
    EventProcessor ep;
    ep.ReceiveEvent(R"({"eventId":"e1"})");
    ep.ReceiveEvent(R"({"eventId":"e2"})");
    EXPECT_EQ(ep.GetEventCount(), 2u);
    ep.Clear();
    EXPECT_EQ(ep.GetEventCount(), 0u);
}

// ==================== 边界和特殊情况 ====================
TEST(EventProcessorTest, EmptyProcessor) {
    EventProcessor ep;
    EXPECT_EQ(ep.GetEventCount(), 0u);
    EXPECT_TRUE(ep.GetPendingEvents().empty());
    EXPECT_TRUE(ep.GetEventsByStatus(EventStatus::PENDING).empty());
}

TEST(EventProcessorTest, PriorityDefaultsByType) {
    EventProcessor ep;
    Event threat = ep.TransformEvent(R"({"eventId":"t1","type":"threat"})");
    EXPECT_EQ(threat.priority, 9);

    Event intel = ep.TransformEvent(R"({"eventId":"i1","type":"intel"})");
    EXPECT_EQ(intel.priority, 7);

    Event mission = ep.TransformEvent(R"({"eventId":"m1","type":"mission"})");
    EXPECT_EQ(mission.priority, 5);

    Event logistic = ep.TransformEvent(R"({"eventId":"l1","type":"logistic"})");
    EXPECT_EQ(logistic.priority, 3);

    Event unknown = ep.TransformEvent(R"({"eventId":"u1","type":"other"})");
    EXPECT_EQ(unknown.priority, 1);
}

TEST(EventProcessorTest, SummaryFromMessageField) {
    EventProcessor ep;
    Event evt = ep.TransformEvent(R"({"eventId":"s1","message":"test message"})");
    EXPECT_EQ(evt.summary, "test message");
}

TEST(EventProcessorTest, SummaryFromSummaryField) {
    EventProcessor ep;
    Event evt = ep.TransformEvent(R"({"eventId":"s1","summary":"override summary"})");
    EXPECT_EQ(evt.summary, "override summary");
}

TEST(EventProcessorTest, LocationDefault) {
    EventProcessor ep;
    Event evt = ep.TransformEvent(R"({"eventId":"loc"})");
    EXPECT_EQ(evt.location, "unknown-zone");
}