#include "PrivateMission.h"
#include "PopScene.h"
#include "Utility.h"
#include "JniFun.h"

PrivateMission::PrivateMission()
{
	m_pGameServerItem = nullptr;

	m_wMeTableID = INVALID_TABLE;
	m_wMeChairID = INVALID_CHAIR;

	zeromemory(&m_kCreatePrivateNet, sizeof(m_kCreatePrivateNet));
	zeromemory(&m_kAutoRoomInfo, sizeof(m_kAutoRoomInfo));
	zeromemory(&m_kDelAutoRoomInfo, sizeof(CMD_GP_DelAutoRoomInfo));
}

// 设置回调接口
void PrivateMission::setMissionSink(IPrivateMissionSink* pSink)
{
	m_pPrivateMissionSink = pSink;
}

//网络连接
void PrivateMission::onEventTCPSocketLink()
{
	SendLogonPacket();
}

//网络关闭
void PrivateMission::onEventTCPSocketShut()
{

}

//网络错误
void PrivateMission::onEventTCPSocketError(int errorCode)
{

}

//网络消息读取
bool PrivateMission::onEventTCPSocketRead(int main, int sub, void* data, int dataSize)
{
	switch (main)
	{
		//登录消息
	case MDM_GR_LOGON:	return OnSocketMainLogon(sub, data, dataSize);
		//用户信息
	case MDM_GR_USER:	return OnSocketMainUser(sub, data, dataSize);
		//系统消息
	case MDM_CM_SYSTEM:	return OnSocketMainSystem(sub, data, dataSize);
		//私人场消息
	case MDM_GR_PRIVATE:return OnSocketMainPrivate(sub, data, dataSize);

	default:
		break;
	}

	return true;
}

//登录消息
bool PrivateMission::OnSocketMainLogon(int sub, void* data, int dataSize)
{

	switch (sub)
	{
	case SUB_GR_LOGON_FINISH:
	{
		if (m_wMeTableID != INVALID_TABLE)
		{
			EnterGameScene();
			return true;
		}

		if (m_eLinkAction == Type_Link_Create)
		{
			SendSocketData(MDM_GR_PRIVATE, SUB_GR_CREATE_PRIVATE, &m_kCreatePrivateNet, sizeof(m_kCreatePrivateNet));
			zeromemory(&m_kCreatePrivateNet, sizeof(m_kCreatePrivateNet));
		}
		else if (m_eLinkAction == Type_Link_Join)
		{
			CMD_GR_Join_Private kSendNet;
			kSendNet.dwRoomNum = m_dwJoinRoomNum;
			SendSocketData(MDM_GR_PRIVATE, SUB_GR_JOIN_PRIVATE, &kSendNet, sizeof(kSendNet));
		}
		else if (Type_Link_Auto == m_eLinkAction)
		{
			SendSocketData(MDM_GR_PRIVATE, SUB_GR_CREATE_AUTO_ROOM, &m_kAutoRoomInfo, sizeof(m_kAutoRoomInfo));
			zeromemory(&m_kAutoRoomInfo, sizeof(m_kAutoRoomInfo));
		}
		else if (Type_Link_Del == m_eLinkAction)
		{
			SendSocketData(MDM_GR_PRIVATE, SUB_GR_DEL_AUTO_ROOM_INFO, &m_kDelAutoRoomInfo, sizeof(m_kDelAutoRoomInfo));
			zeromemory(&m_kDelAutoRoomInfo, sizeof(m_kDelAutoRoomInfo));
		}

		m_eLinkAction = Type_Link_NULL;
	}
	break;
	case SUB_GR_LOGON_FAILURE:
	{
		CMD_GR_LogonError* pGameServer = (CMD_GR_LogonError*)data;
		PopScene::Instance().show(utility::a_u8(pGameServer->szErrorDescribe));
	}
	break;
	case SUB_GR_UPDATE_NOTIFY:
	{
		auto callback = []{
			Director::getInstance()->end();
#if (CC_TARGET_PLATFORM == CC_PLATFORM_IOS)
			exit(0);
#endif
		};

		PopScene::Instance().show(utility::a_u8("发现新版本，请前往官网下载并重新安装！"), callback);

		this->stop();
	}
		break;
	default:
		break;
	}

	return true;
}

//用户信息
bool PrivateMission::OnSocketMainUser(int sub, void* data, int dataSize)
{
	if (sub == SUB_GR_USER_ENTER)
	{
		tagUserInfoHead* pUserInfoHead = (tagUserInfoHead*)data;

		if (pUserInfoHead->dwUserID == m_dwMeUserID)
		{
			m_wMeTableID = pUserInfoHead->wTableID;
			m_wMeChairID = pUserInfoHead->wChairID;
		}
	}
	else if (sub == SUB_GR_USER_STATUS)
	{
		//处理数据
		CMD_GR_UserStatus * pUserStatus = (CMD_GR_UserStatus *)data;

		if (pUserStatus->dwUserID == m_dwMeUserID && 
			(pUserStatus->UserStatus.wTableID != INVALID_TABLE || pUserStatus->UserStatus.wChairID != INVALID_CHAIR))
		{
			EnterGameScene();
		}
	}
	else if (sub == SUB_GR_SIT_FAILED)
	{
		//变量定义
		CMD_GR_RequestFailure * pRequestFailure = (CMD_GR_RequestFailure *)data;

		//效验参数
		ASSERT(dataSize > (sizeof(CMD_GR_RequestFailure) - sizeof(pRequestFailure->szDescribeString)));
		if (dataSize <= (sizeof(CMD_GR_RequestFailure) - sizeof(pRequestFailure->szDescribeString))) return false;

		PopScene::Instance().show(a_u8c(pRequestFailure->szDescribeString));
		
		this->stop();
	}

	return true;
}

//系统消息
bool PrivateMission::OnSocketMainSystem(int sub, void* data, int dataSize)
{
	switch (sub)
	{
		//系统消息
	case SUB_CM_SYSTEM_MESSAGE:	return OnSocketSubSystemMessage(data, dataSize);
	}

	//错误断言
	ASSERT(FALSE);

	return true;
}

//系统消息
bool PrivateMission::OnSocketSubSystemMessage(void* data, int wDataSize)
{
	cocos2d::log(("PrivateMission::OnSocketSubSystemMessage\n"));

	CMD_CM_SystemMessage * pSystemMessage = (CMD_CM_SystemMessage *)data;
	uint16 wHeadSize = sizeof(CMD_CM_SystemMessage) - sizeof(pSystemMessage->szString);

	//效验参数
	ASSERT((wDataSize > wHeadSize) && (wDataSize == (wHeadSize + pSystemMessage->wLength*sizeof(char))));
	if ((wDataSize <= wHeadSize) || (wDataSize != (wHeadSize + pSystemMessage->wLength*sizeof(char)))) return false;

	uint16 wType = pSystemMessage->wType;

	this->stop();

	PopScene::Instance().show(utility::a_u8(pSystemMessage->szString));

	return true;
}

//
bool PrivateMission::OnSocketMainPrivate(int sub, void* data, int dataSize)
{
	switch (sub)
	{
	//费用查询
	case SUB_GR_PRIVATE_INFO:
	{
		return OnSocketSubPrivateInfo(data, dataSize);
	}
	case SUB_GR_CREATE_PRIVATE_SUCESS:
	{
		return OnSocketSubPrivateCreateSuceess(data, dataSize);
	}
	case SUB_GF_PRIVATE_ROOM_INFO:
	{
		return OnSocketSubPrivateRoomInfo(data, dataSize);
	}
	case SUB_GR_PRIVATE_HAS_CREATED:
	{
		EnterGameScene();
		return true;
	}
	case SUB_GR_CREATE_AUTO_RESULTE:
	{
		return OnSocketSubCreateAutoResulte(data, dataSize);
	}
	case SUB_GR_DEL_AUTO_ROOM_INFO:
	{
		return OnSocketSubDelAutoResulte(data, dataSize);
	}
	case SUB_GR_AUTO_USER_READY:
	{
								   return OnSocketSubAutoUserReady(data, dataSize);
	}
	}
	return true;
}

//void PrivateMission::SendPrivateAgagin()
//{
//	CMD_GR_Again_Private kNetInfo;
//	SendSocketData(MDM_GR_PRIVATE, SUB_GR_RRIVATE_AGAIN, &kNetInfo, sizeof(kNetInfo));
//}

//
bool PrivateMission::OnSocketSubPrivateInfo(void* data, int dataSize)
{
	cocos2d::log("PrivateMission::OnSocketSubPrivateInfo\n");
	CMD_GR_Private_Info *pNetInfo = (CMD_GR_Private_Info*)data;

	return true;
}

//创建成功
bool PrivateMission::OnSocketSubPrivateCreateSuceess(void* data, int dataSize)
{
	cocos2d::log("PrivateMission::OnSocketSubPrivateCreateSuceess\n");

	ASSERT(dataSize == sizeof(CMD_GR_Create_Private_Sucess));
	if (dataSize != sizeof(CMD_GR_Create_Private_Sucess)) return false;

	CMD_GR_Create_Private_Sucess *pNetInfo = (CMD_GR_Create_Private_Sucess*)data;

	// 修改创建房间时不加入桌子, 创建完成客户端通过加入消息进入游戏(zhangxw 2017-08-24);
	CMD_GR_Join_Private kSendNet;
	kSendNet.dwRoomNum = pNetInfo->dwRoomNum;
	SendSocketData(MDM_GR_PRIVATE, SUB_GR_JOIN_PRIVATE, &kSendNet, sizeof(kSendNet));

	//EnterGameScene();

	return true;
}

//私人场信息
bool PrivateMission::OnSocketSubPrivateRoomInfo(void* data, int dataSize)
{
	cocos2d::log("PrivateMission::OnSocketSubPrivateRoomInfo\n");

	DataStream kDataStream(data, dataSize);
	CMD_GF_Private_Room_Info kNetInfo;
	kNetInfo.StreamValue(kDataStream, false);

	EnterGameScene();

	return true;
}

//发送函数
bool PrivateMission::SendSocketData(uint16 wMainCmdID, uint16 wSubCmdID)
{
	return SendSocketData(wMainCmdID, wSubCmdID, 0, 0);
}

//发送函数
bool PrivateMission::SendSocketData(uint16 wMainCmdID, uint16 wSubCmdID, void * data, uint16 dataSize)
{
	return send(wMainCmdID, wSubCmdID, (unsigned char*)data, dataSize);
}

//发送登录
bool PrivateMission::SendLogonPacket()
{
	//变量定义
	CGlobalUserInfo * pGlobalUserInfo = CGlobalUserInfo::GetInstance();
	tagGlobalUserData * pGlobalUserData = pGlobalUserInfo->GetGlobalUserData();

	m_dwMeUserID = pGlobalUserData->dwUserID;

	//变量定义
	CMD_GR_LogonUserID LogonUserID;
	zeromemory(&LogonUserID, sizeof(LogonUserID));

	LogonUserID.wKindID = m_wGameKindID;
	//游戏版本
	//LogonUserID.dwProcessVersion = Helps::Instance()->GetGameVersion();
	//LogonUserID.dwPlazaVersion = Helps::Instance()->GetPlazaVersion();
	LogonUserID.dwPlazaVersion = JniFun::getVersionCode();

	//登录信息
	LogonUserID.dwUserID = m_dwMeUserID;
	strncpy(LogonUserID.szPassword, pGlobalUserData->szPassword, countarray(LogonUserID.szPassword));

	//发送数据
	SendSocketData(MDM_GR_LOGON, SUB_GR_LOGON_USERID, &LogonUserID, sizeof(LogonUserID));
	return true;
}


//网络心跳包
bool PrivateMission::onEventTCPHeartTick()
{
	return true;
}

//进入游戏场景
void PrivateMission::EnterGameScene()
{
	stop();

	if (m_pPrivateMissionSink)
	{
		m_pPrivateMissionSink->StartGameScene(m_pGameServerItem);
	}
}

//设置创建私人场房间信息
void PrivateMission::SetCreateInfo(CMD_GR_Create_Private* pInfo)
{
	memcpy(&m_kCreatePrivateNet, pInfo, sizeof(CMD_GR_Create_Private));
	m_eLinkAction = Type_Link_Create;
}


//设置创建代开房间信息
void PrivateMission::SetCreateAutoInfo(CMD_GR_AutoRoomInfo* pInfo)
{
	memcpy(&m_kAutoRoomInfo, pInfo, sizeof(CMD_GR_AutoRoomInfo));
	m_eLinkAction = Type_Link_Auto;
}

//设置删除代开房间信息
void PrivateMission::SetDelAutoInfo(CMD_GP_DelAutoRoomInfo* pInfo)
{
	memcpy(&m_kDelAutoRoomInfo, pInfo, sizeof(CMD_GP_DelAutoRoomInfo));
	m_eLinkAction = Type_Link_Del;
}

//设置加入私人场房间信息
void PrivateMission::SetJoinInfo(uint32 dwJoinRoomNum)
{
	m_dwJoinRoomNum = dwJoinRoomNum;
	m_eLinkAction = Type_Link_Join;
}

//连接服务器
void PrivateMission::ConnectServerByServerID(uint16 wServerID)
{
	CGameServerItem* pServer = CServerListData::shared()->SearchGameServer(wServerID);

	ConnectServer(pServer, true);
}

//连接服务器
void PrivateMission::ConnectServer(CGameServerItem* pServerItem, bool bServerID/* = false*/)
{
	if (pServerItem)
	{
		m_pGameServerItem = pServerItem;
		m_wGameKindID = pServerItem->m_GameServer.wKindID;
		setUrl(pServerItem->m_GameServer.szServerAddr, pServerItem->m_GameServer.wServerPort);
		start();
	}
	else
	{
		if (bServerID)
		{
			PopScene::Instance().show(utility::a_u8("房间号错误！"));
		}
		else
		{
			PopScene::Instance().show(a_u8c("连接游戏服务器失败！"));
		}
	}
}

//创建代开信息结果
bool PrivateMission::OnSocketSubCreateAutoResulte(void* data, int dataSize)
{
	stop();

	ASSERT(dataSize >= sizeof(SCORE));
	if (dataSize < sizeof(SCORE)) return false;

	CMD_GR_AutoResulte *pNetInfo = (CMD_GR_AutoResulte*)data;

	if (m_pPrivateMissionSink)
	{
		m_pPrivateMissionSink->CreateAutoRoomInfoResulte(pNetInfo);
	}

	return true;
}

//删除代开信息完成
bool PrivateMission::OnSocketSubDelAutoResulte(void* data, int dataSize)
{
	stop();

	ASSERT(dataSize >= sizeof(SCORE));
	if (dataSize < sizeof(SCORE)) return false;

	CMD_GR_AutoResulte *pNetInfo = (CMD_GR_AutoResulte*)data;

	if (m_pPrivateMissionSink)
	{
		m_pPrivateMissionSink->CreateAutoRoomInfoResulte(pNetInfo);
	}

	return true;
}

//自由人数开始状态;
bool PrivateMission::OnSocketSubAutoUserReady(void* data, int dataSize)
{
	return true;
}