/**
 * @file PacketFragmentTest.cpp
 * @brief 粘包/分包处理测试
 *
 * 测试覆盖：
 * - 完整包接收和解析
 * - 分包（不完整包）处理
 * - 粘包（多个包粘在一起）处理
 * - 混合场景测试
 * - 边界条件处理
 */

#include <gtest/gtest.h>
#include <cstring>
#include <cstdint>
#include <vector>
#include <queue>
#include <functional>

// ============================================
// 协议常量
// ============================================

const int FLAG_LENGTH = 8;
const int HDR_LENGTH = 16;  // FLAG(8) + PackedLen(4) + OrigLen(4)

// ============================================
// 简化版 CBuffer（测试专用）
// ============================================

class TestBuffer {
public:
    TestBuffer() {}

    void WriteBuffer(const uint8_t* data, size_t len) {
        m_data.insert(m_data.end(), data, data + len);
    }

    size_t ReadBuffer(uint8_t* dst, size_t len) {
        size_t toRead = std::min(len, m_data.size());
        if (toRead > 0) {
            memcpy(dst, m_data.data(), toRead);
            m_data.erase(m_data.begin(), m_data.begin() + toRead);
        }
        return toRead;
    }

    void Skip(size_t len) {
        size_t toSkip = std::min(len, m_data.size());
        m_data.erase(m_data.begin(), m_data.begin() + toSkip);
    }

    size_t GetBufferLength() const {
        return m_data.size();
    }

    const uint8_t* GetBuffer(size_t pos = 0) const {
        if (pos >= m_data.size()) return nullptr;
        return m_data.data() + pos;
    }

    bool CopyBuffer(uint8_t* dst, size_t pos, size_t len) const {
        if (pos + len > m_data.size()) return false;
        memcpy(dst, m_data.data() + pos, len);
        return true;
    }

    void Clear() {
        m_data.clear();
    }

private:
    std::vector<uint8_t> m_data;
};

// ============================================
// 数据包构建辅助函数
// ============================================

#pragma pack(push, 1)
struct PacketHeader {
    char flag[FLAG_LENGTH];
    uint32_t packedLength;      // 包含头部的总长度
    uint32_t originalLength;    // 原始数据长度
};
#pragma pack(pop)

std::vector<uint8_t> BuildPacket(const std::vector<uint8_t>& payload, uint8_t key = 0x42) {
    std::vector<uint8_t> packet(HDR_LENGTH + payload.size());

    PacketHeader* hdr = reinterpret_cast<PacketHeader*>(packet.data());
    memcpy(hdr->flag, "HELL", 4);
    hdr->flag[6] = key;
    hdr->flag[7] = ~key;
    hdr->packedLength = static_cast<uint32_t>(HDR_LENGTH + payload.size());
    hdr->originalLength = static_cast<uint32_t>(payload.size());

    if (!payload.empty()) {
        memcpy(packet.data() + HDR_LENGTH, payload.data(), payload.size());
    }

    return packet;
}

std::vector<uint8_t> BuildPacketWithData(size_t dataSize, uint8_t fillByte = 0xAA) {
    std::vector<uint8_t> payload(dataSize, fillByte);
    return BuildPacket(payload);
}

// ============================================
// 粘包/分包处理器（模拟 OnServerReceiving 逻辑）
// ============================================

class PacketProcessor {
public:
    using PacketCallback = std::function<void(const std::vector<uint8_t>&)>;

    PacketProcessor(PacketCallback callback) : m_callback(callback) {}

    // 接收数据（模拟网络接收）
    void OnReceive(const uint8_t* data, size_t len) {
        m_buffer.WriteBuffer(data, len);
        ProcessBuffer();
    }

    // 获取待处理的字节数
    size_t GetPendingBytes() const {
        return m_buffer.GetBufferLength();
    }

    // 获取已处理的包数量
    size_t GetProcessedCount() const {
        return m_processedCount;
    }

private:
    void ProcessBuffer() {
        while (m_buffer.GetBufferLength() >= HDR_LENGTH) {
            // 验证头部
            const uint8_t* buf = m_buffer.GetBuffer();
            if (memcmp(buf, "HELL", 4) != 0) {
                // 无效头部，跳过一个字节重试
                m_buffer.Skip(1);
                continue;
            }

            // 读取包长度
            uint32_t packedLength;
            m_buffer.CopyBuffer(reinterpret_cast<uint8_t*>(&packedLength),
                               FLAG_LENGTH, sizeof(uint32_t));

            // 检查长度有效性
            if (packedLength < HDR_LENGTH || packedLength > 100 * 1024 * 1024) {
                // 无效长度，跳过头部
                m_buffer.Skip(FLAG_LENGTH);
                continue;
            }

            // 检查包是否完整
            if (m_buffer.GetBufferLength() < packedLength) {
                // 不完整，等待更多数据
                break;
            }

            // 读取完整包
            std::vector<uint8_t> packet(packedLength);
            m_buffer.ReadBuffer(packet.data(), packedLength);

            // 提取 payload
            std::vector<uint8_t> payload(packet.begin() + HDR_LENGTH, packet.end());
            m_callback(payload);
            m_processedCount++;
        }
    }

    TestBuffer m_buffer;
    PacketCallback m_callback;
    size_t m_processedCount = 0;
};

// ============================================
// 完整包接收测试
// ============================================

class CompletePacketTest : public ::testing::Test {
protected:
    std::vector<std::vector<uint8_t>> receivedPackets;

    void SetUp() override {
        receivedPackets.clear();
    }

    PacketProcessor::PacketCallback GetCallback() {
        return [this](const std::vector<uint8_t>& payload) {
            receivedPackets.push_back(payload);
        };
    }
};

TEST_F(CompletePacketTest, SinglePacket) {
    PacketProcessor processor(GetCallback());

    std::vector<uint8_t> payload = {0x01, 0x02, 0x03, 0x04};
    auto packet = BuildPacket(payload);

    processor.OnReceive(packet.data(), packet.size());

    ASSERT_EQ(receivedPackets.size(), 1u);
    EXPECT_EQ(receivedPackets[0], payload);
    EXPECT_EQ(processor.GetPendingBytes(), 0u);
}

TEST_F(CompletePacketTest, EmptyPayload) {
    PacketProcessor processor(GetCallback());

    std::vector<uint8_t> payload;
    auto packet = BuildPacket(payload);

    processor.OnReceive(packet.data(), packet.size());

    ASSERT_EQ(receivedPackets.size(), 1u);
    EXPECT_TRUE(receivedPackets[0].empty());
}

TEST_F(CompletePacketTest, LargePayload) {
    PacketProcessor processor(GetCallback());

    std::vector<uint8_t> payload(64 * 1024);  // 64 KB
    for (size_t i = 0; i < payload.size(); ++i) {
        payload[i] = static_cast<uint8_t>(i & 0xFF);
    }
    auto packet = BuildPacket(payload);

    processor.OnReceive(packet.data(), packet.size());

    ASSERT_EQ(receivedPackets.size(), 1u);
    EXPECT_EQ(receivedPackets[0], payload);
}

// ============================================
// 分包（不完整包）测试
// ============================================

class FragmentedPacketTest : public ::testing::Test {
protected:
    std::vector<std::vector<uint8_t>> receivedPackets;

    PacketProcessor::PacketCallback GetCallback() {
        return [this](const std::vector<uint8_t>& payload) {
            receivedPackets.push_back(payload);
        };
    }
};

TEST_F(FragmentedPacketTest, TwoFragments) {
    PacketProcessor processor(GetCallback());

    std::vector<uint8_t> payload = {0xAA, 0xBB, 0xCC, 0xDD};
    auto packet = BuildPacket(payload);

    // 分两次发送
    size_t half = packet.size() / 2;
    processor.OnReceive(packet.data(), half);
    EXPECT_EQ(receivedPackets.size(), 0u);
    EXPECT_EQ(processor.GetPendingBytes(), half);

    processor.OnReceive(packet.data() + half, packet.size() - half);
    ASSERT_EQ(receivedPackets.size(), 1u);
    EXPECT_EQ(receivedPackets[0], payload);
}

TEST_F(FragmentedPacketTest, ManyFragments) {
    PacketProcessor processor(GetCallback());

    std::vector<uint8_t> payload(100);
    for (size_t i = 0; i < payload.size(); ++i) {
        payload[i] = static_cast<uint8_t>(i);
    }
    auto packet = BuildPacket(payload);

    // 每次发送 10 字节
    for (size_t i = 0; i < packet.size(); i += 10) {
        size_t len = std::min(size_t(10), packet.size() - i);
        processor.OnReceive(packet.data() + i, len);
    }

    ASSERT_EQ(receivedPackets.size(), 1u);
    EXPECT_EQ(receivedPackets[0], payload);
}

TEST_F(FragmentedPacketTest, OnlyHeader) {
    PacketProcessor processor(GetCallback());

    std::vector<uint8_t> payload = {0x01, 0x02};
    auto packet = BuildPacket(payload);

    // 只发送头部
    processor.OnReceive(packet.data(), HDR_LENGTH);
    EXPECT_EQ(receivedPackets.size(), 0u);
    EXPECT_EQ(processor.GetPendingBytes(), HDR_LENGTH);

    // 发送剩余数据
    processor.OnReceive(packet.data() + HDR_LENGTH, packet.size() - HDR_LENGTH);
    ASSERT_EQ(receivedPackets.size(), 1u);
}

TEST_F(FragmentedPacketTest, PartialHeader) {
    PacketProcessor processor(GetCallback());

    std::vector<uint8_t> payload = {0xFF};
    auto packet = BuildPacket(payload);

    // 发送不完整的头部
    processor.OnReceive(packet.data(), 4);  // 只有 "HELL"
    EXPECT_EQ(receivedPackets.size(), 0u);

    // 发送剩余部分
    processor.OnReceive(packet.data() + 4, packet.size() - 4);
    ASSERT_EQ(receivedPackets.size(), 1u);
}

// ============================================
// 粘包测试
// ============================================

class StickyPacketTest : public ::testing::Test {
protected:
    std::vector<std::vector<uint8_t>> receivedPackets;

    PacketProcessor::PacketCallback GetCallback() {
        return [this](const std::vector<uint8_t>& payload) {
            receivedPackets.push_back(payload);
        };
    }
};

TEST_F(StickyPacketTest, TwoPacketsStuckTogether) {
    PacketProcessor processor(GetCallback());

    std::vector<uint8_t> payload1 = {0x11, 0x22};
    std::vector<uint8_t> payload2 = {0x33, 0x44, 0x55};
    auto packet1 = BuildPacket(payload1);
    auto packet2 = BuildPacket(payload2);

    // 合并两个包
    std::vector<uint8_t> combined;
    combined.insert(combined.end(), packet1.begin(), packet1.end());
    combined.insert(combined.end(), packet2.begin(), packet2.end());

    processor.OnReceive(combined.data(), combined.size());

    ASSERT_EQ(receivedPackets.size(), 2u);
    EXPECT_EQ(receivedPackets[0], payload1);
    EXPECT_EQ(receivedPackets[1], payload2);
}

TEST_F(StickyPacketTest, ThreePacketsStuckTogether) {
    PacketProcessor processor(GetCallback());

    std::vector<uint8_t> payload1 = {0x01};
    std::vector<uint8_t> payload2 = {0x02, 0x03};
    std::vector<uint8_t> payload3 = {0x04, 0x05, 0x06};
    auto packet1 = BuildPacket(payload1);
    auto packet2 = BuildPacket(payload2);
    auto packet3 = BuildPacket(payload3);

    // 合并三个包
    std::vector<uint8_t> combined;
    combined.insert(combined.end(), packet1.begin(), packet1.end());
    combined.insert(combined.end(), packet2.begin(), packet2.end());
    combined.insert(combined.end(), packet3.begin(), packet3.end());

    processor.OnReceive(combined.data(), combined.size());

    ASSERT_EQ(receivedPackets.size(), 3u);
    EXPECT_EQ(receivedPackets[0], payload1);
    EXPECT_EQ(receivedPackets[1], payload2);
    EXPECT_EQ(receivedPackets[2], payload3);
}

TEST_F(StickyPacketTest, ManyPacketsStuckTogether) {
    PacketProcessor processor(GetCallback());

    std::vector<uint8_t> combined;
    const int numPackets = 100;

    for (int i = 0; i < numPackets; ++i) {
        std::vector<uint8_t> payload(i % 10 + 1, static_cast<uint8_t>(i));
        auto packet = BuildPacket(payload);
        combined.insert(combined.end(), packet.begin(), packet.end());
    }

    processor.OnReceive(combined.data(), combined.size());

    EXPECT_EQ(receivedPackets.size(), numPackets);
}

// ============================================
// 混合场景测试
// ============================================

class MixedScenarioTest : public ::testing::Test {
protected:
    std::vector<std::vector<uint8_t>> receivedPackets;

    PacketProcessor::PacketCallback GetCallback() {
        return [this](const std::vector<uint8_t>& payload) {
            receivedPackets.push_back(payload);
        };
    }
};

TEST_F(MixedScenarioTest, OneAndHalfPackets) {
    PacketProcessor processor(GetCallback());

    std::vector<uint8_t> payload1 = {0xAA, 0xBB};
    std::vector<uint8_t> payload2 = {0xCC, 0xDD, 0xEE, 0xFF};
    auto packet1 = BuildPacket(payload1);
    auto packet2 = BuildPacket(payload2);

    // 发送完整包1 + 半个包2
    std::vector<uint8_t> firstSend;
    firstSend.insert(firstSend.end(), packet1.begin(), packet1.end());
    firstSend.insert(firstSend.end(), packet2.begin(), packet2.begin() + packet2.size() / 2);

    processor.OnReceive(firstSend.data(), firstSend.size());
    EXPECT_EQ(receivedPackets.size(), 1u);  // 只处理了包1

    // 发送剩余的半个包2
    processor.OnReceive(packet2.data() + packet2.size() / 2, packet2.size() - packet2.size() / 2);
    ASSERT_EQ(receivedPackets.size(), 2u);
    EXPECT_EQ(receivedPackets[0], payload1);
    EXPECT_EQ(receivedPackets[1], payload2);
}

TEST_F(MixedScenarioTest, HalfPacketThenOneAndHalf) {
    PacketProcessor processor(GetCallback());

    std::vector<uint8_t> payload1 = {0x11};
    std::vector<uint8_t> payload2 = {0x22, 0x33};
    auto packet1 = BuildPacket(payload1);
    auto packet2 = BuildPacket(payload2);

    // 发送半个包1
    processor.OnReceive(packet1.data(), packet1.size() / 2);
    EXPECT_EQ(receivedPackets.size(), 0u);

    // 发送剩余包1 + 完整包2
    std::vector<uint8_t> secondSend;
    secondSend.insert(secondSend.end(), packet1.begin() + packet1.size() / 2, packet1.end());
    secondSend.insert(secondSend.end(), packet2.begin(), packet2.end());

    processor.OnReceive(secondSend.data(), secondSend.size());
    ASSERT_EQ(receivedPackets.size(), 2u);
}

TEST_F(MixedScenarioTest, RandomChunkSizes) {
    PacketProcessor processor(GetCallback());

    // 准备多个包
    std::vector<std::vector<uint8_t>> payloads;
    std::vector<uint8_t> allData;

    for (int i = 0; i < 10; ++i) {
        std::vector<uint8_t> payload(i * 5 + 10, static_cast<uint8_t>(i));
        payloads.push_back(payload);
        auto packet = BuildPacket(payload);
        allData.insert(allData.end(), packet.begin(), packet.end());
    }

    // 使用"随机"大小的块发送
    size_t chunkSizes[] = {1, 7, 15, 16, 17, 31, 32, 33, 64, 128};
    size_t pos = 0;
    size_t chunkIdx = 0;

    while (pos < allData.size()) {
        size_t chunkSize = chunkSizes[chunkIdx % (sizeof(chunkSizes) / sizeof(chunkSizes[0]))];
        size_t len = std::min(chunkSize, allData.size() - pos);
        processor.OnReceive(allData.data() + pos, len);
        pos += len;
        chunkIdx++;
    }

    ASSERT_EQ(receivedPackets.size(), payloads.size());
    for (size_t i = 0; i < payloads.size(); ++i) {
        EXPECT_EQ(receivedPackets[i], payloads[i]) << "Mismatch at packet " << i;
    }
}

// ============================================
// 边界条件测试
// ============================================

class PacketBoundaryTest : public ::testing::Test {
protected:
    std::vector<std::vector<uint8_t>> receivedPackets;

    PacketProcessor::PacketCallback GetCallback() {
        return [this](const std::vector<uint8_t>& payload) {
            receivedPackets.push_back(payload);
        };
    }
};

TEST_F(PacketBoundaryTest, ExactlyHdrLength) {
    PacketProcessor processor(GetCallback());

    // 只有头部，无 payload
    std::vector<uint8_t> packet(HDR_LENGTH);
    PacketHeader* hdr = reinterpret_cast<PacketHeader*>(packet.data());
    memcpy(hdr->flag, "HELL", 4);
    hdr->flag[6] = 0x42;
    hdr->flag[7] = ~0x42;
    hdr->packedLength = HDR_LENGTH;
    hdr->originalLength = 0;

    processor.OnReceive(packet.data(), packet.size());

    ASSERT_EQ(receivedPackets.size(), 1u);
    EXPECT_TRUE(receivedPackets[0].empty());
}

TEST_F(PacketBoundaryTest, SingleBytePayload) {
    PacketProcessor processor(GetCallback());

    std::vector<uint8_t> payload = {0xFF};
    auto packet = BuildPacket(payload);

    processor.OnReceive(packet.data(), packet.size());

    ASSERT_EQ(receivedPackets.size(), 1u);
    EXPECT_EQ(receivedPackets[0].size(), 1u);
    EXPECT_EQ(receivedPackets[0][0], 0xFF);
}

TEST_F(PacketBoundaryTest, ByteByByteReceive) {
    PacketProcessor processor(GetCallback());

    std::vector<uint8_t> payload = {0x12, 0x34, 0x56};
    auto packet = BuildPacket(payload);

    // 每次接收 1 字节
    for (size_t i = 0; i < packet.size(); ++i) {
        processor.OnReceive(packet.data() + i, 1);
    }

    ASSERT_EQ(receivedPackets.size(), 1u);
    EXPECT_EQ(receivedPackets[0], payload);
}

// ============================================
// 数据完整性测试
// ============================================

class DataIntegrityTest : public ::testing::Test {
protected:
    std::vector<std::vector<uint8_t>> receivedPackets;

    PacketProcessor::PacketCallback GetCallback() {
        return [this](const std::vector<uint8_t>& payload) {
            receivedPackets.push_back(payload);
        };
    }
};

TEST_F(DataIntegrityTest, BinaryData) {
    PacketProcessor processor(GetCallback());

    // 包含所有字节值的 payload
    std::vector<uint8_t> payload(256);
    for (int i = 0; i < 256; ++i) {
        payload[i] = static_cast<uint8_t>(i);
    }
    auto packet = BuildPacket(payload);

    processor.OnReceive(packet.data(), packet.size());

    ASSERT_EQ(receivedPackets.size(), 1u);
    EXPECT_EQ(receivedPackets[0], payload);
}

TEST_F(DataIntegrityTest, AllZeros) {
    PacketProcessor processor(GetCallback());

    std::vector<uint8_t> payload(100, 0x00);
    auto packet = BuildPacket(payload);

    processor.OnReceive(packet.data(), packet.size());

    ASSERT_EQ(receivedPackets.size(), 1u);
    for (uint8_t b : receivedPackets[0]) {
        EXPECT_EQ(b, 0x00);
    }
}

TEST_F(DataIntegrityTest, AllOnes) {
    PacketProcessor processor(GetCallback());

    std::vector<uint8_t> payload(100, 0xFF);
    auto packet = BuildPacket(payload);

    processor.OnReceive(packet.data(), packet.size());

    ASSERT_EQ(receivedPackets.size(), 1u);
    for (uint8_t b : receivedPackets[0]) {
        EXPECT_EQ(b, 0xFF);
    }
}

// ============================================
// 性能相关测试
// ============================================

class PacketPerformanceTest : public ::testing::Test {
protected:
    size_t packetCount = 0;

    PacketProcessor::PacketCallback GetCallback() {
        return [this](const std::vector<uint8_t>& payload) {
            packetCount++;
        };
    }
};

TEST_F(PacketPerformanceTest, ManySmallPackets) {
    PacketProcessor processor(GetCallback());

    const int numPackets = 10000;
    std::vector<uint8_t> allData;

    for (int i = 0; i < numPackets; ++i) {
        std::vector<uint8_t> payload = {static_cast<uint8_t>(i & 0xFF)};
        auto packet = BuildPacket(payload);
        allData.insert(allData.end(), packet.begin(), packet.end());
    }

    processor.OnReceive(allData.data(), allData.size());

    EXPECT_EQ(packetCount, numPackets);
}

TEST_F(PacketPerformanceTest, LargePacketInSmallChunks) {
    PacketProcessor processor(GetCallback());

    std::vector<uint8_t> payload(100 * 1024);  // 100 KB
    for (size_t i = 0; i < payload.size(); ++i) {
        payload[i] = static_cast<uint8_t>(i & 0xFF);
    }
    auto packet = BuildPacket(payload);

    // 每次发送 1 KB
    const size_t chunkSize = 1024;
    for (size_t i = 0; i < packet.size(); i += chunkSize) {
        size_t len = std::min(chunkSize, packet.size() - i);
        processor.OnReceive(packet.data() + i, len);
    }

    EXPECT_EQ(packetCount, 1u);
}