#include "stdafx.h"

#include "Logic.Active.h"

//////////////////////////////////////////////////////////////////////////
//

//struct LF_INFO
//{
//	DWORD						CODE;
//	LF_EXECUTE_POLICY			POLICY;
//	ConditionLogicHandler		CONDITION;
//	ActiveLogicHandler			ACTIVE_HANDLER;
//	ActiveLogicHandler			ACTIVE_HANDLER_REDIRECT;
//	PassiveLogicHandler			PASSIVE_HANDLER;
//	PassiveLogicHandler			PASSIVE_HANDLER_REDIRECT;
//	TCHAR						NAME[64];
//};
static LF_INFO	s_LF_INFO[S_999999_LF_EOL_MARK_LF+1] =
{
#	undef LF_DEFINE_T
#	define LF_DEFINE_T(name)	{ name, LFEXE_BASE, NULL, ACTIVE_HANDLER_##name, NULL, NULL, NULL, #name },
#	include <Logic.Internal.Definition.hxx>
#	undef LF_DEFINE_T
};

static LF_MAP*	s_pLF_TABLE = NULL;
#define LF_MAP_INTERFACE	(*s_pLF_TABLE)

void		LogicFlowController::CreateTable()
{
	s_pLF_TABLE = new LF_MAP;
	LF_INFO* pOffset = s_LF_INFO;
	//printf("S_999999_LF_EOL_MARK_LF %u\n", S_999999_LF_EOL_MARK_LF);
	for(DWORD dwIdx=S_000000_START_MARK_LF ; dwIdx<(S_999999_LF_EOL_MARK_LF+1) ; ++dwIdx, ++pOffset)
	{
		DWORD dwCode = pOffset->CODE;
		//printf("%u\t%s\n", dwCode, pOffset->NAME);
		LF_MAP_INTERFACE.insert(LF_MAP_INTERFACE.end(), make_pair(dwCode, pOffset));
	}
}

void		LogicFlowController::ReleaseTable()
{
	LF_MAP_INTERFACE.clear();
	SAFE_DELETE(s_pLF_TABLE);
}

BOOL		LogicFlowController::DoProcess()
{
	//	DEBUGGING_CODE_L3("");
	//printf("STAT %u %u\n", m_eSTEP, m_eCONTROL);
	BOOL bPass = (BOOL)(S_000099_CLOSURE_MARK_LF == m_eSTEP);
	if(bPass)	return TRUE;
	bPass = (BOOL)(LFRET_PENDING_UNTIL_PASSIVE == m_eCONTROL);
	if(bPass) return TRUE;

	LF_MAP_IT itFIND = LF_MAP_INTERFACE.find(m_eSTEP);
	if(itFIND == LF_MAP_INTERFACE.end())
	{
		DEBUGGING_CODE_L1("FAIL1");
		return FALSE;
	}

	LF_INFO* pINFO = itFIND->second;
	LF_RESULT eRET = LFRET_FAIL;

	LF_EXECUTE_POLICY ePOLICY = pINFO->POLICY;
	// (WARNING) 아래 루틴 수정해야 한다...
	LogicFlowDelegator rLF((LogicFlowBase*)this);

	switch(ePOLICY)
	{
	case LFEXE_BASE:				// 기본 핸들러만 실행한다.
		{
			ActiveLogicHandler& rHANDLER = pINFO->ACTIVE_HANDLER;
			if(rHANDLER)		eRET = (rHANDLER)(&rLF, NULL);
			else				eRET = LFRET_FAIL;
		}
		break;
	case LFEXE_REDIRECT:			// 재설정한 핸들러만 실행한다.
		{
			ActiveLogicHandler& rHANDLER = pINFO->ACTIVE_HANDLER_REDIRECT;
			if(rHANDLER)		eRET = (rHANDLER)(&rLF, NULL);
			else				eRET = LFRET_FAIL;
		}
		break;
	case LFEXE_BASE_N_REDIRECT:		// 기본 핸들러 실행 후 재설정한 핸들러를 실행시킨다.
		{
			if(pINFO->ACTIVE_HANDLER)
				eRET = (pINFO->ACTIVE_HANDLER)(&rLF, NULL);
			else
				eRET = LFRET_FAIL;

			if(LFRET_FAIL != eRET)
			{
				if(pINFO->ACTIVE_HANDLER_REDIRECT)
					eRET = (pINFO->ACTIVE_HANDLER_REDIRECT)(&rLF, NULL);
				else
					eRET = LFRET_FAIL;
			}
		}
		break;
	case LFEXE_REDIRECT_N_BASE:		// 재설정한 핸들러를 실행 후 기본 핸들러를 실행시킨다.
		{
			if(pINFO->ACTIVE_HANDLER_REDIRECT)
				eRET = (pINFO->ACTIVE_HANDLER_REDIRECT)(&rLF, NULL);
			else
				eRET = LFRET_FAIL;

			if(LFRET_FAIL != eRET)
			{
				if(pINFO->ACTIVE_HANDLER)
					eRET = (pINFO->ACTIVE_HANDLER)(&rLF, NULL);
				else
					eRET = LFRET_FAIL;
			}
		}
		break;
	case LFEXE_NO_ACTION:			// 핸들러 정의되지 않았다. 문제 발생한디야~
		{

		}
		break;
	default:
		DEBUGGING_CODE_L1("FAIL-POLICY");
		break;
	}
	//if(pINFO->HANDLER_REDIRECT)
	//{
	//	LogicFlowDelegator rDelegator = LogicFlowDelegator(this);
	//	eRET = pINFO->HANDLER_REDIRECT(&rDelegator, NULL);
	//}
	//else
	//	eRET = (this->*pINFO->HANDLER)(NULL);

	switch(eRET)
	{
	case LFRET_FAIL:
		DEBUGGING_CODE_L1("FAIL-RET");
		return FALSE;
	case LFRET_SUCCESS_DEFAULT:
		ChangeNextStep();
		break;
	case LFRET_SUCCESS_LOOP:
		break;
	case LFRET_SUCCESS_JUMP:	// 각각의 핸들러에서 해당값을 입력했을 것이다.
		break;
	case LFRET_PENDING_UNTIL_PASSIVE:
		m_eCONTROL = LFRET_PENDING_UNTIL_PASSIVE;
		break;
	}

	return TRUE;
}

//////////////////////////////////////////////////////////////////////////
//
LogicFlowBase::LogicFlowBase(LogicFlowController& rLFC) : m_rLFC(rLFC)
{
}

LogicFlowBase::~LogicFlowBase()
{
}

BOOL	LogicFlowBase::DoProcess()
{
	BOOL bPass = (BOOL)(ENDofSTEP() == m_eSTEP);
	if(bPass)	return TRUE;
	bPass = (BOOL)(LFRET_PENDING_UNTIL_PASSIVE == m_eCONTROL);
	if(bPass) return TRUE;

	LF_MAP_IT itFIND = LF_MAP_INTERFACE.find(m_eSTEP);
	if(itFIND == LF_MAP_INTERFACE.end())
	{
		DEBUGGING_CODE_L1("FAIL1");
		return FALSE;
	}

	LF_INFO* pINFO = itFIND->second;
	LF_RESULT eRET = LFRET_FAIL;

	LF_EXECUTE_POLICY ePOLICY = pINFO->POLICY;
	LogicFlowDelegator rLF(this);

	switch(ePOLICY)
	{
	case LFEXE_BASE:				// 기본 핸들러만 실행한다.
		{
			ActiveLogicHandler& rHANDLER = pINFO->ACTIVE_HANDLER;
			if(rHANDLER)		eRET = (rHANDLER)(&rLF, NULL);
			else				eRET = LFRET_FAIL;
		}
		break;
	case LFEXE_REDIRECT:			// 재설정한 핸들러만 실행한다.
		{
			ActiveLogicHandler& rHANDLER = pINFO->ACTIVE_HANDLER_REDIRECT;
			if(rHANDLER)		eRET = (rHANDLER)(&rLF, NULL);
			else				eRET = LFRET_FAIL;
		}
		break;
	case LFEXE_BASE_N_REDIRECT:		// 기본 핸들러 실행 후 재설정한 핸들러를 실행시킨다.
		{
			if(pINFO->ACTIVE_HANDLER)
				eRET = (pINFO->ACTIVE_HANDLER)(&rLF, NULL);
			else
				eRET = LFRET_FAIL;

			if(LFRET_FAIL != eRET)
			{
				if(pINFO->ACTIVE_HANDLER_REDIRECT)
					eRET = (pINFO->ACTIVE_HANDLER_REDIRECT)(&rLF, NULL);
				else
					eRET = LFRET_FAIL;
			}
		}
		break;
	case LFEXE_REDIRECT_N_BASE:		// 재설정한 핸들러를 실행 후 기본 핸들러를 실행시킨다.
		{
			if(pINFO->ACTIVE_HANDLER_REDIRECT)
				eRET = (pINFO->ACTIVE_HANDLER_REDIRECT)(&rLF, NULL);
			else
				eRET = LFRET_FAIL;

			if(LFRET_FAIL != eRET)
			{
				if(pINFO->ACTIVE_HANDLER)
					eRET = (pINFO->ACTIVE_HANDLER)(&rLF, NULL);
				else
					eRET = LFRET_FAIL;
			}
		}
		break;
	case LFEXE_NO_ACTION:			// 핸들러 정의되지 않았다. 문제 발생한디야~
		{

		}
		break;
	default:
		DEBUGGING_CODE_L1("FAIL-POLICY");
		break;
	}
	//if(pINFO->HANDLER_REDIRECT)
	//{
	//	LogicFlowDelegator rDelegator = LogicFlowDelegator(this);
	//	eRET = pINFO->HANDLER_REDIRECT(&rDelegator, NULL);
	//}
	//else
	//	eRET = (this->*pINFO->HANDLER)(NULL);

	switch(eRET)
	{
	case LFRET_FAIL:
		DEBUGGING_CODE_L1("FAIL-RET");
		return FALSE;
	case LFRET_SUCCESS_DEFAULT:
		ChangeNextStep();
		break;
	case LFRET_SUCCESS_LOOP:
		break;
	case LFRET_SUCCESS_JUMP:	// 각각의 핸들러에서 해당값을 입력했을 것이다.
		break;
	case LFRET_PENDING_UNTIL_PASSIVE:
		m_eCONTROL = LFRET_PENDING_UNTIL_PASSIVE;
		break;
	}

	return TRUE;
}

BOOL	LogicFlowBase::IsComplete()
{
	return (BOOL)(/*!LF_CONTROLLER().GetWiseUser() ||*/ (ENDofSTEP() == STEP()));
}

void	LogicFlowBase::OnMsg(sSIG_MSG* pSIG_MSG)
{
	//DEBUGGING_CODE_L3("");
	sSIG_WISEBASE& rSIG_BASE = *(sSIG_WISEBASE*)pSIG_MSG;
	if(eSIG_WISEMSG::LF_MAIN_CMD != rSIG_BASE.SIGTYPE())
	{
		return;
	}

	// 다음 로직은 eSIG_WISEMSG::LF_MAIN_CMD 만 전담한다.
	sSIG_LF_MAIN& rSIG_PLOGIC	= *(sSIG_LF_MAIN*)pSIG_MSG;
	eWISESUBTYPE& rSUBTYPE		= rSIG_PLOGIC.SUBTYPE();
	sSIG_STEP_ARG& rARG	= rSIG_PLOGIC.TypeOf<sSIG_STEP_ARG>();

	if(GetGroupOfLF() != rARG.GROUP)
		return;

	switch(rSUBTYPE)
	{
	case sSIG_LF_MAIN::NO_TYPE:
		break;
	case sSIG_LF_MAIN::ACTIVATE_JUMP_STEP:
		{
			GotoStep(rARG.STEP, NULL);
		}
		break;
	case sSIG_LF_MAIN::ACTIVATE_NEXT_STEP:
		ChangeNextStep();
		break;
	//case sSIG_LF_MAIN::CLOSURE_STEP:
	//	{
	//		GotoStep(ENDofSTEP(), NULL);
	//	}
	//	break;
	default: DEBUGGING_CODE_L1("NO-ACTION by OnMSG"); return;
	}
}

void	LogicFlowBase::ChangeNextStep()
{
	if(ENDofSTEP() != m_eSTEP)
	{
		m_eSTEP = (LF_DEFINE)(((DWORD)m_eSTEP)+1);
		m_eCONTROL = LFRET_SUCCESS_DEFAULT;
	}
}

BOOL	LogicFlowBase::GotoStep(LF_DEFINE step, PASSING_ARG IN arguments)
{
	// 상한선, 하한선 모두를 고려해야 하지만... 일단 다음 기회를 노리자.
	if((DWORD)step > (DWORD)ENDofSTEP())
		return FALSE;

	m_eSTEP = step;
	m_eCONTROL = LFRET_SUCCESS_JUMP;
	//arguments

	return TRUE;
}

//////////////////////////////////////////////////////////////////////////
//

LogicFlowConnection::LogicFlowConnection(LogicFlowController& rLFC) : LogicFlowBase(rLFC)
{
	GROUPofLF() = LFG_CONNECTION;
	STEP() = S_000100_START_MARK_LF;
	ENDofSTEP() = S_000999_CLOSURE_MARK_LF;
	CONTROL() = LFRET_SUCCESS_DEFAULT;
};

LogicFlowConnection::~LogicFlowConnection()
{
}

BOOL		LogicFlowConnection::DoInit()
{
	GROUPofLF() = LFG_CONNECTION;
	STEP() = S_000100_START_MARK_LF;
	CONTROL() = LFRET_SUCCESS_DEFAULT;

	return TRUE;
}

BOOL		LogicFlowConnection::DoProcess()
{
	//DEBUGGING_CODE_L3("");
	BOOL bRET = LogicFlowBase::DoProcess();
	return bRET;
}

BOOL		LogicFlowConnection::IsComplete()
{
	return LogicFlowBase::IsComplete();
}

BOOL		LogicFlowConnection::DoRelease()
{
	WiseUser* pUser = LF_CONTROLLER().GetWiseUser();
	if(pUser)
		pUser->GetLogicFlow() = LogicFlowDelegator(NULL);
	//// NULL...
	//if(AGENT_SESSION == idxSession)
	//{
	//	// 해당 세션을 종료시켜야 한다.
	//	GetWiseUser()->Release();
	//	ObjectPoolRouter::Instance()->Free(OBJTYPE_USER, GetWiseUser());
	//	return;
	//}

	//LF_CONTROLLER().GetWiseUser()->
	return TRUE;
}


void		LogicFlowConnection::OnMsg(sSIG_MSG* pSIG_MSG)
{
	LogicFlowBase::OnMsg(pSIG_MSG);
	return ;
}


//////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////
//

LogicFlowZone::LogicFlowZone(LogicFlowController& rLFC) : LogicFlowBase(rLFC)
{
	GROUPofLF() = LFG_ZONE;
	STEP() = S_001000_START_MARK_LF;
	ENDofSTEP() = S_002999_CLOSURE_MARK_LF;
	CONTROL() = LFRET_SUCCESS_DEFAULT;
};

LogicFlowZone::~LogicFlowZone()
{
}

BOOL		LogicFlowZone::DoInit()
{
	GROUPofLF() = LFG_ZONE;
	STEP() = S_001000_START_MARK_LF;
	CONTROL() = LFRET_SUCCESS_DEFAULT;

	return TRUE;
}

BOOL		LogicFlowZone::DoProcess()
{
	//DEBUGGING_CODE_L3("");
	BOOL bRET = LogicFlowBase::DoProcess();
	return bRET;
}

BOOL		LogicFlowZone::IsComplete()
{
	return LogicFlowBase::IsComplete();
}

BOOL		LogicFlowZone::DoRelease()
{
	return TRUE;
}


void		LogicFlowZone::OnMsg(sSIG_MSG* pSIG_MSG)
{
	LogicFlowBase::OnMsg(pSIG_MSG);
	return ;
}


//////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////
//

LogicFlowMove::LogicFlowMove(LogicFlowController& rLFC) : LogicFlowBase(rLFC)
{
	GROUPofLF() = LFG_MOVE;
	STEP() = S_003000_START_MARK_LF;
	ENDofSTEP() = S_003999_CLOSURE_MARK_LF;
	CONTROL() = LFRET_SUCCESS_DEFAULT;
};

LogicFlowMove::~LogicFlowMove()
{
}

BOOL		LogicFlowMove::DoInit()
{
	GROUPofLF() = LFG_MOVE;
	STEP() = S_003000_START_MARK_LF;
	CONTROL() = LFRET_SUCCESS_DEFAULT;

	return TRUE;
}

BOOL		LogicFlowMove::DoProcess()
{
	//DEBUGGING_CODE_L3("");
	BOOL bRET = LogicFlowBase::DoProcess();
	return bRET;
}

BOOL		LogicFlowMove::IsComplete()
{
	return LogicFlowBase::IsComplete();
}

BOOL		LogicFlowMove::DoRelease()
{
	return TRUE;
}


void		LogicFlowMove::OnMsg(sSIG_MSG* pSIG_MSG)
{
	LogicFlowBase::OnMsg(pSIG_MSG);
	return ;
}

//////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////


LF_ACTIVE_HANDLER_IMPL_NULL(S_000100_START_MARK_LF);
//LF_ACTIVE_HANDLER_IMPL_NULL(S_000200_WISEUSER_CREATE_LF);
//LF_ACTIVE_HANDLER_IMPL_NULL(S_000300_CREATE_LOGIN_FRONT_SESSION_LF);
//LF_ACTIVE_HANDLER_IMPL_NULL(S_000310_CONNECT_TO_LOGIN_FRONT_LF);
//LF_ACTIVE_HANDLER_IMPL_NULL(S_000320_WAIT_CONNECT_TO_LOGIN_FRONT_LF);
//LF_ACTIVE_HANDLER_IMPL_NULL(S_000330_WAIT_MSG_S2C_READY_LF);
//LF_ACTIVE_HANDLER_IMPL_NULL(S_000340_SEND_FC_AUTH_VERIFY_LF);
//LF_ACTIVE_HANDLER_IMPL_NULL(S_000920_CLOSURE_EXCEPTION_LF);
LF_ACTIVE_HANDLER_IMPL_NULL(S_990100_PLAYER_RELEASE_LF);
LF_ACTIVE_HANDLER_IMPL_NULL(S_990105_USER_RELEASE_LF);
LF_ACTIVE_HANDLER_IMPL_NULL(S_999999_LF_EOL_MARK_LF);
LF_ACTIVE_HANDLER_IMPL_NULL(S_000999_CLOSURE_MARK_LF);

LF_ACTIVE_HANDLER_IMPL_NULL(S_001000_START_MARK_LF);