// DlgReviewOffSetTool.cpp: 구현 파일
//

#include "stdafx.h"
#include "ReviewSystem.h"
#include "DlgReviewOffSetTool.h"
#include "afxdialogex.h"
#include "CHCommonClasses/MacroFile.h"
//#include "CHMotorControls/MotorControl.h"
// DlgReviewOffSetTool 대화 상자


IMPLEMENT_DYNAMIC(DlgReviewOffSetTool, CDialogEx)

DlgReviewOffSetTool::DlgReviewOffSetTool(CWnd* pParent /*=nullptr*/)
	: CDialogEx(IDD_DLG_REVIEW_OFFSET_TOOL, pParent)
	, m_EditOffSetValueX(0)
	, m_EditOffSetValueY(0)
	, m_nEditCameraCount(0)
	, m_nEditScanCount(0)
	, m_nEditReviewCameraCount(0)
	, m_nEditXposCount(0)
	, m_strEditSettingFilePath(_T(""))
	, m_editGlassOffSetmodeCamIndex(0)
	, m_editGlassOffSetmodeScanIndex(0)
	, m_editGlassOffSetmodeXpos(0)
	, m_editGlassOffSetmodeYpos(0)
	, m_dWarnStandard(0)
	, m_dHardStandard(0)
{
	m_EditChangeTargetXpos = 0;
	m_EditChangeTargetYpos = 0;
	m_EditTargetXpos = 0;
	m_EditTargetYpos = 0;
	m_nCameraCount = 0;
	m_nScanCount = 0;
	m_XposCount = 0;
	m_SelectedCellCol = -1;
	m_SelectedCellRow = -1;
	m_nReveiwCamCount = 2;
	m_nSelectedModule = 0;
	dBarValue = 0;
}

DlgReviewOffSetTool::~DlgReviewOffSetTool()
{
}

void DlgReviewOffSetTool::DoDataExchange(CDataExchange* pDX)
{
	CDialogEx::DoDataExchange(pDX);
	DDX_Control(pDX, IDC_GRID_REVIEW_OFFSET_INFO, m_ctrlGridReviewOffSetInfo);
	DDX_Text(pDX, IDC_EDIT_TARGET_XPOS, m_EditTargetXpos);
	DDX_Text(pDX, IDC_EDIT_TARGET_YPOS, m_EditTargetYpos);
	DDX_Text(pDX, IDC_EDIT_CHANGE_TARGET_XPOS, m_EditChangeTargetXpos);
	DDX_Text(pDX, IDC_EDIT_CHANGE_TARGET_YPOS, m_EditChangeTargetYpos);
	DDX_Control(pDX, IDC_COMBO_SELECT_MODULE, m_ctrlComboModule);
	DDX_Text(pDX, IDC_EDIT_OFFSET_X_VALUE, m_EditOffSetValueX);
	DDX_Text(pDX, IDC_EDIT_OFFSET_Y_VALUE, m_EditOffSetValueY);
	DDX_Text(pDX, IDC_EDIT_CAMERA_COUNT, m_nEditCameraCount);
	DDX_Text(pDX, IDC_EDIT_SCAN_COUNT, m_nEditScanCount);
	DDX_Text(pDX, IDC_EDIT_REVIEW_CAMCOUNT, m_nEditReviewCameraCount);
	DDX_Text(pDX, IDC_EDIT_XPOS_COUNT, m_nEditXposCount);
	DDX_Control(pDX, IDC_BUTTON_APPLY_GRID_DATA, m_ctrlGradAppltbt);
	DDX_Control(pDX, IDC_BUTTON_APPLT_OFFSET_PARAM, m_ctrlApplyOffsetParamBt);
	DDX_Control(pDX, IDC_BUTTON_APPLT_OFFSET, m_ctrlApplyOffsetBt);
	DDX_Control(pDX, IDC_BUTTION_TARGET_POS, m_ctrlSetTargetMotorBt);
	DDX_Control(pDX, IDC_BUTTION_CAHNGE_TARGET_POS, m_ctrlSetChangeMotorBt);
	DDX_Text(pDX, IDC_EDIT_SETTINGFILE_PATH, m_strEditSettingFilePath);
	DDX_Control(pDX, IDC_PROGRESS_PROCESS, m_ctrlProcessBar);
	DDX_Control(pDX, IDC_BUTTON_SAVE_SETTING_FILE, m_ctrlSaveBt);
	DDX_Control(pDX, IDC_CHECK_OFFSET_MODE, m_ctrlOffSetMode);
	DDX_Text(pDX, IDC_EDIT_CAM_INDEX, m_editGlassOffSetmodeCamIndex);
	DDX_Text(pDX, IDC_EDIT_SCAN_INDEX, m_editGlassOffSetmodeScanIndex);
	DDX_Text(pDX, IDC_EDIT_MOTOR_XPOS, m_editGlassOffSetmodeXpos);
	DDX_Text(pDX, IDC_EDIT_MOTOR_YPOS, m_editGlassOffSetmodeYpos);
	DDX_Text(pDX, IDC_EDIT_WARN_STANDARD, m_dWarnStandard);
	DDX_Text(pDX, IDC_EDIT_HARD_STANDARD, m_dHardStandard);
}


BEGIN_MESSAGE_MAP(DlgReviewOffSetTool, CDialogEx)
	ON_BN_CLICKED(IDOK, &DlgReviewOffSetTool::OnBnClickedOk)
	ON_BN_CLICKED(IDC_BUTTION_TARGET_POS, &DlgReviewOffSetTool::OnBnClickedButtionTargetPos)
	ON_BN_CLICKED(IDC_BUTTION_CAHNGE_TARGET_POS, &DlgReviewOffSetTool::OnBnClickedButtionCahngeTargetPos)
	ON_NOTIFY(GVN_SELCHANGED, IDC_GRID_REVIEW_OFFSET_INFO, OnGridSelChanged)
	ON_BN_CLICKED(IDC_BUTTON_APPLT_OFFSET, &DlgReviewOffSetTool::OnBnClickedButtonAppltOffset)
	ON_EN_CHANGE(IDC_EDIT_REVIEW_CAMCOUNT, &DlgReviewOffSetTool::OnEnChangeEditReviewCamcount)
	ON_EN_CHANGE(IDC_EDIT_SCAN_COUNT, &DlgReviewOffSetTool::OnEnChangeEditScanCount)
	ON_BN_CLICKED(IDC_BUTTON_APPLY_GRID_DATA, &DlgReviewOffSetTool::OnBnClickedButtonApplyGridData)
	ON_CBN_SELCHANGE(IDC_COMBO_SELECT_MODULE, &DlgReviewOffSetTool::OnCbnSelchangeComboSelectModule)
	ON_BN_CLICKED(IDC_BUTTON_APPLT_OFFSET_PARAM, &DlgReviewOffSetTool::OnBnClickedButtonAppltOffsetParam)
	ON_MESSAGE(WM_OFFSETTOOL_MESSAGE, OnUserFunc)
	ON_MESSAGE(WM_OFFSETTOOL_MESSAGE2, OnUpdatedata)
	ON_BN_CLICKED(IDC_BUTTON_SAVE_SETTING_FILE, &DlgReviewOffSetTool::OnBnClickedButtonSaveSettingFile)
	ON_BN_CLICKED(IDC_CHECK_OFFSET_MODE, &DlgReviewOffSetTool::OnBnClickedCheckOffsetMode)
	ON_BN_CLICKED(IDC_OFFSET_LOAD, &DlgReviewOffSetTool::OnBnClickedOffsetLoad)
END_MESSAGE_MAP()


// DlgReviewOffSetTool 메시지 처리기


void DlgReviewOffSetTool::OnBnClickedOk()
{
	// TODO: 여기에 컨트롤 알림 처리기 코드를 추가합니다.
	CDialogEx::OnOK();
}

void DlgReviewOffSetTool::InitModuleCombobox()
{
	for (int nModule = 0; nModule < 2; nModule++)
	{

		if (nModule == 0)
		{
			m_ctrlComboModule.InsertString(0, _T("LEFT_GANTRY"));

		}
		else if (nModule == 1)
		{
			m_ctrlComboModule.InsertString(1, _T("RIGHT_GANTRY"));
		}

	}
	m_ctrlComboModule.SetCurSel(0);

}

void DlgReviewOffSetTool::InitOffSetInfoGridControl()
{	
	int nRowIdx, nColIdx, nRows, nCols, nFixRows, nDataColumnWidth, nMargin;
	CString strTemp;
	CRect rect;
	nRows = 10;
	nCols = 10;
	nFixRows = 1;
	nRowIdx = 0;
	nColIdx = 0;
	double dGlassXdivideSize = 0;
	double dGlassXsize = 2500;
	double dGlassXposMin = 0;
	double dGlassXposMax = 0;
	bool bDefault = FALSE;
	if (m_nCameraCount == 0 || m_nScanCount == 0)
	{
		nRows = CAM_MAX_COUNT * SCAN_MAX_COUNT;
		bDefault = TRUE;
	}
	else
	{
		nRows = m_nCameraCount * m_nScanCount;
		
	}

	if (m_XposCount == 0)
	{
		nCols = XPOS_MAX_COUNT*2;


	}
	else
	{
		nCols = m_XposCount * 2;
	}

	dGlassXdivideSize = dGlassXsize / (nCols/2);

	m_ctrlGridReviewOffSetInfo.GetWindowRect(&rect);
	m_ctrlGridReviewOffSetInfo.GetDefaultCell(FALSE, FALSE)->SetBackClr(RGB(0xFF, 0xFF, 0xE0));
	m_ctrlGridReviewOffSetInfo.SetRowCount(nRows+1);
	m_ctrlGridReviewOffSetInfo.SetColumnCount(nCols+1);
	m_ctrlGridReviewOffSetInfo.SetFixedRowCount(nFixRows);
	m_ctrlGridReviewOffSetInfo.SetFixedColumnCount(1);

	nMargin = 5;
	nDataColumnWidth = (rect.Width() - nMargin) / 10 +5;

	GV_ITEM Item;

	//첫번째
	Item.mask = GVIF_TEXT;
	Item.row = 0;
	Item.col = 0;
	strTemp.Format(_T(""));
	Item.strText = strTemp;
	m_ctrlGridReviewOffSetInfo.SetItem(&Item);
	m_ctrlGridReviewOffSetInfo.SetColumnWidth(nColIdx, nDataColumnWidth);

	for (int nColIndex = 0; nColIndex < nCols / 2; nColIndex++)
	{
		dGlassXposMax += dGlassXdivideSize;
		nColIdx++;
		Item.row = nRowIdx;
		Item.col = nColIdx;
		strTemp.Format(_T("[%d]X:%.03lf ~ %.03lf"), nColIndex, dGlassXposMin, dGlassXposMax);
		Item.strText = strTemp;
		m_ctrlGridReviewOffSetInfo.SetItem(&Item);

		m_ctrlGridReviewOffSetInfo.SetItemBkColour(nRowIdx, nColIdx, Color[nColIndex]);
		m_ctrlGridReviewOffSetInfo.SetColumnWidth(nColIdx, nDataColumnWidth+20);

		nColIdx++;
		Item.row = nRowIdx;
		Item.col = nColIdx;
		strTemp.Format(_T("[%d]Y:%.03lf~%.03lf"), nColIndex, dGlassXposMin, dGlassXposMax);
		Item.strText = strTemp;
		m_ctrlGridReviewOffSetInfo.SetItem(&Item);
		m_ctrlGridReviewOffSetInfo.SetItemBkColour(nRowIdx, nColIdx, Color[nColIndex]);
		m_ctrlGridReviewOffSetInfo.SetColumnWidth(nColIdx, nDataColumnWidth + 20);

		dGlassXposMin = dGlassXposMax;

	}

	for (int nCam = 0; nCam < m_nCameraCount; nCam++)
	{
		for (int nScan = 0; nScan < m_nScanCount; nScan++)
		{
				nRowIdx++;
				Item.row = nRowIdx;
				Item.col = 0;
				strTemp.Format(_T("Cam[%d]Scan[%d]"), nCam, nScan);
				Item.strText = strTemp;
				m_ctrlGridReviewOffSetInfo.SetItem(&Item);
				m_ctrlGridReviewOffSetInfo.SetColumnWidth(nColIdx, nDataColumnWidth+10);
		}
	}
		
}


void DlgReviewOffSetTool::ApplyOffSetInfo(int nMode)
{

	int nModuleidx = 0;
	double dXoffset;
	double dYoffset;
	int nRow=1;
	int nCol=1;
	CString strData;
	double dXposMin = 0;
	double dXposMax = 0;
	double nGlassSize = 2500;
	double nIncreaseValue = 0;

	nIncreaseValue = 2500.0 /(double)m_XposCount;

	int testdata = 0;

	nModuleidx = m_ctrlComboModule.GetCurSel();

	if (nMode == 1)
	{
		if (nModuleidx == m_nSelectedModule)
		{
			nModuleidx = m_nSelectedModule;
		}
		else
		{
			if (nModuleidx == 0)
			{
				nModuleidx = 1;
			}
			else
			{
				nModuleidx = 0;
			}
		}
		
	}

	for (int nCamidx = 0; nCamidx < m_nCameraCount; nCamidx++)
	{


		for (int nScanidx = 0; nScanidx < m_nScanCount; nScanidx++)
		{

			for (int nXposIndex = 0; nXposIndex < m_XposCount; nXposIndex++)
			{

			strData = m_ctrlGridReviewOffSetInfo.GetItemText(nCol, nRow);
			dXoffset = atof(strData);
			strData = m_ctrlGridReviewOffSetInfo.GetItemText(nCol, nRow+1);
			dYoffset = atof(strData);

			dXposMax += nIncreaseValue; 

			////테스트
			//dXoffset = testdata;
			//testdata += 1;
			//dYoffset = testdata;
			//testdata += 1;

			SetInputOffSet(nModuleidx, nCamidx, nScanidx, nXposIndex, dXoffset, dYoffset, dXposMin, dXposMax);

			dXposMin = dXposMax;
			nRow += 2;

			}
			nRow = 1;
			nCol += 1;
			dXposMin = 0;
			dXposMax = 0;

		}
	}
	
}



bool DlgReviewOffSetTool::ReadConfigFile()
{
	CString strPath = _T("");

	strPath.Format(_T("%s%s"), REVIEW_OFFSET_CONFIGFILE_PATH, REVIEW_OFFSET_CONFIGFILE_NAME);
	return LoadInfo(strPath);
}

bool DlgReviewOffSetTool::ApplyConfigFile()
{
	m_nEditCameraCount= m_nCameraCount;
	m_nEditScanCount=m_nScanCount;
	m_nEditXposCount= m_XposCount;
	CString strPath = _T("");
	strPath.Format(_T("%s%s"), REVIEW_OFFSET_CONFIGFILE_PATH, REVIEW_OFFSET_CONFIGFILE_NAME);
	m_strEditSettingFilePath = strPath;
	m_nReveiwCamCount = 2;
	//UpdateData(FALSE);
	//Invalidate(TRUE);

	PostMessage(WM_OFFSETTOOL_MESSAGE, 100, 200);

	return true;
}

void DlgReviewOffSetTool::SetColorType()
{

	for (int i = 0; i < sizeof(Color); i++)
	{
		if (i == 0) {
			Color[0] = FFA7A7;
		}
		else if (i == 1) {
			Color[1] = FFC19E;
		}
		else if (i == 2) {
			Color[2] = FFE08C;
		}
		else if (i == 3) {
			Color[3] = FAED7D;
		}
		else if (i == 4) {
			Color[4] = FFB2F5;
		}
		else if (i == 5) {
			Color[5] = A566FF;
		}
		else if (i == 6) {
			Color[6] = D9418C;
		}
		else if (i == 7) {
			Color[7] = A00D8FF;
		}
		else if (i == 8) {
			Color[8] = A2F9D27;
		}
		else if (i == 9) {
			Color[9] = A4641D9;
		}

	}

}

bool DlgReviewOffSetTool::SetInputOffSet(int nModuleidx, int nCamIndex, int ScanIndex, int nXposIndex, double dXOffsetValue, double dYOffsetValue, double dXposMin, double dXposMax)
{

	if (nCamIndex > CAM_MAX_COUNT || nCamIndex < 0)
	{
		return FALSE;
	}

	if (ScanIndex > SCAN_MAX_COUNT || ScanIndex < 0)
	{
		return FALSE;
	}


	if (nModuleidx == 0)
	{
		VecOffSetScanData* pScandata = &m_vecOffSetCameraInfo[nCamIndex];
		VecOffSetData* pData = &pScandata->at(ScanIndex);
		OffSetInfo* pOffSetData = &pData->at(nXposIndex);
		pOffSetData->dXoffSetValue = dXOffsetValue;
		pOffSetData->dYoffSetValue = dYOffsetValue;
		pOffSetData->dXposMin = dXposMin;
		pOffSetData->dXposMax = dXposMax;
	}
	else if(nModuleidx ==1)
	{
		VecOffSetScanData* pScandata = &m_vecOffSetCameraInfo2[nCamIndex];
		VecOffSetData* pData = &pScandata->at(ScanIndex);
		OffSetInfo* pOffSetData = &pData->at(nXposIndex);
		pOffSetData->dXoffSetValue = dXOffsetValue;
		pOffSetData->dYoffSetValue = dYOffsetValue;
		pOffSetData->dXposMin = dXposMin;
		pOffSetData->dXposMax = dXposMax;
	}
	else
	{
		return FALSE;
	}

	

}

void DlgReviewOffSetTool::UpdateGridcontrol()
{
	int nModuleidx = 0;
	double dXoffset;
	double dYoffset;
	int nRow = 1;
	int nCol = 1;
	CString strData;
	/*< LYW 20211111 - #3766 ADD Start >*/
	BOOL b_checkHardAlarm = FALSE;
	/*< LYW 20211111 - #3766 ADD End >*/

	nModuleidx = m_ctrlComboModule.GetCurSel();

	for (int nCamidx = 0; nCamidx < m_nCameraCount; nCamidx++)
	{


		for (int nScanidx = 0; nScanidx < m_nScanCount; nScanidx++)
		{

			for (int nXposIndex = 0; nXposIndex < m_XposCount; nXposIndex++)
			{

				OffSetInfo pOffSet =  GetOffSetInfo(nModuleidx, nCamidx, nScanidx, nXposIndex);

				strData.Format(_T("%.03lf"), pOffSet.dXoffSetValue);
				m_ctrlGridReviewOffSetInfo.SetItemText(nCol, nRow,strData);
				/*< LYW 20211111 - #3766 ADD Start >*/
				if (abs(pOffSet.dXoffSetValue) * 1000 >= m_dHardStandard)
				{
					m_ctrlGridReviewOffSetInfo.SetItemBkColour(nCol, nRow, RGB(255, 0, 0));
					b_checkHardAlarm = TRUE;
				}
				else if (abs(pOffSet.dXoffSetValue) * 1000 >= m_dWarnStandard)
				{
					m_ctrlGridReviewOffSetInfo.SetItemBkColour(nCol, nRow, RGB(255, 255, 0));
				}
				else
				{
					m_ctrlGridReviewOffSetInfo.SetItemBkColour(nCol, nRow, RGB(255, 255, 210));
				}
				/*< LYW 20211111 - #3766 ADD End >*/

				strData.Format(_T("%.03lf"), pOffSet.dYoffSetValue);
				m_ctrlGridReviewOffSetInfo.SetItemText( nCol, nRow + 1, strData);
				/*< LYW 20211111 - #3766 ADD Start >*/
				if (abs(pOffSet.dYoffSetValue) * 1000 >= m_dHardStandard)
				{
					m_ctrlGridReviewOffSetInfo.SetItemBkColour(nCol, nRow + 1, RGB(255, 0, 0));
					b_checkHardAlarm = TRUE;
				}
				else if (abs(pOffSet.dYoffSetValue) * 1000 >= m_dWarnStandard)
				{
					m_ctrlGridReviewOffSetInfo.SetItemBkColour(nCol, nRow + 1, RGB(255, 255, 0));
				}
				else
				{
					m_ctrlGridReviewOffSetInfo.SetItemBkColour(nCol, nRow + 1, RGB(255, 255, 210));
				}
				/*< LYW 20211111 - #3766 ADD End >*/
				nRow += 2;
			}
			nRow = 1;
			nCol += 1;

		}
	}

	if (b_checkHardAlarm == TRUE)
	{
		AfxMessageBox(_T("기준 초과된 Offset 값이 존재 합니다."), MB_OK | MB_ICONINFORMATION);
	}
	//UpdateData(FALSE);
	//Invalidate(TRUE);
}

void DlgReviewOffSetTool::InitDataInfo()
{
	//미리 공간 할당
	for (int nCamidx = 0; nCamidx < CAM_MAX_COUNT; nCamidx++)
	{

		VecOffSetScanData pVecScanData;
		for (int nScanidx = 0; nScanidx < SCAN_MAX_COUNT; nScanidx++)
		{
			VecOffSetData     pVecData;
			for (int nXposIndex = 0; nXposIndex < XPOS_MAX_COUNT; nXposIndex++)
			{

				OffSetInfo pInfo;
				pInfo.nXposIndex = nXposIndex;
				pInfo.nScanIndex = nScanidx;
				pInfo.nCamIndex = nCamidx;
				pVecData.push_back(pInfo);

			}
			pVecScanData.push_back(pVecData);

		}

		m_vecOffSetCameraInfo.push_back(pVecScanData);
	}

	for (int nCamidx = 0; nCamidx < CAM_MAX_COUNT; nCamidx++)
	{

		VecOffSetScanData pVecScanData;
		for (int nScanidx = 0; nScanidx < SCAN_MAX_COUNT; nScanidx++)
		{
			VecOffSetData     pVecData;
			for (int nXposIndex = 0; nXposIndex < XPOS_MAX_COUNT; nXposIndex++)
			{

				OffSetInfo pInfo;
				pInfo.nXposIndex = nXposIndex;
				pInfo.nScanIndex = nScanidx;
				pInfo.nCamIndex = nCamidx;
				pVecData.push_back(pInfo);

			}
			pVecScanData.push_back(pVecData);

		}

		m_vecOffSetCameraInfo2.push_back(pVecScanData);
	}
	
}

OffSetInfo DlgReviewOffSetTool::GetOffSetInfo(int nModuleidx, int nCamIndex, int ScanIndex, int nXposIndex)
{

	OffSetInfo pOFF;
	if (nCamIndex > CAM_MAX_COUNT || nCamIndex < 0)
	{
		return pOFF;
	}

	if (ScanIndex > SCAN_MAX_COUNT || ScanIndex < 0)
	{
		return pOFF;
	}


	if (nModuleidx == 0)
	{
		VecOffSetScanData* pScandata = &m_vecOffSetCameraInfo[nCamIndex];
		VecOffSetData* pData = &pScandata->at(ScanIndex);
		OffSetInfo* pOffSetData = &pData->at(nXposIndex);
		
		return *pOffSetData;
	}
	else if (nModuleidx == 1)
	{
		VecOffSetScanData* pScandata = &m_vecOffSetCameraInfo2[nCamIndex];
		VecOffSetData* pData = &pScandata->at(ScanIndex);
		OffSetInfo* pOffSetData = &pData->at(nXposIndex);
		return *pOffSetData;
	}
	else
	{
		return pOFF;
	}

}

void DlgReviewOffSetTool::GetOffSetInfo(int nModuleidx, int nCamIndex, int ScanIndex, double dGlassXPos, double &dXpos, double &dYpos)
{
	OffSetInfo pOFF;
	if (nCamIndex > CAM_MAX_COUNT || nCamIndex < 0)
	{
		dXpos = 0;
		dYpos = 0;
		return ;
	}

	if (ScanIndex > SCAN_MAX_COUNT || ScanIndex < 0)
	{
		dXpos = 0;
		dYpos = 0;
		return ;
	}

	double dMax = 0;
	double dMin = 0;
	if (nModuleidx == 0)
	{
		VecOffSetScanData* pScandata = &m_vecOffSetCameraInfo[nCamIndex];
		VecOffSetData* pData = &pScandata->at(ScanIndex);
		for (int nXposindex = 0; nXposindex < m_XposCount; nXposindex++)
		{
			
			OffSetInfo* pOffSetData = &pData->at(nXposindex);
			dMax = pOffSetData->dXposMax;
			dMin = pOffSetData->dXposMin;
			if (dMax > dGlassXPos && dMin < dGlassXPos)
			{
				dXpos = floor((pOffSetData->dXoffSetValue*1000))/1000.0;
				dYpos = floor((pOffSetData->dYoffSetValue * 1000))/1000.0;
				break;
			}
			
		}
	}
	else if (nModuleidx == 1)
	{
		VecOffSetScanData* pScandata = &m_vecOffSetCameraInfo2[nCamIndex];
		VecOffSetData* pData = &pScandata->at(ScanIndex);
		for (int nXposindex = 0; nXposindex < m_XposCount; nXposindex++)
		{
			
			OffSetInfo* pOffSetData = &pData->at(nXposindex);
			dMax = pOffSetData->dXposMax;
			dMin = pOffSetData->dXposMin;
			if (dMax > dGlassXPos && dMin < dGlassXPos)
			{
				dXpos = floor((pOffSetData->dXoffSetValue * 1000)) / 1000.0;
				dYpos = floor((pOffSetData->dYoffSetValue * 1000)) / 1000.0;
				break;
			}

		}
	
	}
	
}

OffSetInfo* DlgReviewOffSetTool::GetOffSetInfoCBR(int nModuleidx, int nCamIndex, int ScanIndex, int nXposIndex)
{
	OffSetInfo* pOFF;
	if (nCamIndex > CAM_MAX_COUNT || nCamIndex < 0)
	{
		return pOFF;
	}

	if (ScanIndex > SCAN_MAX_COUNT || ScanIndex < 0)
	{
		return pOFF;
	}


	if (nModuleidx == 0)
	{
		VecOffSetScanData* pScandata = &m_vecOffSetCameraInfo[nCamIndex];
		VecOffSetData* pData = &pScandata->at(ScanIndex);
		OffSetInfo* pOffSetData = &pData->at(nXposIndex);

		return pOffSetData;
	}
	else if (nModuleidx == 1)
	{
		VecOffSetScanData* pScandata = &m_vecOffSetCameraInfo2[nCamIndex];
		VecOffSetData* pData = &pScandata->at(ScanIndex);
		OffSetInfo* pOffSetData = &pData->at(nXposIndex);
		return pOffSetData;
	}
	else
	{
		return pOFF;
	}
}


BOOL DlgReviewOffSetTool::SetOffSetValue(int nMoudleidx, int nCamIndex, int ScanIndex, int nXposIndex, double dXOffsetValue, double dYOffsetValue)
{
	if (nMoudleidx == 0)
	{
		VecOffSetScanData* pScandata = &m_vecOffSetCameraInfo[nCamIndex];
		if (pScandata == NULL) return FALSE;
		VecOffSetData* pData = &pScandata->at(ScanIndex);
		if (pData == NULL) return FALSE;
		OffSetInfo* pOffSetData = &pData->at(nXposIndex);
		if (pOffSetData == NULL) return FALSE;

		pOffSetData->dXoffSetValue = dXOffsetValue;
		pOffSetData->dYoffSetValue = dYOffsetValue;
	}
	else if (nMoudleidx == 1)
	{
		VecOffSetScanData* pScandata = &m_vecOffSetCameraInfo2[nCamIndex];
		if (pScandata == NULL) return FALSE;
		VecOffSetData* pData = &pScandata->at(ScanIndex);
		if (pData == NULL) return FALSE;
		OffSetInfo* pOffSetData = &pData->at(nXposIndex);
		if (pOffSetData == NULL) return FALSE;

		pOffSetData->dXoffSetValue = dXOffsetValue;
		pOffSetData->dYoffSetValue = dYOffsetValue;
	}

	return TRUE;
}

BOOL DlgReviewOffSetTool::OnInitDialog()
{
	CDialogEx::OnInitDialog();

	nThreadType = 0;
	m_pThread  = AfxBeginThread(ThradProcess,this);
	return TRUE;  // return TRUE unless you set the focus to a control
				  // 예외: OCX 속성 페이지는 FALSE를 반환해야 합니다.
}


void DlgReviewOffSetTool::InitProcess()
{
	CString strForderPath;
	strForderPath.Format(_T("%s%s"), REVIEW_OFFSET_CONFIGFILE_PATH, REVIEW_OFFSET_BACKUP_FORDER_NAME);
	CreateDirectory(REVIEW_OFFSET_BACKUP_FORDER_PATH, NULL);

	m_ctrlProcessBar.SetRange(0, PROGRESS_BAR_MAX);
	m_ctrlProcessBar.SetPos(0);
	InitModuleCombobox();
	//공간 만들기 
	InitDataInfo();
	ReadConfigFile();
	ApplyConfigFile();
	SetColorType();
	InitOffSetInfoGridControl();
	IncressProcessBar(200);
	// TODO:  여기에 추가 초기화 작업을 추가합니다.
	//ApplyOffSetInfo();
	UpdateGridcontrol();
	IncressProcessBar(200);
	PostMessage(WM_OFFSETTOOL_MESSAGE, 100, 200);
}

void DlgReviewOffSetTool::DissableBT()
{
	m_ctrlComboModule.EnableWindow(FALSE);
	m_ctrlGradAppltbt.EnableWindow(FALSE);
	m_ctrlApplyOffsetParamBt.EnableWindow(FALSE);
	m_ctrlApplyOffsetBt.EnableWindow(FALSE);
	m_ctrlSetTargetMotorBt.EnableWindow(FALSE);
	m_ctrlSetChangeMotorBt.EnableWindow(FALSE);
	m_ctrlSaveBt.EnableWindow(FALSE);
}

void DlgReviewOffSetTool::EnableBT()
{
	m_ctrlComboModule.EnableWindow(TRUE);
	m_ctrlGradAppltbt.EnableWindow(TRUE);
	m_ctrlApplyOffsetParamBt.EnableWindow(TRUE);
	m_ctrlApplyOffsetBt.EnableWindow(TRUE);
	m_ctrlSetTargetMotorBt.EnableWindow(TRUE);
	m_ctrlSetChangeMotorBt.EnableWindow(TRUE);
	m_ctrlSaveBt.EnableWindow(TRUE);
}

void DlgReviewOffSetTool::IncressProcessBar(double dValue)
{
	//dBarValue += dValue;
	m_ctrlProcessBar.OffsetPos(dValue);
}

void DlgReviewOffSetTool::OnBnClickedButtionTargetPos()
{
	// TODO: 여기에 컨트롤 알림 처리기 코드를 추가합니다.
	double dMotorXpos;
	double dMotorYpos;
	int nSelectedModule = m_ctrlComboModule.GetCurSel();

	m_pDDL2P->IDRO2P_GetMotorPos(nSelectedModule, dMotorXpos, dMotorYpos);
	m_EditTargetXpos = floor(1000.*dMotorXpos) / 1000;
	m_EditTargetYpos = floor(1000.*dMotorYpos) / 1000;

	m_EditOffSetValueX = m_EditTargetXpos - m_EditChangeTargetXpos;
	m_EditOffSetValueY = m_EditTargetYpos - m_EditChangeTargetYpos;

	ApplyToEditOffSetValue();

	UpdateData(FALSE);
	Invalidate(TRUE);
}


void DlgReviewOffSetTool::OnBnClickedButtionCahngeTargetPos()
{
	// TODO: 여기에 컨트롤 알림 처리기 코드를 추가합니다.
	double dMotorXpos;
	double dMotorYpos;
	int nSelectedModule = m_ctrlComboModule.GetCurSel();
	
	m_pDDL2P->IDRO2P_GetMotorPos(nSelectedModule, dMotorXpos, dMotorYpos);
	m_EditChangeTargetXpos = floor(1000.*dMotorXpos) / 1000;
	m_EditChangeTargetYpos = floor(1000.*dMotorYpos) / 1000;

	ApplyToEditOffSetValue();

	UpdateData(FALSE);
	Invalidate(TRUE);



}

void DlgReviewOffSetTool::OnGridSelChanged(NMHDR* pNMHDR, LRESULT* pResult)
{
	NM_GRIDVIEW *pItem = (NM_GRIDVIEW *)pNMHDR;

	*pResult = 0;

	 m_SelectedCellCol = pItem->iRow;

	 m_SelectedCellRow = pItem->iColumn;
}


void DlgReviewOffSetTool::ApplyToEditOffSetValue()
{
	double dXTemp = 0;
	double dYTemp = 0;
	dXTemp  = m_EditTargetXpos - m_EditChangeTargetXpos;
	dYTemp  = m_EditTargetYpos - m_EditChangeTargetYpos;

	dXTemp = (dXTemp * -1) *1000;
	dYTemp = (dYTemp * -1) *1000;

	m_EditOffSetValueX = dXTemp/1000.0;
	m_EditOffSetValueY = dYTemp/1000.0;
	//dXTemp = dXTemp

//	m_EditOffSetValueX = floor(((1000.0*(m_EditTargetXpos - m_EditChangeTargetXpos)*-1)) / 1000);
	//m_EditOffSetValueY = floor(((1000.0*(m_EditTargetYpos - m_EditChangeTargetYpos)*-1)) / 1000);
		
}

void DlgReviewOffSetTool::OnBnClickedButtonAppltOffset()
{
	// TODO: 여기에 컨트롤 알림 처리기 코드를 추가합니다.

	UpdateData(TRUE);
	int nRow, nCol;
	nRow = m_SelectedCellRow;
	nCol = m_SelectedCellCol;
	if (nRow == 0 || nCol==0)
	{
		return;
	}

	if (nRow % 2 == 0)
	{
		nRow -= 1;
	}

	CString strValue;

	strValue.Format(_T("%03lf"), m_EditOffSetValueX);
	m_ctrlGridReviewOffSetInfo.SetItemText(nCol, nRow, strValue);


	strValue.Format(_T("%03lf"), m_EditOffSetValueY);
	m_ctrlGridReviewOffSetInfo.SetItemText(nCol, nRow + 1,strValue);
	
	Invalidate(FALSE);
}


void DlgReviewOffSetTool::OnEnChangeEditReviewCamcount()
{
	// TODO:  RICHEDIT 컨트롤인 경우, 이 컨트롤은
	// CDialogEx::OnInitDialog() 함수를 재지정 
	//하고 마스크에 OR 연산하여 설정된 ENM_CHANGE 플래그를 지정하여 CRichEditCtrl().SetEventMask()를 호출하지 않으면
	// 이 알림 메시지를 보내지 않습니다.

	// TODO:  여기에 컨트롤 알림 처리기 코드를 추가합니다.
}


void DlgReviewOffSetTool::OnEnChangeEditScanCount()
{
	// TODO:  RICHEDIT 컨트롤인 경우, 이 컨트롤은
	// CDialogEx::OnInitDialog() 함수를 재지정 
	//하고 마스크에 OR 연산하여 설정된 ENM_CHANGE 플래그를 지정하여 CRichEditCtrl().SetEventMask()를 호출하지 않으면
	// 이 알림 메시지를 보내지 않습니다.

	// TODO:  여기에 컨트롤 알림 처리기 코드를 추가합니다.
}

 
UINT DlgReviewOffSetTool::ThradProcess(LPVOID param)
{

	DlgReviewOffSetTool  * pDlgOffsetTool= (DlgReviewOffSetTool*)param;
	if (pDlgOffsetTool->nThreadType==0)
	{
		pDlgOffsetTool->DissableBT();
		pDlgOffsetTool->InitProcess();
		pDlgOffsetTool->EnableBT();
	}
	else if(pDlgOffsetTool->nThreadType == 1)
	{
		pDlgOffsetTool->DissableBT();
		pDlgOffsetTool->SaveConfigFile();
		pDlgOffsetTool->EnableBT();
	}
	else
	{
		pDlgOffsetTool->DissableBT();
		pDlgOffsetTool->OffsetLoad();
		pDlgOffsetTool->EnableBT();
	}
	return 0;
}

void DlgReviewOffSetTool::OnBnClickedButtonApplyGridData()
{
	// TODO: 여기에 컨트롤 알림 처리기 코드를 추가합니다.
	ApplyOffSetInfo();
	UpdateGridcontrol();
	UpdateData(TRUE);
	
	
}


void DlgReviewOffSetTool::OnCbnSelchangeComboSelectModule()
{
	
	// TODO: 여기에 컨트롤 알림 처리기 코드를 추가합니다.
	ApplyOffSetInfo(1);	
	UpdateGridcontrol();
	UpdateData(FALSE);
	Invalidate(TRUE);
	m_nSelectedModule = m_ctrlComboModule.GetCurSel();
}



BOOL DlgReviewOffSetTool::LoadInfo(CString strFilePath)
{
	dBarValue = 0;
	CMacroFile macroFile;

	if (!macroFile.Read(strFilePath))
		return FALSE;

	macroFile.GetItem(_T("CAMERA_COUNT"),m_nCameraCount , 0);
	macroFile.GetItem(_T("SCAN_COUNT"), m_nScanCount, 0);
	macroFile.GetItem(_T("XPOS_COUNT"), m_XposCount, 0);
	/*< LYW 20211111 - #3766 ADD Start >*/
	macroFile.GetItem(_T("WARN_STANDARD"), m_dWarnStandard, 0);
	macroFile.GetItem(_T("HARD_STANDARD"), m_dHardStandard, 0);
	/*< LYW 20211111 - #3766 ADD End >*/
	CString strItem = _T("");
	double dXoffset=0;
	double dYoffset=0;
	double dXMin=0;
	double dXMAX=0;

	double dValue = 0;
	dValue = 2 * CAM_MAX_COUNT*SCAN_MAX_COUNT;
	dValue = 1600 / dValue;

	for (int nModuleidx = 0; nModuleidx < 2; nModuleidx++)
	{
		for (int nCamidx = 0; nCamidx < CAM_MAX_COUNT; nCamidx++)
		{
			for (int nScanidx = 0; nScanidx < SCAN_MAX_COUNT; nScanidx++)
			{

				for (int nXposIndex = 0; nXposIndex < XPOS_MAX_COUNT; nXposIndex++)
				{

					strItem.Format(_T("MODULE[%d]_CAM[%d]_SCAN[%d]_IDX[%d]_OFFSET_X"), nModuleidx, nCamidx, nScanidx, nXposIndex);
					macroFile.GetItem(strItem, dXoffset);
					

					strItem.Format(_T("MODULE[%d]_CAM[%d]_SCAN[%d]_IDX[%d]_OFFSET_Y"), nModuleidx, nCamidx, nScanidx, nXposIndex);
					macroFile.GetItem(strItem, dYoffset);

					strItem.Format(_T("MODULE[%d]_CAM[%d]_SCAN[%d]_IDX[%d]_XPOS_X_MIN"), nModuleidx, nCamidx, nScanidx, nXposIndex);
					macroFile.GetItem(strItem, dXMin);

					strItem.Format(_T("MODULE[%d]_CAM[%d]_SCAN[%d]_IDX[%d]_XPOS_X_MAN"), nModuleidx, nCamidx, nScanidx, nXposIndex);
					macroFile.GetItem(strItem, dXMAX);

					SetInputOffSet(nModuleidx, nCamidx, nScanidx, nXposIndex, dXoffset, dYoffset, dXMin, dXMAX);

				}
				IncressProcessBar(dValue);
			}
		}
	}

	return TRUE;
}

bool DlgReviewOffSetTool::SaveConfigFile()
{
	//UpdateData(TRUE);

	dBarValue = 0;

	CString strForderPath;
	CString strFileName;
	CTime time = CTime::GetCurrentTime();
	strFileName.Format(_T("ReviewOffSet_%04d%02d%02d%02d%02d%02d.cfg"),time.GetYear(), time.GetMonth(), time.GetDay(), time.GetHour(), time.GetMinute(), time.GetSecond());
	strForderPath.Format(_T("%s%s"), REVIEW_OFFSET_BACKUP_FORDER_PATH, strFileName);

	CopyFile(REVIEW_OFFSET_CONFIGFILE_FULL_PATHNAME, strForderPath,FALSE);

	BOOL bReturn = FALSE;
	CString strTemp;
	int nTemp;
	double dTemp;

	CMacroFile macroFile;
	macroFile.Clear();

	CString strItem = _T("");


	strItem.Format(_T("CAMERA_COUNT"));
	macroFile.SetItem(strItem, m_nCameraCount);

	strItem.Format(_T("SCAN_COUNT"));
	macroFile.SetItem(strItem, m_nScanCount);

	strItem.Format(_T("XPOS_COUNT"));
	macroFile.SetItem(strItem, m_XposCount);

	/*< LYW 20211111 - #3766 ADD Start >*/
	strItem.Format(_T("WARN_STANDARD"));
	macroFile.SetItem(strItem, m_dWarnStandard);

	strItem.Format(_T("HARD_STANDARD"));
	macroFile.SetItem(strItem, m_dHardStandard);
	/*< LYW 20211111 - #3766 ADD End >*/

	
	CString strData;
	double dData= 0;
	for (int nModuleidx = 0; nModuleidx<2; nModuleidx++)
	{
		for (int nCamidx = 0; nCamidx < CAM_MAX_COUNT; nCamidx++)
		{
			for (int nScanidx = 0; nScanidx < SCAN_MAX_COUNT; nScanidx++)
			{

				for (int nXposIndex = 0; nXposIndex < XPOS_MAX_COUNT; nXposIndex++)
				{

					OffSetInfo pOffSet = GetOffSetInfo(nModuleidx, nCamidx, nScanidx, nXposIndex);

					strItem.Format(_T("MODULE[%d]_CAM[%d]_SCAN[%d]_IDX[%d]_OFFSET_X"), nModuleidx, nCamidx, nScanidx);
					dData = pOffSet.dXoffSetValue;
					macroFile.SetItem(strItem, dData);

					strItem.Format(_T("MODULE[%d]_CAM[%d]_SCAN[%d]_IDX[%d]_OFFSET_Y"), nModuleidx, nCamidx, nScanidx);
					dData = pOffSet.dYoffSetValue;
					macroFile.SetItem(strItem, dData);

					strItem.Format(_T("MODULE[%d]_CAM[%d]_SCAN[%d]_IDX[%d]_XPOS_X_MIN"), nModuleidx, nCamidx, nScanidx);
					dData = pOffSet.dXposMin;
					macroFile.SetItem(strItem, dData);

					strItem.Format(_T("MODULE[%d]_CAM[%d]_SCAN[%d]_IDX[%d]_XPOS_X_MAN"), nModuleidx, nCamidx, nScanidx);
					dData = pOffSet.dXposMax;
					macroFile.SetItem(strItem, dData);
				}
				IncressProcessBar(5);
			}
		}
	}
	
	CString strFilePath;
	strFilePath.Format(_T("%s%s"),REVIEW_OFFSET_CONFIGFILE_PATH , REVIEW_OFFSET_CONFIGFILE_NAME);

	bReturn = macroFile.Write(strFilePath);

	/*< LYW 20220525 - #4161 ADD Start >*/
	CString strRTMSBackUpFilePath;
	strRTMSBackUpFilePath.Format(_T("%s\\%s"), _REVIEW_SERVER_SYSTEM_SETTING_BACKUP_PATH_CPJT, REVIEW_OFFSET_CONFIGFILE_NAME);

	if (bReturn)
	{
		CopyFile(REVIEW_OFFSET_CONFIGFILE_FULL_PATHNAME, strRTMSBackUpFilePath, FALSE);
	}
	/*< LYW 20220525 - #4161 ADD End >*/

	// #3563 LYW_ CF AOI Review Offset 파라미터 저장시 완료 팝업 추가 ADD START
	CString strMessage;
	strMessage.Format(_T("Save Offset Success!!"));

	if (IDOK == AfxMessageBox(strMessage, MB_OK | MB_ICONINFORMATION))
	{
		g_pLog->DisplayMessage(_T("Save Offset Success!!"));
	}
	// #3563 LYW_ CF AOI Review Offset 파라미터 저장시 완료 팝업 추가 ADD END
	/*< LYW 20211111 - #3766 ADD Start >*/
	UpdateGridcontrol();
	UpdateData(TRUE);
	Invalidate(FALSE);
	/*< LYW 20211111 - #3766 ADD End >*/

	return bReturn;
}



void DlgReviewOffSetTool::OnBnClickedButtonAppltOffsetParam()
{
	// TODO: 여기에 컨트롤 알림 처리기 코드를 추가합니다.
	UpdateData(TRUE);
	m_nCameraCount= m_nEditCameraCount;
	  m_nScanCount = m_nEditScanCount;
	  m_XposCount = m_nEditXposCount;

	  InitOffSetInfoGridControl();
	  UpdateGridcontrol();

	  UpdateData(FALSE);
	  Invalidate(TRUE);
}

LRESULT DlgReviewOffSetTool::OnUserFunc(WPARAM wParam, LPARAM lParam)
{
	int nmsg = (int)wParam;
	if (nmsg == 0)
	{
		nThreadType = 2;
		m_ctrlProcessBar.SetPos(0);
		m_pThread = AfxBeginThread(ThradProcess, this);
		return 0;
	}
	UpdateData(FALSE);
	Invalidate(TRUE);
	return 0;
}

LRESULT DlgReviewOffSetTool::OnUpdatedata(WPARAM wParam, LPARAM lParam)
{
	UpdateData(TRUE);
	Invalidate(TRUE);
	return 0;
}


void DlgReviewOffSetTool::OnBnClickedButtonSaveSettingFile()
{
	// TODO: 여기에 컨트롤 알림 처리기 코드를 추가합니다.
	UpdateData(TRUE);
	nThreadType = 1;
	m_ctrlProcessBar.SetPos(0);
	m_pThread = AfxBeginThread(ThradProcess, this);
}


void DlgReviewOffSetTool::OnBnClickedCheckOffsetMode()
{
	// TODO: 여기에 컨트롤 알림 처리기 코드를 추가합니다.
	UpdateData(FALSE);
	
	// m_pDDL2P->IDRO2P_SetGlassMode(m_ctrlOffSetMode.GetCheck(), m_editGlassOffSetmodeCamIndex, m_editGlassOffSetmodeScanIndex, m_editGlassOffSetmodeXpos*1000, m_editGlassOffSetmodeYpos*1000);
	 
	
}

/*< LYW 20211025 - #3684 ADD Start >*/
void DlgReviewOffSetTool::OnBnClickedOffsetLoad()
{
	// TODO: 여기에 컨트롤 알림 처리기 코드를 추가합니다.
	nThreadType = 2;
	m_ctrlProcessBar.SetPos(0);
	m_pThread = AfxBeginThread(ThradProcess, this);
}
void DlgReviewOffSetTool::OffsetLoad()
{
	ReadConfigFile();
	UpdateGridcontrol();
	UpdateData(TRUE);
	Invalidate(FALSE);
}
/*< LYW 20211025 - #3684 ADD End >*/


BOOL DlgReviewOffSetTool::OnNotify(WPARAM wParam, LPARAM lParam, LRESULT* pResult)
{
	// TODO: 여기에 특수화된 코드를 추가 및/또는 기본 클래스를 호출합니다.
	if (m_ctrlGridReviewOffSetInfo.GetSafeHwnd() && wParam == (WPARAM)m_ctrlGridReviewOffSetInfo.GetDlgCtrlID())
	{
		//*pResult = 1;
		GV_DISPINFO *pDispInfo = (GV_DISPINFO*)lParam;
		if (NM_DBLCLK == pDispInfo->hdr.code)
		{
			//int nCol = pDispInfo->item.col;
			if (pDispInfo->item.row)
			{
				int nRow = (pDispInfo->item.row) - 1;
				int CamIdx = nRow / m_nScanCount;
				int scanIdx = nRow % m_nScanCount;

				if (m_pDDL2P)
				{
					m_pDDL2P->IDRO2P_SetOffsetPram(CamIdx, scanIdx, TRUE);
				}

			}
		}
	}

	return CDialogEx::OnNotify(wParam, lParam, pResult);
}