package main

import (
	"time"

	"mongo.games.com/goserver/core/logger"
	"mongo.games.com/goserver/core/netlib"

	"mongo.games.com/game/common"
	"mongo.games.com/game/model"
	"mongo.games.com/game/protocol/pets"
	"mongo.games.com/game/protocol/server"
	"mongo.games.com/game/srvdata"
)

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
				}
			}
			if role == nil {
				logger.Logger.Tracef("人物不存在")
				return nil
			}
			//背包数据处理
			item := BagMgrSingleton.GetItem(p.SnId, role.Fragment)
			if item != nil && item.ItemNum >= int64(role.Amount) {
				role.HaveAmount -= role.Amount
				remark := role.Name + "升星"
				BagMgrSingleton.AddItems(&model.AddItemParam{
					Platform: p.Platform,
					SnId:     p.SnId,
					Change: []*model.Item{
						{
							ItemId:  item.ItemId,
							ItemNum: int64(-role.Amount),
						},
					},
					GainWay:  common.GainWay_RoleUpgrade,
					Operator: "player",
					Remark:   remark,
				})
				//人物模型状态处理
				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
				}
			}
			if pet == nil {
				logger.Logger.Tracef("宠物不存在")
				return nil
			}
			//背包数据处理
			item := BagMgrSingleton.GetItem(p.SnId, pet.Fragment)
			if item != nil && item.ItemNum >= int64(pet.Amount) {
				pet.HaveAmount -= pet.Amount
				remark := pet.Name + "升星"
				BagMgrSingleton.AddItems(&model.AddItemParam{
					Platform: p.Platform,
					Change: []*model.Item{
						{
							ItemId:  item.ItemId,
							ItemNum: int64(-pet.Amount),
						},
					},
					GainWay:  common.GainWay_PetUpgrade,
					Operator: "player",
					Remark:   remark,
				})
				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.AddItems(&model.AddItemParam{
							Platform: p.Platform,
							SnId:     p.SnId,
							Change: []*model.Item{
								{
									ItemId:  item.ItemId,
									ItemNum: int64(-roleInfo.Amount),
								},
							},
							GainWay:  common.GainWay_RoleUpgrade,
							Operator: "player",
							Remark:   remark,
						})
						p.Roles.ModUnlock[msg.UseModId] = 1
						if p.Roles.Mod[msg.UseModId] == nil {
							p.Roles.Mod[msg.UseModId] = &model.ModEx{}
						}
						if p.Roles.Mod[msg.UseModId].Ts == 0 {
							p.Roles.Mod[msg.UseModId].Ts = time.Now().Unix()
						}
						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.AddItems(&model.AddItemParam{
							Platform: p.Platform,
							SnId:     p.SnId,
							Change: []*model.Item{
								{
									ItemId:  item.ItemId,
									ItemNum: int64(-petInfo.Amount),
								},
							},
							GainWay:  common.GainWay_PetUpgrade,
							Operator: "player",
							Remark:   remark,
						})
						p.Pets.ModUnlock[msg.UseModId] = 1
						if p.Pets.Mod[msg.UseModId] == nil {
							p.Pets.Mod[msg.UseModId] = &model.ModEx{}
						}
						if p.Pets.Mod[msg.UseModId].Ts == 0 {
							p.Pets.Mod[msg.UseModId].Ts = time.Now().Unix()
						}
						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 []*model.Item
		for itemId, itemNum := range itemCon {
			if itemNum <= 0 {
				return nil
			}
			items = append(items, &model.Item{
				ItemId:  int32(itemId),
				ItemNum: -itemNum,
			})
		}
		_, _, isF := BagMgrSingleton.AddItems(&model.AddItemParam{
			Platform: p.Platform,
			SnId:     p.SnId,
			Change:   items,
			GainWay:  common.GainWayPetSkillLevelUp,
			Operator: "system",
			Remark:   "宠物技能升级消耗",
		})
		if isF {
			p.Pets.SkillInfo[petId][skillId] = level + 1
			if level == 0 {
				if p.Pets.Skill[petId] == nil {
					p.Pets.Skill[petId] = make(map[int32]*model.SkillEx)
				}
				if p.Pets.Skill[petId][skillId] == nil {
					p.Pets.Skill[petId][skillId] = &model.SkillEx{}
				}
				if p.Pets.Skill[petId][skillId].Ts == 0 {
					p.Pets.Skill[petId][skillId].Ts = time.Now().Unix()
				}
			}
			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 CSSkinInfo(s *netlib.Session, packetid int, data interface{}, sid int64) error {
	logger.Logger.Tracef("CSSkinInfo %v", data)
	_, ok := data.(*pets.CSSkinInfo)
	if !ok {
		return nil
	}
	p := PlayerMgrSington.GetPlayer(sid)
	if p == nil {
		logger.Logger.Warn("CSSkinInfo p == nil")
		return nil
	}
	pack := &pets.SCSkinInfo{
		Infos: PetMgrSington.GetSkinInfos(p),
	}
	p.SendToClient(int(pets.PetsPacketID_PACKET_SC_SKIN_INFO), pack)
	logger.Logger.Tracef("SCSkinInfo: %v", pack)
	return nil
}

func CSSkinUse(s *netlib.Session, packetid int, data interface{}, sid int64) error {
	logger.Logger.Tracef("CSSkinUse %v", data)
	msg, ok := data.(*pets.CSSkinUse)
	if !ok {
		return nil
	}
	p := PlayerMgrSington.GetPlayer(sid)
	if p == nil {
		logger.Logger.Warn("CSSkinUse p == nil")
		return nil
	}

	pack := &pets.SCSkinUse{
		Id:      msg.GetId(),
		SnId:    p.SnId,
		RetCode: pets.OpResultCode_OPRC_Error,
	}
	send := func() {
		p.SendToClient(int(pets.PetsPacketID_PACKET_SC_SKIN_USE), pack)
		logger.Logger.Tracef("SCSkinUse: %v", pack)

		// 在游戏中广播
		if pack.RetCode == pets.OpResultCode_OPRC_Sucess {
			if p.scene != nil && p.scene.dbGameFree.GetGameType() == common.GameType_PVP {
				p.scene.Broadcast(int(pets.PetsPacketID_PACKET_SC_SKIN_USE), pack, sid)
			}
		}
	}

	// 已解锁的
	info := PetMgrSington.GetSkinInfo(p, msg.GetId())
	if !info.GetIsUnlock() {
		logger.Logger.Errorf("CSSkinUse unlock")
		pack.RetCode = pets.OpResultCode_OPRC_Unlock
		send()
		return nil
	}

	p.Skin.ModId = msg.GetId()
	pack.RetCode = pets.OpResultCode_OPRC_Sucess
	send()
	return nil
}

func CSSkinUpgrade(s *netlib.Session, packetid int, data interface{}, sid int64) error {
	logger.Logger.Tracef("CSSkinUpgrade %v", data)
	msg, ok := data.(*pets.CSSkinUpgrade)
	if !ok {
		return nil
	}
	p := PlayerMgrSington.GetPlayer(sid)
	if p == nil {
		logger.Logger.Warn("CSSkinUpgrade p == nil")
		return nil
	}

	cfg := PlatformMgrSingleton.GetSkinInfo(p.Platform, msg.GetId())

	pack := &pets.SCSkinUpgrade{
		RetCode: pets.OpResultCode_OPRC_Error,
	}
	send := func() {
		p.SendToClient(int(pets.PetsPacketID_PACKET_SC_SKIN_UPGRADE), pack)
		logger.Logger.Tracef("SCSkinUpgrade: %v", pack)
	}

	// 是否已经解锁
	info := PetMgrSington.GetSkinInfo(p, msg.GetId())
	if !info.GetIsUnlock() {
		logger.Logger.Errorf("CSSkinUpgrade not unlock")
		send()
		return nil
	}

	if info.GetLevel() >= PlatformMgrSingleton.GetSkinMaxLevel(p.Platform, msg.GetId()) || cfg.GetIsUpgrade() == 2 {
		logger.Logger.Errorf("CSSkinUpgrade max level")
		pack.RetCode = pets.OpResultCode_OPRC_MaxLevel
		send()
		return nil
	}

	var change []*model.Item
	for _, v := range info.GetCost() {
		e := BagMgrSingleton.GetItem(p.SnId, v.GetId())
		if e == nil || e.ItemNum < v.GetN() {
			logger.Logger.Errorf("CSSkinUpgrade not enough")
			pack.RetCode = pets.OpResultCode_OPRC_NotEnough
			send()
			return nil
		}
		change = append(change, &model.Item{
			ItemId:  v.GetId(),
			ItemNum: -v.GetN(),
		})
	}
	_, _, ok = BagMgrSingleton.AddItems(&model.AddItemParam{
		Platform: p.Platform,
		SnId:     p.SnId,
		Change:   change,
		Add:      0,
		GainWay:  common.GainWaySkinUpGrade,
		Operator: "system",
		Remark:   "皮肤升级消耗",
	})
	if !ok {
		logger.Logger.Errorf("CSSkinUpgrade upgrade error")
		send()
		return nil
	}
	p.Skin.ModUnlock[msg.GetId()] = info.GetLevel() + 1
	pack.RetCode = pets.OpResultCode_OPRC_Sucess
	pack.Info = PetMgrSington.GetSkinInfo(p, msg.GetId())
	send()

	// 任务加成变更
	if info.GetSkillId() == common.SkillIdTask && p.GetSkillAdd(common.SkillIdTask) > 0 {
		OnNotifyChange(p, common.TaskActivityTypeEveryDay)
	}
	return nil
}

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

	info := PetMgrSington.GetSkinInfo(p, id)
	if info.GetIsUnlock() {
		return nil, pets.OpResultCode_OPRC_Error
	}

	var change []*model.Item
	if info.GetUnLockType() == common.SkinGetVip {
		if p.VIP < info.GetNeedVip() {
			logger.Logger.Errorf("CSSKinUnLock Unlock vip error")
			return nil, pets.OpResultCode_OPRC_Error
		}
	} else {
		for _, v := range info.GetCost() {
			e := BagMgrSingleton.GetItem(p.SnId, v.GetId())
			if e == nil || e.ItemNum < v.GetN() {
				return nil, pets.OpResultCode_OPRC_NotEnough
			}
			change = append(change, &model.Item{
				ItemId:  v.GetId(),
				ItemNum: -v.GetN(),
			})
		}
		_, _, ok := BagMgrSingleton.AddItems(&model.AddItemParam{
			Platform: p.Platform,
			SnId:     p.SnId,
			Change:   change,
			Add:      0,
			GainWay:  common.GainWaySkinUnLock,
			Operator: "system",
			Remark:   "皮肤解锁消耗",
		})
		if !ok {
			logger.Logger.Errorf("CSSKinUnLock Unlock error")
			return nil, pets.OpResultCode_OPRC_Error
		}
	}
	p.Skin.ModUnlock[id] = 1
	if p.Skin.Mod[id] == nil {
		p.Skin.Mod[id] = &model.ModEx{}
	}
	if p.Skin.Mod[id].Ts == 0 {
		p.Skin.Mod[id].Ts = time.Now().Unix()
	}
	pack := &pets.SCSkinUnLock{
		Id:      id,
		RetCode: pets.OpResultCode_OPRC_Sucess,
		Info:    PetMgrSington.GetSkinInfo(p, id),
	}
	p.SendToClient(int(pets.PetsPacketID_PACKET_SC_SKIN_UNLOCK), pack)
	logger.Logger.Tracef("SCSkinUnlock: %v", pack)

	// 任务加成变更
	if info.GetSkillId() == common.SkillIdTask && p.GetSkillAdd(common.SkillIdTask) > 0 {
		OnNotifyChange(p, common.TaskActivityTypeEveryDay)
	}

	// 自动使用
	if cfg.GetUnlockType() == common.SkinGetAuto {
		CSSkinUse(p.gateSess, int(pets.PetsPacketID_PACKET_CS_SKIN_USE), &pets.CSSkinUse{Id: id}, p.sid)
	}
	return pack.Info, pets.OpResultCode_OPRC_Sucess
}

func CSSKinUnLock(s *netlib.Session, packetid int, data interface{}, sid int64) error {
	logger.Logger.Tracef("CSSKinUnLock %v", data)
	msg, ok := data.(*pets.CSSKinUnLock)
	if !ok {
		return nil
	}
	p := PlayerMgrSington.GetPlayer(sid)
	if p == nil {
		logger.Logger.Errorf("CSSKinUnLock p == nil")
		return nil
	}

	pack := &pets.SCSkinUnLock{
		Id:      msg.GetId(),
		RetCode: pets.OpResultCode_OPRC_Error,
	}
	send := func() {
		p.SendToClient(int(pets.PetsPacketID_PACKET_SC_SKIN_UNLOCK), pack)
		logger.Logger.Tracef("SCSkinUnlock: %v", pack)
	}

	pack.Info, pack.RetCode = SkinUnLock(p, msg.GetId())
	if pack.GetRetCode() != pets.OpResultCode_OPRC_Sucess {
		send()
	}
	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{})

	// 皮肤信息
	common.Register(int(pets.PetsPacketID_PACKET_CS_SKIN_INFO), pets.CSSkinInfo{}, CSSkinInfo)
	// 皮肤解锁
	common.Register(int(pets.PetsPacketID_PACKET_CS_SKIN_UNLOCK), pets.CSSKinUnLock{}, CSSKinUnLock)
	// 皮肤使用
	common.Register(int(pets.PetsPacketID_PACKET_CS_SKIN_USE), pets.CSSkinUse{}, CSSkinUse)
	// 皮肤升级
	common.Register(int(pets.PetsPacketID_PACKET_CS_SKIN_UPGRADE), pets.CSSkinUpgrade{}, CSSkinUpgrade)
}