package tienlen

import (
	"encoding/json"
	"fmt"
	"math/rand"
	tienlenApi "mongo.games.com/game/api3th/smart/tienlen"
	"mongo.games.com/game/common"
	"mongo.games.com/game/gamerule/tienlen"
	"mongo.games.com/game/proto"
	"mongo.games.com/game/protocol/gamehall"
	proto_tienlen "mongo.games.com/game/protocol/tienlen"
	"mongo.games.com/game/robot/base"
	"mongo.games.com/goserver/core/basic"
	"mongo.games.com/goserver/core/logger"
	"mongo.games.com/goserver/core/netlib"
	"mongo.games.com/goserver/core/task"
	"sort"
	"strconv"
	"strings"
)

func SendEmote(s *netlib.Session, scene *TienLenScene, p *TienLenPlayer, arr []int, tp int) {
	if !base.SceneMgrSingleton.IsFreeMode(scene.GetRoomId()) && !scene.IsMatchScene() {
		if p.EmoteTimes[tp] == 0 {
			base.SendEmote(s, arr)
		}
		p.EmoteTimes[tp]++
	}
}

type SCTienLenRoomInfoPacketFactory struct {
}

type SCTienLenRoomInfoHandler struct {
}

func (this *SCTienLenRoomInfoPacketFactory) CreatePacket() interface{} {
	pack := &proto_tienlen.SCTienLenRoomInfo{}
	return pack
}

func (this *SCTienLenRoomInfoHandler) Process(s *netlib.Session, packid int, pack interface{}) error {
	logger.Logger.Tracef("(this *SCTienLenRoomInfoHandler) Process [%v].", s.GetSessionConfig().Id)
	if msg, ok := pack.(*proto_tienlen.SCTienLenRoomInfo); ok {
		scene := base.SceneMgrSingleton.GetScene(msg.GetRoomId())
		if scene == nil {
			scene = NewTienLenScene(msg)
			base.SceneMgrSingleton.AddScene(scene)
		}
		if scene != nil {
			for _, pd := range msg.GetPlayers() {
				if scene.GetPlayerBySnid(pd.GetSnId()) == nil {
					p := NewTienLenPlayer(pd)
					if p != nil {
						scene.AddPlayer(p)
					}
				}
			}
		}
	} else {
		logger.Logger.Error("SCTienLenRoomInfo package data error.")
	}
	return nil
}

type SCTienLenPlayerOpPacketFactory struct {
}

type SCTienLenPlayerOpHandler struct {
}

func (this *SCTienLenPlayerOpPacketFactory) CreatePacket() interface{} {
	pack := &proto_tienlen.SCTienLenPlayerOp{}
	return pack
}

func (this *SCTienLenPlayerOpHandler) Process(s *netlib.Session, packid int, pack interface{}) error {
	logger.Logger.Tracef("(this *SCTienLenPlayerOpHandler) Process [%v].", s.GetSessionConfig().Id)
	if scTienLenOp, ok := pack.(*proto_tienlen.SCTienLenPlayerOp); ok {
		if scene, ok := base.GetScene(s).(*TienLenScene); ok {
			player := scene.GetMe(s)

			if player == base.NilPlayer {
				return nil
			}
			if me, ok2 := player.(*TienLenPlayer); ok2 && me != TienLenNilPlayer {
				if me.GetSnId() == scTienLenOp.GetSnId() {
					if int(scTienLenOp.GetOpRetCode()) == 0 {
						switch scTienLenOp.GetOpCode() {
						case tienlen.TienLenPlayerOpPlay:
							delC := []int32{}
							delCards := scTienLenOp.GetOpParam()
							for _, delcard := range delCards {
								for i, card := range me.Cards {
									if card != tienlen.InvalideCard && card == int32(delcard) {
										me.Cards[i] = tienlen.InvalideCard
										delC = append(delC, card)
									}
								}
							}

							lastPlayer := scene.GetPlayerBySnid(scene.LastOpSnid)
							if lastPlayer != nil && lastPlayer.IsRobot() && me.SnId != lastPlayer.GetSnId() &&
								(tienlen.IsTwo(scene.LastCards) || tienlen.IsBomb(scene.LastCards, !common.IsTienLenYuLe(int(scene.GetGameId())))) {
								// 机器人出2/炸弹被压制
								SendEmote(base.PlayerMgrSingleton.GetPlayerSession(scene.LastOpSnid), scene, lastPlayer.(*TienLenPlayer), base.Emote1, 1)
							}
							scene.LastCards = delC
							scene.LastOpSnid = me.SnId
							me.PassTimes = 0
						case tienlen.TienLenPlayerOpPass:
							me.PassTimes++
							if me.PassTimes >= 2 {
								me.PassTimes = 0
								// 机器人过牌两次
								SendEmote(s, scene, me, base.Emote2, 2)
							}
						}

					} else { //操作失败
						switch scTienLenOp.GetOpCode() {
						case tienlen.TienLenPlayerOpPlay: //出牌操作失败，改为过
							if scTienLenOp.GetSnId() == me.GetSnId() {
								packOp := &proto_tienlen.CSTienLenPlayerOp{
									OpCode: proto.Int32(2),
								}
								proto.SetDefaults(packOp)
								s.Send(int(proto_tienlen.TienLenPacketID_PACKET_CSTienLenPlayerOp), packOp)
							}
						case int32(tienlen.TienLenPlayerOpPass): //过牌操作失败，改为出
						}
					}
				}
			}
		}
	} else {
		logger.Logger.Error("SCTienLenPlayerOp package data error.")
	}
	return nil
}

type SCTienLenRoomStatePacketFactory struct {
}

type SCTienLenRoomStateHandler struct {
}

func (this *SCTienLenRoomStatePacketFactory) CreatePacket() interface{} {
	pack := &proto_tienlen.SCTienLenRoomState{}
	return pack
}

func (this *SCTienLenRoomStateHandler) Process(s *netlib.Session, packid int, pack interface{}) error {
	logger.Logger.Tracef("(this *SCTienLenRoomStateHandler) Process [%v].", s.GetSessionConfig().Id)
	if scTienLenRoomState, ok := pack.(*proto_tienlen.SCTienLenRoomState); ok {
		if scene, ok := base.GetScene(s).(*TienLenScene); ok {
			scene.State = scTienLenRoomState.State
			p := scene.GetMe(s)
			if me, ok2 := p.(*TienLenPlayer); ok2 && me != TienLenNilPlayer {
				switch scTienLenRoomState.GetState() {
				case int32(tienlen.TienLenSceneStateWaitPlayer):
					scene.Clear()
				case int32(tienlen.TienLenSceneStateWaitStart): //等待开始
					scene.Clear()
					if me.GetSnId() == scene.GetMasterSnid() {
						packOp := &proto_tienlen.CSTienLenPlayerOp{
							OpCode: proto.Int32(3),
						}
						proto.SetDefaults(packOp)
						//if scene.GetIsAllAi() {
						//	base.DelayAISend(s, int(proto_tienlen.TienLenPacketID_PACKET_CSTienLenPlayerOp), packOp)
						//} else {
						//	base.DelaySendSecond(s, int(proto_tienlen.TienLenPacketID_PACKET_CSTienLenPlayerOp), packOp, []int{3, 7}...)
						//}
						base.DelaySendSecond(s, int(proto_tienlen.TienLenPacketID_PACKET_CSTienLenPlayerOp), packOp, []int{3, 7}...)
					}
				case int32(tienlen.TienLenSceneStatePlayerOp):
				case int32(tienlen.TienLenSceneStateBilled):
					scene.Clear()
					me.Clear()
				}
			}
		}
	} else {
		logger.Logger.Error("SCTienLenRoomState package data error.")
	}
	return nil
}

type SCTienLenGameBilledPacketFactory struct {
}

type SCTienLenGameBilledHandler struct {
}

func (this *SCTienLenGameBilledPacketFactory) CreatePacket() interface{} {
	pack := &proto_tienlen.SCTienLenGameBilled{}
	return pack
}

func (this *SCTienLenGameBilledHandler) Process(s *netlib.Session, packid int, pack interface{}) error {
	logger.Logger.Tracef("(this *SCTienLenGameBilledHandler) Process [%v].", s.GetSessionConfig().Id)
	if scTienLenBilled, ok := pack.(*proto_tienlen.SCTienLenGameBilled); ok {
		if scene, ok := base.GetScene(s).(*TienLenScene); ok {
			//logger.Logger.Trace(scTienLenBilled)
			billData := scTienLenBilled.GetDatas()
			for _, data := range billData {
				p := scene.GetMe(s)
				if p == base.NilPlayer {
					continue
				}
				if me, ok2 := p.(*TienLenPlayer); ok2 && me != TienLenNilPlayer {
					if data.GetSnId() == me.GetSnId() { //自己的数据
						me.Coin = proto.Int64(data.GetGameCoin())
					}
				}
			}
		}
	} else {
		logger.Logger.Error("SCTienLenGameBilled package data error.")
	}
	return nil
}

type SCTienLenCurOpPosPacketFactory struct {
}

type SCTienLenCurOpPosHandler struct {
}

func (this *SCTienLenCurOpPosPacketFactory) CreatePacket() interface{} {
	pack := &proto_tienlen.SCTienLenCurOpPos{}
	return pack
}

func (this *SCTienLenCurOpPosHandler) Process(s *netlib.Session, packid int, pack interface{}) error {
	logger.Logger.Tracef("(this *SCTienLenCurOpPosHandler) Process [%v].", s.GetSessionConfig().Id)
	if scTienLenCurOpPos, ok := pack.(*proto_tienlen.SCTienLenCurOpPos); ok {
		if scene, ok := base.GetScene(s).(*TienLenScene); ok {
			curPos := scTienLenCurOpPos.GetPos()
			p := scene.GetMe(s)
			if me, ok2 := p.(*TienLenPlayer); ok2 && me != TienLenNilPlayer {
				if scene.GetState() == int32(tienlen.TienLenSceneStatePlayerOp) {
					if me.GetPos() == curPos {
						packOp := &proto_tienlen.CSTienLenPlayerOp{
							OpCode: proto.Int32(1),
						}
						cpCards := []int32{}
						for _, card := range me.Cards {
							if card != tienlen.InvalideCard {
								cpCards = append(cpCards, card)
							}
						}
						recmCards := []int32{}

						exDelayTs := int(scTienLenCurOpPos.GetExDelay()) * 1000
						minS := 1500
						maxS := 3000
						if scene.IsMatchScene() && scene.GetIsAllAi() {
							exDelayTs = 1
							minS = 1
							maxS = 2
						}
						notExDelay := true //立即出牌
						notExDelayTs := 1
						notExDelayminS := 1
						notExDelaymaxS := 2
						if len(cpCards) > 0 {
							logger.Logger.Trace("tienlenApi.Config.Switch() = ", tienlenApi.Config.Switch(), "scene.GetIsAllAi() = ", scene.GetIsAllAi())
							if tienlenApi.Config.Switch() && (!scene.IsMatchScene() || (scene.IsMatchScene() && !scene.GetIsAllAi())) { //开启 不是比赛场或者是比赛场但不是纯ai
								if me.data != nil && me.data.Num_cards_left_0 == 13 &&
									me.data.Num_cards_left_1 == 13 &&
									me.data.Num_cards_left_2 == 13 &&
									me.data.Num_cards_left_3 == 13 &&
									me.data.Card_play_action_seq == "" {
									//根据最小牌值去推荐出牌:顺子>2连对>三张>对子>单张
									recmCards = tienlen.GetOutCards(cpCards, me.data, me.GetPos())
									if len(recmCards) == 0 {
										logger.Logger.Error("RecommendCardsWithMinCard error1: ", me.GetSnId(), " recmCards:", recmCards)
									}
									if len(recmCards) > 0 {
										for _, card := range recmCards {
											packOp.OpParam = append(packOp.OpParam, int64(card))
										}
									} else {
										packOp.OpCode = proto.Int32(2)
										//压不住的时候，90%概率1s后出牌
										if rand.Intn(100) < 90 {
											if exDelayTs == 0 {
												exDelayTs = 1000
											}
											minS = 1
											maxS = 2
										}
									}
									proto.SetDefaults(packOp)
									if notExDelay && len(recmCards) == len(cpCards) { //最后一手牌立即打出
										exDelayTs = notExDelayTs
										minS = notExDelayminS
										maxS = notExDelaymaxS
									}
									base.DelaySendMillisecond(s, int(proto_tienlen.TienLenPacketID_PACKET_CSTienLenPlayerOp), packOp, []int{exDelayTs + minS, exDelayTs + maxS}...)
								} else {
									var err error
									var res []byte
									if me == nil {
										return nil
									}

									task.New(nil, task.CallableWrapper(func(o *basic.Object) interface{} {
										if scene.IsTienLenYule() {
											tienlenApi.Config.IPAddr = common.CustomConfig.GetString(fmt.Sprintf("%s2Api3thAddr", tienlenApi.Config.Name))
										} else {
											tienlenApi.Config.IPAddr = common.CustomConfig.GetString(fmt.Sprintf("%sApi3thAddr", tienlenApi.Config.Name))
										}
										res, err = tienlenApi.Config.Do(tienlenApi.Predict, me.data)
										return nil
									}), task.CompleteNotifyWrapper(func(data interface{}, t task.Task) {
										if scene.GetState() != int32(tienlen.TienLenSceneStatePlayerOp) || me.GetPos() != curPos {
											tienlenApi.Config.Log().Errorf("TienLen TienLenSmart return too later state[%v-%v] pos[%v-%v] GameId[%v] RoomId[%v]", scene.GetState(),
												tienlen.TienLenSceneStatePlayerOp, me.GetPos(), curPos, scene.GameId, scene.RoomId)
											return
										}
										logger.Logger.Infof("AI返回要出的牌！！！！！！！ err = %v,,,,res = %v", err, res)
										if err != nil || res == nil {
											tienlenApi.Config.Log().Errorf("TienLen TienLenSmart Err:%v", err)
											lastDelCards := scTienLenCurOpPos.GetCards()
											if len(lastDelCards) != 0 && !scTienLenCurOpPos.GetIsNew() { //根据上手牌出牌
												logger.Logger.Trace("根据上手牌出牌: ", me.GetSnId(), " lastDelCards:", lastDelCards, " IsNew:", scTienLenCurOpPos.GetIsNew())
												//压牌
												recmCards = tienlen.GetPressCards(cpCards, lastDelCards, me.data, me.GetPos())
											} else { //自由出牌
												logger.Logger.Trace("自由出牌: ", me.GetSnId(), " lastDelCards:", lastDelCards, " IsNew:", scTienLenCurOpPos.GetIsNew())
												//根据最小牌值去推荐出牌:顺子>2连对>三张>对子>单张
												//手牌
												recmCards = tienlen.GetOutCards(cpCards, me.data, me.GetPos())
												if len(recmCards) == 0 {
													logger.Logger.Error("RecommendCardsWithMinCard error2: ", me.GetSnId(), " lastDelCards:", lastDelCards, " recmCards:", recmCards)
												}
											}
											if len(recmCards) > 0 {

												for _, card := range recmCards {
													packOp.OpParam = append(packOp.OpParam, int64(card))
												}
											} else {
												packOp.OpCode = proto.Int32(2)
												//压不住的时候，90%概率1s后出牌
												if rand.Intn(100) < 90 {
													if exDelayTs == 0 {
														exDelayTs = 1000
													}
													minS = 1
													maxS = 2
												}
											}
											proto.SetDefaults(packOp)
											if notExDelay && len(recmCards) == len(cpCards) { //最后一手牌立即打出
												exDelayTs = notExDelayTs
												minS = notExDelayminS
												maxS = notExDelaymaxS
											}
											base.DelaySendMillisecond(s, int(proto_tienlen.TienLenPacketID_PACKET_CSTienLenPlayerOp), packOp, []int{exDelayTs + minS, exDelayTs + maxS}...)
											return
										}
										PredictResponse := new(tienlenApi.PredictResponse)
										if err = json.Unmarshal(res, PredictResponse); err != nil {
											logger.Logger.Error("AI返回要出的牌  解析报错！！！！！！！！！！！！！！！！！！！")
											tienlenApi.Config.Log().Errorf("TienLen TienLenSmart json.Unmarshal() error: %v", err)
											return
										}
										logger.Logger.Info("-------------------AI返回要出的牌----------------", PredictResponse)
										tienlenApi.Config.Log().Infof("PredictResponse：%v", *PredictResponse)
										cardstr := ""
										maxwinrate := 0.0
										for k, v := range PredictResponse.WinRates {
											v_rate, errrate := strconv.ParseFloat(v, 32)
											if errrate != nil {
												tienlenApi.Config.Log().Errorf("TienLen TienLenSmart strconv.ParseFloat() error: %v", err)
												continue
											}
											if v_rate >= maxwinrate {
												maxwinrate = v_rate
												cardstr = k
											}
										}
										recmCardss := strings.Split(cardstr, ",")
										for _, v := range recmCardss {
											card, errcard := strconv.Atoi(v)
											if errcard == nil {
												tmp := tienlenApi.AiCardToCard[int32(card)]
												recmCards = append(recmCards, int32(tmp))
											}
										}
										tienlenApi.Config.Log().Infof("--> %v Start TienLen:%+v", me.GetSnId(), cardstr)
										lastDelCards := scTienLenCurOpPos.GetCards()
										recmCards = scene.FilterRobotAICard(me, cpCards, lastDelCards, recmCards, scTienLenCurOpPos.GetIsNew())

										if len(recmCards) > 0 {
											for _, card := range recmCards {
												packOp.OpParam = append(packOp.OpParam, int64(card))
											}
										} else {
											lastDelCards := scTienLenCurOpPos.GetCards()
											if len(lastDelCards) != 0 && !scTienLenCurOpPos.GetIsNew() { //根据上手牌出牌
												packOp.OpCode = proto.Int32(2)
												//压不住的时候，90%概率1s后出牌
												if rand.Intn(100) < 90 {
													if exDelayTs == 0 {
														exDelayTs = 1000
													}
													minS = 1
													maxS = 2
												}
											} else { //自由出牌
												logger.Logger.Trace("自由出牌: ", me.GetSnId(), " lastDelCards:", lastDelCards, " IsNew:", scTienLenCurOpPos.GetIsNew())
												//根据最小牌值去推荐出牌:顺子>2连对>三张>对子>单张
												recmCards = tienlen.GetOutCards(cpCards, me.data, me.GetPos())
												logger.Logger.Trace("根据最小牌值去推荐出牌: ", recmCards)
												if len(recmCards) > 0 {
													for _, card := range recmCards {
														packOp.OpParam = append(packOp.OpParam, int64(card))
													}
												}
											}
										}
										tienlenApi.Config.Log().Tracef("--> %v Start TienLen:%+v", me.GetSnId(), packOp.GetOpParam())
										proto.SetDefaults(packOp)
										if notExDelay && len(recmCards) == len(cpCards) { //最后一手牌立即打出
											exDelayTs = notExDelayTs
											minS = notExDelayminS
											maxS = notExDelaymaxS
										}
										logger.Logger.Info("AI通知游戏服 出牌！！！！！！！！！！！！ packOp = ", packOp)
										base.DelaySendMillisecond(s, int(proto_tienlen.TienLenPacketID_PACKET_CSTienLenPlayerOp), packOp, []int{exDelayTs + minS, exDelayTs + maxS}...)
									}), "SmartStart_TienLen_action").Start()

								}
							} else {
								//不是用远程机器人的情况下走下面逻辑
								lastDelCards := scTienLenCurOpPos.GetCards()
								if len(lastDelCards) != 0 && !scTienLenCurOpPos.GetIsNew() { //根据上手牌出牌
									logger.Logger.Trace("根据上手牌出牌: ", me.GetSnId(), " lastDelCards:", lastDelCards, " IsNew:", scTienLenCurOpPos.GetIsNew())
									//压牌
									recmCards = tienlen.GetPressCards(cpCards, lastDelCards, me.data, me.GetPos())
								} else { //出首牌
									logger.Logger.Trace("自由出牌: ", me.GetSnId(), " lastDelCards:", lastDelCards, " IsNew:", scTienLenCurOpPos.GetIsNew())
									//根据最小牌值去推荐出牌:顺子>2连对>三张>对子>单张
									recmCards = tienlen.GetOutCards(cpCards, me.data, me.GetPos())
								}
								if len(recmCards) > 0 {
									for _, card := range recmCards {
										packOp.OpParam = append(packOp.OpParam, int64(card))
									}
								} else {
									packOp.OpCode = proto.Int32(2)
									//压不住的时候，90%概率1s后出牌
									if rand.Intn(100) < 90 {
										if exDelayTs == 0 {
											exDelayTs = 1000
										}
										minS = 1
										maxS = 2
									}
								}
								proto.SetDefaults(packOp)
								if notExDelay && len(recmCards) == len(cpCards) { //最后一手牌立即打出
									exDelayTs = notExDelayTs
									minS = notExDelayminS
									maxS = notExDelaymaxS
									if scene.FirstWinSnid == 0 {
										SendEmote(s, scene, me, base.Emote5, 5)
										scene.FirstWinSnid = me.SnId
									}
								}
								base.DelaySendMillisecond(s, int(proto_tienlen.TienLenPacketID_PACKET_CSTienLenPlayerOp), packOp, []int{exDelayTs + minS, exDelayTs + maxS}...)
							}
						}
					}
				}
			}
		}
	} else {
		logger.Logger.Error("SCTienLenCurOpPosHandler package data error.")
	}
	return nil
}

type SCTienLenCardPacketFactory struct {
}

type SCTienLenCardHandler struct {
}

func (this *SCTienLenCardPacketFactory) CreatePacket() interface{} {
	pack := &proto_tienlen.SCTienLenCard{}
	return pack
}

func (this *SCTienLenCardHandler) Process(s *netlib.Session, packid int, pack interface{}) error {
	logger.Logger.Tracef("(this *SCTienLenCardHandler) Process [%v].", s.GetSessionConfig().Id)
	if scTienLenCard, ok := pack.(*proto_tienlen.SCTienLenCard); ok {
		if scene, ok := base.GetScene(s).(*TienLenScene); ok {
			cards := scTienLenCard.GetCards()
			p := scene.GetMe(s)
			if me, ok2 := p.(*TienLenPlayer); ok2 && me != TienLenNilPlayer {
				if scene.GetState() == int32(tienlen.TienLenSceneStateHandCard) {
					me.Cards = []int32{}
					for _, card := range cards {
						me.Cards = append(me.Cards, card)
					}
					sort.Slice(me.Cards, func(i, j int) bool {
						if me.Cards[i] > me.Cards[j] {
							return false
						}
						return true
					})
				}
			}
		}
	} else {
		logger.Logger.Error("SCTienLenCardHandler package SCTienLenCard error.")
	}
	return nil
}

type SCTienLenUpdateMasterSnidPacketFactory struct {
}

type SCTienLenUpdateMasterSnidHandler struct {
}

func (this *SCTienLenUpdateMasterSnidPacketFactory) CreatePacket() interface{} {
	pack := &proto_tienlen.SCTienLenUpdateMasterSnid{}
	return pack
}

func (this *SCTienLenUpdateMasterSnidHandler) Process(s *netlib.Session, packid int, pack interface{}) error {
	logger.Logger.Tracef("(this *SCTienLenUpdateMasterSnidHandler) Process [%v].", s.GetSessionConfig().Id)
	if scTienLenUpdateMasterSnid, ok := pack.(*proto_tienlen.SCTienLenUpdateMasterSnid); ok {
		if scene, ok := base.GetScene(s).(*TienLenScene); ok {
			masterSnid := scTienLenUpdateMasterSnid.GetMasterSnid()
			scene.MasterSnid = masterSnid //更新房主
		}
	} else {
		logger.Logger.Error("SCTienLenUpdateMasterSnidHandler package SCTienLenUpdateMasterSnid error.")
	}
	return nil
}

type SCTienLenAIPacketFactory struct {
}

type SCTienLenAIHandler struct {
}

func (this *SCTienLenAIPacketFactory) CreatePacket() interface{} {
	pack := &proto_tienlen.SCTienLenAIData{}
	return pack
}

func (this *SCTienLenAIHandler) Process(s *netlib.Session, packid int, pack interface{}) error {
	logger.Logger.Tracef("(this *SCTienLenAIHandler) Process [%v].", s.GetSessionConfig().Id)
	if scTienLenAI, ok := pack.(*proto_tienlen.SCTienLenAIData); ok {
		if scene, ok := base.GetScene(s).(*TienLenScene); ok {
			//logger.Logger.Tracef("(this *SCTienLenAIHandler) Process [%v] %v", scene.GetRoomId(), scTienLenAI)
			p := scene.GetMe(s)
			if me, ok2 := p.(*TienLenPlayer); ok2 && me != TienLenNilPlayer {
				if me.GetPos() == scTienLenAI.GetPlayerPosition() {
					me.data = &tienlenApi.PredictRequest{
						Bomb_num:             0,
						Card_play_action_seq: scTienLenAI.GetCardPlayActionSeq(),
						Last_move_0:          scTienLenAI.GetLastMove_0(),
						Last_move_1:          scTienLenAI.GetLastMove_1(),
						Last_move_2:          scTienLenAI.GetLastMove_2(),
						Last_move_3:          scTienLenAI.GetLastMove_3(),
						Num_cards_left_0:     int(scTienLenAI.GetNumCardsLeft_0()),
						Num_cards_left_1:     int(scTienLenAI.GetNumCardsLeft_1()),
						Num_cards_left_2:     int(scTienLenAI.GetNumCardsLeft_2()),
						Num_cards_left_3:     int(scTienLenAI.GetNumCardsLeft_3()),
						Other_hand_cards:     scTienLenAI.GetOtherHandCards(),
						Played_cards_0:       scTienLenAI.GetPlayedCards_0(),
						Played_cards_1:       scTienLenAI.GetPlayedCards_1(),
						Played_cards_2:       scTienLenAI.GetPlayedCards_2(),
						Played_cards_3:       scTienLenAI.GetPlayedCards_3(),
						Player_hand_cards:    scTienLenAI.GetPlayerHandCards(),
						Player_position:      int(scTienLenAI.GetPlayerPosition()),
						IsTienLenYule:        scTienLenAI.IsTienLenYule,
						IsFirstHand:          scTienLenAI.IsFirstHand,
						Cards_left_0:         scTienLenAI.CardsLeft_0,
						Cards_left_1:         scTienLenAI.CardsLeft_1,
						Cards_left_2:         scTienLenAI.CardsLeft_2,
						Cards_left_3:         scTienLenAI.CardsLeft_3,
						Last_pos:             scTienLenAI.LastPos,
						IsEnd:                scTienLenAI.IsEnd,
						WinSnids:             scTienLenAI.WinSnids,
						IsWin:                scTienLenAI.IsWin,
					}
				}
			}
		}
	} else {
		logger.Logger.Error("SCTienLenAIHandler package SCTienLenAIData error.")
	}
	return nil
}

func SCRoomEvent(s *netlib.Session, packid int, pack interface{}) error {
	logger.Logger.Tracef("SCRoomEvent %v", pack)
	msg, ok := pack.(*gamehall.SCRoomEvent)
	if !ok {
		return nil
	}

	if msg.Content == "" || len(msg.Param) == 0 {
		return nil
	}

	scene, ok := base.GetScene(s).(*TienLenScene)
	if !ok {
		return nil
	}

	p := scene.GetMe(s)
	if p == nil {
		return nil
	}

	pos, err := strconv.Atoi(msg.GetContent())
	if err != nil {
		return nil
	}
	if p.GetPos() != int32(pos) {
		return nil
	}

	switch msg.Param[0] {
	case common.ItemIDBucket, common.ItemIDSlippers:
		SendEmote(s, scene, p.(*TienLenPlayer), base.Emote3, 3)
	case common.ItemIDLike, common.ItemIDCoffee:
		SendEmote(s, scene, p.(*TienLenPlayer), base.Emote4, 3)
	}

	return nil
}

func init() {
	//SCTienLenRoomInfo
	netlib.RegisterHandler(int(proto_tienlen.TienLenPacketID_PACKET_SCTienLenRoomInfo), &SCTienLenRoomInfoHandler{})
	netlib.RegisterFactory(int(proto_tienlen.TienLenPacketID_PACKET_SCTienLenRoomInfo), &SCTienLenRoomInfoPacketFactory{})
	//SCTienLenPlayerOp
	netlib.RegisterHandler(int(proto_tienlen.TienLenPacketID_PACKET_SCTienLenPlayerOp), &SCTienLenPlayerOpHandler{})
	netlib.RegisterFactory(int(proto_tienlen.TienLenPacketID_PACKET_SCTienLenPlayerOp), &SCTienLenPlayerOpPacketFactory{})
	//SCTienLenRoomState
	netlib.RegisterHandler(int(proto_tienlen.TienLenPacketID_PACKET_SCTienLenRoomState), &SCTienLenRoomStateHandler{})
	netlib.RegisterFactory(int(proto_tienlen.TienLenPacketID_PACKET_SCTienLenRoomState), &SCTienLenRoomStatePacketFactory{})
	//SCTienLenFinalBilled
	netlib.RegisterHandler(int(proto_tienlen.TienLenPacketID_PACKET_SCTienLenGameBilled), &SCTienLenGameBilledHandler{})
	netlib.RegisterFactory(int(proto_tienlen.TienLenPacketID_PACKET_SCTienLenGameBilled), &SCTienLenGameBilledPacketFactory{})
	//SCTienLenCurOpPos
	netlib.RegisterHandler(int(proto_tienlen.TienLenPacketID_PACKET_SCTienLenCurOpPos), &SCTienLenCurOpPosHandler{})
	netlib.RegisterFactory(int(proto_tienlen.TienLenPacketID_PACKET_SCTienLenCurOpPos), &SCTienLenCurOpPosPacketFactory{})
	//SCTienLenCard
	netlib.RegisterHandler(int(proto_tienlen.TienLenPacketID_PACKET_SCTienLenCard), &SCTienLenCardHandler{})
	netlib.RegisterFactory(int(proto_tienlen.TienLenPacketID_PACKET_SCTienLenCard), &SCTienLenCardPacketFactory{})
	//SCTienLenUpdateMasterSnid
	netlib.RegisterHandler(int(proto_tienlen.TienLenPacketID_PACKET_SCTienLenUpdateMasterSnid), &SCTienLenUpdateMasterSnidHandler{})
	netlib.RegisterFactory(int(proto_tienlen.TienLenPacketID_PACKET_SCTienLenUpdateMasterSnid), &SCTienLenUpdateMasterSnidPacketFactory{})
	//SCTienLenAIData
	netlib.RegisterHandler(int(proto_tienlen.TienLenPacketID_PACKET_SCTienLenAI), &SCTienLenAIHandler{})
	netlib.RegisterFactory(int(proto_tienlen.TienLenPacketID_PACKET_SCTienLenAI), &SCTienLenAIPacketFactory{})
	// SCRoomEvent
	netlib.Register(int(gamehall.GameHallPacketID_PACKET_SCRoomEvent), gamehall.SCRoomEvent{}, SCRoomEvent)
}