package campaign

import (
	"joybuywork/internal/app"
	"joybuywork/internal/consts"
	"joybuywork/internal/plugins/jsonm"
	"joybuywork/internal/repository/cache"
	"joybuywork/internal/repository/dbcheck"
	"joybuywork/internal/repository/finder"
	"joybuywork/internal/repository/model"
	"joybuywork/internal/repository/mtype"
	"joybuywork/internal/service/provider"
	"joybuywork/internal/utils"
	"joybuywork/internal/utils/blink"
	"joybuywork/internal/utils/logic"
	"joybuywork/internal/utils/timez"
	"joybuywork/internal/utils/verify"
	pb "joybuywork/proto/go_proto/w_campaign"
	"joybuywork/proto/go_proto/workerr"

	dlinkpb "gits.branchcn.com/backend/deeplink/proto/go_proto/dlink"
	"gorm.io/gen"
)

type Show struct {
	logic.Logic
	Req *pb.ShowReq
	Res *pb.ShowRes

	rewardLangList []*model.RewardLang

	levelMap map[int64]string

	helpMap map[int64][]*model.FissionCampaignTask

	ruleMap map[int64]*model.FissionCampaignRewardRule

	rewardAddMap  map[int64]*pb.ShowRes_OpenAdd
	rewardTaskMap map[int64]*pb.ShowRes_RewardTask
}

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

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

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

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

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

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

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

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

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

	if !s.Req.GetNotReward() {
		err = s.setReward(cpn, conf)
		if err != nil {
			return
		}
	}

	return
}

// 设置活动数据
func (s *Show) setCampaign() (cpn *model.FissionCampaign, err error) {
	cpn, err = finder.Campaign(s.Ctx, s.Req.GetId(), s.Req.GetHashId())
	if err != nil {
		return nil, s.BE().CacheError(err)
	}

	if cpn == nil || cpn.IsDel == mtype.Yes {
		err = workerr.NotFound("campaign not found")
		return
	}

	s.AddAfterRun(func() (err error) {
		s.Res.Id = cpn.ID
		s.Res.HashId = cpn.HashID
		s.Res.Title = cpn.Title
		s.Res.TempId = cpn.TemplateID
		s.Res.ProjectId = cpn.ProjectID
		s.Res.FissionMark = consts.FissionIdMap[cpn.FissionID]
		s.Res.Status = int32(cpn.Status)
		s.Res.CoverUrl = cpn.CoverURL
		s.Res.TOffset = cpn.TOffset
		s.Res.StartTime = cpn.StartTime
		s.Res.TStart = cpn.TStart
		s.Res.EndTime = cpn.EndTime
		s.Res.TEnd = cpn.TEnd
		s.Res.LangMarks = cpn.GetLangMarks()
		s.Res.FissionId = cpn.FissionID

		return
	})

	return
}

// 设置活动配置数据
func (s *Show) setConf(cpn *model.FissionCampaign) (conf *model.FissionCampaignConfig, err error) {
	cc := cache.NewCampaignConfig(s.Ctx)
	conf, err = cc.FindByCampaignId(cpn.ID)
	if err != nil {
		err = s.BE().CacheError(err)
		return
	}

	project, err := finder.Project(s.Ctx, cpn.ProjectID)
	if err != nil {
		err = s.BE().CacheError(err)
		return
	}

	var targetChannelMap = make(map[int64]*model.FissionCampaignChannel)
	var targetCpnMap = make(map[int64]*model.FissionCampaign)
	var zoneMap = make(map[int64][]*model.FissionCampaignLongImgZone)
	var longImgs []*model.FissionCampaignLongImg
	if conf.HasLongImg == mtype.Yes {
		longImgM := s.GetDao().FissionCampaignLongImg
		longImgs, err = longImgM.WithContext(s.Ctx).Where(
			longImgM.CampaignID.Eq(cpn.ID),
			longImgM.IsDel.Eq(mtype.No),
			longImgM.LangID.Eq(0),
		).Find()
		if err != nil {
			err = s.BE().MysqlError(err)
			return
		}

		var cpnIds []int64
		var zoneImgIds []int64
		for _, longImg := range longImgs {
			if longImg.ClickType == mtype.FissionCampaignLongImgClickTypeZone {
				zoneImgIds = append(zoneImgIds, longImg.ID)
			}

			if longImg.TargetType == mtype.FissionCampaignLongImgTargetTypeCampaign {
				cpnIds = append(cpnIds, longImg.TargetID)
			}
		}

		if len(zoneImgIds) > 0 {
			zoneM := s.GetDao().FissionCampaignLongImgZone
			var zones []*model.FissionCampaignLongImgZone
			zones, err = zoneM.WithContext(s.Ctx).Where(zoneM.ImgID.In(zoneImgIds...), zoneM.IsDel.Eq(mtype.No)).Find()
			if err != nil {
				err = s.BE().MysqlError(err)
				return
			}

			for _, zone := range zones {
				zoneMap[zone.ImgID] = append(zoneMap[zone.ImgID], zone)
				if zone.TargetType == mtype.FissionCampaignLongImgTargetTypeCampaign {
					cpnIds = append(cpnIds, zone.TargetID)
				}
			}
		}

		if len(cpnIds) > 0 {
			cpnM := s.GetDao().FissionCampaign
			var cpns []*model.FissionCampaign
			cpns, err = cpnM.WithContext(s.Ctx).Where(cpnM.ID.In(cpnIds...)).Find()
			if err != nil {
				err = s.BE().MysqlError(err)
				return
			}

			for _, v := range cpns {
				targetCpnMap[v.ID] = v
			}

			channelM := s.GetDao().FissionCampaignChannel
			var channels []*model.FissionCampaignChannel
			channels, err = channelM.WithContext(s.Ctx).Where(channelM.CampaignID.In(cpnIds...), channelM.IsDefault.Eq(mtype.Yes), channelM.IsDel.Eq(mtype.No)).Find()
			if err != nil {
				err = s.BE().MysqlError(err)
				return
			}

			for _, channel := range channels {
				targetChannelMap[channel.CampaignID] = channel
			}

		}
	}

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

	var pointsUse *model.FissionCampaignPointsUse
	if conf.PointsUse == mtype.Yes {
		pointsUse, err = cache.NewCampaignPointsUse(s.Ctx).FindByCampaignId(cpn.ID)
		if err != nil {
			err = s.BE().CacheError(err)
			return
		}
	}

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

	s.AddAfterRun(func() (err error) {

		// 一般配置
		s.Res.Config = &pb.ShowRes_Config{
			RuleTextColor:       conf.RuleTextColor,
			RuleBgColor:         conf.RuleBgColor,
			ShareText:           conf.ShareText,
			ShareImg:            conf.ShareImg,
			HasRank:             int32(conf.HasRank),
			RankBackgroundColor: conf.RankBackgroundColor,
			RankTextColor:       conf.RankTextColor,
			DownloadPageImage:   conf.DownloadPageImage,
			IsDefaultDownload:   int32(conf.IsDefaultDownload),
			WechatPageImage:     conf.WechatPageImage,
			IsDefaultWechat:     int32(conf.IsDefaultWechat),
			ImageMain:           conf.ImageMain,
			IsDefaultMain:       int32(conf.IsDefaultMain),
			ImagePreview:        conf.ImagePreview,
			LinkBtnTextColor:    conf.LinkBtnTextColor,
			LinkBtnBgColor:      conf.LinkBtnBgColor,
			LinkTextColor:       conf.LinkTextColor,
			ShowShare:           int32(conf.ShowShare),
			Share:               conf.GetShare(),
			PlayRule:            conf.PlayRule,
			PageTitle:           conf.PageTitle,
			DmShow:              int32(conf.DmShow),
			WebBgImg:            conf.WebBgImg,
			HasWeb:              int32(conf.HasWeb),
			HasWarmUp:           int32(conf.HasWarmUp),
			WarmUpImg:           conf.WarmUpImg,
			WarmUpEnd:           conf.WarmUpEnd,
			IconType:            int32(conf.IconType),
			IconBgColor:         conf.IconBgColor,
			DlType:              int32(conf.DlType),
			DlBannerType:        int32(conf.DlBannerType),
			DlBannerImg:         conf.DlBannerImg,
			DlBannerAppLogo:     conf.DlBannerAppLogo,
			DlBannerAppName:     conf.DlBannerAppName,
			DlBannerAppBtn:      conf.DlBannerAppBtn,
			DlBannerPosition:    int32(conf.DlBannerPosition),
			TopicColor:          conf.TopicColor,
			WindowCover:         int32(conf.WindowCover),
			OpenAd:              0,
			CloseCopyShare:      int32(project.CloseCopyShare),
			IconOpen:            conf.GetIconOpen(),
			HasWhite:            int32(conf.HasWhite),
			WhiteList:           conf.WhiteList,
			PcBg:                conf.PcBg,
			AdsType:             int32(conf.AdsType),
			LinkTempId:          conf.LinkTempID,
			RuleTimeOpen:        int32(conf.RuleTimeOpen),
			OutsideTask:         int32(conf.OutsideTask),
			IconTextColor:       "",
			OpenShare:           int32(conf.OpenShare),
			ShowToUse:           int32(conf.ShowToUse),
			RuleType:            int32(conf.RuleType),
			RuleImg:             "",
			RuleOutside:         int32(conf.RuleOutside),
			DeviceOnce:          int32(conf.DeviceOnce),
		}

		if style != nil {
			switch cpn.FissionID {
			case consts.IdPrizeWheel:
				custom := style.GetWheelStyle()
				s.Res.WheelStyle = &pb.ShowRes_WheelStyle{
					TopicMark:      custom.TopicMark,
					MainImg:        custom.MainImg,
					BgColor:        custom.BgColor,
					Bottom1:        custom.Bottom1,
					Bottom2:        custom.Bottom2,
					Bottom3:        custom.Bottom3,
					Pointer:        custom.Pointer,
					PlayBtn:        custom.PlayBtn,
					BorderImg:      custom.BorderImg,
					ButtonColor:    custom.ButtonColor,
					WheelTextColor: custom.WheelTextColor,
				}
			case consts.IdLuckyGrid:
				custom := style.GetGridStyle()
				s.Res.GridStyle = &pb.ShowRes_GridStyle{
					TopicMark:      custom.TopicMark,
					MainImg:        custom.MainImg,
					BgColor:        custom.BgColor,
					ButtonColor:    custom.ButtonColor,
					PlayImg:        custom.PlayImg,
					DisablePlayImg: custom.DisablePlayImg,
					MachineImg:     custom.MachineImg,
					GridImg:        custom.GridImg,
					ActivateImg:    custom.ActivateImg,
				}
			case consts.IdFlip:
				custom := style.GetFlipStyle()
				s.Res.FlipStyle = &pb.ShowRes_FlipStyle{
					TopicMark:   custom.TopicMark,
					MainImg:     custom.MainImg,
					BgColor:     custom.BgColor,
					ButtonColor: custom.ButtonColor,
					PlayImg:     custom.PlayImg,
					CardImg:     custom.CardImg,
				}
			case consts.IdGashapon:
				custom := style.GetGashaponStyle()
				s.Res.GashaponStyle = &pb.ShowRes_GashaponStyle{
					TopicMark:  custom.TopicMark,
					MainImg:    custom.MainImg,
					BgColor:    custom.BgColor,
					MachineImg: custom.MachineImg,
					PlayImg:    custom.PlayImg,
					EggType:    custom.EggType,
					EggImgs:    custom.EggImgs,
				}
			}

			s.Res.Config.IconTextColor = style.IconTextColor
			s.Res.Config.RuleImg = style.RuleImg
		}

		ads, err := cache.NewProjectAd(s.Ctx).FindByProjectId(cpn.ProjectID)
		if err != nil {
			err = s.BE().CacheError(err)
			return
		}

		// 开启广告
		if ads != nil && ads.OpenAd == mtype.Yes {
			if ads.CampaignAd == mtype.Yes && conf.AdsType == mtype.FissionCampaignConfigAdsTypeProject {
				s.Res.Config.OpenAd = mtype.Yes
			} else if conf.AdsType == mtype.FissionCampaignConfigAdsTypeOpen {
				s.Res.Config.OpenAd = mtype.Yes
			}
		}

		// 键值配置
		cd := conf.GetCampaignData()
		s.Res.CampaignData = make([]*pb.ShowRes_KV, 0, len(cd))
		for _, v := range cd {
			s.Res.CampaignData = append(s.Res.CampaignData, &pb.ShowRes_KV{
				Key:   v.Key,
				Value: v.Value,
			})
		}

		// 社媒配置
		var share = conf.GetShare()
		s.Res.Share = make([]*pb.ShowRes_Share, 0, len(share))
		var shareMap = consts.ShareMap
		for _, v := range share {
			if sh, ok := shareMap[v]; ok {
				s.Res.Share = append(s.Res.Share, &pb.ShowRes_Share{
					Id:        sh.Id,
					Title:     sh.Title,
					Logo:      sh.Logo,
					Scheme:    sh.Scheme,
					IosScheme: sh.IosScheme,
				})
			}
		}

		// 长图
		s.Res.LongImgs = make([]*pb.ShowRes_LongImg, 0, len(longImgs))
		for _, v := range longImgs {
			one := &pb.ShowRes_LongImg{
				ImgUrl:     v.ImgURL,
				WebUrl:     v.WebURL,
				AppParam:   v.AppParam,
				Id:         v.ID,
				ClickType:  int32(v.ClickType),
				HotZone:    make([]*pb.ShowRes_HotZone, 0, len(zoneMap[v.ID])),
				TargetType: int32(v.TargetType),
				TargetId:   v.TargetID,
				TargetUrl:  "",
				PcParam:    v.PcParam,
			}

			if v.TargetType == mtype.FissionCampaignLongImgTargetTypeCampaign {
				one.TargetUrl = blink.NewCampaignLink(project.Domain, targetCpnMap[v.TargetID].HashID, targetChannelMap[v.TargetID].Mark).CampaignShareLink()
			}

			for _, zone := range zoneMap[v.ID] {
				two := &pb.ShowRes_HotZone{
					Id:         zone.ID,
					WebUrl:     zone.WebURL,
					AppParam:   zone.AppParam,
					ClickX:     zone.ClickX,
					ClickY:     zone.ClickY,
					ClickW:     zone.ClickW,
					ClickH:     zone.ClickH,
					TargetType: int32(zone.TargetType),
					TargetId:   zone.TargetID,
					TargetUrl:  "",
					PcParam:    zone.PcParam,
				}

				if zone.TargetType == mtype.FissionCampaignLongImgTargetTypeCampaign {
					two.TargetUrl = blink.NewCampaignLink(project.Domain, targetCpnMap[zone.TargetID].HashID, targetChannelMap[zone.TargetID].Mark).CampaignShareLink()
				}

				one.HotZone = append(one.HotZone, two)

			}

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

		if pointsUse != nil {
			s.Res.PointsUse = &pb.ShowRes_PointsUse{
				Open:       int32(conf.PointsUse),
				Icon:       pointsUse.Icon,
				UrlId:      pointsUse.URLID,
				UseNum:     pointsUse.UseNum,
				DayLimit:   pointsUse.DayLimit,
				TotalLimit: pointsUse.TotalLimit,
			}
		}

		if chat != nil {
			s.Res.Chat = &pb.ShowRes_Chat{
				Open:      int32(conf.OpenChat),
				HeaderImg: chat.HeaderImg,
				ChatBg:    chat.ChatBg,
				DayLimit:  chat.DayLimit,
			}
		}

		return
	})

	return
}

func (s *Show) setTargetOption(cpn *model.FissionCampaign, conf *model.FissionCampaignConfig) (err error) {

	condM := s.GetDao().FissionCampaignCond
	var cond = []gen.Condition{
		condM.CampaignID.Eq(cpn.ID),
		condM.RewardID.Eq(0),
	}
	if cpn.Status == mtype.FissionCampaignStatusCancel {
		cond = append(cond, condM.DelUse.Eq(mtype.Yes))
	} else {
		cond = append(cond, condM.IsDel.Eq(mtype.No))
	}

	list, err := condM.WithContext(s.Ctx).Where(cond...).Find()
	if err != nil {
		err = s.BE().MysqlError(err)
		return
	}

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

	taskM := s.GetDao().FissionCampaignTask
	taskList, err := taskM.WithContext(s.Ctx).Where(
		taskM.CampaignID.Eq(cpn.ID),
		taskM.PropMark.In(
			mtype.FissionCampaignTaskPropMarkChance,
			mtype.FissionCampaignTaskPropMarkReward,
			mtype.FissionCampaignTaskPropMarkPoint,
			mtype.FissionCampaignTaskPropMarkUnoThree,
			mtype.FissionCampaignTaskPropMarkUnoFix,
			mtype.FissionCampaignTaskPropMarkUnoFive,
		),
		taskM.IsDel.Eq(mtype.No),
	).Find()
	if err != nil {
		err = s.BE().MysqlError(err)
		return
	}

	var rewardIds []int64
	var taskMap = make(map[string]*model.FissionCampaignTask, len(taskList))
	for _, task := range taskList {
		taskMap[task.TaskMark] = task
		rewardIds = append(rewardIds, task.RewardID)
	}

	var rewardMap = make(map[int64]*pb.ShowRes_Reward, len(rewardIds))
	if len(rewardIds) > 0 {
		rewardM := s.GetDao().FissionCampaignReward
		var rewards []*model.FissionCampaignReward
		rewards, err = rewardM.WithContext(s.Ctx).Where(rewardM.ID.In(rewardIds...)).Find()
		if err != nil {
			err = s.BE().MysqlError(err)
			return
		}

		var brids []int64
		for _, reward := range rewards {
			brids = append(brids, reward.RewardID)
		}

		var preward *provider.Rewards
		preward, err = provider.NewRewards(s.Ctx, cpn.ProjectID, brids...)
		if err != nil {
			return
		}

		for _, v := range rewards {
			info, _ := preward.InfoAutoLang(v.RewardID)
			rewardMap[v.ID] = &pb.ShowRes_Reward{
				Id:          v.ID,
				RewardId:    v.RewardID,
				Stock:       v.Stock,
				RewardNum:   v.RewardNum,
				Title:       info.RewardTitle,
				ImgUrl:      info.ImgUrl,
				ReceiveType: info.ReceiveType,
				Contact:     info.Contact,
				Url:         info.Url,
				FormTitle:   info.FormTitle,
				LangMark:    info.Mark,
				ExpiredDay:  v.ExpiredDay,
			}

			for _, datum := range info.KvData {
				rewardMap[v.ID].KvData = append(rewardMap[v.ID].KvData, &pb.ShowRes_KV{
					Key:   datum.Key,
					Value: datum.Value,
				})
			}
		}

	}

	s.AddAfterRun(func() (err error) {

		if consts.NewEventCpn(cpn.FissionID) {
			s.Res.TargetOption = &pb.ShowRes_TargetOption{
				Target: int32(conf.Target),
				Fixed:  nil,
				Custom: nil,
				Option: int32(conf.Option),
			}

			for _, ticket := range tickets {
				switch ticket.Mark {
				case mtype.FissionCampaignTicketFixed:
					fixed := &pb.ShowRes_Fixed{
						Open:        int32(ticket.Open),
						AppEvent:    int32(ticket.AppEvent),
						TargetNum:   0,
						Chance:      0,
						ChanceLimit: 0,
						Percent:     0,
					}

					switch ticket.AppEvent {
					case mtype.FissionCampaignTicketAppEventInstall:
						if task, ok := taskMap[mtype.FissionCampaignTaskMarkInstall]; ok {
							fixed.TargetNum = task.Num
							fixed.Chance = task.Chance
							fixed.ChanceLimit = task.ChanceLimit
							fixed.Percent = task.Percent
						}
					case mtype.FissionCampaignTicketAppEventRegister:
						if task, ok := taskMap[mtype.FissionCampaignTaskMarkRegister]; ok {
							fixed.TargetNum = task.Num
							fixed.Chance = task.Chance
							fixed.ChanceLimit = task.ChanceLimit
							fixed.Percent = task.Percent
						}
					}

					s.Res.TargetOption.Fixed = fixed
				case mtype.FissionCampaignTicketCustom:
					custom := &pb.ShowRes_Custom{
						Open:     int32(ticket.Open),
						BothType: int32(ticket.BothType),
						Cond:     nil,
						BothAll:  nil,
						PreEvent: int32(ticket.PreEvent),
					}

					for _, v := range list {
						one := &pb.ShowRes_Cond{
							Id:               v.ID,
							Event:            v.Event,
							EventKey:         v.EventKey,
							EventVal:         v.EventVal,
							Desc:             v.Desc,
							IfCond:           int32(v.IfCond),
							TaskLimit:        0,
							Chance:           0,
							TriggerType:      int32(v.TriggetType),
							DayLimit:         0,
							LevelIds:         nil,
							EventType:        int32(v.EventType),
							ViewType:         int32(v.ViewType),
							LangMarks:        nil,
							WatchSec:         v.WatchSec,
							WeekLimit:        0,
							WeekNum:          0,
							OpenJump:         int32(v.OpenJump),
							WebUrl:           v.WebURL,
							ExtraParam:       v.ExtraParam,
							GoShow:           int32(v.GoShow),
							AdsStrategyId:    v.AdsStrategyID,
							AdsStrategyTitle: "",
							IsSuper:          int32(v.IsSuper),
							HasPre:           0,
							PreCond:          0,
							ExpiredMin:       0,
							Reward:           nil,
							PropMark:         "",
							Sort:             v.Sort,
							OpenPush:         int32(v.OpenPush),
							PcParam:          v.PcParam,
							AwardMode:        0,
							GoText:           v.GoText,
							ClickEffectOpen:  int32(v.ClickEffectOpen),
							ClickEffect:      v.ClickEffect,
							ClickEffectUnit:  v.ClickEffectUnit,
							ExpiredDay:       "",
							PullInvite:       int32(v.PullInvite),
						}

						if task, ok := taskMap[utils.FissionCampaignTaskMarkCondOneVal(v.ID)]; ok {
							one.TaskLimit = task.TaskLimit
							one.DayLimit = task.DayLimit
							one.Chance = task.Chance
							one.LevelIds = task.GetLevelLimit()
							one.LangMarks = task.GetLangMarks()
							one.WeekLimit = task.WeekLimit
							one.WeekNum = int32(task.WeekNum)
							one.HasPre = int32(task.HasPre)
							one.PreCond = task.PreCond
							one.ExpiredMin = task.ExpiredMin
							one.PropMark = task.PropMark
							one.Reward = rewardMap[task.RewardID]
							one.AwardMode = int32(task.AwardMode)
							one.ExpiredDay = one.GetReward().GetExpiredDay()
						}

						custom.Cond = append(custom.Cond, one)
					}

					if task, ok := taskMap[mtype.FissionCampaignTaskMarkCondAll]; ok {
						custom.BothAll = &pb.ShowRes_BothAll{
							TaskLimit:  task.TaskLimit,
							Chance:     task.Chance,
							DayLimit:   task.DayLimit,
							LevelIds:   task.GetLevelLimit(),
							LangMarks:  task.GetLangMarks(),
							WeekLimit:  task.WeekLimit,
							WeekNum:    int32(task.WeekNum),
							Reward:     nil,
							PropMark:   task.PropMark,
							ExpiredDay: "",
						}

						if reward, ok1 := rewardMap[task.RewardID]; ok1 && reward != nil {
							custom.BothAll.Reward = reward
							custom.BothAll.ExpiredDay = reward.ExpiredDay
						}

					}
					s.Res.TargetOption.Custom = custom
				}
			}

			return
		}

		// 目标配置
		s.Res.Target = &pb.ShowRes_Target{
			Target:   int32(cpn.Target),
			Option:   int32(conf.Option),
			AppEvent: int32(conf.AppEvent),
			BothType: int32(conf.BothType),
			Cond:     make([]*pb.ShowRes_Cond, 0, len(list)),
		}

		for _, v := range list {
			one := &pb.ShowRes_Cond{
				Id:          v.ID,
				Event:       v.Event,
				EventKey:    v.EventKey,
				EventVal:    v.EventVal,
				Desc:        v.Desc,
				IfCond:      int32(v.IfCond),
				TriggerType: int32(v.TriggetType),
				EventType:   int32(v.EventType),
			}

			if task, ok := taskMap[utils.FissionCampaignTaskMarkCondOneVal(v.ID)]; ok {
				one.TaskLimit = task.TaskLimit
				one.Chance = task.Chance
			}

			s.Res.Target.Cond = append(s.Res.Target.Cond, one)
		}

		return
	})

	return
}

// 设置玩法特有数据
func (s *Show) setFission(cpn *model.FissionCampaign) (err error) {
	switch cpn.FissionID {
	case consts.IdPrizeWheel: //大转盘
		return s._setPrizeWheel(cpn)
	case consts.IdSlotMachine: //老虎机
		return s._setSlotMachine(cpn)
	case consts.IdLuckyGrid: //九宫格
		return s._setLuckyGrid(cpn)
	case consts.IdBlindBox: //盲盒
		return s._setBlindBox(cpn)
	case consts.IdReferral: //老带新
		return s._setReferral(cpn)
	case consts.IdPrizeAnswer, consts.IdQa, consts.IdQaAudio, consts.IdQaVideo: //趣味问答
		return s._setPrizeAnswer(cpn)
	case consts.IdPrizeQuiz: //有奖竞猜
		return s._setPrizeQuiz(cpn)
	case consts.IdWinTogether: //老带新
		return s._setWinTogether(cpn)
	case consts.IdSignIn: //签到
		return s._setSignIn(cpn)
	case consts.IdDice: //大富翁
		return s._setDice(cpn)
	case consts.IdGrow: //农场
		return s._setGrow(cpn)
	case consts.IdBallot: //抽签
		return s._setBallot(cpn)
	case consts.IdChop: //砍一刀
		return s._setChop(cpn)
	case consts.IdCash: //现金抽奖
		return s._setCash(cpn)
	case consts.IdFlip: //翻牌活动
		return s._setFlip(cpn)
	case consts.IdKeep: //激励养成
		return s._setKeep(cpn)
	case consts.IdGold: //金币任务
		return s._setGold(cpn)
	case consts.IdCoin: //金币池
		return s._setCoin(cpn)
	case consts.IdVs:
		return s._setVs(cpn)
	case consts.IdUno:
		return s._setUno(cpn)
	case consts.IdGashapon: //扭蛋机
		return s._setGashapon(cpn)
	default:

	}
	return
}

// 设置赛事竞猜
func (s *Show) _setPrizeQuiz(cpn *model.FissionCampaign) (err error) {

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

	if fcq == nil {
		return workerr.NotFound("not found quiz")
	}

	optionM := s.GetDao().FissionCampaignQuizOption
	options, err := optionM.WithContext(s.Ctx).Where(optionM.CampaignID.Eq(cpn.ID), optionM.IsDel.Eq(mtype.No)).Find()
	if err != nil {
		return s.BE().MysqlError(err)
	}

	s.AddAfterRun(func() (err error) {
		s.Res.Quiz = &pb.ShowRes_Quiz{
			TargetNum:  fcq.TargetNum,
			InitChance: fcq.InitChance,
			Chance:     fcq.Chance,
			RewardRule: int32(fcq.RewardRule),
			OpenPrize:  fcq.OpenPrize,
			Title:      fcq.Title,
			OpenType:   int32(fcq.OpenType),
			Options:    make([]*pb.ShowRes_QuizOption, 0, len(options)),
			TOpen:      fcq.TOpen,
		}

		for _, v := range options {
			s.Res.Quiz.Options = append(s.Res.Quiz.Options, &pb.ShowRes_QuizOption{
				Id:      v.ID,
				Title:   v.Title,
				ImgUrl:  v.ImgURL,
				IsRight: int32(v.IsRight),
				VoteNum: v.VoteNum,
			})
		}

		return
	})

	return
}

// 大转盘数据
func (s *Show) _setPrizeWheel(cpn *model.FissionCampaign) error {
	cc := cache.NewCampaignWheel(s.Ctx)
	conf, err := cc.FindByCampaignId(cpn.ID)
	if err != nil {
		return s.BE().CacheError(err)
	}

	if conf == nil {
		return workerr.NotFound("not found wheel conf")
	}

	s.AddAfterRun(func() (err error) {
		s.Res.PrizeWheel = &pb.ShowRes_LotteryConfig{
			TargetNum:  conf.TargetNum,
			InitChance: conf.InitChance,
			Chance:     conf.Chance,
			DayChance:  conf.DayChance,
		}
		return
	})

	return nil
}

func (s *Show) _setReferral(cpn *model.FissionCampaign) (err error) {
	rfl, err := cache.NewCampaignReferral(s.Ctx).FindByCampaignId(cpn.ID)
	if err != nil {
		err = s.BE().CacheError(err)
		return
	}

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

	s.AddAfterRun(func() (err error) {
		s.Res.Referral = &pb.ShowRes_InviteConfig{
			RewardLimit: rfl.RewardLimit,
			RewardRule:  int32(rfl.RewardRule),
			InviteLimit: rfl.InviteLimit,
			StepLoop:    int32(rfl.StepLoop),
		}

		return
	})

	return
}

func (s *Show) _setSlotMachine(cpn *model.FissionCampaign) (err error) {
	conf, err := cache.NewCampaignSlot(s.Ctx).FindByCampaignId(cpn.ID)
	if err != nil {
		err = s.BE().CacheError(err)
		return
	}

	if conf == nil {
		return workerr.NotFound("not found blind conf")
	}

	s.AddAfterRun(func() (err error) {
		s.Res.Slot = &pb.ShowRes_LotteryConfig{
			TargetNum:  conf.TargetNum,
			InitChance: conf.InitChance,
			Chance:     conf.Chance,
			DayChance:  conf.DayChance,
		}

		return
	})

	return
}

func (s *Show) _setLuckyGrid(cpn *model.FissionCampaign) (err error) {
	conf, err := cache.NewCampaignGrid(s.Ctx).FindByCampaignId(cpn.ID)
	if err != nil {
		err = s.BE().CacheError(err)
		return
	}

	if conf == nil {
		return workerr.NotFound("not found grid conf")
	}

	s.AddAfterRun(func() (err error) {
		s.Res.Grid = &pb.ShowRes_LotteryConfig{
			TargetNum:  conf.TargetNum,
			InitChance: conf.InitChance,
			Chance:     conf.Chance,
			DayChance:  conf.DayChance,
		}

		return
	})

	return
}

func (s *Show) _setBlindBox(cpn *model.FissionCampaign) (err error) {
	conf, err := cache.NewCampaignBlind(s.Ctx).FindByCampaignId(cpn.ID)
	if err != nil {
		err = s.BE().CacheError(err)
		return
	}

	if conf == nil {
		return workerr.NotFound("not found blind conf")
	}

	s.AddAfterRun(func() (err error) {
		s.Res.Blind = &pb.ShowRes_LotteryConfig{
			TargetNum:  conf.TargetNum,
			InitChance: conf.InitChance,
			Chance:     conf.Chance,
			DayChance:  conf.DayChance,
		}

		return
	})

	return
}

func (s *Show) _setPrizeAnswer(cpn *model.FissionCampaign) (err error) {
	qa, err := cache.NewCampaignQa(s.Ctx).FindByCampaignId(cpn.ID)
	if err != nil {
		err = s.BE().CacheError(err)
		return
	}

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

	var (
		questions                     []*model.FissionCampaignQaQuestion
		options                       []*model.FissionCampaignQaOption
		qoMap                         = make(map[int64][]*model.FissionCampaignQaOption)
		groupHashId, guideGroupHashId string
	)

	if cpn.FissionID == consts.IdPrizeAnswer {
		cqqM := s.GetDao().FissionCampaignQaQuestion
		questions, err = cqqM.WithContext(s.Ctx).Where(cqqM.QaID.Eq(qa.ID), cqqM.IsDel.Eq(mtype.No)).Order(cqqM.Sort).Find()
		if err != nil {
			return s.BE().MysqlError(err)
		}

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

		cqoM := s.GetDao().FissionCampaignQaOption
		options, err = cqoM.WithContext(s.Ctx).Where(cqoM.QuestionID.In(qids...), cqoM.IsDel.Eq(mtype.No)).Find()
		if err != nil {
			return s.BE().MysqlError(err)
		}

		for _, v := range options {
			qoMap[v.QuestionID] = append(qoMap[v.QuestionID], v)
		}
	}

	if qa.QaGroupID > 0 {
		var group *model.LibraryQaGroup
		groupM := s.GetDao().LibraryQaGroup
		group, err = groupM.WithContext(s.Ctx).Where(groupM.ID.Eq(qa.QaGroupID)).Take()
		if err = dbcheck.DbError(err); err != nil {
			err = s.BE().MysqlError(err)
			return
		}

		if group != nil {
			groupHashId = group.HashID
		}
	}

	if qa.GuideGroupID > 0 {
		var group *model.LibraryQaGroup
		groupM := s.GetDao().LibraryQaGroup
		group, err = groupM.WithContext(s.Ctx).Where(groupM.ID.Eq(qa.GuideGroupID)).Take()
		if err = dbcheck.DbError(err); err != nil {
			err = s.BE().MysqlError(err)
			return
		}

		if group != nil {
			guideGroupHashId = group.HashID
		}
	}

	s.AddAfterRun(func() (err error) {

		s.Res.QuestionAnswer = &pb.ShowRes_QuestionAnswer{
			TargetNum:        qa.TargetNum,
			Chance:           qa.Chance,
			InitChance:       qa.InitChance,
			QuestionAskTime:  qa.QuestionAskTime,
			Questions:        make([]*pb.ShowRes_QaQuestion, 0, len(questions)),
			GroupHashId:      groupHashId,
			QaNum:            qa.QaNum,
			DayChance:        qa.DayChance,
			OpenGuide:        int32(qa.OpenGuide),
			GuideGroupHashId: guideGroupHashId,
		}

		for _, v := range questions {
			one := &pb.ShowRes_QaQuestion{
				Id:      v.ID,
				Title:   v.Title,
				Score:   v.Score,
				Options: nil,
			}

			if ops, ok := qoMap[v.ID]; ok {
				one.Options = make([]*pb.ShowRes_QaOption, 0, len(ops))
				for _, op := range ops {
					one.Options = append(one.Options, &pb.ShowRes_QaOption{
						Id:      op.ID,
						Title:   op.Title,
						IsRight: int32(op.IsRight),
					})
				}
			}

			s.Res.QuestionAnswer.Questions = append(s.Res.QuestionAnswer.Questions, one)
		}

		return
	})

	return
}

func (s *Show) _setWinTogether(cpn *model.FissionCampaign) (err error) {

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

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

	s.AddAfterRun(func() (err error) {
		s.Res.Win = &pb.ShowRes_InviteConfig{
			RewardLimit:  fcw.RewardLimit,
			RewardRule:   int32(fcw.RewardRule),
			InviteLimit:  fcw.InviteLimit,
			NewcomerCond: int32(fcw.NewcomerCond),
			StepLoop:     int32(fcw.StepLoop),
		}

		return
	})

	return
}

func (s *Show) _setSignIn(cpn *model.FissionCampaign) (err error) {
	conf, err := cache.NewCampaignSign(s.Ctx).FindByCampaignId(cpn.ID)
	if err != nil {
		err = s.BE().CacheError(err)
		return
	}

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

	s.AddAfterRun(func() (err error) {
		s.Res.Sign = &pb.ShowRes_Sign{
			SignType:     int32(conf.SignType),
			IsContinue:   int32(conf.IsContinue),
			HasCard:      int32(conf.HasCard),
			InviteNum:    conf.InviteNum,
			LimitCardNum: 0,
			IsLoop:       int32(conf.IsLoop),
			SignCycle:    conf.SignCycle,
			RecycleType:  int32(conf.RecycleType),
			Color:        conf.Color,
		}

		return
	})

	return
}

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

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

	s.AddAfterRun(func() (err error) {
		s.Res.Dice = &pb.ShowRes_Dice{
			InitChance:    fcd.InitChance,
			DayChance:     fcd.DayChance,
			FixDice:       int32(fcd.FixDice),
			FixDiceTarget: fcd.FixDiceTarget,
			FixDiceLimit:  fcd.FixDiceLimit,
			CustomDice:    fcd.CustomDice,
			OpenMapPoint:  int32(fcd.OpenMapPoint),
			MapPoint: &pb.ShowRes_MapPoint{
				Blank:  fcd.GetMapPoint().Blank,
				Again:  fcd.GetMapPoint().Again,
				Normal: fcd.GetMapPoint().Normal,
				Supper: fcd.GetMapPoint().Supper,
			},
			AwardType:   int32(fcd.AwardType),
			OpenInvite:  int32(fcd.OpenInvite),
			RollAgain:   int32(fcd.RollAgain),
			FixDiceCond: int32(fcd.FixDiceCond),
			Odds:        fcd.Odds,
			PlayImg:     fcd.PlayImg,
			CloudImg:    fcd.CloudImg,
		}

		return
	})

	return
}

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

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

	stepM := s.GetDao().FissionCampaignGrowStep

	steps, err := stepM.WithContext(s.Ctx).Where(stepM.CampaignID.Eq(cpn.ID), stepM.IsDel.Eq(mtype.No)).Find()
	if err != nil {
		err = s.BE().MysqlError(err)
		return
	}

	s.AddAfterRun(func() (err error) {
		s.Res.Grow = &pb.ShowRes_Grow{
			AutoHour:  conf.AutoHour,
			AutoNum:   conf.AutoNum,
			GrowNum:   conf.GrowNum,
			TargetNum: conf.TargetNum,
			Revive:    int32(conf.Revive),
			ReviveNum: conf.ReviveNum,
			DieHour:   conf.DieHour,
			Steps:     make([]*pb.ShowRes_GrowStep, 0, len(steps)),
			InitNum:   conf.InitNum,
		}

		for _, step := range steps {
			s.Res.Grow.Steps = append(s.Res.Grow.Steps, &pb.ShowRes_GrowStep{
				Id:  step.ID,
				Num: step.Num,
			})
		}

		return
	})

	return
}

func (s *Show) _setBallot(cpn *model.FissionCampaign) (err error) {

	conf, err := cache.NewCampaignBallot(s.Ctx).FindByCampaignId(cpn.ID)
	if err != nil {
		err = s.BE().CacheError(err)
		return
	}
	if conf == nil {
		return workerr.NotFound("not found")
	}

	s.AddAfterRun(func() (err error) {
		s.Res.Ballot = &pb.ShowRes_Ballot{
			InitChance: conf.InitChance,
			DayChance:  conf.DayChance,
		}

		return
	})

	return
}

func (s *Show) _setChop(cpn *model.FissionCampaign) (err error) {
	conf, err := cache.NewCampaignChop(s.Ctx).FindByCampaignId(cpn.ID)
	if err != nil {
		return s.BE().CacheError(err)
	}

	if conf == nil {
		return workerr.NotFound("not found chop conf")
	}

	s.AddAfterRun(func() (err error) {
		s.Res.Chop = &pb.ShowRes_Chop{
			ShowBar: int32(conf.ShowBar),
		}

		return
	})

	return
}

// 设置延迟深度链接数据
func (s *Show) setDelayLinkData(cpn *model.FissionCampaign) (err error) {
	res, err := app.NewDeepLinkLink().GetCampaignDataList(s.Ctx, &dlinkpb.GetCampaignDataListReq{
		ProjectId:  cpn.ProjectID,
		CampaignId: cpn.ID,
	})
	if err != nil {
		return
	}

	s.Res.DelayLinkData = make([]*pb.ShowRes_KV, 0, len(res.GetList()))
	for _, v := range res.GetList() {
		s.Res.DelayLinkData = append(s.Res.DelayLinkData, &pb.ShowRes_KV{
			Key:   v.GetKey(),
			Value: v.GetVal(),
		})
	}

	return
}

// 设置奖品数据
func (s *Show) setReward(cpn *model.FissionCampaign, conf *model.FissionCampaignConfig) (err error) {
	err = s._helpMap(cpn)
	if err != nil {
		return
	}
	err = s._ruleMap(cpn)
	if err != nil {
		return
	}

	tempM := s.GetDao().FissionTemp
	temp, err := tempM.WithContext(s.Ctx).Where(tempM.ID.Eq(cpn.TemplateID)).Take()
	if err = dbcheck.DbError(err); err != nil {
		err = s.BE().MysqlError(err)
		return
	}

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

	tempMark := mtype.FissionLangTypeToMark[temp.LangType]

	m := s.GetDao().FissionCampaignReward
	list, err := m.WithContext(s.Ctx).Where(
		m.CampaignID.Eq(conf.CampaignID),
		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
	}

	err = s._rewardAddMap(cpn.ID, cpn.TOffset)
	if err != nil {
		return
	}

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

	var rewardIds []int64
	var rewardInfoMap = make(map[int64]*provider.RewardInfo)
	var webList, extraList, newcomerList, appList []*model.FissionCampaignReward
	for _, v := range list {
		if _, ok := rewardInfoMap[v.RewardID]; !ok {
			rewardInfoMap[v.RewardID] = nil
			rewardIds = append(rewardIds, v.RewardID)
		}

		switch v.RewardType {
		case mtype.FissionCampaignRewardTypeApp:
			appList = append(appList, v)
		case mtype.FissionCampaignRewardTypeWeb:
			webList = append(webList, v)
		case mtype.FissionCampaignRewardTypeExtra:
			extraList = append(extraList, v)
		case mtype.FissionCampaignRewardTypeNewcomer:
			newcomerList = append(newcomerList, v)
		}
	}

	preward, err := provider.NewRewards(s.Ctx, cpn.ProjectID, rewardIds...)
	if err != nil {
		return
	}

	rewardInfoMap, err = preward.InfoMap()
	if err != nil {
		return
	}

	langMark := mtype.FissionLangTypeToMark[cpn.GetLangTypes()[0]]

	s._appendReward(preward, webList, &s.Res.RewardsWeb, langMark)
	s._appendReward(preward, extraList, &s.Res.RewardsExtra, langMark)
	s._appendReward(preward, newcomerList, &s.Res.RewardsNewcomer, langMark)

	s.Res.Rewards = &pb.ShowRes_Rewards{
		RewardGroup:   int32(conf.RewardGroup),
		Normal:        nil,
		UserLevel:     nil,
		Langs:         nil,
		LangUserLevel: nil,
	}

	ful := finder.NewFuserLayer(conf)

	switch conf.RewardGroup {
	case mtype.FissionRewardGroupNormal:
		s._appendReward(preward, appList, &s.Res.Rewards.Normal, langMark)
	case mtype.FissionRewardGroupUserLevel:
		var levelMap = make(map[int64]string)
		levelMap, err = s._getLevelMap(cpn.ProjectID)
		if err != nil {
			return
		}

		dlId := ful.Level().Default
		s.Res.Rewards.UserLevel = &pb.ShowRes_UserLevel{
			DefaultLevelId:    dlId,
			DefaultLevelTitle: levelMap[dlId],
			LevelList:         nil,
		}

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

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

		s._appendUserLevel(preward, levelIds, levelRewardMap, &s.Res.Rewards.UserLevel.LevelList, langMark)
	case mtype.FissionRewardGroupLang:
		var langMarks []string
		var langRewardMap = make(map[string][]*model.FissionCampaignReward)
		for _, v := range appList {
			if _, ok := langRewardMap[v.LangMark]; !ok {
				langMarks = append(langMarks, v.LangMark)
			}
			langRewardMap[v.LangMark] = append(langRewardMap[v.LangMark], v)
		}

		s.Res.Rewards.Langs = make([]*pb.ShowRes_Lang, 0, len(langMarks))
		for _, mark := range langMarks {
			one := &pb.ShowRes_Lang{
				LangType:    int32(mtype.MarkToLangType[mark]),
				LangMark:    mark,
				DefaultLang: mark == tempMark,
				Rewards:     nil,
			}

			s._appendReward(preward, langRewardMap[mark], &one.Rewards, mark)
			s.Res.Rewards.Langs = append(s.Res.Rewards.Langs, one)
		}
	case mtype.FissionRewardGroupLangAndUserLevel:
		dms := ful.LangLevel().Default
		var dmMap = make(map[string]int64)
		for _, dm := range dms {
			dmMap[dm.Lang] = dm.Level
		}

		var langMarks []string
		var langLevelMap = make(map[string][]int64)

		var levelRewardMap = make(map[string]map[int64][]*model.FissionCampaignReward)
		for _, v := range appList {
			if _, ok := langLevelMap[v.LangMark]; !ok {
				langMarks = append(langMarks, v.LangMark)
				levelRewardMap[v.LangMark] = make(map[int64][]*model.FissionCampaignReward)
			}

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

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

		s.Res.Rewards.LangUserLevel = make([]*pb.ShowRes_LangUserLevel, 0, len(langMarks))

		var levelMap = make(map[int64]string)
		levelMap, err = s._getLevelMap(cpn.ProjectID)
		if err != nil {
			return
		}

		for _, mark := range langMarks {
			var levelIds = langLevelMap[mark]

			one := &pb.ShowRes_LangUserLevel{
				LangMark:          mark,
				LangType:          int32(mtype.MarkToLangType[mark]),
				DefaultLang:       mark == tempMark,
				DefaultLevelId:    dmMap[mark],
				DefaultLevelTitle: levelMap[dmMap[mark]],
				LevelList:         make([]*pb.ShowRes_UserLevelOne, 0, len(levelIds)),
			}

			s._appendUserLevel(preward, levelIds, levelRewardMap[mark], &one.LevelList, mark)
			s.Res.Rewards.LangUserLevel = append(s.Res.Rewards.LangUserLevel, one)
		}
	case mtype.FissionRewardGroupCountry:
		s.Res.Rewards.Country = &pb.ShowRes_Country{
			DefaultCountryMark: ful.Country().Default,
			CountryList:        nil,
		}

		var countryIds []string
		var countryRewardMap = make(map[string][]*model.FissionCampaignReward)
		for _, v := range appList {
			if _, ok := countryRewardMap[v.CountryMark]; !ok {
				countryIds = append(countryIds, v.CountryMark)
			}

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

		s._appendCountry(preward, countryIds, countryRewardMap, &s.Res.Rewards.Country.CountryList, langMark)
	}
	return
}

func (s *Show) _appendReward(preward *provider.Rewards, in []*model.FissionCampaignReward, out *[]*pb.ShowRes_Reward, langMark string) {
	*out = make([]*pb.ShowRes_Reward, 0, len(in))

	for _, v := range in {
		one := &pb.ShowRes_Reward{
			Id:                v.ID,
			RewardId:          v.RewardID,
			Stock:             v.Stock,
			InviteNum:         v.InviteNum,
			RewardNum:         v.RewardNum,
			IsThank:           int32(v.IsThank),
			Score:             v.Score,
			SignDay:           v.SignDay,
			CollectNum:        v.CollectNum,
			IsSuper:           int32(v.IsSuper),
			KvData:            nil,
			Title:             "",
			ImgUrl:            "",
			ReceiveType:       0,
			Contact:           "",
			Url:               "",
			Help:              0,
			HelpPercent:       0,
			Click:             0,
			ClickPercent:      0,
			ClickPercentLimit: 0,
			Open:              0,
			OpenPercent:       0,
			OpenPercentLimit:  0,
			LangMark:          "",
			Odds:              v.Odds,
			JumpUrl:           v.JumpURL,
			FormTitle:         "",
			CampaignLimit:     0,
			Register:          0,
			RegisterPercent:   0,
			InitPercent:       v.InitPercent,
			CollectRule:       nil,
			OpenAdd:           nil,
			RewardTask:        nil,
		}

		if add, ok := s.rewardAddMap[v.ID]; ok {
			one.OpenAdd = add
			one.OpenAdd.Open = int32(v.OpenAdd)
		}

		if task, ok := s.rewardTaskMap[v.ID]; ok {
			one.RewardTask = task
			one.RewardTask.Open = int32(v.OpenTask)
		}

		if v.CollectRule != "" {
			collectRule := v.GetCollectRule()
			one.CollectRule = &pb.ShowRes_CollectRule{
				Open:        collectRule.Open,
				InitCollect: collectRule.InitCollect,
				SignDay:     collectRule.SignDay,
				AddCollect:  collectRule.AddCollect,
				ResetType:   collectRule.ResetType,
			}
		}

		info, _ := preward.Info(v.RewardID)
		if info != nil {
			one.ReceiveType = info.ReceiveType
			one.Contact = info.Contact
			one.Url = info.Url
			one.FormTitle = info.FormTitle

			for _, kv := range info.KvData {
				one.KvData = append(one.KvData, &pb.ShowRes_KV{
					Key:   kv.Key,
					Value: kv.Value,
				})
			}
		}

		lang := preward.AutoLang(v.RewardID, langMark)
		one.Title, one.ImgUrl, one.LangMark = lang.Title, lang.ImgUrl, lang.Mark

		for _, help := range s.helpMap[v.ID] {
			switch help.TaskType {
			case mtype.FissionCampaignTaskTypeInstall:
				one.Help = mtype.Yes
				one.HelpPercent = help.Percent
			case mtype.FissionCampaignTaskTypeOpen:
				one.Open = mtype.Yes
				one.OpenPercent = help.Percent
				one.OpenPercentLimit = help.PercentLimit
			case mtype.FissionCampaignTaskTypeClick:
				one.Click = mtype.Yes
				one.ClickPercent = help.Percent
				one.ClickPercentLimit = help.PercentLimit
			case mtype.FissionCampaignTaskTypeRegister:
				one.Register = mtype.Yes
				one.RegisterPercent = help.Percent
			}
		}

		if rule, ok := s.ruleMap[v.ID]; ok {
			one.CampaignLimit = rule.CampaignLimit
		}

		*out = append(*out, one)
	}
}

func (s *Show) _rewardAddMap(campaignID int64, tOffset int32) (err error) {
	m := s.GetDao().FissionCampaignRewardAdd
	list, err := m.WithContext(s.Ctx).Where(m.CampaignID.Eq(campaignID), m.IsDel.Eq(mtype.No)).Find()
	if err != nil {
		return s.BE().MysqlError(err)
	}

	s.rewardAddMap = make(map[int64]*pb.ShowRes_OpenAdd, len(list))
	for _, v := range list {
		s.rewardAddMap[v.RewardID] = &pb.ShowRes_OpenAdd{
			Start:  timez.STZ(v.Start, tOffset),
			End:    timez.STZ(v.End, tOffset),
			DayNum: v.DayNum,
			DayAdd: v.DayAdd,
		}
	}

	return
}

func (s *Show) _rewardTaskMap(campaignID int64) (err error) {
	m := s.GetDao().FissionCampaignCond
	list, err := m.WithContext(s.Ctx).Where(m.CampaignID.Eq(campaignID), m.IsDel.Eq(mtype.No), m.RewardID.Gt(0)).Find()
	if err != nil {
		return s.BE().MysqlError(err)
	}

	s.rewardTaskMap = make(map[int64]*pb.ShowRes_RewardTask, len(list))
	for _, v := range list {
		s.rewardTaskMap[v.RewardID] = &pb.ShowRes_RewardTask{
			Event:       v.Event,
			EventKey:    v.EventKey,
			EventVal:    v.EventVal,
			IfCond:      int32(v.IfCond),
			TriggerType: int32(v.TriggetType),
			EventType:   int32(v.EventType),
			OpenPush:    int32(v.OpenPush),
		}
	}

	return
}

func (s *Show) _appendUserLevel(preward *provider.Rewards, levelIds []int64, levelRewardMap map[int64][]*model.FissionCampaignReward, out *[]*pb.ShowRes_UserLevelOne, langMark string) {
	*out = make([]*pb.ShowRes_UserLevelOne, 0, len(levelIds))

	levelMap, _ := s._getLevelMap(preward.GetProjectId())

	for _, id := range levelIds {
		one := &pb.ShowRes_UserLevelOne{
			LevelId:    id,
			LevelTitle: levelMap[id],
			Rewards:    nil,
		}

		s._appendReward(preward, levelRewardMap[id], &one.Rewards, langMark)
		*out = append(*out, one)
	}
}

func (s *Show) _appendCountry(preward *provider.Rewards, countryMarks []string, countryRewardMap map[string][]*model.FissionCampaignReward, out *[]*pb.ShowRes_CountryOne, langMark string) {
	*out = make([]*pb.ShowRes_CountryOne, 0, len(countryMarks))
	for _, id := range countryMarks {
		one := &pb.ShowRes_CountryOne{
			CountryMark: id,
			Rewards:     nil,
		}

		s._appendReward(preward, countryRewardMap[id], &one.Rewards, langMark)
		*out = append(*out, one)
	}
}

func (s *Show) _getLevelMap(projectId int64) (data map[int64]string, err error) {

	if s.levelMap != nil {
		return s.levelMap, nil
	}

	m := s.GetDao().FissionUserLevel
	list, err := m.WithContext(s.Ctx).Where(m.ProjectID.Eq(projectId), m.DeletedAt.Eq(0)).Find()
	if err != nil {
		err = s.BE().MysqlError(err)
		return
	}

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

	s.levelMap = data

	return
}

func (s *Show) _helpMap(cpn *model.FissionCampaign) (err error) {
	var helpMap = make(map[int64][]*model.FissionCampaignTask)

	defer func() {
		s.helpMap = helpMap
	}()

	if cpn.FissionID != consts.IdChop {
		return
	}

	helpM := s.GetDao().FissionCampaignTask
	helps, err := helpM.WithContext(s.Ctx).Where(helpM.CampaignID.Eq(cpn.ID), helpM.IsDel.Eq(mtype.No)).Find()
	if err != nil {
		err = s.BE().MysqlError(err)
		return
	}

	for _, v := range helps {
		rewardId := utils.FissionCampaignTaskMarkRewardOneRewardId(v.TaskMark)
		if rewardId <= 0 {
			continue
		}

		helpMap[rewardId] = append(helpMap[rewardId], v)
	}

	return
}

func (s *Show) _ruleMap(cpn *model.FissionCampaign) (err error) {
	ruleM := s.GetDao().FissionCampaignRewardRule
	rules, err := ruleM.WithContext(s.Ctx).Where(ruleM.CampaignID.Eq(cpn.ID)).Find()
	if err != nil {
		err = s.BE().MysqlError(err)
		return
	}
	var ruleMap = make(map[int64]*model.FissionCampaignRewardRule, len(rules))
	for _, v := range rules {
		ruleMap[v.RewardID] = v
	}

	s.ruleMap = ruleMap

	return
}

func (s *Show) _setCash(cpn *model.FissionCampaign) (err error) {
	conf, err := cache.NewCampaignCash(s.Ctx).FindByCampaignId(cpn.ID)
	if err != nil {
		err = s.BE().CacheError(err)
		return
	}

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

	s.AddAfterRun(func() (err error) {
		s.Res.Cash = &pb.ShowRes_Cash{
			ExpiredDay: conf.ExpiredDay,
			Price:      conf.Price,
			PriceNum:   conf.PriceNum,
			SpinCash:   make([]*pb.ShowRes_SpinCash, 0, len(consts.FissionCashSpin)),
			Lack:       int32(conf.Lack),
			Currency:   int32(conf.Currency),
			LoopNum:    conf.LoopNum,
		}

		for _, v := range consts.FissionCashSpin {
			s.Res.Cash.SpinCash = append(s.Res.Cash.SpinCash, &pb.ShowRes_SpinCash{
				Id:   v.Id,
				Cash: v.Cash,
			})
		}

		return
	})

	return
}

func (s *Show) _setFlip(cpn *model.FissionCampaign) (err error) {
	conf, err := cache.NewCampaignFlip(s.Ctx).FindByCampaignId(cpn.ID)
	if err != nil {
		err = s.BE().CacheError(err)
		return
	}

	if conf == nil {
		return workerr.NotFound("not found flip conf")
	}

	s.AddAfterRun(func() (err error) {
		s.Res.Flip = &pb.ShowRes_Flip{
			InitChance: conf.InitChance,
			CardImg:    conf.CardImg,
			DayChance:  conf.DayChance,
		}

		return
	})

	return
}

func (s *Show) _setKeep(cpn *model.FissionCampaign) (err error) {
	conf, err := cache.NewCampaignKeep(s.Ctx).FindByCampaignId(cpn.ID)
	if err != nil {
		err = s.BE().CacheError(err)
		return
	}

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

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

	var rewardIds []int64
	for _, v := range steps {
		if v.RewardID > 0 {
			rewardIds = append(rewardIds, v.RewardID)
		}
	}

	var rewardMap = make(map[int64]*pb.ShowRes_Reward)
	if len(rewardIds) > 0 {
		rewardM := s.GetDao().FissionCampaignReward
		var rewardList []*model.FissionCampaignReward
		rewardList, err = rewardM.WithContext(s.Ctx).Where(rewardM.ID.In(rewardIds...)).Find()
		if err != nil {
			err = s.BE().MysqlError(err)
			return
		}

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

		brewards, _ := provider.NewRewards(s.Ctx, cpn.ProjectID, bIds...)
		for _, v := range rewardList {
			info, _ := brewards.InfoAutoLang(v.RewardID)
			rewardMap[v.ID] = &pb.ShowRes_Reward{
				Id:          v.ID,
				RewardId:    v.RewardID,
				Stock:       v.Stock,
				RewardNum:   v.RewardNum,
				Title:       info.RewardTitle,
				ImgUrl:      info.ImgUrl,
				ReceiveType: info.ReceiveType,
				Contact:     info.Contact,
				Url:         info.Url,
				FormTitle:   info.FormTitle,
				LangMark:    info.Mark,
			}

			for _, datum := range info.KvData {
				rewardMap[v.ID].KvData = append(rewardMap[v.ID].KvData, &pb.ShowRes_KV{
					Key:   datum.Key,
					Value: datum.Value,
				})
			}

		}

	}

	s.AddAfterRun(func() (err error) {
		s.Res.KeepDog = &pb.ShowRes_Keep{
			Collect:        conf.Collect,
			CollectSecond:  conf.CollectSecond,
			OpenInvite:     int32(conf.OpenInvite),
			Invite:         nil,
			InitGet:        conf.InitGet,
			SecGet:         conf.SecGet,
			FeedNum:        conf.FeedNum,
			FeedCycle:      conf.FeedCycle,
			MaxFeed:        conf.MaxFeed,
			FeedGet:        conf.FeedGet,
			FeedGetNum:     conf.FeedGetNum,
			TalkText:       nil,
			Steps:          make([]*pb.ShowRes_KeepStep, 0, len(steps)),
			SecGetDayLimit: conf.SecGetDayLimit,
			MachineType:    int32(conf.MachineType),
			OfflineMin:     conf.OfflineMin,
			OfflineGet:     conf.OfflineGet,
			OfflineLimit:   conf.OfflineLimit,
		}

		_ = jsonm.StrUnmarshal(conf.Invite, &s.Res.KeepDog.Invite)
		_ = jsonm.StrUnmarshal(conf.TalkText, &s.Res.KeepDog.TalkText)

		for _, v := range steps {
			s.Res.KeepDog.Steps = append(s.Res.KeepDog.Steps, &pb.ShowRes_KeepStep{
				Step:       v.Step,
				Percent:    v.Percent,
				RewardType: int32(v.RewardType),
				Reward:     rewardMap[v.RewardID],
				RewardNum:  v.RewardNum,
			})
		}

		return
	})

	return
}

func (s *Show) setPush(cpn *model.FissionCampaign) (err error) {
	m := s.GetDao().FissionCampaignPush
	list, err := m.WithContext(s.Ctx).Where(m.CampaignID.Eq(cpn.ID)).Find()
	if err != nil {
		err = s.BE().MysqlError(err)
		return
	}

	s.Res.Push = &pb.ShowRes_Push{}

	for _, v := range list {
		if v.Open == mtype.No {
			continue
		}
		switch v.Mark {
		case mtype.FissionCampaignPushMarkActive:
			s.Res.Push.Active = &pb.ShowRes_PushOne{
				Open:     mtype.Yes,
				PushCond: nil,
			}

			_ = jsonm.StrUnmarshal(v.Cond, &s.Res.Push.Active.PushCond)
		case mtype.FissionCampaignPushMarkTaskReset:
			s.Res.Push.TaskReset = &pb.ShowRes_PushOne{
				Open:     mtype.Yes,
				PushCond: nil,
			}

			_ = jsonm.StrUnmarshal(v.Cond, &s.Res.Push.TaskReset.PushCond)

		case mtype.FissionCampaignPushMarkOffline:
			s.Res.Push.Offline = &pb.ShowRes_PushOne{
				Open:     mtype.Yes,
				PushCond: nil,
			}

			_ = jsonm.StrUnmarshal(v.Cond, &s.Res.Push.Offline.PushCond)
		case mtype.FissionCampaignPushMarkVisit:
			s.Res.Push.Visit = &pb.ShowRes_PushOne{
				Open: mtype.Yes,
			}
		}

	}

	return
}

func (s *Show) setChild(cpn *model.FissionCampaign) (err error) {
	m := s.GetDao().FissionCampaignChild
	list, err := m.WithContext(s.Ctx).Where(m.CampaignID.Eq(cpn.ID)).Find()
	if err != nil {
		err = s.BE().MysqlError(err)
		return
	}

	if len(list) == 0 {
		return
	}

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

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

	s.Res.Child = make([]*pb.ShowRes_Child, 0, len(childs))

	for _, v := range childs {
		s.Res.Child = append(s.Res.Child, &pb.ShowRes_Child{
			HashId:    v.HashID,
			ChildType: int32(v.ChildType),
		})
	}

	return
}

func (s *Show) _setGold(cpn *model.FissionCampaign) (err error) {
	conf, err := cache.NewCampaignGold(s.Ctx).FindByCampaignId(cpn.ID)
	if err != nil {
		err = s.BE().CacheError(err)
		return
	}

	if conf == nil {
		return workerr.NotFound("not found gold conf")
	}

	s.AddAfterRun(func() (err error) {
		s.Res.Gold = &pb.ShowRes_Gold{
			GoldNum:    conf.GoldNum,
			ExpiredDay: conf.ExpiredDay,
			Price:      conf.Price,
			PriceNum:   conf.PriceNum,
			Currency:   int32(conf.Currency),
			SpinCash:   make([]*pb.ShowRes_SpinCash, 0, len(consts.FissionCashSpin)),
			Lack:       int32(conf.Lack),
		}

		for _, v := range consts.FissionCashSpin {
			s.Res.Gold.SpinCash = append(s.Res.Gold.SpinCash, &pb.ShowRes_SpinCash{
				Id:   v.Id,
				Cash: v.Cash,
			})
		}

		return
	})

	return
}

func (s *Show) _setCoin(cpn *model.FissionCampaign) (err error) {
	conf, err := cache.NewCampaignCoin(s.Ctx).FindByCampaignId(cpn.ID)
	if err != nil {
		err = s.BE().CacheError(err)
		return
	}

	if conf == nil {
		return workerr.NotFound("not found gold conf")
	}

	var customBtnId int64
	if verify.InArray[int32](mtype.FissionCampaignCoinLackBtnCustom, conf.GetLackBtn()...) {
		var customBtn *model.FissionCustomBtn
		customBtn, err = cache.NewFissionCustomBtn(s.Ctx).FindByUniq(cpn.ID, conf.CustomBtnText)
		if err != nil {
			return s.BE().CacheError(err)
		}

		if customBtn != nil {
			customBtnId = customBtn.ID
		}
	}

	s.AddAfterRun(func() (err error) {
		s.Res.Coin = &pb.ShowRes_Coin{
			CoinImg:          conf.CoinImg,
			OpenDays:         conf.OpenDays,
			OpenLimit:        conf.OpenLimit,
			InitCoin:         conf.InitCoin,
			InitUse:          conf.InitUse,
			UseCoin:          conf.UseCoin,
			UseLimit:         conf.UseLimit,
			UrlId:            conf.URLID,
			LackBtn:          conf.GetLackBtn(),
			CustomBtnText:    conf.CustomBtnText,
			CustomWebUrl:     conf.CustomWebURL,
			CustomExtraParam: conf.CustomExtraParam,
			CustomBtnId:      customBtnId,
			CustomPcParam:    conf.CustomPcParam,
		}

		return
	})

	return
}

func (s *Show) _setVs(cpn *model.FissionCampaign) (err error) {
	conf, err := cache.NewCampaignVs(s.Ctx).FindByCampaignId(cpn.ID)
	if err != nil {
		err = s.BE().CacheError(err)
		return
	}

	if conf == nil {
		return workerr.NotFound("not found vs conf")
	}

	m := s.GetDao().FissionCampaignVsSchedule
	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
	rewards, 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(rewards))
	for _, v := range rewards {
		rewardMap[v.ID] = v
	}

	teamM := s.GetDao().FissionCampaignVsTeam
	teams, 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(teams))
	for _, v := range teams {
		teamMap[v.ID] = v
	}

	var scheduleMap = make(map[int32][]*pb.ShowRes_PkTeam)
	for _, v := range list {
		one := &pb.ShowRes_PkTeam{
			Id:           v.ID,
			Teams:        nil,
			VoteStart:    v.VoteStart,
			VoteEnd:      v.VoteEnd,
			VsAt:         v.VsAt,
			VsImg:        v.VsImg,
			Desc:         v.Desc,
			PropMark:     "",
			RewardId:     0,
			PropNum:      0,
			ExpiredDay:   "",
			IsSettlement: int32(v.IsSettlement),
			OtherVote:    v.GetOtherVote(),
			OpenOdds:     int32(v.OpenOdds),
			OddsLeft:     v.OddsLeft,
			OddsRight:    v.OddsRight,
			OddsDraw:     v.OddsDraw,
			Status:       v.GetStatus(),
		}

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

		if reward, ok := rewardMap[v.RewardID]; ok {
			one.PropMark = reward.PropMark
			one.RewardId = reward.RewardID
			one.PropNum = reward.RewardNum
			one.ExpiredDay = reward.ExpiredDay
		}

		scheduleMap[v.VsIdx] = append(scheduleMap[v.VsIdx], one)
	}

	var schedules = make([]*pb.ShowRes_Schedule, len(scheduleMap))
	for k, v := range scheduleMap {
		schedules[k] = &pb.ShowRes_Schedule{
			Id:      k,
			PkTeams: v,
		}
	}

	s.AddAfterRun(func() (err error) {
		s.Res.Vs = &pb.ShowRes_Vs{
			InitChance:   conf.InitChance,
			EachLimitNum: conf.EachLimitNum,
			OpenPoint:    int32(conf.OpenPoint),
			PointsNum:    conf.PointsNum,
			MallOpen:     int32(conf.MallOpen),
			MallId:       conf.MallID,
			VsTz:         conf.VsTz,
			ClaimType:    int32(conf.ClaimType),
			Schedules:    schedules,
			IconMall:     conf.IconMall,
			IconReward:   conf.IconReward,
			IconSchedule: conf.IconSchedule,
		}
		return
	})

	return
}

func (s *Show) _setUno(cpn *model.FissionCampaign) (err error) {
	conf, err := cache.NewCampaignUno(s.Ctx).FindByCampaignId(cpn.ID)
	if err != nil {
		err = s.BE().CacheError(err)
		return
	}

	if conf == nil {
		return workerr.NotFound("not found uno conf")
	}

	m := s.GetDao().FissionCampaignUnoGroup
	groups, 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 _, group := range groups {
		rewardIds = append(rewardIds, group.RewardID)
	}

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

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

	preward, err := provider.NewRewards(s.Ctx, cpn.ProjectID, bids...)
	if err != nil {
		return
	}

	langMark := mtype.FissionLangTypeToMark[cpn.GetLangTypes()[0]]

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

	var cardMap = make(map[string][]*model.FissionCampaignUnoCard)
	for _, v := range cards {
		cardMap[v.Mark] = append(cardMap[v.Mark], v)
	}

	s.AddAfterRun(func() (err error) {
		s.Res.Uno = &pb.ShowRes_Uno{
			InitChance: conf.InitChance,
			PropMarks:  conf.GetPropMarks(),
			Red:        nil,
			Yellow:     nil,
			Blue:       nil,
			Green:      nil,
		}

		for _, v := range groups {
			lr := v.GetLimitRule()
			g := &pb.ShowRes_UnoGroup{
				Id:       v.ID,
				Odds:     v.Odds,
				Reward:   nil,
				OpenRule: int32(v.OpenRule),
				LimitRule: &pb.ShowRes_UnoLimitRule{
					InitNum:   lr.InitNum,
					SignDay:   lr.SignDay,
					AddNum:    lr.AddNum,
					ResetType: lr.ResetType,
				},
				CustomCard: int32(v.CustomCard),
				Cards:      make([]*pb.ShowRes_UnoCard, 0, len(cardMap[v.Mark])),
			}

			for _, cd := range cardMap[v.Mark] {
				g.Cards = append(g.Cards, &pb.ShowRes_UnoCard{
					Id:       cd.ID,
					Title:    cd.Title,
					ImgUrl:   cd.ImgURL,
					WebUrl:   cd.WebURL,
					AppParam: cd.AppParam,
					PcParam:  cd.PcParam,
					CardNo:   cd.CardNo,
				})
			}

			if r, ok := rewardMap[v.RewardID]; ok {
				info, _ := preward.InfoAutoLang(r.RewardID, langMark)
				g.Reward = &pb.ShowRes_Reward{
					Id:          r.ID,
					RewardId:    r.RewardID,
					Stock:       r.Stock,
					RewardNum:   r.RewardNum,
					KvData:      make([]*pb.ShowRes_KV, 0, len(info.KvData)),
					Title:       info.Title,
					ImgUrl:      info.ImgUrl,
					ReceiveType: info.ReceiveType,
					Contact:     info.Contact,
					Url:         info.Url,
					FormTitle:   info.FormTitle,
				}
				for _, datum := range info.KvData {
					g.Reward.KvData = append(g.Reward.KvData, &pb.ShowRes_KV{
						Key:   datum.Key,
						Value: datum.Value,
					})
				}
			}

			switch v.Mark {
			case mtype.FissionCampaignUnoGroupRed:
				s.Res.Uno.Red = g
			case mtype.FissionCampaignUnoGroupYellow:
				s.Res.Uno.Yellow = g
			case mtype.FissionCampaignUnoGroupBlue:
				s.Res.Uno.Blue = g
			case mtype.FissionCampaignUnoGroupGreen:
				s.Res.Uno.Green = g
			}
		}

		return
	})

	return
}

func (s *Show) setEvent(cpn *model.FissionCampaign) (err error) {

	m := s.GetDao().FissionCampaignEvent
	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 {
		for _, reward := range v.GetRewards() {
			if reward.RewardId > 0 {
				rewardIds = append(rewardIds, reward.RewardId)
			}
		}
	}

	rewardM := s.GetDao().FissionCampaignReward
	rewards, 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(rewards))
	var brids []int64
	for _, v := range rewards {
		brids = append(brids, v.RewardID)
		rewardMap[v.ID] = v
	}

	var preward *provider.Rewards
	if len(brids) > 0 {
		preward, err = provider.NewRewards(s.Ctx, cpn.ProjectID, brids...)
		if err != nil {
			return
		}
	}

	s.Res.Event = &pb.ShowRes_Event{}

	var fn = func(rewards []*mtype.EventReward) []*pb.ShowRes_EventReward {

		r := make([]*pb.ShowRes_EventReward, 0, len(rewards))
		for _, v := range rewards {
			var reward *pb.ShowRes_Reward

			switch v.PropMark {
			case mtype.FissionCampaignRewardPropMarkReward:
				cr := rewardMap[v.RewardId]
				info, _ := preward.InfoAutoLang(cr.RewardID, cpn.GetLangMarks()[0])
				reward = &pb.ShowRes_Reward{
					Id:          cr.ID,
					RewardId:    cr.RewardID,
					Stock:       cr.Stock,
					RewardNum:   cr.RewardNum,
					KvData:      make([]*pb.ShowRes_KV, 0, len(info.KvData)),
					Title:       info.Title,
					ImgUrl:      info.ImgUrl,
					ReceiveType: info.ReceiveType,
					Contact:     info.Contact,
					Url:         info.Url,
					FormTitle:   info.FormTitle,
				}

				for _, v := range info.KvData {
					reward.KvData = append(reward.KvData, &pb.ShowRes_KV{
						Key:   v.Key,
						Value: v.Value,
					})
				}

			case mtype.FissionCampaignRewardPropMarkPoint:
				cr := rewardMap[v.RewardId]
				reward = &pb.ShowRes_Reward{
					Id:         cr.ID,
					RewardId:   cr.RewardID,
					Stock:      cr.Stock,
					RewardNum:  cr.RewardNum,
					ExpiredDay: cr.ExpiredDay,
				}
			case mtype.FissionCampaignRewardPropMarkChance:

			}

			r = append(r, &pb.ShowRes_EventReward{
				Id:         reward.GetId(),
				PropMark:   v.PropMark,
				Reward:     reward,
				Chance:     v.Chance,
				ExpiredDay: reward.GetExpiredDay(),
			})
		}

		return r
	}

	for _, v := range list {
		one := &pb.ShowRes_EventOne{
			Open:    int32(v.Open),
			Rewards: fn(v.GetRewards()),
		}
		switch v.Mark {
		case mtype.FissionCampaignEventMarkFirstVisit:
			s.Res.Event.FirstVisit = one
		}
	}

	return
}

func (s *Show) _setGashapon(cpn *model.FissionCampaign) (err error) {
	conf, err := cache.NewCampaignGashapon(s.Ctx).FindByCampaignId(cpn.ID)
	if err != nil {
		err = s.BE().CacheError(err)
		return
	}

	if conf == nil {
		return workerr.NotFound("not found blind conf")
	}

	s.AddAfterRun(func() (err error) {
		s.Res.Gashapon = &pb.ShowRes_LotteryConfig{
			InitChance: conf.InitChance,
			DayChance:  conf.DayChance,
		}

		return
	})

	return

}