package campaign

import (
	"joybuywork/internal/plugins/hashid"
	"joybuywork/internal/repository/finder"
	"joybuywork/internal/repository/model"
	"joybuywork/internal/repository/mtype"
	"joybuywork/internal/repository/withdefault"
	"joybuywork/internal/utils"
	"joybuywork/internal/utils/logic"
	pb "joybuywork/proto/go_proto/w_campaign"
	"joybuywork/proto/go_proto/workerr"
)

type ChildStore struct {
	logic.Logic
	Req *pb.ChildStoreReq
	Res *pb.ChildStoreRes

	project *model.Project

	otherReward    []*model.FissionCampaignReward
	otherRelateIds []int64
	otherRelateMap map[int64]struct{}
}

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

func (s *ChildStore) Exec() (err error) {
	err = s.depend()
	if err != nil {
		return
	}

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

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

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

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

	return
}

func (s *ChildStore) depend() (err error) {
	project, err := finder.Project(s.Ctx, s.Req.GetProjectId())
	if err != nil {
		return s.BE().CacheError(err)
	}

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

	s.otherRelateMap = make(map[int64]struct{})
	s.project = project

	s.AddAfterRun(func() (err error) {
		s.OL().User(s.Req.GetUserId(), s.Req.GetIp()).CampaignSave(s.Res.GetId(), s.Req)
		return
	})

	return
}

// 创建活动
func (s *ChildStore) create() (cpn *model.FissionCampaign, err error) {
	cpn = withdefault.FissionCampaign(&model.FissionCampaign{
		FissionID: s.Req.GetFissionId(),
		ProjectID: s.project.ID,
		CreatorID: s.Req.GetUserId(),
		Title:     s.Req.GetTitle(),
		Status:    mtype.FissionCampaignStatusWait,
		TStart:    s.Req.GetStartTime(),
		TEnd:      s.Req.GetEndTime(),
		Target:    mtype.FissionCampaignConfigTargetChild,
		ChildType: int8(s.Req.GetChildType()),
	})

	if s.Req.GetStartTime() == 0 {
		cpn.Status = mtype.FissionCampaignStatusPub
	}

	m := s.GetDao().FissionCampaign

	if err = m.WithContext(s.Ctx).Create(cpn); err != nil {
		return nil, s.BE().MysqlError(err)
	}

	s.AddAfterRun(func() (err error) {
		s.Res.Id = cpn.ID
		s.Res.HashId = cpn.HashID
		return
	})

	return
}

func (s *ChildStore) createConfig(cpn *model.FissionCampaign) (err error) {
	conf := withdefault.FissionCampaignConfig(&model.FissionCampaignConfig{
		CampaignID:  cpn.ID,
		PlayType:    int8(s.Req.GetPlayType()),
		RewardGroup: mtype.FissionRewardGroupNormal,
		Target:      mtype.FissionCampaignConfigTargetChild,
	})

	err = s.GetDao().FissionCampaignConfig.WithContext(s.Ctx).Create(conf)
	if err != nil {
		return s.BE().MysqlError(err)
	}

	return
}

func (s *ChildStore) createTask(cpn *model.FissionCampaign) (err error) {
	// todo 创建超级任务
	return
}

func (s *ChildStore) createReward(cpn *model.FissionCampaign) (err error) {
	var add = s.otherReward
	var addRules []*model.FissionCampaignRewardRule
	var relateMap = s.otherRelateMap
	var relateIds = s.otherRelateIds
	for i, one := range s.Req.GetRewards() {
		var step = int32(i) + 1

		var id = hashid.IdBigint()

		add = append(add, withdefault.FissionCampaignReward(&model.FissionCampaignReward{
			ID:          id,
			CampaignID:  cpn.ID,
			Stock:       one.GetStock(),
			Sort:        int32(i),
			RewardType:  mtype.FissionCampaignRewardTypeChild,
			Step:        step,
			InviteNum:   one.GetInviteNum(),
			RewardNum:   one.GetRewardNum(),
			IsThank:     int8(one.GetIsThank()),
			Score:       one.GetScore(),
			SignDay:     step,
			CollectNum:  one.GetCollectNum(),
			IsSuper:     int8(one.GetIsSuper()),
			RewardID:    one.GetRewardId(),
			Odds:        one.GetOdds(),
			JumpURL:     one.GetJumpUrl(),
			HasRule:     utils.Ternary[int8](one.GetCampaignLimit() > 0, mtype.Yes, mtype.No),
			InitPercent: one.GetInitPercent(),
			PropMark:    one.GetPropMark(),
		}))

		if one.GetCampaignLimit() > 0 {
			addRules = append(addRules, withdefault.FissionCampaignRewardRule(&model.FissionCampaignRewardRule{
				CampaignID:    cpn.ID,
				RewardID:      id,
				CampaignLimit: one.GetCampaignLimit(),
			}))
		}

		if _, ok := relateMap[one.GetRewardId()]; !ok && one.GetRewardId() > 0 {
			relateMap[one.GetRewardId()] = struct{}{}
			relateIds = append(relateIds, one.GetRewardId())
		}
	}

	if len(add) == 0 {
		return
	}

	m := s.GetDao().FissionCampaignReward
	if err = m.WithContext(s.Ctx).Create(add...); err != nil {
		err = s.BE().MysqlError(err)
		return
	}

	var relates []*model.RewardRelated
	for _, v := range relateIds {
		relates = append(relates, withdefault.RewardRelated(&model.RewardRelated{
			RewardID:    v,
			RelateID:    cpn.ID,
			RelateTable: s.GetDao().FissionCampaign.TableName(),
		}))
	}

	relateM := s.GetDao().RewardRelated
	if err = relateM.WithContext(s.Ctx).Create(relates...); err != nil {
		err = s.BE().MysqlError(err)
		return
	}

	if len(addRules) > 0 {
		ruleM := s.GetDao().FissionCampaignRewardRule
		err = ruleM.WithContext(s.Ctx).Create(addRules...)
		if err != nil {
			err = s.BE().MysqlError(err)
			return
		}
	}

	return
}

// 其他形式的奖品追加
func (s *ChildStore) _otherAppendReward(reward *model.FissionCampaignReward) {
	if _, ok := s.otherRelateMap[reward.RewardID]; !ok && reward.RewardID > 0 {
		s.otherRelateMap[reward.RewardID] = struct{}{}
		s.otherRelateIds = append(s.otherRelateIds, reward.RewardID)
	}

	s.otherReward = append(s.otherReward, reward)
}