package containers

import (
	"joybuywork/internal/app"
	"joybuywork/internal/consts"
	"joybuywork/internal/repository/cache"
	"joybuywork/internal/repository/dao"
	"joybuywork/internal/repository/model"
	"joybuywork/internal/repository/mtype"
	"joybuywork/internal/service/provider/players"
	"joybuywork/internal/service/provider/pusher"
	"joybuywork/internal/utils/logic"
	"fmt"
	"strconv"
	"strings"
	"sync"
	"time"

	"github.com/panjf2000/ants/v2"
	"gorm.io/gen"
)

const (
	faultTolerance = 900
)

type PushNotify struct {
	logic.Logic

	data map[int64]string
}

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

func (s *PushNotify) Exec() (err error) {
	m := dao.FissionCampaign

	list, err := m.WithContext(s.Ctx).Where(
		m.StartTime.Gt(0),
		m.StartTime.Lte(time.Now().Unix()),
		m.Status.In(mtype.FissionCampaignStatusPub, mtype.FissionCampaignStatusPubPre),
		m.IsDel.Eq(mtype.No),
	).Find()
	if err != nil {
		err = s.BE().MysqlError(err)
		return
	}

	if len(list) == 0 {
		return
	}

	wg := sync.WaitGroup{}
	defer wg.Wait()

	gp, _ := ants.NewPool(10)
	defer gp.Release()

	for _, v := range list {
		wg.Add(1)
		_ = gp.Submit(func() {
			defer wg.Done()
			defer app.TryCatch(s.Ctx, fmt.Sprintf("活动奖品补偿失败：cpnid：%d", v.ID))

			pushM := dao.FissionCampaignPush
			pushs, err2 := pushM.WithContext(s.Ctx).Where(pushM.CampaignID.Eq(v.ID), pushM.Open.Eq(mtype.Yes)).Find()
			if err2 != nil {
				err = err2
				return
			}

			if len(pushs) == 0 {
				return
			}

			for _, push := range pushs {
				switch push.Mark {
				case mtype.FissionCampaignPushMarkTaskReset:
					for _, cond := range push.GetCond() {
						err = s.taskReset(v, cond)
						if err != nil {
							return
						}
					}
				case mtype.FissionCampaignPushMarkOffline:
					for _, cond := range push.GetCond() {
						err = s.offline(v, cond)
						if err != nil {
							return
						}
					}
				case mtype.FissionCampaignPushMarkActive:
					for _, cond := range push.GetCond() {
						err = s.active(v, cond)
						if err != nil {
							return
						}
					}
				}
			}
		})
	}

	return
}

// 日活
func (s *PushNotify) active(cpn *model.FissionCampaign, cond *mtype.PushCond) (err error) {
	hour, markCode, codeVal := s._getHourCond(cond)
	t := s._minTime().Add(-time.Duration(hour) * time.Hour)

	push, err := pusher.NewPusher(s.Ctx, cpn)
	if err != nil {
		return
	}

	m := dao.FissionUserActive

	var list []*model.FissionUserActive
	err = m.WithContext(s.Ctx).
		Where(
			m.CampaignID.Eq(cpn.ID),
			m.LastActive.Lte(t.Unix()),
			m.LastActive.Gt(t.Unix()-faultTolerance),
		).
		FindInBatches(&list, 200, func(tx gen.Dao, batch int) error {
			var userLines []*pusher.UserLine
			for _, v := range list {
				userLines = append(userLines, &pusher.UserLine{
					Id:     v.UserID,
					DoneAt: v.LastActive,
				})
			}

			return push.Active(t, markCode, codeVal, userLines)
		})

	return
}

// 任务重制
func (s *PushNotify) taskReset(cpn *model.FissionCampaign, cond *mtype.PushCond) (err error) {
	switch cpn.FissionID {
	case consts.IdCash:
		return s._cashReset(cpn, cond)
	case consts.IdGold:
		return s._goldReset(cpn, cond)
	}
	return
}

func (s *PushNotify) _cashReset(cpn *model.FissionCampaign, cond *mtype.PushCond) (err error) {
	hour, markCode, codeVal := s._getHourCond(cond)
	t := s._minTime().Add(time.Duration(hour) * time.Hour)

	push, err := pusher.NewPusher(s.Ctx, cpn)
	if err != nil {
		return
	}

	m := dao.FissionCash
	var list []*model.FissionCash
	err = m.WithContext(s.Ctx).
		Where(
			m.CampaignID.Eq(cpn.ID),
			m.ExpiredIn.Lte(t.Unix()),
			m.ExpiredIn.Gt(t.Unix()-faultTolerance),
		).
		FindInBatches(&list, 200, func(tx gen.Dao, batch int) error {
			var userLines []*pusher.UserLine
			for _, v := range list {
				userLines = append(userLines, &pusher.UserLine{
					Id:     v.UserID,
					DoneAt: v.ExpiredIn,
				})
			}

			return push.TaskRest(t, markCode, codeVal, userLines)
		})
	if err != nil {
		return
	}

	return
}

func (s *PushNotify) _goldReset(cpn *model.FissionCampaign, cond *mtype.PushCond) (err error) {
	hour, markCode, codeVal := s._getHourCond(cond)
	t := s._minTime().Add(time.Duration(hour) * time.Hour)

	push, err := pusher.NewPusher(s.Ctx, cpn)
	if err != nil {
		return
	}

	m := dao.FissionGold
	var list []*model.FissionGold
	err = m.WithContext(s.Ctx).
		Where(
			m.CampaignID.Eq(cpn.ID),
			m.ExpiredIn.Lte(t.Unix()),
			m.ExpiredIn.Gt(t.Unix()-faultTolerance),
		).
		FindInBatches(&list, 200, func(tx gen.Dao, batch int) error {
			var userLines []*pusher.UserLine
			for _, v := range list {
				userLines = append(userLines, &pusher.UserLine{
					Id:     v.UserID,
					DoneAt: v.ExpiredIn,
				})
			}

			return push.TaskRest(t, markCode, codeVal, userLines)
		})
	if err != nil {
		return
	}

	return
}

// 离线
func (s *PushNotify) offline(cpn *model.FissionCampaign, cond *mtype.PushCond) (err error) {
	switch cpn.FissionID {
	case consts.IdKeep:
		return s._keepOffline(cpn, cond)
	}
	return
}

func (s *PushNotify) _keepOffline(cpn *model.FissionCampaign, cond *mtype.PushCond) (err error) {
	keep, err := cache.NewCampaignKeep(s.Ctx).FindByCampaignId(cpn.ID)
	if err != nil {
		err = s.BE().CacheError(err)
		return
	}

	if keep == nil || keep.MachineType != mtype.FissionCampaignKeepMachineTypeOffline {
		return
	}

	minute, markCode, codeVal := s._getMinCond(cond)

	tm := keep.OfflineMin + int32(minute)

	t := s._minTime().Add(-(time.Duration(tm)) * time.Minute)

	push, err := pusher.NewPusher(s.Ctx, cpn)
	if err != nil {
		return
	}

	m := dao.FissionKeep
	var list []*model.FissionKeep
	err = m.WithContext(s.Ctx).
		Where(
			m.CampaignID.Eq(cpn.ID),
			m.RewardID.Gt(0),
			m.RecordID.Eq(0),
			m.ReceiveOffline.Lte(t.Unix()),
			m.ReceiveOffline.Gt(t.Unix()-faultTolerance),
		).
		FindInBatches(&list, 200, func(tx gen.Dao, batch int) error {
			var userLines []*pusher.UserLine
			var userIds []int64
			for _, v := range list {
				userIds = append(userIds, v.UserID)
			}

			userM := s.GetDao().FissionUser
			users, _ := userM.WithContext(s.Ctx).Where(userM.ID.In(userIds...)).Find()
			var playerMap = make(map[int64]*players.KeepDog, len(users))
			for _, user := range users {
				playerMap[user.ID], _ = players.NewKeepDog(s.Ctx, user, players.SetCpn(cpn))
			}

			for _, v := range list {
				player, ok := playerMap[v.UserID]
				if !ok {
					continue
				}

				if ok, _ = player.OfflineLimit(); ok {
					continue
				}

				userLines = append(userLines, &pusher.UserLine{
					Id:     v.UserID,
					DoneAt: v.ReceiveOffline,
				})

			}

			return push.Offline(t, markCode, codeVal, userLines)
		})
	if err != nil {
		return
	}

	return
}

func (s *PushNotify) _getHourCond(cond *mtype.PushCond) (hour int, markCode, codeVal string) {
	if cond.Mark == "custom" {
		hour, _ = strconv.Atoi(cond.Val)
	} else {
		day := cond.Mark[strings.LastIndex(cond.Mark, "_")+1:]
		dayi, _ := strconv.Atoi(day)
		hour = dayi * 24
	}

	return hour, cond.Mark, cond.Val
}

func (s *PushNotify) _getMinCond(cond *mtype.PushCond) (min int, markCode, codeVal string) {
	if cond.Mark == "custom" {
		min, _ = strconv.Atoi(cond.Val)
	} else {
		hour := cond.Mark[strings.LastIndex(cond.Mark, "_")+1:]
		houri, _ := strconv.Atoi(hour)
		min = houri * 60
	}

	return min, cond.Mark, cond.Val
}

func (s *PushNotify) _minTime() time.Time {
	t, _ := time.ParseInLocation("2006-01-02 15:04", time.Now().Format("2006-01-02 15:04"), time.Local)

	return t
}