package campaignuser

import (
	"joybuywork/internal/app"
	"joybuywork/internal/consts"
	"joybuywork/internal/consts/ckey"
	"joybuywork/internal/repository/cache"
	"joybuywork/internal/repository/dbcheck"
	"joybuywork/internal/repository/finder"
	"joybuywork/internal/repository/model"
	"joybuywork/internal/repository/mtype"
	"joybuywork/internal/utils"
	"joybuywork/internal/utils/logic"
	"joybuywork/internal/utils/timez"
	"joybuywork/internal/utils/verify"
	pb "joybuywork/proto/go_proto/w_campaign_user"
	"fmt"

	"gorm.io/gen"
	"gorm.io/gen/field"
)

type List struct {
	logic.Logic
	Req *pb.ListReq
	Res *pb.ListRes

	diceMap      map[int64]*pb.ListRes_Dice
	chopMap      map[int64]*pb.ListRes_Chop
	newcomerMap  map[int64]*pb.ListRes_Win
	keepDogMap   map[int64]*pb.ListRes_Keep
	cashMap      map[int64]map[string]*pb.ListRes_Cash
	goldMap      map[int64]map[string]*pb.ListRes_Gold
	helpFailMark map[int64]string

	coinMap map[int64]*pb.ListRes_Coin

	signMap map[int64]*pb.ListRes_Sign

	vsMap map[int64]*pb.ListRes_Vs

	unoMap map[int64]*pb.ListRes_Uno
}

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

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

	if cpn == nil {
		return
	}

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

	return
}

// 活动数据
func (s *List) campaign() (cpn *model.FissionCampaign, err error) {
	cpn, err = finder.Campaign(s.Ctx, s.Req.GetCampaignId(), s.Req.GetCampaignHashId())
	if err != nil {
		err = s.BE().CacheError(err)
		return
	}

	if cpn == nil || cpn.IsDel == mtype.Yes {
		return
	}

	tz := utils.STernary[int32](s.Req.GetTOffset(), consts.DefaultTz, cpn.TOffset)

	s.Req.Start = timez.GMT(s.Req.Start, tz)
	s.Req.End = timez.GMT(s.Req.End, tz)

	s.Res.TOffset = tz
	s.Res.FissionId = cpn.FissionID
	s.Res.FissionMark = consts.FissionIdMap[cpn.FissionID]

	return
}

func (s *List) list(cpn *model.FissionCampaign) (err error) {
	m := s.GetDao().FissionUser.SubTable(cpn.ID)
	var cond = []gen.Condition{
		m.IsDel.Eq(mtype.No),
		m.IsView.Eq(mtype.No),
		m.CampaignID.Eq(cpn.ID),
	}

	if s.Req.GetPid() > 0 {
		cond = append(cond, m.ParentID.Eq(s.Req.GetPid()))
	}

	if !verify.EmptyString(s.Req.GetUserMark()) {
		cond = append(cond, m.UserMark.Eq(s.Req.GetUserMark()))
	}

	if s.Req.GetStart() > 0 {
		cond = append(cond, m.CreatedAt.Gte(s.Req.GetStart()))
	}

	if s.Req.GetEnd() > 0 {
		cond = append(cond, m.CreatedAt.Lte(s.Req.GetEnd()))
	}

	if s.Req.GetSource() > 0 {
		cond = append(cond, m.Source.Eq(int8(s.Req.GetSource())))
	}

	if s.Req.GetLangMark() != "" {
		cond = append(cond, m.LangMark.Eq(s.Req.GetLangMark()))
	}

	if s.Req.GetParentUserMark() != "" {
		var puser *model.FissionUser
		puser, err = cache.NewFissionUser(s.Ctx, cpn.ID).FindBySubUserId(s.Req.GetParentUserMark())
		if err != nil {
			err = s.BE().CacheError(err)
			return
		}
		if puser == nil {
			cond = append(cond, m.ID.Eq(-1))
		} else {
			cond = append(cond, m.ParentID.Eq(puser.ID))
		}
	}

	if s.Req.GetPidType() != 0 {
		switch s.Req.GetPidType() {
		case 1:
			cond = append(cond, m.ParentID.Gt(0))
		case 2:
			cond = append(cond, m.ParentID.Eq(0))
		}
	}

	if s.Req.GetJoinType() != 0 {
		switch s.Req.GetJoinType() {
		case 1:
			cond = append(cond, m.JoinAt.Gt(0))
		case 2:
			cond = append(cond, m.JoinAt.Eq(0))
		}
	}

	if len(s.Req.GetUserCond()) > 0 {
		for _, v := range s.Req.GetUserCond() {
			switch v {
			case mtype.FissionUserStateDataCondInstall:
				cond = append(cond, m.InstallAt.Gt(0))
			case mtype.FissionUserStateDataCondRegister:
				cond = append(cond, m.RegisterAt.Gt(0))
			default:
				cond = append(cond, m.ID.Eq(0))
			}
		}
	}

	var orderBys []field.Expr
	if s.Req.OrderByTimeAsc {
		orderBys = append(orderBys, m.CreatedAt)
	}
	orderBys = append(orderBys, m.ID.Desc())

	list, total, err := s._find(cpn.ID, cond, orderBys)
	if err != nil || total == 0 {
		return
	}

	//找上级用户数据
	var (
		pids, ids, channelIds, lvIds []int64
		userMap                      = make(map[int64]string)
		channelMap                   = make(map[int64]string)
		platformMap                  = make(map[int64]string)
		lvTitleMap                   = make(map[int64]string)
		chanceMap                    = make(map[int64]int32)
		statNumMap                   = make(map[int64]*model.FissionUserStat)
		userCondMap                  = make(map[int64][]*pb.ListRes_Cond)
	)
	for _, v := range list {
		ids = append(ids, v.ID)
		statNumMap[v.ID] = nil
		chanceMap[v.ID] = 0
		userMap[v.ID] = v.UserMark
		platformMap[v.ID] = ""
		userCondMap[v.ID] = nil

		if _, ok := userMap[v.ParentID]; !ok && v.ParentID > 0 {
			userMap[v.ParentID] = ""
			pids = append(pids, v.ParentID)
		}

		if _, ok := channelMap[v.ChannelID]; !ok && v.ChannelID > 0 {
			channelMap[v.ChannelID] = ""
			channelIds = append(channelIds, v.ChannelID)
		}

		if _, ok := lvTitleMap[v.UserLevel]; !ok && v.UserLevel > 0 {
			lvTitleMap[v.UserLevel] = ""
			lvIds = append(lvIds, v.UserLevel)
		}
	}

	err = s._parentMap(cpn.ID, pids, userMap)
	if err != nil {
		return
	}

	err = s._statMap(ids, statNumMap)
	if err != nil {
		return
	}

	err = s._channelMap(channelIds, channelMap)
	if err != nil {
		return
	}

	err = s._chanceMap(cpn, ids, chanceMap)
	if err != nil {
		return
	}

	err = s._platformMap(cpn, ids, platformMap)
	if err != nil {
		return
	}

	err = s._lvTitleMap(lvIds, lvTitleMap)
	if err != nil {
		return
	}

	err = s._conds(cpn.ID, ids, userCondMap)
	if err != nil {
		return
	}

	err = s._helpMap(cpn, list)
	if err != nil {
		return
	}

	s.AddAfterRun(func() (err error) {
		s.Res.List = make([]*pb.ListRes_One, 0, len(list))
		s.Res.Total = total

		for _, v := range list {
			one := &pb.ListRes_One{
				Id:             v.ID,
				HashId:         v.HashID,
				SubUserId:      v.SubUserID,
				Parent:         userMap[v.ParentID],
				ChildNum:       0,
				IndirectNum:    0,
				IsNew:          int32(v.IsNew),
				CreatedAt:      v.CreatedAt,
				Chance:         chanceMap[v.ID],
				IsHelp:         0,
				Dice:           nil,
				ChannelTitle:   channelMap[v.ChannelID],
				Source:         int32(v.Source),
				EffectNum:      0,
				LangMark:       v.LangMark,
				CountryMark:    v.UserCountry,
				LvTitle:        lvTitleMap[v.UserLevel],
				Platform:       platformMap[v.ID],
				UserMark:       v.UserMark,
				UserMarkSource: utils.Ternary[int32](v.SubUserID == "", 2, 1),
				Conds:          userCondMap[v.ID],
				DeviceId:       v.DeviceID,
				JoinAt:         v.JoinAt,
				InstallAt:      v.InstallAt,
				RegisterAt:     v.RegisterAt,
			}

			if stat, ok := statNumMap[v.ID]; ok && stat != nil {
				one.ChildNum = stat.DirectNum
				one.IndirectNum = stat.IndirectNum
				one.EffectNum = stat.EffectiveNum
			}

			if v.ParentID > 0 {
				one.IsHelp = utils.Ternary[int32](v.IsHelp == mtype.Yes, 1, 2)
				one.FailMark = s.helpFailMark[v.ID]
			}

			switch cpn.FissionID {
			case consts.IdDice:
				one.Dice = s.diceMap[v.ID]
			case consts.IdChop:
				one.Chop = s.chopMap[v.ID]
			case consts.IdWinTogether:
				one.Win = s.newcomerMap[v.ID]
			case consts.IdKeep:
				one.KeepDog = s.keepDogMap[v.ID]
			case consts.IdCash:
				if cash, ok := s.cashMap[v.ID][v.LangMark]; ok {
					one.Cash = cash
				}
			case consts.IdGold:
				if gold, ok := s.goldMap[v.ID][v.LangMark]; ok {
					one.Gold = gold
				}
			case consts.IdCoin:
				one.Coin = s.coinMap[v.ID]
			case consts.IdSignIn:
				one.Sign = s.signMap[v.ID]
			case consts.IdVs:
				one.Vs = s.vsMap[v.ID]
			case consts.IdUno:
				one.Uno = s.unoMap[v.ID]
			default:

			}

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

		return
	})

	return
}

func (s *List) _find(campaignId int64, cond []gen.Condition, orderBys []field.Expr) (list []*model.FissionUser, total int64, err error) {

	m := s.GetDao().FissionUser.SubTable(campaignId)
	offset, limit := utils.PpDbLo(s.Req.GetPage(), s.Req.GetPerPage())

	total, err = m.WithContext(s.Ctx).Select(m.ID).Where(cond...).Count()
	if err != nil {
		err = s.BE().MysqlError(err)
		return
	}

	subId := field.NewInt64("a", "id")
	subQuery := gen.Table(m.WithContext(s.Ctx).Select(m.ID).Where(cond...).Order(orderBys...).Offset(offset).Limit(limit).As("a")).Select(subId)

	qm := s.GetDao().FissionUser.SubTable(campaignId).As("qm")
	list, err = qm.WithContext(s.Ctx).Where(qm.WithContext(s.Ctx).Columns(qm.ID).In(subQuery)).Find()
	if err != nil {
		err = s.BE().MysqlError(err)
		return
	}

	return

}

// 父级数据
func (s *List) _parentMap(cpnId int64, ids []int64, userMap map[int64]string) (err error) {
	if len(ids) == 0 {
		return
	}
	m := s.GetDao().FissionUser.SubTable(cpnId)

	//找上级数据
	userList, err := m.WithContext(s.Ctx).Where(m.ID.In(ids...)).Find()
	if err != nil {
		err = s.BE().MysqlError(err)
		return
	}
	for _, v := range userList {
		userMap[v.ID] = v.UserMark
	}

	return
}

// 统计数据
func (s *List) _statMap(ids []int64, statNumMap map[int64]*model.FissionUserStat) (err error) {
	if len(ids) == 0 {
		return
	}

	//统计数据
	statM := s.GetDao().FissionUserStat
	statList, err := statM.WithContext(s.Ctx).Where(statM.UserID.In(ids...)).Find()
	if err != nil {
		return s.BE().MysqlError(err)
	}
	for _, v := range statList {
		statNumMap[v.UserID] = v
	}

	return
}

// 剩余活动次数
func (s *List) _chanceMap(cpn *model.FissionCampaign, ids []int64, chanceMap map[int64]int32) (err error) {

	switch cpn.FissionID {
	case consts.IdBlindBox:
		m := s.GetDao().FissionBlind
		var list []*model.FissionBlind
		list, err = m.WithContext(s.Ctx).Where(m.UserID.In(ids...)).Find()
		if err != nil {
			return s.BE().MysqlError(err)
		}
		for _, v := range list {
			chanceMap[v.UserID] = v.Chance
		}
	case consts.IdLuckyGrid:
		m := s.GetDao().FissionGrid
		var list []*model.FissionGrid
		list, err = m.WithContext(s.Ctx).Where(m.UserID.In(ids...)).Find()
		if err != nil {
			return s.BE().MysqlError(err)
		}
		for _, v := range list {
			chanceMap[v.UserID] = v.Chance
		}
	case consts.IdSlotMachine:
		m := s.GetDao().FissionSlot
		var list []*model.FissionSlot
		list, err = m.WithContext(s.Ctx).Where(m.UserID.In(ids...)).Find()
		if err != nil {
			return s.BE().MysqlError(err)
		}
		for _, v := range list {
			chanceMap[v.UserID] = v.Chance
		}
	case consts.IdPrizeWheel:
		m := s.GetDao().FissionPrizeWheel
		var list []*model.FissionPrizeWheel
		list, err = m.WithContext(s.Ctx).Where(m.UserID.In(ids...)).Find()
		if err != nil {
			return s.BE().MysqlError(err)
		}
		for _, v := range list {
			chanceMap[v.UserID] = v.Chance
		}
	case consts.IdPrizeAnswer, consts.IdQa, consts.IdQaVideo, consts.IdQaAudio:
		m := s.GetDao().FissionQa
		var list []*model.FissionQa
		list, err = m.WithContext(s.Ctx).Where(m.UserID.In(ids...)).Find()
		if err != nil {
			return s.BE().MysqlError(err)
		}
		for _, v := range list {
			chanceMap[v.UserID] = v.Chance
		}
	case consts.IdPrizeQuiz:
		m := s.GetDao().FissionQuiz
		var list []*model.FissionQuiz
		list, err = m.WithContext(s.Ctx).Where(m.UserID.In(ids...)).Find()
		if err != nil {
			return s.BE().MysqlError(err)
		}
		for _, v := range list {
			chanceMap[v.UserID] = v.Chance
		}
	case consts.IdFlip:
		m := s.GetDao().FissionFlip
		var list []*model.FissionFlip
		list, err = m.WithContext(s.Ctx).Where(m.UserID.In(ids...)).Find()
		if err != nil {
			return s.BE().MysqlError(err)
		}
		for _, v := range list {
			chanceMap[v.UserID] = v.Chance
		}
	case consts.IdBallot:
		m := s.GetDao().FissionBallot
		var list []*model.FissionBallot
		list, err = m.WithContext(s.Ctx).Where(m.UserID.In(ids...)).Find()
		if err != nil {
			return s.BE().MysqlError(err)
		}
		for _, v := range list {
			chanceMap[v.UserID] = v.Chance
		}
	case consts.IdDice:
		err = s._dice(ids)
		if err != nil {
			return
		}

		m := s.GetDao().FissionCampaignDice
		var conf *model.FissionCampaignDice
		conf, err = m.WithContext(s.Ctx).Where(m.CampaignID.Eq(cpn.ID)).Take()
		if err = dbcheck.DbError(err); err != nil {
			err = s.BE().MysqlError(err)
			return
		}

		if conf != nil {
			s.Res.FixDice = int32(conf.FixDice)
		}
	case consts.IdGrow:
		m := s.GetDao().FissionGrow
		var list []*model.FissionGrow
		list, err = m.WithContext(s.Ctx).Where(m.UserID.In(ids...)).Find()
		if err != nil {
			return s.BE().MysqlError(err)
		}
		for _, v := range list {
			chanceMap[v.UserID] = v.GrowNum
		}

	case consts.IdChop:
		err = s._chop(ids)
		if err != nil {
			return
		}
	case consts.IdWinTogether:

		s.newcomerMap = make(map[int64]*pb.ListRes_Win, len(ids))

		m := s.GetDao().FissionWin
		var list []*model.FissionWin
		list, err = m.WithContext(s.Ctx).Where(m.UserID.In(ids...)).Find()
		if err != nil {
			return s.BE().MysqlError(err)
		}
		for _, v := range list {
			s.newcomerMap[v.UserID] = &pb.ListRes_Win{
				IsNewcomer: int32(v.IsNewcomer),
			}
		}

	case consts.IdKeep:
		err = s._keep(ids)
		if err != nil {
			return
		}
	case consts.IdCash:
		err = s._cash(ids)
		if err != nil {
			return
		}
	case consts.IdGold:
		err = s._gold(ids)
		if err != nil {
			return
		}
	case consts.IdCoin:
		err = s._coin(cpn, ids)
		if err != nil {
			return
		}
	case consts.IdSignIn:
		err = s._sign(ids)
		if err != nil {
			return
		}
	case consts.IdVs:
		err = s._vs(ids)
		if err != nil {
			return
		}
	case consts.IdUno:
		err = s._uno(ids)
		if err != nil {
			return
		}

	}

	return
}

func (s *List) _sign(ids []int64) (err error) {
	if s.signMap != nil || len(ids) == 0 {
		return
	}

	playerM := s.GetDao().FissionSign
	list, err := playerM.WithContext(s.Ctx).Where(playerM.UserID.In(ids...)).Find()
	if err != nil {
		return s.BE().MysqlError(err)
	}

	s.signMap = make(map[int64]*pb.ListRes_Sign, len(ids))
	for _, v := range list {
		s.signMap[v.UserID] = &pb.ListRes_Sign{
			SignDay:     v.SignDay,
			MaxContinue: v.MaxContinue,
		}
	}

	return
}

func (s *List) _coin(cpn *model.FissionCampaign, ids []int64) (err error) {
	if s.coinMap != nil || len(ids) == 0 {
		return
	}

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

	m := s.GetDao().FissionCoinScene
	scenes, err := m.WithContext(s.Ctx).Where(m.CampaignID.Eq(cpn.ID)).Find()
	if err != nil {
		return s.BE().MysqlError(err)
	}
	var sceneMap = make(map[int64]string, len(scenes))
	for _, scene := range scenes {
		day, _, _ := timez.GMTStartAndEndTs(cpn.TOffset, scene.OpenTime)
		sceneMap[scene.ID] = fmt.Sprintf("%s(GMT%s)", day, gmt)
	}

	playerM := s.GetDao().FissionCoin
	list, err := playerM.WithContext(s.Ctx).Where(playerM.UserID.In(ids...)).Find()
	if err != nil {
		return s.BE().MysqlError(err)
	}

	s.coinMap = make(map[int64]*pb.ListRes_Coin, len(ids))
	var playerMap = make(map[int64][]*model.FissionCoin, len(ids))
	for _, v := range list {
		playerMap[v.UserID] = append(playerMap[v.UserID], v)
	}

	for userId, players := range playerMap {

		var totalUse, totalCoin int32
		var userScenes []*pb.ListRes_CoinScene
		for _, player := range players {

			userScenes = append(userScenes, &pb.ListRes_CoinScene{
				Title:   sceneMap[player.SceneID],
				UseNum:  player.UseNum,
				GetCoin: player.GetCoin,
			})

			totalUse += player.UseNum
			totalCoin += player.GetCoin
		}

		s.coinMap[userId] = &pb.ListRes_Coin{
			TotalUse: totalUse,
			TotalNum: totalCoin,
			Scenes:   userScenes,
		}
	}

	return
}

func (s *List) _keep(ids []int64) (err error) {
	if s.keepDogMap != nil || len(ids) == 0 {
		return
	}

	m := s.GetDao().FissionKeep
	list, err := m.WithContext(s.Ctx).Where(m.UserID.In(ids...)).Find()
	if err != nil {
		return s.BE().MysqlError(err)
	}

	var rewardMap = make(map[int64]string)
	var rewardIds []int64
	for _, v := range list {
		if _, ok := rewardMap[v.RewardID]; !ok {
			rewardMap[v.RewardID] = ""
			rewardIds = append(rewardIds, v.RewardID)
		}
	}

	rewardTitleMap, err := s._getRewardTitle(rewardIds)
	if err != nil {
		return
	}

	s.keepDogMap = make(map[int64]*pb.ListRes_Keep, len(list))

	for _, v := range list {
		s.keepDogMap[v.UserID] = &pb.ListRes_Keep{
			CollectNum:  v.CollectNum,
			RewardTitle: rewardTitleMap[v.RewardID],
			Chance:      v.Num,
		}
	}

	return
}

func (s *List) _dice(ids []int64) (err error) {
	if s.diceMap != nil || len(ids) == 0 {
		return
	}

	m := s.GetDao().FissionDice
	list, err := m.WithContext(s.Ctx).Where(m.UserID.In(ids...)).Find()
	if err != nil {
		return s.BE().MysqlError(err)
	}

	s.diceMap = make(map[int64]*pb.ListRes_Dice, len(list))

	for _, v := range list {
		s.diceMap[v.UserID] = &pb.ListRes_Dice{
			Chance:      v.Chance,
			LuckyChance: 0,
		}
	}

	pm := s.GetDao().FissionDiceProp
	plist, err := pm.WithContext(s.Ctx).Where(pm.UserID.In(ids...), pm.Mark.Eq(mtype.FissionDicePropMarkFixedRoll)).Find()
	if err != nil {
		return s.BE().MysqlError(err)
	}

	for _, v := range plist {
		s.diceMap[v.UserID].LuckyChance = v.Num
	}

	return
}

func (s *List) _chop(ids []int64) (err error) {
	if s.chopMap != nil || len(ids) == 0 {
		return
	}

	m := s.GetDao().FissionChop
	list, err := m.WithContext(s.Ctx).Where(m.UserID.In(ids...)).Find()
	if err != nil {
		return s.BE().MysqlError(err)
	}

	s.chopMap = make(map[int64]*pb.ListRes_Chop, len(list))

	var chopMap = make(map[int64]*model.FissionChopReward, len(list))
	var chopRewardMap = make(map[int64]string)
	var chopRewardIds []int64
	for _, v := range list {
		if v.ChopRewardID == 0 {
			continue
		}
		chopRewardIds = append(chopRewardIds, v.ChopRewardID)
	}

	if len(chopRewardIds) > 0 {
		chopRewardM := s.GetDao().FissionChopReward
		var chopRewardList []*model.FissionChopReward
		chopRewardList, err = chopRewardM.WithContext(s.Ctx).Where(chopRewardM.ID.In(chopRewardIds...)).Find()
		if err != nil {
			err = s.BE().MysqlError(err)
			return
		}

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

		var rewardTitleMap map[int64]string
		rewardTitleMap, err = s._getRewardTitle(rewardIds)
		if err != nil {
			return
		}

		for _, v := range chopRewardList {
			chopRewardMap[v.ID] = rewardTitleMap[v.RewardID]
		}
	}

	s.chopMap = make(map[int64]*pb.ListRes_Chop, len(list))
	for _, v := range list {
		if chop, ok := chopMap[v.ChopRewardID]; ok {
			s.chopMap[v.UserID] = &pb.ListRes_Chop{
				ChopRewardId: v.ChopRewardID,
				RewardTitle:  chopRewardMap[chop.ID],
				Percent:      utils.PercentCutZero(chop.Percent),
			}
		} else {
			s.chopMap[v.UserID] = &pb.ListRes_Chop{}
		}
	}

	return
}

func (s *List) _channelMap(ids []int64, channelMap map[int64]string) (err error) {
	if len(ids) == 0 {
		return
	}

	m := s.GetDao().FissionCampaignChannel
	list, err := m.WithContext(s.Ctx).Where(m.ID.In(ids...)).Find()
	if err != nil {
		err = s.BE().MysqlError(err)
		return
	}

	for _, v := range list {
		channelMap[v.ID] = v.Title
	}
	return
}

func (s *List) _platformMap(cpn *model.FissionCampaign, ids []int64, platformMap map[int64]string) (err error) {
	if len(ids) == 0 {
		return
	}

	m := s.GetDao().FissionUserAttr
	list, err := m.WithContext(s.Ctx).Where(m.CampaignID.Eq(cpn.ID), m.UserID.In(ids...), m.Attr.Eq(mtype.FissionUserAttrMarkPlatform)).Find()
	if err != nil {
		return s.BE().MysqlError(err)
	}

	for _, v := range list {
		platformMap[v.UserID] = v.Value
	}

	return
}

func (s *List) _lvTitleMap(ids []int64, lvTitleMap map[int64]string) (err error) {
	if len(ids) == 0 {
		return
	}
	m := s.GetDao().FissionUserLevel
	list, err := m.WithContext(s.Ctx).Where(m.ID.In(ids...)).Find()
	if err != nil {
		err = s.BE().MysqlError(err)
		return
	}

	for _, v := range list {
		lvTitleMap[v.ID] = v.Title
	}
	return
}

func (s *List) _conds(cpnId int64, ids []int64, data map[int64][]*pb.ListRes_Cond) (err error) {
	condM := s.GetDao().FissionCampaignCond
	conds, err := condM.WithContext(s.Ctx).Where(condM.CampaignID.Eq(cpnId)).
		Where(
			condM.WithContext(s.Ctx).
				Or(condM.IsDel.Eq(mtype.No)).
				Or(condM.IsDel.Eq(mtype.Yes), condM.DelUse.Eq(mtype.Yes)),
		).Find()
	if err != nil {
		err = s.BE().MysqlError(err)
		return
	}

	if len(conds) == 0 {
		return
	}

	m := s.GetDao().FissionUserCond
	list, err := m.WithContext(s.Ctx).Where(m.UserID.In(ids...)).Find()
	if err != nil {
		err = s.BE().MysqlError(err)
		return
	}

	var userCondMap = make(map[int64]map[int64]int64)
	for _, v := range list {

		if _, ok := userCondMap[v.UserID]; !ok {
			userCondMap[v.UserID] = map[int64]int64{
				v.CondID: v.Num,
			}
		} else {
			userCondMap[v.UserID][v.CondID] = v.Num
		}
	}

	for _, userId := range ids {

		for _, cond := range conds {
			one := &pb.ListRes_Cond{
				Desc: cond.Desc,
				Num:  0,
			}

			if uc, ok := userCondMap[userId]; ok {
				one.Num = uc[cond.ID]
			}

			data[userId] = append(data[userId], one)
		}
	}

	return
}

func (s *List) _helpMap(cpn *model.FissionCampaign, users []*model.FissionUser) (err error) {
	s.helpFailMark = make(map[int64]string, len(users))

	if len(users) == 0 {
		return
	}

	key := ckey.FissionUserHelpFailMark(cpn.ID)
	var ids []int64
	for _, user := range users {

		s.helpFailMark[user.ID] = ""
		if user.ParentID == 0 || user.IsHelp == mtype.Yes {
			continue
		}

		failMark := app.Redis.Cache.HGet(s.Ctx, key, fmt.Sprint(user.ID)).Val()
		if failMark == "" {
			ids = append(ids, user.ID)
			continue
		}

		s.helpFailMark[user.ID] = failMark
	}

	if len(ids) == 0 {
		return
	}

	m := s.GetDao().FissionCampaignTicket
	tickets, err := m.WithContext(s.Ctx).Where(m.CampaignID.Eq(cpn.ID), m.Open.Eq(mtype.Yes)).Find()
	if err != nil {
		err = s.BE().MysqlError(err)
		return
	}

	for _, ticket := range tickets {

		if ticket.Mark == mtype.FissionCampaignTicketFixed {
			var vals []string
			for _, id := range ids {
				failMark := utils.Ternary[string](ticket.AppEvent == mtype.FissionCampaignTicketAppEventInstall, consts.HelpStatusNotInstall, consts.HelpStatusNotRegister)
				s.helpFailMark[id] = failMark
				vals = append(vals, fmt.Sprint(id), failMark)
			}

			app.Redis.Cache.HSet(s.Ctx, key, vals)

			return
		}

		if ticket.Mark == mtype.FissionCampaignTicketCustom && verify.InArray(cpn.FissionID, consts.IdReferral, consts.IdWinTogether) {

			if ticket.PreEvent == mtype.FissionCampaignTicketPreEventNone {
				var vals []string
				for _, id := range ids {
					failMark := consts.HelpStatusNotTask
					s.helpFailMark[id] = failMark
					vals = append(vals, fmt.Sprint(id), failMark)
				}

				app.Redis.Cache.HSet(s.Ctx, key, vals)

				return
			}

			switch cpn.FissionID {
			case consts.IdReferral:
				playerM := s.GetDao().FissionReferral
				var list []*model.FissionReferral
				list, err = playerM.WithContext(s.Ctx).Where(playerM.UserID.In(ids...)).Find()
				if err != nil {
					err = s.BE().MysqlError(err)
					return
				}
				var vals []string
				switch ticket.PreEvent {
				case mtype.FissionCampaignTicketPreEventInstall:

					for _, v := range list {
						failMark := utils.Ternary[string](v.BindInstall == mtype.Yes, consts.HelpStatusNotTask, consts.HelpStatusNotInstall)
						s.helpFailMark[v.UserID] = failMark
						vals = append(vals, fmt.Sprint(v.UserID), failMark)
					}

				case mtype.FissionCampaignTicketAppEventRegister:
					for _, v := range list {
						failMark := utils.Ternary[string](v.BindInstall == mtype.Yes, consts.HelpStatusNotTask, consts.HelpStatusNotRegister)
						s.helpFailMark[v.UserID] = failMark
						vals = append(vals, fmt.Sprint(v.UserID), failMark)
					}
				}

				app.Redis.Cache.HSet(s.Ctx, key, vals)

			case consts.IdWinTogether:
				playerM := s.GetDao().FissionWin
				var list []*model.FissionWin
				list, err = playerM.WithContext(s.Ctx).Where(playerM.UserID.In(ids...)).Find()
				if err != nil {
					err = s.BE().MysqlError(err)
					return
				}
				var vals []string
				switch ticket.PreEvent {
				case mtype.FissionCampaignTicketPreEventInstall:

					for _, v := range list {
						failMark := utils.Ternary[string](v.BindInstall == mtype.Yes, consts.HelpStatusNotTask, consts.HelpStatusNotInstall)
						s.helpFailMark[v.UserID] = failMark
						vals = append(vals, fmt.Sprint(v.UserID), failMark)
					}

				case mtype.FissionCampaignTicketAppEventRegister:
					for _, v := range list {
						failMark := utils.Ternary[string](v.BindInstall == mtype.Yes, consts.HelpStatusNotTask, consts.HelpStatusNotRegister)
						s.helpFailMark[v.UserID] = failMark
						vals = append(vals, fmt.Sprint(v.UserID), failMark)
					}
				}

				app.Redis.Cache.HSet(s.Ctx, key, vals)
			}

			return
		}

	}

	return
}

func (s *List) _getRewardTitle(rewardIds []int64) (data map[int64]string, err error) {
	m := s.GetDao().FissionCampaignReward
	rewards, err := m.WithContext(s.Ctx).Where(m.ID.In(rewardIds...)).Find()
	if err != nil {
		err = s.BE().MysqlError(err)
		return
	}

	var bMap = make(map[int64]string)
	var bIds []int64
	for _, v := range rewards {
		if _, ok := bMap[v.RewardID]; !ok {
			bIds = append(bIds, v.RewardID)
		}
	}

	rewardM := s.GetDao().Reward

	list, err := rewardM.WithContext(s.Ctx).Where(rewardM.ID.In(bIds...)).Find()
	for _, v := range list {
		bMap[v.ID] = v.RewardTitle
	}

	data = make(map[int64]string, len(rewards))
	for _, v := range rewards {
		data[v.ID] = bMap[v.RewardID]
	}
	return
}

func (s *List) _cash(ids []int64) (err error) {
	if s.cashMap != nil || len(ids) == 0 {
		return
	}

	m := s.GetDao().FissionCash
	list, err := m.WithContext(s.Ctx).Where(m.UserID.In(ids...)).Find()
	if err != nil {
		return s.BE().MysqlError(err)
	}

	s.cashMap = make(map[int64]map[string]*pb.ListRes_Cash, len(list))

	for _, v := range list {
		if _, ok := s.cashMap[v.ID]; !ok {
			s.cashMap[v.UserID] = map[string]*pb.ListRes_Cash{
				v.Lang: {ExpiredAt: v.ExpiredIn},
			}
		} else {
			s.cashMap[v.UserID][v.Lang] = &pb.ListRes_Cash{ExpiredAt: v.ExpiredIn}
		}
	}

	return
}

func (s *List) _gold(ids []int64) (err error) {
	if s.goldMap != nil || len(ids) == 0 {
		return
	}

	m := s.GetDao().FissionGold
	list, err := m.WithContext(s.Ctx).Where(m.UserID.In(ids...)).Find()
	if err != nil {
		return s.BE().MysqlError(err)
	}

	s.goldMap = make(map[int64]map[string]*pb.ListRes_Gold, len(list))

	for _, v := range list {
		if _, ok := s.goldMap[v.ID]; !ok {
			s.goldMap[v.UserID] = map[string]*pb.ListRes_Gold{
				v.Lang: {
					GoldNum:   v.GoldNum,
					ExpiredAt: v.ExpiredIn,
				},
			}
		} else {
			s.goldMap[v.UserID][v.Lang] = &pb.ListRes_Gold{
				GoldNum:   v.GoldNum,
				ExpiredAt: v.ExpiredIn,
			}
		}
	}

	return
}

func (s *List) _vs(ids []int64) (err error) {
	if s.vsMap != nil || len(ids) == 0 {
		return
	}

	m := s.GetDao().FissionV
	list, err := m.WithContext(s.Ctx).Where(m.UserID.In(ids...)).Find()
	if err != nil {
		return s.BE().MysqlError(err)
	}

	s.vsMap = make(map[int64]*pb.ListRes_Vs, len(list))

	for _, v := range list {
		s.vsMap[v.UserID] = &pb.ListRes_Vs{
			Chance:  v.Chance,
			VoteNum: v.VoteNum,
			CoinGet: v.CoinGet,
			CoinUse: v.CoinUse,
		}
	}

	return
}

func (s *List) _uno(ids []int64) (err error) {
	if s.unoMap != nil || len(ids) == 0 {
		return
	}

	m := s.GetDao().FissionUno
	list, err := m.WithContext(s.Ctx).Where(m.UserID.In(ids...)).Find()
	if err != nil {
		return s.BE().MysqlError(err)
	}

	s.unoMap = make(map[int64]*pb.ListRes_Uno, len(list))

	for _, v := range list {
		s.unoMap[v.UserID] = &pb.ListRes_Uno{
			Chance:   v.Chance,
			ThreeNum: v.ThreeNum,
			FiveNum:  v.FiveNum,
			FixNum:   v.FixNum,
		}
	}

	return
}