robj *createStringObjectFromLongLongWithOptions(long long value, int flag) {
    robj *o;

    if (value >= 0 && value < OBJ_SHARED_INTEGERS && flag == LL2STROBJ_AUTO) {
        // 如果在 0-10000 之间，使用共享整数
        o = shared.integers[value];
    } else {
        if ((value >= LONG_MIN && value <= LONG_MAX) && flag != LL2STROBJ_NO_INT_ENC) {
            // 如果在 long 范围内，使用 int 编码
            o = createObject(OBJ_STRING, NULL);
            o->encoding = OBJ_ENCODING_INT;
            o->ptr = (void*)((long)value);
        } else {
            // 否则使用字符串编码
            char buf[LONG_STR_SIZE];
            int len = ll2string(buf, sizeof(buf), value);
            o = createStringObject(buf, len);
        }
    }
    return o;
}

robj *createStringObject(const char *ptr, size_t len) {
    if (len <= OBJ_ENCODING_EMBSTR_SIZE_LIMIT)
        // 如果长度小于 44，使用 embstr 编码
        return createEmbeddedStringObject(ptr,len);
    else
        // 否则使用 sds 编码
        return createRawStringObject(ptr,len);
}

/**
 * @param where LIST_HEAD(0) or LIST_TAIL(1)
 * @param xx 如果设置为 1，则只有当 key 存在时才会进行操作
 */
void pushGenericCommand(client *c, int where, int xx) {
    int j;

    robj *lobj = lookupKeyWrite(c->db, c->argv[1]);
    if (checkType(c,lobj,OBJ_LIST)) return;
    if (!lobj) {
        if (xx) {
            // 如果键不存在且 xx 为 1，报错返回
            addReply(c, shared.czero);
            return;
        }

        // 如果之前没有这个键，则直接创建 listpack 对象
        lobj = createListListpackObject();
        dbAdd(c->db,c->argv[1],lobj);
    }

    // 在添加元素前，决定是否要转换 list 的编码方式
    listTypeTryConversionAppend(lobj,c->argv,2,c->argc-1,NULL,NULL);

    // 插入元素
    for (j = 2; j < c->argc; j++) {
        listTypePush(lobj,c->argv[j],where);
        server.dirty++;
    }

    addReplyLongLong(c, listTypeLength(lobj));

    char *event = (where == LIST_HEAD) ? "lpush" : "rpush";
    signalModifiedKey(c,c->db,c->argv[1]);
    notifyKeyspaceEvent(NOTIFY_LIST,event,c->argv[1],c->db->id);
}

/**
 * 尝试将 listpack 转换为 quicklist
 * @param o 要转换的对象
 * @param argv 要添加的元素
 * @param start 开始索引
 * @param end 结束索引
 * @param fn 转换前的回调函数
 * @param data 回调函数的参数
 */
static void listTypeTryConvertListpack(robj *o, robj **argv, int start, int end,
                                       beforeConvertCB fn, void *data)
{
    serverAssert(o->encoding == OBJ_ENCODING_LISTPACK);

    size_t add_bytes = 0;
    size_t add_length = 0;

    // 计算要添加的字节数和长度
    if (argv) {
        for (int i = start; i <= end; i++) {
            if (!sdsEncodedObject(argv[i]))
                continue;
            add_bytes += sdslen(argv[i]->ptr);
        }
        add_length = end - start + 1;
    }

    // 检查是否超过了限制
    if (quicklistNodeExceedsLimit(server.list_max_listpack_size,
            lpBytes(o->ptr) + add_bytes, lpLength(o->ptr) + add_length))
    {
        // 如果超过了限制，转换为 quicklist
        if (fn) fn(data);

        quicklist *ql = quicklistNew(server.list_max_listpack_size, server.list_compress_depth);

        if (lpLength(o->ptr))
            quicklistAppendListpack(ql, o->ptr);
        else
            lpFree(o->ptr);
        o->ptr = ql;
        o->encoding = OBJ_ENCODING_QUICKLIST;
    }
}

/**
 * 根据对象本身的类型，将其转换为另一种类型
 * @param o 要转换的对象
 * @param lct 转换类型（LIST_CONV_GROWING、LIST_CONV_SHRINKING、LIST_CONV_AUTO）
 * @param argv 要添加的元素
 * @param start 开始索引
 * @param end 结束索引
 * @param fn 转换前的回调函数
 * @param data 回调函数的参数
 */
static void listTypeTryConversionRaw(robj *o, list_conv_type lct,
                                     robj **argv, int start, int end,
                                     beforeConvertCB fn, void *data)
{
    if (o->encoding == OBJ_ENCODING_QUICKLIST) {
        // 转换为 listpack
        if (lct == LIST_CONV_GROWING) return;
        listTypeTryConvertQuicklist(o, lct == LIST_CONV_SHRINKING, fn, data);
    } else if (o->encoding == OBJ_ENCODING_LISTPACK) {
        // 转换为 quicklist
        if (lct == LIST_CONV_SHRINKING) return;
        listTypeTryConvertListpack(o, argv, start, end, fn, data);
    } else {
        serverPanic("Unknown list encoding");
    }
}

void listTypeTryConversionAppend(robj *o, robj **argv, int start, int end,
                                 beforeConvertCB fn, void *data)
{
    listTypeTryConversionRaw(o, LIST_CONV_GROWING, argv, start, end, fn, data);
}

// 优化等级，代表 listpack 的最大字节数
static const size_t optimization_level[] = {4096, 8192, 16384, 32768, 65536};

static size_t quicklistNodeNegFillLimit(int fill) {
    assert(fill < 0);
    size_t offset = (-fill) - 1;
    size_t max_level = sizeof(optimization_level) / sizeof(*optimization_level);
    if (offset >= max_level) offset = max_level - 1;
    return optimization_level[offset];
}

/**
 * 根据 fill 的值返回 listpack 的最大字节数或者最大元素个数
 */
void quicklistNodeLimit(int fill, size_t *size, unsigned int *count) {
    *size = SIZE_MAX; // _UI64_MAX / _UI32_MAX
    *count = UINT_MAX;

    if (fill >= 0) {
        // 如果 fill 为正数，表示每个节点的最大元素个数
        *count = (fill == 0) ? 1 : fill;
    } else {
        // 如果 fill 为负数，取反后表示优化等级。我们根据优化等级返回 listpack 的最大字节数
        *size = quicklistNodeNegFillLimit(fill);
    }
}

/**
 * 判断新了 list 的大小是否超过了限制
 * @param fill 设置中的 list-max-listpack-size。如果为正数，表示每个节点的最大元素个数；如果为负数，表示每个节点的最大字节数
 * @param new_sz 新元素的字节数
 * @param new_count 新元素的个数
 * @return 是否超过限制
 */
int quicklistNodeExceedsLimit(int fill, size_t new_sz, unsigned int new_count) {
    size_t sz_limit;
    unsigned int count_limit;
    quicklistNodeLimit(fill, &sz_limit, &count_limit);

    if (likely(sz_limit != SIZE_MAX)) {
        // 使用最大元素个数来判断
        return new_sz > sz_limit;
    } else if (count_limit != UINT_MAX) {
        // 使用最大字节数来判断
        if (!sizeMeetsSafetyLimit(new_sz)) return 1;
        return new_count > count_limit;
    }

    redis_unreachable();
}

static robj *hashTypeLookupWriteOrCreate(client *c, robj *key) {
    robj *o = lookupKeyWrite(c->db,key);
    if (checkType(c,o,OBJ_HASH)) return NULL;

    if (o == NULL) {
        o = createHashObject();
        dbAdd(c->db,key,o);
    }
    return o;
}

robj *setTypeCreate(sds value, size_t size_hint) {
    if (isSdsRepresentableAsLongLong(value,NULL) == C_OK && size_hint <= server.set_max_intset_entries)
        // 如果元素都是整数且元素个数小于等于 set_max_intset_entries，使用 intset 编码
        return createIntsetObject();
    if (size_hint <= server.set_max_listpack_entries)
        // 如果元素个数小于等于 set_max_listpack_entries，使用 listpack 编码
        return createSetListpackObject();

    // 否则使用 hashtable 编码
    robj *o = createSetObject();
    dictExpand(o->ptr, size_hint);
    return o;
}

robj *zsetTypeCreate(size_t size_hint, size_t val_len_hint) {
    if (size_hint <= server.zset_max_listpack_entries &&
        val_len_hint <= server.zset_max_listpack_value)
    {
        // 如果元素个数小于等于 zset_max_listpack_entries 且元素长度小于等于 zset_max_listpack_value，使用 listpack 编码
        return createZsetListpackObject();
    }

    // 否则使用 skiplist 编码
    robj *zobj = createZsetObject();
    zset *zs = zobj->ptr;
    dictExpand(zs->dict, size_hint);
    return zobj;
}

void zsetTypeMaybeConvert(robj *zobj, size_t size_hint) {
    // 如果元素个数超过了 zset_max_listpack_entries，转换为 skiplist 编码，此时不关心元素长度
    if (zobj->encoding == OBJ_ENCODING_LISTPACK &&
        size_hint > server.zset_max_listpack_entries)
    {
        zsetConvertAndExpand(zobj, OBJ_ENCODING_SKIPLIST, size_hint);
    }
}

robj *lookupStringForBitCommand(client *c, uint64_t maxbit, int *dirty) {
    size_t byte = maxbit >> 3;
    robj *o = lookupKeyWrite(c->db,c->argv[1]);
    if (checkType(c,o,OBJ_STRING)) return NULL;
    if (dirty) *dirty = 0;

    if (o == NULL) {
        o = createObject(OBJ_STRING,sdsnewlen(NULL, byte+1));
        dbAdd(c->db,c->argv[1],o);
        if (dirty) *dirty = 1;
    } else {
        o = dbUnshareStringValue(c->db,c->argv[1],o);
        size_t oldlen = sdslen(o->ptr);
        o->ptr = sdsgrowzero(o->ptr,byte+1);
        if (dirty && oldlen != sdslen(o->ptr)) *dirty = 1;
    }
    return o;
}

int geohashEncode(const GeoHashRange *long_range, const GeoHashRange *lat_range,
                  double longitude, double latitude, uint8_t step,
                  GeoHashBits *hash) {
    // 输入验证与范围检查
    if (hash == NULL || step > 32 || step == 0 ||
        RANGEPISZERO(lat_range) || RANGEPISZERO(long_range)) return 0;
    if (longitude > GEO_LONG_MAX || longitude < GEO_LONG_MIN ||
        latitude > GEO_LAT_MAX || latitude < GEO_LAT_MIN) return 0;

    // bits 用于存储编码后的结果，step 用于存储精度
    hash->bits = 0;
    hash->step = step;

    if (latitude < lat_range->min || latitude > lat_range->max ||
        longitude < long_range->min || longitude > long_range->max) {
        return 0;
    }

    // 计算偏移量，将经纬度转换为 0-1 之间的相对值
    double lat_offset =
        (latitude - lat_range->min) / (lat_range->max - lat_range->min);
    double long_offset =
        (longitude - long_range->min) / (long_range->max - long_range->min);

    // 将经纬度编码
    lat_offset *= (1ULL << step);
    long_offset *= (1ULL << step);
    hash->bits = interleave64(lat_offset, long_offset);
    return 1;
}

typedef struct stream {
    rax *rax; // 基数树
    uint64_t length; // 当前消息数量
    streamID last_id; // 最新消息 ID，如果没有则置 0
    streamID first_id; // 最旧消息 ID
    streamID max_deleted_entry_id; // 最大被删除的消息 ID
    uint64_t entries_added; // 添加过的总消息数量
    rax *cgroups; // 消费者组字典：name -> streamCG
} stream;

typedef struct rax {
    raxNode *head;
    uint64_t numele;
    uint64_t numnodes;
    void *metadata[];
} rax;

typedef struct raxNode {
    uint32_t iskey:1; // 该节点是否包含键
    uint32_t isnull:1; // 该节点是否为空
    uint32_t iscompr:1; // 该节点是否为压缩节点
    uint32_t size:29; // 子节点数量 / 数据长度
    unsigned char data[];
} raxNode;

typedef struct streamCG {
    streamID last_id; // 最后接收但未确认的消息 ID
    long long entries_read; // 已读取的消息数量
    rax *pel; // 待确认消息列表
    rax *consumers; // 消费者字典：name -> streamConsumer
} streamCG;

typedef struct streamConsumer {
    mstime_t seen_time; // 最后一次尝试读取/确认消息时间
    mstime_t active_time; // 最后一次成功读取/确认消息时间
    sds name; // 消费者名
    rax *pel; // 待确认消息列表
} streamConsumer;

typedef struct streamNACK {
    mstime_t delivery_time; // 该消息被投递的时间
    uint64_t delivery_count; // 该消息被投递的次数
    streamConsumer *consumer; // 最后一次投递给的消费者
} streamNACK;