#include <cassert>
#include <iostream>
#include <string>
#include "core/event.hpp"
#include "core/task.hpp"
#include "core/template.hpp"
#include "core/plan.hpp"
#include "core/dispatch.hpp"

/// @brief 测试 EventProcessor 模块
static void TestEventProcessor() {
    battlefield::EventProcessor ep;

    bool ok = ep.ReceiveEvent(R"({"type":"intel","priority":7})");
    assert(ok);
    assert(ep.GetEventCount() == 1);

    ok = ep.ReceiveEvent(R"({"type":"threat","priority":9})");
    assert(ok);
    assert(ep.GetEventCount() == 2);

    auto pending = ep.GetPendingEvents();
    assert(pending.size() == 2);

    ep.SortEventsByPriority(false); // 降序
    pending = ep.GetPendingEvents();
    assert(pending[0].priority >= pending[1].priority);

    std::cout << "[PASS] TestEventProcessor\n";
}

/// @brief 测试 TaskGenerator 模块
static void TestTaskGenerator() {
    battlefield::TaskGenerator tg;
    battlefield::Event evt;
    evt.id = "EVT-001";
    evt.priority = 8;
    evt.type = battlefield::EventType::INTEL;

    battlefield::TaskDraft draft = tg.CreateTaskFromEvent(evt);
    assert(draft.relatedEventId == "EVT-001");
    assert(draft.status == battlefield::DraftStatus::DRAFT);

    auto list = tg.GetDraftList();
    assert(list.size() == 1);

    bool submitted = tg.SubmitDraft(draft.id, "http://engine.local");
    assert(submitted);

    list = tg.GetDraftList();
    assert(list[0].status == battlefield::DraftStatus::SUBMITTED);

    std::cout << "[PASS] TestTaskGenerator\n";
}

/// @brief 测试 TemplateManager 模块
static void TestTemplateManager() {
    battlefield::TemplateManager tm;
    size_t count = tm.LoadTemplates("/fake/path");
    assert(count == 3);
    assert(tm.GetTemplateCount() == 3);

    auto list = tm.GetTemplateList();
    assert(list.size() == 3);

    auto selected = tm.SelectTemplate("v1.1");
    assert(!selected.versionId.empty());
    assert(selected.name == "Template-1");

    auto recommended = tm.RecommendTemplate();
    assert(!recommended.versionId.empty());

    std::cout << "[PASS] TestTemplateManager\n";
}

/// @brief 测试 PlanManager 模块
static void TestPlanManager() {
    battlefield::PlanManager pm;
    battlefield::Plan a = pm.CreatePlan("Plan A", "First option");
    battlefield::Plan b = pm.CreatePlan("Plan B", "Second option");
    assert(!a.id.empty());
    assert(!b.id.empty());

    auto list = pm.GetPlanList();
    assert(list.size() == 2);

    std::string cmp = pm.ComparePlans(a.id, b.id);
    assert(cmp.find("Score") != std::string::npos);

    // 融合测试
    battlefield::Plan merged = pm.MergePlans({a.id, b.id});
    assert(merged.id.find("MERGED") != std::string::npos);

    std::cout << "[PASS] TestPlanManager\n";
}

/// @brief 测试 DispatchMonitor 模块
static void TestDispatchMonitor() {
    battlefield::DispatchMonitor dm;
    battlefield::Plan plan;
    plan.id = "PLN-TEST";
    plan.name = "Test Plan";

    battlefield::PlanSubTask st;
    st.id = "ST-1";
    st.name = "Recon";
    plan.subTasks.push_back(st);

    battlefield::CmdPacket cmd = dm.DispatchPlan(plan, "unit-alpha");
    assert(cmd.packetId.find("CMD-") != std::string::npos);
    assert(cmd.targetUnit == "unit-alpha");

    auto status = dm.GetMonitorStatus();
    assert(status.totalTasks == 1);

    dm.AdvanceProgress(1);
    status = dm.GetMonitorStatus();
    assert(status.completedTasks == 1);
    assert(status.progressPercent == 100.0);

    std::string dash = dm.GetDashboardData();
    assert(dash.find("Progress") != std::string::npos);

    std::cout << "[PASS] TestDispatchMonitor\n";
}

/// @brief 主测试入口
/// @return 0 全部通过
int main() {
    std::cout << "========== BattlefieldTaskPlanner 单元测试 ==========\n\n";

    TestEventProcessor();
    TestTaskGenerator();
    TestTemplateManager();
    TestPlanManager();
    TestDispatchMonitor();

    std::cout << "\n========== 全部测试通过 ==========\n";
    return 0;
}