#include <gtest/gtest.h>
#include "core/dispatch.hpp"
#include <string>
#include <vector>
#include <memory>
#include <chrono>

// 为保持测试独立可编译，此处提供依赖结构体的最小化定义
// 实际项目中应直接包含对应头文件
namespace battlefield {
struct Plan {
    std::string id;
    std::string name;
    std::vector<std::string> subTasks;
};
struct CmdPacket {
    std::string packetId;
    std::string planId;
    std::string targetUnit;
    std::string payload;
    std::chrono::system_clock::time_point issueTime;
};
struct MonitorStatus {
    int32_t totalTasks = 0;
    int32_t completedTasks = 0;
    int32_t inProgressTasks = 0;
    int32_t failedTasks = 0;
    double progressPercent = 0.0;
};
struct DispatchLog {
    std::string logId;
    std::string planId;
    std::string action;
    std::chrono::system_clock::time_point timestamp;
    bool success;
};

class DispatchMonitor {
public:
    CmdPacket DispatchPlan(const Plan& plan, const std::string& targetUnit);
    MonitorStatus GetMonitorStatus() const;
    std::string GetDashboardData() const;
    void LogDispatch(const std::string& planId, const std::string& action, bool success);
    void AdvanceProgress(int32_t completed);
private:
    std::vector<CmdPacket> issuedPackets_;
    std::vector<DispatchLog> logs_;
    MonitorStatus status_;
};
} // namespace battlefield

// 测试夹具
class DispatchMonitorTest : public ::testing::Test {
protected:
    void SetUp() override {
        monitor_ = std::make_unique<battlefield::DispatchMonitor>();
    }
    void TearDown() override {
        monitor_.reset();
    }
    std::unique_ptr<battlefield::DispatchMonitor> monitor_;
};

// ==================== DispatchPlan 测试 ====================
TEST_F(DispatchMonitorTest, testDispatchPlanNormalInput) {
    // 正常输入：包含多个子任务的计划
    battlefield::Plan plan{"P001", "Attack Plan", {"Task1", "Task2", "Task3"}};
    std::string target = "UnitAlpha";

    auto packet = monitor_->DispatchPlan(plan, target);

    // 验证返回值
    EXPECT_EQ(packet.packetId, "CMD-P001");
    EXPECT_EQ(packet.planId, "P001");
    EXPECT_EQ(packet.targetUnit, "UnitAlpha");
    EXPECT_TRUE(packet.payload.find("Attack Plan") != std::string::npos);
    EXPECT_TRUE(packet.payload.find("3") != std::string::npos);

    // 验证副作用：状态更新
    auto status = monitor_->GetMonitorStatus();
    EXPECT_EQ(status.totalTasks, 3);
    EXPECT_EQ(status.inProgressTasks, 3);
    EXPECT_EQ(status.completedTasks, 0);
}

TEST_F(DispatchMonitorTest, testDispatchPlanBoundaryZeroTasks) {
    // 边界值测试：空子任务列表
    battlefield::Plan plan{"P002", "Empty Plan", {}};
    auto packet = monitor_->DispatchPlan(plan, "UnitBeta");

    EXPECT_EQ(packet.packetId, "CMD-P002");
    auto status = monitor_->GetMonitorStatus();
    EXPECT_EQ(status.totalTasks, 0);
    EXPECT_EQ(status.inProgressTasks, 0);
}

// ==================== GetMonitorStatus 测试 ====================
TEST_F(DispatchMonitorTest, testGetMonitorStatusInitialState) {
    // 正常输入：初始状态验证
    auto status = monitor_->GetMonitorStatus();
    EXPECT_EQ(status.totalTasks, 0);
    EXPECT_EQ(status.completedTasks, 0);
    EXPECT_EQ(status.inProgressTasks, 0);
    EXPECT_EQ(status.failedTasks, 0);
    EXPECT_DOUBLE_EQ(status.progressPercent, 0.0);
}

// ==================== GetDashboardData 测试 ====================
TEST_F(DispatchMonitorTest, testGetDashboardDataNormalFormat) {
    // 正常输入：执行部分操作后验证仪表盘格式
    battlefield::Plan plan{"P003", "Test Plan", {"T1", "T2"}};
    monitor_->DispatchPlan(plan, "UnitGamma");
    monitor_->AdvanceProgress(1);

    std::string dashboard = monitor_->GetDashboardData();
    EXPECT_TRUE(dashboard.find("=== Dashboard ===") != std::string::npos);
    EXPECT_TRUE(dashboard.find("Total Tasks: 2") != std::string::npos);
    EXPECT_TRUE(dashboard.find("Completed: 1") != std::string::npos);
    EXPECT_TRUE(dashboard.find("In Progress: 1") != std::string::npos);
    EXPECT_TRUE(dashboard.find("Progress: 50.0%") != std::string::npos);
    EXPECT_TRUE(dashboard.find("Issued Packets: 1") != std::string::npos);
    EXPECT_TRUE(dashboard.find("Log Entries: 1") != std::string::npos);
}

TEST_F(DispatchMonitorTest, testGetDashboardDataEmptyState) {
    // 边界值测试：空状态下的仪表盘输出
    std::string dashboard = monitor_->GetDashboardData();
    EXPECT_TRUE(dashboard.find("Total Tasks: 0") != std::string::npos);
    EXPECT_TRUE(dashboard.find("Progress: 0.0%") != std::string::npos);
    EXPECT_TRUE(dashboard.find("Issued Packets: 0") != std::string::npos);
}

// ==================== LogDispatch 测试 ====================
TEST_F(DispatchMonitorTest, testLogDispatchNormalSuccess) {
    // 正常输入：记录成功日志
    monitor_->LogDispatch("P004", "START", true);
    std::string dash = monitor_->GetDashboardData();
    EXPECT_TRUE(dash.find("Log Entries: 1") != std::string::npos);
}

TEST_F(DispatchMonitorTest, testLogDispatchBoundaryEmptyStrings) {
    // 边界值测试：空字符串参数
    monitor_->LogDispatch("", "", false);
    std::string dash = monitor_->GetDashboardData();
    EXPECT_TRUE(dash.find("Log Entries: 1") != std::string::npos);
    // 验证日志ID自增逻辑正常
    monitor_->LogDispatch("P005", "END", true);
    dash = monitor_->GetDashboardData();
    EXPECT_TRUE(dash.find("Log Entries: 2") != std::string::npos);
}

// ==================== AdvanceProgress 测试 ====================
TEST_F(DispatchMonitorTest, testAdvanceProgressNormal) {
    // 正常输入：正常推进进度
    battlefield::Plan plan{"P005", "Progress Plan", {"A", "B", "C", "D"}};
    monitor_->DispatchPlan(plan, "UnitDelta");
    monitor_->AdvanceProgress(2);

    auto status = monitor_->GetMonitorStatus();
    EXPECT_EQ(status.completedTasks, 2);
    EXPECT_EQ(status.inProgressTasks, 2);
    EXPECT_DOUBLE_EQ(status.progressPercent, 50.0);
}

TEST_F(DispatchMonitorTest, testAdvanceProgressBoundaryClamping) {
    // 边界值测试：完成数大于进行中任务数（触发截断）
    battlefield::Plan plan{"P006", "Clamp Plan", {"X", "Y"}};
    monitor_->DispatchPlan(plan, "UnitEpsilon");
    monitor_->AdvanceProgress(10); // 10 > 2

    auto status = monitor_->GetMonitorStatus();
    EXPECT_EQ(status.completedTasks, 2);
    EXPECT_EQ(status.inProgressTasks, 0);
    EXPECT_DOUBLE_EQ(status.progressPercent, 100.0);
}

TEST_F(DispatchMonitorTest, testAdvanceProgressSpecialZeroTotal) {
    // 特殊场景测试：总任务数为0时避免除零异常
    monitor_->AdvanceProgress(5);
    auto status = monitor_->GetMonitorStatus();
    // inProgressTasks 初始为0，min(5, 0) = 0，故 completedTasks 不变
    EXPECT_EQ(status.completedTasks, 0);
    EXPECT_DOUBLE_EQ(status.progressPercent, 0.0);
}