package cache

import (
	"errors"
	"fmt"
	"github.com/fonchain_enterprise/utils/zap_log"
	"strconv"
	"time"

	"dubbo.apache.org/dubbo-go/v3/common/logger"
	"github.com/go-redis/redis"
)

// RedisClient Redis缓存客户端单例
var (
	RedisClient *redis.Client
)
var deleteScript = `
if redis.call("get",KEYS[1]) == ARGV[1] then
    return redis.call("del",KEYS[1])
else
    return 0
end
`

type RedisConfig struct {
	RedisDB     string
	RedisAddr   string
	RedisPw     string
	RedisDbName string
}

//LoadRedis 在中间件中初始化redis链接
func LoadRedis(configEnv RedisConfig) {
	db, _ := strconv.ParseUint(configEnv.RedisDbName, 10, 64)
	client := redis.NewClient(&redis.Options{
		Addr:     configEnv.RedisAddr,
		Password: configEnv.RedisPw,
		DB:       int(db),
	})
	_, err := client.Ping().Result()
	if err != nil {
		logger.Info(err)
		panic(err)
	}
	RedisClient = client
}

//LockConcurrency 锁死并发
func LockConcurrency(key string, value string, ms time.Duration) (bool, error) {
	fmt.Println(ms)
	setNx := RedisClient.SetNX(key, value, ms)

	result, err := setNx.Result()

	if err != nil {
		zap_log.Error(fmt.Sprintf("锁死加解密的时候，redis 失效,err%s,%v", key, err))
		//panic(err)
		return false, err
	}

	if result {
		zap_log.Info(fmt.Sprintf("新增key存在，设置成功%s", key))
	} else {
		zap_log.Info(fmt.Sprintf("新增key已存在，设置失败%s", key))
	}

	zap_log.Info(fmt.Sprintf("日志%v%v%s", result, err, key))

	if setNx.Val() == false {
		return false, errors.New("已经被人锁定")
	}

	return true, nil

}

func Release(key, value string) error {
	result, err := RedisClient.Eval(deleteScript, []string{key}, value).Result()
	if err != nil {
		return err
	}

	// 判断Lua脚本执行的结果
	if result == int64(1) {
		fmt.Println("Lock released.")
		return nil
	} else {
		fmt.Println("Failed to release lock, or lock was not held by this client.")
		return errors.New("释放失败也可能是超时自动解锁了,请您刷新")
	}
}