#include "stdafx.h"
#include "UserSessionMgr.h"

#include "ServerSession.AgentServer.h"
#include "ServerSession.WorldServer.h"
#include "ServerSession.LoginFront.h"

#include <Object/WiseUser.h>
#include <PacketHandler/PacketHandler.h>
#include <PacketControl/PacketControl.h>

//////////////////////////////////////////////////////////////////////////
//
#define LOGIC_CHECKER_WITH_ARG(outputV, condition, etcPtr)				\
	BOOL outputValue = (BOOL)((condition) && etcPtr);						\
	ASSERT(__FUNCTION__ && outputValue && etcPtr && (condition));			\
	if(outputValue)


#define SESSION_IDX_CHECKER_WITH_PTR(outputValue, dwIdx, etcPtr)			\
	BOOL outputValue = (BOOL)((MAX_SESSION > (DWORD)dwIdx) && etcPtr);	\
	ASSERT(__FUNCTION__ && outputValue && etcPtr);						\
	if(outputValue)

#define SESSION_IDX_CHECKER(outputValue, dwIdx)				\
	BOOL outputValue = (BOOL)((MAX_SESSION > (DWORD)dwIdx));	\
	ASSERT(__FUNCTION__ && outputValue);						\
	if(outputValue)

//////////////////////////////////////////////////////////////////////////
//
WiseUser*	UserSessionMgr::ms_pActiveTransactionWiseUser = NULL;

//////////////////////////////////////////////////////////////////////////
//
UserSessionMgr::UserSessionMgr() {}
UserSessionMgr::~UserSessionMgr() {}

//////////////////////////////////////////////////////////////////////////
//
void			UserSessionMgr::Connect(eCONNECT_SESSIONS idxSession)
{
	SESSION_IDX_CHECKER(bAccept, idxSession)
	{
		IOCPServer* pIOCP = Manipulater::IOCPServerREF();
		if(pIOCP)
		{
			ServerSession* pSession = m_pSessions[idxSession];
			if(pSession->IsConnecting())
				return;

			pSession->SetConnecting(TRUE);

			sCONNECT_INFO& rINFO = m_pConnectInfos[idxSession];
			pIOCP->Connect(CLIENT_IOHANDLER, (NetworkObject*)pSession,
				rINFO.pIP.GetBUFFER(), rINFO.wPORT);
		}
	}
}

void			UserSessionMgr::OnConnect(eCONNECT_SESSIONS idxSession)
{
	SESSION_IDX_CHECKER(bAccept, idxSession)
	{
		sSIG_NOTIFY rNOTIFY;
		eWISESUBTYPE& rSUB_T = rNOTIFY.SUBTYPE();
		switch(idxSession)
		{
		case AGENT_SESSION: rSUB_T = sSIG_NOTIFY::NTF_SESSION_ON_CONNECTED_AGENTSERVER; break;
		case WORLD_SESSION: rSUB_T = sSIG_NOTIFY::NTF_SESSION_ON_CONNECTED_WORLDSERVER; break;
		case LOGIN_FRONT_SESSION: rSUB_T = sSIG_NOTIFY::NTF_SESSION_ON_CONNECTED_LOGINFRONT; break;
		//default: DEBUGGING_CODE_L1("NOTYPE"); rSUB_T = sSIG_NOTIFY::eSUBTYPE::NO_TYPE; return;
		}

		ServerSession* pSession = m_pSessions[idxSession];
		// NULL...
		GetWiseUser()->OnMsg(&rNOTIFY);
	}
}

void			UserSessionMgr::Disconnect(eCONNECT_SESSIONS idxSession)
{
	SESSION_IDX_CHECKER(bAccept, idxSession)
	{
		ServerSession* pSession = m_pSessions[idxSession];
		pSession->Disconnect();
	}
}

void			UserSessionMgr::OnDisconnect(eCONNECT_SESSIONS idxSession)
{
	SESSION_IDX_CHECKER(bAccept, idxSession)
	{
		sSIG_NOTIFY rNOTIFY;
		eWISESUBTYPE& rSUB_T = rNOTIFY.SUBTYPE();
		switch(idxSession)
		{
		case AGENT_SESSION: rSUB_T = sSIG_NOTIFY::NTF_SESSION_ON_DISCONNECTED_AGENTSERVER; break;
		case WORLD_SESSION: rSUB_T = sSIG_NOTIFY::NTF_SESSION_ON_DISCONNECTED_WORLDSERVER; break;
		case LOGIN_FRONT_SESSION: rSUB_T = sSIG_NOTIFY::NTF_SESSION_ON_DISCONNECTED_LOGINFRONT; break;
			//default: DEBUGGING_CODE_L1("NOTYPE"); rSUB_T = sSIG_NOTIFY::eSUBTYPE::NO_TYPE; return;
		}

		ServerSession* pSession = m_pSessions[idxSession];
		GetWiseUser()->OnMsg(&rNOTIFY);
	}
}

void			UserSessionMgr::OnRecv(eCONNECT_SESSIONS idxSession, BYTE *pMsg, WORD wSize)
{
//MSG_BASE* pBASE = (MSG_BASE*)pMsg;
//printf("Onrecv [%u:%u] %u\n", pBASE->m_byCategory, pBASE->m_byProtocol, wSize);

	SESSION_IDX_CHECKER(bAccept, idxSession)
	{
		ServerSession* pSession = m_pSessions[idxSession];
		ClientCryptPack4Packet& rRECVCRYPT = pSession->SECURE_PACK().RECV_CRYPT_PACKET_INFO();
		RECV_MESSAGE_BLOCK& rRECV_MSG = GetWiseUser()->RECV_MSG();

		if(rRECVCRYPT.IsPacketCrypted())
		{
			//DEBUGGING_CODE_L3("CRYPTED");
			CRYPT_MSG_RECV rRECVMSG(rRECV_MSG.MESSAGE_BLOCK);
			MSG_CG_CRYPTOGRAPHY_PACKET_ENCODED& rENCODED = rRECVMSG.TypeOf<MSG_CG_CRYPTOGRAPHY_PACKET_ENCODED>();
			if(rRECVMSG.MSG_ROOT_PTR() != pMsg)
				CopyMemory(rRECVMSG.MSG_ROOT_PTR(), pMsg, wSize);

			pMsg = (BYTE*)rRECVMSG.MSG_HDR_PTR();
			wSize -= 2;

			if(/*rENCODED.GetSNKey()*/ rRECVMSG.SNKEY() == rRECVCRYPT.GetRecvSNKey())
			{
				if(wSize && (wSize<8200)
					&& rRECVCRYPT.Decrypt(rRECVMSG.MSG_HDR_PTR(), wSize, rENCODED.GetCRC()))
				{
					rRECVCRYPT.NextRoundSNKey4Recv();
                    if (idxSession == AGENT_SESSION) {
                        nsPacket::PacketInfo pack_info = \
                            nsPacket::PacketControl::UnPack((MSG_BASE*)pMsg, wSize);
                        pMsg = (BYTE*)pack_info.pMsg;
                        wSize = pack_info.Size;
                    }
				}
			}
		}

		rRECV_MSG.Store(pSession, GetWiseUser(), pMsg, wSize);

		GetWiseUser()->OnMsg(rRECV_MSG.SIG_NETWORK_MESSAGE_REF);
	}
}

BOOL			UserSessionMgr::SendPacket(eCONNECT_SESSIONS idxSession, MSG_BASE* pMsg, WORD wSize)
{
	SESSION_IDX_CHECKER(bAccept, idxSession)
	{
		SHOW_PACKET_STREAM((MSG_BASE*)pMsg, wSize, "C2G");

		ServerSession* pSession = m_pSessions[idxSession];
		ClientCryptPack4Packet& rSENDCRYPT = pSession->SECURE_PACK().SEND_CRYPT_PACKET_INFO();
		SEND_MESSAGE_BLOCK& rSEND_BLK = GetWiseUser()->SEND_MSG();

		if(rSENDCRYPT.IsPacketCrypted())
		{
			//DEBUGGING_CODE_L3("CRYPTED");
			CRYPT_MSG_SEND rSENDMSG(rSEND_BLK.MESSAGE_BLOCK);
			MSG_CG_CRYPTOGRAPHY_PACKET_ENCODING& rENCODING = rSENDMSG.TypeOf<MSG_CG_CRYPTOGRAPHY_PACKET_ENCODING>();
			if(rSENDMSG.MSG_HDR_PTR() != (BYTE*)pMsg)
			{
				//printf("MEMCPY %08X %08X\t%08X\t%u\n", rSENDMSG.MSG_ROOT_PTR(), rSENDMSG.MSG_HDR_PTR(), pMsg, wSize);
				CopyMemory(rSENDMSG.MSG_HDR_PTR(), pMsg, wSize);
			}
			//else
			//{
			//	printf("FFF\n");
			//}

			pMsg = (MSG_BASE*)rSENDMSG.MSG_ROOT_PTR();//&rENCODING;

			rENCODING.SetSNKey(rSENDCRYPT.GetSendSNKey());
			rSENDCRYPT.Encrypt(rSENDMSG.MSG_HDR_PTR(), wSize, rENCODING.GetCRC());

			wSize += 2;

			rSENDCRYPT.NextRoundSNKey4Send();

		}

		sSIG_NETMSG& rNETMSG = *rSEND_BLK.SIG_NETWORK_MESSAGE_REF;

		rNETMSG.SUBTYPE() = sSIG_NETMSG::SENDMSG;
		rNETMSG.SESSION_PTR() = pSession;
		rNETMSG.MSG_HDR() = (BYTE*)pMsg;
		rNETMSG.MSG_LEN() = wSize;

		GetWiseUser()->OnMsg(&rNETMSG);
	}

	return FALSE;
}

void			UserSessionMgr::Init()
{
	m_pWiseUser = NULL;
	ZeroMemory(m_pSessions, sizeof(m_pSessions));
	ZeroMemory(m_pConnectInfos, sizeof(m_pConnectInfos));
	ObjectPoolRouter* pROUTER = ObjectPoolRouter::Instance();
	m_pSessions[AGENT_SESSION] = (ServerSessionAgentServer*)pROUTER->Alloc(OBJTYPE_SERVER_AGENT);
	m_pSessions[WORLD_SESSION] = (ServerSessionWorldServer*)pROUTER->Alloc(OBJTYPE_SERVER_WORLD);
	m_pSessions[LOGIN_FRONT_SESSION] = (ServerSessionLoginFront*)pROUTER->Alloc(OBJTYPE_SERVER_LOGINFRONT);

	for(DWORD idx=0 ; idx<MAX_SESSION ; ++idx)
	{
		ServerSession* pSession = m_pSessions[idx];
		pSession->Init();
		pSession->SetLinkedUser(this);
	}
}

void			UserSessionMgr::Release()
{
	ObjectPoolRouter* pROUTER = ObjectPoolRouter::Instance();
	for(DWORD idx=0 ; idx<MAX_SESSION ; ++idx)
	{
		ServerSession*& rpSession = m_pSessions[idx];
		if(rpSession)
		{
			rpSession->Release();
			pROUTER->Free((eWISE_OBJECT_INDEX)idx, rpSession);
			rpSession = NULL;
		}
	}
}

void			UserSessionMgr::SetConnectionInfo(eCONNECT_SESSIONS idxSession, sCONNECT_INFO* IN pConnectInfo)
{
	SESSION_IDX_CHECKER_WITH_PTR(bAccept, idxSession, pConnectInfo)
	{
		sCONNECT_INFO& rINFO = m_pConnectInfos[idxSession];
		rINFO.wPORT = pConnectInfo->wPORT;
		rINFO.pIP.CopyFrom(pConnectInfo->pIP.GetBUFFER());
		rINFO.pIP.MakeSafeString();
	}
}

BOOL			UserSessionMgr::GetConnectionInfo(eCONNECT_SESSIONS idxSession, sCONNECT_INFO* OUT pConnectInfo)
{
	SESSION_IDX_CHECKER_WITH_PTR(bAccept, idxSession, pConnectInfo)
	{
		sCONNECT_INFO& rINFO = m_pConnectInfos[idxSession];
		pConnectInfo->wPORT = rINFO.wPORT;
		pConnectInfo->pIP.CopyFrom(rINFO.pIP.GetBUFFER());
		pConnectInfo->pIP.MakeSafeString();

		return TRUE;
	}

	return FALSE;
}


ServerSession*	UserSessionMgr::GetSession(eCONNECT_SESSIONS idxSession)
{
	SESSION_IDX_CHECKER(bAccept, idxSession)
	{
		ServerSession* pSession = m_pSessions[idxSession];
		return pSession;
	}
	return NULL;
}