#include "cocos2d.h"
#include "LoginMission.h"
#include "Utility.h"

#define MISSION_LOGIN_ACCOUNT	1
#define MISSION_LOGIN_GAMEID	2
#define MISSION_REGISTER		3
#define MISSION_UPDATE_INFO		4
#define MISSION_SERVER_INFO		5
#define MISSION_LOGIN_VISITOR	6	


LoginMission::LoginMission()
{
	mMissionType = 0;
	mILoginMissionSink = 0;
}


// ���ûص��ӿ�
void LoginMission::setMissionSink(ILoginMissionSink* pILoginMissionSink)
{
	mILoginMissionSink = pILoginMissionSink;
}

// �˺ŵ�½
void LoginMission::loginAccount(const CMD_GP_LogonAccounts& LoginAccount)
{
	memcpy(&mLoginAccount, &LoginAccount, sizeof(mLoginAccount));
	mMissionType = MISSION_LOGIN_ACCOUNT;
	start();
}
// �ο͵�¼
void LoginMission::loginVisitor(const CMD_GP_VisitorLogon& VisitorAccount)
{
	memcpy(&mVisitorAccount, &VisitorAccount, sizeof(VisitorAccount));
	mVisitorAccount.dwPlazaVersion = Helps::Instance()->GetPlazaVersion();
	mMissionType = MISSION_LOGIN_VISITOR;
	start();
}

// I D��½
void LoginMission::loginGameID(const CMD_GP_LogonByUserID& LoginGameID)
{
	memcpy(&mLoginGameID, &LoginGameID, sizeof(mLoginGameID));
	mMissionType = MISSION_LOGIN_GAMEID;
	start();
}

void LoginMission::registerServer(const CMD_GP_RegisterAccounts& RegisterAccount)
{
	memcpy(&mRegisterAccount, &RegisterAccount, sizeof(mRegisterAccount));
	mMissionType = MISSION_REGISTER;
	start();
}

void LoginMission::updateOnlineInfo()
{
	mMissionType = MISSION_UPDATE_INFO;
	start();
}

//��������
bool LoginMission::updateServerInfo(uint16 kind)
{
	KIND_ITER it = std::find(mKindList.begin(), mKindList.end(), kind);

	if (it != mKindList.end())
	{
		return false;
	}

	it = std::find(mKindWaitList.begin(), mKindWaitList.end(), kind);

	if (it != mKindWaitList.end())
	{
		return false;
	}

	mKindList.push_back(kind);
	mMissionType = MISSION_SERVER_INFO;
	start();

	return true;
}

// ��½
bool LoginMission::sendLoginVisitor(const CMD_GP_VisitorLogon& VisitorAccount)
{
	CGlobalUserInfo * pGlobalUserInfo=CGlobalUserInfo::GetInstance();
	tagGlobalUserData * pGlobalUserData=pGlobalUserInfo->GetGlobalUserData();
	strncpy(pGlobalUserData->szPassword,mVisitorAccount.szPassWord,countarray(pGlobalUserData->szPassword));

	//��������
	send(MDM_GP_LOGON, SUB_GP_LOGON_VISITOR, (void*)&mVisitorAccount, sizeof(mVisitorAccount));
	return true;
}
//���͵�½��Ϣ
bool LoginMission::sendLoginAccount(const CMD_GP_LogonAccounts& LoginAccount)
{
	cocos2d::log(("LoginMission::sendLoginAccount\n"));
	//��������
	CGlobalUserInfo * pGlobalUserInfo=CGlobalUserInfo::GetInstance();
	tagGlobalUserData * pGlobalUserData=pGlobalUserInfo->GetGlobalUserData();
	strncpy(pGlobalUserData->szPassword,LoginAccount.szPassword, countarray(pGlobalUserData->szPassword));

	//��������
	send(MDM_GP_LOGON, SUB_GP_LOGON_ACCOUNTS, (void*)&LoginAccount, sizeof(LoginAccount));
	return true;
}

//���͵�½��Ϣ
bool LoginMission::sendLoginGameID(const CMD_GP_LogonByUserID& LoginGameID)
{
	return true;
}

//����ע����Ϣ
bool LoginMission::sendRegisterPacket(const CMD_GP_RegisterAccounts& RegisterAccount)
{
	cocos2d::log(("LoginMission::sendRegisterPacket\n"));

	CGlobalUserInfo * pGlobalUserInfo=CGlobalUserInfo::GetInstance();
	tagGlobalUserData * pGlobalUserData=pGlobalUserInfo->GetGlobalUserData();
	strncpy(pGlobalUserData->szPassword,RegisterAccount.szLogonPass, countarray(pGlobalUserData->szPassword));

	//��������
	send(MDM_GP_LOGON, SUB_GP_REGISTER_ACCOUNTS, (void*)&RegisterAccount, sizeof(RegisterAccount));
	return true;
}


// ��������
bool LoginMission::sendUpdateOnlineInfoPacket()
{
	return true;

}

// �������ͷ����б�
void LoginMission::sendUpdateServerInfo()
{
}

void LoginMission::onEventTCPSocketLink()
{
	cocos2d::log(("LoginMission::onEventTCPSocketLink\n"));

	switch (mMissionType)
	{
		// ��½
	case MISSION_LOGIN_ACCOUNT:
		sendLoginAccount(mLoginAccount);
		break;
	case MISSION_LOGIN_VISITOR:
		sendLoginVisitor(mVisitorAccount);
		break;
		// ��½
	case MISSION_LOGIN_GAMEID:
		sendLoginGameID(mLoginGameID);
		break;
		// ע��
	case MISSION_REGISTER:
		sendRegisterPacket(mRegisterAccount);
		break;
		// ��������
	case MISSION_UPDATE_INFO:
		sendUpdateOnlineInfoPacket();
		break;
		// �������ͷ����б�
	case MISSION_SERVER_INFO:
		sendUpdateServerInfo();
		break;
	}
}

void LoginMission::onEventTCPSocketShut()
{
	cocos2d::log(("LoginMission::onEventTCPSocketShut\n"));
}

void LoginMission::onEventTCPSocketError(int errorCode)
{
	cocos2d::log(("LoginMission::onEventTCPSocketError code[%d]\n"), errorCode);
	if (mILoginMissionSink)
		mILoginMissionSink->onGPError(errorCode);
}

bool LoginMission::onEventTCPSocketRead(int main, int sub, void* data, int size) 
{
	cocos2d::log(("onEventTCPSocketRead main:%d sub:%d size:%d\n"), main, sub, size);
	switch (main)
	{
	//case SUB_MB_LOGON_GAMEID:	return onSocketMainLogon(sub, data, size);
	case MDM_GP_LOGON:			return onSocketMainLogon(sub, data, size);
	case MDM_GP_SERVER_LIST:	return onSocketMainServerList(sub, data, size);
	default:
		break;
	}
	CCAssert(false,"");
	return false;
}

//////////////////////////////////////////////////////////////////////////
// ��½��Ϣ
bool LoginMission::onSocketMainLogon(int sub, void* data, int size)
{
	switch (sub)
	{
		//��¼�ɹ�
	case SUB_GP_LOGON_SUCCESS:		return onSocketSubLogonSuccess(data, size);
		//��¼ʧ��
	case SUB_GP_LOGON_FAILURE:		return onSocketSubLogonFailure(data, size);
 		//��¼ʧ��
 	case SUB_GP_VALIDATE_MBCARD:	return onSocketSubLogonValidateMBCard(data, size);
 		//������ʾ
 	case SUB_GP_UPDATE_NOTIFY:		return onSocketSubUpdateNotify(data, size);
 		//��¼���
	case SUB_GP_LOGON_FINISH:		return onSocketSubLogonFinish(data, size);
	case SUB_GP_GROWLEVEL_CONFIG:	return true;
	case SUB_GP_MATCH_SIGNUPINFO:	return onSocketSubMacthSignupInfo(data, size);
	}

	CCAssert(false,"");
	return false;
}

//��¼�ɹ�
bool LoginMission::onSocketSubLogonSuccess(void* data, int size)
{
	cocos2d::log(("LoginMission::onSocketSubLogonSuccess\n"));

	//��½�ɹ�
	CMD_GP_LogonSuccess* pData = (CMD_GP_LogonSuccess*)data;
	//��������
	CGlobalUserInfo * pGlobalUserInfo=CGlobalUserInfo::GetInstance();
	tagGlobalUserData * pGlobalUserData=pGlobalUserInfo->GetGlobalUserData();

	pGlobalUserData->lUserScore = pData->lUserScore;
	pGlobalUserData->lUserInsure = pData->lUserInsure;
	pGlobalUserData->lGrade = pData->lGrade;

	//������Ϣ
	pGlobalUserData->wFaceID = pData->wFaceID;
	pGlobalUserData->cbGender = pData->cbGender;
	pGlobalUserData->dwUserID =pData->dwUserID;
	pGlobalUserData->dwGameID = pData->dwGameID;
	pGlobalUserData->dwSpreaderID = pData->dwSpreaderID;
	pGlobalUserData->dwExperience =pData->dwExperience;
	pGlobalUserData->cbInsureEnabled = pData->cbInsureEnabled;
	pGlobalUserData->cbWXShareTimes = pData->cbWXShareTimes;
	strncpy(pGlobalUserData->szNickName, (char*)pData->szNickName, countarray(pGlobalUserData->szNickName)-1);
	strncpy(pGlobalUserData->szAccounts, ((char*)pData->szAccounts), countarray(pGlobalUserData->szAccounts)-1);

	// �齱��Ϣ;
	pGlobalUserData->isLottery = pData->isLottery;

	//�����Ï?
	pGlobalUserInfo->upPlayerInfo();

	if (mILoginMissionSink)
		mILoginMissionSink->onGPLoginSuccess();

	return true;
}

//��¼ʧ��
bool LoginMission::onSocketSubLogonFailure(void* data, int size)
{
	cocos2d::log(("LoginMission::onSocketSubLogonFailure\n"));

	DBR_GP_LogonError* pNetInfo =(DBR_GP_LogonError*)data;
	//��ʾ��Ϣ
	if (mILoginMissionSink)
		mILoginMissionSink->onGPLoginFailure(pNetInfo->lErrorCode,utility::a_u8(pNetInfo->szErrorDescribe).c_str());
	return true;

}

//������ʾ
bool LoginMission::onSocketSubUpdateNotify(void* data, int size)
{
	cocos2d::log(("LoginMission::onSocketSubUpdateNotify\n"));
	//�����

	return true;
}

//��¼ʧ��(�ܱ���)
bool LoginMission::onSocketSubLogonValidateMBCard(void* data, int size)
{
	cocos2d::log(("LoginMission::onSocketSubLogonValidateMBCard\n"));
	return true;
}

//��¼���
bool LoginMission::onSocketSubLogonFinish(void* data, int size)
{
	cocos2d::log(("LoginMission::onSocketSubLogonFinish\n"));

	stop();

	if (mILoginMissionSink)
		mILoginMissionSink->onGPLoginComplete();

	CGlobalUserInfo * pGlobalUserInfo=CGlobalUserInfo::GetInstance();
	tagGlobalUserData * pGlobalUserData=pGlobalUserInfo->GetGlobalUserData();
	pGlobalUserInfo->LoginSucess();

	return true;
}
bool LoginMission::onSocketSubMacthSignupInfo(void* data, int size)
{
	//������
	if(size%sizeof(uint16)!=0) return false;

	//��ȡ����			
	tagSignupMatchInfo * pSignupMatchInfo = (tagSignupMatchInfo *)data;
	uint16 wSignupCount = size/sizeof(pSignupMatchInfo);

	//��ȡ����
	ASSERT(CServerListData::shared()!=NULL);
	CServerListData * pServerListData=CServerListData::shared();

	//���ҷ���
	CGameServerItem * pGameServerItem = NULL;

	//����
	for(uint16 i=0;i<wSignupCount;i++)
	{
		pGameServerItem = pServerListData->SearchGameServer(pSignupMatchInfo[i].wServerID);
		if(pGameServerItem!=NULL && pGameServerItem->m_GameMatch.dwMatchID==pSignupMatchInfo[i].dwMatchID)
		{
			pGameServerItem->m_bSignuped=true;
		}
	}

	return true;
}

//////////////////////////////////////////////////////////////////////////
// �б���Ϣ
bool LoginMission::onSocketMainServerList(int sub, void* data, int size)
{
 	switch (sub)
	{
		case SUB_GP_LIST_TYPE:		return onSocketListType(data, size);
		case SUB_GP_LIST_KIND:		return onSocketListKind(data, size);
		case SUB_GP_LIST_SERVER:	return onSocketListServer(data, size);
		case SUB_GP_LIST_MATCH:		return onSocketListMatch(data, size);
		case SUB_GP_LIST_FINISH:	return onSocketListFinish(data, size);
		case SUB_GR_KINE_ONLINE:	return onSocketKindOnline(data, size);
		case SUB_GR_SERVER_ONLINE:	return onSocketServerOnline(data, size);
 		case SUB_GR_ONLINE_FINISH:	return onSocketOnlineFinish(data, size);
	}

	return false;
}

//������Ϣ
bool LoginMission::onSocketListType(void* data, int size)
{
	cocos2d::log(("LoginMission::onSocketListType\n"));
	//QY
	return true;
}

//������Ϣ
bool LoginMission::onSocketListKind(void* data, int size)
{
	cocos2d::log(("LoginMission::onSocketListKind\n"));
	////��������
	int itemSize = sizeof(tagGameKind);

	ASSERT(size%itemSize==0);
	if (size%itemSize!=0) return false;
	char* pNetInfo = (char*)data;
	int iItemCount=size/itemSize;
	CServerListData * pServerListData=CServerListData::shared();
	for (int i=0;i<iItemCount;i++)
	{
		tagGameKind* pGameKind = (tagGameKind*)&(pNetInfo[i*itemSize]);
		pServerListData->InsertGameKind(pGameKind);

	}
	return true;
}

// �����б�
bool LoginMission::onSocketListServer(void* data, int size)
{
	cocos2d::log(("LoginMission::onSocketListServer\n"));
	////��������
	int itemSize = sizeof(tagGameServer);

	ASSERT(size%itemSize==0);
	if (size%itemSize!=0) return false;
	char* pNetInfo = (char*)data;
	int iItemCount=size/itemSize;
	CServerListData * pServerListData=CServerListData::shared();
	for (int i=0;i<iItemCount;i++)
	{
		tagGameServer* pGameServer = (tagGameServer*)&(pNetInfo[i*itemSize]);
		pServerListData->InsertGameServer(pGameServer);
		
	}
	return true;
}
//�����б�
bool LoginMission::onSocketListMatch(void* data, int size)
{
	cocos2d::log(("LoginMission::onSocketListMatch\n"));
	int itemSize = sizeof(tagGameMatch);

	ASSERT(size%itemSize==0);
	if (size%itemSize!=0) return false;

	//��������
	uint16 wItemCount=size/sizeof(tagGameMatch);
	tagGameMatch * pGameMatch=(tagGameMatch *)(data);

	//��ȡ����
	CGameServerItem * pGameServerItem=NULL;
	CServerListData * pServerListData=CServerListData::shared();

	//��������
	for (uint16 i=0;i<wItemCount;i++)
	{
		pGameServerItem = pServerListData->SearchGameServer(pGameMatch->wServerID);
		if(pGameServerItem!=NULL)
		{
			memcpy(&pGameServerItem->m_GameMatch,pGameMatch++,sizeof(pGameServerItem->m_GameMatch));
		}
	}

	return true;

}

// ����
bool LoginMission::onSocketListFinish(void* data, int size)
{
	cocos2d::log(("LoginMission::onSocketListFinish\n"));

	ASSERT(CServerListData::shared()!=0);
	if (CServerListData::shared()!=0) 
	{
		CServerListData::shared()->OnEventListFinish();
	}
	return true;
}
//�����
bool LoginMission::onSocketListConfig(void* data, int size)
{
	cocos2d::log(("LoginMission::onSocketListConfig\n"));

	CMD_GP_ListConfig* pListConfig = (CMD_GP_ListConfig*)data;
	return true;
}


//////////////////////////////////////////////////////////////////////////
// ���߸���
//////////////////////////////////////////////////////////////////////////
//��������
bool LoginMission::onSocketKindOnline(void* data, int size)
{
	cocos2d::log(("LoginMission::onSocketKindOnline\n"));

	//��������
	
	return true;

}

//��������
bool LoginMission::onSocketServerOnline(void* data, int size)
{
	cocos2d::log(("LoginMission::onSocketServerOnline\n"));

	//��������
	
	return true;

}

// ���߸������
bool LoginMission::onSocketOnlineFinish(void* data, int size)
{
	cocos2d::log(("LoginMission::onSocketOnlineFinish\n"));

	return true;
}

//////////////////////////////////////////////////////////////////////////

//��Ƶ����
bool LoginMission::onSocketVideoOption(void* data, int size)
{
	cocos2d::log(("LoginMission::onSocketVideoOption\n"));

	cocos2d::log("onSocketVideoOption");
	return true;
}