#include "stdafx.h"
#include "SkillPreviewWindow.h"
#include "Label.h"
#include "ComboBox.h"
#include "GameResourceManager.h"
#include "TabButton.h"
#include "SkillPreviewSheet.h"
#include "UIRootNode.h"
#include "SkillScript.h"
#include "ObjectManager.h"
#include "Hero.h"
#include "SkillManager.h"

cSkillPreviewWindow::cSkillPreviewWindow()
: mpUsePoint(0)
, mpLimitLevel(0)
{
	memset( mpJobCombo, 0, sizeof(mpJobCombo) );
	mTabBaseRect.Set( 0, 0, 0, 0 );
}

cSkillPreviewWindow::~cSkillPreviewWindow()
{
}

void cSkillPreviewWindow::Close()
{
	Clear();
}

void cSkillPreviewWindow::OnHide()
{
	cTabWindow::OnHide();

	Clear();

	UIMAN->HideTip();
	HERO->CloseNpcTalk();
}

void cSkillPreviewWindow::Clear()
{
	// ÄÞº¸¹Ú½º Ŭ¸®¾î
	for( int i = 0; i < MAX_JOBCOMBO; ++i )
	{
		if( mpJobCombo[i] )
			mpJobCombo[i]->Clear();
	}

	//
	mJobIndexList.Clear();

	HideJobTab( 0 );

	// µ¥ÀÌÅÍ »èÁ¦
	typedef tPointerHashMap<unsigned long, void*> cKeepSkillMap;

	cJobSkillMap::cIterator i = mJobSkillMap.Begin();
	cJobSkillMap::cIterator end = mJobSkillMap.End();
	for( ; i != end; ++i )
	{
		sPreviewData* data = (sPreviewData*)(i->mSecond);
		SAFE_DELETE( data );
	}
	mJobSkillMap.Clear();

	//
	cKeepSkillMap::cIterator di = mKeepSkillMap.Begin();
	cKeepSkillMap::cIterator dend = mKeepSkillMap.End();
	for( ; di != dend; ++di )
	{
		sSkillData* skillData = (sSkillData*)(di->mSecond);
		if( skillData )
		{
			skillData->skillSet.Clear();
		}
		SAFE_DELETE( skillData );
	}
	mKeepSkillMap.Clear();

	//
	SetLevel( 0 );
	SetUsePoint( 0 );
}

void cSkillPreviewWindow::Show( unsigned long jobindex1, unsigned long jobindex2 )
{
	if( !mpJobCombo[0] )
	{
		assert(0);
		return;
	}

	cTabWindow::Show( true );

	unsigned long first = jobindex1 / 1000;
	unsigned long second = jobindex2 / 1000;

	// ÇØ´ç ±âº»Á÷¾÷°ú °ü·ÃÀÖ´Â Á÷¾÷¸¸ µû·Î Ã߸®±â
	typedef tPointerHashMap<unsigned long, void*> cJopInfoMap;
	cJopInfoMap* jobInfoMap = GAMERESOURCEMAN->GetJobInfoMap();
	if( jobInfoMap && jobInfoMap->IsEmpty() == false )
	{
		cJopInfoMap::cIterator i = jobInfoMap->Begin();
		cJopInfoMap::cIterator end = jobInfoMap->End();
		for( ; i != end; ++i )
		{
			unsigned long index = (unsigned long)(i->mFirst);
			sJobInfo* info = (sJobInfo*)(i->mSecond);
			if( info )
			{
				unsigned long value = index / 1000;
				if( value == first || value == second )
				{
					mJobIndexList.PushBack( index );
				}
			}
			else
				assert(0);
		}

		///
		mJobIndexList.Sort();
	}

	// ´Ù¸¥ ÄÞº¸´Â ±âº»À¸·Î ¼¼ÆÃ
	for( int i = 1; i < MAX_JOBCOMBO; ++i )
	{
		if( mpJobCombo[i] )
		{
			mpJobCombo[i]->AddItem( UIMAN->GetUIText( 160 ), (void*)0 );
			mpJobCombo[i]->SetSelect( 0, false );
			mpJobCombo[i]->SetEnabled( false );
		}
	}

	// ±âº»Á÷¾÷ 2°³ ¼¼ÆÃ
	LPCTSTR jobname1 = GAMERESOURCEMAN->GetJobName( jobindex1 );
	LPCTSTR jobname2 = GAMERESOURCEMAN->GetJobName( jobindex2 );

	mpJobCombo[0]->AddItem( jobname1, (void*)jobindex1 );
	mpJobCombo[0]->AddItem( jobname2, (void*)jobindex2 );
	mpJobCombo[0]->SetSelect( 0 );

	// ½ºÅ³µ¿±âÈ­ ¹öÆ° - heroÀÇ Á÷¾÷°ú °ü·ÃµÈ Á÷¾÷±ºÀ϶§¸¸ »ç¿ë°¡´ÉÇÏ°Ô ÇÑ´Ù
	if( mpSyncSkill )
	{
		mpSyncSkill->Hide();

		unsigned long heroJobIndex = HERO->GetJob();
		if( heroJobIndex == jobindex1 || heroJobIndex == jobindex2 )
		{
			mpSyncSkill->Show();
		}
		else
		{
			tArray<unsigned long>* parray = GAMERESOURCEMAN->GetParentJob( heroJobIndex );
			if( parray && parray->IsEmpty() == false )
			{
				unsigned long defaultJob = (unsigned long)(*parray)[0];
				if( defaultJob == jobindex1 || defaultJob == jobindex2 )
					mpSyncSkill->Show();
				else
					mpSyncSkill->Hide();
			}
		}
	}
}
 
bool cSkillPreviewWindow::OnCreate( cUINodeProperty* property )
{
	if( cTabWindow::OnCreate( property ) == false )
		return false;

	mpUsePoint = (cLabel*)GetChild( eUIID_SKILLPREVIEW_USEPOINT );
	mpLimitLevel = (cLabel*)GetChild( eUIID_SKILLPREVIEW_LEVEL );
	mpSyncSkill = GetChild( eUIID_SKILLPREVIEW_SYNC );
	mpJobCombo[0] = (cComboBox*)GetChild( eUIID_SKILLPREVIEW_DEFAULTJOB );
	mpJobCombo[1] = (cComboBox*)GetChild( eUIID_SKILLPREVIEW_CHANGEJOB1 );

	for( int i = 0; i < MAX_JOBCOMBO; ++i )
	{
		cString str = "Preview_JobTabbutton";
		cTabButton* p = new cTabButton;
		if( p->CreateBySkinName( str, this, i+1 ) == false )
		{
			assert(0);
			return false;
		}

		// À§Ä¡ ¼³Á¤
		mTabBaseRect = p->GetRelativeRect();

		cUIPos pos;
		pos.mX = mTabBaseRect.mLeft + mTabBaseRect.GetWidth() * i;
		pos.mY = mTabBaseRect.mTop;
		p->SetRelativePos( pos );

		// ¹öÆ° Ãß°¡
		AddTab( p );
		UIMAN->GetRootNode()->AddProcessChild( p );

		// ½ÃÆ® »ý¼º
		cSkillPreviewSheet* sheet = new cSkillPreviewSheet;
		if( sheet->CreateBySkinName( "Preview_SkillSheet", this, i+1 ) == false )
		{
			assert(0);
			return false;
		}

		// ½ÃÆ® Ãß°¡
		AddSheet( sheet );
		UIMAN->GetRootNode()->AddProcessChild( sheet );
	}
	return true;
}

void cSkillPreviewWindow::OnCommand( cUINode* node, unsigned int id )
{
	switch( id )
	{
	case eUIID_SKILLPREVIEW_CLOSE:
		Hide();
		break;
	case eUIID_SKILLPREVIEW_CLEAR:
		{
			// Àüü ÃʱâÈ­
			typedef tPointerHashMap<unsigned long, void*> cKeepSkillMap;

			cJobSkillMap::cIterator i = mJobSkillMap.Begin();
			cJobSkillMap::cIterator end = mJobSkillMap.End();
			for( ; i != end; ++i )
			{
				sPreviewData* data = (sPreviewData*)(i->mSecond);
				if( data )
				{
					data->highLevel = 0;
					data->jobPoint = 0;
				}
			}

			cKeepSkillMap::cIterator di = mKeepSkillMap.Begin();
			cKeepSkillMap::cIterator dend = mKeepSkillMap.End();
			for( ; di != dend; ++di )
			{
				sSkillData* skillData = (sSkillData*)(di->mSecond);
				if( skillData )
				{
					skillData->step = UCHAR_MAX;
					skillData->skillSet.Clear();
				}
			}

			SetLevel( 0 );
			SetUsePoint( 0 );

			// ½ÃÆ® ÃʱâÈ­
			for( unsigned int i = 0; i < mTabSheetArray.GetSize(); i++ )
			{
				cSkillPreviewSheet* p = (cSkillPreviewSheet*)mTabSheetArray[i];
				if( p ) 
					p->InitSkillTree();
			}
		}
		break;
	case eUIID_SKILLPREVIEW_SYNC:
		// ÇöÀç ½ºÅ³°ú µ¿±âÈ­
		SyncHeroSkill();
		break;
	}
}

//
void cSkillPreviewWindow::OnComboSelected( cUINode* caller, unsigned int id )
{
	if( caller == 0 )
	{
		assert(0);
		return;
	}

	cComboBox* jobCombo = (cComboBox*)caller;
	unsigned long jobIndex = (unsigned long)jobCombo->GetSelectData();

	unsigned int jobStep = 0;
	switch( id )
	{
	case eUIID_SKILLPREVIEW_DEFAULTJOB:	jobStep = 0; break;
	case eUIID_SKILLPREVIEW_CHANGEJOB1:	jobStep = 1; break;
	default:							assert(0);	 return;
	}

	// ¼³Á¤
	HideJobTab( jobStep );
	ShowJobTab( jobStep, jobIndex );

	// ÄÞº¸ °»½Å - ¼±Åà ÃʱâÈ­ ( 1Â÷ ÀÌ»óÀº ¾Èº¸ÀÌ°ÔÇÑ´Ù)
	if( jobStep + 1 > 1 )
		return;

	UpdateJobCombo( jobStep + 1 );
	mpJobCombo[jobStep + 1]->SetSelect( 0 );
}

void cSkillPreviewWindow::HideJobTab( unsigned int jobStep )
{
	if( mTabSheetArray.GetSize() < jobStep )
		return;

	// ÅǹöÆ°, ÅǽÃÆ®
	for( unsigned int i = jobStep; i < mTabSheetArray.GetSize(); i++ )
	{
		cSkillPreviewSheet* p = (cSkillPreviewSheet*)mTabSheetArray[i];
		if( p ) 
		{
			p->Hide();
			p->Clear();
		}
	}

	for( unsigned int i = jobStep; i < mTabButtonArray.GetSize(); i++ )
	{
		cTabButton* p = (cTabButton*)mTabButtonArray[i];
		if( p ) 
			p->Hide();
	}
}

void cSkillPreviewWindow::ShowJobTab( unsigned int jobStep, unsigned long jobIndex )
{
	cSkillTree* tree = SKILLSCRIPT->GetSkillTree( jobIndex );
	if( tree )
	{
		// »õÅÇ º¸À̱â
		cSkillPreviewSheet* sheet = (cSkillPreviewSheet*)mTabSheetArray[jobStep];
		cTabButton* button = (cTabButton*)mTabButtonArray[jobStep];
		if( sheet && button )
		{
			// ¹öÆ° ¼¼ÆÃ
			LPCTSTR jobname = GAMERESOURCEMAN->GetJobName( jobIndex );
			button->SetText( jobname );

			// ½ºÅ³Æ®¸® ¼ÂÆÃ
			sheet->SetSkillTree( jobIndex, tree );

			SetCurrent( jobStep );
			button->Show();
		}

	}
	else
	{
		if( jobStep > 0 )
			SetCurrent( jobStep - 1);
	}

}

void cSkillPreviewWindow::UpdateJobCombo( int step )
{
	// ¹üÀ§°Ë»ç
	if( !(step > 0 && step < MAX_JOBCOMBO) )
		return;

	// ÄÞº¸ ¸ñ·Ï Àç ¼¼ÆÃ
	if( mJobIndexList.IsEmpty() == false )
	{
		mpJobCombo[step]->Clear();
		mpJobCombo[step]->AddItem( UIMAN->GetUIText( 160 ), (void*)0 );
		mpJobCombo[step]->SetSelect( 0, false );
		mpJobCombo[step]->SetEnabled( false );
		
		// Á÷¾÷À妽º
		unsigned long selectJobIndex = (unsigned long)mpJobCombo[step-1]->GetSelectData();
		unsigned long selectDefaultJob = selectJobIndex;

		tArray<unsigned long>* parentJobArr = GAMERESOURCEMAN->GetParentJob( selectJobIndex );
		if( parentJobArr )
			selectDefaultJob = (*parentJobArr)[0];

		cJobIndexList::cIterator i = mJobIndexList.Begin();
		cJobIndexList::cIterator end = mJobIndexList.End();
		for( ; i != end; ++i )
		{
			unsigned long jobIndex = (unsigned long)(*i);
			unsigned long defaultJob = jobIndex;

			tArray<unsigned long>* parentJobArr = GAMERESOURCEMAN->GetParentJob( jobIndex );
			if( parentJobArr )
				defaultJob = (*parentJobArr)[0];

			// ±âº»Á÷¾÷ÀÌ µ¿ÀÏÇÑ Á÷¾÷ ¸®½ºÆ®¸¸ »ðÀÔ
			if( defaultJob != selectDefaultJob )
				continue;

			// ÀüÁ÷ ´Ü°è °Ë»ç
			unsigned short jobStep = (short)(( jobIndex - defaultJob ) / 100);
			if( jobStep != step )
				continue;

			// 1Â÷ ÀüÁ÷À̸é ÀüºÎ »ðÀÔ ±×¿Ü ÀüÁ÷Àº ¾Õ ´Ü°è¿Í ¿¬°á µÇ´Â ³»¿ë¸¸ »ðÀÔ
			if( step != 1 )
			{
				short selectValue = (short)( selectJobIndex % 10 );
				short value = (short)( jobIndex % 10 );
				if( selectValue != value )
					continue;
			}

			// µ¿ÀÏ ÀüÁ÷ Â÷¼ö¸¸ »ðÀÔ
			LPCTSTR jobname = GAMERESOURCEMAN->GetJobName( jobIndex );
			mpJobCombo[step]->AddItem( jobname, (void*)jobIndex );
			mpJobCombo[step]->SetEnabled( true );
		}
	}
}

void cSkillPreviewWindow::SyncHeroSkill()
{
	// µ¥ÀÌÅÍ ÃʱâÈ­
	typedef tPointerHashMap<unsigned long, void*> cKeepSkillMap;
	cKeepSkillMap::cIterator di = mKeepSkillMap.Begin();
	cKeepSkillMap::cIterator dend = mKeepSkillMap.End();
	for( ; di != dend; ++di )
	{
		//unsigned long skillIndex = (unsigned long)(di->mFirst);
		sSkillData* skillData = (sSkillData*)(di->mSecond);
		if( skillData )
		{
			skillData->step = UCHAR_MAX;
			skillData->skillSet.Clear();
		}
	}

	typedef tPointerHashMap<unsigned long, void*> cHeroKeepSkillMap;
	cHeroKeepSkillMap* keepSkillMap = SKILLMAN->GetKeepSkillMap();
	if( keepSkillMap )
	{
		cHeroKeepSkillMap::cIterator i = keepSkillMap->Begin();		
		cHeroKeepSkillMap::cIterator end = keepSkillMap->End();
		for( ; i != end; ++i )
		{
			unsigned long skillIndex = (unsigned long)(i->mFirst);
			sKeepSkill* pKeepSkill = (sKeepSkill*)(i->mSecond);

			if( pKeepSkill )
			{
				// ½ºÅÜÁ¤º¸ °»½Å
				sSkillData* data = (sSkillData*)mKeepSkillMap.GetAt( skillIndex );
				if( data )
				{
					sPlayerSkillBaseInfo* info = SKILLSCRIPT->GetPlayerSkillInfo( skillIndex );
					if( info == 0 )
					{
						assert(0);
						continue;
					}

					sPlayerSkillStepInfo stepInfo = info->mpSetpInfoArray[pKeepSkill->mStep];

					// ¼±Çེų °ü·Ã µ¥ÀÌÅÍ °»½Å
					if( stepInfo.mLearnSkillIdx1 > 0 )
					{
						sSkillData* learnData = GetSkillData( stepInfo.mLearnSkillIdx1 );
						if( learnData )
						{
							learnData->skillSet.Insert( skillIndex );
						}
						else
							assert(0);
					}

					if( stepInfo.mLearnSkillIdx2 > 0 )
					{
						sSkillData* learnData = GetSkillData( stepInfo.mLearnSkillIdx2 );
						if( learnData )
						{
							learnData->skillSet.Insert( skillIndex );
						}
						else
							assert(0);
					}

					// ½ºÅÇ °»½Å
					data->step = pKeepSkill->mStep;
				}
			}
		}
	}

	for( unsigned int i = 0; i < mTabSheetArray.GetSize(); i++ )
	{
		cSkillPreviewSheet* p = (cSkillPreviewSheet*)mTabSheetArray[i];
		if( p ) 
			p->SyncSkillTree();
	}
}

sPreviewData* cSkillPreviewWindow::GetPreviewData( unsigned long jobIndex )
{
	if( mJobSkillMap.IsEmpty() == true )
		return 0;

	return (sPreviewData*)mJobSkillMap.GetAt( jobIndex );
}

sSkillData* cSkillPreviewWindow::GetSkillData( unsigned long skillIndex )
{
	return (sSkillData*)mKeepSkillMap.GetAt( skillIndex );
}

void cSkillPreviewWindow::InsertKeepSkill( unsigned long skillindex, unsigned char step )
{
	if( GetSkillData( skillindex ) == 0 )
	{
		sSkillData* p = new sSkillData;

		p->step = step;

		if( mKeepSkillMap.Insert( skillindex, p ) == false )
		{
			assert(0);
		}
	}
}

void cSkillPreviewWindow::UpdateSkillStep( unsigned long skillIndex, unsigned char step )
{
	sSkillData* skilldata = (sSkillData*)mKeepSkillMap.GetAt( skillIndex );
	if( skilldata )
	{
		skilldata->step = step;
	}
}

void cSkillPreviewWindow::SetLevel( char level )
{
	if( mpLimitLevel )
		mpLimitLevel->SetValue( level );
}

void cSkillPreviewWindow::SetUsePoint( long point )
{
	if( mpUsePoint )
		mpUsePoint->SetValue( point );
}

void cSkillPreviewWindow::CheckInfo( unsigned long jobIndex )
{
	unsigned long totalPoint = 0;
	char highLevel = 0;

	cSkillTree* tree = SKILLSCRIPT->GetSkillTree( jobIndex );
	if( tree )
	{
		for( unsigned int i = 0; i < tree->mIconCount; ++i )
		{
			unsigned long skillIndex = tree->mIconList[i].skillIdx;

			sSkillData* data = GetSkillData( skillIndex );
			if( !data )
				continue;

			if( data->step == UCHAR_MAX )
				continue;

			sPlayerSkillBaseInfo* info = SKILLSCRIPT->GetPlayerSkillInfo( skillIndex );
			if( info )
			{
				// ÇöÀç ´Ü°è±îÁö ÇÊ¿äÇÑ Æ÷ÀÎÆ® °è»ê
				for( int step = 0; step < data->step + 1; ++step )
				{
					sPlayerSkillStepInfo stepInfo = info->mpSetpInfoArray[step];
					totalPoint += stepInfo.mRequireSP;

					if( highLevel < stepInfo.mPlayerLevel )
						highLevel = stepInfo.mPlayerLevel;
				}
			}
		}
	}

	// Á÷¾÷º° Á¤º¸ °»½Å
	UpdatePreviewData( jobIndex, totalPoint, highLevel );
}

void cSkillPreviewWindow::UpdateInfoUI( unsigned long jobIndex )
{
	sPreviewData* data = GetPreviewData( jobIndex );
	if( data )
	{
		SetLevel( data->highLevel );
		SetUsePoint( data->jobPoint );
	}
}

bool cSkillPreviewWindow::UpdatePreviewData( unsigned long jobIndex, long jobPoint, char highLevel )
{
	sPreviewData* p = GetPreviewData( jobIndex );
	if( p == 0 )
	{
		p = new sPreviewData;
		if( mJobSkillMap.Insert( jobIndex, p ) == false )
		{
			SAFE_DELETE( p );
			assert(0);
			return false;
		}
	}

	p->jobPoint = jobPoint;
	p->highLevel = highLevel;
	return true;
}

unsigned long cSkillPreviewWindow::GetCurrentJobIndex()
{
	cSkillPreviewSheet* pSkillPrevSheet = (cSkillPreviewSheet*)GetCurrentSheet();
	if( pSkillPrevSheet && pSkillPrevSheet->GetParent() == this )
	{
		return pSkillPrevSheet->GetJobIndex();
	}
	else
	{
		assert(0);
		return 0;
	}
}