// MsrResults.cpp : implementation file
//

#include "stdafx.h"
#include "OTSData.h"
#include "MsrResults.h"
#include "otsdataconst.h"

namespace OTSMODEL {
	using namespace OTSDATA;
	// CMsrResultItem


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

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

		// copy data over
		Duplicate(a_oSource);
	}

	// copy constructor
	CMsrResultItem::CMsrResultItem(CMsrResultItem* 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	
	CMsrResultItem& CMsrResultItem::operator=(const CMsrResultItem& a_oSource)
	{
		// cleanup
		Cleanup();

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

		// return class
		return *this;
	}

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

	// ==operator
	BOOL CMsrResultItem::operator==(const CMsrResultItem& a_oSource)
	{
		return m_nTypeId == a_oSource.m_nTypeId &&
			m_nArea == a_oSource.m_nArea &&
			m_nNumber == a_oSource.m_nNumber;
	}

	// CMsrResultItem member functions

	// public

	// serialization
	

	void CMsrResultItem::Serialize(bool isStoring, tinyxml2::XMLDocument * classDoc, tinyxml2::XMLElement * rootNode)
	{
		xmls::xInt xTypeId;
		xmls::xDouble xArea;
		xmls::xDWORD xNumber;
		xmls::Slo slo;
		slo.Register("TypeId", &xTypeId);
		slo.Register("Area", &xArea);
		slo.Register("Number", &xNumber);

		if (isStoring)
		{
			xTypeId = m_nTypeId;
			xArea = m_nArea;
			xNumber = m_nNumber;

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

			m_nTypeId = xTypeId.value();
			m_nArea = xArea.value();
			m_nNumber = xNumber.value();
		}
	}


	// protected

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

	// initialization
	void CMsrResultItem::Init()
	{
		m_nTypeId = -1;
		m_nArea = 0;
		m_nNumber = 0;
	}

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

		// copy data over
		m_nTypeId = a_oSource.m_nTypeId;
		m_nArea = a_oSource.m_nArea;
		m_nNumber = a_oSource.m_nNumber;
	}

	// CMsrResults

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

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

		// copy data over
		Duplicate(a_oSource);
	}

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

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

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

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

		// return class
		return *this;
	}

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

	// ==operator
	BOOL CMsrResults::operator==(const CMsrResults& a_oSource)
	{
		// return FASLE, if the two holes list are in different size
		int nSize = (int)m_listResultItems.size();
		if (nSize != (int)a_oSource.m_listResultItems.size())
		{
			return FALSE;
		}

		// return FALSE if any of the pare holes are different
		for (int i = 0; i < nSize; ++i)
		{
			if (!(*(m_listResultItems[i].get()) == *(a_oSource.m_listResultItems[i].get())))
			{
				return FALSE;
			}
		}

		// members check
		return ( ( abs(m_dRadio - a_oSource.m_dRadio) <MIN_DOUBLE_VALUE )&& (m_nMeasuredArea == a_oSource.m_nMeasuredArea));
	}

	// CMsrResults member functions

	// public

	// serialization


	void CMsrResults::Serialize(bool isStoring, tinyxml2::XMLDocument * classDoc, tinyxml2::XMLElement * rootNode)
	{
		xmls::xDouble xdRadio;
		xmls::xDWORD xnMeasuredArea;
		xmls::Collection<CMsrResultItem> xResultItemlist;
		xmls::Slo slo;
		slo.Register("Ratio", &xdRadio);
		slo.Register("MeasuredArea", &xnMeasuredArea);
		slo.Register("ResultItems", &xResultItemlist);
	
		if (isStoring)
		{
			xdRadio = m_dRadio;
			xnMeasuredArea = m_nMeasuredArea;
			xResultItemlist.Clear();
			for (unsigned int i = 0; i < m_listResultItems.size(); i++)
			{
				xResultItemlist.addItem(m_listResultItems[i].get());
			}
		
			slo.Serialize(true, classDoc, rootNode);
		}
		else
		{
			slo.Serialize(false, classDoc, rootNode);

			m_dRadio = xdRadio.value();
			m_nMeasuredArea = xnMeasuredArea.value();
			m_listResultItems.clear();
			for (unsigned int i = 0; i < xResultItemlist.size(); i++)
			{
				m_listResultItems.push_back(CMsrResultItemPtr(xResultItemlist.getItem(i)));
			}
		}
	}

	// results item list
	void CMsrResults::SetResultItems(CMsrResultItemsList& a_listResultItems)
	{
		// set results item list
		m_listResultItems.clear();
		for (auto poResultItem : a_listResultItems)
		{
			CMsrResultItemPtr poResultItemNew(new CMsrResultItem(poResultItem.get()));
			m_listResultItems.push_back(poResultItemNew); 
		}
	}
	DWORD CMsrResults::GetTotalParticleArea()
	{
		DWORD nArea = 0;
		for (auto poResultItem : m_listResultItems)
		{
			nArea += poResultItem->GetArea();
		}
		return nArea;
	}
	DWORD CMsrResults::GetTotalparticleIdentifyArea()
	{
		DWORD nArea = 0;
		for (auto poResultItem : m_listResultItems)
		{
			if (poResultItem->GetTypeId() > 7)
			{
				nArea += poResultItem->GetArea();
			}
		}
		return nArea;
	}
	DWORD CMsrResults::GetTotalParticleNumber()
	{
		DWORD nParticleNum = 0;
		for (auto poResultItem : m_listResultItems)
		{
			nParticleNum += poResultItem->GetNumber();
		}
		return nParticleNum;
	}

	// calculate display radio
	double CMsrResults::CalDisplayRadio()
	{
		double dDisplayRadio = 0;
		if (m_nMeasuredArea == 0)
		{
			return dDisplayRadio;
		}
		DWORD nTotalParticleArea = GetTotalParticleArea();
		dDisplayRadio = (double)nTotalParticleArea / (double)m_nMeasuredArea * m_dRadio;

		return dDisplayRadio;
	}

	// cumulate measure results
	void CMsrResults::CumulateMeasureResults(CMsrResultItemPtr a_poResultItem)
	{
		// input check
		ASSERT(a_poResultItem);
		if (!a_poResultItem)
		{
			return;
		}

		// find if same type item already in the list
		int nTypeId = a_poResultItem->GetTypeId();
		if (nTypeId == -1)
		{
			// invalid item
			return;
		}
		auto itr = std::find_if(m_listResultItems.begin(), m_listResultItems.end(), [nTypeId](CMsrResultItemPtr& poResultItem) { return poResultItem->GetTypeId() == nTypeId; });
		if (itr != m_listResultItems.end())
		{
			// same type item already in the list

			// get the item
			CMsrResultItemPtr poResultItem = *(itr);
			poResultItem->SetArea(poResultItem->GetArea() + a_poResultItem->GetArea());
			poResultItem->SetNumber(poResultItem->GetNumber() + a_poResultItem->GetNumber());

			// get out
			return;
		}
		else
		{
			m_listResultItems.push_back(a_poResultItem);

		}

	}
	void CMsrResults::CumulateMeasureResults(CMsrResultItemsList& a_listResultItems)
	{
		for (auto poResultItem : a_listResultItems)
		{
			CumulateMeasureResults(poResultItem);
		}
	} 

	// protected

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

	// initialization
	void CMsrResults::Init()
	{
		m_dRadio = DEFAULT_RADIO;
		m_nMeasuredArea = 0;
		m_listResultItems.clear();
	}

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

		// copy data over
		m_dRadio = a_oSource.m_dRadio;
		m_nMeasuredArea = a_oSource.m_nMeasuredArea;
		for(auto poResultItem : a_oSource.m_listResultItems)
		{ 
			CMsrResultItemPtr poResultItem(new CMsrResultItem(poResultItem.get()));
			m_listResultItems.push_back(poResultItem);
		}
	}
}