package manager

import (
	"context"
	"encoding/json"
	"errors"
	"fmt"
	"slices"
	"sync"
	"time"

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

// 缓存适配层

// ICache 定义缓存的标准行为接口
// Get 方法的 value 参数必须为指针类型，用于反序列化结果。
// Set/SetLocal/SetRedis 方法 ttl <= 0 时，默认过期时间为 24 小时。
type ICache interface {
	Set(ctx context.Context, key string, value any, ttl time.Duration, ids []int64) error
	Get(ctx context.Context, key string, value any) error // value 必须为指针类型
	Del(ctx context.Context, key string) error
	Remove(ctx context.Context, ids []int64) error
	BatchDel(ctx context.Context, keys []string) error
}

var (
	ErrCacheNil = errors.New("cache value is nil")
)

// CacheRedisHash 以 Redis Hash 结构实现的缓存方案
// 实现原理：
//   - 所有缓存数据存储在同一个 Redis Hash（keyName）下，不同业务 key 作为 field。
//   - 只支持整个 hash 的过期时间（通过 Expire 设置），不支持 field 级别的过期。
//   - 适合 field 数量有限、生命周期一致的场景。
//   - 若 field 很多且生命周期不一致，建议使用 CacheRedis。
//   - 频繁访问某个 field 会导致整个 hash 过期时间被刷新，其他 field 也不会过期，需注意内存风险。
//
// 适用场景：
//   - 业务 key 数量有限，生命周期一致，且需要批量操作 hash 的场景。
type CacheRedisHash struct {
	options       *managerOptions
	redisClient   redis.UniversalClient
	keyName       string
	hashTableName string // 记录Key=>ids 映射关系的Hash表，field为key，value为ids的json字符串
	ttl           time.Duration
}

// NewCacheRedisHash 创建新的 Redis Hash 缓存实例
// ttl <= 0 时，默认过期时间为 24 小时
// keyName 是 Redis Hash 的 key，实际缓存项存储在该 Hash 中，field 为具体的缓存 key
// 适用于需要在 Redis 中存储大量相关缓存项的场景，避免过多的 Redis key 导致性能问题
// 这种 hash 结构适合 field 数量有限、生命周期一致的场景。如果 field 很多且生命周期不一致，建议直接用 string 类型的 key-value。
// 例如，可以存储配置项等，一直不需要过期的数据。
func NewCacheRedisHash(redis redis.UniversalClient, keyName string, ttl time.Duration, ops ...OptionFunc) *CacheRedisHash {

	options := defaultManagerOptions()
	for _, op := range ops {
		op(options)
	}

	if ttl <= 0 {
		ttl = 24 * time.Hour
	}

	return &CacheRedisHash{
		options:       options,
		redisClient:   redis,
		keyName:       keyName,
		hashTableName: keyName + ":hashTable",
		ttl:           ttl,
	}
}

func (l *CacheRedisHash) Get(ctx context.Context, key string, value any) error {

	val, err := l.redisClient.HGet(ctx, l.keyName, key).Result()
	if err != nil {
		if err == redis.Nil {
			return ErrCacheNil // 明确区分缓存未命中和其他错误
		}
		l.options.logger.Errorf(ctx, "cache redis get error: %v", err)
		return err
	}

	err = sonic.Unmarshal([]byte(val), value)
	if err != nil {
		l.options.logger.Errorf(ctx, "cache redis unmarshal error: %v", err)
		return err
	}

	l.redisClient.Expire(ctx, l.keyName, l.ttl)

	return nil
}

func (r *CacheRedisHash) Set(ctx context.Context, key string, value any, ttl time.Duration, ids []int64) error {

	jsonBy, err := sonic.Marshal(value)
	if err != nil {
		r.options.logger.Errorf(ctx, "cache redis marshal error: %v", err)
		return err
	}
	if ttl <= 0 {
		ttl = r.ttl // 默认过期时间
	}

	idsBy, err := sonic.Marshal(ids)
	if err != nil {
		r.options.logger.Errorf(ctx, "CacheRedisHash Set redis marshal ids key:%s error: %v", key, err)
		return err
	}
	p := r.redisClient.Pipeline()
	p.HSet(ctx, r.keyName, key, jsonBy)
	p.Expire(ctx, r.keyName, ttl) // 设置整个 hash 的过期时间，注意这会影响到 hash 中的所有 field
	p.HSet(ctx, r.hashTableName, key, idsBy)
	p.Expire(ctx, r.hashTableName, ttl)

	cmders, err := p.Exec(ctx)
	if err != nil {
		r.options.logger.Errorf(ctx, "CacheRedisHash Set redis pipeline exec key:%s error: %v", key, err)
		return err
	}

	// 检查 pipeline 中每个命令的错误
	for i, cmd := range cmders {
		if err := cmd.Err(); err != nil {
			r.options.logger.Errorf(ctx, "CacheRedisHash Set redis pipeline cmd[%d] error: %v", i, err)
			return err
		}
	}

	return nil
}

func (r *CacheRedisHash) Del(ctx context.Context, key string) error {

	p := r.redisClient.Pipeline()

	p.HDel(ctx, r.keyName, key)
	p.HDel(ctx, r.hashTableName, key)
	cmders, err := p.Exec(ctx)
	if err != nil {
		r.options.logger.Errorf(ctx, "CacheRedisHash Del redis pipeline exec key:%s error: %v", key, err)
		return err
	}

	// 检查 pipeline 中每个命令的错误
	for i, cmd := range cmders {
		if err := cmd.Err(); err != nil {
			r.options.logger.Errorf(ctx, "CacheRedisHash Del redis pipeline cmd[%d] error: %v", i, err)
			return err
		}
	}

	return nil
}

func (r *CacheRedisHash) Remove(ctx context.Context, ids []int64) error {
	// 获取所有 field=>ids 映射关系
	hashTable, err := r.redisClient.HGetAll(ctx, r.hashTableName).Result()
	if err != nil {
		r.options.logger.Errorf(ctx, "CacheRedisHash Remove redis get keyName:%s error: %v", r.hashTableName, err)
		return err
	}

	for k, v := range hashTable {
		var inIds []int64
		err = sonic.Unmarshal([]byte(v), &inIds)
		if err != nil {
			continue
		}
		for _, id := range ids {
			if slices.Contains(inIds, id) {
				if err := r.Del(ctx, k); err != nil {
					r.options.logger.Errorf(ctx, "CacheRedisHash Remove Del key:%s error: %v", k, err)
				}
				break
			}
		}
	}
	return nil
}

func (r *CacheRedisHash) BatchDel(ctx context.Context, keys []string) error {
	if len(keys) == 0 {
		return nil
	}
	err := r.redisClient.HDel(ctx, r.keyName, keys...).Err()
	if err != nil {
		r.options.logger.Errorf(ctx, "cache redis batch del error: %v", err)
		return err
	}
	return nil
}

func BatchGetRedisHash[T any](r *CacheRedisHash, ctx context.Context, keys []string) (map[string]*T, error) {
	if len(keys) == 0 { // 批量获取的key为空时，返回空map
		return map[string]*T{}, nil
	}

	res, err := r.redisClient.HMGet(ctx, r.keyName, keys...).Result()
	if err != nil && !errors.Is(err, redis.Nil) {
		r.options.logger.Errorf(ctx, "cache redis get error: %v", err)
		return nil, err
	}

	r.options.logger.Infof(ctx, "cache redis get keyName:%s keys: %v len:%d", r.keyName, keys, len(res))

	result := make(map[string]*T)
	for i, v := range res {
		if v == nil {
			continue
		}
		var t T
		err := sonic.Unmarshal([]byte(v.(string)), &t)
		if err != nil {
			r.options.logger.Errorf(ctx, "cache redis unmarshal error: %v", err)
			return nil, err
		}
		result[keys[i]] = &t
	}
	return result, nil
}

// CacheRedis 以 Redis String 结构实现的缓存方案
// 实现原理：
//   - 每个缓存 key 独立存储为一个 Redis String，支持单独设置过期时间。
//   - 通过 prefix 区分不同业务，避免 key 冲突。
//   - 支持泛型批量获取（BatchGetRedis），底层用 pipeline 提高性能。
//   - 适合 key 数量较多、生命周期不一致的场景。
//
// 适用场景：
//   - 业务 key 数量较多，生命周期不一致，或需要单独控制每个 key 过期时间。
type CacheRedis struct {
	options       *managerOptions
	redisClient   redis.UniversalClient
	prefix        string // key前缀，避免不同业务之间的key冲突
	hashTableName string // 记录Key=>ids 映射关系的Hash表，field为key，value为ids的json字符串
	sortSetName   string // 记录key的过期时间的有序集合，number为过期的毫秒时间戳，value为key
}

// NewCacheRedis 创建新的redis缓存实例
func NewCacheRedis(ctx context.Context, redis redis.UniversalClient, prefix string, ops ...OptionFunc) *CacheRedis {

	options := defaultManagerOptions()
	for _, op := range ops {
		op(options)
	}

	r := &CacheRedis{
		redisClient:   redis,
		prefix:        prefix,
		hashTableName: fmt.Sprintf("%s:hashTable", prefix),
		sortSetName:   fmt.Sprintf("%s:sortSet", prefix),
		options:       options,
	}

	go func() {
		ticker := time.NewTicker(time.Hour) // 定时检查过期key
		defer ticker.Stop()
		for {
			select {
			case <-ctx.Done():
				return
			case <-ticker.C:
				r.clean(ctx)
			}
		}
	}()

	return r
}

func (r *CacheRedis) clean(ctx context.Context) error {
	// 从sortSet查询已过期的key，并删除
	now := time.Now().UnixMilli()
	expiredKeys, err := r.redisClient.ZRangeByScore(ctx, r.sortSetName, &redis.ZRangeBy{
		Min: "0",
		Max: fmt.Sprintf("%d", now),
	}).Result()
	if err != nil {
		r.options.logger.Errorf(ctx, "CacheRedis clean redis ZRangeByScore keyName:%s error: %v", r.sortSetName, err)
		return err
	}
	for _, key := range expiredKeys {
		r.Del(ctx, key)
	}
	return nil

}

func (r *CacheRedis) Set(ctx context.Context, key string, value any, ttl time.Duration, ids []int64) error {

	key = fmt.Sprintf("%s:%s", r.prefix, key)
	// global.Logger.Infof(ctx, "cache redis set key: %s", key)

	jsonBy, err := sonic.Marshal(value)
	if err != nil {
		r.options.logger.Errorf(ctx, "cache redis marshal error: %v", err)
		return err
	}

	if ttl <= 0 {
		ttl = time.Hour * 24 // 默认过期时间
	}

	idsBy, err := sonic.Marshal(ids)
	if err != nil {
		r.options.logger.Errorf(ctx, "CacheRedis Set redis marshal ids key:%s error: %v", key, err)
		return err
	}

	p := r.redisClient.Pipeline()
	p.Set(ctx, key, jsonBy, ttl)
	p.ZAdd(ctx, r.sortSetName, redis.Z{
		Score:  float64(time.Now().Add(ttl).UnixMilli()),
		Member: key,
	})
	p.HSet(ctx, r.hashTableName, key, idsBy)
	p.Expire(ctx, r.hashTableName, time.Hour*24*30) // 一个月
	cmders, err := p.Exec(ctx)
	if err != nil {
		r.options.logger.Errorf(ctx, "CacheRedis Set redis pipeline exec key:%s error: %v", key, err)
		return err
	}

	// 检查 pipeline 中每个命令的错误
	for i, cmd := range cmders {
		if err := cmd.Err(); err != nil {
			r.options.logger.Errorf(ctx, "CacheRedis Set redis pipeline cmd[%d] error: %v", i, err)
			return err
		}
	}

	return nil
}

func (r *CacheRedis) Get(ctx context.Context, key string, value any) error {

	key = fmt.Sprintf("%s:%s", r.prefix, key)

	val, err := r.redisClient.Get(ctx, key).Result()
	if err != nil {
		if err == redis.Nil {
			return ErrCacheNil // 明确区分缓存未命中和其他错误
		}
		r.options.logger.Errorf(ctx, "cache redis get error: %v", err)
		return err
	}

	err = sonic.Unmarshal([]byte(val), value)
	if err != nil {
		r.options.logger.Errorf(ctx, "cache redis unmarshal error: %v", err)
		return err
	}

	return nil
}

func (l *CacheRedis) Remove(ctx context.Context, ids []int64) error {
	// 获取所有 field=>ids 映射关系
	hashTable, err := l.redisClient.HGetAll(ctx, l.hashTableName).Result()
	if err != nil {
		l.options.logger.Errorf(ctx, "CacheRedis Remove redis get keyName:%s error: %v", l.hashTableName, err)
		return err
	}

	for k, v := range hashTable {
		var inIds []int64
		err = json.Unmarshal([]byte(v), &inIds)
		if err != nil {
			continue
		}
		for _, id := range ids {
			if slices.Contains(inIds, id) {
				if err := l.Del(ctx, k); err != nil {
					l.options.logger.Errorf(ctx, "CacheRedis Remove Del key:%s error: %v", k, err)
				}
				break
			}
		}
	}
	return nil
}

// BatchGetRedis 批量获取Redis缓存，支持泛型
func BatchGetRedis[T any](r *CacheRedis, ctx context.Context, keys []string) (map[string]*T, error) {

	result := make(map[string]*T)
	if len(keys) == 0 {
		return result, nil
	}

	keyMap := make(map[string]string, len(keys))
	redisKeys := make([]string, 0, len(keys))
	cmder, err := r.redisClient.Pipeline().Pipelined(ctx, func(pipe redis.Pipeliner) error {
		for _, key := range keys {
			rediskey := fmt.Sprintf("%s:%s", r.prefix, key)
			redisKeys = append(redisKeys, rediskey)
			keyMap[rediskey] = key
			// global.Logger.Infof(ctx, "cache redis get key: %s", key)
			pipe.Get(ctx, rediskey)
		}
		return nil
	})
	if err != nil && !errors.Is(err, redis.Nil) {
		r.options.logger.Errorf(ctx, "BatchGetRedis pipeline exec error: %v", err)
		return nil, err
	}

	for i, cmd := range cmder {

		stringCom, ok := cmd.(*redis.StringCmd)
		// r.options.logger.Infof(ctx, "cache redis get key: %s ok:%+v val:%+v", redisKeys[i], ok, stringCom)
		if !ok {
			continue
		}
		if stringCom.Err() != nil {
			continue
		}
		val := stringCom.Val()
		key := keyMap[redisKeys[i]]
		var t T
		err := sonic.Unmarshal([]byte(val), &t)
		if err != nil {
			// 反序列化失败时跳过该项，整体不报错
			continue
		}
		result[key] = &t
	}
	return result, nil
}

// CacheRedis 删除缓存 保证Key删除的幂等性和一致性
func (r *CacheRedis) Del(ctx context.Context, key string) error {
	key = fmt.Sprintf("%s:%s", r.prefix, key)

	p := r.redisClient.Pipeline()
	// 删除key
	p.Del(ctx, key)
	// 从过期时间的有序集合中删除
	p.ZRem(ctx, r.sortSetName, key)
	// 从hashTable中删除
	p.HDel(ctx, r.hashTableName, key)
	cmders, err := p.Exec(ctx)
	if err != nil {
		r.options.logger.Errorf(ctx, "CacheRedis Del redis pipeline exec key:%s error: %v", key, err)
		return err
	}

	// 检查 pipeline 中每个命令的错误
	for i, cmd := range cmders {
		if err := cmd.Err(); err != nil {
			r.options.logger.Errorf(ctx, "CacheRedis Del redis pipeline cmd[%d] error: %v", i, err)
			return err
		}
	}

	r.options.logger.Infof(ctx, "CacheRedis Del redis del key:%s", key)

	return nil
}

func (r *CacheRedis) BatchDel(ctx context.Context, keys []string) error {
	if len(keys) == 0 {
		return nil
	}
	redisKeys := make([]string, 0, len(keys))
	for _, key := range keys {
		redisKeys = append(redisKeys, fmt.Sprintf("%s:%s", r.prefix, key))
	}
	//global.Logger.Infof(ctx, "CacheRedis BatchDel redis del keys:%+v", redisKeys)
	err := r.redisClient.Del(ctx, redisKeys...).Err()
	if err != nil {
		r.options.logger.Errorf(ctx, "cache redis batch del error: %v", err)
		return err
	}
	return nil
}

// CacheLocal 本地内存缓存实现
// 实现原理：
//   - 使用 map[string]item 存储所有缓存，item 结构体包含值和过期时间。
//   - 通过互斥锁保证并发安全。
//   - 启动后台协程定期清理过期 key。
//   - 适合单机场景，缓存容量受限于本地内存。
//
// 适用场景：
//   - 适用于高性能、低延迟、单机进程内缓存需求，如热点数据、本地会话等。
//   - 不适合分布式场景或大容量缓存。
type CacheLocal struct {
	options     *managerOptions
	cacheMap    sync.Map
	keyTableMap sync.Map      // 记录Key=>ids 映射关系的Map，field为key，value为ids的数组
	quit        chan struct{} // 用于停止后台清理协程
}

// item 内部存储单元，包含值和过期时间
type item struct {
	value  any
	expiry int64 // 过期时间戳 (Unix Nano)
}

func NewCacheLocal(cleanupInterval time.Duration, ops ...OptionFunc) *CacheLocal {

	options := defaultManagerOptions()
	for _, op := range ops {
		op(options)
	}

	cache := &CacheLocal{
		options:     options,
		cacheMap:    sync.Map{},
		keyTableMap: sync.Map{},
		quit:        make(chan struct{}),
	}

	// 启动后台清理协程
	go func() {
		ticker := time.NewTicker(cleanupInterval)
		defer ticker.Stop()
		for {
			select {
			case <-ticker.C:
				cache.cleanup(context.Background())
			case <-cache.quit:
				return
			}
		}
	}()

	return cache
}

// cleanup 定期清理过期的 Key
func (c *CacheLocal) cleanup(ctx context.Context) {

	now := time.Now().UnixNano()

	c.cacheMap.Range(func(key, value any) bool {
		it, ok := value.(item)
		if !ok {
			return true
		}
		if it.expiry > 0 && now > it.expiry {
			c.cacheMap.Delete(key) // 删除过时的缓存项
		}
		return true
	})
	c.options.logger.Infof(ctx, "CacheLocal cleanup")
	return
}

// Stop 停止后台清理协程（通常在程序退出时调用）
func (c *CacheLocal) Stop() {
	select {
	case <-c.quit:
		// 已关闭
		return
	default:
		close(c.quit)
	}
}

// Set 将 value 存储为 interface{}，建议 value 为可安全复制的类型
func (l *CacheLocal) Set(ctx context.Context, key string, value any, ttl time.Duration, ids []int64) error {

	if ttl <= 0 {
		ttl = time.Hour * 24 // 默认过期时间
	}

	// 存储深拷贝，防止外部修改
	var v any
	switch vv := value.(type) {
	case nil:
		v = nil
	case string, int, int64, float64, bool:
		v = vv
	default:
		// 对于结构体、切片、map等，序列化再反序列化实现深拷贝
		by, err := sonic.Marshal(vv)
		if err != nil {
			return err
		}
		err = sonic.Unmarshal(by, &v)
		if err != nil {
			return err
		}
	}
	l.cacheMap.Store(key, item{v, time.Now().Add(ttl).UnixNano()})
	l.keyTableMap.Store(key, ids)
	return nil
}

// Get 直接类型断言赋值，提升类型安全
func (l *CacheLocal) Get(ctx context.Context, key string, value any) error {

	itemData, exists := l.cacheMap.Load(key)
	if !exists {
		return ErrCacheNil // 不存在，返回nil表示缓存未命中
	}

	item, ok := itemData.(item)
	if !ok {
		return ErrCacheNil // 类型断言失败，返回nil表示缓存未命中
	}

	if time.Now().UnixNano() > item.expiry {
		l.cacheMap.Delete(key) // 删除过期的缓存
		return ErrCacheNil
	}

	// 直接类型断言赋值
	switch v := value.(type) {
	case *string:
		vv, ok := item.value.(string)
		if !ok {
			return errors.New("cache type mismatch: expect string")
		}
		*v = vv
	case *int:
		vv, ok := item.value.(int)
		if !ok {
			return errors.New("cache type mismatch: expect int")
		}
		*v = vv
	case *int64:
		vv, ok := item.value.(int64)
		if !ok {
			return errors.New("cache type mismatch: expect int64")
		}
		*v = vv
	case *float64:
		vv, ok := item.value.(float64)
		if !ok {
			return errors.New("cache type mismatch: expect float64")
		}
		*v = vv
	case *bool:
		vv, ok := item.value.(bool)
		if !ok {
			return errors.New("cache type mismatch: expect bool")
		}
		*v = vv
	default:
		// 结构体、切片、map等，序列化再反序列化
		by, err := sonic.Marshal(item.value)
		if err != nil {
			return err
		}
		err = sonic.Unmarshal(by, value)
		if err != nil {
			return err
		}
	}
	return nil
}

// BatchGetLocal 批量获取本地缓存，支持泛型
func BatchGetLocal[T any](c *CacheLocal, ctx context.Context, keys []string) (map[string]*T, error) {
	result := make(map[string]*T)
	for _, key := range keys {
		var t T
		err := c.Get(ctx, key, &t)
		if err != nil && !errors.Is(err, ErrCacheNil) {
			return nil, err
		}
		if errors.Is(err, ErrCacheNil) {
			continue
		}
		result[key] = &t
	}
	return result, nil
}

func (l *CacheLocal) BatchDel(ctx context.Context, keys []string) error {
	return nil
}

func (l *CacheLocal) Del(ctx context.Context, key string) error {
	l.cacheMap.Delete(key) // 删除指定的缓存
	l.keyTableMap.Delete(key)
	return nil
}

func (l *CacheLocal) Remove(ctx context.Context, ids []int64) error {
	l.keyTableMap.Range(func(key, value any) bool {
		idsArr, ok := value.([]int64)
		if !ok {
			return true
		}
		keyStr, ok := key.(string)
		if !ok {
			return true
		}
		for _, id := range idsArr {
			for _, id2 := range ids {
				if id == id2 {
					l.Del(ctx, keyStr)
				}
			}
		}
		return true
	})

	return nil
}