package game

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

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

	"math/rand"

	"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               map[int32]*Player
	m_CronEntryIDs          map[int]*LimitActPeriod
	Mdispatr                *timer.Dispatcher
	M_LimitActiveList       []int
	NotInitPlayer           *Player
	MReadyToRemoveList      map[*Player]*timer.Timer
	Mlogger                 *log.Logger
	MloggerErr              error
	Version                 int32
	M_SvrGlobal             db.SqlSvrGlobalStruct
	MChampshipsManager      *NewChampshipsManager
	MLimiteEventManager     *LimiteEventManager
	MPlayerProfileManager   *PlayerProfileManager
	MOldPlayerCompensateMgr *OldPlayerCompensateMgr
	MHttpManager            *HttpManager

	MLogManager  *LogMgr
	SeverInfo    *ServerInfo
	FriendMgr    *FriendMgr
	RankMgr      *RankMgr
	MailMgr      *MailMgr
	ChampshipMgr *ChampshipMgr
}

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{Type: MsgMod.SERVER_ZERO_UPDATE}) // 零点更新排行榜
	gl.CreateDailyLogFile()
}

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

func (gl *GameLogic) SetPlayer(player *Player) {
	gl.M_Players[player.M_DwUin] = player
}

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

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.Mdispatr.AfterFunc(time.Second*time.Duration(GoUtil.NextNoonTimestampDuration()), func() {
		gl.NoonFlush()
	})
	gl.CreateDailyLogFile()

	go func() {
		for k := range gl.Mdispatr.ChanTimer {
			k.Cb()
		}
	}()
	go func() {
		// 注释内容也可以使用

		ticker := time.NewTicker(time.Second * 1)

		for range ticker.C {
			timeStamp := (int64)(time.Now().Unix())
			GoUtil.CallEvent(MergeConst.Notify_Clock_Tick_Sec, []interface{}{timeStamp})
			if gl.M_SvrGlobal.StartMileStoneSvrTime == 0 {
				gl.M_SvrGlobal.StartMileStoneSvrTime = int32(gl.DailyTaskTimestamp)
				gl.M_SvrGlobal.OpenSvrTime = int32(gl.DailyTaskTimestamp)
				db.FormatAllMemUpdateDb(&gl.M_SvrGlobal, "t_server_global_data", "Id")
			}
			if int32(timeStamp) >= gl.M_SvrGlobal.StartMileStoneSvrTime+MergeConst.G_MailStone_Period {
				deltaTime := int32(timeStamp) - gl.M_SvrGlobal.StartMileStoneSvrTime
				mod := deltaTime % MergeConst.G_MailStone_Period
				gl.M_SvrGlobal.StartMileStoneSvrTime = int32(timeStamp) - mod
				db.FormatAllMemUpdateDb(&gl.M_SvrGlobal, "t_server_global_data", "Id")
				var a1 = []interface{}{gl.M_SvrGlobal.StartMileStoneSvrTime}
				GoUtil.CallEvent(MergeConst.Notify_MileStone_Renew, a1)
			}
		}
	}()
}

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.M_Players[player.M_DwUin] = player

}

// 重新绑定玩家和网络连接代理
func (ad *GameLogic) RebindPlayerAndAgent(a gate.Agent, player *Player) {
	internal.AsignPlayerToAgents(a, player)
	ad.M_Players[player.M_DwUin] = player
	player.Reconnect()
	player.SetAgent(a)
	timer1 := ad.MReadyToRemoveList[player]
	timer1.Disabled()
	ad.Mdispatr.ChanTimer <- timer1
	timer1.Stop()
	delete(G_GameLogicPtr.MReadyToRemoveList, 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) GetPlayerByUid(Uid int) *Player {
	p, ok := ad.M_Players[int32(Uid)]
	if ok {
		return p
	}
	return nil
}

func (ad *GameLogic) ReadAllConfigs() {
	gamedata.InitReadAllCfg()
	// gamedata.ReadConfigFromAllConfig("Activity.txt")
}

// 好友管理器
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) GetSimplePlayerByUid(Id int) *PlayerSimpleData {
	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), 300)
	} 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 = make(map[int32]*Player)
		G_GameLogicPtr.MReadyToRemoveList = make(map[*Player]*timer.Timer)
		G_GameLogicPtr.NotInitPlayer = new(Player)
		G_GameLogicPtr.M_LimitActiveList = []int{}
		G_GameLogicPtr.LoadSvrGlobalData()        // 加载服务器全局数据
		G_GameLogicPtr.CreateChamshipsMgr()       // 创建锦标赛管理器
		G_GameLogicPtr.CreateLimiteEventManager() // 创建限时活动管理器
		G_GameLogicPtr.CreateProfileManager()     // 创建玩家档案管理器
		G_GameLogicPtr.CreateCompensateMgr()      // 创建老玩家补偿管理器
		G_GameLogicPtr.OpenTimestampTick()        // 开启时间戳计时器
		G_GameLogicPtr.ReadAllConfigs()           // 读取所有配置文件
		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()       // 创建竞标赛管理器
		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) DisorderLuaTable(length int, Cnt int) []int {

	// length := len(tb)
	indexList := []int{}
	copy := []int{}
	for i := 0; i < Cnt; i++ {
		index := rand.Intn(length - i)
		if len(indexList) == 0 {
			indexList = append(indexList, index)
		} else {
			for n := 0; n < len(copy); n++ {
				if index >= copy[n] {
					index = index + 1
				}
			}
			indexList = append(indexList, index)
		}
		copy = []int{}
		for j := 0; j < len(indexList); j++ {
			copy = append(copy, indexList[j])
		}

		sort.Slice(copy, func(i, j int) bool { return copy[i] < copy[j] })
	}
	contentList := indexList[:]
	return contentList
}

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)
		go func() {
			time.Sleep(100 * time.Second)
			if player != nil {
				player.lock.Lock()
				defer player.lock.Unlock()
				if player.agent == nil {
					delete(ad.M_Players, player.M_DwUin)
					player.ClearData()
					log.Debug("player %d 延迟100s关闭", player.M_DwUin)
				}
			}
		}()
	}
}

func (ad *GameLogic) FindOfflinePlayer(dwUin int32) *Player {
	for k := range G_GameLogicPtr.MReadyToRemoveList {
		if k.M_DwUin == dwUin {
			return k
		}
	}
	return nil
}

func (ad *GameLogic) InitPassportInsertDb(player *Player, StartSvrTime int32, EndSvrTime int32, ConfigActId int) int32 {
	st := &db.SqlLimitPassportStruct{}
	st.CurFreeLv = 0
	st.CurPayLv = 0
	st.DwUin = player.M_DwUin
	st.IsPay = 0
	st.Star = 0
	st.StartSvrTime = StartSvrTime
	st.EndSvrTime = EndSvrTime
	st.Status = 0
	st.ActiveID = 0
	st.ConfigActId = int32(ConfigActId)
	activityID, _ := db.FormatAllMemInsertDb(st, "t_player_LimitPassport")

	return int32(activityID)
}

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) InitCardCollectInsertDb(player *Player, StartSvrTime int32, EndSvrTime int32, ConfigActId int) int32 {
	st := &db.SqlCardCollectStruct{}
	st.DwUin = player.M_DwUin

	st.StartSvrTime = StartSvrTime
	st.EndSvrTime = EndSvrTime
	st.ActiveID = 0
	st.Fragment = 0
	st.CardInfo = ""
	st.ConfigActId = int32(ConfigActId)
	activityID, _ := db.FormatAllMemInsertDb(st, "t_player_card_data")

	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) OpenNewLimitActivity(args []interface{}) {
	go func() {
		internal.Agents.Range(func(k, v interface{}) bool {
			if v == ad.NotInitPlayer {
				return true
			}
			player := v.(*Player)
			notify := &msg.NotifyLimitedTimeActiveData{}
			notify.MActiveList = []*msg.LimitedTimeActiveStruct{}

			id := args[0].(int)
			activityCfg := gamedata.GetConfigByName("Activity")
			record := activityCfg.Index(id).(*gamedata.ActivityRecord)

			act := &msg.LimitedTimeActiveStruct{}
			act.StartSvrTime = args[1].(int32)
			act.EndSvrTime = args[2].(int32)
			act.Type = int32(record.Type)
			if act.Type == 1 {
				act.ActiveID = ad.InitPassportInsertDb(player, act.StartSvrTime, act.EndSvrTime, id)
			}
			if act.Type == 2 {
				act.ActiveID = ad.InitPromotionInsertDb(player, act.StartSvrTime, act.EndSvrTime, id)
			}
			if act.Type == 3 {
				act.ActiveID = ad.InitInfinitePackInsertDb(player, act.StartSvrTime, act.EndSvrTime, id)
			}
			if act.Type == 4 {
				act.ActiveID = ad.Init7DayLoginInsertDb(player, act.StartSvrTime, act.EndSvrTime, id)
			}
			if act.Type == 5 {
				act.ActiveID = ad.InitCardCollectInsertDb(player, act.StartSvrTime, act.EndSvrTime, id)
			}
			notify.MActiveList = append(notify.MActiveList, act)
			data, _ := proto.Marshal(notify)
			ad.PackResInfo(k.(gate.Agent), "NotifyLimitedTimeActiveData", data)
			return true
		})
	}()

}

func (ad *GameLogic) RegisterEvent() {

	GoUtil.RegisterEvent(MergeConst.Notify_Socket_Closed, ad.ClearData, nil)
	GoUtil.RegisterEvent(MergeConst.Notify_Socket_Connect, ad.NewPlayerConnect, nil)
	GoUtil.RegisterEvent(MergeConst.OpenNewLimitActivity, ad.OpenNewLimitActivity, 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) {
	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)
	ad.M_Players[player.M_DwUin] = player
	player.PushClientRes(&msg.ResLogin{
		ResultCode: 0,
		DwUin:      player.M_DwUin,
	})
	player.LoginBackData()
}

func (ad *GameLogic) SendMassage(dwUin int32, Func string, data []byte) bool {
	player, ok := ad.M_Players[dwUin]
	if ok {
		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_%02d_%02d_%02d.log",
		now.Year(),
		now.Month(),
		now.Day(),
		now.Hour(),
		now.Minute(),
		now.Second())

	filepathname := "log/" + 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("ReqPlayerBaseInfo", ReqPlayerBaseInfofunction)   // 请求玩家基本信息
	RegisterMsgProcessFunc("UpdateBaseItemInfo", UpdateBaseItemInfofunction) // 保存引导
	RegisterMsgProcessFunc("ReqKv", ReqKv)                                   // 保存客户端数据

	RegisterMsgProcessFunc("ReqPlayerEmitUnlockData", ReqPlayerEmitUnlockDatafunction)
	RegisterMsgProcessFunc("UpdatePlayerEmitUnlockData", UpdatePlayerEmitUnlockDatafunction)

	RegisterMsgProcessFunc("ReqPlayerChessData", ReqPlayerChessDataFunc)
	RegisterMsgProcessFunc("UpdatePlayerChessData", UpdatePlayerChessDataFunc)

	RegisterMsgProcessFunc("UpdateChessColorData", UpdateChessColorDataFunc)
	RegisterMsgProcessFunc("ReqChessColorData", ResChessColorDataFunc)

	RegisterMsgProcessFunc("ReqUnlockingChestID", ReqUnlockingChestIDFunc)
	RegisterMsgProcessFunc("ReqChestUnlockCD", ReqChestUnlockCDFunc)

	RegisterMsgProcessFunc("ReqEmitMergeMap", ReqEmitMergeMapFunc)
	RegisterMsgProcessFunc("ReqEmitCountMap", ReqResEmitCountMapFunc)
	RegisterMsgProcessFunc("ReqEmitCDStartData", ReqEmitCDStartDataFunc)
	RegisterMsgProcessFunc("UpdateEmitMergeMap", UpdateEmitMergeMapFunc)
	RegisterMsgProcessFunc("UpdateEmitCountMap", UpdateEmitCountMapFunc)
	RegisterMsgProcessFunc("ReqEmitSubCD", ReqEmitSubCDFunc)

	RegisterMsgProcessFunc("ReqShopData", ReqShopDatafunc)
	RegisterMsgProcessFunc("ReqShopBuy", ReqShopBuyFunc)
	RegisterMsgProcessFunc("ReqRenewItemBuyCnt", ReqRenewItemBuyCntFunc)

	RegisterMsgProcessFunc("ReqBriefEmailData", ReqBriefEmailDataFunc)
	RegisterMsgProcessFunc("ReqDetailEmailData", ReqDetailEmailDataFunc)
	RegisterMsgProcessFunc("ReqGetEmailReward", ReqGetEmailRewardFunc)
	RegisterMsgProcessFunc("ReqDeleteEmail", ReqDeleteEmailFunc)

	RegisterMsgProcessFunc("ReqLimitPassportDetail", ReqLimitPassportDetailFunc)
	RegisterMsgProcessFunc("ReqPromotionDetail", ReqPromotionDetailFunc)
	RegisterMsgProcessFunc("ReqInfinitePackDetail", ReqInfinitePackDetailFunc)

	RegisterMsgProcessFunc("ReqGetLimitPassportReward", ReqGetLimitPassportRewardFunc)
	RegisterMsgProcessFunc("ReqBuyLimitPromotionReward", ReqBuyLimitPromotionRewardFunc)
	RegisterMsgProcessFunc("ReqBuyInfinitePack", ReqBuyInfinitePackFunc)

	RegisterMsgProcessFunc("ReqPayPassport", ReqPayPassportFunc)
	RegisterMsgProcessFunc("ReqActiveAddStar", ReqActiveAddStarFunc)

	RegisterMsgProcessFunc("ReqOfflineReconnect", ReqOfflineReconnectFunc)

	RegisterMsgProcessFunc("ReqOpenNewPig", ReqOpenNewPigFunc)
	RegisterMsgProcessFunc("ReqPigDetailInfo", ReqPigDetailInfoFunc)
	RegisterMsgProcessFunc("UpdateFinishOrderDiamond", UpdateFinishOrderDiamondFunc)
	RegisterMsgProcessFunc("ReqGetPigReward", ReqGetPigRewardFunc)
	RegisterMsgProcessFunc("ReqDropPigReward", ReqDropPigRewardFunc)

	RegisterMsgProcessFunc("ReqLevelUpPackInfo", ReqLevelUpPackInfoFunc)
	RegisterMsgProcessFunc("ReqBuyLevelUpPack", ReqBuyLevelUpPackFunc)

	RegisterMsgProcessFunc("ReqGrowthFundInfo", ReqGrowthFundInfoFunc)
	RegisterMsgProcessFunc("ReqBuyGrowthFund", ReqBuyGrowthFundFunc)
	RegisterMsgProcessFunc("ReqGetGrowthFundWard", ReqGetGrowthFundWardFunc)
	RegisterMsgProcessFunc("ReqRemoveAd", ReqRemoveAdFunc)

	RegisterMsgProcessFunc("ReqSupremeGiftInfo", ReqSupremeGiftInfoFunc)
	RegisterMsgProcessFunc("ReqBuySupremeGift", ReqBuySupremeGiftFunc)

	RegisterMsgProcessFunc("ReqIllustratedInfo", ReqIllustratedInfoFunc)
	RegisterMsgProcessFunc("ReqGetIllustrateItemReward", ReqGetIllustrateItemRewardFunc)
	RegisterMsgProcessFunc("UpdateIllustrateItem", UpdateIllustrateItemFunc)

	RegisterMsgProcessFunc("ReqCardCollectDetail", ReqCardCollectDetailFunc)
	RegisterMsgProcessFunc("ReqGetCardAlbumReward", ReqGetCardAlbumRewardFunc)
	RegisterMsgProcessFunc("ReqGetAllCardReward", ReqGetAllCardRewardFunc)
	RegisterMsgProcessFunc("ReqAddCard", ReqAddCardFunc)
	RegisterMsgProcessFunc("ReqUnpackCard", ReqUnpackCardFunc)
	RegisterMsgProcessFunc("ReqAddMasterCard", ReqAddMasterCardFunc)
	RegisterMsgProcessFunc("ReqUseMasterCard", ReqUseMasterCardFunc)
	RegisterMsgProcessFunc("ReqBuyStickerItem", ReqBuyStickerItemFunc)

	RegisterMsgProcessFunc("ReqExchangeCardBoxData", ReqExchangeCardBoxDataFunc)
	RegisterMsgProcessFunc("ReqDonateFriendCard", ReqDonateFriendCardFunc)
	RegisterMsgProcessFunc("ReqGetDonateCard", ReqGetDonateCardFunc)
	RegisterMsgProcessFunc("ReqExchangeCard", ReqExchangeCardFunc)
	RegisterMsgProcessFunc("ReqReceiptCard", ReqReceiptCardFunc)
	RegisterMsgProcessFunc("ReqCompleteExchangeCard", ReqCompleteExchangeCardFunc)
	RegisterMsgProcessFunc("ReqGetExchangeCard", ReqGetExchangeCardFunc)
	RegisterMsgProcessFunc("ReqRefuseExchange", ReqRefuseExchangeFunc)
	RegisterMsgProcessFunc("ReqRequestCard", ReqRequestCardFunc)
	RegisterMsgProcessFunc("ReqCompleteRequestCard", ReqCompleteRequestCardFunc)
	RegisterMsgProcessFunc("ReqRefuseRequestCard", ReqRefuseRequestCardFunc)
	RegisterMsgProcessFunc("ReqGetRequestCard", ReqGetRequestCardFunc)

	RegisterMsgProcessFunc("ReqDailyTaskData", ResDailyTaskDataFunc)
	RegisterMsgProcessFunc("UpdateDailyTaskData", UpdateDailyTaskDataFunc)
	RegisterMsgProcessFunc("RenewDailyTaskData", RenewDailyTaskDataFunc)
	RegisterMsgProcessFunc("RenewWeekyActiveData", RenewWeekyActiveDataFunc)

	RegisterMsgProcessFunc("ReqMileStoneData", ResMileStoneDataFunc)
	RegisterMsgProcessFunc("UpdateMileStoneData", UpdateMileStoneDataFunc)
	RegisterMsgProcessFunc("RenewMileStoneData", RenewMileStoneDataFunc)

	RegisterMsgProcessFunc("ReqChampshipData", ReqChampshipDataFunc)
	RegisterMsgProcessFunc("ReqChampshipAddScore", ReqChampshipAddScoreFunc)
	RegisterMsgProcessFunc("ReqChampshipAddTime", ReqChampshipAddTimeFunc)
	RegisterMsgProcessFunc("ReqPlayerChampshipData", ReqPlayerChampshipData)

	RegisterMsgProcessFunc("ReqAdPackData", ReqAdPackDataFunc)
	RegisterMsgProcessFunc("ReqWatchAdPack", ReqWatchAdPackFunc)

	RegisterMsgProcessFunc("ReqPlayerSingleData", ReqPlayerSingleDataFunc)
	RegisterMsgProcessFunc("ReqOpenNewbiePack", ReqOpenNewbiePackFunc)
	RegisterMsgProcessFunc("ReqBuyNewbiePack", ReqBuyNewbiePackFunc)
	RegisterMsgProcessFunc("ReqAddNoAdCnt", ReqAddNoAdCntFunc)
	RegisterMsgProcessFunc("ReqAddWatchAdCnt", ReqAddWatchAdCntFunc)

	RegisterMsgProcessFunc("ReqPlayerPayData", ReqPlayerPayDataFunc)
	RegisterMsgProcessFunc("ReqAddPay", ReqAddPayFunc)

	RegisterMsgProcessFunc("ReqLimitData", ReqLimitDataFunc)
	RegisterMsgProcessFunc("ReqAddLimitTime", ReqAddLimitTimeFunc)

	RegisterMsgProcessFunc("ReqGenSuperOrder", ReqGenSuperOrderFunc)
	RegisterMsgProcessFunc("ReqEndSuperOrder", ReqEndSuperOrder)
	RegisterMsgProcessFunc("ReqCompleteDoubleHit", ReqCompleteDoubleHit)
	RegisterMsgProcessFunc("ReqTagThief", ReqTagThief)

	RegisterMsgProcessFunc("ReqFriendData", ReqFriendDataFunc)
	RegisterMsgProcessFunc("ReqWillPlayerDetail", ReqWillPlayerDetailFunc)
	RegisterMsgProcessFunc("ReqAddFriendData", ReqAddFriendDataFunc)
	RegisterMsgProcessFunc("ReqAllAddFriendInfo", ReqAllAddFriendInfoFunc)
	RegisterMsgProcessFunc("ReqAgreeFriendReq", ReqAgreeFriendReqFunc)
	RegisterMsgProcessFunc("ReqRefuseFriendReq", ReqRefuseFriendReqFunc)
	RegisterMsgProcessFunc("ReqDeleteFriend", ReqDeleteFriendFunc)
	RegisterMsgProcessFunc("ReqAutoFBAddFriend", ReqAutoFBAddFriend)
	RegisterMsgProcessFunc("ReqAutoAddInviteFriend", ReqAutoAddInviteFriend)
	RegisterMsgProcessFunc("ReqRecommendFriendList", ReqRecommendFriendList)
	RegisterMsgProcessFunc("ReqInviteFriendData", ReqInviteFriendData)
	RegisterMsgProcessFunc("ReqSelfInvited", ReqSelfInvited)
	RegisterMsgProcessFunc("ReqGetInviteReward", ReqGetInviteReward)
	RegisterMsgProcessFunc("ReqFriendTreasureData", ReqFriendTreasureData)
	RegisterMsgProcessFunc("ReqUpdateFriendStar", ReqUpdateFriendStar)

	RegisterMsgProcessFunc("ReqPlayerProfileData", ReqPlayerProfileDataFunc)
	RegisterMsgProcessFunc("ReqUpdatePlayerProfile", ReqUpdatePlayerProfileFunc)
	RegisterMsgProcessFunc("ReqPlayerBriefProfileData", ReqPlayerBriefProfileDataFunc)
	RegisterMsgProcessFunc("ReqFriendEventData", ReqFriendEventDataFunc)
	RegisterMsgProcessFunc("ReqUpdateFBPicURL", ReqUpdateFBPicURLFunc)

	RegisterMsgProcessFunc("ReqBindFacebookAccount", ReqBindFacebookAccount)
	RegisterMsgProcessFunc("ReqOnlyBindFacebook", ReqOnlyBindFacebook)
	RegisterMsgProcessFunc("ReqUnBindFacebook", ReqUnBindFacebook)
	RegisterMsgProcessFunc("ReqSynGameData", ReqSynGameData)

	RegisterMsgProcessFunc("ReqPlayerPetData", ReqPlayerPetData)
	RegisterMsgProcessFunc("ReqUpdatePetProfile", ReqUpdatePetProfile)

	RegisterMsgProcessFunc("ReqPetHomeData", ReqPetHomeData)
	RegisterMsgProcessFunc("ReqOpenOtherPetHome", ReqOpenOtherPetHome)
	RegisterMsgProcessFunc("ReqCompleteMiniGame", ReqCompleteMiniGame)
	RegisterMsgProcessFunc("ReqOpenSelfPet", ReqOpenSelfPet)
	RegisterMsgProcessFunc("ReqPetHomeInterActST", ReqPetHomeInterActST)
	RegisterMsgProcessFunc("ReqShiftVisitPet", ReqShiftVisitPet)
	RegisterMsgProcessFunc("ReqCallBackPet", ReqCallBackPet)
	RegisterMsgProcessFunc("ReqUnlockDecorate", ReqUnlockDecorate)
	RegisterMsgProcessFunc("ReqSaveSelectDecorate", ReqSaveSelectDecorate)

	// 玩家
	RegisterMsgProcessFunc("ReqUserInfo", ReqUserInfo)
	RegisterMsgProcessFunc("ReqSetName", ReqSetName) // 设置名字

	// 棋盘
	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)

	//卡牌
	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("ReqGuideReward", ReqGuideReward)
	// 头像
	RegisterMsgProcessFunc("ReqSetFace", ReqSetFace)
	// 头像框
	RegisterMsgProcessFunc("ReqSetAvatar", ReqSetAvatar)

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

	// 连击快手奖励
	RegisterMsgProcessFunc("ReqLimitEvent", ReqLimitEvent)
	RegisterMsgProcessFunc("ReqFastProduceReward", ReqFastProduceReward)
	//场景转盘
	RegisterMsgProcessFunc("ReqLimitSenceReward", ReqLimitSenceReward)
	//领取限时事件进度奖励

	// 好友
	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)       // 删除好友

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

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

	// 商店
	RegisterMsgProcessFunc("ReqFreeShop", ReqFreeShop)                 // 领取商店免费奖励
	RegisterMsgProcessFunc("ReqBuyChessShop", ReqBuyChessShop)         // 购买商店棋子
	RegisterMsgProcessFunc("ReqRefreshChessShop", ReqRefreshChessShop) // 刷新棋子商店

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

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

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

}

func (ad *GameLogic) ResPlayerEmitUnlockData(param []interface{}) {
	data := (param[0].(*Player).GetIFGameData("PlayerEmitUnlockData"))
	data.(*PlayerEmitUnlockData).ResPlayerEmitUnlockData(param[0].(*Player))
}

func (ad *GameLogic) broadcastInfoAllPlayer(Func string, data []byte) {
	internal.Agents.Range(func(k, v interface{}) bool {
		if v == ad.NotInitPlayer {
			return true
		}
		ad.PackResInfo(k.(gate.Agent), Func, data)
		return true
	})
}

func (ad *GameLogic) JudgeIsActivity(c *cron.Cron, Id int) int {
	activityCfg := gamedata.GetConfigByName("Activity")
	record := activityCfg.Index(Id).(*gamedata.ActivityRecord)

	timeStamp := time.Now().Unix()
	t := time.Unix(timeStamp, 0).Local()
	nianchu := timeStamp - (int64)(t.Hour()*3600+t.Minute()*60+t.Second()) - int64((t.YearDay()-1)*3600*24)

	key := ad.m_CronEntryIDs[record.Id]
	Schedule := c.Entry(key.StartCronID).Schedule
	Next := Schedule.Next(time.Unix(nianchu, 0))

	if timeStamp >= Next.Unix() && timeStamp <= Next.Unix()+int64(record.Duration) {
		return 2
	} else {
		if timeStamp < Next.Unix() {
			return 1
		}
	}
	return 3
}

func (ad *GameLogic) CalcDeltaEndTime(c *cron.Cron, Id int) int32 {
	activityCfg := gamedata.GetConfigByName("Activity")
	record := activityCfg.Index(Id).(*gamedata.ActivityRecord)

	timeStamp := time.Now().Unix()
	t := time.Unix(timeStamp, 0).Local()
	nianchu := timeStamp - (int64)(t.Hour()*3600+t.Minute()*60+t.Second()) - int64((t.YearDay()-1)*3600*24)

	key := ad.m_CronEntryIDs[record.Id]
	Schedule := c.Entry(key.StartCronID).Schedule
	Next := Schedule.Next(time.Unix(nianchu, 0))
	return int32(Next.Unix() + int64(record.Duration) - timeStamp)
}

func (ad *GameLogic) GetActiveParamById(Id int) *LimitActPeriod {
	v, ok := ad.m_CronEntryIDs[Id]
	if ok {
		return v
	}
	return nil
}

func (ad *GameLogic) CreateLimiteEventManager() {
	ad.MLimiteEventManager = new(LimiteEventManager)
	ad.MLimiteEventManager.InitManager()
}

func (ad *GameLogic) CreateProfileManager() {
	ad.MPlayerProfileManager = new(PlayerProfileManager)
	ad.MPlayerProfileManager.InitManager()
}

func (ad *GameLogic) CreateChamshipsMgr() {
	ad.MChampshipsManager = new(NewChampshipsManager)
	ad.MChampshipsManager.InitManager()
}

func (ad *GameLogic) CreateCompensateMgr() {
	ad.MOldPlayerCompensateMgr = new(OldPlayerCompensateMgr)
	ad.MOldPlayerCompensateMgr.InitManager()
}

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)
	activityCfg := gamedata.GetConfigByName("Activity")
	c := cron.New()

	timeStamp := time.Now().Unix()
	t := time.Unix(timeStamp, 0).Local()
	nianchu := timeStamp - (int64)(t.Hour()*3600+t.Minute()*60+t.Second()) - int64((t.YearDay()-1)*3600*24)

	for i := 0; i < activityCfg.NumRecord(); i++ {
		record := activityCfg.Record(i).(*gamedata.ActivityRecord)
		start := record.StartTime
		var LAP = LimitActPeriod{}

		LAP.StartCronID, _ = c.AddFunc(start, func() {
			log.Debug("Next: UTC", c.Entry(LAP.StartCronID).Next.Unix())
			G_GameLogicPtr.M_LimitActiveList = append(G_GameLogicPtr.M_LimitActiveList, record.Id)
			cur := int32(time.Now().Unix())
			GoUtil.CallEvent(MergeConst.OpenNewLimitActivity, []interface{}{record.Id, cur, cur + int32(record.Duration), record.Type})
			go func() {
				LeafTimer := ad.Mdispatr.AfterFunc(time.Duration(record.Duration)*time.Second, func() {
					GoUtil.CallEvent(MergeConst.CloseNewLimitActivity, []interface{}{record})
					G_GameLogicPtr.M_LimitActiveList = GoUtil.DeleteEleByValue(G_GameLogicPtr.M_LimitActiveList, record.Id)
				})
				LAP.EndTimer = LeafTimer
			}()
		})
		ad.m_CronEntryIDs[record.Id] = &LAP
	}
	c.Start()
	for k, v := range ad.m_CronEntryIDs {
		ret := ad.JudgeIsActivity(c, k)
		if ret == 3 { //已经结束
			delete(ad.m_CronEntryIDs, k)
		}
		if ret == 2 {
			key := k
			value := v
			G_GameLogicPtr.M_LimitActiveList = append(G_GameLogicPtr.M_LimitActiveList, k)
			go func() {
				delta := ad.CalcDeltaEndTime(c, key)
				LeafTimer := ad.Mdispatr.AfterFunc(time.Duration(delta)*time.Second, func() {
					record := activityCfg.Index(key).(*gamedata.ActivityRecord)
					GoUtil.CallEvent(MergeConst.CloseNewLimitActivity, []interface{}{record})
					G_GameLogicPtr.M_LimitActiveList = GoUtil.DeleteEleByValue(G_GameLogicPtr.M_LimitActiveList, key)
				})
				value.EndTimer = LeafTimer
				Schedule := c.Entry(value.StartCronID).Schedule
				Next := Schedule.Next(time.Unix(nianchu, 0))
				value.StartTime = int32(Next.Unix())
				value.EndTime = int32(Next.Unix()) + activityCfg.Index(key).(*gamedata.ActivityRecord).Duration
			}()
		}
	}
}

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

func (ad *GameLogic) NotifyAll(m *MsgMod.Msg) {
	for _, v := range ad.M_Players {
		v.Send(m)
	}
}

func NotifyPlayer(Uid int, m *MsgMod.Msg) {
	p := G_GameLogicPtr.GetPlayerByUid(Uid)
	if p == nil || p.stop {
		return
	}
	p.SendMsg(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, "")
}