/**
 * @file ResumeStateTest.cpp
 * @brief 断点续传状态管理测试
 *
 * 测试覆盖：
 * - 续传状态序列化/反序列化
 * - 续传请求/响应包构建
 * - 状态文件格式
 * - 多文件续传管理
 */

#include <gtest/gtest.h>
#include <cstring>
#include <vector>
#include <map>
#include <string>
#include <cstdint>

// ============================================
// 协议结构（测试专用）
// ============================================

#pragma pack(push, 1)

struct FileRangeV2 {
    uint64_t    offset;
    uint64_t    length;
};

struct FileResumePacketV2 {
    uint8_t     cmd;
    uint64_t    transferID;
    uint64_t    srcClientID;
    uint64_t    dstClientID;
    uint32_t    fileIndex;
    uint64_t    fileSize;
    uint64_t    receivedBytes;
    uint16_t    flags;
    uint16_t    rangeCount;
};

enum FileFlagsV2 : uint16_t {
    FFV2_NONE         = 0x0000,
    FFV2_RESUME_REQ   = 0x0002,
    FFV2_RESUME_RESP  = 0x0004,
};

struct FileResumeResponseV2 {
    uint8_t     cmd;
    uint64_t    srcClientID;
    uint64_t    dstClientID;
    uint16_t    flags;
    uint32_t    fileCount;
};

struct FileResumeResponseEntryV2 {
    uint32_t    fileIndex;
    uint64_t    receivedBytes;
};

#pragma pack(pop)

// ============================================
// 续传状态管理类（测试专用实现）
// ============================================

struct FileResumeEntry {
    uint32_t fileIndex;
    uint64_t fileSize;
    uint64_t receivedBytes;
    std::string relativePath;
    std::vector<std::pair<uint64_t, uint64_t>> receivedRanges;
};

class ResumeStateManager {
public:
    ResumeStateManager() : m_transferID(0), m_srcClientID(0), m_dstClientID(0) {}

    void Initialize(uint64_t transferID, uint64_t srcClientID, uint64_t dstClientID,
                   const std::string& targetDir) {
        m_transferID = transferID;
        m_srcClientID = srcClientID;
        m_dstClientID = dstClientID;
        m_targetDir = targetDir;
        m_entries.clear();
    }

    void AddFile(uint32_t fileIndex, uint64_t fileSize, const std::string& path) {
        FileResumeEntry entry;
        entry.fileIndex = fileIndex;
        entry.fileSize = fileSize;
        entry.receivedBytes = 0;
        entry.relativePath = path;
        m_entries.push_back(entry);
    }

    void UpdateProgress(uint32_t fileIndex, uint64_t offset, uint64_t length) {
        for (auto& entry : m_entries) {
            if (entry.fileIndex == fileIndex) {
                entry.receivedRanges.emplace_back(offset, length);
                entry.receivedBytes += length;
                break;
            }
        }
    }

    bool GetFileState(uint32_t fileIndex, FileResumeEntry& outEntry) const {
        for (const auto& entry : m_entries) {
            if (entry.fileIndex == fileIndex) {
                outEntry = entry;
                return true;
            }
        }
        return false;
    }

    // 序列化为字节流
    std::vector<uint8_t> Serialize() const {
        std::vector<uint8_t> buffer;

        // Header
        auto appendU64 = [&buffer](uint64_t val) {
            for (int i = 0; i < 8; ++i) {
                buffer.push_back(static_cast<uint8_t>(val >> (i * 8)));
            }
        };
        auto appendU32 = [&buffer](uint32_t val) {
            for (int i = 0; i < 4; ++i) {
                buffer.push_back(static_cast<uint8_t>(val >> (i * 8)));
            }
        };
        auto appendU16 = [&buffer](uint16_t val) {
            buffer.push_back(static_cast<uint8_t>(val & 0xFF));
            buffer.push_back(static_cast<uint8_t>(val >> 8));
        };
        auto appendString = [&buffer, &appendU16](const std::string& str) {
            appendU16(static_cast<uint16_t>(str.size()));
            buffer.insert(buffer.end(), str.begin(), str.end());
        };

        // Magic
        buffer.push_back('R');
        buffer.push_back('S');
        buffer.push_back('T');
        buffer.push_back('V');  // Resume State V2

        appendU64(m_transferID);
        appendU64(m_srcClientID);
        appendU64(m_dstClientID);
        appendString(m_targetDir);
        appendU32(static_cast<uint32_t>(m_entries.size()));

        for (const auto& entry : m_entries) {
            appendU32(entry.fileIndex);
            appendU64(entry.fileSize);
            appendU64(entry.receivedBytes);
            appendString(entry.relativePath);
            appendU16(static_cast<uint16_t>(entry.receivedRanges.size()));
            for (const auto& range : entry.receivedRanges) {
                appendU64(range.first);
                appendU64(range.second);
            }
        }

        return buffer;
    }

    // 从字节流反序列化
    bool Deserialize(const std::vector<uint8_t>& buffer) {
        if (buffer.size() < 8) return false;

        size_t pos = 0;

        auto readU64 = [&buffer, &pos]() -> uint64_t {
            if (pos + 8 > buffer.size()) return 0;
            uint64_t val = 0;
            for (int i = 0; i < 8; ++i) {
                val |= static_cast<uint64_t>(buffer[pos++]) << (i * 8);
            }
            return val;
        };
        auto readU32 = [&buffer, &pos]() -> uint32_t {
            if (pos + 4 > buffer.size()) return 0;
            uint32_t val = 0;
            for (int i = 0; i < 4; ++i) {
                val |= static_cast<uint32_t>(buffer[pos++]) << (i * 8);
            }
            return val;
        };
        auto readU16 = [&buffer, &pos]() -> uint16_t {
            if (pos + 2 > buffer.size()) return 0;
            uint16_t val = buffer[pos] | (buffer[pos + 1] << 8);
            pos += 2;
            return val;
        };
        auto readString = [&buffer, &pos, &readU16]() -> std::string {
            uint16_t len = readU16();
            if (pos + len > buffer.size()) return "";
            std::string str(buffer.begin() + pos, buffer.begin() + pos + len);
            pos += len;
            return str;
        };

        // Check magic
        if (buffer[0] != 'R' || buffer[1] != 'S' || buffer[2] != 'T' || buffer[3] != 'V') {
            return false;
        }
        pos = 4;

        m_transferID = readU64();
        m_srcClientID = readU64();
        m_dstClientID = readU64();
        m_targetDir = readString();
        uint32_t entryCount = readU32();

        m_entries.clear();
        for (uint32_t i = 0; i < entryCount; ++i) {
            FileResumeEntry entry;
            entry.fileIndex = readU32();
            entry.fileSize = readU64();
            entry.receivedBytes = readU64();
            entry.relativePath = readString();
            uint16_t rangeCount = readU16();
            for (uint16_t j = 0; j < rangeCount; ++j) {
                uint64_t offset = readU64();
                uint64_t length = readU64();
                entry.receivedRanges.emplace_back(offset, length);
            }
            m_entries.push_back(entry);
        }

        return true;
    }

    uint64_t GetTransferID() const { return m_transferID; }
    uint64_t GetSrcClientID() const { return m_srcClientID; }
    uint64_t GetDstClientID() const { return m_dstClientID; }
    const std::string& GetTargetDir() const { return m_targetDir; }
    size_t GetFileCount() const { return m_entries.size(); }

    // 获取所有文件的接收偏移映射
    std::map<uint32_t, uint64_t> GetReceivedOffsets() const {
        std::map<uint32_t, uint64_t> offsets;
        for (const auto& entry : m_entries) {
            offsets[entry.fileIndex] = entry.receivedBytes;
        }
        return offsets;
    }

private:
    uint64_t m_transferID;
    uint64_t m_srcClientID;
    uint64_t m_dstClientID;
    std::string m_targetDir;
    std::vector<FileResumeEntry> m_entries;
};

// ============================================
// 续传包构建/解析辅助函数
// ============================================

std::vector<uint8_t> BuildResumeRequest(
    uint64_t transferID,
    uint64_t srcClientID,
    uint64_t dstClientID,
    uint32_t fileIndex,
    uint64_t fileSize,
    uint64_t receivedBytes,
    const std::vector<std::pair<uint64_t, uint64_t>>& ranges)
{
    size_t size = sizeof(FileResumePacketV2) + ranges.size() * sizeof(FileRangeV2);
    std::vector<uint8_t> buffer(size);

    FileResumePacketV2* pkt = reinterpret_cast<FileResumePacketV2*>(buffer.data());
    pkt->cmd = 86;  // COMMAND_FILE_RESUME
    pkt->transferID = transferID;
    pkt->srcClientID = srcClientID;
    pkt->dstClientID = dstClientID;
    pkt->fileIndex = fileIndex;
    pkt->fileSize = fileSize;
    pkt->receivedBytes = receivedBytes;
    pkt->flags = FFV2_RESUME_REQ;
    pkt->rangeCount = static_cast<uint16_t>(ranges.size());

    FileRangeV2* rangePtr = reinterpret_cast<FileRangeV2*>(buffer.data() + sizeof(FileResumePacketV2));
    for (size_t i = 0; i < ranges.size(); ++i) {
        rangePtr[i].offset = ranges[i].first;
        rangePtr[i].length = ranges[i].second;
    }

    return buffer;
}

bool ParseResumeRequest(
    const uint8_t* buffer, size_t len,
    FileResumePacketV2& header,
    std::vector<std::pair<uint64_t, uint64_t>>& ranges)
{
    if (len < sizeof(FileResumePacketV2)) {
        return false;
    }

    memcpy(&header, buffer, sizeof(FileResumePacketV2));

    size_t expectedLen = sizeof(FileResumePacketV2) + header.rangeCount * sizeof(FileRangeV2);
    if (len < expectedLen) {
        return false;
    }

    ranges.clear();
    const FileRangeV2* rangePtr = reinterpret_cast<const FileRangeV2*>(buffer + sizeof(FileResumePacketV2));
    for (uint16_t i = 0; i < header.rangeCount; ++i) {
        ranges.emplace_back(rangePtr[i].offset, rangePtr[i].length);
    }

    return true;
}

std::vector<uint8_t> BuildResumeResponse(
    uint64_t srcClientID,
    uint64_t dstClientID,
    const std::map<uint32_t, uint64_t>& offsets)
{
    size_t size = sizeof(FileResumeResponseV2) + offsets.size() * sizeof(FileResumeResponseEntryV2);
    std::vector<uint8_t> buffer(size);

    FileResumeResponseV2* pkt = reinterpret_cast<FileResumeResponseV2*>(buffer.data());
    pkt->cmd = 86;  // COMMAND_FILE_RESUME
    pkt->srcClientID = srcClientID;
    pkt->dstClientID = dstClientID;
    pkt->flags = FFV2_RESUME_RESP;
    pkt->fileCount = static_cast<uint32_t>(offsets.size());

    FileResumeResponseEntryV2* entryPtr = reinterpret_cast<FileResumeResponseEntryV2*>(
        buffer.data() + sizeof(FileResumeResponseV2));

    size_t i = 0;
    for (const auto& kv : offsets) {
        entryPtr[i].fileIndex = kv.first;
        entryPtr[i].receivedBytes = kv.second;
        ++i;
    }

    return buffer;
}

bool ParseResumeResponse(
    const uint8_t* buffer, size_t len,
    std::map<uint32_t, uint64_t>& offsets)
{
    if (len < sizeof(FileResumeResponseV2)) {
        return false;
    }

    const FileResumeResponseV2* pkt = reinterpret_cast<const FileResumeResponseV2*>(buffer);

    if ((pkt->flags & FFV2_RESUME_RESP) == 0) {
        return false;
    }

    size_t expectedLen = sizeof(FileResumeResponseV2) + pkt->fileCount * sizeof(FileResumeResponseEntryV2);
    if (len < expectedLen) {
        return false;
    }

    offsets.clear();
    const FileResumeResponseEntryV2* entryPtr = reinterpret_cast<const FileResumeResponseEntryV2*>(
        buffer + sizeof(FileResumeResponseV2));

    for (uint32_t i = 0; i < pkt->fileCount; ++i) {
        offsets[entryPtr[i].fileIndex] = entryPtr[i].receivedBytes;
    }

    return true;
}

// ============================================
// ResumeStateManager 测试
// ============================================

class ResumeStateManagerTest : public ::testing::Test {};

TEST_F(ResumeStateManagerTest, Initialize) {
    ResumeStateManager mgr;
    mgr.Initialize(12345, 100, 200, "C:\\Downloads\\");

    EXPECT_EQ(mgr.GetTransferID(), 12345u);
    EXPECT_EQ(mgr.GetSrcClientID(), 100u);
    EXPECT_EQ(mgr.GetDstClientID(), 200u);
    EXPECT_EQ(mgr.GetTargetDir(), "C:\\Downloads\\");
    EXPECT_EQ(mgr.GetFileCount(), 0u);
}

TEST_F(ResumeStateManagerTest, AddFiles) {
    ResumeStateManager mgr;
    mgr.Initialize(1, 0, 0, "");
    mgr.AddFile(0, 1000, "file1.txt");
    mgr.AddFile(1, 2000, "subdir/file2.bin");
    mgr.AddFile(2, 3000, "another/path/file3.dat");

    EXPECT_EQ(mgr.GetFileCount(), 3u);

    FileResumeEntry entry;
    ASSERT_TRUE(mgr.GetFileState(1, entry));
    EXPECT_EQ(entry.fileSize, 2000u);
    EXPECT_EQ(entry.relativePath, "subdir/file2.bin");
}

TEST_F(ResumeStateManagerTest, UpdateProgress) {
    ResumeStateManager mgr;
    mgr.Initialize(1, 0, 0, "");
    mgr.AddFile(0, 10000, "file.bin");

    mgr.UpdateProgress(0, 0, 2000);
    mgr.UpdateProgress(0, 2000, 3000);

    FileResumeEntry entry;
    ASSERT_TRUE(mgr.GetFileState(0, entry));
    EXPECT_EQ(entry.receivedBytes, 5000u);
    EXPECT_EQ(entry.receivedRanges.size(), 2u);
}

TEST_F(ResumeStateManagerTest, GetReceivedOffsets) {
    ResumeStateManager mgr;
    mgr.Initialize(1, 0, 0, "");
    mgr.AddFile(0, 1000, "a.txt");
    mgr.AddFile(1, 2000, "b.txt");
    mgr.AddFile(2, 3000, "c.txt");

    mgr.UpdateProgress(0, 0, 500);
    mgr.UpdateProgress(1, 0, 1500);
    mgr.UpdateProgress(2, 0, 2500);

    auto offsets = mgr.GetReceivedOffsets();
    EXPECT_EQ(offsets.size(), 3u);
    EXPECT_EQ(offsets[0], 500u);
    EXPECT_EQ(offsets[1], 1500u);
    EXPECT_EQ(offsets[2], 2500u);
}

// ============================================
// 序列化/反序列化测试
// ============================================

class ResumeSerializationTest : public ::testing::Test {};

TEST_F(ResumeSerializationTest, EmptyState) {
    ResumeStateManager mgr1, mgr2;
    mgr1.Initialize(12345, 100, 200, "C:\\Target\\");

    auto buffer = mgr1.Serialize();
    ASSERT_TRUE(mgr2.Deserialize(buffer));

    EXPECT_EQ(mgr2.GetTransferID(), 12345u);
    EXPECT_EQ(mgr2.GetSrcClientID(), 100u);
    EXPECT_EQ(mgr2.GetDstClientID(), 200u);
    EXPECT_EQ(mgr2.GetTargetDir(), "C:\\Target\\");
    EXPECT_EQ(mgr2.GetFileCount(), 0u);
}

TEST_F(ResumeSerializationTest, SingleFile) {
    ResumeStateManager mgr1, mgr2;
    mgr1.Initialize(1, 0, 0, "/tmp/download/");
    mgr1.AddFile(0, 10000, "test.bin");
    mgr1.UpdateProgress(0, 0, 5000);

    auto buffer = mgr1.Serialize();
    ASSERT_TRUE(mgr2.Deserialize(buffer));

    EXPECT_EQ(mgr2.GetFileCount(), 1u);

    FileResumeEntry entry;
    ASSERT_TRUE(mgr2.GetFileState(0, entry));
    EXPECT_EQ(entry.fileSize, 10000u);
    EXPECT_EQ(entry.receivedBytes, 5000u);
    EXPECT_EQ(entry.relativePath, "test.bin");
}

TEST_F(ResumeSerializationTest, MultipleFiles) {
    ResumeStateManager mgr1, mgr2;
    mgr1.Initialize(99999, 111, 222, "D:\\Backup\\");
    mgr1.AddFile(0, 1000, "file1.txt");
    mgr1.AddFile(1, 2000, "dir/file2.bin");
    mgr1.AddFile(2, 3000, "path/to/file3.dat");

    mgr1.UpdateProgress(0, 0, 1000);  // 完成
    mgr1.UpdateProgress(1, 0, 500);
    mgr1.UpdateProgress(1, 500, 500);
    mgr1.UpdateProgress(2, 0, 1000);
    mgr1.UpdateProgress(2, 2000, 500);

    auto buffer = mgr1.Serialize();
    ASSERT_TRUE(mgr2.Deserialize(buffer));

    EXPECT_EQ(mgr2.GetFileCount(), 3u);

    FileResumeEntry entry;

    ASSERT_TRUE(mgr2.GetFileState(0, entry));
    EXPECT_EQ(entry.receivedBytes, 1000u);

    ASSERT_TRUE(mgr2.GetFileState(1, entry));
    EXPECT_EQ(entry.receivedBytes, 1000u);
    EXPECT_EQ(entry.receivedRanges.size(), 2u);

    ASSERT_TRUE(mgr2.GetFileState(2, entry));
    EXPECT_EQ(entry.receivedBytes, 1500u);
    EXPECT_EQ(entry.receivedRanges.size(), 2u);
}

TEST_F(ResumeSerializationTest, InvalidMagic) {
    std::vector<uint8_t> invalidBuffer = {'X', 'X', 'X', 'X', 0, 0, 0, 0};
    ResumeStateManager mgr;
    EXPECT_FALSE(mgr.Deserialize(invalidBuffer));
}

TEST_F(ResumeSerializationTest, TruncatedBuffer) {
    ResumeStateManager mgr1;
    mgr1.Initialize(1, 0, 0, "test");
    mgr1.AddFile(0, 1000, "file.txt");

    auto buffer = mgr1.Serialize();

    // 截断
    std::vector<uint8_t> truncated(buffer.begin(), buffer.begin() + 10);

    ResumeStateManager mgr2;
    // 可能成功也可能失败，取决于截断位置
    // 主要验证不会崩溃
    mgr2.Deserialize(truncated);
    SUCCEED();
}

// ============================================
// 续传请求/响应包测试
// ============================================

class ResumePacketTest : public ::testing::Test {};

TEST_F(ResumePacketTest, BuildResumeRequest_NoRanges) {
    std::vector<std::pair<uint64_t, uint64_t>> ranges;
    auto buffer = BuildResumeRequest(12345, 100, 200, 5, 10000, 0, ranges);

    EXPECT_EQ(buffer.size(), sizeof(FileResumePacketV2));

    const FileResumePacketV2* pkt = reinterpret_cast<const FileResumePacketV2*>(buffer.data());
    EXPECT_EQ(pkt->cmd, 86);
    EXPECT_EQ(pkt->flags, FFV2_RESUME_REQ);
    EXPECT_EQ(pkt->rangeCount, 0);
}

TEST_F(ResumePacketTest, BuildResumeRequest_WithRanges) {
    std::vector<std::pair<uint64_t, uint64_t>> ranges = {
        {0, 1000},
        {2000, 500},
        {5000, 2000}
    };
    auto buffer = BuildResumeRequest(1, 0, 0, 0, 10000, 3500, ranges);

    FileResumePacketV2 header;
    std::vector<std::pair<uint64_t, uint64_t>> parsedRanges;

    ASSERT_TRUE(ParseResumeRequest(buffer.data(), buffer.size(), header, parsedRanges));
    EXPECT_EQ(header.fileSize, 10000u);
    EXPECT_EQ(header.receivedBytes, 3500u);
    ASSERT_EQ(parsedRanges.size(), 3u);
    EXPECT_EQ(parsedRanges[0].first, 0u);
    EXPECT_EQ(parsedRanges[0].second, 1000u);
    EXPECT_EQ(parsedRanges[2].first, 5000u);
}

TEST_F(ResumePacketTest, BuildResumeResponse) {
    std::map<uint32_t, uint64_t> offsets = {
        {0, 1000},
        {1, 0},
        {2, 5000}
    };
    auto buffer = BuildResumeResponse(100, 200, offsets);

    std::map<uint32_t, uint64_t> parsedOffsets;
    ASSERT_TRUE(ParseResumeResponse(buffer.data(), buffer.size(), parsedOffsets));

    EXPECT_EQ(parsedOffsets.size(), 3u);
    EXPECT_EQ(parsedOffsets[0], 1000u);
    EXPECT_EQ(parsedOffsets[1], 0u);
    EXPECT_EQ(parsedOffsets[2], 5000u);
}

TEST_F(ResumePacketTest, ParseTruncatedRequest) {
    auto buffer = BuildResumeRequest(1, 0, 0, 0, 1000, 0, {{0, 500}});

    // 截断
    FileResumePacketV2 header;
    std::vector<std::pair<uint64_t, uint64_t>> ranges;

    EXPECT_FALSE(ParseResumeRequest(buffer.data(), sizeof(FileResumePacketV2) - 5, header, ranges));
}

TEST_F(ResumePacketTest, ParseTruncatedResponse) {
    std::map<uint32_t, uint64_t> offsets = {{0, 1000}};
    auto buffer = BuildResumeResponse(0, 0, offsets);

    // 截断
    std::map<uint32_t, uint64_t> parsedOffsets;
    EXPECT_FALSE(ParseResumeResponse(buffer.data(), sizeof(FileResumeResponseV2) - 5, parsedOffsets));
}

// ============================================
// 续传场景测试
// ============================================

class ResumeScenarioTest : public ::testing::Test {};

TEST_F(ResumeScenarioTest, SimulateInterruptAndResume) {
    // 第一次传输，接收了部分数据
    ResumeStateManager session1;
    session1.Initialize(12345, 100, 0, "C:\\Downloads\\");
    session1.AddFile(0, 10000, "large_file.bin");
    session1.AddFile(1, 5000, "small_file.txt");

    session1.UpdateProgress(0, 0, 3000);  // 30%
    session1.UpdateProgress(1, 0, 5000);  // 100%

    // 保存状态
    auto savedState = session1.Serialize();

    // 模拟程序重启，恢复状态
    ResumeStateManager session2;
    ASSERT_TRUE(session2.Deserialize(savedState));

    // 获取续传偏移
    auto offsets = session2.GetReceivedOffsets();
    EXPECT_EQ(offsets[0], 3000u);  // 从 3000 继续
    EXPECT_EQ(offsets[1], 5000u);  // 已完成

    // 继续传输
    session2.UpdateProgress(0, 3000, 7000);

    FileResumeEntry entry;
    ASSERT_TRUE(session2.GetFileState(0, entry));
    EXPECT_EQ(entry.receivedBytes, 10000u);
}

TEST_F(ResumeScenarioTest, C2CResumeNegotiation) {
    // 源客户端查询续传状态
    std::vector<std::pair<std::string, uint64_t>> files = {
        {"file1.txt", 1000},
        {"file2.txt", 2000},
        {"file3.txt", 3000}
    };

    // 目标客户端已有部分数据
    std::map<uint32_t, uint64_t> receivedOffsets = {
        {0, 500},   // file1: 50%
        {1, 2000},  // file2: 100%
        {2, 0}      // file3: 0%
    };

    // 构建响应
    auto response = BuildResumeResponse(100, 200, receivedOffsets);

    // 源客户端解析响应
    std::map<uint32_t, uint64_t> parsedOffsets;
    ASSERT_TRUE(ParseResumeResponse(response.data(), response.size(), parsedOffsets));

    // 根据偏移决定发送策略
    for (size_t i = 0; i < files.size(); ++i) {
        uint32_t fileIndex = static_cast<uint32_t>(i);
        uint64_t startOffset = parsedOffsets[fileIndex];

        if (startOffset >= files[i].second) {
            // 已完成，跳过
            EXPECT_EQ(i, 1u) << "Only file2 should be complete";
        } else if (startOffset > 0) {
            // 部分完成，从偏移继续
            EXPECT_EQ(i, 0u) << "Only file1 should be partial";
            EXPECT_EQ(startOffset, 500u);
        } else {
            // 未开始，从头发送
            EXPECT_EQ(i, 2u) << "Only file3 should start from beginning";
        }
    }
}

TEST_F(ResumeScenarioTest, LargeFileResume) {
    ResumeStateManager mgr;
    uint64_t fileSize = 10ULL * 1024 * 1024 * 1024;  // 10 GB
    mgr.Initialize(1, 0, 0, "/data/");
    mgr.AddFile(0, fileSize, "huge.bin");

    // 模拟接收了 5 GB
    mgr.UpdateProgress(0, 0, 5ULL * 1024 * 1024 * 1024);

    auto offsets = mgr.GetReceivedOffsets();
    EXPECT_EQ(offsets[0], 5ULL * 1024 * 1024 * 1024);

    // 序列化/反序列化
    auto buffer = mgr.Serialize();
    ResumeStateManager mgr2;
    ASSERT_TRUE(mgr2.Deserialize(buffer));

    FileResumeEntry entry;
    ASSERT_TRUE(mgr2.GetFileState(0, entry));
    EXPECT_EQ(entry.fileSize, 10ULL * 1024 * 1024 * 1024);
    EXPECT_EQ(entry.receivedBytes, 5ULL * 1024 * 1024 * 1024);
}

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

class ResumeBoundaryTest : public ::testing::Test {};

TEST_F(ResumeBoundaryTest, EmptyFileName) {
    ResumeStateManager mgr;
    mgr.Initialize(1, 0, 0, "");
    mgr.AddFile(0, 100, "");

    auto buffer = mgr.Serialize();
    ResumeStateManager mgr2;
    ASSERT_TRUE(mgr2.Deserialize(buffer));

    FileResumeEntry entry;
    ASSERT_TRUE(mgr2.GetFileState(0, entry));
    EXPECT_EQ(entry.relativePath, "");
}

TEST_F(ResumeBoundaryTest, SpecialCharactersInPath) {
    ResumeStateManager mgr;
    mgr.Initialize(1, 0, 0, "C:\\My Files\\测试目录\\");
    mgr.AddFile(0, 100, "文件 (1).txt");

    auto buffer = mgr.Serialize();
    ResumeStateManager mgr2;
    ASSERT_TRUE(mgr2.Deserialize(buffer));

    EXPECT_EQ(mgr2.GetTargetDir(), "C:\\My Files\\测试目录\\");

    FileResumeEntry entry;
    ASSERT_TRUE(mgr2.GetFileState(0, entry));
    EXPECT_EQ(entry.relativePath, "文件 (1).txt");
}

TEST_F(ResumeBoundaryTest, ManyRanges) {
    ResumeStateManager mgr;
    mgr.Initialize(1, 0, 0, "");
    mgr.AddFile(0, 100000, "fragmented.bin");

    // 添加很多小区间
    for (uint64_t i = 0; i < 100000; i += 20) {
        mgr.UpdateProgress(0, i, 10);
    }

    auto buffer = mgr.Serialize();
    ResumeStateManager mgr2;
    ASSERT_TRUE(mgr2.Deserialize(buffer));

    FileResumeEntry entry;
    ASSERT_TRUE(mgr2.GetFileState(0, entry));
    EXPECT_EQ(entry.receivedRanges.size(), 5000u);
}

TEST_F(ResumeBoundaryTest, MaxFileCount) {
    ResumeStateManager mgr;
    mgr.Initialize(1, 0, 0, "");

    // 添加大量文件
    for (uint32_t i = 0; i < 1000; ++i) {
        mgr.AddFile(i, 100 * (i + 1), "file" + std::to_string(i) + ".txt");
    }

    auto buffer = mgr.Serialize();
    ResumeStateManager mgr2;
    ASSERT_TRUE(mgr2.Deserialize(buffer));

    EXPECT_EQ(mgr2.GetFileCount(), 1000u);
}