#include "stdafx.h"
#include "CGlass.h"


namespace SERVO {
	CGlass::CGlass()
	{
		m_pPath = nullptr;
		m_type = MaterialsType::G1;
		m_pBuddy = nullptr;
	}

	CGlass::~CGlass()
	{

	}

	void CGlass::reset()
	{
		CPath* pPath = m_pPath;
		while (pPath != nullptr) {
			CPath* pTemp = pPath->getNext();
			delete pPath;
			pPath = pTemp;
		}
		m_pPath = nullptr;

		if (m_pBuddy != nullptr) {
			m_pBuddy->release();
		}
	}

	std::string& CGlass::getClassName()
	{
		static std::string strName = "CGlass";
		return strName;
	}

	std::string CGlass::toString()
	{
		std::string strText;
		strText += "CGlass[";
		strText += ("ID:" + m_strID + ";");
		strText += "]";

		return strText;
	}

	MaterialsType CGlass::getType()
	{
		return m_type;
	}

	void CGlass::setType(MaterialsType type)
	{
		m_type = type;
	}

	void CGlass::setID(const char* pszID)
	{
		m_strID = pszID;
	}

	std::string& CGlass::getID()
	{
		return m_strID;
	}

	CPath* CGlass::getPath()
	{
		return m_pPath;
	}

	CPath* CGlass::getPathWithEq(unsigned int nEqId, unsigned int nUnit)
	{
		CPath* pTemp = m_pPath;
		while (pTemp != nullptr) {
			if (pTemp->getEqID() == nEqId && pTemp->getUnit() == nUnit) {
				return pTemp;
			}

			pTemp = pTemp->getNext();
		}

		return nullptr;
	}

	void CGlass::addPath(unsigned int nEqId, unsigned int nUnit)
	{
		CPath* pPath = new CPath(nEqId, nUnit);
		if (m_pPath == nullptr) {
			m_pPath = pPath;
		}
		else {
			m_pPath->addPath(pPath);
		}
	}

	void CGlass::serialize(CArchive& ar)
	{
		if (ar.IsStoring())
		{
			Lock();
			ar << (int)m_type;
			WriteString(ar, m_strID);
			ar << (ULONGLONG)m_pPath;
			if (m_pPath != nullptr) {
				m_pPath->serialize(ar);
			}
			char temp[JOBDATAS_SIZE] = { 0 };
			m_jobDataB.serialize(temp, JOBDATAB_SIZE);
			ar.Write(temp, JOBDATAB_SIZE);
			m_jobDataS.serialize(temp, JOBDATAS_SIZE);
			ar.Write(temp, JOBDATAS_SIZE);
			ar << (ULONGLONG)m_pBuddy;
			WriteString(ar, m_strBuddyId);
			Unlock();
		}
		else
		{
			ULONGLONG ullPath;
			int type;

			Lock();
			ar >> type;
			m_type = (MaterialsType)type;
			ReadString(ar, m_strID);
			ar >> ullPath;
			if (ullPath != 0) {
				m_pPath = new CPath();
				m_pPath->serialize(ar);
			}
			char temp[JOBDATAS_SIZE];
			ar.Read(temp, JOBDATAB_SIZE);
			m_jobDataB.unserialize(temp, JOBDATAB_SIZE);
			ar.Read(temp, JOBDATAS_SIZE);
			m_jobDataS.unserialize(temp, JOBDATAS_SIZE);
			ar >> ullPath;					// ÕâÊÇm_pBuddy, Óò»ÉÏ
			ReadString(ar, m_strBuddyId);
			Unlock();
		}
	}

	void CGlass::setJobDataB(CJobDataB* pJobDataB)
	{
		m_jobDataB.copy(pJobDataB);
	}

	CJobDataB* CGlass::getJobDataB()
	{
		return &m_jobDataB;
	}

	void CGlass::setJobDataS(CJobDataS* pJobDataS)
	{
		m_jobDataS.copy(pJobDataS);
	}

	CJobDataS* CGlass::getJobDataS()
	{
		return &m_jobDataS;
	}

	BOOL CGlass::setBuddy(CGlass* pGlass)
	{
		if (m_pBuddy != nullptr) return FALSE;
		if (pGlass->getType() == this->getType()) return FALSE;
		m_pBuddy = pGlass;
		if (m_type == MaterialsType::G1) {
			m_pBuddy->addRef();
		}
		m_strBuddyId = m_pBuddy->getID();

		return TRUE;
	}

	CGlass* CGlass::getBuddy()
	{
		return m_pBuddy;
	}

	std::string& CGlass::getBuddyId()
	{
		return m_strBuddyId;
	}

	void CGlass::processEnd(unsigned int nEqId, unsigned int nUnit)
	{
		CPath* pPath = getPathWithEq(nEqId, nUnit);
		if (pPath != nullptr) {
			pPath->processEnd();
		}
	}

	BOOL CGlass::isProcessed(unsigned int nEqId, unsigned int nUnit)
	{
		CPath* pPath = getPathWithEq(nEqId, nUnit);
		if (pPath == nullptr) return FALSE;

		return pPath->isProcessEnd();
	}
}