/**
 * @file test_data_processor.cpp
 * @brief DataProcessor 单元测试
 * 
 * 测试数据处理管道、加密/解密、压缩/解压功能。
 */

#include "test_framework.h"
#include <extra2d/asset/data_processor.h>

using namespace extra2d;
using namespace extra2d::test;

// ---------------------------------------------------------------------------
// XOR 加密/解密测试
// ---------------------------------------------------------------------------

TEST(DataProcessor, XOR_EncryptDecrypt) {
    std::vector<u8> original = createTestData(1024);
    std::string key = "test-key-12345";
    
    Encryptor encryptor(key, Decryptor::Type::XOR);
    Decryptor decryptor(key, Decryptor::Type::XOR);
    
    std::vector<u8> encrypted = encryptor.process(original);
    std::vector<u8> decrypted = decryptor.process(encrypted);
    
    TEST_ASSERT_TRUE(dataEquals(original, decrypted));
    TEST_ASSERT_FALSE(dataEquals(original, encrypted));
}

TEST(DataProcessor, XOR_SameKeyProducesSameResult) {
    std::vector<u8> data = createTestData(512);
    std::string key = "secret";
    
    Encryptor enc1(key, Decryptor::Type::XOR);
    Encryptor enc2(key, Decryptor::Type::XOR);
    
    std::vector<u8> result1 = enc1.process(data);
    std::vector<u8> result2 = enc2.process(data);
    
    TEST_ASSERT_TRUE(dataEquals(result1, result2));
}

TEST(DataProcessor, XOR_DifferentKeysProduceDifferentResults) {
    std::vector<u8> data = createTestData(512);
    
    Encryptor enc1("key1", Decryptor::Type::XOR);
    Encryptor enc2("key2", Decryptor::Type::XOR);
    
    std::vector<u8> result1 = enc1.process(data);
    std::vector<u8> result2 = enc2.process(data);
    
    TEST_ASSERT_FALSE(dataEquals(result1, result2));
}

TEST(DataProcessor, XOR_EmptyKey) {
    std::vector<u8> data = createTestData(256);
    
    Encryptor encryptor("", Decryptor::Type::XOR);
    Decryptor decryptor("", Decryptor::Type::XOR);
    
    std::vector<u8> encrypted = encryptor.process(data);
    std::vector<u8> decrypted = decryptor.process(encrypted);
    
    TEST_ASSERT_TRUE(dataEquals(data, decrypted));
}

TEST(DataProcessor, XOR_EmptyData) {
    std::vector<u8> empty;
    std::string key = "test";
    
    Encryptor encryptor(key, Decryptor::Type::XOR);
    Decryptor decryptor(key, Decryptor::Type::XOR);
    
    std::vector<u8> encrypted = encryptor.process(empty);
    std::vector<u8> decrypted = decryptor.process(encrypted);
    
    TEST_ASSERT_TRUE(decrypted.empty());
}

// ---------------------------------------------------------------------------
// DataPipe 测试
// ---------------------------------------------------------------------------

TEST(DataProcessor, DataPipe_Empty) {
    DataPipe pipe;
    
    TEST_ASSERT_TRUE(pipe.empty());
    TEST_ASSERT_EQ(0u, pipe.size());
    
    std::vector<u8> data = createTestData(100);
    std::vector<u8> result = pipe.process(data);
    
    TEST_ASSERT_TRUE(dataEquals(data, result));
}

TEST(DataProcessor, DataPipe_SingleProcessor) {
    DataPipe pipe;
    pipe.encrypt("key", Decryptor::Type::XOR);
    
    TEST_ASSERT_FALSE(pipe.empty());
    TEST_ASSERT_EQ(1u, pipe.size());
    
    std::vector<u8> original = createTestData(256);
    std::vector<u8> processed = pipe.process(original);
    
    TEST_ASSERT_FALSE(dataEquals(original, processed));
}

TEST(DataProcessor, DataPipe_MultipleProcessors) {
    DataPipe pipe;
    pipe.encrypt("key", Decryptor::Type::XOR);
    pipe.encrypt("key2", Decryptor::Type::XOR);
    pipe.encrypt("key", Decryptor::Type::XOR);
    pipe.encrypt("key2", Decryptor::Type::XOR);
    
    TEST_ASSERT_EQ(4u, pipe.size());
    
    std::vector<u8> original = createTestData(512);
    std::vector<u8> processed = pipe.process(original);
    
    TEST_ASSERT_TRUE(dataEquals(original, processed));
}

TEST(DataProcessor, DataPipe_EncryptDecrypt) {
    DataPipe encryptPipe;
    encryptPipe.encrypt("secret-key", Decryptor::Type::XOR);
    
    DataPipe decryptPipe;
    decryptPipe.decrypt("secret-key", Decryptor::Type::XOR);
    
    std::vector<u8> original = createTestData(1024);
    std::vector<u8> encrypted = encryptPipe.process(original);
    std::vector<u8> decrypted = decryptPipe.process(encrypted);
    
    TEST_ASSERT_TRUE(dataEquals(original, decrypted));
}

TEST(DataProcessor, DataPipe_Clear) {
    DataPipe pipe;
    pipe.encrypt("key", Decryptor::Type::XOR);
    pipe.encrypt("key2", Decryptor::Type::XOR);
    
    TEST_ASSERT_EQ(2u, pipe.size());
    
    pipe.clear();
    
    TEST_ASSERT_TRUE(pipe.empty());
    TEST_ASSERT_EQ(0u, pipe.size());
}

TEST(DataProcessor, DataPipe_MoveSemantics) {
    DataPipe pipe1;
    pipe1.encrypt("key", Decryptor::Type::XOR);
    
    DataPipe pipe2 = std::move(pipe1);
    
    TEST_ASSERT_EQ(1u, pipe2.size());
    
    std::vector<u8> data = createTestData(128);
    std::vector<u8> result = pipe2.process(data);
    
    TEST_ASSERT_FALSE(dataEquals(data, result));
}

// ---------------------------------------------------------------------------
// 校验和测试
// ---------------------------------------------------------------------------

TEST(DataProcessor, Checksum_Consistency) {
    std::vector<u8> data = createTestData(1024);
    
    std::vector<u8> checksum1 = computeChecksum(data);
    std::vector<u8> checksum2 = computeChecksum(data);
    
    TEST_ASSERT_TRUE(dataEquals(checksum1, checksum2));
}

TEST(DataProcessor, Checksum_DifferentData) {
    std::vector<u8> data1 = createTestData(1024, 42);
    std::vector<u8> data2 = createTestData(1024, 43);
    
    std::vector<u8> checksum1 = computeChecksum(data1);
    std::vector<u8> checksum2 = computeChecksum(data2);
    
    TEST_ASSERT_FALSE(dataEquals(checksum1, checksum2));
}

TEST(DataProcessor, Checksum_Verify) {
    std::vector<u8> data = createTestData(2048);
    std::vector<u8> checksum = computeChecksum(data);
    
    TEST_ASSERT_TRUE(verifyChecksum(data, checksum));
}

TEST(DataProcessor, Checksum_VerifyTampered) {
    std::vector<u8> data = createTestData(2048);
    std::vector<u8> checksum = computeChecksum(data);
    
    data[100] ^= 0xFF;
    
    TEST_ASSERT_FALSE(verifyChecksum(data, checksum));
}

TEST(DataProcessor, Checksum_Size) {
    std::vector<u8> data = createTestData(100);
    std::vector<u8> checksum = computeChecksum(data);
    
    TEST_ASSERT_EQ(32u, checksum.size());
}

// ---------------------------------------------------------------------------
// 处理器链测试
// ---------------------------------------------------------------------------

TEST(DataProcessor, Chain_EncryptDecrypt) {
    std::vector<u8> original = createTestData(512);
    std::string key = "chain-test-key";
    
    Encryptor encryptor(key, Decryptor::Type::XOR);
    Decryptor decryptor(key, Decryptor::Type::XOR);
    
    encryptor.setNext(std::make_unique<Decryptor>(key, Decryptor::Type::XOR));
    
    std::vector<u8> result = encryptor.process(original);
    
    TEST_ASSERT_TRUE(dataEquals(original, result));
}

// ---------------------------------------------------------------------------
// 边界条件测试
// ---------------------------------------------------------------------------

TEST(DataProcessor, Boundary_SingleByte) {
    std::vector<u8> data = {0x42};
    std::string key = "key";
    
    Encryptor encryptor(key, Decryptor::Type::XOR);
    Decryptor decryptor(key, Decryptor::Type::XOR);
    
    std::vector<u8> encrypted = encryptor.process(data);
    std::vector<u8> decrypted = decryptor.process(encrypted);
    
    TEST_ASSERT_TRUE(dataEquals(data, decrypted));
    TEST_ASSERT_EQ(1u, encrypted.size());
}

TEST(DataProcessor, Boundary_LargeData) {
    std::vector<u8> data = createTestData(1024 * 1024);
    std::string key = "large-data-key";
    
    Encryptor encryptor(key, Decryptor::Type::XOR);
    Decryptor decryptor(key, Decryptor::Type::XOR);
    
    std::vector<u8> encrypted = encryptor.process(data);
    std::vector<u8> decrypted = decryptor.process(encrypted);
    
    TEST_ASSERT_TRUE(dataEquals(data, decrypted));
}