package clawdoll

import (
	"github.com/zegoim/zego_server_assistant/token/go/src/token04"
	"mongo.games.com/game/common"
	rule "mongo.games.com/game/gamerule/clawdoll"
	"mongo.games.com/game/gamesrv/base"
	"mongo.games.com/game/model"
	"mongo.games.com/game/protocol/clawdoll"
	"mongo.games.com/game/protocol/machine"
	"mongo.games.com/goserver/core/basic"
	"mongo.games.com/goserver/core/logger"
	"mongo.games.com/goserver/core/netlib"
	"mongo.games.com/goserver/core/task"
	"mongo.games.com/goserver/core/timer"
	"strconv"
)

type CSPlayerOpPacketFactory struct {
}

type CSPlayerOpHandler struct {
}

func (f *CSPlayerOpPacketFactory) CreatePacket() interface{} {
	pack := &clawdoll.CSCLAWDOLLOp{}
	return pack
}

func (h *CSPlayerOpHandler) Process(s *netlib.Session, packetid int, data interface{}, sid int64) error {
	logger.Logger.Trace("CSPlayerOpHandler Process recv ", data)
	if msg, ok := data.(*clawdoll.CSCLAWDOLLOp); ok {
		p := base.PlayerMgrSington.GetPlayer(sid)
		if p == nil {
			logger.Logger.Warn("CSPlayerOpHandler p == nil")
			return nil
		}
		scene := p.GetScene()
		if scene == nil {
			logger.Logger.Warn("CSPlayerOpHandler p.scene == nil")
			return nil
		}

		if scene.KeyGameDif != common.GameDifClawdoll {
			logger.Logger.Error("CSPlayerOpHandler gameId Error ", scene.GameId)
			return nil
		}
		if !scene.HasPlayer(p) {
			return nil
		}
		sp := scene.GetScenePolicy()
		if sp != nil {
			sp.OnPlayerOp(scene, p, int(msg.GetOpCode()), msg.GetParams())
		}
		return nil
	}
	return nil
}
func MSDollMachineoCoinResultHandler(session *netlib.Session, packetId int, data interface{}) error {
	logger.Logger.Tracef("收到返回上分结果！！！！！！！！！！")
	if msg, ok := data.(*machine.MSDollMachineoPerateResult); ok {
		p := base.PlayerMgrSington.GetPlayerBySnId(msg.GetSnid())
		if p == nil {
			logger.Logger.Warn("MSDollMachineoCoinResultHandler p == nil")
			return nil
		}

		s := p.GetScene()
		if s == nil {
			logger.Logger.Warn("MSDollMachineoCoinResultHandler p.scene == nil")
			return nil
		}

		sceneEx, ok := s.ExtraData.(*SceneEx)
		if !ok {
			return nil
		}

		playerEx, ok := p.ExtraData.(*PlayerEx)
		if !ok {
			return nil
		}

		switch msg.TypeId {
		case 1:
			logger.Logger.Tracef("ClawDoll OnPlayerOp payCoin response, SnId= %v", p.SnId)
			if msg.Result == 1 {
				logger.Logger.Tracef("上分成功！！！！！！！！！！！！snid = %v", msg.Snid)

				playerEx.CostPlayCoin()

				sceneEx.playingSnid = p.SnId

				//发送向前移动指令
				sceneEx.OnPlayerSMPerateOp(p.SnId, int32(sceneEx.machineId), rule.ButtonBack)

				s.ChangeSceneState(rule.ClawDollSceneStateStart)
				sceneEx.SetPlayingState(int32(rule.ClawDollSceneStateStart))

				ClawdollBroadcastRoomState(s)
				ClawdollSendPlayerInfo(s)

				ClawdollBroadcastPlayingInfo(s)

			} else {
				logger.Logger.Tracef("上分失败！！！！！！！！！！！！snid = %v", msg.Snid)
			}

		case 2:
			if msg.Result == 1 {
				// 获得娃娃卡

				playerEx.IsWin = true
				logger.Logger.Tracef("下抓成功！！！！！！！！！！！！snid = %v", msg.Snid)
			} else {
				logger.Logger.Tracef("下抓失败！！！！！！！！！！！！snid = %v", msg.Snid)

				playerEx.IsWin = false
			}

			playerEx.CatchCardClawdoll()

			logger.Logger.Tracef("ClawDoll StatePlayGame OnPlayerOp Grab response, SnId= %v", msg.Snid)

			s.ChangeSceneState(rule.ClawDollSceneStateBilled)
			sceneEx.SetPlayingState(int32(rule.ClawDollSceneStateBilled))

			ClawdollBroadcastRoomState(s)
			ClawdollSendPlayerInfo(s)

			if sceneEx.grabTimerHandle != timer.TimerHandle(0) {
				timer.StopTimer(sceneEx.grabTimerHandle)
				sceneEx.grabTimerHandle = timer.TimerHandle(0)
			}
		}
	}
	return nil
}

type CSGetTokenPacketFactory struct {
}

type CSGetTokenHandler struct {
}

func (f *CSGetTokenPacketFactory) CreatePacket() interface{} {
	pack := &clawdoll.CSCLAWDOLLGetToken{}
	return pack
}

func (h *CSGetTokenHandler) Process(s *netlib.Session, packetid int, data interface{}, sid int64) error {
	//转发到娃娃机主机
	logger.Logger.Tracef("CSGetTokenHandler")
	if _, ok := data.(*clawdoll.CSCLAWDOLLGetToken); ok {
		p := base.PlayerMgrSington.GetPlayer(sid)
		if p == nil {
			logger.Logger.Warn("CSGetTokenHandler p == nil")
			return nil
		}

		scene := p.GetScene()
		if scene == nil {
			return nil
		}
		sceneEx, ok := scene.ExtraData.(*SceneEx)
		if !ok {
			return nil
		}

		machineId := scene.GetDBGameFree().GetId() % 6080000
		machineInfo := sceneEx.GetMachineServerInfo(machineId, p.Platform)
		if machineInfo == nil {
			logger.Logger.Warn("CSGetTokenHandler machineId = %v not found", machineId)
			return nil
		}

		logger.Logger.Tracef("CSGetTokenHandler appId = %v, serverSecret = %v, streamId = %v,snid = %d", machineInfo.AppId, machineInfo.ServerSecret, machineInfo.StreamId, p.SnId)

		//生成token
		token, err := token04.GenerateToken04(uint32(machineInfo.AppId), strconv.Itoa(int(p.SnId)), machineInfo.ServerSecret, 3600, "")
		if err != nil {
			logger.Logger.Error(err)
			return err
		}
		logger.Logger.Trace("======================token========================", token)

		pack := &clawdoll.SCCLAWDOLLSendToken{
			LogicId:  scene.DBGameFree.GetId(),
			Appid:    machineInfo.AppId,
			Token:    token,
			StreamId: machineInfo.StreamId,
		}
		p.SendToClient(int(clawdoll.CLAWDOLLPacketID_PACKET_SC_SENDTOKEN), pack)
	}
	return nil
}

type CSGetPlayerLogPacketFactory struct {
}

type CSGetPlayerLogHandler struct {
}

func (f *CSGetPlayerLogPacketFactory) CreatePacket() interface{} {
	pack := &clawdoll.CSCLAWDOLLGetPlayerLog{}
	return pack
}

func (h *CSGetPlayerLogHandler) Process(s *netlib.Session, packetid int, data interface{}, sid int64) error {
	//转发到娃娃机主机
	logger.Logger.Tracef("CSGetPlayerLogHandler")
	if msg, ok := data.(*clawdoll.CSCLAWDOLLGetPlayerLog); ok {
		p := base.PlayerMgrSington.GetPlayer(sid)
		if p == nil {
			logger.Logger.Warn("CSGetPlayerLogHandler p == nil")
			return nil
		}

		scene := p.GetScene()
		if scene == nil {
			return nil
		}
		sceneEx, ok := scene.ExtraData.(*SceneEx)
		if !ok {
			return nil
		}

		machineId := scene.GetDBGameFree().GetId() % 6080000
		machineInfo := sceneEx.GetMachineServerInfo(machineId, p.Platform)
		if machineInfo == nil {
			logger.Logger.Warn("CSGetPlayerLogHandler machineId = %v not found", machineId)
			return nil
		}

		logger.Logger.Tracef("CSGetPlayerLogHandler appId = %v, serverSecret = %v, streamId = %v,snid = %d", machineInfo.AppId, machineInfo.ServerSecret, machineInfo.StreamId, p.SnId)

		ret := &clawdoll.SCCLAWDOLLSendPlayerLog{}
		ret.Type = msg.GetType()

		var err error
		var ItemLogs []model.ClawdollSuccessItemLog

		//娃娃机道具使用日志
		task.New(nil, task.CallableWrapper(func(o *basic.Object) interface{} {
			ItemLogs, err = model.GetClawdollSuccessItemLog(p.Platform, p.SnId)
			return err
		}), task.CompleteNotifyWrapper(func(data interface{}, t task.Task) {
			for _, logData := range ItemLogs {
				infoData := &clawdoll.ClawdollSuccessItemLog{}

				infoData.SnId = logData.SnId
				infoData.Name = logData.Name
				infoData.ModId = logData.ModId
				infoData.Time = logData.Time

				ret.ItemLogs = append(ret.ItemLogs, infoData)
			}

			p.SendToClient(int(clawdoll.CLAWDOLLPacketID_PACKET_SC_SENDPLAYERLOG), ret)
			logger.Logger.Tracef("CSGetPlayerLogHandler:%v", ret)
		}), "GetPlayerLogHandler").Start()
	}

	return nil
}

func init() {
	common.RegisterHandler(int(clawdoll.CLAWDOLLPacketID_PACKET_CS_PLAYEROP), &CSPlayerOpHandler{})
	netlib.RegisterFactory(int(clawdoll.CLAWDOLLPacketID_PACKET_CS_PLAYEROP), &CSPlayerOpPacketFactory{})
	netlib.Register(int(machine.DollMachinePacketID_PACKET_MSDollMachineoPerateResult), &machine.MSDollMachineoPerateResult{}, MSDollMachineoCoinResultHandler)
	//客户端请求token
	common.RegisterHandler(int(clawdoll.CLAWDOLLPacketID_PACKET_CS_GETTOKEN), &CSGetTokenHandler{})
	netlib.RegisterFactory(int(clawdoll.CLAWDOLLPacketID_PACKET_CS_GETTOKEN), &CSGetTokenPacketFactory{})

	common.RegisterHandler(int(clawdoll.CLAWDOLLPacketID_PACKET_CS_GETPLAYERLOG), &CSGetPlayerLogHandler{})
	netlib.RegisterFactory(int(clawdoll.CLAWDOLLPacketID_PACKET_CS_GETPLAYERLOG), &CSGetPlayerLogPacketFactory{})

}