package main

import (
	"crypto/md5"
	"encoding/base64"
	"encoding/hex"
	"encoding/json"
	"fmt"
	"io"
	"math/rand"
	"net/url"
	"regexp"
	"slices"
	"strconv"
	"strings"
	"time"
	"unicode/utf8"

	"mongo.games.com/goserver/core/basic"
	"mongo.games.com/goserver/core/i18n"
	"mongo.games.com/goserver/core/logger"
	"mongo.games.com/goserver/core/netlib"
	"mongo.games.com/goserver/core/task"

	"mongo.games.com/game/common"
	"mongo.games.com/game/model"
	"mongo.games.com/game/mq"
	"mongo.games.com/game/proto"
	player_proto "mongo.games.com/game/protocol/player"
	webapi_proto "mongo.games.com/game/protocol/webapi"
	"mongo.games.com/game/webapi"
)

var reTelRule, _ = regexp.Compile(`^(1[3|4|5|6|7|8|9][0-9]\d{4,8})$`)

// 获取邀请码奖励
type CSInviteCodePlayerPacketFactory struct {
}
type CSInviteCodePlayerHandler struct {
}

func (this *CSInviteCodePlayerPacketFactory) CreatePacket() interface{} {
	pack := &player_proto.CSPlayerInviteCode{}
	return pack
}

func (this *CSInviteCodePlayerHandler) Process(s *netlib.Session, packetid int, data interface{}, sid int64) error {
	logger.Logger.Trace("CSInviteCodePlayerHandler Process recv ", data)
	if msg, ok := data.(*player_proto.CSPlayerInviteCode); ok {
		p := PlayerMgrSington.GetPlayer(sid)
		if p == nil {
			logger.Logger.Warn("CSInviteCodePlayerHandler p == nil")
			return nil
		}
		inviteCode := msg.GetCode()
		task.New(nil, task.CallableWrapper(func(o *basic.Object) interface{} {

			var ret webapi.RequestBody
			var err error
			data := make(url.Values)
			data["MemberId"] = []string{strconv.Itoa(int(p.SnId))}
			data["Key"] = []string{inviteCode}

			ret, err = webapi.API_OP("/api/ExchangeCode/MemberExchangeCode", data)
			logger.Logger.Trace("webapi返回数据: ", ret)
			if err != nil {
				return nil
			}
			if ret == nil {
				return nil
			}

			state, _ := ret.GetInt("State")
			if state == 0 {
				return nil
			}

			ret_data, _ := ret.GetRequestBody("Data")
			if ret_data == nil {
				return nil
			}
			coin, _ := ret_data.GetInt64("Price")
			if coin <= 0 {
				return nil
			}

			//发送邮件
			var otherParams []int64
			newMsg := model.NewMessage("", p.SnId, "", p.SnId, model.MSGTYPE_INVITECODE, p.Name, inviteCode, coin, 0,
				model.MSGSTATE_UNREAD, time.Now().Unix(), 0, "", otherParams, p.Platform, model.HallAll, nil)
			err = model.InsertMessage(p.Platform, newMsg)
			if err == nil {

				//执行成功后通知后端
				data := make(url.Values)
				data["Snid"] = []string{strconv.Itoa(int(p.SnId))}
				data["Code"] = []string{inviteCode}
				data["State"] = []string{strconv.Itoa(1)}
				_, err_res := webapi.API_OP("/api/ExchangeCode/MemberExchangeCodeSuccess", data)
				if err_res != nil {
					logger.Logger.Error("/api/ExchangeCode/MemberExchangeCodeSuccess err ", err_res)
				}

				return newMsg
			} else {
				//执行失败后通知后端
				data := make(url.Values)
				data["Snid"] = []string{strconv.Itoa(int(p.SnId))}
				data["Code"] = []string{inviteCode}
				data["State"] = []string{strconv.Itoa(0)}
				_, err_res := webapi.API_OP("/api/ExchangeCode/MemberExchangeCodeSuccess", data)
				if err_res != nil {
					logger.Logger.Error("/api/ExchangeCode/MemberExchangeCodeSuccess err ", err_res)
				}

				return nil
			}
		}), task.CompleteNotifyWrapper(func(data interface{}, t task.Task) {
			retCode := player_proto.OpResultCode_OPRC_Sucess
			if newMsg, OK := data.(*model.Message); OK {
				p.AddMessage(newMsg)
			} else {
				retCode = player_proto.OpResultCode_OPRC_Error
			}

			//错误提示
			pack := &player_proto.SCPlayerInviteCode{
				OpRetCode: retCode,
			}
			proto.SetDefaults(pack)
			p.SendToClient(int(player_proto.PlayerPacketID_PACKET_SC_INVITECODE), pack)

		}), "InviteCode").Start()

	}
	return nil
}

// 修改昵称
type CSPlayerChangeNickPacketFactory struct {
}
type CSPlayerChangeNickHandler struct {
}

func (this *CSPlayerChangeNickPacketFactory) CreatePacket() interface{} {
	pack := &player_proto.CSChangeNick{}
	return pack
}

func (this *CSPlayerChangeNickHandler) Process(s *netlib.Session, packetid int, data interface{}, sid int64) error {
	//logger.Logger.Trace("CSPlayerChangeNickHandler Process recv ", data)
	//if msg, ok := data.(*player_proto.CSChangeNick); ok {
	//	//logger.Logger.Trace("修改昵称，获得IP",s.RemoteAddr())
	//	p := PlayerMgrSington.GetPlayer(sid)
	//	if p == nil {
	//		logger.Logger.Warn("CSPlayerChangeNickHandler p == nil")
	//		return nil
	//	}
	//
	//	sendPack := func(code *player_proto.OpResultCode) {
	//		pack := &player_proto.SCChangeNick{
	//			OpRetCode: code,
	//			Nick:      msg.Nick,
	//		}
	//		proto.SetDefaults(pack)
	//		p.SendToClient(int(player_proto.PlayerPacketID_PACKET_SC_CHANGENICK), pack)
	//	}
	//
	//	nick := msg.GetNick()
	//	//昵称不能为空
	//	if nick == "" {
	//		sendPack(player_proto.OpResultCode_OPRC_NickIsNull)
	//		return nil
	//	}
	//
	//	if !utf8.ValidString(nick) {
	//		sendPack(player_proto.OpResultCode_OPRC_NickIsIllegal)
	//		return nil
	//	}
	//	//昵称已占用，昵称允许重复
	//	//if model.GetPlayerNickIsExist(nick) {
	//	//	sendPack(player_proto.OpResultCode_OPRC_NickIsExist)
	//	//	return nil
	//	//}
	//
	//	//昵称超出长度限制
	//	if len(nick) > 21 {
	//		sendPack(player_proto.OpResultCode_OPRC_NickIsTooLen)
	//		return nil
	//	}
	//
	//	if p.IsStopRename == 1 {
	//		sendPack(player_proto.OpResultCode_OPRC_NickIsCantRename)
	//		return nil
	//	}
	//
	//	//TODO 校验昵称的合法性
	//	//var agentName, agentKey, thirdPlf = model.GetDgConfigByPlatform(p.Platform)
	//	var agentDgName, agentDgKey, thirdDgPlf = model.OnlyGetDgConfigByPlatform(p.Platform)
	//	var agentHboName, agentHboKey, thirdHboPlf = model.OnlyGetHboConfigByPlatform(p.Platform)
	//	//为了兼容以前的数据
	//	var hboGame, hboPass, dgGame, dgPass string
	//	if len(p.StoreHboGame) > 0 {
	//		hboGame = p.StoreHboGame
	//		hboPass = p.StoreHboPass
	//	}
	//	if len(p.StoreDgGame) > 0 {
	//		dgGame = p.StoreDgGame
	//		dgPass = p.StoreDgPass
	//	}
	//	if len(p.DgGame) > 0 && strings.Contains(p.DgGame, "dg") {
	//		dgGame = p.DgGame
	//		dgPass = p.DgPass
	//	}
	//	if len(p.DgGame) > 0 && strings.Contains(p.DgGame, "hbo") {
	//		hboGame = p.DgGame
	//		hboPass = p.DgPass
	//	}
	//	task.New(nil, task.CallableWrapper(func(o *basic.Object) interface{} {
	//		code := model.UpdatePlayerNick(p.AccountId, msg.GetNick())
	//		if code == 0 {
	//
	//			if len(hboGame) > 0 && len(agentHboName) > 0 {
	//				err, codeid, _, _ := webapi.API_DgUpdate(thirdHboPlf, common.GetAppId(),
	//					hboGame, hboPass, nick, agentHboName, agentHboKey)
	//				if err != nil {
	//					logger.Logger.Error("Update hbo name error:", err)
	//				}
	//				if codeid != 0 {
	//					logger.Logger.Error("Update hbo code:", codeid)
	//				}
	//			}
	//
	//			if len(dgGame) > 0 && len(agentDgName) > 0 {
	//				err, codeid, _, _ := webapi.API_DgUpdate(thirdDgPlf, common.GetAppId(),
	//					dgGame, dgPass, nick, agentDgName, agentDgKey)
	//				if err != nil {
	//					logger.Logger.Error("Update dg name error:", err)
	//				}
	//				if codeid != 0 {
	//					logger.Logger.Error("Update dg code:", codeid)
	//				}
	//			}
	//
	//		}
	//		return code
	//	}), task.CompleteNotifyWrapper(func(data interface{}, t *task.Task) {
	//		if i, ok := data.(int); ok {
	//			if i == 0 {
	//				PlayerSubjectSign.UpdateName(p.SnId, nick)
	//				sendPack(player_proto.OpResultCode_OPRC_Sucess)
	//			} else {
	//				sendPack(player_proto.OpResultCode_OPRC_Error)
	//			}
	//		}
	//	}), "UpdatePlayerNick").Start()
	//}
	return nil
}

// 修改头像
type CSPlayerChangeIconPacketFactory struct {
}
type CSPlayerChangeIconHandler struct {
}

func (this *CSPlayerChangeIconPacketFactory) CreatePacket() interface{} {
	pack := &player_proto.CSPlayerChangeIcon{}
	return pack
}

func (this *CSPlayerChangeIconHandler) Process(s *netlib.Session, packetid int, data interface{}, sid int64) error {
	logger.Logger.Trace("CSPlayerChangeIconHandler Process recv ", data)
	if msg, ok := data.(*player_proto.CSPlayerChangeIcon); ok {
		p := PlayerMgrSington.GetPlayer(sid)
		if p == nil {
			logger.Logger.Warn("CSPlayerChangeIconHandler p == nil")
			return nil
		}

		sendPack := func(code player_proto.OpResultCode) {
			pack := &player_proto.SCPlayerChangeIcon{
				OpRetCode: code,
				Icon:      msg.Icon,
			}
			proto.SetDefaults(pack)
			p.SendToClient(int(player_proto.PlayerPacketID_PACKET_SC_CHANGEICON), pack)
		}

		if int32(time.Now().Sub(p.changeIconTime)/time.Second) > 30 {
			PlayerSubjectSign.UpdateHead(p.SnId, msg.GetIcon())
			sendPack(player_proto.OpResultCode_OPRC_Sucess)
		} else {
			sendPack(player_proto.OpResultCode_OPRC_Frequently)
		}
	}
	return nil
}

// 修改头像框
type CSPlayerChangeHeadOutLinePacketFactory struct {
}
type CSPlayerChangeHeadOutLineHandler struct {
}

func (this *CSPlayerChangeHeadOutLinePacketFactory) CreatePacket() interface{} {
	pack := &player_proto.CSPlayerChangeHeadOutLine{}
	return pack
}

func (this *CSPlayerChangeHeadOutLineHandler) Process(s *netlib.Session, packetid int, data interface{}, sid int64) error {
	logger.Logger.Trace("CSPlayerChangeHeadOutLineHandler Process recv ", data)
	if msg, ok := data.(*player_proto.CSPlayerChangeHeadOutLine); ok {
		p := PlayerMgrSington.GetPlayer(sid)
		if p == nil {
			logger.Logger.Warn("CSPlayerChangeHeadOutLineHandler p == nil")
			return nil
		}

		sendPack := func(code player_proto.OpResultCode) {
			pack := &player_proto.SCPlayerChangeHeadOutLine{
				OpRetCode:   code,
				HeadOutLine: msg.HeadOutLine,
			}
			proto.SetDefaults(pack)
			p.SendToClient(int(player_proto.PlayerPacketID_PACKET_SC_HEADOUTLINE), pack)
		}

		headOutline := msg.GetHeadOutLine()
		can := false
		for vip := int32(0); vip <= p.VIP; vip++ {
			dbVip := VipMgrSington.GetVIPLevelCfg(p.Platform, vip)
			if dbVip != nil {
				if common.InSliceInt32(dbVip.GetRewardOutlineID(), headOutline) {
					can = true
					break
				}
			}
		}
		if !can {
			sendPack(player_proto.OpResultCode_OPRC_IconError)
			return nil
		}
		if msg.GetHeadOutLine() != 0 {
			PlayerSubjectSign.UpdateHeadOutline(p.SnId, headOutline)
			sendPack(player_proto.OpResultCode_OPRC_Sucess)
		} else {
			sendPack(player_proto.OpResultCode_OPRC_Frequently)
		}
	}
	return nil
}

// 修改性别
type CSPlayerChangeSexPacketFactory struct {
}
type CSPlayerChangeSexHandler struct {
}

func (this *CSPlayerChangeSexPacketFactory) CreatePacket() interface{} {
	pack := &player_proto.CSPlayerChangeSex{}
	return pack
}

func (this *CSPlayerChangeSexHandler) Process(s *netlib.Session, packetid int, data interface{}, sid int64) error {
	logger.Logger.Trace("CSPlayerChangeSexHandler Process recv ", data)
	if msg, ok := data.(*player_proto.CSPlayerChangeSex); ok {
		p := PlayerMgrSington.GetPlayer(sid)
		if p == nil {
			logger.Logger.Warn("CSPlayerChangeSexHandler p == nil")
			return nil
		}

		sendPack := func(code player_proto.OpResultCode) {
			pack := &player_proto.SCPlayerChangeSex{
				OpRetCode: code,
				Sex:       msg.Sex,
			}
			proto.SetDefaults(pack)
			p.SendToClient(int(player_proto.PlayerPacketID_PACKET_SC_CHANGESEX), pack)
		}
		if msg.GetSex() < 0 || msg.GetSex() > 2 {
			sendPack(player_proto.OpResultCode_OPRC_SexError)
			return nil
		}

		p.Sex = msg.GetSex()
		p.dirty = true
		sendPack(player_proto.OpResultCode_OPRC_Sucess)
	}
	return nil
}

//// 帐号绑定，帐号密码找回，保险箱密码找回
//type CSUpgradeAccountPacketFactory struct {
//}
//type CSUpgradeAccountHandler struct {
//}
//
//func (this *CSUpgradeAccountPacketFactory) CreatePacket() interface{} {
//	pack := &player_proto.CSUpgradeAccount{}
//	return pack
//}
//
//func (this *CSUpgradeAccountHandler) Process(s *netlib.Session, packetid int, data interface{}, sid int64) error {
//	logger.Logger.Trace("CSUpgradeAccountHandler Process recv ", data)
//	if msg, ok := data.(*player_proto.CSUpgradeAccount); ok {
//		p := PlayerMgrSington.GetPlayer(sid)
//
//		sendPack := func(code player_proto.OpResultCode) {
//			pack := &player_proto.SCUpgradeAccount{
//				OpRetCode:  code,
//				Tel:        msg.Tel,
//				ChangeType: msg.ChangeType,
//			}
//			proto.SetDefaults(pack)
//			//p.SendToClient(int(player_proto.PlayerPacketID_PACKET_SC_UPGRADEACCOUNT), pack)
//			common.SendToGate(sid, int(player_proto.PlayerPacketID_PACKET_SC_UPGRADEACCOUNT), pack, s)
//		}
//
//		//验证手机号
//		tel := msg.GetTel()
//		if !reTelRule.MatchString(tel) {
//			sendPack(player_proto.OpResultCode_OPRC_TelError)
//			return nil
//		}
//		platformId, _, _, _, tagkey := PlatformMgrSingleton.GetPlatformByPackageTag(msg.GetPlatformTag())
//		platformID := strconv.Itoa(int(platformId))
//		platform := PlatformMgrSingleton.GetPlatform(platformID)
//		if msg.GetChangeType() == 0 {
//			if !platform.RegisterVerifyCodeSwitch {
//				code := CacheMemory.Get(fmt.Sprintf("%v_%v", tel, tagkey))
//				if code == nil {
//					sendPack(player_proto.OpResultCode_OPRC_VerificationCodeError)
//					return nil
//				}
//				if verifyCode, ok := code.(string); ok && verifyCode != "" {
//					if verifyCode != msg.GetVerificationCode() {
//						sendPack(player_proto.OpResultCode_OPRC_VerificationCodeError)
//						return nil
//					}
//				}
//			}
//		} else {
//			if platform.VerifyCodeType != common.CodeTypeNo {
//				code := CacheMemory.Get(fmt.Sprintf("%v_%v", tel, tagkey))
//				if code == nil {
//					sendPack(player_proto.OpResultCode_OPRC_VerificationCodeError)
//					return nil
//				}
//				if verifyCode, ok := code.(string); ok && verifyCode != "" {
//					if verifyCode != msg.GetVerificationCode() {
//						sendPack(player_proto.OpResultCode_OPRC_VerificationCodeError)
//						return nil
//					}
//				}
//			}
//		}
//
//		//验证密码
//		if msg.GetPassword() == "" || len(msg.GetPassword()) < 32 {
//			sendPack(player_proto.OpResultCode_OPRC_UpgradeAccount_PasswordIllegal)
//			return nil
//		}
//
//		var upgradeaccountcount int32
//		//升级账号
//		task.New(nil, task.CallableWrapper(func(o *basic.Object) interface{} {
//			//绑定手机
//			if msg.GetChangeType() == 0 {
//				if p != nil {
//					//手机号是否已经注册
//					if model.PlayerTelIsExist(msg.GetTel(), platformID, tagkey) {
//						sendPack(player_proto.OpResultCode_OPRC_TelIsExist)
//						return errors.New("TelIsExist is Error")
//					}
//					//帐号绑定
//					//更新Account数据
//					err := model.UpgradeAccount(p.AccountId, msg.GetTel(), msg.GetPassword(), platformID, tagkey)
//					if err != nil {
//						return err
//					}
//
//					//当前IP和日期已经赠送的金币总额
//					upgradeaccountcount = model.GetUpgradeAccountCoinLogsByIPAndDate(p.RegIp, p.Platform, time.Now())
//					//更新玩家信息表
//					return model.UpdatePlayerTel(p.Platform, p.SnId, msg.GetTel())
//				} else {
//					//账号密码找回
//					return model.GetBackPlayerPassword(msg.GetTel(), msg.GetPassword(), platformID, tagkey)
//				}
//			}
//			//设置保险箱密码
//			/*if msg.GetChangeType() == 1 {
//				raw := fmt.Sprintf("111111%v", common.GetAppId())
//				h := md5.New()
//				io.WriteString(h, raw)
//				pwd := hex.EncodeToString(h.Sum(nil))
//				return model.UpdateSafeBoxPassword(p.AccountId, pwd, msg.GetPassword())
//			}*/
//			//帐号密码找回
//			if msg.GetChangeType() == 2 {
//				//账号密码找回
//				return model.GetBackPlayerPassword(msg.GetTel(), msg.GetPassword(), platformID, tagkey)
//			}
//			//保险箱密码找回
//			if msg.GetChangeType() == 3 {
//				if p != nil {
//					p.SafeBoxPassword = msg.GetPassword()
//				}
//				return model.GetBackSafeBoxPassword(msg.GetTel(), msg.GetPassword(), platformID, tagkey)
//			}
//			return fmt.Errorf("GetChangeType is Error:%v", msg.GetChangeType())
//		}), task.CompleteNotifyWrapper(func(data interface{}, t task.Task) {
//			if data == nil {
//				if msg.GetChangeType() == 0 || msg.GetChangeType() == 2 {
//					als := LoginStateMgrSington.GetLoginStateByTelAndPlatform(msg.GetTel(), platformID)
//					if als != nil && als.acc != nil {
//						als.acc.Tel = msg.GetTel()
//						als.acc.TelPassWord = msg.GetPassword()
//					}
//				}
//				if p != nil {
//					oldTel := p.Tel
//					p.Tel = msg.GetTel()
//					if msg.GetChangeType() == 0 {
//						if !p.IsRob {
//							//用户绑定事件
//							if oldTel == "" { //首次绑定账号
//								p.UpgradeTime = time.Now()
//								p.ReportBindPhoneEvent()
//								//p.ReportWebEvent(model.WEBEVENT_UPGRADEACC, 0, 0, 1)
//
//								//升级账号赠送
//								upgradeAccountGiveCoin := p.GetUpdateAccPrize()
//								if upgradeAccountGiveCoin > 0 && !p.layered[common.ActId_UpgradeAccount] {
//									if model.GameParamData.UpgradeAccountGiveCoinLimit != 0 && upgradeaccountcount < model.GameParamData.UpgradeAccountGiveCoinLimit {
//										p.AddCoin(int64(upgradeAccountGiveCoin), common.GainWay_UpgradeAccount, "", "")
//										//增加泥码
//										p.AddDirtyCoin(0, int64(upgradeAccountGiveCoin))
//										p.AddPayCoinLog(int64(upgradeAccountGiveCoin), model.PayCoinLogType_Coin, "system")
//										p.ReportSystemGiveEvent(upgradeAccountGiveCoin, common.GainWay_UpgradeAccount, true)
//									} else {
//										upgradeAccountGiveCoin = 0
//										sendPack(player_proto.OpResultCode_OPRC_Account_IP_TooManyReg)
//									}
//								}
//
//								//记录赠送日志
//								task.New(nil, task.CallableWrapper(func(o *basic.Object) interface{} {
//									model.InsertUpgradeAccountCoinLog(p.RegIp, time.Now(), upgradeAccountGiveCoin, p.SnId, p.Channel, p.Platform, p.BeUnderAgentCode, p.PackageID, p.City, p.InviterId)
//									return nil
//								}), nil, "InsertUpgradeAccountCoinLog").StartByFixExecutor("InsertUpgradeAccountCoinLog")
//								//正式用户的登录红包
//								//actRandCoinMgr.OnRandOnlineCoin(p)
//							}
//						}
//					}
//				}
//				sendPack(player_proto.OpResultCode_OPRC_Sucess)
//			} else {
//				logger.Logger.Warnf("UpgradeAccount err:%v", data)
//				sendPack(player_proto.OpResultCode_OPRC_Error)
//			}
//		}), "UpgradeAccount").StartByExecutor(msg.GetTel())
//	}
//
//	return nil
//}

// 绑定支付宝
type CSBindAlipayPacketFactory struct {
}
type CSBindAlipayHandler struct {
}

func (this *CSBindAlipayPacketFactory) CreatePacket() interface{} {
	pack := &player_proto.CSBindAlipay{}
	return pack
}

func (this *CSBindAlipayHandler) Process(s *netlib.Session, packetid int, data interface{}, sid int64) error {
	logger.Logger.Trace("CSBindAlipayHandler Process recv ", data)
	if msg, ok := data.(*player_proto.CSBindAlipay); ok {
		p := PlayerMgrSington.GetPlayer(sid)
		if p == nil {
			logger.Logger.Warn("CSBindAlipayHandler p == nil")
			return nil
		}

		sendPack := func(code player_proto.OpResultCode) {
			pack := &player_proto.SCBindAlipay{
				OpRetCode:     code,
				AlipayAccount: msg.AlipayAccount,
				AlipayAccName: msg.AlipayAccName,
			}
			proto.SetDefaults(pack)
			p.SendToClient(int(player_proto.PlayerPacketID_PACKET_SC_BINDALIPAY), pack)
		}
		platform := PlatformMgrSingleton.GetPlatform(p.Platform)
		if platform != nil {
			if !platform.IsMarkFlag(int32(BindAlipay)) {
				sendPack(player_proto.OpResultCode_OPRC_BindAlipay_PlatformError)
				return nil
			}
		}
		alipayAccount := msg.GetAlipayAccount()
		if alipayAccount == "" {
			sendPack(player_proto.OpResultCode_OPRC_BindAlipay_AccountEmpty)
			return nil
		}

		if !utf8.ValidString(alipayAccount) {
			sendPack(player_proto.OpResultCode_OPRC_BindAlipay_AccountIllegal)
			return nil
		}

		alipayAccName := msg.GetAlipayAccName()
		if alipayAccName == "" {
			sendPack(player_proto.OpResultCode_OPRC_BindAlipay_AccNameEmpty)
			return nil
		}

		if !utf8.ValidString(alipayAccName) {
			sendPack(player_proto.OpResultCode_OPRC_BindAlipay_AccNameIllegal)
			return nil
		}

		if platform.NeedSameName {
			if p.BankAccName != "" {
				if p.BankAccName != alipayAccName {
					sendPack(player_proto.OpResultCode_OPRC_BankAndAli_NotSame)
					return nil
				}
			}
		}

		if msg.GetPassword() == "" || len(msg.GetPassword()) < 32 {
			sendPack(player_proto.OpResultCode_OPRC_Safebox_PasswordIllegal)
			return nil
		}

		raw := fmt.Sprintf("%v%v%v", p.SafeBoxPassword, common.GetAppId(), msg.GetTimeStamp())
		h := md5.New()
		io.WriteString(h, raw)
		hashsum := hex.EncodeToString(h.Sum(nil))
		if hashsum != msg.GetPassword() {
			sendPack(player_proto.OpResultCode_OPRC_Safebox_PasswordIllegal)
			return nil
		}

		var limitCount int32
		if platform != nil && platform.PerBankNoLimitAccount != 0 {
			limitCount = platform.PerBankNoLimitAccount
		}
		var prohibit bool
		var isLimitNum bool
		//绑定支付宝账号
		task.New(nil, task.CallableWrapper(func(o *basic.Object) interface{} {
			cnt := model.CountAlipayAccountCount(p.Platform, msg.GetAlipayAccount())
			if limitCount > 0 && cnt >= int(limitCount) { //没有事务，存在容差，认为可以容忍
				prohibit = true
				return nil
			}
			if platform.PerBankNoLimitName > 0 {
				cnt := model.CountBankAlipayNameCount(p.Platform, alipayAccName, p.SnId)
				if cnt >= int(platform.PerBankNoLimitName) {
					isLimitNum = true
					return nil
				}
			}

			err := model.UpdatePlayerAlipay(p.Platform, p.SnId, alipayAccount, alipayAccName)
			if err == nil {
				model.NewBankBindLog(p.SnId, p.Platform, model.BankBindLogType_Ali, msg.GetAlipayAccName(),
					msg.GetAlipayAccount(), 1)
			}
			return err
		}), task.CompleteNotifyWrapper(func(data interface{}, t task.Task) {
			if data == nil {
				if prohibit {
					sendPack(player_proto.OpResultCode_OPRC_BindAlipay_CountLimit)
				} else if isLimitNum {
					sendPack(player_proto.OpResultCode_OPRC_BindBankAlipay_NameCountLimit)
				} else {
					p.AlipayAccount = msg.GetAlipayAccount()
					p.AlipayAccName = msg.GetAlipayAccName()
					//用户绑定支付宝事件
					p.ReportBindAlipayEvent()
					sendPack(player_proto.OpResultCode_OPRC_Sucess)
				}
			} else {
				sendPack(player_proto.OpResultCode_OPRC_Error)
			}
		}), "UpdatePlayerAlipay").StartByExecutor(strconv.Itoa(int(p.SnId)))

	}
	return nil
}

// 绑定银行卡
type CSBindBankPacketFactory struct {
}
type CSBindBankHandler struct {
}

func (this *CSBindBankPacketFactory) CreatePacket() interface{} {
	pack := &player_proto.CSBindBank{}
	return pack
}

func (this *CSBindBankHandler) Process(s *netlib.Session, packetid int, data interface{}, sid int64) error {
	logger.Logger.Trace("CSBindBankHandler Process recv ", data)
	if msg, ok := data.(*player_proto.CSBindBank); ok {
		p := PlayerMgrSington.GetPlayer(sid)
		if p == nil {
			logger.Logger.Warn("CSBindBankHandler p == nil")
			return nil
		}

		sendPack := func(code player_proto.OpResultCode) {
			pack := &player_proto.SCBindBank{
				OpRetCode:   code,
				Bank:        msg.Bank,
				BankAccount: msg.BankAccount,
				BankAccName: msg.BankAccName,
			}
			proto.SetDefaults(pack)
			p.SendToClient(int(player_proto.PlayerPacketID_PACKET_SC_BINDBANK), pack)
		}
		platform := PlatformMgrSingleton.GetPlatform(p.Platform)
		if platform != nil {
			if !platform.IsMarkFlag(int32(BindBackCard)) {
				sendPack(player_proto.OpResultCode_OPRC_BindBank_PlatformError)
				return nil
			}
		}
		bank := msg.GetBank()
		if bank == "" {
			sendPack(player_proto.OpResultCode_OPRC_BindBank_NameEmpty)
			return nil
		}

		if !utf8.ValidString(bank) {
			sendPack(player_proto.OpResultCode_OPRC_BindBank_NameIllegal)
			return nil
		}

		bankAccount := msg.GetBankAccount()
		if bankAccount == "" {
			sendPack(player_proto.OpResultCode_OPRC_BindBank_AccountEmpty)
			return nil
		}

		if !utf8.ValidString(bankAccount) {
			sendPack(player_proto.OpResultCode_OPRC_BindBank_AccountIllegal)
			return nil
		}

		bankAccName := msg.GetBankAccName()
		if bankAccName == "" {
			sendPack(player_proto.OpResultCode_OPRC_BindBank_AccNameEmpty)
			return nil
		}

		if !utf8.ValidString(bankAccName) {
			sendPack(player_proto.OpResultCode_OPRC_BindBank_AccNameIllegal)
			return nil
		}

		if platform.NeedSameName {
			if p.AlipayAccName != "" {
				if p.AlipayAccName != bankAccName {
					sendPack(player_proto.OpResultCode_OPRC_BankAndAli_NotSame)
					return nil
				}
			}
		}

		if msg.GetPassword() == "" || len(msg.GetPassword()) < 32 {
			sendPack(player_proto.OpResultCode_OPRC_Safebox_PasswordIllegal)
			return nil
		}

		raw := fmt.Sprintf("%v%v%v", p.SafeBoxPassword, common.GetAppId(), msg.GetTimeStamp())
		h := md5.New()
		io.WriteString(h, raw)
		hashsum := hex.EncodeToString(h.Sum(nil))
		if hashsum != msg.GetPassword() {
			sendPack(player_proto.OpResultCode_OPRC_Safebox_PasswordIllegal)
			return nil
		}

		if p.BankAccount != "" {
			logger.Logger.Errorf("player had bank,now modify:%v", p.SnId)
		}

		var limitCount int32
		if platform != nil && platform.PerBankNoLimitAccount != 0 {
			limitCount = platform.PerBankNoLimitAccount
		}
		var prohibit bool
		var isLimitNum bool
		//绑定银行账号
		task.New(nil, task.CallableWrapper(func(o *basic.Object) interface{} {
			cnt := model.CountBankAccountCount(p.Platform, bankAccount)
			if limitCount > 0 && cnt >= int(limitCount) { //没有事务，存在容差，认为可以容忍
				prohibit = true
				return nil
			}
			if platform.PerBankNoLimitName > 0 {
				cnt := model.CountBankAlipayNameCount(p.Platform, bankAccName, p.SnId)
				if cnt >= int(platform.PerBankNoLimitName) {
					isLimitNum = true
					return nil
				}
			}

			err := model.UpdatePlayerBank(p.Platform, p.SnId, bank, bankAccount, bankAccName)
			if err == nil {
				model.NewBankBindLog(p.SnId, p.Platform, model.BankBindLogType_Bank, bankAccName, bankAccount, 1)
			}
			return err
		}), task.CompleteNotifyWrapper(func(data interface{}, t task.Task) {
			if data == nil {
				if prohibit {
					sendPack(player_proto.OpResultCode_OPRC_BindBank_CountLimit)
				} else if isLimitNum {
					sendPack(player_proto.OpResultCode_OPRC_BindBankAlipay_NameCountLimit)
				} else {
					p.Bank = bank
					p.BankAccount = bankAccount
					p.BankAccName = bankAccName
					sendPack(player_proto.OpResultCode_OPRC_Sucess)
				}
			} else {
				sendPack(player_proto.OpResultCode_OPRC_Error)
			}
		}), "UpdatePlayerBank").StartByExecutor(strconv.Itoa(int(p.SnId)))
	}
	return nil
}

// 修改密码
type CSChangePasswordPacketFactory struct {
}
type CSChangePasswordHandler struct {
}

func (this *CSChangePasswordPacketFactory) CreatePacket() interface{} {
	pack := &player_proto.CSChangePassword{}
	return pack
}

func (this *CSChangePasswordHandler) Process(s *netlib.Session, packetid int, data interface{}, sid int64) error {
	logger.Logger.Trace("CSChangePasswordHandler Process recv ", data)
	if msg, ok := data.(*player_proto.CSChangePassword); ok {
		p := PlayerMgrSington.GetPlayer(sid)
		if p == nil {
			logger.Logger.Warn("CSChangePasswordHandler p == nil")
			return nil
		}

		sendPack := func(code player_proto.OpResultCode) {
			pack := &player_proto.SCChangePassword{
				OpRetCode:  code,
				ChangeType: msg.ChangeType,
			}
			proto.SetDefaults(pack)
			p.SendToClient(int(player_proto.PlayerPacketID_PACKET_SC_CHANGEPASSWORD), pack)
		}

		//修改类型不匹配
		if msg.GetChangeType() < 0 || msg.GetChangeType() > 2 {
			sendPack(player_proto.OpResultCode_OPRC_Error)
			return nil
		}

		//旧密码
		if msg.GetOldPassword() == "" || len(msg.GetOldPassword()) < 32 {
			if msg.GetChangeType() == 0 {
				sendPack(player_proto.OpResultCode_OPRC_UpgradeAccount_PasswordIllegal)
			} else {
				sendPack(player_proto.OpResultCode_OPRC_Safebox_PasswordIllegal)
			}
			return nil
		}

		//新密码
		if msg.GetNewPassword() == "" || len(msg.GetNewPassword()) < 32 {
			if msg.GetChangeType() == 0 {
				sendPack(player_proto.OpResultCode_OPRC_UpgradeAccount_PasswordIllegal)
			} else {
				sendPack(player_proto.OpResultCode_OPRC_Safebox_PasswordIllegal)
			}
			return nil
		}

		if msg.GetNewPassword() == msg.GetOldPassword() && msg.GetChangeType() != 2 {
			sendPack(player_proto.OpResultCode_OPRC_PasswordEqual)
			return nil
		}

		switch msg.GetChangeType() { //0：帐号密码  1：保险箱密码  2：设置保险箱密码
		case 0:
			//修改帐号密码
			task.New(nil, task.CallableWrapper(func(o *basic.Object) interface{} {
				return model.UpdatePlayerPassword(p.Platform, p.AccountId, msg.GetOldPassword(), msg.GetNewPassword())
			}), task.CompleteNotifyWrapper(func(data interface{}, t task.Task) {
				if data == nil {
					als := LoginStateMgrSington.GetLoginStateByAccId(p.AccountId)
					if als != nil && als.acc != nil {
						als.acc.TelPassWord = msg.GetNewPassword()
					}
					sendPack(player_proto.OpResultCode_OPRC_Sucess)
				} else {
					sendPack(player_proto.OpResultCode_OPRC_Error)
				}
			}), "UpdatePlayerPassword").StartByExecutor(strconv.Itoa(int(p.SnId)))
		case 1:
			//验证保险箱密码

			if p.SafeBoxPassword != msg.GetOldPassword() {
				sendPack(player_proto.OpResultCode_OPRC_Safebox_PasswordIllegal)
				return nil
			}
			//修改帐号密码
			task.New(nil, task.CallableWrapper(func(o *basic.Object) interface{} {
				return model.UpdateSafeBoxPassword(p.Platform, p.AccountId, msg.GetOldPassword(), msg.GetNewPassword())
			}), task.CompleteNotifyWrapper(func(data interface{}, t task.Task) {
				if i, ok := data.(int); ok {
					if i == 0 {
						p.SafeBoxPassword = msg.GetNewPassword()
						sendPack(player_proto.OpResultCode_OPRC_Sucess)
					} else {
						sendPack(player_proto.OpResultCode_OPRC_Error)
					}
				}
			}), "UpdatePlayerPassword").StartByExecutor(strconv.Itoa(int(p.SnId)))
		case 2:
			//验证保险箱密码
			/*raw := fmt.Sprintf("%v%v%v", p.SafeBoxPassword, common.GetAppId(), msg.GetTimeStamp())
			h := md5.New()
			io.WriteString(h, raw)
			hashsum := hex.EncodeToString(h.Sum(nil))
			if hashsum != msg.GetOldPassword() {
				sendPack(player_proto.OpResultCode_OPRC_Safebox_PasswordIllegal)
				return nil
			}*/
			raw := fmt.Sprintf("%v%v", model.DEFAULT_PLAYER_SAFEBOX_PWD, common.GetAppId())
			h := md5.New()
			io.WriteString(h, raw)
			pwd := hex.EncodeToString(h.Sum(nil))

			//修改帐号密码
			task.New(nil, task.CallableWrapper(func(o *basic.Object) interface{} {
				return model.UpdateSafeBoxPassword(p.Platform, p.AccountId, pwd, msg.GetNewPassword())
			}), task.CompleteNotifyWrapper(func(data interface{}, t task.Task) {
				if i, ok := data.(int); ok {
					if i == 0 {
						p.SafeBoxPassword = msg.GetNewPassword()
						sendPack(player_proto.OpResultCode_OPRC_Sucess)
					} else {
						sendPack(player_proto.OpResultCode_OPRC_Error)
					}
				}
			}), "UpdatePlayerPassword").StartByExecutor(strconv.Itoa(int(p.SnId)))
		}
		//sendPack(player_proto.OpResultCode_OPRC_Sucess)
	}
	return nil
}

// 操作保险箱
type CSPlayerSafeBoxPacketFactory struct {
}
type CSPlayerSafeBoxHandler struct {
}

func (this *CSPlayerSafeBoxPacketFactory) CreatePacket() interface{} {
	pack := &player_proto.CSPlayerOpCoin{}
	return pack
}

func (this *CSPlayerSafeBoxHandler) Process(s *netlib.Session, packetid int, data interface{}, sid int64) error {
	logger.Logger.Trace("CSPlayerSafeBoxHandler Process recv ", data)
	if msg, ok := data.(*player_proto.CSPlayerOpCoin); ok {
		p := PlayerMgrSington.GetPlayer(sid)
		if p == nil {
			logger.Logger.Warn("CSPlayerSafeBoxHandler p == nil")
			return nil
		}
		if p.scene != nil {
			logger.Logger.Warn("CSPlayerSafeBoxHandler p.scene != nil")
			return nil
		}
		sendPack := func(code player_proto.OpResultCode) {
			pack := &player_proto.SCPlayerOpCoin{
				OpRetCode:   code,
				Op:          msg.Op,
				Coin:        proto.Int64(p.Coin),
				SafeBoxCoin: proto.Int64(p.SafeBoxCoin),
			}
			proto.SetDefaults(pack)
			p.SendToClient(int(player_proto.PlayerPacketID_PACKET_SC_PLAYEROPCOIN), pack)
		}
		if msg.GetCoin() <= 0 {
			sendPack(player_proto.OpResultCode_OPRC_Error)
			return nil
		}
		snid := p.SnId
		beforeCoin := p.Coin
		beforeBank := p.SafeBoxCoin
		afterCoin := p.Coin
		afterBank := p.SafeBoxCoin
		if msg.GetOp() == model.SafeBoxLogType_Save {
			//验证金币
			if p.Coin < msg.GetCoin() {
				sendPack(player_proto.OpResultCode_OPRC_CoinNotEnough)
				return nil
			}
			//计算日志数据
			afterCoin = p.Coin - msg.GetCoin()
			afterBank = p.SafeBoxCoin + msg.GetCoin()
			//操作数据
			p.SafeBoxCoin += msg.GetCoin()
			p.AddCoin(-msg.GetCoin(), 0, common.GainWay_SafeBoxSave, "system", "保险箱存入")
			p.dirty = true
		} else if msg.GetOp() == model.SafeBoxLogType_TakeOut {
			//验证金币
			if p.SafeBoxCoin < msg.GetCoin() {
				sendPack(player_proto.OpResultCode_OPRC_CoinNotEnough)
				return nil
			}
			//验证密码
			if msg.GetPassword() == "" || len(msg.GetPassword()) < 32 {
				sendPack(player_proto.OpResultCode_OPRC_Safebox_PasswordIllegal)
				return nil
			}
			hashsum := common.MakeMd5String(p.SafeBoxPassword, common.GetAppId(), strconv.Itoa(int(msg.GetTimeStamp())))
			if hashsum != msg.GetPassword() {
				sendPack(player_proto.OpResultCode_OPRC_SafeBoxPasswordError)
				return nil
			}
			//计算日志数据
			afterCoin = p.Coin + msg.GetCoin()
			afterBank = p.SafeBoxCoin - msg.GetCoin()
			//操作数据
			p.SafeBoxCoin -= msg.GetCoin()
			p.AddCoin(msg.GetCoin(), 0, common.GainWay_SafeBoxTakeOut, "system", "保险箱取出")
			p.dirty = true
		}

		p.SendDiffData()
		sendPack(player_proto.OpResultCode_OPRC_Sucess)
		var oper string
		var logs []*model.PayCoinLog
		var coinPayts int64
		var safePayts int64
		billNo := time.Now().UnixNano()
		if msg.GetOp() == model.SafeBoxLogType_Save {
			log := model.NewPayCoinLog(billNo, p.SnId, msg.GetCoin(), 0, "system", model.PayCoinLogType_SafeBoxCoin, 0)
			if log != nil {
				safePayts = log.TimeStamp
				logs = append(logs, log)
			}
			billNo += 1
			log = model.NewPayCoinLog(billNo, p.SnId, -msg.GetCoin(), 0, "system", model.PayCoinLogType_Coin, 0)
			if log != nil {
				coinPayts = log.TimeStamp
				logs = append(logs, log)
			}
			oper = "保险箱存入"
		} else if msg.GetOp() == model.SafeBoxLogType_TakeOut {
			log := model.NewPayCoinLog(billNo, p.SnId, -msg.GetCoin(), 0, "system", model.PayCoinLogType_SafeBoxCoin, 0)
			if log != nil {
				safePayts = log.TimeStamp
				logs = append(logs, log)
			}
			billNo += 1
			log = model.NewPayCoinLog(billNo, p.SnId, msg.GetCoin(), 0, "system", model.PayCoinLogType_Coin, 0)
			if log != nil {
				coinPayts = log.TimeStamp
				logs = append(logs, log)
			}
			oper = "保险箱取出"
		}
		isNeedRollBack := true
		task.New(nil, task.CallableWrapper(func(o *basic.Object) interface{} {

			err := model.InsertPayCoinLogs(p.Platform, logs...)
			if err != nil {
				logger.Logger.Trace("InsertPayCoinLogs err:", err)
				return err
			}
			err, _ = model.InsertSafeBox(p.SnId, msg.GetCoin(), beforeBank, afterBank, beforeCoin, afterCoin,
				msg.GetOp(), time.Now(), p.Ip, oper, p.Platform, p.Channel, p.BeUnderAgentCode)
			if err != nil {
				isNeedRollBack = false
			}
			return err
		}), task.CompleteNotifyWrapper(func(data interface{}, t task.Task) {
			if data != nil && isNeedRollBack {
				//如果保存失败，并不会回滚玩家的数据，主要原因时无法回滚，如果回滚就需要先扣后补，因为只是在玩家身上流转，
				//所以可以可以不考虑回滚问题
				logger.Logger.Errorf("Player %v box coin op log error.", snid)
			} else {
				p.SetPayTs(coinPayts)
				p.SetSafeBoxPayTs(safePayts)
				p.dirty = true
			}
		}), oper).StartByExecutor(strconv.Itoa(int(p.SnId)))
	}
	return nil
}

// 读取保险箱记录
type CSPlayerSafeBoxCoinLogPacketFactory struct {
}
type CSPlayerSafeBoxCoinLogHandler struct {
}

func (this *CSPlayerSafeBoxCoinLogPacketFactory) CreatePacket() interface{} {
	pack := &player_proto.CSGetSafeBoxCoinLog{}
	return pack
}

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

		pack := &player_proto.SCGetSafeBoxCoinLog{}

		sendPack := func(code player_proto.OpResultCode) {
			pack.OpRetCode = code
			proto.SetDefaults(pack)
			p.SendToClient(int(player_proto.PlayerPacketID_PACKET_SC_GETSAFEBOXCOINLOG), pack)
		}

		task.New(nil, task.CallableWrapper(func(o *basic.Object) interface{} {
			if sblist, err := model.GetSafeBoxs(p.Platform, p.SnId); err == nil {
				return sblist
			} else {
				sendPack(player_proto.OpResultCode_OPRC_Error)
				return nil
			}
		}), task.CompleteNotifyWrapper(func(data interface{}, t task.Task) {
			if safeboxrec, ok := data.([]model.SafeBoxRec); ok {
				for i := 0; i < len(safeboxrec); i++ {
					safeBoxInfo := &player_proto.SafeBoxCoinLog{
						LogType:     proto.Int32(safeboxrec[i].LogType),
						OPCoin:      proto.Int64(safeboxrec[i].Count),
						OPCoinFront: proto.Int64(safeboxrec[i].BeforeSafeBox),
						OPCoinLast:  proto.Int64(safeboxrec[i].AfterSafeBox),
						Ts:          proto.Int64(safeboxrec[i].Time.Unix()),
					}
					pack.Logs = append(pack.Logs, safeBoxInfo)
				}
				sendPack(player_proto.OpResultCode_OPRC_Sucess)
			} else {
				sendPack(player_proto.OpResultCode_OPRC_Error)
			}
		}), "GetSafeBoxCoinLog").StartByExecutor(strconv.Itoa(int(p.SnId)))
	}
	return nil
}

//
////读取游戏记录
//type CSPlayerGameCoinLogPacketFactory struct {
//}
//type CSPlayerGameCoinLogHandler struct {
//}
//
//func (this *CSPlayerGameCoinLogPacketFactory) CreatePacket() interface{} {
//	pack := &player_proto.CSGetGameCoinLog{}
//	return pack
//}
//
//func (this *CSPlayerGameCoinLogHandler) Process(s *netlib.Session, packetid int, data interface{}, sid int64) error {
//	logger.Logger.Trace("CSPlayerGameCoinLogHandler Process recv ", data)
//	if _, ok := data.(*player_proto.CSGetGameCoinLog); ok {
//		p := PlayerMgrSington.GetPlayer(sid)
//		if p == nil {
//			logger.Logger.Warn("CSPlayerGameCoinLogHandler p == nil")
//			return nil
//		}
//		//model.InsertGameRecList(p.SnId, 0, 20, p.entercoin, p.Coin, p.enterts, time.Now())
//		pack := &player_proto.SCGetGameCoinLog{}
//		sendPack := func(code player_proto.OpResultCode) {
//			pack.OpRetCode = code
//			proto.SetDefaults(pack)
//			p.SendToClient(int(player_proto.PlayerPacketID_PACKET_SC_GETGAMECOINLOG), pack)
//		}
//		task.New(nil, task.CallableWrapper(func(o *basic.Object) interface{} {
//			if glist, err := model.GetGameRecLogs(p.SnId); err == nil {
//				return glist
//			} else {
//				sendPack(player_proto.OpResultCode_OPRC_Error)
//				return nil
//			}
//		}), task.CompleteNotifyWrapper(func(data interface{}, t *task.Task) {
//			if gamelist, ok := data.([]model.GameRecLog); ok {
//				for i := 0; i < len(gamelist); i++ {
//					gameInfo := &player_proto.GameCoinLog{
//						GameId:     proto.Int32(gamelist[i].GameId),
//						EnterCount: proto.Int64(gamelist[i].EnterCount),
//						LeaveCount: proto.Int64(gamelist[i].LeaveCount),
//						EnterTs:    proto.Int64(gamelist[i].EnterTs.Unix()),
//						LeaveTs:    proto.Int64(gamelist[i].LeaveTs.Unix()),
//					}
//					pack.Logs = append(pack.Logs, gameInfo)
//				}
//				sendPack(player_proto.OpResultCode_OPRC_Sucess)
//			} else {
//				sendPack(player_proto.OpResultCode_OPRC_Error)
//			}
//		}), "GetSafeBoxCoinLog").StartByExecutor(p.AccountId)
//	}
//	return nil
//}

// 注册帐号
type CSPlayerRegisterPacketFactory struct {
}
type CSPlayerRegisterHandler struct {
}

func (this *CSPlayerRegisterPacketFactory) CreatePacket() interface{} {
	pack := &player_proto.CSRegister{}
	return pack
}

func (this *CSPlayerRegisterHandler) Process(s *netlib.Session, packetid int, data interface{}, sid int64) error {
	logger.Logger.Trace("CSPlayerRegisterHandler Process recv ", data)
	if t, ok := data.(*player_proto.CSRegister); ok {
		sendPack := func(code player_proto.OpResultCode) {
			pack := &player_proto.SCRegister{
				OpRetCode: code,
			}
			proto.SetDefaults(pack)
			common.SendToGate(sid, int(player_proto.PlayerPacketID_PACKET_SC_REGISTER), pack, s)
		}

		//替换为后台拿到的配置数据，不再使用客户端的发送数据,
		platformID, _, promoter, _, tagkey := PlatformMgrSingleton.GetPlatformByPackageTag(t.GetPlatformTag())
		if platformID == 0 {
			sendPack(player_proto.OpResultCode_OPRC_Error)
			return nil
		}
		var loginType int32
		//手机号注册，验证参数
		if t.GetRegistType() == 0 {
			loginType = common.RegisterTypeTel
			//检验手机号合法
			tel := t.GetTel()
			if !reTelRule.MatchString(tel) {
				sendPack(player_proto.OpResultCode_OPRC_TelError)
				return nil
			}

			//验证验证码
			platform := PlatformMgrSingleton.GetPlatform(strconv.Itoa(int(platformID)))
			if !platform.RegisterVerifyCodeSwitch {
				if platform.VerifyCodeType != common.CodeTypeNo { // 不使用验证码注册
					code := CacheMemory.Get(fmt.Sprintf("%v_%v", tel, tagkey))
					if code == nil {
						sendPack(player_proto.OpResultCode_OPRC_VerificationCodeError)
						return nil
					}
					if verifyCode, ok := code.(string); ok && verifyCode != "" {
						if verifyCode != t.GetVerificationCode() {
							sendPack(player_proto.OpResultCode_OPRC_VerificationCodeError)
							return nil
						}
					}
				}
			}

			//验证密码
			if t.GetTelPassword() == "" || len(t.GetTelPassword()) < 32 {
				sendPack(player_proto.OpResultCode_OPRC_UpgradeAccount_PasswordIllegal)
				return nil
			}
			if t.GetPassword() == "" || len(t.GetPassword()) < 32 {
				sendPack(player_proto.OpResultCode_OPRC_UpgradeAccount_PasswordIllegal)
				return nil
			}
		} else {
			// username,telpassword
			loginType = common.RegisterTypeName
			if t.GetUsername() == "" {
				sendPack(player_proto.OpResultCode_OPRC_UserNameError)
				return nil
			}
			//验证密码
			if t.GetTelPassword() == "" || len(t.GetTelPassword()) < 32 {
				sendPack(player_proto.OpResultCode_OPRC_UpgradeAccount_PasswordIllegal)
				return nil
			}
		}

		//backupPromoter := ""

		strPlatform := strconv.Itoa(int(platformID))
		if t.GetChannel() != common.Channel_Rob {
			t.Platform = proto.String(strPlatform)
			//因为后台需要，修改此方法，修改为客户端传递的数据
			if len(t.GetPromoter()) <= 0 {
				t.Promoter = proto.String(strconv.Itoa(int(promoter)))
			} else {
				//backupPromoter = t.GetPromoter()
			}
		}

		plt := PlatformMgrSingleton.GetPlatform(strPlatform)
		//if plt != nil {
		//	amount += plt.NewAccountGiveCoin
		//	amount += plt.UpgradeAccountGiveCoin
		//}

		var temp []byte
		var ee error
		di := t.GetDeviceInfo()
		if plt.NeedDeviceInfo && di == "" { //maybe res ver is low
			sendPack(player_proto.OpResultCode_OPRC_YourResVerIsLow)
			return nil
		}

		if di != "" {
			var e common.Encryptor
			e.Init(common.GetAppId(), t.GetPlatformTag(), int32(t.GetTimeStamp()))
			temp, ee = base64.StdEncoding.DecodeString(di)
			if ee != nil {
				sendPack(player_proto.OpResultCode_OPRC_YourResVerIsLow)
				return nil
			}

			e.Encrypt(temp, len(temp))

			if model.GameParamData.ValidDeviceInfo && !json.Valid(temp) {
				sendPack(player_proto.OpResultCode_OPRC_YourResVerIsLow)
				return nil
			}
		}

		deviceInfo := string(temp)
		if bi, ok := BlackListMgrSington.CheckDeviceInBlack(deviceInfo, BlackState_Login, t.GetPlatform()); ok {
			sendPack(player_proto.OpResultCode_OPRC_InBlackList)
			if bi != nil {
				common.SendToGate(sid, int(player_proto.PlayerPacketID_PACKET_SC_SRVMSG), common.CreateSrvMsg(common.SRVMSG_CODE_DEFAULT, i18n.Tr("languages", "BlackListLimit1Args", bi.Id, bi.Id, bi.Id, bi.Id)), s)
			}
			return nil
		}

		var pi *model.PlayerData
		var acc *model.Account
		//var promoterCfg *PromoterConfig
		//var invitePromoterID string
		var tf bool
		task.New(nil, task.CallableWrapper(func(o *basic.Object) interface{} {
			_, code := model.AccountIsExist(t.GetUsername(), t.GetTel(), t.GetPassword(), t.GetPlatform(), t.GetTimeStamp(),
				loginType, tagkey, false, false)
			if code == common.LoginTelExist {
				//手机号已经注册
				return player_proto.OpResultCode_OPRC_TelIsRegister
			}
			if code == common.RegisterExist {
				//账号密码已经注册
				return player_proto.OpResultCode_OPRC_Login_CreateFailed
			}
			if code == common.RegisterNotExist {
				//新帐号,游客
				raw := fmt.Sprintf("%v%v", t.GetUsername(), common.GetAppId())
				h := md5.New()
				io.WriteString(h, raw)
				pwd := hex.EncodeToString(h.Sum(nil))
				clientVer := t.GetClientVer()
				if clientVer < 0 {
					clientVer = model.GameParamData.ClientVersion
				}
				acc = &model.Account{}
				//可以帐号密码登录，也可以游客登录
				acc, code = model.InsertAccount(&model.InsertAccountParam{
					Platform:    t.GetPlatform(),
					UserName:    t.GetUsername(),
					Password:    pwd,
					TelPassword: t.GetTelPassword(),
					Channel:     t.GetChannel(),
					Params:      t.GetParams(),
					DeviceOs:    "",
					DeviceInfo:  t.GetDeviceInfo(),
					ChannelId:   t.GetChannelID(),
					AccountType: 0,
					Tel:         t.GetTel(),
					ClientVer:   clientVer,
				})
				if code != common.InsertAccountOk {
					return player_proto.OpResultCode_OPRC_Error
				}
				//生成玩家数据
				pi, tf = model.InsertPlayerData(&model.InsertPlayerDataParam{
					Plt:      acc.Platform,
					AccId:    acc.AccountId.Hex(),
					NickName: "",
					HeadUrl:  niceIdMgr.GetRobHeadUrlIdx(),
				})
				if pi == nil || tf == false {
					return player_proto.OpResultCode_OPRC_Error
				}
			} else {
				logger.Logger.Tracef("CSPlayerRegister Player code:%v", code)
				return player_proto.OpResultCode_OPRC_Error
			}

			if pi != nil && pi.InviterId != 0 {
				invitePd := model.GetPlayerBaseInfo(pi.Platform, pi.InviterId)
				if invitePd != nil {
					//invitePromoterID = invitePd.BeUnderAgentCode
				}
			}

			//新号赠送初始金额
			err2 := model.UpdatePlayerCoin(pi.Platform, pi.SnId, pi.Coin+int64(model.GameParamData.NewPlayerCoin), 0, 0, time.Now().Unix(), time.Now().Unix(), 0, pi.ShopID)
			if err2 == nil {
				if !pi.IsRob {
					mq.Write(model.GenerateSystemFreeGive(pi.SnId, pi.Name, pi.Platform, pi.Channel, model.SystemFreeGive_GiveType_NewPlayer, model.SystemFreeGive_CoinType_Coin, int64(model.GameParamData.NewPlayerCoin)))
				}
				log := model.NewCoinLogEx(&model.CoinLogParam{
					Platform:   pi.Platform,
					SnID:       pi.SnId,
					Channel:    pi.Channel,
					ChangeType: common.BillTypeCoin,
					ChangeNum:  int64(model.GameParamData.NewPlayerCoin),
					RemainNum:  pi.Coin + int64(model.GameParamData.NewPlayerCoin),
					Add:        0,
					LogType:    common.GainWay_NewPlayer,
					GameID:     0,
					GameFreeID: 0,
					BaseCoin:   0,
					Operator:   "",
					Remark:     "",
				})
				if log != nil {
					mq.Write(log)
				}
			}
			return player_proto.OpResultCode_OPRC_Sucess
		}), task.CompleteNotifyWrapper(func(data interface{}, tt task.Task) {
			if code, ok := data.(player_proto.OpResultCode); ok {
				if code != player_proto.OpResultCode_OPRC_Sucess {
					sendPack(code)
					return
				}
			}
			//清理掉cache中的无效id
			PlayerCacheMgrSingleton.UnCacheInvalidPlayerId(pi.SnId)
			sendPack(player_proto.OpResultCode_OPRC_Sucess)
		}), "PlayerRegister").StartByExecutor(t.GetUsername())
	}
	return nil
}

type CSCustomerNewMsgAckPacketFactory struct {
}

type CSCustomerNewMsgAckHandler struct {
}

func (this *CSCustomerNewMsgAckPacketFactory) CreatePacket() interface{} {
	pack := &player_proto.CSCustomerNewMsgAck{}
	return pack
}

func (this *CSCustomerNewMsgAckHandler) Process(s *netlib.Session, packetid int, data interface{}, sid int64) error {
	logger.Logger.Trace("CSCustomerNewMsgAckHandler Process recv ", data)
	//if msg, ok := data.(*player_proto.CSCustomerNewMsgAck); ok {
	//	p := PlayerMgrSington.GetPlayer(sid)
	//	if p == nil {
	//		logger.Logger.Warn("CSCustomerNewMsgAckHandler p == nil")
	//		return nil
	//	}
	//
	//	CustomerOfflineMsgMgrSington.OnOfflineMsgAck(p.SnId, msg.GetMsgIds())
	//}
	return nil
}

type CSIosInstallStablePacketFactory struct {
}

type CSIosInstallStableHandler struct {
}

func (this *CSIosInstallStablePacketFactory) CreatePacket() interface{} {
	pack := &player_proto.CSIosInstallStable{}
	return pack
}

func (this *CSIosInstallStableHandler) Process(s *netlib.Session, packetid int, data interface{}, sid int64) error {
	logger.Logger.Trace("CSIosInstallStableHandler Process recv ", data)
	//if _, ok := data.(*player_proto.CSIosInstallStable); ok {
	//	p := PlayerMgrSington.GetPlayer(sid)
	//	if p == nil {
	//		logger.Logger.Warn("CSIosInstallStableHandler p == nil")
	//		return nil
	//	}
	//
	//	if p.CoinPayTotal < int64(model.GameParamData.IosStablePrizeMinRecharge) { //不满足最低充值需求
	//		return nil
	//	}
	//	if p.DeviceOS != "ios" { //不是苹果系统，直接忽略
	//		return nil
	//	}
	//	if p.IosStableState != model.IOSSTABLESTATE_NIL { //未标注过才行
	//		return nil
	//	}
	//
	//	p.IosStableState = model.IOSSTABLESTATE_MARK
	//	p.dirty = true
	//}
	return nil
}

// 查询中奖
type CSFishJackpotPacketFactory struct {
}
type CSFishJackpotHandler struct {
}

func (this *CSFishJackpotPacketFactory) CreatePacket() interface{} {
	pack := &player_proto.CSJackpotList{}
	return pack
}
func (this *CSFishJackpotHandler) Process(s *netlib.Session, packetid int, data interface{}, sid int64) error {
	logger.Logger.Trace("CSFishJackpotHandler Process recv ", data)
	if _, ok := data.(*player_proto.CSJackpotList); ok {
		player := PlayerMgrSington.GetPlayer(sid)
		if player == nil {
			logger.Logger.Warn("CSFishJackpotHandler p == nil")
			return nil
		}

		pack := &player_proto.SCJackpotList{}

		datas := FishJackListMgr.GetJackInfo(player.Platform)
		for _, v := range datas {
			info := &player_proto.FishJackpotInfo{
				Name: proto.String(v.Name),
				Coin: proto.Int64(v.JackpotCoin),
				Type: proto.Int32(v.JackpotType),
				Ts:   proto.Int64(v.Ts),
			}
			pack.JackpotList = append(pack.JackpotList, info)
		}
		logger.Logger.Trace("CSFishJackpotHandler Pb  ", pack)
		player.SendToClient(int(player_proto.PlayerPacketID_PACKET_SC_FISHJACKPOTCOIN), pack)

		return nil
	}
	return nil
}

// 查询奖池金额
type CSFishJackpotCoinPacketFactory struct {
}
type CSFishJackpotCoinHandler struct {
}

func (this *CSFishJackpotCoinPacketFactory) CreatePacket() interface{} {
	pack := &player_proto.CSFishJackpotCoin{}
	return pack
}
func (this *CSFishJackpotCoinHandler) Process(s *netlib.Session, packetid int, data interface{}, sid int64) error {
	logger.Logger.Trace("CSFishJackpotCoinHandler Process recv ", data)
	if _, ok := data.(*player_proto.CSFishJackpotCoin); ok {
		player := PlayerMgrSington.GetPlayer(sid)
		if player == nil {
			logger.Logger.Warn("CSFishJackpotCoinHandler p == nil")
			return nil
		}

		pack := &player_proto.SCFishJackpotCoin{}
		if datas, exist := FishJackpotCoinMgr.Jackpot[player.Platform]; exist {
			pack.Coin = proto.Int64(datas + 234982125)
			//pack.Coin = proto.Int64(datas)
		} else {
			pack.Coin = proto.Int64(234982125) // 假数据
			//pack.Coin = proto.Int64(0) // 假数据
		}
		logger.Logger.Trace("CSFishJackpotCoinHandler Pb  ", pack)
		player.SendToClient(int(player_proto.PlayerPacketID_PACKET_SC_FISHJACKPOTDATA), pack)

		return nil
	}
	return nil
}

// 全民是否打开
type CSGetSpreadIsOpenPacketFactory struct {
}
type CSGetSpreadIsOpenHandler struct {
}

func (this *CSGetSpreadIsOpenPacketFactory) CreatePacket() interface{} {
	pack := &player_proto.CSGetSpreadLWIsOpen{}
	return pack
}

func (this *CSGetSpreadIsOpenHandler) Process(s *netlib.Session, packetid int, data interface{}, sid int64) error {
	logger.Logger.Trace("CSGetSpreadIsOpenHandler Process recv ", data)
	if _, ok := data.(*player_proto.CSGetSpreadLWIsOpen); ok {
		p := PlayerMgrSington.GetPlayer(sid)
		if p == nil {
			logger.Logger.Warn("CSGetSpreadIsOpenHandler p == nil")
			return nil
		}
		plt := PlatformMgrSingleton.GetPlatform(p.Platform)
		if plt == nil {

			return nil
		}

		pack := &player_proto.SCGetSpreadLWIsOpen{}
		if plt.SpreadWinLose {
			pack.IsOpen = proto.Int32(1)
		} else {
			pack.IsOpen = proto.Int32(0)
		}
		proto.SetDefaults(pack)
		p.SendToClient(int(player_proto.PlayerPacketID_PACKET_SC_GetSpreadLWIsOpen), pack)

		//sendPack(player_proto.OpResultCode_OPRC_Sucess)
	}
	return nil
}

// 玩家设置 音乐音效客户端修改 目前功能只有兑换码
type CSPlayerSettingPacketFactory struct {
}
type CSPlayerSettingHandler struct {
}

func (this *CSPlayerSettingPacketFactory) CreatePacket() interface{} {
	pack := &player_proto.CSPlayerSetting{}
	return pack
}

func (this *CSPlayerSettingHandler) Process(s *netlib.Session, packetid int, data interface{}, sid int64) error {
	logger.Logger.Trace("CSPlayerSettingHandler Process recv ", data)
	if msg, ok := data.(*player_proto.CSPlayerSetting); ok {
		p := PlayerMgrSington.GetPlayer(sid)
		if p == nil {
			logger.Logger.Warn("CSPlayerSettingHandler p == nil")
			return nil
		}

		//p.SCVIPInfo()
		//p.SCVIPBuy(int64(10))
		//p.VIPDraw(3)
		pack := &player_proto.SCPlayerSetting{
			OpRetCode: player_proto.OpResultCode_OPRC_Jyb_CodeErr,
		}

		if msg.PackageCode != "" {
			args := &model.VerifyUpJybInfoArgs{
				UseCode: msg.PackageCode,
				Plt:     p.Platform,
				SnId:    p.SnId,
			}
			if len(msg.PackageCode) < 12 { // 通用
				args.CodeType = 1
			} else {
				key, err := model.Code2Id(msg.PackageCode)
				if err != nil || key < uint64(model.Keystart) {
					pack.OpRetCode = player_proto.OpResultCode_OPRC_Jyb_CodeErr
					proto.SetDefaults(pack)
					p.SendToClient(int(player_proto.PlayerPacketID_PACKET_ALL_SETTING), pack)
					return nil
				}

				start := uint64(model.Keystart)
				args.CodeStart = int64(key / start * start) // 过滤
				args.CodeType = 2
			}
			BagMgrSingleton.VerifyUpJybInfo(p, args)

		} else {
			proto.SetDefaults(pack)
			p.SendToClient(int(player_proto.PlayerPacketID_PACKET_ALL_SETTING), pack)
		}
	}
	return nil
}

// 充值VIP 后续要删掉
type CSPlayerVIPBuyPacketFactory struct {
}
type CSPlayerVIPBuyHandler struct {
}

func (this *CSPlayerVIPBuyPacketFactory) CreatePacket() interface{} {
	pack := &player_proto.CSVIPBuy{}
	return pack
}

func (this *CSPlayerVIPBuyHandler) Process(s *netlib.Session, packetid int, data interface{}, sid int64) error {
	logger.Logger.Trace("CSVIPBuy Process recv ", data)
	//if msg, ok := data.(*player_proto.CSVIPBuy); ok {
	//	p := PlayerMgrSington.GetPlayer(sid)
	//	if p == nil {
	//		logger.Logger.Warn("CSPlayerVIPBuyHandler p == nil")
	//		return nil
	//	}
	//
	//	p.SCVIPBuy(int64(msg.GetMoney()))
	//}
	return nil
}

// VIP信息
type CSPlayerVIPInfoPacketFactory struct {
}
type CSPlayerVIPInfoHandler struct {
}

func (this *CSPlayerVIPInfoPacketFactory) CreatePacket() interface{} {
	pack := &player_proto.CSVIPInfo{}
	return pack
}

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

// 玩家领取VIP礼包
type CSPlayerVIPDrawPacketFactory struct {
}
type CSPlayerVIPDrawHandler struct {
}

func (this *CSPlayerVIPDrawPacketFactory) CreatePacket() interface{} {
	pack := &player_proto.CSVIPDraw{}
	return pack
}

func (this *CSPlayerVIPDrawHandler) Process(s *netlib.Session, packetid int, data interface{}, sid int64) error {
	logger.Logger.Trace("CSVIPDraw Process recv ", data)
	if msg, ok := data.(*player_proto.CSVIPDraw); ok {
		p := PlayerMgrSington.GetPlayer(sid)
		if p == nil {
			logger.Logger.Warn("CSPlayerVIPDrawHandler p == nil")
			return nil
		}

		p.VIPDraw(msg.GetId(), msg.GetVip())
	}
	return nil
}

// 玩家领取VIP礼包
type CSVIPPrivilegeInfoPacketFactory struct {
}
type CSVIPPrivilegeInfoHandler struct {
}

func (this *CSVIPPrivilegeInfoPacketFactory) CreatePacket() interface{} {
	pack := &player_proto.CSVIPPrivilegeInfo{}
	return pack
}

func (this *CSVIPPrivilegeInfoHandler) Process(s *netlib.Session, packetid int, data interface{}, sid int64) error {
	logger.Logger.Trace("CSVIPPrivilegeInfoHandler Process recv ", data)
	if msg, ok := data.(*player_proto.CSVIPPrivilegeInfo); ok {
		p := PlayerMgrSington.GetPlayer(sid)
		if p == nil {
			logger.Logger.Warn("CSVIPPrivilegeInfoHandler p == nil")
			return nil
		}
		code := msg.GetCode()
		pack := &player_proto.SCVIPPrivilegeInfo{
			Code: proto.Int32(code),
			Vip:  proto.Int32(p.VIP),
		}
		switch code {
		case 1: //1.VIP比赛场免费次数
			pack.Value = p.GetMatchFreeTimes() + p.GetSkillAdd(common.SkillIdVipTimes)
			pack.NowValue = p.VipMatchTimes
		}
		p.SendToClient(int(player_proto.PlayerPacketID_PACKET_SC_VIPPrivilegeInfo), pack)
	}
	return nil
}

func init() {
	//修改昵称信息
	common.RegisterHandler(int(player_proto.PlayerPacketID_PACKET_CS_CHANGENICK), &CSPlayerChangeNickHandler{})
	netlib.RegisterFactory(int(player_proto.PlayerPacketID_PACKET_CS_CHANGENICK), &CSPlayerChangeNickPacketFactory{})
	//修改头像信息
	common.RegisterHandler(int(player_proto.PlayerPacketID_PACKET_CS_CHANGEICON), &CSPlayerChangeIconHandler{})
	netlib.RegisterFactory(int(player_proto.PlayerPacketID_PACKET_CS_CHANGEICON), &CSPlayerChangeIconPacketFactory{})
	//修改头像框信息
	common.RegisterHandler(int(player_proto.PlayerPacketID_PACKET_CS_HEADOUTLINE), &CSPlayerChangeHeadOutLineHandler{})
	netlib.RegisterFactory(int(player_proto.PlayerPacketID_PACKET_CS_HEADOUTLINE), &CSPlayerChangeHeadOutLinePacketFactory{})
	//修改性别信息
	common.RegisterHandler(int(player_proto.PlayerPacketID_PACKET_CS_CHANGESEX), &CSPlayerChangeSexHandler{})
	netlib.RegisterFactory(int(player_proto.PlayerPacketID_PACKET_CS_CHANGESEX), &CSPlayerChangeSexPacketFactory{})
	//绑定支付宝账号
	common.RegisterHandler(int(player_proto.PlayerPacketID_PACKET_CS_BINDALIPAY), &CSBindAlipayHandler{})
	netlib.RegisterFactory(int(player_proto.PlayerPacketID_PACKET_CS_BINDALIPAY), &CSBindAlipayPacketFactory{})
	//绑定银行卡账号
	common.RegisterHandler(int(player_proto.PlayerPacketID_PACKET_CS_BINDBANK), &CSBindBankHandler{})
	netlib.RegisterFactory(int(player_proto.PlayerPacketID_PACKET_CS_BINDBANK), &CSBindBankPacketFactory{})
	//更改密码
	common.RegisterHandler(int(player_proto.PlayerPacketID_PACKET_CS_CHANGEPASSWORD), &CSChangePasswordHandler{})
	netlib.RegisterFactory(int(player_proto.PlayerPacketID_PACKET_CS_CHANGEPASSWORD), &CSChangePasswordPacketFactory{})
	//保险箱存取
	common.RegisterHandler(int(player_proto.PlayerPacketID_PACKET_CS_PLAYEROPCOIN), &CSPlayerSafeBoxHandler{})
	netlib.RegisterFactory(int(player_proto.PlayerPacketID_PACKET_CS_PLAYEROPCOIN), &CSPlayerSafeBoxPacketFactory{})
	//读取保险箱记录
	common.RegisterHandler(int(player_proto.PlayerPacketID_PACKET_CS_GETSAFEBOXCOINLOG), &CSPlayerSafeBoxCoinLogHandler{})
	netlib.RegisterFactory(int(player_proto.PlayerPacketID_PACKET_CS_GETSAFEBOXCOINLOG), &CSPlayerSafeBoxCoinLogPacketFactory{})
	//注册帐号
	common.RegisterHandler(int(player_proto.PlayerPacketID_PACKET_CS_REGISTER), &CSPlayerRegisterHandler{})
	netlib.RegisterFactory(int(player_proto.PlayerPacketID_PACKET_CS_REGISTER), &CSPlayerRegisterPacketFactory{})
	//获取邀请码
	common.RegisterHandler(int(player_proto.PlayerPacketID_PACKET_CS_INVITECODE), &CSInviteCodePlayerHandler{})
	netlib.RegisterFactory(int(player_proto.PlayerPacketID_PACKET_CS_INVITECODE), &CSInviteCodePlayerPacketFactory{})
	//客服离线消息接收ack
	common.RegisterHandler(int(player_proto.PlayerPacketID_PACKET_CS_CUSTOMNEWMSGACK), &CSCustomerNewMsgAckHandler{})
	netlib.RegisterFactory(int(player_proto.PlayerPacketID_PACKET_CS_CUSTOMNEWMSGACK), &CSCustomerNewMsgAckPacketFactory{})
	//ios稳定版升级标注
	common.RegisterHandler(int(player_proto.PlayerPacketID_PACKET_CS_IOSINSTALLSTABLE), &CSIosInstallStableHandler{})
	netlib.RegisterFactory(int(player_proto.PlayerPacketID_PACKET_CS_IOSINSTALLSTABLE), &CSIosInstallStablePacketFactory{})
	//查询中奖
	common.RegisterHandler(int(player_proto.PlayerPacketID_PACKET_CS_FISHJACKPOTCOIN), &CSFishJackpotHandler{})
	netlib.RegisterFactory(int(player_proto.PlayerPacketID_PACKET_CS_FISHJACKPOTCOIN), &CSFishJackpotPacketFactory{})
	//查询奖池金额
	common.RegisterHandler(int(player_proto.PlayerPacketID_PACKET_CS_FISHJACKPOTDATA), &CSFishJackpotCoinHandler{})
	netlib.RegisterFactory(int(player_proto.PlayerPacketID_PACKET_CS_FISHJACKPOTDATA), &CSFishJackpotCoinPacketFactory{})
	//查询客损是否打开
	common.RegisterHandler(int(player_proto.PlayerPacketID_PACKET_CS_GetSpreadLWIsOpen), &CSGetSpreadIsOpenHandler{})
	netlib.RegisterFactory(int(player_proto.PlayerPacketID_PACKET_CS_GetSpreadLWIsOpen), &CSGetSpreadIsOpenPacketFactory{})
	//玩家设置
	common.RegisterHandler(int(player_proto.PlayerPacketID_PACKET_ALL_SETTING), &CSPlayerSettingHandler{})
	netlib.RegisterFactory(int(player_proto.PlayerPacketID_PACKET_ALL_SETTING), &CSPlayerSettingPacketFactory{})
	//充值VIP
	common.RegisterHandler(int(player_proto.PlayerPacketID_PACKET_CS_VIPBUY), &CSPlayerVIPBuyHandler{})
	netlib.RegisterFactory(int(player_proto.PlayerPacketID_PACKET_CS_VIPBUY), &CSPlayerVIPBuyPacketFactory{})
	//VIP信息
	common.RegisterHandler(int(player_proto.PlayerPacketID_PACKET_CS_VIPINFO), &CSPlayerVIPInfoHandler{})
	netlib.RegisterFactory(int(player_proto.PlayerPacketID_PACKET_CS_VIPINFO), &CSPlayerVIPInfoPacketFactory{})
	//玩家领取VIP礼包
	common.RegisterHandler(int(player_proto.PlayerPacketID_PACKET_CS_DRAWVIPGIFT), &CSPlayerVIPDrawHandler{})
	netlib.RegisterFactory(int(player_proto.PlayerPacketID_PACKET_CS_DRAWVIPGIFT), &CSPlayerVIPDrawPacketFactory{})
	//VIP特权
	common.RegisterHandler(int(player_proto.PlayerPacketID_PACKET_CS_VIPPrivilegeInfo), &CSVIPPrivilegeInfoHandler{})
	netlib.RegisterFactory(int(player_proto.PlayerPacketID_PACKET_CS_VIPPrivilegeInfo), &CSVIPPrivilegeInfoPacketFactory{})

}

func CSExchangeChannel(s *netlib.Session, packetid int, data interface{}, sid int64) error {
	logger.Logger.Trace("CSExchangeChannel Process recv ", data)
	msg, ok := data.(*player_proto.CSExchangeChannel)
	if !ok {
		return nil
	}

	p := PlayerMgrSington.GetPlayer(sid)
	if p == nil {
		logger.Logger.Warn("CSExchangeChannel p == nil")
		return nil
	}

	pack := &player_proto.SCExchangeChannel{}

	if msg.Tp == 0 {
		for _, v := range PlatformMgrSingleton.GetConfig(p.Platform).ChannelSwitch {
			if v == nil {
				continue
			}
			pack.Datas = append(pack.Datas, &player_proto.ChannelSwitch{
				OnChannelName: v.OnChannelName,
				Tp:            v.Tp,
			})
		}
	} else {
		v := PlatformMgrSingleton.GetConfig(p.Platform).ChannelSwitch[msg.GetTp()]
		if v != nil {
			pack.Datas = append(pack.Datas, &player_proto.ChannelSwitch{
				OnChannelName: v.OnChannelName,
				Tp:            v.Tp,
			})
		}
	}

	p.SendToClient(int(player_proto.PlayerPacketID_PACKET_SCExchangeChannel), pack)
	logger.Logger.Tracef("SCExchangeChannel %v", pack)
	return nil
}

func CSPlayerData(s *netlib.Session, packetid int, data interface{}, sid int64) error {
	logger.Logger.Trace("CSPlayerDataHandler Process recv ", data)
	cspl, ok := data.(*player_proto.CSPlayerData)
	if !ok {
		return nil
	}

	ls := LoginStateMgrSington.GetLoginStateBySid(sid)
	if ls == nil {
		logger.Logger.Warnf("CSPlayerDataHandler sid:%v not login 1!!!", sid)
		return nil
	}
	if ls.als == nil {
		logger.Logger.Warnf("CSPlayerDataHandler sid:%v not login 2!!!", sid)
		return nil
	}
	if ls.als.acc == nil {
		logger.Logger.Warnf("CSPlayerDataHandler sid:%v not login 3!!!", sid)
		return nil
	}

	if cspl.GetAccId() != ls.als.acc.AccountId.Hex() {
		cspl.AccId = proto.String(ls.als.acc.AccountId.Hex())
		logger.Logger.Warnf("CSPlayerDataHandler player(%v) try to hit db!!!", cspl.GetAccId())
	}

	// 公共方法
	playerFunc := func(p *Player, msg *player_proto.CSPlayerData) {
		p.dirty = true
		if p.GMLevel > 2 {
			//伪造IP地址
			p.Ip = fmt.Sprintf("%v.%v.%v.%v", 1+rand.Int31n(255), 1+rand.Int31n(255), 1+rand.Int31n(255), 1+rand.Int31n(255))
		}
		p.params = p.UpdateParams(msg.GetParams())
		//player.DeviceInfo = deviceInfo
		p.DeviceId = msg.GetDeviceId()
		p.DeviceName = msg.GetDeviceName()
		p.PackageName = msg.GetPackageName()
		p.AppVersion = msg.GetAppVersion()
		p.BuildVersion = msg.GetBuildVersion()
		p.AppChannel = msg.GetAppChannel()
		p.LastChannel = p.AppChannel
		if (p.Channel == "" || p.Channel == "0") && p.Channel != msg.AppChannel {
			p.Channel = msg.AppChannel
		}
		if ls.als.acc.ChannelId != "" && p.ChannelId == "" {
			p.ChannelId = ls.als.acc.ChannelId
		}

		if ls.clog != nil {
			PlayerSubjectSign.UpdateHeadUrl(p.SnId, ls.clog.HeadUrl)
		}

		// 重置对战场统计数据重置
		v, ok := p.GDatas[common.GetKeyGameType(2)]
		if ok && v != nil {
			if int(v.Statics.Version) < model.GameParamData.GameStaticsFightVersion {
				v.Statics.Version = int32(model.GameParamData.GameStaticsFightVersion)
				v.Statics.TotalIn = 0
				v.Statics.TotalOut = 0
				v.Statics.Tax = 0
				v.Statics.MaxSysOut = 0
				// 个人水池
				p.TotalIn = 0
				p.TotalOut = 0
				p.PlayerTax = 0
				p.dirty = true
			}
		}

		// 老版本升级
		clientUpgradeConfig := PlatformMgrSingleton.GetConfig(p.Platform).ClientUpgrade
		if clientUpgradeConfig != nil && clientUpgradeConfig.GetOn() == common.On &&
			(len(model.GameParamData.ClientVersionChannel) == 0 || slices.Contains(model.GameParamData.ClientVersionChannel, p.LastChannel)) {
			if p.ClientVer < model.GameParamData.ClientVersion {
				if cspl.GetClientVer() == model.GameParamData.ClientVersion {
					// 升级了
					p.ClientVer = model.GameParamData.ClientVersion
					AddMailClientUpgrade(p.SnId, clientUpgradeConfig.GetReward())
				}
			}
		}
	}

	// 有缓存数据
	player := PlayerMgrSington.GetPlayerByAccount(cspl.GetAccId())
	if player != nil {
		// 当前玩家登录，踢掉其它客户端连接
		if player.IsOnLine() {
			if player.sid != 0 && player.sid != sid {
				//Kick the exist player disconnect
				player.Kickout(common.KickReason_OtherLogin)
			}
		}

		var temp []byte
		var err error
		di := cspl.GetDeviceInfo()

		// 获取不到平台信息，登录失败
		pt := PlatformMgrSingleton.GetPlatform(player.Platform)
		if !player.IsRob && pt == nil {
			scPlayerData := &player_proto.SCPlayerData{
				OpRetCode: player_proto.OpResultCode_OPRC_Error,
			}
			logger.Logger.Trace("player no platform:", player.Platform, player.SnId)
			proto.SetDefaults(scPlayerData)
			player.SendRawToClientIncOffLine(sid, s, int(player_proto.PlayerPacketID_PACKET_SC_PLAYERDATA), scPlayerData)
			//Kick the exist player disconnect
			player.Kickout(common.KickReason_Freeze)
			return nil
		}

		// 没有设备信息，登录失败
		if !player.IsRob && pt.NeedDeviceInfo && di == "" { //maybe res ver is low
			scPlayerData := &player_proto.SCPlayerData{
				OpRetCode: player_proto.OpResultCode_OPRC_LoginFailed,
			}
			logger.Logger.Trace("player no deviceinfo:", player.SnId)

			proto.SetDefaults(scPlayerData)
			player.SendRawToClientIncOffLine(sid, s, int(player_proto.PlayerPacketID_PACKET_SC_PLAYERDATA), scPlayerData)
			//Kick the exist player disconnect
			player.Kickout(common.KickReason_Freeze)
			return nil
		}

		// 设备验证失败，登录失败
		if !player.IsRob && di != "" && cspl.GetPlatformTag() != "" {
			var e common.Encryptor
			e.Init(common.GetAppId(), cspl.GetPlatformTag(), int32(cspl.GetTimeStamp()))
			temp, err = base64.StdEncoding.DecodeString(di)
			if err == nil {
				e.Encrypt(temp, len(temp))
			} else {
				scPlayerData := &player_proto.SCPlayerData{
					OpRetCode: player_proto.OpResultCode_OPRC_NotLogin,
				}
				logger.Logger.Trace("player no decode deviceinfo:", player.SnId)

				proto.SetDefaults(scPlayerData)
				player.SendRawToClientIncOffLine(sid, s, int(player_proto.PlayerPacketID_PACKET_SC_PLAYERDATA), scPlayerData)
				//Kick the exist player disconnect
				player.Kickout(common.KickReason_Freeze)
				return nil
			}

			if !player.IsRob && model.GameParamData.ValidDeviceInfo && !json.Valid(temp) {
				scPlayerData := &player_proto.SCPlayerData{
					OpRetCode: player_proto.OpResultCode_OPRC_NotLogin,
				}
				logger.Logger.Trace("player no json deviceinfo:", player.SnId, temp)
				proto.SetDefaults(scPlayerData)
				player.SendRawToClientIncOffLine(sid, s, int(player_proto.PlayerPacketID_PACKET_SC_PLAYERDATA), scPlayerData)
				//Kick the exist player disconnect
				player.Kickout(common.KickReason_Freeze)
				return nil
			}
		}

		if !player.IsRob {
			if _, ok := BlackListMgrSington.CheckLogin(player.PlayerData); !ok {
				//var msg string
				//if bi != nil {
				//	msg = i18n.Tr("languages", "BlackListLimit2Args", player.SnId, bi.Id, player.SnId, bi.Id, player.SnId, bi.Id, player.SnId, bi.Id)
				//} else {
				//	msg = i18n.Tr("languages", "BlackListLimit1Args", player.SnId, player.SnId, player.SnId, player.SnId)
				//}
				//common.SendSrvMsg(player, common.SRVMSG_CODE_DEFAULT, msg)
				//scPlayerData := &player_proto.SCPlayerData{
				//	OpRetCode: player_proto.OpResultCode_OPRC_InBlackList,
				//}
				//proto.SetDefaults(scPlayerData)
				//player.SendToClient(int(player_proto.PlayerPacketID_PACKET_SC_PLAYERDATA), scPlayerData)
				//Kick the exist player disconnect
				player.Kickout(common.KickReason_Freeze)
				return nil
			}
		}

		// 给玩家发送三方余额状态
		//statePack := &gamehall_proto.SCThridGameBalanceUpdateState{}
		//if player.thridBalanceReqIsSucces {
		//	statePack.OpRetCode = gamehall_proto.OpResultCode_Game_OPRC_Sucess_Game
		//} else {
		//	statePack.OpRetCode = gamehall_proto.OpResultCode_Game_OPRC_Error_Game
		//}
		//player.SendRawToClientIncOffLine(sid, s, int(gamehall_proto.GameHallPacketID_PACKET_SC_THRIDGAMEBALANCEUPDATESTATE), statePack)

		//抽奖次数兼容老玩家
		if !player.IsRob && !player.InitLotteryStatus && WelfareMgrSington.GetPhoneLotteryStatus(player.Platform) == model.WelfareOpen {
			player.addLotteryCount(20)
			player.InitLotteryStatus = true
			player.dirty = true
			mq.Write(model.GeneratePhoneLottery(player.SnId, player.Platform, "", 3, 20, 5, 0))
		}

		// rehold player
		playerFunc(player, cspl)
		PlayerMgrSington.ReholdPlayer(player, sid, s)
		player.OnRehold()
		player.SendPlayerInfo()
		return nil
	}

	// 没有缓存数据
	if PlayerMgrSington.StartLoading(cspl.GetAccId(), sid) {
		return nil
	}

	PlayerCacheMgrSingleton.UnCacheInvalidPlayerId(ls.als.acc.SnId)
	PlayerCacheMgrSingleton.Get(ls.als.acc.Platform, ls.als.acc.SnId, func(pd *PlayerCacheItem, async, isnew bool) {
		send := func(code player_proto.OpResultCode) {
			scPlayerData := &player_proto.SCPlayerData{
				OpRetCode: code,
			}
			proto.SetDefaults(scPlayerData)
			common.SendToGate(sid, int(player_proto.PlayerPacketID_PACKET_SC_PLAYERDATA), scPlayerData, s)
			logger.Logger.Tracef("SC_PLAYERDATA %v", scPlayerData)
		}

		sid := PlayerMgrSington.EndPlayerLoading(cspl.GetAccId())

		if pd == nil {
			send(player_proto.OpResultCode_OPRC_Login_CreateFailed)
			return
		}

		var promoterID string
		var promoterCfg *PromoterConfig
		f := func() {
			PlayerMgrSington.AddPlayer(sid, pd.PlayerData, s)
			player := PlayerMgrSington.GetPlayer(sid)
			if player == nil {
				return
			}

			if !player.IsRob {
				if _, ok := BlackListMgrSington.CheckLogin(pd.PlayerData); !ok {
					//黑名单用户也需要调用一下onlogin,否则会导致数据无法刷新
					player.OnLogined()
					player.Kickout(common.KickReason_Freeze)
					return
				}
			}

			if promoterID != "" {
				key, err := GetPromoterKey(0, promoterID, "")
				if err == nil {
					promoterCfg = PromoterMgrSington.GetConfig(key)
					if promoterCfg != nil && promoterCfg.IsInviteRoot > 0 {
						player.BeUnderAgentCode = promoterID
					}
				}
			}

			var temp []byte
			var ee error
			di := cspl.GetDeviceInfo()
			if di != "" {
				var e common.Encryptor
				e.Init(common.GetAppId(), player.PackageID, int32(cspl.GetTimeStamp()))
				temp, ee = base64.StdEncoding.DecodeString(di)
				if ee == nil {
					e.Encrypt(temp, len(temp))
				}
			}

			if isnew { //新用户赠送金币
				//首次创建账号事件
				//isBind := 0
				//if pd.Tel != "" {
				//	isBind = 1
				//}
				//LogChannelSingleton.WriteMQData(model.GeneratePlayerEvent(model.WEBEVENT_LOGIN, pd.Platform, pd.PackageID, pd.SnId, pd.Channel, pd.BeUnderAgentCode, pd.PromoterTree, 1, 1, isBind, common.GetAppId()))

				//newbieCoin := player.GetRegisterPrize()
				//if newbieCoin > 0 {
				//	player.AddCoin(int64(newbieCoin), common.GainWay_NewPlayer, "system", "")
				//	//增加泥码
				//	player.AddDirtyCoin(0, int64(newbieCoin))
				//	player.ReportSystemGiveEvent(newbieCoin, common.GainWay_NewPlayer, true)
				//	player.AddPayCoinLog(int64(newbieCoin), model.PayCoinLogType_Coin, "NewPlayer")
				//	LogChannelSingleton.WriteMQData(model.GenerateSystemFreeGive(pd.SnId, pd.Name, pd.Platform, model.SystemFreeGive_GiveType_NewPlayer, model.SystemFreeGive_CoinType_Coin, int64(newbieCoin)))
				//}
				//if player.InviterId > 0 {
				//	//actRandCoinMgr.OnPlayerInvite(player.Platform, player.InviterId)
				//}
			}
			//测试代码

			playerFunc(player, cspl)
			player.OnLogined()
			player.SendPlayerInfo()
			return
		}

		if pd.InviterId != 0 {
			// 获取推广人
			PlayerCacheMgrSingleton.UnCacheInvalidPlayerId(pd.InviterId)
			PlayerCacheMgrSingleton.Get(pd.Platform, pd.InviterId, func(inviter *PlayerCacheItem, async, isnew bool) {
				if inviter != nil {
					promoterID = inviter.BeUnderAgentCode
				}
				f()
			}, false)
		} else {
			f()
		}
	}, true)

	return nil
}

func CSQueryPlayer(s *netlib.Session, packetid int, data interface{}, sid int64) error {
	logger.Logger.Trace("CSQueryPlayerHandler Process recv ", data)
	if msg, ok := data.(*player_proto.CSQueryPlayer); ok {
		p := PlayerMgrSington.GetPlayer(sid)
		if p == nil {
			logger.Logger.Warn("CSQueryPlayerHandler p == nil")
			return nil
		}
		destSnId := msg.GetSnId()
		send := func(f *model.Friend) {
			pack := &player_proto.SCQueryPlayer{
				SnId:      f.SnId,
				Name:      f.Name,
				Head:      f.Head,
				Sex:       f.Sex,
				Coin:      f.Coin,
				Diamond:   f.Diamond,
				VCard:     f.VCard,
				HeadUrl:   f.HeadUrl,
				Signature: f.Signature,
				Age:       f.Age,
				GameID:    f.GameID,
			}
			//IsFriend
			pack.IsFriend = FriendMgrSington.IsFriend(p.Platform, p.SnId, f.SnId)
			//IsShield
			pack.IsShield = FriendMgrSington.IsShield(p.Platform, p.SnId, f.SnId)
			//Role
			roleInfo := f.Roles
			if roleInfo != nil {
				for id, level := range roleInfo {
					role := &player_proto.RoleOrPet{
						Id:    id,
						Level: level,
					}
					roleData := ModelMgrSingleton.GetIntroductionByModId(id)
					if roleData != nil {
						role.Name = roleData.Name
					}
					pack.Roles = append(pack.Roles, role)
				}
			}
			//Pet
			petInfo := f.Pets
			if petInfo != nil {
				for id, level := range petInfo {
					pet := &player_proto.RoleOrPet{
						Id:    id,
						Level: level,
					}
					petData := ModelMgrSingleton.GetIntroductionByModId(id)
					if petData != nil {
						pet.Name = petData.Name
					}
					pack.Pets = append(pack.Pets, pet)
				}
			}
			ok := p.SendToClient(int(player_proto.PlayerPacketID_PACKET_SC_QUERYPLAYER), pack)
			logger.Logger.Trace("SCQueryPlayerHandler ok: ", ok, " pack: ", pack)
		}

		player := PlayerMgrSington.GetPlayerBySnId(destSnId)
		if player != nil && player.IsRob {
			pack := &player_proto.SCQueryPlayer{
				SnId:      player.SnId,
				Name:      player.Name,
				Head:      player.Head,
				Sex:       player.Sex,
				Coin:      player.Coin,
				Diamond:   player.Diamond,
				HeadUrl:   player.HeadUrl,
				Signature: player.Signature,
				Age:       player.Age,
				GameID:    player.GameID,
			}
			proto.SetDefaults(pack)
			p.SendToClient(int(player_proto.PlayerPacketID_PACKET_SC_QUERYPLAYER), pack)
			logger.Logger.Trace("SCQueryPlayerHandler ok: ", ok, " pack: ", pack)
		} else { // 真人去friend取信息
			friend := FriendMgrSington.GetPlayer(p.Platform, destSnId)
			if friend != nil {
				send(friend)
			} else {
				task.New(nil, task.CallableWrapper(func(o *basic.Object) interface{} {
					ret, err := model.QueryFriendBySnid(p.Platform, destSnId)
					if err != nil {
						return nil
					}
					return ret
				}), task.CompleteNotifyWrapper(func(data interface{}, tt task.Task) {
					if ret, ok := data.(*model.Friend); ok && ret != nil {
						send(ret)
					}
				})).Start()
			}
		}
	}
	return nil
}

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

	if msg.GetName() != "" && msg.GetName() != p.Name {
		PlayerSubjectSign.UpdateName(p.SnId, msg.GetName())
	}

	if msg.GetHead() != 0 && msg.GetHeadUrl() != p.HeadUrl {
		PlayerSubjectSign.UpdateHead(p.SnId, msg.GetHead())
	}

	if msg.GetHeadUrl() != "" && msg.GetHeadUrl() != p.HeadUrl {
		PlayerSubjectSign.UpdateHeadUrl(p.SnId, msg.GetHeadUrl())
	}

	if msg.GetSex() != 0 && msg.GetSex() != p.Sex {
		p.Sex = msg.GetSex()
	}

	if msg.GetAge() > 0 && msg.GetAge() != p.Age {
		p.Age = msg.GetAge()
	}

	if msg.GetSignature() != "" && msg.GetSignature() != p.Signature && len([]rune(msg.GetSignature())) < 100 {
		p.Signature = msg.GetSignature()
	}

	if msg.GetRoleID() > 0 && msg.GetRoleID() != p.Roles.ModId {
		if _, ok := p.Roles.ModUnlock[msg.GetRoleID()]; ok {
			p.Roles.ModId = msg.GetRoleID()
		}
	}

	if msg.GetPetID() > 0 {
		if _, ok := p.Pets.ModUnlock[msg.GetPetID()]; ok {
			if msg.GetPetID() == p.Pets.ModId {
				p.Pets.ModId = 0
			} else {
				p.Pets.ModId = msg.GetPetID()
			}
		}
	}

	p.SendToClient(int(player_proto.PlayerPacketID_PACKET_SCSavePlayerInfo), &player_proto.SCSavePlayerInfo{
		OpRetCode: player_proto.OpResultCode_OPRC_Sucess,
	})

	return nil
}

func CSHeadUrl(s *netlib.Session, packetId int, data interface{}, sid int64) error {
	logger.Logger.Trace("CSHeadUrl Process recv ", data)
	msg, ok := data.(*player_proto.CSHeadUrl)
	if !ok {
		return nil
	}
	p := PlayerMgrSington.GetPlayer(sid)
	if p == nil {
		logger.Logger.Warn("CSHeadUrl p == nil")
		return nil
	}

	if len(msg.GetUrl()) >= 500 {
		logger.Logger.Warn("CSHeadUrl msg.GetUrl() >= 500")
		return nil
	}

	PlayerSubjectSign.UpdateHeadUrl(p.SnId, msg.GetUrl())

	pack := &player_proto.SCHeadUrl{
		OpRetCode: player_proto.OpResultCode_OPRC_Sucess,
		Url:       p.HeadUrl,
	}

	p.SendToClient(int(player_proto.PlayerPacketID_PACKET_SC_HeadUrl), pack)
	return nil
}

func CSBindTelInfo(s *netlib.Session, packetId int, data interface{}, sid int64) error {
	logger.Logger.Trace("CSBindTelInfo Process ", data)
	_, ok := data.(*player_proto.CSBindTelInfo)
	if !ok {
		return nil
	}

	p := PlayerMgrSington.GetPlayer(sid)
	if p == nil {
		logger.Logger.Error("CSBindTelInfo p == nil", sid)
		return nil
	}

	plt := PlatformMgrSingleton.GetPlatform(p.Platform)
	if plt == nil {
		logger.Logger.Error("CSBindTelInfo platform is nil", sid)
		return nil
	}

	pack := &player_proto.SCBindTelInfo{
		BindTelReward: make(map[int32]int64),
	}
	for k, v := range plt.BindTelReward {
		pack.BindTelReward[common.ToItemId(k)] = v
	}
	p.SendToClient(int(player_proto.PlayerPacketID_PACKET_SCBindTelInfo), pack)
	return nil
}

var telRule, _ = regexp.Compile(`^(\d{2,15})$`)

func CSPlayerSMSCode(s *netlib.Session, packetId int, data interface{}, sid int64) error {
	logger.Logger.Trace("CSPlayerSMSCode Process ", data)
	msg, ok := data.(*player_proto.CSPlayerSMSCode)
	if !ok {
		return nil
	}

	p := PlayerMgrSington.GetPlayer(sid)

	sendPack := func(code player_proto.OpResultCode) {
		pack := &player_proto.SCPlayerSMSCode{
			Code: code,
		}
		proto.SetDefaults(pack)
		common.SendToGate(sid, int(player_proto.PlayerPacketID_PACKET_SCPlayerSMSCode), pack, s)
		logger.Logger.Trace("SCPlayerSMSCode send pack ", code)
	}

	if msg.GetTel() == "" || msg.GetAreaCode() == "" {
		sendPack(player_proto.OpResultCode_OPRC_TelError)
		return nil
	}

	msg.Tel = strings.TrimPrefix(msg.GetTel(), "0")

	tel := fmt.Sprint(msg.GetAreaCode(), msg.GetTel())
	// tel
	if !telRule.MatchString(tel) {
		sendPack(player_proto.OpResultCode_OPRC_TelError)
		return nil
	}

	// 验证图片验证码
	imageCodeKey := common.GetImageCodeKey(strconv.FormatInt(sid, 10))
	imageCode := CacheMemory.Get(imageCodeKey)
	if imageCode != nil {
		if imageCode != msg.GetImageCode() {
			sendPack(player_proto.OpResultCode_OPRC_ImageVerifyCodeFailed)
			return nil
		}
		CacheMemory.Delete(imageCodeKey)
	}

	var telKey string
	var snid int32
	if p != nil {
		msg.Platform = p.Platform
		snid = p.SnId
	}

	var validTime time.Duration
	switch msg.GetTypeID() {
	case 0, common.SMSCodeTelBind:
		msg.TypeID = common.SMSCodeTelBind // 旧接口是0
		telKey = common.GetBindTelCodeKey(msg.GetPlatform(), tel)
		validTime = common.SMSCodeValidTimeTelBind

	case common.SMSCodeTelLogin:
		telKey = common.GetTelLoginCodeKey(msg.GetPlatform(), tel)
		validTime = common.SMSCodeValidTimeTelLogin

	default:
		logger.Logger.Errorf("CSPlayerSMSCode typeID error %d", msg.GetTypeID())
		sendPack(player_proto.OpResultCode_OPRC_Error)
		return nil
	}

	key := fmt.Sprintf("key%s", telKey)
	code := CacheMemory.Get(key) // 频率限制
	if code != nil {
		sendPack(player_proto.OpResultCode_OPRC_Frequently)
		return nil
	}

	if model.GameParamData.FakeVerifyCode != "" {
		CacheMemory.Put(telKey, model.GameParamData.FakeVerifyCode, int64(validTime))
		CacheMemory.Put(key, model.GameParamData.FakeVerifyCode, common.SMSCodeValidTime)
		sendPack(player_proto.OpResultCode_OPRC_Sucess)
		return nil
	}

	//先设置注册码，防止多次注册
	smsCode := common.RandSmsCode()
	CacheMemory.Put(telKey, smsCode, int64(validTime))
	CacheMemory.Put(key, smsCode, common.SMSCodeValidTime)
	logger.Logger.Trace("CSPlayerSMSCode smsCode ", smsCode)

	var res []byte
	var err error
	task.New(nil, task.CallableWrapper(func(o *basic.Object) interface{} {
		param := &webapi_proto.ASSendSms{
			Snid:     snid,
			Phone:    tel,
			Code:     smsCode,
			Platform: msg.GetPlatform(),
			TypeID:   msg.GetTypeID(),
		}
		res, err = webapi.ApiSendSMS(common.GetAppId(), param)
		return nil
	}), task.CompleteNotifyWrapper(func(data interface{}, t task.Task) {
		if err != nil || res == nil {
			logger.Logger.Errorf("API_SendSms err %v", err)
			sendPack(player_proto.OpResultCode_OPRC_Error)
			return
		}

		var info webapi_proto.SASendSms
		proto.Unmarshal(res, &info)

		if info.Tag == webapi_proto.TagCode_SUCCESS {
			CacheMemory.Put(telKey, smsCode, int64(validTime))
			sendPack(player_proto.OpResultCode_OPRC_Sucess)
		} else {
			if info.Tag == webapi_proto.TagCode_Limit {
				logger.Logger.Warnf("API_SendSms Limit tel:%s", tel)
				sendPack(player_proto.OpResultCode_OPRC_SMSCodeLimit)
				return
			}
			logger.Logger.Errorf("API_SendSms err %v", err)
			sendPack(player_proto.OpResultCode_OPRC_Error)
		}
	}), "API_SendSms").Start()
	return nil
}

func CSBindTel(s *netlib.Session, packetId int, data interface{}, sid int64) error {
	logger.Logger.Trace("CSBindTel Process ", data)
	msg, ok := data.(*player_proto.CSBindTel)
	if !ok {
		return nil
	}

	p := PlayerMgrSington.GetPlayer(sid)
	if p == nil {
		logger.Logger.Error("CSBindTel p == nil", sid)
		return nil
	}

	//test
	//if model.GameParamData.FakeVerifyCode != "" && msg.GetTel() == "0" {
	//	CacheMemory.Delete(fmt.Sprintf("%v-%v", p.Tel, p.Platform))
	//	a := PlayerMgrSington.GetPlayerByAccount(p.AccountId)
	//	if a != nil {
	//		a.Tel = ""
	//	}
	//	p.Tel = ""
	//	return nil
	//}
	//test

	sendPack := func(code player_proto.OpResultCode) {
		pack := &player_proto.SCBindTel{
			Code: code,
		}
		proto.SetDefaults(pack)
		p.SendToClient(int(player_proto.PlayerPacketID_PACKET_SCBindTel), pack)
		logger.Logger.Tracef("SCBindTel send pack %v", pack)
	}

	if p.Tel != "" {
		sendPack(player_proto.OpResultCode_OPRC_TelIsExist)
		return nil
	}

	if msg.GetTel() == "" || msg.GetAreaCode() == "" {
		sendPack(player_proto.OpResultCode_OPRC_TelError)
		return nil
	}

	//验证手机号
	//tel := msg.GetTel()
	//if !reTelRule.MatchString(tel) {
	//	sendPack(player_proto.OpResultCode_OPRC_TelError.Enum())
	//	return nil
	//}

	msg.Tel = strings.TrimPrefix(msg.GetTel(), "0")

	tel := fmt.Sprint(msg.GetAreaCode(), msg.GetTel())
	telKey := common.GetBindTelCodeKey(p.Platform, tel)

	//验证验证码
	code := CacheMemory.Get(telKey)
	if code == nil {
		sendPack(player_proto.OpResultCode_OPRC_VerificationCodeError)
		return nil
	}

	if msg.GetCode() == "" {
		sendPack(player_proto.OpResultCode_OPRC_VerificationCodeError)
		return nil
	}

	verifyCode, ok := code.(string)
	if !ok || verifyCode == "" {
		sendPack(player_proto.OpResultCode_OPRC_VerificationCodeError)
		return nil
	}

	if verifyCode != msg.GetCode() {
		sendPack(player_proto.OpResultCode_OPRC_VerificationCodeError)
		return nil
	}

	var snid int32
	var err error
	task.New(nil, task.CallableWrapper(func(o *basic.Object) interface{} {
		//if model.GameParamData.FakeVerifyCode == "" {
		// 手机号是否已经被绑定
		snid, _ = model.GetPlayerTel(tel, p.Platform, 0) // tagKey没用了，给0就行
		if snid != 0 {
			return nil
		}
		// 绑定手机号
		if err = model.BindTelAccount(p.AccountId, tel, p.Platform); err != nil {
			logger.Logger.Errorf("BindTelAccount err: %v", err)
			return nil
		}

		if err = model.UpdatePlayerTel(p.Platform, p.SnId, tel); err != nil {
			logger.Logger.Errorf("UpdatePlayerTel err: %v", err)
			return nil
		}
		//}
		return nil
	}), task.CompleteNotifyWrapper(func(i interface{}, t task.Task) {
		if err != nil {
			sendPack(player_proto.OpResultCode_OPRC_VerificationCodeError)
			return
		}

		if snid != 0 {
			sendPack(player_proto.OpResultCode_OPRC_TelIsExist)
			return
		}

		if p.Tel == "" {
			// 首次绑定赠送奖励
			a := PlayerMgrSington.GetPlayerByAccount(p.AccountId)
			if a != nil {
				a.Tel = tel
			}
			p.Tel = tel
			p.BindTelReward()

			// 邀请人绑定手机号
			if p.PSnId > 0 {
				cfg := PlatformMgrSingleton.GetConfig(p.Platform).ActInviteConfig
				SaveInviteScore(&model.InviteScore{
					Platform:   p.Platform,
					SnId:       p.SnId,
					InviteSnId: p.PSnId,
					Tp:         common.InviteScoreTypeBindTel,
					Score:      cfg.GetBindTelScore(),
					Ts:         time.Now().Unix(),
					Money:      0,
				})
			}
		}

		// 删除验证码
		//CacheMemory.Delete(telKey)
		sendPack(player_proto.OpResultCode_OPRC_Sucess)
	})).StartByFixExecutor(fmt.Sprintf("Platform%v", p.Platform))
	return nil
}

func CSGetImageVerifyCode(s *netlib.Session, packetId int, data interface{}, sid int64) error {
	logger.Logger.Tracef("CSGetImageVerifyCode ", data)
	if _, ok := data.(*player_proto.CSGetImageVerifyCode); ok {
		sendPack := func(code player_proto.OpResultCode, data string) {
			pack := &player_proto.SCGetImageVerifyCode{
				OpRetCode: code,
				ImageData: proto.String(data),
			}
			proto.SetDefaults(pack)
			common.SendToGate(sid, int(player_proto.PlayerPacketID_PACKET_SC_GETIMAGEVERIFYCODE), pack, s)
			logger.Logger.Tracef("SCGetImageVerifyCode ", pack)
		}

		var err error
		var b []byte
		imgVerifyMsg := &webapi_proto.SAGetImgVerify{}
		task.New(nil, task.CallableWrapper(func(o *basic.Object) interface{} {
			param := &webapi_proto.ASGetImgVerify{
				//Tel: msg.GetTel(),
			}
			b, err = webapi.ApiGetImageVerify(common.GetAppId(), param)
			return err
		}), task.CompleteNotifyWrapper(func(data interface{}, t task.Task) {
			if err != nil || len(b) == 0 {
				sendPack(player_proto.OpResultCode_OPRC_Error, "")
				return
			}
			err = proto.Unmarshal(b, imgVerifyMsg)
			if err != nil || imgVerifyMsg.GetTag() != webapi_proto.TagCode_SUCCESS ||
				imgVerifyMsg.GetImageData() == "" || imgVerifyMsg.GetCode() == "" {
				sendPack(player_proto.OpResultCode_OPRC_Error, "")
				return
			}
			key := common.GetImageCodeKey(strconv.FormatInt(sid, 10))
			CacheMemory.Put(key, imgVerifyMsg.Code, 600)
			logger.Logger.Infof("@CacheMemory.Put(key:%v, val:%v)", key, imgVerifyMsg.Code)
			sendPack(player_proto.OpResultCode_OPRC_Sucess, imgVerifyMsg.ImageData)
		}), "API_GetImgVerify").Start()
	}
	return nil
}

func CSGetImageVerifyCodeLocal(s *netlib.Session, packetId int, data interface{}, sid int64) error {
	logger.Logger.Tracef("CSGetImageVerifyCode ", data)
	if _, ok := data.(*player_proto.CSGetImageVerifyCode); ok {
		sendPack := func(code player_proto.OpResultCode, data string) {
			pack := &player_proto.SCGetImageVerifyCode{
				OpRetCode: code,
				ImageData: proto.String(data),
			}
			proto.SetDefaults(pack)
			common.SendToGate(sid, int(player_proto.PlayerPacketID_PACKET_SC_GETIMAGEVERIFYCODE), pack, s)
			logger.Logger.Tracef("SCGetImageVerifyCode ", pack)
		}

		var err error
		var b64, answer string
		task.New(nil, task.CallableWrapper(func(o *basic.Object) interface{} {
			b64, answer, err = common.ImageCode()
			return nil
		}), task.CompleteNotifyWrapper(func(data interface{}, t task.Task) {
			if err != nil {
				sendPack(player_proto.OpResultCode_OPRC_Error, "")
				return
			}

			key := common.GetImageCodeKey(strconv.FormatInt(sid, 10))
			CacheMemory.Put(key, answer, 600)
			logger.Logger.Infof("@CacheMemory.Put(key:%v, val:%v)", key, answer)
			sendPack(player_proto.OpResultCode_OPRC_Sucess, b64)
		}), "API_GetImgVerify").Start()
	}
	return nil
}

func CSImageVerifyCode(s *netlib.Session, packetId int, data interface{}, sid int64) error {
	logger.Logger.Trace("CSImageVerifyCode Process ", data)
	msg, ok := data.(*player_proto.CSImageVerifyCode)
	if !ok {
		return nil
	}

	sendPack := func(code player_proto.OpResultCode) {
		pack := &player_proto.SCImageVerifyCode{
			OpRetCode: code,
		}
		proto.SetDefaults(pack)
		common.SendToGate(sid, int(player_proto.PlayerPacketID_PACKET_SC_ImageVerifyCode), pack, s)
		logger.Logger.Trace("SCImageVerifyCode send pack ", code)
	}

	imageCodeKey := common.GetImageCodeKey(strconv.FormatInt(sid, 10))
	imageCode := CacheMemory.Get(imageCodeKey)
	if imageCode != nil {
		if imageCode != msg.GetCode() {
			sendPack(player_proto.OpResultCode_OPRC_ImageVerifyCodeFailed)
			return nil
		}
		CacheMemory.Delete(imageCodeKey)
	}

	sendPack(player_proto.OpResultCode_OPRC_Sucess)
	return nil
}

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

	ret := &player_proto.SCBillList{}

	if msg.GetTs() <= 0 {
		msg.Ts = time.Now().Unix()
	}
	startTs := msg.GetTs() - 24*60*60
	if startTs <= 0 {
		return nil
	}
	endTs := msg.GetTs()

	if msg.GetPageNo() < 0 {
		msg.PageNo = 0
	}
	if msg.GetPageSize() > 100 {
		msg.PageSize = 100
	}
	if msg.GetPageSize() <= 0 {
		msg.PageSize = 10
	}

	fromIndex := msg.GetPageNo() * msg.GetPageSize()
	toIndex := fromIndex + msg.GetPageSize()

	var err error
	var logs []model.CoinLog
	task.New(nil, task.CallableWrapper(func(o *basic.Object) interface{} {
		logs, _, err = model.GetCoinLogGame(p.Platform, p.SnId, common.BillTypeCoin, startTs, endTs, int(fromIndex), int(toIndex))
		return nil
	}), task.CompleteNotifyWrapper(func(i interface{}, t task.Task) {
		if err != nil {
			logger.Logger.Errorf("GetCoinLogGame err:%v", err)
			p.SendToClient(int(player_proto.PlayerPacketID_PACKET_SCBillList), ret)
			return
		}

		for _, v := range logs {
			ret.Items = append(ret.Items, &player_proto.BillItem{
				Ts:         v.Ts,
				Id:         v.LogId.Hex(),
				BillType:   int64(v.LogType),
				Amount:     v.Count,
				Balance:    v.RestCount,
				GameID:     int64(v.InGame),
				GameFreeID: v.GameFreeId,
				BaseCoin:   v.BaseCoin,
			})
		}
		p.SendToClient(int(player_proto.PlayerPacketID_PACKET_SCBillList), ret)
		logger.Logger.Tracef("SCBillList pageNo:%d, pageSize:%d %v", msg.GetPageNo(), msg.GetPageSize(), ret)
	}), "GetCoinLogGame").Start()
	return nil
}

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

	TaskSubjectSingleton.Touch(common.TaskTypeAdv, &TaskData{
		SnId: p.SnId,
		Num:  1,
	})

	ret := &player_proto.SCADV{
		Param: msg.GetParam(),
	}
	p.SendToClient(int(player_proto.PlayerPacketID_PACKET_SCADV), ret)
	logger.Logger.Tracef("SCADV %v", ret)
	return nil
}

// 获取运营商配置
func CSSMSConfig(s *netlib.Session, packetId int, data interface{}, sid int64) error {
	logger.Logger.Tracef("CSSMSConfig Process %v", data)
	p := PlayerMgrSington.GetPlayer(sid)
	if p == nil {
		return nil
	}
	var res []byte
	var err error
	task.New(nil, task.CallableWrapper(func(o *basic.Object) interface{} {
		param := &webapi_proto.ASSMSConfig{
			SnId:     p.SnId,
			Platform: p.Platform,
		}
		res, err = webapi.ApiSMSConfig(common.GetAppId(), param)
		return nil
	}), task.CompleteNotifyWrapper(func(data interface{}, t task.Task) {
		if err != nil || res == nil {
			logger.Logger.Errorf("API_SmsConfig err %v", err)
			return
		}
		var info webapi_proto.SASMSConfig
		proto.Unmarshal(res, &info)
		if info.Tag == webapi_proto.TagCode_SUCCESS {
			ret := &player_proto.SCSMSConfig{}
			for _, smsInfo := range info.Info {
				infoData := &player_proto.SMSInfo{}
				infoData.Id = smsInfo.Id
				infoData.SmsName = smsInfo.SmsName
				ret.Info = append(ret.Info, infoData)
			}
			p.SendToClient(int(player_proto.PlayerPacketID_PACKET_SCSMSConfig), ret)
		} else {
			logger.Logger.Errorf("API_SmsConfig err %v", info.Msg)
		}
	}), "API_SmsConfig").Start()
	return nil
}

// 获取获奖记录
func CSAwardLog(s *netlib.Session, packetId int, data interface{}, sid int64) error {
	logger.Logger.Tracef("CSAwardLog Process %v", data)
	p := PlayerMgrSington.GetPlayer(sid)
	if p == nil {
		return nil
	}
	msg, ok := data.(*player_proto.CS_AwardLog)
	if !ok {
		return nil
	}
	awardLogConfig := PlatformMgrSingleton.GetConfig(p.Platform).AwardLogConfig

	AwardLog := AwardLogMgr.GetAwardLog(p.Platform, msg.TypeId)
	ret := &player_proto.SCAwardLog{}
	awardData := &player_proto.AwardLogData{}
	ret.TypeId = msg.TypeId
	for itemId, num := range AwardLog {
		itemNum := int64(num)
		infoData := &player_proto.AwardLogInfo{}
		infoData.ItemId = itemId
		infoData.Num = itemNum
		awardData.AwardLog = append(awardData.AwardLog, infoData)
	}
	//处理后台数据
	if awardLogConfig != nil {
		for _, awardLog := range awardLogConfig.AwardLog {
			if awardLog.TypeId == msg.TypeId {
				for _, log := range awardLog.AwardLog {
					status := false
					for _, info := range awardData.AwardLog {
						if log.ItemId == info.ItemId {
							status = true
							info.Order = log.Order
							info.Url = log.Url

							if log.Num > info.Num {
								info.Num = log.Num
							}
							break
						}
					}
					if !status {
						infoData := &player_proto.AwardLogInfo{}
						infoData.ItemId = log.ItemId
						infoData.Num = log.Num
						infoData.Order = log.Order
						infoData.Url = log.Url
						awardData.AwardLog = append(awardData.AwardLog, infoData)
					}
				}
				awardData.SortId = awardLog.SortId
			}
		}
	}
	ret.AwardLog = awardData
	//实时播报数据
	AnnouncerLog := AwardLogMgr.GetAnnouncerLog(p.Platform, msg.TypeId)
	for _, logInfo := range AnnouncerLog {
		infoData := &player_proto.AnnouncerLogInfo{}
		//infoData.Snid = logInfo.Snid
		infoData.Name = logInfo.Name
		str := ""
		if len(logInfo.Phone) > 4 {
			str = logInfo.Phone[:4]
		}
		infoData.Phone = str
		infoData.ItemId = logInfo.ItemId
		infoData.TypeId = logInfo.TypeId
		ret.AnnouncerLog = append(ret.AnnouncerLog, infoData)
	}
	//处理实时播报数据
	if len(ret.AnnouncerLog) < 100 {
		//后台数据
		if awardLogConfig != nil {
			for _, info := range awardLogConfig.AnnouncerLog {
				if info.TypeId == msg.TypeId {
					infoData := &player_proto.AnnouncerLogInfo{}
					//infoData.Snid = info.Snid
					infoData.Name = info.Name
					str := ""
					if len(info.Phone) > 4 {
						str = info.Phone[:4]
					}
					infoData.Phone = str
					infoData.ItemId = info.ItemId
					infoData.TypeId = info.TypeId
					ret.AnnouncerLog = append(ret.AnnouncerLog, infoData)
					if len(ret.AnnouncerLog) >= 100 {
						break
					}
				}
			}
		}
	}
	p.SendToClient(int(player_proto.PlayerPacketID_PACKET_SCAwardLog), ret)
	logger.Logger.Tracef("SCAwardLog:%v", ret)
	return nil
}
func CSPopUpWindowsConfig(s *netlib.Session, packetId int, data interface{}, sid int64) error {
	p := PlayerMgrSington.GetPlayer(sid)
	if p == nil {
		return nil
	}
	var res []byte
	var err error
	task.New(nil, task.CallableWrapper(func(o *basic.Object) interface{} {
		param := &webapi_proto.ASPopUpWindowsConfig{
			SnId:     p.SnId,
			Platform: p.Platform,
		}
		res, err = webapi.ApiPopupWindowsConfig(common.GetAppId(), param)
		return nil
	}), task.CompleteNotifyWrapper(func(data interface{}, t task.Task) {
		if err != nil || res == nil {
			logger.Logger.Errorf("API_SmsConfig err %v", err)
			return
		}
		var info webapi_proto.SAPopUpWindowsConfig
		proto.Unmarshal(res, &info)
		if info.Tag == webapi_proto.TagCode_SUCCESS {
			ret := &player_proto.SCPopUpWindowsConfig{}
			for _, config := range info.Info {
				infoData := &player_proto.WindowsInfo{}
				infoData.ItemName = config.ItemName
				infoData.Url = config.Url
				infoData.Sort = config.Sort
				infoData.PartNum = config.PartNum
				infoData.GainNum = config.GainNum
				ret.Info = append(ret.Info, infoData)
			}
			p.SendToClient(int(player_proto.PlayerPacketID_PACKET_SCPopUpWindowsConfig), ret)
		} else {
			logger.Logger.Errorf("ApiPopupWindowsConfig err %v", info.Msg)
		}
	}), "Api_PopupWindowsConfig").Start()
	return nil
}

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

	stepId := p.GuideStep + 1
	pack := &player_proto.SCUpdateAttribute{
		OpRetCode: player_proto.OpResultCode_OPRC_Error,
		Tp:        msg.GetTp(),
		Param:     msg.GetParam(),
	}

	send := func() {
		p.SendToClient(int(player_proto.PlayerPacketID_PACKET_SCUpdateAttribute), pack)
		logger.Logger.Tracef("SCUpdateAttribute %v", pack)
		// 日志
		if pack.OpRetCode == player_proto.OpResultCode_OPRC_Sucess {
			switch msg.GetTp() {
			case common.AttributeGuideStep, common.AttributeGuideSkip:
				d := model.CustomData{
					Event:    "guide",
					Platform: p.Platform,
					GuideTp:  msg.GetTp(),
					N:        int64(stepId),
				}
				b, _ := json.Marshal(d)
				mq.Write(&model.ClientLogMysql{
					Data:     string(b),
					Platform: p.Platform,
					Snid:     p.SnId,
					Ts:       time.Now().Unix(),
					CreateTs: p.CreateTime.Unix(),
				})
			}
		}
	}

	switch msg.GetTp() {
	case common.AttributeGuideStep:
		if len(msg.GetParam()) == 0 || msg.GetParam()[0] == 0 || p.GuideStep < 0 {
			return nil
		}
		if PlatformMgrSingleton.GetConfig(p.Platform).GuideConfig.GetOn() != common.On {
			pack.OpRetCode = player_proto.OpResultCode_OPRC_Guide_Close
			send()
			return nil
		}
		if p.GuideStep >= model.GameParamData.GuideStepMaxNum {
			pack.OpRetCode = player_proto.OpResultCode_OPRC_GuideStep_End
			send()
			return nil
		}
		if int64(p.GuideStep) >= msg.GetParam()[0] {
			pack.OpRetCode = player_proto.OpResultCode_OPRC_GuideStep_Finish
			send()
			return nil
		}
		if int64(p.GuideStep)+1 < msg.GetParam()[0] {
			pack.OpRetCode = player_proto.OpResultCode_OPRC_GuideStep_Front
			send()
			return nil
		}
		p.GuideStep = int32(msg.GetParam()[0])
		stepId = p.GuideStep
		pack.OpRetCode = player_proto.OpResultCode_OPRC_Sucess
		send()
		// 获得10v卡
		if p.GuideStep == 2 {
			BagMgrSingleton.AddItems(&model.AddItemParam{
				Platform: p.Platform,
				SnId:     p.SnId,
				Change: []*model.Item{
					{
						ItemId:  common.ItemIDVCard,
						ItemNum: 10,
					},
				},
				GainWay:  common.GainWayGuide,
				Operator: "system",
				Remark:   "新手引导奖励",
			})
		}
		return nil
	case common.AttributeGuideSkip:
		if PlatformMgrSingleton.GetConfig(p.Platform).GuideConfig.GetSkip() != common.On {
			pack.OpRetCode = player_proto.OpResultCode_OPRC_Guide_SkipClose
			send()
			return nil
		}
		if p.GuideStep >= 0 && p.GuideStep < model.GameParamData.GuideStepMaxNum {
			p.GuideStep = -1 // 跳过引导为 -1
			pack.OpRetCode = player_proto.OpResultCode_OPRC_Sucess
			send()
			return nil
		}
	case common.AttributeGuideTest:
		if !common.Config.IsDevMode {
			return nil
		}
		p.GuideStep = int32(msg.GetParam()[0])
		pack.OpRetCode = player_proto.OpResultCode_OPRC_Sucess
		send()
		return nil
	case common.AttributeGuideCustom:
		p.MarkFlag(common.PlayerFlagsGuideCustom)
		pack.OpRetCode = player_proto.OpResultCode_OPRC_Sucess
		send()
		return nil
	}
	return nil
}

// 获取获奖记录
func CSClawdollItemLog(s *netlib.Session, packetId int, data interface{}, sid int64) error {
	logger.Logger.Tracef("CSClawdollItemLog Process %v", data)
	p := PlayerMgrSington.GetPlayer(sid)
	if p == nil {
		return nil
	}

	msg, ok := data.(*player_proto.CSClawdollItemLog)
	if !ok {
		return nil
	}

	ret := &player_proto.SCClawdollItemLog{}
	ret.TypeIds = append(ret.TypeIds, msg.TypeIds...)

	var err error
	var ItemUseLogs []model.RetClawdollItemLog

	//娃娃机道具使用日志
	task.New(nil, task.CallableWrapper(func(o *basic.Object) interface{} {
		ItemUseLogs, err = model.GetClawdollItemLog(p.Platform, p.SnId, msg.TypeIds)
		return err
	}), task.CompleteNotifyWrapper(func(data interface{}, t task.Task) {
		for _, logInfo := range ItemUseLogs {
			infoData := &player_proto.ClawdollItemLogData{}

			infoData.ItemId = logInfo.ItemId
			infoData.Time = logInfo.CreateTs
			infoData.Num = logInfo.Count
			infoData.TypeId = logInfo.TypeId
			infoData.LogType = logInfo.LogType

			ret.ItemLogs = append(ret.ItemLogs, infoData)
		}

		p.SendToClient(int(player_proto.PlayerPacketID_PACKET_SCClawdollItemLog), ret)
		logger.Logger.Tracef("SCClawdollItemLog:%v", ret)
	}), "GetClawdollItemLog").Start()

	return nil
}

func CSCLAWDOLLConfig(s *netlib.Session, packetId int, data interface{}, sid int64) error {
	logger.Logger.Tracef("CSDollConfigHandler")
	if _, ok := data.(*player_proto.CSCLAWDOLLConfig); ok {
		p := PlayerMgrSington.GetPlayer(sid)
		if p == nil {
			logger.Logger.Warn("CSDollConfigHandler p == nil")
			return nil
		}

		machineInfo := PlatformMgrSingleton.GetConfig(p.Platform).MachineConfig
		if machineInfo == nil {
			return nil
		}
		pack := &player_proto.SCCLAWDOLLConfig{}
		for _, value := range machineInfo.Info {
			info := &player_proto.MachineInfo{
				IconAddr:    value.IconAddr,
				CostItemNum: value.CostItemNum,
				ItemId:      value.ItemId,
				ItemNum:     value.ItemNum,
				MachineId:   value.MachineId,
				Name:        value.Name,
			}
			pack.Info = append(pack.Info, info)
		}
		p.SendToClient(int(player_proto.PlayerPacketID_PACKET_SCDollConfig), pack)
	}
	return nil
}
func init() {
	// 用户信息
	common.Register(int(player_proto.PlayerPacketID_PACKET_CS_PLAYERDATA), player_proto.CSPlayerData{}, CSPlayerData)
	// 查看别人信息
	common.Register(int(player_proto.PlayerPacketID_PACKET_CS_QUERYPLAYER), player_proto.CSQueryPlayer{}, CSQueryPlayer)
	// 修改个人信息
	common.Register(int(player_proto.PlayerPacketID_PACKET_CSSavePlayerInfo), player_proto.CSSavePlayerInfo{}, CSSavePlayerInfo)
	// 修改头像url
	common.Register(int(player_proto.PlayerPacketID_PACKET_CS_HeadUrl), player_proto.CSHeadUrl{}, CSHeadUrl)
	// 获取绑定手机号奖励
	common.Register(int(player_proto.PlayerPacketID_PACKET_CSBindTelInfo), player_proto.CSBindTelInfo{}, CSBindTelInfo)
	// 获取短信验证码
	common.Register(int(player_proto.PlayerPacketID_PACKET_CSPlayerSMSCode), player_proto.CSPlayerSMSCode{}, CSPlayerSMSCode)
	// 绑定手机号
	common.Register(int(player_proto.PlayerPacketID_PACKET_CSBindTel), player_proto.CSBindTel{}, CSBindTel)
	// 获取图片验证码
	common.Register(int(player_proto.PlayerPacketID_PACKET_CS_GETIMAGEVERIFYCODE), player_proto.CSGetImageVerifyCode{}, CSGetImageVerifyCodeLocal)
	// 验证图片验证码
	common.Register(int(player_proto.PlayerPacketID_PACKET_CS_ImageVerifyCode), player_proto.CSImageVerifyCode{}, CSImageVerifyCode)
	// 查询游戏账变记录
	common.Register(int(player_proto.PlayerPacketID_PACKET_CSBillList), player_proto.CSBillList{}, CSBillList)
	// 看广告一次
	common.Register(int(player_proto.PlayerPacketID_PACKET_CSADV), player_proto.CSADV{}, CSADV)
	// 渠道开关
	common.Register(int(player_proto.PlayerPacketID_PACKET_CSExchangeChannel), player_proto.CSExchangeChannel{}, CSExchangeChannel)
	//获取运营商配置
	common.Register(int(player_proto.PlayerPacketID_PACKET_CSSMSConfig), player_proto.CSSMSConfig{}, CSSMSConfig)
	//获奖记录
	common.Register(int(player_proto.PlayerPacketID_PACKET_CSAwardLog), player_proto.CS_AwardLog{}, CSAwardLog)
	//弹窗配置
	common.Register(int(player_proto.PlayerPacketID_PACKET_CSPopUpWindowsConfig), player_proto.CSPopUpWindowsConfig{}, CSPopUpWindowsConfig)
	// 更新属性；新手引导阶段
	common.Register(int(player_proto.PlayerPacketID_PACKET_CSUpdateAttribute), player_proto.CSUpdateAttribute{}, CSUpdateAttribute)
	//娃娃卡道具记录
	common.Register(int(player_proto.PlayerPacketID_PACKET_CSClawdollItemLog), player_proto.CSClawdollItemLog{}, CSClawdollItemLog)
	//客户端请求配置信息
	common.Register(int(player_proto.PlayerPacketID_PACKET_CSDollConfig), player_proto.CSCLAWDOLLConfig{}, CSCLAWDOLLConfig)
}