#include "stdafx.h"
#include "CPortStatusReport.h"
#include "ToolUnits.h"
#include "Common.h"
#include "Log.h"


namespace SERVO {
	CPortStatusReport::CPortStatusReport()
	{
		m_nPortStatus = 0;
		m_nCassetteSequenceNo = 0;
		m_nLoadingCassetteType = 0;
		m_nQTimeFlag = 0;
		m_nCassetteMappingState = 0;
		m_nCassetteStatus = 0;
	}

	CPortStatusReport::~CPortStatusReport()
	{

	}

	void CPortStatusReport::copyEx(CPortStatusReport& other)
	{
		m_nPortStatus = other.m_nPortStatus;
		m_nCassetteSequenceNo = other.m_nCassetteSequenceNo;
		m_strCassetteID = other.m_strCassetteID;

		// Job Existence Slot
		if (PORT_INUSE == m_nPortStatus) {
			for (int i = 0; i < 12; i++) {
				m_nJobExistenceSlot[i] = other.m_nJobExistenceSlot[i];
			}
		}

		if (!m_strCassetteID.empty()) {
			m_nLoadingCassetteType = other.m_nLoadingCassetteType;
		}

		if (PORT_UNLOAD_READY == m_nPortStatus) {
			m_nQTimeFlag = other.m_nQTimeFlag;
		}

		m_nCassetteMappingState = other.m_nCassetteMappingState;
		m_nCassetteStatus = other.m_nCassetteStatus;
	}

	short CPortStatusReport::getPortStatus()
	{
		return m_nPortStatus;
	}

	void CPortStatusReport::setPortStatus(short status)
	{
		m_nPortStatus = status;
	}

	short CPortStatusReport::getCassetteSequenceNo()
	{
		return m_nCassetteSequenceNo;
	}

	std::string& CPortStatusReport::getCassetteId()
	{
		return m_strCassetteID;
	}

	short CPortStatusReport::getLoadingCassetteType()
	{
		return m_nLoadingCassetteType;
	}

	short CPortStatusReport::getQTimeFlag()
	{
		return m_nQTimeFlag;
	}

	short CPortStatusReport::getCassetteMappingState()
	{
		return m_nCassetteMappingState;
	}

	short CPortStatusReport::getCassetteStatus()
	{
		return m_nCassetteStatus;
	}

	int CPortStatusReport::serialize(char* pszBuffer, int nBufferSize)
	{
		if (nBufferSize < 32 * 2) return -1;

		int index = 0;
		memcpy(&pszBuffer[index], &m_nPortStatus, sizeof(short));
		index += sizeof(short);

		memcpy(&pszBuffer[index], &m_nCassetteSequenceNo, sizeof(short));
		index += sizeof(short);

		int strLen = min(20, m_strCassetteID.size());
		memcpy(&pszBuffer[index], m_strCassetteID.c_str(), strLen);
		index += 20;

		memcpy(&pszBuffer[index], &m_nJobExistenceSlot[0], sizeof(short));
		index += 12 * sizeof(short);

		memcpy(&pszBuffer[index], &m_nLoadingCassetteType, sizeof(short));
		index += sizeof(short);

		memcpy(&pszBuffer[index], &m_nQTimeFlag, sizeof(short));
		index += sizeof(short);

		memcpy(&pszBuffer[index], &m_nCassetteMappingState, sizeof(short));
		index += sizeof(short);

		memcpy(&pszBuffer[index], &m_nCassetteStatus, sizeof(short));
		index += sizeof(short);

		return 32 * 2;
	}

	int CPortStatusReport::unserialize(const char* pszBuffer, int nBufferSize)
	{
		if (nBufferSize < 32 * 2) return -1;

		int index = 0;
		memcpy(&m_nPortStatus, &pszBuffer[index], sizeof(short));
		index += sizeof(short);

		memcpy(&m_nCassetteSequenceNo, &pszBuffer[index], sizeof(short));
		index += sizeof(short);

		CToolUnits::convertString(&pszBuffer[index], 20, m_strCassetteID);
		index += 20;

		memcpy(&m_nJobExistenceSlot[0], &pszBuffer[index], sizeof(short));
		index += 12 * sizeof(short);

		memcpy(&m_nLoadingCassetteType, &pszBuffer[index], sizeof(short));
		index += sizeof(short);

		memcpy(&m_nQTimeFlag, &pszBuffer[index], sizeof(short));
		index += sizeof(short);

		memcpy(&m_nCassetteMappingState, &pszBuffer[index], sizeof(short));
		index += sizeof(short);

		memcpy(&m_nCassetteStatus, &pszBuffer[index], sizeof(short));
		index += sizeof(short);

		return 32 * 2;
	}

	void CPortStatusReport::getAttributeVector(CAttributeVector& attrubutes, int beginWeight)
	{
		unsigned int weight = beginWeight;
		std::string strTemp;

		attrubutes.addAttribute(new CAttribute("PortStatus",
			std::to_string(m_nPortStatus).c_str(), "", weight++));

		attrubutes.addAttribute(new CAttribute("CassetteSequenceNo",
			std::to_string(m_nCassetteSequenceNo).c_str(), "", weight++));

		attrubutes.addAttribute(new CAttribute("CassetteID",
			m_strCassetteID.c_str(), "", weight++));

		attrubutes.addAttribute(new CAttribute("LoadingCassetteType",
			std::to_string(m_nLoadingCassetteType).c_str(), "", weight++));

		attrubutes.addAttribute(new CAttribute("QTimeFlag",
			std::to_string(m_nQTimeFlag).c_str(), "", weight++));

		attrubutes.addAttribute(new CAttribute("CassetteMappingState",
			std::to_string(m_nCassetteMappingState).c_str(), "", weight++));

		attrubutes.addAttribute(new CAttribute("CassetteStatus",
			std::to_string(m_nCassetteStatus).c_str(), "", weight++));
	}

	void CPortStatusReport::serialize(CArchive& ar)
	{
		if (ar.IsStoring()) {
			ar << m_nPortStatus;
			ar << m_nCassetteSequenceNo;
			WriteString(ar, m_strCassetteID);
			for (int i = 0; i < 12; i++) {
				ar << m_nJobExistenceSlot[i];
			}
			ar << m_nLoadingCassetteType;
			ar << m_nQTimeFlag;
			ar << m_nCassetteMappingState;
			ar << m_nCassetteStatus;
		}
		else {
			ar >> m_nPortStatus;
			ar >> m_nCassetteSequenceNo;
			ReadString(ar, m_strCassetteID);
			for (int i = 0; i < 12; i++) {
				ar >> m_nJobExistenceSlot[i];
			}
			ar >> m_nLoadingCassetteType;
			ar >> m_nQTimeFlag;
			ar >> m_nCassetteMappingState;
			ar >> m_nCassetteStatus;
		}
	}

	bool CPortStatusReport::canPickFromPort()
	{
		// 1. Port ״̬±ØÐëÊÇ Load Ready£¨ÉÏÁÏÇëÇó£©
		if (m_nPortStatus != PORT_LOAD_REQUEST) return false;

		// 2. Cassette ״̬±ØÐë²»ÊÇ¡°ÎÞºÐ×Ó¡±£¬Ó¦ÎªµÈ´ý¿ªÊ¼»ò´¦ÀíÖеÈ
		if (m_nCassetteStatus == CASSETTE_NO_EXIST || m_nCassetteStatus == CASSETTE_PROCCESS_PAUSED)
			return false;

		// 3. Cassette ID ²»¿ÉΪ¿Õ
		if (m_strCassetteID.empty()) return false;

		// 4. ÖÁÉÙÒ»¸öSlot´æÔÚ²£Á§
		if (!isJobExistenceSlot()) return false;

		// 5. Mapping״̬±ØÐëÒÑʹÓÃ
		if (m_nCassetteMappingState != 1) return false;

		// 6. Cassette ÀàÐͱØÐëÊÇÓÐЧºÐ×Ó
		if (m_nLoadingCassetteType != 1) return false;

		return true;
	}

	bool CPortStatusReport::isJobExistenceSlot()
	{
		for (int i = 0; i < 12; i++) {
			if (m_nJobExistenceSlot[i] != 0) return true;
		}

		return false;
	}

	short CPortStatusReport::getJobExistenceSlot()
	{
		return m_nJobExistenceSlot[0];
	}

	void CPortStatusReport::setJobExistenceSlot(short map)
	{
		m_nJobExistenceSlot[0] = map;
	}

	void CPortStatusReport::WriteString(CArchive& ar, std::string& string)
	{
		CString strTemp = string.c_str();
		ar << strTemp;
	}

	void CPortStatusReport::ReadString(CArchive& ar, std::string& string)
	{
		CString strTemp;
		ar >> strTemp;
		string = (LPTSTR)(LPCTSTR)strTemp;
	}
}