#include "stdafx.h"
#include "OTSProgMgrParamFile.h"
#include "STDXMLFileMnr.h"
#include "STDFileMgr.h"
namespace OTSMODEL
{
	using namespace std;
	
	COTSProgMgrParamFile::COTSProgMgrParamFile()
	{
		Init();	
	}
	COTSProgMgrParamFile::~COTSProgMgrParamFile()
	{
		// cleanup
		Cleanup();
		
	}
	COTSProgMgrParamFile::COTSProgMgrParamFile(const COTSProgMgrParamFile& a_oSource)
	{
		// can't copy itself
		if (&a_oSource == this)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("COTSProgMgrParamFile: invalid pointer."));
			return;
		}

		// copy data over
		Duplicate(a_oSource);
	}
	// copy constructor
	COTSProgMgrParamFile::COTSProgMgrParamFile(COTSProgMgrParamFile* a_poSource)
	{
		// input check
		ASSERT(a_poSource);
		if (!a_poSource)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("COTSProgMgrParamFile: invalid pointer."));
			return;
		}

		// can't copy itself
		if (a_poSource == this)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("COTSProgMgrParamFile: same pointer."));
			return;
		}

		// copy data over
		Duplicate(*a_poSource);
	}
	// =operator
	COTSProgMgrParamFile& COTSProgMgrParamFile::operator=(const COTSProgMgrParamFile& a_oSource)
	{
		// cleanup
		Cleanup();

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

		// return class
		return *this;
	}

	void COTSProgMgrParamFile::SetStageData(CSEMStageDataPtr a_pStageData)
	{
		ASSERT(a_pStageData);
		if (!a_pStageData)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("SetStageData: invalid SEM stage data pointer."));
			return;
		}
		m_pStageData = CSEMStageDataPtr(new CSEMStageData(a_pStageData.get()));
	}
	void COTSProgMgrParamFile::SetGenParam(COTSGeneralParametersPtr a_pGenParam)
	{
		ASSERT(a_pGenParam);
		if (!a_pGenParam)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("SetGenParam: invalid general param pointer."));
			return;
		}
		m_pGenParam = COTSGeneralParametersPtr(new COTSGeneralParameters(a_pGenParam.get()));
	}
	void COTSProgMgrParamFile::SetImageScanParam(COTSImageScanParamPtr a_pImageScanParam)
	{
		ASSERT(a_pImageScanParam);
		if (!a_pImageScanParam)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("SetImageScanParam: invalid image scan param pointer."));
			return;
		}
		m_pImageScanParam = COTSImageScanParamPtr(new COTSImageScanParam(a_pImageScanParam.get()));
	}
	void COTSProgMgrParamFile::SetImageProcParam(COTSImageProcessParamPtr a_pImageProcParam)
	{
		ASSERT(a_pImageProcParam);
		if (!a_pImageProcParam)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("SetImageScanParam: invalid image process param pointer."));
			return;
		}
		m_pImageProcParam = COTSImageProcessParamPtr(new COTSImageProcessParam(a_pImageProcParam.get()));
	}
	void COTSProgMgrParamFile::SetXRayParam(COTSXRayParamPtr a_pXRayParam)
	{
		ASSERT(a_pXRayParam);
		if (!a_pXRayParam)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("SetXRayParam: invalid x ray param pointer."));
			return;
		}
		m_pXRayParam = COTSXRayParamPtr(new COTSXRayParam(a_pXRayParam.get()));
	}

	// Load/Save
	// NOTE: be sure a_strPathName is a valid file pathname
	BOOL COTSProgMgrParamFile::Load(CString a_strPathName)
	{// file pathname
		m_strPathName = a_strPathName;
		// create stage data
		m_pStageData = CSEMStageDataPtr(new CSEMStageData());
		m_pGenParam = COTSGeneralParametersPtr(new COTSGeneralParameters());
		m_pImageScanParam = COTSImageScanParamPtr(new COTSImageScanParam());
		m_pImageProcParam = COTSImageProcessParamPtr(new COTSImageProcessParam());
		m_pXRayParam = COTSXRayParamPtr(new COTSXRayParam());




		tinyxml2::XMLDocument doc;
		doc.LoadFile(a_strPathName);//载入xml文件

		tinyxml2::XMLElement *rootNode;
		rootNode = doc.FirstChildElement(RootClassName);
		Serialize(false, &doc, rootNode);
		////load the stdLib file

		CSTDFileMgrPtr m_poSTDFileMgr = CSTDFileMgrPtr(new CSTDFileMgr());
		m_poSTDFileMgr->Load();

		CPartSTDDataPtr pSTDlib = m_poSTDFileMgr->GenerateSTDLib(IDENTIFY_KIND::ALL);
		//CString sSTDFileName = m_pGenParam->GetPartSTDLibFileName();

		//a_pSTDlib->SetName(sSTDFileName);
		m_pGenParam->SetPartSTDLib(pSTDlib);


		//load string resource according to the language setup.
		MultiLang::GetInstance().LoadStringFromXml();

		return TRUE;
	}
	BOOL COTSProgMgrParamFile::Save(CString a_strPathName)
	{
		ASSERT(m_pStageData);
		ASSERT(m_pGenParam);		
		ASSERT(m_pImageScanParam);
		ASSERT(m_pImageProcParam);
		ASSERT(m_pXRayParam);

		tinyxml2::XMLDocument doc;
		doc.LoadFile(a_strPathName);
		doc.Clear();
		tinyxml2::XMLDeclaration* declaration = doc.NewDeclaration();//添加xml文件头申明
		doc.InsertFirstChild(declaration);


		tinyxml2::XMLElement *rootNode;
		rootNode = doc.NewElement(RootClassName);
		doc.InsertEndChild(rootNode);
		Serialize(true, &doc, rootNode);
		int result = doc.SaveFile(a_strPathName);


		// file pathname
		m_strPathName = a_strPathName;

		// ok, return TRUE
		return TRUE;
	}

	void COTSProgMgrParamFile::Serialize(bool isStoring, tinyxml2::XMLDocument * classDoc, tinyxml2::XMLElement * rootNode)
	{
		xmls::xInt xProgMgrFileMark; 
		xmls::xString xProgMgrFileVersion; 
		xmls::Slo slo;
		slo.Register("ProgMgrFileMark", &xProgMgrFileMark);
		slo.Register("ProgMgrFileVersion", &xProgMgrFileVersion);
		slo.Register("StageData", m_pStageData.get());
		slo.Register("GenParam", m_pGenParam.get());
		slo.Register("ImageScanParam", m_pImageScanParam.get());
		slo.Register("ImageProcParam", m_pImageProcParam.get());
		slo.Register("XrayParam", m_pXRayParam.get());
		if (isStoring)
		{
			xProgMgrFileMark = PROG_MGR_FILE_MARK;
			xProgMgrFileVersion = PROG_MGR_FILE_VERSION;
			slo.Serialize(true, classDoc, rootNode);
		}
		else
		{
			slo.Serialize(false, classDoc, rootNode);
			
		}
	}

	// serialization
	 
	// cleanup
	void COTSProgMgrParamFile::Cleanup()
	{
	}
	// initialization
	void COTSProgMgrParamFile::Init()
	{
		m_strPathName = _T("");
	}
	// duplication
	void COTSProgMgrParamFile::Duplicate(const COTSProgMgrParamFile& a_oSource)
	{
		// initialization
		Init(); 
		
		// copy data over
		m_pStageData = CSEMStageDataPtr(new CSEMStageData((a_oSource.m_pStageData).get()));
		m_strPathName = a_oSource.m_strPathName;

		m_pGenParam = COTSGeneralParametersPtr(new COTSGeneralParameters((a_oSource.m_pGenParam).get()));
		m_pImageScanParam = COTSImageScanParamPtr(new COTSImageScanParam((a_oSource.m_pImageScanParam).get()));
		m_pImageProcParam = COTSImageProcessParamPtr(new COTSImageProcessParam((a_oSource.m_pImageProcParam).get()));
		m_pXRayParam = COTSXRayParamPtr(new COTSXRayParam((a_oSource.m_pXRayParam).get()));
	}

}