package campaignuser

import (
	"joybuywork/internal/app"
	"joybuywork/internal/consts"
	"joybuywork/internal/repository/dbcheck"
	"joybuywork/internal/repository/finder"
	"joybuywork/internal/repository/model"
	"joybuywork/internal/repository/mtype"
	"joybuywork/internal/repository/withdefault"
	"joybuywork/internal/service/cmm"
	"joybuywork/internal/service/provider"
	"joybuywork/internal/service/provider/award"
	"joybuywork/internal/service/provider/fissionaction"
	"joybuywork/internal/utils"
	"joybuywork/internal/utils/logic"
	"joybuywork/internal/utils/verify"
	pb "joybuywork/proto/go_proto/w_campaign_user"
	"joybuywork/proto/go_proto/workerr"
	"fmt"
	"time"

	"gits.branchcn.com/backend/microcode/plugins/lucky"
	"gorm.io/gen/field"
)

type rollData struct {
	MarkType    int8   // 格子类型
	Step        int32  // 下标数据
	RewardId    int64  // 活动奖品id
	MapId       int64  // 地图int类型id
	MapHashId   string // 地图hash_id
	RewardTitle string // 奖品名称
	ImgUrl      string // 奖品地址
	Intact      bool   // 合成了奖品
	Lack        bool   // 缺库存
}

const (
	campaignUserDiceFailTypeNone  = iota // 没有错误
	campaignUserDiceFailTypeLack         // 缺骰子数
	campaignUserDiceFailTypeProps        // 道具不足
)

type Dice struct {
	logic.Logic
	Req *pb.DiceReq
	Res *pb.DiceRes

	isView bool //是否预览用户
	prop   map[string]*model.FissionDiceProp

	user *model.FissionUser
}

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

func (s *Dice) Exec() (err error) {
	player, run, err := s.player()
	if err != nil {
		return
	}

	if s._isFixedRoll() {
		return s.useFixedRoll(player, run)
	}

	return s.normal(player, run)
}

func (s *Dice) player() (player *model.FissionDice, run *model.FissionDiceRun, err error) {
	cpn, err := finder.Campaign(s.Ctx, s.Req.GetCampaignId())
	if err != nil {
		err = s.BE().CacheError(err)
		return
	}

	if cpn == nil || cpn.IsDel == mtype.Yes {
		err = workerr.NotFound("not found cpn")
		return
	}

	user, err := finder.FissionUser(s.Ctx, cpn.ID, s.Req.GetUserId())
	if err != nil {
		err = s.BE().CacheError(err)
		return
	}

	if user == nil {
		err = workerr.UnauthorizedError
		return
	}

	m := s.GetDao().FissionDice
	player, err = m.WithContext(s.Ctx).Where(m.UserID.Eq(user.ID)).Take()
	if err = dbcheck.DbError(err); err != nil {
		err = s.BE().MysqlError(err)
		return
	}

	if player == nil {
		err = workerr.NotFound("not found player")
		return
	}

	run, err = cmm.NewCMM(s.Ctx, s.GetDao()).GetUserMap(user)
	if err != nil {
		return
	}

	s.isView = user.IsView == mtype.Yes
	s.user = user

	return
}

func (s *Dice) useFixedRoll(player *model.FissionDice, run *model.FissionDiceRun) (err error) {
	m := s.GetDao().FissionDiceProp
	prop, err := m.WithContext(s.Ctx).Where(m.UserID.Eq(player.UserID), m.Mark.Eq(mtype.FissionDicePropMarkFixedRoll)).Take()
	if err = dbcheck.DbError(err); err != nil {
		err = s.BE().MysqlError(err)
		return
	}

	if prop == nil || prop.Num <= 0 {
		s.Res.FailType = campaignUserDiceFailTypeProps
		return
	}

	_, err = m.WithContext(s.Ctx).Where(m.ID.Eq(prop.ID)).UpdateSimple(m.Num.Sub(1))
	if err != nil {
		err = s.BE().MysqlError(err)
		return
	}

	step := utils.StrToInt(s.Req.GetVal()) - 1

	res, err := s._rollMap(run, step)
	if err != nil || res == nil {
		return
	}

	// 记录日志
	err = s._diceRecord(player, res, true)
	if err != nil {
		return
	}

	// 使用道具埋点
	fissionaction.NewMarkPoint(s.Ctx).InApp(s.user).UseProp(time.Now().Unix(), consts.PropNameFixedDice)

	return s._resp(run, res)
}

func (s *Dice) normal(player *model.FissionDice, run *model.FissionDiceRun) (err error) {
	if player.Chance <= 0 {
		s.Res.FailType = campaignUserDiceFailTypeLack
		return
	}

	step := utils.RandNumber(6)

	res, err := s._rollMap(run, int(step))
	if err != nil || res == nil {
		return
	}

	// 不是预览用户要减次数，并且不是再来一次就减一次
	if !s.isView && res.MarkType != mtype.FissionDiceMapMarkTypeChance {
		m := s.GetDao().FissionDice
		_, err = m.WithContext(s.Ctx).Where(m.ID.Eq(player.ID)).UpdateSimple(m.Chance.Sub(1))
		if err != nil {
			err = s.BE().MysqlError(err)
			return
		}
	}

	// 记录日志
	err = s._diceRecord(player, res, false)
	if err != nil {
		return
	}

	return s._resp(run, res)
}

// 结果处理
func (s *Dice) _resp(run *model.FissionDiceRun, res *rollData) (err error) {

	// 更新地图信息
	runM := s.GetDao().FissionDiceRun
	_, err = runM.WithContext(s.Ctx).Where(runM.ID.Eq(run.ID)).UpdateSimple(
		runM.MapID.Value(res.MapId),
		runM.MapHashID.Value(res.MapHashId),
		runM.GoStep.Add(int64(res.Step)+1),
	)
	if err != nil {
		err = s.BE().MysqlError(err)
		return
	}

	s.Res.MarkType = int32(res.MarkType)
	s.Res.MapHashId = res.MapHashId
	s.Res.RewardTitle = res.RewardTitle
	s.Res.ImgUrl = res.ImgUrl
	s.Res.IsIntact = res.Intact
	s.Res.RollNum = res.Step + 1
	s.Res.Lack = res.Lack
	s.Res.RewardId = res.RewardId

	return
}

func (s *Dice) _rollMap(run *model.FissionDiceRun, idx int) (res *rollData, err error) {
	m := s.GetDao().FissionDiceMap
	list, err := m.WithContext(s.Ctx).Where(m.CampaignID.Eq(run.CampaignID), m.DmgID.Eq(run.DmgID), m.ID.Gt(run.MapID)).Limit(6).Find()
	if err != nil {
		err = s.BE().MysqlError(err)
		return
	}

	if len(list) < 6 {

		back := 6 - len(list)
		var backList []*model.FissionDiceMap
		backList, err = m.WithContext(s.Ctx).Where(m.CampaignID.Eq(run.CampaignID), m.DmgID.Eq(run.DmgID)).Limit(back).Order(m.ID).Find()
		if err != nil {
			err = s.BE().MysqlError(err)
			return
		}

		for _, v := range backList {
			list = append(list, v)
		}

	}

	if len(list) == 0 {
		app.Logger.Error(s.Ctx, fmt.Sprintf("活动[%d]地图生成异常, 用户id[%d]", run.CampaignID, run.UserID))
		err = workerr.ServerError
		return
	}

	var loseMap = make(map[int]*model.FissionDiceMap)
	for i, v := range list {
		if verify.InArray(v.MarkType, mtype.FissionDiceMapMarkTypeNone, mtype.FissionDiceMapMarkTypeChance, mtype.FissionDiceMapMarkTypeFixedRoll) {
			loseMap[i] = v
		}
	}

	var win, lose *rollData

	for i, v := range loseMap {
		switch v.MarkType {
		case mtype.FissionDiceMapMarkTypeNone, mtype.FissionDiceMapMarkTypeChance:
			lose = &rollData{
				MarkType:  v.MarkType,
				Step:      int32(i),
				RewardId:  v.RewardID,
				MapId:     v.ID,
				MapHashId: v.HashID,
			}
			break
		}
	}

	win = &rollData{
		MarkType:  list[idx].MarkType,
		Step:      int32(idx),
		RewardId:  list[idx].RewardID,
		MapId:     list[idx].ID,
		MapHashId: list[idx].HashID,
	}

	// 预览用户直接返回结果
	if s.isView {
		return s._viewWin(run.CampaignID, win)
	}

	// 不是固定骰子，要看看走不走概率
	if !s._isFixedRoll() {
		confM := s.GetDao().FissionCampaignDice
		var conf *model.FissionCampaignDice
		conf, err = confM.WithContext(s.Ctx).Where(confM.CampaignID.Eq(run.CampaignID)).Take()
		if err = dbcheck.DbError(err); err != nil {
			err = s.BE().MysqlError(err)
			return
		}

		// 走概率发奖
		if conf.AwardType == mtype.FissionCampaignDiceAwardTypeOdds {

			winner, _ := lucky.NewDiscrete(s.Ctx, []lucky.Reward{
				{Share: int(conf.Odds), Mark: true},
				{Share: 1000 - int(conf.Odds), Mark: false},
			}).Lottery()

			// 赢不了
			if !winner.Bool() {
				return lose, nil
			}

			return s._odds(run, list, win, lose)
		}
	}

	// 如果都没中奖品，那就不用做奖品处理
	if !verify.InArray(win.MarkType, mtype.FissionDiceMapMarkTypeNormal, mtype.FissionDiceMapMarkTypeSuper) {
		return win, nil
	}

	res, err = s._reward(run, win, lose)
	if err != nil {
		return
	}

	return
}

func (s *Dice) _reward(run *model.FissionDiceRun, win, lose *rollData) (res *rollData, err error) {
	m := s.GetDao().FissionCampaignReward
	reward, err := m.WithContext(s.Ctx).Where(m.ID.Eq(win.RewardId)).Take()
	if err = dbcheck.DbError(err); err != nil {
		err = s.BE().MysqlError(err)
		return
	}

	if reward == nil || reward.IsDel == mtype.Yes {
		return lose, nil
	}

	collect, err := s._getCollect(run, reward)
	if err != nil {
		return
	}

	return s._rewardInDb(reward, collect, win, lose)
}

// 完整的奖品处理
func (s *Dice) _intactReward(cpn *model.FissionCampaign, reward *model.FissionCampaignReward, lack bool) (record *model.FissionRewardRecord, err error) {
	var opts []award.RecordOption
	if lack {
		opts = append(opts, award.RewardRecordStatus(
			mtype.FissionRewardRecordStatusFail,
			mtype.FissionRewardRecordFailTypeCli,
			mtype.FissionRewardRecordFailTypeCliLackMsg,
		))
	}

	record, _, async, err := award.NewAwardReward(s.Ctx, s.GetDao(), cpn.ProjectID, s.user).One(reward, false, opts...)
	if lack {
		return
	}

	s.AddAfterRun(func() (err error) {
		for _, do := range async {
			do()
		}
		return
	})

	return
}

// 概率获取奖品
func (s *Dice) _odds(run *model.FissionDiceRun, diceMaps []*model.FissionDiceMap, win *rollData, lose *rollData) (res *rollData, err error) {

	var rewardMap = make(map[int64]*model.FissionCampaignReward)
	var ids []int64
	var mapIdx = make(map[int]*model.FissionDiceMap)
	for idx, v := range diceMaps {
		if _, ok := rewardMap[v.RewardID]; !ok {
			ids = append(ids, v.RewardID)
			rewardMap[v.RewardID] = nil
		}
		mapIdx[idx] = v
	}

	if len(ids) == 0 {
		return win, nil
	}

	m := s.GetDao().FissionCampaignReward
	list, err := m.WithContext(s.Ctx).Where(m.ID.In(ids...)).Find()
	if err != nil {
		err = s.BE().MysqlError(err)
		return
	}

	var allOdds int
	var prize []lucky.Reward
	for _, v := range list {
		odds := int(v.Odds)
		prize = append(prize, lucky.Reward{
			Share: odds,
			Mark:  v.ID,
		})

		allOdds = allOdds + odds
		rewardMap[v.ID] = v
	}

	reward, err := lucky.NewDiscrete(s.Ctx, prize).Lottery()
	if err != nil {
		return
	}

	id := reward.Int64()

	// 概率中奖了，就走到那个中奖的格子
	for idx, diceMap := range mapIdx {
		if diceMap.RewardID == id {
			win = &rollData{
				MarkType:  diceMap.MarkType,
				Step:      int32(idx),
				RewardId:  diceMap.RewardID,
				MapId:     diceMap.ID,
				MapHashId: diceMap.HashID,
			}
			break
		}
	}

	collect, err := s._getCollect(run, rewardMap[id])
	if err != nil {
		return
	}

	return s._rewardInDb(rewardMap[id], collect, win, lose)
}

// 获取收集碎片的记录
func (s *Dice) _getCollect(run *model.FissionDiceRun, reward *model.FissionCampaignReward) (collect *model.FissionDiceCollect, err error) {
	collectM := s.GetDao().FissionDiceCollect
	collect, err = collectM.WithContext(s.Ctx).Where(collectM.UserID.Eq(run.UserID), collectM.RewardID.Eq(reward.ID)).Take()
	if err = dbcheck.DbError(err); err != nil {
		err = s.BE().MysqlError(err)
		return
	}

	if collect == nil {
		collect = withdefault.FissionDiceCollect(&model.FissionDiceCollect{
			UserID:     run.UserID,
			CampaignID: run.CampaignID,
			RewardID:   reward.ID,
			Num:        0,
			IntactNum:  0,
		})
		if err = collectM.WithContext(s.Ctx).Create(collect); err != nil {
			err = s.BE().MysqlError(err)
			return
		}
	}

	return
}

// 奖品入库
func (s *Dice) _rewardInDb(reward *model.FissionCampaignReward, collect *model.FissionDiceCollect, win, lose *rollData) (res *rollData, err error) {
	var intact bool
	var lack bool
	if reward.CollectNum == collect.Num+1 {

		//中奖了
		var check bool
		check, err = award.NewAwardIssVerify(s.Ctx, s.user, reward).DeductStock().RuleFilter().IsOK()
		if err != nil {
			return
		}

		if !check && s.Req.GetMark() != mtype.FissionDicePropMarkFixedRoll {
			return lose, nil
		}

		intact = true
		lack = !check
	}

	cpn, err := finder.Campaign(s.Ctx, reward.CampaignID)
	if err != nil {
		err = s.BE().CacheError(err)
		return
	}

	preward, err := provider.NewRewards(s.Ctx, cpn.ProjectID, reward.RewardID)
	if err != nil {
		return
	}

	info := preward.AutoLang(reward.RewardID, s.user.LangMark)

	collectM := s.GetDao().FissionDiceCollect
	var up []field.AssignExpr
	var record *model.FissionRewardRecord
	if intact {
		record, err = s._intactReward(cpn, reward, lack)
		if err != nil {
			return
		}

		if lack { // 没有库存，那就不让客户看动画了
			up = append(up, collectM.Num.Value(0), collectM.IntactNum.Add(1))

			s.AddAfterRun(func() (err error) {

				// 骰子记录
				var diceRecord = withdefault.FissionDiceRecord(&model.FissionDiceRecord{
					CreatedAt:  record.CreatedAt,
					CampaignID: record.CampaignID,
					UserID:     record.UserID,
					Mark:       mtype.FissionDiceRecordMarkReward,
					Data:       "",
				})

				diceRecord.SetData(&mtype.DiceRecord{
					RewardId: record.RewardID,
					RecordId: record.ID,
				})

				// 这里事务已经提交了，不能用有事务的dao
				err = s.Dao().FissionDiceRecord.WithContext(s.Ctx).Create(diceRecord)
				if err != nil {
					err = s.BE().MysqlError(err)
					return
				}
				return
			})

		} else { // 有库存，让用户看到合成动画
			up = append(up, collectM.Num.Add(1), collectM.RecordID.Value(record.ID))
		}

	} else { // 没有收集完碎片，碎片数 +1
		up = append(up, collectM.Num.Add(1))
	}

	_, err = collectM.WithContext(s.Ctx).Where(collectM.ID.Eq(collect.ID)).UpdateSimple(up...)
	if err != nil {
		err = s.BE().MysqlError(err)
		return
	}

	win.RewardTitle = info.Title
	win.ImgUrl = info.ImgUrl
	win.Intact = intact
	win.Lack = lack

	return win, nil
}

// 预览用户返回的数据
func (s *Dice) _viewWin(cpnId int64, rd *rollData) (win *rollData, err error) {
	win = rd

	if win.RewardId == 0 {
		return
	}

	cpn, err := finder.Campaign(s.Ctx, cpnId)
	if err != nil {
		err = s.BE().CacheError(err)
		return
	}

	m := s.GetDao().FissionCampaignReward
	reward, err := m.WithContext(s.Ctx).Where(m.ID.Eq(win.RewardId)).Take()
	if err = dbcheck.DbError(err); err != nil {
		err = s.BE().MysqlError(err)
		return
	}

	preward, err := provider.NewRewards(s.Ctx, cpn.ProjectID, reward.RewardID)
	if err != nil {
		return
	}

	info := preward.AutoLang(reward.RewardID, s.user.LangMark)

	win.RewardTitle = info.Title
	win.ImgUrl = info.ImgUrl

	return
}

// 加骰子记录
func (s *Dice) _diceRecord(player *model.FissionDice, win *rollData, luckyProp bool) (err error) {
	if s.Res.FailType != campaignUserDiceFailTypeNone {
		return
	}

	record := withdefault.FissionDiceRecord(&model.FissionDiceRecord{
		CampaignID: player.CampaignID,
		UserID:     player.UserID,
	})

	data := &mtype.DiceRecord{
		Point:    win.Step + 1,
		RewardId: win.RewardId,
	}

	defer func() {
		err = s.GetDao().FissionDiceRecord.WithContext(s.Ctx).Create(record)
		if err != nil {
			err = s.BE().MysqlError(err)
		}
	}()

	// 使用幸运骰子道具
	if luckyProp {

		switch win.MarkType {
		case mtype.FissionDiceMapMarkTypeNone:
			record.Mark = mtype.FissionDiceRecordMarkLucky
		case mtype.FissionDiceMapMarkTypeChance:
			record.Mark = mtype.FissionDiceRecordMarkLuckyChance
			data.Chance = 1
		default:
			record.Mark = mtype.FissionDiceRecordMarkLuckyCollect
		}

		record.SetData(data)

		return
	}

	switch win.MarkType {
	case mtype.FissionDiceMapMarkTypeNone:
		record.Mark = mtype.FissionDiceRecordMarkRoll
	case mtype.FissionDiceMapMarkTypeChance:
		record.Mark = mtype.FissionDiceRecordMarkRollChance
		data.Chance = 1
	default:
		record.Mark = mtype.FissionDiceRecordMarkRollCollect
	}

	record.SetData(data)

	return
}

// 是否固定骰子
func (s *Dice) _isFixedRoll() bool {
	return s.Req.GetMark() == mtype.FissionDicePropMarkFixedRoll
}