// LevelDB 内部的 LRU Cache 实现（简化版）
struct LRUHandle {
    void* value;
    void (*deleter)(const Slice&, void* value);
    LRUHandle* next_hash;   // 哈希表链
    LRUHandle* next;         // LRU 双向链表
    LRUHandle* prev;
    size_t charge;
    uint32_t hash;
    char key_data[1];        // 变长 key
};

struct LRUCache {
    size_t capacity;          // 缓存容量
    std::unordered_map<uint32_t, LRUHandle*> table;  // 哈希表
    LRUHandle lru;            // LRU 链表头
    size_t usage;             // 当前使用量
};

// Table Cache 大小通过 max_open_files 控制
leveldb::Options options;
options.max_open_files = 500;  // 默认 1000

// Block Cache 大小
leveldb::Options options;
options.block_cache = leveldb::NewLRUCache(128 * 1024 * 1024);  // 128MB

#include "leveldb/cache.h"
#include "leveldb/db.h"

leveldb::Options options;

// 方法 1：创建自定义大小的 LRU Cache
options.block_cache = leveldb::NewLRUCache(256 * 1024 * 1024);  // 256MB

// 方法 2：禁用 Block Cache（每次读磁盘）
options.block_cache = leveldb::NewLRUCache(0);

// 方法 3：共享多个数据库实例的缓存
auto shared_cache = leveldb::NewLRUCache(512 * 1024 * 1024);  // 512MB
options1.block_cache = shared_cache;
options2.block_cache = shared_cache;

// 场景 1：正常读取（填充缓存）
leveldb::ReadOptions ropts;
ropts.fill_cache = true;  // 默认
db->Get(ropts, "hot_key", &value);  // 读取结果加入缓存

// 场景 2：批量扫描（不污染缓存）
leveldb::ReadOptions ropts;
ropts.fill_cache = false;
auto* it = db->NewIterator(ropts);
for (it->SeekToFirst(); it->Valid(); it->Next()) {
    // 大量顺序读取不会把热数据挤出缓存
}
delete it;

leveldb::Options options;
options.statistics = leveldb::CreateDBStatistics();

// ... 使用数据库 ...

auto stats = options.statistics;
uint64_t hits = stats->getTickerCount(leveldb::BLOCK_CACHE_HIT);
uint64_t misses = stats->getTickerCount(leveldb::BLOCK_CACHE_MISS);
double hit_rate = (double)hits / (hits + misses) * 100.0;

std::cout << "Block Cache 命中率: " << hit_rate << "%" << std::endl;

class CachedUserAPI {
public:
    CachedUserAPI(leveldb::DB* db) : db_(db) {
        // 配置较大的 Block Cache
        leveldb::Options opts;
        opts.block_cache = leveldb::NewLRUCache(512 * 1024 * 1024);
        // ... 重新打开数据库 ...
    }

    // 热点用户查询（会被缓存）
    std::string GetUser(int user_id) {
        std::string value;
        leveldb::ReadOptions ropts;
        ropts.fill_cache = true;
        db_->Get(ropts, "user:" + std::to_string(user_id), &value);
        return value;
    }

    // 导出所有用户（不污染缓存）
    void ExportAllUsers(std::ostream& out) {
        leveldb::ReadOptions ropts;
        ropts.fill_cache = false;
        auto* it = db_->NewIterator(ropts);
        for (it->Seek("user:"); it->Valid(); it->Next()) {
            if (!it->key().starts_with("user:")) break;
            out << it->key().ToString() << "\t"
                << it->value().ToString() << "\n";
        }
        delete it;
    }

private:
    leveldb::DB* db_;
};

// 配置服务：用户数据库 + 配置数据库共享缓存
auto shared_cache = leveldb::NewLRUCache(1024 * 1024 * 1024);  // 1GB

leveldb::Options user_opts;
user_opts.create_if_missing = true;
user_opts.block_cache = shared_cache;
leveldb::DB* user_db;
leveldb::DB::Open(user_opts, "/data/users", &user_db);

leveldb::Options config_opts;
config_opts.create_if_missing = true;
config_opts.block_cache = shared_cache;
leveldb::DB* config_db;
leveldb::DB::Open(config_opts, "/data/config", &config_db);

// 两个数据库公平竞争缓存空间

// 较大的 block_size 减少索引条目，但可能降低缓存效率
options.block_size = 8192;  // 8KB（默认 4KB）

// 将热数据和冷数据存储在不同的数据库实例中
// 热数据库：大缓存
leveldb::Options hot_opts;
hot_opts.block_cache = leveldb::NewLRUCache(1GB);

// 冷数据库：小缓存
leveldb::Options cold_opts;
cold_opts.block_cache = leveldb::NewLRUCache(64MB);

// 定期检查缓存命中率，动态调整
void MonitorCache(leveldb::DB* db, leveldb::Statistics* stats) {
    uint64_t hits = stats->getTickerCount(leveldb::BLOCK_CACHE_HIT);
    uint64_t misses = stats->getTickerCount(leveldb::BLOCK_CACHE_MISS);
    double rate = (double)hits / (hits + misses);

    if (rate < 0.8) {
        // 缓存命中率低，考虑增大缓存或优化数据访问模式
        LOG(WARNING) << "Block Cache hit rate low: " << rate;
    }
}