#include "stdafx.h"
#include "CRobotTask.h"
#include "ToolUnits.h"
#include "Log.h"


namespace SERVO {
	CRobotTask::CRobotTask()
	{
		generateId(m_strId);
		m_state = ROBOT_TASK_STATE::Ready;
		m_timeCreate = CToolUnits::getUnixTimestamp();
		m_timeFetchOut = 0;
		m_timeStored = 0;
		m_timeFinish = 0;
		m_pContext = nullptr;
		m_pEFEM = nullptr;
	}

	CRobotTask::~CRobotTask()
	{
		if (m_pContext != nullptr) {
			m_pContext->release();
			m_pContext = nullptr;
		}
	}

	std::string CRobotTask::getDescription() const
	{
		std::string strOut = "CRobotTask<ID:";
		strOut = strOut + std::to_string(m_robotCmdParam[ACTION_TRANSFER].sequenceNo);
		strOut = strOut + ",Arm:";
		strOut = strOut + std::to_string(m_robotCmdParam[ACTION_TRANSFER].armNo);
		strOut = strOut + ",GetPossion:";
		strOut = strOut + std::to_string(m_robotCmdParam[ACTION_TRANSFER].getPosition);
		strOut = strOut + ",GetSlot:";
		strOut = strOut + std::to_string(m_robotCmdParam[ACTION_TRANSFER].getSlotNo);
		strOut = strOut + ",PutPossion:";
		strOut = strOut + std::to_string(m_robotCmdParam[ACTION_TRANSFER].putPosition);
		strOut = strOut + ",PutSlot:";
		strOut = strOut + std::to_string(m_robotCmdParam[ACTION_TRANSFER].putSlotNo);
		strOut = strOut + ">";

		return strOut;
	}

	std::string CRobotTask::getSimpleDescription() const
	{
		std::string strOut = "CRobotTask<ID:";
		strOut = strOut + std::to_string(m_robotCmdParam[ACTION_TRANSFER].sequenceNo);
		strOut = strOut + ",Arm:";
		strOut = strOut + std::to_string(m_robotCmdParam[ACTION_TRANSFER].armNo);
		strOut = strOut + ",GetPossion:";
		strOut = strOut + std::to_string(m_robotCmdParam[ACTION_TRANSFER].getPosition);
		strOut = strOut + ",GetSlot:";
		strOut = strOut + std::to_string(m_robotCmdParam[ACTION_TRANSFER].getSlotNo);
		strOut = strOut + ",PutPossion:";
		strOut = strOut + std::to_string(m_robotCmdParam[ACTION_TRANSFER].putPosition);
		strOut = strOut + ",PutSlot:";
		strOut = strOut + std::to_string(m_robotCmdParam[ACTION_TRANSFER].putSlotNo);
		strOut = strOut + ">";

		return strOut;
	}

	void CRobotTask::setContext(CContext* pContext)
	{
		if (m_pContext != nullptr) {
			m_pContext->release();
		}

		m_pContext = pContext;
		if (m_pContext != nullptr) {
			m_pContext->addRef();
		}
	}

	CContext* CRobotTask::getContext()
	{
		return m_pContext;
	}

	void CRobotTask::setEFEM(CEFEM* pEFEM)
	{
		m_pEFEM = pEFEM;
	}

	std::string& CRobotTask::generateId(std::string& out)
	{
		char szBuffer[256];
		CTime time = CTime::GetCurrentTime();
		__int64 nTick = 0;
		QueryPerformanceCounter((LARGE_INTEGER*)&nTick);
		sprintf_s(szBuffer, 256, "%d%02d%02d%02d%02d%02d%010llu", time.GetYear(),
			time.GetMonth(), time.GetDay(), time.GetHour(), time.GetMinute(), time.GetSecond(),
			nTick % 10000000000);
		out = szBuffer;

		return out;
	}

	std::string& CRobotTask::getId()
	{
		return m_strId;
	}

	int CRobotTask::setRobotTransferParam(int seq, int armNo, int fromPos, int toPos, int fromSlot, int toSlot)
	{
		// ÕâÊÇÖ±½ÓʹÓðáÔËģʽµÄ²ÎÊý£¬
		// Èç¹ûEFEM²»Ö§³Ö£¬»¹ÐèÒª²ð½âΪȡºÍ·ÅµÄ¶¯×÷¼°»Ø·ÅԭλÖõÄÆäËü3ÌײÎÊý
		m_robotCmdParam[ACTION_TRANSFER] = {};
		m_robotCmdParam[ACTION_TRANSFER].sequenceNo = static_cast<short>(seq+1);
		m_robotCmdParam[ACTION_TRANSFER].rcmd = static_cast<short>(SERVO::RCMD::Transfer);
		m_robotCmdParam[ACTION_TRANSFER].armNo = static_cast<short>(armNo);
		m_robotCmdParam[ACTION_TRANSFER].getPosition = static_cast<short>(fromPos);
		m_robotCmdParam[ACTION_TRANSFER].getSlotNo = static_cast<short>(fromSlot);
		m_robotCmdParam[ACTION_TRANSFER].putPosition = static_cast<short>(toPos);
		m_robotCmdParam[ACTION_TRANSFER].putSlotNo = static_cast<short>(toSlot);

		// ת»»Ò»ÏÂÔ´ºÍÄ¿±êÕ¾ºÅ
		int srcPos, srcSlot, tarPos, tarSlot;
		transformPosAndSlot(fromPos, fromSlot, srcPos, srcSlot);
		transformPosAndSlot(toPos, toSlot, tarPos, tarSlot);

		m_robotCmdParam[ACTION_PICK] = {};
		m_robotCmdParam[ACTION_PICK].sequenceNo = static_cast<short>(seq+1);
		m_robotCmdParam[ACTION_PICK].rcmd = static_cast<short>(SERVO::RCMD::Get);
		m_robotCmdParam[ACTION_PICK].armNo = static_cast<short>(armNo);
		m_robotCmdParam[ACTION_PICK].getPosition = static_cast<short>(srcPos);
		m_robotCmdParam[ACTION_PICK].getSlotNo = static_cast<short>(srcSlot);

		m_robotCmdParam[ACTION_PLACE] = {};
		m_robotCmdParam[ACTION_PLACE].sequenceNo = static_cast<short>(seq + 2);
		m_robotCmdParam[ACTION_PLACE].rcmd = static_cast<short>(SERVO::RCMD::Put);
		m_robotCmdParam[ACTION_PLACE].armNo = static_cast<short>(armNo);
		m_robotCmdParam[ACTION_PLACE].putPosition = static_cast<short>(tarPos);
		m_robotCmdParam[ACTION_PLACE].putSlotNo = static_cast<short>(tarSlot);

		m_robotCmdParam[ACTION_RESTORE] = {};
		m_robotCmdParam[ACTION_RESTORE].sequenceNo = static_cast<short>(seq + 3);
		m_robotCmdParam[ACTION_RESTORE].rcmd = static_cast<short>(SERVO::RCMD::Put);
		m_robotCmdParam[ACTION_RESTORE].armNo = static_cast<short>(armNo);
		m_robotCmdParam[ACTION_RESTORE].putPosition = static_cast<short>(srcPos);
		m_robotCmdParam[ACTION_RESTORE].putSlotNo = static_cast<short>(srcSlot);

		return seq + 3;
	}

	ROBOT_CMD_PARAM& CRobotTask::getRobotCmdParam(int index)
	{
		ASSERT(ACTION_PICK <= index && index <= ACTION_TRANSFER);
		return m_robotCmdParam[index];
	}

	time_t CRobotTask::getCreateTime()
	{
		return m_timeCreate;
	}

	time_t CRobotTask::getFetchoutTime()
	{
		return m_timeFetchOut;
	}

	time_t CRobotTask::getStoredTime()
	{
		return m_timeStored;
	}

	time_t CRobotTask::getFinishTime()
	{
		return m_timeFinish;
	}

	int CRobotTask::getArmNo()
	{
		return m_robotCmdParam[ACTION_PICK].armNo;

	}

	ROBOT_TASK_STATE CRobotTask::getState()
	{
		return m_state;
	}

	bool CRobotTask::isPicking()
	{
		return m_state == ROBOT_TASK_STATE::Picking;
	}

	bool CRobotTask::isPicked()
	{
		return m_state == ROBOT_TASK_STATE::Picked;
	}

	bool CRobotTask::isPlacing()
	{
		return m_state == ROBOT_TASK_STATE::Placing;
	}

	bool CRobotTask::isRestoring()
	{
		return m_state == ROBOT_TASK_STATE::Restoring;
	}

	void CRobotTask::run()
	{
		ASSERT(m_pEFEM);
		m_state = ROBOT_TASK_STATE::Running;

		static int seq = 0;
		m_pEFEM->robotSendTransfer(++seq,
			m_robotCmdParam[ACTION_TRANSFER].armNo,
			m_robotCmdParam[ACTION_TRANSFER].getPosition,
			m_robotCmdParam[ACTION_TRANSFER].putPosition,
			m_robotCmdParam[ACTION_TRANSFER].getSlotNo,
			m_robotCmdParam[ACTION_TRANSFER].putSlotNo,
			[&](int code) -> int {
				if (code == WOK) {
					LOGI(_T("RobotTaskÒÑÏ·¢µ½EFEM"));
				}
				else {
					LOGI(_T("RobotTaskÒÑÏ·¢Ê§°Ü"));
				}

				return 0;
			});
	}

	void CRobotTask::pick()
	{
		ASSERT(m_pEFEM);
		m_state = ROBOT_TASK_STATE::Picking;

		m_pEFEM->robotCmd(m_robotCmdParam[ACTION_PICK],
			[&](int code) -> int {
				if (code == WOK) {
					LOGI(_T("RobotTask/getÒÑÏ·¢µ½EFEM"));
				}
				else {
					LOGI(_T("RobotTask/getÒÑÏ·¢Ê§°Ü"));
				}

				return 0;
			});
	}

	void CRobotTask::picked()
	{
		m_state = ROBOT_TASK_STATE::Picked;
	}

	void CRobotTask::place()
	{
		ASSERT(m_pEFEM);
		m_state = ROBOT_TASK_STATE::Placing;

		m_pEFEM->robotCmd(m_robotCmdParam[ACTION_PLACE],
			[&](int code) -> int {
				if (code == WOK) {
					LOGI(_T("RobotTask/putÒÑÏ·¢µ½EFEM"));
				}
				else {
					LOGI(_T("RobotTask/putÒÑÏ·¢Ê§°Ü"));
				}

				return 0;
			});
	}

	void CRobotTask::restore()
	{
		ASSERT(m_pEFEM);
		m_state = ROBOT_TASK_STATE::Restoring;

		m_pEFEM->robotCmd(m_robotCmdParam[ACTION_RESTORE],
			[&](int code) -> int {
				if (code == WOK) {
					LOGI(_T("RobotTask/restore-putÒÑÏ·¢µ½EFEM"));
				}
				else {
					LOGI(_T("RobotTask/restore-putÒÑÏ·¢Ê§°Ü"));
				}

				return 0;
			});
	}

	void CRobotTask::completed()
	{
		m_state = ROBOT_TASK_STATE::Completed;
	}

	void CRobotTask::restored()
	{
		m_state = ROBOT_TASK_STATE::Restored;
	}

	void CRobotTask::error()
	{
		m_state = ROBOT_TASK_STATE::Error;
	}

	void CRobotTask::abort()
	{
		m_state = ROBOT_TASK_STATE::Abort;
	}

	int CRobotTask::getSrcPosition()
	{
		return m_robotCmdParam[ACTION_TRANSFER].getPosition;
	}

	int CRobotTask::getTarPosition()
	{
		return m_robotCmdParam[ACTION_TRANSFER].putPosition;
	}

	int CRobotTask::getSrcSlot()
	{
		return m_robotCmdParam[ACTION_TRANSFER].getSlotNo;
	}

	int CRobotTask::getTarSlot()
	{
		return m_robotCmdParam[ACTION_TRANSFER].putSlotNo;
	}

	CString CRobotTask::getStateString()
	{
		switch (m_state) {
		case ROBOT_TASK_STATE::Ready:     return _T("Ready");
		case ROBOT_TASK_STATE::Running:   return _T("Running");
		case ROBOT_TASK_STATE::Picking:   return _T("Picking");
		case ROBOT_TASK_STATE::Placing:   return _T("Placing");
		case ROBOT_TASK_STATE::Restoring: return _T("Restoring");
		case ROBOT_TASK_STATE::Error:     return _T("Error");
		case ROBOT_TASK_STATE::Abort:     return _T("Abort");
		case ROBOT_TASK_STATE::Completed: return _T("Completed");
		default:                          return _T("Unknown");
		}
	}

	void CRobotTask::fetchOut()
	{
		m_timeFetchOut = CToolUnits::getUnixTimestamp();;
	}

	void CRobotTask::stored()
	{
		m_timeStored = CToolUnits::getUnixTimestamp();;
	}

	void CRobotTask::transformPosAndSlot(int srcPos, int srcSlot, int& tarPos, int& tarSlot)
	{
		switch (srcPos)
		{
		case EQ_ID_LOADPORT1:
		case EQ_ID_LOADPORT2:
		case EQ_ID_LOADPORT3:
		case EQ_ID_LOADPORT4:
			tarPos = srcPos;
			tarSlot = srcSlot;
			break;
		case EQ_ID_ARM_TRAY1:
		case EQ_ID_ARM_TRAY2:
		case EQ_ID_ALIGNER:
		case EQ_ID_FLIPER:
			tarPos = srcPos;
			tarSlot = 1;
			break;
		case EQ_ID_Bonder1:
			if (1 <= srcSlot && srcSlot <= 2) {
				tarPos = 9 + srcSlot - 1;
				tarSlot = 1;
			}
			break;
		case EQ_ID_Bonder2:
			if (1 <= srcSlot && srcSlot <= 2) {
				tarPos = 11 + srcSlot - 1;
				tarSlot = 1;
			}
			break;
		case EQ_ID_VACUUMBAKE:
			if (1 <= srcSlot && srcSlot <= 2) {
				tarPos = 13 + srcSlot - 1;
				tarSlot = 1;
			}
			break;
		case EQ_ID_BAKE_COOLING:
			if (1 <= srcSlot && srcSlot <= 4) {
				tarPos = 15 + srcSlot - 1;
				tarSlot = 1;
			}
			break;
		case EQ_ID_MEASUREMENT:
			tarPos = 19;
			tarSlot = 1;
			break;
		default:
			tarPos = srcPos;
			tarSlot = srcSlot;
			break;
		}
	}
}