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

using namespace battlefield;

// ==================== PlanSubTask 结构体 ====================
TEST(PlanSubTaskTest, DefaultConstruction) {
    PlanSubTask st;
    EXPECT_TRUE(st.id.empty());
    EXPECT_TRUE(st.parentId.empty());
    EXPECT_TRUE(st.name.empty());
    EXPECT_TRUE(st.description.empty());
    EXPECT_EQ(st.orderIndex, 0);
    EXPECT_TRUE(st.assignedUnit.empty());
    EXPECT_DOUBLE_EQ(st.estimatedDuration, 0.0);
    EXPECT_EQ(st.resourceCost, 0);
}

// ==================== Plan 结构体 ====================
TEST(PlanTest, DefaultConstruction) {
    Plan plan;
    EXPECT_TRUE(plan.id.empty());
    EXPECT_TRUE(plan.name.empty());
    EXPECT_TRUE(plan.description.empty());
    EXPECT_TRUE(plan.subTasks.empty());
    EXPECT_DOUBLE_EQ(plan.score, 0.0);
}

TEST(PlanTest, SubTaskCountEmpty) {
    Plan plan;
    EXPECT_EQ(plan.SubTaskCount(), 0u);
}

TEST(PlanTest, SubTaskCountWithTasks) {
    Plan plan;
    PlanSubTask st;
    plan.subTasks.push_back(st);
    plan.subTasks.push_back(st);
    EXPECT_EQ(plan.SubTaskCount(), 2u);
}

TEST(PlanTest, TotalEstimatedDurationEmpty) {
    Plan plan;
    EXPECT_DOUBLE_EQ(plan.TotalEstimatedDuration(), 0.0);
}

TEST(PlanTest, TotalEstimatedDuration) {
    Plan plan;
    PlanSubTask st1;
    st1.estimatedDuration = 30.0;
    PlanSubTask st2;
    st2.estimatedDuration = 45.5;
    plan.subTasks.push_back(st1);
    plan.subTasks.push_back(st2);
    EXPECT_DOUBLE_EQ(plan.TotalEstimatedDuration(), 75.5);
}

TEST(PlanTest, TotalResourceCostEmpty) {
    Plan plan;
    EXPECT_EQ(plan.TotalResourceCost(), 0);
}

TEST(PlanTest, TotalResourceCost) {
    Plan plan;
    PlanSubTask st1;
    st1.resourceCost = 10;
    PlanSubTask st2;
    st2.resourceCost = 25;
    plan.subTasks.push_back(st1);
    plan.subTasks.push_back(st2);
    EXPECT_EQ(plan.TotalResourceCost(), 35);
}

// ==================== PlanComparison 结构体 ====================
TEST(PlanComparisonTest, DefaultConstruction) {
    PlanComparison cmp;
    EXPECT_TRUE(cmp.differences.empty());
}

// ==================== CreatePlan ====================
TEST(PlanManagerTest, CreatePlan) {
    PlanManager pm;
    Plan plan = pm.CreatePlan("测试方案", "测试描述");
    EXPECT_FALSE(plan.id.empty());
    EXPECT_TRUE(plan.id.find("PLN-") != std::string::npos);
    EXPECT_EQ(plan.name, "测试方案");
    EXPECT_EQ(plan.description, "测试描述");
    EXPECT_DOUBLE_EQ(plan.score, 0.0);
    EXPECT_TRUE(plan.subTasks.empty());
    EXPECT_EQ(pm.GetPlanCount(), 1u);
}

TEST(PlanManagerTest, CreateMultiplePlans) {
    PlanManager pm;
    pm.CreatePlan("A", "desc A");
    pm.CreatePlan("B", "desc B");
    pm.CreatePlan("C", "desc C");
    EXPECT_EQ(pm.GetPlanCount(), 3u);
}

// ==================== GetPlan ====================
TEST(PlanManagerTest, GetPlanFound) {
    PlanManager pm;
    Plan created = pm.CreatePlan("查找方案", "desc");
    Plan found = pm.GetPlan(created.id);
    EXPECT_EQ(found.id, created.id);
    EXPECT_EQ(found.name, "查找方案");
}

TEST(PlanManagerTest, GetPlanNotFound) {
    PlanManager pm;
    Plan plan = pm.GetPlan("nonexistent");
    EXPECT_TRUE(plan.id.empty());
}

// ==================== GetPlanList ====================
TEST(PlanManagerTest, GetPlanListEmpty) {
    PlanManager pm;
    auto list = pm.GetPlanList();
    EXPECT_TRUE(list.empty());
}

TEST(PlanManagerTest, GetPlanListWithPlans) {
    PlanManager pm;
    pm.CreatePlan("A", "");
    pm.CreatePlan("B", "");
    auto list = pm.GetPlanList();
    EXPECT_EQ(list.size(), 2u);
}

// ==================== AddSubTask ====================
TEST(PlanManagerTest, AddSubTaskValid) {
    PlanManager pm;
    Plan plan = pm.CreatePlan("方案", "");
    PlanSubTask st{"ST-1", "", "侦察", "无人机侦察", 1, "drone", 30.0, 3};
    EXPECT_TRUE(pm.AddSubTask(plan.id, st));
    EXPECT_EQ(pm.GetPlan(plan.id).SubTaskCount(), 1u);
}

TEST(PlanManagerTest, AddSubTaskInvalidPlan) {
    PlanManager pm;
    PlanSubTask st{"ST-1", "", "侦察", "", 1, "", 30.0, 3};
    EXPECT_FALSE(pm.AddSubTask("nonexistent", st));
}

TEST(PlanManagerTest, AddMultipleSubTasks) {
    PlanManager pm;
    Plan plan = pm.CreatePlan("方案", "");
    for (int i = 0; i < 5; ++i) {
        PlanSubTask st{"ST-"+std::to_string(i), "", "任务"+std::to_string(i), "", i, "unit", 10.0, 1};
        pm.AddSubTask(plan.id, st);
    }
    EXPECT_EQ(pm.GetPlan(plan.id).SubTaskCount(), 5u);
}

// ==================== RemoveSubTask ====================
TEST(PlanManagerTest, RemoveSubTaskValid) {
    PlanManager pm;
    Plan plan = pm.CreatePlan("方案", "");
    PlanSubTask st{"ST-1", "", "侦察", "", 1, "", 10.0, 1};
    PlanSubTask st2{"ST-2", "", "打击", "", 2, "", 20.0, 2};
    pm.AddSubTask(plan.id, st);
    pm.AddSubTask(plan.id, st2);
    EXPECT_EQ(pm.GetPlan(plan.id).SubTaskCount(), 2u);

    EXPECT_TRUE(pm.RemoveSubTask(plan.id, "ST-1"));
    EXPECT_EQ(pm.GetPlan(plan.id).SubTaskCount(), 1u);
}

TEST(PlanManagerTest, RemoveSubTaskInvalidPlan) {
    PlanManager pm;
    EXPECT_FALSE(pm.RemoveSubTask("nonexistent", "ST-1"));
}

TEST(PlanManagerTest, RemoveSubTaskInvalidSubTask) {
    PlanManager pm;
    Plan plan = pm.CreatePlan("方案", "");
    EXPECT_FALSE(pm.RemoveSubTask(plan.id, "nonexistent"));
}

// ==================== ReorganizePlan ====================
TEST(PlanManagerTest, ReorganizePlanValid) {
    PlanManager pm;
    Plan plan = pm.CreatePlan("方案", "");
    std::vector<PlanSubTask> newTasks = {
        {"NEW-1", "", "新任务1", "", 1, "unit_a", 10.0, 1},
        {"NEW-2", "NEW-1", "新任务2", "", 2, "unit_b", 20.0, 2}
    };
    EXPECT_TRUE(pm.ReorganizePlan(plan.id, newTasks));
    EXPECT_EQ(pm.GetPlan(plan.id).SubTaskCount(), 2u);
}

TEST(PlanManagerTest, ReorganizePlanInvalidPlan) {
    PlanManager pm;
    std::vector<PlanSubTask> empty;
    EXPECT_FALSE(pm.ReorganizePlan("nonexistent", empty));
}

// ==================== MergePlans ====================
TEST(PlanManagerTest, MergePlans) {
    PlanManager pm;
    Plan a = pm.CreatePlan("方案A", "");
    Plan b = pm.CreatePlan("方案B", "");

    PlanSubTask stA{"ST-A-1", "", "A1", "", 1, "", 10.0, 1};
    PlanSubTask stB1{"ST-B-1", "", "B1", "", 1, "", 20.0, 2};
    PlanSubTask stB2{"ST-B-2", "", "B2", "", 2, "", 30.0, 3};
    pm.AddSubTask(a.id, stA);
    pm.AddSubTask(b.id, stB1);
    pm.AddSubTask(b.id, stB2);

    Plan merged = pm.MergePlans({a.id, b.id});
    EXPECT_TRUE(merged.id.find("PLN-MERGED-") != std::string::npos);
    EXPECT_EQ(merged.SubTaskCount(), 3u);
}

TEST(PlanManagerTest, MergePlansEmptyList) {
    PlanManager pm;
    Plan merged = pm.MergePlans({});
    EXPECT_EQ(merged.SubTaskCount(), 0u);
}

TEST(PlanManagerTest, MergePlansWithInvalidIds) {
    PlanManager pm;
    Plan a = pm.CreatePlan("方案A", "");
    PlanSubTask st{"ST-1", "", "task", "", 1, "", 10.0, 1};
    pm.AddSubTask(a.id, st);

    Plan merged = pm.MergePlans({a.id, "nonexistent"});
    EXPECT_EQ(merged.SubTaskCount(), 1u);
}

TEST(PlanManagerTest, MergePlansCalculatesAverageScore) {
    PlanManager pm;
    Plan a = pm.CreatePlan("方案A", "");
    Plan b = pm.CreatePlan("方案B", "");
    PlanSubTask st{"ST-1", "", "task", "", 1, "", 10.0, 5};
    pm.AddSubTask(a.id, st);
    pm.AddSubTask(b.id, st);
    pm.RecalculateAllScores();

    Plan merged = pm.MergePlans({a.id, b.id});
    EXPECT_GT(merged.score, 0.0);
}

// ==================== 排序测试 ====================
TEST(PlanManagerTest, SortPlansByScoreDescending) {
    PlanManager pm;
    Plan a = pm.CreatePlan("方案A", "");
    Plan b = pm.CreatePlan("方案B", "");
    PlanSubTask st{"ST-1", "", "task", "", 1, "unit", 15.0, 3};
    pm.AddSubTask(a.id, st);
    pm.RecalculateAllScores();
    pm.SortPlansByScore(false);
    auto list = pm.GetPlanList();
    EXPECT_GE(list[0].score, list[1].score);
}

TEST(PlanManagerTest, SortPlansByNameAscending) {
    PlanManager pm;
    pm.CreatePlan("Gamma", "");
    pm.CreatePlan("Alpha", "");
    pm.CreatePlan("Beta", "");
    pm.SortPlansByName(true);
    // std::map 以 key(id) 排序，但名称排序逻辑已验证不崩溃
    SUCCEED();
}

TEST(PlanManagerTest, SortPlansByNameDescending) {
    PlanManager pm;
    pm.CreatePlan("Alpha", "");
    pm.CreatePlan("Zulu", "");
    pm.SortPlansByName(false);
    // std::map 以 key(id) 排序，无法验证名称排序的 map 遍历顺序
    SUCCEED();
}

TEST(PlanManagerTest, SortPlansBySubTaskCountDescending) {
    PlanManager pm;
    Plan a = pm.CreatePlan("A", "");
    Plan b = pm.CreatePlan("B", "");
    for (int i = 0; i < 3; ++i) {
        PlanSubTask st{"S-"+std::to_string(i), "", "", "", i, "", 1.0, 1};
        pm.AddSubTask(a.id, st);
    }
    pm.SortPlansBySubTaskCount(false);
    auto list = pm.GetPlanList();
    EXPECT_EQ(list[0].SubTaskCount(), 3u);
}

TEST(PlanManagerTest, SortPlansByDurationAscending) {
    PlanManager pm;
    Plan a = pm.CreatePlan("fast", "");
    Plan b = pm.CreatePlan("slow", "");
    PlanSubTask stFast{"ST-F", "", "", "", 1, "", 10.0, 1};
    PlanSubTask stSlow{"ST-S", "", "", "", 1, "", 100.0, 1};
    pm.AddSubTask(a.id, stFast);
    pm.AddSubTask(b.id, stSlow);
    pm.SortPlansByDuration(true);
    auto list = pm.GetPlanList();
    EXPECT_DOUBLE_EQ(list[0].TotalEstimatedDuration(), 10.0);
}

// ==================== 评分计算 ====================
TEST(PlanManagerTest, CalculatePlanScoreEmptyPlan) {
    PlanManager pm;
    Plan plan;
    double score = pm.CalculatePlanScore(plan);
    EXPECT_GE(score, 0.0);
}

TEST(PlanManagerTest, CalculatePlanScoreWithSubTasks) {
    PlanManager pm;
    Plan plan;
    PlanSubTask st{"ST-1", "", "task", "", 1, "unit_a", 15.0, 2};
    plan.subTasks.push_back(st);
    double score = pm.CalculatePlanScore(plan);
    EXPECT_GT(score, 0.0);
}

TEST(PlanManagerTest, CalculatePlanScoreWithMultipleUnits) {
    PlanManager pm;
    Plan plan;
    PlanSubTask st1{"ST-1", "", "", "", 1, "unit_a", 10.0, 1};
    PlanSubTask st2{"ST-2", "", "", "", 2, "unit_b", 10.0, 1};
    PlanSubTask st3{"ST-3", "", "", "", 3, "unit_c", 10.0, 1};
    plan.subTasks.push_back(st1);
    plan.subTasks.push_back(st2);
    plan.subTasks.push_back(st3);
    double score = pm.CalculatePlanScore(plan);
    EXPECT_GT(score, 30.0); // 3 subTasks * 5 + time bonus + resource bonus + unit bonus
}

TEST(PlanManagerTest, RecalculateAllScores) {
    PlanManager pm;
    Plan a = pm.CreatePlan("A", "desc A");
    Plan b = pm.CreatePlan("B", "");
    PlanSubTask st{"ST-1", "", "", "", 1, "", 10.0, 1};
    pm.AddSubTask(a.id, st);
    pm.RecalculateAllScores();
    EXPECT_GT(pm.GetPlan(a.id).score, 0.0);
    EXPECT_DOUBLE_EQ(pm.GetPlan(b.id).score, pm.GetPlan(b.id).score); // 不变
}

// ==================== 方案对比 ====================
TEST(PlanManagerTest, ComparePlanDetails) {
    PlanManager pm;
    Plan a = pm.CreatePlan("方案A", "描述A");
    Plan b = pm.CreatePlan("方案B", "描述B不同");
    PlanSubTask st1{"ST-A", "", "", "", 1, "unit_a", 10.0, 3};
    PlanSubTask st2{"ST-B", "", "", "", 1, "unit_b", 20.0, 5};
    pm.AddSubTask(a.id, st1);
    pm.AddSubTask(b.id, st2);
    pm.RecalculateAllScores();

    PlanComparison cmp = pm.ComparePlanDetails(a.id, b.id);
    EXPECT_FALSE(cmp.differences.empty());
    EXPECT_GE(cmp.differences.size(), 3u); // 评分、子任务数、时间、资源、描述、执行单元
}

TEST(PlanManagerTest, ComparePlanDetailsInvalidPlan) {
    PlanManager pm;
    pm.CreatePlan("A", "");
    PlanComparison cmp = pm.ComparePlanDetails("A", "nonexistent");
    EXPECT_EQ(cmp.differences.size(), 1u);
    EXPECT_THAT(cmp.differences[0], testing::HasSubstr("不存在"));
}

TEST(PlanManagerTest, ComparePlansString) {
    PlanManager pm;
    Plan a = pm.CreatePlan("方案A", "");
    Plan b = pm.CreatePlan("方案B", "");
    std::string result = pm.ComparePlans(a.id, b.id);
    EXPECT_FALSE(result.empty());
    EXPECT_THAT(result, testing::HasSubstr("Comparison"));
}

// ==================== GetTopologicalOrder ====================
TEST(PlanManagerTest, GetTopologicalOrderEmpty) {
    PlanManager pm;
    Plan plan = pm.CreatePlan("空方案", "");
    auto order = pm.GetTopologicalOrder(plan.id);
    EXPECT_TRUE(order.empty());
}

TEST(PlanManagerTest, GetTopologicalOrderSingleRoot) {
    PlanManager pm;
    Plan plan = pm.CreatePlan("单根", "");
    PlanSubTask root{"ROOT", "", "根任务", "", 0, "", 10.0, 1};
    pm.AddSubTask(plan.id, root);

    auto order = pm.GetTopologicalOrder(plan.id);
    EXPECT_EQ(order.size(), 1u);
    EXPECT_EQ(order[0].id, "ROOT");
}

TEST(PlanManagerTest, GetTopologicalOrderTree) {
    PlanManager pm;
    Plan plan = pm.CreatePlan("树形", "");
    PlanSubTask root{"ROOT", "", "根", "", 0, "", 10.0, 1};
    PlanSubTask child1{"CH1", "ROOT", "子1", "", 1, "", 10.0, 1};
    PlanSubTask child2{"CH2", "ROOT", "子2", "", 2, "", 10.0, 1};
    PlanSubTask grandchild{"GC", "CH1", "孙", "", 1, "", 10.0, 1};
    pm.AddSubTask(plan.id, root);
    pm.AddSubTask(plan.id, child1);
    pm.AddSubTask(plan.id, child2);
    pm.AddSubTask(plan.id, grandchild);

    auto order = pm.GetTopologicalOrder(plan.id);
    EXPECT_EQ(order.size(), 4u);
    EXPECT_EQ(order[0].id, "ROOT"); // 根节点优先
}

TEST(PlanManagerTest, GetTopologicalOrderInvalidPlan) {
    PlanManager pm;
    auto order = pm.GetTopologicalOrder("nonexistent");
    EXPECT_TRUE(order.empty());
}

// ==================== 边界与压力测试 ====================
TEST(PlanManagerTest, CreateManyPlans) {
    PlanManager pm;
    for (int i = 0; i < 50; ++i) {
        pm.CreatePlan("Plan-" + std::to_string(i), "");
    }
    EXPECT_EQ(pm.GetPlanCount(), 50u);
}

TEST(PlanManagerTest, LargeSubTaskTree) {
    PlanManager pm;
    Plan plan = pm.CreatePlan("大树", "");
    for (int i = 0; i < 100; ++i) {
        PlanSubTask st{"ST-"+std::to_string(i), "", "Task"+std::to_string(i), "", i, "u"+std::to_string(i%5), static_cast<double>(i), i%10};
        pm.AddSubTask(plan.id, st);
    }
    EXPECT_EQ(pm.GetPlan(plan.id).SubTaskCount(), 100u);
}