package game

import (
	"encoding/json"
	"fmt"
	"runtime"
	"server/GoUtil"
	"server/MergeConst"
	"server/conf"
	"server/db"
	Msg "server/game/mod/msg"
	"server/gamedata"
	"server/msg"
	"server/pkg/github.com/name5566/leaf/gate"
	"server/pkg/github.com/name5566/leaf/log"
	"time"

	"github.com/shirou/gopsutil/cpu"
	"github.com/shirou/gopsutil/mem"
	"google.golang.org/protobuf/proto"
)

var AdminFuncMap = map[string]func([]interface{}) error{
	"ReqAdminInfo":        AdminPlayerInfo,
	"ReqServerInfo":       ReqServerInfo,
	"ReqReloadServerMail": ReqReloadServerMail,
	"ReqReload":           ReqReload,
	"ReqAdminGm":          ReqAdminGm,
	"ReqAdminBan":         ReqAdminBan,
}

func AdminProcess(Func string, args []interface{}) {
	defer func() {
		if r := recover(); r != nil {
			GoUtil.SendFeishuFatal(0, Func, fmt.Sprintf("fatal : %s", r))
		}
	}()
	if f, ok := AdminFuncMap[Func]; ok {
		err := f(args)
		if err != nil {
			log.Debug("AdminProcess error: %v", err)
		}
		return
	}
	log.Debug("AdminProcess error: %v", "Func not found")
}

func VerifyUser(accountInfo *db.Db_Account, detail *msg.ReqLogin) (ResLogin *msg.ResLogin) {
	if detail.Type == msg.LOGIN_TYPE_CODE_LOGIN {
		err := VerifyCode(detail.UserName, detail.Code)
		if err != nil {
			ResLogin = &msg.ResLogin{
				ResultCode: MergeConst.Protocol_Error_Account_Code_Error,
				DwUin:      0,
			}
			return
		}
	}
	if accountInfo == nil {
		ResLogin = &msg.ResLogin{
			ResultCode: MergeConst.Protocol_Error_Account_NoExsit,
			DwUin:      0,
		}
		return
	}
	if detail.Type == msg.LOGIN_TYPE_ACCOUNT_LOGIN && accountInfo.UserPassword != detail.UserPwd {
		ResLogin = &msg.ResLogin{
			ResultCode: MergeConst.Protocol_Error_Account_OR_PWD_ERROR,
			DwUin:      0,
		}
		return
	}
	if detail.Type == msg.LOGIN_TYPE_DEVICE_LOGIN {
		if detail.Device != accountInfo.DeviceId {
			ResLogin = &msg.ResLogin{
				ResultCode: MergeConst.Protocol_Error_Account_Device_Error,
				DwUin:      0,
			}
			return
		}
	}
	playerbaseinfo := db.GetPlayerBaseInfoFromDbByName(detail.UserName)
	if playerbaseinfo == nil {
		ResLogin = &msg.ResLogin{
			ResultCode: MergeConst.Protocol_Error_Account_NoExsit,
			DwUin:      0,
		}
		return
	}

	if G_GameLogicPtr.BanMgr.IsBanned(playerbaseinfo.DwUin) {
		ResLogin = &msg.ResLogin{
			ResultCode: MergeConst.Protocol_Error_Account_Ban,
			DwUin:      0,
		}
		return
	}

	ResLogin = &msg.ResLogin{
		ResultCode: 0,
		DwUin:      playerbaseinfo.DwUin,
		FaceBookId: playerbaseinfo.FaceBookId,
		UserName:   playerbaseinfo.UserName,
	}
	return
}

func AdminPlayerInfo(args []interface{}) error {
	a, buf := ParseAdminArgs(args)
	req := &msg.ReqAdminInfo{}
	proto.Unmarshal(buf, req)
	player := G_GameLogicPtr.GetPlayer(req.Uid)
	online := true
	if player == nil {
		player = new(Player)
		player.M_DwUin = req.Uid
		player.InitPlayerOnly()
		player.ZeroUpdate(nil)
		online = false
	}
	res := make(map[string]interface{})
	res["Name"] = player.PlayMod.getBaseMod().NickName
	res["Uid"] = player.M_DwUin
	res["AreaId"] = player.PlayMod.getDecorateMod().GetAreaId()
	res["Charge"] = player.PlayMod.getChargeMod().Charge
	res["Level"] = player.GetPlayerBaseMod().GetLevel()
	res["Diamond"] = player.GetPlayerBaseMod().GetDiamond()
	res["Star"] = player.GetPlayerBaseMod().GetStar()
	res["Energy"] = player.GetPlayerBaseMod().GetEnergy()
	res["Diamond"] = player.GetPlayerBaseMod().GetDiamond()
	res["Mac"] = player.GetPlayerBaseMod().GetName()
	res["Login"] = player.PlayMod.getBaseMod().LoginTime
	res["Cumulative"] = player.PlayMod.getBaseMod().Cumulative
	res["RegisterTime"] = player.GetPlayerBaseMod().GetRegisterTime()
	res["TodayCumulative"] = player.PlayMod.getBaseMod().TodayCumulative
	res["Ban"] = G_GameLogicPtr.BanMgr.GetBanInfo(player.M_DwUin).EndTime
	if online {
		res["Cumulative"] = int64(player.PlayMod.getBaseMod().Cumulative) + GoUtil.Now() - int64(player.PlayMod.getBaseMod().LoginTime)
		res["TodayCumulative"] = int64(player.PlayMod.getBaseMod().TodayCumulative) + GoUtil.Now() - int64(player.PlayMod.getBaseMod().LoginTime)
	}
	res["Bonus"] = player.PlayMod.getLimitedTimeEventMod().Progress
	res["Code"] = player.PlayMod.getBaseMod().AddCode
	OrderMap := make(map[int]interface{})
	Index := 0
	for k, v := range player.PlayMod.getOrderMod().OrderList {
		OrderMap[Index] = map[string]interface{}{
			"Id":      k,
			"Type":    v.Type,
			"Time":    v.Timestamp,
			"ChessId": GoUtil.IntSliceToString(v.MergeId),
			"Diff":    v.Diff,
		}
		Index++
	}
	res["Order"] = OrderMap
	AdminPlayerBack(a, res)
	return nil
}

func AdminPlayerBack(a gate.Agent, res map[string]interface{}) {
	JsonBuff, _ := json.Marshal(res)
	response := &msg.AdminRes{}
	response.Func = "admin"
	response.Info = JsonBuff
	a.WriteMsg(response)
}

func ReqServerInfo(args []interface{}) error {
	a, _ := ParseAdminArgs(args)
	res := make(map[string]interface{})
	res["PlayerNum"] = G_GameLogicPtr.GetPlayerNum()
	res["StartTime"] = G_GameLogicPtr.GetStartTime()
	var m runtime.MemStats
	runtime.ReadMemStats(&m)
	res["TotalAlloc"] = fmt.Sprintf("%dM", m.TotalAlloc/(1024*1024))
	// 2. 获取系统内存使用信息
	vmStat, err := mem.VirtualMemory()
	if err == nil {
		res["Sys"] = fmt.Sprintf("%.2f%%", vmStat.UsedPercent)
	}
	// 3. 获取 CPU 使用率（一秒内采样）
	cpuPercent, err := cpu.Percent(time.Second, false)
	if err == nil && len(cpuPercent) > 0 {
		res["CPU"] = fmt.Sprintf("%.2f%%", cpuPercent[0])
	}
	res["Version"] = conf.Server.Version
	AdminPlayerBack(a, res)
	return nil
}

func ReqReloadServerMail(args []interface{}) error {
	G_GameLogicPtr.MailMgrCall(&Msg.Msg{Type: Msg.HANDLE_TYPE_MAIL_RELOAD})
	G_GameLogicPtr.NotifyAll(&Msg.Msg{Type: Msg.HANDLE_TYPE_MAIL})
	log.Debug("ReqReloadServerMail success")
	return nil
}

func ReqReload(args []interface{}) error {
	a, _ := ParseAdminArgs(args)
	gamedata.Reload()
	res := make(map[string]interface{})
	res["Code"] = 0
	AdminPlayerBack(a, res)
	return nil
}

func ReqAdminGm(args []interface{}) error {
	a, buf := ParseAdminArgs(args)
	req := &msg.ReqAdminGm{}
	proto.Unmarshal(buf, req)
	res := make(map[string]interface{})
	res["Code"] = 0
	res["Msg"] = "ok"
	player := G_GameLogicPtr.GetPlayer(req.Uid)
	if player == nil {
		res["Code"] = 1
		res["Msg"] = "player not found"
		AdminPlayerBack(a, res)
		return nil
	}
	player.lock.Lock()
	defer player.lock.Unlock()
	err := ReqGmCommand_(player, req.Command)
	if err != nil {
		res["Code"] = 1
		res["Msg"] = err.Error()
		AdminPlayerBack(a, res)
		return err
	}
	AdminPlayerBack(a, res)
	return nil
}

func ReqAdminBan(args []interface{}) error {
	a, buf := ParseAdminArgs(args)
	req := &msg.ReqAdminBan{}
	proto.Unmarshal(buf, req)
	res := make(map[string]interface{})
	res["Code"] = 0
	res["Msg"] = "ok"
	G_GameLogicPtr.BanMgr.BanUser(req.Uid, int64(req.Time), req.Reason)
	AdminPlayerBack(a, res)
	return nil
}