package game

import (
	// "server/GoUtil"
	// "server/MergeConst"

	"context"
	"database/sql"
	"encoding/json"
	"errors"
	"math"
	"server/GoUtil"
	activityCfg "server/conf/activity"
	cardCfg "server/conf/card"
	guesscolorCfg "server/conf/guessColor"
	itemCfg "server/conf/item"
	mergeDataCfg "server/conf/mergeData"
	miningCfg "server/conf/mining"
	"server/db"
	"server/game/mod/item"
	"server/game/mod/limitedTimeEvent"
	MsgMod "server/game/mod/msg"
	"server/game/mod/playroom"
	"server/game/mod/quest"
	"server/msg"
	telog "server/thinkdata"
	"strconv"
	"sync"
	"time"

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

	"github.com/robfig/cron/v3"

	"google.golang.org/protobuf/proto"
)

// import "reflect"

//"fmt"

type Player struct {
	PlayerBaseMod *PlayerBaseData
	PlayMod       PlayerMod
	M_DwUin       int64
	agent         gate.Agent
	lock          sync.Mutex
	stopSignal    chan bool
	Msg           []PlayerMsg
	Trigger       []*quest.Trigger
	MDispatr      *timer.Dispatcher
	McronSave     *cron.Cron
	McronSaveID   cron.EntryID
	msgChan       chan *MsgMod.Msg
	args          map[string]interface{}
	timerList     map[string]*timer.Timer
	activity      map[int]*ActivityInfo
	stop          bool
	wg            sync.WaitGroup
}

type PlayerBackUp struct {
	Data    msg.ResPlayerBaseInfo
	PlayMod []byte
}

type PlayerMsg struct {
	F string
	B []byte
}

func (p *Player) Stop() {
	select {
	case <-p.stopSignal:
		// 通道已经关闭
		return
	default:
		p.wg.Wait()
		close(p.stopSignal)
		close(p.msgChan)
	}
	G_GameLogicPtr.AddLog(&Log{
		Uid:       p.M_DwUin,
		EventName: "Login_Out",
	})
	p.McronSave.Stop()
	p.stop = true
}

func (p *Player) CallEvent(Duration time.Duration, F func(), Label string) {
	if v, ok := p.timerList[Label]; ok {
		v.Stop()
	}
	t := p.MDispatr.AfterFunc(Duration, F)
	p.timerList[Label] = t
}

// 异步请求
func (p *Player) Send(m *MsgMod.Msg) {
	if m == nil {
		return
	}
	p.wg.Add(1)
	p.msgChan <- m
}

func (p *Player) Call(m MsgMod.Msg) {
	HandleMsg(p, &m)
}

func (p *Player) SendClientRes() {
	for _, v := range p.Msg {
		G_GameLogicPtr.PackResInfo(p.GetAgent(), v.F, v.B)
	}
	p.Msg = make([]PlayerMsg, 0)
}

func (p *Player) PushClientRes(m proto.Message) {
	key := GetStructName(m)
	buff, _ := proto.Marshal(m)
	p.Msg = append(p.Msg, PlayerMsg{
		F: key,
		B: buff,
	})
}

func (p *Player) PushAndSendClienRes(m proto.Message) {
	key := GetStructName(m)
	buff, _ := proto.Marshal(m)
	G_GameLogicPtr.PackResInfo(p.GetAgent(), key, buff)
}

func (p *Player) SendErrClienRes(m proto.Message) {
	key := GetStructName(m)
	buff, _ := proto.Marshal(m)
	G_GameLogicPtr.PackResInfo(p.GetAgent(), key, buff)
}

func (p *Player) QuestTrigger(tr *quest.Trigger) {
	p.Trigger = append(p.Trigger, tr)
}

func (p *Player) QuestTriggerList(tr []*quest.Trigger) {
	p.Trigger = append(p.Trigger, tr...)
}

func (p *Player) ProcessTrigger() {
	IsDailyBack := false
	DailyTaskMod := p.PlayMod.getDailyTaskMod()

	for _, tr := range p.Trigger {
		if DailyTaskMod.Trigger(tr) {
			IsDailyBack = true
		}
	}

	if IsDailyBack {
		p.PushClientRes(DailyTaskMod.BackData())
	}
	p.Trigger = make([]*quest.Trigger, 0)
}

// 接口请求之前备份数据
func (p *Player) BackUp() *PlayerBackUp {
	BackUp := PlayerBackUp{}
	p.PlayMod.BackUp(&BackUp)
	BackUp.Data = p.GetPlayerBaseMod().BackUp()
	return &BackUp
}

// 接口发生错误时 还原数据
func (p *Player) Recover(backUp *PlayerBackUp) {
	// p.GetPlayerBaseMod().Data = backUp.Data
	p.PlayMod.Recover(backUp)
	p.Msg = make([]PlayerMsg, 0)
}

func (p *Player) InitPlayer(UserName string) error {
	p.lock.Lock()
	defer p.lock.Unlock()
	p.msgChan = make(chan *MsgMod.Msg, 100)
	p.Msg = make([]PlayerMsg, 0)
	p.args = make(map[string]interface{})
	p.timerList = make(map[string]*timer.Timer)
	p.MDispatr = timer.NewDispatcher(100)
	p.stopSignal = make(chan bool)
	Base := &PlayerBaseData{p: p}

	// 玩家基础数据
	ok := Base.LoadDataFromDB(UserName)
	if !ok {
		log.Debug("load PlayerBaseData failed:", UserName)
		return errors.New("load PlayerBaseData failed")
	}
	p.PlayerBaseMod = Base
	p.M_DwUin = Base.Data.DwUin

	// 棋盘数据

	// 玩家模块数据
	modData := &PlayerModData{PlayerData: NewPlayerData("PlayerModData", p)}
	ok = modData.LoadDataFromDB(Base.Data.DwUin)
	if !ok {
		log.Debug("load PlayerModData failed:", UserName)
		return errors.New("load PlayerModData failed")
	}
	IsUpdate, err := modData.InitMod(p)
	if err != nil {
		log.Debug("InitMod failed:", err)
		return err
	}
	p.PlayMod.mod_list = modData.ModList
	p.PlayMod.is_update = IsUpdate

	go func() { // 处理数据回调
		var cb *timer.Timer
		for {
			select {
			case <-p.stopSignal:
				return
			case cb = <-p.MDispatr.ChanTimer:
				if cb != nil {
					cb.Cb()
				} else {
					log.Debug("Timer callback or Timer is nil")
				}
			case msg := <-p.msgChan:
				if msg != nil {
					p.wg.Done()
					log.Debug("player %d recive msg %v", p.M_DwUin, msg)
					go HandleMsg(p, msg)
				}
			}
		}
	}()
	p.McronSave = cron.New()
	_, err = p.McronSave.AddFunc("@every 1m", p.AutoSaveData)
	if err != nil {
		log.Debug("AddFunc failed:", err)
	}
	p.McronSave.Start()
	p.initAcitivity()
	p.ZeroUpdate(nil)
	p.NoonUpdate(nil)
	p.Login()
	p.LoginBackData()
	// GoUtil.RegisterEvent(MergeConst.Notify_Daily_Renew, p.ZeroUpdate, p)
	// GoUtil.RegisterEvent(MergeConst.Notify_Midday_Renew, p.ZeroUpdate, p)
	SyncFriendMsg(p)
	p.UpdateUserInfo()
	return nil
}

func (p *Player) Test() {
	p.PlayMod.getBaseMod().EnergyMul = 100
}

// 零点更新
func (p *Player) ZeroUpdate(a []interface{}) {
	VarMod := p.PlayMod.getVarMod()
	zeroTimestamp := GoUtil.ZeroTimestamp()
	PlayerBaseMod := p.GetPlayerBaseMod()
	// 零点更新
	if VarMod.DailyResetTime < zeroTimestamp {
		VarMod.DailyResetTime = zeroTimestamp
		VarMod.DailyVar = make(map[int]interface{})
		//卡牌
		p.PlayMod.getCardMod().ZeroUpdate()
		p.PushClientRes(p.PlayMod.getCardMod().BackData())

		// 每日任务
		p.PlayMod.getDailyTaskMod().ZeroUpdate(p.GetPlayerBaseMod().GetLevel(), p.PlayMod.getDecorateMod().GetAreaId())
		p.PushClientRes(p.PlayMod.getDailyTaskMod().BackData())

		// 能量商店
		p.PlayMod.getBaseMod().ZeroUpdate()
		p.PushClientRes(p.PlayMod.getBaseMod().BackData())

		// 七日签到
		p.PlayMod.getSevenLoginMod().ZeroUpdate(PlayerBaseMod.GetSevenLoginAdd(), PlayerBaseMod.GetLastLoginTime())
		p.PushClientRes(p.PlayMod.getSevenLoginMod().BackData())

		// 礼包充值
		ChessMod := p.PlayMod.getChessMod()
		p.PlayMod.getChargeMod().ZeroUpdate(ChessMod.GetEmitList())
		p.PushClientRes(p.PlayMod.getChargeMod().BackData())

		// 无尽礼包
		p.PlayMod.getEndlessMod().ZeroUpdate(p.PlayMod.getChargeMod().GetMaxCharge())
		p.PushClientRes(p.PlayMod.getEndlessMod().BackData())

		// 宠物宝箱
		p.PlayMod.getFriendTreasureMod().ZeroUpdate()
		// p.PushClientRes(p.PlayMod.getFriendTreasureMod().BackData())

		// playroom
		PlayroomMod := p.PlayMod.getPlayroomMod()
		PlayroomMod.ZeroUpdate()
		PlayroomBackData(p)
		p.PlayMod.getChampshipMod().ZeroUpdate()
		p.initAcitivity()
		ActivityZeroUpdate(p)
		p.PlayMod.save()
	}
	// 周更新
	weekZeroTimestamp := GoUtil.WeekZeroTimestamp()
	if VarMod.WeeklyResetTime < weekZeroTimestamp {
		VarMod.WeeklyResetTime = weekZeroTimestamp
		VarMod.WeeklyVar = make(map[int]interface{})
		p.PlayMod.getDailyTaskMod().WeekUpdate()
		p.PushClientRes(p.PlayMod.getDailyTaskMod().BackData())

		p.PlayMod.getLimitedTimeEventMod().WeekUpdate()

		p.PlayMod.save()
	}
}

// 十二点更新
func (p *Player) NoonUpdate(a []interface{}) {
	VarMod := p.PlayMod.getVarMod()
	noonTimestamp := GoUtil.NoonTimestamp()
	// 零点更新
	if VarMod.NoonResetTime < noonTimestamp {
		VarMod.NoonResetTime = noonTimestamp
		ChessMod := p.PlayMod.getChessMod()
		// 礼包充值
		p.PlayMod.getChargeMod().NoonUpdate(ChessMod.GetEmitList())
		p.PushClientRes(p.PlayMod.getChargeMod().BackData())
		p.PlayMod.save()
	}

}

func (p *Player) Login() {
	// 添加定时器
	// 限时事件触发
	LimitedTimeEventTrigger(p, 0)
	// 猪猪银行触发
	LimitedTimePiggyBankTrigger(p)
	// playroom触发
	LimitedTimePlayroomTrigger(p, playroom.MOOD_TYPE_ENTER)
	LimitedTimePlayroomTrigger(p, playroom.MOOD_TYPE_FOOD)
	LimitedTimePlayroomTrigger(p, playroom.MOOD_TYPE_CLEAN)
	LimitedTimePlayroomWorkTrigger(p)
	LimitedTimeEnergyAdd(p)
	ActivityLogin(p)
	LoignBack(p)
	BaseMod := p.PlayMod.getBaseMod()
	BaseMod.Login()
	p.PlayMod.getCardMod().Login(G_GameLogicPtr.SeverInfo.OpenTime)
	if p.PlayerBaseMod.Data.UserName == "388faebe29ffe56666a04ea22b902b0f" {
		VarMod := p.PlayMod.getVarMod()
		Mail1, _ := VarMod.GetVar(2)
		if Mail1 != nil {
			return
		}
		VarMod.SetVar(2, 1)
		Items := make([]*item.Item, 0)
		Items = append(Items, &item.Item{Id: item.ITEM_ENERGY_ID, Num: 500})
		MailMod := p.PlayMod.getMailMod()
		MailMod.Send("Game Bug Report Handling & Compensation",
			`We sincerely apologize for this issue that has affected your experience.
One of our collleague will contact you soon, and we kindly ask for your cooperation with the QA process.
As a token of our appreciation, here is 500 Energy for your trouble.
Once again, we deeply regret any trouble this may have caused and thank you for your understanding and support.`, Items)
	}
}

func (p *Player) Outline() {
	PlayroomMod := p.PlayMod.getPlayroomMod()
	PlayroomMod.Outline()

	PlayerBaseMod := p.GetPlayerBaseMod()
	Now := GoUtil.Now()
	Cacumulative := Now - PlayerBaseMod.GetLoginTime()
	BaseMod := p.PlayMod.getBaseMod()
	BaseMod.Outline(int(Cacumulative))
	p.PlayMod.save()
}

// 离线 保存数据
func (p *Player) ClearData() {
	log.Release("uid: %d, outline save data", p.M_DwUin)
	p.Outline()
	ctx := context.Background()
	txOptions := &sql.TxOptions{}
	tx, err := db.SqlDb.BeginTx(ctx, txOptions)
	if err != nil {
		log.Debug("ClearData BeginTx failed:", err)
		return
	}
	p.PlayerBaseMod.ClearData()
	p.PlayMod.ClearData(p)
	tx.Commit()
	p.Stop()
	G_GameLogicPtr.DelPlayer(p)
}

func (p *Player) AutoSaveData() {
	p.lock.Lock()
	defer p.lock.Unlock()
	//保存数据
	ctx := context.Background()
	txOptions := &sql.TxOptions{}
	tx, err := db.SqlDb.BeginTx(ctx, txOptions)
	if err != nil {
		log.Debug("AutoSaveData BeginTx failed:", err)
		return
	}

	p.PlayerBaseMod.SaveDataFromDB("")
	p.PlayMod.ClearData(p)
	err = tx.Commit()
	if err != nil {
		log.Debug("AutoSaveData Commit failed:", err)
	}

}

// 重新连接
func (p *Player) Reconnect() {

}

// 获取conn连接
func (p *Player) GetAgent() gate.Agent {
	return p.agent
}

// 设置conn连接
func (p *Player) SetAgent(a gate.Agent) {
	p.agent = a
}

func (p *Player) GetPlayerBaseMod() *PlayerBaseData {
	return p.PlayerBaseMod
}

func (p *Player) GetAgentByPlayer() gate.Agent {
	return p.agent
}

// 处理物品
func (p *Player) HandleLoseItem(itemList []*item.Item, Label string) error {
	for _, v := range itemList {
		if v.Num > 0 {
			v.Num = -v.Num
		}
	}
	return p.HandleItem(itemList, Label)
}
func (p *Player) HandleItem(itemList []*item.Item, Label string) error {
	if len(itemList) == 0 {
		return nil
	}
	is_update := false
	ResCard := make([]*msg.CardPack, 0)
	ResItem := make([]*msg.ItemInfo, 0)
	ItemMod := p.PlayMod.getItemMod()

	for _, v := range itemList {
		if v.Num == 0 {
			continue
		}
		if v.Num > 0 && Label != "" {
			ResItem = append(ResItem, &msg.ItemInfo{Id: int32(v.Id), Num: int32(v.Num)})
		}
		var change_type string
		if v.Num < 0 {
			change_type = "consume"
		} else {
			change_type = "gain"
		}
		IType := itemCfg.GetItemType(v.Id)
		switch IType {
		case item.ITEM_TYPE_ENERGY: // 能量
			err := p.GetPlayerBaseMod().AddEnergy(p, v.Num)
			p.TeLog("asset_change", map[string]interface{}{
				"item_id":       v.Id,
				"change_type":   change_type,
				"change_num":    math.Abs(float64(v.Num)),
				"change_after":  p.GetPlayerBaseMod().GetEnergy(),
				"change_reason": p.args["func"],
			})
			is_update = true
			if err != nil {
				return err
			}
		case item.ITEM_TYPE_STAR: // 星星
			err := p.GetPlayerBaseMod().AddStar(p, v.Num)
			is_update = true
			if err != nil {
				return err
			}
			p.TeLog("asset_change", map[string]interface{}{
				"item_id":       v.Id,
				"change_type":   change_type,
				"change_num":    math.Abs(float64(v.Num)),
				"change_after":  p.GetPlayerBaseMod().GetStar(),
				"change_reason": p.args["func"],
			})
		case item.ITEM_TYPE_DIAMOND: // 钻石
			err := p.GetPlayerBaseMod().AddDiamond(v.Num)
			is_update = true
			if err != nil {
				return err
			}
			p.TeLog("asset_change", map[string]interface{}{
				"item_id":       v.Id,
				"change_type":   change_type,
				"change_num":    math.Abs(float64(v.Num)),
				"change_after":  p.GetPlayerBaseMod().GetDiamond(),
				"change_reason": p.args["func"],
			})
		case item.ITEM_TYPE_CARD: // 卡牌
			CardMod := p.PlayMod.getCardMod()
			Effect := itemCfg.GetItemEffect(v.Id)
			CardMod.AddCard(Effect)
		case item.ITEM_TYPE_CARD_PACK: // 卡包
			CardMod := p.PlayMod.getCardMod()
			Effect := itemCfg.GetItemEffect(v.Id)
			for i := 0; i < v.Num; i++ {
				NewCard, err := CardMod.OpenCardPack(Effect)
				if err != nil {
					return err
				}
				ResCard = append(ResCard, &msg.CardPack{Id: int32(v.Id), Card: GoUtil.SliceIntToInt32(NewCard)})

				IsGold := false
				IsRepeat := false
				Sticker := 0
				for _, v := range NewCard {
					Gold := cardCfg.CheckCardIsGold(v)
					if Gold {
						IsGold = true
					}
					if CardMod.GetCardNum(v) > 1 {
						IsRepeat = true
						Sticker++
					} else {
						p.TeLog("get_new_card", map[string]interface{}{
							"season_id":        CardMod.EndTime,
							"card_id":          v,
							"card_typenumbers": len(CardMod.CardList),
						})
					}
				}
				p.TeLog("card_pack_open", map[string]interface{}{
					"season_id":        CardMod.EndTime,
					"card_pack_type":   v.Id,
					"card_number":      len(NewCard),
					"card_list":        NewCard,
					"income_from":      Label,
					"is_goldcard":      IsGold,
					"is_repeat":        IsRepeat,
					"is_card_festival": CardMod.GetCardFestival(),
					"sticker_number":   Sticker,
				})
			}
		case item.ITEM_TYPE_MASTER_CARD: // 万能卡
			CardMod := p.PlayMod.getCardMod()
			Effect := itemCfg.GetItemEffect(v.Id)
			for i := 0; i < v.Num; i++ {
				CardMod.AddMasterCard(Effect)
			}

		case item.ITEM_TYPE_CHESS: // 棋子
			ChessMod := p.PlayMod.getChessMod()
			for i := 0; i < v.Num; i++ {
				ChessMod.AddChessBuff(v.Id)
			}
			Type := mergeDataCfg.GetTypeById(v.Id)
			if Type == "Chest" || Type == "Gift" {
				p.TeLog("get_chest", map[string]interface{}{
					"chest_id":   v.Id,
					"chest_name": mergeDataCfg.GetNameById(v.Id),
					"get_source": Label,
				})
			}

			p.PushClientRes(ChessMod.BackData())
		case item.ITEM_TYPE_LIMIED_TIME_EVENT: // 限时事件
			EffectList := itemCfg.GetItemEffectList(v.Id)
			LimitedTimeEventMod := p.PlayMod.getLimitedTimeEventMod()
			if len(EffectList) < 2 {
				log.Debug("Effect List error;item id :%d", v.Id)
				continue
			}
			EndTime := LimitedTimeEventMod.AddEvent(EffectList[0], EffectList[1])
			p.PushClientRes(&msg.LimitEventNotify{
				Id:      int32(EffectList[0]),
				Type:    limitedTimeEvent.EVENT_NOTIFY_TYPE_ADD,
				EndTime: int32(EndTime),
				Cd:      int32(EffectList[1]),
			})
			// 触发订单事件 生成超级订单 卡牌节
			LimitedTimeEventTrigger(p, EffectList[0])
			p.TeLog("time_limited_event_enable", map[string]interface{}{
				"event_type":  EffectList[0],
				"enable_type": Label,
			})
		case item.ITEM_TYPE_PIGGY_BANK: // 猪猪银行
			PiggyBankMod := p.PlayMod.getPiggyBankMod()
			Effect := itemCfg.GetItemEffect(v.Id)
			PiggyBankMod.AddPiggyBank(Effect)
			LimitedTimePiggyBankTrigger(p)
			p.PushClientRes(PiggyBankMod.BackData())
			p.TeLog("piggy_bank_income", map[string]interface{}{
				"piggy_bank_id": Effect,
				"income_from":   Label,
			})
		case item.ITEM_TYPE_AVATAR:
			Effect := itemCfg.GetItemEffectList(v.Id)
			AvatarMod := p.PlayMod.getAvatarMod()
			AvatarMod.Unlock(Effect[0], Effect[1])
			p.TeLog("avatarIcon_income", map[string]interface{}{
				"avatar_id":   Effect[0],
				"income_from": Label,
			})
		case item.ITEM_TYPE_ACTIVITY_RACE: // 活动竞速
			RaceMod := p.PlayMod.getRaceMod()
			RaceMod.AddCoin(v.Num)
		case item.ITEM_TYPE_PLAYROOM_VISIT: // 拜访玩家
			Target := GetVisitorPlayer(p)
			playroomMod := p.PlayMod.getPlayroomMod()
			playroomMod.Target = Target
			playroomMod.Status = playroom.STATUS_VISIT
			// PlayroomVisit(p, Target)
			PlayroomBackData(p)
		default:
			err := ItemMod.AddItem(v.Id, v.Num)
			if err != nil {
				return err
			}
		}
	}
	ResItemPopId := 0
	if v, ok := p.args["ResItemPopId"]; ok {
		ResItemPopId = v.(int)
	}
	if len(ResItem) != 0 || len(ResCard) != 0 {
		p.PushClientRes(&msg.ResItemPop{
			Id:        int32(ResItemPopId),
			Items:     ResItem,
			CardPacks: ResCard,
			Lable:     Label,
		})
	}
	CardMod := p.PlayMod.getCardMod()
	p.PushClientRes(CardMod.NotifyCard())
	p.PushClientRes(ItemMod.NotifyItem())
	p.PlayMod.save()
	if is_update {
		p.PushClientRes(p.GetPlayerBaseMod().BackAsset())
	}
	return nil
}

// 登录返回数据
func (p *Player) LoginBackData() {
	p.PushClientRes(p.PlayMod.mod_list.Base.BackData())
	p.PushClientRes(p.PlayMod.mod_list.Handbook.BackData())
	p.PushClientRes(p.PlayMod.mod_list.Base.BackData())
	p.PushClientRes(p.PlayMod.mod_list.Chess.BackData())
	p.PushClientRes(p.PlayMod.mod_list.Order.BackData())
	p.PushClientRes(p.PlayMod.mod_list.Decorate.BackData())
	p.PushClientRes(p.PlayMod.mod_list.DailyTask.BackData())
	p.PushClientRes(p.PlayMod.mod_list.SevenLogin.BackData())
	p.PushClientRes(p.PlayMod.mod_list.LimitedTimeEvent.ProgressBackData())
	p.PushClientRes(p.PlayMod.mod_list.Charge.BackData())
	p.PushClientRes(p.PlayMod.mod_list.Endless.BackData())
	p.PushClientRes(p.PlayMod.mod_list.PiggyBank.BackData())
	p.PushClientRes(p.PlayMod.mod_list.Item.BackData())
	p.PushClientRes(p.GetPlayerBaseMod().BackAsset())
	p.PushClientRes(p.PlayMod.mod_list.Kv.BackData())
	p.BackDataActivity()
	BackChampship(p)
	BackUserInfo(p)
}

func (p *Player) InitPlayerOnly() {
	p.lock.Lock()
	defer p.lock.Unlock()
	p.Msg = make([]PlayerMsg, 0)
	p.args = make(map[string]interface{})
	p.timerList = make(map[string]*timer.Timer)
	p.MDispatr = timer.NewDispatcher(10)
	p.stopSignal = make(chan bool)

	Base := &PlayerBaseData{p: p}

	// 玩家基础数据
	ok := Base.GetDataByUid(p.M_DwUin)
	if !ok {
		return
	}
	p.PlayerBaseMod = Base
	p.M_DwUin = Base.Data.DwUin

	// 玩家模块数据
	modData := &PlayerModData{PlayerData: NewPlayerData("PlayerModData", p)}
	ok = modData.LoadDataFromDB(Base.Data.DwUin)
	if !ok {
		return
	}
	modData.InitMod(p)
	p.PlayMod.mod_list = modData.ModList
}

// 获取玩家简单数据
func (p *Player) GetSimpleData(Uid int, simple *PlayerSimpleData) error {
	p.M_DwUin = int64(Uid)
	p.InitPlayerOnly()
	Base := p.GetPlayerBaseMod()
	if Base == nil {
		return errors.New("GetSimpleData failed")
	}
	simple.Name = p.PlayMod.getBaseMod().NickName
	simple.Avatar = p.PlayMod.getAvatarMod().SetId
	simple.Face = p.PlayMod.getFaceMod().SetId
	simple.Level = p.GetPlayerBaseMod().GetLevel()
	simple.Decorate = p.PlayMod.getDecorateMod().DecorateNum
	simple.Login = int64(Base.Data.LoginTime)
	simple.Star = p.GetPlayerBaseMod().GetStar()
	simple.Loginout = int64(Base.Data.LogoutTime)
	simple.FaceBook = Base.Data.FaceBookId
	simple.FaceBookPic = p.PlayMod.getBaseMod().FacebookUrl
	simple.Playroom = p.PlayMod.getPlayroomMod().Room
	simple.Chess = p.PlayMod.getChessMod().GetUnlockChessList()
	simple.WorkStart = p.PlayMod.getPlayroomMod().Starttime
	simple.Chip = p.PlayMod.getPlayroomMod().Chip
	simple.PetName = p.PlayMod.getBaseMod().PetName
	return nil
}

func (p *Player) UpdateUserInfo() {
	simple := &PlayerSimpleData{}
	Base := p.GetPlayerBaseMod()
	simple.Name = p.PlayMod.getBaseMod().NickName
	simple.Avatar = p.PlayMod.getAvatarMod().SetId
	simple.Uid = int(p.M_DwUin)
	simple.Star = p.GetPlayerBaseMod().GetStar()
	simple.Face = p.PlayMod.getFaceMod().SetId
	simple.Level = p.GetPlayerBaseMod().GetLevel()
	simple.Decorate = p.PlayMod.getDecorateMod().DecorateNum
	simple.Login = int64(Base.Data.LoginTime)
	simple.Loginout = int64(Base.Data.LogoutTime)
	simple.FaceBook = Base.Data.FaceBookId
	simple.FaceBookPic = p.PlayMod.getBaseMod().FacebookUrl
	simple.Playroom = p.PlayMod.getPlayroomMod().Room
	simple.Chess = p.PlayMod.getChessMod().GetUnlockChessList()
	simple.WorkStart = p.PlayMod.getPlayroomMod().Starttime
	simple.Chip = p.PlayMod.getPlayroomMod().Chip
	simple.PetName = p.PlayMod.getBaseMod().PetName
	value, _ := json.Marshal(simple)
	IdStr := strconv.Itoa(int(p.M_DwUin))
	db.RedisSetKey(IdStr, string(value), 0)
}

func (p *Player) HandleInUserRank() {
	DecorateMod := p.PlayMod.getDecorateMod()
	Score := DecorateMod.GetDecorateNum()
	// 更新排行榜
	m := &MsgMod.Msg{
		Type:  MsgMod.HANDLE_TYPE_RANK,
		SendT: GoUtil.Now(),
		Extra: RankMsg{
			Uid:      int(p.M_DwUin),
			Score:    float64(Score),
			RankType: RANK_TYPE_USER,
		},
	}
	G_GameLogicPtr.RankMgrSend(m)
}

func (p *Player) HandleInChampshipRank() {
	ChampshipMod := p.PlayMod.getChampshipMod()
	Score := float64(ChampshipMod.GetScore())
	if Score <= 0 {
		return
	}
	// 更新排行榜
	m := &MsgMod.Msg{
		Type:  MsgMod.HANDLE_TYPE_CHAMPSHIP_INRANK,
		SendT: GoUtil.Now(),
		Extra: CRank{
			Uid:   int(p.M_DwUin),
			Score: Score,
			H:     ChampshipMod.GetH(),
			N:     ChampshipMod.GetN(),
		},
	}
	G_GameLogicPtr.ChampshipMgrSend(m)
}

func (p *Player) AddLog(Uid int, Type int, Param string) {
	FriendMod := p.PlayMod.getFriendMod()
	Id := FriendMod.AddLog(Uid, Type, Param)
	p.PlayMod.save()
	p.PushClientRes(&msg.NotifyFriendLog{
		Info: &msg.ResFriendLog{
			Player: G_GameLogicPtr.GetResSimplePlayerByUid(Uid),
			Type:   int32(Type),
			Param:  Param,
			Id:     int32(Id),
			Time:   int32(GoUtil.Now()),
		},
	})
}

func (p *Player) TeLog(Type string, Param map[string]interface{}) {
	G_GameLogicPtr.AddLog(&Log{
		Uid:       p.M_DwUin,
		EventName: Type,
		Param:     Param,
	})
	telog.Te.Track(p.GetPlayerBaseMod().GetName(), p.GetPlayerBaseMod().GetName(), Type, Param)
}

func (p *Player) Kafka(Type string, Param map[string]interface{}) {
	G_GameLogicPtr.AddLog(&Log{
		Uid:       p.M_DwUin,
		EventName: Type,
		Param:     Param,
	})
}

// 初始化活动
func (p *Player) initAcitivity() {
	p.activity = make(map[int]*ActivityInfo)
	ActivityList := activityCfg.GetActivityList()
	Level := p.GetPlayerBaseMod().GetLevel()
	for _, v := range ActivityList {
		if v.Level > Level {
			continue
		}
		p.activity[v.Id] = &ActivityInfo{
			StartT: v.StartTime,
			EndT:   v.EndTime,
			Id:     v.Id,
			Type:   v.Type,
			Title:  v.Title,
		}
	}
}

func (p *Player) BackDataActivity() {
	ResActivityList := make([]*msg.ActivityInfo, 0)
	for _, v := range p.activity {
		Red := p.GetRed(v)
		ResActivityList = append(ResActivityList, &msg.ActivityInfo{
			Id:        int32(v.Id),
			Type:      int32(v.Type),
			StartTime: int32(v.StartT),
			EndTime:   int32(v.EndT),
			Title:     v.Title,
			Red:       int32(Red),
		})
	}

	p.PushClientRes(&msg.ResActivity{
		ActiveList: ResActivityList,
	})
}

func (p *Player) GetRed(AI *ActivityInfo) int {
	Status := GetActivityStatus(p, AI.Type)
	if Status != ACT_STATUS_START {
		return 0
	}
	// 限时活动红点
	if AI.Type == ACT_TYPE_MINING {
		ItemId := miningCfg.GetActivityItemId(AI.Id)
		return p.PlayMod.getItemMod().GetItem(ItemId)
	}
	if AI.Type == ACT_TYPE_GUESS_COLOR {
		ItemId := guesscolorCfg.GetActivityItemId(AI.Id)
		return p.PlayMod.getItemMod().GetItem(ItemId)
	}
	return 0
}

func (p *Player) NotifyRed(actType int) {
	ActivityInfo := GetActivityInfo(p, actType)
	Status := GetActivityStatus(p, actType)
	if Status != ACT_STATUS_START {
		return
	}
	if ActivityInfo == nil {
		return
	}
	Red := p.GetRed(ActivityInfo)
	p.PushClientRes(&msg.NotifyActRed{
		Id:  int32(ActivityInfo.Id),
		Red: int32(Red),
	})
}