package clawdoll

import (
	"github.com/zegoim/zego_server_assistant/token/go/src/token04"
	"mongo.games.com/game/gamesrv/action"
	"mongo.games.com/game/model"
	"mongo.games.com/game/protocol/clawdoll"
	"strconv"
	"time"

	"mongo.games.com/goserver/core"
	"mongo.games.com/goserver/core/logger"

	"mongo.games.com/game/common"
	rule "mongo.games.com/game/gamerule/clawdoll"
	"mongo.games.com/game/gamesrv/base"
	"mongo.games.com/game/proto"
)

var PolicyClawdollSingleton = &PolicyClawdoll{}

type PolicyClawdoll struct {
	base.BaseScenePolicy
	states [rule.ClawDollSceneStateMax]base.SceneState
}

func (this *PolicyClawdoll) CreateSceneExData(s *base.Scene) interface{} {
	sceneEx := NewClawdollSceneData(s)
	if sceneEx != nil {
		if sceneEx.init() {
			s.ExtraData = sceneEx
		}
	}
	return sceneEx
}

func (this *PolicyClawdoll) CreatePlayerExData(s *base.Scene, p *base.Player) interface{} {
	playerEx := &PlayerEx{Player: p}
	if playerEx != nil {
		p.ExtraData = playerEx
	}
	return playerEx
}

func (this *PolicyClawdoll) OnStart(s *base.Scene) {
	logger.Logger.Trace("(this *PolicyClawdoll) OnStart, sceneId=", s.GetSceneId())

	sceneEx := NewClawdollSceneData(s)
	if sceneEx != nil {
		if sceneEx.init() {
			s.ExtraData = sceneEx
			s.ChangeSceneState(rule.ClawDollSceneStateWait)
		}
	}
}

func (this *PolicyClawdoll) OnStop(s *base.Scene) {
	logger.Logger.Trace("(this *PolicyClawdoll) OnStop , sceneId=", s.GetSceneId())
}

func (this *PolicyClawdoll) OnTick(s *base.Scene) {
	if s == nil {
		return
	}
	if s.SceneState != nil {
		s.SceneState.OnTick(s)
	}

	sceneEx, ok := s.ExtraData.(*SceneEx)
	if ok {
		if sceneEx.machineId == 0 {
			machineId := s.DBGameFree.GetId() % 6080000
			sceneEx.machineId = action.GetFreeDollMachineId(machineId)
		}
		if sceneEx.machineId != 0 {
			machineStatus := action.GetDollMachineStatus(sceneEx.machineId)
			if machineStatus == 0 {
				//链接状态不可用  踢出所有玩家
				for _, p := range sceneEx.players {
					sceneEx.PlayerLeave(p.Player, common.PlayerLeaveReason_RoomClose, false)
				}
				sceneEx.machineStatus = 0
				logger.Logger.Trace("娃娃机离线，当前场景暂停服务！")
				//通知客户单房间不可用
			} else {
				if sceneEx.machineStatus == 0 {
					sceneEx.machineStatus = machineStatus
					//通知客户端房间可用
				}
			}
		}
	}

}

func (this *PolicyClawdoll) OnPlayerEnter(s *base.Scene, p *base.Player) {
	if s == nil || p == nil {
		return
	}
	logger.Logger.Trace("(this *PolicyClawdoll) OnPlayerEnter, sceneId=", s.GetSceneId(), " player=", p.SnId)
	if sceneEx, ok := s.ExtraData.(*SceneEx); ok {
		playerEx := &PlayerEx{Player: p}
		sceneEx.players[p.SnId] = playerEx
		baseScore := sceneEx.GetBaseScore()
		p.ExtraData = playerEx
		playerEx.Clear(baseScore)
		//playerEx.clawDollState = rule.ClawDollPlayerAudience

		p.MarkFlag(base.PlayerState_WaitNext)
		p.UnmarkFlag(base.PlayerState_Ready)

		//给自己发送房间信息
		this.SendRoomInfo(s, p, sceneEx)

		ClawdollSendRoomWaitPlayers(s, p)
		ClawdollBroadcastPlayingInfo(s)

		// 玩家数据发送
		sceneEx.OnPlayerEnter(p, 0)

		this.SendGetVideoToken(s, p, sceneEx)
		s.FirePlayerEvent(p, base.PlayerEventEnter, nil)
	}
}

func (this *PolicyClawdoll) OnPlayerLeave(s *base.Scene, p *base.Player, reason int) {
	logger.Logger.Trace("(this *PolicyClawdoll) OnPlayerLeave, sceneId=", s.GetSceneId(), " player=", p.SnId)
	if s == nil || p == nil {
		return
	}
	if !this.CanChangeCoinScene(s, p) {
		return
	}

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

	isBilled := false

	// 游戏已开始，玩家离开，备份玩家数据
	if sceneEx.Gaming {
		sceneEx.BackupPlayer(playerEx, isBilled)
	}

	// 清理玩家数据
	sceneEx.OnPlayerLeave(p, reason)
	s.FirePlayerEvent(p, base.PlayerEventLeave, nil)
}

func (this *PolicyClawdoll) OnPlayerDropLine(s *base.Scene, p *base.Player) {
	if s == nil || p == nil {
		return
	}
	logger.Logger.Trace("(this *PolicyClawdoll) OnPlayerDropLine, sceneId=", s.GetSceneId(), " player=", p.SnId)
	s.FirePlayerEvent(p, base.PlayerEventDropLine, nil)
}

func (this *PolicyClawdoll) OnPlayerRehold(s *base.Scene, p *base.Player) {
	if s == nil || p == nil {
		return
	}
	logger.Logger.Trace("(this *PolicyClawdoll) OnPlayerRehold, sceneId=", s.GetSceneId(), " player=", p.SnId)
	if sceneEx, ok := s.ExtraData.(*SceneEx); ok {
		if _, ok := p.ExtraData.(*PlayerEx); ok {
			//发送房间信息给自己
			if p.IsGameing() {
				p.MarkFlag(base.PlayerState_Ready)
			}
			this.SendRoomInfo(s, p, sceneEx)
			ClawdollSendRoomWaitPlayers(s, p)
			ClawdollBroadcastPlayingInfo(s)

			this.SendGetVideoToken(s, p, sceneEx)
			s.FirePlayerEvent(p, base.PlayerEventRehold, nil)
		}
	}
}

func (this *PolicyClawdoll) OnPlayerReturn(s *base.Scene, p *base.Player) {
	if s == nil || p == nil {
		return
	}
	logger.Logger.Trace("(this *PolicyClawdoll) OnPlayerRehold, sceneId=", s.GetSceneId(), " player=", p.SnId)
	if sceneEx, ok := s.ExtraData.(*SceneEx); ok {
		if _, ok := p.ExtraData.(*PlayerEx); ok {
			//发送房间信息给自己
			if p.IsGameing() {
				p.MarkFlag(base.PlayerState_Ready)
			}
			this.SendRoomInfo(s, p, sceneEx)
			ClawdollSendRoomWaitPlayers(s, p)
			ClawdollBroadcastPlayingInfo(s)

			this.SendGetVideoToken(s, p, sceneEx)
			s.FirePlayerEvent(p, base.PlayerEventReturn, nil)
		}
	}
}

func (this *PolicyClawdoll) OnPlayerOp(s *base.Scene, p *base.Player, opcode int, params []int64) bool {
	if s == nil || p == nil {
		return false
	}
	logger.Logger.Trace("(this *PolicyClawdoll) OnPlayerOp, sceneId=", s.GetSceneId(), " player=", p.SnId, " opcode=", opcode, " params=", params)
	if s.SceneState != nil {
		p.LastOPTimer = time.Now()
		p.Trusteeship = 0
		return s.SceneState.OnPlayerOp(s, p, opcode, params)
	}
	return true
}

func (this *PolicyClawdoll) OnPlayerEvent(s *base.Scene, p *base.Player, evtcode int, params []int64) {
	if s == nil || p == nil {
		return
	}
	logger.Logger.Trace("(this *PolicyClawdoll) OnPlayerEvent, sceneId=", s.GetSceneId(), " player=", p.SnId, " eventcode=", evtcode, " params=", params)
	if s.SceneState != nil {
		s.SceneState.OnPlayerEvent(s, p, evtcode, params)
	}
}

func (this *PolicyClawdoll) IsCompleted(s *base.Scene) bool {
	if s == nil {
		return false
	}
	if sceneEx, ok := s.ExtraData.(*SceneEx); ok {
		return !sceneEx.Gaming
	}
	return false
}

func (this *PolicyClawdoll) IsCanForceStart(s *base.Scene) bool {
	return false
}

func (this *PolicyClawdoll) ForceStart(s *base.Scene) {
	if sceneEx, ok := s.ExtraData.(*SceneEx); ok {
		if sceneEx.SceneState.GetState() == rule.ClawDollSceneStateWait {
			s.ChangeSceneState(rule.ClawDollSceneStateStart)
		}
	}
}

// 当前状态能否退出游戏
func (this *PolicyClawdoll) CanChangeCoinScene(s *base.Scene, p *base.Player) bool {
	if s == nil || p == nil {
		return false
	}
	if s.GetSceneState() != nil {
		return s.GetSceneState().CanChangeCoinScene(s, p)
	}

	return true
}

func (this *PolicyClawdoll) SendRoomInfo(s *base.Scene, p *base.Player, sceneEx *SceneEx) {
	if s == nil || p == nil || sceneEx == nil {
		return
	}

	pack := sceneEx.ClawdollCreateRoomInfoPacket(s, p)

	p.SendToClient(int(clawdoll.CLAWDOLLPacketID_PACKET_SC_ROOMINFO), pack)
}

func (this *PolicyClawdoll) SendGetVideoToken(s *base.Scene, p *base.Player, sceneEx *SceneEx) {
	//转发到娃娃机主机
	if s == nil || p == nil || sceneEx == nil {
		return
	}
	logger.Logger.Tracef("ClawdollGetVideoToken")
	if p == nil {
		logger.Logger.Warn("ClawdollGetVideoToken p == nil")
		return
	}

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

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

	logger.Logger.Tracef("获取娃娃机 appId = %v, serverSecret = %v, streamId = %v, token = %v", machineinfo.AppId, machineinfo.ServerSecret, machineinfo.StreamId, token)

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

// 广播房间状态
func ClawdollBroadcastRoomState(s *base.Scene, params ...float32) {
	pack := &clawdoll.SCCLAWDOLLRoomState{
		State:  proto.Int(s.SceneState.GetState()),
		Params: params,
	}
	s.Broadcast(int(clawdoll.CLAWDOLLPacketID_PACKET_SC_ROOMSTATE), pack, 0)
}

// 玩家状态信息变化
func ClawdollSendPlayerInfo(s *base.Scene) {

	if sceneEx, ok := s.ExtraData.(*SceneEx); ok {
		playerEx := sceneEx.GetPlayingEx()
		if playerEx != nil && playerEx.SnId == sceneEx.playingSnid {
			pack := &clawdoll.SCCLAWDOLLPlayerInfo{
				SnId:          proto.Int32(playerEx.SnId),
				ClawDollState: proto.Int32(playerEx.GetClawState()),
				Coin:          proto.Int64(playerEx.Coin),
				GainCoin:      proto.Int64(playerEx.gainCoin),
			}

			proto.SetDefaults(pack)

			playerEx.SendToClient(int(clawdoll.CLAWDOLLPacketID_PACKET_SC_PLAYERINFO), pack)
		}
	}
}

// 广播房间里所有等待玩家信息
func ClawdollSendRoomWaitPlayers(s *base.Scene, p *base.Player) {
	pack := &clawdoll.CLAWDOLLWaitPlayers{}

	if sceneEx, ok := s.ExtraData.(*SceneEx); ok {
		for _, playerEx := range sceneEx.players {
			// 玩家信息
			if playerEx.SnId != sceneEx.playingSnid {
				pd := &clawdoll.CLAWDOLLPlayerDigestInfo{
					SnId:    proto.Int32(playerEx.SnId),
					Head:    proto.Int32(playerEx.Head),
					HeadUrl: proto.String(playerEx.HeadUrl),
					Name:    proto.String(playerEx.Name),
					Stat:    proto.Int32(playerEx.clawDollState),
				}

				pack.WaitPlayersInfo = append(pack.WaitPlayersInfo, pd)
			}
		}

		p.SendToClient(int(clawdoll.CLAWDOLLPacketID_PACKET_SC_WAITPLAYERS), pack)
	}
}

// 广播房间正在控制娃娃机的玩家信息
func ClawdollBroadcastPlayingInfo(s *base.Scene) {
	if sceneEx, ok := s.ExtraData.(*SceneEx); ok {

		if !sceneEx.IsHasPlaying() {
			pack := &clawdoll.CLAWDOLLPlayerDigestInfo{
				SnId: proto.Int32(0),
				Head: proto.Int32(0),
			}

			s.Broadcast(int(clawdoll.CLAWDOLLPacketID_PACKET_SC_PLAYINGINFO), pack, 0)
			return
		}

		playerEx := sceneEx.GetPlayingEx()
		if playerEx != nil && playerEx.SnId == sceneEx.playingSnid {
			pack := &clawdoll.CLAWDOLLPlayerDigestInfo{
				SnId:    proto.Int32(playerEx.SnId),
				Head:    proto.Int32(playerEx.Head),
				HeadUrl: proto.String(playerEx.HeadUrl),
				Name:    proto.String(playerEx.Name),
			}

			s.Broadcast(int(clawdoll.CLAWDOLLPacketID_PACKET_SC_PLAYINGINFO), pack, 0)
			//playerEx.SendToClient(int(clawdoll.CLAWDOLLPacketID_PACKET_SC_PLAYERINFO), pack)
		}
	}
}

//=====================================
// BaseState 状态基类
//=====================================

type BaseState struct {
}

func (this *BaseState) GetTimeout(s *base.Scene) int {
	if sceneEx, ok := s.ExtraData.(*SceneEx); ok {
		return int(time.Now().Sub(sceneEx.StateStartTime) / time.Second)
	}
	return 0
}

func (this *BaseState) CanChangeTo(s base.SceneState) bool {
	return true
}

func (this *BaseState) CanChangeCoinScene(s *base.Scene, p *base.Player) bool {

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

	if !playerEx.CanLeaveScene(s.GetSceneState().GetState()) {
		return false
	}

	return true
}

func (this *BaseState) OnEnter(s *base.Scene) {
	if sceneEx, ok := s.ExtraData.(*SceneEx); ok {
		sceneEx.StateStartTime = time.Now()
	}
}

func (this *BaseState) OnLeave(s *base.Scene) {}

func (this *BaseState) OnTick(s *base.Scene) {

}

func (this *BaseState) OnPlayerOp(s *base.Scene, p *base.Player, opcode int, params []int64) bool {

	return false
}

func (this *BaseState) OnPlayerEvent(s *base.Scene, p *base.Player, evtcode int, params []int64) {
}

//=====================================
// StateWait 等待中
//=====================================

type StateWait struct {
	BaseState
}

func (this *StateWait) GetState() int {
	return rule.ClawDollSceneStateWait
}

func (this *StateWait) CanChangeTo(s base.SceneState) bool {
	if s.GetState() == rule.ClawDollSceneStateStart {
		return true
	}
	return false
}

func (this *StateWait) GetTimeout(s *base.Scene) int {
	return this.BaseState.GetTimeout(s)
}

func (this *StateWait) OnEnter(s *base.Scene) {
	this.BaseState.OnEnter(s)
	if _, ok := s.ExtraData.(*SceneEx); ok {
		if s.Gaming {
			s.NotifySceneRoundPause()
		}
		s.Gaming = false

		ClawdollBroadcastRoomState(s)
		ClawdollSendPlayerInfo(s)
	}
}

// 玩家事件
func (this *StateWait) OnPlayerEvent(s *base.Scene, p *base.Player, evtcode int, params []int64) {
	logger.Logger.Trace("(this *StateWait) OnPlayerEvent, sceneId=", s.GetSceneId(), " player=", p.SnId, " evtcode=", evtcode)
	this.BaseState.OnPlayerEvent(s, p, evtcode, params)
	if _, ok := s.ExtraData.(*SceneEx); ok {
		switch evtcode {
		case base.PlayerEventLeave:
		case base.PlayerEventEnter:
			if !p.IsReady() {
				p.MarkFlag(base.PlayerState_Ready)
				p.SyncFlag()
			}
		}
	}
}

func (this *StateWait) OnTick(s *base.Scene) {
	this.BaseState.OnTick(s)
	if sceneEx, ok := s.ExtraData.(*SceneEx); ok {
		if s.CheckNeedDestroy() {
			sceneEx.SceneDestroy(true)
			return
		}
	}
}

func (this *StateWait) OnPlayerOp(s *base.Scene, p *base.Player, opcode int, params []int64) bool {
	if this.BaseState.OnPlayerOp(s, p, opcode, params) {
		return true
	}

	sceneEx, ok := s.ExtraData.(*SceneEx)
	if !ok {
		return false
	}
	playerEx, ok := p.ExtraData.(*PlayerEx)
	if !ok {
		return false
	}

	switch opcode {
	case rule.ClawDollPlayerOpPayCoin:
		if sceneEx.IsHasPlaying() {
			return false
		}

		if !playerEx.CanPayCoin() {
			return false
		}

		if sceneEx.CanStart() {
			// 1-前 2-后 3-左 4-右 5-投币
			sceneEx.OnPlayerSMPerateOp(p.SnId, int32(sceneEx.machineId), rule.ButtonPayCoin)

			if rule.DebugSwitch {
				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)
			}

			logger.Logger.Trace("(ClawDoll this *StateWait) OnPlayerOp payCoin, sceneId=", s.GetSceneId(), " player=", p.SnId, " machineId=", sceneEx.machineId)

			//sceneEx.OnPlayerSCOp(p, opcode, clawdoll.OpResultCode_OPRC_Success, params)
		}
	}

	return false
}

//=====================================
// StateStart 开始倒计时
//=====================================

type StateStart struct {
	BaseState
}

func (this *StateStart) GetState() int {
	return rule.ClawDollSceneStateStart
}

func (this *StateStart) CanChangeTo(s base.SceneState) bool {
	switch s.GetState() {
	case rule.ClawDollSceneStatePlayGame:
		return true
	case rule.ClawDollSceneStateWait:
		return true
	}
	return false
}

func (this *StateStart) OnEnter(s *base.Scene) {
	this.BaseState.OnEnter(s)
	if sceneEx, ok := s.ExtraData.(*SceneEx); ok {
		ClawdollBroadcastRoomState(s)
		ClawdollSendPlayerInfo(s)

		s.Gaming = false
		sceneEx.GameNowTime = time.Now()
		sceneEx.NumOfGames++
	}
}

func (this *StateStart) OnTick(s *base.Scene) {
	this.BaseState.OnTick(s)
	if sceneEx, ok := s.ExtraData.(*SceneEx); ok {
		if time.Now().Sub(sceneEx.StateStartTime) > rule.ClawDollSceneStartTimeout {

			logger.Logger.Trace("ClawDoll StateStart OnTick ChangeSceneState:", rule.ClawDollSceneStatePlayGame)
			//切换到等待操作状态
			s.ChangeSceneState(rule.ClawDollSceneStatePlayGame)
			sceneEx.SetPlayingState(int32(rule.ClawDollSceneStatePlayGame))

			ClawdollBroadcastRoomState(s)
			ClawdollSendPlayerInfo(s)
		}
	}
}

func (this *StateStart) OnPlayerOp(s *base.Scene, p *base.Player, opcode int, params []int64) bool {
	return false
}

func (this *StateStart) OnPlayerEvent(s *base.Scene, p *base.Player, evtcode int, params []int64) {
	logger.Logger.Trace("(this *StateStart) OnPlayerEvent, sceneId=", s.GetSceneId(), " player=", p.SnId, " evtcode=", evtcode)
	this.BaseState.OnPlayerEvent(s, p, evtcode, params)
	if _, ok := s.ExtraData.(*SceneEx); ok {
		switch evtcode {
		case base.PlayerEventEnter:
			if !p.IsReady() {
				p.MarkFlag(base.PlayerState_Ready)
				p.SyncFlag()
			}
		}
	}
}

// =====================================
// PlayGame 游戏中
// =====================================
type PlayGame struct {
	BaseState
}

func (this *PlayGame) GetState() int {
	return rule.ClawDollSceneStatePlayGame
}

func (this *PlayGame) CanChangeTo(s base.SceneState) bool {
	switch s.GetState() {
	case rule.ClawDollSceneStateBilled:
		return true
	}
	return false
}

func (this *PlayGame) OnEnter(s *base.Scene) {
	logger.Logger.Trace("(this *PlayGame) OnEnter, sceneid=", s.GetSceneId())

	this.BaseState.OnEnter(s)

	s.Gaming = true

	ClawdollBroadcastRoomState(s)
	ClawdollSendPlayerInfo(s)

}

func (this *PlayGame) OnPlayerOp(s *base.Scene, p *base.Player, opcode int, params []int64) bool {

	logger.Logger.Trace("ClawDoll StatePlayGame OnPlayerOp-----SnId:", p.SnId, " opcode: ", opcode, " params:", params)

	if this.BaseState.OnPlayerOp(s, p, opcode, params) {
		return true
	}

	sceneEx, ok := s.ExtraData.(*SceneEx)
	if !ok {
		return false
	}
	playerEx, ok := p.ExtraData.(*PlayerEx)
	if !ok {
		return false
	}

	switch opcode {
	case rule.ClawDollPlayerOpGo:

		if !sceneEx.CheckGrapOp(playerEx) {
			return false
		}

		if !playerEx.CanGrab() {
			return false
		}

		grapType := sceneEx.GetPlayGrabType(playerEx)

		logger.Logger.Trace("ClawDoll StatePlayGame OnPlayerOp Grab-----SnId:", p.SnId, " grapType: ", grapType)
		//1-弱力抓 2 -强力抓
		sceneEx.OnPlayerSMGrabOp(p.SnId, int32(sceneEx.machineId), grapType)

		if rule.DebugSwitch {
			if sceneEx.RoundId/2 == 1 {
				// 获得娃娃卡
				playerEx.CatchCardClawdoll()

				playerEx.IsWin = true

			} else {
				playerEx.IsWin = false
			}

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

			ClawdollBroadcastRoomState(s)
			ClawdollSendPlayerInfo(s)
		}

		sceneEx.Gaming = false

	case rule.ClawDollPlayerOpMove:

		if !sceneEx.CheckMoveOp(playerEx) {
			return false
		}

		if !playerEx.CanMove() {
			return false
		}

		if params[0] < rule.ButtonFront || params[0] > rule.ButtonRight {
			logger.Logger.Trace("ClawDoll StatePlayGame OnPlayerOp-----SnId:", p.SnId, " opcode: ", opcode, " params:", params)
			return false
		}
		// 1-前 2-后 3-左 4-右 5-投币
		sceneEx.OnPlayerSMPerateOp(p.SnId, int32(sceneEx.machineId), int32(params[0]))
	}

	return false
}

func (this *PlayGame) OnTick(s *base.Scene) {
	this.BaseState.OnTick(s)
	if sceneEx, ok := s.ExtraData.(*SceneEx); ok {
		if time.Now().Sub(sceneEx.StateStartTime) > rule.ClawDollScenePlayTimeout {

			if sceneEx.Gaming && sceneEx.TimeOutPlayGrab() {
				sceneEx.Gaming = false
				logger.Logger.Trace("PlayGame OnTick TimeOutPlayGrab SnId: ", sceneEx.playingSnid, " machineId:", sceneEx.machineId)

				sceneEx.GrabTimerHandle()
			}

			return
		}
	}
}

//=====================================
// StateBilled 结算
//=====================================

type StateBilled struct {
	BaseState
}

func (this *StateBilled) GetState() int {
	return rule.ClawDollSceneStateBilled
}

func (this *StateBilled) CanChangeTo(s base.SceneState) bool {
	switch s.GetState() {
	case rule.ClawDollSceneWaitPayCoin:
		return true
	}
	return false
}

func (this *StateBilled) OnPlayerOp(s *base.Scene, p *base.Player, opcode int, params []int64) bool {
	return false
}

func (this *StateBilled) OnEnter(s *base.Scene) {
	logger.Logger.Trace("(this *StateBilled) OnEnter, sceneid=", s.GetSceneId())
	this.BaseState.OnEnter(s)

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

	playerEx := sceneEx.GetPlayingEx()
	if playerEx != nil {
		logger.Logger.Trace("ClawdollSaveLog Save Snid : ", playerEx.SnId)

		machineId := s.GetDBGameFree().GetId() % 6080000
		machineInfo := s.GetMachineServerInfo(machineId, playerEx.Platform)
		if machineInfo == nil {
			return
		}

		curClawdollItemNum, ok := playerEx.Items[int32(common.ItemIDClawdoll)]
		if !ok {
			return
		}

		LogBaseResult := model.ClawdollResultType{}
		LogBaseResult.RoomId = int32(sceneEx.GetSceneId())
		LogBaseResult.PlayerSnid = playerEx.SnId
		LogBaseResult.BeforeClawdollItemNum = curClawdollItemNum + int64(machineInfo.CostItemNum)
		LogBaseResult.AfterClawdollItemNum = curClawdollItemNum
		LogBaseResult.IsWin = playerEx.IsWin
		LogBaseResult.Channel = playerEx.Channel
		LogBaseResult.MachineId = machineId
		LogBaseResult.Name = machineInfo.Name

		if !playerEx.IsRob {
			sceneEx.logid, _ = model.AutoIncGameLogId()
			info, err := model.MarshalGameNoteByHUNDRED(LogBaseResult)
			if err == nil {
				sceneEx.SaveGameDetailedLog(sceneEx.logid, info, &base.GameDetailedParam{})
			}

			TotalBetValue := 0
			totalin := int64(TotalBetValue)
			totalout := playerEx.gainCoin
			validFlow := totalin + totalout
			validBet := common.AbsI64(totalin - totalout)
			logParam := &base.SaveGamePlayerListLogParam{
				Platform:          playerEx.Platform,
				Channel:           playerEx.Channel,
				Promoter:          playerEx.BeUnderAgentCode,
				PackageTag:        playerEx.PackageID,
				InviterId:         playerEx.InviterId,
				LogId:             sceneEx.logid,
				TotalIn:           totalin,
				TotalOut:          totalout,
				TaxCoin:           playerEx.taxCoin,
				BetAmount:         int64(TotalBetValue),
				WinAmountNoAnyTax: playerEx.gainCoin,
				ValidBet:          validBet,
				ValidFlow:         validFlow,
				IsFirstGame:       sceneEx.IsPlayerFirst(playerEx.Player),
				IsFree:            false,
				WinSmallGame:      0,
				WinTotal:          0,
			}
			sceneEx.SaveGamePlayerListLog(playerEx.SnId, logParam)
		}

		playerEx.lastIsWin = playerEx.IsWin
		sceneEx.PayCoinCount++
		playerEx.ReStartGame()
	}
}

func (this *StateBilled) OnLeave(s *base.Scene) {
	logger.Logger.Trace("(this *StateBilled) OnLeave, sceneid=", s.GetSceneId())
	this.BaseState.OnLeave(s)
	if sceneEx, ok := s.ExtraData.(*SceneEx); ok {

		sceneEx.PlayerBackup = make(map[int32]*PlayerData)

		if s.CheckNeedDestroy() {
			sceneEx.SceneDestroy(true)
		}
	}
}

func (this *StateBilled) OnTick(s *base.Scene) {
	this.BaseState.OnTick(s)
	if sceneEx, ok := s.ExtraData.(*SceneEx); ok {
		if time.Now().Sub(sceneEx.StateStartTime) > rule.ClawDollSceneBilledTimeout {

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

			ClawdollBroadcastRoomState(s)
			ClawdollSendPlayerInfo(s)

			return
		}
	}
}

//=====================================
// StateWaitPayCoin 等待下一局投币
//=====================================

type StateWaitPayCoin struct {
	BaseState
}

func (this *StateWaitPayCoin) GetState() int {
	return rule.ClawDollSceneWaitPayCoin
}

func (this *StateWaitPayCoin) CanChangeTo(s base.SceneState) bool {
	switch s.GetState() {
	case rule.ClawDollSceneStateStart:
		return true
	case rule.ClawDollSceneStateWait:
		return true
	}
	return false
}

func (this *StateWaitPayCoin) OnPlayerOp(s *base.Scene, p *base.Player, opcode int, params []int64) bool {
	logger.Logger.Trace("StatePlayGame OnPlayerOp-----SnId:", p.SnId, " opcode: ", opcode, " params:", params)

	if this.BaseState.OnPlayerOp(s, p, opcode, params) {
		return true
	}

	sceneEx, ok := s.ExtraData.(*SceneEx)
	if !ok {
		return false
	}
	playerEx, ok := p.ExtraData.(*PlayerEx)
	if !ok {
		return false
	}

	switch opcode {
	case rule.ClawDollPlayerOpPayCoin:

		if sceneEx.playingSnid != playerEx.SnId {
			logger.Logger.Trace("StateWaitPayCoin OnPlayerOp-----sceneEx.playingSnid:", sceneEx.playingSnid, " playerEx.SnId: ", playerEx.SnId)
			return false
		}

		// 投币检测
		if !playerEx.CanPayCoin() {
			logger.Logger.Trace("StateWaitPayCoin OnPlayerOp-----CanPayCoin: false")
			return false
		}

		sceneEx.OnPlayerSMPerateOp(p.SnId, int32(sceneEx.machineId), rule.ButtonPayCoin)

		playerEx.ReStartGame()

		sceneEx.OnPlayerSCOp(p, opcode, clawdoll.OpResultCode_OPRC_Success, params)
		if rule.DebugSwitch {
			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)
		}

	case rule.ClawDollPlayerCancelPayCoin:
		if sceneEx.playingSnid != playerEx.SnId {
			logger.Logger.Trace("StateWaitPayCoin OnPlayerOp-----sceneEx.playingSnid:", sceneEx.playingSnid, " playerEx.SnId: ", playerEx.SnId)
			return false
		}

		// 先设置时间
		playingEx := sceneEx.GetPlayingEx()
		if playingEx != nil {
			playingEx.ReStartGame()
			ClawdollSendPlayerInfo(s)
		}

		// 再重置scene数据
		sceneEx.ReStartGame()

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

		ClawdollBroadcastRoomState(s)
		ClawdollBroadcastPlayingInfo(s)
	}

	return false
}

func (this *StateWaitPayCoin) OnEnter(s *base.Scene) {
	logger.Logger.Trace("(this *StateWaitPayCoin) OnEnter, sceneid=", s.GetSceneId())
	this.BaseState.OnEnter(s)

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

	playingEx := sceneEx.GetPlayingEx()
	if playingEx != nil {
		playingEx.SendPlayerGameBilled(int32(sceneEx.RoundId))

		playingEx.lastIsWin = false
	}
}

func (this *StateWaitPayCoin) OnLeave(s *base.Scene) {
	logger.Logger.Trace("(this *StateWaitPayCoin) OnLeave, sceneid=", s.GetSceneId())
	this.BaseState.OnLeave(s)
}

func (this *StateWaitPayCoin) OnTick(s *base.Scene) {
	this.BaseState.OnTick(s)
	if sceneEx, ok := s.ExtraData.(*SceneEx); ok {
		if time.Now().Sub(sceneEx.StateStartTime) > rule.ClawDollSceneWaitPayCoinimeout {

			// 先设置时间
			playingEx := sceneEx.GetPlayingEx()
			if playingEx != nil {
				playingEx.ReStartGame()
				ClawdollSendPlayerInfo(s)
			}

			// 再重置scene数据
			sceneEx.ReStartGame()

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

			ClawdollBroadcastRoomState(s)
			ClawdollBroadcastPlayingInfo(s)
			return
		}
	}
}

// // //////////////////////////////////////////////////////////////////////////////
func (this *PolicyClawdoll) RegisteSceneState(state base.SceneState) {
	if state == nil {
		return
	}
	stateid := state.GetState()

	if stateid < 0 || stateid >= rule.ClawDollSceneStateMax {
		return
	}
	this.states[stateid] = state
}

func (this *PolicyClawdoll) GetSceneState(s *base.Scene, stateid int) base.SceneState {
	if stateid >= 0 && stateid < rule.ClawDollSceneStateMax {
		return this.states[stateid]
	}
	return nil
}

func init() {
	PolicyClawdollSingleton.RegisteSceneState(&StateWait{})
	PolicyClawdollSingleton.RegisteSceneState(&StateStart{})
	PolicyClawdollSingleton.RegisteSceneState(&PlayGame{})
	PolicyClawdollSingleton.RegisteSceneState(&StateBilled{})
	PolicyClawdollSingleton.RegisteSceneState(&StateWaitPayCoin{})

	core.RegisteHook(core.HOOK_BEFORE_START, func() error {
		base.RegisteScenePolicy(common.GameId_Clawdoll, 0, PolicyClawdollSingleton)

		return nil
	})
}