package cache

import (
	"context"
	"crypto/md5"
	"encoding/hex"
	"encoding/json"
	"fmt"
	"reflect"
	"strings"
	"sync"
	"time"

	"go.uber.org/zap"
	"gorm.io/gorm"

	"tyapi-server/internal/shared/interfaces"
)

// GormCachePlugin GORM缓存插件
type GormCachePlugin struct {
	cache  interfaces.CacheService
	logger *zap.Logger
	config CacheConfig

	// 缓存失效去重机制
	invalidationQueue map[string]*time.Timer
	queueMutex        sync.RWMutex
}

// CacheConfig 缓存配置
type CacheConfig struct {
	// 基础配置
	DefaultTTL     time.Duration `json:"default_ttl"`     // 默认TTL
	TablePrefix    string        `json:"table_prefix"`    // 表前缀
	EnabledTables  []string      `json:"enabled_tables"`  // 启用缓存的表
	DisabledTables []string      `json:"disabled_tables"` // 禁用缓存的表

	// 查询配置
	MaxCacheSize    int  `json:"max_cache_size"`    // 单次查询最大缓存记录数
	CacheComplexSQL bool `json:"cache_complex_sql"` // 是否缓存复杂SQL

	// 高级特性
	EnableStats      bool `json:"enable_stats"`      // 启用统计
	EnableWarmup     bool `json:"enable_warmup"`     // 启用预热
	PenetrationGuard bool `json:"penetration_guard"` // 缓存穿透保护
	BloomFilter      bool `json:"bloom_filter"`      // 布隆过滤器

	// 失效策略
	AutoInvalidate  bool          `json:"auto_invalidate"`  // 自动失效
	InvalidateDelay time.Duration `json:"invalidate_delay"` // 延迟失效时间
}

// DefaultCacheConfig 默认缓存配置
func DefaultCacheConfig() CacheConfig {
	return CacheConfig{
		DefaultTTL:       30 * time.Minute,
		TablePrefix:      "gorm_cache",
		MaxCacheSize:     1000,
		CacheComplexSQL:  false,
		EnableStats:      true,
		EnableWarmup:     false,
		PenetrationGuard: true,
		BloomFilter:      false,
		AutoInvalidate:   true,
		// 增加延迟失效时间，减少频繁的缓存失效操作
		InvalidateDelay: 500 * time.Millisecond,
	}
}

// NewGormCachePlugin 创建GORM缓存插件
func NewGormCachePlugin(cache interfaces.CacheService, logger *zap.Logger, config ...CacheConfig) *GormCachePlugin {
	cfg := DefaultCacheConfig()
	if len(config) > 0 {
		cfg = config[0]
	}

	return &GormCachePlugin{
		cache:             cache,
		logger:            logger,
		config:            cfg,
		invalidationQueue: make(map[string]*time.Timer),
	}
}

// Name 插件名称
func (p *GormCachePlugin) Name() string {
	return "gorm-cache-plugin"
}

// Initialize 初始化插件
func (p *GormCachePlugin) Initialize(db *gorm.DB) error {
	p.logger.Info("初始化GORM缓存插件",
		zap.Duration("default_ttl", p.config.DefaultTTL),
		zap.Bool("auto_invalidate", p.config.AutoInvalidate),
		zap.Bool("penetration_guard", p.config.PenetrationGuard),
		zap.Duration("invalidate_delay", p.config.InvalidateDelay),
	)

	// 注册回调函数
	return p.registerCallbacks(db)
}

// Shutdown 关闭插件，清理资源
func (p *GormCachePlugin) Shutdown() {
	p.queueMutex.Lock()
	defer p.queueMutex.Unlock()

	// 停止所有定时器
	for table, timer := range p.invalidationQueue {
		timer.Stop()
		p.logger.Debug("停止缓存失效定时器", zap.String("table", table))
	}

	// 清空队列
	p.invalidationQueue = make(map[string]*time.Timer)

	p.logger.Info("GORM缓存插件已关闭")
}

// registerCallbacks 注册GORM回调
func (p *GormCachePlugin) registerCallbacks(db *gorm.DB) error {
	// Query回调 - 查询时检查缓存
	db.Callback().Query().Before("gorm:query").Register("cache:before_query", p.beforeQuery)
	db.Callback().Query().After("gorm:query").Register("cache:after_query", p.afterQuery)

	// Create回调 - 创建时失效缓存
	db.Callback().Create().After("gorm:create").Register("cache:after_create", p.afterCreate)

	// Update回调 - 更新时失效缓存
	db.Callback().Update().After("gorm:update").Register("cache:after_update", p.afterUpdate)

	// Delete回调 - 删除时失效缓存
	db.Callback().Delete().After("gorm:delete").Register("cache:after_delete", p.afterDelete)

	return nil
}

// ================ 查询回调 ================

// beforeQuery 查询前回调
func (p *GormCachePlugin) beforeQuery(db *gorm.DB) {
	// 检查是否启用缓存
	if !p.shouldCache(db) {
		p.logger.Debug("跳过缓存", zap.String("table", db.Statement.Table))
		return
	}

	ctx := db.Statement.Context
	if ctx == nil {
		ctx = context.Background()
	}

	// 生成缓存键
	cacheKey := p.generateCacheKey(db)

	// 从缓存获取结果
	var cachedResult CachedResult
	if err := p.cache.Get(ctx, cacheKey, &cachedResult); err == nil {
		p.logger.Debug("缓存命中",
			zap.String("cache_key", cacheKey),
			zap.String("table", db.Statement.Table),
		)

		// 恢复查询结果
		if err := p.restoreFromCache(db, &cachedResult); err == nil {
			// 设置标记，跳过实际查询
			db.Statement.Set("cache:hit", true)
			db.Statement.Set("cache:key", cacheKey)

			// 更新统计
			if p.config.EnableStats {
				p.updateStats("hit", db.Statement.Table)
			}
			return
		} else {
			p.logger.Warn("缓存数据恢复失败，将执行数据库查询",
				zap.String("cache_key", cacheKey),
				zap.Error(err))
		}
	} else {
		p.logger.Debug("缓存未命中",
			zap.String("cache_key", cacheKey),
			zap.Error(err))
	}

	// 缓存未命中，设置标记
	db.Statement.Set("cache:miss", true)
	db.Statement.Set("cache:key", cacheKey)

	if p.config.EnableStats {
		p.updateStats("miss", db.Statement.Table)
	}
}

// afterQuery 查询后回调
func (p *GormCachePlugin) afterQuery(db *gorm.DB) {
	// 检查是否缓存未命中
	if _, ok := db.Statement.Get("cache:miss"); !ok {
		return
	}

	// 检查查询是否成功
	if db.Error != nil {
		return
	}

	ctx := db.Statement.Context
	if ctx == nil {
		ctx = context.Background()
	}

	cacheKey, _ := db.Statement.Get("cache:key")

	// 将查询结果保存到缓存
	if err := p.saveToCache(ctx, cacheKey.(string), db); err != nil {
		p.logger.Warn("保存查询结果到缓存失败",
			zap.String("cache_key", cacheKey.(string)),
			zap.Error(err),
		)
	}
}

// ================ CUD回调 ================

// afterCreate 创建后回调
func (p *GormCachePlugin) afterCreate(db *gorm.DB) {
	if !p.config.AutoInvalidate || db.Error != nil {
		return
	}

	// 只对启用缓存的表执行失效操作
	if p.shouldInvalidateTable(db.Statement.Table) {
		p.invalidateTableCache(db.Statement.Context, db.Statement.Table)
	}
}

// afterUpdate 更新后回调
func (p *GormCachePlugin) afterUpdate(db *gorm.DB) {
	if !p.config.AutoInvalidate || db.Error != nil {
		return
	}

	// 只对启用缓存的表执行失效操作
	if p.shouldInvalidateTable(db.Statement.Table) {
		p.invalidateTableCache(db.Statement.Context, db.Statement.Table)
	}
}

// afterDelete 删除后回调
func (p *GormCachePlugin) afterDelete(db *gorm.DB) {
	if !p.config.AutoInvalidate || db.Error != nil {
		return
	}

	// 只对启用缓存的表执行失效操作
	if p.shouldInvalidateTable(db.Statement.Table) {
		p.invalidateTableCache(db.Statement.Context, db.Statement.Table)
	}
}

// ================ 缓存管理方法 ================

// shouldInvalidateTable 判断是否应该对表执行缓存失效操作
func (p *GormCachePlugin) shouldInvalidateTable(table string) bool {
	// 使用全局缓存配置管理器进行智能决策
	if GlobalCacheConfigManager != nil {
		return GlobalCacheConfigManager.IsTableCacheEnabled(table)
	}

	// 如果全局管理器未初始化，使用本地配置
	// 检查表是否在禁用列表中
	for _, disabledTable := range p.config.DisabledTables {
		if disabledTable == table {
			return false
		}
	}

	// 如果配置了启用列表，只对启用列表中的表执行失效操作
	if len(p.config.EnabledTables) > 0 {
		for _, enabledTable := range p.config.EnabledTables {
			if enabledTable == table {
				return true
			}
		}
		return false
	}

	// 如果没有配置启用列表，默认对所有表执行失效操作（除了禁用列表中的表）
	return true
}

// shouldCache 判断是否应该缓存
func (p *GormCachePlugin) shouldCache(db *gorm.DB) bool {
	// 检查是否手动禁用缓存
	if value, ok := db.Statement.Get("cache:disabled"); ok && value.(bool) {
		return false
	}

	// 检查是否手动启用缓存
	if value, ok := db.Statement.Get("cache:enabled"); ok && value.(bool) {
		return true
	}

	// 使用全局缓存配置管理器进行智能决策
	if GlobalCacheConfigManager != nil {
		return GlobalCacheConfigManager.IsTableCacheEnabled(db.Statement.Table)
	}

	// 如果全局管理器未初始化，使用本地配置
	// 检查表是否在禁用列表中
	for _, disabledTable := range p.config.DisabledTables {
		if disabledTable == db.Statement.Table {
			return false
		}
	}

	// 检查表是否在启用列表中（如果配置了启用列表）
	if len(p.config.EnabledTables) > 0 {
		for _, table := range p.config.EnabledTables {
			if table == db.Statement.Table {
				return true
			}
		}
		return false
	}

	// 如果没有配置启用列表，默认对所有表启用缓存（除了禁用列表中的表）
	return true
}

// isComplexQuery 判断是否为复杂查询
func (p *GormCachePlugin) isComplexQuery(db *gorm.DB) bool {
	sql := db.Statement.SQL.String()

	// 检查是否包含复杂操作
	complexKeywords := []string{
		"JOIN", "UNION", "SUBQUERY", "GROUP BY",
		"HAVING", "WINDOW", "RECURSIVE",
	}

	upperSQL := strings.ToUpper(sql)
	for _, keyword := range complexKeywords {
		if strings.Contains(upperSQL, keyword) {
			return true
		}
	}

	return false
}

// generateCacheKey 生成缓存键
func (p *GormCachePlugin) generateCacheKey(db *gorm.DB) string {
	// 构建缓存键的组成部分
	keyParts := []string{
		p.config.TablePrefix,
		db.Statement.Table,
	}

	// 添加SQL语句hash
	sqlHash := p.hashSQL(db.Statement.SQL.String(), db.Statement.Vars)
	keyParts = append(keyParts, sqlHash)

	return strings.Join(keyParts, ":")
}

// hashSQL 对SQL语句和参数进行hash
func (p *GormCachePlugin) hashSQL(sql string, vars []interface{}) string {
	// 修复：改进SQL hash生成，确保唯一性
	combined := sql
	for _, v := range vars {
		// 使用更精确的格式化，避免类型信息丢失
		switch val := v.(type) {
		case string:
			combined += ":" + val
		case int, int32, int64:
			combined += fmt.Sprintf(":%d", val)
		case float32, float64:
			combined += fmt.Sprintf(":%f", val)
		case bool:
			combined += fmt.Sprintf(":%t", val)
		default:
			// 对于复杂类型，使用JSON序列化
			if jsonData, err := json.Marshal(v); err == nil {
				combined += ":" + string(jsonData)
			} else {
				combined += fmt.Sprintf(":%v", v)
			}
		}
	}

	// 计算MD5 hash
	hasher := md5.New()
	hasher.Write([]byte(combined))
	return hex.EncodeToString(hasher.Sum(nil))
}

// CachedResult 缓存结果结构
type CachedResult struct {
	Data      interface{} `json:"data"`
	RowCount  int64       `json:"row_count"`
	Timestamp time.Time   `json:"timestamp"`
}

// saveToCache 保存结果到缓存
func (p *GormCachePlugin) saveToCache(ctx context.Context, cacheKey string, db *gorm.DB) error {
	// 检查结果大小限制
	if db.Statement.RowsAffected > int64(p.config.MaxCacheSize) {
		p.logger.Debug("查询结果过大，跳过缓存",
			zap.String("cache_key", cacheKey),
			zap.Int64("rows", db.Statement.RowsAffected),
		)
		return nil
	}

	// 获取查询结果
	dest := db.Statement.Dest
	if dest == nil {
		return fmt.Errorf("查询结果为空")
	}

	// 修复：改进缓存数据保存逻辑
	var dataToCache interface{}

	// 如果dest是切片，需要特殊处理
	destValue := reflect.ValueOf(dest)
	if destValue.Kind() == reflect.Ptr && destValue.Elem().Kind() == reflect.Slice {
		// 对于切片，直接使用原始数据
		dataToCache = destValue.Elem().Interface()
	} else {
		// 对于单个对象，也直接使用原始数据
		dataToCache = dest
	}

	// 构建缓存结果
	result := CachedResult{
		Data:      dataToCache,
		RowCount:  db.Statement.RowsAffected,
		Timestamp: time.Now(),
	}

	// 获取TTL
	ttl := p.getTTL(db)

	// 保存到缓存
	if err := p.cache.Set(ctx, cacheKey, result, ttl); err != nil {
		p.logger.Error("保存查询结果到缓存失败",
			zap.String("cache_key", cacheKey),
			zap.Error(err),
		)
		return fmt.Errorf("保存到缓存失败: %w", err)
	}

	p.logger.Debug("查询结果已缓存",
		zap.String("cache_key", cacheKey),
		zap.Int64("rows", db.Statement.RowsAffected),
		zap.Duration("ttl", ttl),
	)

	return nil
}

// restoreFromCache 从缓存恢复结果
func (p *GormCachePlugin) restoreFromCache(db *gorm.DB, cachedResult *CachedResult) error {
	if cachedResult.Data == nil {
		return fmt.Errorf("缓存数据为空")
	}

	// 反序列化到目标对象
	destValue := reflect.ValueOf(db.Statement.Dest)
	if destValue.Kind() != reflect.Ptr || destValue.IsNil() {
		return fmt.Errorf("目标对象必须是指针")
	}

	// 修复：改进缓存数据恢复逻辑
	cachedValue := reflect.ValueOf(cachedResult.Data)

	// 如果类型完全匹配，直接赋值
	if cachedValue.Type().AssignableTo(destValue.Elem().Type()) {
		destValue.Elem().Set(cachedValue)
	} else {
		// 尝试JSON转换
		jsonData, err := json.Marshal(cachedResult.Data)
		if err != nil {
			p.logger.Error("序列化缓存数据失败", zap.Error(err))
			return fmt.Errorf("缓存数据类型转换失败: %w", err)
		}

		if err := json.Unmarshal(jsonData, db.Statement.Dest); err != nil {
			p.logger.Error("反序列化缓存数据失败",
				zap.String("json_data", string(jsonData)),
				zap.Error(err))
			return fmt.Errorf("JSON反序列化失败: %w", err)
		}
	}

	// 设置影响行数
	db.Statement.RowsAffected = cachedResult.RowCount

	p.logger.Debug("从缓存恢复数据成功",
		zap.Int64("rows", cachedResult.RowCount),
		zap.Time("timestamp", cachedResult.Timestamp))

	return nil
}

// getTTL 获取TTL
func (p *GormCachePlugin) getTTL(db *gorm.DB) time.Duration {
	// 检查是否设置了自定义TTL
	if value, ok := db.Statement.Get("cache:ttl"); ok {
		if ttl, ok := value.(time.Duration); ok {
			return ttl
		}
	}

	return p.config.DefaultTTL
}

// invalidateTableCache 失效表相关缓存
func (p *GormCachePlugin) invalidateTableCache(ctx context.Context, table string) {
	// 使用去重机制，避免重复的缓存失效操作
	p.queueMutex.Lock()
	defer p.queueMutex.Unlock()

	// 如果已经有相同的失效操作在队列中，取消之前的定时器
	if timer, exists := p.invalidationQueue[table]; exists {
		timer.Stop()
		delete(p.invalidationQueue, table)
	}

	// 创建独立的上下文，避免受到原始请求上下文的影响
	// 设置合理的超时时间，避免缓存失效操作阻塞
	cacheCtx, cancel := context.WithTimeout(context.Background(), 10*time.Second)

	// 创建新的定时器
	timer := time.AfterFunc(p.config.InvalidateDelay, func() {
		// 执行缓存失效
		p.doInvalidateTableCache(cacheCtx, table)

		// 清理定时器引用
		p.queueMutex.Lock()
		delete(p.invalidationQueue, table)
		p.queueMutex.Unlock()

		// 取消上下文
		cancel()
	})

	// 将定时器加入队列
	p.invalidationQueue[table] = timer

	p.logger.Debug("缓存失效操作已加入队列",
		zap.String("table", table),
		zap.Duration("delay", p.config.InvalidateDelay),
	)
}

// doInvalidateTableCache 执行缓存失效
func (p *GormCachePlugin) doInvalidateTableCache(ctx context.Context, table string) {
	pattern := fmt.Sprintf("%s:%s:*", p.config.TablePrefix, table)

	// 添加重试机制，提高缓存失效的可靠性
	maxRetries := 3
	for attempt := 1; attempt <= maxRetries; attempt++ {
		if err := p.cache.DeletePattern(ctx, pattern); err != nil {
			if attempt < maxRetries {
				p.logger.Warn("缓存失效失败，准备重试",
					zap.String("table", table),
					zap.String("pattern", pattern),
					zap.Int("attempt", attempt),
					zap.Error(err),
				)
				// 短暂延迟后重试
				time.Sleep(time.Duration(attempt) * 100 * time.Millisecond)
				continue
			}

			p.logger.Warn("失效表缓存失败",
				zap.String("table", table),
				zap.String("pattern", pattern),
				zap.Int("attempts", maxRetries),
				zap.Error(err),
			)
			return
		}

		// 成功删除，记录日志并退出
		p.logger.Debug("表缓存已失效",
			zap.String("table", table),
			zap.String("pattern", pattern),
		)
		return
	}
}

// updateStats 更新统计信息
func (p *GormCachePlugin) updateStats(operation, table string) {
	// 这里可以接入Prometheus等监控系统
	p.logger.Debug("缓存统计",
		zap.String("operation", operation),
		zap.String("table", table),
	)
}

// ================ 高级功能 ================

// WarmupCache 预热缓存
func (p *GormCachePlugin) WarmupCache(ctx context.Context, db *gorm.DB, queries []string) error {
	if !p.config.EnableWarmup {
		return fmt.Errorf("缓存预热未启用")
	}

	for _, query := range queries {
		if err := db.Raw(query).Error; err != nil {
			p.logger.Warn("缓存预热失败",
				zap.String("query", query),
				zap.Error(err),
			)
		}
	}

	return nil
}

// GetCacheStats 获取缓存统计
func (p *GormCachePlugin) GetCacheStats(ctx context.Context) (map[string]interface{}, error) {
	stats, err := p.cache.Stats(ctx)
	if err != nil {
		return nil, err
	}

	return map[string]interface{}{
		"hits":        stats.Hits,
		"misses":      stats.Misses,
		"keys":        stats.Keys,
		"memory":      stats.Memory,
		"connections": stats.Connections,
		"config":      p.config,
	}, nil
}

// SetCacheEnabled 设置缓存启用状态
func (p *GormCachePlugin) SetCacheEnabled(db *gorm.DB, enabled bool) *gorm.DB {
	return db.Set("cache:enabled", enabled)
}

// SetCacheDisabled 设置缓存禁用状态
func (p *GormCachePlugin) SetCacheDisabled(db *gorm.DB, disabled bool) *gorm.DB {
	return db.Set("cache:disabled", disabled)
}

// SetCacheTTL 设置缓存TTL
func (p *GormCachePlugin) SetCacheTTL(db *gorm.DB, ttl time.Duration) *gorm.DB {
	return db.Set("cache:ttl", ttl)
}