import (
    "context"
    "encoding/json"

    "github.com/redis/go-redis/v9"
    xCache "github.com/bamboo-services/bamboo-base-go/major/cache"
)

type UserConfig struct {
    Theme    string `json:"theme"`
    Language string `json:"language"`
    Timezone string `json:"timezone"`
}

type UserConfigCache struct {
    *xCache.Cache
}

// Get 获取单个配置项
func (c *UserConfigCache) Get(ctx context.Context, userID string, field string) (*string, bool, error) {
    key := "user:config:" + userID

    val, err := c.RDB.HGet(ctx, key, field).Result()
    if err == redis.Nil {
        return nil, false, nil
    }
    if err != nil {
        return nil, false, err
    }

    return &val, true, nil
}

// Set 设置单个配置项
func (c *UserConfigCache) Set(ctx context.Context, userID string, field string, value *string) error {
    key := "user:config:" + userID
    return c.RDB.HSet(ctx, key, field, *value).Err()
}

// GetAll 获取所有配置
func (c *UserConfigCache) GetAll(ctx context.Context, userID string) (map[string]string, error) {
    key := "user:config:" + userID

    result, err := c.RDB.HGetAll(ctx, key).Result()
    if err != nil {
        return nil, err
    }

    return result, nil
}

// SetAll 批量设置配置
func (c *UserConfigCache) SetAll(ctx context.Context, userID string, fields map[string]*string) error {
    key := "user:config:" + userID

    data := make(map[string]interface{})
    for field, value := range fields {
        if value != nil {
            data[field] = *value
        }
    }

    return c.RDB.HSet(ctx, key, data).Err()
}

// Exists 检查配置项是否存在
func (c *UserConfigCache) Exists(ctx context.Context, userID string, field string) (bool, error) {
    key := "user:config:" + userID
    return c.RDB.HExists(ctx, key, field).Result()
}

// Remove 删除配置项
func (c *UserConfigCache) Remove(ctx context.Context, userID string, fields ...string) error {
    key := "user:config:" + userID
    return c.RDB.HDel(ctx, key, fields...).Err()
}

// Delete 删除所有配置
func (c *UserConfigCache) Delete(ctx context.Context, userID string) error {
    key := "user:config:" + userID
    return c.RDB.Del(ctx, key).Err()
}

type UserConfigService struct {
    cache *UserConfigCache
}

func NewUserConfigService(cache *xCache.Cache) *UserConfigService {
    return &UserConfigService{
        cache: &UserConfigCache{Cache: cache},
    }
}

// GetTheme 获取用户主题
func (s *UserConfigService) GetTheme(ctx context.Context, userID string) (string, error) {
    theme, exists, err := s.cache.Get(ctx, userID, "theme")
    if err != nil {
        return "", err
    }
    if !exists {
        return "default", nil
    }
    return *theme, nil
}

// UpdateTheme 更新用户主题
func (s *UserConfigService) UpdateTheme(ctx context.Context, userID string, theme string) error {
    // 更新数据库
    if err := s.updateThemeInDB(userID, theme); err != nil {
        return err
    }

    // 更新缓存
    return s.cache.Set(ctx, userID, "theme", &theme)
}

// GetAllConfig 获取所有配置
func (s *UserConfigService) GetAllConfig(ctx context.Context, userID string) (map[string]string, error) {
    config, err := s.cache.GetAll(ctx, userID)
    if err != nil {
        return nil, err
    }

    // 如果缓存为空，从数据库加载
    if len(config) == 0 {
        config, err = s.loadConfigFromDB(userID)
        if err != nil {
            return nil, err
        }

        // 写入缓存
        fields := make(map[string]*string)
        for k, v := range config {
            val := v
            fields[k] = &val
        }
        _ = s.cache.SetAll(ctx, userID, fields)
    }

    return config, nil
}

// ResetConfig 重置配置
func (s *UserConfigService) ResetConfig(ctx context.Context, userID string) error {
    // 删除数据库配置
    if err := s.deleteConfigFromDB(userID); err != nil {
        return err
    }

    // 删除缓存
    return s.cache.Delete(ctx, userID)
}