第9章：存储与回溯 — 世界持久化格式设计

// 第一步：RLE 编码（把连续相同的方块合在一起）
struct RLEBlock {
    uint16_t count;  // 连续多少个
    uint8_t type;    // 方块类型
};
// "石头,石头,石头,石头,石头,空气,空气,空气"
// 变成 [{count=5, type=Stone}, {count=3, type=Air}]

// 第二步：zstd 压缩 RLE 结果
// ZSTD_compress(rleData, rleSize, compressedBuf, compressedCapacity, 3)

#include <fstream>
#include <zstd.h>

bool WorldStorage::save(const QString &path,
                         const QVector<Chunk*> &chunks)
{
    std::ofstream file(path.toStdString(), std::ios::binary);
    if (!file) return false;

    // 1. 写文件头
    writeHeader(file);
    // 2. 预留索引表位置（写完 Chunk 数据后回填）
    auto indexPos = file.tellp();
    uint32_t chunkCount = 0;
    file.seekp(4 * 8); // 跳过 N*8 字节给索引表

    // 3. 写 Chunk 数据
    struct IndexEntry { int32_t cx; int16_t cz; uint16_t size; };
    QVector<IndexEntry> index;

    for (auto *chunk : chunks) {
        if (!chunk->isModified()) continue;  // 只存修改过的！

        // RLE 编码
        auto rleData = encodeRLE(chunk);

        // zstd 压缩
        size_t compBound = ZSTD_compressBound(rleData.size());
        auto compBuf = std::make_unique<uint8_t[]>(compBound);
        size_t compSize = ZSTD_compress(
            compBuf.get(), compBound,
            rleData.data(), rleData.size(),
            3  // 压缩级别 1-19，3 是速度与体积的平衡点
        );

        // 写数据
        file.write(reinterpret_cast<const char*>(compBuf.get()), compSize);
        index.push_back({chunk->chunkX(), chunk->chunkZ(),
                         static_cast<uint16_t>(compSize)});
    }

    // 4. 回填索引表
    auto dataStart = file.tellp();
    file.seekp(indexPos);
    file.write(reinterpret_cast<const char*>(&chunkCount), 4);
    for (auto &e : index) {
        file.write(reinterpret_cast<const char*>(&e.cx), 4);
        file.write(reinterpret_cast<const char*>(&e.cz), 2);
        file.write(reinterpret_cast<const char*>(&e.size), 2);
    }

    return true;
}

bool WorldStorage::load(const QString &path,
                         ChunkManager &manager,
                         uint64_t &seed)
{
    std::ifstream file(path.toStdString(), std::ios::binary);
    if (!file) return false;

    // 1. 读文件头 + 验证
    uint32_t magic;
    file.read(reinterpret_cast<char*>(&magic), 4);
    if (magic != 0x4C584F56) {
        qWarning() << "Invalid world file: bad magic";
        return false;
    }

    uint32_t version;
    file.read(reinterpret_cast<char*>(&version), 4);
    file.read(reinterpret_cast<char*>(&seed), 8);

    // 2. 读索引表
    uint32_t chunkCount;
    file.read(reinterpret_cast<char*>(&chunkCount), 4);
    QVector<IndexEntry> index(chunkCount);
    file.read(reinterpret_cast<char*>(index.data()),
              chunkCount * sizeof(IndexEntry));

    // 3. 按需加载 Chunk（先不全部加载，只注册到索引）
    for (auto &e : index) {
        auto *chunk = new Chunk(e.cx, e.cz);
        chunk->setHasSavedData(true);  // 标记：数据在磁盘，等玩家靠近再解压
        manager.registerChunk(chunk);
    }

    // 4. ChunkManager 在玩家靠近时调 loadChunkData
    return true;
}

bool WorldStorage::loadChunkData(Chunk *chunk,
                                  std::ifstream &file,
                                  const IndexEntry &entry)
{
    file.seekg(entry.dataOffset);

    auto compBuf = std::make_unique<uint8_t[]>(entry.compSize);
    file.read(reinterpret_cast<char*>(compBuf.get()), entry.compSize);

    // zstd 解压
    size_t decSize = ZSTD_getFrameContentSize(compBuf.get(), entry.compSize);
    auto rleBuf = std::make_unique<uint8_t[]>(decSize);
    ZSTD_decompress(rleBuf.get(), decSize, compBuf.get(), entry.compSize);

    // RLE 解码 → 方块数据
    decodeRLE(chunk, rleBuf.get(), decSize);
    chunk->rebuildMesh();
    return true;
}

bool WorldStorage::load(const QString &path, ...) {
    // ...
    if (version == 1) {
        loadV1(file, manager, seed);
    } else if (version == 2) {
        loadV2(file, manager, seed);
    } else {
        qWarning() << "Unsupported world version:" << version;
        return false;
    }
}