package redisController

import (
	"appPlatform/overall"
	"context"
	"fmt"
	"time"

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

type RedisStoreType struct {
	Expiration time.Duration
	PreKey     string
	Context    context.Context
	RedisDb    *redis.Client
}

// 启动redis
func InitRedis(redisClient *redis.Client) *RedisStoreType {
	var redisStoreType RedisStoreType
	redisStoreType.Expiration = time.Second * 300
	redisStoreType.PreKey = fmt.Sprintf("%v:", overall.CONSTANT_CONFIG.RedisPrefixStr.PreFix)
	redisStoreType.Context = context.Background()
	redisStoreType.RedisDb = redisClient
	return &redisStoreType
}

// 设置键前缀
func (r *RedisStoreType) SetRedisPrefix(prefix string) {
	r.PreKey = prefix
}

// 设置过期时间
func (r *RedisStoreType) SetRedisTime(timeDate int64) {
	r.Expiration = time.Second * time.Duration(timeDate)
}
func (r *RedisStoreType) SetRedisTimes(timeDate time.Duration) {
	r.Expiration = time.Second * timeDate
}

// 获取数据库配置
// func (r *RedisStoreType) ConfigGet(key string) (interface{}, error) {
func (r *RedisStoreType) ConfigGet(key string) (map[string]string, error) {
	err := r.RedisDb.ConfigGet(r.Context, key)
	return err.Val(), err.Err()
}

// 设置字符串
func (r *RedisStoreType) Set(key string, value string) bool {
	err := r.RedisDb.Set(r.Context, key, value, r.Expiration).Err()
	// fmt.Printf("设置字符串:%v\n", err)

	if err != nil {
		return false
	}
	return true
}

// 获取字符串
func (r *RedisStoreType) Get(key string) (bool, string) {
	err := r.RedisDb.Get(r.Context, key)
	if err.Err() != nil {
		return false, ""
	}
	return true, err.Val()
}

/*
*Keys 命令用于查找所有符合给定模式 pattern 的 key 。。
 */
func (r *RedisStoreType) Keys(key string) (val []string, err error) {
	val, err = r.RedisDb.Keys(r.Context, key).Result()
	return
}

/*
*以秒为单位返回 key 的剩余过期时间
 */
func (r *RedisStoreType) TTl(key string) (val int64, err error) {
	redisVal := r.RedisDb.TTL(r.Context, key)
	err = redisVal.Err()
	val = redisVal.Val().Microseconds() / 1000000
	return
}
func (r *RedisStoreType) PTTl(key string) (val time.Duration, err error) {
	redisVal := r.RedisDb.PTTL(r.Context, key)
	err = redisVal.Err()
	val = time.Duration(redisVal.Val().Microseconds())
	return
}

/*
*返回数据键类型
 */
func (r *RedisStoreType) KeyType(key string) (val string, err error) {
	redisObject := r.RedisDb.Type(r.Context, key)
	err = redisObject.Err()
	val = redisObject.Val()
	return
}

// 删除键
func (r *RedisStoreType) DelKey(key string) bool {
	err := r.RedisDb.Del(r.Context, key).Err()
	if err != nil {
		return false
	}
	return true
}

//哈希操作
/*
获取单个哈希键值
@hashName			集合名称
@hashKey			哈希键
callback
	errs			状态
	hashVal			获得值
*/
func (r *RedisStoreType) HashGet(hashName, hashKey string) (errs bool, hashVal string) {
	err := r.RedisDb.HGet(r.Context, hashName, hashKey)
	if err.Err() != nil {
		return false, ""
	}
	return true, err.Val()
}

/*
为哈希表中的字段赋值 。			单一设置
@hashName			集合名称
@hashKey			哈希键
@hashVal			要添加的值
*/
func (r *RedisStoreType) HashSet(hashName, hashKey, hashVal string) bool {
	err := r.RedisDb.HSet(r.Context, hashName, hashKey, hashVal).Err()
	if err != nil {
		return false
	}
	if r.Expiration == 0 {
		r.RedisDb.Persist(r.Context, hashName)
	} else {
		r.RedisDb.PExpire(r.Context, hashName, r.Expiration)
	}
	// global.GVA_REDIS.PExpire(r.Context, hashName, r.Expiration)
	return true
}

/*
同时将多个 field-value (字段-值)对设置到哈希表中。
@hashName			集合名称
@hashVal			要添加的键与值
*/
func (r *RedisStoreType) HashMsetAdd(hashName string, hashVal map[string]interface{}) bool {
	// rdb := RedisInit()
	err := r.RedisDb.HMSet(r.Context, hashName, hashVal).Err()
	// fmt.Printf("错误sss=========》%v=====2====》%v\n", err, hashVal)
	// err := rdb.HMSet(ctx, "userfg", hashVal).Err()
	if err != nil {
		return false
	}
	if r.Expiration == 0 {
		r.RedisDb.Persist(r.Context, hashName)
	} else {
		r.RedisDb.PExpire(r.Context, hashName, r.Expiration)
	}

	return true
}
func (r *RedisStoreType) HashMsetAddinterface(hashName string, hashVal interface{}) bool {
	// rdb := RedisInit()
	err := r.RedisDb.HMSet(r.Context, hashName, hashVal).Err()
	// fmt.Printf("错误sss=========》%v=====2====》%v\n", err, hashVal)
	// err := rdb.HMSet(ctx, "userfg", hashVal).Err()
	if err != nil {
		return false
	}
	if r.Expiration == 0 {
		r.RedisDb.Persist(r.Context, hashName)
	} else {
		r.RedisDb.PExpire(r.Context, hashName, r.Expiration)
	}

	return true
}
func (r *RedisStoreType) HashMsetAddAry(hashName string, hashVal []map[string]interface{}) bool {
	// rdb := RedisInit()
	err := r.RedisDb.HMSet(r.Context, hashName, hashVal).Err()
	// err := rdb.HMSet(ctx, "userfg", hashVal).Err()
	if err != nil {
		return false
	}
	if r.Expiration == 0 {
		r.RedisDb.Persist(r.Context, hashName)
	} else {
		r.RedisDb.PExpire(r.Context, hashName, r.Expiration)
	}
	// global.GVA_REDIS.PExpire(r.Context, hashName, r.Expiration)
	// fmt.Printf("错误sss=========》%v\n", hashVal)
	return true
}

/*
返回哈希表中，所有的字段和值。
@hashName			集合名称
@hashKey			哈希键
*/
func (r *RedisStoreType) HashGetAll(hashName string) (map[string]string, bool) {
	// rdb := RedisInit()
	// fmt.Printf("strKEy:===>%v\n", hashName)
	val, err := r.RedisDb.HGetAll(r.Context, hashName).Result()
	// fmt.Printf("strKEy:==1=>%v==1=>%v\n", val, err)
	if err != nil {
		return val, false
	}
	if len(val) == 0 {
		return val, false
	}
	return val, true
}

//Redis 列表(List)

/*
*
Linsert 命令用于在列表的元素前或者后插入元素。当指定元素不存在于列表中时，不执行任何操作。
当列表不存在时，被视为空列表，不执行任何操作。
如果 key 不是列表类型，返回一个错误。
@key		列表
@op			插入状态 (1:在pivot之后；2：在pivot之前)
@pivot		定位值
@value		要插入值
*/
func (r *RedisStoreType) Linsert(key string, op int, pivot, value interface{}) (int64, bool) {
	BeforeOrAfter := "BEFORE"
	if op != 1 {
		BeforeOrAfter = "AFTER"
	}
	linsert, linsertErr := r.RedisDb.LInsert(r.Context, key, BeforeOrAfter, pivot, value).Result()
	if linsertErr != nil {
		return 0, false
	}
	if r.Expiration == 0 {
		r.RedisDb.Persist(r.Context, key)
	} else {
		r.RedisDb.PExpire(r.Context, key, r.Expiration)
	}
	return linsert, true
}

/*
*
Lindex 命令用于通过索引获取列表中的元素。你也可以使用负数下标，以 -1 表示列表的最后一个元素， -2 表示列表的倒数第二个元素，以此类推。
@key		列表
@index		索引
*/
func (r *RedisStoreType) Lindex(key string, index int64) (val string, err error) {
	val, err = r.RedisDb.LIndex(r.Context, key, index).Result()
	return
}

/*
*
Llen 命令用于返回列表的长度。 如果列表 key 不存在，则 key 被解释为一个空列表，返回 0 。 如果 key 不是列表类型，返回一个错误。
@key		列表
*/
func (r *RedisStoreType) Llen(key string) (val int64, err error) {
	val, err = r.RedisDb.LLen(r.Context, key).Result()
	return
}

/*
*
Lpop 命令用于移除并返回列表的第一个元素。
@key		列表
*/
func (r *RedisStoreType) Lpop(key string) (val string, err error) {
	val, err = r.RedisDb.LPop(r.Context, key).Result()
	return
}

/*
*
Lpush 命令将一个或多个值插入到列表头部。 如果 key 不存在，一个空列表会被创建并执行 LPUSH 操作。 当 key 存在但不是列表类型时，返回一个错误。
@key		列表
@value     要插入的字符串
*/
func (r *RedisStoreType) Lpush(key string, value ...interface{}) (val int64, err error) {
	val, err = r.RedisDb.LPush(r.Context, key, value).Result()
	if r.Expiration == 0 {
		r.RedisDb.Persist(r.Context, key)
	} else {
		r.RedisDb.PExpire(r.Context, key, r.Expiration)
	}
	return
}

/*
*
Lpushx 将一个值插入到已存在的列表头部，列表不存在时操作无效。
@key		列表
@value     要插入的字符串
*/
func (r *RedisStoreType) Lpushx(key, value string) (val int64, err error) {
	val, err = r.RedisDb.LPushX(r.Context, key, value).Result()
	if r.Expiration == 0 {
		r.RedisDb.Persist(r.Context, key)
	} else {
		r.RedisDb.PExpire(r.Context, key, r.Expiration)
	}
	return
}

/*
*
Lrange 返回列表中指定区间内的元素，区间以偏移量 START 和 END 指定。 其中 0 表示列表的第一个元素， 1 表示列表的第二个元素，以此类推。 你也可以使用负数下标，以 -1 表示列表的最后一个元素， -2 表示列表的倒数第二个元素，以此类推。
@key		列表
@start		起始值
@stop		结束值
*/
func (r *RedisStoreType) Lrange(key string, start, stop int64) (val []string, err error) {
	val, err = r.RedisDb.LRange(r.Context, key, start, stop).Result()
	return
}

/*
*
Lrem 根据参数 COUNT 的值，移除列表中与参数 VALUE 相等的元素。
COUNT 的值可以是以下几种：

	count > 0 : 从表头开始向表尾搜索，移除与 VALUE 相等的元素，数量为 COUNT 。
	count < 0 : 从表尾开始向表头搜索，移除与 VALUE 相等的元素，数量为 COUNT 的绝对值。
	count = 0 : 移除表中所有与 VALUE 相等的值。

@start  = COUNT
@key		列表
*/
func (r *RedisStoreType) Lrem(key string, start int64, value ...interface{}) (val int64, err error) {
	val, err = r.RedisDb.LRem(r.Context, key, start, value).Result()
	return
}

/*
*
Redis Lset 通过索引来设置元素的值。

当索引参数超出范围，或对一个空列表进行 LSET 时，返回一个错误。
@key		列表
@indexes		索引值
*/
func (r *RedisStoreType) Lset(key string, indexes int64, value ...interface{}) (val string, err error) {
	val, err = r.RedisDb.LSet(r.Context, key, indexes, value).Result()
	if r.Expiration == 0 {
		r.RedisDb.Persist(r.Context, key)
	} else {
		r.RedisDb.PExpire(r.Context, key, r.Expiration)
	}
	return
}

/*
*
Ltrim 对一个列表进行修剪(trim)，就是说，让列表只保留指定区间内的元素，不在指定区间之内的元素都将被删除。

下标 0 表示列表的第一个元素，以 1 表示列表的第二个元素，以此类推。 你也可以使用负数下标，以 -1 表示列表的最后一个元素， -2 表示列表的倒数第二个元素，以此类推。
@key		列表
@start		起始值
@stop		结束值
*/
func (r *RedisStoreType) Ltrim(key string, start, stop int64) (val string, err error) {
	val, err = r.RedisDb.LTrim(r.Context, key, start, stop).Result()
	return
}

/*
*
Rpop 命令用于移除列表的最后一个元素，返回值为移除的元素。
@key		列表
*/
func (r *RedisStoreType) Rpop(key string) (val string, err error) {
	val, err = r.RedisDb.RPop(r.Context, key).Result()
	return
}

/*
*
Rpoplpush 命令用于移除列表的最后一个元素，并将该元素添加到另一个列表并返回。
@sourceKey		源列表
@newKey		目标列表
*/
func (r *RedisStoreType) Rpoplpush(sourceKey, newKey string) (val string, err error) {
	val, err = r.RedisDb.RPopLPush(r.Context, sourceKey, newKey).Result()
	return
}

/*
*
Rpush 命令用于将一个或多个值插入到列表的尾部(最右边)。
如果列表不存在，一个空列表会被创建并执行 RPUSH 操作。 当列表存在但不是列表类型时，返回一个错误。
@key		列表
@value     要插入的字符串
*/
func (r *RedisStoreType) Rpush(key string, value ...interface{}) (val int64, err error) {
	val, err = r.RedisDb.RPush(r.Context, key, value).Result()
	if r.Expiration == 0 {
		r.RedisDb.Persist(r.Context, key)
	} else {
		r.RedisDb.PExpire(r.Context, key, r.Expiration)
	}
	return
}

/*
*
Rpushx 命令用于将一个值插入到已存在的列表尾部(最右边)。如果列表不存在，操作无效。
@key		列表
@value     要插入的字符串
*/
func (r *RedisStoreType) Rpushx(key string, value ...interface{}) (val int64, err error) {
	val, err = r.RedisDb.RPushX(r.Context, key, value).Result()
	if r.Expiration == 0 {
		r.RedisDb.Persist(r.Context, key)
	} else {
		r.RedisDb.PExpire(r.Context, key, r.Expiration)
	}
	return
}

/*
*
Blpop 命令移出并获取列表的第一个元素， 如果列表没有元素会阻塞列表直到等待超时或发现可弹出元素为止。
@key		列表
*/
func (r *RedisStoreType) Blpop(key string) (val []string, err error) {
	val, err = r.RedisDb.BLPop(r.Context, r.Expiration, key).Result()
	return
}

/*
*
Brpop 命令移出并获取列表的最后一个元素， 如果列表没有元素会阻塞列表直到等待超时或发现可弹出元素为止。
@key		列表
*/
func (r *RedisStoreType) Brpop(key string) (val []string, err error) {
	val, err = r.RedisDb.BRPop(r.Context, r.Expiration, key).Result()
	return
}

/*
*
Brpoplpush 命令从列表中取出最后一个元素，并插入到另外一个列表的头部； 如果列表没有元素会阻塞列表直到等待超时或发现可弹出元素为止。
@source		源列表
@destination		目标列表
*/
func (r *RedisStoreType) Brpoplpush(source, destination string) (val string, err error) {
	val, err = r.RedisDb.BRPopLPush(r.Context, source, destination, r.Expiration).Result()
	return
}

/*
Redis 键(key)
Redis 键命令用于管理 redis 的键。
*/

/*
Redis SCAN 命令
Redis Scan 命令用于迭代数据库中的数据库键。

SCAN 命令是一个基于游标的迭代器，每次被调用之后， 都会向用户返回一个新的游标， 用户在下次迭代时需要使用这个新游标作为 SCAN 命令的游标参数， 以此来延续之前的迭代过程。

SCAN 返回一个包含两个元素的数组， 第一个元素是用于进行下一次迭代的新游标， 而第二个元素则是一个数组， 这个数组中包含了所有被迭代的元素。如果新游标返回 0 表示迭代已结束。

相关命令：

	SSCAN 命令用于迭代集合键中的元素。
	HSCAN 命令用于迭代哈希键中的键值对。
	ZSCAN 命令用于迭代有序集合中的元素（包括元素成员和元素分值）。
*/

func (r *RedisStoreType) Scan(cursor uint64, match string, count int64) (keys []string, cursores uint64, err error) {
	keys, cursores, err = r.RedisDb.Scan(r.Context, cursor, match, count).Result()
	return
}

/*
集合操作
*/
/**
@ 作者: 秦东
@ 时间: 2023-11-14 09:44:32
@ 功能: Redis Smembers 命令返回集合中的所有的成员。 不存在的集合 key 被视为空集合。
@ 参数
		#key  键
@ 返回值
		#
@ 方法原型
		#
*/
func (r *RedisStoreType) Smembers(key string) ([]string, error) {
	redisClient := r.RedisDb.SMembers(r.Context, key)
	return redisClient.Val(), redisClient.Err()
}

/*
*
@ 作者: 秦东
@ 时间: 2023-11-14 09:47:54
@ 功能: Redis Sadd 命令将一个或多个成员元素加入到集合中，已经存在于集合的成员元素将被忽略。

	假如集合 key 不存在，则创建一个只包含添加的元素作成员的集合。

	当集合 key 不是集合类型时，返回一个错误。

	注意：在 Redis2.4 版本以前， SADD 只接受单个成员值。

@ 参数

	#

@ 返回值

	#

@ 方法原型

	#
*/
func (r *RedisStoreType) Sadd(key string, val []string) (msg []string) {
	if len(val) > 0 {
		for _, v := range val {
			redisClient := r.RedisDb.SAdd(r.Context, key, v)
			if redisClient.Err() == nil {
				msg = append(msg, fmt.Sprintf("集合%v添加%v成功", key, v))
			} else {
				msg = append(msg, fmt.Sprintf("集合%v添加%v失败", key, v))
			}
		}
		if r.Expiration == 0 {
			r.RedisDb.Persist(r.Context, key)
		} else {
			r.RedisDb.PExpire(r.Context, key, r.Expiration)
		}
	}
	return
}

/*
*有序集合
 */
/**
@ 作者: 秦东
@ 时间: 2023-11-14 10:02:56
@ 功能: Redis Zrange 返回有序集中，指定区间内的成员。

		其中成员的位置按分数值递增(从小到大)来排序。

		具有相同分数值的成员按字典序(lexicographical order )来排列。

		如果你需要成员按

		值递减(从大到小)来排列，请使用 ZREVRANGE 命令。

		下标参数 start 和 stop 都以 0 为底，也就是说，以 0 表示有序集第一个成员，以 1 表示有序集第二个成员，以此类推。

		你也可以使用负数下标，以 -1 表示最后一个成员， -2 表示倒数第二个成员，以此类推。
@ 参数
		#
@ 返回值
		#
@ 方法原型
		#
*/
func (r *RedisStoreType) Zrange(key string, start, stop int64) ([]string, error) {
	redisClient := r.RedisDb.ZRange(r.Context, key, start, stop)
	return redisClient.Val(), redisClient.Err()
}

/*
*
@ 作者: 秦东
@ 时间: 2023-11-14 10:05:51
@ 功能: Redis Zadd 命令用于将一个或多个成员元素及其分数值加入到有序集当中。

	如果某个成员已经是有序集的成员，那么更新这个成员的分数值，并通过重新插入这个成员元素，来保证该成员在正确的位置上。

	分数值可以是整数值或双精度浮点数。

	如果有序集合 key 不存在，则创建一个空的有序集并执行 ZADD 操作。

	当 key 存在但不是有序集类型时，返回一个错误。

	注意： 在 Redis 2.4 版本以前， ZADD 每次只能添加一个元素。

@ 参数

	#

@ 返回值

	#

@ 方法原型

	#
*/
func (r *RedisStoreType) Zadd(key string, val []string) (msg []string) {
	if len(val) > 0 {
		for _, v := range val {
			redisClient := r.RedisDb.ZAdd(r.Context, key, redis.Z{1, v})
			if redisClient.Err() == nil {
				msg = append(msg, fmt.Sprintf("有序集合%v添加%v成功", key, v))
			} else {
				msg = append(msg, fmt.Sprintf("有序集合%v添加%v失败", key, v))
			}
		}
		if r.Expiration == 0 {
			r.RedisDb.Persist(r.Context, key)
		} else {
			r.RedisDb.PExpire(r.Context, key, r.Expiration)
		}
	}
	return
}