#include "StdAfx.h"
#include "CHReviewSetting/Sys_AlignManager.h"

CAlignCameraInfo::CAlignCameraInfo()
{
	Reset();
}

CAlignCameraInfo::~CAlignCameraInfo(void)
{
	Reset();
}

void CAlignCameraInfo::Reset()
{
	m_CameraControlInfo.Reset();
	m_LightControlInfo.Reset();
}

void CAlignCameraInfo::SetInfo(const CAlignCameraInfo& rhs)
{
	//Camera Info
	GetCameraControlInfo()->SetStandardCamera(rhs.GetCameraControlInfo()->GetStandardCamera());
	GetCameraControlInfo()->SetLibraryType(rhs.GetCameraControlInfo()->GetLibraryType());
	GetCameraControlInfo()->SetFlipType(rhs.GetCameraControlInfo()->GetFlipType());
	GetCameraControlInfo()->SetName(rhs.GetCameraControlInfo()->GetName());
	GetCameraControlInfo()->SetConnectionPort(rhs.GetCameraControlInfo()->GetConnectionPort());
	GetCameraControlInfo()->SetFrameCount(rhs.GetCameraControlInfo()->GetFrameCount());
	GetCameraControlInfo()->SetFrameWidth(rhs.GetCameraControlInfo()->GetFrameWidth());
	GetCameraControlInfo()->SetFrameHeight(rhs.GetCameraControlInfo()->GetFrameHeight());
	GetCameraControlInfo()->SetImageBufferCount(rhs.GetCameraControlInfo()->GetImageBufferCount());
	GetCameraControlInfo()->SetPixelResolution(rhs.GetCameraControlInfo()->GetPixelResolution());
	GetCameraControlInfo()->SetFrameChannels(rhs.GetCameraControlInfo()->GetFrameChannels());
	GetCameraControlInfo()->SetAxisDirectionX(rhs.GetCameraControlInfo()->GetAxisDirectionX());
	GetCameraControlInfo()->SetAxisDirectionY(rhs.GetCameraControlInfo()->GetAxisDirectionY());

	// [2017:1:20]-[WEZASW] : 'ReviewSystemSetting' Parameter Ç׸ñ Á¤¸®
	//GetCameraControlInfo()->SetGrabberIndex(rhs.GetCameraControlInfo()->GetGrabberIndex());
	//GetCameraControlInfo()->SetChannelIndex(rhs.GetCameraControlInfo()->GetChannelIndex());
	//GetCameraControlInfo()->SetCameraDistanceX(rhs.GetCameraControlInfo()->GetCameraDistanceX());
	//GetCameraControlInfo()->SetCameraDistanceY(rhs.GetCameraControlInfo()->GetCameraDistanceY());
	//GetCameraControlInfo()->SetCameraOffsetX(rhs.GetCameraControlInfo()->GetCameraDistanceX());
	//GetCameraControlInfo()->SetCameraOffsetY(rhs.GetCameraControlInfo()->GetCameraDistanceY());
	//GetCameraControlInfo()->SetCameraFilePath(rhs.GetCameraControlInfo()->GetCameraFilePath());

	//Light Info
	GetLightContorlInfo()->SetControllerType(rhs.GetLightContorlInfo()->GetControllerType());
	GetLightContorlInfo()->SetConnectionPort(rhs.GetLightContorlInfo()->GetConnectionPort());
	GetLightContorlInfo()->SetChannel(rhs.GetLightContorlInfo()->GetMaster());
	GetLightContorlInfo()->SetChannel(rhs.GetLightContorlInfo()->GetChannel());
	GetLightContorlInfo()->SetDefaultValue(rhs.GetLightContorlInfo()->GetDefaultValue());	
}

void CAlignCameraInfo::GetInfo(CAlignCameraInfo& rhs)
{
	//Camera Info
	rhs.GetCameraControlInfo()->SetStandardCamera(GetCameraControlInfo()->GetStandardCamera());
	rhs.GetCameraControlInfo()->SetLibraryType(GetCameraControlInfo()->GetLibraryType());
	rhs.GetCameraControlInfo()->SetFlipType(GetCameraControlInfo()->GetFlipType());
	rhs.GetCameraControlInfo()->SetName(GetCameraControlInfo()->GetName());
	rhs.GetCameraControlInfo()->SetConnectionPort(GetCameraControlInfo()->GetConnectionPort());
	rhs.GetCameraControlInfo()->SetFrameCount(GetCameraControlInfo()->GetFrameCount());
	rhs.GetCameraControlInfo()->SetFrameWidth(GetCameraControlInfo()->GetFrameWidth());
	rhs.GetCameraControlInfo()->SetFrameHeight(GetCameraControlInfo()->GetFrameHeight());
	rhs.GetCameraControlInfo()->SetImageBufferCount(GetCameraControlInfo()->GetImageBufferCount());
	rhs.GetCameraControlInfo()->SetAxisDirectionX(GetCameraControlInfo()->GetAxisDirectionX());
	rhs.GetCameraControlInfo()->SetAxisDirectionY(GetCameraControlInfo()->GetAxisDirectionY());
	rhs.GetCameraControlInfo()->SetPixelResolution(GetCameraControlInfo()->GetPixelResolution());
	rhs.GetCameraControlInfo()->SetFrameChannels(GetCameraControlInfo()->GetFrameChannels());

	// [2017:1:20]-[WEZASW] : 'ReviewSystemSetting' Parameter Ç׸ñ Á¤¸®
	//rhs.GetCameraControlInfo()->SetGrabberIndex(GetCameraControlInfo()->GetGrabberIndex());
	//rhs.GetCameraControlInfo()->SetChannelIndex(GetCameraControlInfo()->GetChannelIndex());
	//rhs.GetCameraControlInfo()->SetCameraDistanceX(GetCameraControlInfo()->GetCameraDistanceX());
	//rhs.GetCameraControlInfo()->SetCameraDistanceY(GetCameraControlInfo()->GetCameraDistanceY());
	//rhs.GetCameraControlInfo()->SetCameraOffsetX(GetCameraControlInfo()->GetCameraDistanceX());
	//rhs.GetCameraControlInfo()->SetCameraOffsetY(GetCameraControlInfo()->GetCameraDistanceY());
	//rhs.GetCameraControlInfo()->SetCameraFilePath(GetCameraControlInfo()->GetCameraFilePath());

	//Light Info
	GetLightContorlInfo()->SetControllerType(rhs.GetLightContorlInfo()->GetControllerType());
	GetLightContorlInfo()->SetConnectionPort(rhs.GetLightContorlInfo()->GetConnectionPort());
	GetLightContorlInfo()->SetChannel(rhs.GetLightContorlInfo()->GetMaster());
	GetLightContorlInfo()->SetChannel(rhs.GetLightContorlInfo()->GetChannel());
	GetLightContorlInfo()->SetDefaultValue(rhs.GetLightContorlInfo()->GetDefaultValue());
}

CSys_AlignManager::CSys_AlignManager(void)
{
	m_vecAlignCameraInfo.clear();
}

CSys_AlignManager::~CSys_AlignManager(void)
{
	m_vecAlignCameraInfo.clear();
}

CAlignCameraInfo* CSys_AlignManager::GetAlignCameraInfo(int nIndex)
{
	if (nIndex<0 || nIndex>=(int)m_vecAlignCameraInfo.size()) return NULL;

	return &(m_vecAlignCameraInfo[nIndex]);
}

const CAlignCameraInfo* CSys_AlignManager::GetAlignCameraInfo(int nIndex) const
{
	if (nIndex<0 || nIndex>=(int)m_vecAlignCameraInfo.size()) return NULL;

	return &(m_vecAlignCameraInfo[nIndex]);
}

void CSys_AlignManager::SetProfile(CMacroFile& macroFile)
{
	CString strItem = _T("");

	// AlignCamera
	int nCameraCount = GetAlignCameraInfoCount();
	strItem.Format(_T("SYS_ALIGN_CAMERA_COUNT"));
	macroFile.SetItem(strItem, nCameraCount);

	for(int i = 0; i < nCameraCount; i++)
	{
		const CAlignCameraInfo* pAlignCameraInfo = GetAlignCameraInfo(i);
		if (pAlignCameraInfo==NULL) continue;


		if(i==0){
			strItem.Format(_T("SYS_ALIGN_CAMERA_FRAME_RATE_APPLY"));
			macroFile.SetItem(strItem,(int)pAlignCameraInfo->GetAlignCameraFrameRateApply());

		}

		const CCameraControlInfo_Plus *pCameraInfo = pAlignCameraInfo->GetCameraControlInfo();
		if (pCameraInfo)
		{
			strItem.Format(_T("SYS_ALIGN_CAMERA_INDEX_%02d"), i);
			macroFile.SetItem(strItem, pCameraInfo->GetIndex());

			strItem.Format(_T("SYS_ALIGN_CAMERA_STANDARD_%02d"), i);
			macroFile.SetItem(strItem, (int)pCameraInfo->GetStandardCamera());

			strItem.Format(_T("SYS_ALIGN_CAMERA_LIBRARY_TYPE_%02d"), i);
			macroFile.SetItem(strItem, pCameraInfo->GetLibraryType());

			strItem.Format(_T("SYS_ALIGN_CAMERA_FLIP_TYPE_%02d"), i);
			macroFile.SetItem(strItem, pCameraInfo->GetFlipType());

			strItem.Format(_T("SYS_ALIGN_CAMERA_NAME_%02d"), i);
			macroFile.SetItem(strItem, pCameraInfo->GetName());

			strItem.Format(_T("SYS_ALIGN_CAMERA_CONNECTION_PORT_%02d"), i);
			macroFile.SetItem(strItem, pCameraInfo->GetConnectionPort());

			strItem.Format(_T("SYS_ALIGN_CAMERA_FRAME_COUNT_%02d"), i);
			macroFile.SetItem(strItem, pCameraInfo->GetFrameCount());

			strItem.Format(_T("SYS_ALIGN_CAMERA_FRAME_WIDTH_%02d"), i);
			macroFile.SetItem(strItem, pCameraInfo->GetFrameWidth());

			strItem.Format(_T("SYS_ALIGN_CAMERA_FRAME_HEIGHT_%02d"), i);
			macroFile.SetItem(strItem, pCameraInfo->GetFrameHeight());

			strItem.Format(_T("SYS_ALIGN_CAMERA_IMAGE_BUFFER_COUNT_%02d"), i);
			macroFile.SetItem(strItem, pCameraInfo->GetImageBufferCount());

			strItem.Format(_T("SYS_ALIGN_CAMERA_RESOLUTION_%02d"), i);
			macroFile.SetItem(strItem, pCameraInfo->GetPixelResolution());

			strItem.Format(_T("SYS_ALIGN_CAMERA_FRAME_CHANNEL_%02d"), i);
			macroFile.SetItem(strItem, pCameraInfo->GetFrameChannels());

			strItem.Format(_T("SYS_ALIGN_CAMERA_X_AXIS_DIRECTION_%02d"), i);
			macroFile.SetItem(strItem, pCameraInfo->GetAxisDirectionX());

			strItem.Format(_T("SYS_ALIGN_CAMERA_Y_AXIS_DIRECTION_%02d"), i);
			macroFile.SetItem(strItem, pCameraInfo->GetAxisDirectionY());

			// [2017:1:20]-[WEZASW] : 'ReviewSystemSetting' Parameter Ç׸ñ Á¤¸®
			//strItem.Format(_T("SYS_ALIGN_CAMERA_GRABBER_INDEX_%02d"), i);
			//macroFile.SetItem(strItem, pCameraInfo->GetGrabberIndex());

			//strItem.Format(_T("SYS_ALIGN_CAMERA_CHANNEL_INDEX_%02d"), i);
			//macroFile.SetItem(strItem, pCameraInfo->GetChannelIndex());
		}

		const CLightControlInfo* pLightInfo = pAlignCameraInfo->GetLightContorlInfo();
		if (pLightInfo)
		{
			strItem.Format(_T("SYS_ALIGN_CAMERA_LIGHT_TYPE_%02d"), i);
			macroFile.SetItem(strItem, pLightInfo->GetControllerType());

			strItem.Format(_T("SYS_ALIGN_CAMERA_LIGHT_PORT_%02d"), i);
			macroFile.SetItem(strItem, pLightInfo->GetConnectionPort());

			strItem.Format(_T("SYS_ALIGN_CAMERA_LIGHT_MASTER_%02d"), i);
			macroFile.SetItem(strItem, pLightInfo->GetMaster());

			strItem.Format(_T("SYS_ALIGN_CAMERA_LIGHT_CHANNEL_%02d"), i);
			macroFile.SetItem(strItem, pLightInfo->GetChannel());

			strItem.Format(_T("SYS_ALIGN_CAMERA_LIGHT_DEFAULT_VALUE_%02d"), i);
			macroFile.SetItem(strItem, pLightInfo->GetDefaultValue());
		}
	}
}

void CSys_AlignManager::GetProfile(CMacroFile& macroFile)
{
	CString strItem = _T("");
	
	int nCameraCount = 0;
	strItem.Format(_T("SYS_ALIGN_CAMERA_COUNT"));
	macroFile.GetItem(strItem, nCameraCount);
	CAlignCameraInfo AlignCameraInfo;
	m_vecAlignCameraInfo.clear();


	int nGetItem = 0;
	double dGetItem = 0.;
	CString strGetItem =_T("");

	strItem.Format(_T("SYS_ALIGN_CAMERA_FRAME_RATE_APPLY"));
	macroFile.GetItem(strItem,nGetItem);
	AlignCameraInfo.SetAlignCameraFrameRateApply(nGetItem);

	for(int i = 0; i < nCameraCount; i++)
	{
		AlignCameraInfo.Reset();

		strItem.Format(_T("SYS_ALIGN_CAMERA_INDEX_%02d"), i);
		macroFile.GetItem(strItem, nGetItem);
		AlignCameraInfo.GetCameraControlInfo()->SetIndex(nGetItem);

		strItem.Format(_T("SYS_ALIGN_CAMERA_STANDARD_%02d"), i);
		macroFile.GetItem(strItem, nGetItem);
		AlignCameraInfo.GetCameraControlInfo()->SetStandardCamera((BOOL)nGetItem);		

		strItem.Format(_T("SYS_ALIGN_CAMERA_LIBRARY_TYPE_%02d"), i);
		macroFile.GetItem(strItem, nGetItem);
		AlignCameraInfo.GetCameraControlInfo()->SetLibraryType(nGetItem);

		strItem.Format(_T("SYS_ALIGN_CAMERA_FLIP_TYPE_%02d"), i);
		macroFile.GetItem(strItem, nGetItem);
		AlignCameraInfo.GetCameraControlInfo()->SetFlipType(nGetItem);

		strItem.Format(_T("SYS_ALIGN_CAMERA_NAME_%02d"), i);
		macroFile.GetItem(strItem, strGetItem);
		AlignCameraInfo.GetCameraControlInfo()->SetName(strGetItem);

		strItem.Format(_T("SYS_ALIGN_CAMERA_CONNECTION_PORT_%02d"), i);
		macroFile.GetItem(strItem, strGetItem);
		AlignCameraInfo.GetCameraControlInfo()->SetConnectionPort(strGetItem);

		strItem.Format(_T("SYS_ALIGN_CAMERA_FRAME_COUNT_%02d"), i);
		macroFile.GetItem(strItem, nGetItem);
		AlignCameraInfo.GetCameraControlInfo()->SetFrameCount(nGetItem);

		strItem.Format(_T("SYS_ALIGN_CAMERA_FRAME_WIDTH_%02d"), i);
		macroFile.GetItem(strItem, nGetItem);
		AlignCameraInfo.GetCameraControlInfo()->SetFrameWidth(nGetItem);

		strItem.Format(_T("SYS_ALIGN_CAMERA_FRAME_HEIGHT_%02d"), i);
		macroFile.GetItem(strItem, nGetItem);
		AlignCameraInfo.GetCameraControlInfo()->SetFrameHeight(nGetItem);

		strItem.Format(_T("SYS_ALIGN_CAMERA_IMAGE_BUFFER_COUNT_%02d"), i);
		macroFile.GetItem(strItem, nGetItem);
		AlignCameraInfo.GetCameraControlInfo()->SetImageBufferCount(nGetItem);

		strItem.Format(_T("SYS_ALIGN_CAMERA_RESOLUTION_%02d"), i);
		macroFile.GetItem(strItem, dGetItem);
		AlignCameraInfo.GetCameraControlInfo()->SetPixelResolution(dGetItem);

		strItem.Format(_T("SYS_ALIGN_CAMERA_FRAME_CHANNEL_%02d"), i);
		macroFile.GetItem(strItem, nGetItem);
		AlignCameraInfo.GetCameraControlInfo()->SetFrameChannels(nGetItem);

		strItem.Format(_T("SYS_ALIGN_CAMERA_X_AXIS_DIRECTION_%02d"), i);
		macroFile.GetItem(strItem, nGetItem);
		AlignCameraInfo.GetCameraControlInfo()->SetAxisDirectionX(nGetItem);

		strItem.Format(_T("SYS_ALIGN_CAMERA_Y_AXIS_DIRECTION_%02d"), i);
		macroFile.GetItem(strItem, nGetItem);
		AlignCameraInfo.GetCameraControlInfo()->SetAxisDirectionY(nGetItem);

		// [2017:1:20]-[WEZASW] : 'ReviewSystemSetting' Parameter Ç׸ñ Á¤¸®
		//strItem.Format(_T("SYS_ALIGN_CAMERA_GRABBER_INDEX_%02d"), i);
		//macroFile.GetItem(strItem, nGetItem);
		//AlignCameraInfo.GetCameraControlInfo()->SetGrabberIndex(nGetItem);

		//strItem.Format(_T("SYS_ALIGN_CAMERA_CHANNEL_INDEX_%02d"), i);
		//macroFile.GetItem(strItem, nGetItem);
		//AlignCameraInfo.GetCameraControlInfo()->SetChannelIndex(nGetItem);

		//////////////////////////////////////////////////////////////////////////
		strItem.Format(_T("SYS_ALIGN_CAMERA_LIGHT_TYPE_%02d"), i);
		macroFile.GetItem(strItem, nGetItem);
		AlignCameraInfo.GetLightContorlInfo()->SetControllerType(nGetItem);

		strItem.Format(_T("SYS_ALIGN_CAMERA_LIGHT_PORT_%02d"), i);
		macroFile.GetItem(strItem, strGetItem);
		AlignCameraInfo.GetLightContorlInfo()->SetConnectionPort(strGetItem);

		strItem.Format(_T("SYS_ALIGN_CAMERA_LIGHT_MASTER_%02d"), i);
		macroFile.GetItem(strItem, nGetItem);
		AlignCameraInfo.GetLightContorlInfo()->SetMaster(nGetItem);

		strItem.Format(_T("SYS_ALIGN_CAMERA_LIGHT_CHANNEL_%02d"), i);
		macroFile.GetItem(strItem, nGetItem);
		AlignCameraInfo.GetLightContorlInfo()->SetChannel(nGetItem);

		strItem.Format(_T("SYS_ALIGN_CAMERA_LIGHT_DEFAULT_VALUE_%02d"), i);
		macroFile.GetItem(strItem, nGetItem);
		AlignCameraInfo.GetLightContorlInfo()->SetDefaultValue(nGetItem);

		m_vecAlignCameraInfo.push_back(AlignCameraInfo);
	}
}

int CSys_AlignManager::GetStandardCameraIndex() const
{
	int nIndex = 0;
	for (constVectorAlignCameraInfoIt it=m_vecAlignCameraInfo.begin(); it!=m_vecAlignCameraInfo.end(); it++)
	{		
		if (it->GetCameraControlInfo()->GetStandardCamera())
		{
			return nIndex;
		}
		nIndex++;
	}

	return -1;
}

CAlignCameraInfo* CSys_AlignManager::GetStandardAlignCameraInfo()
{
	for (VectorAlignCameraInfoIt it=m_vecAlignCameraInfo.begin(); it!=m_vecAlignCameraInfo.end(); it++)
	{
		if (it->GetCameraControlInfo()->GetStandardCamera())
		{
			return &(*it);
		}
	}

	return NULL;
}

const CAlignCameraInfo* CSys_AlignManager::GetStandardAlignCameraInfo() const
{
	for (constVectorAlignCameraInfoIt it=m_vecAlignCameraInfo.begin(); it!=m_vecAlignCameraInfo.end(); it++)
	{
		if (it->GetCameraControlInfo()->GetStandardCamera())
		{
			return &(*it);
		}
	}

	return NULL;
}

void CSys_AlignManager::SetAlignCameraInfoCount(int nCount)
{
	m_vecAlignCameraInfo.resize(nCount);
}