rediscli

var (

	// ErrScriptNotFound is returned when a script is not found in the scripts map
	ErrScriptNotFound = errors.New("script not found")
)

var LuaScripts = map[string]string{

	"IncrementAndExpire": `
local count = redis.call("INCR", KEYS[1])
redis.call("EXPIRE", KEYS[1], ARGV[1])
return count
`,

	"AddToSetAndExpire": `
local result = redis.call("SADD", KEYS[1], ARGV[1])
redis.call("EXPIRE", KEYS[1], ARGV[2])
return result
`,

	"ZAddCountAndExpire": `
redis.call("ZADD", KEYS[1], ARGV[1], ARGV[2])
local count = redis.call("ZCOUNT", KEYS[1], "-inf", "+inf")
redis.call("EXPIRE", KEYS[1], ARGV[4])
redis.call("HSET", KEYS[2], ARGV[3], count)
redis.call("EXPIRE", KEYS[2], ARGV[4])
return count
`,

	"CalculateAdaptiveToleration": `
local positive = tonumber(redis.call("HGET", KEYS[1], "positive") or "0")
local negative = tonumber(redis.call("HGET", KEYS[1], "negative") or "0")
local min_percent = tonumber(ARGV[1])
local max_percent = tonumber(ARGV[2])
local scale_factor = tonumber(ARGV[3])
local static_percent = tonumber(ARGV[4])
local adaptive_enabled = tonumber(ARGV[5]) == 1

-- If adaptive toleration is disabled or there are no positive attempts, use static percentage
if not adaptive_enabled or positive == 0 then
    local max_negative = math.floor((static_percent * positive) / 100)
    return {static_percent, max_negative, positive, negative, 0}
end

-- Calculate adaptive percentage based on positive attempts and scale factor
local percent = min_percent
if positive > 0 then
    -- Calculate percentage between min and max based on positive attempts and scale factor
    local factor = math.min(1, math.log(positive + 1) / math.log(100) * scale_factor)
    percent = math.floor(min_percent + (max_percent - min_percent) * factor)

    -- Ensure percent is within bounds
    percent = math.max(min_percent, math.min(max_percent, percent))
end

-- Calculate maximum allowed negative attempts
local max_negative = math.floor((percent * positive) / 100)

-- Return the calculated percentage, max negative attempts, positive count, positive count, and factor
return {percent, max_negative, positive, negative, 1}
`,

	"AddToSetAndExpireLimit": `
local key = KEYS[1]
local hash = ARGV[1]
local ttl = tonumber(ARGV[2])
local max = tonumber(ARGV[3])
local legacy_hash = ARGV[4]

redis.call('SREM', key, legacy_hash)

if redis.call('SCARD', key) >= max then
  if redis.call('SISMEMBER', key, hash) == 1 then
    redis.call('EXPIRE', key, ttl)
    return 1
  end
  return 0
end

redis.call('SADD', key, hash)
redis.call('EXPIRE', key, ttl)
return 1
`,

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

	"RWPSlidingWindowCheck": `
local key = KEYS[1]
local hash = ARGV[1]
local now = tonumber(ARGV[2])
local ttl = tonumber(ARGV[3])
local max = tonumber(ARGV[4])
local legacy_hash = ARGV[5]

-- Remove outdated entries (necessary for accurate cardinality)
redis.call('ZREMRANGEBYSCORE', key, '-inf', '(' .. (now - ttl))

-- Check if hash already exists
local score = redis.call('ZSCORE', key, hash)
local legacy_score = redis.call('ZSCORE', key, legacy_hash)
local card = redis.call('ZCARD', key)

-- Return 1 if it was a repeat (existed before) or if we were below the limit
if score or legacy_score or card < max then
    return 1
end

return 0
`,

	"RWPSlidingWindowCommit": `
local key = KEYS[1]
local hash = ARGV[1]
local now = tonumber(ARGV[2])
local ttl = tonumber(ARGV[3])
local max = tonumber(ARGV[4])
local legacy_hash = ARGV[5]

-- Remove outdated entries
redis.call('ZREMRANGEBYSCORE', key, '-inf', '(' .. (now - ttl))

-- Add/update the current hash
redis.call('ZREM', key, legacy_hash)
redis.call('ZADD', key, now, hash)

-- If we exceed the max unique hashes, remove the oldest one
if redis.call('ZCARD', key) > max then
    redis.call('ZREMRANGEBYRANK', key, 0, 0)
end

redis.call('EXPIRE', key, ttl)

return 1
`,

	"SlidingWindowCounter": `
local current_key = KEYS[1]
local prev_key = KEYS[2]

local increment = tonumber(ARGV[1])
local weight = tonumber(ARGV[2])
local ttl = tonumber(ARGV[3])
local base_limit = tonumber(ARGV[4] or "-1")

local adaptive_enabled = tonumber(ARGV[5] or "0") == 1
local min_percent = tonumber(ARGV[6] or "0")
local max_percent = tonumber(ARGV[7] or "0")
local scale_factor = tonumber(ARGV[8] or "1")
local static_percent = tonumber(ARGV[9] or "0")
local positive = tonumber(ARGV[10] or "0")
local rwp_floor = tonumber(ARGV[11] or "0")

local limit = base_limit

if positive > 0 then
    local percent = static_percent
    if adaptive_enabled then
        local factor = math.min(1, math.log(positive + 1) / math.log(100) * scale_factor)
        percent = math.floor(min_percent + (max_percent - min_percent) * factor)
        percent = math.max(min_percent, math.min(max_percent, percent))
    end
    limit = math.floor(base_limit * (1 + percent / 100))
end

local current_cnt = tonumber(redis.call("GET", current_key) or 0)
local is_new_key = (current_cnt == 0)

-- RWP catch-up: if the bucket is below the RWP floor, bring it up to (floor - 1)
-- so the subsequent normal +1 increment lands exactly at the floor value.
-- This compensates for the attempts that were tolerated during RWP grace.
if rwp_floor > 0 and current_cnt < rwp_floor then
    local delta = rwp_floor - 1 - current_cnt
    if delta > 0 then
        current_cnt = redis.call("INCRBY", current_key, delta)
    end
end

if increment > 0 then
    current_cnt = redis.call("INCRBY", current_key, increment)
end

-- Set expiry when the key was freshly created during this call
if is_new_key and current_cnt > 0 then
    redis.call("EXPIRE", current_key, ttl)
end

local prev_cnt = tonumber(redis.call("GET", prev_key) or 0)
local total = current_cnt + (prev_cnt * weight)

local exceeded = 0
if limit >= 0 and total > limit then
    exceeded = 1
end

return {tostring(total), exceeded, tostring(limit)}
`,
}