package game

import (
	"bytes"
	"encoding/gob"
	"encoding/json"
	"fmt"
	"os"
	"reflect"
	"server/MergeConst"
	"server/conf"
	userCfg "server/conf/user"
	GoUtil "server/game_util"
	"strconv"
	"sync"

	l "log"
	"server/db"
	"server/game/internal"

	MsgMod "server/game/mod/msg"
	"server/msg"
	"time"

	"github.com/robfig/cron/v3"

	"google.golang.org/protobuf/proto"

	"gitea.bywaystudios.com/pet_home/leaf/gate"
	"gitea.bywaystudios.com/pet_home/leaf/timer"

	"gitea.bywaystudios.com/pet_home/leaf/log"
)

var (
	G_GameLogicPtr *GameLogic
)

var isInitGameLogic = false
var RegisterNetWorkFunc = make(map[string]interface{})
var NewRegisterNetWorkFunc = make(map[string]func(*Player, *proto.Message) error)

const (
	SERVER_STATUS_OPEN     = 1 // 服务器状态 开放
	SERVER_STATUS_CLOSE    = 2 // 服务器状态 关闭
	SERVER_STATUS_MAINTAIN = 3 // 服务器状态 维护
	SERVER_STATUS_FULL     = 4 // 服务器状态 爆满
)

func RegisterMsgProcessFunc(key string, value1 interface{}) {
	RegisterNetWorkFunc[key] = value1
}

func RegisterNewMsgProcessFunc(key string, value interface{}) {
	handler, err := buildNewMsgHandlerAdapter(value)
	if err != nil {
		panic(fmt.Sprintf("RegisterNewMsgProcessFunc[%s] invalid handler: %v", key, err))
	}
	NewRegisterNetWorkFunc[key] = handler
}

func buildNewMsgHandlerAdapter(value interface{}) (func(*Player, *proto.Message) error, error) {
	if fn, ok := value.(func(*Player, *proto.Message) error); ok {
		return fn, nil
	}

	if value == nil {
		return nil, fmt.Errorf("handler is nil")
	}

	rv := reflect.ValueOf(value)
	rt := rv.Type()
	if rt.Kind() != reflect.Func {
		return nil, fmt.Errorf("handler must be function, got %s", rt.Kind())
	}
	if rt.NumIn() != 2 || rt.NumOut() != 1 {
		return nil, fmt.Errorf("handler signature must be func(*Player, *T) error")
	}
	if rt.In(0) != reflect.TypeOf(&Player{}) {
		return nil, fmt.Errorf("first arg must be *Player")
	}
	errorType := reflect.TypeOf((*error)(nil)).Elem()
	if !rt.Out(0).Implements(errorType) {
		return nil, fmt.Errorf("return type must be error")
	}

	msgIfaceType := reflect.TypeOf((*proto.Message)(nil)).Elem()
	msgArgType := rt.In(1)
	if msgArgType == reflect.TypeOf((*proto.Message)(nil)) {
		return func(player *Player, msg *proto.Message) error {
			results := rv.Call([]reflect.Value{reflect.ValueOf(player), reflect.ValueOf(msg)})
			if results[0].IsNil() {
				return nil
			}
			return results[0].Interface().(error)
		}, nil
	}
	if msgArgType.Kind() != reflect.Ptr || !msgArgType.Implements(msgIfaceType) {
		return nil, fmt.Errorf("second arg must be *proto.Message or pointer type implementing proto.Message")
	}

	return func(player *Player, msg *proto.Message) error {
		if msg == nil || *msg == nil {
			return fmt.Errorf("nil proto message")
		}

		raw := *msg
		rawType := reflect.TypeOf(raw)
		if !rawType.AssignableTo(msgArgType) {
			return fmt.Errorf("message type mismatch, expect %s got %s", msgArgType, rawType)
		}

		results := rv.Call([]reflect.Value{reflect.ValueOf(player), reflect.ValueOf(raw)})
		if results[0].IsNil() {
			return nil
		}
		return results[0].Interface().(error)
	}, nil
}

func RunNewNetProcessByKey(key string, player *Player, msg *proto.Message) error {
	fun, ok := NewRegisterNetWorkFunc[key]
	if ok {
		err := fun(player, msg)
		return err
	}
	return fmt.Errorf("cant find network func %s", key)
}

func RunNetProcessByKey(key string, param []interface{}) error {
	fun, ok := RegisterNetWorkFunc[key]
	if ok {
		_, player, buf := ParseArgs(param)
		err := fun.(func(*Player, []byte) error)(player, buf)
		return err
	}
	return fmt.Errorf("cant find network func %s", key)
}

type LimitActPeriod struct {
	StartCronID cron.EntryID
	EndTimer    *timer.Timer
	StartTime   int32
	EndTime     int32
}

type GameLogic struct {
	Db_AccountInfo     db.Db_Account
	DailyTaskTimestamp int64
	M_Players          sync.Map
	m_CronEntryIDs     map[int]*LimitActPeriod
	Mdispatr           *timer.Dispatcher
	M_LimitActiveList  []int
	NotInitPlayer      *Player
	Version            int32
	M_SvrGlobal        db.SqlSvrGlobalStruct
	SeverInfo          *ServerInfo

	FriendMgr    *FriendMgr    // 好友管理器
	RankMgr      *RankMgr      // 排行榜管理器
	MailMgr      *MailMgr      // 邮件管理器
	ChampshipMgr *ChampshipMgr // 锦标赛管理器
	VarMgr       *VarMgr       // 变量管理器
	StartTime    int64         // 服务器启动时间
	MessageMgr   *MessageMgr   // 消息管理器
	ActivityMgr  *ActivityMgr  // 活动管理器
}

type ServerInfo struct {
	ServerID int    // 服务器ID
	CenterID int    // 中心ID
	GroupID  int    // 组ID
	OpenTime int64  // 开服时间
	Name     string // 服务器名字
	Status   int    // 服务器状态
}

// 零点更新
func (gl *GameLogic) ZeroFlush() {
	gl.Mdispatr.AfterFunc(time.Second*86400, func() {
		gl.ZeroFlush()
	})
	var a1 = []interface{}{gl.DailyTaskTimestamp}
	GoUtil.CallEvent(MergeConst.Notify_Daily_Renew, a1)
	gl.NotifyAll(MsgMod.MSG_ZERO_UPDATE)
	gl.CreateDailyLogFile()
	log.Debug("Server ZeroFlush")
}

// 中午更新
func (gl *GameLogic) NoonFlush() {
	log.Debug("Server NoonFlush")
	gl.Mdispatr.AfterFunc(time.Second*86400, func() {
		gl.NoonFlush()
	})
	gl.NotifyAll(MsgMod.MSG_NOON_UPDATE)
}

func (gl *GameLogic) SetPlayer(player *Player) {
	gl.M_Players.Store(player.M_DwUin, player)
}

func (gl *GameLogic) DelPlayer(player *Player) {
	gl.M_Players.Delete(player.M_DwUin)
}

func (gl *GameLogic) GetPlayer(DwUin int64) *Player {
	if v, ok := gl.M_Players.Load(DwUin); ok {
		return v.(*Player)
	}
	return nil
}

func (gl *GameLogic) OpenTimestampTick() {
	gl.DailyTaskTimestamp = 0
	gl.Mdispatr = timer.NewDispatcher(0)
	gl.Mdispatr.AfterFunc(time.Second*time.Duration(GoUtil.NextZeroTimestampDuration()), func() {
		gl.ZeroFlush()
	})
	gl.Mdispatr.AfterFunc(time.Second*time.Duration(GoUtil.NextNoonTimestampDuration()), func() {
		gl.NoonFlush()
	})
	//gl.CreateDailyLogFile()
	go func() {
		for k := range gl.Mdispatr.ChanTimer {
			k.Cb()
		}
	}()
}

func (ad *GameLogic) IsExsitAccount(UserName string) bool {
	return ad.LoadDataFromDB(UserName)
}

func (ad *GameLogic) LoadDataFromDB(UserName string) bool {
	sqlStr := "SELECT * FROM t_account WHERE user_name = ?"
	if err := db.SqlDb.Get(&ad.Db_AccountInfo, sqlStr, UserName); err != nil {
		// log.Debug("get data failed, err:%v\n", err)
		return false
	}

	return true
}

func (ad *GameLogic) NewAccountInsertDataToDB() bool {
	sqlStr := "INSERT INTO t_account(user_name, user_password) VALUES(:user_name, :user_password)"
	result, err := db.SqlDb.NamedExec(sqlStr, map[string]interface{}{
		"user_name":     ad.Db_AccountInfo.UserName,
		"user_password": ad.Db_AccountInfo.UserPassword,
	})
	if err != nil {
		log.Debug("named exec failed, err:%v\n", err)
		return false
	}
	insertId, err := result.LastInsertId()
	if err != nil {
		log.Debug("get last insert id failed, err:%v\n", err)
		return false
	}

	insertId = insertId + int64(100000) + int64(conf.Server.AppID*100000000)
	playerInfo := &db.ResPlayerBaseInfo{}
	playerInfo.DwUin = int64(insertId)
	playerInfo.Energy = int32(userCfg.GetInitEnergy())
	playerInfo.Star = int32(userCfg.GetInitStar())
	playerInfo.RecoverTime = int32(time.Now().Unix())
	playerInfo.Diamond = int32(userCfg.GetInitDiamond())
	playerInfo.Level = 1
	playerInfo.Exp = 0
	playerInfo.StartOrderId = "1"
	playerInfo.MusicCode = 1
	playerInfo.Guild = 1
	playerInfo.PackUnlockCount = 5
	playerInfo.UserName = ad.Db_AccountInfo.UserName
	playerInfo.LoginTime = (int32)(time.Now().Unix())
	playerInfo.LogoutTime = 0
	playerInfo.Node = int32(conf.Server.ServerID)
	playerInfo.Rolecreatetime = (int32)(time.Now().Unix())
	playerInfo.FaceBookId = ""
	db.FormatAllMemInsertDb(playerInfo, "t_player_baseinfo")

	var buf bytes.Buffer
	encode := gob.NewEncoder(&buf)
	encode.Encode(&PlayerModList{})
	playerMod := &db.SqlModStruct{
		DwUin:      int64(insertId),
		ModData:    buf.Bytes(),
		UpdataTime: int32(time.Now().Unix()),
	}
	db.FormatAllMemInsertDb(playerMod, "t_player_mod")
	// 创建玩家日志
	player := new(Player)
	BaseMod := player.PlayMod.getBaseMod()
	BaseMod.Account = ad.Db_AccountInfo.UserName
	BaseMod.RegisterTime = time.Now().Unix()
	player.TeLog("register", nil)

	return true
}

func (ad *GameLogic) PackLoginResInfo(a gate.Agent, ResLogin *msg.ResLogin) {
	resBuff, _ := proto.Marshal(ResLogin)
	ad.PackResInfo(a, "ResLogin", resBuff)
}

func (ad *GameLogic) PackResInfo(a gate.Agent, Func string, data []byte) {
	if a == nil {
		return
	}
	response := &msg.ClientRes{}
	response.Func = Func
	response.Cid = "cid"
	response.Info = data
	a.WriteMsg(response)
}

// 创建新玩家，初始化数据
func (ad *GameLogic) CreateNewPlayer(a gate.Agent, UserName string) *Player {
	player := new(Player)
	internal.AsignPlayerToAgents(a, player) //绑定player和网络连接代理
	player.agent = a
	err := player.InitPlayer(UserName)
	if err != nil {
		data, _ := proto.Marshal(&msg.ResLogin{ResultCode: MergeConst.Protocol_Error_Account_Fail})
		G_GameLogicPtr.PackResInfo(a, "ResLogin", data)
		panic(err)
	}
	ad.SetPlayer(player)
	return player
}

func (ad *GameLogic) GetPlayerByAgent(gate gate.Agent) *Player {
	p, ok := internal.Agents.Load(gate)
	if ok {
		return p.(*Player)
	}
	return nil
}

// 好友管理器
func (ad *GameLogic) CreateFriendMgr() {
	ad.FriendMgr = &FriendMgr{
		ServerMod: new(ServerMod),
	}
	ad.FriendMgr.Init()
}

// 排行榜管理器
func (ad *GameLogic) CreateRankMgr() {
	ad.RankMgr = &RankMgr{
		ServerMod: new(ServerMod),
	}
	ad.RankMgr.Init()
}

func (ad *GameLogic) RankMgrSend(m *MsgMod.Msg) {
	ad.RankMgr.Send(m)
}

func (ad *GameLogic) RankMgrCall(m *MsgMod.Msg) interface{} {
	result, err := ad.RankMgr.Call(m)
	if err != nil {
		return nil
	}
	return result
}

// 邮件管理器
func (ad *GameLogic) CreateMailMgr() {
	ad.MailMgr = &MailMgr{
		ServerMod: new(ServerMod),
	}
	ad.MailMgr.Init()
}

// 活动管理器
func (ad *GameLogic) CreateActivityMgr() {
	ad.ActivityMgr = &ActivityMgr{}
	ad.ActivityMgr.Init()
}

func (ad *GameLogic) CreateMessageMgr() {
	ad.MessageMgr = &MessageMgr{
		ServerMod: new(ServerMod),
	}
	ad.MessageMgr.MessageMgrInit()
}

func (ad *GameLogic) MailMgrSend(m *MsgMod.Msg) {
	ad.MailMgr.Send(m)
}

func (ad *GameLogic) MailMgrCall(m *MsgMod.Msg) interface{} {
	result, err := ad.MailMgr.Call(m)
	if err != nil {
		return nil
	}
	return result
}

// 锦标赛管理器
func (ad *GameLogic) CreateChampshipMgr() {
	ad.ChampshipMgr = &ChampshipMgr{
		ServerMod: new(ServerMod),
	}
	ad.ChampshipMgr.Init()
}

func (ad *GameLogic) ChampshipMgrSend(m *MsgMod.Msg) {
	ad.ChampshipMgr.Send(m)
}

func (ad *GameLogic) ChampshipMgrCall(m *MsgMod.Msg) interface{} {
	result, err := ad.ChampshipMgr.Call(m)
	if err != nil {
		return nil
	}
	return result
}

// 变量管理器
func (ad *GameLogic) CreateVarMgr() {
	ad.VarMgr = &VarMgr{
		ServerMod: new(ServerMod),
	}
	ad.VarMgr.Init()
}

func (ad *GameLogic) VarMgrSend(m *MsgMod.Msg) {
	ad.VarMgr.Send(m)
}

func (ad *GameLogic) VarMgrCall(m *MsgMod.Msg) interface{} {
	result, err := ad.VarMgr.Call(m)
	if err != nil {
		return nil
	}
	return result
}

func (ad *GameLogic) GetSimplePlayerByUid(Id int) *PlayerSimpleData {
	if Id == 0 {
		return nil
	}
	Idstr := strconv.Itoa(Id)
	Value, _ := db.RedisGetKey(Idstr)
	player := &PlayerSimpleData{}
	player.Playroom = make(map[int]int)
	player.Uid = Id
	if Value == "" {
		p := new(Player)
		err := p.GetSimpleData(Id, player)
		if err != nil {
			return nil
		}
		value, _ := json.Marshal(player)
		db.RedisSetKey(Idstr, string(value), time.Duration(300)*time.Second)
	} else {
		err := json.Unmarshal([]byte(Value), player)
		if err != nil {
			return nil
		}
	}
	return player
}

func (ad *GameLogic) GetResSimplePlayerByUid(Id int) *msg.ResPlayerSimple {
	Idstr := strconv.Itoa(Id)
	Value, _ := db.RedisGetKey(Idstr)
	player := &PlayerSimpleData{}
	player.Uid = Id
	if Value == "" {
		p := new(Player)
		err := p.GetSimpleData(Id, player)
		if err != nil {
			return nil
		}
		value, _ := json.Marshal(player)
		db.RedisSetKey(Idstr, string(value), 0)
	} else {
		err := json.Unmarshal([]byte(Value), player)
		if err != nil {
			return nil
		}
	}

	return &msg.ResPlayerSimple{
		Uid:      int64(player.Uid),
		Name:     player.Name,
		Level:    int32(player.Level),
		Avatar:   int32(player.Avatar),
		Face:     int32(player.Face),
		Decorate: int32(player.Decorate),
		Login:    int32(player.Login),
		Loginout: int32(player.Loginout),
		Emoji:    GoUtil.MapIntToInt32(player.Emoji),
	}
}

func (ad *GameLogic) GetResFriendPlayerByUid(Id int) *msg.ResFriendPlayerSimple {
	Idstr := strconv.Itoa(Id)
	Value, _ := db.RedisGetKey(Idstr)
	player := &PlayerSimpleData{}
	player.Uid = Id
	if Value == "" {
		p := new(Player)
		err := p.GetSimpleData(Id, player)
		if err != nil {
			return nil
		}
		value, _ := json.Marshal(player)
		db.RedisSetKey(Idstr, string(value), 0)
	} else {
		err := json.Unmarshal([]byte(Value), player)
		if err != nil {
			return nil
		}
	}
	last := &msg.ActLog{}
	if player.ActLog != nil {
		last = &msg.ActLog{
			Type:  int32(player.ActLog.Type),
			Time:  player.ActLog.Time,
			Param: player.ActLog.Param,
		}
	}
	return &msg.ResFriendPlayerSimple{
		Uid:        int64(player.Uid),
		Name:       player.Name,
		Level:      int32(player.Level),
		Avatar:     int32(player.Avatar),
		Face:       int32(player.Face),
		Decorate:   int32(player.Decorate),
		Login:      int32(player.Login),
		Loginout:   int32(player.Loginout),
		Emoji:      GoUtil.MapIntToInt32(player.Emoji),
		Facebook:   player.FaceBook,
		Playroom:   GoUtil.MapIntToInt32(player.Playroom),
		DressSet:   GoUtil.MapIntToInt32(player.DressSet),
		Friend:     GoUtil.IntToInt32(player.Friend),
		Physiology: GoUtil.MapIntToInt32(player.Physiology),
		Last:       last,
		PetName:    player.PetName,
		PetFur:     int32(player.PetFur),
	}
}

// 初始化服务器协程
func G_getGameLogic() *GameLogic {
	if !isInitGameLogic {
		G_GameLogicPtr = new(GameLogic)
		isInitGameLogic = true
		G_GameLogicPtr.Mdispatr = timer.NewDispatcher(10)
		G_GameLogicPtr.InitServerInfo()
		G_GameLogicPtr.M_Players = sync.Map{}
		G_GameLogicPtr.NotInitPlayer = new(Player)
		G_GameLogicPtr.M_LimitActiveList = []int{}
		G_GameLogicPtr.CreateMessageMgr()    // 创建消息管理器
		G_GameLogicPtr.OpenTimestampTick()   // 开启时间戳计时器
		G_GameLogicPtr.RegisterEvent()       // 注册事件
		G_GameLogicPtr.RegisterNetWorkFunc() // 注册客户端接口
		G_GameLogicPtr.InitActivity()        // 初始化活动
		if conf.Server.ServerType == "center" {
			// G_GameLogicPtr.CreateFriendMgr()    //创建好友管理器
			G_GameLogicPtr.CreateChampshipMgr() // 创建竞标赛管理器
			G_GameLogicPtr.CreateVarMgr()       // 创建变量管理器
		} else {
			G_GameLogicPtr.CreateActivityMgr() //创建活动管理器
		}
		G_GameLogicPtr.CreateRankMgr() //创建排行榜管理器
		G_GameLogicPtr.CreateMailMgr() //创建邮件管理器
		ClusterMgrInit()               //初始化集群
		G_GameLogicPtr.StartTime = time.Now().Unix()
		// G_GameLogicPtr.CreateHttpManager()
	}
	return G_GameLogicPtr
}

func (ad *GameLogic) InitServerInfo() {
	Now := time.Now().Unix()
	ServerInfo := &ServerInfo{}
	ServerInfo.ServerID = conf.Server.ServerID
	ServerInfo.OpenTime = GoUtil.ParseTime(conf.Server.ServerOpenTime)
	ServerInfo.Name = conf.Server.ServerName
	if Now < ServerInfo.OpenTime {
		ServerInfo.Status = SERVER_STATUS_CLOSE
	} else {
		ServerInfo.Status = SERVER_STATUS_OPEN
	}
	ad.SeverInfo = ServerInfo
}

func (ad *GameLogic) SendServerVersion(a gate.Agent) {
	res := &msg.ResServerVersion{}
	res.Version = G_GameLogicPtr.Version
	data, _ := proto.Marshal(res)
	G_getGameLogic().PackResInfo(a, "ResServerVersion", data)
}

func (ad *GameLogic) ClearData(args []interface{}) {
	player := args[0].(*Player)
	if player != nil && player.M_DwUin != 0 {
		player.agent = nil
		player.AutoSaveData()
		log.Debug("player %d 断开连接", player.M_DwUin)
		player.CallEvent(120*time.Second, func() {
			player.lock.Lock()
			defer player.lock.Unlock()
			if player.agent == nil {
				player.ClearData()
				log.Debug("player %d 延迟120s关闭", player.M_DwUin)
			}
		}, "LateClose")
	}
}

func (ad *GameLogic) RegisterEvent() {

	GoUtil.RegisterEvent(MergeConst.Notify_Socket_Closed, ad.ClearData, nil)
	GoUtil.RegisterEvent(MergeConst.Notify_Socket_Connect, ad.NewPlayerConnect, nil)
}

func (ad *GameLogic) NewPlayerConnect(args []interface{}) {
	a := args[0].(gate.Agent)
	internal.AsignPlayerToAgents(a, ad.NotInitPlayer)
}

func (ad *GameLogic) ReplaceExistPlayerAndAgent(a gate.Agent, player *Player) error {
	if player == nil {
		return fmt.Errorf("player is nil")
	}
	player.lock.Lock()
	defer player.lock.Unlock()
	storePlayer := ad.GetPlayer(player.M_DwUin)
	if storePlayer == nil {
		return fmt.Errorf("player is delete")
	}
	if player.stop {
		return fmt.Errorf("player is stop")
	}
	agent := player.GetAgentByPlayer()
	notify := &msg.ForceKickOut{}
	data, _ := proto.Marshal(notify)
	if agent != nil && a != agent {
		G_getGameLogic().PackResInfo(agent, "ForceKickOut", data)
		internal.AsignPlayerToAgents(agent, ad.NotInitPlayer)
	}
	internal.AsignPlayerToAgents(a, player)
	player.SetAgent(a)
	// 取消延迟关闭
	Timer, ok := player.timerList["LateClose"]
	if ok {
		Timer.Stop()
	}
	log.Debug("player %d 重连", player.M_DwUin)
	return nil
}

func (ad *GameLogic) SendMassage(dwUin int64, Func string, data []byte) bool {
	player := ad.GetPlayer(dwUin)
	if player != nil {
		agent := player.GetAgentByPlayer()
		if agent != nil {
			G_getGameLogic().PackResInfo(agent, Func, data)
			return true
		}
	}
	return false
}

func (ad *GameLogic) FileExist(path string) bool {
	_, err := os.Lstat(path)
	return !os.IsNotExist(err)
}

func (ad *GameLogic) CreateDailyLogFile() {
	zero := GoUtil.ZeroTimestamp()
	now := time.Unix(zero, 0).Local()
	err := log.NewDailyLog(now, log.DEBUG_LEVEL, conf.Server.LogPath, l.LstdFlags)
	if err != nil {
		fmt.Println(err)
	}
	log.Debug("CreateDailyLogFile")
	ad.RemoveOldLogs(MergeConst.Go_log_delete_days)
}

func (ad *GameLogic) RemoveOldLogs(days int) {
	dir := conf.Server.LogPath
	files, err := os.ReadDir(dir)
	if err != nil {
		log.Debug("Failed to read log directory: %v", err)
		return
	}

	cutoff := time.Now().AddDate(0, 0, -days)
	for _, file := range files {
		if file.IsDir() {
			continue
		}
		fileInfo, err := file.Info()
		if err != nil {
			log.Debug("Failed to get file info: %v", err)
			continue
		}
		if fileInfo.ModTime().Before(cutoff) {
			err := os.Remove(dir + "/" + file.Name())
			if err != nil {
				log.Debug("Failed to remove old log file: %v", err)
			} else {
				log.Debug("Removed old log file: %s", file.Name())
			}
		}
	}
}

func (ad *GameLogic) RegisterNetWorkFunc() {

	RegisterNewMsgProcessFunc("ReqRemoveAd", ReqRemoveAd)
	RegisterNewMsgProcessFunc("ReqPlayerBriefProfileData", ReqPlayerBriefProfileData)
	RegisterNewMsgProcessFunc("ReqFriendPlayerSimple", ReqFriendPlayerSimple)
	// RegisterMsgProcessFunc("ReqOfflineReconnect", ReqOfflineReconnectFunc)
	RegisterNewMsgProcessFunc("ReqPlayerAsset", ReqPlayerAsset)
	RegisterNewMsgProcessFunc("ReqId2Verify", ReqId2Verify) // 身份证验证
	// 玩家
	RegisterNewMsgProcessFunc("ReqUserInfo", ReqUserInfo)
	RegisterNewMsgProcessFunc("ReqSetName", ReqSetName)                       // 设置名字
	RegisterNewMsgProcessFunc("ReqLang", ReqLang)                             // 设置语言
	RegisterNewMsgProcessFunc("ReqSetPetName", ReqSetPetName)                 // 设置宠物名字
	RegisterNewMsgProcessFunc("ReqSetFacebookUrl", ReqSetFacebookUrl)         // 设置facebook地址
	RegisterNewMsgProcessFunc("ReqPlayerBaseInfo", ReqPlayerBaseInfofunction) // 请求玩家基本信息
	RegisterNewMsgProcessFunc("ReqKv", ReqKv)                                 // 保存客户端数据
	RegisterNewMsgProcessFunc("ReqGetEnergyByAD", ReqGetEnergyByAD)           // 看广告获取能量
	RegisterNewMsgProcessFunc("ReqBuyEnergy", ReqBuyEnergy)                   // 购买能量
	RegisterNewMsgProcessFunc("ReqAdWatch", ReqAdWatch)                       // 观看广告
	// #region 棋盘
	RegisterNewMsgProcessFunc("ReqPlayerChessData", ReqPlayerChessData)
	RegisterNewMsgProcessFunc("UpdatePlayerChessData", UpdatePlayerChessData)         // 更新棋盘数据
	RegisterNewMsgProcessFunc("ReqSetEnergyMul", RegSetEneryFunc)                     //设置能量倍数
	RegisterNewMsgProcessFunc("ReqChessEx", ReqChessEx)                               // 转换棋子
	RegisterNewMsgProcessFunc("ReqGetChessFromBuff", ReqGetChessFromBuff)             // 从buff中获取棋子
	RegisterNewMsgProcessFunc("ReqPutPartInBag", ReqPutPartInBag)                     // 把零件放入背包
	RegisterNewMsgProcessFunc("ReqPutChessInBag", ReqPutChessInBag)                   // 把棋子放入背包
	RegisterNewMsgProcessFunc("ReqTakeChessOutBag", ReqTakeChessOutBag)               // 从背包中取出棋子
	RegisterNewMsgProcessFunc("ReqTakeChessOutBagToHonor", ReqTakeChessOutBagToHonor) // 从背包中取出棋子
	RegisterNewMsgProcessFunc("ReqBuyChessBagGrid", ReqBuyChessBagGrid)               // 解锁背包格子
	RegisterNewMsgProcessFunc("ReqSourceChest", ReqSourceChest)                       // 开宝箱
	RegisterNewMsgProcessFunc("ReqSeparateChess", ReqSeparateChess)                   // 分解棋子
	RegisterNewMsgProcessFunc("ReqUpgradeChess", ReqUpgradeChess)                     // 升级棋子
	RegisterNewMsgProcessFunc("ReqSellChessNum", ReqSellChessNum)                     //购买能量
	RegisterNewMsgProcessFunc("ReqGetChessRetireReward", ReqGetChessRetireReward)     //领取棋子退役奖励

	//领取图鉴奖励
	RegisterNewMsgProcessFunc("ReqGetHandbookReward", ReqGetHandbookReward) //领取图鉴奖励
	RegisterNewMsgProcessFunc("RegHandbookAllReward", RegHandbookAllReward) //领取图鉴收集奖励
	//领取订单奖励
	RegisterNewMsgProcessFunc("ReqRewardOrder", ReqRewardOrder)       // 领取订单奖励
	RegisterNewMsgProcessFunc("ReqDelOrder", ReqDelOrder)             // 删除订单
	RegisterNewMsgProcessFunc("ReqCreatePetOrder", ReqCreatePetOrder) // 生成消耗品订单

	//装饰
	RegisterNewMsgProcessFunc("ReqDecorate", ReqDecorate)       // 装饰
	RegisterNewMsgProcessFunc("ReqDecorateAll", ReqDecorateAll) // 装饰全部
	RegisterNewMsgProcessFunc("ReqAreaReward", ReqAreaReward)   // 章节奖励
	//Gm命令
	RegisterNewMsgProcessFunc("ReqGmCommand", ReqGmCommand) // Gm命令

	// #region 卡牌
	RegisterNewMsgProcessFunc("ReqCardInfo", ReqCardInfo)                           // 请求卡牌信息
	RegisterNewMsgProcessFunc("ReqCardSeasonFirstReward", ReqCardSeasonFirstReward) // 领取赛季首次奖励
	RegisterNewMsgProcessFunc("ReqCardCollectReward", ReqCardCollectReward)         //领取卡牌系列收集奖励
	RegisterNewMsgProcessFunc("ReqExStarReward", ReqExStarReward)                   // 兑换收集星星奖励
	RegisterNewMsgProcessFunc("ReqAllCollectReward", ReqAllCollectReward)           // 领取全收集奖励
	RegisterNewMsgProcessFunc("ReqCardGive", ReqCardGive)                           // 请求赠送卡牌
	RegisterNewMsgProcessFunc("ReqAgreeCardGive", ReqAgreeCardGive)                 // 同意赠送卡牌
	RegisterNewMsgProcessFunc("ReqRefuseCardGive", ReqRefuseCardGive)               // 拒绝赠送卡牌

	RegisterNewMsgProcessFunc("ReqCardExchange", ReqCardExchange)             // 请求交换卡牌
	RegisterNewMsgProcessFunc("ReqSelectCardExchange", ReqSelectCardExchange) // 选择交换的卡牌
	RegisterNewMsgProcessFunc("ReqAgreeCardExchange", ReqAgreeCardExchange)   // 完成交换卡牌
	RegisterNewMsgProcessFunc("ReqRefuseCardSelect", ReqRefuseCardSelect)     // 拒绝选择卡牌进行交换
	RegisterNewMsgProcessFunc("ReqRefuseCardExchange", ReqRefuseCardExchange) // 拒绝卡牌交换
	RegisterNewMsgProcessFunc("ReqCardSend", ReqCardSend)                     // 直接赠送卡牌
	RegisterNewMsgProcessFunc("ReqGetFriendCard", ReqGetFriendCard)           // 领取好友赠送的卡牌
	RegisterNewMsgProcessFunc("ReqMasterCard", ReqMasterCard)                 // 万能卡兑换
	RegisterNewMsgProcessFunc("ReqCardHandbookReward", ReqCardHandbookReward) // 卡牌图鉴

	// 日常任务
	RegisterNewMsgProcessFunc("ReqGetDailyTaskReward", ReqGetDailyTaskReward) // 领取日常任务奖励
	RegisterNewMsgProcessFunc("ReqGetDailyWeekReward", ReqGetDailyWeekReward) // 领取周活跃奖励
	RegisterNewMsgProcessFunc("ReqDailyUnlock", ReqDailyUnlock)               // 日常任务解锁
	// 新手任务
	RegisterNewMsgProcessFunc("ReqGetGuideTaskReward", ReqGetGuideTaskReward)     // 领取日新手任务奖励
	RegisterNewMsgProcessFunc("ReqGetGuideActiveReward", ReqGetGuideActiveReward) // 领取活跃奖励

	// 引导奖励
	RegisterNewMsgProcessFunc("ReqGuideReward", ReqGuideReward)     // 领取引导奖励
	RegisterNewMsgProcessFunc("ReqGuidePlayroom", ReqGuidePlayroom) // 领取playroom引导奖励

	// 头像
	RegisterNewMsgProcessFunc("ReqSetFace", ReqSetFace) // 设置头像
	// 头像框
	RegisterNewMsgProcessFunc("ReqSetAvatar", ReqSetAvatar) // 设置头像框
	// 表情
	RegisterNewMsgProcessFunc("ReqSetEmoji", ReqSetEmoji) // 设置表情
	// 收藏室
	RegisterNewMsgProcessFunc("ReqCollectInfo", ReqCollectInfo) // 请求收藏室数据
	RegisterNewMsgProcessFunc("ReqCollect", ReqCollect)         // 领取收藏室奖励
	// 七日签到
	RegisterNewMsgProcessFunc("ReqGetSevenLoginReward", ReqGetSevenLoginReward) // 领取七日签到奖励
	RegisterNewMsgProcessFunc("ReqGetMonthLoginReward", ReqGetMonthLoginReward) // 领取月签到奖励

	// 限时事件
	RegisterNewMsgProcessFunc("ReqLimitEvent", ReqLimitEvent)                 // 请求限时事件数据
	RegisterNewMsgProcessFunc("ReqFastProduceReward", ReqFastProduceReward)   // 连击快手奖励
	RegisterNewMsgProcessFunc("ReqFastProduceInfo", ReqFastProduceInfo)       // 请求连击快手数据
	RegisterNewMsgProcessFunc("ReqLimitSenceReward", ReqLimitSenceReward)     // 获取场景转盘奖励
	RegisterNewMsgProcessFunc("ReqSelectLimitEvent", ReqSelectLimitEvent)     //领取Bouns限时事件进度奖励
	RegisterNewMsgProcessFunc("ReqGetGoldCard", ReqGetGoldCard)               //请求金卡交换信息
	RegisterNewMsgProcessFunc("ReqLimitEventLuckyCat", ReqLimitEventLuckyCat) //幸运猫获取奖励
	RegisterNewMsgProcessFunc("ReqCatTrickReward", ReqCatTrickReward)         //小猫戏法获取奖励

	// #region 好友
	RegisterNewMsgProcessFunc("ReqFriendList", ReqFriendList)               // 请求好友列表
	RegisterNewMsgProcessFunc("ReqFriendApply", ReqFriendApply)             // 请求申请好友列表
	RegisterNewMsgProcessFunc("ReqFriendCardMsg", ReqFriendCardMsg)         // 请求好友卡牌申请列表
	RegisterNewMsgProcessFunc("ReqWishApplyList", ReqWishApplyList)         // 请求好友心愿单申请列表
	RegisterNewMsgProcessFunc("ReqFriendTimeLine", ReqFriendTimeLine)       // 请求好友时间线
	RegisterNewMsgProcessFunc("ReqFriendRecommend", ReqFriendRecommend)     // 获取推荐好友
	RegisterNewMsgProcessFunc("ReqFriendTLUpvote", ReqFriendTLUpvote)       // 请求时间线点赞
	RegisterNewMsgProcessFunc("ReqFriendTReward", ReqFriendTReward)         // 获取时间线奖励
	RegisterNewMsgProcessFunc("ReqAddNpc", ReqAddNpc)                       // 增加npc
	RegisterNewMsgProcessFunc("ReqWishApply", ReqWishApply)                 // 同意好友心愿单请求
	RegisterNewMsgProcessFunc("ReqFriendByCode", ReqFriendByCode)           // 根据邀请码查询好友
	RegisterNewMsgProcessFunc("ReqFriendReplyHandle", ReqFriendReplyHandle) // 回复好友信息

	RegisterNewMsgProcessFunc("ReqSearchPlayer", ReqSearchPlayer) // 搜索好友
	RegisterNewMsgProcessFunc("ReqApplyFriend", ReqApplyFriend)   // 申请好友
	RegisterNewMsgProcessFunc("ReqAgreeFriend", ReqAgreeFriend)   // 同意申请
	RegisterNewMsgProcessFunc("ReqRefuseFriend", ReqRefuseFriend) // 拒绝申请
	RegisterNewMsgProcessFunc("ReqDelFriend", ReqDelFriend)       // 删除好友

	// Facebook邀请好友
	RegisterNewMsgProcessFunc("ReqInviteFriendData", ReqInviteFriendData)         // 请求邀请好友数据
	RegisterNewMsgProcessFunc("ReqSelfInvited", ReqSelfInvited)                   // 请求自己邀请的好友
	RegisterNewMsgProcessFunc("ReqGetInviteReward", ReqGetInviteReward)           // 领取邀请奖励
	RegisterNewMsgProcessFunc("ReqAutoAddInviteFriend", ReqAutoAddInviteFriend)   // 自动添加邀请好友
	RegisterNewMsgProcessFunc("ReqAutoAddInviteFriend2", ReqAutoAddInviteFriend2) // 自动添加邀请好友
	RegisterNewMsgProcessFunc("ReqBindFacebookAccount", ReqBindFacebookAccount)   // 绑定facebook账号
	RegisterNewMsgProcessFunc("ReqOnlyBindFacebook", ReqOnlyBindFacebook)         // 绑定唯一facebook
	RegisterNewMsgProcessFunc("ReqUnBindFacebook", ReqUnBindFacebook)             // 解绑facebook
	RegisterNewMsgProcessFunc("ReqSynGameData", ReqSynGameData)                   // 同步账号数据

	// 榜单
	RegisterNewMsgProcessFunc("ReqRank", ReqRank) // 请求榜单数据

	// 邮件
	RegisterNewMsgProcessFunc("ReqMailList", ReqMailList)           // 请求邮件数据
	RegisterNewMsgProcessFunc("ReqReadMail", ReqReadMail)           // 读取邮件
	RegisterNewMsgProcessFunc("ReqGetMailReward", ReqGetMailReward) // 领取邮件奖励
	RegisterNewMsgProcessFunc("ReqDeleteMail", ReqDeleteMail)       // 删除邮件

	// 商店
	RegisterNewMsgProcessFunc("ReqFreeShop", ReqFreeShop)                 // 领取商店免费奖励
	RegisterNewMsgProcessFunc("ReqBuyChessShop", ReqBuyChessShop)         // 购买商店棋子
	RegisterNewMsgProcessFunc("ReqBuyChessShop2", ReqBuyChessShop2)       // 购买商店棋子直接加入棋盘
	RegisterNewMsgProcessFunc("ReqRefreshChessShop", ReqRefreshChessShop) // 刷新棋子商店
	RegisterNewMsgProcessFunc("ReqAddWish", ReqAddWish)                   // 添加心愿单
	RegisterNewMsgProcessFunc("ReqGetWish", ReqGetWish)                   // 领取心愿单奖励
	RegisterNewMsgProcessFunc("ReqSendWishBeg", ReqSendWishBeg)           // 发送心愿单请求
	// 无尽礼包
	RegisterNewMsgProcessFunc("ReqEndless", ReqEndless)             // 请求无尽礼包数据
	RegisterNewMsgProcessFunc("ReqEndlessReward", ReqEndlessReward) // 领取无尽礼包免费奖励

	// 小猪存钱罐
	RegisterNewMsgProcessFunc("ReqPiggyBankReward", ReqPiggyBankReward) // 小猪存钱罐领取奖励

	// 锦标赛
	RegisterNewMsgProcessFunc("ReqChampship", ReqChampship)                     // 请求锦标赛数据
	RegisterNewMsgProcessFunc("ReqChampshipReward", ReqChampshipReward)         // 领取锦标赛奖励
	RegisterNewMsgProcessFunc("ReqChampshipRankReward", ReqChampshipRankReward) // 领取锦标赛排行榜奖励
	RegisterNewMsgProcessFunc("ReqChampshipRank", ReqChampshipRank)             // 请求锦标赛排行榜
	RegisterNewMsgProcessFunc("ReqChampshipPreRank", ReqChampshipPreRank)       // 请求锦标赛昨日排行榜

	// #region 活动
	RegisterNewMsgProcessFunc("ReqActivityReward", ReqActivityReward) // 领取活动奖励
	RegisterNewMsgProcessFunc("ReqAddGiftReward", ReqAddGiftReward)   // 领取加赠活动奖励
	// 挖矿
	RegisterNewMsgProcessFunc("ReqMining", ReqMining)             // 请求挖矿数据
	RegisterNewMsgProcessFunc("ReqMiningReward", ReqMiningReward) // 领取挖矿奖励
	RegisterNewMsgProcessFunc("ReqMiningTake", ReqMiningTake)     // 挖矿
	// 猜颜色
	RegisterNewMsgProcessFunc("ReqGuessColor", ReqGuessColor)             // 请求猜颜色数据
	RegisterNewMsgProcessFunc("ReqGuessColorReward", ReqGuessColorReward) // 领取猜颜色奖励
	RegisterNewMsgProcessFunc("ReqGuessColorTake", ReqGuessColorTake)     // 猜颜色
	//  三段竞赛
	RegisterNewMsgProcessFunc("ReqRace", ReqRace)
	RegisterNewMsgProcessFunc("ReqRaceReward", ReqRaceReward)
	RegisterNewMsgProcessFunc("ReqRaceStart", ReqRaceStart)
	// 猫草大作战
	RegisterNewMsgProcessFunc("ReqCatnip", ReqCatnip)                       // 请求猫草大作战数据
	RegisterNewMsgProcessFunc("ReqCatnipInvite", ReqCatnipInvite)           // 猫草大作战邀请好友
	RegisterNewMsgProcessFunc("ReqCatnipAgree", ReqCatnipAgree)             // 同意邀请
	RegisterNewMsgProcessFunc("ReqCatnipRefuse", ReqCatnipRefuse)           // 拒绝邀请
	RegisterNewMsgProcessFunc("ReqCatnipMultiply", ReqCatnipMultiply)       // 猫草大作战倍数
	RegisterNewMsgProcessFunc("ReqCatnipPlay", ReqCatnipPlay)               // 猫草大作战游戏转盘
	RegisterNewMsgProcessFunc("ReqCatnipReward", ReqCatnipReward)           // 猫草大作战领取奖励
	RegisterNewMsgProcessFunc("ReqCatnipGrandReward", ReqCatnipGrandReward) // 猫草大作战领取大奖
	RegisterNewMsgProcessFunc("ReqCatnipEmoji", ReqCatnipEmoji)
	// 猫猫回礼
	RegisterNewMsgProcessFunc("ReqCatReturnGift", ReqCatReturnGift)             // 请求猫猫回礼数据
	RegisterNewMsgProcessFunc("ReqCatReturnGiftReward", ReqCatReturnGiftReward) // 领取猫猫回礼奖励
	RegisterNewMsgProcessFunc("ReqCatReturnGiftScore", ReqCatReturnGiftScore)   // 领取猫猫回礼积分
	// 活动通行证
	RegisterNewMsgProcessFunc("ReqActPass", ReqActPass)             // 请求活动通行证数据
	RegisterNewMsgProcessFunc("ReqActPassReward", ReqActPassReward) // 领取活动通行证奖励
	// #region playroom
	RegisterNewMsgProcessFunc("ReqPlayroom", ReqPlayroom)                             // 请求playroom数据
	RegisterNewMsgProcessFunc("ReqPlayroomInfo", ReqPlayroomInfo)                     // 请求playroom拜访信息
	RegisterNewMsgProcessFunc("ReqPlayroomDressSet", ReqPlayroomDressSet)             // 设置服装
	RegisterNewMsgProcessFunc("ReqPlayroomPetAirSet", ReqPlayroomPetAirSet)           // 获取宠物空气
	RegisterNewMsgProcessFunc("ReqPlayroomGame", ReqPlayroomGame)                     // 游戏结果
	RegisterNewMsgProcessFunc("ReqPlayroomInteract", ReqPlayroomInteract)             // 宠物交互
	RegisterNewMsgProcessFunc("ReqPlayroomSetRoom", ReqPlayroomSetRoom)               // playroom装饰
	RegisterNewMsgProcessFunc("ReqPlayroomSelectReward", ReqPlayroomSelectReward)     // playroom选择奖励
	RegisterNewMsgProcessFunc("ReqPlayroomLose", ReqPlayroomLose)                     // 处理偷取的棋子
	RegisterNewMsgProcessFunc("ReqPlayroomWork", ReqPlayroomWork)                     // 宠物工作
	RegisterNewMsgProcessFunc("ReqPlayroomRest", ReqPlayroomRest)                     // 宠物休息
	RegisterNewMsgProcessFunc("ReqPlayroomDraw", ReqPlayroomDraw)                     // 转盘
	RegisterNewMsgProcessFunc("ReqPlayroomFlip", ReqPlayroomFlip)                     // 翻牌
	RegisterNewMsgProcessFunc("ReqPlayroomFlipReward", ReqPlayroomFlipReward)         // 翻牌奖励
	RegisterNewMsgProcessFunc("ReqPlayroomChip", ReqPlayroomChip)                     // 消除碎片
	RegisterNewMsgProcessFunc("ReqPlayroomOutline", ReqPlayroomOutline)               // 打工离线
	RegisterNewMsgProcessFunc("ReqPlayroomWrokOutline", ReqPlayroomWrokOutline)       // 打工离线完成
	RegisterNewMsgProcessFunc("ReqPlayroomShop", ReqPlayroomShop)                     // playroom 商店
	RegisterNewMsgProcessFunc("ReqPlayroomBuyItem", ReqPlayroomBuyItem)               // 购买playroom物品
	RegisterNewMsgProcessFunc("ReqPlayroomUpvote", ReqPlayroomUpvote)                 // 点赞别人的playroom
	RegisterNewMsgProcessFunc("ReqPlayroomUnlock", ReqPlayroomUnlock)                 // 解锁房间
	RegisterNewMsgProcessFunc("ReqPlayroomTask", ReqPlayroomTask)                     // playroom任务
	RegisterNewMsgProcessFunc("ReqPlayroomTaskReward", ReqPlayroomTaskReward)         // 领取任务奖励
	RegisterNewMsgProcessFunc("ReqPlayroomGameShowReward", ReqPlayroomGameShowReward) // 展示游戏结果数据
	RegisterNewMsgProcessFunc("ReqPlayroomGuide", ReqPlayroomGuide)                   // 展示游戏结果数据
	RegisterNewMsgProcessFunc("ReqPetFur", ReqPetFur)                                 // 宠物毛皮信息
	RegisterNewMsgProcessFunc("ReqPetFurBuy", ReqPetFurBuy)                           // 宠物毛皮商店购买
	RegisterNewMsgProcessFunc("ReqFurSet", ReqFurSet)                                 // 宠物毛皮设置
	// 宠物宝藏
	RegisterNewMsgProcessFunc("ReqFriendTreasure", ReqFriendTreasure)           // 请求好友宝藏数据
	RegisterNewMsgProcessFunc("ReqFriendTreasureStart", ReqFriendTreasureStart) // 开始游戏
	RegisterNewMsgProcessFunc("ReqFriendTreasureFilp", ReqFriendTreasureFilp)   // 翻牌
	RegisterNewMsgProcessFunc("ReqFriendTreasureEnd", ReqFriendTreasureEnd)     // 结束游戏

	// #region 充值
	RegisterNewMsgProcessFunc("ReqCreateOrderSn", ReqCreateOrderSn) // 创建订单号
	RegisterNewMsgProcessFunc("ReqShippingOrder", ReqShippingOrder) // 获取订单号
	RegisterNewMsgProcessFunc("ReqChargeReceive", ReqChargeReceive) // 礼包回复邮件
}

func (ad *GameLogic) InitActivity() {
	ad.m_CronEntryIDs = make(map[int]*LimitActPeriod)
}

func (ad *GameLogic) NotifyAll(m *MsgMod.Msg) {
	ad.M_Players.Range(func(k, v interface{}) bool {
		v.(*Player).Send(m)
		return true
	})
}

func (ad *GameLogic) GetPlayerNum() int {
	length := 0
	ad.M_Players.Range(func(_, _ interface{}) bool {
		length++
		return true
	})
	return length
}

func (ad *GameLogic) GetStartTime() int64 {
	return ad.StartTime
}

func NotifyPlayer(Uid int, m *MsgMod.Msg) {
	clone := *m
	clone.To = Uid
	clone.HandleType = MsgMod.HANDLE_MOD_PLAYER_MSG
	NotifyPlayerMsgAsync(&clone)
}

func Destroy() {
	log.Debug("服务器下线")
	if G_GameLogicPtr != nil {
		G_GameLogicPtr.M_Players.Range(func(k, v interface{}) bool {
			v.(*Player).PushAndSendClienRes(&msg.ForceKickOut{})
			v.(*Player).ClearData()
			log.Debug("palyer %d 断开连接 写入数据", k)
			return true
		})
		if G_GameLogicPtr.FriendMgr != nil {
			G_GameLogicPtr.FriendMgr.SaveData()
		}
		if G_GameLogicPtr.MessageMgr != nil {
			G_GameLogicPtr.MessageMgr.SaveData()
		}
		if G_GameLogicPtr.VarMgr != nil {
			G_GameLogicPtr.VarMgr.SaveData()
		}
		if G_GameLogicPtr.ChampshipMgr != nil {
			G_GameLogicPtr.ChampshipMgr.SaveData()
		}
		if G_GameLogicPtr.MailMgr != nil {
			G_GameLogicPtr.MailMgr.SaveData()
		}
		if G_GameLogicPtr.RankMgr != nil {
			G_GameLogicPtr.RankMgr.SaveData()
		}
	}
	log.Debug("服务器下线完成")
}

func GeneratedCode(Phone string) (string, error) {
	Code := GoUtil.Rand6DigitNumber()
	log.Debug("生成验证码: %s", Code)
	key := "Code_" + Phone
	value, _ := db.RedisGetKey(key)
	if value != "" {
		//return fmt.Errorf("验证码已发送，请稍后再试")
	}
	db.RedisSetKey(key, Code, 5*time.Minute)
	err := GoUtil.SmsCode(Phone, Code)
	if err != nil {
		log.Error("发送验证码失败: %v", err)
	}
	// TODO 测试用
	return Code, err
}

func VerifyCode(Phone, Code string) error {
	key := "Code_" + Phone
	value, err := db.RedisGetKey(key)
	if err != nil {
		return fmt.Errorf("验证码已失效")
	}
	if value == Code {
		db.RedisDelKey(key)
		return nil
	}
	return fmt.Errorf("验证码错误")
}