#include "stdafx.h"
#include "SDecomposeDB.h"

#include "DecomposeBase.h"
#include <kfile/KFileManager.h>

#include "SLog.h"

#include "SkillBaseFile.h"
#include <kfile/KStream.h>
#include "KTypes.h"

//-----------------------------------------------------------------------------------------------------------------
// 분해 식 DB 인스턴스 얻기
//-----------------------------------------------------------------------------------------------------------------
SDecomposeDB* SDecomposeDB::m_pThis = NULL;
SDecomposeDB & GetDecomposeDB()
{
	if( NULL == SDecomposeDB::m_pThis )
		SDecomposeDB::m_pThis = new SDecomposeDB;

	return *SDecomposeDB::m_pThis;

//	static SDecomposeDB DecomposeDB;
//	return DecomposeDB;
}


//-----------------------------------------------------------------------------------------------------------------
// 생성자
//-----------------------------------------------------------------------------------------------------------------
SDecomposeDB::SDecomposeDB()
{
	if( false == Load() )
	{
		SDEBUGLOG( "[SDecomposeDB] Load Failed " );
		assert( NULL );
	}
}


//-----------------------------------------------------------------------------------------------------------------
// 파괴자
//-----------------------------------------------------------------------------------------------------------------
SDecomposeDB::~SDecomposeDB()
{
	Destroy();
}


//-----------------------------------------------------------------------------------------------------------------
// RDB 파일 불러오기
//-----------------------------------------------------------------------------------------------------------------
bool SDecomposeDB::Load()
{
	KStream* pRes( KFileManager::Instance().CreateStreamFromResource( "db_Decompose.rdb" ) );
	if( NULL == pRes ) 
	{
		SDEBUGLOG( "[SDecomposeDB] Create Stream Failed - [db_Decompose.rdb]" );
		assert( NULL );
		return false;
	}

	GAME_DB			db_hdr;
	std::string		idKey;

	pRes->Read( &db_hdr, sizeof(db_hdr) );

	for( int nCount = 0; nCount < db_hdr.nCount; nCount++ )
	{
		DecomposeBase stDecomposeBase;
		size_t ReadSize( pRes->Read( &stDecomposeBase, sizeof(DecomposeBase) ) );
		if( NULL == ReadSize )
		{
			SDEBUGLOG( "[SDecomposeDB] Read Failed" );
			assert( ReadSize );
			return false;
		}

		PDECOMPOSE_FORMULA_INFO pFormulaInfo( new DECOMPOSE_FORMULA_INFO() );
		if( NULL == pFormulaInfo )
		{
			SDEBUGLOG( "[SDecomposeDB] Memory Alloc Failed" );
			assert( pFormulaInfo );
			continue;
		}
		
		pFormulaInfo->m_nNeedPrice = stDecomposeBase.nNeed_Price;

		// 아 그지같다... 정녕 이렇게 밖에 넣을 수 없는가...
		DECOMPOSE_IDENTITY_INFO stIdentityInfo_01;
		stIdentityInfo_01.m_nType	= stDecomposeBase.nMaterial_Type_01;
		stIdentityInfo_01.m_nValue = stDecomposeBase.nMaterial_Value_01;
	
		pFormulaInfo->m_vecIdentity.push_back( stIdentityInfo_01 );

		DECOMPOSE_IDENTITY_INFO stIdentityInfo_02;
		stIdentityInfo_02.m_nType	= stDecomposeBase.nMaterial_Type_02;
		stIdentityInfo_02.m_nValue = stDecomposeBase.nMaterial_Value_02;
	
		pFormulaInfo->m_vecIdentity.push_back( stIdentityInfo_02 );

		DECOMPOSE_IDENTITY_INFO stIdentityInfo_03;
		stIdentityInfo_03.m_nType	= stDecomposeBase.nMaterial_Type_03;
		stIdentityInfo_03.m_nValue = stDecomposeBase.nMaterial_Value_03;
	
		pFormulaInfo->m_vecIdentity.push_back( stIdentityInfo_03 );

		DECOMPOSE_IDENTITY_INFO stIdentityInfo_04;
		stIdentityInfo_04.m_nType	= stDecomposeBase.nMaterial_Type_04;
		stIdentityInfo_04.m_nValue = stDecomposeBase.nMaterial_Value_04;
	
		pFormulaInfo->m_vecIdentity.push_back( stIdentityInfo_04 );

		DECOMPOSE_IDENTITY_INFO stIdentityInfo_05;
		stIdentityInfo_05.m_nType	= stDecomposeBase.nMaterial_Type_05;
		stIdentityInfo_05.m_nValue = stDecomposeBase.nMaterial_Value_05;
	
		pFormulaInfo->m_vecIdentity.push_back( stIdentityInfo_05 );

		if( false == m_mapDecomposeFormula.insert( pair<UINT, PDECOMPOSE_FORMULA_INFO>( stDecomposeBase.nID, pFormulaInfo ) ).second )
		{
			SAFE_DELETE( pFormulaInfo );
			SDEBUGLOG( "[SDecomposeDB] ID 중복이거나 컨테이너 삽입에 실패하였습니다." );
			assert( pFormulaInfo );
			continue;
		}
	}

	KFileManager::Instance().DeleteStream( pRes );

	return true;
}


//-----------------------------------------------------------------------------------------------------------------
// 파괴
//-----------------------------------------------------------------------------------------------------------------
void SDecomposeDB::Destroy()
{
	for( DECOMPOSE_FORMULA_ITER Iter =  m_mapDecomposeFormula.begin(); Iter != m_mapDecomposeFormula.end(); ++Iter )
	{
		PDECOMPOSE_FORMULA_INFO pDecomposeFormula( Iter->second );
		SAFE_DELETE( pDecomposeFormula );	
	}

	m_mapDecomposeFormula.clear();
}


//-----------------------------------------------------------------------------------------------------------------
// 분해 식 리스트 얻기
//-----------------------------------------------------------------------------------------------------------------
map< UINT, DECOMPOSE_FORMULA_INFO* >* const SDecomposeDB::GetDecomposeFormula()
{
	return &m_mapDecomposeFormula;
}