package campaign

import (
	"joybuywork/internal/app"
	"joybuywork/internal/consts"
	"joybuywork/internal/consts/ckey"
	"joybuywork/internal/repository/cache"
	"joybuywork/internal/repository/finder"
	"joybuywork/internal/repository/model"
	"joybuywork/internal/repository/mtype"
	"joybuywork/internal/service/provider/cachecurd"
	"joybuywork/internal/service/provider/stocks"
	"joybuywork/internal/utils"
	"joybuywork/internal/utils/logic"
	"joybuywork/internal/utils/timez"
	"joybuywork/internal/utils/verify"
	pb "joybuywork/proto/go_proto/w_campaign"
	"joybuywork/proto/go_proto/workerr"
	"fmt"
	"time"

	"gorm.io/gen/field"
)

type RewardDetail struct {
	logic.Logic
	Req *pb.RewardDetailReq
	Res *pb.RewardDetailRes

	rewardLangList []*model.RewardLang

	levelMap map[int64]string

	helpMap map[int64][]*model.FissionCampaignRewardHelp

	ruleMap map[int64]*model.FissionCampaignRewardRule
}

func (s *RewardDetail) Run() error {
	return logic.Run(s)
}

func (s *RewardDetail) Exec() (err error) {
	cpn, conf, err := s.campaign()
	if err != nil {
		return
	}

	err = s.reward(cpn, conf)
	if err != nil {
		return
	}

	err = s.fission(cpn)
	if err != nil {
		return
	}

	err = s.task(cpn)
	if err != nil {
		return
	}

	return
}

func (s *RewardDetail) campaign() (cpn *model.FissionCampaign, conf *model.FissionCampaignConfig, err error) {
	cpn, err = finder.Campaign(s.Ctx, s.Req.GetHashId())
	if err != nil {
		err = s.BE().CacheError(err)
		return
	}

	if cpn == nil {
		err = workerr.NotFound("not found cpn")
		return
	}

	conf, err = cache.NewCampaignConfig(s.Ctx).FindByCampaignId(cpn.ID)
	if err != nil {
		err = s.BE().CacheError(err)
		return
	}

	s.Res.RewardGroup = int32(conf.RewardGroup)

	return
}

func (s *RewardDetail) task(cpn *model.FissionCampaign) (err error) {
	m := s.GetDao().FissionCampaignReward
	list, err := m.WithContext(s.Ctx).Where(m.CampaignID.Eq(cpn.ID), m.RewardType.Eq(mtype.FissionCampaignRewardTypeTask), m.IsDel.Eq(mtype.No)).Find()
	if err != nil {
		err = s.BE().MysqlError(err)
		return
	}

	if len(list) == 0 {
		return
	}

	s._hasTask()

	titleMap, stockMap, selectMap, err := s._mapData(list, false)
	if err != nil {
		return
	}

	var rewardIds []int64
	for _, reward := range list {
		rewardIds = append(rewardIds, reward.ID)
	}

	taskM := s.GetDao().FissionCampaignTask
	tasks, err := taskM.WithContext(s.Ctx).Where(taskM.CampaignID.Eq(cpn.ID), taskM.RewardID.In(rewardIds...)).Find()
	if err != nil {
		err = s.BE().MysqlError(err)
		return
	}

	var condIds []int64
	var condRewardMap = make(map[int64]int64)
	for _, task := range tasks {
		condId := utils.FissionCampaignTaskMarkCondOneCondId(task.TaskMark)
		condIds = append(condIds, condId)
		condRewardMap[condId] = task.RewardID

	}

	condM := s.GetDao().FissionCampaignCond
	conds, err := condM.WithContext(s.Ctx).Where(condM.ID.In(condIds...)).Find()
	if err != nil {
		err = s.BE().MysqlError(err)
		return
	}

	var rewardTaskMap = make(map[int64]string, len(conds))
	for _, cond := range conds {
		rewardTaskMap[condRewardMap[cond.ID]] = cond.Desc
	}

	s.Res.TaskReward = make([]*pb.RewardDetailRes_Reward, 0, len(list))
	for _, reward := range list {
		one := s._one(reward, stockMap[reward.ID], selectMap[reward.ID], titleMap[reward.RewardID], false)

		one.TaskTitle = rewardTaskMap[reward.ID]

		s.Res.TaskReward = append(s.Res.TaskReward, one)
	}

	return
}

func (s *RewardDetail) reward(cpn *model.FissionCampaign, conf *model.FissionCampaignConfig) (err error) {
	if verify.InArray[int64](cpn.FissionID, consts.IdCoin, consts.IdVs, consts.IdUno) {
		return
	}

	if cpn.FissionID == consts.IdSignIn {
		s._hasAppSign()
	} else {
		s._hasApp()
	}

	m := s.GetDao().FissionCampaignReward
	list, err := m.WithContext(s.Ctx).Where(
		m.CampaignID.Eq(conf.CampaignID),
		m.RewardType.Eq(mtype.FissionCampaignRewardTypeApp),
		m.IsDel.Eq(mtype.No),
	).Order(m.Step, m.Sort, m.ID).Find()
	if err != nil {
		return s.BE().MysqlError(err)
	}

	if len(list) == 0 {
		return
	}

	showSelect := verify.InArray[int64](cpn.FissionID, consts.IdKeep)

	titleMap, stockMap, selectMap, err := s._mapData(list, showSelect)
	if err != nil {
		return
	}

	switch conf.RewardGroup {
	case mtype.FissionRewardGroupNormal:
		return s._normal(list, stockMap, selectMap, titleMap, showSelect)
	case mtype.FissionRewardGroupUserLevel:
		return s._userLv(cpn, list, stockMap, selectMap, titleMap, showSelect)
	case mtype.FissionRewardGroupLang:
		return s._lang(list, stockMap, selectMap, titleMap, showSelect)
	case mtype.FissionRewardGroupLangAndUserLevel:
		return s._langUserLv(cpn, list, stockMap, selectMap, titleMap, showSelect)
	case mtype.FissionRewardGroupCountry:
		return s._country(list, stockMap, selectMap, titleMap, showSelect)
	}

	return
}

func (s *RewardDetail) _normal(list []*model.FissionCampaignReward, stockMap, selectMap map[int64]int64, titleMap map[int64]string, showSelect bool) (err error) {
	s.Res.Normal = make([]*pb.RewardDetailRes_Reward, 0, len(list))
	for _, reward := range list {
		s.Res.Normal = append(s.Res.Normal, s._one(reward, stockMap[reward.ID], selectMap[reward.ID], titleMap[reward.RewardID], showSelect))
	}

	return
}

func (s *RewardDetail) _userLv(cpn *model.FissionCampaign, list []*model.FissionCampaignReward, stockMap, selectMap map[int64]int64, titleMap map[int64]string, showSelect bool) (err error) {
	m := s.GetDao().FissionUserLevel
	lvList, err := m.WithContext(s.Ctx).Where(m.ProjectID.Eq(cpn.ProjectID), m.DeletedAt.Eq(0)).Find()
	if err != nil {
		err = s.BE().MysqlError(err)
		return
	}

	lvMap := make(map[int64]string, len(lvList))
	for _, v := range lvList {
		lvMap[v.ID] = v.Title
	}

	var levelIds []int64
	var levelRewardMap = make(map[int64][]*model.FissionCampaignReward)
	for _, v := range list {
		if _, ok := levelRewardMap[v.LevelID]; !ok {
			levelIds = append(levelIds, v.LevelID)
		}

		levelRewardMap[v.LevelID] = append(levelRewardMap[v.LevelID], v)
	}

	s.Res.UserLevel = make([]*pb.RewardDetailRes_UserLevelOne, 0, len(levelIds))
	for _, v := range levelIds {
		one := &pb.RewardDetailRes_UserLevelOne{
			LevelId:    v,
			LevelTitle: lvMap[v],
			Rewards:    make([]*pb.RewardDetailRes_Reward, 0, len(levelRewardMap[v])),
		}
		for _, reward := range levelRewardMap[v] {
			one.Rewards = append(one.Rewards, s._one(reward, stockMap[reward.ID], selectMap[reward.ID], titleMap[reward.RewardID], showSelect))
		}
		s.Res.UserLevel = append(s.Res.UserLevel, one)
	}

	return
}

func (s *RewardDetail) _lang(list []*model.FissionCampaignReward, stockMap, selectMap map[int64]int64, titleMap map[int64]string, showSelect bool) (err error) {
	var langMarks []string
	var langRewardMap = make(map[string][]*model.FissionCampaignReward)
	for _, v := range list {
		if _, ok := langRewardMap[v.LangMark]; !ok {
			langMarks = append(langMarks, v.LangMark)
		}

		langRewardMap[v.LangMark] = append(langRewardMap[v.LangMark], v)
	}

	s.Res.Langs = make([]*pb.RewardDetailRes_LangOne, 0, len(langMarks))
	for _, v := range langMarks {
		one := &pb.RewardDetailRes_LangOne{
			LangMark: v,
			Rewards:  make([]*pb.RewardDetailRes_Reward, 0, len(langRewardMap[v])),
		}
		for _, reward := range langRewardMap[v] {
			one.Rewards = append(one.Rewards, s._one(reward, stockMap[reward.ID], selectMap[reward.ID], titleMap[reward.RewardID], showSelect))
		}
		s.Res.Langs = append(s.Res.Langs, one)
	}

	return
}

func (s *RewardDetail) _langUserLv(cpn *model.FissionCampaign, list []*model.FissionCampaignReward, stockMap, selectMap map[int64]int64, titleMap map[int64]string, showSelect bool) (err error) {
	m := s.GetDao().FissionUserLevel
	lvList, err := m.WithContext(s.Ctx).Where(m.ProjectID.Eq(cpn.ProjectID), m.DeletedAt.Eq(0)).Find()
	if err != nil {
		err = s.BE().MysqlError(err)
		return
	}

	lvMap := make(map[int64]string, len(lvList))
	for _, v := range lvList {
		lvMap[v.ID] = v.Title
	}

	var langMarks []string
	var langUserLv = make(map[string][]int64)
	var langUserLvRewardMap = make(map[string]map[int64][]*model.FissionCampaignReward)

	for _, v := range list {

		if _, ok := langUserLv[v.LangMark]; !ok {
			langMarks = append(langMarks, v.LangMark)
			langUserLv[v.LangMark] = nil
			langUserLvRewardMap[v.LangMark] = make(map[int64][]*model.FissionCampaignReward)
		}

		if _, ok := langUserLvRewardMap[v.LangMark][v.LevelID]; !ok {
			langUserLv[v.LangMark] = append(langUserLv[v.LangMark], v.LevelID)
		}

		langUserLvRewardMap[v.LangMark][v.LevelID] = append(langUserLvRewardMap[v.LangMark][v.LevelID], v)
	}

	s.Res.LangUserLevel = make([]*pb.RewardDetailRes_LangUserLevelOne, 0, len(langMarks))
	for _, v := range langMarks {
		one := &pb.RewardDetailRes_LangUserLevelOne{
			LangMark:  v,
			LevelList: make([]*pb.RewardDetailRes_UserLevelOne, 0, len(langUserLv[v])),
		}

		for _, lvId := range langUserLv[v] {
			two := &pb.RewardDetailRes_UserLevelOne{
				LevelId:    lvId,
				LevelTitle: lvMap[lvId],
				Rewards:    make([]*pb.RewardDetailRes_Reward, 0, len(langUserLvRewardMap[v][lvId])),
			}

			for _, reward := range langUserLvRewardMap[v][lvId] {
				two.Rewards = append(two.Rewards, s._one(reward, stockMap[reward.ID], selectMap[reward.ID], titleMap[reward.RewardID], showSelect))
			}

			one.LevelList = append(one.LevelList, two)
		}

		s.Res.LangUserLevel = append(s.Res.LangUserLevel, one)
	}

	return
}

func (s *RewardDetail) _country(list []*model.FissionCampaignReward, stockMap, selectMap map[int64]int64, titleMap map[int64]string, showSelect bool) (err error) {
	var countryMarks []string
	var countryRewardMap = make(map[string][]*model.FissionCampaignReward)
	for _, v := range list {
		if _, ok := countryRewardMap[v.CountryMark]; !ok {
			countryMarks = append(countryMarks, v.CountryMark)
		}

		countryRewardMap[v.CountryMark] = append(countryRewardMap[v.CountryMark], v)
	}

	s.Res.Country = make([]*pb.RewardDetailRes_CountryOne, 0, len(countryMarks))
	for _, v := range countryMarks {
		one := &pb.RewardDetailRes_CountryOne{
			CountryMark: v,
			Rewards:     make([]*pb.RewardDetailRes_Reward, 0, len(countryRewardMap[v])),
		}
		for _, reward := range countryRewardMap[v] {
			one.Rewards = append(one.Rewards, s._one(reward, stockMap[reward.ID], selectMap[reward.ID], titleMap[reward.RewardID], showSelect))
		}
		s.Res.Country = append(s.Res.Country, one)
	}

	return
}

func (s *RewardDetail) fission(cpn *model.FissionCampaign) (err error) {
	switch cpn.FissionID {
	case consts.IdKeep:
		return s._keep(cpn)
	case consts.IdWinTogether:
		return s._win(cpn)
	case consts.IdReferral:
		return s._referral(cpn)
	case consts.IdCoin:
		return s._coin(cpn)
	case consts.IdCash:
		return s._cash(cpn)
	case consts.IdGold:
		return s._gold(cpn)
	case consts.IdVs:
		return s._vs(cpn)
	case consts.IdUno:
		return s._uno(cpn)
	}
	return
}

func (s *RewardDetail) _uno(cpn *model.FissionCampaign) (err error) {
	s._hasUno()

	m := s.GetDao().FissionCampaignUnoGroup
	list, err := m.WithContext(s.Ctx).Where(m.CampaignID.Eq(cpn.ID)).Find()
	if err != nil {
		err = s.BE().MysqlError(err)
		return
	}

	var rewardIds []int64
	for _, v := range list {
		rewardIds = append(rewardIds, v.RewardID)
	}

	// 奖品
	rewardM := s.GetDao().FissionCampaignReward
	rewardList, err := rewardM.WithContext(s.Ctx).Where(rewardM.ID.In(rewardIds...)).Find()
	if err != nil {
		err = s.BE().MysqlError(err)
		return
	}

	var rewardMap = make(map[int64]*model.FissionCampaignReward, len(rewardList))
	for _, v := range rewardList {
		rewardMap[v.ID] = v
	}

	titleMap, stockMap, _, err := s._mapData(rewardList, false)
	if err != nil {
		return
	}

	s.Res.UnoCards = make([]*pb.RewardDetailRes_UnoCard, 0, len(list))

	type num struct {
		Mark         string `json:"mark"`
		PreIntactNum int64  `json:"pre_intact_num"`
		IntactNum    int64  `json:"intact_num"`
	}

	collectM := s.GetDao().FissionUnoCollect
	var nums []*num
	err = collectM.WithContext(s.Ctx).
		Select(
			collectM.Mark,
			collectM.PreIntactNum.Sum().As("pre_intact_num"),
			collectM.IntactNum.Sum().As("intact_num"),
		).
		Where(collectM.CampaignID.Eq(cpn.ID)).
		Group(collectM.Mark).
		Scan(&nums)
	if err != nil {
		err = s.BE().MysqlError(err)
		return
	}

	// 合并
	var numMap = make(map[string]*num)
	for _, v := range nums {
		numMap[v.Mark] = v
	}

	for _, v := range list {
		var stock, useStock int64
		var title string
		if reward, ok := rewardMap[v.RewardID]; ok {
			stock, useStock = int64(reward.Stock), stockMap[reward.ID]
			title = titleMap[reward.RewardID]
		}

		var piNum, iNum int64
		if n, ok := numMap[v.Mark]; ok {
			piNum = n.PreIntactNum
			iNum = n.IntactNum
		}

		s.Res.UnoCards = append(s.Res.UnoCards, &pb.RewardDetailRes_UnoCard{
			Id:           v.ID,
			Mark:         v.Mark,
			Title:        title,
			Stock:        stock,
			Remain:       utils.Ternary[int64](stock < useStock, 0, stock-useStock),
			PreIntactNum: piNum,
			IntactNum:    iNum,
		})
	}

	return
}

func (s *RewardDetail) _vs(cpn *model.FissionCampaign) (err error) {
	s._hasSchedule()

	conf, err := cache.NewCampaignVs(s.Ctx).FindByCampaignId(cpn.ID)
	if err != nil {
		err = s.BE().CacheError(err)
		return
	}

	teamM := s.GetDao().FissionCampaignVsTeam
	teamList, err := teamM.WithContext(s.Ctx).Where(teamM.CampaignID.Eq(cpn.ID)).Find()
	if err != nil {
		err = s.BE().MysqlError(err)
		return
	}

	var teamMap = make(map[int64]*model.FissionCampaignVsTeam, len(teamList))
	for _, v := range teamList {
		teamMap[v.ID] = v
	}

	m := s.GetDao().FissionCampaignVsSchedule
	list, err := m.WithContext(s.Ctx).Where(m.CampaignID.Eq(cpn.ID), m.VsAt.Gt(0)).Order(m.VsAt.Desc()).Find()
	if err != nil {
		err = s.BE().MysqlError(err)
		return
	}

	var scheduleIds []int64
	for _, v := range list {
		scheduleIds = append(scheduleIds, v.ID)
	}

	type voteNum struct {
		ScheduleId int64 `json:"schedule_id"`
		WinType    int32 `json:"win_type"`
		WinTeamId  int64 `json:"win_team_id"`
		Num        int64 `json:"num"`
		UserNum    int64 `json:"user_num"`
	}

	var votes []*voteNum

	voteM := s.GetDao().FissionVsVote
	voteNumField := field.NewUnsafeFieldRaw("free_vote + point_vote")
	err = voteM.WithContext(s.Ctx).
		Select(
			voteM.ScheduleID,
			voteM.WinType,
			voteM.WinTeamID,
			voteNumField.Sum().As("num"),
			voteM.ID.Count().As("user_num"),
		).
		Where(voteM.CampaignID.Eq(cpn.ID), voteM.ScheduleID.In(scheduleIds...)).
		Group(voteM.ScheduleID, voteM.WinType, voteM.WinTeamID).
		Scan(&votes)
	if err != nil {
		err = s.BE().MysqlError(err)
		return
	}

	type num struct {
		ScheduleId int64 `json:"schedule_id"`
		Num        int64 `json:"num"`
	}

	var preRewardNum []*num
	stlM := s.GetDao().FissionVsVoteSettlement
	err = stlM.WithContext(s.Ctx).Select(
		stlM.ScheduleID,
		stlM.ID.Count().As("num"),
	).Where(stlM.ScheduleID.In(scheduleIds...)).Group(stlM.ScheduleID).Scan(&preRewardNum)
	if err != nil {
		err = s.BE().MysqlError(err)
		return
	}

	var preRewardNumMap = make(map[int64]int64, len(preRewardNum))
	for _, v := range preRewardNum {
		preRewardNumMap[v.ScheduleId] = v.Num
	}

	var rewardNum []*num
	err = stlM.WithContext(s.Ctx).Select(
		stlM.ScheduleID,
		stlM.ID.Count().As("num"),
	).Where(stlM.ScheduleID.In(scheduleIds...), stlM.AcceptAt.Gt(0)).Group(stlM.ScheduleID).Scan(&rewardNum)
	if err != nil {
		err = s.BE().MysqlError(err)
		return
	}

	var rewardNumMap = make(map[int64]int64, len(rewardNum))
	for _, v := range rewardNum {
		rewardNumMap[v.ScheduleId] = v.Num
	}

	var voteNumMap = make(map[int64][]*voteNum, len(votes))
	for _, v := range votes {
		voteNumMap[v.ScheduleId] = append(voteNumMap[v.ScheduleId], v)
	}

	for _, v := range list {

		stl := v.GetSettlement()
		one := &pb.RewardDetailRes_Schedule{
			Id:           v.ID,
			VsAt:         v.VsAt,
			VoteStart:    v.VoteStart,
			VoteEnd:      v.VoteEnd,
			Teams:        nil,
			WinType:      stl.WinType,
			WinTeamId:    stl.WinTeamId,
			PreRewardNum: preRewardNumMap[v.ID],
			RewardNum:    rewardNumMap[v.ID],
			Tz:           conf.VsTz,
			Votes:        nil,
		}

		var drawNum, drawUserNum int64
		var teamNum = make(map[int64]int64)
		var teamUserNumMap = make(map[int64]int64)
		for _, vote := range voteNumMap[v.ID] {
			switch vote.WinType {
			case mtype.FissionCampaignVsScheduleWinTypeDraw:
				drawNum = vote.Num
				drawUserNum = vote.UserNum
			default:
				teamNum[vote.WinTeamId] = vote.Num
				teamUserNumMap[vote.WinTeamId] = vote.UserNum
			}
		}

		for _, id := range v.GetVsTeamIds() {
			if team, ok := teamMap[id]; ok {
				one.Teams = append(one.Teams, &pb.RewardDetailRes_Team{
					Id:      team.ID,
					Name:    team.Name,
					LogoImg: team.LogoImg,
				})
			} else {
				one.Teams = append(one.Teams, &pb.RewardDetailRes_Team{
					Id: id,
				})
			}

			one.Votes = append(one.Votes, &pb.RewardDetailRes_Vote{
				WinType:     mtype.FissionCampaignVsScheduleWinTypeWin,
				WinTeamId:   id,
				VoteNum:     teamNum[id],
				VoteUserNum: teamUserNumMap[id],
			})
		}

		if verify.InArray[string](mtype.FissionCampaignVsScheduleOtherVoteDraw, v.GetOtherVote()...) {
			one.Votes = append(one.Votes, &pb.RewardDetailRes_Vote{
				WinType:     mtype.FissionCampaignVsScheduleWinTypeDraw,
				VoteNum:     drawNum,
				VoteUserNum: drawUserNum,
			})
		}

		s.Res.Schedules = append(s.Res.Schedules, one)
	}

	return
}

func (s *RewardDetail) _mapData(list []*model.FissionCampaignReward, showSelect bool) (titleMap map[int64]string, stockMap, selectMap map[int64]int64, err error) {
	var ids, rewardIds []int64
	var existMap = make(map[int64]struct{})
	for _, v := range list {
		ids = append(ids, v.ID)
		if _, ok := existMap[v.RewardID]; !ok {
			rewardIds = append(rewardIds, v.RewardID)
			existMap[v.RewardID] = struct{}{}
		}
	}

	titleMap, err = s._titleMap(rewardIds)
	if err != nil {
		return
	}

	stockMap, selectMap = make(map[int64]int64, len(ids)), make(map[int64]int64, len(ids))

	stock, err := stocks.NewCampaignReward(s.Ctx, ids...)
	if err != nil {
		return
	}
	stockMap, _ = stock.AllUseStock()

	if !showSelect {
		return
	}

	selectStock, err := stocks.NewCampaignRewardSelect(s.Ctx, ids...)
	if err != nil {
		return
	}
	selectMap, _ = selectStock.AllUseStock()

	return
}

func (s *RewardDetail) _one(reward *model.FissionCampaignReward, useStock, selectNum int64, title string, showSelect bool) *pb.RewardDetailRes_Reward {
	stock := int64(reward.Stock)

	remain := utils.Ternary[int64](showSelect, stock-selectNum, stock-useStock)
	if remain < 0 {
		remain = 0
	}

	return &pb.RewardDetailRes_Reward{
		Id:        reward.ID,
		Title:     title,
		Stock:     stock,
		Remain:    remain,
		Given:     useStock,
		CanUp:     reward.IsThank == mtype.No,
		IsThank:   int32(reward.IsThank),
		SelectNum: selectNum,
		SignDay:   reward.SignDay,
	}
}

func (s *RewardDetail) _titleMap(rewardIds []int64) (titleMap map[int64]string, err error) {
	titleMap = make(map[int64]string, len(rewardIds))
	if len(rewardIds) == 0 {
		return
	}

	rewardM := s.GetDao().Reward
	rewards, err := rewardM.WithContext(s.Ctx).Where(rewardM.ID.In(rewardIds...)).Find()
	if err != nil {
		err = s.BE().MysqlError(err)
		return
	}

	for _, reward := range rewards {
		titleMap[reward.ID] = reward.RewardTitle
	}

	for _, reward := range app.FissionFixRewards {
		titleMap[reward.Id] = reward.RewardTitle
	}
	return
}

type RewardDetailNum struct {
	RewardId int64 `json:"reward_id"`
	Num      int64 `json:"num"`
}

func (s *RewardDetail) _dbNum(cpnId int64, ids []int64) (numMap map[int64]int64, err error) {
	var nums []*RewardDetailNum
	m := s.GetDao().FissionRewardRecord.SubTable(cpnId)
	err = m.WithContext(s.Ctx).Select(m.RewardID, m.ID.Count().As("num")).Where(m.RewardID.In(ids...)).Group(m.RewardID).Scan(&nums)
	if err != nil {
		err = s.BE().MysqlError(err)
		return
	}

	numMap = make(map[int64]int64, len(ids))

	for _, num := range nums {
		numMap[num.RewardId] = num.Num
	}
	return
}

func (s *RewardDetail) _coin(cpn *model.FissionCampaign) (err error) {
	s._hasPool()

	m := s.GetDao().FissionCoinScene
	list, err := m.WithContext(s.Ctx).Where(m.CampaignID.Eq(cpn.ID)).Order(m.ID.Desc()).Find()
	if err != nil {
		err = s.BE().MysqlError(err)
		return
	}

	s.Res.Pools = make([]*pb.RewardDetailRes_Pool, 0, len(list))

	gmt := utils.Ternary[string](cpn.TOffset < 0, fmt.Sprint(cpn.TOffset), fmt.Sprintf("+%d", cpn.TOffset))

	conf, err := cache.NewCampaignCoin(s.Ctx).FindByCampaignId(cpn.ID)
	if err != nil {
		err = s.BE().CacheError(err)
		return
	}

	l := len(list)
	var notRunId = make(map[int64]struct{})
	for i, scene := range list {
		if i+1 >= l {
			break
		}

		if scene.OpenTime > time.Now().Unix() && list[i+1].OpenTime > time.Now().Unix() {
			notRunId[scene.ID] = struct{}{}
		}

	}

	for _, v := range list {
		day, _, _ := timez.GMTStartAndEndTs(cpn.TOffset, v.OpenTime)

		var status int32 = 3
		initCoin := v.InitCoin
		userCoin := v.UserCoin
		initUse := v.InitUse
		joinNum := v.JoinNum
		joinUserNum := v.JoinUserNum
		getNum := v.GetNum
		getCoin := v.GetCoin

		noOpen := v.OpenTime > time.Now().Unix()      // 还没到开奖时间
		gotReward := v.RewardTime < time.Now().Unix() // 已经领完奖了
		if noOpen {
			// 进行中
			scene, _ := cachecurd.NewHMap(s.Ctx,
				ckey.FissionCoinSceneData(v.ID),
				cachecurd.SetCoinSceneBuild(cpn.ID, v.ID),
				cachecurd.SetHMapExp(time.Duration(conf.OpenDays+1)*consts.TimeDay),
			)

			initCoin = conf.InitCoin
			initUse = conf.InitUse
			userCoin, _ = scene.GetInt64(cachecurd.CoinSceneUserCoin)
			joinNum, _ = scene.GetInt64(cachecurd.CoinSceneJoinNum)
			joinUserNum, _ = scene.GetInt64(cachecurd.CoinSceneJoinUserNum)

			status = 1
			if _, ok := notRunId[v.ID]; ok {
				status = 4
			}
		} else if !gotReward { // 领奖中
			scene, _ := cachecurd.NewHMap(s.Ctx,
				ckey.FissionCoinSceneData(v.ID),
				cachecurd.SetCoinSceneBuild(cpn.ID, v.ID),
				cachecurd.SetHMapExp(time.Duration(conf.OpenDays+1)*consts.TimeDay),
			)

			userCoin, _ = scene.GetInt64(cachecurd.CoinSceneUserCoin)
			joinNum, _ = scene.GetInt64(cachecurd.CoinSceneJoinNum)
			joinUserNum, _ = scene.GetInt64(cachecurd.CoinSceneJoinUserNum)
			getNum, _ = scene.GetInt64(cachecurd.CoinSceneGetNum)
			getCoin, _ = scene.GetInt64(cachecurd.CoinSceneGetTotal)

			status = 2
		}

		var oneUseCoin, joinAvg int64
		if joinNum > 0 {
			oneUseCoin = (userCoin + int64(initCoin)) / (joinNum + int64(initUse))
			joinAvg = (joinNum + int64(initUse)) / joinUserNum
		}

		s.Res.Pools = append(s.Res.Pools, &pb.RewardDetailRes_Pool{
			Id:          v.ID,
			Title:       fmt.Sprintf("%s(GMT%s)", day, gmt),
			Status:      status,
			InitCoin:    initCoin,
			UserCoin:    userCoin,
			InitUse:     initUse,
			JoinNum:     joinNum,
			OneUseCoin:  oneUseCoin,
			JoinUserNum: joinUserNum,
			GetNum:      getNum,
			JoinAvg:     joinAvg,
			GetCoin:     getCoin,
		})
	}

	return
}

func (s *RewardDetail) _keep(cpn *model.FissionCampaign) (err error) {
	s._hasStep()
	s._showSelect()

	m := s.GetDao().FissionCampaignReward
	list, err := m.WithContext(s.Ctx).Where(m.CampaignID.Eq(cpn.ID), m.RewardType.Eq(mtype.FissionCampaignRewardTypeGrowStep), m.IsDel.Eq(mtype.No)).Find()
	if err != nil {
		err = s.BE().MysqlError(err)
		return
	}

	if len(list) == 0 {
		return
	}

	var ids, rewardIds []int64
	var existMap = make(map[int64]struct{})
	for _, v := range list {
		ids = append(ids, v.ID)
		if _, ok := existMap[v.RewardID]; !ok {
			rewardIds = append(rewardIds, v.RewardID)
			existMap[v.RewardID] = struct{}{}
		}
	}

	titleMap, err := s._titleMap(rewardIds)
	if err != nil {
		return
	}

	stockMap, err := s._dbNum(cpn.ID, ids)
	if err != nil {
		return
	}

	s.Res.StepReward = make([]*pb.RewardDetailRes_Reward, 0, len(list))

	for _, reward := range list {
		stock, useStock := int64(reward.Stock), stockMap[reward.ID]

		s.Res.StepReward = append(s.Res.StepReward, &pb.RewardDetailRes_Reward{
			Id:        reward.ID,
			Title:     titleMap[reward.RewardID],
			Stock:     stock,
			Remain:    utils.Ternary[int64](stock < stockMap[reward.ID], 0, stock-useStock),
			Given:     useStock,
			CanUp:     reward.IsThank == mtype.No,
			IsThank:   int32(reward.IsThank),
			SelectNum: 0,
		})
	}

	return
}

func (s *RewardDetail) _win(cpn *model.FissionCampaign) (err error) {
	s._hasNewcomer()
	s._showAll()
	s._showSelect()

	conf, err := cache.NewCampaignWin(s.Ctx).FindByCampaignId(cpn.ID)
	if err != nil {
		err = s.BE().CacheError(err)
		return
	}

	stock, err := stocks.NewCampaign(s.Ctx, cpn.ID)
	if err != nil {
		return
	}

	s.Res.All = int64(conf.RewardLimit)
	s.Res.AllUse, _ = stock.GetUseStock(cpn.ID)

	m := s.GetDao().FissionCampaignReward
	list, err := m.WithContext(s.Ctx).Where(m.CampaignID.Eq(cpn.ID), m.RewardType.In(mtype.FissionCampaignRewardTypeExtra, mtype.FissionCampaignRewardTypeNewcomer), m.IsDel.Eq(mtype.No)).Find()
	if err != nil {
		err = s.BE().MysqlError(err)
		return
	}

	if len(list) == 0 {
		return
	}

	var ids, rewardIds []int64
	var existMap = make(map[int64]struct{})
	var hasExtra bool
	for _, v := range list {
		ids = append(ids, v.ID)
		if _, ok := existMap[v.RewardID]; !ok {
			rewardIds = append(rewardIds, v.RewardID)
			existMap[v.RewardID] = struct{}{}
		}

		if !hasExtra && v.RewardType == mtype.FissionCampaignRewardTypeExtra {
			hasExtra = true
		}
	}

	if hasExtra {
		s._hasStep()
	}

	titleMap, err := s._titleMap(rewardIds)
	if err != nil {
		return
	}

	stockMap, err := s._dbNum(cpn.ID, ids)
	if err != nil {
		return
	}

	for _, reward := range list {
		useStock := stockMap[reward.ID]

		switch reward.RewardType {
		case mtype.FissionCampaignRewardTypeExtra:
			s.Res.ExtraReward = append(s.Res.ExtraReward, &pb.RewardDetailRes_Reward{
				Id:        reward.ID,
				Title:     titleMap[reward.RewardID],
				Given:     useStock,
				CanUp:     reward.IsThank == mtype.No,
				IsThank:   int32(reward.IsThank),
				SelectNum: 0,
			})
		case mtype.FissionCampaignRewardTypeNewcomer:
			s.Res.NewcomerReward = append(s.Res.NewcomerReward, &pb.RewardDetailRes_Reward{
				Id:        reward.ID,
				Title:     titleMap[reward.RewardID],
				Given:     useStock,
				CanUp:     reward.IsThank == mtype.No,
				IsThank:   int32(reward.IsThank),
				SelectNum: 0,
			})
		}
	}

	return
}

func (s *RewardDetail) _referral(cpn *model.FissionCampaign) (err error) {
	s._showAll()
	s._showSelect()

	conf, err := cache.NewCampaignReferral(s.Ctx).FindByCampaignId(cpn.ID)
	if err != nil {
		err = s.BE().CacheError(err)
		return
	}

	stock, err := stocks.NewCampaign(s.Ctx, cpn.ID)
	if err != nil {
		return
	}

	s.Res.All = int64(conf.RewardLimit)
	s.Res.AllUse, _ = stock.GetUseStock(cpn.ID)

	m := s.GetDao().FissionCampaignReward
	list, err := m.WithContext(s.Ctx).Where(m.CampaignID.Eq(cpn.ID), m.RewardType.In(mtype.FissionCampaignRewardTypeExtra), m.IsDel.Eq(mtype.No)).Find()
	if err != nil {
		err = s.BE().MysqlError(err)
		return
	}

	if len(list) == 0 {
		return
	}

	s._hasExtra()

	var ids, rewardIds []int64
	var existMap = make(map[int64]struct{})
	for _, v := range list {
		ids = append(ids, v.ID)
		if _, ok := existMap[v.RewardID]; !ok {
			rewardIds = append(rewardIds, v.RewardID)
			existMap[v.RewardID] = struct{}{}
		}
	}

	titleMap, err := s._titleMap(rewardIds)
	if err != nil {
		return
	}

	stockMap, err := s._dbNum(cpn.ID, ids)
	if err != nil {
		return
	}

	for _, reward := range list {
		useStock := stockMap[reward.ID]

		s.Res.ExtraReward = append(s.Res.ExtraReward, &pb.RewardDetailRes_Reward{
			Id:        reward.ID,
			Title:     titleMap[reward.RewardID],
			Given:     useStock,
			CanUp:     reward.IsThank == mtype.No,
			IsThank:   int32(reward.IsThank),
			SelectNum: 0,
		})
	}

	return
}

func (s *RewardDetail) _cash(cpn *model.FissionCampaign) (err error) {
	s._showAll()
	s._showSelect()

	conf, err := cache.NewCampaignCash(s.Ctx).FindByCampaignId(cpn.ID)
	if err != nil {
		err = s.BE().CacheError(err)
		return
	}

	stock, err := stocks.NewCampaign(s.Ctx, cpn.ID)
	if err != nil {
		return
	}

	s.Res.All = int64(conf.PriceNum)
	s.Res.AllUse, _ = stock.GetUseStock(cpn.ID)

	return
}

func (s *RewardDetail) _gold(cpn *model.FissionCampaign) (err error) {
	s._showAll()
	s._showSelect()

	conf, err := cache.NewCampaignGold(s.Ctx).FindByCampaignId(cpn.ID)
	if err != nil {
		err = s.BE().CacheError(err)
		return
	}

	stock, err := stocks.NewCampaign(s.Ctx, cpn.ID)
	if err != nil {
		return
	}

	s.Res.All = int64(conf.PriceNum)
	s.Res.AllUse, _ = stock.GetUseStock(cpn.ID)

	return
}

// 显示额外奖品模块
func (s *RewardDetail) _hasExtra() {
	s.Res.RewardType = append(s.Res.RewardType, "extra")
}

// 显示活动主奖励模块
func (s *RewardDetail) _hasApp() {
	s.Res.RewardType = append(s.Res.RewardType, "app")
}

// 显示活动主奖励模块
func (s *RewardDetail) _hasAppSign() {
	s.Res.RewardType = append(s.Res.RewardType, "app_sign")
}

// 显示任务奖品模块
func (s *RewardDetail) _hasTask() {
	s.Res.RewardType = append(s.Res.RewardType, "task")
}

// 显示奖池记录模块
func (s *RewardDetail) _hasPool() {
	s.Res.RewardType = append(s.Res.RewardType, "pool")
}

// 显示阶梯奖品模块
func (s *RewardDetail) _hasStep() {
	s.Res.RewardType = append(s.Res.RewardType, "step")
}

// 显示新人奖品模块
func (s *RewardDetail) _hasNewcomer() {
	s.Res.RewardType = append(s.Res.RewardType, "newcomer")
}

// 显示赛程模块
func (s *RewardDetail) _hasSchedule() {
	s.Res.RewardType = append(s.Res.RewardType, "schedule")
}

// 显示Uno模块
func (s *RewardDetail) _hasUno() {
	s.Res.RewardType = append(s.Res.RewardType, "uno")
}

// 显示总预算模块
func (s *RewardDetail) _showAll() {
	s.Res.ShowAll = 1
}

// 显示活动主奖励模块要展示“选择数”的列
func (s *RewardDetail) _showSelect() {
	s.Res.ShowSelect = 1
}