package cachecurd

import (
	"joybuywork/internal/consts"
	"joybuywork/internal/repository/cache"
	"joybuywork/internal/repository/dao"
	"joybuywork/internal/repository/model"
	"joybuywork/internal/repository/mtype"
	"joybuywork/internal/utils"
	"joybuywork/internal/utils/lockdo"
	"joybuywork/proto/go_proto/workerr"
	"fmt"
)

const (
	StockFieldStock    = "stock"     // 总库存
	StockFieldUseStock = "use_stock" // 已使用
	StockFieldPoolNum  = "pool_num"  // 奖品池使用
)

const (
	tRewardSelectStock   = "rewardSelectStock"   // 奖品被选择的库存
	tCampaignRewardStock = "campaignRewardStock" // 活动奖品库存
	tCampaignStock       = "campaignStock"       // 活动库存

	tMallItemStock = "mallItemStock" // 商城库存
)

// 奖品总预算情况
func (s *HMap) campaignStock(cond *HMapBuild) (err error) {
	err = lockdo.ExistDo(s.ctx, s.key, func(exist bool) (err error) {
		if exist {
			return
		}

		var cpn *model.FissionCampaign
		cpn, err = cache.NewCampaign(s.ctx).FindById(cond.CpnId)
		if err != nil {
			return
		}

		var rewardLimit int64

		switch cpn.FissionID {
		case consts.IdReferral:
			var conf *model.FissionCampaignReferral
			conf, err = cache.NewCampaignReferral(s.ctx).FindByCampaignId(cpn.ID)
			if err != nil {
				return
			}
			rewardLimit = int64(conf.RewardLimit)
		case consts.IdWinTogether:
			var conf *model.FissionCampaignWin
			conf, err = cache.NewCampaignWin(s.ctx).FindByCampaignId(cpn.ID)
			if err != nil {
				return
			}
			rewardLimit = int64(conf.RewardLimit)
		case consts.IdGold:
			var conf *model.FissionCampaignGold
			conf, err = cache.NewCampaignGold(s.ctx).FindByCampaignId(cpn.ID)
			if err != nil {
				return
			}
			rewardLimit = int64(conf.PriceNum)
		case consts.IdCash:
			var conf *model.FissionCampaignCash
			conf, err = cache.NewCampaignCash(s.ctx).FindByCampaignId(cpn.ID)
			if err != nil {
				return
			}
			rewardLimit = int64(conf.PriceNum)
		default:
			return workerr.VerifyError("The fission is not be support")
		}

		var num int64
		switch cpn.FissionID {
		case consts.IdGold:
			m := dao.FissionGoldLog
			num, err = m.WithContext(s.ctx).
				Where(m.CampaignID.Eq(cpn.ID), m.Type.Eq(mtype.FissionGoldLogTypeReward)).
				Count()
			if err != nil {
				return
			}
		case consts.IdCash:
			m := dao.FissionCashRecord
			num, err = m.WithContext(s.ctx).
				Where(m.CampaignID.Eq(cpn.ID), m.Type.Eq(mtype.FissionCashRecordTypeReward)).
				Count()
			if err != nil {
				return
			}
		default:
			var rewardNum struct {
				Num int64 `json:"num"`
			}
			m := dao.FissionRewardRecord.SubTable(cond.CpnId)
			err = m.WithContext(s.ctx).
				Select(m.RewardNum.Sum().As("num")).
				Where(m.CampaignID.Eq(cond.CpnId), m.RewardType.Eq(mtype.FissionCampaignRewardTypeApp)).
				Scan(&rewardNum)
			if err != nil {
				return
			}

			num = rewardNum.Num
		}

		return s._setStock(rewardLimit, num, rewardLimit-num)
	})

	return
}

// 奖品发放库存情况
func (s *HMap) campaignRewardStock(cond *HMapBuild) (err error) {
	err = lockdo.ExistDo(s.ctx, s.key, func(exist bool) (err error) {
		if exist {
			return
		}

		rewardId := cond.RewardId

		rewardM := dao.FissionCampaignReward
		reward, err := rewardM.WithContext(s.ctx).Where(rewardM.ID.Eq(rewardId)).Take()
		if err != nil {
			return
		}

		m := dao.FissionRewardRecord.SubTable(reward.CampaignID)
		count, err := m.WithContext(s.ctx).Where(
			m.RewardID.Eq(rewardId),
			m.Status.Neq(mtype.FissionRewardRecordStatusFail),
		).Count()
		if err != nil {
			return
		}

		return s._setStock(int64(reward.Stock), count, utils.Ternary[int64](reward.IsThank == mtype.Yes, -1, int64(reward.Stock)-count))

	})

	return
}

// 奖品选择库存情况
func (s *HMap) rewardSelectStock(cond *HMapBuild) (err error) {
	err = lockdo.ExistDo(s.ctx, s.key, func(exist bool) (err error) {
		if exist {
			return
		}

		rewardId := cond.RewardId

		rewardM := dao.FissionCampaignReward
		reward, err := rewardM.WithContext(s.ctx).Where(rewardM.ID.Eq(rewardId)).Take()
		if err != nil {
			return
		}

		cpn, err := cache.NewCampaign(s.ctx).FindById(reward.CampaignID)
		if err != nil {
			return
		}

		var count int64
		switch cpn.FissionID {
		case consts.IdKeep:
			m := dao.FissionKeep
			count, err = m.WithContext(s.ctx).Where(
				m.RewardID.Eq(rewardId),
				m.CancelReward.Eq(mtype.No),
			).Count()
			if err != nil {
				return
			}
		default:
			return workerr.VerifyError("The fission is not be support")
		}

		return s._setStock(int64(reward.Stock), count, utils.Ternary[int64](reward.IsThank == mtype.Yes, -1, int64(reward.Stock)-count))
	})

	return
}

func (s *HMap) mallItemStock(cond *HMapBuild) (err error) {
	err = lockdo.ExistDo(s.ctx, s.key, func(exist bool) (err error) {
		if exist {
			return
		}

		rewardId := cond.RewardId

		rewardM := dao.RedeemMallItem
		reward, err := rewardM.WithContext(s.ctx).Where(rewardM.ID.Eq(rewardId)).Take()
		if err != nil {
			return
		}

		m := dao.RedeemMallRecord
		count, err := m.WithContext(s.ctx).Where(m.MallItemID.Eq(reward.ID)).Count()
		if err != nil {
			return
		}

		return s._setStock(reward.Stock, count, reward.Stock-count)
	})

	return
}

func (s *HMap) _setStock(stock, useStock, poolNum int64) (err error) {
	s.data = make(map[string]string, 3)
	return s.Set(StockFieldStock, fmt.Sprint(stock), StockFieldUseStock, fmt.Sprint(useStock), StockFieldPoolNum, fmt.Sprint(poolNum))
}