package main

import (
	"mongo.games.com/game/common"
	"mongo.games.com/game/protocol/pets"
	"mongo.games.com/game/protocol/server"
	"mongo.games.com/game/srvdata"
	"mongo.games.com/goserver/core/logger"
	"mongo.games.com/goserver/core/netlib"
)

type CSRoleInfoPacketFactory struct {
}

type CSRoleInfoHandler struct {
}

func (this *CSRoleInfoPacketFactory) CreatePacket() interface{} {
	pack := &pets.CSRoleInfo{}
	return pack
}

func (this *CSRoleInfoHandler) Process(s *netlib.Session, packetid int, data interface{}, sid int64) error {
	logger.Logger.Trace("CSRoleInfoHandler Process recv ", data)
	if _, ok := data.(*pets.CSRoleInfo); ok {
		p := PlayerMgrSington.GetPlayer(sid)
		if p == nil {
			logger.Logger.Warn("CSRoleInfoHandler p == nil")
			return nil
		}
		platform := p.GetPlatform()
		if platform == nil {
			return nil
		}
		roleInfos := PetMgrSington.GetRoleInfos(p)
		pack := &pets.SCRoleInfo{
			Infos: roleInfos,
		}
		logger.Logger.Trace("SCRoleInfo:", pack)
		p.SendToClient(int(pets.PetsPacketID_PACKET_SC_ROLE_INFO), pack)
	}

	return nil
}

type CSPetInfoPacketFactory struct {
}

type CSPetInfoHandler struct {
}

func (this *CSPetInfoPacketFactory) CreatePacket() interface{} {
	pack := &pets.CSPetInfo{}
	return pack
}

func (this *CSPetInfoHandler) Process(s *netlib.Session, packetid int, data interface{}, sid int64) error {
	logger.Logger.Trace("CSPetInfoHandler Process recv ", data)
	if _, ok := data.(*pets.CSPetInfo); ok {
		p := PlayerMgrSington.GetPlayer(sid)
		if p == nil {
			logger.Logger.Warn("CSPetInfoHandler p == nil")
			return nil
		}
		platform := p.GetPlatform()
		if platform == nil {
			return nil
		}

		petInfos := PetMgrSington.GetPetInfos(p)
		pack := &pets.SCPetInfo{
			Infos: petInfos,
		}
		logger.Logger.Trace("SCPetInfo:", pack)
		p.SendToClient(int(pets.PetsPacketID_PACKET_SC_PET_INFO), pack)
	}
	return nil
}

type CSRisingStarPacketFactory struct {
}

type CSRisingStarHandler struct {
}

func (this *CSRisingStarPacketFactory) CreatePacket() interface{} {
	pack := &pets.CSRisingStar{}
	return pack
}

func (this *CSRisingStarHandler) Process(s *netlib.Session, packetid int, data interface{}, sid int64) error {
	logger.Logger.Trace("CSRisingStarHandler Process recv ", data)
	if msg, ok := data.(*pets.CSRisingStar); ok {
		p := PlayerMgrSington.GetPlayer(sid)
		if p == nil {
			logger.Logger.Warn("CSRisingStarHandler p == nil")
			return nil
		}
		platform := p.GetPlatform()
		if platform == nil {
			return nil
		}
		SendInfoRole := func(retCode pets.OpResultCode, roleInfo *pets.RoleInfo) {
			pack := &pets.SCRoleRisingStar{
				RetCode:  retCode,
				RoleInfo: roleInfo,
			}
			logger.Logger.Trace("SCPetRisingStar:", pack)
			p.SendToClient(int(pets.PetsPacketID_PACKET_SC_ROLE_RISINGSTAR), pack)
		}
		SendInfoPet := func(retCode pets.OpResultCode, petInfo *pets.PetInfo) {
			pack := &pets.SCPetRisingStar{
				RetCode: retCode,
				PetInfo: petInfo,
			}
			logger.Logger.Trace("SCPetRisingStar:", pack)
			p.SendToClient(int(pets.PetsPacketID_PACKET_SC_PET_RISINGSTAR), pack)
		}
		if msg.RisingModId == 0 {
			logger.Logger.Warn("CSRisingStarHandler UseModId:", msg.RisingModId)
			SendInfoRole(pets.OpResultCode_OPRC_Error, PetMgrSington.GetRoleInfo(p, msg.RisingModId))
			return nil
		}
		if msg.RisingType == 0 {
			roleInfo := PetMgrSington.GetIntroductionByModId(msg.RisingModId)
			if roleInfo == nil {
				SendInfoRole(pets.OpResultCode_OPRC_Error, PetMgrSington.GetRoleInfo(p, msg.RisingModId))
				return nil
			}
			if roleInfo.MaxLevel == p.Roles.ModUnlock[msg.RisingModId] {
				logger.Logger.Trace("人物已经达到最大等级")
				SendInfoRole(pets.OpResultCode_OPRC_Error, PetMgrSington.GetRoleInfo(p, msg.RisingModId))
				return nil
			}
			role := PetMgrSington.GetRoleInfo(p, msg.RisingModId)
			if role != nil {
				if role.HaveAmount < role.Amount {
					logger.Logger.Trace("人物碎片道具数量不够", role.HaveAmount, role.Amount)
					return nil
				}
			}
			//背包数据处理
			item := BagMgrSingleton.GetItem(p.SnId, role.Fragment)
			if item != nil {
				// item.ItemNum -= role.Amount
				role.HaveAmount -= role.Amount
				remark := role.Name + "升星"
				BagMgrSingleton.AddItem(p, int64(item.ItemId), int64(-role.Amount), 0, common.GainWay_RoleUpgrade,
					"player", remark, 0, 0, false)
				//人物模型状态处理
				p.Roles.ModUnlock[msg.RisingModId]++
				FriendMgrSington.UpdateInfo(p.Platform, p.SnId)
				p.dirty = true
				//人物
				SendInfoRole(pets.OpResultCode_OPRC_Sucess, PetMgrSington.GetRoleInfo(p, msg.RisingModId))
			}
		} else if msg.RisingType == 1 {
			petInfo := PetMgrSington.GetIntroductionByModId(msg.RisingModId)
			if petInfo == nil {
				SendInfoPet(pets.OpResultCode_OPRC_Error, PetMgrSington.GetPetInfo(p, msg.RisingModId))
				return nil
			}
			if petInfo.MaxLevel == p.Pets.ModUnlock[msg.RisingModId] {
				logger.Logger.Trace("宠物已经达到最大等级")
				SendInfoPet(pets.OpResultCode_OPRC_Error, PetMgrSington.GetPetInfo(p, msg.RisingModId))
				return nil
			}

			pet := PetMgrSington.GetPetInfo(p, msg.RisingModId)
			if pet != nil {
				if pet.HaveAmount < pet.Amount {
					logger.Logger.Trace("宠物碎片道具数量不够", pet.HaveAmount, pet.Amount)
					return nil
				}
			}
			//背包数据处理
			item := BagMgrSingleton.GetItem(p.SnId, pet.Fragment)
			if item != nil {
				// item.ItemNum -= pet.Amount
				pet.HaveAmount -= pet.Amount
				remark := pet.Name + "升星"
				BagMgrSingleton.AddItem(p, int64(item.ItemId), int64(-pet.Amount), 0, common.GainWay_PetUpgrade,
					"player", remark, 0, 0, false)

				p.Pets.ModUnlock[msg.RisingModId]++
				FriendMgrSington.UpdateInfo(p.Platform, p.SnId)
				p.dirty = true
				//宠物
				SendInfoPet(pets.OpResultCode_OPRC_Sucess, PetMgrSington.GetPetInfo(p, msg.RisingModId))
			}
		}

	}
	return nil
}

type CSRolePetUseOpPacketFactory struct {
}

type CSRolePetUseOpHandler struct {
}

func (this *CSRolePetUseOpPacketFactory) CreatePacket() interface{} {
	pack := &pets.CSRolePetUseOp{}
	return pack
}

func (this *CSRolePetUseOpHandler) Process(s *netlib.Session, packetid int, data interface{}, sid int64) error {
	logger.Logger.Trace("CSRolePetUseOpHandler Process recv ", data)
	if msg, ok := data.(*pets.CSRolePetUseOp); ok {
		p := PlayerMgrSington.GetPlayer(sid)
		if p == nil {
			logger.Logger.Warn("CSRolePetUseOpHandler p == nil")
			return nil
		}
		platform := p.GetPlatform()
		if platform == nil {
			return nil
		}
		if msg.UseModId == 0 {
			logger.Logger.Warn("CSRolePetUseOpHandler UseModId:", msg.UseModId)
			return nil
		}
		if msg.UseModType == 0 {
			if p.Roles.ModId == msg.UseModId {
				logger.Logger.Trace("人物使用中 不能直接取消人物使用")
				return nil
			}
			p.Roles.ModId = msg.UseModId
			p.dirty = true
			logger.Logger.Trace("使用人物:", msg.UseModId)
		} else {
			if p.Pets.ModId == msg.UseModId {
				p.Pets.ModId = 0
				logger.Logger.Trace("取消宠物跟随:", msg.UseModId)
				p.dirty = true
			} else {
				logger.Logger.Trace("设置宠物跟随:", msg.UseModId)
				p.Pets.ModId = msg.UseModId
				p.dirty = true
			}
		}
		pack := &pets.SCRolePetUseOp{
			RetCode:    pets.OpResultCode_OPRC_Sucess,
			UseModType: msg.UseModType,
			UseModId:   msg.UseModId,
		}
		logger.Logger.Trace("SCRolePetUseOp:", pack)
		p.SendToClient(int(pets.PetsPacketID_PACKET_SC_ROLEPETUSEOP), pack)
	}
	return nil
}

type CSRolePetUnlockPacketFactory struct {
}

type CSRolePetUnlockHandler struct {
}

func (this *CSRolePetUnlockPacketFactory) CreatePacket() interface{} {
	pack := &pets.CSRolePetUnlock{}
	return pack
}

func (this *CSRolePetUnlockHandler) Process(s *netlib.Session, packetid int, data interface{}, sid int64) error {
	logger.Logger.Trace("CSRolePetUnlockHandler Process recv ", data)
	if msg, ok := data.(*pets.CSRolePetUnlock); ok {
		p := PlayerMgrSington.GetPlayer(sid)
		if p == nil {
			logger.Logger.Warn("CSRolePetUnlockHandler p == nil")
			return nil
		}
		platform := p.GetPlatform()
		if platform == nil {
			return nil
		}
		SendMsg := func(retCode pets.OpResultCode, roleInfo *pets.RoleInfo, petInfo *pets.PetInfo) {
			pack := &pets.SCRolePetUnlock{
				RetCode:    retCode,
				UseModType: msg.UseModType,
				UseModId:   msg.UseModId,
				RoleInfo:   roleInfo,
				PetInfo:    petInfo,
			}
			logger.Logger.Trace("SCRolePetUnlock:", pack)
			p.SendToClient(int(pets.PetsPacketID_PACKET_SC_ROLEPETUNLOCK), pack)
		}
		if msg.UseModId == 0 {
			logger.Logger.Warn("CSRolePetUnlockHandler UseModId:", msg.UseModId)
			SendMsg(pets.OpResultCode_OPRC_Error, nil, nil)
			return nil
		}
		if msg.UseModType == 0 {
			if _, ok1 := p.Roles.ModUnlock[msg.UseModId]; !ok1 {
				roleInfo := PetMgrSington.GetRoleInfo(p, msg.UseModId)
				if roleInfo != nil {
					item := BagMgrSingleton.GetItem(p.SnId, roleInfo.Fragment)
					if item != nil && item.ItemNum >= int64(roleInfo.Amount) {
						remark := roleInfo.Name + "解锁"
						BagMgrSingleton.AddItem(p, int64(item.ItemId), int64(-roleInfo.Amount), 0, common.GainWay_RoleUpgrade,
							"player", remark, 0, 0, false)

						p.Roles.ModUnlock[msg.UseModId] = 1
						FriendMgrSington.UpdateInfo(p.Platform, p.SnId)
						p.dirty = true
						logger.Logger.Trace("解锁人物", msg.UseModId)
						SendMsg(pets.OpResultCode_OPRC_Sucess, PetMgrSington.GetRoleInfo(p, msg.UseModId), nil)
						return nil
					}
				}
			}
		} else if msg.UseModType == 1 {
			if _, ok1 := p.Pets.ModUnlock[msg.UseModId]; !ok1 {
				petInfo := PetMgrSington.GetPetInfo(p, msg.UseModId)
				if petInfo != nil {
					item := BagMgrSingleton.GetItem(p.SnId, petInfo.Fragment)
					if item != nil && item.ItemNum >= int64(petInfo.Amount) {
						remark := petInfo.Name + "解锁"
						BagMgrSingleton.AddItem(p, int64(item.ItemId), int64(-petInfo.Amount), 0, common.GainWay_PetUpgrade,
							"player", remark, 0, 0, false)

						p.Pets.ModUnlock[msg.UseModId] = 1
						FriendMgrSington.UpdateInfo(p.Platform, p.SnId)
						p.dirty = true
						logger.Logger.Trace("解锁宠物", msg.UseModId)
						SendMsg(pets.OpResultCode_OPRC_Sucess, nil, PetMgrSington.GetPetInfo(p, msg.UseModId))
						return nil
					}
				}
			}
		}
		SendMsg(pets.OpResultCode_OPRC_Error, nil, nil)
	}
	return nil
}

// 宠物技能升级
type CSPetSkillLevelUpPacketFactory struct {
}

type CSPetSkillLevelUpHandler struct {
}

func (this *CSPetSkillLevelUpPacketFactory) CreatePacket() interface{} {
	pack := &pets.CSPetSkillLevelUp{}
	return pack
}

func (this *CSPetSkillLevelUpHandler) Process(s *netlib.Session, packetid int, data interface{}, sid int64) error {
	if msg, ok := data.(*pets.CSPetSkillLevelUp); ok {
		p := PlayerMgrSington.GetPlayer(sid)
		if p == nil {
			logger.Logger.Warn("CSPetSkillLevelUp p == nil")
			return nil
		}
		skillId := msg.SkillId
		petId := msg.PetId
		if p.Pets.SkillInfo == nil {
			p.Pets.SkillInfo = make(map[int32]map[int32]int32)
		}
		level := int32(0)
		if p.Pets.SkillInfo[petId] != nil {
			level = p.Pets.SkillInfo[petId][skillId]
		}
		logger.Logger.Tracef("玩家升级宠物技能%d %d %d", petId, skillId, level)
		data := srvdata.PBDB_PetSkillMgr.Datas.GetArr()
		var SkillInfo *server.DB_PetSkill = nil
		for _, info := range data {
			if info.PetId == petId && info.SkillId == skillId && info.SkillLevel == level+1 {
				SkillInfo = info
				break
			}
		}
		if SkillInfo == nil {
			return nil
		}
		if p.Pets.SkillInfo[petId] == nil {
			p.Pets.SkillInfo[petId] = make(map[int32]int32)
		}
		//消耗道具
		itemCon := SkillInfo.ItemConsum
		var items []*Item
		for itemId, itemNum := range itemCon {
			if itemNum == 0 {
				return nil
			}
			items = append(items, &Item{
				ItemId:  int32(itemId),
				ItemNum: -itemNum,
			})
		}
		_, _, isF := BagMgrSingleton.AddItems(p, items, 0, common.GainWayPetSkillLevelUp, "system", "宠物技能升级消耗", 0, 0, false)
		if isF {
			p.Pets.SkillInfo[petId][skillId] = level + 1
			pack := &pets.SCPetSkillLevelUp{}
			pack.PetId = petId
			pack.SkillId = skillId
			pack.SkillLevel = p.Pets.SkillInfo[petId][skillId]
			p.SendToClient(int(pets.PetsPacketID_PACKET_SC_PETSKILLLEVELUP), pack)
		}
	}
	return nil
}

func init() {
	common.RegisterHandler(int(pets.PetsPacketID_PACKET_CS_ROLE_INFO), &CSRoleInfoHandler{})
	netlib.RegisterFactory(int(pets.PetsPacketID_PACKET_CS_ROLE_INFO), &CSRoleInfoPacketFactory{})
	common.RegisterHandler(int(pets.PetsPacketID_PACKET_CS_PET_INFO), &CSPetInfoHandler{})
	netlib.RegisterFactory(int(pets.PetsPacketID_PACKET_CS_PET_INFO), &CSPetInfoPacketFactory{})
	common.RegisterHandler(int(pets.PetsPacketID_PACKET_CS_PET_RISINGSTAR), &CSRisingStarHandler{})
	netlib.RegisterFactory(int(pets.PetsPacketID_PACKET_CS_PET_RISINGSTAR), &CSRisingStarPacketFactory{})
	common.RegisterHandler(int(pets.PetsPacketID_PACKET_CS_ROLEPETUSEOP), &CSRolePetUseOpHandler{})
	netlib.RegisterFactory(int(pets.PetsPacketID_PACKET_CS_ROLEPETUSEOP), &CSRolePetUseOpPacketFactory{})
	common.RegisterHandler(int(pets.PetsPacketID_PACKET_CS_ROLEPETUNLOCK), &CSRolePetUnlockHandler{})
	netlib.RegisterFactory(int(pets.PetsPacketID_PACKET_CS_ROLEPETUNLOCK), &CSRolePetUnlockPacketFactory{})
	common.RegisterHandler(int(pets.PetsPacketID_PACKET_CS_PETSKILLLEVELUP), &CSPetSkillLevelUpHandler{})
	netlib.RegisterFactory(int(pets.PetsPacketID_PACKET_CS_PETSKILLLEVELUP), &CSPetSkillLevelUpPacketFactory{})
}