/**
 * @file test_asset_pack.cpp
 * @brief AssetPack 单元测试
 *
 * 测试资源包的创建、读取和管理功能。
 */

#include "test_framework.h"
#include <extra2d/asset/asset_pack.h>
#include <filesystem>
#include <fstream>

using namespace extra2d;
using namespace extra2d::test;

// ---------------------------------------------------------------------------
// 测试辅助函数
// ---------------------------------------------------------------------------

namespace {
std::string testDir = "test_temp";

void setupTestDir() { std::filesystem::create_directories(testDir); }

void cleanupTestDir() { std::filesystem::remove_all(testDir); }

std::string getTestPath(const std::string &name) {
  return testDir + "/" + name;
}

void writeTestFile(const std::string &path, const std::vector<u8> &data) {
  std::ofstream file(path, std::ios::binary);
  file.write(reinterpret_cast<const char *>(data.data()), data.size());
}
} // namespace

// ---------------------------------------------------------------------------
// AssetPackBuilder 测试
// ---------------------------------------------------------------------------

TEST(AssetPackBuilder, Create) {
  AssetPackBuilder builder;

  TEST_ASSERT_EQ(0u, builder.count());
  TEST_ASSERT_EQ(0u, builder.totalOriginalSize());
  TEST_ASSERT_EQ(0u, builder.totalCompressedSize());
}

TEST(AssetPackBuilder, AddData) {
  AssetPackBuilder builder;

  std::vector<u8> data = createTestData(1024);
  builder.add("test.bin", data);

  TEST_ASSERT_EQ(1u, builder.count());
  TEST_ASSERT_EQ(1024u, builder.totalOriginalSize());
}

TEST(AssetPackBuilder, AddMultipleData) {
  AssetPackBuilder builder;

  builder.add("file1.bin", createTestData(100));
  builder.add("file2.bin", createTestData(200));
  builder.add("file3.bin", createTestData(300));

  TEST_ASSERT_EQ(3u, builder.count());
  TEST_ASSERT_EQ(600u, builder.totalOriginalSize());
}

TEST(AssetPackBuilder, AddMovedData) {
  AssetPackBuilder builder;

  std::vector<u8> data = createTestData(512);
  builder.add("moved.bin", std::move(data));

  TEST_ASSERT_EQ(1u, builder.count());
}

TEST(AssetPackBuilder, Clear) {
  AssetPackBuilder builder;

  builder.add("test.bin", createTestData(100));
  builder.clear();

  TEST_ASSERT_EQ(0u, builder.count());
  TEST_ASSERT_EQ(0u, builder.totalOriginalSize());
}

TEST(AssetPackBuilder, BuildSimple) {
  setupTestDir();

  AssetPackBuilder builder;
  builder.add("test.bin", createTestData(256));

  std::string packPath = getTestPath("simple.pack");
  bool result = builder.build(packPath);

  TEST_ASSERT_TRUE(result);
  TEST_ASSERT_TRUE(std::filesystem::exists(packPath));

  cleanupTestDir();
}

TEST(AssetPackBuilder, BuildMultipleFiles) {
  setupTestDir();

  AssetPackBuilder builder;
  builder.add("file1.bin", createTestData(100, 1));
  builder.add("file2.bin", createTestData(200, 2));
  builder.add("file3.bin", createTestData(300, 3));

  std::string packPath = getTestPath("multi.pack");
  bool result = builder.build(packPath);

  TEST_ASSERT_TRUE(result);
  TEST_ASSERT_TRUE(std::filesystem::exists(packPath));

  cleanupTestDir();
}

TEST(AssetPackBuilder, SetEncryption) {
  AssetPackBuilder builder;
  builder.setEncryption("secret-key", Decryptor::Type::XOR);

  builder.add("encrypted.bin", createTestData(128));

  TEST_ASSERT_EQ(1u, builder.count());
}

// ---------------------------------------------------------------------------
// AssetPack 测试
// ---------------------------------------------------------------------------

TEST(AssetPack, Create) {
  AssetPack pack;

  TEST_ASSERT_FALSE(pack.isOpen());
  TEST_ASSERT_EQ(0u, pack.count());
}

TEST(AssetPack, OpenNonExistent) {
  AssetPack pack;

  bool result = pack.open("nonexistent.pack");

  TEST_ASSERT_FALSE(result);
  TEST_ASSERT_FALSE(pack.isOpen());
}

TEST(AssetPack, OpenAndClose) {
  setupTestDir();

  AssetPackBuilder builder;
  builder.add("test.bin", createTestData(100));
  builder.build(getTestPath("test.pack"));

  AssetPack pack;
  bool opened = pack.open(getTestPath("test.pack"));

  TEST_ASSERT_TRUE(opened);
  TEST_ASSERT_TRUE(pack.isOpen());

  pack.close();

  TEST_ASSERT_FALSE(pack.isOpen());

  cleanupTestDir();
}

TEST(AssetPack, ReadAsset) {
  setupTestDir();

  std::vector<u8> originalData = createTestData(512);

  AssetPackBuilder builder;
  builder.add("data.bin", originalData);
  builder.build(getTestPath("read.pack"));

  AssetPack pack;
  pack.open(getTestPath("read.pack"));

  std::vector<u8> readData = pack.read("data.bin");

  TEST_ASSERT_TRUE(dataEquals(originalData, readData));

  pack.close();
  cleanupTestDir();
}

TEST(AssetPack, HasAsset) {
  setupTestDir();

  AssetPackBuilder builder;
  builder.add("exists.bin", createTestData(100));
  builder.build(getTestPath("has.pack"));

  AssetPack pack;
  pack.open(getTestPath("has.pack"));

  TEST_ASSERT_TRUE(pack.has("exists.bin"));
  TEST_ASSERT_FALSE(pack.has("not_exists.bin"));

  pack.close();
  cleanupTestDir();
}

TEST(AssetPack, GetAssets) {
  setupTestDir();

  AssetPackBuilder builder;
  builder.add("file1.bin", createTestData(100));
  builder.add("file2.bin", createTestData(100));
  builder.add("file3.bin", createTestData(100));
  builder.build(getTestPath("assets.pack"));

  AssetPack pack;
  pack.open(getTestPath("assets.pack"));

  std::vector<AssetID> assets = pack.assets();

  TEST_ASSERT_EQ(3u, assets.size());

  pack.close();
  cleanupTestDir();
}

TEST(AssetPack, MoveSemantics) {
  setupTestDir();

  AssetPackBuilder builder;
  builder.add("test.bin", createTestData(100));
  builder.build(getTestPath("move.pack"));

  AssetPack pack1;
  pack1.open(getTestPath("move.pack"));

  AssetPack pack2 = std::move(pack1);

  TEST_ASSERT_TRUE(pack2.isOpen());
  TEST_ASSERT_FALSE(pack1.isOpen());

  pack2.close();
  cleanupTestDir();
}

// ---------------------------------------------------------------------------
// PackManager 测试
// ---------------------------------------------------------------------------

TEST(PackManager, Create) {
  PackManager manager;

  TEST_ASSERT_EQ(0u, manager.count());
}

TEST(PackManager, MountUnmount) {
  setupTestDir();

  AssetPackBuilder builder;
  builder.add("test.bin", createTestData(100));
  builder.build(getTestPath("manager.pack"));

  PackManager manager;
  bool mounted = manager.mount(getTestPath("manager.pack"));

  TEST_ASSERT_TRUE(mounted);
  TEST_ASSERT_EQ(1u, manager.count());

  manager.unmount(getTestPath("manager.pack"));

  TEST_ASSERT_EQ(0u, manager.count());

  cleanupTestDir();
}

TEST(PackManager, MountNonExistent) {
  PackManager manager;

  bool mounted = manager.mount("nonexistent.pack");

  TEST_ASSERT_FALSE(mounted);
  TEST_ASSERT_EQ(0u, manager.count());
}

TEST(PackManager, HasAsset) {
  setupTestDir();

  AssetPackBuilder builder;
  builder.add("resource.bin", createTestData(100));
  builder.build(getTestPath("has.pack"));

  PackManager manager;
  manager.mount(getTestPath("has.pack"));

  TEST_ASSERT_TRUE(manager.has("resource.bin"));
  TEST_ASSERT_FALSE(manager.has("missing.bin"));

  manager.unmountAll();
  cleanupTestDir();
}

TEST(PackManager, ReadAsset) {
  setupTestDir();

  std::vector<u8> originalData = createTestData(256);

  AssetPackBuilder builder;
  builder.add("data.bin", originalData);
  builder.build(getTestPath("read.pack"));

  PackManager manager;
  manager.mount(getTestPath("read.pack"));

  std::vector<u8> readData = manager.read("data.bin");

  TEST_ASSERT_TRUE(dataEquals(originalData, readData));

  manager.unmountAll();
  cleanupTestDir();
}

TEST(PackManager, MultiplePacks) {
  setupTestDir();

  AssetPackBuilder builder1;
  builder1.add("pack1/file1.bin", createTestData(100));
  builder1.build(getTestPath("pack1.pack"));

  AssetPackBuilder builder2;
  builder2.add("pack2/file2.bin", createTestData(200));
  builder2.build(getTestPath("pack2.pack"));

  PackManager manager;
  manager.mount(getTestPath("pack1.pack"));
  manager.mount(getTestPath("pack2.pack"));

  TEST_ASSERT_EQ(2u, manager.count());
  TEST_ASSERT_TRUE(manager.has("pack1/file1.bin"));
  TEST_ASSERT_TRUE(manager.has("pack2/file2.bin"));

  manager.unmountAll();
  cleanupTestDir();
}

TEST(PackManager, UnmountAll) {
  setupTestDir();

  AssetPackBuilder builder;
  builder.add("test.bin", createTestData(100));
  builder.build(getTestPath("unmount.pack"));

  PackManager manager;
  manager.mount(getTestPath("unmount.pack"));

  manager.unmountAll();

  TEST_ASSERT_EQ(0u, manager.count());

  cleanupTestDir();
}

TEST(PackManager, AllAssets) {
  setupTestDir();

  AssetPackBuilder builder;
  builder.add("file1.bin", createTestData(100));
  builder.add("file2.bin", createTestData(100));
  builder.build(getTestPath("all.pack"));

  PackManager manager;
  manager.mount(getTestPath("all.pack"));

  std::vector<AssetID> assets = manager.allAssets();

  TEST_ASSERT_EQ(2u, assets.size());

  manager.unmountAll();
  cleanupTestDir();
}

TEST(PackManager, MountedPacks) {
  setupTestDir();

  AssetPackBuilder builder;
  builder.add("test.bin", createTestData(100));
  builder.build(getTestPath("mounted.pack"));

  PackManager manager;
  manager.mount(getTestPath("mounted.pack"));

  std::vector<std::string> mounted = manager.mountedPacks();

  TEST_ASSERT_EQ(1u, mounted.size());

  manager.unmountAll();
  cleanupTestDir();
}

// ---------------------------------------------------------------------------
// 加密资源包测试
// ---------------------------------------------------------------------------

TEST(AssetPack, EncryptedPack) {
  setupTestDir();

  std::vector<u8> originalData = createTestData(256);
  std::string key = "encryption-key";

  AssetPackBuilder builder(Compression::None);
  builder.setEncryption(key, Decryptor::Type::XOR);
  builder.add("encrypted.bin", originalData);
  builder.build(getTestPath("encrypted.pack"));

  AssetPack pack;
  pack.open(getTestPath("encrypted.pack"));

  DataPipe pipe;
  pipe.decrypt(key, Decryptor::Type::XOR);
  pack.setPipe(std::move(pipe));

  std::vector<u8> readData = pack.read("encrypted.bin");

  TEST_ASSERT_TRUE(dataEquals(originalData, readData));

  pack.close();
  cleanupTestDir();
}