#include "stdafx.h"
#include "CReadStep.h"
#include "Common.h"
#include "CEquipment.h"


namespace SERVO {
#define TIMEOUT			15

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

	CReadStep::CReadStep() : CStep()
	{
		m_nWordThreadAddr = 0;
		m_hWorkStop = nullptr;
		m_hWorkThreadHandle = nullptr;
		m_hReadSignalOn = ::CreateEvent(NULL, TRUE, FALSE, NULL);
		m_hReadSignalOff = ::CreateEvent(NULL, TRUE, FALSE, NULL);
		m_nSignalType = 0;
		m_nCurStep = 0;
		m_szReturnBuf[1024] = {0};
		m_nReturnDataSize = 0;
		m_nReturnDevNo = 0;
	}

	CReadStep::~CReadStep()
	{
		ASSERT(m_hReadSignalOn);
		CloseHandle(m_hReadSignalOn);
		m_hReadSignalOn = nullptr;

		ASSERT(m_hReadSignalOff);
		CloseHandle(m_hReadSignalOff);
		m_hReadSignalOff = nullptr;
	}

	void CReadStep::setWriteSignalDev(int dev)
	{
		m_nWriteSignalDev = dev;
	}
	
	void CReadStep::setReturnDev(int dev)
	{
		m_nReturnDevNo = dev;
	}

	void CReadStep::onReadSignal(int nSignalType)
	{
		Lock();
		m_nSignalType = nSignalType;
		if (m_nCurStep == 0 && nSignalType != 0) {
			SetEvent(m_hReadSignalOn);
		}
		else if (m_nCurStep == 3 && nSignalType == 0) {
			SetEvent(m_hReadSignalOff);
		}

		Unlock();
	}

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

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

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

			// ´ýÍ˳öÐźŻòʱ¼äµ½
			HANDLE hEvents[] = { m_hWorkStop, m_hReadSignalOn };
			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_hReadSignalOn);

				// 1.¶ÁÈ¡Êý¾Ý
				nextStep();
				ASSERT(m_pCclink);
				if (0 == onReadData()) {
					ASSERT(m_pEquipment);
					m_pEquipment->onStepEvent(this, STEP_EVENT_READDATA);
				}

				// 0426ÐÂÔö
				// 1.1£¬Ð´return code or data
				if (m_nReturnDataSize > 0) {
					int nWriteRet = m_pCclink->WriteData(m_station, (short)DeviceType::W,
						m_nReturnDevNo, m_nReturnDataSize, (short*)m_szReturnBuf);
					if (0 != nWriteRet) {
						onTimeout();
						goto RESET;
					}
				}

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


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


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


				// 6.Íê³É
				nextStep();
				if (0 == onComplete()) {
					ASSERT(m_pEquipment);
					m_pEquipment->onStepEvent(this, STEP_EVENT_COMPLETE);
				}

				// »Ø¸´Êý¾ÝÇå¿Õ
				m_nReturnDataSize = 0;
			}
		}

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

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

	void CReadStep::getAttributeVector(CAttributeVector& attrubutes)
	{
		CStep::getAttributeVector(attrubutes);
		std::string strTemp;

		attrubutes.addAttribute(new CAttribute("Current Step",
			std::to_string(m_nCurStep).c_str(), ""));
		attrubutes.addAttribute(new CAttribute("Signal Dev",
			("W" + CToolUnits::toHexString(m_nWriteSignalDev, strTemp)).c_str(), ""));
	}

	void CReadStep::init()
	{
		CStep::init();

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

	void CReadStep::term()
	{
		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;
	}

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

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


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

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