/*
 * @Author: i@douxuefeng.cn
 * @Date: 2021-10-31 16:32:16
 * @LastEditTime: 2022-05-28 14:23:07
 * @LastEditors: i@douxuefeng.cn
 * @Description:
 * @FilePath: \go-utils\cache\redis.go
 */
package cache

import (
	"time"

	"github.com/gomodule/redigo/redis"
)

type redisPool struct {
	Pool *redis.Pool
}

type RedisOpt struct {
	Host        string
	Password    string
	Database    int
	MaxIdle     int
	MaxActive   int
	IdleTimeout int //second
}

var client *redisPool

func InitRedis(opt *RedisOpt) {
	client = new(redisPool)
	client.Pool = &redis.Pool{
		MaxIdle:     opt.MaxIdle,
		MaxActive:   opt.MaxActive,
		IdleTimeout: time.Duration(opt.IdleTimeout) * time.Second,
		Wait:        true,
		Dial: func() (redis.Conn, error) {
			return redis.Dial("tcp", opt.Host,
				redis.DialPassword(opt.Password),
				redis.DialDatabase(opt.Database),
				redis.DialConnectTimeout(time.Duration(opt.IdleTimeout)*time.Second),
				redis.DialReadTimeout(time.Duration(opt.IdleTimeout)*time.Second),
				redis.DialWriteTimeout(time.Duration(opt.IdleTimeout)*time.Second))
		},
	}
}

func NewRedisConn() *redisPool {
	return client
}

func (r *redisPool) Get(key string) (string, error) {
	conn := r.Pool.Get()
	defer conn.Close()
	return redis.String(conn.Do("GET", key))
}

//Set 设置一个过期时间值
func (r *redisPool) Set(key string, data string, timeout int64) error {
	conn := r.Pool.Get()
	defer conn.Close()
	_, err := conn.Do("SETEX", key, timeout, data)
	return err
}

func (r *redisPool) IsExist(key string) bool {
	conn := r.Pool.Get()
	defer conn.Close()
	a, _ := redis.Bool(conn.Do("EXISTS", key))
	return a
}

func (r *redisPool) Del(key string) error {
	conn := r.Pool.Get()
	defer conn.Close()
	if _, err := conn.Do("DEL", key); err != nil {
		return err
	}
	return nil
}

// hash