#include <gtest/gtest.h>
#include <vector>
#include <string>
#include <cstdint>
#include <ctime>
#include "app.hpp"

/**
 * 测试文件: test_app.cpp
 * 被测文件: app.cpp (dsu namespace)
 * 说明: 由于s_storage为静态全局变量，无法在测试中直接重置，
 *       各测试用例使用唯一的channelId以避免数据干扰。
 *       注意：StorageStatus 和 QueryCondition 定义在全局命名空间。
 */

// ==================== DSU_Write 测试 ====================

class DSUWriteTest : public ::testing::Test {
protected:
    uint32_t channelId = 0;
    time_t timestamp = 1000000;

    void SetUp() override {
        static uint32_t channelCounter = 2000;
        channelId = channelCounter++;
    }
};

// 测试正常写入数据流
TEST_F(DSUWriteTest, testDSUWriteNormalInput) {
    std::vector<uint8_t> data = {0x01, 0x02, 0x03, 0x04};
    bool result = dsu::DSU_Write(data, channelId, timestamp);
    EXPECT_TRUE(result);
}

// 测试空数据写入应返回false
TEST_F(DSUWriteTest, testDSUWriteEmptyData) {
    std::vector<uint8_t> data;
    bool result = dsu::DSU_Write(data, channelId, timestamp);
    EXPECT_FALSE(result);
}

// 测试channelId和timestamp为0的边界值
TEST_F(DSUWriteTest, testDSUWriteBoundaryZeroValues) {
    std::vector<uint8_t> data = {0xFF};
    bool result = dsu::DSU_Write(data, 0, 0);
    EXPECT_TRUE(result);
}

// 测试channelId和timestamp为最大值
TEST_F(DSUWriteTest, testDSUWriteMaxValues) {
    std::vector<uint8_t> data = {0xAB, 0xCD};
    bool result = dsu::DSU_Write(data, UINT32_MAX, static_cast<time_t>(UINT32_MAX));
    EXPECT_TRUE(result);
}

// 测试单字节数据写入
TEST_F(DSUWriteTest, testDSUWriteSingleByte) {
    std::vector<uint8_t> data = {0x42};
    bool result = dsu::DSU_Write(data, channelId, timestamp);
    EXPECT_TRUE(result);
}

// 测试大数据块写入
TEST_F(DSUWriteTest, testDSUWriteLargeData) {
    std::vector<uint8_t> data(1024, 0xAA);
    bool result = dsu::DSU_Write(data, channelId, timestamp);
    EXPECT_TRUE(result);
}

// ==================== DSU_CheckDisk 测试 ====================

// 测试磁盘健康状态检查（正常状态）
TEST(DSUCheckDiskTest, testDSUCheckDiskHealthy) {
    StorageStatus status = dsu::DSU_CheckDisk();
    EXPECT_TRUE(status == StorageStatus::Healthy ||
                status == StorageStatus::Full);
}

// 测试磁盘存储满告警（写入超过1000条触发Full）
TEST(DSUCheckDiskTest, testDSUCheckDiskFull) {
    uint32_t fillChannel = 9000;
    for (int i = 0; i < 1005; ++i) {
        std::vector<uint8_t> data = {static_cast<uint8_t>(i & 0xFF)};
        dsu::DSU_Write(data, fillChannel, static_cast<time_t>(i));
    }
    StorageStatus status = dsu::DSU_CheckDisk();
    EXPECT_EQ(status, StorageStatus::Full);
}

// ==================== DSU_Query 测试 ====================

class DSUQueryTest : public ::testing::Test {
protected:
    uint32_t channelId = 0;

    void SetUp() override {
        static uint32_t channelCounter = 5000;
        channelId = channelCounter++;
    }
};

// 测试正常查询返回匹配数据
TEST_F(DSUQueryTest, testDSUQueryNormalInput) {
    std::vector<uint8_t> data1 = {0x01, 0x02};
    std::vector<uint8_t> data2 = {0x03, 0x04};
    dsu::DSU_Write(data1, channelId, 100);
    dsu::DSU_Write(data2, channelId, 200);

    QueryCondition condition;
    condition.channelId = channelId;
    condition.startTime = 100;
    condition.endTime = 200;
    condition.maxResults = 10;

    std::vector<std::vector<uint8_t>> results;
    std::string log;
    bool ret = dsu::DSU_Query(condition, results, log);

    EXPECT_TRUE(ret);
    EXPECT_EQ(results.size(), 2u);
    EXPECT_EQ(results[0], data1);
    EXPECT_EQ(results[1], data2);
}

// 测试无匹配数据时返回false
TEST_F(DSUQueryTest, testDSUQueryNoMatch) {
    QueryCondition condition;
    condition.channelId = 99999;
    condition.startTime = 0;
    condition.endTime = 100;
    condition.maxResults = 10;

    std::vector<std::vector<uint8_t>> results;
    std::string log;
    bool ret = dsu::DSU_Query(condition, results, log);

    EXPECT_FALSE(ret);
    EXPECT_TRUE(results.empty());
}

// 测试maxResults限制查询结果数量
TEST_F(DSUQueryTest, testDSUQueryMaxResultsLimit) {
    for (int i = 0; i < 5; ++i) {
        std::vector<uint8_t> data = {static_cast<uint8_t>(i)};
        dsu::DSU_Write(data, channelId, static_cast<time_t>(300 + i));
    }

    QueryCondition condition;
    condition.channelId = channelId;
    condition.startTime = 300;
    condition.endTime = 400;
    condition.maxResults = 3;

    std::vector<std::vector<uint8_t>> results;
    std::string log;
    bool ret = dsu::DSU_Query(condition, results, log);

    EXPECT_TRUE(ret);
    EXPECT_LE(results.size(), 3u);
}

// 测试时间范围精确查询
TEST_F(DSUQueryTest, testDSUQueryTimeRange) {
    std::vector<uint8_t> data1 = {0x10};
    std::vector<uint8_t> data2 = {0x20};
    std::vector<uint8_t> data3 = {0x30};
    dsu::DSU_Write(data1, channelId, 500);
    dsu::DSU_Write(data2, channelId, 600);
    dsu::DSU_Write(data3, channelId, 700);

    QueryCondition condition;
    condition.channelId = channelId;
    condition.startTime = 550;
    condition.endTime = 650;
    condition.maxResults = 10;

    std::vector<std::vector<uint8_t>> results;
    std::string log;
    bool ret = dsu::DSU_Query(condition, results, log);

    EXPECT_TRUE(ret);
    EXPECT_EQ(results.size(), 1u);
    EXPECT_EQ(results[0], data2);
}

// 测试查询日志包含结果数量信息
TEST_F(DSUQueryTest, testDSUQueryLogOutput) {
    std::vector<uint8_t> data = {0x01};
    dsu::DSU_Write(data, channelId, 100);

    QueryCondition condition;
    condition.channelId = channelId;
    condition.startTime = 100;
    condition.endTime = 100;
    condition.maxResults = 10;

    std::vector<std::vector<uint8_t>> results;
    std::string log;
    dsu::DSU_Query(condition, results, log);

    EXPECT_FALSE(log.empty());
    EXPECT_NE(log.find("Query returned"), std::string::npos);
}

// ==================== DSU_Replay 测试 ====================

class DSUReplayTest : public ::testing::Test {
protected:
    uint32_t channelId = 0;

    void SetUp() override {
        static uint32_t channelCounter = 7000;
        channelId = channelCounter++;
    }
};

// 测试正常回放数据
TEST_F(DSUReplayTest, testDSUReplayNormalInput) {
    std::vector<uint8_t> data1 = {0x01, 0x02};
    std::vector<uint8_t> data2 = {0x03, 0x04};
    dsu::DSU_Write(data1, channelId, 100);
    dsu::DSU_Write(data2, channelId, 200);

    QueryCondition condition;
    condition.channelId = channelId;
    condition.startTime = 100;
    condition.endTime = 200;
    condition.maxResults = 10;

    std::vector<uint8_t> replayOutput;
    std::string log;
    bool ret = dsu::DSU_Replay(condition, replayOutput, log);

    EXPECT_TRUE(ret);
    EXPECT_EQ(replayOutput.size(), 4u);
    EXPECT_EQ(replayOutput[0], 0x01);
    EXPECT_EQ(replayOutput[1], 0x02);
    EXPECT_EQ(replayOutput[2], 0x03);
    EXPECT_EQ(replayOutput[3], 0x04);
}

// 测试无数据时回放返回false
TEST_F(DSUReplayTest, testDSUReplayNoData) {
    QueryCondition condition;
    condition.channelId = 88888;
    condition.startTime = 0;
    condition.endTime = 100;
    condition.maxResults = 10;

    std::vector<uint8_t> replayOutput;
    std::string log;
    bool ret = dsu::DSU_Replay(condition, replayOutput, log);

    EXPECT_FALSE(ret);
}

// 测试多数据块按序拼接回放
TEST_F(DSUReplayTest, testDSUReplayMultipleBlocks) {
    std::vector<uint8_t> data1 = {0xAA};
    std::vector<uint8_t> data2 = {0xBB, 0xCC};
    std::vector<uint8_t> data3 = {0xDD, 0xEE, 0xFF};
    dsu::DSU_Write(data1, channelId, 100);
    dsu::DSU_Write(data2, channelId, 200);
    dsu::DSU_Write(data3, channelId, 300);

    QueryCondition condition;
    condition.channelId = channelId;
    condition.startTime = 100;
    condition.endTime = 300;
    condition.maxResults = 10;

    std::vector<uint8_t> replayOutput;
    std::string log;
    bool ret = dsu::DSU_Replay(condition, replayOutput, log);

    EXPECT_TRUE(ret);
    EXPECT_EQ(replayOutput.size(), 6u);
    EXPECT_EQ(replayOutput[0], 0xAA);
    EXPECT_EQ(replayOutput[1], 0xBB);
    EXPECT_EQ(replayOutput[2], 0xCC);
    EXPECT_EQ(replayOutput[3], 0xDD);
    EXPECT_EQ(replayOutput[4], 0xEE);
    EXPECT_EQ(replayOutput[5], 0xFF);
}

// 测试回放日志包含完成信息
TEST_F(DSUReplayTest, testDSUReplayLogContainsInfo) {
    std::vector<uint8_t> data = {0x01};
    dsu::DSU_Write(data, channelId, 100);

    QueryCondition condition;
    condition.channelId = channelId;
    condition.startTime = 100;
    condition.endTime = 100;
    condition.maxResults = 10;

    std::vector<uint8_t> replayOutput;
    std::string log;
    dsu::DSU_Replay(condition, replayOutput, log);

    EXPECT_FALSE(log.empty());
    EXPECT_NE(log.find("Replay completed"), std::string::npos);
}