package reward

import (
	"context"
	"encoding/json"
	"fmt"
	"github.com/gogf/gf/v2/database/gdb"
	"github.com/gogf/gf/v2/os/gtime"
	"server/internal/consts"
	"server/internal/dao"
	"server/internal/model"
	"server/internal/model/do"
	"server/internal/service"
	"server/utility/ecode"
	"server/utility/gamelife"
	"time"
)

type sReward struct{}

func init() {
	service.RegisterReward(New())
}

func New() service.IReward {
	return &sReward{}
}

// Create 创建奖励
func (s *sReward) Create(ctx context.Context, in *model.RewardCreateIn) (out *model.RewardCreateOut, err error) {
	// 仅管理员能创建系统奖励（source=1）
	if in.Source == 1 && in.OperatorRole != consts.AdminRoleCode {
		return nil, ecode.Params.Sub("只有管理员可以创建系统奖励")
	}

	// 权限验证
	switch in.OperatorRole {
	case consts.MerchantRoleCode:
		// 检查商户管理员是否有该门店权限
		exist, err := dao.MerchantAdmins.Ctx(ctx).LeftJoin(
			dao.Stores.Table(),
			fmt.Sprintf("%s.%s = %s.%s",
				dao.MerchantAdmins.Table(), dao.MerchantAdmins.Columns().MerchantId,
				dao.Stores.Table(), dao.Stores.Columns().MerchantId,
			),
		).Where(
			fmt.Sprintf("%s.%s = ?", dao.Stores.Table(), dao.Stores.Columns().Id), in.StoreId,
		).Where(
			do.MerchantAdmins{Id: in.OperatorId},
		).Exist()
		if err != nil {
			return nil, ecode.Fail.Sub("检查商户权限失败")
		}
		if !exist {
			return nil, ecode.Params.Sub("无门店权限")
		}

	case consts.StoreRoleCode:
		// 检查门店管理员是否有该门店权限
		exist, err := dao.StoreAdmins.Ctx(ctx).LeftJoin(
			dao.Stores.Table(),
			fmt.Sprintf("%s.%s = %s.%s",
				dao.StoreAdmins.Table(), dao.StoreAdmins.Columns().StoreId,
				dao.Stores.Table(), dao.Stores.Columns().Id,
			),
		).Where(
			fmt.Sprintf("%s.%s = ?", dao.Stores.Table(), dao.Stores.Columns().Id), in.StoreId,
		).Where(
			do.StoreAdmins{Id: in.OperatorId},
		).Exist()
		if err != nil {
			return nil, ecode.Fail.Sub("检查门店权限失败")
		}
		if !exist {
			return nil, ecode.Params.Sub("无门店权限")
		}
	}

	// 创建奖励
	_, err = dao.Rewards.Ctx(ctx).Data(do.Rewards{
		StoreId:         in.StoreId,
		Name:            in.Name,
		RewardTypeId:    in.RewardTypeId,
		ImageUrl:        in.Img,
		QqGoodsId:       in.QQGoodsId,
		QqGoodsIdStr:    in.QQGoodsIdStr,
		Status:          in.Status,
		ValidFrom:       in.ValidFrom,
		ValidTo:         in.ValidTo,
		ExpireType:      in.ExpireType,
		ExpireDays:      in.ExpireDays,
		DailyTotalLimit: in.DailyTotalLimit,
		TotalLimit:      in.TotalLimit,
		GameId:          in.GameId,
		UserDailyLimit:  in.UserDailyLimit,
		UserTotalLimit:  in.UserTotalLimit,
	}).OmitEmptyData().Insert()

	if err != nil {
		return nil, err
	}

	return &model.RewardCreateOut{Success: true}, nil
}

// Update 更新奖励
func (s *sReward) Update(ctx context.Context, in *model.RewardUpdateIn) (out *model.RewardUpdateOut, err error) {
	// 查询原始记录，确保存在，并获取 source 与 store_id 用于权限校验
	data, err := dao.Rewards.Ctx(ctx).
		Fields(dao.Rewards.Columns().Id, dao.Rewards.Columns().StoreId).
		Where(do.Rewards{Id: in.Id}).One()
	if err != nil {
		return nil, ecode.Fail.Sub("查询奖励失败")
	}
	if data.IsEmpty() {
		return nil, ecode.Params.Sub("奖励不存在")
	}

	// 系统奖励（source=1）只能由管理员修改
	if in.Source == 1 && in.OperatorRole != consts.AdminRoleCode {
		return nil, ecode.Params.Sub("只有管理员可以修改系统奖励")
	}

	storeId := data[dao.Rewards.Columns().StoreId].Int64()

	// 权限校验（管理员跳过）
	switch in.OperatorRole {
	case consts.MerchantRoleCode:
		// 商户管理员权限校验：是否管理该门店
		exist, err := dao.MerchantAdmins.Ctx(ctx).LeftJoin(
			dao.Stores.Table(),
			fmt.Sprintf("%s.%s = %s.%s",
				dao.MerchantAdmins.Table(), dao.MerchantAdmins.Columns().MerchantId,
				dao.Stores.Table(), dao.Stores.Columns().MerchantId,
			),
		).Where(
			fmt.Sprintf("%s.%s = ?", dao.Stores.Table(), dao.Stores.Columns().Id), storeId,
		).Where(
			do.MerchantAdmins{Id: in.OperatorId},
		).Exist()
		if err != nil {
			return nil, ecode.Fail.Sub("检查操作者权限异常")
		}
		if !exist {
			return nil, ecode.Params.Sub("无门店权限")
		}

	case consts.StoreRoleCode:
		// 门店管理员权限校验：是否管理该门店
		exist, err := dao.StoreAdmins.Ctx(ctx).LeftJoin(
			dao.Stores.Table(),
			fmt.Sprintf("%s.%s = %s.%s",
				dao.StoreAdmins.Table(), dao.StoreAdmins.Columns().StoreId,
				dao.Stores.Table(), dao.Stores.Columns().Id,
			),
		).Where(
			fmt.Sprintf("%s.%s = ?", dao.Stores.Table(), dao.Stores.Columns().Id), storeId,
		).Where(
			do.StoreAdmins{Id: in.OperatorId},
		).Exist()
		if err != nil {
			return nil, ecode.Fail.Sub("检查操作者权限异常")
		}
		if !exist {
			return nil, ecode.Params.Sub("无门店权限")
		}
	}

	// 执行更新（不允许更新 store_id 和 source）
	_, err = dao.Rewards.Ctx(ctx).
		Where(do.Rewards{Id: in.Id}).
		Data(do.Rewards{
			Name:            in.Name,
			RewardTypeId:    in.RewardTypeId,
			GameId:          in.GameId,
			ImageUrl:        in.Img,
			QqGoodsId:       in.QQGoodsId,
			QqGoodsIdStr:    in.QQGoodsIdStr,
			Status:          in.Status,
			ValidFrom:       in.ValidFrom,
			ValidTo:         in.ValidTo,
			ExpireType:      in.ExpireType,
			ExpireDays:      in.ExpireDays,
			DailyTotalLimit: in.DailyTotalLimit,
			TotalLimit:      in.TotalLimit,
			UserDailyLimit:  in.UserDailyLimit,
			UserTotalLimit:  in.UserTotalLimit,
			GrantQuantity:   in.GrantQuantity,
		}).OmitEmptyData().Update()

	if err != nil {
		return nil, ecode.Fail.Sub("更新奖励失败")
	}

	// 判断过期类型
	if in.ExpireType == 1 {
		in.ExpireDays = 0
		_, err = dao.Rewards.Ctx(ctx).Where(do.Rewards{Id: in.Id}).Update("expire_days = null")
		if err != nil {
			return nil, err
		}
	} else {
		_, err = dao.Rewards.Ctx(ctx).Where(do.Rewards{Id: in.Id}).Update("valid_from = null,valid_to = null")
		if err != nil {
			return nil, err
		}
	}

	return &model.RewardUpdateOut{Success: true}, nil
}

// Delete 删除奖励
func (s *sReward) Delete(ctx context.Context, in *model.RewardDeleteIn) (out *model.RewardDeleteOut, err error) {
	data, err := dao.Rewards.Ctx(ctx).
		Fields("id", "store_id").
		Where(do.Rewards{Id: in.Id}).One()
	if err != nil {
		return nil, ecode.Fail.Sub("查询奖励失败")
	}
	if data.IsEmpty() {
		return nil, ecode.Params.Sub("奖励不存在")
	}

	if in.Source == 1 && in.OperatorRole != consts.AdminRoleCode {
		return nil, ecode.Params.Sub("只有管理员可以删除系统奖励")
	}

	storeId := data["store_id"].Int64()
	switch in.OperatorRole {
	case consts.MerchantRoleCode:
		exist, err := dao.MerchantAdmins.Ctx(ctx).LeftJoin(
			dao.Stores.Table(),
			fmt.Sprintf("%s.%s = %s.%s",
				dao.MerchantAdmins.Table(), dao.MerchantAdmins.Columns().MerchantId,
				dao.Stores.Table(), dao.Stores.Columns().MerchantId),
		).Where(fmt.Sprintf("%s.%s = ?", dao.Stores.Table(), dao.Stores.Columns().Id), storeId).
			Where(do.MerchantAdmins{Id: in.OperatorId}).Exist()
		if err != nil {
			return nil, ecode.Fail.Sub("权限校验失败")
		}
		if !exist {
			return nil, ecode.Params.Sub("无门店权限")
		}
	case consts.StoreRoleCode:
		exist, err := dao.StoreAdmins.Ctx(ctx).Where(do.StoreAdmins{Id: in.OperatorId, StoreId: storeId}).Exist()
		if err != nil {
			return nil, ecode.Fail.Sub("权限校验失败")
		}
		if !exist {
			return nil, ecode.Params.Sub("无门店权限")
		}
	}

	_, err = dao.Rewards.Ctx(ctx).Where(do.Rewards{Id: in.Id}).Delete()
	if err != nil {
		return nil, ecode.Fail.Sub("删除失败")
	}

	return &model.RewardDeleteOut{Success: true}, nil
}

// List 奖励列表
func (s *sReward) List(ctx context.Context, in *model.RewardListIn) (out *model.RewardListOut, err error) {

	rewardCols := dao.Rewards.Columns()
	orm := dao.Rewards.Ctx(ctx).LeftJoin(
		dao.RewardTypes.Table(),
		fmt.Sprintf(
			"%s.%s = %s.%s",
			dao.Rewards.Table(), dao.Rewards.Columns().RewardTypeId,
			dao.RewardTypes.Table(), dao.RewardTypes.Columns().Id,
		),
	).Fields(fmt.Sprintf("%s.*,%s.name as reward_type_name", dao.Rewards.Table(), dao.RewardTypes.Table()))
	switch in.OperatorRole {
	case consts.AdminRoleCode:
		// 系统管理员只能查询 source = 1 的奖励
		orm = orm.Where(rewardCols.Source, 1)
	case consts.MerchantRoleCode, consts.StoreRoleCode:
		// 合并商户和门店角色权限校验
		var exist bool
		if in.OperatorRole == consts.MerchantRoleCode {
			exist, err = dao.MerchantAdmins.Ctx(ctx).
				Where(do.MerchantAdmins{Id: in.OperatorId}).
				LeftJoin(
					dao.Stores.Table(),
					fmt.Sprintf("%s.%s = %s.%s",
						dao.MerchantAdmins.Table(), dao.MerchantAdmins.Columns().MerchantId,
						dao.Stores.Table(), dao.Stores.Columns().MerchantId,
					),
				).
				Where(fmt.Sprintf("%s.%s = ?", dao.Stores.Table(), dao.Stores.Columns().Id), in.StoreId).
				Exist()
		} else {
			exist, err = dao.StoreAdmins.Ctx(ctx).
				Where(do.StoreAdmins{Id: in.OperatorId}).
				LeftJoin(
					dao.Stores.Table(),
					fmt.Sprintf("%s.%s = %s.%s",
						dao.StoreAdmins.Table(), dao.StoreAdmins.Columns().StoreId,
						dao.Stores.Table(), dao.Stores.Columns().Id,
					),
				).
				Where(fmt.Sprintf("%s.%s = ?", dao.Stores.Table(), dao.Stores.Columns().Id), in.StoreId).
				Exist()
		}
		if err != nil {
			return nil, ecode.Fail.Sub("检查操作者权限异常")
		}
		if !exist {
			return nil, ecode.Params.Sub("无门店权限")
		}
		orm = orm.Where(rewardCols.Source, 2)
	default:
		return nil, ecode.Params.Sub("无效的角色")
	}

	// ==== 其他查询条件 ====
	if in.Status != 0 {
		orm = orm.Where(fmt.Sprintf("%s.%s = ?", dao.Rewards.Table(), rewardCols.Status), in.Status)
	}
	if in.RewardTypeId != 0 {
		// 确保 reward_type_id 过滤独立应用
		orm = orm.Where(fmt.Sprintf("%s.%s = ?", dao.Rewards.Table(), rewardCols.RewardTypeId), in.RewardTypeId)
	}
	if in.Name != "" {
		orm = orm.WhereLike(rewardCols.Name, "%"+in.Name+"%")
	}

	// ==== 总数统计 ====
	list := make([]model.Reward, 0)
	var total int
	err = orm.ScanAndCount(&list, &total, false)
	if err != nil {
		return nil, err
	}

	return &model.RewardListOut{
		List:  list,
		Total: total,
	}, nil
}

// GetLift 领取奖励
func (s *sReward) GetLift(ctx context.Context, in *model.GetRewardIn) (out *model.GetRewardOut, err error) {

	giftParam := model.GiftParam{}
	// 判断奖励类型
	if in.Source == 1 {
		// 系统奖励处理
		if in.RewradTypeId != 16 {
			// 需要大区角色
			giftParam.AreaId = in.AreaId
			giftParam.Gid = in.GameId
			giftParam.RoleIdx = in.RoleIdx
			giftParam.TaskId = in.TaskId
		} else {
			// 不需要
			giftParam.TaskId = in.TaskId
			giftParam.Gid = in.GameId
		}
	} else {
		// 门店奖励处理

	}

	activity, err := gamelife.GetGamelifeClient(ctx).RequestActivity(ctx, &model.QQNetbarActivityIn{PopenId: in.PopenId, ServiceName: consts.GetGift, GiftParam: giftParam})

	if err != nil {
		return nil, err
	}

	result, ok := activity.(*model.GiftResponse)
	if !ok {
		return nil, ecode.Fail.Sub("数据类型转换失败")
	}

	// 存储数据库记录
	if err = dao.RewardWaters.Transaction(ctx, func(ctx context.Context, tx gdb.TX) (err error) {
		for _, item := range result.GiftItem {
			marshal, err := json.Marshal(item.Water)
			if err != nil {
				return ecode.Fail.Sub("序列化 json 数据出现异常")
			}
			_, err = dao.RewardWaters.Ctx(ctx).Insert(model.RewardWaters{
				OrderId: item.Water.OrderId,
				Status:  int64(item.Result),
				Uid:     item.Water.Uid,
				Water:   string(marshal),
				TaskId:  in.TaskId,
				GameId:  int64(in.GameId),
			})

			if err != nil {
				return ecode.Fail.Sub("添加奖励领取记录异常")
			}

			// 根据 result判断
			if item.Result == 1 {
				// 奖励发放成功，修改状态，扣除数量
				if _, err = dao.UserTaskRewards.Ctx(ctx).Where(do.UserTaskRewards{ExternalOrderId: item.Water.OrderId}).Update(consts.RewardSuccessStatus); err != nil {
					return ecode.Fail.Sub("修改奖励领取记录状态异常")
				}

				value, err := dao.UserTaskRewards.Ctx(ctx).Where(do.UserTaskRewards{ExternalOrderId: item.Water.OrderId}).Value(dao.UserTaskRewards.Columns().RewardId)
				if err != nil {
					return ecode.Fail.Sub("获取奖励领取记录异常")
				}
				if value.IsEmpty() {
					return ecode.Fail.Sub("获取奖励领取记录异常")
				}
				// 扣除数量
				if _, err = dao.Rewards.Ctx(ctx).Where(do.Rewards{Id: value.Int()}).One(); err != nil {
					return ecode.Fail.Sub("获取奖励记录异常")
				}
				return
			} else if item.Result == 2 || item.Result == 3 {
				// 发放背包成功，修改状态
			} else if item.Result == 4 {
				// 奖励领取失败,不做操作，直接返回
			}
		}

		return

	}); err != nil {
		return
	}

	return nil, err
}

// GetGoodsList 调用外部获取物品列表
func (s *sReward) GetGoodsList(ctx context.Context, in *model.GetGoodsListIn) (out *model.GetGoodsListOut, err error) {

	var user model.User
	// 查询用户信息
	//err = dao.Users.Ctx(ctx).Where(do.Users{Id: in.UserId}).Scan(&user)
	err = dao.Users.Ctx(ctx).Where(do.Users{Id: 19}).Scan(&user)
	if err != nil {
		return nil, ecode.Fail.Sub("查询用户失败")
	}
	var pOpenId string
	// 判断绑定类型 QQ还是WX
	if in.BindType == 1 {
		pOpenId = user.QQPopenId
	} else {
		pOpenId = user.WXPopenId
	}

	// 调用 tencent
	result, err := gamelife.GetGamelifeClient(ctx).RequestActivity(ctx, &model.QQNetbarActivityIn{ServiceName: consts.QueryUserGoodsList, BindType: in.BindType,
		GoodsParam: model.GoodsParam{AppFilter: in.Appfilter, BigTime: in.BigTime, GoodsStatus: int(in.Goodsstatus), Num: int(in.Num), OrderByDesc: true, OrderType: in.OrderType, Pageidx: in.Pageidx, Gid: 26},
		PopenId:    pOpenId, NickName: user.Nickname})
	if err != nil {
		return nil, ecode.Fail.Sub("请求失败")
	}

	response, ok := result.(*model.GoodsResponse)
	if !ok {
		return nil, ecode.Fail.Sub("类型断言失败")
	}

	return &model.GetGoodsListOut{
		List:    response.Waters,
		Pageidx: response.PageIdx,
		Total:   response.Total,
	}, nil
}

// GetGoods 物品兑换
func (s *sReward) GetGoods(ctx context.Context, in *model.GetGoodsGetIn) (out *model.GoodsGetOut, err error) {
	return nil, err
}

// GetGoodsDetails 物品详情
func (s *sReward) GetGoodsDetails(ctx context.Context, in *model.GetGoodsDetailsIn) (out *model.QueryUserGoodsDetailResponse, err error) {

	//
	activity, err := gamelife.GetGamelifeClient(ctx).RequestActivity(ctx, &model.QQNetbarActivityIn{PopenId: in.PopenId, ServiceName: consts.QueryUserGoodsDetail, QueryUserGoodsDetailParam: model.QueryUserGoodsDetailParam{
		Gid:         in.Gid,
		WinningTime: in.WinningTime,
		OrderId:     in.OrderId,
		IsActInfo:   in.IsActInfo,
		IsDocument:  in.IsDocument,
		IsDetail:    in.IsDetail,
	}})

	if err != nil {
		return nil, err
	}

	result, ok := activity.(*model.QueryUserGoodsDetailResponse)
	if !ok {
		return nil, ecode.Fail.Sub("数据类型转换失败")
	}

	return &model.QueryUserGoodsDetailResponse{
		Water: result.Water,
	}, nil
}

func (s *sReward) OperateTaskReward(ctx context.Context, in *model.OperateTaskRewardIn) (out *model.OperateTaskRewardOut, err error) {
	// 如果是系统管理员给任务添加奖励，需要校验奖励的来源
	exist, err := dao.Rewards.Ctx(ctx).Where(do.Rewards{Id: in.RewardId}).Exist()
	if err != nil {
		return nil, ecode.Fail.Sub("奖励不存在")
	}
	if !exist {
		return nil, ecode.Params.Sub("奖励不存在")
	}

	if in.Type == 1 {
		_, err := dao.TaskRewards.Ctx(ctx).Data(do.TaskRewards{TaskId: in.TaskId, RewardId: in.RewardId}).Insert()
		return &model.OperateTaskRewardOut{Success: true}, err
	} else {
		_, err := dao.TaskRewards.Ctx(ctx).Where(do.TaskRewards{TaskId: in.TaskId, RewardId: in.RewardId}).Delete()
		return &model.OperateTaskRewardOut{Success: true}, err
	}
}

// CallBack 奖励回调
func (s *sReward) CallBack(ctx context.Context, in *model.RewardCallbackIn) (out *model.RewardCallbackOut, err error) {
	var reward *model.Reward
	var res model.RewardCallbackOut
	res.OrderId = in.OrderId
	res.AppId = in.AppId

	// 查询奖励
	err = dao.Rewards.Ctx(ctx).Where(do.Rewards{PrizeId: in.PrizeId}).Scan(&reward)
	if err != nil {
		res.Errcode = -1
		res.Errmsg = "查询奖励异常"
		res.Datas = nil
		return &res, ecode.Fail.Sub("查询奖励异常")
	}

	if reward == nil {
		res.Errcode = -1
		res.Errmsg = "查询奖励为空"
		res.Datas = nil
		return &res, ecode.Params.Sub("查询奖励为空")
	}

	// 判断是否过期
	if reward.ExpireType == 1 {
		//时间段过期
		if reward.ValidTo.Before(gtime.Now()) {
			res.Errcode = consts.BatchOutDate
			res.Errmsg = consts.BatchOutDateMSG
		}
	}

	// 日
	now := time.Now()
	// 当天开始时间
	start := time.Date(now.Year(), now.Month(), now.Day(), 0, 0, 0, 0, now.Location())
	// 当天结束时间
	end := time.Date(now.Year(), now.Month(), now.Day(), 23, 59, 59, 0, now.Location())
	// 查先询用户当日已领取
	dailyGetNum, err := dao.Rewards.Ctx(ctx).Where(dao.Rewards.Columns().PrizeId, in.PrizeId).InnerJoin(dao.UserTaskRewards.Table(), fmt.Sprintf("%s.id=%s.reward_id", dao.Rewards.Table(),
		dao.UserTaskRewards.Table())).InnerJoin(dao.RewardWaters.Table(), fmt.Sprintf("%s.external_order_id = %s.order_id", dao.UserTaskRewards.Table(), dao.RewardWaters.Table())).
		Where(dao.RewardWaters.Columns().Recvuid, in.Uid).Where(dao.UserTaskRewards.Columns().Status, 3).WhereOr(dao.UserTaskRewards.Columns().Status, 6).
		WhereBetween(dao.UserTaskRewards.Columns().UpdatedAt, start, end).Fields(fmt.Sprintf("%s.*,%s.*", dao.Rewards.Table(), dao.UserTaskRewards.Table())).Count()

	if err != nil {
		res.Errcode = -1
		res.Errmsg = "查询用户当日领取数量失败"
		res.Datas = nil
		return &res, ecode.Fail.Sub("查询用户当日领取数量失败")
	}

	// 判断是否达到用户日限制
	if int(reward.UserDailyLimit) <= dailyGetNum {
		res.Errcode = consts.UserDayLimit
		res.Errmsg = consts.UserDayLimitMSG
	}

	// 查先询用户总共已领取
	dailyTotalNum, err := dao.Rewards.Ctx(ctx).Where(dao.Rewards.Columns().PrizeId, in.PrizeId).InnerJoin(dao.UserTaskRewards.Table(), fmt.Sprintf("%s.id=%s.reward_id", dao.Rewards.Table(),
		dao.UserTaskRewards.Table())).InnerJoin(dao.RewardWaters.Table(), fmt.Sprintf("%s.external_order_id = %s.order_id", dao.UserTaskRewards.Table(), dao.RewardWaters.Table())).
		Where(dao.RewardWaters.Columns().Recvuid, in.Uid).Where(dao.UserTaskRewards.Columns().Status, 3).WhereOr(dao.UserTaskRewards.Columns().Status, 6).
		Fields(fmt.Sprintf("%s.*,%s.*", dao.Rewards.Table(), dao.UserTaskRewards.Table())).Count()

	if err != nil {
		res.Errcode = -1
		res.Errmsg = "查询用户当日总共领取数量失败"
		res.Datas = nil
		return &res, ecode.Fail.Sub("查询用户当日总共领取数量失败")
	}
	// 判断是否达到用户总限制
	if int(reward.UserTotalLimit) <= dailyTotalNum {
		res.Errcode = consts.UserTotalLimit
		res.Errmsg = consts.UserTotalLimitMSG
	}

	// 查先询该批次当日已领取
	batchDailyGetNum, err := dao.Rewards.Ctx(ctx).Where(dao.Rewards.Columns().PrizeId, in.PrizeId).InnerJoin(dao.UserTaskRewards.Table(), fmt.Sprintf("%s.id = %s.reward_id",
		dao.Rewards.Table(), dao.UserTaskRewards.Table())).Where(dao.UserTaskRewards.Columns().Status, 3).WhereOr(dao.UserTaskRewards.Columns().Status, 6).
		WhereBetween(dao.UserTaskRewards.Columns().UpdatedAt, start, end).Fields(fmt.Sprintf("%s.*,%s.*", dao.Rewards.Table(), dao.UserTaskRewards.Table())).Count()
	if err != nil {
		res.Errcode = -1
		res.Errmsg = "查询该批次当日总共领取数量失败"
		res.Datas = nil
		return &res, ecode.Fail.Sub("查询该批次当日总共领取数量失败")
	}
	// 判断是否达到该批次日限制
	if int(reward.DailyTotalLimit) <= batchDailyGetNum {
		res.Errcode = consts.BatchDayLimit
		res.Errmsg = consts.BatchDayLimitMSG
	}

	// 查先询该批次总共已领取
	batchTotalGetNum, err := dao.Rewards.Ctx(ctx).Where(dao.Rewards.Columns().PrizeId, in.PrizeId).InnerJoin(dao.UserTaskRewards.Table(), fmt.Sprintf("%s.id = %s.reward_id",
		dao.Rewards.Table(), dao.UserTaskRewards.Table())).Where(dao.UserTaskRewards.Columns().Status, 3).WhereOr(dao.UserTaskRewards.Columns().Status, 6).
		Fields(fmt.Sprintf("%s.*,%s.*", dao.Rewards.Table(), dao.UserTaskRewards.Table())).Count()

	if err != nil {
		res.Errcode = -1
		res.Errmsg = "查询该批次总共领取数量失败"
		res.Datas = nil
		return &res, ecode.Fail.Sub("查询该批次总共领取数量失败")
	}
	// 判断是否达到该批次总共限制
	if int(reward.TotalLimit) <= batchTotalGetNum {
		res.Errcode = consts.BatchTotalLimit
		res.Errmsg = consts.BatchTotalLimitMSG
	}

	_, err = dao.RewardCallback.Ctx(ctx).OmitEmptyData().Insert(do.RewardCallback{
		OrderId:      in.OrderId,
		PrizeId:      in.PrizeId,
		PrizeType:    in.PrizeType,
		PrizeSubType: in.PrizeSubType,
		Uid:          in.Uid,
		Num:          in.Num,
		CustomInfo:   in.CustomInfo,
		AppId:        in.AppId,
	})

	if err != nil {
		res.Errcode = -1
		res.Errmsg = "存储奖励回调数据异常"
		res.Datas = nil
		return &res, ecode.Fail.Sub("存储奖励回调数据异常")
	}

	// 回调成功，组装响应参数
	var userTaskReward []*model.UserTaskRewards
	if err = dao.Rewards.Ctx(ctx).Where(dao.Rewards.Columns().PrizeId, in.PrizeId).InnerJoin(dao.UserTaskRewards.Table(), fmt.Sprintf("%s.%s = %s.%s",
		dao.Rewards.Table(), dao.Rewards.Columns().Id, dao.UserTaskRewards.Table(), dao.UserTaskRewards.Columns().RewardId)).Scan(&userTaskReward); err != nil {
		return nil, ecode.Fail.Sub("获取用户奖励记录异常")
	}

	if userTaskReward == nil {
		res.Errcode = -1
		res.Errmsg = "用户奖励记录为空"
		res.Datas = nil
		return &res, ecode.Fail.Sub("用户奖励记录为空")
	}

	callbackData := make([]model.CallbackData, 0)
	for _, v := range userTaskReward {
		callbackData = append(callbackData, model.CallbackData{
			PrizeCode: v.InnerOrderId,
		})
	}

	res.Datas = callbackData

	return &res, err
}