package game

import (
	"bytes"
	"encoding/gob"
	"fmt"
	"server/db"
	"server/game/mod/avatar"
	"server/game/mod/base"
	"server/game/mod/card"
	"server/game/mod/champship"
	"server/game/mod/charge"
	"server/game/mod/chess"
	"server/game/mod/dailyTask"
	"server/game/mod/decorate"
	"server/game/mod/endless"
	"server/game/mod/face"
	"server/game/mod/friend"
	"server/game/mod/friendTreasure.go"
	guesscolor "server/game/mod/guessColor"
	"server/game/mod/guild"
	"server/game/mod/handbook"
	"server/game/mod/invite"
	"server/game/mod/item"
	"server/game/mod/kv"
	"server/game/mod/limitedTimeEvent"
	"server/game/mod/mail"
	"server/game/mod/mining"
	"server/game/mod/order"
	"server/game/mod/piggyBank"
	"server/game/mod/playroom"
	"server/game/mod/race"
	"server/game/mod/sevenLogin"
	Var "server/game/mod/var"
	"server/pkg/github.com/name5566/leaf/log"
	"time"
)

type PlayerModData struct {
	*PlayerData
	Data    db.SqlModStruct
	ModList PlayerModList
}

// PlayerModList 玩家模块列表
type PlayerModList struct {
	Base             base.Base                            // 基础信息
	Chess            chess.ChessBorad                     // 棋盘
	Handbook         handbook.Handbook                    // 图鉴
	Order            order.OrderMod                       //订单
	Decorate         decorate.Decorate                    //装饰
	Card             card.CardMod                         //卡牌
	Var              Var.Var                              // 变量
	Guild            guild.Guild                          // 引导
	DailyTask        dailyTask.DailyTaskMod               // 每日任务
	Face             face.FaceMod                         // 头像
	Avatar           avatar.AvatarMod                     // 头像框
	SevenLogin       sevenLogin.SevenLoginMod             // 七天签到
	LimitedTimeEvent limitedTimeEvent.LimitedTimeEventMod // 限时事件
	Friend           friend.FriendMod                     // 好友
	Mail             mail.MailMod                         // 邮件
	Charge           charge.ChargeMod                     // 商店充值
	Endless          endless.EndlessMod                   // 无尽礼包
	PiggyBank        piggyBank.PiggyBankMod               // 小猪存钱
	Champship        champship.ChampshipMod               // 锦标赛
	Invite           invite.InviteMod                     // 邀请
	Kv               kv.KvMod                             //  客户端数据
	Mining           mining.MiningMod                     // 挖矿活动
	Item             item.ItemMod                         // 道具
	GuessColor       guesscolor.GuessColorMod             // 猜颜色活动
	Race             race.RaceMod                         // 竞赛活动
	Playroom         playroom.PlayroomMod                 // 玩家小屋
	FriendTreasure   friendTreasure.FriendTreasureMod     // 好友宝藏
}

func (p *PlayerModData) LoadDataFromDB(dwUin interface{}) bool {
	sqlStr := "SELECT * FROM t_player_mod WHERE dwUin = ?"
	p.Data = db.SqlModStruct{}
	if err := db.SqlDb.Get(&p.Data, sqlStr, dwUin.(int64)); err != nil {

		p.IsHaveDataDb = false
	} else {
		p.IsHaveDataDb = true
	}
	p.Data.DwUin = dwUin.(int64)
	return true
}

func (p *PlayerModData) ClearData() bool {
	return true
}

func (p *PlayerModData) SaveDataFromDB(Key interface{}) bool {
	//序列化数据
	db.FormatAllMemUpdateDb(&p.Data, "t_player_mod", "dwUin")
	p.IsHaveDataDb = true
	return true
}

func (p *PlayerModData) ReqModData(buf []byte) {

}

// 推送基础数据
func (p *PlayerModData) Reconnect(b bool) []byte {

	return []byte{}
}

func (p *PlayerModData) InitMod(player *Player) (bool, error) {
	playerModList := PlayerModList{}
	if len(p.Data.ModData) > 0 {
		buf := bytes.NewBuffer(p.Data.ModData)
		decoder := gob.NewDecoder(buf)
		err := decoder.Decode(&playerModList)
		if err != nil {
			log.Debug("playmod get data failed, err:%v\n", err)
			return false, fmt.Errorf("playmod get data failed, err:%v", err)
		}
	}
	p.ModList = playerModList
	is_update := false

	// 初始化棋盘模块

	if p.ModList.Chess.IsEmpty() {
		var chessMod chess.ChessBorad
		chessMod.InitData()
		p.ModList.Chess = chessMod
		is_update = true
	}
	BaseMod := p.ModList.Base
	if BaseMod.Uid == 0 {
		PlayerBaseMod := player.GetPlayerBaseMod()
		BaseMod.Uid = PlayerBaseMod.Data.DwUin
		BaseMod.SetAccount(PlayerBaseMod.Data.UserName)
		BaseMod.SetLevel(int(PlayerBaseMod.Data.Level))
		BaseMod.SetExp(int(PlayerBaseMod.Data.Exp))
		BaseMod.SetEnergy(int(PlayerBaseMod.Data.Energy))
		BaseMod.SetStar(int(PlayerBaseMod.Data.Star))
		BaseMod.SetDiamond(int(PlayerBaseMod.Data.Diamond))
		BaseMod.SetRecoverTime(int64(PlayerBaseMod.Data.RecoverTime))
		BaseMod.FackBookId = PlayerBaseMod.Data.FaceBookId
		BaseMod.SetLoginTime(int64(PlayerBaseMod.Data.LoginTime))
		BaseMod.SetLogoutTime(int64(PlayerBaseMod.Data.LogoutTime))
		p.ModList.Base = BaseMod
		is_update = true
	}

	p.ModList.Handbook.InitData()
	p.ModList.Order.InitData()
	p.ModList.Decorate.InitData()
	p.ModList.Card.InitData()
	p.ModList.Var.InitData()
	p.ModList.Guild.InitData()
	p.ModList.DailyTask.InitData()
	p.ModList.Face.InitData()
	p.ModList.Avatar.InitData()
	p.ModList.Base.InitData(int(p.Data.DwUin))
	p.ModList.SevenLogin.InitData()
	p.ModList.LimitedTimeEvent.InitData()
	p.ModList.Friend.InitData()
	p.ModList.Mail.InitData()
	p.ModList.Charge.InitData()
	p.ModList.Endless.InitData()
	p.ModList.Invite.InitData()
	p.ModList.Kv.InitData()
	p.ModList.Mining.InitData()
	p.ModList.Item.InitData()
	p.ModList.GuessColor.InitData()
	p.ModList.Playroom.InitData()

	return is_update, nil
}

type PlayerMod struct {
	mod_list  PlayerModList
	is_update bool
}

func (p *PlayerMod) save() {
	p.is_update = true
}

func (p *PlayerMod) ClearData(player *Player) {
	ChessMod := p.getChessMod()
	if len(ChessMod.ChessMap) > 0 && len(ChessMod.ChessList) != len(ChessMod.ChessMap) {
		log.Debug("uid: %d, SaveData, chess error ", player.M_DwUin)
		return
	}
	if p.is_update {
		//序列化模块
		var buf bytes.Buffer
		encode := gob.NewEncoder(&buf)
		err := encode.Encode(p.mod_list)
		if err != nil {
			log.Debug("uid: %d, SaveData, playmod error %v", player.M_DwUin, err)
			return
		}
		// log.Debug("uid: %d, ClearData, playmod", player.M_DwUin)
		modData := &db.SqlModStruct{
			DwUin:      player.M_DwUin,
			ModData:    buf.Bytes(),
			UpdataTime: int32(time.Now().Unix()),
		}

		err = db.SavePlayerModData(modData)
		if err != nil {
			log.Debug("uid: %d, SaveData, playmod error %v", player.M_DwUin, err)
			return
		}
		p.is_update = false
	}
}

func (p *PlayerMod) BackUp(B *PlayerBackUp) {
	var buf bytes.Buffer
	encode := gob.NewEncoder(&buf)
	err := encode.Encode(p.mod_list)
	if err != nil {
		log.Debug("Backup, playmod error %v", err)
		return
	}
	B.PlayMod = buf.Bytes()
}

func (p *PlayerMod) Recover(B *PlayerBackUp) {
	if len(B.PlayMod) > 0 {
		PlayMod := PlayerModList{}
		buf := bytes.NewBuffer(B.PlayMod)
		decoder := gob.NewDecoder(buf)
		err := decoder.Decode(&PlayMod)
		if err != nil {
			log.Debug("Recover, playmod error %v", err)
			return
		}
		p.mod_list = PlayMod
	}
}

func (p *PlayerMod) getChessMod() *chess.ChessBorad {
	return &p.mod_list.Chess
}

func (p *PlayerMod) getBaseMod() *base.Base {
	return &p.mod_list.Base
}

func (p *PlayerMod) getHandbookMod() *handbook.Handbook {
	return &p.mod_list.Handbook
}

func (p *PlayerMod) getOrderMod() *order.OrderMod {
	return &p.mod_list.Order
}

func (p *PlayerMod) getDecorateMod() *decorate.Decorate {
	return &p.mod_list.Decorate
}

func (p *PlayerMod) getCardMod() *card.CardMod {
	return &p.mod_list.Card
}

func (p *PlayerMod) getVarMod() *Var.Var {
	return &p.mod_list.Var
}

func (p *PlayerMod) getGuildMod() *guild.Guild {
	return &p.mod_list.Guild
}

func (p *PlayerMod) getDailyTaskMod() *dailyTask.DailyTaskMod {
	return &p.mod_list.DailyTask
}

func (p *PlayerMod) getFaceMod() *face.FaceMod {
	return &p.mod_list.Face
}

func (p *PlayerMod) getAvatarMod() *avatar.AvatarMod {
	return &p.mod_list.Avatar
}

func (p *PlayerMod) getSevenLoginMod() *sevenLogin.SevenLoginMod {
	return &p.mod_list.SevenLogin
}

func (p *PlayerMod) getLimitedTimeEventMod() *limitedTimeEvent.LimitedTimeEventMod {
	return &p.mod_list.LimitedTimeEvent
}

func (p *PlayerMod) getFriendMod() *friend.FriendMod {
	return &p.mod_list.Friend
}

func (p *PlayerMod) getMailMod() *mail.MailMod {
	return &p.mod_list.Mail
}

func (p *PlayerMod) getChargeMod() *charge.ChargeMod {
	return &p.mod_list.Charge
}

func (p *PlayerMod) getEndlessMod() *endless.EndlessMod {
	return &p.mod_list.Endless
}

func (p *PlayerMod) getPiggyBankMod() *piggyBank.PiggyBankMod {
	return &p.mod_list.PiggyBank
}

func (p *PlayerMod) getChampshipMod() *champship.ChampshipMod {
	return &p.mod_list.Champship
}

func (p *PlayerMod) getInviteMod() *invite.InviteMod {
	return &p.mod_list.Invite
}

func (p *PlayerMod) getKvMod() *kv.KvMod {
	return &p.mod_list.Kv
}

func (p *PlayerMod) getMiningMod() *mining.MiningMod {
	return &p.mod_list.Mining
}

func (p *PlayerMod) getItemMod() *item.ItemMod {
	return &p.mod_list.Item
}

func (p *PlayerMod) getGuessColorMod() *guesscolor.GuessColorMod {
	return &p.mod_list.GuessColor
}

func (p *PlayerMod) getRaceMod() *race.RaceMod {
	return &p.mod_list.Race
}

func (p *PlayerMod) getPlayroomMod() *playroom.PlayroomMod {
	return &p.mod_list.Playroom
}

func (p *PlayerMod) getFriendTreasureMod() *friendTreasure.FriendTreasureMod {
	return &p.mod_list.FriendTreasure
}