#include "stdafx.h"
#include "OTSData.h"
#include "OTSSample.h"

namespace OTSMODEL {
	
	


	// constructor
	COTSSample::COTSSample()
	{
		// initialization
		Init();
	}

	// copy constructor
	COTSSample::COTSSample(const COTSSample& a_oSource)
	{
		
		// can't copy itself
		if (&a_oSource == this)
		{
			return;
		}

		// copy data over
		Duplicate(a_oSource);
	}

	// copy constructor
	COTSSample::COTSSample(COTSSample* a_poSource)
	{
		// input check
		ASSERT(a_poSource);
		if (!a_poSource)
		{
			return;
		}

		// can't copy itself
		if (a_poSource == this)
		{
			return;
		}

		// copy data over
		Duplicate(*a_poSource);
	}

	// =operator	
	COTSSample& COTSSample::operator=(const COTSSample& a_oSource)
	{
		// cleanup
		Cleanup();

		// copy the class data over
		Duplicate(a_oSource);

		// return class
		return *this;
	}

	// destructor
	COTSSample::~COTSSample()
	{
		// cleanup
		Cleanup();
	}

	// ==operator
	BOOL COTSSample::operator==(const COTSSample& a_oSource)
	{
		return m_strName.Compare(a_oSource.m_strName) == 0 &&
			m_strHoleName == a_oSource.m_strHoleName &&
			m_bParamLock == a_oSource.m_bParamLock &&
			m_bSwitch == a_oSource.m_bSwitch &&
		
			*(m_poMsrArea.get()) == *(a_oSource.m_poMsrArea.get()) &&
			*(m_poSEMDataMsr.get()) == *(a_oSource.m_poSEMDataMsr.get());
		
	}
	
	void COTSSample::Serialize(bool isStoring, tinyxml2::XMLDocument* classDoc, tinyxml2::XMLElement* rootNode)
	{
		xmls::xString xstrName;
		xmls::xString xstrHoleName;
		xmls::xBool xbParamlock;
		xmls::xBool xbSwitch;
		xmls::Slo slo;
		slo.Register("SampleName", &xstrName);
		slo.Register("HoleName", &xstrHoleName);
		slo.Register("ParamLock", &xbParamlock);
		slo.Register("Switch", &xbSwitch);
		slo.Register("MsrParams", m_poMsrParams.get());
		slo.Register("MsrArea", m_poMsrArea.get());
		slo.Register("SEMDataMsr", m_poSEMDataMsr.get());
		/*slo.Register("MsrStatus", m_poMsrStatus.get());
		slo.Register("MsrResults", m_poMsrResults.get());*/

		if (isStoring)
		{
			xstrName = m_strName;
			xstrHoleName = m_strHoleName;
			xbParamlock = m_bParamLock;
			xbSwitch = m_bSwitch;

			slo.Serialize(true, classDoc, rootNode);
		}
		else
		{
			slo.Serialize(false, classDoc, rootNode);

			m_strName = xstrName.value().c_str();
			m_strHoleName = xstrHoleName.value().c_str();
			m_bParamLock = xbParamlock.value();
			m_bSwitch = xbSwitch.value();
		}
	}



	COTSParticleList COTSSample::GetAllParticles()
	{
		COTSParticleList listParticle;
		COTSFieldDataList& listFieldData = this->GetFieldsData();
		for (auto pFieldData : listFieldData)
		{
			COTSParticleList listParticlenew = pFieldData->GetParticleList();
			for (auto pParticle : listParticlenew)
			{
				listParticle.push_back(pParticle);
			}
		}
		return listParticle;
	}
	// measurement parameter 
	void COTSSample::SetMsrParams(CMsrParamsPtr a_poMsrParams)
	{
		// make sure that measure parameters is always valid
		if (!a_poMsrParams)
		{
			m_poMsrParams = CMsrParamsPtr(new CMsrParams());
		}
		else
		{
			m_poMsrParams = CMsrParamsPtr(new CMsrParams(a_poMsrParams.get()));
		}
	}

	// measurement area
	void COTSSample::SetMsrArea(CDomainPtr a_poMsrArea)
	{
		// make sure that measure area is always valid
		if (!a_poMsrArea)
		{
			m_poMsrArea = CDomainPtr(new CDomain());
		}
		else
		{
			m_poMsrArea = CDomainPtr(new CDomain(a_poMsrArea.get()));
		}
	}

	// SEM data (measurement)
	void COTSSample::SetSEMDataMsr(CSEMDataMsrPtr a_poSEMDataMsr)
	{
		// make sure that measure SEM data is always valid
		if (!a_poSEMDataMsr)
		{
			m_poSEMDataMsr = CSEMDataMsrPtr(new CSEMDataMsr());
		}
		else
		{
			m_poSEMDataMsr = CSEMDataMsrPtr(new CSEMDataMsr(a_poSEMDataMsr.get()));
		}
	}
	// measure status
	void COTSSample::SetMsrStatus(CMsrSampleStatusPtr a_poMsrStatus)
	{
		// make sure that measure status is always valid
		if (!a_poMsrStatus)
		{
			m_poMsrStatus = CMsrSampleStatusPtr(new CMsrSampleStatus());
		}
		else
		{
			m_poMsrStatus = CMsrSampleStatusPtr(new CMsrSampleStatus(a_poMsrStatus.get()));
		}
	}
	// measure results
	void COTSSample::SetMsrResults(CMsrResultsPtr a_poMsrResults)
	{
		// make sure that measure results is always valid
		if (!a_poMsrResults)
		{
			m_poMsrResults = CMsrResultsPtr(new CMsrResults());
		}
		else
		{
			m_poMsrResults = CMsrResultsPtr(new CMsrResults(a_poMsrResults.get()));
		}
	}
	// fields
	void COTSSample::SetFieldsData(COTSFieldDataList& a_listFieldData)
	{
		m_listFieldData.clear();

		for (auto pFieldData : a_listFieldData)
		{
			
			COTSFieldDataPtr pFieldDataNew = pFieldData;
			m_listFieldData.push_back(pFieldDataNew);
		}
	}

	// has measure results test
	BOOL COTSSample::HasMeasureResult()
	{
		// result items is not empty
		BOOL bHasResult = !(m_poMsrResults->GetResultItems().empty());
		return bHasResult;
	}


	// calculate pixel size 
	double COTSSample::CalculateAFieldArea()
	{
		// pixel size 
		double dAFieldArea = 0.0;


			int nImageSize =m_BseSize.cx;			

			// pixel size (micros)
			double dPixelSize = 0;
			dPixelSize = m_pixelsize;

			// calculate pixel size 
			dAFieldArea = (double)nImageSize * (double)m_BseSize.cy * dPixelSize * dPixelSize * 0.000001;// mm^2
		

		// return pixel size 
		return dAFieldArea;
	}

	BOOL COTSSample::GetBSESize(int& a_nWidth, int& a_nHeight)
	{


		// get scan field size
		a_nWidth = m_BseSize.cx;
		a_nHeight = m_BseSize.cy;

		return TRUE;
	}

	// protected

	// cleanup 
	void COTSSample::Cleanup()
	{
		// need to do nothing at the moment
	}

	// initialization
	void COTSSample::Init()
	{
		m_strName = _T("");
		m_strHoleName = _T("");
		m_bParamLock = FALSE;
		m_bSwitch = TRUE;
	
		m_poMsrArea = CDomainPtr(new CDomain());
		m_poSEMDataMsr = CSEMDataMsrPtr(new CSEMDataMsr());
		m_poMsrParams = CMsrParamsPtr(new CMsrParams());
		m_poMsrStatus = CMsrSampleStatusPtr(new CMsrSampleStatus());
		m_poMsrResults = CMsrResultsPtr(new CMsrResults());
	}

	// duplication 
	void COTSSample::Duplicate(const COTSSample& a_oSource)
	{
		// initialization
		Init();

		// copy data over
		m_strName = a_oSource.m_strName;
		m_strHoleName = a_oSource.m_strHoleName;
		m_bParamLock = a_oSource.m_bParamLock;
		m_bSwitch = a_oSource.m_bSwitch;
	
		m_poMsrArea = CDomainPtr(new CDomain(a_oSource.m_poMsrArea.get()));
		m_poSEMDataMsr = CSEMDataMsrPtr(new CSEMDataMsr(a_oSource.m_poSEMDataMsr.get()));
	
	}

	// create a property items group
	
	
	// calculate scan field size
	int COTSSample::CalculateScanFieldSize()
	{
		// scan field size
		int nScanFiledSize = 0;


			int nImageSize = m_BseSize.cx;

			// calculate scan field size
			nScanFiledSize = (int)((m_pixelsize * (double)nImageSize) + 0.5);
		

		// return scan field size
		return nScanFiledSize;
	}

}