package campaignnotice

import (
	"joybuywork/internal/repository/cache"
	"joybuywork/internal/repository/dbcheck"
	"joybuywork/internal/repository/model"
	"joybuywork/internal/repository/mtype"
	"joybuywork/internal/repository/withdefault"
	"joybuywork/internal/service/provider/fissionaction"
	"joybuywork/internal/service/queue/producer"
	"joybuywork/internal/service/queue/types"
	"joybuywork/internal/utils/logic"
	"time"

	"gorm.io/gen"
)

type VsSettlement struct {
	logic.Logic

	Req *types.CampaignVsSettlement
}

func (s *VsSettlement) Exec() (err error) {

	m := s.GetDao().FissionCampaignVsSchedule
	schedule, err := m.WithContext(s.Ctx).Where(m.ID.Eq(s.Req.ScheduleId)).Take()
	if err = dbcheck.DbError(err); err != nil {
		err = s.BE().MysqlError(err)
		return
	}

	if schedule == nil || schedule.IsSettlement == mtype.No {
		return
	}

	mp := fissionaction.NewMarkPoint(s.Ctx)

	t := time.Now().Unix()

	slt := schedule.GetSettlement()
	var settlements = make([]*model.FissionVsVoteSettlement, 0, 200)

	voteM := s.GetDao().FissionVsVote
	var votes []*model.FissionVsVote
	err = voteM.WithContext(s.Ctx).Where(
		voteM.ScheduleID.Eq(schedule.ID),
		voteM.WinType.Eq(int8(slt.WinType)),
		voteM.WinTeamID.Eq(slt.WinTeamId),
	).FindInBatches(&votes, 200, func(tx gen.Dao, batch int) error {
		var userIds []int64
		for _, v := range votes {
			userIds = append(userIds, v.UserID)
		}

		userM := s.GetDao().FissionUser.SubTable(schedule.CampaignID)
		users, err1 := userM.WithContext(s.Ctx).Where(userM.ID.In(userIds...)).Find()
		if err1 != nil {
			return s.BE().MysqlError(err1)
		}

		var userMap = make(map[int64]*model.FissionUser)
		for _, p := range users {
			userMap[p.ID] = p
		}

		var ids []int64
		for _, vote := range votes {
			ids = append(ids, vote.ID)
			settlements = append(settlements, withdefault.FissionVsVoteSettlement(&model.FissionVsVoteSettlement{
				CampaignID: vote.CampaignID,
				UserID:     vote.UserID,
				ScheduleID: vote.ScheduleID,
				VsID:       vote.VsID,
				VoteID:     vote.ID,
				AcceptAt:   0,
				RecordIds:  "[]",
				Odds:       schedule.GetOdds(),
			}))

			mp.InApp(userMap[vote.UserID]).VsWin(t, vote.ScheduleID, vote.FreeVote+vote.PointVote)
		}

		_, err = voteM.WithContext(s.Ctx).Where(voteM.ID.In(ids...)).UpdateColumnSimple(voteM.IsWin.Value(mtype.Yes))
		if err != nil {
			return s.BE().MysqlError(err)
		}

		return nil
	})

	err = s.GetDao().FissionVsVoteSettlement.WithContext(s.Ctx).CreateInBatches(settlements, 200)
	if err != nil {
		return s.BE().MysqlError(err)
	}

	conf, err := cache.NewCampaignVs(s.Ctx).FindByCampaignId(schedule.CampaignID)
	if err != nil {
		err = s.BE().CacheError(err)
		return
	}

	if conf.ClaimType == mtype.FissionCampaignVsClaimTypePage {
		return
	}

	p := producer.NewCampaignNotice(s.Ctx)
	for _, v := range settlements {
		p.CampaignSettlementReward(types.CampaignSettlementReward{
			SettlementId: v.ID,
		})
	}

	return
}