package room

import (
	"errors"
	"github.com/google/uuid"
	"math/rand"
	"samba/pkg/log"
	"samba/pkg/servername"
	"samba/proto"
	"samba/server/cacheta/poker"
	. "samba/server/cacheta/service"
	. "samba/server/game/baseroom"
	. "samba/server/game/player"
	"samba/stub"
	"samba/util/event"
	"samba/util/model"
	"samba/util/routingKey"
	"samba/util/state"
	"samba/util/util"
	"time"
)

const (
	WaitRealPlayerTimeout = 30 // 30秒等待真人
	RandRobotTimeout      = 10 // 10秒内随机机器人
)

func NewPlayer(uid int64) (*Player, error) {
	p := &Player{UserInfo: &model.UserInfo{UID: uid}}
	return p, p.Load()
}

type GameRoom struct {
	*BaseRoom[*GameSeat]
	*event.Events
	pokers     poker.IPokerGenerator
	pickPokers []*poker.Poker // 摸牌区
	outPokers  []*poker.Poker // 弃牌区

	dealer        int // 庄家座位
	current       int // 当前行动人座位
	roundStartPos int // 本轮中最开始的位置，用于比牌
	round         int // 当前轮

	gameStep GameStep // 游戏状态

	gameNo         string // 本局游戏唯一id
	startTime      time.Time
	endTime        time.Time
	record         *TrucoGameRecord // 战绩玩家查询
	gameLog        *TrucoGameLog    // 游戏操作汇总给后台
	smallGameCount int              // 记录第几小局
	waitSecond     int              // 记录第一个入座玩家等待了几秒，用于分配机器人
}

func NewGameRoom(id, roomType, clubId int) (IRoom, proto.ErrorCode) {
	baseRoom, code := NewBaseRoom[*GameSeat](id, roomType, clubId)
	if code != proto.Ok {
		return nil, code
	}
	room := &GameRoom{
		BaseRoom: baseRoom,
		Events:   event.NewEvents(),
		pokers:   poker.NewCachetaPokers(),

		dealer:  0,
		current: 0,
		round:   0,

		gameStep: GsReadyGame,
		gameNo:   uuid.NewString(),
		//record:      NewTrucoGameRecord(),
		smallGameCount: 0,
	}
	if room.pokers == nil {
		log.Error(room.Log("create room fail.play type:%v", baseRoom.RoomCnf.PlayType))
		return nil, proto.Internal
	}
	room.SetTruthRoom(room)
	room.SetTimerHandler(room)
	if room.RoomCnf.CathetaInitPoint == 0 {
		room.RoomCnf.CathetaInitPoint = 5
	}
	for i := 0; i < room.RoomCnf.MinPlayers; i++ {
		room.Seats = append(room.Seats, &GameSeat{
			BaseSeat: NewBaseSeat(i),
			pokers:   make([]*poker.Poker, 0),
			//ActType:  AtUnknown,
			Point: room.RoomCnf.CathetaInitPoint,
		})
	}
	room.dealer = int(rand.Int31n(int32(len(room.Seats))))
	room.current = room.dealer
	room.roundStartPos = room.current

	if err := CathetaService.QueueBind(QueueName(), routingKey.RoomKey(room.Id()), util.Direct(servername.Cacheta)); err != nil {
		log.Error(err.Error())
	}

	return room, code
}

// 获取金币或者俱乐部币
func (r *GameRoom) getCoin(uid int64) (coins int64) {
	op := model.NewUserResourceOp()
	coins, _ = op.Get(uid, util.Tie[string](r.ClubId() == 0, model.ResCoins, model.ResClubUserScore))
	return coins
}

// 获取金币或者俱乐部币
func (r *GameRoom) getTakeCoin(player *Player) (coins int64) {
	return util.Tie(r.ClubId() == 0, player.TakeCoin, player.TakeClubCoin)
}

func (r *GameRoom) addTakeCoin(player *Player, add int64, reason string) {
	// holdTakeCoin在多开时，是多个房间的总携带，不是本房间的携带
	if r.ClubId() == 0 {
		if holdTakeCoin, ok := model.NewUserResourceOp().AddTakeCoin(player.UID, add); ok {
			player.TakeCoin += add
			res := &proto.ReqAddResource{
				UserId:   player.UID,
				ResValue: add,
				ResType:  model.ResTakeCoins,
				Reason:   reason,
				RoomId:   r.Id(),
				RoomType: r.Type(),
				GameNo:   r.gameNo,
				Desc:     "",
				IsNotify: true,
			}
			model.NewResourceRecord(res, holdTakeCoin).Flush(CathetaService)
		}
	} else {
		log.Error(r.Log("club room:%v has not take_club_coin.room_type:%v play_type:%v club:%v ", r.Id(), r.Type(), r.PlayType(), r.ClubId()))
		//if holdTakeCoin, ok := model.NewUserResourceOp().AddClubTakeCoin(player.UID, add); ok {
		//	player.TakeCoin += add
		//	res := &proto.ReqAddResource{
		//		UserId:   player.UID,
		//		ResValue: add,
		//		ResType:  model.ResTakeClubCoins,
		//		Reason:   reason,
		//		RoomId:   r.Id(),
		//		RoomId: r.Type(),
		//		GetGameNo:   r.gameNo,
		//		Desc:     "",
		//	}
		//	model.NewResourceRecord(res, holdTakeCoin).Flush(CathetaService)
		//}
	}
}

func (r *GameRoom) addResource(player *Player, add int64, resType, reason string) {
	if resType == model.ResTakeCoins {
		r.addTakeCoin(player, add, reason)
	} else {
		resType = util.Tie[string](r.ClubId() == 0, model.ResCoins, model.ResClubUserScore)
		router := routingKey.DbKey(player.UID)
		SendMsgToDb(router, player.UID, proto.ReqAddResourceId, &proto.ReqAddResource{
			UserId:   player.UID,
			ResValue: add,
			ResType:  resType,
			Reason:   reason,
			RoomId:   r.Id(),
			RoomType: r.Type(),
			GameNo:   r.gameNo,
			Desc:     "",
			IsNotify: true,
		})
	}
}

// 大局之前初始化
func (r *GameRoom) ReInit() {
	RoomMgr.Add(r)

	r.startTime = time.Now()
	r.record = NewTrucoGameRecord()
	var err error
	var playingNum int64
	for _, seat := range r.Seats {
		if !seat.Empty() && !seat.Player().IsRobot() {
			num, err1 := model.AddRoomTypePlayerNum(r.RoomCnf, seat.Player().UID)
			if err1 != nil {
				err = errors.Join(err1)
			} else {
				playingNum = num
			}
			seat.Point = r.RoomCnf.CathetaInitPoint
		}
	}
	if err == nil && r.RoomCnf.Mode != int(stub.RmClub) {
		// 金币场 广播虚假在玩人数
		BroadcastMsg(proto.NtfPlayingNumId, &proto.NtfPlayingNum{RoomType: r.RoomCnf.Id, PlayingNum: model.CalculateFakeCount(playingNum)})
	}
	r.record.AddPlayers(r)
	r.gameLog = NewTrucoGameLog(r)
}

func (r *GameRoom) OnMessage(msgId string, msg map[string]interface{}) {
	switch msgId {
	case proto.ReqReadyGameId:
		r.onReady(msg)
	case proto.ReqEmoteId:
		r.onEmote(msg)
	case proto.ReqLeaveRoomId:
		r.onLeaveRoom(msg)
	case proto.ReqEnterRoomId:
		r.onEnterRoom(msg)

	case proto.ReqCachetaTidyPokerId:
		r.onTidyPoker(msg)
	case proto.ReqCachetaPickPokerId:
		r.onPickPoker(msg)
	case proto.ReqCachetaOutPokerId:
		r.onOutPoker(msg)
	case proto.ReqCachetaHuId:
		r.onHu(msg)
	case proto.ReqCachetaReconnectId, proto.ReqReconnectId:
		r.onReconnect(msg)

	case proto.NtfMaintainId:
		r.onMaintain(msg)
	case proto.ReqDisbandRoomId:
		r.onDisbandRoom(msg)
	}
}

func (r *GameRoom) FindSeat(uid int64) *GameSeat {
	for _, seat := range r.Seats {
		if !seat.Empty() && seat.Player().UID == uid {
			return seat
		}
	}
	return nil
}

func (r *GameRoom) GetSeat(uid int64) *GameSeat {
	st := r.FindSeat(uid)
	if st != nil {
		return st
	}
	log.Error(r.Log("player:%d not in any seat", uid))
	return nil
}

func (r *GameRoom) GetSeatNo(uid int64) int {
	for _, seat := range r.Seats {
		if !seat.Empty() && seat.Player().UID == uid {
			return seat.No()
		}
	}
	log.Error(r.Log("player:%d is not in any seat", uid))
	return -1
}

func (r *GameRoom) groupHighToHandPoker(groups []*poker.GroupPokers, high []*poker.Poker) proto.CachetaHandPoker {
	var handPoker proto.CachetaHandPoker
	for _, group := range groups {
		g := proto.GroupPoker{}
		for _, pk := range group.Pokers {
			g.Pokers = append(g.Pokers, pk.ToInt())
		}
		handPoker.Groups = append(handPoker.Groups, &g)
	}
	for _, h := range high {
		handPoker.Pokers = append(handPoker.Pokers, h.ToInt())
	}
	return handPoker
}

// 发牌
func (r *GameRoom) testStraight() []*poker.Poker {
	var pks []*poker.Poker
	pks = append(pks, poker.NewPokerEx(poker.Club, poker.PointA, poker.Ext1))
	pks = append(pks, poker.NewPokerEx(poker.Club, poker.Point2, poker.Ext1))
	pks = append(pks, poker.NewPokerEx(poker.Club, poker.Point3, poker.Ext1))
	pks = append(pks, poker.NewPokerEx(poker.Club, poker.Point4, poker.Ext1))
	pks = append(pks, poker.NewPokerEx(poker.Club, poker.Point5, poker.Ext1))
	pks = append(pks, poker.NewPokerEx(poker.Club, poker.Point6, poker.Ext1))
	pks = append(pks, poker.NewPokerEx(poker.Club, poker.Point7, poker.Ext1))
	pks = append(pks, poker.NewPokerEx(poker.Club, poker.Point8, poker.Ext1))
	pks = append(pks, poker.NewPokerEx(poker.Diamond, poker.Point9, poker.Ext1))
	return pks
}

// 发牌
func (r *GameRoom) dealPoker() {
	r.gameStep = GsDealPoker
	r.pokers.Shuffle()
	begin := 0
	for _, seat := range r.Seats {
		if seat.Empty() {
			continue
		}
		seat.pokers = append(seat.pokers, r.pokers.Pokers()[begin:begin+PlayerPokersNum]...)
		// 调整手牌
		groups, high := poker.FindBestGroupsAndRemains(r.pokers.WildPoker(), seat.pokers)
		seat.handPoker = r.groupHighToHandPoker(groups, high)
		log.Debug(r.SeatLog(seat, "玩家手牌:%v", poker.PokersToString(seat.pokers)))

		begin = begin + PlayerPokersNum
	}
	r.outPokers = append(r.outPokers, r.pokers.Pokers()[begin])
	begin += 1
	r.pickPokers = r.pokers.Pokers()[begin:]
	log.Debug(r.Log("所有牌数量:%v, 摸牌区数据:%v, begin:%v", len(r.pokers.Pokers()), len(r.pickPokers), begin))
}

func (r *GameRoom) playerPokersToPorto(seatNo int) []*proto.CachetaHandPoker {
	var handPokers []*proto.CachetaHandPoker
	for _, seat := range r.Seats {
		if seat.Empty() {
			handPokers = append(handPokers, &proto.CachetaHandPoker{Pokers: make([]int, 0)})
			continue
		}
		if seat.No() == seatNo {
			handPokers = append(handPokers, &seat.handPoker)
		} else {
			handPokers = append(handPokers, &proto.CachetaHandPoker{Pokers: make([]int, PlayerPokersNum)})
		}
	}
	return handPokers
}

// 开始游戏
func (r *GameRoom) GameStart() {
	r.BaseRoom.GameStart()
	RoomMgr.CreateClubRoom(r.ClubId(), r.Type(), NewGameRoom)
	r.smallGameStart()
}

// 小局游戏开始
func (r *GameRoom) smallGameStart() {
	r.smallGameCount++
	log.Debug(r.Log("第%d小局，开始发牌", r.smallGameCount))
	r.record.NewGame()
	r.SetStatus(state.RsGaming)
	exist := false
	for _, st := range r.Seats {
		st.ReInit()
		if st.Empty() {
			continue
		}
		// 清理分数为0的玩家信息
		if st.Point < 1 {
			r.leaveRoom(st, true)
		} else {
			exist = true
			r.TriggerClubMemberPlaying(st.Player().UID, true)
		}
	}
	if !exist {
		log.Error(r.Log("房间所有位置都是空，无法开始"))
		return
	}
	r.current = r.dealer
	r.NextSeat()
	r.dealer = r.current

	r.roundStartPos = r.current
	r.round = 0

	r.dealPoker()
	r.notifyDealPoker()

	r.NewTimer(TtDealPoker, time.Duration(stub.GGlobal.TrucoDealPokerTime)*time.Second, r.CurrentPlayer())
}

// 广播发牌
func (r *GameRoom) notifyDealPoker() {
	// 向玩家发送消息
	rsp := &proto.NtfDealCachetaPokers{
		Time:         0,
		CuttingPoker: 0,
		WildPoker:    nil,
		Poker:        nil,
		Dealer:       r.dealer,
		DropPoker:    r.outPokers[0].ToInt(),
		PickPokerNum: len(r.pickPokers),
		GameCount:    r.smallGameCount,
	}
	if r.pokers.CutPoker() != nil {
		rsp.CuttingPoker = r.pokers.CutPoker().ToInt()
	}
	for _, pk := range r.pokers.WildPokers() {
		rsp.WildPoker = append(rsp.WildPoker, pk.ToInt())
	}
	for _, seat := range r.Seats {
		if !seat.Empty() {
			rsp.Seat = seat.No()
			rsp.Poker = r.playerPokersToPorto(seat.No())
			r.SendMsg(seat.Player(), proto.NtfDealCachetaPokersId, rsp, false)
		}
	}
	log.Debug(r.SeatLog(r.Seats[r.dealer], "庄家:%v", r.dealer))

	rsp.Seat = 0
	rsp.Poker = nil
	for _, seat := range r.Seats {
		if !seat.Empty() {
			rsp.Poker = append(rsp.Poker, &seat.handPoker)
		}
	}
	// 牌局回顾
	r.record.AddAction(proto.NtfDealCachetaPokersId, rsp)
}

func (r *GameRoom) CurrentPlayer() *Player {
	return r.Seats[r.current].Player()
}

func (r *GameRoom) CurrentSeat() *GameSeat {
	return r.Seats[r.current]
}

func (r *GameRoom) NextSeat() {
	for i := r.current + 1; i < r.current+len(r.Seats); i++ {
		seatNo := i % len(r.Seats)
		if seatNo == r.current {
			break
		}
		if !r.Seats[seatNo].Empty() {
			r.current = seatNo
			r.Seats[r.current].ActType = SatPickPokerOrWin
			break
		}
	}
}

//func (r *GameRoom) CutLineSeat() *GameSeat {
//	for i := r.current + 1; i < r.current+len(r.Seats); i++ {
//		seatNo := i % len(r.Seats)
//		if seatNo == r.current {
//			break
//		}
//		if !r.Seats[seatNo].Empty() && r.Seats[seatNo].TingHu {
//			return r.Seats[seatNo]
//		}
//	}
//	return nil
//}

func (r *GameRoom) AutoPlayerPickPoker() {
	if r.Seats[r.current].Player().IsRobot() {
		log.Error(r.SeatLog(r.Seats[r.current], "robot can not trigger timer auto out poker"))
	}

	req := proto.ReqCachetaPickPoker{}
	log.Debug(r.SeatLog(r.Seats[r.current], "自动摸牌"))
	msg := util.MakeMessage(proto.ReqCachetaPickPokerId, req, r.CurrentPlayer().UID, r.Id())
	r.OnMessage(proto.ReqCachetaPickPokerId, msg)
}

func (r *GameRoom) copyHandPoker(hp proto.CachetaHandPoker) proto.CachetaHandPoker {
	var handPoker proto.CachetaHandPoker
	for _, g := range hp.Groups {
		var ng proto.GroupPoker
		ng.Pokers = append(ng.Pokers, g.Pokers...)
		handPoker.Groups = append(handPoker.Groups, &ng)
	}
	handPoker.Pokers = append(handPoker.Pokers, hp.Pokers...)
	return handPoker
}

func (r *GameRoom) AutoPlayerOutPoker() {
	if r.Seats[r.current].Player().IsRobot() {
		log.Error(r.SeatLog(r.Seats[r.current], "robot can not trigger timer auto out poker"))
	}
	seat := r.Seats[r.current]
	// 有牌则出牌
	if len(seat.pokers) > 0 {
		outPoker := 0
		if len(seat.handPoker.Pokers) != 0 {
			pk := seat.handPoker.Pokers[len(seat.handPoker.Pokers)-1]
			for _, p := range seat.pokers {
				if pk == p.ToInt() {
					outPoker = pk
					break
				}
			}
		}
		if outPoker == 0 {
			for i := len(seat.handPoker.Groups) - 1; i >= 0; i-- {
				if len(seat.handPoker.Groups[i].Pokers) != 0 {
					pks := seat.handPoker.Groups[i].Pokers
					pk := pks[len(pks)-1]
					for _, p := range seat.pokers {
						if pk == p.ToInt() {
							outPoker = pk
							break
						}
					}
					if outPoker != 0 {
						break
					}
				}
			}
		}
		if outPoker == 0 {
			outPoker = seat.pokers[len(seat.pokers)-1].ToInt()
		}
		req := proto.ReqCachetaOutPoker{Poker: outPoker}
		log.Debug(r.SeatLog(r.Seats[r.current], "自动出牌:%v", poker.NewPoker(req.Poker).ToString()))
		msg := util.MakeMessage(proto.ReqCachetaOutPokerId, req, r.CurrentPlayer().UID, r.Id())
		r.OnMessage(proto.ReqCachetaOutPokerId, msg)
		return
	}
	log.Error(r.SeatLog(r.Seats[r.current], "poker was empty"))
}

func (r *GameRoom) OnTimer(timerType TimerType, args ...interface{}) {
	r.CancelTimer(timerType)
	switch timerType {
	case TtSecond:
		r.onWaitTimer()
	case TtGameReadyStart:
		if r.SeatPlayerNum() >= r.RoomCnf.MinPlayers && r.Status() != state.RsGaming {
			r.ReInit()
			r.GameStart()
		}
	case TtDealPoker:
		r.PlayerAct(r.CurrentPlayer())

	case TtPlayerAct:
		user := args[0].(*Player)
		if r.CurrentPlayer() == user {
			seat := r.CurrentSeat()
			if seat.ActType == SatPickPokerOrWin {
				r.AutoPlayerPickPoker()
			} else {
				r.AutoPlayerOutPoker()
			}
		} else {
			log.Error(r.SeatLog(r.Seats[r.current], " is not user:%v", user.UID))
		}
	case TtPlayerCutLine:
		r.NextSeat()
		r.PlayerAct(r.CurrentPlayer())

	case TtNextGame:
		r.smallGameStart()
	}
}

// PlayerAct 通知玩家行动
func (r *GameRoom) PlayerAct(user *Player) {
	seat := r.GetSeat(user.UID)
	if seat.No() != r.current {
		log.Error(r.SeatLog(r.GetSeat(user.UID), "is not current:%v", r.current))
		return
	}
	r.gameStep = GsPlayerAct
	r.notifyPlayerAct(seat)
	r.NewTimer(TtPlayerAct, time.Duration(r.RoomCnf.ActTime+stub.GGlobal.TrucoActExTime)*time.Second, user)
}

// 通知玩家行动
func (r *GameRoom) notifyPlayerAct(seat *GameSeat) {
	// 向玩家发送消息
	rsp := &proto.NtfPlayerCachetaAct{
		RoomId:      r.Id(),
		Seat:        r.current,
		Countdown:   r.RoomCnf.ActTime,
		CountdownEx: stub.GGlobal.TrucoActExTime,
		Type:        int(seat.ActType),
		CanWin:      0,
	}
	_, highPokers := poker.FindBestGroupsAndRemains(r.pokers.WildPoker(), seat.pokers)
	if len(highPokers) == 0 || (len(seat.pokers) == poker.HandlerPokerCount+1 && len(highPokers) == 1) {
		rsp.CanWin = 1
	}

	log.Debug(r.SeatLog(seat, "玩家行动:%s", seat.ActType.String()))
	r.Broadcast(proto.NtfPlayerCachetaActId, rsp, true)

	// 牌局回顾
	r.record.AddAction(proto.NtfPlayerCachetaActId, rsp)
}

// 结算
func (r *GameRoom) settlementBySeat(winSeat *GameSeat, highNum int) bool {
	point := util.Tie(highNum == 0, 2, 1)
	//winnerAddPoint := 0
	// 通杀
	bigWinner := 0 // 为1时表明全场只有庄家分数大于0

	for _, st := range r.Seats {
		if st.Empty() {
			continue
		}
		if st.No() != winSeat.No() {
			st.Point = util.Tie(st.Point-point > 0, st.Point-point, 0)
			//winnerAddPoint += point
			//winSeat.Point += point
		}
		if st.Point > 0 {
			bigWinner++
		}

	}

	// 结算消息
	ntf := &proto.NtfCachetaGameSettle{
		SeatSettle: nil,
		NextGame:   util.Tie(bigWinner == 1, 0, 1),
	}
	for _, st := range r.Seats {
		if st.Empty() {
			continue
		}

		seatSettle := &proto.SeatSettle{Seat: st.No(), SumPoint: st.Point, HandPoker: st.HandPoker()}
		if st.No() != winSeat.No() {
			seatSettle.AddPoint = -point
			// 没分数，个人大结算
			if st.Point < 1 {
				seatSettle.AddScore = -r.RoomCnf.Blind
				seatSettle.SumScore = 0
			}
		} else {
			//seatSettle.AddPoint = winnerAddPoint
			// 最终胜利者，大结算
			if bigWinner == 1 {
				seatSettle.AddScore += int64(r.RoomCnf.MinPlayers-1) * r.RoomCnf.Blind
			}
		}
		// 净胜分结算
		if seatSettle.AddScore != 0 {
			if seatSettle.AddScore > 0 {
				tip := seatSettle.AddScore * int64(r.RoomCnf.Rate) / int64(100)
				r.gameLog.Player(st.No()).Tip = tip
				seatSettle.AddScore -= tip
			}
			log.Info(r.SeatLog(st, "赢取金币:%v", seatSettle.AddScore))
			// 机器人输赢汇入总池
			if st.Player().IsRobot() {
				model.AddRobotResourcePool(r.Type(), seatSettle.AddScore, util.Tie[string](r.ClubId() <= 0, model.ResCoins, model.ResClubUserScore))
			}
			r.addResource(st.Player(), -r.RoomCnf.Blind, model.ResTakeCoins, model.ReasonGame)
			if seatSettle.AddScore != 0 {
				r.addResource(st.Player(), seatSettle.AddScore, model.ResCoins, model.ReasonGame)
			}
		}

		ntf.SeatSettle = append(ntf.SeatSettle, seatSettle)
	}
	r.Broadcast(proto.NtfCachetaGameSettleId, ntf, false)
	r.record.AddAction(proto.NtfCachetaGameSettleId, ntf)
	return bigWinner == 1
}

// GameOver 本局游戏结束，会清理部分数据
func (r *GameRoom) GameOver(seat *GameSeat, highNum int) {
	r.gameStep = GsGameSettle
	//log.Debug(r.Log("cancel timer:all timer"))
	r.CancelAllTimer()
	clear(r.LastMsg)

	bigSettle := r.settlementBySeat(seat, highNum)
	if !bigSettle {
		// 开启下一局
		r.NewTimer(TtNextGame, time.Duration(stub.GGlobal.TrucoNextGameTime)*time.Second)
		return
	}

	// 游戏结束
	r.endTime = time.Now()
	// 牌局回顾
	for _, st := range r.Seats {
		if !st.Empty() {
			r.record.AddPlayerRecord(r, st.Player().UID, r.getTakeCoin(st.Player()), r.getTakeCoin(st.Player()), r.ClubId())
		}
	}
	r.record.Flush()
	r.gameLog.Flush(r)

	r.gameStep = GsWaitGame
	// 清理玩家信息
	for _, st := range r.Seats {
		if !st.Empty() {
			r.leaveRoom(st, true)
		}
	}
}

// 离开房间
func (r *GameRoom) SetFakeLeave(uid int64, fake bool) {
	seat := r.GetSeat(uid)
	if seat == nil {
		log.Error(r.Log("player:%d seat is nil", uid))
		return
	}
	if fake {
		log.Debug(r.SeatLog(seat, "玩家假离开, room status:%v", r.gameStep))
		seat.SetFakeLeave(true)
	} else {
		log.Debug(r.SeatLog(seat, "玩家假离开后返回, room status:%v", r.gameStep))
		seat.SetFakeLeave(false)
	}
	r.notifyFakeLeave(seat)
}

// 推送房间信息给玩家
func (r *GameRoom) notifyFakeLeave(seat *GameSeat) {
	ntf := &proto.NtfFakeLeave{
		RoomId:      r.Id(),
		CurrentSeat: seat.No(),
		FakeLeave:   util.Tie(seat.FakeLeave(), 0, 1),
	}
	r.Broadcast(proto.NtfFakeLeaveId, ntf, false)
}

// 推送房间信息给玩家
func (r *GameRoom) notifyRoomInfo(user *Player) {
	ntf := r.makeProtoRoomInfo()
	r.SendMsg(user, proto.NtfCachetaRoomInfoId, ntf, false)
}

// 推送玩家信息给房间里的玩家
func (r *GameRoom) notifyMeToOthers(user *Player) {
	ntf := proto.NtfCachetaPlayerInfo{Players: make([]*proto.CachetaPlayer, 0)}
	ntf.Players = append(ntf.Players, r.makePlayerToProto(r.GetSeat(user.UID), true))
	for _, seat := range r.Seats {
		if !seat.Empty() && seat.Player().UID != user.UID {
			r.SendMsg(seat.Player(), proto.NtfCachetaPlayerInfoId, ntf, false)
		}
	}
}

// 推送玩家信息给房间里的玩家
func (r *GameRoom) notifyOthersToMe(user *Player) {
	ntf := proto.NtfCachetaPlayerInfo{Players: make([]*proto.CachetaPlayer, 0)}
	for _, seat := range r.Seats {
		if !seat.Empty() {
			ntf.Players = append(ntf.Players, r.makePlayerToProto(seat, true))
		}
	}
	r.SendMsg(user, proto.NtfCachetaPlayerInfoId, ntf, false)
}

// 推送玩家信息给房间里的玩家
func (r *GameRoom) notifyPlayerInfo(user *Player, isReentry bool) {
	if !isReentry {
		r.notifyMeToOthers(user)
	}
	r.notifyOthersToMe(user)
}

func (r *GameRoom) SetGmPokers(uid int64, pokers [][]int, ghostPoker int) bool {
	seatNo := 0
	for _, seat := range r.Seats {
		if !seat.Empty() && seat.Player().UID == uid {
			seatNo = seat.No()
			break
		}
	}
	log.Debug(r.SeatLog(r.Seats[seatNo], "玩家:%v seat:%v 配牌:%+v 鬼牌:%v", uid, seatNo, pokers, ghostPoker))
	r.pokers.SetGmPoker(pokers, ghostPoker, seatNo)
	r.pokers.Pokers()
	return true
}

func (r *GameRoom) SetRobotTemper(seatNo int, cnf stub.RobotTemper) {
	seat := r.Seats[seatNo]
	//user := seat.Player()
	if !seat.Empty() && seat.Player().IsRobot() {
		//switch cnf {
		//case stub.RteAplomb:
		//	user.Robot = NewRobotAplomb(cnf, user.UserInfo, seat, r)
		//case stub.RteNormal:
		//	user.Robot = NewRobotNormal(cnf, user.UserInfo, seat, r)
		//case stub.RteRadical:
		//	user.Robot = NewRobotRadical(cnf, user.UserInfo, seat, r)
		//case stub.RteRotten:
		//	user.Robot = NewRobotRotten(cnf, user.UserInfo, seat, r)
		//case stub.RteEvaluation:
		//	user.Robot = NewRobotEvaluation(cnf, user.UserInfo, seat, r)
		//default:
		//	log.Error(r.SeatLog(seat, "初始化机器人失败:%v", cnf.String()))
		//}
		log.Debug(r.SeatLog(seat, "初始化%v机器人", cnf.String()))
	}
}

func (r *GameRoom) StopWaitTimer() {
	r.CancelTimer(TtSecond)
	r.waitSecond = 0
}

func (r *GameRoom) StartWaitTimer() {
	r.NewTimer(TtSecond, time.Second)
}

func (r *GameRoom) onWaitTimer() {
	r.waitSecond++
	// 达到最少人数或者房间不是等待状态，结束等待定时器
	if r.SeatPlayerNum() >= r.RoomCnf.MinPlayers || r.Status() != state.RsWait {
		r.StopWaitTimer()
		return
	}
	// 所有真人都离开，移除机器人
	if r.RealPlayerNum() == 0 {
		for _, st := range r.Seats {
			if !st.Empty() {
				r.leaveRoom(st, false)
			}
		}
		return
	}
	/*
		2.玩家点击匹配后，优先匹配真人：
		1）低于30S（可修改）若匹配到最大人数则立即开始游戏
		2）达到30S时若已经匹配到真人，无论匹配到几个，都立即开始游戏
		3）超过30S依旧未匹配到真人，则匹配1个（可修改）AI，并继续匹配10S（可修改），10S内若匹配到真人则立即开始游戏，若没有匹配到真人达到10S时也立即开始游戏
	*/
	if r.RobotPlayerNum() == 0 && r.waitSecond > WaitRealPlayerTimeout && r.waitSecond > WaitRealPlayerTimeout+rand.Intn(RandRobotTimeout) {
		if robot := RobotMgr.Pop(r.RoomCnf); robot != nil {
			r.OnEnterRoom(robot)
		}
	}
	r.NewTimer(TtSecond, time.Second)
}