#include "stdafx.h"
#include "CcosSMachineV2.h"
#include "common_api.h"
#include <sstream>

using namespace std;

CcosSMachineV2::CcosSMachineV2()
{
	m_pStatePosList = new MsgQueue<ResDataObject>();
	m_StateQuedEvent = CreateEvent(0, 1, 0, 0);

}

CcosSMachineV2::~CcosSMachineV2()
{
	delete m_pStatePosList;

	CloseHandle(m_StateQuedEvent);

	if (GetLogger() != 0)
	{
		ReleseLogger((Logger*)GetLogger());
		SetLogger(0);
	}
}

void CcosSMachineV2::SetStateMachineLog(const char* pszLogTitle)
{
	if (GetLogger() == 0)
	{
		string logfile = GetProcessDirectory() + "\\logs\\";
		logfile = FormatstdString("%s%s.log", logfile.c_str(), pszLogTitle);
		Logger* pLog = CreateLogger();
		pLog->SetLogFilepath(logfile.c_str());
		SetLogger(pLog);

	}

}


bool CcosSMachineV2::OnStartThread()
{
	return PrePareStateMachine();
}

bool CcosSMachineV2::Exec()
{
	ExecStateMachine(GetExitEvt(), NULL, 0);

	return false;
}

void CcosSMachineV2::PushStateChange(ResDataObject& ChangedPos)
{
	m_pStatePosList->InQueue(ChangedPos);
	SetEvent(m_StateQuedEvent);

}

bool CcosSMachineV2::PopStateChange(ResDataObject& LastPos)
{
	bool ret = false;

	if (m_pStatePosList->size() > 0)
	{
		m_pStatePosList->DeQueue(LastPos);
		m_LastHitStatePos = LastPos;
		ret = true;
	}

	if (m_pStatePosList->size() == 0)
	{
		ResetEvent(m_StateQuedEvent);
	}
	else
	{
		SetEvent(m_StateQuedEvent);
	}

	if (ret == false)
	{
		if (m_LastHitStatePos.size() > 0)
		{
			LastPos = m_LastHitStatePos;
			ret = true;
		}

	}

	return ret;

}


HANDLE CcosSMachineV2::GetStateQuedEvent()
{
	return m_StateQuedEvent;
}


bool CcosSMachineV2::StartStateMachine(CcosStMRouteLine* pExternalWaitEvts[], DWORD WaitCount)
{
	m_LastHitStatePos.clear();

	if (WaitTheThreadEnd(0) == false)
	{
		//it's in running state
		printf("StartStateMachine Failed.it's in running state\n");
		return false;
	}

	if (pExternalWaitEvts != NULL && WaitCount > 0)
	{
		m_RouteExternalEvtCount = WaitCount;
		m_pRouteExternalMap = &pExternalWaitEvts[0];
	}

	bool ret = StartThread();

	if (ret)
	{
		return GetRunningState(TIMEOUT_TEMP);
	}

	return ret;
}

void CcosSMachineV2::StopStateMachine(DWORD timeout)
{
	//直接StopThread好像不是个办法，得让状态机退出前进行OnExit操作.

	StopThread(timeout);

	ClearState();
}


CcosSubSMachine::CcosSubSMachine(void)
{

}

CcosSubSMachine::CcosSubSMachine(const char* pName) : CcosStMRoutePos(pName)
{
	SetStateMachineName(pName);
}

CcosSubSMachine::~CcosSubSMachine(void)
{

}

bool CcosSubSMachine::IsSMachine()
{
	return true;
}


bool CcosSMachineV2::Reset(DWORD Timeout)
{
	StopStateMachine(Timeout);

	return m_pDevicePool->ClearDevices();

}

bool CcosSMachineV2::AddDevices(ResDataObject& DevList)
{
	return m_pDevicePool->AddDevices(DevList);
}

bool CcosSMachineV2::ClearDevices()
{
	return m_pDevicePool->ClearDevices();
}

bool CcosSMachineV2::TriggerEvent(const char* pEventName)
{
	CcosStMEvt Evt;

	printf("TriggerEvent:%s\n", pEventName);
	TPRINTA_DEBUG("TriggerEvent:%s\n", pEventName);

	string ErrEvent = CcosErrorType;
	if (ErrEvent == pEventName)
	{
		Evt.SetEvt(CcosErrorType, CcosFrameError);

	}
	else
	{
		Evt.SetEvt(pEventName, NULL);
	}

	return PushEvent(Evt);

}

bool CcosSMachineV2::AddStateActions(ResDataObject& ActionMap)
{
	return m_pDevicePool->AddStateActions(ActionMap);
}

bool CcosSMachineV2::AddStateEvents(ResDataObject& EventMap)
{
	return m_pDevicePool->AddStateEvents(EventMap);
}

void CcosSMachineV2::ClearStateActionMaps()
{
	m_pDevicePool->ClearStateActionMaps();
}

void CcosSMachineV2::ClearStateEventMaps()
{
	m_pDevicePool->ClearStateEventMaps();
}

bool CcosSMachineV2::RunStateMachine(const char* pszLogTitle)
{
	SetStateMachineLog(pszLogTitle);

	return StartStateMachine(0, 0);
}

CCOSSTMRET CcosSMachineV2::StateMachineEntry(DWORD timeout)
{
	printf("Enter Dr StateMachine\n");
	TPRINTA_DEBUG("Enter Dr StateMachine");

	m_pDevicePool->SetThreadExitHandle(GetExitEvt());

	return CCOSSMRET_OK;
}

CCOSSTMRET CcosSMachineV2::StateMachineExit(DWORD timeout)
{
	printf("Exit Dr StateMachine\n");

	TPRINTA_DEBUG("Exit Dr StateMachine");

	return CCOSSMRET_OK;

}