package redislock

import (
    "errors"
    "time"

    "github.com/go-redis/redis"
)

var (
    REDIS_LOCK_EXIST              error = errors.New("鎖已經(jīng)存在")
    DEL_REDIS_LOCK_ERROR          error = errors.New("解鎖失敗")
    REDIS_LOCK_WAIT_TIME_OUT_EXIT error = errors.New("嘗試獲取鎖等待超時(shí)并退出")
)

type RedisConfig struct {
    RedisAddr            string
    Password             string
    Db                   int
    RedisLockTimeOut     time.Duration //鎖的有效時(shí)間，超時(shí)釋放
    RedisLockWaitTimeOut time.Duration //獲取鎖阻塞時(shí)間，超時(shí)放棄
}

type RedisLock struct {
    redisClient          *redis.Client
    redisLockTimeOut     time.Duration
    redisLockWaitTimeOut time.Duration
}

func newRedisLock(redisConfig *RedisConfig) *RedisLock {
    redisClient := redis.NewClient(&redis.Options{
        Addr:               redisConfig.RedisAddr,
        Password:           redisConfig.Password,
        DB:                 redisConfig.Db,
        PoolSize:           30,
        DialTimeout:        2 * time.Second,
        ReadTimeout:        2 * time.Second,
        WriteTimeout:       2 * time.Second,
        PoolTimeout:        10 * time.Second,
        IdleTimeout:        3600 * time.Second,
        IdleCheckFrequency: 300 * time.Second,
    })
    return &RedisLock{
        redisClient:          redisClient,
        redisLockTimeOut:     redisConfig.RedisLockTimeOut,
        redisLockWaitTimeOut: redisConfig.RedisLockWaitTimeOut,
    }
}

func (this *RedisLock) Lock(key string) error {
    val := this.redisClient.SetNX(key+".lock", time.Now().Unix(), this.redisLockTimeOut)
    if val.Val() == true { //成功獲取到鎖
        return nil
    } else {
        return REDIS_LOCK_EXIST //鎖已經(jīng)存在
    }
}

func (this *RedisLock) Unlock(key string) error {
    val := this.redisClient.Del(key + ".lock")
    if val.Val() == 0 {
        log.Errorf("key = %s err = %s", key, DEL_REDIS_LOCK_ERROR)
        return DEL_REDIS_LOCK_ERROR //解鎖失敗
    }
    return nil
}

func (this *RedisLock) TryGetLock(key string) error {
    nowTime := time.Now().Unix()
    for {
        err := this.Lock(key)
        if err == nil { //成功獲取到鎖就直接返回
            return nil
        } else {// 否則阻塞一段時(shí)間，期間每隔0.2s嘗試獲取鎖，超時(shí)退出
            if err = this.IsWaitTimeOut(nowTime); err == nil {
                time.Sleep(200 * time.Millisecond)
            } else {
                return err
            }
        }
    }
}

func (this *RedisLock) IsWaitTimeOut(nowTime int64) error {
    //判斷是否等待超時(shí)
    if time.Now().Unix() >= nowTime+int64(this.redisLockWaitTimeOut/time.Second) {
        return REDIS_LOCK_WAIT_TIME_OUT_EXIT //嘗試獲取鎖等待超時(shí)并退出
    }
    return nil
}