#include "stdafx.h"
#include "OTSReportProjFileMgrClr.h"

namespace OTSINTERFACE {


	COTSReportProjFileMgrClr::COTSReportProjFileMgrClr()
	{
		CReportProjFilePtr pReportProjFile = CReportProjFilePtr(new CReportProjFile());

		m_pReportProjFileMgr = new CReportProjFileMgrPtr(new CReportProjFileMgr(pReportProjFile));
	}
	COTSReportProjFileMgrClr::COTSReportProjFileMgrClr(COTSReportProjFileClr^ a_pReportProjFile)
	{
		ASSERT(a_pReportProjFile);
		if (!a_pReportProjFile)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("COTSReportProjFileMgrClr: invalid report project file."));
			return;
		}

		CReportProjFilePtr pReportProjFile = a_pReportProjFile->GetReportProjFilePtr();

		m_pReportProjFileMgr = new CReportProjFileMgrPtr(new CReportProjFileMgr(pReportProjFile));
	}
	COTSReportProjFileMgrClr::COTSReportProjFileMgrClr(CReportProjFileMgrPtr pRProjFileMgr)
	{
		ASSERT(pRProjFileMgr);
		if (!pRProjFileMgr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("COTSReportProjFileMgrClr: Generate ReportProjFileMgr pointer failed."));
			return;
		}		

		

		
			m_pReportProjFileMgr = new CReportProjFileMgrPtr(pRProjFileMgr);
		
	}
	
	COTSReportProjFileMgrClr::~COTSReportProjFileMgrClr()
	{
		if (m_pReportProjFileMgr != nullptr)
		{
			delete m_pReportProjFileMgr;
			m_pReportProjFileMgr = nullptr;
		}
	}
	COTSReportProjFileMgrClr::!COTSReportProjFileMgrClr()
	{
		if (m_pReportProjFileMgr != nullptr)
		{
			delete m_pReportProjFileMgr;
			m_pReportProjFileMgr = nullptr;
		}
	}

	JObject^ COTSReportProjFileMgrClr::GetReportJSONProperty(int a_nPageIndex)
	{
		if (m_pReportProjFileMgr == nullptr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("GetReportJSONProperty: invalid project file manager pointer."));
			return nullptr;
		}

		JObject^ SMeasureInfo = gcnew JObject();

		//Treeview 的样品信息 
		JObject^ TSampleParam = gcnew JObject();
		//获取样品名称
		String^ sSampleTitleName = GetFileName();
		TSampleParam->Add("sSampleTitleName", sSampleTitleName);
		//获取Switch
		CSmplMsrResultFileMgrClr^ ResultFileMgr = GetWorkingSmplMsrReslMgr();
		ASSERT(ResultFileMgr);
		if (!ResultFileMgr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("GetReportJSONPro perty: invalid result file manager pointer."));
			return nullptr;
		}

		CSmplMsrResultFileClr^ ResultFile = ResultFileMgr->GetSmplMsrResultFile();
		ASSERT(ResultFile);
		if (!ResultFile)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("GetReportJSONProperty: invalid result file pointer."));
			return nullptr;
		}
		bool bSwitch = ResultFile->GetSwitch();
		TSampleParam->Add("bSwitch", bSwitch);
		SMeasureInfo->Add("TSampleParam", TSampleParam);

		CPropParamClr^ pPropParam ;
		if (a_nPageIndex == (int)DISPLAY_PICTURE_TYPE::IMAGE)
		{
			pPropParam = GetPropertyParamImage();
		}
		else if (a_nPageIndex == (int)DISPLAY_PICTURE_TYPE::TABLE )
		{
			pPropParam = GetPropertyParamTable();
		}
		else if (a_nPageIndex == (int)DISPLAY_PICTURE_TYPE::CHART  )
		{
			pPropParam = GetPropertyParamChart();
		}
		else
		{
			return nullptr;
		}

		pPropParam->SetPropertyItems();
		
		//获得 样品属性值
		List<CPropItemClr^>^ PropItemList = pPropParam->GetPropItemsList();
		int iItemCount = (int)PropItemList->Count;
		JArray^ itemArray = gcnew JArray();

		for (int k = 0; k < iItemCount; k++)
		{
			JObject^ SData = gcnew JObject();
			SData->Add("iSampleId", (int)PropItemList[k]->GetReportItemId());
			SData->Add("sSCaptionName", PropItemList[k]->GetName());
			SData->Add("iSampleValType", (int)PropItemList[k]->GetTypeId());
			SData->Add("bReadOnly", PropItemList[k]->IsReadOnly());
			SData->Add("sDescriptionInfo", PropItemList[k]->GetDescription());
			String^ val = gcnew String("");
			List<String^>^ comboDownList = gcnew List<String^>();
			//part size file name list
		/*	if ((int)PropItemList[k]->GetReportItemId() == (int)OTS_RETORT_PROP_GRID_ITEMS::GRAIN_SIZE_CLASS_TABLE)
			{
				int nPos = -1;
				if (this->GetPartSizeFileList(nPos, comboDownList))
				{
					if(nPos >= 0)
					val = comboDownList[nPos];
				}
			}
			else
			{*/
				val = pPropParam->GetItemCurrentValueStr((OTS_RETORT_PROP_GRID_ITEMS)PropItemList[k]->GetReportItemId());
				pPropParam->GetPropComboStrings(PropItemList[k]->GetReportItemId(), comboDownList);				
			/*}*/
			SData->Add("SampleVal", val);
			JArray^ jarr = gcnew JArray();
			if ((int)comboDownList->Count > 0)
			{
				for (int i = 0; i < (int)comboDownList->Count; i++)
				{
					jarr->Add(comboDownList[i]);
				}
			}
			SData->Add("comboDownList", jarr);
			itemArray->Add(SData);
		}
		SMeasureInfo->Add("SampleDataList", itemArray);
		return SMeasureInfo;
	}

	
	CReportProjFileMgrPtr COTSReportProjFileMgrClr::GetCReportProjFileMgrPtr()
	{
		return *m_pReportProjFileMgr;
	}
	
	void COTSReportProjFileMgrClr::SetSwitchForSmlResultFile(int nIndex,bool ifcheck)
	{
		auto smlMgrs=m_pReportProjFileMgr->get()->GetSmplMsrResultMgrs();
		auto smlFile=smlMgrs[nIndex]->GetSmplMsrResultFile();
		smlFile->SetSwitch(ifcheck);
	}
	CPropParamClr^ COTSReportProjFileMgrClr::GetCurrentPropParam()
	{
		if (m_pReportProjFileMgr == nullptr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("GetPropertyParamImage: current CLR point is invalid."));
			return nullptr;
		}

		CPropParamPtr pPropParam = m_pReportProjFileMgr->get()->GetCurrentPropParam();
		ASSERT(pPropParam);
		if (!pPropParam)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("GetPropertyParamImage: get empty prop param pointer."));
			return nullptr;
		}

		CPropParamClr^ pPropParamClr = gcnew CPropParamClr(pPropParam);

		return pPropParamClr;
	}
	CPropParamClr^ COTSReportProjFileMgrClr::GetPropertyParamImage()
	{
		if (m_pReportProjFileMgr == nullptr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("GetPropertyParamImage: current CLR point is invalid."));
			return nullptr;
		}		

		CPropParamPtr pPropParam = m_pReportProjFileMgr->get()->GetPropertyParamImage();
		ASSERT(pPropParam);
		if (!pPropParam)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("GetPropertyParamImage: get empty prop param pointer."));
			return nullptr;
		}

		CPropParamClr^ pPropParamClr = gcnew CPropParamClr(pPropParam);

		return pPropParamClr;
	}
	CPropParamClr^ COTSReportProjFileMgrClr::GetPropertyParamTable()
	{
		if (m_pReportProjFileMgr == nullptr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("GetPropertyParamGrid: current CLR point is invalid."));
			return nullptr;
		}

		CPropParamPtr pPropParam = m_pReportProjFileMgr->get()->GetPropertyParamGrid();
		ASSERT(pPropParam);
		if (!pPropParam)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("GetPropertyParamGrid: get empty prop param pointer."));
			return nullptr;
		}

		CPropParamClr^ pPropParamClr = gcnew CPropParamClr(pPropParam);

		return pPropParamClr;
	}
	CPropParamClr^ COTSReportProjFileMgrClr::GetPropertyParamChart()
	{
		if (m_pReportProjFileMgr == nullptr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("GetPropertyParamChart: current CLR point is invalid."));
			return nullptr;
		}

		CReportProjFileMgrPtr pReportProjFileMgr = GetCReportProjFileMgrPtr();
		ASSERT(pReportProjFileMgr);
		if (!pReportProjFileMgr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("GetPropertyParamChart: get empty report project file manager pointer."));
			return nullptr;
		}

		CPropParamPtr pPropParam = pReportProjFileMgr->GetPropertyParamChart();
		ASSERT(pPropParam);
		if (!pPropParam)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("GetPropertyParamChart: get empty prop param pointer."));
			return nullptr;
		}

		CPropParamClr^ pPropParamClr = gcnew CPropParamClr(pPropParam);

		return pPropParamClr;
	}



	void COTSReportProjFileMgrClr::SetSelectedPicture(int a_nType)
	{
		m_pReportProjFileMgr->get()->SetSelectedPicture((DISPLAY_PICTURE_TYPE)a_nType);
	}

	bool COTSReportProjFileMgrClr::NewFile()
	{
		if (m_pReportProjFileMgr == nullptr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("NewFile: current CLR point is invalid."));
			return false;
		}

		CReportProjFileMgrPtr pReportProjFileMgr = GetCReportProjFileMgrPtr();
		ASSERT(pReportProjFileMgr);
		if (!pReportProjFileMgr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("NewFile: get empty report project file manager pointer."));
			return false;
		}

		bool bRet = pReportProjFileMgr->NewFile();

		return bRet;
	}

	// Load 
	bool COTSReportProjFileMgrClr::Load(String^ a_strPathname)
	{
		if (m_pReportProjFileMgr == nullptr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("Load: current CLR point is invalid."));
			return false;
		}

		CReportProjFileMgrPtr pReportProjFileMgr = GetCReportProjFileMgrPtr();
		ASSERT(pReportProjFileMgr);
		if (!pReportProjFileMgr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("Load: get empty report project file manager pointer."));
			return false;
		}

		bool bRet = pReportProjFileMgr->Load(a_strPathname);

		return bRet;
	}

	// Save 
	bool COTSReportProjFileMgrClr::Save()
	{
		if (m_pReportProjFileMgr == nullptr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("Save: current CLR point is invalid."));
			return false;
		}

		CReportProjFileMgrPtr pReportProjFileMgr = GetCReportProjFileMgrPtr();
		ASSERT(pReportProjFileMgr);
		if (!pReportProjFileMgr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("Save: get empty report project file manager pointer."));
			return false;
		}

		bool bRet = pReportProjFileMgr->Save();
		return bRet;
	}
	
	// Save 
	bool COTSReportProjFileMgrClr::SaveAs()
	{
		if (m_pReportProjFileMgr == nullptr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("SaveAs: current CLR point is invalid."));
			return false;
		}

		CReportProjFileMgrPtr pReportProjFileMgr = GetCReportProjFileMgrPtr();
		ASSERT(pReportProjFileMgr);
		if (!pReportProjFileMgr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("SaveAs: get empty report project file manager pointer."));
			return false;
		}

		bool bRet = pReportProjFileMgr->SaveAs();

		return bRet;
	}

	bool COTSReportProjFileMgrClr::IsValid()
	{

		if (m_pReportProjFileMgr == nullptr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("IsValid: current CLR point is invalid."));
			return false;
		}

		CReportProjFileMgrPtr pReportProjFileMgr = GetCReportProjFileMgrPtr();
		ASSERT(pReportProjFileMgr);
		if (!pReportProjFileMgr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("IsValid: get empty report project file manager pointer."));
			return false;
		}

		bool bRet = pReportProjFileMgr->IsValid();

		return bRet;
	}

	COTSReportProjFileClr ^ COTSReportProjFileMgrClr::GetReportProjFile()
	{
		if (m_pReportProjFileMgr == nullptr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("GetReportProjFile: current CLR point is invalid."));
			return nullptr;
		}
		 CReportProjFilePtr rptPtr = m_pReportProjFileMgr->get()->GetReportProjFile();
		 COTSReportProjFileClr ^ rptClr = gcnew COTSReportProjFileClr(rptPtr);
		 return rptClr;
	}

	void COTSReportProjFileMgrClr::SetReportProjFile(COTSReportProjFileClr ^ a_pReportProjFile)
	{
		if (m_pReportProjFileMgr == nullptr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("GetReportProjFile: current CLR point is invalid."));
			return ;
		}

		ASSERT(a_pReportProjFile);
		if (!a_pReportProjFile)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("GetReportProjFile: report project file pointer is invalid."));
			return;
		}
		
		CReportProjFilePtr pReportProjFile = a_pReportProjFile->GetReportProjFilePtr();
		ASSERT(pReportProjFile);
		if(!pReportProjFile)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("GetReportProjFile: report project file pointer is invalid."));
			return;
		}

		m_pReportProjFileMgr->get()->SetReportProjFile(pReportProjFile);
	}

	bool COTSReportProjFileMgrClr::ResetPropertyParams(bool a_bClear)
	{
		if (m_pReportProjFileMgr == nullptr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("ResetPropertyParams: empty pointer."));
			return false;
		}

		CReportProjFileMgrPtr pRProjFileMgrPtr = GetCReportProjFileMgrPtr();
		
		if (nullptr == pRProjFileMgrPtr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("ResetPropertyParams: can't generate pointer."));
			return false;
		}

		bool bRet = pRProjFileMgrPtr->ResetPropertyParams(a_bClear);
		
		return bRet;
	}
	List<CPropParamClr^>^ COTSReportProjFileMgrClr::GetPropertyParams()
	{
		if (m_pReportProjFileMgr == nullptr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("GetPropertyParams: empty pointer."));
			return nullptr;
		}

		CReportProjFileMgrPtr pRProjFileMgrPtr = GetCReportProjFileMgrPtr();

		if (nullptr == pRProjFileMgrPtr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("GetPropertyParams: can't generate pointer."));
			return nullptr;
		}

		List<CPropParamClr^>^ listPropParamClr = gcnew List<CPropParamClr^>();
		CPropParamsList listPropParams = pRProjFileMgrPtr->GetPropertyParams();
		for (auto pPropParam : listPropParams)
		{
			CPropParamClr^ PropParamClr = gcnew CPropParamClr(pPropParam);
			listPropParamClr->Add(PropParamClr);
		}

		return listPropParamClr;

	}
	void COTSReportProjFileMgrClr::SetPropertyParams(List<CPropParamClr^>^ a_listPropertyParam)
	{
		if (m_pReportProjFileMgr == nullptr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("SetPropertyParams: empty pointer."));
			return;
		}

		CReportProjFileMgrPtr pRProjFileMgrPtr = GetCReportProjFileMgrPtr();

		if (nullptr == pRProjFileMgrPtr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("SetPropertyParams: can't generate pointer."));
			return;
		}

		CPropParamsList listPropParam;
		
		int nSize = a_listPropertyParam->Count;
		for (int i = 0; i < nSize; i++)
		{
			CPropParamPtr pParam = a_listPropertyParam[i]->GetPropParamPtr();
			ASSERT(pParam);
			if (!pParam)
			{
				LogErrorTrace(__FILE__, __LINE__, _T("SetPropertyParams: can't update clr. "));
				return;
			}

			listPropParam.push_back(pParam);
		}

		pRProjFileMgrPtr->SetPropertyParams(listPropParam);		
	}
	// file modify flag
	bool COTSReportProjFileMgrClr::IsModified()
	{
		if (m_pReportProjFileMgr == nullptr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("IsModified: empty pointer."));
			return false;
		}

		CReportProjFileMgrPtr pRProjFileMgrPtr = GetCReportProjFileMgrPtr();

		if (nullptr == pRProjFileMgrPtr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("IsModified: can't generate pointer."));
			return false;
		}

		return pRProjFileMgrPtr->IsModified();
	}
	void COTSReportProjFileMgrClr::SetModify(bool a_bModify)
	{
		if (m_pReportProjFileMgr == nullptr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("SetModify: empty pointer."));
			return;
		}

		CReportProjFileMgrPtr pRProjFileMgrPtr = GetCReportProjFileMgrPtr();

		if (nullptr == pRProjFileMgrPtr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("SetModify: can't generate pointer."));
			return;
		}

		pRProjFileMgrPtr->SetModify(a_bModify);
	}

	// path name
	String^ COTSReportProjFileMgrClr::GetPathName()
	{
		if (m_pReportProjFileMgr == nullptr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("GetPathName: empty pointer."));
			return nullptr;
		}

		CReportProjFileMgrPtr pRProjFileMgrPtr = GetCReportProjFileMgrPtr();

		if (nullptr == pRProjFileMgrPtr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("GetPathName: can't generate pointer."));
			return nullptr;
		}

		String^ pathNameClr = gcnew String(pRProjFileMgrPtr->GetPathName());

		return pathNameClr;
	}
	void COTSReportProjFileMgrClr::SetPathName(String^ a_strPathName)
	{
		if (m_pReportProjFileMgr == nullptr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("SetPathName: empty pointer."));
			return;
		}

		CReportProjFileMgrPtr pRProjFileMgrPtr = GetCReportProjFileMgrPtr();

		if (nullptr == pRProjFileMgrPtr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("SetPathName: can't generate pointer."));
			return;
		}

		pRProjFileMgrPtr->SetPathName(a_strPathName);
	}

	List<CSmplMsrResultFileMgrClr^>^ COTSReportProjFileMgrClr::GetSmplMsrResultMgrs()
	{
		if (m_pReportProjFileMgr == nullptr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("GetSmplMsrResultMgrs: empty pointer."));
			return nullptr;
		}

		CReportProjFileMgrPtr pRProjFileMgrPtr = GetCReportProjFileMgrPtr();

		if (nullptr == pRProjFileMgrPtr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("GetSmplMsrResultMgrs: can't generate pointer."));
			return nullptr;
		}

		List<CSmplMsrResultFileMgrClr^>^ listSmplMsrResultFileMgrClr = gcnew List<CSmplMsrResultFileMgrClr^>();
		CSmplMsrResultFileMgrList listCSmplMsrResultFileMgr = pRProjFileMgrPtr->GetSmplMsrResultMgrs();
		for (auto pCSmplMsrResultFileMgr : listCSmplMsrResultFileMgr)
		{
			CSmplMsrResultFileMgrClr^ CMgrClr = gcnew CSmplMsrResultFileMgrClr(pCSmplMsrResultFileMgr);
			listSmplMsrResultFileMgrClr->Add(CMgrClr);
		}

		return listSmplMsrResultFileMgrClr;
	}
	bool COTSReportProjFileMgrClr::AddASmplMsrResultMgr(String^ a_strPathName)
	{
		if (m_pReportProjFileMgr == nullptr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("GetSmplMsrResultMgrs: empty pointer."));
			return false;
		}

		CReportProjFileMgrPtr pRProjFileMgrPtr = GetCReportProjFileMgrPtr();

		if (nullptr == pRProjFileMgrPtr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("GetSmplMsrResultMgrs: can't generate pointer."));
			return false;
		}
		//get the ptr object and then operate it.
		if (!pRProjFileMgrPtr->AddASmplMsrResultMgr(a_strPathName))
		{
			LogErrorTrace(__FILE__, __LINE__, _T("(COTSReportProjFileMgrClr::AddASmplMsrResultMgr) AddASmplMsrResultMgr(a_strPathName = %s) = false "), a_strPathName);
			return false;
		}
	
		return true;
	}
	CSmplMsrResultFileMgrClr^ COTSReportProjFileMgrClr::GetASmplMsrResultMgrById(int a_nIndex)
	{
		if (m_pReportProjFileMgr == nullptr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("GetSmplMsrResultMgrs: empty pointer."));
			return nullptr;
		}

		CReportProjFileMgrPtr RProjFileMgrPtr = GetCReportProjFileMgrPtr();
		if (nullptr == RProjFileMgrPtr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("(COTSReportProjFileMgrClr::GetASmplMsrResultMgrById(int a_nIndex = %d)) RProjFileMgrPtr = null "), a_nIndex);
			return nullptr;
		}

		CSmplMsrResultFileMgrPtr pSMsrRetFileMgr = RProjFileMgrPtr->GetASmplMsrResultMgrById(a_nIndex);

		CSmplMsrResultFileMgrClr^ pSMsrRetFileMgrClr = gcnew CSmplMsrResultFileMgrClr(pSMsrRetFileMgr);

		return pSMsrRetFileMgrClr;

	}
	CSmplMsrResultFileMgrClr^ COTSReportProjFileMgrClr::GetASmplMsrResultMgrByPathName(String^ a_strPathName)
	{
		if (m_pReportProjFileMgr == nullptr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("GetSmplMsrResultMgrs: empty pointer."));
			return nullptr;
		}
		CReportProjFileMgrPtr RProjFileMgrPtr = GetCReportProjFileMgrPtr();
		if (nullptr == RProjFileMgrPtr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("(COTSReportProjFileMgrClr::GetASmplMsrResultMgrByPathName(String^ a_strPathName = %s)) RProjFileMgrPtr = null "), a_strPathName);
			return nullptr;
		}

		CSmplMsrResultFileMgrPtr pSMsrRetFileMgr = RProjFileMgrPtr->GetASmplMsrResultMgrByPathName(a_strPathName);
		if (nullptr == pSMsrRetFileMgr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("(COTSReportProjFileMgrClr::GetASmplMsrResultMgrByPathName(String^ a_strPathName = %s)) pSMsrRetFileMgr = null "), a_strPathName);
			return nullptr;
		}

		CSmplMsrResultFileMgrClr^ pSMsrRetFileMgrClr = gcnew CSmplMsrResultFileMgrClr(pSMsrRetFileMgr);

		return pSMsrRetFileMgrClr;
	}
	bool COTSReportProjFileMgrClr::DeleteASmplMsrResultMgrById(int a_nIndex)
	{
		if (m_pReportProjFileMgr == nullptr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("GetSmplMsrResultMgrs: empty pointer."));
			return false;
		}
		CReportProjFileMgrPtr RProjFileMgrPtr = GetCReportProjFileMgrPtr();
		if (nullptr == RProjFileMgrPtr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("(COTSReportProjFileMgrClr::DeleteASmplMsrResultMgrById(int a_nIndex )) RProjFileMgrPtr = null "));
			return false;
		}
		
		if (!RProjFileMgrPtr->DeleteASmplMsrResultMgrById(a_nIndex))
		{
			LogErrorTrace(__FILE__, __LINE__, _T("(COTSReportProjFileMgrClr::DeleteASmplMsrResultMgrById(a_nIndex)) DeleteASmplMsrResultMgrById(a_nIndex = %d) "), a_nIndex);
			return false;
		}

		return true;
	}
	bool  COTSReportProjFileMgrClr::DeleteASmplMsrResultMgrByPathName(String^ a_strPathName)
	{
		if (m_pReportProjFileMgr == nullptr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("GetSmplMsrResultMgrs: empty pointer."));
			return false;
		}
		CReportProjFileMgrPtr RProjFileMgrPtr = GetCReportProjFileMgrPtr();
		if (nullptr == RProjFileMgrPtr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("(COTSReportProjFileMgrClr::DeleteASmplMsrResultMgrByPathName(String^ a_strPathName)) RProjFileMgrPtr = null "));
			return false;
		}

		if (!RProjFileMgrPtr->DeleteASmplMsrResultMgrByPathName(a_strPathName))
		{
			LogErrorTrace(__FILE__, __LINE__, _T("(COTSReportProjFileMgrClr::DeleteASmplMsrResultMgrByPathName(String^ a_strPathName)) DeleteASmplMsrResultMgrByPathName(a_strPathName = %s) = false "), a_strPathName);
			return false;
		}

		return true;

	}

	CSmplMsrResultFileMgrClr^ COTSReportProjFileMgrClr::GetWorkingSmplMsrReslMgr()
	{
		if (m_pReportProjFileMgr == nullptr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("GetWorkingSmplMsrReslMgr: empty pointer."));
			return nullptr;
		}
		CReportProjFileMgrPtr RProjFileMgrPtr = GetCReportProjFileMgrPtr();
		if (nullptr == RProjFileMgrPtr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("(COTSReportProjFileMgrClr::GetWorkingSmplMsrReslMgr(String^ a_strPathName)) RProjFileMgrPtr = null "));
			return nullptr;
		}

		CSmplMsrResultFileMgrPtr pSmplMsrResultFileMgr = RProjFileMgrPtr->GetWorkingSmplMsrReslMgr();

		ASSERT(pSmplMsrResultFileMgr);
		if (!pSmplMsrResultFileMgr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("(COTSReportProjFileMgrClr::GetWorkingSmplMsrReslMgr(String^ a_strPathName)) RProjFileMgrPtr = null "));
			return nullptr;
		}

		CSmplMsrResultFileMgrClr^ pSMRFMgrClr = gcnew CSmplMsrResultFileMgrClr(pSmplMsrResultFileMgr);

		return pSMRFMgrClr;
	}
	String^ COTSReportProjFileMgrClr::GetWorkingSampleName()
	{
		if (m_pReportProjFileMgr == nullptr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("GetWorkingSampleName: empty pointer."));
			return nullptr;
		}
		CReportProjFileMgrPtr RProjFileMgrPtr = GetCReportProjFileMgrPtr();
		if (nullptr == RProjFileMgrPtr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("GetWorkingSampleName: invalid pointer. "));
			return nullptr;
		}

		CString strName = RProjFileMgrPtr->GetWorkingSampleName();

		String^ strNameClr = gcnew String(strName);

		return strNameClr;
	}
	bool COTSReportProjFileMgrClr::SetWorkingSmplMsrReslMgr(CSmplMsrResultFileMgrClr^ a_pSmpMsr)
	{
		if (m_pReportProjFileMgr == nullptr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("SetWorkingSmplMsrReslMgr: empty pointer."));
			return false;
		}

		ASSERT(a_pSmpMsr);
		if (!a_pSmpMsr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("SetWorkingSmplMsrReslMgr: invalid sample measure result file manger clr pointer."));
			return false;
		}

		CReportProjFileMgrPtr RProjFileMgrPtr = GetCReportProjFileMgrPtr();
		if (nullptr == RProjFileMgrPtr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("SetWorkingSmplMsrReslMgr: can't get report project file manager pointer."));
			return false;
		}

		CSmplMsrResultFileMgrPtr pSmplMsrResultFileMgr = a_pSmpMsr->GetCSmplMsrResultFileMgrPtr();
		
		ASSERT(pSmplMsrResultFileMgr);
		if (!pSmplMsrResultFileMgr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("SetWorkingSmplMsrReslMgr: invalid sample measure result file manager pointer."));
			return false;
		}

		bool bRet = RProjFileMgrPtr->SetWorkingSmplMsrReslMgr(pSmplMsrResultFileMgr);

		return bRet;
	}

	// file name
	String^ COTSReportProjFileMgrClr::GetFileName()
	{
		if (m_pReportProjFileMgr == nullptr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("GetFileName: invalid pointer."));
			return nullptr;
		}

		CReportProjFileMgrPtr RProjFileMgrPtr = GetCReportProjFileMgrPtr();
		if (nullptr == RProjFileMgrPtr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("(GetFileName::GetWorkingSmplMsrReslMgr(String^ a_strPathName)) RProjFileMgrPtr = null "));
			return nullptr;
		}

		CString sName = RProjFileMgrPtr->GetFileName();

		String^ sNameClr = gcnew String(sName);

		return sNameClr;

	}

	// working sample index
	int COTSReportProjFileMgrClr::GetWorkingSampleIndex()
	{
		if (m_pReportProjFileMgr == nullptr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("GetWorkingSampleIndex: invalid pointer."));
			return -1;
		}

		CReportProjFileMgrPtr RProjFileMgrPtr = GetCReportProjFileMgrPtr();
		if (nullptr == RProjFileMgrPtr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("(GetWorkingSampleIndex: invalid pointer."));
			return -1;
		}

		return RProjFileMgrPtr->GetWorkingSampleIndex();
	}
	void COTSReportProjFileMgrClr::SetWorkingSampleIndex(int a_nWorkingSampleIndex)
	{
		if (m_pReportProjFileMgr == nullptr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("SetWorkingSampleIndex: invalid pointer."));
			return;
		}

		CReportProjFileMgrPtr RProjFileMgrPtr = GetCReportProjFileMgrPtr();
		if (nullptr == RProjFileMgrPtr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("(SetWorkingSampleIndex: invalid pointer."));
			return;
		}

		RProjFileMgrPtr->SetWorkingSampleIndex(a_nWorkingSampleIndex);
	}

	
	

	CGridDataListClr^ COTSReportProjFileMgrClr::GridDataTransfer()
	{
	

		if (m_pReportProjFileMgr == nullptr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("GridDataTransfer: invalid pointer."));
			return nullptr;
		}

		CReportProjFileMgrPtr pReportProjFileMgr = GetCReportProjFileMgrPtr();

		ASSERT(pReportProjFileMgr);
		if (!pReportProjFileMgr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("GridDataTransfer: failed to create pointer."));
			return nullptr;
		}

		CGridDatasList listGridData = pReportProjFileMgr->GridDataTransfer();
		CGridDataListClr^ listGridDataClr = gcnew CGridDataListClr();
		for (auto pGridData : listGridData)
		{
			CGridDataClr^ GridDataClr = gcnew CGridDataClr(pGridData);
			listGridDataClr->Add(GridDataClr);
		}

		return listGridDataClr;
	}

	bool COTSReportProjFileMgrClr::ReClassify()
	{
		if (m_pReportProjFileMgr == nullptr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("ReClassify: invalid pointer."));
			return false;
		}

		CReportProjFileMgrPtr pReportProjFileMgr = GetCReportProjFileMgrPtr();

		ASSERT(pReportProjFileMgr);
		if (!pReportProjFileMgr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("ReClassify: failed to create pointer."));
			return false;
		}

		bool bRet = pReportProjFileMgr->ReClassify();

		return bRet;
	}

	
	bool COTSReportProjFileMgrClr::GetNomiNateElChemsList(CElementChemistryListClr^ % a_listElChemsInc,
		CElementChemistryListClr^ % a_listNomiElChemsInc)
	{
		if (a_listElChemsInc == nullptr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("GetNomiNateElChemsList: invalid pointer."));
			return false;
		}

		CElementChemistriesList ls_listElChemsInc;
		for (int i = 0; i < a_listElChemsInc->Count; i++)
		{
			ls_listElChemsInc.push_back(a_listElChemsInc[i]->GetElementChemistryPtr());
		}

		CElementChemistriesList ls_listNomiElChemsInc;
		//for (int i = 0; i < a_listNomiElChemsInc->Count; i++)
		//{
		//	ls_listNomiElChemsInc.push_back(a_listNomiElChemsInc[i]->GetElementChemistryPtr());
		//}

		bool  bRet = COTSClassifyEng::NomiNateElChemsList(ls_listElChemsInc,
			ls_listNomiElChemsInc);

		for (int i = 0; i < (int)ls_listNomiElChemsInc.size(); i++)
		{
			a_listNomiElChemsInc->Add(gcnew CElementChemistryClr(ls_listNomiElChemsInc[i]));
		}

		return bRet;
	}

	bool COTSReportProjFileMgrClr::IsHaveMultiDataSource()
	{
		if (m_pReportProjFileMgr == nullptr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("IsHaveMultiDataSource: invalid pointer."));
			return false;
		}

		CReportProjFileMgrPtr pReportProjFileMgr = GetCReportProjFileMgrPtr();

		ASSERT(pReportProjFileMgr);
		if (!pReportProjFileMgr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("IsHaveMultiDataSource: failed to create pointer."));
			return false;
		}

		bool bRet = pReportProjFileMgr->IsHaveMultiDataSource();

		return bRet;
	}
	CRptParamFileClr^ COTSReportProjFileMgrClr::GetRptParamFileClr()
	{
		auto paramfile = m_pReportProjFileMgr->get()->GetRptParamFilePtr();
		auto paramFileClr =gcnew CRptParamFileClr(paramfile);
		return paramFileClr;
	}

	bool COTSReportProjFileMgrClr::ReZoom(String^ a_strInPathName, String^ a_strOutPathName)
	{
		bool nRes = OTSIMGPROC::COTSImageProcess::ReZoom(a_strInPathName, a_strOutPathName);
		return nRes;
	}

}