-- KEYS 和 ARGV 是全局数组
-- KEYS[1], KEYS[2], ... 对应命令中的 key 参数
-- ARGV[1], ARGV[2], ... 对应命令中的 arg 参数

local key = KEYS[1]
local value = ARGV[1]

redis.call('SET', key, value)
return redis.call('GET', key)

-- 数组式 table（连续整数键）
return {1, "hello", true, nil, 3}
-- → *3\r\n:1\r\n$5\r\nhello\r\n:1\r\n
-- 注意：nil 和其后的元素被忽略

return {{1, 2}, {3, 4}}
-- → *2\r\n*2\r\n:1\r\n:2\r\n*2\r\n:3\r\n:4\r\n

import hashlib

script = "return 1"
sha1 = hashlib.sha1(script.encode()).hexdigest()
print(sha1)  # "a5260dd1a28a0680e6dbb9a441b25a4944419b21"

import redis
import hashlib

class ScriptManager:
    """脚本缓存管理器"""

    def __init__(self, client: redis.Redis):
        self.client = client
        self._cache = {}  # script → sha1

    def register(self, script: str) -> str:
        """注册脚本并返回 SHA1"""
        sha1 = hashlib.sha1(script.encode()).hexdigest()
        self._cache[sha1] = script
        # 预加载到服务器
        self.client.script_load(script)
        return sha1

    def evalsha(self, sha1: str, keys=[], args=[]):
        """使用 EVALSHA 执行脚本，失败时自动回退到 EVAL"""
        try:
            return self.client.evalsha(sha1, len(keys), *keys, *args)
        except redis.exceptions.NoScriptError:
            # 脚本不在缓存中，使用 EVAL
            script = self._cache.get(sha1)
            if script is None:
                raise ValueError(f"Unknown script: {sha1}")
            return self.client.eval(script, len(keys), *keys, *args)


# 使用
r = redis.Redis()
sm = ScriptManager(r)

# 注册分布式锁脚本
lock_script = """
if redis.call('SET', KEYS[1], ARGV[1], 'NX', 'EX', ARGV[2]) then
    return 1
else
    return 0
end
"""
lock_sha = sm.register(lock_script)

# 执行
result = sm.evalsha(lock_sha, keys=["mylock"], args=["owner1", 30])

-- 使用 redis.call()：错误会传播
local result = redis.call('GET', 'nonexistent')
-- result 是 false（nil），不会报错

-- 类型错误时：
local result = redis.call('LPUSH', 'string-key', 'value')
-- 报错：WRONGTYPE Operation against a key...
-- 脚本中断，错误返回给客户端

-- 使用 redis.pcall()：错误被捕获
local ok, result = pcall(redis.call, 'LPUSH', 'string-key', 'value')
-- ok = false, result = "WRONGTYPE ..."
-- 脚本继续执行

-- 在脚本中输出日志（写入 Redis 日志文件）
redis.log(redis.LOG_DEBUG, "Debug message")
redis.log(redis.LOG_VERBOSE, "Verbose message")
redis.log(redis.LOG_NOTICE, "Notice message")
redis.log(redis.LOG_WARNING, "Warning message")

-- 示例
local value = redis.call('GET', KEYS[1])
redis.log(redis.LOG_NOTICE, "Current value: " .. tostring(value))
return value

# 使用 redis-cli 的 --ldb 选项调试脚本
redis-cli --ldb --eval /tmp/script.lua mykey , myarg

# 调试命令：
# s - step（单步执行）
# n - next
# c - continue（继续执行）
# p <var> - print variable
# b <line> - break at line
# r - run until return

-- 加锁脚本
-- KEYS[1]: 锁的 key
-- ARGV[1]: 锁的持有者标识
-- ARGV[2]: 过期时间（秒）
-- 返回: 1（成功）/ 0（失败）

if redis.call('SET', KEYS[1], ARGV[1], 'NX', 'EX', ARGV[2]) then
    return 1
else
    return 0
end

-- 解锁脚本
-- KEYS[1]: 锁的 key
-- ARGV[1]: 锁的持有者标识
-- 返回: 1（成功）/ 0（失败或锁不属于当前持有者）

if redis.call('GET', KEYS[1]) == ARGV[1] then
    return redis.call('DEL', KEYS[1])
else
    return 0
end

-- KEYS[1]: 限流 key
-- ARGV[1]: 桶容量
-- ARGV[2]: 每秒填充速率
-- ARGV[3]: 当前时间戳（秒）
-- ARGV[4]: 请求的令牌数

local key = KEYS[1]
local capacity = tonumber(ARGV[1])
local rate = tonumber(ARGV[2])
local now = tonumber(ARGV[3])
local requested = tonumber(ARGV[4])

-- 获取当前桶状态
local data = redis.call('HMGET', key, 'tokens', 'last_time')
local tokens = tonumber(data[1]) or capacity
local last_time = tonumber(data[2]) or now

-- 计算新增令牌
local elapsed = math.max(0, now - last_time)
tokens = math.min(capacity, tokens + elapsed * rate)

-- 判断是否允许
local allowed = 0
if tokens >= requested then
    tokens = tokens - requested
    allowed = 1
end

-- 更新桶状态
redis.call('HMSET', key, 'tokens', tokens, 'last_time', now)
redis.call('EXPIRE', key, math.ceil(capacity / rate) * 2)

return allowed

-- KEYS[1]: 限流 key
-- ARGV[1]: 窗口大小（秒）
-- ARGV[2]: 最大请求数
-- ARGV[3]: 当前时间戳（微秒）
-- ARGV[4]: 唯一标识

local key = KEYS[1]
local window = tonumber(ARGV[1])
local limit = tonumber(ARGV[2])
local now = tonumber(ARGV[3])
local uuid = ARGV[4]

-- 清除窗口外的成员
redis.call('ZREMRANGEBYSCORE', key, 0, now - window * 1000000)

-- 计算当前窗口内的请求数
local count = redis.call('ZCARD', key)

if count < limit then
    -- 允许请求，添加到有序集合
    redis.call('ZADD', key, now, uuid)
    redis.call('PEXPIRE', key, window * 1000)
    return 1  -- 允许
else
    return 0  -- 拒绝
end

# 配置脚本最大执行时间（默认 5 秒）
lua-time-limit 5000

# 超过限制后，其他客户端的命令会返回 BUSY 错误
# 但脚本不会自动停止，需要手动 SCRIPT KILL

-- ✅ 正确：所有 key 在同一个槽
redis.call('SET', '{user:1}:name', 'Alice')
redis.call('SET', '{user:1}:age', '30')

-- ❌ 错误：key 在不同槽
redis.call('SET', 'user:name', 'Alice')
redis.call('SET', 'user:age', '30')  -- 可能在不同槽

-- ❌ 错误
count = count + 1

-- ✅ 正确
local count = 0

-- ❌ 错误：随机结果
return math.random(1, 100)

-- ✅ 正确：使用 Redis 提供的随机数
return redis.call('RANDOMKEY')