package services

import (
	"app/commons/model/entity"
	"fmt"
	"time"
)

// tips:
// 内存中获取常用数据
// 用户信息 指标信息 等级配置...
// 如果希望拿到最新数据 务必刷新所有数据

// 获取用户信息 - 缓存

var userMap map[int64]*entity.User
var userUidMap map[string]*entity.User
var userExpTime int64 = 0

func (s *CommonService) UserInfoFromCache(userId int64) (*entity.User, error) {
	if userMap == nil {
		if err := s.RefreshUserMap(); err != nil {
			return nil, err
		}
	}
	v, ok := userMap[userId]
	if ok {
		return v, nil
	}
	return nil, fmt.Errorf("user not found")
}

func (s *CommonService) UserInfoFromCacheByUid(uid string) (*entity.User, error) {
	if userUidMap == nil || userExpTime < time.Now().Unix() {
		if err := s.RefreshUserMap(); err != nil {
			return nil, err
		}
	}
	v, ok := userUidMap[uid]
	if ok {
		return v, nil
	}
	return nil, fmt.Errorf("user :%s not found", uid)
}

func (s *CommonService) AllUserFromCache() (map[int64]*entity.User, error) {
	if err := s.RefreshUserQuotaMap(); err != nil {
		return nil, err
	}
	return userMap, nil
}

func (s *CommonService) RefreshUserMap() error {
	userMap = make(map[int64]*entity.User)
	userUidMap = make(map[string]*entity.User)
	items, err := s.BatchUser(s.DB().Where("1=1"))
	if err != nil {
		return err
	}
	for _, item := range items {
		userMap[item.Id] = item
		userUidMap[item.Uid] = item
	}
	userExpTime = time.Now().Add(time.Second * 120).Unix()
	return nil
}

// 获取用户指标信息

var userQuotaMap map[int64]*entity.UserQuota
var userQuotaExpTime int64 = 0
var userQuotas []*entity.UserQuota

func (s *CommonService) UserQuotaFromCache(userId int64) (*entity.UserQuota, error) {
	if userQuotaMap == nil || userQuotaExpTime < time.Now().Unix() {
		if err := s.RefreshUserQuotaMap(); err != nil {
			return nil, err
		}
	}
	v, ok := userQuotaMap[userId]
	if ok {
		return v, nil
	}
	return nil, fmt.Errorf("user not found")
}

// 强制刷新用户指标map 并获得

func (s *CommonService) MustNewUserQuotaMapFromCache() (map[int64]*entity.UserQuota, error) {
	if err := s.RefreshUserQuotaMap(); err != nil {
		return nil, err
	}
	return userQuotaMap, nil
}

func (s *CommonService) RefreshUserQuotaMap() error {
	var err error
	userQuotaMap = make(map[int64]*entity.UserQuota)
	userQuotas, err = s.BatchUserQuota(s.DB().Where("1=1"))
	if err != nil {
		return err
	}
	for _, item := range userQuotas {
		userQuotaMap[item.UserId] = item
	}
	userQuotaExpTime = time.Now().Add(time.Second * 120).Unix()
	return nil
}

// 等级

var sysLevelConfigMap map[int]*entity.SysLevelConfig

func (s *CommonService) LevelConfigFromCache(level int) (*entity.SysLevelConfig, error) {
	if sysLevelConfigMap == nil {
		if err := s.RefreshLevelConfigMap(); err != nil {
			return nil, err
		}
	}
	if v, ok := sysLevelConfigMap[level]; ok {
		return v, nil
	}
	return nil, fmt.Errorf("level not found")
}

func (s *CommonService) LevelConfigMapFromCache() (map[int]*entity.SysLevelConfig, error) {
	if err := s.RefreshLevelConfigMap(); err != nil {
		return nil, err
	}
	return sysLevelConfigMap, nil
}

func (s *CommonService) RefreshLevelConfigMap() error {
	sysLevelConfigMap = make(map[int]*entity.SysLevelConfig)
	items, err := s.AllSysLevelConfig(s.DB().Where("1=1"))
	if err != nil {
		return err
	}
	for _, item := range items {
		sysLevelConfigMap[item.Level] = item
	}
	return nil
}