package cardholder

import (
	"apigame/dto"
	"apigame/models"
	"apigame/service/constd"
	"apigame/util/util-lx/lxalilog"
	"apigame/util/util-lx/lxtime"
	"apigame/util/uttype"
)

// SaveData 存储数据
func SaveData(gameId string, d *dto.CardHolderData) {
	d.UpdateTime = lxtime.NowUninx()
	d.Encode()

	dto.Update(dto.DbCommon, gameId, d)
}

func _LoadData(gameId string, uid int64) (d *dto.CardHolderData) {
	d = dto.NewCardHolderData(uid)

	has, err := dto.First(dto.DbCommon, gameId, d)
	if err != nil {
		lxalilog.Errors(err, "cardholder._LoadData", gameId, uid)
		return
	}
	// 解析
	if has {
		d.Decode()
	} else {
		d.Init(uid)
		dto.Insert(dto.DbCommon, gameId, d)
	}
	return
}

// LoadData 获取数据 外部接口
func LoadData(gameId string, uid int64, configId int64) (d *dto.CardHolderData) {
	d = _LoadData(gameId, uid)
	// 如果当前有上线活动(活动ID不为0)，且活动ID和玩家数据不同，说明活动已切换 需更新
	if configId != 0 &&
		configId != d.ActivityId {
		d.ActivityId = configId
		d.Details = dto.NewCardHolderDataDetails()
		SaveData(gameId, d)
	}
	return
}

// CheckStatus 判断活动是否开启
func CheckStatus(conf *CardActivityConfig) string {
	sec := lxtime.NowUninx()
	if conf.Id == 0 {
		return constd.RECODE_MERGE_CARDHOLDER_NOTOPEN1_ERROR
	}
	if sec < conf.Raw.StartTime {
		return constd.RECODE_MERGE_CARDHOLDER_NOTOPEN1_ERROR
	}
	if sec > conf.Raw.EndTime {
		return constd.RECODE_MERGE_CARDHOLDER_NOTOPEN2_ERROR
	}
	return constd.RECODE_OK
}

// CheckGameData 检查游戏数据 轮次等
func CheckGameData(d *dto.CardHolderData, conf *CardActivityConfig) string {
	if d.Details.Round > conf.Raw.Round {
		return constd.RECODE_MERGE_CARDHOLDER_ROUNDFINISH_ERROR
	}
	return constd.RECODE_OK
}

// GetUserSequenceIdAndCohort 获取 用户序列组ID(sequenceId) 用户分组(cohort)
func GetUserSequenceIdAndCohort(uid int64) (sequenceId, cohort string) {
	// todo 这里后续要对接
	sequenceId = "1"
	cohort = "1"
	return
}

// GetOneFromArray 从配置的数组里获取一个值 scale=之前刻度
func GetOneFromArray(array []string, scale int) string {
	length := len(array)
	if length < 1 {
		return ""
	}
	if length == 1 {
		return array[0]
	}
	return array[scale%length]
}

// GetListFromArray 从配置的数组里获取一组值 scale=之前刻度 count=数目
func GetListFromArray(array []string, scale, count int) []string {
	list := make([]string, 0)
	if count < 0 {
		return list
	}
	s := scale
	for i := 0; i < count; i++ {
		one := GetOneFromArray(array, s)
		list = append(list, one)
		s++
	}
	return list
}

// GetNewCard 按顺序查找数目最少的一张卡抽取
func GetNewCard(gameData *dto.CardHolderData, conf *CardActivityConfig) int {
	if len(conf.CardConfig) < 1 {
		return 0
	}
	rate := int64(100000000)
	list := make([]int64, 0)
	for id, _ := range conf.CardConfig {
		count, _ := gameData.Details.Cards[id]
		index := int64(count)*rate + int64(id)
		list = append(list, index)
	}

	indexMin := uttype.Min(list...)
	return int(indexMin % rate)
}

// CheckAlbumFinish 判断卡组是否已集齐
func CheckAlbumFinish(albumId int, gameData *dto.CardHolderData, config *CardActivityConfig) bool {
	for _, conf := range config.CardConfig {
		if conf.SetId == albumId {
			count := gameData.Details.Cards[conf.Id]
			if count < 1 {
				return false
			}
		}
	}
	return true
}

// CheckRoundFinish 判断轮次是否已集齐(所有卡组集齐)
func CheckRoundFinish(gameData *dto.CardHolderData, config *CardActivityConfig) bool {
	for _, conf := range config.AlbumConfig {
		count := gameData.Details.Album[conf.SetId]
		if count < 1 {
			return false
		}
	}
	return true
}

// HandleNextRound 处理轮次完成 保留卡包 星级序列刻度 卡牌序列刻度
func HandleNextRound(gameData *dto.CardHolderData) {
	gameData.Details.Round += 1
	gameData.Details.Cards = make(map[int]int)
	gameData.Details.Album = make(map[int]int)
}

func GetInfo(gameData *dto.CardHolderData, conf *CardActivityConfig) models.CardHolderInfo {
	info := models.CardHolderInfo{
		Cards: make(map[int]int),
		Album: make(map[int]int),
		Round: 0,
	}
	for i, i2 := range gameData.Details.Cards {
		info.Cards[i] = i2
	}
	for i, i2 := range gameData.Details.Album {
		info.Album[i] = i2
	}
	info.Round = gameData.Details.Round
	return info
}