package delay

import (
	"context"
	"joybuywork/internal/app"
	"joybuywork/internal/consts/ckey"
	"joybuywork/internal/repository/cache"
	"joybuywork/internal/repository/dao"
	"joybuywork/internal/repository/dbcheck"
	"joybuywork/internal/repository/mtype"
	"joybuywork/internal/service/queue/producer"
	"joybuywork/internal/service/queue/types"
	"joybuywork/internal/utils/logic"
	"fmt"

	"gits.branchcn.com/backend/microcode/plugins/derivative/delay"
)

func Setup() error {
	customers := delay.RegisterConsumer(
		delayCommon(),
	)

	return customers.Listen()
}

func Stop() {
	delay.Stop()
}

func delayCommon() *delay.Consumer {
	return delay.NewRedisDelayQueue(context.Background(), app.Redis.Cache, ckey.DelayCommonKey()).Consumer(commonCustomerAction)
}

// 通用对列消费者
func commonCustomerAction(ctx context.Context, d delay.Delivery) error {
	var handler *Ctx
	switch d.Type {
	case types.CommonRewardPush:
		handler = NewCtx(ctx, "奖品延时回调", d, rewardPush)
	case types.CommonGlobalRewardPush:
		handler = NewCtx(ctx, "全局奖品延时回调", d, globalRewardPush)

	case types.CommonCoinExpired:
		handler = NewCtx(ctx, "T币过期处理", d, coinExpired)
	case types.CommonCheckRewardPush:
		handler = NewCtx(ctx, "检查奖品是否成功推送", d, checkRewardPush)
	default:
		app.Logger.Error(ctx, fmt.Sprintf("不存在%s类型的延时对列处理场景", d.Type))
	}

	return handler.Done()
}

func checkRewardPush(ctx *Ctx) (err error) {
	var data *types.DelayCommonCheckRewardPush
	err = ctx.Parse(&data)
	if err != nil {
		return
	}

	reward, err := cache.NewReward(ctx.Context()).FindById(data.BaseRewardId)
	if err != nil {
		return
	}

	if reward == nil || reward.ReceiveType != mtype.RewardReceiveTypeNotify {
		return
	}

	m := dao.FissionNotify
	ntf, err := m.WithContext(ctx.Context()).Where(
		m.CampaignID.Eq(data.CampaignId),
		m.RecordID.Eq(data.UserRewardId),
	).Take()
	if err = dbcheck.DbError(err); err != nil {
		return
	}

	if ntf != nil {
		return
	}

	producer.NewCampaignNotice(ctx.Context()).CampaignRewardNotify(types.CampaignRewardNotify{
		CampaignId:   data.CampaignId,
		UserId:       data.UserId,
		UserRewardId: data.UserRewardId,
	})

	return
}

func coinExpired(ctx *Ctx) (err error) {
	var data *types.DelayCommonRewardPush
	err = ctx.Parse(&data)
	if err != nil {
		return
	}

	m := dao.ProjectUserCoinExpired
	expired, err := m.WithContext(ctx.Context()).Where(m.ID.Eq(data.TaskId)).Take()
	if err = dbcheck.DbError(err); err != nil {
		return
	}

	if expired == nil {
		return
	}

	producer.NewCampaignNotice(ctx.Context()).ProjectUserCoinDeduct(types.ProjectUserCoinDeduct{
		UserId:    expired.UserID,
		ExpiredId: expired.ID,
	})

	return
}

func rewardPush(ctx *Ctx) (err error) {
	var data *types.DelayCommonRewardPush
	err = ctx.Parse(&data)
	if err != nil {
		return
	}

	container := new(RewardPush)
	{
		container.Init(ctx.Context(), logic.WithErrData(data))
		container.Req = data
	}

	return logic.Run(container)
}

func globalRewardPush(ctx *Ctx) (err error) {
	var data *types.DelayCommonGlobalRewardPush
	err = ctx.Parse(&data)
	if err != nil {
		return
	}

	container := new(GlobalRewardPush)
	{
		container.Init(ctx.Context(), logic.WithErrData(data))
		container.Req = data
	}

	return logic.Run(container)
}