package redis

import (
	"context"
	"encoding/json"
	"fmt"
	"github.com/go-redis/redis/v8"
	"time"
	"zhiyuan/pkg/config"
	"zhiyuan/pkg/logger"
)

var rdb *redis.Client
var ctx = context.Background()
var Z *redis.Z

func Setup() {
	rdb = redis.NewClient(&redis.Options{
		Addr:     config.Cfg.Redis.Host,
		Password: config.Cfg.Redis.Password,
		DB:       0, // use default DB
	})
	rdb.Ping(ctx)
}

func getKey(key string) string {
	return config.Cfg.Redis.Prefix + key
}

func Set(key string, data interface{}, sec int) error {
	jsonData, err := json.Marshal(data)
	if err != nil {
		return err
	}
	err = rdb.Set(ctx, getKey(key), string(jsonData), time.Duration(sec)*time.Second).Err()
	if err != nil {
		logger.Sugar.Error(err.Error())
		return err
	}
	return nil
}

func SetBasic(key string, data interface{}, sec int) error {
	err := rdb.Set(ctx, getKey(key), data, time.Duration(sec)*time.Second).Err()
	if err != nil {
		logger.Sugar.Error(err.Error())
		return err
	}
	return nil
}

func Get(key string) (string, error) {
	val, err := rdb.Get(ctx, getKey(key)).Result()
	if err != nil {
		logger.Sugar.Error("Get key[" + key + "] error：" + err.Error())
		return "", err
	}
	return val, nil
}

func LPush(key string, val []interface{}) error {
	err := rdb.LPush(ctx, getKey(key), val).Err()
	if err != nil {
		logger.Sugar.Error(err.Error())
		return err
	}
	return nil
}

func HSet(key string, val []interface{}, sec int) error {
	err := rdb.HSet(ctx, getKey(key), val).Err()
	Expire(key, sec)
	if err != nil {
		logger.Sugar.Error(err.Error())
		return err
	}
	return nil
}

func HGet(key string, field string) (string, error) {
	val, err := rdb.HGet(ctx, getKey(key), field).Result()
	if err != nil {
		logger.Sugar.Error(err.Error())
		return "", err
	}
	return val, nil
}

func HGetAll(key string) (map[string]string, error) {
	val, err := rdb.HGetAll(ctx, getKey(key)).Result()
	if err != nil {
		logger.Sugar.Error(err.Error())
		return nil, err
	}
	return val, nil
}

func SAdd(key string, val []interface{}, sec int) {
	err := rdb.SAdd(ctx, getKey(key), val).Err()
	Expire(getKey(key), sec)
	if err != nil {
		logger.Sugar.Error(err.Error())
	}
}

func SMembers(key string) ([]string, error) {
	val, err := rdb.SMembers(ctx, getKey(key)).Result()
	if err != nil {
		logger.Sugar.Error(err.Error())
		return nil, err
	}
	return val, nil
}

func Del(keys string) {
	rdb.Del(ctx, getKey(keys))
}

func Expire(key string, sec int) {
	if sec != -1 {
		rdb.Expire(ctx, getKey(key), time.Duration(sec)*time.Second)
	}
}

func ExpireAt(key string, tm time.Time) {
	rdb.ExpireAt(ctx, getKey(key), tm)
}

func TTL(key string) (time.Duration, error) {
	expire, err := rdb.TTL(ctx, getKey(key)).Result()
	fmt.Printf("expire=%v err=%v\n", expire, err)
	return expire, err
}