require("luaScript.Protocol.ProtocolCommon")

local defs		= require("pk_nanchongdoudizhu.luaScript.Def_53")
local Functions = require("pk_nanchongdoudizhu.luaScript.Functions_53")
local Cmds 		= require("pk_nanchongdoudizhu.luaScript.Protocol.ProtocolCmd_53")
local Messages	= require("pk_nanchongdoudizhu.luaScript.Protocol.ProtocolMessage_53")


local Room = class("Room" , require("luaScript.Protocol.ProtocolRoomBase"))

--队列初始化
local callbackQueue = {}
local callbackRunning = true

function Room:ctor(net)
	Room.super.ctor(self , net)

	-- GPS信息发生变化的时候主动给服务器发消息
	app:addEventListener("onUpdateLoctionSuccessed", handler(self, self.onGpsChangeRequest))
	
	--发送
	-- 请求准备
	self:defMsgFunc{name = "callReadyRequest" , cmd = Cmds.GAME_COMMAND_USER_READY}
	-- 玩家请求解散房间，获取其他玩家回复解散房间
	self:defMsgFunc{name = "dismissRoomRequest", cmd = Cmds.GAME_COMMAND_DISBAND_GAME, sender = Messages.DismissRequest}
	-- 离开房间
	self:defMsgFunc{name = "callLeaveRequest" , cmd = Cmds.GAME_COMMAND_USER_LEAVE}
	
	
	--接收
	-- 玩家进入桌子成功
	self:defPushMsg{cmd = Cmds.GAME_COMMAND_LOGIN_GAME_SUCCESS, reader = Messages.SitDownSuccessResponse, func = handler(self , self.onSitDownSuccessResponse)}
	-- 玩家进入桌子失败
	self:defPushMsg{cmd = Cmds.GAME_COMMAND_LOGIN_GAME_ERR, reader = Messages.SitDownFailedResponse, func = handler(self , self.onSitDownFailedResponse)}
	-- 断线重连
	self:defPushMsg{cmd = Cmds.GAME_COMMAND_GAME_RECONNECTION, reader = Messages.GameReconnection, func = handler(self, self.onGameReconnection)}
	-- 用户退出
	self:defPushMsg{cmd = Cmds.GAME_COMMAND_LOGOUT_GAME_SUCCESS, reader = Messages.UserExitResponse, func = handler(self , self.onUserExitResponse)}
	-- 其他玩家进入桌子
	self:defPushMsg{cmd = Cmds.GAME_COMMAND_BROADCAST_USER_LOGIN, reader = Messages.OtherSitDownResponse, func = handler(self , self.onOtherSitDownResponse)}
	-- 其他玩家掉线
	self:defPushMsg{cmd = Cmds.GAME_COMMAND_BROADCAST_USER_DROPPED, reader = Messages.OtherDroppedResponse, func = handler(self , self.onOtherDroppedResponse)}
	-- 其他玩家退出房间
	self:defPushMsg{cmd = Cmds.GAME_COMMAND_BROADCAST_USER_LOGOUT, reader = Messages.OtherLogoutResponse, func = handler(self , self.onOtherLogoutResponse)}
	-- 收到服务器下发的玩家准备状态
	self:defPushMsg{cmd = Cmds.GAME_COMMAND_BROADCAST_USER_READY, reader = Messages.IntPacket, func = handler(self , self.onUserReadyResponse)}
	
	-- 游戏开始
	self:defPushMsg{cmd = Cmds.cmd_0x8104, reader = Messages.cmd_0x8104_RespStructure, func = handler(self , self.cmd_0x8104_Resp)}
	-- 更新游戏状态
	self:defPushMsg{cmd = Cmds.cmd_0x8105, reader = Messages.cmd_0x8105_RespStructure, func = handler(self , self.cmd_0x8105_Resp)}
	-- 发牌
	self:defPushMsg{cmd = Cmds.cmd_0x8106, reader = Messages.cmd_0x8106_RespStructure, func = handler(self , self.cmd_0x8106_Resp)}
	-- 翻牌信息
	self:defPushMsg{cmd = Cmds.cmd_0x8117, reader = Messages.cmd_0x8117_RespStructure, func = handler(self , self.cmd_0x8117_Resp)}
	-- 选漂
	self:defPushMsg{cmd = Cmds.cmd_0x8115, reader = Messages.cmd_0x8115_RespStructure, func = handler(self , self.cmd_0x8115_Resp)}
	-- 漂结果
	self:defPushMsg{cmd = Cmds.cmd_0x8116, reader = Messages.cmd_0x8116_RespStructure, func = handler(self , self.cmd_0x8116_Resp)}	
	-- 通知玩家是否选择闷抓
	self:defPushMsg{cmd = Cmds.cmd_0x8118, reader = Messages.cmd_0x8118_RespStructure, func = handler(self , self.cmd_0x8118_Resp)}	
	-- 通知玩家闷抓结果
	self:defPushMsg{cmd = Cmds.cmd_0x8119, reader = Messages.cmd_0x8119_RespStructure, func = handler(self , self.cmd_0x8119_Resp)}
	-- 通知玩家是否闷拉
	self:defPushMsg{cmd = Cmds.cmd_0x811b, reader = Messages.cmd_0x811b_RespStructure, func = handler(self , self.cmd_0x811b_Resp)}	
	-- 广播玩家闷拉结果
	self:defPushMsg{cmd = Cmds.cmd_0x811c, reader = Messages.cmd_0x811c_RespStructure, func = handler(self , self.cmd_0x811c_Resp)}
	-- 通知玩家叫分
	self:defPushMsg{cmd = Cmds.cmd_0x8108, reader = Messages.cmd_0x8108_RespStructure, func = handler(self , self.cmd_0x8108_Resp)}
	-- 广播叫分结果
	self:defPushMsg{cmd = Cmds.cmd_0x8109, reader = Messages.cmd_0x8109_RespStructure, func = handler(self , self.cmd_0x8109_Resp)}	
	-- 叫分结果，将底牌发给地主
	self:defPushMsg{cmd = Cmds.cmd_0x810a, reader = Messages.cmd_0x810a_RespStructure, func = handler(self , self.cmd_0x810a_Resp)}	
	-- 通知加倍
	self:defPushMsg{cmd = Cmds.cmd_0x810c, reader = Messages.cmd_0x810c_RespStructure, func = handler(self , self.cmd_0x810c_Resp)}	
	-- 广播玩家加倍结果
	self:defPushMsg{cmd = Cmds.cmd_0x810d, reader = Messages.cmd_0x810d_RespStructure, func = handler(self , self.cmd_0x810d_Resp)}	
	-- 玩家出牌轮次广播
	self:defPushMsg{cmd = Cmds.cmd_0x810e, reader = Messages.cmd_0x810e_RespStructure, func = handler(self , self.cmd_0x810e_Resp)}	
	-- 玩家出牌错误
	self:defPushMsg{cmd = Cmds.cmd_0x810f, reader = Messages.cmd_0x810f_RespStructure, func = handler(self , self.cmd_0x810f_Resp)}	
	-- 玩家出牌成功
	self:defPushMsg{cmd = Cmds.cmd_0x8110, reader = Messages.cmd_0x8110_RespStructure, func = handler(self , self.cmd_0x8110_Resp)}	
	-- 倍率发生变化
	self:defPushMsg{cmd = Cmds.cmd_0x8111, reader = Messages.cmd_0x8111_RespStructure, func = handler(self , self.cmd_0x8111_Resp)}	
	-- 小局结算
	self:defPushMsg{cmd = Cmds.cmd_0x8112, reader = Messages.cmd_0x8112_RespStructure, func = handler(self , self.cmd_0x8112_Resp)}	
	-- 总结算
	self:defPushMsg{cmd = Cmds.cmd_0x8113, reader = Messages.cmd_0x8113_RespStructure, func = handler(self , self.cmd_0x8113_Resp)}	
	-- 无人叫分重新洗牌
	self:defPushMsg{cmd = Cmds.cmd_0x8114, reader = Messages.cmd_0x8114_RespStructure, func = handler(self , self.cmd_0x8114_Resp)}	

	-- 玩家收到解散房间的请求
	self:defPushMsg{cmd = Cmds.GAME_COMMAND_BROADCAST_DISBAND_GAME,	reader = Messages.DismissResponse, func = handler(self , self.onDismissResponse)}
	-- 收到玩家申请解散房间
	self:defPushMsg{cmd = Cmds.GAME_COMMAND_DISBAND_GAME,	reader = Messages.DismissResult, func = handler(self , self.onUserDismissResultResponse)}
	-- 收到玩家申请立即开局
	self:defPushMsg{cmd = Cmds.GAME_COMMAND_RESPONSE_EARLY_START,	reader = Messages.EarlyStartResult, func = handler(self , self.onQuickStartResponse)}
end

-- 无人叫分重新洗牌
function Room:cmd_0x8114_Resp(status, response)
	if not self.roomInfo then
		logD("self.roomInfo no exist,容错处理!")
		return
	end
	
	logD("Room:cmd_0x8114_Resp(), ", table.tostring(response))
	
	-- 发送广播通知
	self:dispatchEvent({name = "cmd_0x8114_Resp", response = response})	
end

-- 总结算
function Room:cmd_0x8113_Resp(status, response)
	if not self.roomInfo then
		logD("self.roomInfo no exist,容错处理!")
		return
	end
	
	logD("Room:cmd_0x8113_Resp(), ", table.tostring(response))
	
	self.roomInfo.isGameOver = 1
	self.roomInfo._GameOverInfo = response
	self.roomInfo._stopFlag = response.stopFlag

	-- 发送广播通知
	self:dispatchEvent({name = "cmd_0x8113_Resp", response = response})	
end

-- 小局结算
function Room:cmd_0x8112_Resp(status, response)
	if not self.roomInfo then
		logD("self.roomInfo no exist,容错处理!")
		return
	end
	
	logD("Room:cmd_0x8112_Resp(), ", table.tostring(response))
	
	self.roomInfo.isGameOver = response.isGameOver
	
	for _,v in pairs(response.memberList) do
		self.roomInfo.memberList[v.nUserId].nTotalScore = v.nTotalScore
	end
	
	-- 强制把操作数据添加到memberList里面，因为小结算直接用的发来的repsonse数据而不是self.roomInfo.memberList
	for _, v in pairs(response.memberOperateData) do
		response.memberList[v.nUserId].ext = v.ext  
		response.memberList[v.nUserId].nMenZhuaState = v.nMenZhuaState
		response.memberList[v.nUserId].nMenLaState = v.nMenLaState
		response.memberList[v.nUserId].nDaoState = v.nDaoState
		response.memberList[v.nUserId].nLaState = v.nLaState
		response.memberList[v.nUserId].nPiaoState = v.nPiaoState
	end

	-- 发送广播通知
	self:dispatchEvent({name = "cmd_0x8112_Resp", response = response})	
end

-- 倍率发生变化
function Room:cmd_0x8111_Resp(status, response)
	if not self.roomInfo then
		logD("self.roomInfo no exist,容错处理!")
		return
	end
	
	logD("Room:cmd_0x8111_Resp(), ", table.tostring(response))
	
	self.roomInfo.nBombs = response.nBombs
	self.roomInfo.curAskLoard = response.baseScore

	-- 发送广播通知
	self:dispatchEvent({name = "cmd_0x8111_Resp", response = response})	
end

-- 玩家出牌成功
function Room:cmd_0x8110_Resp(status, response)
	if not self.roomInfo then
		logD("self.roomInfo no exist,容错处理!")
		return
	end
	
	logD("Room:cmd_0x8110_Resp(), ", table.tostring(response))
	
	-- 发送广播通知
	self:dispatchEvent({name = "cmd_0x8110_Resp", response = response})	
end

-- 玩家出牌错误
function Room:cmd_0x810f_Resp(status, response)
	if not self.roomInfo then
		logD("self.roomInfo no exist,容错处理!")
		return
	end
	
	logD("Room:cmd_0x810f_Resp(), ", table.tostring(response))
	
	-- 发送广播通知
	self:dispatchEvent({name = "cmd_0x810f_Resp", response = response})	
end

-- 玩家出牌轮次广播
function Room:cmd_0x810e_Resp(status, response)
	if not self.roomInfo then
		logD("self.roomInfo no exist,容错处理!")
		return
	end
	
	logD("Room:cmd_0x810e_Resp(), ", table.tostring(response))
	
	-- 发送广播通知
	self:dispatchEvent({name = "cmd_0x810e_Resp", response = response})	
end

-- 广播玩家加倍结果
function Room:cmd_0x810d_Resp(status, response)
	if not self.roomInfo then
		logD("self.roomInfo no exist,容错处理!")
		return
	end
	
	logD("Room:cmd_0x810d_Resp(), ", table.tostring(response))
	
	self.roomInfo.memberList[response.nUserId].askBei = response.askBei
	self.roomInfo.memberList[response.nUserId].nDaoState = response.askBei
	self.roomInfo.memberList[response.nUserId].nLaState = response.askBei
	
	-- 发送广播通知
	self:dispatchEvent({name = "cmd_0x810d_Resp", response = response})	
end

-- 通知加倍
function Room:cmd_0x810c_Resp(status, response)
	if not self.roomInfo then
		logD("self.roomInfo no exist,容错处理!")
		return
	end
	
	logD("Room:cmd_0x810c_Resp(), ", table.tostring(response))
	
	-- 发送广播通知
	self:dispatchEvent({name = "cmd_0x810c_Resp", response = response})	
end

-- 叫分结果，将底牌发给地主
function Room:cmd_0x810a_Resp(status, response)
	if not self.roomInfo then
		logD("self.roomInfo no exist,容错处理!")
		return
	end
	
	logD("Room:cmd_0x810a_Resp(), ", table.tostring(response))
	
	for k,v in pairs(response.Datas) do
		self.roomInfo[k] = v
	end
	
	-- 发送广播通知
	self:dispatchEvent({name = "cmd_0x810a_Resp", response = response})	
end

-- 通知玩家叫分
function Room:cmd_0x8108_Resp(status, response)
	if not self.roomInfo then
		logD("self.roomInfo no exist,容错处理!")
		return
	end
	
	logD("Room:cmd_0x8108_Resp(), ", table.tostring(response))
	
	self.roomInfo.memberList[response.nUserId].askLoard = response.askLoard
	
	-- 发送广播通知
	self:dispatchEvent({name = "cmd_0x8108_Resp", response = response})	
end

-- 发牌
function Room:cmd_0x8106_Resp(status, response)
	if not self.roomInfo then
		logD("self.roomInfo no exist,容错处理!")
		return
	end
	
	logD("Room:cmd_0x8106_Resp(), ", table.tostring(response))
	
	self.roomInfo.memberList[response.nUserId].handCards = response.handCards
	
	-- 发送广播通知
	self:dispatchEvent({name = "cmd_0x8106_Resp"})	
end

-- 翻牌信息
function Room:cmd_0x8117_Resp(status, response)
	if not self.roomInfo then
		logD("self.roomInfo no exist,容错处理!")
		return
	end
	
	logD("Room:cmd_0x8117_Resp(), ", table.tostring(response))
	
	self.roomInfo.nGameStartCount = response.Datas.nGameStartCount
	
	-- 发送广播通知
	self:dispatchEvent({name = "cmd_0x8117_Resp", response = response})	
end

-- 选漂
function Room:cmd_0x8115_Resp(status, response)
	if not self.roomInfo then
		logD("self.roomInfo no exist,容错处理!")
		return
	end
	
	logD("Room:cmd_0x8115_Resp(), ", table.tostring(response))

	self.roomInfo.nGameStartCount = response.Datas.nGameStartCount
	
	-- 发送广播通知
	self:dispatchEvent({name = "cmd_0x8115_Resp", response = response})	
end

-- 漂结果
function Room:cmd_0x8116_Resp(status, response)
	if not self.roomInfo then
		logD("self.roomInfo no exist,容错处理!")
		return
	end
	
	logD("Room:cmd_0x8116_Resp(), ", table.tostring(response))
	
	self.roomInfo.memberList[response.nUserId].nPiaoState = response.nPiaoState

	-- 发送广播通知
	self:dispatchEvent({name = "cmd_0x8116_Resp", response = response})	
end

-- 通知玩家是否选择闷抓
function Room:cmd_0x8118_Resp(status, response)
	if not self.roomInfo then
		logD("self.roomInfo no exist,容错处理!")
		return
	end
	
	logD("Room:cmd_0x8118_Resp(), ", table.tostring(response))

	-- 通知闷抓，重置数据
	if response.nMenZhuaState <= defs.MEN_STATE.MEN_STATE_ZHUAI then
		self.roomInfo.menZhuaUserId = 0
	end

	-- 发送广播通知
	self:dispatchEvent({name = "cmd_0x8118_Resp", response = response})	
end

-- 广播玩家闷抓结果
function Room:cmd_0x8119_Resp(status, response)
	if not self.roomInfo then
		logD("self.roomInfo no exist,容错处理!")
		return
	end
	
	logD("Room:cmd_0x8119_Resp(), ", table.tostring(response))
	
	-- 记录闷抓的玩家
	if response.nMenZhuaState == defs.MEN_STATE.MEN_STATE_ZHUAI then
		self.roomInfo.menZhuaUserId = response.nUserId
	end

	-- 记录闷倒的玩家，保存到自己的内容
	self.roomInfo.memberList[response.nUserId].nMenZhuaState = response.nMenZhuaState

	-- 发送广播通知
	self:dispatchEvent({name = "cmd_0x8119_Resp", response = response})	
end


-- 通知玩家是否闷拉
function Room:cmd_0x811b_Resp(status, response)
	if not self.roomInfo then
		logD("self.roomInfo no exist,容错处理!")
		return
	end
	
	logD("Room:cmd_0x811b_Resp(), ", table.tostring(response))
	
	-- 发送广播通知
	self:dispatchEvent({name = "cmd_0x811b_Resp", response = response})	
end

-- 广播玩家闷拉结果
function Room:cmd_0x811c_Resp(status, response)
	if not self.roomInfo then
		logD("self.roomInfo no exist,容错处理!")
		return
	end
	
	logD("Room:cmd_0x811c_Resp(), ", table.tostring(response))
	
	-- 记录闷倒的玩家，保存到自己的内容内
	self.roomInfo.memberList[response.nUserId].nMenLaState = response.nMenLaState

	-- 发送广播通知
	self:dispatchEvent({name = "cmd_0x811c_Resp", response = response})	
end

-- 更新游戏状态
function Room:cmd_0x8105_Resp(status, response)
	if not self.roomInfo then
		logD("self.roomInfo no exist,容错处理!")
		return
	end
	
	logD("Room:cmd_0x8105_Resp(), ", table.tostring(response))
	
	self.roomInfo.nStatus = response.nStatus
	
	-- 发送广播通知
	self:dispatchEvent({name = "cmd_0x8105_Resp", response = response})	
end

-- 游戏开始
function Room:cmd_0x8104_Resp(status, response)
	if not self.roomInfo then
		logD("self.roomInfo no exist,容错处理!")
		return
	end
	
	logD("Room:cmd_0x8104_Resp(), ", table.tostring(response))
	
	for k,v in pairs(response.Datas) do
		self.roomInfo[k] = v
	end
	
	--重置准备状态
	for _,v in pairs(self.roomInfo.memberList) do
		v.nPlayerFlag = 0
	end
	--重置叫分
	self.roomInfo.curAskLoard = 0
	
	-- 发送广播通知
	self:dispatchEvent({name = "cmd_0x8104_Resp", response = response})	
end

-- 广播叫分结果
function Room:cmd_0x8109_Resp(status, response)
	if not self.roomInfo then
		logD("self.roomInfo no exist,容错处理!")
		return
	end
	
	logD("Room:cmd_0x8109_Resp(), ", table.tostring(response))
	
	if response.askLoard ~= 0 then
		self.roomInfo.curAskLoard = response.askLoard
	end
	
	-- 发送广播通知
	self:dispatchEvent({name = "cmd_0x8109_Resp", response = response})	
end

--8012
function Room:onDismissResponse(status, response)
	--[[-- nUserId
	, defVar("nUserId", VT_Int, 0)
    -- 1: 表示发起解散  2：同意解散 3：不同意解散
    , defVar("operateType", VT_UChar, 0)
	-- 剩余解散超时时间
    , defVar("timeLeft", VT_Short, 0)		--]]
	if not self.roomInfo then
		logD("self.roomInfo no exist,容错处理!")
		return
	end	

	local nUserId = response.nUserId
	local operateType = response.operateType
	
	-- 收到玩家发起请求时，数据重置
	if response.operateType == 1 then
		self:resetDismissData()
	end
	
	--数据记录
	self.dismissInfo[nUserId] = operateType
	self:dispatchEvent({name = "onDismissResponse", response = response})
end

-- 发起请求回复 8011
function Room:onUserDismissResultResponse(status, response)
	logD("User:onUserDismissResultResponse, ", table.tostring(response))
	if not self.roomInfo then
		logD("self.roomInfo no exist,容错处理!")
		return
	end
	--[[
	-- 0：成功   
	-- 1：operateType取值范围不对  
	-- 2：当前没人发起解散  
	-- 3：已经有人申请解散
    , defVar("errorCode", VT_Short, 0)
    -- 玩家操作
    , defVar("operateType", VT_Int, 0)
	
	-- 桌子上其他用户数量
	, defVar("memberList", VT_VectorToMap(UserDismissResult, "nUserId"))
	-- 剩余解散超时时间
    , defVar("timeLeft", VT_Short, 0)	--]]
	
	logD("30000000--runUserDismissResultResponse")
	if response.errorCode == 1 then
		showTooltip("operateType取值范围不对")
	elseif response.errorCode == 2 then
		showTooltip("当前没人发起解散")
	elseif response.errorCode == 3 then
		showTooltip("已经有人申请解散")
	elseif response.errorCode == 4 then
		showTooltip("用户已经操作过")
	else
		-- 其他玩家的解散状态
		for uid, value in pairs(response.memberList) do
			self.dismissInfo[uid] = value.dismissState
		end
		self:dispatchEvent({name = "onDismissResponse", response = response})
	end
end

-- 服务器下发玩家GPS数据发生变化
function Room:onGpsChangeResponse(status, response)
	print("Room:onGpsChangeResponse()", table.tostring(response))
	
	--[[
--server收到0x8060协议后，广播当前桌子上所有用户
ServerChangeUserInfo = defClass("ServerChangeUserInfo"
	--更新信息的用户uid
	, defVar("uid", VT_Int, -1)
	--用户信息
	, defVar("userInfo", VT_String, "")
	--保留字段，暂不使用
	, defVar("reserved", VT_String, "")
)
	--]]
	
	print("Room:onGpsChangeResponse()", table.tostring(response))
	
	local nUserId = response.uid
	local memberInfo = self.roomInfo.memberList[nUserId]
	if memberInfo then
		memberInfo.userInfo = response.userInfo
	end
	
	self:dispatchEvent({name = "onGpsChangeResponse", nUserId = nUserId})
end

--辅助查找
-- 通过玩家逻辑椅子号找到玩家ID
function Room:getUserIdBySeatId(seatId)
	return self.seatList[seatId]
end

-- 通过玩家视图椅子号找到玩家ID
function Room:getUserIdByViewId(seatShowId)
	return self.seatShowList[seatShowId]
end

-- 通过玩家逻辑椅子号找到视图椅子号
function Room:getViewIdBySeatId(nSeatId)
	local userid = self:getUserIdBySeatId(nSeatId)
	return self:getViewIdByUserId(userid)
end

-- 通过玩家视图椅子号找到逻辑椅子号
function Room:getSeatIdByViewId(nViewId)
	local userid = self:getUserIdByViewId(nViewId)
	for seatId,nUserId in pairs(self.seatList) do
		if userid == nUserId then
			return seatId
		end
	end
end

-- return table of userInfo, not string
function Room:getUserInfo(nUserId)
	if self.roomInfo.memberList[nUserId] then
		return json.decode(self.roomInfo.memberList[nUserId].userInfo)
	else
		return nil
	end
end

-- 发起请求立即开局
function Room:requestQuickStart(opType)
	--0初始状态 1申请开始游戏 2同意开始游戏 3不同意开始游戏
	local request = Messages.EarlyStartRequest:new()
	request.optType = opType
	self:sendResponse{cmd = Cmds.GAME_COMMAND_REQUEST_EARLY_START , sender = request}
end

-- 立即开局结果
function Room:onQuickStartResponse(status, response)
	if not self.roomInfo then
		logD("self.roomInfo no exist,容错处理!")
		return
	end	
	
	self.nleftStartGameTimeout = response.nleftStartGameTimeout
	self.quickStartInfo = {}
	for i,v in pairs(response.earlyStartPlayerInfo) do
		self.quickStartInfo[v.nUserId] = v.optType
	end
	
	self:dispatchEvent({name = "onQuickStartResponse", response = response})
end

function Room:resetDismissData()
	--玩家解散数据(userId 为Key,解散类型为value)
	self.dismissInfo = {}
	
	--解散总时间
	self.roomInfo.nDismissToTalTime = nil
	
	-- 解散倒计时
	self.roomInfo.nDismissStateTime = nil
	
	-- 解散显示
	self.roomInfo.nShowDismiss = false
end

function Room:initRoomInfo()
	self.roomInfo = {}
	
	self.seatShowList = {}
	
	self:resetDismissData()
	
	--手牌数据
	self.cards = {}
end

-- 通知服务器玩家GPS数据发生变化
function Room:onGpsChangeRequest()
	print("Room:onUserInfoChangeRequest()")
	
	local request = StringPacket:new()
	request.stringValue = app.user.userInfo or ""
	
	logD("Room:onGpsChangeRequest()", table.tostring(request))
	self:sendResponse{cmd = Cmds.GAME_COMMAND_CLIENT_CHANGE_USERINFO , sender = request}
end


-- 玩家进入桌子成功
function Room:onSitDownSuccessResponse(status, response)
	logD("--------------------玩家进入桌子成功--------------------")
	logD("Room:onSitDownSuccessResponse(), ", table.tostring(response))
	
	app.net:onMsgClear()
	app.net:onMsgPause()
	
	-- 记录当前桌子号
	self:initRoomInfo()
	
	-- 获取到的房间信息
	for k,v in pairs(response.Datas) do
		self.roomInfo[k] = v
	end
	
	--设置默认数据
	self.roomInfo.nGameStartCount = self.roomInfo.nGameStartCount or 0

	local gameinfo = json.decode(self.roomInfo.strGameInfo)
	
	self.roomInfo.gameinfo = gameinfo
	
	--俱乐部标志
	self.roomInfo.clubId = gameinfo.clubId
	
	-- 更新椅子号
	self:updateUserSeateShowId()
	
	logD("Room:onSitDownSuccessResponse() roomInfo = ", table.tostring(self.roomInfo))
	
	-- 发送通知
	self:dispatchEvent({name = "onEnterRoomSuccess", gameId = GAME_IDS.NanChongDouDiZhu, gameType = gameinfo.gamerule})	
end

-- 玩家进入桌子失败
function Room:onSitDownFailedResponse(status, response)
	logD("--------------------玩家进入桌子失败--------------------")
	app.waitDialogManager:closeWaitNetworkDialog()
	local errorCode = response.nErrorCode
	local errorString = ENTER_ROOM_RET_STR[errorCode] or string.format("坐下失败 errorCode = %s", errorCode)
	showTooltip(errorString)
end

function Room:getMyRecordUserId()
	local myUserId = app.user.loginInfo.uid
	local minID = 0
	local isFind = false
	for k,v in pairsByKeys(self.roomInfo.memberList) do
		if myUserId == v.nUserId then
			return myUserId
		end
		if not isFind then
			minID = v.nUserId
			isFind = true
		end
	end
	return minID
end


-- 检查此桌是否有此ID玩家
function Room:checkUserIDIsInTable(nUserId)
	if self.roomInfo.memberList then
		local memberInfo = self.roomInfo.memberList[nUserId]
		if memberInfo then
			return true
		else
			return false
		end
	else
		return false
	end
end

-- 获取桌子上实际人数
function Room:getActualPlayerNum()
	local playernum = 0
	for i,v in pairs(self.roomInfo.memberList) do
		if self:checkUserIDIsInTable(i) then
			playernum = playernum + 1
		end
	end
	return playernum
end

-- 更新玩家的相对椅子号
function Room:updateUserSeateShowId()
	local myUserId = self:getMyRecordUserId()
	local mySeatId = self.roomInfo.memberList[myUserId].nSeatId

	self.roomInfo.nUserId = myUserId
	self.roomInfo.nSeatId = mySeatId
	
	local serverSeatToViewSeat = {
		[4] = {
			[0] = 4,
			[1] = 1,
			[2] = 2,
			[3] = 3,
		},
		[3] = {
			[0] = 4,
			[1] = 1,
			[2] = 3,
		},
		[2] = {
			[0] = 4,
			[1] = 2,
		}
	}
	self.seatList = {}
	self.userList = {}
	self.seatShowList = {}
	for k,v in pairs(self.roomInfo.memberList) do
		local relativeSeat = (v.nSeatId - mySeatId + self.roomInfo.nMaxPlayCount) % self.roomInfo.nMaxPlayCount
		local nSeatShowId = serverSeatToViewSeat[self.roomInfo.nMaxPlayCount][relativeSeat]
		self.seatShowList[nSeatShowId] = v.nUserId
		self.userList[v.nUserId] = nSeatShowId
		self.seatList[v.nSeatId] = v.nUserId
	end
	
	logD("User:updateUserSeateShowId(),seatShowList", table.tostring(self.seatShowList))
	logD("User:updateUserSeateShowId(),seatList ", table.tostring(self.seatList))
	logD("User:updateUserSeateShowId(),userList ", table.tostring(self.userList))
end

--断线重连
function Room:onGameReconnection(status,response)
	logD("===============重连成功，清空之前所有存在的队列==================")
	
	app.net:onMsgClear()
	app.net:onMsgPause()
	logD(" = ", table.tostring(response))
	self:initRoomInfo()
	
	-- 获取到的房间信息
	for k,v in pairs(response.Datas) do 
		self.roomInfo[k] = v
	end

	local gameinfo = json.decode(self.roomInfo.strGameInfo)
	
	self.roomInfo.gameinfo = gameinfo

	--俱乐部标志
    self.roomInfo.clubId = gameinfo.clubId
	
	--当前叫分
	self.roomInfo.curAskLoard = 1
	for k,v in pairs(self.roomInfo.memberList) do
		--最大叫分
		if v.askLoard > self.roomInfo.curAskLoard then
			self.roomInfo.curAskLoard = v.askLoard
		end

		-- 记录闷抓的玩家	
		if v.nMenZhuaState == defs.MEN_STATE.MEN_STATE_ZHUAI then
			self.roomInfo.menZhuaUserId = v.nUserId
		end

		--加倍状态
		v.askBei = v.bAskBei == 1 and v.askBei == 2 and 1 or 0
	end
	
	-- 更新椅子号
	self:updateUserSeateShowId()
	
	--小局结算
	if self.roomInfo.nStatus == defs.GAME_STATUS.ROUND_OVER then
		local myMemberInfo = self.roomInfo.memberList[self:getMyUserId()]
		--已经准备，则重置一些状态
		if myMemberInfo.nPlayerFlag == 1 then
			--庄家
			self.roomInfo.nBankerId = 0
			--玩家数据
			for k,v in pairs(self.roomInfo.memberList) do
				--加倍状态
				v.askBei = 0
				--手牌
				v.handCards.Datas = {}
			end
		end
	end
	
	-- 发送通知
	self:dispatchEvent({name = "onEnterRoomSuccess", gameId = GAME_IDS.NanChongDouDiZhu, gameType = gameinfo.gamerule})
end

-- 通过玩家ID获取玩家展示的座位号
function Room:getViewIdByUserId(nUserId)
	return self.userList[nUserId]
end

-- 我发起请求解散房间
function Room:requestDismissRoom(opType)
	--1: 表示发起解散  2：同意解散 3：不同意解散
	local request = Messages.DismissRequest:new()
	request.operateType = opType
	self:sendResponse{cmd = Cmds.GAME_COMMAND_DISBAND_GAME , sender = request}
end

function Room:onUserExitResponse(status, response)
	logD("Room:onUserExitResponse(), ", table.tostring(response))
	if not self.roomInfo then
		logD("self.roomInfo no exist, 容错处理!")
		return
	end
	
	local ttExtInfo = string.split(response.userInfo, ",")
	app.user.loginInfo.historyCardNum = ttExtInfo[1]
	app.user.loginInfo.curCardNum = ttExtInfo[2]
	
	self:dispatchEvent({name = "onUserExitResponseRoom",response = response})
end

-- 其他玩家进入桌子
function Room:onOtherSitDownResponse(status, response)
	logD("Room:onOtherSitDownResponse(), response = ", table.tostring(response))
	if not self.roomInfo then
		logD("self.roomInfo no exist,容错处理!")
		return
	end
	
	self.roomInfo.memberList[response.nUserId] = response
	
	-- 更新椅子号
	self:updateUserSeateShowId()

	-- 发送广播通知，某个位置有人坐下了
	self:dispatchEvent({name = "onOtherSitDownResponse", response = response})	
end

-- 其他玩家是否掉线
function Room:onOtherDroppedResponse(status, response)
	logD("User:onOtherDroppedResponse(), response = ", table.tostring(response))
	
	local memberInfo = self.roomInfo.memberList[response.nUserId]
	if memberInfo then
		memberInfo.nOnlineStatus = response.nOnlineStatus
	end
	
	self:dispatchEvent({name = "onOtherDroppedResponse", response = response})	
end

-- 其他玩家退出房间
function Room:onOtherLogoutResponse(status, response)
	logD("Room:onOtherLogoutResponse(), response = ", table.tostring(response))
	
	if not self.roomInfo then
		logD("self.roomInfo no exist,容错处理!")
		return
	end
	
	--已开局玩家不可退出（不做处理）
	if (self.roomInfo.nGameStartCount or 0) > 0 then
		logD("onOtherLogoutResponse 已开局玩家不可退出")
		return
	end
	
	response.viewId = self:getViewIdByUserId(response.nUserId)

	self.roomInfo.memberList[response.nUserId] = nil

	self:dispatchEvent({name = "onOtherLogoutResponse", response = response})
end

-- 服务器下发玩家的准备状态
function Room:onUserReadyResponse(status, response)
	logD("Room:onUserReadyResponse(), ", table.tostring(response))
	
	if not self.roomInfo then
		logD("self.roomInfo no exist,容错处理!")
		return
	end
	
	if response.nUserId == self:getMyUserId() then
		--重置庄家
		self.roomInfo.nBankerId = 0
		
		--重置炸弹数量
		self.roomInfo.nBombs = 0
		
		--重置加倍
		for k,v in pairs(self.roomInfo.memberList) do
			v.askBei = 0
			v.nDaoState = -1
			v.nMenLaState = -1
			v.nDaoState = -1
			v.nLaState = -1
		end
	end
	
	--标记准备了
	self.roomInfo.memberList[response.nUserId].nPlayerFlag = 1
	
	self:dispatchEvent({name = "onUserReadyResponse", response = response})
end

function Room:getMyUserId()
	return self:getUserIdByViewId(defs.VIEW_ID.MY_VIEW_ID)
end

-- 玩家地主选择(抓)
function Room:sendAskLoard(askLoard)
	local request = Messages.AskLoard:new()
	request.askLoard = askLoard
	self:sendResponse{cmd = Cmds.cmd_0x8109 , sender = request}
	print('发送抓', askLoard)
end

-- 玩家加倍选择(倒or拉)
function Room:sendAskBeiOrLa(askBeiOrLa)
	local request = Messages.AskBei:new()
	request.askBei = askBeiOrLa
	self:sendResponse{cmd = Cmds.cmd_0x810d , sender = request}
	print('发送倒or拉(可看枚举defs.DAO_STATE)', askBeiOrLa)
end

-- 玩家飘选择
function Room:sendPiao(piao)
	local request = Messages.cmd_0x811e_RespStructure:new()
	request.choosePiao = piao
	self:sendResponse{cmd = Cmds.cmd_0x811e , sender = request}
	print('发送飘', piao)
end

-- 玩家闷抓/闷倒选择
function Room:sendMenZhuaOrMenDao(menZhua)
	local request = Messages.cmd_0x811a_RespStructure:new()
	request.nMenZhua = menZhua
	self:sendResponse{cmd = Cmds.cmd_0x811a , sender = request}
	print('发送闷抓or闷倒(可看枚举defs.MEN_STATE)', menZhua)
end

-- 玩家闷拉选择
function Room:sendMenLa(menLa)
	local request = Messages.cmd_0x811d_RespStructure:new()
	request.nMenLa = menLa
	self:sendResponse{cmd = Cmds.cmd_0x811d , sender = request}
	print('发送闷拉', menLa)
end

function Room:sendOperation(data)
	local request = Messages.Operation:new()
	request.opType = data.opType
	for _,v in ipairs(data.cards) do
		table.insert(request.cards.Datas, v)
	end
	for _, v in ipairs(data.lzCards) do
		table.insert(request.lzCards.Datas, v)
	end
	self:sendResponse{cmd = Cmds.cmd_0x810f , sender = request}
end

return Room