package main

import (
	"errors"
	"fmt"
	"time"

	"mongo.games.com/goserver/core/basic"
	"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/proto"
	webapiproto "mongo.games.com/game/protocol/webapi"
	"mongo.games.com/game/protocol/welfare"
	"mongo.games.com/game/srvdata"
	"mongo.games.com/game/webapi"
)

// 救济金
type CSGetReliefFundPacketFactory struct {
}

type CSGetReliefFundHandler struct {
}

func (this *CSGetReliefFundPacketFactory) CreatePacket() interface{} {
	pack := &welfare.CSGetReliefFund{}
	return pack
}

func (this *CSGetReliefFundHandler) Process(s *netlib.Session, packetid int, data interface{}, sid int64) error {
	logger.Logger.Trace("CSGetReliefFund Process recv ", data)
	if msg, ok := data.(*welfare.CSGetReliefFund); ok {
		p := PlayerMgrSington.GetPlayer(sid)
		if p == nil {
			logger.Logger.Warnf("CSGetReliefFundHandler p == nil")
			return nil
		}
		WelfareMgrSington.GetReliefFund(p, msg.GetIsVideo())
	}
	return nil
}

// 转动转盘
type CSGetTurnplatePacketFactory struct {
}

type CSGetTurnplateHandler struct {
}

func (this *CSGetTurnplatePacketFactory) CreatePacket() interface{} {
	pack := &welfare.CSGetTurnplate{}
	return pack
}

func (this *CSGetTurnplateHandler) Process(s *netlib.Session, packetid int, data interface{}, sid int64) error {
	logger.Logger.Trace("CSGetTurnplate Process recv ", data)
	if msg, ok := data.(*welfare.CSGetTurnplate); ok {
		p := PlayerMgrSington.GetPlayer(sid)
		if p == nil {
			logger.Logger.Warnf("CSGetTurnplateHandler p == nil")
			return nil
		}
		if msg.GetIsVideo() {
			// 看视频可以再领一次
			WelfareMgrSington.GetTurnplteVideo(p)
			return nil
		}
		WelfareMgrSington.GetTurnplate(p)
	}
	return nil
}

// 累计签到
type CSGetAddupSignPacketFactory struct {
}

type CSGetAddupSignHandler struct {
}

func (this *CSGetAddupSignPacketFactory) CreatePacket() interface{} {
	pack := &welfare.CSGetAddupSign{}
	return pack
}

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

		WelfareMgrSington.GetAddupSign(p, msg.GetAddUpDay())
		WelfareMgrSington.UpdateAddUp2Date(p, 0, msg.GetAddUpDay(), time.Now().Unix()+3600)
	}
	return nil
}

// 福利信息
type CSWelfaredInfoPacketFactory struct {
}

type CSWelfaredInfoHandler struct {
}

func (this *CSWelfaredInfoPacketFactory) CreatePacket() interface{} {
	pack := &welfare.CSWelfaredInfo{}
	return pack
}

func (this *CSWelfaredInfoHandler) Process(s *netlib.Session, packetid int, data interface{}, sid int64) error {
	logger.Logger.Trace("CSWelfaredInfo Process recv ", data)
	if _, ok := data.(*welfare.CSWelfaredInfo); ok {
		p := PlayerMgrSington.GetPlayer(sid)
		if p == nil {
			logger.Logger.Warnf("CSWelfaredInfoHandler p == nil")
			return nil
		}
		WelfareMgrSington.WelfaredInfo(p)
	}
	return nil
}

// 查看盲盒
type CSBlindBoxInfoPacketFactory struct {
}

type CSBlindBoxInfoHandler struct {
}

func (this *CSBlindBoxInfoPacketFactory) CreatePacket() interface{} {
	pack := &welfare.CSBlindBoxInfo{}
	return pack
}

func (this *CSBlindBoxInfoHandler) Process(s *netlib.Session, packetid int, data interface{}, sid int64) error {
	logger.Logger.Trace("CSBlindBoxInfo Process recv ", data)
	if msg, ok := data.(*welfare.CSBlindBoxInfo); ok {
		p := PlayerMgrSington.GetPlayer(sid)
		if p == nil {
			logger.Logger.Warnf("CSBlindBoxInfoHandler p == nil")
			return nil
		}
		WelfareMgrSington.BlindBoxInfo(p, msg.GetId())
	}
	return nil
}

// 购买盲盒
type CSBuyBlindBoxPacketFactory struct {
}

type CSBuyBlindBoxHandler struct {
}

func (this *CSBuyBlindBoxPacketFactory) CreatePacket() interface{} {
	pack := &welfare.CSGetBlindBox{}
	return pack
}

func (this *CSBuyBlindBoxHandler) Process(s *netlib.Session, packetid int, data interface{}, sid int64) error {
	logger.Logger.Trace("CSGetBlindBox Process recv ", data)
	if _, ok := data.(*welfare.CSGetBlindBox); ok {
		p := PlayerMgrSington.GetPlayer(sid)
		if p == nil {
			logger.Logger.Warnf("CSBuyBlindBoxHandler p == nil")
			return nil
		}
		//WelfareMgrSington.BuyBlindBox(p, msg.GetId(), msg.ConfigPayId)
	}
	return nil
}

// 查看首充
type CSFirstPayInfoPacketFactory struct {
}

type CSFirstPayInfoHandler struct {
}

func (this *CSFirstPayInfoPacketFactory) CreatePacket() interface{} {
	pack := &welfare.CSWelfareFirstPayData{}
	return pack
}

func (this *CSFirstPayInfoHandler) Process(s *netlib.Session, packetid int, data interface{}, sid int64) error {
	logger.Logger.Trace("CSWelfareFirstPayData Process recv ", data)
	if _, ok := data.(*welfare.CSWelfareFirstPayData); ok {
		p := PlayerMgrSington.GetPlayer(sid)
		if p == nil {
			logger.Logger.Warnf("CSFirstPayInfoHandler p == nil")
			return nil
		}
		WelfareMgrSington.FirstPayInfo(p)
	}
	return nil
}

// 领取首充
type CSBuyFirstPayPacketFactory struct {
}

type CSBuyFirstPayHandler struct {
}

func (this *CSBuyFirstPayPacketFactory) CreatePacket() interface{} {
	pack := &welfare.CSWelfareFirstPay{}
	return pack
}

func (this *CSBuyFirstPayHandler) Process(s *netlib.Session, packetid int, data interface{}, sid int64) error {
	logger.Logger.Trace("CSWelfareFirstPay Process recv ", data)
	if _, ok := data.(*welfare.CSWelfareFirstPay); ok {
		p := PlayerMgrSington.GetPlayer(sid)
		if p == nil {
			logger.Logger.Warnf("CSBuyFirstPayHandler p == nil")
			return nil
		}
		//WelfareMgrSington.BuyFirstPay(p, msg.ConfigPayId)
	}
	return nil
}

// 查看连续充值
type CSContinuousPayInfoPacketFactory struct {
}

type CSContinuousPayInfoHandler struct {
}

func (this *CSContinuousPayInfoPacketFactory) CreatePacket() interface{} {
	pack := &welfare.CSWelfareContinuousPayData{}
	return pack
}

func (this *CSContinuousPayInfoHandler) Process(s *netlib.Session, packetid int, data interface{}, sid int64) error {
	logger.Logger.Trace("CSWelfareContinuousPayData Process recv ", data)
	if _, ok := data.(*welfare.CSWelfareContinuousPayData); ok {
		p := PlayerMgrSington.GetPlayer(sid)
		if p == nil {
			logger.Logger.Warnf("CSContinuousPayInfoHandler p == nil")
			return nil
		}
		WelfareMgrSington.ContinuousPayInfo(p)
	}
	return nil
}

// 领取连续充值
type CSBuyContinuousPayPacketFactory struct {
}

type CSBuyContinuousPayHandler struct {
}

func (this *CSBuyContinuousPayPacketFactory) CreatePacket() interface{} {
	pack := &welfare.CSWelfareContinuousPay{}
	return pack
}

func (this *CSBuyContinuousPayHandler) Process(s *netlib.Session, packetid int, data interface{}, sid int64) error {
	logger.Logger.Trace("CSWelfareContinuousPay Process recv ", data)
	if _, ok := data.(*welfare.CSWelfareContinuousPay); ok {
		p := PlayerMgrSington.GetPlayer(sid)
		if p == nil {
			logger.Logger.Warnf("CSBuyContinuousPayHandler p == nil")
			return nil
		}
		//WelfareMgrSington.BuyContinuousPay(p, msg.ConfigPayId)
	}
	return nil
}

func CSWelfRelief(s *netlib.Session, packetid int, data interface{}, sid int64) error {
	logger.Logger.Tracef("CSWelfRelief Process recv %v", data)
	_, ok := data.(*welfare.CSWelfareRelief)
	if !ok {
		return nil
	}

	p := PlayerMgrSington.GetPlayer(sid)
	if p == nil {
		return nil
	}

	conf := srvdata.PBDB_GameSubsidyMgr.GetData(GameSubsidyid)

	ret := &welfare.SCWelfareRelief{
		LimitNum: conf.GetLimitNum(),
		Get:      conf.GetGet(),
		Times:    conf.GetTimes(),
	}

	p.SendToClient(int(welfare.SPacketID_PACKET_SCWelfRelief), ret)
	logger.Logger.Tracef("SCWelfRelief %v", ret)
	return nil
}

func CSInviteInfo(s *netlib.Session, packetid int, data interface{}, sid int64) error {
	logger.Logger.Tracef("CSInviteInfo Process recv %v", data)
	p := PlayerMgrSington.GetPlayer(sid)
	if p == nil {
		return nil
	}
	link := model.GameParamData.InviteUrl
	f := func() string {
		return fmt.Sprintf("%s?user=%s", link, p.ICode)
	}

	var res []byte
	var err error
	task.New(nil, task.CallableWrapper(func(o *basic.Object) interface{} {
		req := &webapiproto.ASPlayerInviteLink{
			Platform: p.Platform,
			SnId:     p.SnId,
		}
		res, err = webapi.ApiGetInviteLink(common.GetAppId(), req)
		return nil
	}), task.CompleteNotifyWrapper(func(i interface{}, t task.Task) {
		info := webapiproto.SAPlayerInviteLink{}
		if err != nil || res == nil {
			logger.Logger.Errorf("ApiGetInviteLink err %v or not return", err)
		} else {
			proto.Unmarshal(res, &info)
			logger.Logger.Infof("ApiGetInviteLink info %v", info.String())
			link = info.Link
		}

		ret := &welfare.SCInviteInfo{
			Num:       int32(p.INum),
			Code:      p.ICode,
			InviteUrl: f(),
			Score:     p.IScore,
			OtherCode: p.PCode,
		}

		cfg := PlatformMgrSingleton.GetConfig(p.Platform).ActInviteConfig
		if cfg != nil {
			ret.BindScore = cfg.GetBindScore()
			ret.BindTelScore = cfg.GetBindTelScore()
			ret.RechargeScore = cfg.GetRechargeScore()
			ret.PayScore = cfg.GetPayScore()
			for _, v := range cfg.GetAwards1() {
				ret.Awards1 = append(ret.Awards1, &welfare.RankAward{
					Start: v.GetStart(),
					End:   v.GetEnd(),
					Num:   v.GetNum(),
				})
			}
			for _, v := range cfg.GetAwards2() {
				ret.Awards2 = append(ret.Awards2, &welfare.RankAward{
					Start: v.GetStart(),
					End:   v.GetEnd(),
					Num:   v.GetNum(),
				})
			}
			for _, v := range cfg.GetAwards3() {
				ret.Awards3 = append(ret.Awards3, &welfare.RankAward{
					Start: v.GetStart(),
					End:   v.GetEnd(),
					Num:   v.GetNum(),
				})
			}
			ret.Rates = cfg.GetRates()
		}

		p.SendToClient(int(welfare.SPacketID_PACKET_SCInviteInfo), ret)
		logger.Logger.Tracef("SCInviteInfo %v", ret)
	})).Start()
	return nil
}

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

	if !PlatformMgrSingleton.IsOn(p.Platform, common.ChannelSwitchInvite, p.LastChannel) {
		return nil
	}

	ret := &welfare.SCBindInvite{
		OpRetCode: welfare.OpResultCode_OPRC_Error,
	}

	var inviteSnId int32
	var err error
	now := time.Now()
	cfg := PlatformMgrSingleton.GetConfig(p.Platform).ActInviteConfig

	send := func() {
		p.SendToClient(int(welfare.SPacketID_PACKET_SCBindInvite), ret)
		logger.Logger.Tracef("SCBindInvite %v", ret)

		if ret.OpRetCode == welfare.OpResultCode_OPRC_Sucess {
			// 玩家自己的绑定任务
			TaskSubjectSingleton.Touch(common.TaskTypeBindInviter, &TaskData{SnId: p.SnId, Num: 1})
		}
	}

	if p.PSnId != 0 {
		ret.OpRetCode = welfare.OpResultCode_OPRC_AlreadyBind
		send()
		return nil
	}

	task.New(nil, task.CallableWrapper(func(o *basic.Object) interface{} {
		inviteSnId, err = model.GetSnIdByCode(p.Platform, msg.GetCode())
		return nil
	}), task.CompleteNotifyWrapper(func(i interface{}, t task.Task) {
		if err != nil || inviteSnId == 0 {
			logger.Logger.Tracef("GetSnIdByCode not found %v %v", err, msg.GetCode())
			ret.OpRetCode = welfare.OpResultCode_OPRC_NotExist
			send()
			return
		}

		// 3级父级不能是自己
		var err error
		tmpSnId := inviteSnId
		task.New(nil, task.CallableWrapper(func(o *basic.Object) interface{} {
			// todo 优化查找顶级代理
			for i := 0; i < 10000; i++ {
				if tmpSnId == p.SnId {
					ret.OpRetCode = welfare.OpResultCode_OPRC_BindSelf
					err = errors.New("bind error")
					return nil
				}
				tmpSnId, err = model.GetPlayerInviteSnid(p.Platform, tmpSnId)
				if err != nil {
					ret.OpRetCode = welfare.OpResultCode_OPRC_Error
					return nil
				}
				if tmpSnId == 0 {
					break
				}
			}
			if err == nil {
				err = model.BindInviteSnId(p.Platform, p.SnId, inviteSnId, msg.Code)
			}
			if err == nil {
				SaveInviteScore(&model.InviteScore{
					Platform:   p.Platform,
					SnId:       p.SnId,
					InviteSnId: inviteSnId,
					Tp:         common.InviteScoreTypeBind,
					Score:      cfg.GetBindScore(),
					Ts:         now.Unix(),
					Money:      0,
				})
				if len(p.Tel) > 0 {
					SaveInviteScore(&model.InviteScore{
						Platform:   p.Platform,
						SnId:       p.SnId,
						InviteSnId: inviteSnId,
						Tp:         common.InviteScoreTypeBindTel,
						Score:      cfg.GetBindTelScore(),
						Ts:         time.Now().Unix(),
						Money:      0,
					})
				}
			}
			return nil
		}), task.CompleteNotifyWrapper(func(i interface{}, t task.Task) {
			if err != nil {
				send()
				return
			}
			p.PSnId = inviteSnId
			p.PCode = msg.GetCode()
			ret.OpRetCode = welfare.OpResultCode_OPRC_Sucess
			send()
		})).StartByFixExecutor("invite_score")
	})).Start()
	return nil
}

// IsPermitReward 是否已经领取
func IsPermitReward(p *Player, id int32) bool {
	channelConfig := PlatformMgrSingleton.GetPermitConfig(p.Platform, p.LastChannel)
	if channelConfig == nil {
		return true
	}

	startTs := PlatformMgrSingleton.GetConfig(p.Platform).PermitStartTs
	endTs := PlatformMgrSingleton.GetConfig(p.Platform).PermitEndTs

	if p.WelfData != nil && p.WelfData.Task != nil {
		ts := p.WelfData.PermitAward[id]
		if ts == 0 {
			return false
		}
		if ts >= startTs && ts < endTs {
			return true
		}
	}
	return false
}

// IsPermitCanReward 是否可以领取
func IsPermitCanReward(p *Player, id int32) bool {
	if IsPermitReward(p, id) {
		return false
	}

	channelConfig := PlatformMgrSingleton.GetPermitConfig(p.Platform, p.LastChannel)
	if channelConfig == nil {
		return false
	}

	exp := int64(0)
	item := BagMgrSingleton.GetItem(p.SnId, common.ItemIDPermit)
	if item != nil {
		exp = item.ItemNum
	}
	level := PlatformMgrSingleton.GetPermitLevel(p.Platform, p.LastChannel, exp)

	for _, v := range channelConfig.GetLevelConfig() {
		if v.GetRank() == id || v.GetRank()*1000 == id {
			if v.GetRank() == id {
				return level >= int64(v.GetRank())
			} else {
				return p.GetIsPermit() && level >= int64(v.GetRank())
			}
		}
	}

	return false
}

// SendPermitReward 发赛季通行证奖励
// tp 1普通，2典藏
func SendPermitReward(p *Player, m map[int64]int64, tp int32) {
	var items []*model.Item
	for k, v := range m {
		items = append(items, &model.Item{
			ItemId:  int32(k),
			ItemNum: v,
		})
	}
	gain := int32(0)
	giveType := int32(-1)
	switch tp {
	case 1:
		gain = common.GainWayPermitAward
		giveType = model.SystemFreeGive_GiveType_PermitAward
	case 2:
		gain = common.GainWayPermitAward
		giveType = model.SystemFreeGive_GiveType_PermitAward
	}
	BagMgrSingleton.AddItems(&model.AddItemParam{
		Platform:   p.Platform,
		SnId:       p.SnId,
		Change:     items,
		Add:        0,
		GainWay:    gain,
		Operator:   "system",
		Remark:     "通行证奖励",
		GameId:     0,
		GameFreeId: 0,
	})
	for _, v := range items {
		tp1 := int32(-1)
		if v.ItemId == common.ItemIDCoin {
			tp1 = model.SystemFreeGive_CoinType_Coin
		} else if v.ItemId == common.ItemIDDiamond {
			tp1 = model.SystemFreeGive_CoinType_Diamond
		}
		if !p.IsRob && tp1 >= 0 && giveType >= 0 {
			LogChannelSingleton.WriteMQData(
				model.GenerateSystemFreeGive(p.SnId, p.Name, p.Platform, p.Channel, giveType, tp1, v.ItemNum))
		}
	}
}

func CSPermitInfo(s *netlib.Session, packetid int, data interface{}, sid int64) error {
	logger.Logger.Tracef("CSPermitInfo Process recv %v", data)
	_, ok := data.(*welfare.CSPermitInfo)
	if !ok {
		return nil
	}
	p := PlayerMgrSington.GetPlayer(sid)
	if p == nil {
		return nil
	}
	if p.LastChannel == "" {
		logger.Logger.Errorf("CSPermitInfo not channel %v", p.SnId)
		return nil
	}

	channelConfig := PlatformMgrSingleton.GetPermitConfig(p.Platform, p.LastChannel)
	if channelConfig == nil {
		logger.Logger.Errorf("CSPermitInfo not channelConfig %v", p.SnId)
		return nil
	}
	startTs := PlatformMgrSingleton.GetConfig(p.Platform).PermitStartTs
	endTs := PlatformMgrSingleton.GetConfig(p.Platform).PermitEndTs
	if startTs == 0 || endTs == 0 {
		logger.Logger.Errorf("CSPermitInfo not startTs %v", p.SnId)
		return nil
	}
	// 赛季积分
	exp := int64(0)
	item := BagMgrSingleton.GetItem(p.SnId, common.ItemIDPermit)
	if item != nil {
		exp = item.ItemNum
	}
	// 等级
	level := PlatformMgrSingleton.GetPermitLevel(p.Platform, p.LastChannel, exp)

	pack := &welfare.SCPermitInfo{
		Exp:       exp,
		Level:     level,
		Timestamp: []int64{startTs, endTs - 1},
		IsPermit:  p.GetIsPermit(),
		RefreshTs: common.GetDayNextStartTs(time.Now().Unix()),
	}
	// 等级奖励
	for _, v := range channelConfig.GetLevelConfig() {
		var a1, a2 []*welfare.PropInfo
		for _, vv := range v.GetAward1() {
			a1 = append(a1, &welfare.PropInfo{
				ItemId:  vv.GetItemId(),
				ItemNum: vv.GetItemNum(),
			})
		}
		for _, vv := range v.GetAward2() {
			a2 = append(a2, &welfare.PropInfo{
				ItemId:  vv.GetItemId(),
				ItemNum: vv.GetItemNum(),
			})
		}

		status1 := 0
		if IsPermitReward(p, v.GetRank()) {
			status1 = 2
		} else {
			if IsPermitCanReward(p, v.GetRank()) {
				status1 = 1
			}
		}

		status2 := 0
		if IsPermitReward(p, v.GetRank()*1000) {
			status2 = 2
		} else {
			if IsPermitCanReward(p, v.GetRank()*1000) {
				status2 = 1
			}
		}

		pack.Award = append(pack.Award, &welfare.PermitAward{
			Exp:   v.GetScore(),
			Level: int64(v.GetRank()),
			Award1: &welfare.PropItem{
				Award:  a1,
				Status: int64(status1),
				Id:     v.GetRank(),
			},
			Award2: &welfare.PropItem{
				Award:  a2,
				Status: int64(status2),
				Id:     v.GetRank() * 1000,
			},
		})
	}
	// 排行奖励
	for _, v := range channelConfig.GetRankConfig() {
		var items []*welfare.PropInfo
		for _, vv := range v.GetItemId() {
			items = append(items, &welfare.PropInfo{
				ItemId:  vv.GetItemId(),
				ItemNum: vv.GetItemNum(),
			})
		}
		pack.RankAward = append(pack.RankAward, &welfare.PermitRankAward{
			Start:  v.GetStart(),
			End:    v.GetEnd(),
			ItemId: items,
		})
	}
	// 客户端轮播配置
	for _, v := range srvdata.PBDB_PassShowMgr.Datas.GetArr() {
		pack.ShowList = append(pack.ShowList, &welfare.PermitShow{
			ShowType:   v.GetShowType(),
			ShowVolume: v.GetShowVolume(),
			Location:   v.GetLocation(),
		})
	}
	p.SendToClient(int(welfare.SPacketID_PACKET_SCPermitInfo), pack)
	logger.Logger.Tracef("SCPermitInfo: %v", pack)
	return nil
}

func CSPermitAward(s *netlib.Session, packetid int, data interface{}, sid int64) error {
	logger.Logger.Tracef("CSPermitAward Process recv %v", data)
	msg, ok := data.(*welfare.CSPermitAward)
	if !ok {
		return nil
	}
	p := PlayerMgrSington.GetPlayer(sid)
	if p == nil {
		return nil
	}
	if p.LastChannel == "" {
		logger.Logger.Errorf("CSPermitAward not channel %v", p.SnId)
		return nil
	}

	if !PlatformMgrSingleton.IsOn(p.Platform, common.ChannelSwitchPermit, p.LastChannel) {
		return nil
	}

	channelConfig := PlatformMgrSingleton.GetPermitConfig(p.Platform, p.LastChannel)
	if channelConfig == nil {
		logger.Logger.Errorf("CSPermitAward not channelConfig %v", p.SnId)
		return nil
	}
	startTs := PlatformMgrSingleton.GetConfig(p.Platform).PermitStartTs
	endTs := PlatformMgrSingleton.GetConfig(p.Platform).PermitEndTs
	now := time.Now()
	if startTs == 0 || endTs == 0 || now.Unix() < startTs || now.Unix() >= endTs {
		logger.Logger.Errorf("CSPermitAward not startTs %v", p.SnId)
		return nil
	}

	pack := &welfare.SCPermitAward{
		OpRetCode: welfare.OpResultCode_OPRC_Sucess,
		Tp:        msg.GetTp(),
		Id:        msg.GetId(),
	}

	switch msg.GetTp() {
	case 0: // 所有
		for _, v := range channelConfig.GetLevelConfig() {
			if IsPermitCanReward(p, v.GetRank()) {
				for _, vv := range v.GetAward1() {
					pack.Award1 = append(pack.Award1, &welfare.PropInfo{
						ItemId:  vv.GetItemId(),
						ItemNum: vv.GetItemNum(),
					})
				}
				p.WelfData.PermitAward[v.GetRank()] = now.Unix()
			}
			if IsPermitCanReward(p, v.GetRank()*1000) {
				for _, vv := range v.GetAward2() {
					pack.Award2 = append(pack.Award2, &welfare.PropInfo{
						ItemId:  vv.GetItemId(),
						ItemNum: vv.GetItemNum(),
					})
				}
				p.WelfData.PermitAward[v.GetRank()*1000] = now.Unix()
			}
		}

	case 1: // 普通
		for _, v := range channelConfig.GetLevelConfig() {
			if msg.GetId() == 0 {
				if IsPermitCanReward(p, v.GetRank()) {
					for _, vv := range v.GetAward1() {
						pack.Award1 = append(pack.Award1, &welfare.PropInfo{
							ItemId:  vv.GetItemId(),
							ItemNum: vv.GetItemNum(),
						})
					}
					p.WelfData.PermitAward[v.GetRank()] = now.Unix()
				}
			} else {
				if v.GetRank() == msg.GetId() {
					if IsPermitCanReward(p, v.GetRank()) {
						for _, vv := range v.GetAward1() {
							pack.Award1 = append(pack.Award1, &welfare.PropInfo{
								ItemId:  vv.GetItemId(),
								ItemNum: vv.GetItemNum(),
							})
						}
						p.WelfData.PermitAward[v.GetRank()] = now.Unix()
					} else {
						pack.OpRetCode = welfare.OpResultCode_OPRC_NoTimes
					}
					break
				}
			}
		}

	case 2: // 典藏
		for _, v := range channelConfig.GetLevelConfig() {
			if msg.GetId() == 0 {
				if IsPermitCanReward(p, v.GetRank()*1000) {
					for _, vv := range v.GetAward2() {
						pack.Award2 = append(pack.Award2, &welfare.PropInfo{
							ItemId:  vv.GetItemId(),
							ItemNum: vv.GetItemNum(),
						})
					}
					p.WelfData.PermitAward[v.GetRank()*1000] = now.Unix()
				}
			} else {
				if v.GetRank()*1000 == msg.GetId() {
					if IsPermitCanReward(p, msg.GetId()) {
						for _, vv := range v.GetAward2() {
							pack.Award2 = append(pack.Award2, &welfare.PropInfo{
								ItemId:  vv.GetItemId(),
								ItemNum: vv.GetItemNum(),
							})
						}
						p.WelfData.PermitAward[v.GetRank()*1000] = now.Unix()
					} else {
						pack.OpRetCode = welfare.OpResultCode_OPRC_NoTimes
					}
					break
				}
			}
		}
	}

	// 奖励合并
	var award1 = map[int32]*welfare.PropInfo{}
	var award2 = map[int32]*welfare.PropInfo{}
	var awards1 = map[int64]int64{}
	var awards2 = map[int64]int64{}
	for _, v := range pack.GetAward1() {
		e, ok := award1[v.GetItemId()]
		if !ok {
			e = &welfare.PropInfo{
				ItemId:  v.GetItemId(),
				ItemNum: v.GetItemNum(),
			}
			award1[v.GetItemId()] = e
		} else {
			e.ItemNum = e.GetItemNum() + v.GetItemNum()
		}
		awards1[int64(v.GetItemId())] = awards1[int64(v.GetItemId())] + v.GetItemNum()
	}
	for _, v := range pack.GetAward2() {
		e, ok := award2[v.GetItemId()]
		if !ok {
			e = &welfare.PropInfo{
				ItemId:  v.GetItemId(),
				ItemNum: v.GetItemNum(),
			}
			award2[v.GetItemId()] = e
		} else {
			e.ItemNum = e.GetItemNum() + v.GetItemNum()
		}
		awards2[int64(v.GetItemId())] = awards2[int64(v.GetItemId())] + v.GetItemNum()
	}
	// 发奖
	SendPermitReward(p, awards1, 1)
	SendPermitReward(p, awards2, 2)
	pack.Award1 = nil
	pack.Award2 = nil
	for _, v := range award1 {
		pack.Award1 = append(pack.Award1, &welfare.PropInfo{
			ItemId:  v.GetItemId(),
			ItemNum: v.GetItemNum(),
		})
	}
	for _, v := range award2 {
		pack.Award2 = append(pack.Award2, &welfare.PropInfo{
			ItemId:  v.GetItemId(),
			ItemNum: v.GetItemNum(),
		})
	}
	p.SendToClient(int(welfare.SPacketID_PACKET_SCPermitAward), pack)
	logger.Logger.Tracef("SCPermitAward: %v", pack)
	return nil
}

// GetPermitExchangeNum 获取已兑换次数
func GetPermitExchangeNum(p *Player, id int32) int {
	channelConfig := PlatformMgrSingleton.GetPermitConfig(p.Platform, p.LastChannel)
	if channelConfig == nil {
		return 0
	}

	return len(p.WelfData.PermitExchange[id])
}

// GetPermitCanExchange 是否可以兑换
// 1等级不足 2需要典藏通行证 3兑换次数不足 4商品不存在
func GetPermitCanExchange(p *Player, id int32) (bool, int) {
	channelConfig := PlatformMgrSingleton.GetPermitConfig(p.Platform, p.LastChannel)
	if channelConfig == nil {
		return false, 0
	}

	times := GetPermitExchangeNum(p, id)
	exp := int64(0)
	item := BagMgrSingleton.GetItem(p.SnId, common.ItemIDPermit)
	if item != nil {
		exp = item.ItemNum
	}
	level := PlatformMgrSingleton.GetPermitLevel(p.Platform, p.LastChannel, exp)

	for _, v := range channelConfig.GetExchangeConfig() {
		if v.GetId() == id {
			if !v.GetIsShow() {
				return false, 3
			}
			// 等级
			if level < v.GetLevel() {
				return false, 1
			}
			// 通行证
			if v.GetIsPermit() && !p.GetIsPermit() {
				return false, 2
			}
			// 剩余兑换次数
			if v.GetTimes() > 0 && int64(times) >= v.GetTimes() {
				return false, 3
			}
			return true, 0
		}
	}

	return false, 4
}

func CSPermitExchangeList(s *netlib.Session, packetid int, data interface{}, sid int64) error {
	logger.Logger.Tracef("CSPermitExchangeList Process recv %v", data)
	_, ok := data.(*welfare.CSPermitExchangeList)
	if !ok {
		return nil
	}
	p := PlayerMgrSington.GetPlayer(sid)
	if p == nil {
		return nil
	}
	if p.LastChannel == "" {
		logger.Logger.Errorf("CSPermitExchangeList not channel %v", p.SnId)
		return nil
	}

	channelConfig := PlatformMgrSingleton.GetPermitConfig(p.Platform, p.LastChannel)
	if channelConfig == nil {
		logger.Logger.Errorf("CSPermitExchangeList not channelConfig %v", p.SnId)
		return nil
	}
	startTs := PlatformMgrSingleton.GetConfig(p.Platform).PermitStartTs
	endTs := PlatformMgrSingleton.GetConfig(p.Platform).PermitEndTs
	if startTs == 0 || endTs == 0 {
		logger.Logger.Errorf("CSPermitExchangeList not startTs %v", p.SnId)
		return nil
	}

	pack := &welfare.SCPermitExchangeList{}

	for _, v := range channelConfig.GetExchangeConfig() {
		if !v.GetIsShow() {
			continue
		}
		var gain, cost []*welfare.PropInfo
		for _, vv := range v.GetGain() {
			gain = append(gain, &welfare.PropInfo{
				ItemId:  vv.GetItemId(),
				ItemNum: vv.GetItemNum(),
			})
		}
		for _, vv := range v.GetCost() {
			cost = append(cost, &welfare.PropInfo{
				ItemId:  vv.GetItemId(),
				ItemNum: vv.GetItemNum(),
			})
		}

		times := int32(v.GetTimes()) - int32(GetPermitExchangeNum(p, v.GetId()))

		exchangeTimes := v.GetTimes()
		if exchangeTimes == 0 {
			exchangeTimes = -1
		}
		pack.List = append(pack.List, &welfare.ShopInfo{
			Id:            v.GetId(),
			Gain:          gain,
			Cost:          cost,
			ExchangeTimes: int32(exchangeTimes),
			RemainTimes:   times,
			Level:         v.GetLevel(),
			NeedPermit:    v.GetIsPermit(),
			SortId:        v.GetSortId(),
		})
	}
	p.SendToClient(int(welfare.SPacketID_PACKET_SCPermitExchangeList), pack)
	logger.Logger.Tracef("SCPermitExchangeList: %v", pack)
	return nil
}

func CSPermitExchange(s *netlib.Session, packetid int, data interface{}, sid int64) error {
	logger.Logger.Tracef("CSPermitExchange Process recv %v", data)
	msg, ok := data.(*welfare.CSPermitExchange)
	if !ok {
		return nil
	}
	p := PlayerMgrSington.GetPlayer(sid)
	if p == nil {
		return nil
	}
	if p.LastChannel == "" {
		logger.Logger.Errorf("CSPermitExchange not channel %v", p.SnId)
		return nil
	}
	if !PlatformMgrSingleton.IsOn(p.Platform, common.ChannelSwitchPermit, p.LastChannel) {
		return nil
	}
	channelConfig := PlatformMgrSingleton.GetPermitConfig(p.Platform, p.LastChannel)
	if channelConfig == nil {
		logger.Logger.Errorf("CSPermitExchange not channelConfig %v", p.SnId)
		return nil
	}
	startTs := PlatformMgrSingleton.GetConfig(p.Platform).PermitStartTs
	endTs := PlatformMgrSingleton.GetConfig(p.Platform).PermitEndTs
	now := time.Now()
	if startTs == 0 || endTs == 0 || now.Unix() < startTs || now.Unix() >= endTs {
		logger.Logger.Errorf("CSPermitExchange not startTs %v", p.SnId)
		return nil
	}

	isExchange, code := GetPermitCanExchange(p, msg.GetId())
	pack := &welfare.SCPermitExchange{
		OpRetCode: welfare.OpResultCode_OPRC_Sucess,
	}
	send := func(d welfare.OpResultCode) {
		// 1等级不足 2需要典藏通行证 3兑换次数不足 4商品不存在
		switch code {
		case 1:
			pack.OpRetCode = welfare.OpResultCode_OPRC_ExchangeLevelLimit
		case 2:
			pack.OpRetCode = welfare.OpResultCode_OPRC_NeedPermit
		case 3:
			pack.OpRetCode = welfare.OpResultCode_OPRC_ExchangeLimit
		case 4:
			pack.OpRetCode = welfare.OpResultCode_OPRC_NotFound
		}
		if code == 0 {
			pack.OpRetCode = d
		}
		p.SendToClient(int(welfare.SPacketID_PACKET_SCPermitExchange), pack)
		logger.Logger.Tracef("SCPermitExchange: %v", pack)
	}

	if isExchange {
		var exchangeConfig *webapiproto.PermitExchangeConfig
		for _, v := range channelConfig.GetExchangeConfig() {
			if v.GetId() == msg.GetId() {
				exchangeConfig = v
				break
			}
		}
		if exchangeConfig != nil {
			// 检查背包是否足够
			var items []*model.Item
			var costItems, cost1 []*model.Item
			var cost, gain []model.AwardItem
			for _, v := range exchangeConfig.GetCost() {
				item := BagMgrSingleton.GetItem(p.SnId, v.GetItemId())
				if item == nil || item.ItemNum < v.GetItemNum() {
					send(welfare.OpResultCode_OPRC_ErrCost)
					return nil
				}
				info := srvdata.GameItemMgr.Get(p.Platform, v.GetItemId())
				if info != nil {
					costItems = append(costItems, &model.Item{
						ItemId:  v.GetItemId(),
						ItemNum: -v.GetItemNum(),
					})
					cost = append(cost, model.AwardItem{
						Id:  v.GetItemId(),
						Num: v.GetItemNum(),
					})
					cost1 = append(cost1, &model.Item{
						ItemId:  v.GetItemId(),
						ItemNum: v.GetItemNum(),
					})
				}
			}
			for _, v := range exchangeConfig.GetGain() {
				info := srvdata.GameItemMgr.Get(p.Platform, v.GetItemId())
				if info != nil {
					items = append(items, &model.Item{
						ItemId:  v.GetItemId(),
						ItemNum: v.GetItemNum(),
					})
					gain = append(gain, model.AwardItem{
						Id:  v.GetItemId(),
						Num: v.GetItemNum(),
					})
				}
			}
			// 扣除背包物品
			BagMgrSingleton.AddItems(&model.AddItemParam{
				Platform: p.Platform,
				SnId:     p.SnId,
				Change:   costItems,
				GainWay:  common.GainWayPermitExchangeCost,
				Operator: "system",
				Remark:   "赛季通行证兑换消耗",
			})
			// 增加背包物品
			BagMgrSingleton.AddItems(&model.AddItemParam{
				Platform:   p.Platform,
				SnId:       p.SnId,
				Change:     items,
				Cost:       cost1,
				Add:        0,
				GainWay:    common.GainWayPermitExchangeGain,
				Operator:   "system",
				Remark:     "赛季通行证兑换获得",
				GameId:     0,
				GameFreeId: 0,
				NoLog:      false,
			})
			p.WelfData.PermitExchange[msg.GetId()] = append(p.WelfData.PermitExchange[msg.GetId()], now.Unix())
			// 兑换记录
			LogChannelSingleton.WriteLog(&model.BackendPermitExchange{
				Platform: p.Platform,
				StartTs:  startTs,
				SnId:     p.SnId,
				Id:       exchangeConfig.Id,
				Cost:     cost,
				Gain:     gain,
				Ts:       now.Unix(),
			})
		}
	}

	send(welfare.OpResultCode_OPRC_Sucess)
	return nil
}

func CSPermitShop(s *netlib.Session, packetid int, data interface{}, sid int64) error {
	logger.Logger.Tracef("CSPermitShop Process recv %v", data)
	_, ok := data.(*welfare.CSPermitShop)
	if !ok {
		return nil
	}
	p := PlayerMgrSington.GetPlayer(sid)
	if p == nil {
		return nil
	}
	if p.LastChannel == "" {
		logger.Logger.Errorf("CSPermitShop not channel %v", p.SnId)
		return nil
	}
	channelConfig := PlatformMgrSingleton.GetPermitConfig(p.Platform, p.LastChannel)
	if channelConfig == nil {
		logger.Logger.Errorf("CSPermitShop not channelConfig %v", p.SnId)
		return nil
	}
	startTs := PlatformMgrSingleton.GetConfig(p.Platform).PermitStartTs
	endTs := PlatformMgrSingleton.GetConfig(p.Platform).PermitEndTs
	if startTs == 0 || endTs == 0 {
		logger.Logger.Errorf("CSPermitShop not startTs %v", p.SnId)
		return nil
	}

	shopInfo := ShopMgrSington.GetShopInfo(common.ShopIdPermit, p)
	if shopInfo == nil {
		logger.Logger.Errorf("CSPermitShop is null %v", p.SnId)
		return nil
	}
	price := int64(0)
	if len(shopInfo.CostArea) > 0 {
		price = int64(shopInfo.CostArea[0])
	}

	pack := &welfare.SCPermitShop{
		Id:      shopInfo.Id,
		Name:    shopInfo.Name,
		Consume: shopInfo.ConstType,
		Price:   price,
	}
	p.SendToClient(int(welfare.SPacketID_PACKET_SCPermitShop), pack)
	logger.Logger.Tracef("SCPermitShop: %v", pack)
	return nil
}

// ------------------------------------------------
type CSPigBankGetInfoPacketFactory struct {
}

type CSPigBankGetInfoHandler struct {
}

func (this *CSPigBankGetInfoPacketFactory) CreatePacket() interface{} {
	pack := &welfare.CSPigbankGetInfo{}
	return pack
}

func (this *CSPigBankGetInfoHandler) Process(s *netlib.Session, packetid int, data interface{}, sid int64) error {
	logger.Logger.Trace("CSPigbankGetInfo Process recv ", data)
	if _, ok := data.(*welfare.CSPigbankGetInfo); ok {
		p := PlayerMgrSington.GetPlayer(sid)
		if p == nil {
			logger.Logger.Warnf("CSPigBankGetInfoHandler p == nil")
			return nil
		}
		WelfareMgrSington.PigbankGetInfo(p)
	}
	return nil
}

// ------------------------------------------------
type CSPigBankTakeCoinPacketFactory struct {
}

type CSPigBankTakeCoinHandler struct {
}

func (this *CSPigBankTakeCoinPacketFactory) CreatePacket() interface{} {
	pack := &welfare.CSPigbankTakeCoin{}
	return pack
}

func (this *CSPigBankTakeCoinHandler) Process(s *netlib.Session, packetid int, data interface{}, sid int64) error {
	logger.Logger.Trace("CSPigbankTakeCoin Process recv ", data)
	if _, ok := data.(*welfare.CSPigbankTakeCoin); ok {
		p := PlayerMgrSington.GetPlayer(sid)
		if p == nil {
			logger.Logger.Warnf("CSPigBankTakeCoinHandler p == nil")
			return nil
		}
		WelfareMgrSington.PigbankTakeCoin(p)
	}
	return nil
}

// GetAddUp2Award
type CSSignDayAddup2AwardPacketFactory struct {
}

type CSSignDayAddup2AwardHandler struct {
}

func (this *CSSignDayAddup2AwardPacketFactory) CreatePacket() interface{} {
	pack := &welfare.CSSignDayAddup2Award{}
	return pack
}

func (this *CSSignDayAddup2AwardHandler) Process(s *netlib.Session, packetid int, data interface{}, sid int64) error {
	logger.Logger.Trace("CSSignDayAddup2Award Process recv ", data)
	if msg, ok := data.(*welfare.CSSignDayAddup2Award); ok {
		p := PlayerMgrSington.GetPlayer(sid)
		if p == nil {
			logger.Logger.Warnf("CSPigBankTakeCoinHandler p == nil")
			return nil
		}
		WelfareMgrSington.GetAddUp2Award(p, msg.Day)
	}
	return nil
}

type CSDiamondBankGetInfoPacketFactory struct {
}

type CSDiamondBankGetInfoHandler struct {
}

func (this *CSDiamondBankGetInfoPacketFactory) CreatePacket() interface{} {
	pack := &welfare.CSDiamondBankGetInfo{}
	return pack
}

func (this *CSDiamondBankGetInfoHandler) Process(s *netlib.Session, packetid int, data interface{}, sid int64) error {
	logger.Logger.Trace("CSDiamondBankGetInfo Process recv ", data)
	if _, ok := data.(*welfare.CSDiamondBankGetInfo); ok {
		p := PlayerMgrSington.GetPlayer(sid)
		if p == nil {
			logger.Logger.Warnf("CSPigBankTakeCoinHandler p == nil")
			return nil
		}
		WelfareMgrSington.DiamondBankGetInfo(p)
	}
	return nil
}

/*// 钻石储存罐
type CSDiamondBankTakeDiamondPacketFactory struct {
}

type CSDiamondBankTakeDiamondHandler struct {
}

func (this *CSDiamondBankTakeDiamondPacketFactory) CreatePacket() interface{} {
	pack := &welfare.CSDiamondBankTakeDiamond{}
	return pack
}

func (this *CSDiamondBankTakeDiamondHandler) Process(s *netlib.Session, packetid int, data interface{}, sid int64) error {
	logger.Logger.Trace("CSDiamondBankGetInfo Process recv ", data)
	if _, ok := data.(*welfare.CSDiamondBankTakeDiamond); ok {
		p := PlayerMgrSington.GetPlayer(sid)
		if p == nil {
			logger.Logger.Warnf("CSPigBankTakeCoinHandler p == nil")
			return nil
		}
		WelfareMgrSington.DiamondBankTakeCoin(p)
	}
	return nil
}*/

func init() {
	// 领取救济金
	common.RegisterHandler(int(welfare.SPacketID_PACKET_CS_WELF_GETRELIEFFUND), &CSGetReliefFundHandler{})
	netlib.RegisterFactory(int(welfare.SPacketID_PACKET_CS_WELF_GETRELIEFFUND), &CSGetReliefFundPacketFactory{})
	//转动转盘
	common.RegisterHandler(int(welfare.SPacketID_PACKET_CS_WELF_GETTURNPLATE), &CSGetTurnplateHandler{})
	netlib.RegisterFactory(int(welfare.SPacketID_PACKET_CS_WELF_GETTURNPLATE), &CSGetTurnplatePacketFactory{})
	//累计签到
	common.RegisterHandler(int(welfare.SPacketID_PACKET_CS_WELF_GETADDUPSIGN), &CSGetAddupSignHandler{})
	netlib.RegisterFactory(int(welfare.SPacketID_PACKET_CS_WELF_GETADDUPSIGN), &CSGetAddupSignPacketFactory{})
	//福利信息
	common.RegisterHandler(int(welfare.SPacketID_PACKET_CS_WELF_WELFAREINFO), &CSWelfaredInfoHandler{})
	netlib.RegisterFactory(int(welfare.SPacketID_PACKET_CS_WELF_WELFAREINFO), &CSWelfaredInfoPacketFactory{})
	//查看盲盒
	common.RegisterHandler(int(welfare.SPacketID_PACKET_CS_WELF_BLINBOXINFO), &CSBlindBoxInfoHandler{})
	netlib.RegisterFactory(int(welfare.SPacketID_PACKET_CS_WELF_BLINBOXINFO), &CSBlindBoxInfoPacketFactory{})
	//购买盲盒
	common.RegisterHandler(int(welfare.SPacketID_PACKET_CS_WELF_GETBLINBOX), &CSBuyBlindBoxHandler{})
	netlib.RegisterFactory(int(welfare.SPacketID_PACKET_CS_WELF_GETBLINBOX), &CSBuyBlindBoxPacketFactory{})
	//查看首充
	common.RegisterHandler(int(welfare.SPacketID_PACKET_CS_WELF_FIRSTPAYINFO), &CSFirstPayInfoHandler{})
	netlib.RegisterFactory(int(welfare.SPacketID_PACKET_CS_WELF_FIRSTPAYINFO), &CSFirstPayInfoPacketFactory{})
	//领取首充
	common.RegisterHandler(int(welfare.SPacketID_PACKET_CS_WELF_FIRSTPAY), &CSBuyFirstPayHandler{})
	netlib.RegisterFactory(int(welfare.SPacketID_PACKET_CS_WELF_FIRSTPAY), &CSBuyFirstPayPacketFactory{})
	//查看连续充值
	common.RegisterHandler(int(welfare.SPacketID_PACKET_CS_WELF_CONTINPAYINFO), &CSContinuousPayInfoHandler{})
	netlib.RegisterFactory(int(welfare.SPacketID_PACKET_CS_WELF_CONTINPAYINFO), &CSContinuousPayInfoPacketFactory{})
	//领取连续充值
	common.RegisterHandler(int(welfare.SPacketID_PACKET_CS_WELF_CONTINPAY), &CSBuyContinuousPayHandler{})
	netlib.RegisterFactory(int(welfare.SPacketID_PACKET_CS_WELF_CONTINPAY), &CSBuyContinuousPayPacketFactory{})
	// 破产补助信息
	common.Register(int(welfare.SPacketID_PACKET_CSWelfRelief), welfare.CSWelfareRelief{}, CSWelfRelief)
	// 邀请信息
	common.Register(int(welfare.SPacketID_PACKET_CSInviteInfo), welfare.CSInviteInfo{}, CSInviteInfo)
	// 绑定信息
	common.Register(int(welfare.SPacketID_PACKET_CSBindInvite), welfare.CSBindInvite{}, CSBindInvite)

	//获取存钱罐数据
	common.RegisterHandler(int(welfare.SPacketID_PACKET_CSPigbankGetInfo), &CSPigBankGetInfoHandler{})
	netlib.RegisterFactory(int(welfare.SPacketID_PACKET_CSPigbankGetInfo), &CSPigBankGetInfoPacketFactory{})
	//领取存钱罐金币
	common.RegisterHandler(int(welfare.SPacketID_PACKET_CSPigbankTakeCoin), &CSPigBankTakeCoinHandler{})
	netlib.RegisterFactory(int(welfare.SPacketID_PACKET_CSPigbankTakeCoin), &CSPigBankTakeCoinPacketFactory{})
	//领取七日签到进阶奖励
	common.RegisterHandler(int(welfare.SPacketID_PACKET_CS_SignDay_Addup2Award), &CSSignDayAddup2AwardHandler{})
	netlib.RegisterFactory(int(welfare.SPacketID_PACKET_CS_SignDay_Addup2Award), &CSSignDayAddup2AwardPacketFactory{})
	//钻石储存罐信息
	common.RegisterHandler(int(welfare.SPacketID_PACKET_CSDiamondBankGetInfo), &CSDiamondBankGetInfoHandler{})
	netlib.RegisterFactory(int(welfare.SPacketID_PACKET_CSDiamondBankGetInfo), &CSDiamondBankGetInfoPacketFactory{})

	//领取钻石储存罐
	/*	common.RegisterHandler(int(welfare.SPacketID_PACKET_CSDiamondBankTakeDiamond), &CSDiamondBankTakeDiamondHandler{})
		netlib.RegisterFactory(int(welfare.SPacketID_PACKET_CSDiamondBankTakeDiamond), &CSDiamondBankTakeDiamondPacketFactory{})*/

	// 赛季通行证信息
	common.Register(int(welfare.SPacketID_PACKET_CSPermitInfo), welfare.CSPermitInfo{}, CSPermitInfo)
	// 赛季通行证奖励领取
	common.Register(int(welfare.SPacketID_PACKET_CSPermitAward), welfare.CSPermitAward{}, CSPermitAward)
	// 赛季通行证兑换列表
	common.Register(int(welfare.SPacketID_PACKET_CSPermitExchangeList), welfare.CSPermitExchangeList{}, CSPermitExchangeList)
	// 赛季通行证兑换
	common.Register(int(welfare.SPacketID_PACKET_CSPermitExchange), welfare.CSPermitExchange{}, CSPermitExchange)
	// 赛季典藏通行证商品信息
	common.Register(int(welfare.SPacketID_PACKET_CSPermitShop), welfare.CSPermitShop{}, CSPermitShop)
}