#include "stdafx.h"
#include "TriTempFileMgrClr.h"

namespace OTSINTERFACE {
	CTriTempFileMgrClr::CTriTempFileMgrClr()									// constructor
	{
		m_LpTriTempFileMgr = new CTriTempFileMgrPtr(new CTriTempFileMgr());
	}
	CTriTempFileMgrClr::CTriTempFileMgrClr(CTriTempFileMgrPtr a_pTriTempFileMgr)					// copy constructor
	{
		if (a_pTriTempFileMgr == nullptr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("CTriTempFileMgrClr: invalid pointer"));
			return;
		}

			m_LpTriTempFileMgr = new CTriTempFileMgrPtr(a_pTriTempFileMgr);
		

	}

	CTriTempFileMgrClr::!CTriTempFileMgrClr()
	{
		if (m_LpTriTempFileMgr != nullptr)
		{
			delete m_LpTriTempFileMgr;
			m_LpTriTempFileMgr = nullptr;
		}
	}
	CTriTempFileMgrClr::~CTriTempFileMgrClr()
	{
		if (m_LpTriTempFileMgr != nullptr)
		{
			delete m_LpTriTempFileMgr;
			m_LpTriTempFileMgr = nullptr;
		}
	}
	
	CTriTempFileMgrPtr CTriTempFileMgrClr::GetTriTempFileMgrPtr()
	{
		return *m_LpTriTempFileMgr;		
	}

	// Load/Save
	bool CTriTempFileMgrClr::Load(String^ a_strPathName, bool a_bClear)
	{
		if (m_LpTriTempFileMgr == nullptr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("Load: invalid pointer."));
			return false;
		}

		CTriTempFileMgrPtr pTriTempFileMgr = GetTriTempFileMgrPtr();

		ASSERT(pTriTempFileMgr);
		if (!pTriTempFileMgr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("Load: can't get triangle template file manager."));
			return false;
		}

		bool bRet = pTriTempFileMgr->Load(a_strPathName, a_bClear);
		if (!bRet)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("Load: failed to load."));
			return false;
		}

		return true;
	}
	bool CTriTempFileMgrClr::Save(String^ a_strPathName)
	{
		if (m_LpTriTempFileMgr == nullptr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("Save: invalid pointer."));
			return false;
		}

		CTriTempFileMgrPtr pTriTempFileMgr = GetTriTempFileMgrPtr();

		ASSERT(pTriTempFileMgr);
		if (!pTriTempFileMgr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("Save: can't get triangle template file manager."));
			return false;
		}

		bool bRet = pTriTempFileMgr->Save(a_strPathName);
		if (!bRet)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("Save: failed to save."));
			return false;
		}

		return true;
	}
	// std items list
	void CTriTempFileMgrClr::SetTriTempItemListClr(CTriTempItemListClr^ a_listTriTempItems, bool a_bClear)
	{
		if (m_LpTriTempFileMgr == nullptr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("SetTriTempItemListClr: invalid pointer."));
			return;
		}

		CTriTempFileMgrPtr pTriTempFileMgr = GetTriTempFileMgrPtr();

		ASSERT(pTriTempFileMgr);
		if (!pTriTempFileMgr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("SetTriTempItemListClr: can't get triangle template file manager."));
			return;
		}

		CTriTempItemList listTriTempItem;
		int nSize = a_listTriTempItems->Count;
		for (int i = 0; i < nSize; i++)
		{
			CTriTempItemPtr pTriTempItem = a_listTriTempItems[i]->GetTriTempItemPtr();
			ASSERT(pTriTempItem);
			if (!pTriTempItem)
			{
				LogErrorTrace(__FILE__, __LINE__, _T("SetTriTempItemListClr: invalid tirangle template item list."));
				return;
			}

			listTriTempItem.push_back(pTriTempItem);
		}

		pTriTempFileMgr->SetTriTempItemList(listTriTempItem, a_bClear);

	}
	CTriTempItemClr^ CTriTempFileMgrClr::GetTriTempItemByIndex(int a_nIndex)
	{
		if (m_LpTriTempFileMgr == nullptr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("GetTriTempItemByIndex: invalid pointer."));
			return nullptr;
		}

		CTriTempFileMgrPtr pTriTempFileMgr = GetTriTempFileMgrPtr();

		ASSERT(pTriTempFileMgr);
		if (!pTriTempFileMgr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("GetTriTempItemByIndex: can't get triangle template file manager."));
			return nullptr;
		}

		CTriTempItemPtr pTriTempItem = pTriTempFileMgr->GetTriTempItemByIndex(a_nIndex);

		ASSERT(pTriTempItem);
		if (!pTriTempItem)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("GetTriTempItemByIndex: can't get triangle template item."));
			return nullptr;
		}

		CTriTempItemClr^ TriTempItemClr = gcnew CTriTempItemClr(pTriTempItem);
		return TriTempItemClr;
	}
	CTriTempItemClr^ CTriTempFileMgrClr::GetTriTempItemByName(String^ a_strName)
	{
		if (m_LpTriTempFileMgr == nullptr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("GetTriTempItemByName: invalid pointer."));
			return nullptr;
		}

		CTriTempFileMgrPtr pTriTempFileMgr = GetTriTempFileMgrPtr();

		ASSERT(pTriTempFileMgr);
		if (!pTriTempFileMgr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("GetTriTempItemByName: can't get triangle template file manager."));
			return nullptr;
		}

		CTriTempItemPtr pTriTempItem = pTriTempFileMgr->GetTriTempItemByName(a_strName);

		ASSERT(pTriTempItem);
		if (!pTriTempItem)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("GetTriTempItemByName: can't get triangle template item."));
			return nullptr;
		}

		CTriTempItemClr^ TriTempItemClr = gcnew CTriTempItemClr(pTriTempItem);
		return TriTempItemClr;
	}
	bool CTriTempFileMgrClr::DeleteTriTempItemByIndex(int a_nIndex)
	{
		if (m_LpTriTempFileMgr == nullptr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("DeleteTriTempItemByIndex: invalid pointer."));
			return false;
		}

		CTriTempFileMgrPtr pTriTempFileMgr = GetTriTempFileMgrPtr();

		ASSERT(pTriTempFileMgr);
		if (!pTriTempFileMgr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("DeleteTriTempItemByIndex: can't get triangle template file manager."));
			return false;
		}

		bool bRet = pTriTempFileMgr->DeleteTriTempItemByIndex(a_nIndex);
		if (!bRet)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("DeleteTriTempItemByIndex: failed to delete."));
			return false;
		}

		return true;
	}
	bool CTriTempFileMgrClr::AddTriTempItem(CTriTempItemClr^ a_poTriTempItem)
	{
		if (m_LpTriTempFileMgr == nullptr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("AddTriTempItem: invalid pointer."));
			return false;
		}

		CTriTempFileMgrPtr pTriTempFileMgr = GetTriTempFileMgrPtr();

		ASSERT(pTriTempFileMgr);
		if (!pTriTempFileMgr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("AddTriTempItem: can't get triangle template file manager."));
			return false;
		}

		CTriTempItemPtr pTriTempItem = a_poTriTempItem->GetTriTempItemPtr();
		ASSERT(pTriTempItem);
		if (!pTriTempItem)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("AddTriTempItem: can't get triangle template item pointer."));
			return false;
		}

		bool bRet = pTriTempFileMgr->AddTriTempItem(pTriTempItem);
		if (!bRet)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("AddTriTempItem: failed to add."));
			return false;
		}
		return true;
	}
	bool CTriTempFileMgrClr::InsertTriTempItem(int a_nIndex, CTriTempItemClr^ a_poTriTempItem)
	{
		if (m_LpTriTempFileMgr == nullptr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("InsertTriTempItem: invalid pointer."));
			return false;
		}

		CTriTempFileMgrPtr pTriTempFileMgr = GetTriTempFileMgrPtr();

		ASSERT(pTriTempFileMgr);
		if (!pTriTempFileMgr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("InsertTriTempItem: can't get triangle template file manager."));
			return false;
		}

		CTriTempItemPtr pTriTempItem = a_poTriTempItem->GetTriTempItemPtr();
		ASSERT(pTriTempItem);
		if (!pTriTempItem)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("InsertTriTempItem: can't get triangle template item pointer."));
			return false;
		}

		bool bRet = pTriTempFileMgr->InsertTriTempItem(a_nIndex, pTriTempItem);
		if (!bRet)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("InsertTriTempItem: failed to add."));
			return false;
		}

		return true;
	}
	bool CTriTempFileMgrClr::EditTriTempItem(int a_nIndex, CTriTempItemClr^ a_poTriTempItem)
	{
		if (m_LpTriTempFileMgr == nullptr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("EditTriTempItem: invalid pointer."));
			return false;
		}

		CTriTempFileMgrPtr pTriTempFileMgr = GetTriTempFileMgrPtr();

		ASSERT(pTriTempFileMgr);
		if (!pTriTempFileMgr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("EditTriTempItem: can't get triangle template file manager."));
			return false;
		}

		CTriTempItemPtr pTriTempItem = a_poTriTempItem->GetTriTempItemPtr();
		ASSERT(pTriTempItem);
		if (!pTriTempItem)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("EditTriTempItem: can't get triangle template item pointer."));
			return false;
		}

		bool bRet = pTriTempFileMgr->EditTriTempItem(a_nIndex, pTriTempItem);
		if (!bRet)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("EditTriTempItem: failed to add."));
			return false;
		}
		return true;
	}

	CTriTempFileClr^ CTriTempFileMgrClr::GetTriTempFile()
	{
		if (m_LpTriTempFileMgr == nullptr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("GetTriTempFile: invalid pointer."));
			return nullptr;
		}

		CTriTempFileMgrPtr pTriTempFileMgr = GetTriTempFileMgrPtr();

		ASSERT(pTriTempFileMgr);
		if (!pTriTempFileMgr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("GetTriTempFile: can't get triangle template file manager."));
			return nullptr;
		}

		CTriTempFilePtr pTriTempFile = pTriTempFileMgr->GetTriTempFile();
		ASSERT(pTriTempFile);
		if (!pTriTempFile)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("GetTriTempFile: can't get triangle template file."));
			return nullptr;
		}

		CTriTempFileClr^ TriTempFileClr = gcnew CTriTempFileClr(pTriTempFile);

		return TriTempFileClr;

	}
	// triangle template standard data
	void CTriTempFileMgrClr::SetTriTempFile(CTriTempFileClr^ a_poTriTempFile)
	{
		if (m_LpTriTempFileMgr == nullptr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("SetTriTempFile: invalid pointer."));
			return;
		}

		CTriTempFileMgrPtr pTriTempFileMgr = GetTriTempFileMgrPtr();

		ASSERT(pTriTempFileMgr);
		if (!pTriTempFileMgr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("SetTriTempFile: can't get triangle template file manager."));
			return;
		}

		ASSERT(a_poTriTempFile);
		if (!a_poTriTempFile)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("SetTriTempFile: can't get triangle template file."));
			return;
		}

		CTriTempFilePtr pTriTempFile = a_poTriTempFile->GetTriTempFilePtr();
		ASSERT(pTriTempFile);
		if (!pTriTempFile)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("SetTriTempFile: can't get triangle template file."));
			return;
		}

		pTriTempFileMgr->SetTriTempFile(pTriTempFile);
	}

	// file pathname
	String^ CTriTempFileMgrClr::GetPathName()
	{
		if (m_LpTriTempFileMgr == nullptr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("GetPathName: invalid pointer."));
			return nullptr;
		}

		CTriTempFileMgrPtr pTriTempFileMgr = GetTriTempFileMgrPtr();

		ASSERT(pTriTempFileMgr);
		if (!pTriTempFileMgr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("GetPathName: can't get triangle template file manager."));
			return nullptr;
		}

		CString sPathName = pTriTempFileMgr->GetPathName();
		String^ PathNameClr = gcnew String(sPathName);

		return PathNameClr;
	}
	void CTriTempFileMgrClr::SetPathName(String^ a_strPathName)
	{
		if (m_LpTriTempFileMgr == nullptr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("SetPathName: invalid pointer."));
			return;
		}

		CTriTempFileMgrPtr pTriTempFileMgr = GetTriTempFileMgrPtr();

		ASSERT(pTriTempFileMgr);
		if (!pTriTempFileMgr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("SetPathName: can't get triangle template file manager."));
			return;
		}

		pTriTempFileMgr->SetPathName(a_strPathName);

	}

	// modify flag
	bool CTriTempFileMgrClr::IsModified()
	{
		if (m_LpTriTempFileMgr == nullptr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("IsModified: invalid pointer."));
			return false;
		}

		CTriTempFileMgrPtr pTriTempFileMgr = GetTriTempFileMgrPtr();

		ASSERT(pTriTempFileMgr);
		if (!pTriTempFileMgr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("IsModified: can't get triangle template file manager."));
			return false;
		}

		bool bRet = pTriTempFileMgr->IsModified();

		return bRet;

	}
	void CTriTempFileMgrClr::SetModify(bool a_bModify)
	{
		if (m_LpTriTempFileMgr == nullptr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("SetModify: invalid pointer."));
			return;
		}

		CTriTempFileMgrPtr pTriTempFileMgr = GetTriTempFileMgrPtr();

		ASSERT(pTriTempFileMgr);
		if (!pTriTempFileMgr)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("SetModify: can't get triangle template file manager."));
			return;
		}

		pTriTempFileMgr->SetModify(a_bModify);

	}

}