#include "stdafx.h"
#include "CStep.h"
#include "Common.h"


namespace SERVO {
#define TIMEOUT			15

	unsigned __stdcall StepWorkThreadFunction(LPVOID lpParam)
	{
		CStep* pStep = (CStep*)lpParam;
		return pStep->WorkingProc();
	}

	CStep::CStep()
	{
		m_listener = {nullptr};
		m_nWordThreadAddr = 0;
		m_hWorkStop = nullptr;
		m_hWorkThreadHandle = nullptr;
		m_hSignalOn = ::CreateEvent(NULL, TRUE, FALSE, NULL);
		m_hSignalOff = ::CreateEvent(NULL, TRUE, FALSE, NULL);
		m_nCurStep = 0;
		m_pCclink = nullptr;
		m_nWriteSignalDev = 0;
		InitializeCriticalSection(&m_criticalSection);
	}

	CStep::~CStep()
	{
		ASSERT(m_hSignalOn);
		CloseHandle(m_hSignalOn);
		m_hSignalOn = nullptr;

		ASSERT(m_hSignalOff);
		CloseHandle(m_hSignalOff);
		m_hSignalOff = nullptr;

		DeleteCriticalSection(&m_criticalSection);
	}

	void CStep::setListener(StepListener listener)
	{
		m_listener.onEvent = listener.onEvent;
	}

	void CStep::setCcLink(CCCLinkIEControl* pCcLink)
	{
		m_pCclink = pCcLink;
	}

	void CStep::setEquipment(CEquipment* pEquipment)
	{
		m_pEquipment = pEquipment;
	}

	CEquipment* CStep::getEquipment()
	{
		return m_pEquipment;
	}

	void CStep::setName(const char* pszName)
	{
		m_strName = pszName;
	}

	std::string& CStep::getName()
	{
		return m_strName;
	}

	void CStep::getAttributeVector(CAttributeVector& attrubutes)
	{
		attrubutes.clear();
		attrubutes.addAttribute(new CAttribute("Network", 
			std::to_string(m_station.nNetNo).c_str(), ""));
		attrubutes.addAttribute(new CAttribute("Station",
			std::to_string(m_station.nStNo).c_str(), ""));
		attrubutes.addAttribute(new CAttribute("Current Step",
			std::to_string(m_nCurStep).c_str(), ""));
		attrubutes.addAttribute(new CAttribute("Signal Dev",
			std::to_string(m_nWriteSignalDev).c_str(), ""));
	}

	void CStep::setWriteSignalDev(int dev)
	{
		m_nWriteSignalDev = dev;
	}

	void CStep::init()
	{
		if (m_hWorkStop != nullptr) return;
		m_hWorkStop = ::CreateEvent(NULL, TRUE, FALSE, NULL);
		m_hWorkThreadHandle = (HANDLE)_beginthreadex(NULL, 0, SERVO::StepWorkThreadFunction, this,
			0, &m_nWordThreadAddr);
	}

	void CStep::term()
	{
		ASSERT(m_hWorkStop);
		SetEvent(m_hWorkStop);
		if (m_hWorkThreadHandle != NULL) {
			WaitForSingleObject(m_hWorkThreadHandle, INFINITE);
			CloseHandle(m_hWorkThreadHandle);
			m_hWorkThreadHandle = NULL;
		}
		CloseHandle(m_hWorkStop);
		m_hWorkStop = NULL;
	}

	unsigned CStep::WorkingProc()
	{
		HANDLE hEvent = ::CreateEvent(NULL, TRUE, FALSE, NULL);
		BOOL bReadOk = FALSE;

		int nBeginAddr = 0x0;
		while (1) {
RESET:
			resetStep();

			// ´ýÍ˳öÐźŻòʱ¼äµ½
			HANDLE hEvents[] = { m_hWorkStop, m_hSignalOn };
			int nRet = WaitForMultipleObjects(2, hEvents, FALSE, INFINITE);
			if (nRet == WAIT_OBJECT_0) {
				ResetEvent(m_hWorkStop);
				break;
			}

			else if (nRet == WAIT_OBJECT_0 + 1) {
				ResetEvent(m_hSignalOn);

				// 1.¶ÁÈ¡Êý¾Ý
				nextStep();
				ASSERT(m_pCclink);
				if (0 == onReadData()) {
					if (m_listener.onEvent != nullptr) {
						m_listener.onEvent(this, STEP_EVENT_READDATA, nullptr);
					}
				}

				// 2.¸ø¶Ô·½Ð´ON
				nextStep();
				m_pCclink->SetBitDevice(m_station, DeviceType::B, m_nWriteSignalDev);


				// 3.µÈ´ý¶Ô·½OFF
				nextStep();
				int nStep3Ret = ::WaitForSingleObject(m_hSignalOff, TIMEOUT * 1000);
				if (nStep3Ret == WAIT_TIMEOUT) {
					m_pCclink->ResetBitDevice(m_station, DeviceType::B, m_nWriteSignalDev);
					onTimeout();
					goto RESET;
				}
				ResetEvent(m_hSignalOff);


				// 4.¸ø¶Ô·½Ð´OFF
				nextStep();
				m_pCclink->ResetBitDevice(m_station, DeviceType::B, m_nWriteSignalDev);


				// 6.Íê³É
				nextStep();
				if (0 == onComplete()) {
					if (m_listener.onEvent != nullptr) {
						m_listener.onEvent(this, STEP_EVENT_COMPLETE, nullptr);
					}
				}
			}
		}

		if (hEvent != nullptr) {
			CloseHandle(hEvent);
		}

		// _endthreadex(0);
		TRACE("CStep::WorkingProc Ïß³ÌÍ˳ö\n");
		return 0;
	}

	void CStep::onSignal(BOOL bSignal)
	{
		Lock();
		if (m_nCurStep == 0 && bSignal) {
			SetEvent(m_hSignalOn);
		}
		else if (m_nCurStep == 3 && !bSignal) {
			SetEvent(m_hSignalOff);
		}

		Unlock();
	}

	int CStep::onReadData()
	{
		return 0;
	}

	int CStep::onComplete()
	{
		return 0;
	}

	int CStep::onTimeout()
	{
		return 0;
	}

	void CStep::resetStep()
	{
		Lock();
		m_nCurStep = 0;
		Unlock();
	}

	void CStep::nextStep()
	{
		Lock();
		m_nCurStep++;
		Unlock();
	}

	void CStep::convertString(const char* pszBuffer, int size, std::string& strOut)
	{
		strOut.clear();
		int nLength = 0;
		for (int i = 0; i < size; i++) {
			if (pszBuffer[i] == '\0') break;
			nLength++;
		}
		if (nLength > 0) {
			strOut = std::string(pszBuffer, nLength);
		}
	}
}