#include "stdafx.h"
#include "3DEngineWrapper.h"

#include <Information/Zone/WiseMapInfo.h>
#include <Information/Zone/GameZone.h>
#include <Information/Zone/GameField.h>

#include <MapInfoParser.h>


static EngineInterface* s_pEngine = NULL;
static WiseMapInfo* s_pMapInfo = NULL;

#define INTERFACE_ENGINE	(*s_pEngine)
#define INTERFACE_MAPINFO	(*s_pMapInfo)

DECLARE_BASE_WISE_STEP_FUNCTION()
{
	//DEBUGGING_CODE_L1("3D Engine Initialized");
	STARTENDLOG	Checker(_T("3D Engine Initialized"));

	// (¹èÆ÷½Ã)(ÀÓ½ÃÁ¦°Å)
#ifdef __WAVERIX_AUTH_SERVER_TEST__
	 return;
#endif
	FUNC_ContactTerrain func;
	HINSTANCE hDLL = Load3DTerrainLibrary((CHAR*)Manipulater::CONFIG_ENGINE_3DENGINE_TERRAIN, &func);

	if(!hDLL)
	{
		DEBUGGING_CODE_L1("Can't Load Engine");
		DEBUG_INTERRUPT();
		return;
	}

	CLoadHelper* pLoadHelper = (CLoadHelper*)func(CT_NEW_MAPLOADER, 0);

	EngineInstances& rINSTANCE = EngineInterface::RegisterInstance(hDLL, pLoadHelper, func);

	new EngineInterface(rINSTANCE);

#ifdef __WAVERIX_MAP_LOADING_PERFORMANCE_TEST__
	MapInfoParser* pPARSER = MapInfoParser::Instance();
	sMAPINFO_HASH& rHASH = pPARSER->GetMapInfoHash();

	sMAPINFO_HASH::const_iterator itend = rHASH.end();
	for(sMAPINFO_HASH::const_iterator it = rHASH.begin() ; it != itend ; ++it)
	{
		sMAPINFO* pINFO = it->second;
		MAPCODE mcCODE = pINFO->MapCode;
		INTERFACE_ENGINE.NewTokenHandleTerrain(mcCODE);
	}
#endif //__WAVERIX_MAP_LOADING_PERFORMANCE_TEST__
};

REGISTER_STEP_HANDLER_BASE(eWISE_ROUTINES_INIT_ENGINE);


//////////////////////////////////////////////////////////////////////////
//
EngineInterface::EngineInterface(EngineInstances& rINSTANCE) :
m_rINSTANCE(rINSTANCE)
{
	s_pEngine = this;
	m_pArchive = new CWzArchive();
	s_pMapInfo = new WiseMapInfo(rINSTANCE);
}

EngineInterface::~EngineInterface()
{
	SAFE_DELETE(m_pArchive);
	SAFE_DELETE(s_pMapInfo);
}

EngineInterface&		EngineInterface::Instance()
{
	return INTERFACE_ENGINE;
}

void					EngineInterface::ReleaseInstance()
{
	SAFE_DELETE(s_pEngine);
}

//////////////////////////////////////////////////////////////////////////
//
#include <MapInfoParser.h>

void					EngineInterface::CreateTerrain()
{
	m_TokenIDforTerrain = ((MAPCODE)-1) + 2;
	/*
	MapInfoParser* MAPPARSER = MapInfoParser::Instance();

	sFIELDINFO_HASH& rFieldHash = MAPPARSER->GetFieldInfoHash();
	sFIELDINFO_HASH_ITR itendFieldInfo = rFieldHash.end();

	rFieldHash.find(

	for(sFIELDINFO_HASH_ITR it=rFieldHash.begin() ; it != itendFieldInfo ; ++it)
	{
	sFIELDINFO* psFieldInfo = const_cast<sFIELDINFO*>(*it);

	}
	*/
}

//////////////////////////////////////////////////////////////////////////
//
TERRAIN_ID_T			EngineInterface::NewTokenHandleTerrain(MAPCODE mcCODE)
{
	TERRAIN_HASH_IT itFIND = m_TERRAIN.find(mcCODE);
	if(itFIND == m_TERRAIN.end())
	{
		if(INVALID_TERRAIN_ID_VALUE == INTERFACE_MAPINFO.Create(*m_pArchive, mcCODE))
			return INVALID_TERRAIN_ID_VALUE;
		return mcCODE;
	}

//INVALID_CLOSURE:
	return INVALID_TERRAIN_ID_VALUE;
}

//////////////////////////////////////////////////////////////////////////
//
void					EngineInterface::ReleaseTokenHandleTerrain(TERRAIN_ID_T tID)
{
}

C3D_WORLD_BASE			EngineInterface::GetInferfaceOfTerrain(TERRAIN_ID_T tID)
{
	return NULL;
}




BOOL	WiseMapInfo::ConstructInstance(MAPCODE mcCODE, GameZone*& IN OUT rpGameZone)
{
	rpGameZone = NULL;

	EngineInterface& rINTERFACE = EngineInterface::Instance();

	TERRAIN_ID_T instCODE = rINTERFACE.NewTokenHandleTerrain(mcCODE);
	if(INVALID_TERRAIN_ID_VALUE == instCODE)
		return FALSE;

	ObjectPoolRouter* pROUTER = ObjectPoolRouter::Instance();

	GameZone* pZONE = (GameZone*)pROUTER->Alloc(OBJTYPE_GAMEZONE);
	pZONE->Init(mcCODE);

	MAP_CONTAINER_HASH& rHASH = INTERFACE_MAPINFO.m_MAP_CONTAINER_HASH;

	MAP_FIELD_LIST& rLIST = rHASH[mcCODE];
	MAP_FIELD_LIST_IT itend = rLIST.end();
	for(MAP_FIELD_LIST_IT it=rLIST.begin() ; it != itend ; ++it)
	{
		sSharedFieldInfo* pSFIELD = *it;
		GameField* pFIELD = (GameField*)pROUTER->Alloc(OBJTYPE_GAMEFIELD);
		pFIELD->Init();
		pFIELD->m_FieldCode = pSFIELD->SHARED_ID.FIELD;

		MapFieldInfoShared& rFIELDSHR = pFIELD->m_SharedField;
		rFIELDSHR.Register(*pSFIELD);

		pZONE->_AddGameField(pFIELD);
	}

	rpGameZone = pZONE;

	return TRUE;
}

BOOL	WiseMapInfo::DestructInstance(GameZone*& IN OUT rpGameZone)
{
	rpGameZone = NULL;
	return FALSE;
}