package key_helper

import (
	"time"
	
	"gitee.com/jtdd/redis-helper/src/v1/helper/base"
	"github.com/gogf/gf/v2/container/gvar"
	"github.com/gogf/gf/v2/frame/g"
	"github.com/gogf/gf/v2/util/gconv"
)

// KeyHelper Redis String类型助手类
type KeyHelper struct {
	*base.Base
}

// NewKeyHelper 实例化
func NewKeyHelper(b *base.Base) *KeyHelper {
	return &KeyHelper{
		Base: b,
	}
}

func (s KeyHelper) Exists(key string) (v *gvar.Var, err error) {
	v, err = g.Redis().Do(s.Ctx, "EXISTS", s.GetKey(key))
	
	return
}

func (s KeyHelper) ExistsNoError(key string) (v *gvar.Var) {
	v, _ = s.Exists(key)
	
	return
}

func (s KeyHelper) ExistsBool(key string) (b bool, err error) {
	var v *gvar.Var
	v, err = s.Exists(key)
	if err != nil {
		return
	}
	
	b = v.Bool()
	
	return
}

func (s KeyHelper) Del(key string) (v *gvar.Var, err error) {
	v, err = g.Redis().Do(s.Ctx, "DEL", s.GetKey(key))
	
	return
}

func (s KeyHelper) DelOnlyError(key string) (err error) {
	_, err = s.Exists(s.GetKey(key))
	
	return
}

func (s KeyHelper) DelM(keys []string) (v *gvar.Var, err error) {
	v, err = g.Redis().Do(s.Ctx, "DEL", g.SliceAny{s.GetKeys(keys)}...)
	
	return
}

func (s KeyHelper) Expire(key string, seconds time.Duration) (v *gvar.Var, err error) {
	v, err = g.Redis().Do(s.Ctx, "EXPIRE", s.GetKey(key), gconv.Uint64(seconds.Seconds()))
	
	return
}

func (s KeyHelper) Ttl(key string) (v *gvar.Var, err error) {
	v, err = g.Redis().Do(s.Ctx, "TTL", s.GetKey(key))
	
	return
}

func (s KeyHelper) TtlInt(key string) (ttl int64, err error) {
	var v *gvar.Var
	v, err = s.Ttl(key)
	if err != nil {
		return
	}
	
	ttl = v.Int64()
	
	return
}

func (s KeyHelper) ExpireAt(key string, timestamp time.Time) (v *gvar.Var, err error) {
	v, err = g.Redis().Do(s.Ctx, "EXPIREAT", s.GetKey(key), gconv.Uint64(timestamp.Unix()))
	
	return
}

func (s KeyHelper) Persist(key string) (v *gvar.Var, err error) {
	v, err = g.Redis().Do(s.Ctx, "PERSIST", s.GetKey(key))
	
	return
}

// Scan 批量获取key 【注意】key里需要有通配符 比如：a:*
func (s KeyHelper) Scan(key string, callback func(keys []string) error, count ...int) (err error) {
	_count := 100
	if count != nil && len(count) > 0 {
		_count = count[0]
	}
	
	var v *gvar.Var
	
	cursor := 0
	for {
		v, err = g.Redis().Do(s.Ctx, "SCAN", cursor, "MATCH", s.GetKey(key), "COUNT", gconv.String(_count))
		if err != nil {
			return
		}
		data := gconv.SliceAny(v)
		var dataSlice []string
		err = gconv.Scan(data[1], &dataSlice)
		if err != nil {
			return
		}
		
		err = callback(dataSlice)
		if err != nil {
			return
		}
		
		cursor = gconv.Int(data[0])
		if cursor == 0 {
			break
		}
	}
	
	return
}

// PExpire 以毫秒为单位设置 key 的过期时间
func (s KeyHelper) PExpire(key string, milliseconds time.Duration) (v *gvar.Var, err error) {
	v, err = g.Redis().Do(s.Ctx, "PEXPIRE", s.GetKey(key), gconv.Uint64(milliseconds.Milliseconds()))
	return
}

// PExpireAt 以毫秒为单位设置 key 的过期 Unix 时间戳
func (s KeyHelper) PExpireAt(key string, timestamp time.Time) (v *gvar.Var, err error) {
	v, err = g.Redis().Do(s.Ctx, "PEXPIREAT", s.GetKey(key), gconv.Uint64(timestamp.UnixMilli()))
	return
}

// PTtl 以毫秒为单位返回 key 的剩余过期时间
func (s KeyHelper) PTtl(key string) (v *gvar.Var, err error) {
	v, err = g.Redis().Do(s.Ctx, "PTTL", s.GetKey(key))
	return
}

// Type 返回 key 所储存的值的类型
func (s KeyHelper) Type(key string) (v *gvar.Var, err error) {
	v, err = g.Redis().Do(s.Ctx, "TYPE", s.GetKey(key))
	return
}

// Rename 修改 key 的名称
func (s KeyHelper) Rename(oldKey, newKey string) (v *gvar.Var, err error) {
	v, err = g.Redis().Do(s.Ctx, "RENAME", s.GetKey(oldKey), s.GetKey(newKey))
	return
}

// RenameNx 仅当 newkey 不存在时，将 key 改名为 newkey
func (s KeyHelper) RenameNx(oldKey, newKey string) (v *gvar.Var, err error) {
	v, err = g.Redis().Do(s.Ctx, "RENAMENX", s.GetKey(oldKey), s.GetKey(newKey))
	return
}

// RandomKey 从当前数据库中随机返回一个 key
func (s KeyHelper) RandomKey() (v *gvar.Var, err error) {
	v, err = g.Redis().Do(s.Ctx, "RANDOMKEY")
	return
}

// Keys 查找所有符合给定模式 pattern 的 key（谨慎使用，生产环境建议用Scan）
func (s KeyHelper) Keys(pattern string) (v *gvar.Var, err error) {
	v, err = g.Redis().Do(s.Ctx, "KEYS", s.GetKey(pattern))
	return
}

// Move 将当前数据库的 key 移动到给定的数据库 db 当中
func (s KeyHelper) Move(key string, db int) (v *gvar.Var, err error) {
	v, err = g.Redis().Do(s.Ctx, "MOVE", s.GetKey(key), db)
	return
}

// Object 允许从内部察看给定 key 的 Redis 对象
// subcommand: REFCOUNT, ENCODING, IDLETIME, FREQ
func (s KeyHelper) Object(subcommand, key string) (v *gvar.Var, err error) {
	v, err = g.Redis().Do(s.Ctx, "OBJECT", subcommand, s.GetKey(key))
	return
}

// Dump 序列化给定 key ，并返回被序列化的值
func (s KeyHelper) Dump(key string) (v *gvar.Var, err error) {
	v, err = g.Redis().Do(s.Ctx, "DUMP", s.GetKey(key))
	return
}

// Restore 反序列化给定的序列化值，并将它和给定的 key 关联
func (s KeyHelper) Restore(key string, ttl time.Duration, serializedValue string) (v *gvar.Var, err error) {
	v, err = g.Redis().Do(s.Ctx, "RESTORE", s.GetKey(key), gconv.Uint64(ttl.Milliseconds()), serializedValue)
	return
}

// Migrate 将 key 原子性地从当前实例传送到目标实例的指定数据库上
func (s KeyHelper) Migrate(host string, port int, key string, destinationDb int, timeout time.Duration) (v *gvar.Var, err error) {
	v, err = g.Redis().Do(s.Ctx, "MIGRATE", host, port, s.GetKey(key), destinationDb, gconv.Uint64(timeout.Milliseconds()))
	return
}

// MigrateWithOptions 带有选项的迁移命令
// options: COPY, REPLACE, AUTH, AUTH2
func (s KeyHelper) MigrateWithOptions(host string, port int, key string, destinationDb int, timeout time.Duration, options ...interface{}) (v *gvar.Var, err error) {
	args := g.Slice{host, port, s.GetKey(key), destinationDb, gconv.Uint64(timeout.Milliseconds())}
	args = append(args, options...)
	v, err = g.Redis().Do(s.Ctx, "MIGRATE", args...)
	return
}

// Touch 修改 key 的最后访问时间（仅当 key 存在时）
func (s KeyHelper) Touch(keys ...string) (v *gvar.Var, err error) {
	args := g.Slice{}
	for _, key := range keys {
		args = append(args, s.GetKey(key))
	}
	v, err = g.Redis().Do(s.Ctx, "TOUCH", args...)
	return
}

// Unlink 非阻塞删除 key（仅将 keys 从 keyspace 元数据中删除，真正的删除会在后续异步操作）
func (s KeyHelper) Unlink(keys ...string) (v *gvar.Var, err error) {
	args := g.Slice{}
	for _, key := range keys {
		args = append(args, s.GetKey(key))
	}
	v, err = g.Redis().Do(s.Ctx, "UNLINK", args...)
	return
}

// Wait 阻塞当前客户端，直到所有先前的写命令都成功的传输和同步到至少指定数量的副本中
func (s KeyHelper) Wait(numreplicas int, timeout time.Duration) (v *gvar.Var, err error) {
	v, err = g.Redis().Do(s.Ctx, "WAIT", numreplicas, gconv.Uint64(timeout.Milliseconds()))
	return
}

// Sort 返回或保存给定列表、集合、有序集合 key 中经过排序的元素
func (s KeyHelper) Sort(key string, options ...interface{}) (v *gvar.Var, err error) {
	args := g.Slice{s.GetKey(key)}
	args = append(args, options...)
	v, err = g.Redis().Do(s.Ctx, "SORT", args...)
	return
}

// SortStore 对 key 进行排序，并将结果存储到 storeKey 中
func (s KeyHelper) SortStore(key, storeKey string, options ...interface{}) (v *gvar.Var, err error) {
	args := g.Slice{s.GetKey(key)}
	args = append(args, options...)
	args = append(args, "STORE", s.GetKey(storeKey))
	v, err = g.Redis().Do(s.Ctx, "SORT", args...)
	return
}

// ScanOnce 执行一次扫描，返回下一个游标和当前扫描结果
func (s KeyHelper) ScanOnce(cursor int64, pattern string, count int64) (v *gvar.Var, err error) {
	args := g.Slice{cursor}
	
	if pattern != "" {
		args = append(args, "MATCH", s.GetKey(pattern))
	}
	
	if count > 0 {
		args = append(args, "COUNT", count)
	}
	
	v, err = g.Redis().Do(s.Ctx, "SCAN", args...)
	return
}

// GetKeysByPattern 根据模式获取所有匹配的key（使用SCAN替代KEYS，避免阻塞）
func (s KeyHelper) GetKeysByPattern(pattern string) (keys []string, err error) {
	keys = make([]string, 0)
	
	err = s.Scan(pattern, func(matchedKeys []string) error {
		keys = append(keys, matchedKeys...)
		return nil
	}, 1000)
	
	return keys, err
}

// GetKeysCountByPattern 根据模式获取匹配的key数量
func (s KeyHelper) GetKeysCountByPattern(pattern string) (count int64, err error) {
	keys, err := s.GetKeysByPattern(pattern)
	if err != nil {
		return 0, err
	}
	
	return int64(len(keys)), nil
}

// ExistsM 检查多个key是否存在，返回存在的数量
func (s KeyHelper) ExistsM(keys []string) (count int64, err error) {
	if len(keys) == 0 {
		return 0, nil
	}
	
	args := g.Slice{}
	for _, key := range keys {
		args = append(args, s.GetKey(key))
	}
	
	v, err := g.Redis().Do(s.Ctx, "EXISTS", args...)
	if err != nil {
		return 0, err
	}
	
	return v.Int64(), nil
}

// DeleteByPattern 根据模式删除所有匹配的key
func (s KeyHelper) DeleteByPattern(pattern string) (deletedCount int64, err error) {
	keys, err := s.GetKeysByPattern(pattern)
	if err != nil {
		return 0, err
	}
	
	if len(keys) == 0 {
		return 0, nil
	}
	
	v, err := s.DelM(keys)
	if err != nil {
		return 0, err
	}
	
	return v.Int64(), nil
}

// UnlinkByPattern 根据模式异步删除所有匹配的key
func (s KeyHelper) UnlinkByPattern(pattern string) (deletedCount int64, err error) {
	keys, err := s.GetKeysByPattern(pattern)
	if err != nil {
		return 0, err
	}
	
	if len(keys) == 0 {
		return 0, nil
	}
	
	v, err := s.Unlink(keys...)
	if err != nil {
		return 0, err
	}
	
	return v.Int64(), nil
}

// GetTypeString 获取key的类型（字符串形式）
func (s KeyHelper) GetTypeString(key string) (typeStr string, err error) {
	v, err := s.Type(key)
	if err != nil {
		return "", err
	}
	
	return v.String(), nil
}

// IsType 检查key是否为指定类型
func (s KeyHelper) IsType(key, expectedType string) (isType bool, err error) {
	typeStr, err := s.GetTypeString(key)
	if err != nil {
		return false, err
	}
	
	return typeStr == expectedType, nil
}

// IsString 检查key是否为string类型
func (s KeyHelper) IsString(key string) (bool, error) {
	return s.IsType(key, "string")
}

// IsHash 检查key是否为hash类型
func (s KeyHelper) IsHash(key string) (bool, error) {
	return s.IsType(key, "hash")
}

// IsList 检查key是否为list类型
func (s KeyHelper) IsList(key string) (bool, error) {
	return s.IsType(key, "list")
}

// IsSet 检查key是否为set类型
func (s KeyHelper) IsSet(key string) (bool, error) {
	return s.IsType(key, "set")
}

// IsZSet 检查key是否为zset类型
func (s KeyHelper) IsZSet(key string) (bool, error) {
	return s.IsType(key, "zset")
}

// Copy 将key复制到另一个key（Redis 6.2+）
func (s KeyHelper) Copy(sourceKey, destinationKey string, replace bool) (v *gvar.Var, err error) {
	args := g.Slice{s.GetKey(sourceKey), s.GetKey(destinationKey)}
	if replace {
		args = append(args, "REPLACE")
	}
	v, err = g.Redis().Do(s.Ctx, "COPY", args...)
	return
}

// ExpireTime 获取key的过期时间戳（秒）（Redis 7.0+）
func (s KeyHelper) ExpireTime(key string) (v *gvar.Var, err error) {
	v, err = g.Redis().Do(s.Ctx, "EXPIRETIME", s.GetKey(key))
	return
}

// PExpireTime 获取key的过期时间戳（毫秒）（Redis 7.0+）
func (s KeyHelper) PExpireTime(key string) (v *gvar.Var, err error) {
	v, err = g.Redis().Do(s.Ctx, "PEXPIRETIME", s.GetKey(key))
	return
}

// GetEncoding 获取key的内部编码
func (s KeyHelper) GetEncoding(key string) (v *gvar.Var, err error) {
	return s.Object("ENCODING", key)
}

// GetRefCount 获取key的引用计数
func (s KeyHelper) GetRefCount(key string) (v *gvar.Var, err error) {
	return s.Object("REFCOUNT", key)
}

// GetIdleTime 获取key的空闲时间（秒）
func (s KeyHelper) GetIdleTime(key string) (v *gvar.Var, err error) {
	return s.Object("IDLETIME", key)
}

// GetFrequency 获取key的访问频率（Redis 4.0+）
func (s KeyHelper) GetFrequency(key string) (v *gvar.Var, err error) {
	return s.Object("FREQ", key)
}

// RenameWithPrefix 重命名key，自动添加前缀
func (s KeyHelper) RenameWithPrefix(oldKey, newKey string) (v *gvar.Var, err error) {
	return s.Rename(s.GetKey(oldKey), s.GetKey(newKey))
}

// ExistsWithPrefix 检查带前缀的key是否存在
func (s KeyHelper) ExistsWithPrefix(key string) (v *gvar.Var, err error) {
	return s.Exists(s.GetKey(key))
}

// DelWithPrefix 删除带前缀的key
func (s KeyHelper) DelWithPrefix(key string) (v *gvar.Var, err error) {
	return s.Del(s.GetKey(key))
}

// GetTtlInSeconds 获取key的剩余生存时间（秒），key不存在返回-2，永久key返回-1
func (s KeyHelper) GetTtlInSeconds(key string) (ttl int64, err error) {
	return s.TtlInt(key)
}

// GetTtlInMillis 获取key的剩余生存时间（毫秒）
func (s KeyHelper) GetTtlInMillis(key string) (ttl int64, err error) {
	v, err := s.PTtl(key)
	if err != nil {
		return 0, err
	}
	
	return v.Int64(), nil
}

// IsExpired 检查key是否已过期（TTL <= 0）
func (s KeyHelper) IsExpired(key string) (expired bool, err error) {
	ttl, err := s.GetTtlInSeconds(key)
	if err != nil {
		return false, err
	}
	
	// -2表示key不存在，-1表示永久key，0或正数表示剩余时间
	return ttl == -2 || ttl == 0, nil
}

// IsPermanent 检查key是否为永久key（无过期时间）
func (s KeyHelper) IsPermanent(key string) (permanent bool, err error) {
	ttl, err := s.GetTtlInSeconds(key)
	if err != nil {
		return false, err
	}
	
	return ttl == -1, nil
}

// SetExpireInSeconds 设置过期时间（秒）
func (s KeyHelper) SetExpireInSeconds(key string, seconds int64) (v *gvar.Var, err error) {
	return s.Expire(key, time.Duration(seconds)*time.Second)
}

// SetExpireInMinutes 设置过期时间（分钟）
func (s KeyHelper) SetExpireInMinutes(key string, minutes int64) (v *gvar.Var, err error) {
	return s.Expire(key, time.Duration(minutes)*time.Minute)
}

// SetExpireInHours 设置过期时间（小时）
func (s KeyHelper) SetExpireInHours(key string, hours int64) (v *gvar.Var, err error) {
	return s.Expire(key, time.Duration(hours)*time.Hour)
}

// SetExpireInDays 设置过期时间（天）
func (s KeyHelper) SetExpireInDays(key string, days int64) (v *gvar.Var, err error) {
	return s.Expire(key, time.Duration(days)*24*time.Hour)
}

// ClearDatabase 清空当前数据库（谨慎使用）
func (s KeyHelper) ClearDatabase() (v *gvar.Var, err error) {
	v, err = g.Redis().Do(s.Ctx, "FLUSHDB")
	return
}

// ClearAllDatabases 清空所有数据库（谨慎使用）
func (s KeyHelper) ClearAllDatabases() (v *gvar.Var, err error) {
	v, err = g.Redis().Do(s.Ctx, "FLUSHALL")
	return
}