package campaignuser

import (
	"joybuywork/internal/repository/finder"
	"joybuywork/internal/repository/model"
	"joybuywork/internal/repository/mtype"
	"joybuywork/internal/utils"
	"joybuywork/internal/utils/logic"
	pb "joybuywork/proto/go_proto/w_campaign_user"
	"joybuywork/proto/go_proto/workerr"
)

type RewardUser struct {
	logic.Logic
	Req *pb.RewardUserReq
	Res *pb.RewardUserRes
}

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

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

	return s.rewardUser(cpn)
}

// 活动数据
func (s *RewardUser) 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 nil, workerr.NotFound("campaign not found")
	}

	return
}

// 获取到奖品的用户
func (s *RewardUser) rewardUser(cpn *model.FissionCampaign) (err error) {
	offset, limit := utils.PpDbLo(s.Req.GetPage(), s.Req.GetPerPage())
	m, rewardM := s.GetDao().FissionUser.SubTable(cpn.ID), s.GetDao().FissionRewardRecord.SubTable(cpn.ID)
	userList, total, err := m.WithContext(s.Ctx).
		Join(rewardM, rewardM.UserID.EqCol(m.ID)).
		Where(m.CampaignID.Eq(cpn.ID), rewardM.ID.IsNotNull(), rewardM.PropMark.Eq(mtype.FissionCampaignRewardPropMarkReward)).
		FindByPage(offset, limit)
	if err != nil {
		return s.BE().MysqlError(err)
	}

	if total == 0 {
		return
	}

	s.Res.Total = total
	s.Res.List = make([]*pb.RewardUserRes_One, 0, len(userList))

	var ids []int64
	var parentIds []int64
	var parentMap = make(map[int64]string)
	for _, v := range userList {
		ids = append(ids, v.ID)
		parentMap[v.ID] = v.SubUserID
		if _, ok := parentMap[v.ParentID]; !ok {
			parentIds = append(parentIds, v.ParentID)
		}
	}

	var rewardList []*model.FissionRewardRecord
	rewardList, err = rewardM.WithContext(s.Ctx).Where(rewardM.UserID.In(ids...)).Find()
	if err != nil {
		return s.BE().MysqlError(err)
	}

	var rewardMap = make(map[int64][]*model.FissionRewardRecord)
	for _, v := range rewardList {
		rewardMap[v.UserID] = append(rewardMap[v.UserID], v)
	}

	statMap := s._statMap(ids)
	if len(parentIds) > 0 {
		s._parentMap(cpn.ID, parentIds, parentMap)
	}

	for _, v := range userList {
		one := &pb.RewardUserRes_One{
			SubUserId:   v.SubUserID,
			PsuId:       "",
			DirectNum:   0,
			IndirectNum: 0,
			Rewards:     nil,
		}

		if psuId, ok := parentMap[v.ID]; ok {
			one.PsuId = psuId
		}

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

		if reward, ok := rewardMap[v.ID]; ok {
			one.Rewards = make([]*pb.RewardUserRes_Reward, 0, len(reward))
			for _, v1 := range reward {
				one.Rewards = append(one.Rewards, &pb.RewardUserRes_Reward{
					CreatedTime: v1.CreatedAt,
					Title:       v1.Title,
				})
			}
		}

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

// 统计数据
func (s *RewardUser) _statMap(userIds []int64) map[int64]*model.FissionUserStat {
	m := s.GetDao().FissionUserStat
	list, _ := m.WithContext(s.Ctx).Where(m.UserID.In(userIds...)).Find()

	var data = make(map[int64]*model.FissionUserStat)
	for _, v := range list {
		data[v.UserID] = v
	}

	return data
}

// 上级数据
func (s *RewardUser) _parentMap(cpnId int64, userIds []int64, data map[int64]string) {
	m := s.GetDao().FissionUser.SubTable(cpnId)
	list, _ := m.WithContext(s.Ctx).Where(m.ID.In(userIds...)).Find()

	for _, v := range list {
		data[v.ID] = v.SubUserID
	}

	return
}