#include "leveldb/db.h"

leveldb::DB* db;
leveldb::Options options;
options.create_if_missing = true;
leveldb::DB::Open(options, "/tmp/snapdb", &db);

// 写入初始数据
db->Put(leveldb::WriteOptions(), "counter", "100");

// 获取快照
const leveldb::Snapshot* snap = db->GetSnapshot();

// 修改数据
db->Put(leveldb::WriteOptions(), "counter", "200");

// 在快照上读取（得到旧值）
leveldb::ReadOptions ropts;
ropts.snapshot = snap;
std::string value;
db->Get(ropts, "counter", &value);
std::cout << "快照值: " << value << std::endl;  // 输出: 100

// 普通读取（得到新值）
db->Get(leveldb::ReadOptions(), "counter", &value);
std::cout << "当前值: " << value << std::endl;  // 输出: 200

// 释放快照（必须！）
db->ReleaseSnapshot(snap);

delete db;

// 获取快照
snap, _ := db.GetSnapshot()
defer snap.Release()

// 在快照上读取
val, _ := snap.Get([]byte("counter"), nil)
fmt.Printf("快照值: %s\n", val)

snap = db.snapshot()

# 修改数据
db.put(b'counter', b'200')

# 快照读取旧值
old_val = snap.get(b'counter')  # 仍为 b'100'

const leveldb::Snapshot* snap = db->GetSnapshot();

// T1: 数据库有 3 条记录
// T2: 开始遍历
leveldb::ReadOptions ropts;
ropts.snapshot = snap;
leveldb::Iterator* it = db->NewIterator(ropts);

// T3: 其他线程写入新数据
// (新数据的 Seq > snap 的 Seq)

// T4: 继续遍历，新数据不可见
for (it->SeekToFirst(); it->Valid(); it->Next()) {
    // 只看到 T1 时刻的数据
}

delete it;
db->ReleaseSnapshot(snap);

class ScopedSnapshot {
public:
    explicit ScopedSnapshot(leveldb::DB* db)
        : db_(db), snapshot_(db->GetSnapshot()) {}

    ~ScopedSnapshot() {
        if (snapshot_) {
            db_->ReleaseSnapshot(snapshot_);
        }
    }

    const leveldb::Snapshot* Get() const { return snapshot_; }

    // 禁止复制
    ScopedSnapshot(const ScopedSnapshot&) = delete;
    ScopedSnapshot& operator=(const ScopedSnapshot&) = delete;

    // 允许移动
    ScopedSnapshot(ScopedSnapshot&& other) noexcept
        : db_(other.db_), snapshot_(other.snapshot_) {
        other.snapshot_ = nullptr;
    }

private:
    leveldb::DB* db_;
    const leveldb::Snapshot* snapshot_;
};

// 使用
void ReadConsistent(leveldb::DB* db) {
    ScopedSnapshot snap(db);
    leveldb::ReadOptions ropts;
    ropts.snapshot = snap.Get();
    // ... 使用 ropts 读取
}  // 自动释放快照

bool BackupDatabase(leveldb::DB* db, const std::string& backup_path) {
    // 1. 获取一致性快照
    const leveldb::Snapshot* snap = db->GetSnapshot();

    // 2. 基于快照遍历所有数据
    leveldb::ReadOptions ropts;
    ropts.snapshot = snap;
    leveldb::Iterator* it = db->NewIterator(ropts);

    // 3. 写入备份文件
    std::ofstream out(backup_path, std::ios::binary);
    for (it->SeekToFirst(); it->Valid(); it->Next()) {
        std::string key = it->key().ToString();
        std::string value = it->value().ToString();
        uint32_t klen = key.size();
        uint32_t vlen = value.size();
        out.write(reinterpret_cast<char*>(&klen), 4);
        out.write(key.data(), klen);
        out.write(reinterpret_cast<char*>(&vlen), 4);
        out.write(value.data(), vlen);
    }

    delete it;
    db->ReleaseSnapshot(snap);
    return true;
}

// 生成报表：需要读取多个 Key，期间数据不能变化
Report GenerateReport(leveldb::DB* db) {
    ScopedSnapshot snap(db);
    leveldb::ReadOptions ropts;
    ropts.snapshot = snap.Get();

    Report report;
    std::string val;

    db->Get(ropts, "stats:total_orders", &val);
    report.total_orders = std::stoll(val);

    db->Get(ropts, "stats:total_revenue", &val);
    report.total_revenue = std::stod(val);

    db->Get(ropts, "stats:active_users", &val);
    report.active_users = std::stoi(val);

    return report;
    // 快照保证三个数据来自同一时刻
}

// 记录上次读取的位置，增量获取变化
class ChangeReader {
public:
    ChangeReader(leveldb::DB* db, const std::string& checkpoint_key)
        : db_(db), checkpoint_key_(checkpoint_key) {
        // 读取上次的 Sequence Number
        std::string val;
        db->Get(leveldb::ReadOptions(), checkpoint_key, &val);
        last_seq_ = val.empty() ? 0 : std::stoull(val);
    }

    std::vector<Change> ReadChanges() {
        std::vector<Change> changes;
        uint64_t current_seq = last_seq_;

        const leveldb::Snapshot* snap = db_->GetSnapshot();
        leveldb::ReadOptions ropts;
        ropts.snapshot = snap;
        leveldb::Iterator* it = db_->NewIterator(ropts);

        for (it->SeekToFirst(); it->Valid(); it->Next()) {
            // 需要自定义比较器来过滤 Sequence Number
            // 这里简化处理
            changes.push_back({
                it->key().ToString(),
                it->value().ToString()
            });
        }

        delete it;
        db_->ReleaseSnapshot(snap);
        return changes;
    }

private:
    leveldb::DB* db_;
    std::string checkpoint_key_;
    uint64_t last_seq_;
};