// 按字典序排列数字，结果可能不符合预期
db->Put(wopts, "key:1", "...");
db->Put(wopts, "key:2", "...");  
db->Put(wopts, "key:10", "...");
db->Put(wopts, "key:9", "...");

// 遍历顺序：key:1 → key:10 → key:2 → key:9  ← 字典序！
// 期望顺序：key:1 → key:2 → key:9 → key:10   ← 数值序

#include "leveldb/comparator.h"
#include "leveldb/db.h"
#include <cstring>
#include <cstdlib>

class NumericComparator : public leveldb::Comparator {
public:
    // 核心比较函数
    int Compare(const leveldb::Slice& a, const leveldb::Slice& b) const override {
        // 假设 key 格式为 "prefix:数字"
        int num_a = ExtractNumber(a);
        int num_b = ExtractNumber(b);

        if (num_a < num_b) return -1;
        if (num_a > num_b) return 1;

        // 数字相同时，按字节序比较（保证唯一性）
        return a.compare(b);
    }

    // 比较器名称（必须唯一，用于数据库兼容性检查）
    const char* Name() const override {
        return "NumericComparator";
    }

    // 以下方法可留空（高级优化）
    void FindShortestSeparator(std::string*, const leveldb::Slice&) const override {}
    void FindShortSuccessor(std::string*) const override {}

private:
    int ExtractNumber(const leveldb::Slice& key) const {
        std::string s = key.ToString();
        auto pos = s.rfind(':');
        if (pos == std::string::npos) return 0;
        return std::atoi(s.substr(pos + 1).c_str());
    }
};

int main() {
    NumericComparator cmp;
    leveldb::Options options;
    options.create_if_missing = true;
    options.comparator = &cmp;  // 使用自定义比较器

    leveldb::DB* db;
    leveldb::DB::Open(options, "/tmp/numeric_db", &db);

    db->Put(wopts, "item:10", "...");
    db->Put(wopts, "item:2", "...");
    db->Put(wopts, "item:1", "...");
    db->Put(wopts, "item:9", "...");

    auto* it = db->NewIterator(ropts);
    for (it->SeekToFirst(); it->Valid(); it->Next()) {
        std::cout << it->key().ToString() << std::endl;
    }
    // 输出: item:1 → item:2 → item:9 → item:10  ✅

    delete it;
    delete db;
}

type NumericComparer struct{}

func (c NumericComparer) Compare(a, b []byte) int {
    numA := extractNumber(a)
    numB := extractNumber(b)
    if numA < numB { return -1 }
    if numA > numB { return 1 }
    return bytes.Compare(a, b)
}

func (c NumericComparer) Name() string { return "NumericComparer" }

func (c NumericComparer) Separator(dst, a, b []byte) []byte { return nil }
func (c NumericComparer) Successor(dst, b []byte) []byte { return nil }

// 打开数据库时使用
db, err := leveldb.OpenFile("/tmp/db", &opt.Options{
    Comparer: NumericComparer{},
})

// ❌ 错误：时间戳不补齐
std::string key = "log:" + std::to_string(timestamp);
// "log:1683724800" vs "log:9999999999"  → 字典序不等于时间序

// ✅ 正确：补零到固定长度
char key[32];
snprintf(key, sizeof(key), "log:%020ld", timestamp);
// "log:0000000001683724800" vs "log:0000000009999999999"

// 场景：需要按时间从新到旧遍历
// 方法：使用 (MAX - timestamp) 作为 Key

uint64_t now = time(nullptr);
uint64_t reverse_ts = UINT64_MAX - now;

char key[32];
snprintf(key, sizeof(key), "rtlog:%020lu", reverse_ts);
// 遍历时 SeekToFirst 就是从最新开始

// 场景：先按用户 ID 排序，再按时间排序
// Key 格式: user:{user_id:固定8字节}:{timestamp:固定8字节}

std::string MakeKey(uint32_t user_id, uint64_t timestamp) {
    std::string key(16, '\0');
    // 大端编码保证字典序 = 数值序
    key[0] = (user_id >> 24) & 0xFF;
    key[1] = (user_id >> 16) & 0xFF;
    key[2] = (user_id >> 8) & 0xFF;
    key[3] = user_id & 0xFF;
    key[4] = (timestamp >> 56) & 0xFF;
    key[5] = (timestamp >> 48) & 0xFF;
    // ... 依次填充
    return key;
}

class OrderStore {
public:
    OrderStore(leveldb::DB* db) : db_(db) {}

    // 创建订单
    bool CreateOrder(uint64_t order_id, uint32_t user_id,
                     double amount, const std::string& status) {
        leveldb::WriteBatch batch;
        char ts[32];
        snprintf(ts, sizeof(ts), "%020lu", time(nullptr));

        // 主记录
        std::string main_key = "order:" + Uint64ToKey(order_id);
        std::string main_val = SerializeOrder(order_id, user_id, amount, status, ts);
        batch.Put(main_key, main_val);

        // 用户订单索引：支持按用户查询
        std::string user_idx = "idx:user_order:" + Uint32ToKey(user_id)
                              + ":" + Uint64ToKey(order_id);
        batch.Put(user_idx, "");

        // 时间索引：支持按时间查询
        std::string time_idx = "idx:time_order:" + std::string(ts)
                              + ":" + Uint64ToKey(order_id);
        batch.Put(time_idx, "");

        // 状态索引：支持按状态查询
        std::string status_idx = "idx:status:" + status
                                + ":" + Uint64ToKey(order_id);
        batch.Put(status_idx, main_val);

        return db_->Write(leveldb::WriteOptions(), &batch).ok();
    }

    // 查询用户的所有订单
    std::vector<uint64_t> GetUserOrders(uint32_t user_id, int limit = 20) {
        std::vector<uint64_t> orders;
        std::string prefix = "idx:user_order:" + Uint32ToKey(user_id) + ":";
        auto* it = db_->NewIterator(leveldb::ReadOptions());
        for (it->Seek(prefix);
             it->Valid() && it->key().starts_with(prefix) && orders.size() < limit;
             it->Next()) {
            uint64_t oid = KeyToUint64(it->key().ToString().substr(prefix.size()));
            orders.push_back(oid);
        }
        delete it;
        return orders;
    }

private:
    leveldb::DB* db_;

    std::string Uint32ToKey(uint32_t v) {
        std::string s(4, '\0');
        s[0] = (v >> 24); s[1] = (v >> 16);
        s[2] = (v >> 8);  s[3] = v;
        return s;
    }
    std::string Uint64ToKey(uint64_t v) {
        std::string s(8, '\0');
        for (int i = 7; i >= 0; i--) {
            s[i] = v & 0xFF; v >>= 8;
        }
        return s;
    }
    uint64_t KeyToUint64(const std::string& s) {
        uint64_t v = 0;
        for (int i = 0; i < 8; i++) v = (v << 8) | (uint8_t)s[i];
        return v;
    }
    std::string SerializeOrder(...) { /* JSON / Protobuf 序列化 */ return ""; }
};