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


namespace SERVO {
#define TIMEOUT			15

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

	CWriteStep::CWriteStep() : CStep()
	{
		m_nWordThreadAddr = 0;
		m_hWorkStop = nullptr;
		m_hWorkThreadHandle = nullptr;
		m_nCurStep = 0;
		m_nWriteSignalDev = 0;
		m_nWriteDataSize = 0;
		m_nWriteDevNo = 0;
		m_hWriteSignalOn = ::CreateEvent(NULL, TRUE, FALSE, NULL);
		m_hRecvSignalOn = ::CreateEvent(NULL, TRUE, FALSE, NULL);
	}

	CWriteStep::~CWriteStep()
	{
		ASSERT(m_hWriteSignalOn);
		CloseHandle(m_hWriteSignalOn);
		m_hWriteSignalOn = nullptr;

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

	int CWriteStep::writeData(short devno, const char* pszData, int size)
	{
		if (size > 1024) return -1;
		if (m_nCurStep != 0) return -2;

		memcpy(m_szBuffer, pszData, size);
		m_nWriteDataSize = size;
		m_nWriteDevNo = devno;
		SetEvent(m_hWriteSignalOn);

		return 0;
	}

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

	void CWriteStep::onRecvSignal(BOOL bSignal)
	{
		Lock();
		if (m_nCurStep == 3 && bSignal) {
			SetEvent(m_hRecvSignalOn);
		}

		Unlock();
	}

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

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

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

				// 1.дÊý¾Ý
				nextStep();
				ASSERT(m_pCclink);
				int nWriteRet = m_pCclink->WriteData(m_station, (short)DeviceType::W,
					m_nWriteDevNo, m_nWriteDataSize, (short*)m_szBuffer);
				if (0 != nWriteRet) {
					onTimeout();
					goto RESET;
				}


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


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


				// 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);
				}
			}
		}

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

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

	void CWriteStep::getAttributeVector(CAttributeVector& attrubutes)
	{
		CStep::getAttributeVector(attrubutes);
		std::string temp;

		unsigned int weight = 20;
		attrubutes.addAttribute(new CAttribute("Current Step",
			std::to_string(m_nCurStep).c_str(), "", weight++));
		attrubutes.addAttribute(new CAttribute("Signal Dev",
			("W" + CToolUnits::toHexString(m_nWriteSignalDev, temp)).c_str(), "", weight++));
	}

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

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

	void CWriteStep::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 CWriteStep::resetStep()
	{
		Lock();
		m_nCurStep = 0;
		Unlock();
	}

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

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

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