// 原子性設(shè)置鎖：key不存在才設(shè)置，同時(shí)設(shè)置過(guò)期時(shí)間，返回是否成功
ok, err := redisClient.SetNX(ctx, lockKey, requestID, expireTime)
// 或更靈活的SET命令（支持更多參數(shù)）
status, err := redisClient.Do(ctx, "SET", lockKey, requestID, "NX", "PX", expireTime.Milliseconds())

package redislock

import (
	"context"
	"errors"
	"fmt"
	"time"

	redisv6 "code.byted.org/kv/redis-v6"
	"github.com/google/uuid"
)

// RedisLock Redis分布式鎖結(jié)構(gòu)體
type RedisLock struct {
	redisClient  redisv6.Client  // Redis客戶端
	lockKey      string          // 鎖的Key
	requestID    string          // 唯一請(qǐng)求ID，用于標(biāo)識(shí)鎖的持有者
	expireTime   time.Duration   // 鎖的過(guò)期時(shí)間
	renewalTime  time.Duration   // 鎖的續(xù)約間隔時(shí)間
	renewalTicker *time.Ticker   // 續(xù)約定時(shí)器
	stopChan     chan struct{}   // 停止續(xù)約的信號(hào)通道
	ctx          context.Context // 上下文
	cancel       context.CancelFunc// 上下文取消函數(shù)
}

// NewRedisLock 創(chuàng)建Redis分布式鎖實(shí)例
// lockKey：鎖的唯一標(biāo)識(shí)
// expireTime：鎖的過(guò)期時(shí)間（建議30秒左右）
// renewalTime：續(xù)約間隔時(shí)間（建議為過(guò)期時(shí)間的1/3，如10秒）
func NewRedisLock(client redisv6.Client, lockKey string, expireTime, renewalTime time.Duration) *RedisLock {
	// 生成唯一請(qǐng)求ID（用于標(biāo)識(shí)當(dāng)前鎖持有者，避免誤刪其他客戶端的鎖）
	requestID := fmt.Sprintf("lock-%s-%s", uuid.New().String(), time.Now().Format("20060102150405"))
	ctx, cancel := context.WithCancel(context.Background())
	return &RedisLock{
		redisClient:  client,
		lockKey:      lockKey,
		requestID:    requestID,
		expireTime:   expireTime,
		renewalTime:  renewalTime,
		stopChan:     make(chan struct{}, 1),
		ctx:          ctx,
		cancel:       cancel,
	}
}

// Acquire 嘗試獲取分布式鎖，并啟動(dòng)自動(dòng)續(xù)約
func (l *RedisLock) Acquire() (bool, error) {
	// 原子性獲取鎖：SET NX PX（key不存在時(shí)設(shè)置，同時(shí)設(shè)置毫秒級(jí)過(guò)期時(shí)間）
	ok, err := l.redisClient.SetNX(l.ctx, l.lockKey, l.requestID, l.expireTime)
	if err != nil {
		return false, fmt.Errorf("獲取鎖失?。?w", err)
	}
	if !ok {
		// 鎖已被其他客戶端持有
		return false, nil
	}

	// 獲取鎖成功，啟動(dòng)自動(dòng)續(xù)約協(xié)程（看門狗）
	l.startRenewal()
	return true, nil
}

// startRenewal 啟動(dòng)鎖的自動(dòng)續(xù)約機(jī)制
func (l *RedisLock) startRenewal() {
	// 初始化定時(shí)器，每隔renewalTime執(zhí)行一次續(xù)約
	l.renewalTicker = time.NewTicker(l.renewalTime)
	go func() {
		defer l.renewalTicker.Stop()
		for {
			select {
			case <-l.ctx.Done():
				// 上下文取消，停止續(xù)約
				return
			case <-l.stopChan:
				// 主動(dòng)停止續(xù)約
				return
			case <-l.renewalTicker.C:
				// 執(zhí)行續(xù)約操作
				renewed, err := l.renewLock()
				if err != nil {
					fmt.Printf("鎖續(xù)約失?。?v\n", err)
					return
				}
				if !renewed {
					fmt.Printf("鎖已失效或被其他客戶端持有，停止續(xù)約\n")
					return
				}
				fmt.Printf("鎖續(xù)約成功，過(guò)期時(shí)間延長(zhǎng)至%v\n", l.expireTime)
			}
		}
	}()
}

// renewLock 延長(zhǎng)鎖的過(guò)期時(shí)間（原子操作）
func (l *RedisLock) renewLock() (bool, error) {
	// 使用Lua腳本保證續(xù)約的原子性：僅當(dāng)鎖的持有者是當(dāng)前客戶端時(shí)，才延長(zhǎng)過(guò)期時(shí)間
	renewScript := `
		if redis.call('GET', KEYS[1]) == ARGV[1] then
			return redis.call('PEXPIRE', KEYS[1], ARGV[2])
		else
			return 0
		end
	`
	// 執(zhí)行Lua腳本
	result, err := l.redisClient.Eval(
		l.ctx,
		renewScript,
		[]string{l.lockKey},          // KEYS[1]：鎖的Key
		l.requestID,                  // ARGV[1]：當(dāng)前客戶端的請(qǐng)求ID
		l.expireTime.Milliseconds(),  // ARGV[2]：新的過(guò)期時(shí)間（毫秒）
	)
	if err != nil {
		return false, fmt.Errorf("執(zhí)行續(xù)約Lua腳本失?。?w", err)
	}

	// 腳本返回1表示續(xù)約成功，0表示續(xù)約失?。ㄦi已失效或被其他客戶端持有）
	resultInt, ok := result.(int64)
	if !ok {
		return false, errors.New("續(xù)約腳本返回結(jié)果格式異常")
	}

	return resultInt == 1, nil
}

// 錯(cuò)誤示例：兩步操作非原子性
func (l *RedisLock) WrongRelease() error {
	// 1. 先獲取鎖的當(dāng)前值，判斷是否為當(dāng)前客戶端的requestID
	lockValue, err := l.redisClient.Get(l.ctx, l.lockKey)
	if err != nil {
		return err
	}
	if lockValue != l.requestID {
		return errors.New("鎖非當(dāng)前客戶端持有")
	}
	// 2. 再刪除鎖的Key
	return l.redisClient.Del(l.ctx, l.lockKey)
}

// 繼續(xù)在RedisLock結(jié)構(gòu)體中補(bǔ)充解鎖方法
// Release 安全釋放分布式鎖（原子操作）
func (l *RedisLock) Release() error {
	// 停止自動(dòng)續(xù)約
	l.stopChan <- struct{}{}
	l.cancel()

	// 解鎖Lua腳本：先校驗(yàn)鎖的持有者，再刪除鎖，保證原子性
	unlockScript := `
		if redis.call('GET', KEYS[1]) == ARGV[1] then
			return redis.call('DEL', KEYS[1])
		else
			return 0
		end
	`

	// 執(zhí)行Lua腳本
	result, err := l.redisClient.Eval(
		l.ctx,
		unlockScript,
		[]string{l.lockKey},  // KEYS[1]：鎖的Key
		l.requestID,          // ARGV[1]：當(dāng)前客戶端的請(qǐng)求ID
	)
	if err != nil {
		return fmt.Errorf("執(zhí)行解鎖Lua腳本失?。?w", err)
	}

	// 解析腳本返回結(jié)果
	resultInt, ok := result.(int64)
	if !ok {
		return errors.New("解鎖腳本返回結(jié)果格式異常")
	}

	if resultInt == 0 {
		return errors.New("解鎖失?。烘i已失效或非當(dāng)前客戶端持有")
	}

	fmt.Printf("鎖釋放成功\n")
	return nil
}

// 采用UUID+時(shí)間戳的方式，保證全局唯一性
requestID := fmt.Sprintf("lock-%s-%s", uuid.New().String(), time.Now().Format("20060102150405"))

// 原子性設(shè)置鎖時(shí)，將requestID作為鎖的值存入Redis
ok, err := l.redisClient.SetNX(l.ctx, l.lockKey, l.requestID, l.expireTime)

// 在Lua腳本中，通過(guò)ARGV[1]傳入requestID，與鎖的值進(jìn)行比對(duì)
if redis.call('GET', KEYS[1]) == ARGV[1] then
    return redis.call('DEL', KEYS[1])
else
    return 0
end