#include "stdafx.h"
#include "WiseMapInfo.h"

#include <MapInfoParser.h>
#include <io.h>

#include "MapFieldInfo.h"
#include "MapWmoInfo.h"

#include "GameZone.h"
#include "GameField.h"

#include "MapFieldInfo.Shared.h"

#include <Information/3DEngine/3DEngineWrapper.h>

//////////////////////////////////////////////////////////////////////////
//
void	WiseMapInfo::_Clear()
{
	//m_pWorldBase;
	//m_FIELD_ID;
	//m_wVersion;		// Field Version
	//m_MapObjHash;

	//m_TriggerInfoManager;
	for(MAP_FIELD_INFO_HASH_IT it=m_MAP_FIELD_HASH.begin() ; it != m_MAP_FIELD_HASH.end(); ++it)
	{
		MapFieldInfo* pFieldInfo = it->second;
		SAFE_DELETE(pFieldInfo);
	}
	m_MAP_FIELD_HASH.clear();

	for(MAP_WMO_INFO_HASH_IT it=m_MAP_WMO_HASH.begin() ; it != m_MAP_WMO_HASH.end() ; ++it)
	{
		MapWmoInfo* pWmoInfo = it->second;
		SAFE_DELETE(pWmoInfo);
	}
	m_MAP_WMO_HASH.clear();
}

TERRAIN_ID_T	WiseMapInfo::Create(CWzArchive& archive, MAPCODE mcCODE)
{
	MapInfoParser* pPARSER = MapInfoParser::Instance();
	sMAPINFO_HASH& rMAPHASH = pPARSER->GetMapInfoHash();

	sMAPINFO_HASH::iterator itFIND = rMAPHASH.find(mcCODE);
	if(itFIND == rMAPHASH.end())
		return INVALID_TERRAIN_ID_VALUE;

	// 신규 맵 추가
	MAP_FIELD_LIST& rLIST = m_MAP_CONTAINER_HASH[mcCODE];
	if(rLIST.size())	// 이미 생성된 것이 존재한다.
		return mcCODE;

	sMAPINFO* pINFO = itFIND->second;
	MAPCODE* pFIELDs = pINFO->FCode;
	FIELDCODE* pWMOs = pINFO->FWMOCode;
	FIELDCODE* pWUTs = pINFO->FWUTCode;

	for(DWORD dwIdx=0 ; dwIdx<sMAPINFO::MAX_FIELD_NUM ; ++dwIdx, ++pFIELDs, ++pWMOs, ++pWUTs)
	{
		if(!(*pFIELDs))
			continue;

		MapFieldInfo* pFieldInfo = FindMapFieldInfo(*pFIELDs);
		if(!pFieldInfo)
		{
			pFieldInfo = new MapFieldInfo(m_rINSTANCE);
			pFieldInfo->Create(archive, *pFIELDs);
			AddMapFieldInfo(*pFIELDs, pFieldInfo);
		}

		MapWmoInfo* pWmoInfo = FindMapWmoInfo(*pWMOs);
		if(!pWmoInfo)
		{
			pWmoInfo = new MapWmoInfo(m_rINSTANCE, pFieldInfo->EIWORLDBASE());
			pWmoInfo->Create(archive, *pWMOs);
			AddMapWmoInfo(*pWMOs, pWmoInfo);
		}

		// WUTs

		AddSharedMapInfo(*pFIELDs, pFieldInfo, *pWMOs, pWmoInfo);

		sSharedFieldInfo* pSFI = FindSharedMapInfo(*pFIELDs, *pWMOs);
		rLIST.push_back(pSFI);
	}

	return mcCODE;
}

void	WiseMapInfo::AddSharedMapInfo(FIELDCODE fcFIELD, MapFieldInfo* pFIELD, FIELDCODE fcWMO, MapWmoInfo* pWMO)
{
	sSharedFieldInfo* pINFO = FindSharedMapInfo(fcFIELD, fcWMO);
	if(pINFO)
	{
		//DEBUGGING_CODE_L1("INVALID");
		//DEBUG_INTERRUPT();
		return;
	}

	sSharedFieldInfo rINFO;
	uFIELD_ID& uID = rINFO.SHARED_ID;
	uID.FIELD = fcFIELD;
	uID.WMO = fcWMO;

	rINFO.FIELD_INFO = pFIELD;
	rINFO.WMO_INFO = pWMO;

	m_SHARED_FIELD_HASH.insert(make_pair(uID.ID, rINFO));
}


BOOL	WiseMapInfo::_CheckVersion_MAPnWMO(DWORD verMAP, DWORD verWMO)
{
	// 167 이하 버전의 Map은 신규로 교체하는 것이 로딩에 부하가 적다.
	if(!(verMAP > 167))
	{
		//SUNLOG(eCRITICAL_LOG, "[_CheckVersionBetweenMapWmo] Warning! %s Version[%u] is Low!!", m_tszMapPath, MapVersion);
	}

	// 162, 166, 167을 경계로 Wmo 보다 Map의 버전이 더 높으면 안된다.
	BOOL bCheckFail = TRUE;

	bCheckFail = bCheckFail && (verMAP>162) && !(verWMO>162);
	bCheckFail = bCheckFail && (verMAP>166) && !(verWMO>166);
	bCheckFail = bCheckFail && (verMAP>167) && !(verWMO>167);
	bCheckFail = bCheckFail && (verMAP>170) && !(verWMO>170);

	if(!bCheckFail)
	{
		//SUNLOG(eCRITICAL_LOG, "[_CheckVersionBetweenMapWmo] Critical! %s Version[%u] is Low!!", m_tszMapPath, WmoVersion);
		DEBUGGING_CODE_L1("CRITICAL Version Mismatch!");
		DEBUG_INTERRUPT();
		return FALSE;
	}
	return TRUE;
}

void	WiseMapInfo::_Destroy()
{
}


////////////////////////////////////////////////////////////////////////////
////
//void	WiseMapInfo::_Clear()
//{
//	//m_pWorldBase;
//	//m_FIELD_ID;
//	//m_wVersion;		// Field Version
//	//m_MapObjHash;
//
//	//m_TriggerInfoManager;
//}
//
//BOOL	WiseMapInfo::Create(MAPCODE mcCODE)
//{
//	MapInfoParser* pPARSER = MapInfoParser::Instance();
//	sMAPINFO_HASH& rMAPHASH = pPARSER->GetMapInfoHash();
//
//	sMAPINFO_HASH::iterator itFIND = rMAPHASH.find(mcCODE);
//	if(itFIND != rMAPHASH.end())
//	{
//		sMAPINFO* pINFO = itFIND->second;
//		pINFO->
//	}
//
//	//return Create
//}
//
//BOOL	WiseMapInfo::Create(const CHAR* pszFieldPath, FIELDCODE fcFIELD, FIELDCODE fcWMO, BOOL bUsePathEngine)
//{
//	m_FIELD_ID.FIELD = fcFIELD;
//	m_FIELD_ID.WMO = fcWMO;
//
//	STARTENDLOG("MapLoading");
//
//	m_pWorldBase = (CWorldBase*)m_rINSTANCE.HANDLEofTERRAIN()(CT_NEW_WORLD, 0);
//	m_pWorldBase->Create(bUsePathEngine);
//
//	return _Load(pszFieldPath);
//}
//
//
//
//BOOL	WiseMapInfo::_Load_WMO_MAPOBJECT(CWzArchive& archive)
//{
//	//////////////////////////////////////////////////////////////////////////
//	// <MAP OBJECT>
//	CLoadHelper& rLoadHelper = *(EIWORLDBASE().x_pLoadHelper);
//	rLoadHelper.LoadObj(&archive);
//
//	//오브 젝트 리스트 로딩
//	DWORD dwCount = rLoadHelper.GetObjectCount();
//	St_LHObject* pLHObject = rLoadHelper.GetObject();
//
//	ObjectPoolRouter* pROUTER = ObjectPoolRouter::Instance();
//	//ASSERT(count < (ITEM_OBJECT_KEY - MAP_OBJECT_KEY)); //< 키가 5만개 이하여야 한다.
//	for(DWORD dwIdx=0 ; dwIdx<dwCount ; ++dwIdx)
//	{
//		St_LHObject* pOffObj = &pLHObject[dwIdx];
//		sMAPOBJECT_INFO* pOBJECT = (sMAPOBJECT_INFO*)pROUTER->Alloc(OBJTYPE_MAPOBJECT_INFO);
//////
////		WzID				wzId;
////		DWORD				dwAttribute;
////		WzVector			wvPos;
////		WzVector			wzScale;
////		WzVector			wzRot;
////		WzBoundingVolume	wzBV;
////		DWORD				dwExtraInfos[eMAPOBJECT_MAX];
//
//		pOBJECT->dwMapObjectID	= dwIdx; // MAP_OBJECT_KEY +
//		pOBJECT->wzId			= pOffObj->m_WzID;
//		pOBJECT->dwAttribute	= pOffObj->m_dwAttribute;
//		pOBJECT->wvPos			= pOffObj->m_wvPos;
//		pOBJECT->wzScale		= pOffObj->m_wvScale;
//		pOBJECT->wzRot			= pOffObj->m_wvRot;
//		pOBJECT->wzBV			= pOffObj->m_wzBV;
//
//		//// 추가 데이터 설정 (설정값들)
//		//	eMAPOBJECT_TYPE
//		//	eMAPOBJECT_MONSTER
//		//	eMAPOBJECT_USE_ALPHA
//		//	eMAPOBJECT_RESERVED2
//		CopyMemory(pOBJECT->dwExtraInfos, pOffObj->m_dwParam, sizeof(pOBJECT->dwExtraInfos));
//
//		m_MapObjHash[dwIdx] = pOBJECT;
//	}
//
//	rLoadHelper.DeleteObject();
//
//	return TRUE;
//}
//
//BOOL	WiseMapInfo::_Load_WMO_TRIGGER(CWzArchive& archive)
//{
//	m_TriggerInfoManager.LoadGroupInfos(archive);
//
//	return TRUE;
//}
//
//BOOL	WiseMapInfo::_Load_WMO(CWzArchive& archive)
//{
//	BOOL bContinue = TRUE;
//
//	//////////////////////////////////////////////////////////////////////////
//	// <WMO HEADER>
//	do
//	{
//		St_ChunkInfo stCI = archive.ReadChunk();
//		if(stCI.m_nID == 0x1792)
//			bContinue = FALSE;
//		else
//			archive.SkipCurrentChunk(stCI);
//	} while(bContinue);
//
//	const sWMOINFO* pWMOINFO = MapInfoParser::Instance()->FindWMOInfo(CODEofWMO());
//	if(!pWMOINFO)
//		return FALSE;
//
//	//////////////////////////////////////////////////////////////////////////
//	// <WMO EXTRA EREA>
//
//	BOOL bRET = FALSE;
//
//	CWzArchive rWMOArchive;
//	rWMOArchive.SetDiscAccess(EIWORLDBASE().GetDiscAccess());
//
//	if(_access(pWMOINFO->pszPath, 0) < 0)
//	{
//		//SUNLOG(eCRITICAL_LOG,  "[_LoadMapObjectInfo] Failed : %s file is not Exist", pszFilePath);
//		goto CLOSURE_MARK;
//	}
//
//	if(!rWMOArchive.LoadFile(const_cast<char*>(pWMOINFO->pszPath)))
//	{
//		goto CLOSURE_MARK;
//	}
//
//	WORD wVersion = 0;
//	rWMOArchive.Seek(4, SO_CURRENT);
//	rWMOArchive >> wVersion;
//	rWMOArchive.SetVersion(wVersion);
//
//	St_LHFileHeader stLHFH;
//	if(170 < rWMOArchive.GetVersion())
//	{
//		rWMOArchive.Read(&stLHFH.wSecondVersion, sizeof(WORD));
//		rWMOArchive.Read(&stLHFH.dwCheckSum,     sizeof(DWORD));
//		//SUNLOG(eDEV_LOG, "Second Ver[%u] and CheckSum[%u]", fhInfo.wSecondVersion, fhInfo.dwCheckSum);
//	}
//
//	EIWORLDBASE().SerializeExtraAreaInfo(&rWMOArchive, TRUE);
//
//	if(! (bRET = _Load_WMO_MAPOBJECT(rWMOArchive)))
//		goto CLOSURE_MARK;
//
//	if(! (bRET = _Load_WMO_TRIGGER(rWMOArchive)))
//		goto CLOSURE_MARK;
//	
//
//
//	// Map과 Wmo 파일의 Version 무결성 체크!
//	_CheckVersion_MAPnWMO(m_wVersion, wVersion);
//
//	bRET = TRUE;
//
//CLOSURE_MARK:
//	rWMOArchive.Close();
//
//	return bRET;
//}
//
//BOOL	WiseMapInfo::_CheckVersion_MAPnWMO(DWORD verMAP, DWORD verWMO)
//{
//	// 167 이하 버전의 Map은 신규로 교체하는 것이 로딩에 부하가 적다.
//	if(!(verMAP > 167))
//	{
//		//SUNLOG(eCRITICAL_LOG, "[_CheckVersionBetweenMapWmo] Warning! %s Version[%u] is Low!!", m_tszMapPath, MapVersion);
//	}
//
//	// 162, 166, 167을 경계로 Wmo 보다 Map의 버전이 더 높으면 안된다.
//	BOOL bCheckFail = TRUE;
//
//	bCheckFail = bCheckFail && (verMAP>162) && !(verWMO>162);
//	bCheckFail = bCheckFail && (verMAP>166) && !(verWMO>166);
//	bCheckFail = bCheckFail && (verMAP>167) && !(verWMO>167);
//	bCheckFail = bCheckFail && (verMAP>170) && !(verWMO>170);
//
//	if(!bCheckFail)
//	{
//		//SUNLOG(eCRITICAL_LOG, "[_CheckVersionBetweenMapWmo] Critical! %s Version[%u] is Low!!", m_tszMapPath, WmoVersion);
//		DEBUGGING_CODE_L1("CRITICAL Version Mismatch!");
//		DEBUG_INTERRUPT();
//		return FALSE;
//	}
//	return TRUE;
//}
//
//void	WiseMapInfo::_Destroy()
//{
//}
//
//