/**
 * @file SHA256VerifyTest.cpp
 * @brief SHA-256 文件校验测试
 *
 * 测试覆盖：
 * - SHA-256 哈希计算
 * - FileCompletePacketV2 构建与解析
 * - 文件完整性校验逻辑
 * - 校验失败处理
 */

#include <gtest/gtest.h>
#include <cstring>
#include <vector>
#include <array>
#include <string>
#include <iomanip>
#include <sstream>

// ============================================
// 简化版 SHA-256 实现（测试专用）
// 生产环境使用 OpenSSL 或 Windows CNG
// ============================================

class SHA256 {
public:
    SHA256() { Reset(); }

    void Reset() {
        m_state[0] = 0x6a09e667;
        m_state[1] = 0xbb67ae85;
        m_state[2] = 0x3c6ef372;
        m_state[3] = 0xa54ff53a;
        m_state[4] = 0x510e527f;
        m_state[5] = 0x9b05688c;
        m_state[6] = 0x1f83d9ab;
        m_state[7] = 0x5be0cd19;
        m_bitLen = 0;
        m_bufferLen = 0;
    }

    void Update(const uint8_t* data, size_t len) {
        for (size_t i = 0; i < len; ++i) {
            m_buffer[m_bufferLen++] = data[i];
            if (m_bufferLen == 64) {
                Transform();
                m_bitLen += 512;
                m_bufferLen = 0;
            }
        }
    }

    void Update(const std::vector<uint8_t>& data) {
        Update(data.data(), data.size());
    }

    std::array<uint8_t, 32> Finalize() {
        size_t i = m_bufferLen;

        // Pad
        if (m_bufferLen < 56) {
            m_buffer[i++] = 0x80;
            while (i < 56) m_buffer[i++] = 0x00;
        } else {
            m_buffer[i++] = 0x80;
            while (i < 64) m_buffer[i++] = 0x00;
            Transform();
            memset(m_buffer, 0, 56);
        }

        // Append length
        m_bitLen += m_bufferLen * 8;
        m_buffer[63] = static_cast<uint8_t>(m_bitLen);
        m_buffer[62] = static_cast<uint8_t>(m_bitLen >> 8);
        m_buffer[61] = static_cast<uint8_t>(m_bitLen >> 16);
        m_buffer[60] = static_cast<uint8_t>(m_bitLen >> 24);
        m_buffer[59] = static_cast<uint8_t>(m_bitLen >> 32);
        m_buffer[58] = static_cast<uint8_t>(m_bitLen >> 40);
        m_buffer[57] = static_cast<uint8_t>(m_bitLen >> 48);
        m_buffer[56] = static_cast<uint8_t>(m_bitLen >> 56);
        Transform();

        // Output
        std::array<uint8_t, 32> hash;
        for (int j = 0; j < 8; ++j) {
            hash[j * 4 + 0] = (m_state[j] >> 24) & 0xff;
            hash[j * 4 + 1] = (m_state[j] >> 16) & 0xff;
            hash[j * 4 + 2] = (m_state[j] >> 8) & 0xff;
            hash[j * 4 + 3] = m_state[j] & 0xff;
        }
        return hash;
    }

    static std::string HashToHex(const std::array<uint8_t, 32>& hash) {
        std::ostringstream ss;
        for (uint8_t b : hash) {
            ss << std::hex << std::setfill('0') << std::setw(2) << static_cast<int>(b);
        }
        return ss.str();
    }

private:
    static uint32_t RotR(uint32_t x, uint32_t n) { return (x >> n) | (x << (32 - n)); }
    static uint32_t Ch(uint32_t x, uint32_t y, uint32_t z) { return (x & y) ^ (~x & z); }
    static uint32_t Maj(uint32_t x, uint32_t y, uint32_t z) { return (x & y) ^ (x & z) ^ (y & z); }
    static uint32_t Sig0(uint32_t x) { return RotR(x, 2) ^ RotR(x, 13) ^ RotR(x, 22); }
    static uint32_t Sig1(uint32_t x) { return RotR(x, 6) ^ RotR(x, 11) ^ RotR(x, 25); }
    static uint32_t sig0(uint32_t x) { return RotR(x, 7) ^ RotR(x, 18) ^ (x >> 3); }
    static uint32_t sig1(uint32_t x) { return RotR(x, 17) ^ RotR(x, 19) ^ (x >> 10); }

    void Transform() {
        static const uint32_t K[64] = {
            0x428a2f98, 0x71374491, 0xb5c0fbcf, 0xe9b5dba5, 0x3956c25b, 0x59f111f1, 0x923f82a4, 0xab1c5ed5,
            0xd807aa98, 0x12835b01, 0x243185be, 0x550c7dc3, 0x72be5d74, 0x80deb1fe, 0x9bdc06a7, 0xc19bf174,
            0xe49b69c1, 0xefbe4786, 0x0fc19dc6, 0x240ca1cc, 0x2de92c6f, 0x4a7484aa, 0x5cb0a9dc, 0x76f988da,
            0x983e5152, 0xa831c66d, 0xb00327c8, 0xbf597fc7, 0xc6e00bf3, 0xd5a79147, 0x06ca6351, 0x14292967,
            0x27b70a85, 0x2e1b2138, 0x4d2c6dfc, 0x53380d13, 0x650a7354, 0x766a0abb, 0x81c2c92e, 0x92722c85,
            0xa2bfe8a1, 0xa81a664b, 0xc24b8b70, 0xc76c51a3, 0xd192e819, 0xd6990624, 0xf40e3585, 0x106aa070,
            0x19a4c116, 0x1e376c08, 0x2748774c, 0x34b0bcb5, 0x391c0cb3, 0x4ed8aa4a, 0x5b9cca4f, 0x682e6ff3,
            0x748f82ee, 0x78a5636f, 0x84c87814, 0x8cc70208, 0x90befffa, 0xa4506ceb, 0xbef9a3f7, 0xc67178f2
        };

        uint32_t W[64];
        for (int i = 0; i < 16; ++i) {
            W[i] = (m_buffer[i * 4] << 24) | (m_buffer[i * 4 + 1] << 16) |
                   (m_buffer[i * 4 + 2] << 8) | m_buffer[i * 4 + 3];
        }
        for (int i = 16; i < 64; ++i) {
            W[i] = sig1(W[i - 2]) + W[i - 7] + sig0(W[i - 15]) + W[i - 16];
        }

        uint32_t a = m_state[0], b = m_state[1], c = m_state[2], d = m_state[3];
        uint32_t e = m_state[4], f = m_state[5], g = m_state[6], h = m_state[7];

        for (int i = 0; i < 64; ++i) {
            uint32_t t1 = h + Sig1(e) + Ch(e, f, g) + K[i] + W[i];
            uint32_t t2 = Sig0(a) + Maj(a, b, c);
            h = g; g = f; f = e; e = d + t1;
            d = c; c = b; b = a; a = t1 + t2;
        }

        m_state[0] += a; m_state[1] += b; m_state[2] += c; m_state[3] += d;
        m_state[4] += e; m_state[5] += f; m_state[6] += g; m_state[7] += h;
    }

    uint32_t m_state[8];
    uint8_t m_buffer[64];
    uint64_t m_bitLen;
    size_t m_bufferLen;
};

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

#pragma pack(push, 1)

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

enum FileErrorV2 : uint8_t {
    FEV2_OK               = 0,
    FEV2_TARGET_OFFLINE   = 1,
    FEV2_VERSION_MISMATCH = 2,
    FEV2_FILE_NOT_FOUND   = 3,
    FEV2_ACCESS_DENIED    = 4,
    FEV2_DISK_FULL        = 5,
    FEV2_TRANSFER_CANCEL  = 6,
    FEV2_CHECKSUM_ERROR   = 7,
    FEV2_HASH_MISMATCH    = 8,
};

#pragma pack(pop)

// ============================================
// 辅助函数
// ============================================

std::vector<uint8_t> BuildFileCompletePacket(
    uint64_t transferID,
    uint64_t srcClientID,
    uint64_t dstClientID,
    uint32_t fileIndex,
    uint64_t fileSize,
    const std::array<uint8_t, 32>& sha256)
{
    std::vector<uint8_t> buffer(sizeof(FileCompletePacketV2));
    FileCompletePacketV2* pkt = reinterpret_cast<FileCompletePacketV2*>(buffer.data());

    pkt->cmd = 91;  // COMMAND_FILE_COMPLETE_V2
    pkt->transferID = transferID;
    pkt->srcClientID = srcClientID;
    pkt->dstClientID = dstClientID;
    pkt->fileIndex = fileIndex;
    pkt->fileSize = fileSize;
    memcpy(pkt->sha256, sha256.data(), 32);

    return buffer;
}

bool ParseFileCompletePacket(
    const uint8_t* buffer, size_t len,
    FileCompletePacketV2& pkt)
{
    if (len < sizeof(FileCompletePacketV2)) {
        return false;
    }
    memcpy(&pkt, buffer, sizeof(FileCompletePacketV2));
    return true;
}

// 校验文件完整性
FileErrorV2 VerifyFileIntegrity(
    const std::array<uint8_t, 32>& expectedHash,
    const std::vector<uint8_t>& fileData)
{
    SHA256 sha;
    sha.Update(fileData);
    auto actualHash = sha.Finalize();

    if (actualHash == expectedHash) {
        return FEV2_OK;
    }
    return FEV2_HASH_MISMATCH;
}

// ============================================
// SHA-256 基础测试
// ============================================

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

TEST_F(SHA256Test, EmptyString) {
    SHA256 sha;
    auto hash = sha.Finalize();

    // SHA-256("") = e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855
    std::string hex = SHA256::HashToHex(hash);
    EXPECT_EQ(hex, "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855");
}

TEST_F(SHA256Test, HelloWorld) {
    SHA256 sha;
    const char* msg = "Hello, World!";
    sha.Update(reinterpret_cast<const uint8_t*>(msg), strlen(msg));
    auto hash = sha.Finalize();

    // SHA-256("Hello, World!") = dffd6021bb2bd5b0af676290809ec3a53191dd81c7f70a4b28688a362182986f
    std::string hex = SHA256::HashToHex(hash);
    EXPECT_EQ(hex, "dffd6021bb2bd5b0af676290809ec3a53191dd81c7f70a4b28688a362182986f");
}

TEST_F(SHA256Test, ABC) {
    SHA256 sha;
    const char* msg = "abc";
    sha.Update(reinterpret_cast<const uint8_t*>(msg), strlen(msg));
    auto hash = sha.Finalize();

    // SHA-256("abc") = ba7816bf8f01cfea414140de5dae2223b00361a396177a9cb410ff61f20015ad
    std::string hex = SHA256::HashToHex(hash);
    EXPECT_EQ(hex, "ba7816bf8f01cfea414140de5dae2223b00361a396177a9cb410ff61f20015ad");
}

TEST_F(SHA256Test, IncrementalUpdate) {
    SHA256 sha1, sha2;

    const char* part1 = "Hello, ";
    const char* part2 = "World!";
    const char* full = "Hello, World!";

    sha1.Update(reinterpret_cast<const uint8_t*>(part1), strlen(part1));
    sha1.Update(reinterpret_cast<const uint8_t*>(part2), strlen(part2));

    sha2.Update(reinterpret_cast<const uint8_t*>(full), strlen(full));

    auto hash1 = sha1.Finalize();
    auto hash2 = sha2.Finalize();

    EXPECT_EQ(hash1, hash2);
}

TEST_F(SHA256Test, LargeData) {
    SHA256 sha;

    // 1 MB of zeros
    std::vector<uint8_t> data(1024 * 1024, 0);
    sha.Update(data);
    auto hash = sha.Finalize();

    // 验证计算成功（不崩溃）
    EXPECT_EQ(hash.size(), 32u);
}

TEST_F(SHA256Test, BinaryData) {
    SHA256 sha;

    std::vector<uint8_t> data = {0x00, 0x01, 0x02, 0x03, 0xff, 0xfe, 0xfd, 0xfc};
    sha.Update(data);
    auto hash = sha.Finalize();

    // 验证计算成功
    EXPECT_EQ(hash.size(), 32u);
}

TEST_F(SHA256Test, Reset) {
    SHA256 sha;

    sha.Update(reinterpret_cast<const uint8_t*>("test"), 4);
    sha.Reset();
    auto hash = sha.Finalize();

    // 重置后应该等于空字符串的哈希
    std::string hex = SHA256::HashToHex(hash);
    EXPECT_EQ(hex, "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855");
}

// ============================================
// FileCompletePacketV2 测试
// ============================================

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

TEST_F(FileCompletePacketTest, BuildAndParse) {
    std::array<uint8_t, 32> sha256 = {};
    sha256[0] = 0xAA;
    sha256[31] = 0xBB;

    auto buffer = BuildFileCompletePacket(12345, 100, 200, 5, 1024 * 1024, sha256);

    FileCompletePacketV2 pkt;
    ASSERT_TRUE(ParseFileCompletePacket(buffer.data(), buffer.size(), pkt));

    EXPECT_EQ(pkt.cmd, 91);
    EXPECT_EQ(pkt.transferID, 12345u);
    EXPECT_EQ(pkt.srcClientID, 100u);
    EXPECT_EQ(pkt.dstClientID, 200u);
    EXPECT_EQ(pkt.fileIndex, 5u);
    EXPECT_EQ(pkt.fileSize, 1024u * 1024u);
    EXPECT_EQ(pkt.sha256[0], 0xAA);
    EXPECT_EQ(pkt.sha256[31], 0xBB);
}

TEST_F(FileCompletePacketTest, TruncatedPacket) {
    std::array<uint8_t, 32> sha256 = {};
    auto buffer = BuildFileCompletePacket(1, 0, 0, 0, 100, sha256);

    // 截断
    FileCompletePacketV2 pkt;
    EXPECT_FALSE(ParseFileCompletePacket(buffer.data(), sizeof(FileCompletePacketV2) - 10, pkt));
}

TEST_F(FileCompletePacketTest, LargeFileSize) {
    std::array<uint8_t, 32> sha256 = {};
    uint64_t largeSize = 100ULL * 1024 * 1024 * 1024;  // 100 GB

    auto buffer = BuildFileCompletePacket(1, 0, 0, 0, largeSize, sha256);

    FileCompletePacketV2 pkt;
    ASSERT_TRUE(ParseFileCompletePacket(buffer.data(), buffer.size(), pkt));
    EXPECT_EQ(pkt.fileSize, largeSize);
}

// ============================================
// 文件完整性校验测试
// ============================================

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

TEST_F(FileIntegrityTest, CorrectHash) {
    std::vector<uint8_t> fileData = {'H', 'e', 'l', 'l', 'o'};

    SHA256 sha;
    sha.Update(fileData);
    auto expectedHash = sha.Finalize();

    auto result = VerifyFileIntegrity(expectedHash, fileData);
    EXPECT_EQ(result, FEV2_OK);
}

TEST_F(FileIntegrityTest, IncorrectHash) {
    std::vector<uint8_t> fileData = {'H', 'e', 'l', 'l', 'o'};
    std::array<uint8_t, 32> wrongHash = {};  // 全零的错误哈希

    auto result = VerifyFileIntegrity(wrongHash, fileData);
    EXPECT_EQ(result, FEV2_HASH_MISMATCH);
}

TEST_F(FileIntegrityTest, CorruptedData) {
    std::vector<uint8_t> originalData = {'H', 'e', 'l', 'l', 'o'};

    SHA256 sha;
    sha.Update(originalData);
    auto originalHash = sha.Finalize();

    // 修改一个字节
    std::vector<uint8_t> corruptedData = originalData;
    corruptedData[2] = 'X';

    auto result = VerifyFileIntegrity(originalHash, corruptedData);
    EXPECT_EQ(result, FEV2_HASH_MISMATCH);
}

TEST_F(FileIntegrityTest, EmptyFile) {
    std::vector<uint8_t> emptyData;

    SHA256 sha;
    auto emptyHash = sha.Finalize();

    auto result = VerifyFileIntegrity(emptyHash, emptyData);
    EXPECT_EQ(result, FEV2_OK);
}

TEST_F(FileIntegrityTest, SingleBitDifference) {
    std::vector<uint8_t> data1 = {0x00};
    std::vector<uint8_t> data2 = {0x01};  // 单比特差异

    SHA256 sha1, sha2;
    sha1.Update(data1);
    sha2.Update(data2);

    auto hash1 = sha1.Finalize();
    auto hash2 = sha2.Finalize();

    // 哈希应该完全不同
    EXPECT_NE(hash1, hash2);

    // 验证错误检测
    auto result = VerifyFileIntegrity(hash1, data2);
    EXPECT_EQ(result, FEV2_HASH_MISMATCH);
}

// ============================================
// 流式哈希计算测试
// ============================================

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

TEST_F(StreamingHashTest, ChunkedUpdate) {
    std::vector<uint8_t> fullData(10000);
    for (size_t i = 0; i < fullData.size(); ++i) {
        fullData[i] = static_cast<uint8_t>(i & 0xFF);
    }

    // 一次性计算
    SHA256 sha1;
    sha1.Update(fullData);
    auto hash1 = sha1.Finalize();

    // 分块计算
    SHA256 sha2;
    size_t chunkSize = 64;  // SHA-256 块大小
    for (size_t i = 0; i < fullData.size(); i += chunkSize) {
        size_t len = std::min(chunkSize, fullData.size() - i);
        sha2.Update(fullData.data() + i, len);
    }
    auto hash2 = sha2.Finalize();

    EXPECT_EQ(hash1, hash2);
}

TEST_F(StreamingHashTest, VariableChunkSizes) {
    std::vector<uint8_t> data(1000);
    for (size_t i = 0; i < data.size(); ++i) {
        data[i] = static_cast<uint8_t>(i);
    }

    SHA256 sha1;
    sha1.Update(data);
    auto expected = sha1.Finalize();

    // 不同大小的块
    std::vector<size_t> chunkSizes = {1, 7, 63, 64, 65, 128, 1000};

    for (size_t chunkSize : chunkSizes) {
        SHA256 sha2;
        for (size_t i = 0; i < data.size(); i += chunkSize) {
            size_t len = std::min(chunkSize, data.size() - i);
            sha2.Update(data.data() + i, len);
        }
        auto actual = sha2.Finalize();

        EXPECT_EQ(expected, actual) << "Failed for chunk size: " << chunkSize;
    }
}

// ============================================
// 文件传输完整性验证场景
// ============================================

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

TEST_F(TransferVerificationTest, SimulateSuccessfulTransfer) {
    // 模拟文件数据
    std::vector<uint8_t> fileData(1024 * 64);  // 64 KB
    for (size_t i = 0; i < fileData.size(); ++i) {
        fileData[i] = static_cast<uint8_t>(i * 17);  // 伪随机数据
    }

    // 发送方计算哈希
    SHA256 senderSha;
    senderSha.Update(fileData);
    auto senderHash = senderSha.Finalize();

    // 构建校验包
    auto packet = BuildFileCompletePacket(12345, 100, 0, 0, fileData.size(), senderHash);

    // 接收方解析并验证
    FileCompletePacketV2 pkt;
    ASSERT_TRUE(ParseFileCompletePacket(packet.data(), packet.size(), pkt));
    EXPECT_EQ(pkt.fileSize, fileData.size());

    // 接收方计算哈希并比较
    std::array<uint8_t, 32> expectedHash;
    memcpy(expectedHash.data(), pkt.sha256, 32);

    auto result = VerifyFileIntegrity(expectedHash, fileData);
    EXPECT_EQ(result, FEV2_OK);
}

TEST_F(TransferVerificationTest, SimulateCorruptedTransfer) {
    // 原始文件
    std::vector<uint8_t> originalData(1024);
    for (size_t i = 0; i < originalData.size(); ++i) {
        originalData[i] = static_cast<uint8_t>(i);
    }

    // 发送方计算哈希
    SHA256 senderSha;
    senderSha.Update(originalData);
    auto senderHash = senderSha.Finalize();

    // 模拟传输中数据损坏
    std::vector<uint8_t> receivedData = originalData;
    receivedData[512] ^= 0xFF;  // 翻转一个字节

    // 校验失败
    auto result = VerifyFileIntegrity(senderHash, receivedData);
    EXPECT_EQ(result, FEV2_HASH_MISMATCH);
}

TEST_F(TransferVerificationTest, MultipleFilesInTransfer) {
    struct FileInfo {
        std::vector<uint8_t> data;
        std::array<uint8_t, 32> hash;
    };

    std::vector<FileInfo> files(5);

    // 生成测试文件
    for (int i = 0; i < 5; ++i) {
        files[i].data.resize(1000 * (i + 1));
        for (size_t j = 0; j < files[i].data.size(); ++j) {
            files[i].data[j] = static_cast<uint8_t>(j + i * 7);
        }

        SHA256 sha;
        sha.Update(files[i].data);
        files[i].hash = sha.Finalize();
    }

    // 验证每个文件
    for (int i = 0; i < 5; ++i) {
        auto result = VerifyFileIntegrity(files[i].hash, files[i].data);
        EXPECT_EQ(result, FEV2_OK) << "File " << i << " verification failed";
    }

    // 交叉验证应该失败
    auto crossResult = VerifyFileIntegrity(files[0].hash, files[1].data);
    EXPECT_EQ(crossResult, FEV2_HASH_MISMATCH);
}

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

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

TEST_F(HashBoundaryTest, ExactBlockSize) {
    // SHA-256 块大小是 64 字节
    std::vector<uint8_t> data(64, 'A');

    SHA256 sha;
    sha.Update(data);
    auto hash = sha.Finalize();

    EXPECT_EQ(hash.size(), 32u);
}

TEST_F(HashBoundaryTest, BlockSizePlusOne) {
    std::vector<uint8_t> data(65, 'B');

    SHA256 sha;
    sha.Update(data);
    auto hash = sha.Finalize();

    EXPECT_EQ(hash.size(), 32u);
}

TEST_F(HashBoundaryTest, BlockSizeMinusOne) {
    std::vector<uint8_t> data(63, 'C');

    SHA256 sha;
    sha.Update(data);
    auto hash = sha.Finalize();

    EXPECT_EQ(hash.size(), 32u);
}

TEST_F(HashBoundaryTest, MultipleBlocks) {
    std::vector<uint8_t> data(64 * 10, 'D');

    SHA256 sha;
    sha.Update(data);
    auto hash = sha.Finalize();

    EXPECT_EQ(hash.size(), 32u);
}

TEST_F(HashBoundaryTest, PaddingBoundary55) {
    // 55 字节需要特殊处理（padding + length 刚好 64）
    std::vector<uint8_t> data(55, 'E');

    SHA256 sha;
    sha.Update(data);
    auto hash = sha.Finalize();

    EXPECT_EQ(hash.size(), 32u);
}

TEST_F(HashBoundaryTest, PaddingBoundary56) {
    // 56 字节需要额外的块
    std::vector<uint8_t> data(56, 'F');

    SHA256 sha;
    sha.Update(data);
    auto hash = sha.Finalize();

    EXPECT_EQ(hash.size(), 32u);
}