package main

import (
	"mongo.games.com/game/common"
	"mongo.games.com/game/model"
	"mongo.games.com/game/protocol/gamehall"
	"mongo.games.com/game/protocol/pets"
	"mongo.games.com/game/srvdata"
)

const (
	ItemObtain  = iota //得到
	ItemConsume        //消耗
)

var ModelMgrSingleton = &ModelMgr{}

type ModelMgr struct {
	//RPInfos map[int32]*RoleAndPetInfo
}

type RoleAndPetInfo struct {
	ModId      int32  //模型id
	Name       string //名字
	Story      string //人物背景介绍
	AwardTitle string //奖励标题
	MaxLevel   int32  //最大等级
}

// 人物

func (this *ModelMgr) GetRoleInfos(p *Player) []*pets.RoleInfo {
	rolesInfo := srvdata.RolePetMgrSington.Roles
	if rolesInfo != nil {
		var newRoles = make([]*pets.RoleInfo, 0)
		for roleId, roles := range rolesInfo {
			level := p.Roles.ModUnlock[roleId]
			if len(roles) >= int(level) {
				rol := roles[level]
				role := &pets.RoleInfo{
					Id:        rol.Id,
					RoleId:    rol.RoleId,
					Name:      rol.Name,
					Grade:     rol.Grade,
					Level:     rol.Level,
					Fragment:  rol.Fragment,
					Amount:    rol.Amount,
					AwardType: rol.AwardType,
					Award:     rol.Award,
					AwardRate: rol.AwardRate,
				}
				if level > 0 {
					role.IsUnlock = true
					if p.Roles.ModId == roleId {
						role.IsUsing = true
					}
				}

				if level == 0 {
					role.NextAward = roles[1].Award
				} else {
					if int32(len(roles)) > level+1 {
						role.NextAward = roles[level+1].Award
					}
				}

				roleOther := this.GetIntroductionByModId(role.RoleId)
				role.MaxLevel = roleOther.MaxLevel
				role.Name = roleOther.Name
				role.Story = roleOther.Story
				role.AwardTitle = roleOther.AwardTitle
				///
				item := BagMgrSingleton.GetItem(p.SnId, role.Fragment)
				if item != nil {
					role.HaveAmount = int32(item.ItemNum)
				}
				newRoles = append(newRoles, role)
			}
		}
		return newRoles
	}
	return nil
}

func (this *ModelMgr) GetRoleInfo(p *Player, modId int32) *pets.RoleInfo {
	level := p.Roles.ModUnlock[modId]
	roleInfo := srvdata.RolePetMgrSington.GetRoleByRoleIdAndLevel(modId, level)
	if roleInfo != nil {
		role := &pets.RoleInfo{
			Id:        roleInfo.Id,
			RoleId:    roleInfo.RoleId,
			Name:      roleInfo.Name,
			Grade:     roleInfo.Grade,
			Level:     roleInfo.Level,
			Fragment:  roleInfo.Fragment,
			Amount:    roleInfo.Amount,
			AwardType: roleInfo.AwardType,
			Award:     roleInfo.Award,
			AwardRate: roleInfo.AwardRate,
		}
		if level > 0 {
			role.IsUnlock = true
			if p.Roles.ModId == roleInfo.RoleId {
				role.IsUsing = true
			}
		}
		nextInfo := srvdata.RolePetMgrSington.GetRoleByRoleIdAndLevel(modId, level+1)
		if nextInfo != nil {
			role.NextAward = nextInfo.Award
		}
		roleOther := this.GetIntroductionByModId(modId)
		role.MaxLevel = roleOther.MaxLevel
		role.Name = roleOther.Name
		role.Story = roleOther.Story
		role.AwardTitle = roleOther.AwardTitle
		//
		item := BagMgrSingleton.GetItem(p.SnId, role.Fragment)
		if item != nil {
			role.HaveAmount = int32(item.ItemNum)
		}
		return role
	}
	return nil
}

// 宠物

func (this *ModelMgr) GetPetInfos(p *Player) []*pets.PetInfo {
	petsInfo := srvdata.RolePetMgrSington.Pets
	if petsInfo != nil {
		var newPets = make([]*pets.PetInfo, 0)
		for petId, petInfo := range petsInfo {
			level := p.Pets.ModUnlock[petId]
			if len(petInfo) >= int(level) {
				pet := petInfo[level]
				newPet := &pets.PetInfo{
					Id:        pet.Id,
					PetId:     pet.PetId,
					Name:      pet.Name,
					Grade:     pet.Grade,
					Level:     pet.Level,
					Fragment:  pet.Fragment,
					Amount:    pet.Amount,
					AwardType: pet.AwardType,
					Award:     pet.Award,
					AwardRate: pet.AwardRate,
				}
				if level > 0 {
					newPet.IsUnlock = true
					if p.Pets.ModId == petId {
						newPet.IsUsing = true
					}
				}

				if level == 0 {
					newPet.NextAward = petInfo[1].Award
				} else {
					if int32(len(petInfo)) > level+1 {
						newPet.NextAward = petInfo[level+1].Award
					}
				}

				petOther := this.GetIntroductionByModId(newPet.PetId)
				newPet.MaxLevel = petOther.MaxLevel
				newPet.Name = petOther.Name
				newPet.Story = petOther.Story
				newPet.AwardTitle = petOther.AwardTitle
				///
				item := BagMgrSingleton.GetItem(p.SnId, newPet.Fragment)
				if item != nil {
					newPet.HaveAmount = int32(item.ItemNum)
				}
				//技能
				if p.Pets.SkillInfo != nil && p.Pets.SkillInfo[petId] != nil {
					skillInfo := p.Pets.SkillInfo[petId]
					for skillId, skillLevel := range skillInfo {
						info := &pets.PetSkillInfo{}
						info.SkillId = skillId
						info.SkillLevel = skillLevel
						newPet.SkillInfo = append(newPet.SkillInfo, info)
					}

				}
				newPets = append(newPets, newPet)
			}
		}
		return newPets
	}
	return nil
}

func (this *ModelMgr) GetPetInfo(p *Player, modId int32) *pets.PetInfo {
	level := p.Pets.ModUnlock[modId]
	petInfo := srvdata.RolePetMgrSington.GetPetByPetIdAndLevel(modId, level)
	if petInfo != nil {
		newPet := &pets.PetInfo{
			Id:        petInfo.Id,
			PetId:     petInfo.PetId,
			Name:      petInfo.Name,
			Grade:     petInfo.Grade,
			Level:     petInfo.Level,
			Fragment:  petInfo.Fragment,
			Amount:    petInfo.Amount,
			AwardType: petInfo.AwardType,
			Award:     petInfo.Award,
			AwardRate: petInfo.AwardRate,
		}
		if level > 0 {
			newPet.IsUnlock = true
			if p.Roles.ModId == petInfo.PetId {
				newPet.IsUsing = true
			}
		}
		nextInfo := srvdata.RolePetMgrSington.GetPetByPetIdAndLevel(modId, level+1)
		if nextInfo != nil {
			newPet.NextAward = nextInfo.Award
		}
		petOther := this.GetIntroductionByModId(modId)
		newPet.MaxLevel = petOther.MaxLevel
		newPet.Name = petOther.Name
		newPet.Story = petOther.Story
		newPet.AwardTitle = petOther.AwardTitle
		//
		item := BagMgrSingleton.GetItem(p.SnId, newPet.Fragment)
		if item != nil {
			newPet.HaveAmount = int32(item.ItemNum)
		}
		//技能
		if p.Pets.SkillInfo != nil && p.Pets.SkillInfo[modId] != nil {
			skillInfo := p.Pets.SkillInfo[modId]
			for skillId, skillLevel := range skillInfo {
				info := &pets.PetSkillInfo{}
				info.SkillId = skillId
				info.SkillLevel = skillLevel
				newPet.SkillInfo = append(newPet.SkillInfo, info)
			}
		}
		return newPet
	}
	return nil
}

// 皮肤

func (this *ModelMgr) GetSkinInfos(p *Player) []*pets.SkinInfo {
	var ret []*pets.SkinInfo
	for _, v := range PlatformMgrSingleton.GetConfig(p.Platform).SkinConfig.GetItems() {
		ret = append(ret, this.GetSkinInfo(p, v.GetId()))
	}
	return ret
}

func (this *ModelMgr) GetSkinInfo(p *Player, id int32) *pets.SkinInfo {
	cfg := PlatformMgrSingleton.GetSkinInfo(p.Platform, id)
	if cfg == nil {
		return nil
	}

	bag := BagMgrSingleton.GetBagInfo(p.SnId)
	level := p.Skin.ModUnlock[id]
	var unLockCost, cost, have []*pets.Item
	var needVip int32
	for k, v := range cfg.GetUnlockParam() {
		unLockCost = append(unLockCost, &pets.Item{
			Id: k,
			N:  v,
		})
		needVip = k
	}
	if level == 0 {
		cost = unLockCost
		if cfg.GetUnlockType() == common.SkinGetVip {
			cost = cost[:0]
		}
	} else {
		for k, v := range PlatformMgrSingleton.GetSkinLevel(p.Platform, id, level+1).GetUpItem() {
			cost = append(cost, &pets.Item{
				Id: k,
				N:  v,
			})
		}
	}
	for _, v := range cost {
		if bag != nil {
			info := bag.BagItem[v.GetId()]
			if info != nil {
				have = append(have, &pets.Item{
					Id: v.GetId(),
					N:  info.ItemNum,
				})
			}
		}
	}

	unLock := level > 0
	use := unLock && p.Skin.ModId == id

	ret := &pets.SkinInfo{
		Id:         id,
		Level:      level,
		MaxLevel:   PlatformMgrSingleton.GetSkinMaxLevel(p.Platform, id),
		Cost:       cost,
		Have:       have,
		IsUsing:    use,
		IsUnlock:   unLock,
		IsUpgrade:  cfg.GetIsUpgrade() == 1,
		SkillType:  cfg.GetSkillType(),
		UnLockType: cfg.GetUnlockType(),
	}
	if cfg.GetUnlockType() == common.SkinGetVip {
		ret.NeedVip = needVip
	}
	curLevel := PlatformMgrSingleton.GetSkinLevel(p.Platform, id, level)
	nextLevel := PlatformMgrSingleton.GetSkinLevel(p.Platform, id, level+1)
	if curLevel != nil {
		ret.SkillId = curLevel.GetSkillId()
	}
	if nextLevel != nil {
		ret.SkillId = nextLevel.GetSkillId()
	}
	if curLevel != nil {
		ret.SkillLevel = curLevel.GetSkillLevel()
		ret.SkillValue = curLevel.GetSkillValue()
	}
	ret.SkillMaxLevel = PlatformMgrSingleton.GetSkinSkillMaxLevel(p.Platform, id)
	if nextLevel != nil {
		ret.SkillNextLevel = nextLevel.GetSkillLevel()
		ret.SkillNextValue = nextLevel.GetSkillValue()
	}

	return ret
}

// CheckSkinRed 皮肤红点
func (this *ModelMgr) CheckSkinRed(p *Player) {
	if p == nil || p.IsRob {
		return
	}
	for _, v := range PlatformMgrSingleton.GetConfig(p.Platform).SkinConfig.GetItems() {
		if v == nil {
			continue
		}
		info := this.GetSkinInfo(p, v.Id)
		// 解锁
		if !info.GetIsUnlock() {
			ok := true
			for _, v := range info.GetCost() {
				item := BagMgrSingleton.GetItem(p.SnId, v.GetId())
				if item == nil || item.ItemNum < v.GetN() {
					ok = false
					break
				}
			}
			if ok && len(info.GetCost()) > 0 {
				p.SendShowRed(gamehall.ShowRedCode_Skin, v.Id, 1)
				continue
			}
			// vip等级解锁
			if info.GetUnLockType() == common.SkinGetVip && p.VIP >= info.GetNeedVip() {
				p.SendShowRed(gamehall.ShowRedCode_Skin, v.Id, 1)
				continue
			}
		}
		// 升级
		if info.GetIsUnlock() && info.GetLevel() < info.GetMaxLevel() && info.GetIsUpgrade() {
			ok := true
			for _, v := range info.GetCost() {
				item := BagMgrSingleton.GetItem(p.SnId, v.GetId())
				if item == nil || item.ItemNum < v.GetN() {
					ok = false
					break
				}
			}
			if ok && len(info.GetCost()) > 0 {
				p.SendShowRed(gamehall.ShowRedCode_Skin, v.Id, 1)
				continue
			}
		}
	}
}

// GetShopAward 角色加成
// 商品人物加成,角色id 人物功能变动需要修改
func (this *ModelMgr) GetShopAward(shopInfo *model.ShopInfo, p *Player) (award, roleId int32) {
	if shopInfo.Ad > 0 && shopInfo.Type == ShopTypeCoin {
		id, add := srvdata.RolePetMgrSington.GetRoleAdd(p.PlayerData, common.RoleAddADV)
		award += add
		roleId = id
	}

	if shopInfo.Ad == 0 && shopInfo.Type == ShopTypeCoin {
		id, add := srvdata.RolePetMgrSington.GetRoleAdd(p.PlayerData, common.RoleAddCoin)
		award += add
		roleId = id
	}

	//VIP商城没有人物加成
	if shopInfo.Page == ShopPageVip || shopInfo.Page == ShopPagePhoneScore || shopInfo.Page == ShopPagePhoneScoreGoogle {
		award = 0
	}
	return award, roleId
}

// GetAwardPetByWelf 宠物加成
// 宠物加成  宠物功能变动需要修改
func (this *ModelMgr) GetAwardPetByWelf(p *Player) (award int64) {
	petChick := this.GetPetInfo(p, 1000001)
	if petChick != nil && petChick.Level > 0 {
		award = int64(petChick.Award)
	}
	return
}

// GetIntroductionByModId 模型介绍
func (this *ModelMgr) GetIntroductionByModId(modId int32) *RoleAndPetInfo {
	mod := srvdata.PBDB_Game_IntroductionMgr.GetData(modId)
	if mod == nil {
		return &RoleAndPetInfo{}
	}
	return &RoleAndPetInfo{
		ModId:      mod.Id,
		Name:       mod.Name,
		Story:      mod.Story,
		AwardTitle: mod.AwardTitle,
		MaxLevel:   mod.LevelMax,
	}
}

// CheckShowRed 检查红点
// 人物，宠物，宠物技能
func (this *ModelMgr) CheckShowRed(p *Player) {
	if p == nil || p.IsRob {
		return
	}
	var roleRed, petRed bool
	if p.Roles != nil {
		needAmount := make(map[int32]int32)
		for roleId, rol := range srvdata.RolePetMgrSington.Roles {
			if level, ok := p.Roles.ModUnlock[roleId]; ok {
				needAmount[rol[level].Fragment] = rol[level].Amount
			} else {
				needAmount[rol[level].Fragment] = rol[level].Amount
			}
		}
		for fragment, amount := range needAmount {
			item := BagMgrSingleton.GetItem(p.SnId, fragment)
			if item != nil && item.ItemNum >= int64(amount) && amount != 0 {
				roleRed = true
				break
			}
		}
	}
	if p.Pets != nil {
		needAmount := make(map[int32]int32)
		for petId, pet := range srvdata.RolePetMgrSington.Pets {
			if level, ok := p.Pets.ModUnlock[petId]; ok {
				needAmount[pet[level].Fragment] = pet[level].Amount
			} else {
				needAmount[pet[level].Fragment] = pet[level].Amount
			}
		}
		for fragment, amount := range needAmount {
			item := BagMgrSingleton.GetItem(p.SnId, fragment)
			if item != nil && item.ItemNum >= int64(amount) && amount != 0 {
				petRed = true
				break
			}
		}
		//宠物技能红点
		if !petRed {
			for _, SkillInfo := range srvdata.PBDB_PetSkillMgr.Datas.GetArr() {
				if p.Pets.SkillInfo[SkillInfo.PetId] != nil {
					for skillId, skilllevel := range p.Pets.SkillInfo[SkillInfo.PetId] {
						if SkillInfo.SkillId == skillId && SkillInfo.SkillLevel == skilllevel+1 {
							//获取物品数量
							status := true
							for itemId, itemNum := range SkillInfo.ItemConsum {
								item := BagMgrSingleton.GetItem(p.SnId, int32(itemId))
								if item != nil {
									if item.ItemNum < itemNum {
										status = false
										break
									}
								} else {
									status = false
									break
								}
							}
							if status {
								petRed = true
								break
							}
						}
					}
					if petRed {
						break
					}
				} else {
					//获取物品数量
					status := true
					for itemId, itemNum := range SkillInfo.ItemConsum {
						item := BagMgrSingleton.GetItem(p.SnId, int32(itemId))
						if item != nil {
							if item.ItemNum < itemNum {
								status = false
								break
							}
						} else {
							status = false
							break
						}
					}
					if status {
						petRed = true
						break
					}
				}
			}
		}
	}

	if roleRed {
		p.SendShowRed(gamehall.ShowRedCode_Role, 0, 1)
	}
	if petRed {
		p.SendShowRed(gamehall.ShowRedCode_Pet, 0, 1)
	}
}