package campaignuser

import (
	"joybuywork/internal/consts"
	"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/logic"
	"joybuywork/internal/utils/timez"
	"joybuywork/internal/utils/verify"
	pb "joybuywork/proto/go_proto/w_campaign_user"
	"joybuywork/proto/go_proto/workerr"
	"fmt"
	"time"

	"gorm.io/gen"
)

type Reward struct {
	logic.Logic
	Req *pb.RewardReq
	Res *pb.RewardRes

	langMark string
}

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

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

	return s.reward(cpn)
}

// 活动数据
func (s *Reward) 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")
	}

	tz := utils.STernary(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

	return
}

// 奖品处理
func (s *Reward) reward(cpn *model.FissionCampaign) (err error) {

	subCpnId, cond, err := s._findCond(cpn)
	if err != nil {
		return
	}
	m := s.GetDao().FissionRewardRecord.SubTable(subCpnId)
	offset, limit := utils.PpDbLo(s.Req.GetPage(), s.Req.GetPerPage())
	list, total, err := m.WithContext(s.Ctx).Where(cond...).Order(m.ID.Desc()).FindByPage(offset, limit)
	if err != nil {
		return s.BE().MysqlError(err)
	}

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

	if total == 0 {
		return
	}

	var rewardIds []int64
	var rewardKvMap = make(map[int64][]*mtype.KV)
	var userIds []int64
	var userMap = make(map[int64]string)
	var brewardIds []int64
	var brewardMap = make(map[int64]*provider.RewardInfo)
	var childIds []int64
	var childMap = make(map[int64]string)
	for _, v := range list {
		if _, ok := userMap[v.UserID]; !ok {
			userIds = append(userIds, v.UserID)
			userMap[v.UserID] = ""
		}

		if v.BaseRewardID == 0 {
			if _, ok := rewardKvMap[v.RewardID]; !ok {
				rewardKvMap[v.RewardID] = nil
				rewardIds = append(rewardIds, v.RewardID)
			}
		} else {
			if _, ok := brewardMap[v.BaseRewardID]; !ok {
				brewardMap[v.BaseRewardID] = nil
				brewardIds = append(brewardIds, v.BaseRewardID)
			}
		}

		if _, ok := childMap[v.ChildID]; !ok && v.ChildID > 0 {
			childIds = append(childIds, v.ChildID)
			childMap[v.ChildID] = ""
		}
	}

	err = s._fillChildMap(childIds, childMap)
	if err != nil {
		return
	}

	err = s._fillUserMap(subCpnId, userIds, userMap)
	if err != nil {
		return
	}

	if len(rewardIds) > 0 {
		err = s._rewardKv(rewardIds, rewardKvMap)
		if err != nil {
			return
		}
	}

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

		brList, err1 := preward.InfoList()
		if err1 != nil {
			err = err1
			return
		}

		for _, info := range brList {
			brewardMap[info.Id] = info
		}

	}

	for _, v := range list {

		var title = v.Title

		if verify.InArray(cpn.FissionID, consts.IdWinTogether, consts.IdReferral) {
			title = fmt.Sprintf("%d %s", v.RewardNum, v.Title)
		}

		one := &pb.RewardRes_One{
			SubUserId:       userMap[v.UserID],
			CreatedTime:     v.CreatedAt,
			Title:           title,
			KvData:          nil,
			Img:             v.ImgURL,
			IsPush:          utils.Ternary[bool](v.Status == mtype.FissionRewardRecordStatusSuccess, true, false),
			Id:              v.ID,
			HashId:          v.HashID,
			Status:          int32(v.Status),
			FailType:        v.FailType,
			FailMsg:         v.FailMsg,
			RewardTitle:     title,
			RewardId:        v.RewardID,
			CustomRewardVal: v.CustomRewardVal,
			RewardType:      int32(v.RewardType),
			ChildTitle:      childMap[v.ChildID],
			PropMark:        v.PropMark,
			ChanceMark:      consts.FissionPropMark[cpn.FissionID],
			RewardNum:       v.RewardNum,
		}

		if v.Status == mtype.FissionRewardRecordStatusWait && v.CreatedAt+consts.DaySec <= time.Now().Unix() {
			one.Status = mtype.FissionRewardRecordStatusFail
			one.FailType = mtype.FissionRewardRecordFailTypeSys
			one.FailMsg = mtype.FissionRewardRecordFailTypeLongTime
		}

		if kvs, ok := rewardKvMap[v.RewardID]; ok && kvs != nil {
			one.KvData = make([]*pb.RewardRes_KV, 0, len(kvs))
			for _, v1 := range kvs {
				one.KvData = append(one.KvData, &pb.RewardRes_KV{
					Key:   v1.Key,
					Value: v1.Value,
				})
			}
		}

		if info, ok := brewardMap[v.BaseRewardID]; ok && info != nil {
			one.RewardTitle = info.RewardTitle
			one.ReceiveType = info.ReceiveType
			one.Contact = info.Contact
			one.KvData = make([]*pb.RewardRes_KV, 0, len(info.KvData))
			one.DyRewardType = info.DyRewardType
			for _, v1 := range info.KvData {
				one.KvData = append(one.KvData, &pb.RewardRes_KV{
					Key:    v1.Key,
					Value:  v1.Value,
					IsShow: v1.IsShow,
				})
			}

			if s.langMark != "" && preward != nil {
				lang := preward.AutoLang(info.Id, s.langMark)
				one.Title = lang.Title
				one.Img = lang.ImgUrl
				one.OpenToUse = lang.OpenToUse
				one.WebUrl = lang.WebUrl
				one.AppParam = lang.AppParam
				one.PcParam = lang.PcParam
			}
		}

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

	return
}

func (s *Reward) _findCond(cpn *model.FissionCampaign) (subCpnId int64, cond []gen.Condition, err error) {

	subCpnId = cpn.ID
	if s.Req.GetIsChild() == mtype.Yes {
		subCpnId = cpn.Pid
	}

	m := s.GetDao().FissionRewardRecord.SubTable(subCpnId)

	if s.Req.GetIsChild() == mtype.Yes {
		cond = append(cond, m.CampaignID.Eq(subCpnId), m.ChildID.Eq(cpn.ID))
	} else {
		cond = append(
			cond,
			m.CampaignID.Eq(subCpnId),
			m.PropMark.Eq(mtype.FissionCampaignRewardPropMarkReward),
		)
	}

	if s.Req.GetFuserId() > 0 {
		cond = append(cond, m.UserID.Eq(s.Req.GetFuserId()))

		var user *model.FissionUser
		user, err = finder.FissionUser(s.Ctx, subCpnId, s.Req.GetFuserId())
		if err != nil {
			err = s.BE().CacheError(err)
			return
		}
		if user != nil {
			s.langMark = user.LangMark
		}
	}

	if len(s.Req.GetStatus()) > 0 {
		var status = make([]int8, 0, len(s.Req.GetStatus()))
		for _, v := range s.Req.GetStatus() {
			status = append(status, int8(v))
		}

		cond = append(cond, m.Status.In(status...))
	}

	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 !verify.EmptyString(s.Req.GetUserMark()) {
		var userId int64
		var user *model.FissionUser
		userM := s.GetDao().FissionUser.SubTable(subCpnId)
		user, err = userM.WithContext(s.Ctx).Where(userM.CampaignID.Eq(subCpnId), userM.UserMark.Eq(s.Req.GetUserMark())).Take()
		if err = dbcheck.DbError(err); err != nil {
			err = s.BE().MysqlError(err)
			return
		}

		if user != nil {
			userId = user.ID
		}

		cond = append(cond, m.UserID.Eq(userId))
	}

	if !verify.EmptyString(s.Req.GetRewardTitle()) {
		rewardM := s.GetDao().Reward
		var ids []int64
		err = rewardM.WithContext(s.Ctx).Where(
			rewardM.ProjectID.Eq(cpn.ProjectID),
			rewardM.RewardTitle.Like(utils.DbAllLike(s.Req.GetRewardTitle())),
			rewardM.IsDel.Eq(mtype.No),
		).Pluck(rewardM.ID, &ids)
		if err != nil {
			err = s.BE().MysqlError(err)
			return
		}

		cond = append(cond, m.BaseRewardID.In(ids...))
	}

	return
}

// 填充活动用户信息
func (s *Reward) _fillUserMap(cpnId int64, userIds []int64, userMap map[int64]string) (err error) {
	if len(userIds) == 0 {
		return
	}

	m := s.GetDao().FissionUser.SubTable(cpnId)

	list, err := m.WithContext(s.Ctx).Where(m.ID.In(userIds...)).Find()
	if err != nil {
		return s.BE().MysqlError(err)
	}
	for _, v := range list {
		userMap[v.ID] = v.UserMark
	}

	return
}

// 填充子活动信息
func (s *Reward) _fillChildMap(childIds []int64, childMap map[int64]string) (err error) {
	if len(childIds) == 0 {
		return
	}

	m := s.GetDao().FissionCampaign

	list, err := m.WithContext(s.Ctx).Where(m.ID.In(childIds...)).Find()
	if err != nil {
		return s.BE().MysqlError(err)
	}
	for _, v := range list {
		childMap[v.ID] = v.Title
	}

	return
}

func (s *Reward) _rewardKv(rewardIds []int64, data map[int64][]*mtype.KV) (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
	}

	for _, v := range rewards {
		data[v.ID] = v.GetKvData()
	}

	return
}