package goredis

import (
	"errors"
	"fmt"
	"reflect"
	"strconv"
	"strings"
	"time"

	"gitee.com/MikeDDD/gu/logs"
	"github.com/go-redis/redis/v8"
	"github.com/golang/protobuf/proto"
)

func ExpireCli(cli *RedisClienterInstance, key any, t time.Duration) (err error) {
	cmd := cli.Rc.Expire(cli.ctx(), fmt.Sprintf("%v:%v", cli.serverid, key), t)
	if cmd.Err() != nil && !errors.Is(cmd.Err(), redis.Nil) {
		logs.Error("Redis DoExpire error! key=%v, err=%v", key, cmd.Err())
		return cmd.Err()
	}

	return nil
}

func PersistCli(cli *RedisClienterInstance, key any) (err error) {
	cmd := cli.Rc.Persist(cli.ctx(), fmt.Sprintf("%v:%v", cli.serverid, key))
	if cmd.Err() != nil && !errors.Is(cmd.Err(), redis.Nil) {
		logs.Error("Redis DoPersist error! key=%v, err=%v", key, cmd.Err())
		return cmd.Err()
	}

	return nil
}

func TTLCli(cli *RedisClienterInstance, key any) (s time.Duration, err error) {
	cmd := cli.Rc.TTL(cli.ctx(), fmt.Sprintf("%v:%v", cli.serverid, key))
	if cmd.Err() != nil && !errors.Is(cmd.Err(), redis.Nil) {
		logs.Error("Redis DoTTL error! key=%v, err=%v", key, cmd.Err())
		return -1, cmd.Err()
	}

	return cmd.Val(), nil
}

func KeysCli(cli *RedisClienterInstance, key any) (field []string, err error) {
	res := cli.Rc.Keys(cli.ctx(), fmt.Sprintf("%v:%v", cli.serverid, key))
	if res.Err() != nil && !errors.Is(res.Err(), redis.Nil) {
		logs.Error("Redis Do KEYS error! key=%v, err=%v", key, res.Err())
		return field, res.Err()
	}

	for _, v := range res.Val() {
		field = append(field, strings.Replace(v, fmt.Sprintf("%v:", cli.serverid), "", -1))
	}

	return field, nil
}

func DelCli(cli *RedisClienterInstance, keys ...string) error {
	var tempKey []string
	for _, key := range keys {
		key = fmt.Sprintf("%v:%v", cli.serverid, key)
		tempKey = append(tempKey, key)
	}
	res := cli.Rc.Del(cli.ctx(), tempKey...)
	if res.Err() != nil && !errors.Is(res.Err(), redis.Nil) {
		logs.Error("Del fail", res.Err())
		return res.Err()
	}

	return nil
}

func ExistsCli(cli *RedisClienterInstance, key any) (bool, error) {
	res := cli.Rc.Exists(cli.ctx(), fmt.Sprintf("%v:%v", cli.serverid, key))
	if res.Err() != nil && !errors.Is(res.Err(), redis.Nil) {
		logs.Error("Redis Do EXISTS error! key=%v, err=%v", key, res.Err())
		return false, res.Err()
	}

	return res.Val() > 0, nil
}

func SetExtCli(cli *RedisClienterInstance, key any, p any) (err error) {
	bytes, err := proto.Marshal(p.(proto.Message))
	if err != nil {
		logs.Error("Protobuf Marshal error:%v", err)
		return err
	}

	res := cli.Rc.Set(cli.ctx(), fmt.Sprintf("%v:%v", cli.serverid, key), bytes, time.Hour*2)
	if res.Err() != nil && !errors.Is(res.Err(), redis.Nil) {
		logs.Error("Redis Do HEXISTS error! key=%v, err=%v", key, res.Err())
		return res.Err()
	}

	return nil
}

func SetCli(cli *RedisClienterInstance, key, value string) error {
	if res := cli.Rc.Set(cli.ctx(), fmt.Sprintf("%v:%v", cli.serverid, key), value, time.Second*1); res.Err() != nil &&
		!errors.Is(res.Err(), redis.Nil) {
		logs.Error("Redis set error! %v", res.Err())
		return res.Err()
	}
	return nil
}

func GetExtCli(cli *RedisClienterInstance, key any, p any) (exists bool, err error) {
	res := cli.Rc.Get(cli.ctx(), fmt.Sprintf("%v:%v", cli.serverid, key))
	if res.Err() != nil && !errors.Is(res.Err(), redis.Nil) {
		logs.Error("Redis Do GetExt error! key=%v, err=%v", key, res.Err())
		return false, res.Err()
	}

	if len(res.Val()) < 1 {
		return false, nil
	}

	err = proto.Unmarshal([]byte(res.Val()), p.(proto.Message))
	if err != nil {
		logs.Error("Redis Do GET Protobuf Unmarshal error! key=%v, err=%v", key, err)
		return false, err
	}
	return true, nil
}

func HGetCli(cli *RedisClienterInstance, key any, field any) string {
	res := cli.Rc.HGet(cli.ctx(), fmt.Sprintf("%v:%v", cli.serverid, key), fmt.Sprintf("%v", field))
	if res.Err() != nil && !errors.Is(res.Err(), redis.Nil) {
		logs.Error("HGet fail", res.Err())
		return ""
	}

	return res.Val()
}

func HGetExtCli(cli *RedisClienterInstance, key any, field any, p any) (exists bool, ok bool) {
	res := cli.Rc.HGet(cli.ctx(), fmt.Sprintf("%v:%v", cli.serverid, key), fmt.Sprintf("%v", field))
	if res.Err() != nil && !errors.Is(res.Err(), redis.Nil) {
		logs.Error("DoHGetExt fail:", res.Err())
		return false, false
	}

	if len(res.Val()) < 1 {
		return false, true
	}

	err := proto.Unmarshal([]byte(res.Val()), p.(proto.Message))
	if err != nil {
		logs.Error("Redis Do HGET Protobuf Unmarshal error! key=%v, field=%v, err=%v", key, field, err)
		return false, false
	}

	return true, true
}

func HSetCli(cli *RedisClienterInstance, key any, field any, p any) bool {
	_, err := cli.Rc.HSet(cli.ctx(), fmt.Sprintf("%v:%v", cli.serverid, key), fmt.Sprintf("%v", field), fmt.Sprintf("%v", p)).Result()
	if err != nil && !errors.Is(err, redis.Nil) {
		logs.Error("HSet fail", err, p)
		return false
	}
	return true
}

func HSetExtCli(cli *RedisClienterInstance, key any, field any, p any) (err error) {
	bytes, err := proto.Marshal(p.(proto.Message))
	if err != nil && !errors.Is(err, redis.Nil) {
		logs.Error("Redis Do HSET Protobuf Marshal error! key=%v, field=%v, err=%v", key, field, err)
		return err
	}

	res := cli.Rc.HSet(cli.ctx(), fmt.Sprintf("%v:%v", cli.serverid, key), field, bytes)
	if res.Err() != nil && !errors.Is(res.Err(), redis.Nil) {
		logs.Error("DoHSetExt fail", res.Err())
		return res.Err()
	}

	return nil
}

func HValsCli(cli *RedisClienterInstance, key any) (p []string, err error) {
	res := cli.Rc.HVals(cli.ctx(), fmt.Sprintf("%v:%v", cli.serverid, key))
	if res.Err() != nil && !errors.Is(res.Err(), redis.Nil) {
		logs.Error(res.Err())
		return nil, res.Err()
	}

	return res.Val(), nil
}

func HValsExtCli(cli *RedisClienterInstance, key any, p any) (err error) {
	res := cli.Rc.HVals(cli.ctx(), fmt.Sprintf("%v:%v", cli.serverid, key))
	if res.Err() != nil && !errors.Is(res.Err(), redis.Nil) {
		logs.Error(res.Err())
		return res.Err()
	}

	vs := res.Val()

	results := reflect.ValueOf(p)
	if results.Kind() == reflect.Ptr {
		results = results.Elem()
	}

	for _, v := range vs {
		newItem := reflect.New(getStructType(p)).Interface()
		err = proto.Unmarshal([]byte(v), newItem.(proto.Message))
		if err != nil {
			logs.Error("Redis Do HVALS Protobuf Unmarshal error! key=%v, err=%v", key, err)
			return
		}
		results.Set(reflect.Append(results, reflect.ValueOf(newItem)))
	}

	return nil
}

func HLenCli(cli *RedisClienterInstance, key any) (int64, error) {
	res := cli.Rc.HLen(cli.ctx(), fmt.Sprintf("%v:%v", cli.serverid, key))
	if res.Err() != nil && !errors.Is(res.Err(), redis.Nil) {
		logs.Error(res.Err())
		return 0, res.Err()
	}
	return res.Val(), nil
}

func HDelCli(cli *RedisClienterInstance, key string, fields ...string) error {
	if len(fields) == 0 {
		return nil
	}

	res := cli.Rc.HDel(cli.ctx(), fmt.Sprintf("%v:%v", cli.serverid, key), fields...)
	if res.Err() != nil && !errors.Is(res.Err(), redis.Nil) {
		logs.Error("HDel fail", res.Err())
		return res.Err()
	}

	return nil
}

func HExistsCli(cli *RedisClienterInstance, key any, field any) (bool, error) {
	res := cli.Rc.HExists(cli.ctx(), fmt.Sprintf("%v:%v", cli.serverid, key), fmt.Sprintf("%v", field))
	if res.Err() != nil && !errors.Is(res.Err(), redis.Nil) {
		logs.Error("Redis Do HEXISTS error! key=%v, err=%v", key, res.Err())
		return false, res.Err()
	}

	return res.Val(), nil
}

func HKeysCli(cli *RedisClienterInstance, key any) (field []string, err error) {
	res := cli.Rc.HKeys(cli.ctx(), fmt.Sprintf("%v:%v", cli.serverid, key))
	if res.Err() != nil && !errors.Is(res.Err(), redis.Nil) {
		logs.Error("Redis Do HKEYS error! key=%v, err=%v", key, res.Err())
		return field, res.Err()
	}

	return res.Val(), nil
}

func HIncrByCli(cli *RedisClienterInstance, rk, hk string, hv int64) int64 {
	res := cli.Rc.HIncrBy(cli.ctx(), fmt.Sprintf("%v:%v", cli.serverid, rk), hk, hv)
	if res.Err() != nil && !errors.Is(res.Err(), redis.Nil) {
		logs.Error("HIncrBy fail", res.Err())
		return -1
	}
	return res.Val()
}

func ZAddCli(cli *RedisClienterInstance, key any, score, params int64) (err error) {
	arg := &redis.Z{}
	arg.Score = float64(score)
	arg.Member = params

	res := cli.Rc.ZAdd(cli.ctx(), fmt.Sprintf("%v:%v", cli.serverid, key), arg)
	if res.Err() != nil && !errors.Is(res.Err(), redis.Nil) {
		logs.Error("ZAdd fail", res.Err())
		return res.Err()
	}

	return nil
}

func ZIncrByCli(cli *RedisClienterInstance, key any, score, params int64) (err error) {
	arg := &redis.Z{}
	arg.Score = float64(score)
	arg.Member = params

	res := cli.Rc.ZIncrBy(cli.ctx(), fmt.Sprintf("%v:%v", cli.serverid, key), float64(score), strconv.Itoa(int(params)))
	if res.Err() != nil && !errors.Is(res.Err(), redis.Nil) {
		logs.Error("ZIncr fail", res.Err())
		return res.Err()
	}

	return nil
}

func ZRevRangeWithScoresCli(cli *RedisClienterInstance, key any, start, stop int64) (err error, membersSlicePrt []int64, scoreSlicePrt []int64) {
	cmd := cli.Rc.ZRevRangeWithScores(cli.ctx(), fmt.Sprintf("%v:%v", cli.serverid, key), start, stop)
	if cmd.Err() != nil && !errors.Is(cmd.Err(), redis.Nil) {
		logs.Error("Redis ZRevRangeWithScores error! key=%v, start=%v, stop=%v, err=%v", key, start, stop, err)
		return
	}

	for _, val := range cmd.Val() {
		scoreSlicePrt = append(scoreSlicePrt, int64(val.Score))
		vm := val.Member.(string)
		value, _ := strconv.ParseInt(vm, 10, 64)
		membersSlicePrt = append(membersSlicePrt, value)
	}

	return
}

func ZRevRangeCli(cli *RedisClienterInstance, key string, start, stop int64) (err error, membersSlicePrt []int64) {
	cmd := cli.Rc.ZRevRange(cli.ctx(), fmt.Sprintf("%v:%v", cli.serverid, key), start, stop)
	if cmd.Err() != nil && !errors.Is(cmd.Err(), redis.Nil) {
		logs.Error("Redis ZRevRangeWithScores error! key=%v, start=%v, stop=%v, err=%v", key, start, stop, err)
		return
	}

	for _, val := range cmd.Val() {
		value, _ := strconv.ParseInt(val, 10, 64)
		membersSlicePrt = append(membersSlicePrt, value)
	}

	return
}

func ZRangeWithScoresCli(cli *RedisClienterInstance, key any, start, stop int64) (err error, membersSlicePrt []int64, scoreSlicePrt []int64) {
	cmd := cli.Rc.ZRangeWithScores(cli.ctx(), fmt.Sprintf("%v:%v", cli.serverid, key), start, stop)
	if cmd.Err() != nil && !errors.Is(cmd.Err(), redis.Nil) {
		logs.Error("Redis ZRangeWithScores error! key=%v, start=%v, stop=%v, err=%v", key, start, stop, err)
		return
	}

	for _, val := range cmd.Val() {
		scoreSlicePrt = append(scoreSlicePrt, int64(val.Score))
		vm := val.Member.(string)
		value, _ := strconv.ParseInt(vm, 10, 64)
		membersSlicePrt = append(membersSlicePrt, value)
	}

	return
}

func ZRemCli(cli *RedisClienterInstance, key any, member ...any) error {
	cmd := cli.Rc.ZRem(cli.ctx(), fmt.Sprintf("%v:%v", cli.serverid, key), member)
	if cmd.Err() != nil && !errors.Is(cmd.Err(), redis.Nil) {
		logs.Error("Redis DoZRem error! key=%v, err=%v", key, cmd.Err())
		return cmd.Err()
	}

	return nil
}

func ZRevRankCli(cli *RedisClienterInstance, key any, member any) (rank int64, err error) {
	cmd := cli.Rc.ZRevRank(cli.ctx(), fmt.Sprintf("%v:%v", cli.serverid, key), fmt.Sprintf("%v", member))
	if cmd.Err() == nil {
		return cmd.Val(), nil
	}
	if errors.Is(cmd.Err(), redis.Nil) {
		return -1, nil
	}
	return 0, cmd.Err()
}

func ZScoreCli(cli *RedisClienterInstance, key any, member any) (score int64, err error) {
	cmd := cli.Rc.ZScore(cli.ctx(), fmt.Sprintf("%v:%v", cli.serverid, key), fmt.Sprintf("%v", member))
	if cmd.Err() != nil && !errors.Is(cmd.Err(), redis.Nil) {
		logs.Error("Redis DoZRevRank error! key=%v, err=%v", key, cmd.Err())
		return 0, cmd.Err()
	}

	return int64(cmd.Val()), err
}

func ZCardCli(cli *RedisClienterInstance, key any) (cnt int64, err error) {
	cmd := cli.Rc.ZCard(cli.ctx(), fmt.Sprintf("%v:%v", cli.serverid, key))
	if cmd.Err() != nil && !errors.Is(cmd.Err(), redis.Nil) {
		logs.Error("Redis DoZRevRank error! key=%v, err=%v", key, cmd.Err())
		return 0, cmd.Err()
	}

	return int64(cmd.Val()), err
}

func ZRankCli(cli *RedisClienterInstance, key any, member any) (rank int64, err error) {
	cmd := cli.Rc.ZRank(cli.ctx(), fmt.Sprintf("%v:%v", cli.serverid, key), fmt.Sprintf("%v", member))
	if cmd.Err() != nil && !errors.Is(cmd.Err(), redis.Nil) {
		logs.Error("Redis ZRANK error! key=%v, err=%v", key, cmd.Err())
		return 0, cmd.Err()
	}

	return cmd.Val(), err
}

func ZUnionStoreCli(cli *RedisClienterInstance, dest, agg string, weight float64, keys ...string) error {
	zs := &redis.ZStore{Aggregate: agg}
	for _, k := range keys {
		zs.Keys = append(zs.Keys, fmt.Sprintf("%v:%v", cli.serverid, k))
		zs.Weights = append(zs.Weights, weight)
	}

	cmd := cli.Rc.ZUnionStore(cli.ctx(), dest, zs)
	if cmd.Err() != nil && !errors.Is(cmd.Err(), redis.Nil) {
		logs.Error("Redis ZUnionStore error! err=%v", cmd.Err())
		return cmd.Err()
	}

	return nil
}

func LPushExtCli(cli *RedisClienterInstance, key any, p any) (err error) {
	bytes, err := proto.Marshal(p.(proto.Message))
	if err != nil {
		logs.Error("Redis DoLPush Protobuf Marshal error! key=%v, err=%v", key, err)
		return err
	}

	cmd := cli.Rc.LPush(cli.ctx(), fmt.Sprintf("%v:%v", cli.serverid, key), bytes)
	if cmd.Err() != nil && !errors.Is(cmd.Err(), redis.Nil) {
		logs.Error("Redis DoLPush error! key=%v, err=%v", key, cmd.Err())
		return cmd.Err()
	}

	return nil
}

func RPushExtCli(cli *RedisClienterInstance, key any, p any) (err error) {
	bytes, err := proto.Marshal(p.(proto.Message))
	if err != nil {
		logs.Error("Redis DoLPush Protobuf Marshal error! key=%v, err=%v", key, err)
		return err
	}

	cmd := cli.Rc.RPush(cli.ctx(), fmt.Sprintf("%v:%v", cli.serverid, key), bytes)
	if cmd.Err() != nil && !errors.Is(cmd.Err(), redis.Nil) {
		logs.Error("Redis DoLPush error! key=%v, err=%v", key, cmd.Err())
		return cmd.Err()
	}

	return nil
}

func LRangeExtCli(cli *RedisClienterInstance, key any, slicePrt any, start, stop int64) (err error) {
	cmd := cli.Rc.LRange(cli.ctx(), fmt.Sprintf("%v:%v", cli.serverid, key), start, stop)
	if cmd.Err() != nil && !errors.Is(cmd.Err(), redis.Nil) {
		logs.Error("Redis DoLPush error! key=%v, err=%v", key, cmd.Err())
		return cmd.Err()
	}

	results := reflect.ValueOf(slicePrt)
	if results.Kind() == reflect.Ptr {
		results = results.Elem()
	}

	for _, v := range cmd.Val() {
		newItem := reflect.New(getStructType(slicePrt)).Interface()
		err = proto.Unmarshal([]byte(v), newItem.(proto.Message))
		if err != nil {
			logs.Error("Redis DoLRangeExt Protobuf Unmarshal error! key=%v, err=%v", key, err)
			return
		}
		results.Set(reflect.Append(results, reflect.ValueOf(newItem)))

	}

	return nil
}

func LLenCli(cli *RedisClienterInstance, key any) (int64, error) {
	cmd := cli.Rc.LLen(cli.ctx(), fmt.Sprintf("%v:%v", cli.serverid, key))
	if cmd.Err() != nil && !errors.Is(cmd.Err(), redis.Nil) {
		logs.Error("Redis DoLLen error! key=%v, err=%v", key, cmd.Err())
		return 0, cmd.Err()
	}

	return cmd.Val(), nil
}

func RPopCli(cli *RedisClienterInstance, key any) (rank string, err error) {
	cmd := cli.Rc.RPop(cli.ctx(), fmt.Sprintf("%v:%v", cli.serverid, key))
	if cmd.Err() != nil && !errors.Is(cmd.Err(), redis.Nil) {
		logs.Error("Redis DoRPop error! key=%v, err=%v", key, cmd.Err())
		return "", cmd.Err()
	}

	return cmd.Val(), err
}

func LPopCli(cli *RedisClienterInstance, key any) (rank string, err error) {
	cmd := cli.Rc.LPop(cli.ctx(), fmt.Sprintf("%v:%v", cli.serverid, key))
	if cmd.Err() != nil && !errors.Is(cmd.Err(), redis.Nil) {
		logs.Error("Redis DoRPop error! key=%v, err=%v", key, cmd.Err())
		return "", cmd.Err()
	}

	return cmd.Val(), err
}