package cardholder

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

// HandleActivityInfo 活动信息
func HandleActivityInfo(req *models.ReqCardHolderActivityInfo) (code string, rsp models.RspCardHolderActivityInfo) {
	rsp = models.RspCardHolderActivityInfo{}
	code = constd.RECODE_OK

	// 尝试更新配置
	config, _ := TryUpdateConfig(req.GameID)
	rsp.ActivityId = config.Id
	rsp.PreviewTime = config.Raw.PreviewTime
	rsp.StartTime = config.Raw.StartTime
	rsp.EndTime = config.Raw.EndTime

	return
}

// HandleInfo 卡包信息
func HandleInfo(req *models.ReqCardHolderInfo) (code string, rsp models.RspCardHolderInfo) {
	rsp = models.RspCardHolderInfo{}
	code = constd.RECODE_OK

	// 尝试更新配置
	config, hasConfig := TryUpdateConfig(req.GameID)
	if !hasConfig {
		code = constd.RECODE_MERGE_CARDHOLDER_NOTOPEN_ERROR
		return
	}

	// 判断预告时间
	sec := lxtime.NowUninx()
	if sec < config.Raw.StartTime {
		code = constd.RECODE_MERGE_CARDHOLDER_NOTOPEN_ERROR
		return
	}

	// 读取游戏数据
	gameData := LoadData(req.GameID, req.UID, config.Id)

	rsp.CardHolderInfo = GetInfo(gameData, config)

	return
}

// HandleGetNew 获取卡包
func HandleGetNew(req *models.ReqCardHolderGetNew) (code string, rsp models.RspCardHolderGetNew) {
	rsp = models.RspCardHolderGetNew{}
	code = constd.RECODE_OK

	// 尝试更新配置
	config, hasConfig := TryUpdateConfig(req.GameID)
	if !hasConfig {
		code = constd.RECODE_MERGE_CARDHOLDER_NOTOPEN_ERROR
		return
	}

	// 检查活动状态
	code = CheckStatus(config)
	if code != constd.RECODE_OK {
		return
	}
	// 检查卡包ID
	_, okCardholderConfig := config.CardholderConfig[strconv.Itoa(req.Id)]
	if !okCardholderConfig {
		code = constd.RECODE_MERGE_CARDHOLDER_CARDHOLDERID_ERROR
		return
	}
	// 检查卡包数量
	if req.Count < 1 {
		code = constd.RECODE_MERGE_CARDHOLDER_COUNTILLEGAL_ERROR
		return
	}

	// 读取游戏数据
	gameData := LoadData(req.GameID, req.UID, config.Id)
	// 检查游戏数据 轮次等
	code = CheckGameData(gameData, config)
	if code != constd.RECODE_OK {
		return
	}

	gameData.Details.Cardholder[req.Id] += req.Count
	SaveData(req.GameID, gameData)

	// 返回信息
	rsp.CardHolderInfo = GetInfo(gameData, config)

	sequenceId, cohort := GetUserSequenceIdAndCohort(req.UID)
	// 记录日志
	recordBase := dto.NewCardHolderRecordBase(gameData.Uid, sequenceId, cohort, config.Id, gameData.Details.Round)
	dto.SaveRecord(req.GameID, dto.NewCardHolderRecordGetNew(recordBase,
		req.Id, req.Count))

	return
}

// HandleOpen 打开卡包
func HandleOpen(req *models.ReqCardHolderOpen) (code string, rsp models.RspCardHolderOpen) {
	rsp = models.RspCardHolderOpen{}
	code = constd.RECODE_OK

	// 尝试更新配置
	config, hasConfig := TryUpdateConfig(req.GameID)
	if !hasConfig {
		code = constd.RECODE_MERGE_CARDHOLDER_NOTOPEN_ERROR
		return
	}

	// 检查活动状态
	code = CheckStatus(config)
	if code != constd.RECODE_OK {
		return
	}
	// 检查卡包ID
	confCardholder, okCardholderConfig := config.CardholderConfig[strconv.Itoa(req.Id)]
	if !okCardholderConfig {
		code = constd.RECODE_MERGE_CARDHOLDER_CARDHOLDERID_ERROR
		return
	}

	// 读取游戏数据
	gameData := LoadData(req.GameID, req.UID, config.Id)
	// 检查游戏数据 轮次等
	code = CheckGameData(gameData, config)
	if code != constd.RECODE_OK {
		return
	}

	// 判断卡包数目
	countOld, _ := gameData.Details.Cardholder[req.Id]
	if countOld < 1 {
		code = constd.RECODE_MERGE_CARDHOLDER_CARDHOLDER_NOTENOUGH_ERROR
		return
	}

	// 开始处理抽卡
	sequenceId, cohort := GetUserSequenceIdAndCohort(req.UID)
	//logs.Debug("wjwdbg 用户序列组IDsequenceId", sequenceId)
	//logs.Debug("wjwdbg 用户分组IDcohort:", cohort)
	if confCardholder.IsNew != 0 {
		// 如果是新卡包 按顺序查找数目最少的一张卡抽取
		cardId := GetNewCard(gameData, config)
		//logs.Debug("wjwdbg 抽取新卡ID:", cardId)
		// 增加卡牌
		gameData.Details.Cards[cardId] += 1
		rsp.NewCards = append(rsp.NewCards, cardId)
	} else {
		getCardFunc := func(cardConfigId string) {
			confCardSequence, hasCardSequence := config.FindCardSequenceConfig(cardConfigId, sequenceId, cohort)
			if hasCardSequence {
				combineId := CombineIdSequenceIdCohort(cardConfigId, sequenceId, cohort)
				scale := gameData.Details.CardSequenceScales[combineId]
				cardId := GetOneFromArray(confCardSequence.CardIdLists, scale)
				cardIdInt := uttype.StringToInt(cardId)
				// 增加刻度
				gameData.Details.CardSequenceScales[combineId] = scale + 1
				// 增加卡牌
				gameData.Details.Cards[cardIdInt] += 1
				//logs.Debug("wjwdbg😊 抽取卡牌ID:", cardIdInt)
				rsp.NewCards = append(rsp.NewCards, cardIdInt)
			}
		}
		// 正常抽卡
		// 先抽保底卡
		if confCardholder.GuaranteedStarCardId != "0" {
			getCardFunc(confCardholder.GuaranteedStarCardId)
			//logs.Debug("wjwdbg 保底卡牌配置ID:", confCardholder.GuaranteedStarCardId)
		}
		// 非保底卡
		if confCardholder.NormalCardNumber > 0 {
			count := confCardholder.NormalCardNumber
			confNormalCardStar, hasNormalCardStar := config.FindNormalCardStarConfig(confCardholder.MinimumGuaranteeCardId, sequenceId, cohort)
			if hasNormalCardStar {
				combineIdStar := CombineIdSequenceIdCohort(confCardholder.MinimumGuaranteeCardId, sequenceId, cohort)
				scaleStar := gameData.Details.StarSequenceScales[combineIdStar]
				starIds := GetListFromArray(confNormalCardStar.NormalCardSequenceIds, scaleStar, count)
				// 增加星级刻度
				gameData.Details.StarSequenceScales[combineIdStar] = scaleStar + count
				//logs.Debug("wjwdbg 非保底卡星级ID:", confCardholder.MinimumGuaranteeCardId)
				//logs.Debug("wjwdbg 非保底卡星级抽取序列:", starIds)
				// 遍历星级刻度抽取n张卡牌
				for _, id := range starIds {
					getCardFunc(id)
				}
			}
		}
	}

	// 删除一个卡包
	gameData.Details.Cardholder[req.Id] = countOld - 1

	// 存档
	SaveData(req.GameID, gameData)

	// 记录日志
	recordBase := dto.NewCardHolderRecordBase(gameData.Uid, sequenceId, cohort, config.Id, gameData.Details.Round)
	dto.SaveRecord(req.GameID, dto.NewCardHolderRecordOpen(recordBase,
		req.Id, utjson.JsonString(rsp.NewCards)))

	//logs.Debug("wjwdbg 获取卡牌列表:", rsp.NewCards)
	uttype.Shuffle(rsp.NewCards)
	//logs.Debug("wjwdbg 获取卡牌列表打乱:", rsp.NewCards)

	// 返回信息
	rsp.CardHolderInfo = GetInfo(gameData, config)

	return
}

// HandleGetRewardAlbum 领取卡组奖励
func HandleGetRewardAlbum(req *models.ReqCardHolderGetRewardAlbum) (code string, rsp models.RspCardHolderGetRewardAlbum) {
	rsp = models.RspCardHolderGetRewardAlbum{}
	code = constd.RECODE_OK

	// 尝试更新配置
	config, hasConfig := TryUpdateConfig(req.GameID)
	if !hasConfig {
		code = constd.RECODE_MERGE_CARDHOLDER_NOTOPEN_ERROR
		return
	}

	// 检查活动状态
	code = CheckStatus(config)
	if code != constd.RECODE_OK {
		return
	}
	// 检查卡组ID
	albumId := strconv.Itoa(req.Id)
	confAlbum, okAlbum := config.AlbumConfig[albumId]
	if !okAlbum {
		code = constd.RECODE_MERGE_CARDHOLDER_ALBUMID_ERROR
		return
	}

	// 读取游戏数据
	gameData := LoadData(req.GameID, req.UID, config.Id)
	// 检查游戏数据 轮次等
	code = CheckGameData(gameData, config)
	if code != constd.RECODE_OK {
		return
	}

	// 是否已领过
	countGot := gameData.Details.Album[albumId]
	if countGot > 0 {
		code = constd.RECODE_MERGE_CARDHOLDER_ALBUM_HASGOT_ERROR
		return
	}
	// 检查卡组内卡是否集齐
	for _, conf := range config.CardConfig {
		if conf.SetId == albumId {
			count := gameData.Details.Cards[conf.Id]
			if count < 1 {
				code = constd.RECODE_MERGE_CARDHOLDER_ALBUM_NOTFINISH_ERROR
				return
			}
		}
	}

	gameData.Details.Album[albumId] += 1
	SaveData(req.GameID, gameData)

	// 当前轮次
	round := gameData.Details.Round
	// 返回奖励
	rsp.Award = confAlbum.Rewards[uttype.IntToString(round)]

	// 返回信息
	rsp.CardHolderInfo = GetInfo(gameData, config)

	sequenceId, cohort := GetUserSequenceIdAndCohort(req.UID)
	// 记录日志
	recordBase := dto.NewCardHolderRecordBase(gameData.Uid, sequenceId, cohort, config.Id, gameData.Details.Round)
	dto.SaveRecord(req.GameID, dto.NewCardHolderRecordRewardAlbum(recordBase,
		req.Id, rsp.Award))

	return
}

// HandleGetRewardRound 领取轮次奖励
func HandleGetRewardRound(req *models.ReqCardHolderGetRewardRound) (code string, rsp models.RspCardHolderGetRewardRound) {
	rsp = models.RspCardHolderGetRewardRound{}
	code = constd.RECODE_OK

	// 尝试更新配置
	config, hasConfig := TryUpdateConfig(req.GameID)
	if !hasConfig {
		code = constd.RECODE_MERGE_CARDHOLDER_NOTOPEN_ERROR
		return
	}

	// 检查活动状态
	code = CheckStatus(config)
	if code != constd.RECODE_OK {
		return
	}

	// 读取游戏数据
	gameData := LoadData(req.GameID, req.UID, config.Id)
	// 检查游戏数据 轮次等
	code = CheckGameData(gameData, config)
	if code != constd.RECODE_OK {
		return
	}

	// 判断所有卡组是否已经集齐
	// 检查卡组内卡是否集齐
	for _, conf := range config.AlbumConfig {
		count := gameData.Details.Album[conf.SetId]
		if count < 1 {
			code = constd.RECODE_MERGE_CARDHOLDER_ROUND_NOTFINISH_ERROR
			return
		}
	}

	// 当前轮次
	round := gameData.Details.Round
	// 返回奖励
	rsp.Award = config.Awards[uttype.IntToString(round)]

	sequenceId, cohort := GetUserSequenceIdAndCohort(req.UID)
	// 记录日志
	recordBase := dto.NewCardHolderRecordBase(gameData.Uid, sequenceId, cohort, config.Id, gameData.Details.Round)
	dto.SaveRecord(req.GameID, dto.NewCardHolderRecordRewardRound(recordBase,
		rsp.Award))

	// 处理轮次完成
	HandleNextRound(gameData)
	SaveData(req.GameID, gameData)

	// 返回信息
	rsp.CardHolderInfo = GetInfo(gameData, config)

	return
}