package game

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

	l "log"
	"server/db"
	"server/game/internal"
	MsgMod "server/game/mod/msg" // Ensure this package exists and is correctly referenced
	"server/msg"
	"time"

	"github.com/robfig/cron/v3"

	"google.golang.org/protobuf/proto"

	"server/pkg/github.com/name5566/leaf/gate"
	"server/pkg/github.com/name5566/leaf/log"
	"server/pkg/github.com/name5566/leaf/timer"
)

var (
	G_GameLogicPtr *GameLogic
)

var isInitGameLogic = false
var RegisterNetWorkFunc = make(map[string]interface{})

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 RunNetProcessByKey(key string, param []interface{}) error {
	fun, ok := RegisterNetWorkFunc[key]
	if ok {
		err := fun.(func([]interface{}) error)(param)
		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
	Mlogger            *log.Logger
	MloggerErr         error
	Version            int32
	M_SvrGlobal        db.SqlSvrGlobalStruct
	MHttpManager       *HttpManager
	SeverInfo          *ServerInfo

	MLogManager  *LogMgr       // 日志管理器
	FriendMgr    *FriendMgr    // 好友管理器
	RankMgr      *RankMgr      // 排行榜管理器
	MailMgr      *MailMgr      // 邮件管理器
	ChampshipMgr *ChampshipMgr // 锦标赛管理器
	VarMgr       *VarMgr       // 变量管理器

}

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.RankMgrSend(MsgMod.MSG_ZERO_UPDATE) // 零点更新排行榜
	gl.VarMgrSend(MsgMod.MSG_ZERO_UPDATE)  // 零点更新变量
	gl.NotifyAll(MsgMod.MSG_ZERO_UPDATE)
	gl.CreateDailyLogFile()
}

// 中午更新
func (gl *GameLogic) NoonFlush() {
	gl.Mdispatr.AfterFunc(time.Second*86400, func() {
		gl.NoonFlush()
	})
	var a1 = []interface{}{gl.DailyTaskTimestamp}
	gl.NotifyAll(MsgMod.MSG_NOON_UPDATE)
	GoUtil.CallEvent(MergeConst.Notify_Midday_Renew, a1)
}

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 int32) *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(conf.Server.ServerID*100000)
	playerInfo := &db.ResPlayerBaseInfo{}
	playerInfo.DwUin = int32(insertId)
	playerInfo.Energy = 100
	playerInfo.Star = 0
	playerInfo.RecoverTime = int32(time.Now().Unix())
	playerInfo.Diamond = 0
	playerInfo.Level = 1
	playerInfo.Exp = 0
	playerInfo.StartOrderId = "1"
	playerInfo.MusicCode = 1
	playerInfo.Guild = 1
	playerInfo.PackUnlockCount = 5
	playerInfo.EnergyBuyCount = 0
	playerInfo.UserName = ad.Db_AccountInfo.UserName
	playerInfo.LoginTime = 0
	playerInfo.LogoutTime = 0
	playerInfo.Todayolinetime = 0
	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:      int32(insertId),
		ModData:    buf.Bytes(),
		UpdataTime: int32(time.Now().Unix()),
	}
	db.FormatAllMemInsertDb(playerMod, "t_player_mod")

	return true
}

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 := 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)
}

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) FriendMgrSend(m *MsgMod.Msg) {
	ad.FriendMgr.Send(m)
}

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

// 排行榜管理器
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) 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)
		p.GetSimpleData(Id, player)
		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:      int32(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),
	}
}

// 初始化服务器协程
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.LoadSvrGlobalData()   // 加载服务器全局数据
		G_GameLogicPtr.OpenTimestampTick()   // 开启时间戳计时器
		G_GameLogicPtr.RegisterEvent()       // 注册事件
		G_GameLogicPtr.RegisterNetWorkFunc() // 注册客户端接口
		G_GameLogicPtr.InitActivity()        // 初始化活动
		G_GameLogicPtr.GetVersion()          // 获取版本号
		G_GameLogicPtr.CreateLogManager()    //加载日志管理器
		G_GameLogicPtr.CreateFriendMgr()     //创建好友管理器
		G_GameLogicPtr.CreateRankMgr()       //创建排行榜管理器
		G_GameLogicPtr.CreateMailMgr()       //创建邮件管理器
		G_GameLogicPtr.CreateChampshipMgr()  // 创建竞标赛管理器
		G_GameLogicPtr.CreateVarMgr()        // 创建变量管理器
		ClusterMgrInit()                     //初始化集群

		// 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) GetVersion() {
	sqlStr := "SELECT * FROM t_gameserver WHERE id = ?"
	sqlStruck := db.SqlVersionStruct{}
	IsHaveDataDb := false
	sqlStruck.Id = 1
	G_GameLogicPtr.Version = 0
	if err := db.SqlDb.Get(&sqlStruck, sqlStr, 1); err != nil {
		G_GameLogicPtr.Version = 1
		IsHaveDataDb = false
	} else {
		G_GameLogicPtr.Version = sqlStruck.IsClose + 1
		IsHaveDataDb = true
	}
	sqlStruck.IsClose = G_GameLogicPtr.Version

	if IsHaveDataDb {
		db.FormatAllMemUpdateDb(&sqlStruck, "t_gameserver", "id")
	} else {
		db.FormatAllMemInsertDb(&sqlStruck, "t_gameserver")
	}
}

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
		log.Debug("player %d 断开连接", player.M_DwUin)
		player.CallEvent(300*time.Second, func() {
			player.lock.Lock()
			defer player.lock.Unlock()
			if player.agent == nil {
				player.ClearData()
				log.Debug("player %d 延迟300s关闭", player.M_DwUin)
			}
		}, "LateClose")
	}
}

func (ad *GameLogic) InitPromotionInsertDb(player *Player, StartSvrTime int32, EndSvrTime int32, ConfigActId int) int32 {
	st := &db.SqlLimitPromotionStruct{}
	st.DwUin = player.M_DwUin
	st.IsPay = 0
	st.StartSvrTime = StartSvrTime
	st.EndSvrTime = EndSvrTime
	st.ActiveID = 0
	st.ConfigActId = int32(ConfigActId)
	activityID, _ := db.FormatAllMemInsertDb(st, "t_player_LimitPromotion")

	return int32(activityID)
}

func (ad *GameLogic) InitInfinitePackInsertDb(player *Player, StartSvrTime int32, EndSvrTime int32, ConfigActId int) int32 {
	st := &db.SqlLimitInfinitePackStruct{}
	st.DwUin = player.M_DwUin
	st.CurGear = 1
	st.StartSvrTime = StartSvrTime
	st.EndSvrTime = EndSvrTime
	st.ActiveID = 0
	st.ConfigActId = int32(ConfigActId)
	activityID, _ := db.FormatAllMemInsertDb(st, "t_player_LimitInfinitePack")

	return int32(activityID)
}

func (ad *GameLogic) Init7DayLoginInsertDb(player *Player, StartSvrTime int32, EndSvrTime int32, ConfigActId int) int32 {
	st := &db.SqlSevenDayLoginStruct{}
	st.DwUin = player.M_DwUin
	st.LastGetTime = 0
	st.StartSvrTime = StartSvrTime
	st.EndSvrTime = EndSvrTime
	st.ActiveID = 0
	st.GetIndex = 0
	st.ConfigActId = int32(ConfigActId)
	activityID, _ := db.FormatAllMemInsertDb(st, "t_player_Limit7DayLogin")

	return int32(activityID)
}

func (ad *GameLogic) LoadSvrGlobalData() {
	sqlStr := "SELECT * FROM t_server_global_data WHERE Id = ?"

	ad.M_SvrGlobal = db.SqlSvrGlobalStruct{}

	if err := db.SqlDb.Get(&ad.M_SvrGlobal, sqlStr, 1); err != nil {
		log.Debug("get data failed, err:%v\n", err)
		timeStamp := time.Now().Unix()
		t := time.Unix(timeStamp, 0).Local()
		zero := timeStamp - (int64)(t.Hour()*3600+t.Minute()*60+t.Second())
		ad.M_SvrGlobal.StartMileStoneSvrTime = int32(zero)
		ad.M_SvrGlobal.Id = 1
		db.FormatAllMemInsertDb(&ad.M_SvrGlobal, "t_server_global_data")
	} else {

	}
}

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)
	player.PushClientRes(&msg.ResLogin{
		ResultCode: 0,
		DwUin:      player.M_DwUin,
	})
	// 取消延迟关闭
	Timer, ok := player.timerList["LateClose"]
	if ok {
		Timer.Stop()
	}
	player.LoginBackData()
	log.Debug("player %d 重连", player.M_DwUin)
	return nil
}

func (ad *GameLogic) SendMassage(dwUin int32, 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()

	filename := fmt.Sprintf("%d%02d%02d.log",
		now.Year(),
		now.Month(),
		now.Day(),
	)

	filepathname := conf.Server.LogPath + "/" + filename
	if !ad.FileExist(filepathname) {
		if ad.Mlogger != nil {
			ad.Mlogger.Close()
		}
		ad.Mlogger, ad.MloggerErr = log.NewDailyLog(now, "Debug", "log", l.LstdFlags)
		if ad.MloggerErr != nil {
			return
		}
		log.Export(ad.Mlogger)
	} else {
		ad.Mlogger, ad.MloggerErr = log.BindLoggerToFile("Debug", filepathname, l.LstdFlags)
		log.Export(ad.Mlogger)
	}
	ad.Mlogger.Debug("CreateDailyLogFile")
}

func (ad *GameLogic) RegisterNetWorkFunc() {

	RegisterMsgProcessFunc("ReqRemoveAd", ReqRemoveAdFunc)
	RegisterMsgProcessFunc("ReqPlayerBriefProfileData", ReqPlayerBriefProfileDataFunc)
	RegisterMsgProcessFunc("ReqOfflineReconnect", ReqOfflineReconnectFunc)

	// 玩家
	RegisterMsgProcessFunc("ReqUserInfo", ReqUserInfo)
	RegisterMsgProcessFunc("ReqSetName", ReqSetName)                         // 设置名字
	RegisterMsgProcessFunc("ReqSetFacebookUrl", ReqSetFacebookUrl)           // 设置facebook地址
	RegisterMsgProcessFunc("ReqPlayerBaseInfo", ReqPlayerBaseInfofunction)   // 请求玩家基本信息
	RegisterMsgProcessFunc("UpdateBaseItemInfo", UpdateBaseItemInfofunction) // 保存引导
	RegisterMsgProcessFunc("ReqKv", ReqKv)                                   // 保存客户端数据

	// #region 棋盘
	RegisterMsgProcessFunc("ReqPlayerChessData", ReqPlayerChessDataFunc)
	RegisterMsgProcessFunc("UpdatePlayerChessData", UpdatePlayerChessDataFunc) // 更新棋盘数据
	RegisterMsgProcessFunc("ReqSetEnergyMul", RegSetEneryFunc)                 //设置能量倍数
	RegisterMsgProcessFunc("ReqChessEx", ReqChessEx)                           // 转换棋子
	RegisterMsgProcessFunc("ReqGetChessFromBuff", ReqGetChessFromBuff)         // 从buff中获取棋子
	RegisterMsgProcessFunc("ReqPutChessInBag", ReqPutChessInBag)               // 把棋子放入背包
	RegisterMsgProcessFunc("ReqTakeChessOutBag", ReqTakeChessOutBag)           // 从背包中取出棋子
	RegisterMsgProcessFunc("ReqBuyChessBagGrid", ReqBuyChessBagGrid)           // 解锁背包格子

	RegisterMsgProcessFunc("ReqBuyEnergy", ReqBuyEnergy) //购买能量

	//领取图鉴奖励
	RegisterMsgProcessFunc("ReqGetHandbookReward", ReqGetHandbookReward) //领取图鉴奖励

	//领取订单奖励
	RegisterMsgProcessFunc("ReqRewardOrder", ReqRewardOrder) // 领取订单奖励

	//装饰
	RegisterMsgProcessFunc("ReqDecorate", ReqDecorate)       // 装饰
	RegisterMsgProcessFunc("ReqDecorateAll", ReqDecorateAll) // 装饰全部
	//Gm命令
	RegisterMsgProcessFunc("ReqGmCommand", ReqGmCommand) // Gm命令

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

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

	// 日常任务
	RegisterMsgProcessFunc("ReqGetDailyTaskReward", ReqGetDailyTaskReward) // 领取日常任务奖励
	RegisterMsgProcessFunc("ReqGetDailyWeekReward", ReqGetDailyWeekReward) // 领取周活跃奖励
	RegisterMsgProcessFunc("ReqDailyUnlock", ReqDailyUnlock)               // 日常任务解锁

	// 引导奖励
	RegisterMsgProcessFunc("ReqGuideReward", ReqGuideReward) // 领取引导奖励
	// 头像
	RegisterMsgProcessFunc("ReqSetFace", ReqSetFace) // 设置头像
	// 头像框
	RegisterMsgProcessFunc("ReqSetAvatar", ReqSetAvatar) // 设置头像框

	// 七日签到
	RegisterMsgProcessFunc("ReqGetSevenLoginReward", ReqGetSevenLoginReward) // 领取七日签到奖励
	RegisterMsgProcessFunc("ReqGetMonthLoginReward", ReqGetMonthLoginReward) // 领取月签到奖励

	// 限时事件
	RegisterMsgProcessFunc("ReqLimitEvent", ReqLimitEvent)               // 请求限时事件数据
	RegisterMsgProcessFunc("ReqFastProduceReward", ReqFastProduceReward) // 连击快手奖励
	RegisterMsgProcessFunc("ReqLimitSenceReward", ReqLimitSenceReward)   // 获取场景转盘奖励
	RegisterMsgProcessFunc("ReqSelectLimitEvent", ReqSelectLimitEvent)   //领取限时事件进度奖励
	RegisterMsgProcessFunc("ReqGetGoldCard", ReqGetGoldCard)             //请求金卡交换信息

	// #region 好友
	RegisterMsgProcessFunc("ReqFriendList", ReqFriendList)           // 请求好友列表
	RegisterMsgProcessFunc("ReqFriendApply", ReqFriendApply)         // 请求申请好友列表
	RegisterMsgProcessFunc("ReqFriendCardMsg", ReqFriendCardMsg)     // 请求好友卡牌申请列表
	RegisterMsgProcessFunc("ReqFriendTimeLine", ReqFriendTimeLine)   // 请求好友时间线
	RegisterMsgProcessFunc("ReqFriendRecommend", ReqFriendRecommend) // 获取推荐好友

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

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

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

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

	// 商店
	RegisterMsgProcessFunc("ReqFreeShop", ReqFreeShop)                 // 领取商店免费奖励
	RegisterMsgProcessFunc("ReqBuyChessShop", ReqBuyChessShop)         // 购买商店棋子
	RegisterMsgProcessFunc("ReqBuyChessShop2", ReqBuyChessShop2)       // 购买商店棋子直接加入棋盘
	RegisterMsgProcessFunc("ReqRefreshChessShop", ReqRefreshChessShop) // 刷新棋子商店

	// 无尽礼包
	RegisterMsgProcessFunc("ReqEndless", ReqEndless)             // 请求无尽礼包数据
	RegisterMsgProcessFunc("ReqEndlessReward", ReqEndlessReward) // 领取无尽礼包免费奖励

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

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

	// #region 活动
	// 挖矿
	RegisterMsgProcessFunc("ReqMining", ReqMining)             // 请求挖矿数据
	RegisterMsgProcessFunc("ReqMiningReward", ReqMiningReward) // 领取挖矿奖励
	RegisterMsgProcessFunc("ReqMiningTake", ReqMiningTake)     // 挖矿
	// 猜颜色
	RegisterMsgProcessFunc("ReqGuessColor", ReqGuessColor)             // 请求猜颜色数据
	RegisterMsgProcessFunc("ReqGuessColorReward", ReqGuessColorReward) // 领取猜颜色奖励
	RegisterMsgProcessFunc("ReqGuessColorTake", ReqGuessColorTake)     // 猜颜色
	//  三段竞赛
	RegisterMsgProcessFunc("ReqRace", ReqRace)
	RegisterMsgProcessFunc("ReqRaceReward", ReqRaceReward)
	RegisterMsgProcessFunc("ReqRaceStart", ReqRaceStart)

	// #region playroom
	RegisterMsgProcessFunc("ReqPlayroom", ReqPlayroom)                         // 请求playroom数据
	RegisterMsgProcessFunc("ReqPlayroomInfo", ReqPlayroomInfo)                 // 请求playroom拜访信息
	RegisterMsgProcessFunc("ReqPlayroomGame", ReqPlayroomGame)                 // 游戏结果
	RegisterMsgProcessFunc("ReqPlayroomInteract", ReqPlayroomInteract)         // 宠物交互
	RegisterMsgProcessFunc("ReqPlayroomSetRoom", ReqPlayroomSetRoom)           // playroom装饰
	RegisterMsgProcessFunc("ReqPlayroomSelectReward", ReqPlayroomSelectReward) // playroom选择奖励
	RegisterMsgProcessFunc("ReqPlayroomLose", ReqPlayroomLose)                 // 处理偷取的棋子
	RegisterMsgProcessFunc("ReqPlayroomWork", ReqPlayroomWork)                 // 宠物工作
	RegisterMsgProcessFunc("ReqPlayroomRest", ReqPlayroomRest)                 // 宠物休息
	RegisterMsgProcessFunc("ReqPlayroomDraw", ReqPlayroomDraw)                 // 转盘
	RegisterMsgProcessFunc("ReqPlayroomChip", ReqPlayroomChip)                 // 消除碎片
	RegisterMsgProcessFunc("ReqPlayroomOutline", ReqPlayroomOutline)           // 打工离线
	RegisterMsgProcessFunc("ReqPlayroomWrokOutline", ReqPlayroomWrokOutline)   // 打工离线完成

}

func (ad *GameLogic) CreateHttpManager() {

	go func() {
		ad.MHttpManager = new(HttpManager)
		ad.MHttpManager.InitRounter()
	}()

}

func (ad *GameLogic) CreateLogManager() {
	ad.MLogManager = new(LogMgr)
	ad.MLogManager.InitManager()
}

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

func (ad *GameLogic) AddLog(Log *Log) {
	Log.TimeStamp = time.Now().Unix()
	go func() {
		ad.MLogManager.AddLog(Log)
	}()
}

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

func NotifyPlayer(Uid int, m *MsgMod.Msg) {
	p := G_GameLogicPtr.GetPlayer(int32(Uid))
	if p == nil || p.stop {
		return
	}
	p.Send(m)
}

func setRedisLock(key, value string, Duration time.Duration) bool {
	return db.RedisLock(key, "", Duration)
}

func getRedisLock(key string) error {
	_, err := db.RedisGetKey(key)
	return err
}

func unsetRedisLock(key string) {
	db.RedisUnlock(key, "")
}

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