#include "stdafx.h"
#include "SItemDB.h"

#include <Windows.h>
#include <kfile/KStream.h>
#include "KTypes.h"
#include <kfile/KFileManager.h>
#include <toolkit/XStringUtil.h>
//#include "Util.h"
#include "SStringDB.h"
#include "GameDefine.h"

#include "Slog.h"
#include <tchar.h>

#ifdef _DEV
#include "KResourceManager.h"
#endif

#include "SDebug_Util.h"

SItemReferenceDB::SItemReferenceDB()
{
	Init();
}

SItemReferenceDB::~SItemReferenceDB()
{
	Destroy();
}

void SItemReferenceDB::Init()
{
	Load();
}

void SItemReferenceDB::Destroy()
{
	SAFE_DELETE_VECTOR( m_ItemReferenceList );
}

void SItemReferenceDB::Load()
{
	KStream * pRes = KFileManager::Instance().CreateStreamFromResource("db_item.ref");
	if (!pRes) return;
	int nCount = 0;
	int nKey = 0;
	
	pRes->Read( &nCount, sizeof(nCount) );
	pRes->Read( &nKey, sizeof(nKey) );

	for ( int i(0); nCount > i; i++ )
	{
		char* szText = new char[nKey];

		pRes->Read( szText, sizeof( char ) * nKey );
		m_ItemReferenceList.push_back( szText );
	}

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

void SItemReferenceDB::SetInfo( ItemBaseEx_info_Client * pBase, ItemBaseEx * nBase )
{
	pBase->pModel00				= allocString( GetReference(nBase->model00) );
	pBase->pModel01				= allocString( GetReference(nBase->model01) );
	pBase->pModel02				= allocString( GetReference(nBase->model02) );
	pBase->pModel03				= allocString( GetReference(nBase->model03) );
	pBase->pModel04				= allocString( GetReference(nBase->model04) );
	pBase->pModel05				= allocString( GetReference(nBase->model05) );
	pBase->pModel06				= allocString( GetReference(nBase->model06) );
	pBase->pModel07				= allocString( GetReference(nBase->model07) );
	pBase->pModel08				= allocString( GetReference(nBase->model08) );
	pBase->pModel09				= allocString( GetReference(nBase->model09) );
	pBase->pModel10				= allocString( GetReference(nBase->model10) );
	pBase->pModel11				= allocString( GetReference(nBase->model11) );
	pBase->pModel12				= allocString( GetReference(nBase->model12) );
	pBase->pModel13				= allocString( GetReference(nBase->model13) );
	pBase->pModel14				= allocString( GetReference(nBase->model14) );
	pBase->pModel15				= allocString( GetReference(nBase->model15) );
	pBase->pModel16				= allocString( GetReference(nBase->model16) );
	pBase->pModel17				= allocString( GetReference(nBase->model17) );
	if(nBase->icon_file_name != -1)
		pBase->pIcon_name		= allocString( GetReference(nBase->icon_file_name) );
	else
		pBase->pIcon_name		= allocString( "static_enhance_failed_item" );
	pBase->pDrop_model			= allocString( GetReference(nBase->drop_model) );
	pBase->pTexture_filename	= allocString( GetReference(nBase->texture_filename) );
}

const char * SItemReferenceDB::GetReference( int nIndex )
{
	if (m_ItemReferenceList.empty()) return c_szNotFound;

	if (0 < nIndex && nIndex <= (int)m_ItemReferenceList.size())
	{
		return m_ItemReferenceList[nIndex];
	}
	return "";
}

SItemReferenceDB* SItemReferenceDB::m_pThis = NULL;
SItemReferenceDB & GetItemReferenceDB()
{
	if (NULL == SItemReferenceDB::m_pThis)
		SItemReferenceDB::m_pThis = new SItemReferenceDB;

	return *SItemReferenceDB::m_pThis;
}

SItemDB::SItemDB() : m_pDummyData( NULL )
{
	Init();
}

SItemDB::~SItemDB()
{
	Destroy();
}

bool SItemDB::IsWearable( ENC_INT nItemID, int nJobID, int nRace, int nLevel ) 
{
	const ItemBaseEx_info* pItem = GetItemDB().GetItemData( nItemID );
	return IsWearable( pItem, nJobID, nRace, nLevel );
}

bool	SItemDB::IsWearable( const ItemBaseEx_info* pItem, int nJobID, int nRace, int nLevel )
{
	// 장비품 아님
	if( pItem->WearType == ItemBase::WEAR_CANTWEAR && pItem->nCode != 804000 )
	{
		return false;
	}

	if( GetItemDB().IsWearablebyRace( pItem, nRace ) == false )
	{
		return false;
	}

	if( GetItemDB().IsWearablebyJob( pItem, nJobID, nRace ) == false )
	{
		return false;
	}

	if( GetItemDB().IsWearablebyJobDepth( pItem, nJobID ) == false )
	{
		return false;
	}

	if( GetItemDB().IsWearablebyLevel( pItem, nLevel ) == false )
	{
		return false;
	}

	return true;
}

SItemDB::ITEM_ENHANCE_LEVEL SItemDB::CheckItemLevel( int nItemLevel )
{
	if( nItemLevel >= 0 && nItemLevel <= 5 )
		return LEVEL_1;
	else if( nItemLevel >= 6 && nItemLevel <= 9 )
		return LEVEL_2;
	else if( nItemLevel >= 10 )
		return LEVEL_3;

	return LEVEL_MAX;
}

void SItemDB::Init()
{
	Load();

	m_pDummyData = new ItemBaseEx_info_Client;
	::ZeroMemory( m_pDummyData, sizeof(ItemBaseEx_info_Client) );

	ItemBaseEx itembaseex;

	itembaseex.icon_id			= (-1);	
	itembaseex.icon_file_name = -1;
	itembaseex.model00 = 0;
	itembaseex.model01 = 0;
	itembaseex.model02 = 0;
	itembaseex.model03 = 0;
	itembaseex.model04 = 0;
	itembaseex.model05 = 0;
	itembaseex.model06 = 0;
	itembaseex.model07 = 0;
	itembaseex.model08 = 0;
	itembaseex.model09 = 0;
	itembaseex.model10 = 0;
	itembaseex.model11 = 0;
	itembaseex.model12 = 0;
	itembaseex.model13 = 0;
	itembaseex.model14 = 0;
	itembaseex.model15 = 0;
	itembaseex.model16 = 0;
	itembaseex.model17 = 0;
	itembaseex.drop_model = 0;
	itembaseex.texture_filename = 0;

	m_pDummyData->SetInfo( &itembaseex );
	GetItemReferenceDB().SetInfo( m_pDummyData, &itembaseex );
}

void SItemDB::Destroy()
{
	SAFE_DELETE( m_pDummyData );

	ItemBaseEx_info_Client* pItem = NULL;
	bool res;
	res = m_hashItem.get_first_value( pItem );
	while ( res )
	{
		if ( pItem != NULL )
		{
			delete pItem;
		}
		res = m_hashItem.get_next_value( pItem );
	}
	m_hashItem.clear();
}

const std::vector< ItemEnhanceEffectBase >& SItemDB::Find(int nEnhanceID)
{
	auto pos = m_mapEnhanceEffect.find(nEnhanceID);
	if (pos != m_mapEnhanceEffect.end())
	{
		return pos->second;
	}

	static std::vector< ItemEnhanceEffectBase > empty_list;
	return empty_list;
}

void SItemDB::Load()
{
	KStream * pRes = KFileManager::Instance().CreateStreamFromResource( "db_item.rdb" );
	if( !pRes ) return;
	GAME_DB db_hdr;

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

	ItemBaseEx item;
	for( int i(0); db_hdr.nCount>i; i++ )
	{
		memset( &item, 0, sizeof(item) );
		pRes->Read( &item, sizeof(item) );

		ItemBaseEx_info_Client * pFindItem = NULL;

		ItemBaseEx_info_Client * pItem = new ItemBaseEx_info_Client;
		::memset(pItem, 0x00, sizeof(ItemBaseEx_info_Client)); //초기화가 없어서 쓰레기값 들어있음 -N4-
		pItem->SetInfo( &item );
		
		GetItemReferenceDB().SetInfo( pItem, &item );

		if (pItem->nEnhanceID > 0)
		{
			std::vector< ItemEnhanceEffectBase > v;
			
			item.SetInfo(pItem->nEnhanceID, &v);
			m_mapEnhanceEffect.insert(std::make_pair(pItem->nEnhanceID, v));
		}

		pItem->real_uid = pItem->nCode;

#ifdef _DEV

		if(KSpriteManager::GetManager()->GetResSpriteAni("ui_frame.spr", pItem->pIcon_name) == NULL)
		{		
			GetLog().DebugLog( "ItemDB - spr에 icon 파일이 등록되지 않았습니다  -  id:%d   /  icon id:%d  /  %s  \n",pItem->nCode, pItem->icon_id,pItem->pIcon_name );
		}

#endif

		pItem->nCode = XFastRandom();

		// 7랭크 세트 아이템을 제외한 세트 아이템 목록 저장
		if( pItem->set_id 
			&& pItem->nRank != 7 )
		{
			m_vSetItem.push_back(pItem);
		}


		if( m_hashItem.lookup( pItem->real_uid, pFindItem ) == false )
		{
			m_hashItem.add( pItem->real_uid, pItem );
		}
		else
		{
			//_oprint( "!!!!Data Error Item Code 가 중복되었습니다.!!!!\n" );
			GetLog().DebugLog( "!!!!Data Error Item Code 가 중복되었습니다.!!!!\n" );

			//			assert(0); //기획팀에 알려 주세여. 바로 수정 해야 합니다.
		}





	}

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

vector<ITEMIDENTITYFORDEV> SItemDB::GetItemIdentityList(  string strFindItemName )
{
	vector<ITEMIDENTITYFORDEV> vecItemIdentity;

#ifdef _DEV
	KHash< struct ItemBaseEx_info_Client*, hashPr_mod_ENC_INT>::node* _node = NULL;
	
	bool bResult = m_hashItem.get_first_node( _node );
	while ( bResult )
	{
		ItemBaseEx_info_Client* pItem( _node->value );
		
		if( pItem )
		{
			string strItemName( S( pItem->nNameId ) );

			size_t found = strItemName.find( strFindItemName );
		
			if (found != string::npos)
			{
				ITEMIDENTITYFORDEV stItemIdentityForDev;
	
				stItemIdentityForDev.m_uItemID		= pItem->real_uid.value();
				stItemIdentityForDev.m_strItemName	= strItemName;
					
				vecItemIdentity.push_back( stItemIdentityForDev );
			}
		}

		bResult = m_hashItem.get_next_node( _node );
	}
#endif

	return vecItemIdentity;
}

SItemDB* SItemDB::m_pThis = NULL;
SItemDB & GetItemDB()
{
//	static SItemDB itemdb;
	if( NULL == SItemDB::m_pThis )
		SItemDB::m_pThis = new SItemDB;

	return *SItemDB::m_pThis;
//	return itemdb;
}

//////////////////////////////////////////////////////////////////////////
//FaceWink Data

SFaceWinkDB::SFaceWinkDB()
{
	Init();
}

SFaceWinkDB::~SFaceWinkDB()
{
	Destroy();
}

void SFaceWinkDB::Init()
{
	Load();
}

void SFaceWinkDB::Destroy()
{
	FaceWinkData* pData = NULL;
	bool res;
	res = m_hashFaceWinkRes.get_first_value( pData );
	while ( res )
	{
		if ( pData != NULL )
		{
			delete pData;
		}
		res = m_hashFaceWinkRes.get_next_value( pData );
	}
	m_hashFaceWinkRes.clear();
}

void SFaceWinkDB::Load()
{
	KStream * pRes = KFileManager::Instance().CreateStreamFromResource( "FaceWinkDB.txt" );
	if( !pRes ) return;

	size_t nLen = pRes->GetLength();
	char * pstrTemp = new char[nLen+1];
	pstrTemp[nLen] = '\0';
	for( size_t i(0); nLen>i; i++ )
	{
		pRes->Read( &pstrTemp[i], 1 );
	}

	std::vector< std::string > vString;
	XStringUtil::Split( pstrTemp, vString, "|\r\n" );

	int nLoop = (int)vString.size()/7;

	int n=0;
	for( int i(0); nLoop>i; i++ )
	{
		int nModelID = atoi( vString[n++].c_str() );

		FaceWinkData* pFind = NULL;
		if( m_hashFaceWinkRes.lookup( nModelID, pFind ) )
		{
			continue;
		}

		FaceWinkData* pData = new FaceWinkData;

		pData->model_id		= nModelID;
		pData->deva_male	= vString[n++].c_str();
		pData->deva_female	= vString[n++].c_str();
		pData->asura_male	= vString[n++].c_str();
		pData->asura_female	= vString[n++].c_str();
		pData->gaia_male	= vString[n++].c_str();
		pData->gaia_female	= vString[n++].c_str();

		m_hashFaceWinkRes.add( pData->model_id, pData );
	}

	vString.clear();

	delete [] pstrTemp;
	KFileManager::Instance().DeleteStream( pRes );
}

const char* SFaceWinkDB::GetFileName( int nRace, int nSex, int nDefaultID )
{
	FaceWinkData * pFindItem = NULL;
	if( m_hashFaceWinkRes.lookup( nDefaultID, pFindItem ) )
	{
		if( nRace == GCLAN_GAIA )
		{
			if( nSex == SEX_FEMALE )	return pFindItem->gaia_female.c_str();
			else if( nSex == SEX_MALE   )	return pFindItem->gaia_male.c_str();
		}
		else if( nRace == GCLAN_DEVA )
		{
			if( nSex == SEX_FEMALE )	return pFindItem->deva_female.c_str();
			else if( nSex == SEX_MALE   )	return pFindItem->deva_male.c_str();
		}
		else if( nRace == GCLAN_ASURA )
		{
			if( nSex == SEX_FEMALE )	return pFindItem->asura_female.c_str();
			else if( nSex == SEX_MALE   )	return pFindItem->asura_male.c_str();
		}
	}
	return "NotFoundFile";
}

SFaceWinkDB & GetFaceWinkDB()
{
	static SFaceWinkDB FaceWinkDB;
	return FaceWinkDB;
}

//////////////////////////////////////////////////////////////////////////
//Default Item Data
SDefaultItemDB & GetDefaultItemDB()
{
	static SDefaultItemDB DefaultItemDB;
	return DefaultItemDB;
}

SDefaultItemDB::SDefaultItemDB()
{
	Init();
}

SDefaultItemDB::~SDefaultItemDB()
{
	Destroy();
}

void SDefaultItemDB::Init()
{
	m_nCurFaceIndex = 0;
	Load();
}

void SDefaultItemDB::Destroy()
{
	DefaultModelResforGame* pDefaultModelRes = NULL;
	bool res;
	res = m_hashDefaultModelRes.get_first_value( pDefaultModelRes );
	while ( res )
	{
		if ( pDefaultModelRes != NULL )
		{
			delete pDefaultModelRes;
		}
		res = m_hashDefaultModelRes.get_next_value( pDefaultModelRes );
	}
	m_hashDefaultModelRes.clear();
}

void SDefaultItemDB::Load()
{
	KStream * pRes = KFileManager::Instance().CreateStreamFromResource( "db_DefaultModelRes.rdb" );
	if( !pRes ) return;
	GAME_DB db_hdr;

	pRes->Read( &db_hdr, sizeof(db_hdr) );
	for( int i(0); db_hdr.nCount>i; i++ )
	{
		DefaultModelResforGame* pItem = new DefaultModelResforGame;

		DefaultModelRes defItem;
		memset( &defItem, 0, sizeof(DefaultModelRes) );
		pRes->Read( &defItem, sizeof(DefaultModelRes) );

		pItem->SetData( &defItem );

		DefaultModelResforGame* pFindItem = NULL;
		if( m_hashDefaultModelRes.lookup( pItem->model_id, pFindItem ) == false )
		{
			switch( pItem->part_id )
			{
			case DEF_ITEM_ARMOR : 
				{
					if( pItem->lobby_resource_id == DEF_RANK )
						m_BodyItemList.push_back(pItem); 
					else if( pItem->lobby_resource_id == TOP_RANK )
						m_TopRank_BodyItemList.push_back(pItem); 
				}
				break;

			case DEF_ITEM_INNER : m_InnerItemList.push_back(pItem); break;
			case DEF_ITEM_GLOVE : 
				{
					if( pItem->lobby_resource_id == DEF_RANK )
						m_HandItemList.push_back(pItem);
					else if( pItem->lobby_resource_id == TOP_RANK )
						m_TopRank_HandItemList.push_back(pItem);
				}
				break;
			case DEF_ITEM_FOOTS : 
				{
					if( pItem->lobby_resource_id == DEF_RANK )
						m_FootItemList.push_back(pItem);
					else if( pItem->lobby_resource_id == TOP_RANK )
						m_TopRank_FootItemList.push_back(pItem);
				}
				break;
			case DEF_ITEM_HAIR  : m_HairItemList.push_back(pItem); break;
			case DEF_ITEM_FACE  : m_FaceItemList.push_back(pItem); break;
			}

			m_hashDefaultModelRes.add( pItem->model_id, pItem );
		}
		else
		{
			_oprint( "Data Error! SDefaultModelResDB::Load() Code is duplicated! %d\n", pItem->model_id );
			assert(0); // Notify planning team: must be fixed immediately

			delete pItem;
		}
	}

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

int SDefaultItemDB::GetHairID( int nIndex )
{
	if( nIndex >= 0 && nIndex < (int)m_HairItemList.size() )
	{
		return m_HairItemList[nIndex]->model_id;
	}
	assert(0);
	return -1;
}
int SDefaultItemDB::GetFaceID( int nIndex )
{
	if( nIndex >= 0 && nIndex < (int)m_FaceItemList.size() )
	{
		return m_FaceItemList[nIndex]->model_id;
	}
	assert(0);
	return -1;
}
int SDefaultItemDB::GetBodyID( int nIndex )
{
	if( nIndex >= 0 && nIndex < (int)m_BodyItemList.size() )
	{
		return m_BodyItemList[nIndex]->model_id;
	}
	assert(0);
	return -1;
}
int SDefaultItemDB::GetHandID( int nIndex )
{
	if( nIndex >= 0 && nIndex < (int)m_HandItemList.size() )
	{
		return m_HandItemList[nIndex]->model_id;
	}
	assert(0);
	return -1;
}
int SDefaultItemDB::GetFootID( int nIndex )
{
	if( nIndex >= 0 && nIndex < (int)m_FootItemList.size() )
	{
		return m_FootItemList[nIndex]->model_id;
	}
	assert(0);
	return -1;
}

int SDefaultItemDB::GetInnerID( int nIndex )
{
	if( nIndex >= 0 && nIndex < (int)m_InnerItemList.size() )
	{
		return m_InnerItemList[nIndex]->model_id;
	}
	assert(0);
	return -1;
}

int SDefaultItemDB::GetTopBodyID( int nIndex )
{
	if( nIndex >= 0 && nIndex < (int)m_TopRank_BodyItemList.size() )
	{
		return m_TopRank_BodyItemList[nIndex]->model_id;
	}
	assert(0);
	return -1;
}

int SDefaultItemDB::GetTopHandID( int nIndex )
{
	if( nIndex >= 0 && nIndex < (int)m_TopRank_HandItemList.size() )
	{
		return m_TopRank_HandItemList[nIndex]->model_id;
	}
	assert(0);
	return -1;
}

int SDefaultItemDB::GetTopFootID( int nIndex )
{
	if( nIndex >= 0 && nIndex < (int)m_TopRank_FootItemList.size() )
	{
		return m_TopRank_FootItemList[nIndex]->model_id;
	}
	assert(0);
	return -1;
}

int SDefaultItemDB::GetHairIndex( int nID )
{
	for( unsigned int i(0); m_HairItemList.size()>i; i++ )
	{
		if( m_HairItemList[i]->model_id == nID )
			return i;
	}
	assert(0);
	return -1;
}
int SDefaultItemDB::GetFaceIndex( int nID )
{
	for( unsigned int i(0); m_FaceItemList.size()>i; i++ )
	{
		if( m_FaceItemList[i]->model_id == nID )
			return i;
	}
	assert(0);
	return -1;
}
int SDefaultItemDB::GetBodyIndex( int nID )
{
	for( unsigned int i(0); m_BodyItemList.size()>i; i++ )
	{
		if( m_BodyItemList[i]->model_id == nID )
			return i;
	}

	return GetInnerIndex( nID );

	assert(0);
	return -1;
}

int SDefaultItemDB::GetInnerIndex( int nID )
{
	for( unsigned int i(0); m_InnerItemList.size()>i; i++ )
	{
		if( m_InnerItemList[i]->model_id == nID )
			return i;
	}
	assert(0);
	return -1;
}

int SDefaultItemDB::GetTopBodyIndex( int nID )
{
	for( unsigned int i(0); m_TopRank_BodyItemList.size()>i; i++ )
	{
		if( m_TopRank_BodyItemList[i]->model_id == nID )
			return i;
	}
	assert(0);
	return -1;
}

int SDefaultItemDB::GetTopHandIndex( int nID )
{
	for( unsigned int i(0); m_TopRank_HandItemList.size()>i; i++ )
	{
		if( m_TopRank_HandItemList[i]->model_id == nID )
			return i;
	}
	assert(0);
	return -1;
}

int SDefaultItemDB::GetTopFootIndex( int nID )
{
	for( unsigned int i(0); m_TopRank_FootItemList.size()>i; i++ )
	{
		if( m_TopRank_FootItemList[i]->model_id == nID )
			return i;
	}
	assert(0);
	return -1;
}

int SDefaultItemDB::GetHandIndex( int nID )
{
	for( unsigned int i(0); m_HandItemList.size()>i; i++ )
	{
		if( m_HandItemList[i]->model_id == nID )
			return i;
	}
	assert(0);
	return -1;
}
int SDefaultItemDB::GetFootIndex( int nID )
{
	for( unsigned int i(0); m_FootItemList.size()>i; i++ )
	{
		if( m_FootItemList[i]->model_id == nID )
			return i;
	}
	assert(0);
	return -1;
}

int SDefaultItemDB::GetFaceGroupID( int nIndex )
{
	if( nIndex >= 0 && nIndex < (int)m_FaceItemList.size() )
	{
		return m_FaceItemList[nIndex]->texture_group_id;
	}
	assert(0);
	return -1;
}

int SDefaultItemDB::GetHairGroupID( int nIndex )
{
	if( nIndex >= 0 && nIndex < (int)m_HairItemList.size() )
	{
		return m_HairItemList[nIndex]->texture_group_id;
	}
	assert(0);
	return -1;
}

int SDefaultItemDB::GetBodyGroupID( int nIndex )
{
	if( nIndex >= 0 && nIndex < (int)m_BodyItemList.size() )
	{
		return m_BodyItemList[nIndex]->texture_group_id;
	}		
	assert(0);
	return -1;
}

int SDefaultItemDB::GetDecoFaceGroupID( int nID )
{
	for( int i = 0; i < (int)m_FaceItemList.size(); i++ )
	{
		if( m_FaceItemList[i]->model_id == nID )
		{
			return  m_FaceItemList[i]->texture_group_id;
		}
	}
	//	assert(0);
	return -1;
}
int SDefaultItemDB::GetDecoHairGroupID( int nID )
{
	for( int i = 0; i < (int)m_HairItemList.size(); i++ )
	{
		if( m_HairItemList[i]->model_id == nID )
		{
			return  m_HairItemList[i]->texture_group_id;
		}
	}
	//	assert(0);
	return -1;
}

const char* SDefaultItemDB::GetFileName( int nRace, int nSex, int nDefaultID )
{
	DefaultModelResforGame * pFindItem = NULL;
	if( m_hashDefaultModelRes.lookup( nDefaultID, pFindItem ) )
	{
		if( nRace == GCLAN_GAIA )
		{
			if( nSex == SEX_FEMALE )	return pFindItem->gaia_female;
			else if( nSex == SEX_MALE   )	return pFindItem->gaia_male;
		}
		else if( nRace == GCLAN_DEVA )
		{
			if( nSex == SEX_FEMALE )	return pFindItem->deva_female;
			else if( nSex == SEX_MALE   )	return pFindItem->deva_male;
		}
		else if( nRace == GCLAN_ASURA )
		{
			if( nSex == SEX_FEMALE )	return pFindItem->asura_female;
			else if( nSex == SEX_MALE   )	return pFindItem->asura_male;
		}
	}
	return "NotFoundFile";
}