#pragma once

#include <FunctionMap.h>

//
// PACKET STRUCTUREs
#include <PacketStruct_CG.h>
#include <PacketStruct_AM.h>
#include <PacketStruct_AG.h>
#include <PacketStruct_AW.h>
#include <PacketStruct_AD.h>
#include <PacketStruct_AZ.h>
#include <SunAuth/AuthProtocol_GA.h>
//
#include <ServerSessions/ServerSessionEx.h>
#include <ServerSessions/TempServerSessionEx.h>
#include <ServerSessions/MasterServerSession.h>
#include <ServerSessions/AuthAgentServerSession.h>
#include <ServerSessions/DBProxyServerSession.h>

#include <ServerSessions/WorldServerSession.h>
#include <ServerSessions/GameServerSession.h>
#include <ServerSessions/BattleServerSession.h>
#include <ServerSessions/FieldServerSession.h>

//
#ifdef _DEBUG
#	include <CPShowMSG.h>
#define __NA000000_081104_REGISTERED_PROTOCOL_NAMES__
#endif

//收收收收收收收收收收收收收收收收收收收收收收收收收收收收收收收收收收收收收收收收收收收收收收收收收收收收收收收收收收收收收收收收收收收收收收收收收
//
struct MSG_BASE;
class UserSession;

//收收收收收收收收收收收收收收收收收收收收收收收收收收收收收收收收收收收收收收收收收收收收收收收收收收收收收收收收收收收收收收收收收收收收收收收收收
//
#pragma pack(push,1)
#pragma warning(push)
#pragma warning(disable : 4201)
// Agent 晦遽辨
struct	PACKET_CONTROL
{
	static const DWORD	MAX_PACKET_SIZE = 16384;

	union uPACKET_STRUCTURE
	{
		BYTE	PacketStream[PACKET_CONTROL::MAX_PACKET_SIZE];

		struct
		{
			DWORD	dwUserKey;
			BYTE	pC2APacketPtr[1];
		};

		struct
		{
			WORD									wBLANK;
			union
			{
				MSG_CG_CRYPTOGRAPHY_PACKET_ENCODING	pMSG_ENCODING[1];
				MSG_CG_CRYPTOGRAPHY_PACKET_ENCODED	pMSG_ENCODED[1];
			};
		} BASE_PK;

		struct
		{
			DWORD					dwUserKey;
			MSG_BASE_INTERNAL		pMSG_BASE_INTERNAL[1];
		} FORWARD;

		struct 
		{
			MSG_BASE				pMSG_BASE[1];
			MSG_BASE_FORWARD		pMSG_BASE_FORWARD[1];
		} BASE;
	};

	static uPACKET_STRUCTURE		sRECV_PACKET_STRUCTURE;
	static uPACKET_STRUCTURE		sSEND_PACKET_STRUCTURE;

	// TempUser, User(no crypt), MSG_BASE root
	inline static BYTE*		GetPacketPtr_C2A() { return (BYTE*)sRECV_PACKET_STRUCTURE.pC2APacketPtr; }
	// TempUser, User(no crypt), MSG_BASE root
	inline static BYTE*		GetPacketPtr_A2C() { return (BYTE*)sSEND_PACKET_STRUCTURE.pC2APacketPtr; }

	// User(crypt)
	inline static MSG_CG_CRYPTOGRAPHY_PACKET_ENCODED* GetPacketPtr_C2A_ENCODED()
	{ return sRECV_PACKET_STRUCTURE.BASE_PK.pMSG_ENCODED; }
	// User(crypt)
	inline static MSG_CG_CRYPTOGRAPHY_PACKET_ENCODING* GetPacketPtr_A2C_ENCODING()
	{ return sSEND_PACKET_STRUCTURE.BASE_PK.pMSG_ENCODING; }

	inline static MSG_BASE*	GetPacketPtr_BASE_C2A() { return sRECV_PACKET_STRUCTURE.BASE.pMSG_BASE; }
	inline static MSG_BASE*	GetPacketPtr_BASE_A2C() { return sSEND_PACKET_STRUCTURE.BASE.pMSG_BASE; }
	inline static MSG_BASE_FORWARD*	GetPacketPtr_FORWARD_C2A() { return sRECV_PACKET_STRUCTURE.BASE.pMSG_BASE_FORWARD; }
	inline static MSG_BASE_FORWARD*	GetPacketPtr_FORWARD_A2C() { return sSEND_PACKET_STRUCTURE.BASE.pMSG_BASE_FORWARD; }

	// Agent Server -> 憮幗丿 婦葬 憮幗菟
	inline static BYTE*		GetPacketPtr_A2GDWMZ() { return (BYTE*)&(sSEND_PACKET_STRUCTURE.FORWARD); }
	// 憮幗丿 婦葬 憮幗菟 -> Agent Server
	inline static BYTE*		GetPacketPtr_GDWMZ2A() { return (BYTE*)&(sRECV_PACKET_STRUCTURE.FORWARD); }
	// Agent Server -> Login F, Auth, Wops
	inline static BYTE*		GetPacketPtr_A2LUO() { return (BYTE*)sSEND_PACKET_STRUCTURE.FORWARD.pMSG_BASE_INTERNAL; }
	// Login F, Auth, Wops -> Agent Server
	inline static BYTE*		GetPacketPtr_LUO2A() { return (BYTE*)sRECV_PACKET_STRUCTURE.FORWARD.pMSG_BASE_INTERNAL; }

	static BOOL		m_bShowPacketStream;
#ifdef _DEBUG
	static const CPShowFNTable*	m_CPShowHandler;
#endif
	static BOOL		GetShowPacketStream() { return m_bShowPacketStream; }
	static VOID		SetShowPacketStream( BOOL bSet )
	{
		m_bShowPacketStream = bSet;
#ifdef _DEBUG
		m_CPShowHandler = GetCPShowHandler();
		m_CPShowHandler->fnInit( C2S_HIGH_VERSION_NO, C2S_MIDDLE_VERSION_NO, CATEGORY_ODD_NUMBER, PROTOCOL_ODD_NUMBER );
#endif
	}
	static VOID		ShowPacketStream( MSG_BASE* pBASE, WORD wSize, CHAR* pPrefix );
};
#pragma warning(pop)
#pragma pack(pop)


//收收收收收收收收收收收收收收收收收收收收收收收收收收收收收收收收收收收收收收收收收收收收收收收收收收收收收收收收收收收收收收收收收收收收收收收收收
//	TYPE DEFINITION
typedef VOID (*PH_fnHandler)( ServerSession* pSession, MSG_BASE* pMsg, WORD wSize );
typedef VOID (*PH_fnCAHandler)( UserSession* pSession, MSG_BASE* pMsg, WORD wSize );

struct sPACKET_HANDLER_INFO
{
	WORD			wCATEGORYnPROTOCOL;
	ePHASE_SHIFT	ePHASE_SHIFT_T;
	PH_fnHandler	pfnHandler;
};

struct FUNC_GENERIC : public util::BASE_FUNC
{
	ePHASE_SHIFT	m_PHASE_SHIFT_T;
	PH_fnHandler	m_fnHandler;
};

class PacketHandler;


//收收收收收收收收收收收收收收收收收收收收收收收收收收收收收收收收收收收收收收收收收收收收收收收收收收收收收收收收收收收收收收收收收收收收收收收收收
//
class ProtocolMatrix
{
#pragma warning(push)
#pragma warning(disable : 4201)
public:	struct sNode
		{
			union {
				WORD			wPROTOCOLnCATEGORY;
				struct {
					BYTE		bPROTOCOL;	// 橾奩婁 羲牖... 翱樓 蝶⑷葡 橢晦 嬪ヘ.
					BYTE		bCATEGORY;	// MAKEWORD(pMsg->m_byProtocol, pMsg->m_byCategory)
				};
			};
			ePHASE_SHIFT		ePHASE_SHIFT_T;
			PH_fnCAHandler		m_fnHandler;
		#ifdef __NA000000_081104_REGISTERED_PROTOCOL_NAMES__
			const CHAR*			m_ProtocolName;
		#endif
		};
#pragma warning(pop)
		typedef util::ARRAY_TYPEINFO< sNode, 0, 65536 >		array_t;
public:

public:		ProtocolMatrix();
public:
    const sNode* Find(BYTE category, BYTE protocol) const;
    bool RegisterFowardHandler(PH_fnCAHandler handler) { m_FowardHandler = handler; }
    bool RegisterAllDefault(const ePHASE_SHIFT phase, PH_fnCAHandler handler);
    bool RegisterHandler(const sPACKET_HANDLER_INFO* IN pInfo);
    bool RegisterHandlerRange(const BYTE category, const ePHASE_SHIFT phase, PH_fnCAHandler handler);
#ifdef __NA000000_081104_REGISTERED_PROTOCOL_NAMES__
    void RegisterHandlerName(const BYTE category, const BYTE protocol, const CHAR* const protocol_name);
#endif

private:	array_t::array_type		m_Array;
			ePHASE_SHIFT			m_DefaultPhase;
			PH_fnCAHandler			m_DefaultHandler;
			PH_fnCAHandler			m_FowardHandler;
			friend class PacketHandler;
};

//收收收收收收收收收收收收收收收收收收收收收收收收收收收收收收收收收收收收收收收收收收收收收收收收收收收收收收收收收收收收收收收收收收收收收收收收收
//
typedef Delegator<PacketHandler>					PACKET_HANDLER_DELEGATOR;
typedef Delegator<PacketHandler>*					PACKET_HANDLER_DELEGATOR_P;

typedef Delegator<util::FunctionMap>				FUNCTION_MAP_DELEGATOR;
typedef Delegator<FUNC_GENERIC>						FUNC_GENERIC_DELEGATOR;

//收收收收收收收收收收收收收收收收收收收收收收收收收收收收收收收收收收收收收收收收收收收收收收收收收收收收收收收收收收收收收收收收收收收收收收收收收
//
class PacketHandler
{
public:
	PacketHandler();
	~PacketHandler();

	static VOID				RegisterHandler();
	static VOID				ReleaseHandler();

	static PACKET_HANDLER_DELEGATOR	GetHandler()	{ return ms_pInstance; }

    const FUNC_GENERIC* GetServerProtocolBinding(eSERVER_TYPE server_type, BYTE category, BYTE protocol);
    const ProtocolMatrix::sNode* GetClientProtocolBinding(BYTE category, BYTE protocol) const;

	//-------------------------------------------------------------------------------------
	// 彐韃 冖諒 <憮幗 除 翱唸>
	inline BOOL		CanDoProcess( FUNC_GENERIC_DELEGATOR& funcDelegator );

	BOOL			ParsePacket( eSERVER_TYPE serverType, ServerSession* pSession, MSG_BASE* pMsg, WORD wSize )
	{
		return _ParsePacket( serverType, pSession, pMsg, wSize );
	}

	BOOL			ParsePacket( eSERVER_TYPE serverType, ServerSession* pSession, MSG_BASE_INTERNAL* pMsg, WORD wSize )
	{
		return _ParsePacket( serverType, pSession, pMsg, wSize );
	}

	//-------------------------------------------------------------------------------------
	// 彐韃 冖諒 <憮幗 除 翱唸>
	BOOL			ParsePacketCA( eUSER_PARSER_TYPE userType, User* pSession, MSG_BASE* pMsg, WORD wSize )
	{
		return _ParsePacketCA( userType, pSession, pMsg, wSize );
	}

	BOOL			ParsePacketCA( eUSER_PARSER_TYPE userType, User* pSession, MSG_BASE_INTERNAL* pMsg, WORD wSize )
	{
		return _ParsePacketCA( userType, pSession, pMsg, wSize );
	}

private:
	BOOL			_ParsePacket( eSERVER_TYPE serverType, ServerSession* pSession, MSG_BASE* pMsg, WORD wSize );
	BOOL			_ParsePacket( eSERVER_TYPE serverType, ServerSession* pSession, MSG_BASE_INTERNAL* pMsg, WORD wSize );
	BOOL			_ParsePacketCA( eUSER_PARSER_TYPE userType, User* pSession, MSG_BASE* pMsg, WORD wSize );
	BOOL			_ParsePacketCA( eUSER_PARSER_TYPE userType, User* pSession, MSG_BASE_INTERNAL* pMsg, WORD wSize );
	// 傳 氈棻賊 Г(060815) 撲啗鼻 Connection 啗翮橾 匙檜棻.
	//-------------------------------------------------------------------------------------

public:
	class Phase
	{
	private:
		ePHASE_SHIFT	m_Phase;
	public:
		Phase() : m_Phase(PHASE_NOACTION) {}

		BOOL		Shift( ePHASE_SHIFT	phase );
		BOOL		RegisterHandler( sPACKET_HANDLER_INFO* pINFOs, WORD wCounts );
	};

public:
	template<eSERVER_TYPE serverType>
	BOOL			RegisterHandler_( sPACKET_HANDLER_INFO* pINFOs )
	{
		return _RegisterHandler( serverType, pINFOs );
	}

	template<eUSER_PARSER_TYPE userType>
	BOOL			RegisterHandlerCA_( sPACKET_HANDLER_INFO* pINFOs )
	{
		return _RegisterHandlerCA( userType, pINFOs );
	}

    bool RegisterFowardHandlerGroupCG(eUSER_PARSER_TYPE user_parse_type, BYTE category);
#ifdef _NA000000_CW_PROTOCOL_UNIFICATION
    bool RegisterFowardHandlerGroupCW(eUSER_PARSER_TYPE user_parse_type, BYTE category);
#endif
#ifdef __NA000000_081104_REGISTERED_PROTOCOL_NAMES__
	BOOLEAN			RegisterHandlerNames();
	const CHAR*		GetProtocolName( const BYTE category, const BYTE protocol );
#endif

private:
	BOOL			_RegisterHandler( eSERVER_TYPE serverType, sPACKET_HANDLER_INFO* pINFOs );
	BOOL			_RegisterHandlerCA( eUSER_PARSER_TYPE userType, sPACKET_HANDLER_INFO* pINFOs );

private:
	VOID			_Initialize();

	//FUNC_HASH_DELEGATOR		GetHandler( ServerSessionEx* pSession );

private:
	VOID			_LockInit() { m_bLock = FALSE; }
	BOOL			_IsLock() { return m_bLock; }
	VOID			_Locking() { m_bLock = TRUE; }
	VOID			_UnLocking() { m_bLock = FALSE; }

	//
	VOID			_CALockInit() { m_bCALock = FALSE; }
	BOOL			_IsCALock() { return m_bCALock; }
	VOID			_CALocking() { m_bCALock = TRUE; }
	VOID			_CAUnLocking() { m_bCALock = FALSE; }

private:
	//
	static PACKET_HANDLER_DELEGATOR		ms_pInstance;

	BOOL						m_bLock;
	BOOL						m_bCALock;
	// <COMMON HANDLER CONTAINER>
#ifdef _NA_007988_20150127_MODIFY_PROTOCOL_MATRIX_TO_STATIC 
    ProtocolMatrix              m_ProtocolMatrix;
#else
    ProtocolMatrix*				m_pProtocolMatrix;
#endif // _NA_007988_20150127_MODIFY_PROTOCOL_MATRIX_TO_STATIC
	FUNCTION_MAP_DELEGATOR		m_FuncMaps[MAX_SERVER];
};