package action

import (
	"joybuywork/internal/app"
	"joybuywork/internal/consts/ckey"
	"joybuywork/internal/repository/cache"
	"joybuywork/internal/repository/dao"
	"joybuywork/internal/repository/model"
	"joybuywork/internal/repository/mtype"
	"sync"
	"time"

	"github.com/panjf2000/ants/v2"
	t_centerpb "gits.branchcn.com/backend/taskcenter/proto/go_proto/t_center"
	"gorm.io/gen"
)

type ErrLog struct {
	Action
}

func (s *ErrLog) Desc() string {
	return "清理错误日志"
}

func (s *ErrLog) OnceKey() *OnceKey {
	return &OnceKey{
		exp:     2 * time.Minute,
		key:     ckey.CronNotifyReward(),
		release: true,
	}
}

func (s *ErrLog) Exec() (err error) {
	m := dao.ErrLog
	t := time.Now().AddDate(0, -1, -15)
	_, err = m.WithContext(s.ctx).Where(m.CreatedAt.Lte(t.Unix())).Delete()
	if err != nil {
		return
	}

	return
}

type SlowLog struct {
	Action
}

func (s *SlowLog) Desc() string {
	return "清理错误日志"
}

func (s *SlowLog) OnceKey() *OnceKey {
	return &OnceKey{
		exp:     2 * time.Minute,
		key:     ckey.CronNotifyReward(),
		release: true,
	}
}

func (s *SlowLog) Exec() (err error) {
	m := dao.SlowLog
	t := time.Now().AddDate(0, 0, -15)
	_, err = m.WithContext(s.ctx).Where(m.CreatedAt.Lte(t.Unix())).Delete()
	if err != nil {
		return
	}

	return
}

type RewardCancel struct {
	Action
	wg *sync.WaitGroup
}

func (s *RewardCancel) Desc() string {
	return "清理错误日志"
}

func (s *RewardCancel) OnceKey() *OnceKey {
	return &OnceKey{
		exp:     2 * time.Minute,
		key:     ckey.CronNotifyReward(),
		release: true,
	}
}

func (s *RewardCancel) Exec() (err error) {
	m := dao.RewardRelated

	s.wg = new(sync.WaitGroup)

	cpnP, _ := ants.NewPool(5)
	defer cpnP.Release()

	ctP, _ := ants.NewPool(5)
	defer ctP.Release()

	var list []*model.RewardRelated
	err = m.WithContext(s.ctx).Where(m.CancelTime.Eq(0)).FindInBatches(&list, 1000, func(tx gen.Dao, batch int) error {
		cpnMap := make(map[int64][]*model.RewardRelated)
		ctMap := make(map[int64][]*model.RewardRelated)

		for _, v := range list {

			switch v.RelateTable {
			case "fission_campaign":
				cpnMap[v.RelateID] = append(cpnMap[v.RelateID], v)
			case "taskcenter.center":
				ctMap[v.RelateID] = append(ctMap[v.RelateID], v)
			}
		}

		s.cpn(cpnP, cpnMap)
		s.ct(ctP, ctMap)

		return nil
	})

	s.wg.Wait()

	return
}

func (s *RewardCancel) cpn(cpnP *ants.Pool, cpnMap map[int64][]*model.RewardRelated) (err error) {
	if len(cpnMap) == 0 {
		return
	}

	m := dao.RewardRelated
	for id, relates := range cpnMap {
		s.wg.Add(1)
		cpnId := id
		cpnP.Submit(func() {
			defer s.wg.Done()

			cpn, _ := cache.NewCampaign(s.ctx).FindById(cpnId)

			if cpn == nil || cpn.Status == mtype.FissionCampaignStatusCancel || cpn.IsDel == mtype.Yes {
				_, err = m.WithContext(s.ctx).Where(
					m.RelateID.Eq(cpnId),
					m.RelateTable.Eq("fission_campaign"),
					m.CancelTime.Eq(0),
				).UpdateSimple(m.CancelTime.Value(time.Now().Unix()))
				if err != nil {
					return
				}
				return
			}

			rewardM := dao.FissionCampaignReward
			rewards, _ := rewardM.WithContext(s.ctx).Where(
				rewardM.CampaignID.Eq(cpnId),
				rewardM.IsDel.Eq(mtype.No),
			).Find()

			var useRewardIdMap = make(map[int64]struct{})
			for _, reward := range rewards {
				useRewardIdMap[reward.RewardID] = struct{}{}
			}

			var cancelIds []int64
			for _, relate := range relates {
				if _, ok := useRewardIdMap[relate.RewardID]; !ok {
					cancelIds = append(cancelIds, relate.ID)
				}
			}

			_, err = m.WithContext(s.ctx).Where(m.ID.In(cancelIds...)).UpdateSimple(m.CancelTime.Value(time.Now().Unix()))
			if err != nil {
				return
			}
			return

		})

	}

	return
}

func (s *RewardCancel) ct(ctP *ants.Pool, ctMap map[int64][]*model.RewardRelated) (err error) {
	if len(ctMap) == 0 {
		return
	}

	m := dao.RewardRelated
	for id, relates := range ctMap {
		s.wg.Add(1)
		ctId := id
		ctP.Submit(func() {
			defer s.wg.Done()

			ctReward, _ := app.NewTaskcenterCenter().CheckRewardUse(s.ctx, &t_centerpb.CheckRewardUseReq{
				Id: ctId,
			})

			var useRewardIdMap = make(map[int64]struct{})
			for _, rewardId := range ctReward.GetRewardIds() {
				useRewardIdMap[rewardId] = struct{}{}
			}

			var cancelIds []int64
			for _, relate := range relates {
				if _, ok := useRewardIdMap[relate.RewardID]; !ok {
					cancelIds = append(cancelIds, relate.ID)
				}
			}

			if len(cancelIds) == 0 {
				return
			}

			_, err = m.WithContext(s.ctx).Where(m.ID.In(cancelIds...)).UpdateSimple(m.CancelTime.Value(time.Now().Unix()))
			if err != nil {
				return
			}
			return

		})

	}

	return
}