package model

import (
	"rocommon/service"
	"rocommon/util"
	"roserver/baseserver/model"
	"roserver/serverproto"
)

const (
	DrawType_Card       = 1
	DrawType_Pet        = 2
	DrawType_SkillEquip = 3
	DrawType_EggsGold    = 4 // 金蛋
	DrawType_EggsSpecial = 5 // 彩蛋

	DrawPetEnableLimitNum        = 400
	DrawCardEnableLimitNum       = 400
	DrawSkillEquipEnableLimitNum = 400
)

const (
	Draw_Count_One  = 1
	Draw_Count_Five = 5
	Draw_Count_Ten  = 10
)

type RoleDraw struct {
	SaveObject

	DrawSystem map[int32]*serverproto.DrawData

	totalCardDrawNum       int32
	totalPetDrawNum        int32
	totalSkillEquipDrawNum int32
}

func newRoleDraw(r *Role) *RoleDraw {
	roleCommon := &RoleDraw{
		SaveObject: SaveObject{
			role: r,
		},
	}
	roleCommon.DrawSystem = map[int32]*serverproto.DrawData{}

	return roleCommon
}

func (this *RoleDraw) Load(msg interface{}) bool {
	proRole := msg.(*serverproto.Role)
	if proRole != nil && proRole.RoleDraw != nil {
		for _, data := range proRole.RoleDraw.DrawSystem {
			this.DrawSystem[data.DrawType] = data
		}
		this.totalPetDrawNum = proRole.RoleDraw.PetDrawTotalNum
		this.totalCardDrawNum = proRole.RoleDraw.CardDrawTotalNum
		this.totalSkillEquipDrawNum = proRole.RoleDraw.SkillEquipDrawTotalNum
	}

	return true
}

func (this *RoleDraw) Save() {
	this.SetDirty(false)
	util.DebugF("uid=%v RoleDraw save...", this.role.GetUUid())

	saveMsg := &serverproto.SSRoleDrawDataSaveReq{
		RoleDraw: &serverproto.RoleDraw{
			PetDrawTotalNum:        this.totalPetDrawNum,
			CardDrawTotalNum:       this.totalCardDrawNum,
			SkillEquipDrawTotalNum: this.totalSkillEquipDrawNum,
		},
	}
	for _, data := range this.DrawSystem {
		saveMsg.RoleDraw.DrawSystem = append(saveMsg.RoleDraw.DrawSystem, data)
	}
	this.role.SendDb(saveMsg)
}

func (this *RoleDraw) CopyData(draw *serverproto.RoleDraw) {
	for _, data := range this.DrawSystem {
		draw.DrawSystem = append(draw.DrawSystem, data)
	}
}

func (this *RoleDraw) CheckIsNew(drawType int32, itemId int32) bool {
	if drawType == DrawType_Card {
		return this.role.GetRoleCard().CheckNewCard(itemId)
	} else if drawType == DrawType_Pet {
		return this.role.GetRolePet().CheckNewPet(itemId)
	}

	return false
}

func (this *RoleDraw) GetDrawItem(drawType *model.SummonCostByServerTime, isUseGold bool, addItemList map[int32]int32, ackMsg *serverproto.SCDrawCardAck) int32 {
	resType := model.Draw_ResType_Item
	if isUseGold == true {
		resType = model.Draw_ResType_Gold
	}
	//调用接口。找到一个随机Item
	drawTemplate := model.GetDrawProbItem(drawType.Id, int32(resType))
	if drawTemplate == nil {
		return 0
	}
	//根据Item随机道具
	ntfItemList := map[int32]*serverproto.KeyValueType{}
	var index int32 = 0
	for _, data := range drawTemplate.DrawItem {
		itemList := map[int32]int32{}
		for i := 0; i < int(data.Key); i++ {
			this.role.GetRoleBattle().DropProcess(itemList, int32(data.Value))
			for key, value := range itemList {
				addItemList[key] += value

				index++
				ntfItemList[index] = &serverproto.KeyValueType{
					Key:   key,
					Value: value,
				}
			}
			itemList = make(map[int32]int32)
		}
	}
	for _, data := range ntfItemList {
		ackMsg.ItemList = append(ackMsg.ItemList, &serverproto.DrawItem{
			ItemId:  data.Key,
			ItemNum: data.Value,
			IsNew:   this.CheckIsNew(drawType.SummonType, data.Key),
		})
	}
	//选择的概率ID
	util.InfoF("uid=%v RoleDraw draw configId=%v drawType=%v, resType=%v", this.role.GetUUid(), drawTemplate.ConfigId, drawType, resType)
	return drawTemplate.ExtraPoint
}

func (this *RoleDraw) DrawReq(drawType int32, drawCount int32, ackMsg *serverproto.SCDrawCardAck) serverproto.ErrorCode {
	//判定配置
	////drawCfg, ok := serverproto.SummonCfgLoader[drawType]
	//if !ok {
	//	return serverproto.ErrorCode_ERROR_DRAWSYSTEM_CONFIG_NOT_FOUND
	//}
	costData, ok2 := model.ConvertSummonList[drawType]
	if !ok2 {
		return serverproto.ErrorCode_ERROR_DRAWSYSTEM_CONFIG_NOT_FOUND
	}
	//判定是否存在抽取次数
	_, ok3 := costData.DrawCount[drawCount]
	if !ok3 {
		return serverproto.ErrorCode_ERROR_DRAWSYSTEM_DRAW_COUNT
	}

	//1.检查道具是否足够，检查方式：优先用道具，道具不够金币补足，金币不够拉倒
	var itemNum int32 = 0
	var goldNum int32 = 0
	isUseGold := false
	curItemNum := uint32(this.role.GetResNum(costData.ItemId))
	if costData.ItemId > 0 && curItemNum >= uint32(costData.ItemNum*drawCount) {
		itemNum = costData.ItemNum * drawCount
	} else {
		itemNum = int32(curItemNum)
		goldNum = (drawCount - itemNum) * costData.SourceNum

		curSourceNum := this.role.GetRmb()
		if curSourceNum < uint32(goldNum) || goldNum <= 0 {
			return serverproto.ErrorCode_ERROR_DRAWSYSTEM_RES_NOT_ENOUGH
		}
		isUseGold = true
	}

	if checkCode := this.CheckDrawEnable(costData.SummonType); checkCode != serverproto.ErrorCode_ERROR_OK {
		return checkCode
	}

	//根据开服天数获取召唤数据(活动召唤无效)
	startUpTime := service.GetServiceStartupTime()
	curDiffDay := util.GetDurationDay2(startUpTime, util.GetTimeMilliseconds())
	drawCfg := costData.GetDataByDiffDay(curDiffDay)
	if drawCfg == nil {
		return serverproto.ErrorCode_ERROR_DRAWSYSTEM_CONFIG_NOT_FOUND
	}

	totalItemList := make(map[int32]int32)
	extraPoint := int32(Draw_Count_One)
	if drawCount == Draw_Count_One {
		if isUseGold == true {
			this.role.GetRoleBattle().DropProcess(totalItemList, int32(drawCfg.DropId2))
		} else {
			this.role.GetRoleBattle().DropProcess(totalItemList, int32(drawCfg.DropId))
		}
		if len(totalItemList) > 0 {
			for key, num := range totalItemList {
				ackMsg.ItemList = append(ackMsg.ItemList, &serverproto.DrawItem{
					ItemId:  int32(key),
					ItemNum: int32(num),
					IsNew:   this.CheckIsNew(drawType, key),
				})
			}
		}
	} else if drawCount == Draw_Count_Five || drawCount == Draw_Count_Ten {
		extraPoint = this.GetDrawItem(drawCfg, isUseGold, totalItemList, ackMsg)
	}
	if len(totalItemList) <= 0 {
		return serverproto.ErrorCode_ERROR_DRAWSYSTEM_CONFIG_NOT_FOUND
	}

	//累积抽取次数
	_, ok1 := this.DrawSystem[drawType]
	if !ok1 {
		this.DrawSystem[drawType] = &serverproto.DrawData{
			DrawType:  drawType,
			DrawTimes: extraPoint,
		}
	} else {
		this.DrawSystem[drawType].DrawTimes += extraPoint
	}
	//如果次数>=配置次数，给累计奖励
	var bSuperUnlockRechargeDropId int32 = 0
	if this.DrawSystem[drawType].DrawTimes >= costData.Total {
		var exItemList = map[int32]int32{}
		this.role.GetRoleBattle().DropProcess(exItemList, int32(drawCfg.ExtDropId))
		if len(exItemList) > 0 {
			for key, value := range exItemList {
				if key > 0 && value > 0 {
					ackMsg.ExtraItem = append(ackMsg.ExtraItem, &serverproto.DrawItem{
						ItemId:  key,
						ItemNum: value,
						IsNew:   this.CheckIsNew(drawType, key),
					})

					totalItemList[key] += value
				}
			}
		}
		//扣除一次累计奖励需要的累计次数
		this.DrawSystem[drawType].DrawTimes -= costData.Total
		bSuperUnlockRechargeDropId = drawCfg.ExtDropId
	}
	bRet := this.role.GetRoleBag().CanAddItemList(totalItemList)
	if bRet == serverproto.ErrorCode_ERROR_OK {
		//先扣除消耗
		removeItemList := make(map[int32]int32)
		if itemNum > 0 {
			removeItemList[costData.ItemId] = itemNum
		}
		if goldNum > 0 {
			removeItemList[costData.SourceId] = goldNum
		}

		if drawType == DrawType_Card {
			this.role.GetRoleBag().DelItemList(removeItemList, AddItemST{AddFrom: AddFrom_DrawCard})
			//添加卡片
			this.role.AddItemList(totalItemList, AddFrom_DrawCard, true)

			this.totalCardDrawNum += drawCount
			TaskMagCheck(this.role, serverproto.TaskType_Draw_Card_Num, 0)
			TaskMagCheck(this.role, serverproto.TaskType_Eve_Card_Num, drawCount)
			if bSuperUnlockRechargeDropId > 0 {
				this.role.roleActivity.SuperChargeUnlockCheck(serverproto.UnlockChargeType_UChargeType_DrawCardSpecial,
					&SuperChargeUnlockST{oldValue: bSuperUnlockRechargeDropId})
			}
		} else if drawType == DrawType_Pet {
			this.role.GetRoleBag().DelItemList(removeItemList, AddItemST{AddFrom: AddFrom_DrawPet})
			//添加卡片
			this.role.AddItemList(totalItemList, AddFrom_DrawPet, true)

			this.totalPetDrawNum += drawCount
			TaskMagCheck(this.role, serverproto.TaskType_Draw_Pet_Num, 0)
			TaskMagCheck(this.role, serverproto.TaskType_Eve_Pet_Num, drawCount)
			if bSuperUnlockRechargeDropId > 0 {
				this.role.roleActivity.SuperChargeUnlockCheck(serverproto.UnlockChargeType_UChargeType_DrawPetSpecial,
					&SuperChargeUnlockST{oldValue: bSuperUnlockRechargeDropId})
			}
		} else if drawType == DrawType_SkillEquip {
			this.role.GetRoleBag().DelItemList(removeItemList, AddItemST{AddFrom: AddFrom_DrawSkillEquip})
			this.role.AddItemList(totalItemList, AddFrom_DrawSkillEquip, true)
			this.totalSkillEquipDrawNum += drawCount

			//TaskMagCheck(this.role, serverproto.TaskType_Draw_Pet_Num, 0)
			//this.role.GetRoleActivity().TaskCheck(serverproto.TaskType_Eve_Pet_Num, drawCount)
			if bSuperUnlockRechargeDropId > 0 {
				this.role.roleActivity.SuperChargeUnlockCheck(serverproto.UnlockChargeType_UChargeType_DrawSkillEquipSpecial,
					&SuperChargeUnlockST{oldValue: bSuperUnlockRechargeDropId})
			}
		} else {
			//活动召唤
			if costData.ActivitiesId > 0 {
				this.role.GetRoleBag().DelItemList(removeItemList, AddItemST{AddFrom: AddFrom_ActivitySummon})

				if costData.SummonType == DrawType_EggsGold {
					this.role.AddItemList(totalItemList, AddFrom_ActivitySmashEggs, true)
				} else if costData.SummonType == DrawType_EggsSpecial {
					this.role.AddItemList(totalItemList, AddFrom_ActivitySmashEggsSpeical, true)
				} else {
					this.role.AddItemList(totalItemList, AddFrom_ActivitySummon, true)
				}
				//召唤类型
				switch costData.SummonType {
				case DrawType_Card:
					this.totalCardDrawNum += drawCount
					TaskMagCheck(this.role, serverproto.TaskType_Draw_Card_Num, 0)
					TaskMagCheck(this.role, serverproto.TaskType_Eve_Card_Num, drawCount)
				case DrawType_Pet:
					this.totalPetDrawNum += drawCount
					TaskMagCheck(this.role, serverproto.TaskType_Draw_Pet_Num, 0)
					TaskMagCheck(this.role, serverproto.TaskType_Eve_Pet_Num, drawCount)
				case DrawType_SkillEquip:
				}
			}
		}
		this.OnDrawEnd(drawType, totalItemList)
	} else {
		//如果道具没有加进去。则扣除
		this.DrawSystem[drawType].DrawTimes -= drawCount
		ackMsg.ItemList = append(ackMsg.ItemList[0:0])
		ackMsg.ExtraItem = append(ackMsg.ExtraItem[0:0])
		if bRet == serverproto.ErrorCode_ERROR_BAG_FULL {
			if drawType == DrawType_Card {
				return serverproto.ErrorCode_ERROR_DRAWSYSTEM_CARD_BAG_FULL
			} else if drawType == DrawType_Pet {
				return serverproto.ErrorCode_ERROR_DRAWSYSTEM_PET_BAG_FULL
			}
		} else {
			return bRet
		}
	}

	ackMsg.AddPoint = extraPoint
	ackMsg.DrawCount = drawCount
	ackMsg.DrawTimes = this.DrawSystem[drawType].DrawTimes

	this.SetDirty(true)
	return serverproto.ErrorCode_ERROR_OK
}

func (this *RoleDraw) OnDrawEnd(drawType int32, rewardList map[int32]int32) {
	if drawType == DrawType_Card {
		for key, _ := range rewardList {
			itemCfg, ok := serverproto.ItemCfgLoader[key]
			if !ok {
				continue
			}
			if itemCfg.ResType == int32(serverproto.ResType_Res_Card) {
				cardCfg, ok2 := serverproto.CardCfgLoader[key]
				if !ok2 {
					continue
				}
				if cardCfg.CardType == model.Card_Type_MVP {
					this.role.GetRoleActivity().SuperChargeUnlockCheck(
						serverproto.UnlockChargeType_UChargeType_DrawCardMVP, &SuperChargeUnlockST{oldValue: key})
				}
			}
		}
		this.role.GetRoleActivity().SuperChargeUnlockCheck(
			serverproto.UnlockChargeType_UChargeType_DrawCardQualityNum, &SuperChargeUnlockST{rewardCardList: rewardList})
	} else if drawType == DrawType_Pet {
		for key, _ := range rewardList {
			itemCfg, ok := serverproto.ItemCfgLoader[key]
			if !ok {
				continue
			}
			if itemCfg.ResType == int32(serverproto.ResType_Res_Pet) {
				cardCfg, ok2 := serverproto.PetCfgLoader[key]
				if !ok2 {
					continue
				}
				if cardCfg.Quality == model.Card_Type_MVP {
					this.role.GetRoleActivity().SuperChargeUnlockCheck(
						serverproto.UnlockChargeType_UChargeType_DrawPetMVP, &SuperChargeUnlockST{oldValue: key})
				}
			}
		}
	} else {
		for key, _ := range rewardList {
			itemCfg, ok := serverproto.ItemCfgLoader[key]
			if !ok {
				continue
			}
			if itemCfg.ResType == int32(serverproto.ResType_Res_Pet) {
				cardCfg, ok2 := serverproto.PetCfgLoader[key]
				if !ok2 {
					continue
				}
				if cardCfg.Quality == model.Card_Type_MVP {
					this.role.GetRoleActivity().SuperChargeUnlockCheck(
						serverproto.UnlockChargeType_UChargeType_DrawPetMVP, &SuperChargeUnlockST{oldValue: key})
				}
			} else if itemCfg.ResType == int32(serverproto.ResType_Res_Card) {
				cardCfg, ok2 := serverproto.CardCfgLoader[key]
				if !ok2 {
					continue
				}
				if cardCfg.CardType == model.Card_Type_MVP {
					this.role.GetRoleActivity().SuperChargeUnlockCheck(
						serverproto.UnlockChargeType_UChargeType_DrawCardMVP, &SuperChargeUnlockST{oldValue: key})
				}
			}
		}
	}
}

func (this *RoleDraw) GetDrawCardNum() int32 {
	return this.totalCardDrawNum
}
func (this *RoleDraw) GetDrawPetNum() int32 {
	return this.totalPetDrawNum
}

//召唤限制,背包最大数量超过上限(格子数量)时，需要减少数量，否则不允许进行召唤操作,
func (this *RoleDraw) CheckDrawEnable(drawType int32) serverproto.ErrorCode {
	switch drawType {
	case DrawType_Pet:
		if this.role.GetRolePet().GetPetePileTotalNum() >= DrawPetEnableLimitNum {
			return serverproto.ErrorCode_ERROR_DAWSYSTEM_PET_FULL
		}
	case DrawType_Card:
		if this.role.GetRoleCard().GetCardPileTotalNum() >= DrawCardEnableLimitNum {
			return serverproto.ErrorCode_ERROR_DAWSYSTEM_CARD_FULL
		}
	case DrawType_SkillEquip:
		if this.role.GetRoleSkillEquip().GetSkillEquipPileTotalNum() >= DrawSkillEquipEnableLimitNum {
			return serverproto.ErrorCode_ERROR_DAWSYSTEM_SKILLEQUIP_FULL
		}
	}
	return serverproto.ErrorCode_ERROR_OK
}