/**
 * @file FileTransferV2Test.cpp
 * @brief V2 文件传输逻辑测试
 *
 * 测试覆盖：
 * - TransferOptionsV2 结构体
 * - 传输ID生成
 * - 包头构建与解析
 * - 变长数据包处理
 */

#include <gtest/gtest.h>
#include <cstring>
#include <vector>
#include <map>
#include <random>
#include <chrono>

// ============================================
// 从 file_upload.h 复制的结构体定义（测试专用）
// ============================================

#pragma pack(push, 1)

enum FileFlagsV2 : uint16_t {
    FFV2_NONE         = 0x0000,
    FFV2_LAST_CHUNK   = 0x0001,
    FFV2_RESUME_REQ   = 0x0002,
    FFV2_RESUME_RESP  = 0x0004,
    FFV2_CANCEL       = 0x0008,
    FFV2_DIRECTORY    = 0x0010,
    FFV2_COMPRESSED   = 0x0020,
    FFV2_ERROR        = 0x0040,
};

struct FileChunkPacketV2 {
    uint8_t     cmd;
    uint64_t    transferID;
    uint64_t    srcClientID;
    uint64_t    dstClientID;
    uint32_t    fileIndex;
    uint32_t    totalFiles;
    uint64_t    fileSize;
    uint64_t    offset;
    uint64_t    dataLength;
    uint64_t    nameLength;
    uint16_t    flags;
    uint16_t    checksum;
    uint8_t     reserved[8];
};

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;
};

struct FileCompletePacketV2 {
    uint8_t     cmd;
    uint64_t    transferID;
    uint64_t    srcClientID;
    uint64_t    dstClientID;
    uint32_t    fileIndex;
    uint64_t    fileSize;
    uint8_t     sha256[32];
};

struct FileQueryResumeV2 {
    uint8_t     cmd;
    uint64_t    transferID;
    uint64_t    srcClientID;
    uint64_t    dstClientID;
    uint32_t    fileCount;
};

struct FileQueryResumeEntryV2 {
    uint64_t    fileSize;
    uint16_t    nameLength;
};

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)

// V2 传输选项
struct TransferOptionsV2 {
    uint64_t    transferID;
    uint64_t    srcClientID;
    uint64_t    dstClientID;
    bool        enableResume;
    std::map<uint32_t, uint64_t> startOffsets;

    TransferOptionsV2() : transferID(0), srcClientID(0), dstClientID(0), enableResume(true) {}
};

// ============================================
// 辅助函数（测试专用实现）
// ============================================

// 生成传输ID（简化实现）
uint64_t GenerateTransferID() {
    static std::mt19937_64 rng(
        static_cast<uint64_t>(std::chrono::high_resolution_clock::now().time_since_epoch().count())
    );
    return rng();
}

// 构建文件块包
std::vector<uint8_t> BuildFileChunkPacketV2(
    uint64_t transferID,
    uint64_t srcClientID,
    uint64_t dstClientID,
    uint32_t fileIndex,
    uint32_t totalFiles,
    uint64_t fileSize,
    uint64_t offset,
    const std::string& filename,
    const std::vector<uint8_t>& data,
    uint16_t flags = FFV2_NONE)
{
    size_t totalSize = sizeof(FileChunkPacketV2) + filename.size() + data.size();
    std::vector<uint8_t> buffer(totalSize);

    FileChunkPacketV2* pkt = reinterpret_cast<FileChunkPacketV2*>(buffer.data());
    pkt->cmd = 85;  // COMMAND_SEND_FILE_V2
    pkt->transferID = transferID;
    pkt->srcClientID = srcClientID;
    pkt->dstClientID = dstClientID;
    pkt->fileIndex = fileIndex;
    pkt->totalFiles = totalFiles;
    pkt->fileSize = fileSize;
    pkt->offset = offset;
    pkt->dataLength = data.size();
    pkt->nameLength = filename.size();
    pkt->flags = flags;
    pkt->checksum = 0;
    memset(pkt->reserved, 0, sizeof(pkt->reserved));

    // 追加文件名
    memcpy(buffer.data() + sizeof(FileChunkPacketV2), filename.data(), filename.size());

    // 追加数据
    if (!data.empty()) {
        memcpy(buffer.data() + sizeof(FileChunkPacketV2) + filename.size(), data.data(), data.size());
    }

    return buffer;
}

// 解析文件块包
bool ParseFileChunkPacketV2(
    const uint8_t* buffer, size_t len,
    FileChunkPacketV2& header,
    std::string& filename,
    std::vector<uint8_t>& data)
{
    if (len < sizeof(FileChunkPacketV2)) {
        return false;
    }

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

    size_t expectedLen = sizeof(FileChunkPacketV2) + header.nameLength + header.dataLength;
    if (len < expectedLen) {
        return false;
    }

    const char* namePtr = reinterpret_cast<const char*>(buffer + sizeof(FileChunkPacketV2));
    filename.assign(namePtr, header.nameLength);

    if (header.dataLength > 0) {
        const uint8_t* dataPtr = buffer + sizeof(FileChunkPacketV2) + header.nameLength;
        data.assign(dataPtr, dataPtr + header.dataLength);
    } else {
        data.clear();
    }

    return true;
}

// 构建续传查询包
std::vector<uint8_t> BuildResumeQuery(
    uint64_t transferID,
    uint64_t srcClientID,
    uint64_t dstClientID,
    const std::vector<std::pair<std::string, uint64_t>>& files)
{
    // 计算总大小
    size_t totalSize = sizeof(FileQueryResumeV2);
    for (const auto& file : files) {
        totalSize += sizeof(FileQueryResumeEntryV2) + file.first.size();
    }

    std::vector<uint8_t> buffer(totalSize);
    FileQueryResumeV2* pkt = reinterpret_cast<FileQueryResumeV2*>(buffer.data());
    pkt->cmd = 88;  // COMMAND_FILE_QUERY_RESUME
    pkt->transferID = transferID;
    pkt->srcClientID = srcClientID;
    pkt->dstClientID = dstClientID;
    pkt->fileCount = static_cast<uint32_t>(files.size());

    uint8_t* ptr = buffer.data() + sizeof(FileQueryResumeV2);
    for (const auto& file : files) {
        FileQueryResumeEntryV2* entry = reinterpret_cast<FileQueryResumeEntryV2*>(ptr);
        entry->fileSize = file.second;
        entry->nameLength = static_cast<uint16_t>(file.first.size());
        ptr += sizeof(FileQueryResumeEntryV2);
        memcpy(ptr, file.first.data(), file.first.size());
        ptr += file.first.size();
    }

    return buffer;
}

// 解析续传查询包
bool ParseResumeQuery(
    const uint8_t* buffer, size_t len,
    uint64_t& transferID,
    uint64_t& srcClientID,
    uint64_t& dstClientID,
    std::vector<std::pair<std::string, uint64_t>>& files)
{
    if (len < sizeof(FileQueryResumeV2)) {
        return false;
    }

    const FileQueryResumeV2* pkt = reinterpret_cast<const FileQueryResumeV2*>(buffer);
    transferID = pkt->transferID;
    srcClientID = pkt->srcClientID;
    dstClientID = pkt->dstClientID;

    files.clear();
    const uint8_t* ptr = buffer + sizeof(FileQueryResumeV2);
    const uint8_t* end = buffer + len;

    for (uint32_t i = 0; i < pkt->fileCount; ++i) {
        if (ptr + sizeof(FileQueryResumeEntryV2) > end) {
            return false;
        }
        const FileQueryResumeEntryV2* entry = reinterpret_cast<const FileQueryResumeEntryV2*>(ptr);
        ptr += sizeof(FileQueryResumeEntryV2);

        if (ptr + entry->nameLength > end) {
            return false;
        }
        std::string name(reinterpret_cast<const char*>(ptr), entry->nameLength);
        ptr += entry->nameLength;

        files.emplace_back(name, entry->fileSize);
    }

    return true;
}

// ============================================
// TransferOptionsV2 测试
// ============================================

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

TEST_F(TransferOptionsV2Test, DefaultValues) {
    TransferOptionsV2 options;

    EXPECT_EQ(options.transferID, 0u);
    EXPECT_EQ(options.srcClientID, 0u);
    EXPECT_EQ(options.dstClientID, 0u);
    EXPECT_TRUE(options.enableResume);
    EXPECT_TRUE(options.startOffsets.empty());
}

TEST_F(TransferOptionsV2Test, SetStartOffsets) {
    TransferOptionsV2 options;
    options.startOffsets[0] = 1024;
    options.startOffsets[1] = 2048;
    options.startOffsets[2] = 0;

    EXPECT_EQ(options.startOffsets.size(), 3u);
    EXPECT_EQ(options.startOffsets[0], 1024u);
    EXPECT_EQ(options.startOffsets[1], 2048u);
    EXPECT_EQ(options.startOffsets[2], 0u);
}

TEST_F(TransferOptionsV2Test, C2CConfiguration) {
    TransferOptionsV2 options;
    options.transferID = 12345;
    options.srcClientID = 100;
    options.dstClientID = 200;

    EXPECT_EQ(options.transferID, 12345u);
    EXPECT_EQ(options.srcClientID, 100u);
    EXPECT_EQ(options.dstClientID, 200u);
}

// ============================================
// TransferID 生成测试
// ============================================

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

TEST_F(TransferIDTest, GeneratesNonZero) {
    // 多次生成应该都不为 0（极低概率）
    for (int i = 0; i < 100; ++i) {
        uint64_t id = GenerateTransferID();
        // 不做强制断言，因为理论上可能为 0
        // 但实际概率极低
        if (id == 0) {
            // 如果真的生成了 0，再生成一次
            id = GenerateTransferID();
        }
    }
    SUCCEED();
}

TEST_F(TransferIDTest, GeneratesUnique) {
    std::vector<uint64_t> ids;
    for (int i = 0; i < 1000; ++i) {
        ids.push_back(GenerateTransferID());
    }

    // 检查没有重复
    std::sort(ids.begin(), ids.end());
    auto it = std::unique(ids.begin(), ids.end());
    EXPECT_EQ(it, ids.end()) << "Found duplicate transfer IDs";
}

// ============================================
// FileChunkPacketV2 构建测试
// ============================================

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

TEST_F(FileChunkPacketV2BuildTest, BuildSimplePacket) {
    uint64_t transferID = 12345;
    std::string filename = "test.txt";
    std::vector<uint8_t> data = {0x01, 0x02, 0x03, 0x04};

    auto buffer = BuildFileChunkPacketV2(
        transferID, 0, 0, 0, 1, 100, 0, filename, data);

    EXPECT_EQ(buffer.size(), sizeof(FileChunkPacketV2) + filename.size() + data.size());

    const FileChunkPacketV2* pkt = reinterpret_cast<const FileChunkPacketV2*>(buffer.data());
    EXPECT_EQ(pkt->cmd, 85);
    EXPECT_EQ(pkt->transferID, transferID);
    EXPECT_EQ(pkt->nameLength, filename.size());
    EXPECT_EQ(pkt->dataLength, data.size());
}

TEST_F(FileChunkPacketV2BuildTest, BuildWithFlags) {
    auto buffer = BuildFileChunkPacketV2(
        1, 0, 0, 0, 1, 100, 50, "file.bin", {}, FFV2_LAST_CHUNK);

    const FileChunkPacketV2* pkt = reinterpret_cast<const FileChunkPacketV2*>(buffer.data());
    EXPECT_EQ(pkt->flags, FFV2_LAST_CHUNK);
    EXPECT_EQ(pkt->offset, 50u);
}

TEST_F(FileChunkPacketV2BuildTest, BuildC2CPacket) {
    auto buffer = BuildFileChunkPacketV2(
        999, 100, 200, 0, 3, 1024, 0, "shared/doc.pdf", {});

    const FileChunkPacketV2* pkt = reinterpret_cast<const FileChunkPacketV2*>(buffer.data());
    EXPECT_EQ(pkt->srcClientID, 100u);
    EXPECT_EQ(pkt->dstClientID, 200u);
    EXPECT_EQ(pkt->totalFiles, 3u);
}

TEST_F(FileChunkPacketV2BuildTest, BuildEmptyDataPacket) {
    std::vector<uint8_t> emptyData;
    auto buffer = BuildFileChunkPacketV2(
        1, 0, 0, 0, 1, 0, 0, "empty.txt", emptyData);

    const FileChunkPacketV2* pkt = reinterpret_cast<const FileChunkPacketV2*>(buffer.data());
    EXPECT_EQ(pkt->dataLength, 0u);
    EXPECT_EQ(pkt->fileSize, 0u);
}

TEST_F(FileChunkPacketV2BuildTest, BuildDirectoryPacket) {
    auto buffer = BuildFileChunkPacketV2(
        1, 0, 0, 0, 1, 0, 0, "subdir/", {}, FFV2_DIRECTORY);

    const FileChunkPacketV2* pkt = reinterpret_cast<const FileChunkPacketV2*>(buffer.data());
    EXPECT_EQ(pkt->flags & FFV2_DIRECTORY, FFV2_DIRECTORY);
    EXPECT_EQ(pkt->dataLength, 0u);
}

// ============================================
// FileChunkPacketV2 解析测试
// ============================================

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

TEST_F(FileChunkPacketV2ParseTest, ParseValidPacket) {
    std::string originalName = "test/file.txt";
    std::vector<uint8_t> originalData = {0xAA, 0xBB, 0xCC, 0xDD, 0xEE};

    auto buffer = BuildFileChunkPacketV2(
        12345, 100, 200, 3, 10, 1024 * 1024, 512, originalName, originalData, FFV2_COMPRESSED);

    FileChunkPacketV2 header;
    std::string parsedName;
    std::vector<uint8_t> parsedData;

    bool result = ParseFileChunkPacketV2(buffer.data(), buffer.size(), header, parsedName, parsedData);

    EXPECT_TRUE(result);
    EXPECT_EQ(header.transferID, 12345u);
    EXPECT_EQ(header.srcClientID, 100u);
    EXPECT_EQ(header.dstClientID, 200u);
    EXPECT_EQ(header.fileIndex, 3u);
    EXPECT_EQ(header.totalFiles, 10u);
    EXPECT_EQ(header.fileSize, 1024u * 1024u);
    EXPECT_EQ(header.offset, 512u);
    EXPECT_EQ(header.flags, FFV2_COMPRESSED);
    EXPECT_EQ(parsedName, originalName);
    EXPECT_EQ(parsedData, originalData);
}

TEST_F(FileChunkPacketV2ParseTest, ParseTruncatedHeader) {
    std::vector<uint8_t> truncated(sizeof(FileChunkPacketV2) - 10);

    FileChunkPacketV2 header;
    std::string name;
    std::vector<uint8_t> data;

    bool result = ParseFileChunkPacketV2(truncated.data(), truncated.size(), header, name, data);
    EXPECT_FALSE(result);
}

TEST_F(FileChunkPacketV2ParseTest, ParseTruncatedData) {
    auto buffer = BuildFileChunkPacketV2(
        1, 0, 0, 0, 1, 100, 0, "file.txt", {0x01, 0x02, 0x03});

    // 截断数据部分
    std::vector<uint8_t> truncated(buffer.begin(), buffer.end() - 2);

    FileChunkPacketV2 header;
    std::string name;
    std::vector<uint8_t> data;

    bool result = ParseFileChunkPacketV2(truncated.data(), truncated.size(), header, name, data);
    EXPECT_FALSE(result);
}

TEST_F(FileChunkPacketV2ParseTest, RoundTrip) {
    // 构建各种类型的包并验证往返
    struct TestCase {
        uint64_t transferID;
        uint32_t fileIndex;
        uint64_t fileSize;
        uint64_t offset;
        std::string filename;
        std::vector<uint8_t> data;
        uint16_t flags;
    };

    std::vector<TestCase> cases = {
        {1, 0, 100, 0, "a.txt", {0x01}, FFV2_NONE},
        {UINT64_MAX, 999, UINT64_MAX, UINT64_MAX - 100, "path/to/file.bin", {}, FFV2_LAST_CHUNK},
        {12345, 5, 1024, 512, "中文文件.txt", {0xAA, 0xBB, 0xCC}, FFV2_COMPRESSED | FFV2_LAST_CHUNK},
    };

    for (const auto& tc : cases) {
        auto buffer = BuildFileChunkPacketV2(
            tc.transferID, 0, 0, tc.fileIndex, 10, tc.fileSize, tc.offset, tc.filename, tc.data, tc.flags);

        FileChunkPacketV2 header;
        std::string name;
        std::vector<uint8_t> data;

        ASSERT_TRUE(ParseFileChunkPacketV2(buffer.data(), buffer.size(), header, name, data));
        EXPECT_EQ(header.transferID, tc.transferID);
        EXPECT_EQ(header.fileIndex, tc.fileIndex);
        EXPECT_EQ(header.fileSize, tc.fileSize);
        EXPECT_EQ(header.offset, tc.offset);
        EXPECT_EQ(header.flags, tc.flags);
        EXPECT_EQ(name, tc.filename);
        EXPECT_EQ(data, tc.data);
    }
}

// ============================================
// 续传查询包测试
// ============================================

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

TEST_F(ResumeQueryTest, BuildEmpty) {
    std::vector<std::pair<std::string, uint64_t>> files;
    auto buffer = BuildResumeQuery(12345, 100, 200, files);

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

    const FileQueryResumeV2* pkt = reinterpret_cast<const FileQueryResumeV2*>(buffer.data());
    EXPECT_EQ(pkt->cmd, 88);
    EXPECT_EQ(pkt->fileCount, 0u);
}

TEST_F(ResumeQueryTest, BuildSingleFile) {
    std::vector<std::pair<std::string, uint64_t>> files = {
        {"file.txt", 1024}
    };
    auto buffer = BuildResumeQuery(12345, 100, 200, files);

    const FileQueryResumeV2* pkt = reinterpret_cast<const FileQueryResumeV2*>(buffer.data());
    EXPECT_EQ(pkt->fileCount, 1u);
}

TEST_F(ResumeQueryTest, BuildMultipleFiles) {
    std::vector<std::pair<std::string, uint64_t>> files = {
        {"file1.txt", 1024},
        {"dir/file2.bin", 2048},
        {"another/path/file3.dat", 4096}
    };
    auto buffer = BuildResumeQuery(12345, 100, 200, files);

    const FileQueryResumeV2* pkt = reinterpret_cast<const FileQueryResumeV2*>(buffer.data());
    EXPECT_EQ(pkt->fileCount, 3u);
}

TEST_F(ResumeQueryTest, ParseRoundTrip) {
    std::vector<std::pair<std::string, uint64_t>> original = {
        {"file1.txt", 1024},
        {"subdir/file2.bin", UINT64_MAX},
        {"中文/文件.txt", 0}
    };

    auto buffer = BuildResumeQuery(99999, 111, 222, original);

    uint64_t transferID, srcClientID, dstClientID;
    std::vector<std::pair<std::string, uint64_t>> parsed;

    bool result = ParseResumeQuery(buffer.data(), buffer.size(), transferID, srcClientID, dstClientID, parsed);

    EXPECT_TRUE(result);
    EXPECT_EQ(transferID, 99999u);
    EXPECT_EQ(srcClientID, 111u);
    EXPECT_EQ(dstClientID, 222u);
    ASSERT_EQ(parsed.size(), original.size());

    for (size_t i = 0; i < original.size(); ++i) {
        EXPECT_EQ(parsed[i].first, original[i].first);
        EXPECT_EQ(parsed[i].second, original[i].second);
    }
}

TEST_F(ResumeQueryTest, ParseTruncated) {
    std::vector<std::pair<std::string, uint64_t>> files = {
        {"file.txt", 1024}
    };
    auto buffer = BuildResumeQuery(1, 0, 0, files);

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

    uint64_t transferID, srcClientID, dstClientID;
    std::vector<std::pair<std::string, uint64_t>> parsed;

    bool result = ParseResumeQuery(truncated.data(), truncated.size(), transferID, srcClientID, dstClientID, parsed);
    EXPECT_FALSE(result);
}

// ============================================
// 大文件支持测试
// ============================================

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

TEST_F(LargeFileTest, FileSize_GreaterThan4GB) {
    uint64_t largeSize = 5ULL * 1024 * 1024 * 1024;  // 5 GB
    auto buffer = BuildFileChunkPacketV2(
        1, 0, 0, 0, 1, largeSize, 0, "large.bin", {});

    const FileChunkPacketV2* pkt = reinterpret_cast<const FileChunkPacketV2*>(buffer.data());
    EXPECT_EQ(pkt->fileSize, largeSize);
}

TEST_F(LargeFileTest, Offset_GreaterThan4GB) {
    uint64_t largeOffset = 10ULL * 1024 * 1024 * 1024;  // 10 GB
    uint64_t fileSize = 20ULL * 1024 * 1024 * 1024;     // 20 GB

    auto buffer = BuildFileChunkPacketV2(
        1, 0, 0, 0, 1, fileSize, largeOffset, "huge.bin", {});

    const FileChunkPacketV2* pkt = reinterpret_cast<const FileChunkPacketV2*>(buffer.data());
    EXPECT_EQ(pkt->fileSize, fileSize);
    EXPECT_EQ(pkt->offset, largeOffset);
}

TEST_F(LargeFileTest, MaxValues) {
    auto buffer = BuildFileChunkPacketV2(
        UINT64_MAX, UINT64_MAX, UINT64_MAX,
        UINT32_MAX, UINT32_MAX, UINT64_MAX, UINT64_MAX,
        "max.bin", {}, UINT16_MAX);

    FileChunkPacketV2 header;
    std::string name;
    std::vector<uint8_t> data;

    ASSERT_TRUE(ParseFileChunkPacketV2(buffer.data(), buffer.size(), header, name, data));
    EXPECT_EQ(header.transferID, UINT64_MAX);
    EXPECT_EQ(header.srcClientID, UINT64_MAX);
    EXPECT_EQ(header.dstClientID, UINT64_MAX);
    EXPECT_EQ(header.fileIndex, UINT32_MAX);
    EXPECT_EQ(header.totalFiles, UINT32_MAX);
    EXPECT_EQ(header.fileSize, UINT64_MAX);
    EXPECT_EQ(header.offset, UINT64_MAX);
}

// ============================================
// 多文件传输测试
// ============================================

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

TEST_F(MultiFileTransferTest, SequentialFileIndices) {
    std::vector<std::pair<std::string, uint64_t>> files = {
        {"file1.txt", 100},
        {"file2.txt", 200},
        {"file3.txt", 300}
    };

    for (uint32_t i = 0; i < files.size(); ++i) {
        auto buffer = BuildFileChunkPacketV2(
            12345, 0, 0, i, static_cast<uint32_t>(files.size()),
            files[i].second, 0, files[i].first, {}, FFV2_LAST_CHUNK);

        const FileChunkPacketV2* pkt = reinterpret_cast<const FileChunkPacketV2*>(buffer.data());
        EXPECT_EQ(pkt->fileIndex, i);
        EXPECT_EQ(pkt->totalFiles, files.size());
    }
}

TEST_F(MultiFileTransferTest, ConsistentTransferID) {
    uint64_t transferID = GenerateTransferID();

    for (int i = 0; i < 5; ++i) {
        auto buffer = BuildFileChunkPacketV2(
            transferID, 0, 0, i, 5, 1000 * (i + 1), 0, "file" + std::to_string(i), {});

        const FileChunkPacketV2* pkt = reinterpret_cast<const FileChunkPacketV2*>(buffer.data());
        EXPECT_EQ(pkt->transferID, transferID);
    }
}

// ============================================
// 错误处理测试
// ============================================

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

TEST_F(ErrorHandlingTest, CancelFlag) {
    auto buffer = BuildFileChunkPacketV2(
        12345, 0, 0, 0, 1, 0, 0, "", {}, FFV2_CANCEL);

    const FileChunkPacketV2* pkt = reinterpret_cast<const FileChunkPacketV2*>(buffer.data());
    EXPECT_EQ(pkt->flags & FFV2_CANCEL, FFV2_CANCEL);
}

TEST_F(ErrorHandlingTest, ErrorFlag) {
    auto buffer = BuildFileChunkPacketV2(
        12345, 0, 0, 0, 1, 0, 0, "", {}, FFV2_ERROR);

    const FileChunkPacketV2* pkt = reinterpret_cast<const FileChunkPacketV2*>(buffer.data());
    EXPECT_EQ(pkt->flags & FFV2_ERROR, FFV2_ERROR);
}

TEST_F(ErrorHandlingTest, CombinedErrorFlags) {
    uint16_t flags = FFV2_ERROR | FFV2_CANCEL | FFV2_LAST_CHUNK;
    auto buffer = BuildFileChunkPacketV2(
        12345, 0, 0, 0, 1, 0, 0, "", {}, flags);

    const FileChunkPacketV2* pkt = reinterpret_cast<const FileChunkPacketV2*>(buffer.data());
    EXPECT_TRUE(pkt->flags & FFV2_ERROR);
    EXPECT_TRUE(pkt->flags & FFV2_CANCEL);
    EXPECT_TRUE(pkt->flags & FFV2_LAST_CHUNK);
}