#pragma once

//
#include <MemoryPoolFactoryV.h>

using namespace util;

//
// <TYPE DEFINITIONs>
//
enum eWISE_OBJECT_INDEX
{
	OBJTYPE_EMPTY,
	OBJTYPE_DELEGATOR,
	OBJTYPE_PASSING_OBJECT,
	OBJTYPE_LINKEDLIST,
	//OBJTYPE_USERINFO,
	OBJTYPE_USER,
	OBJTYPE_CHARACTER,
	OBJTYPE_USERDELEGATOR,
	OBJTYPE_LOGIC_ACTIVE,
	OBJTYPE_LOGIC_PASSIVE,
	OBJTYPE_SERVER_LOGINFRONT,
	OBJTYPE_SERVER_AGENT,
	OBJTYPE_SERVER_WORLD,
	OBJTYPE_ACCOUNT_INFO,
	OBJTYPE_MAPOBJECT_INFO,
	OBJTYPE_GAMEZONE,
	OBJTYPE_GAMEFIELD,
	OBJTYPE_PLAYER,
	OBJTYPE_MONSTER,
	//
	//
	//
	//
	OBJTYPE_MAX
};

enum eWISE_OBJKEY_INDEX
{
	OBJKEYTYPE_PLAYERKEY,
	OBJKEYTYPE_ZONEKEY,
	OBJKEYTYPE_PARTYKEY,
	OBJKEYTYPE_MAX,
};

typedef struct sLINKEDLIST_NODE
{
	sLINKEDLIST_NODE*	next;
	sLINKEDLIST_NODE*	prev;
	PVOID				pREF;		// ½ÇÁ¦ µ¥ÀÌÅÍ ÂüÁ¶
	DWORD				dwExtra;	// Objectº° Ưº°È÷ »ç¿ëÇÒ ¼ö ÀÖ´Â Çʵå
} *sLINKEDLIST_NODE_P;

struct sDELEGATOR_NODE
{
};

class PassingObject
{
public:		PassingObject() : m_dwSize(0), m_pAllocedPtr(NULL) { }
			PassingObject(const PassingObject& rPassingObj)
				: m_dwSize(rPassingObj.m_dwSize), m_pAllocedPtr(rPassingObj.m_pAllocedPtr) {}
			~PassingObject() {}

			inline PVOID	GetAllocedPtr()		{ return m_pAllocedPtr; }
			inline DWORD	GetAllocedSize()	{ return m_dwSize; }
			inline PVOID	Alloc(DWORD dwSize)
			{
				m_dwSize = dwSize;
				m_pAllocedPtr = malloc(m_dwSize);
				return m_pAllocedPtr;
			}

			inline void		Free()
			{
				m_dwSize = 0;
				SAFE_DELETE(m_pAllocedPtr);
			}

private:	DWORD	m_dwSize;
			PVOID	m_pAllocedPtr;
};

//////////////////////////////////////////////////////////////////////////
// ¼­¹ö¸ðµå¿¡ µû¶ó ´Þ¶óÁú ¼ö ÀÖ´Â ¼öÄ¡
struct sPOOL_SIZE_INFO
{
	DWORD	dwUserPoolBase;
	DWORD	dwUserPoolExtend;
	DWORD	dwTempUserPoolBase;
	DWORD	dwTempUserPoolExtend;
};


typedef Delegator<sDELEGATOR_NODE>		REF_DELEGATOR;
typedef REF_DELEGATOR*					REF_DELEGATOR_P;
typedef PoolRouter<OBJTYPE_MAX>			OBJECT_POOL_ROUTER;

//////////////////////////////////////////////////////////////////////////
// <CLASS DEFINITION>
//
class ObjectPoolRouter
{
public:
	ObjectPoolRouter();
	~ObjectPoolRouter();

public:
	static ObjectPoolRouter*	Instance();

//////////////////////////////////////////////////////////////////////////
// <OBJECT POOL INTERFACE>
public:
	inline PVOID				Alloc(eWISE_OBJECT_INDEX eTypeIdx)
	{
		return m_pPoolRouter->Alloc(eTypeIdx);
	}

	inline BOOL					Free(eWISE_OBJECT_INDEX eTypeIdx, PVOID pInstance)
	{
		return m_pPoolRouter->Free(eTypeIdx, pInstance);
	}

	//inline sLINKEDLIST_NODE_P	AllocList()
	//{
	//	return (sLINKEDLIST_NODE_P)m_pPoolRouter->Alloc(OBJTYPE_LINKEDLIST);
	//}

	//inline BOOL					FreeList(sLINKEDLIST_NODE_P pInst)
	//{
	//	return m_pPoolRouter->Free(OBJTYPE_LINKEDLIST, pInst);
	//}

	inline REF_DELEGATOR_P		AllocToken()
	{
		return (REF_DELEGATOR_P)m_pPoolRouter->Alloc(OBJTYPE_DELEGATOR);
	}

	inline BOOL					FreeToken(REF_DELEGATOR_P pInst)
	{
		return m_pPoolRouter->Free(OBJTYPE_DELEGATOR, pInst);
	}

public:
	BOOL						InitializeByPoolInfo(sPOOL_SIZE_INFO* pSizeInfo);
	inline void					Initialize(eWISE_OBJECT_INDEX eTypeIdx, DWORD dwPoolBasicSize, DWORD dwPoolExtendSize = 0)
	{
		m_pPoolRouter->Initialize((DWORD)eTypeIdx, dwPoolBasicSize, dwPoolExtendSize);
	}

	template<typename _TYPENAME_>
	inline BOOL					Register(DWORD dwIndex)
	{
		return m_pPoolRouter->Register<_TYPENAME_>(dwIndex);
	}

private:
	OBJECT_POOL_ROUTER*			m_pPoolRouter;
};