#include "StdAfx.h"
#include "ReviewData.h"

#include "CHReviewSetting/SystemManager.h"
#include "CHReviewRecipe/RsRecipeManager.h"
#include "CHResultFileManager/ResultFileManager.h"
#include "CHReviewResultParser/ParsingGlassResult.h"
#include "CHResultFileManager/ResultFileManager_CPJT.h"
#include "CHReviewResultParser/ParsingGlassResult_CPJT.h"
#include "CHReviewResultParser/ParsingGlassResult_Simulation.h"

#include "CHReviewSetting/Sys_SystemManager.h"
#include "CHReviewSetting/Sys_GlassTypeManager.h"
#include "CHReviewSetting/Sys_AlignManager.h"
#include "CHReviewSetting/Sys_SignalManager.h"
#include "CHReviewSetting/Sys_MotorManager.h"
#include "CHReviewSetting/Sys_NetworkManager.h"

#include "CHReviewRecipe/RsRecipeManager.h"
#include "CHReviewRecipe/Rcp_RsReviewManager.h"
#include "CHReviewRecipe/Rcp_RsMeasureManager.h"
#include "CHReviewRecipe/Rcp_RsAlignManager.h"
#include "CHReviewRecipe/Rcp_RsDefectFindManager.h"
#include "CHReviewRecipe/Rcp_RsGlassTypeInfoManager.h"

#include "ModuleStatus.h"
#include "ConnectionStatus.h"

#include "DitGlassRawClient.h"

using namespace CHReviewResult;

int GetDefectType(const CString& strValue)
{
	if (strValue.Compare(_T("BD"))==0)
	{
		return DEFECT_TYPE_BD;	//3
	}
	else if (strValue.Compare(_T("B"))==0)
	{
		return DEFECT_TYPE_B;	//2
	}
	else if (strValue.Compare(_T("D"))==0)
	{
		return DEFECT_TYPE_D;	//1
	}
	else if (strValue.Compare(_T("PBD"))==0)
	{
		return DEFECT_TYPE_PBD;	//3
	}
	else if (strValue.Compare(_T("PB"))==0)
	{
		return DEFECT_TYPE_PB;	//2
	}
	else if (strValue.Compare(_T("PD"))==0)
	{
		return DEFECT_TYPE_PD;	//1
	}
	else if (strValue.Compare(_T("MNT"))==0)
	{
		return DEFECT_TYPE_MNT;
	}
	else if (strValue.Compare(_T("EC"))==0)
	{
		return DEFECT_TYPE_EC;
	}
	else if (strValue.Compare(_T("MURA"))==0)
	{
		return DEFECT_TYPE_MURA;
	}

	return 0;
}

int GetGrayType(const CString& strValue)
{
	if (strValue == "POSI")		return DEFECT_GRAY_WHITE;
	else						return DEFECT_GRAY_BLACK;

	return DEFECT_GRAY_NONE;
}

int GetProcessType(const CString& strValue)
{
	if (strValue == "M")		return DEFECT_PROCESS_MASK;
	else if (strValue == "C")	return DEFECT_PROCESS_COMMON;
	else if (strValue == "K")	return DEFECT_PROCESS_CRACK;
	else						return DEFECT_PROCESS_NORMAL;

	return DEFECT_PROCESS_NONE;
}

int GetSizeType(const CString& strValue)
{
	if (strValue == "S")		return DEFECT_SIZE_SMALL;
	else if (strValue == "M")	return DEFECT_SIZE_MEDIUM;
	else if (strValue == "L")	return DEFECT_SIZE_LARGE;
	else						return DEFECT_SIZE_HUGE;
	return DEFECT_SIZE_NONE;
}

int GetStackType(const CString& strValue)
{
	if (strValue == "TD")		return DEFECT_STACK_TD;
	else if (strValue == "SD")	return DEFECT_STACK_SD;
	else if (strValue == "PD")	return DEFECT_STACK_PD;
	else						return DEFECT_STACK_SP;

	return DEFECT_STACK_NONE;
}

int GetJudgeType(const CString& strValue)
{
	if (strValue == "R")		return DEFECT_JUDGE_TR;
	else if (strValue == "X")	return DEFECT_JUDGE_PR;
	else if (strValue == "W")	return DEFECT_JUDGE_PR;
	else						return DEFECT_JUDGE_OK;

	return DEFECT_JUDGE_NONE;	
}

int GetOpticType(int nDefectType)
{
	if (nDefectType==DEFECT_TYPE_BD || nDefectType==DEFECT_TYPE_PBD)
	{
		return DEFECT_OPTIC_DKBR;
	}
	else if (nDefectType==DEFECT_TYPE_D || nDefectType==DEFECT_TYPE_PD)
	{
		return DEFECT_OPTIC_DARK;
	}
	else if (nDefectType==DEFECT_TYPE_B || nDefectType==DEFECT_TYPE_PB)
	{
		return DEFECT_OPTIC_BRIGHT;
	}

	return 0;
}


CReviewData::CReviewData(void)
{
	// system
	m_pSystemManager			= NULL;
	m_pRsRecipeManager			= NULL;

	// glass
	m_nTotalGlassResultCount	= 0;
	m_nCurGlassResultIndex		= 0;
	m_pCurGlassResult			= NULL;
	m_vecGlassResult.reserve(MAX_GLASS_RESULT_SIZE);

	m_nTotalHistoryResultCount = 0;
	m_nCurHistoryResultIndex = 0;
	m_pCurGlassResult = NULL;
	m_vecHistoryResult.reserve(MAX_GLASS_RESULT_SIZE);

	// resfule file
	m_pResultFileManager		= NULL;		
	m_pResultFileManagerCD		= NULL;
	m_pResultFileManagerSD		= NULL;

	m_pResultFileManagerMeasure = NULL; //Add by Juneki 2016-03-01

	m_pResultFileParser			= NULL;
	m_pResultFileParserCD		= NULL;
	m_pResultFileParserSD		= NULL;

	m_pResultFileParserMeasure  = NULL; //Add by Juneki 2016-03-01


	// etc variable
	m_pDefectFilter	= new SDefectFilter;				// Defect Filter
	m_pSignalIOStatus = new SSignalIOStatus;			// Signal IO Status
	m_pTransferData = new STransferData;				// transfer data
	m_pConnectionStatus = new CConnectionStatus;		// connection status

	InitializeCriticalSection(&m_csReviewData);	// critical section initialize
}

CReviewData::~CReviewData(void)
{
	// system
	if(m_pSystemManager)
	{
		delete m_pSystemManager;
		m_pSystemManager = NULL;
	}

	// recipe
	if(m_pRsRecipeManager)
	{
		delete m_pRsRecipeManager;
		m_pRsRecipeManager = NULL;
	}

	// glass
	int i, nGlassResultCount;
	nGlassResultCount = (int)m_vecGlassResult.size();
	for(i = 0; i < nGlassResultCount; i++)
	{
		CGlassResult* pGlassResult;
		pGlassResult = m_vecGlassResult[i];
		delete pGlassResult;
	}
	m_vecGlassResult.clear();

	// result
	if (m_pResultFileManager)
	{
		delete m_pResultFileManager;
		m_pResultFileManager = NULL;
	}

	if (m_pResultFileManagerCD)
	{
		delete m_pResultFileManagerCD;
		m_pResultFileManagerCD = NULL;
	}

	if (m_pResultFileManagerSD)
	{
		delete m_pResultFileManagerSD;
		m_pResultFileManagerSD = NULL;
	}

	if(m_pResultFileParserMeasure)
	{
		delete m_pResultFileParserMeasure;
		m_pResultFileParserMeasure = NULL;
	}

	if(m_pResultFileParser)
	{
		delete m_pResultFileParser;
		m_pResultFileParser = NULL;
	}

	if(m_pResultFileParserCD)
	{
		delete m_pResultFileParserCD;
		m_pResultFileParserCD = NULL;
	}

	if(m_pResultFileParserSD)
	{
		delete m_pResultFileParserSD;
		m_pResultFileParserSD = NULL;
	}

	if(m_pResultFileParserMeasure)
	{
		delete m_pResultFileParserMeasure;
		m_pResultFileParserMeasure = NULL;
	}

	// etc variable
	if (m_pDefectFilter) 
	{
		delete m_pDefectFilter;
		m_pDefectFilter = NULL;
	}

	if (m_pSignalIOStatus) 
	{
		delete m_pSignalIOStatus;
		m_pSignalIOStatus = NULL;
	}

	if (m_pTransferData) 
	{
		delete m_pTransferData;
		m_pTransferData = NULL;
	}

	if (m_pConnectionStatus) 
	{
		delete m_pConnectionStatus;
		m_pConnectionStatus = NULL;
	}

	DeleteCriticalSection(&m_csReviewData); // delete critical section
}

BOOL CReviewData::InitReviewData()
{
	// system
	m_pSystemManager = new CSystemManager();
	if (m_pSystemManager->ReadSystemConfigFile(_REVIEW_SERVER_SYSTEM_SETTING_FILE_PATH_)==FALSE)
	{
		return FALSE;
	}

	m_pRsRecipeManager = new CRsRecipeManager();
	if (m_pRsRecipeManager)
	{
		m_pRsRecipeManager->SetRecipdFilePath(_REVIEW_RECIPE_PATH_);
	}

	// glass
	m_nTotalGlassResultCount		= 0;
	m_nCurGlassResultIndex			= 0;
	m_pCurGlassResult				= NULL;
	m_vecGlassResult.reserve(MAX_GLASS_RESULT_SIZE);

	m_nTotalHistoryResultCount = 0;
	m_nCurHistoryResultIndex = 0;
	m_pCurHistoryResult = NULL;
	m_vecHistoryResult.reserve(MAX_GLASS_RESULT_SIZE);

	// result file init
	InitResultPointer();

	return TRUE;
}

void CReviewData::InitResultPointer()
{
	CSystemInfo *pSystemInfo = m_pSystemManager->GetSysSystemManager()->GetSystemInfo();

	if (pSystemInfo == NULL) return;
	
	int nLineType	= pSystemInfo->m_nLineType;
	int nMachine	= pSystemInfo->m_nMachineType;
	
	switch(nLineType) 
	{
		case SystemLine_CPJT:
			switch(nMachine)
			{
			case SystemMachine_CPJT_QD:
				m_pResultFileManager	= new CResultFileManager_CPJT;		
				m_pResultFileManagerCD	= new CResultFileManager_CPJT;
				m_pResultFileManagerSD	= new CResultFileManager_CPJT;

				m_pResultFileParser		= new CParsingGlassResult_CPJT;
				m_pResultFileParserCD	= new CParsingGlassResult_CPJT;
				m_pResultFileParserSD	= new CParsingGlassResult_CPJT;
				break;

			case SystemMachine_CPJT_RGB:
				m_pResultFileManager	= new CResultFileManager_CPJT;		
				m_pResultFileManagerCD	= new CResultFileManager_CPJT;
				m_pResultFileManagerSD	= new CResultFileManager_CPJT;

				m_pResultFileParser		= new CParsingGlassResult_CPJT;
				m_pResultFileParserCD	= new CParsingGlassResult_CPJT;
				m_pResultFileParserSD	= new CParsingGlassResult_CPJT;
				break;

			case SystemMachine_CPJT_BANK:
				m_pResultFileManager	= new CResultFileManager_CPJT;		
				m_pResultFileManagerCD	= new CResultFileManager_CPJT;
				m_pResultFileManagerSD	= new CResultFileManager_CPJT;

				m_pResultFileParser		= new CParsingGlassResult_CPJT;
				m_pResultFileParserCD	= new CParsingGlassResult_CPJT;
				m_pResultFileParserSD	= new CParsingGlassResult_CPJT;
				break;

			case SystemMachine_CPJT_OC:
				m_pResultFileManager	= new CResultFileManager_CPJT;		
				m_pResultFileManagerCD	= new CResultFileManager_CPJT;
				m_pResultFileManagerSD	= new CResultFileManager_CPJT;

				m_pResultFileParser		= new CParsingGlassResult_CPJT;
				m_pResultFileParserCD	= new CParsingGlassResult_CPJT;
				m_pResultFileParserSD	= new CParsingGlassResult_CPJT;
				break;

			case SystemMachine_CPJT_BDI:
				m_pResultFileManager	= new CResultFileManager_CPJT;		
				m_pResultFileManagerCD	= new CResultFileManager_CPJT;
				m_pResultFileManagerSD	= new CResultFileManager_CPJT;

				m_pResultFileParser		= new CParsingGlassResult_CPJT;
				m_pResultFileParserCD	= new CParsingGlassResult_CPJT;
				m_pResultFileParserSD	= new CParsingGlassResult_CPJT;
				break;

			case SystemMachine_CPJT_CS:
				m_pResultFileManager	= new CResultFileManager_CPJT;		
				m_pResultFileManagerCD	= new CResultFileManager_CPJT;
				m_pResultFileManagerSD	= new CResultFileManager_CPJT;

				m_pResultFileParser		= new CParsingGlassResult_CPJT;
				m_pResultFileParserCD	= new CParsingGlassResult_CPJT;
				m_pResultFileParserSD	= new CParsingGlassResult_CPJT;
				break;
		default:
			break;
		}
		break;
	}
}

BOOL CReviewData::Recipe_WriteRecipeFile()
{
	if (m_pRsRecipeManager==NULL) return FALSE;

	return m_pRsRecipeManager->WriteRecipeFile();
}

BOOL CReviewData::Recipe_ReadRecipeFile(const CString& strPPID_RC, CString& strRecipeName/*const CString& strPPID, CString& strRecipeName*/)
{
	if(m_pRsRecipeManager == NULL) return FALSE;

	m_pRsRecipeManager->SetRecipeReadStatus(RCP_READ_STATUS_NONE);

	strRecipeName = _T("");

	// find recipe file	
	if(Recipe_FindRecipeFile(strPPID_RC, strRecipeName) == FALSE)
	{
		strRecipeName.Format(_T("Default"));
	}

	// read recipe file
	if(m_pRsRecipeManager->ReadRecipeFile(strRecipeName) == FALSE)
	{
		m_pRsRecipeManager->SetRecipeReadStatus(RCP_READ_STATUS_FAIL);
		return FALSE;
	}

	m_pRsRecipeManager->SetRecipeReadStatus(RCP_READ_STATUS_SUCCESS);

	return TRUE;

}

BOOL CReviewData::Recipe_FindRecipeFile(const CString& strPPID_RC, CString& strRecipeName/*const CString& strPPID, CString& strRecipeName*/)
{
	BOOL bRet = FALSE, bFind;
	CFileFind finder;
	CString strSearchPath;

	//if(strPPID.IsEmpty() == TRUE) return bRet;
	if(strPPID_RC.IsEmpty() == TRUE) return bRet;

	//strSearchPath.Format(_T("%s\\*%s.rcp"), _REVIEW_RECIPE_PATH_, strPPID);
	strSearchPath.Format(_T("%s\\*%s.rcp"), _REVIEW_RECIPE_PATH_, strPPID_RC);

	bFind = finder.FindFile(strSearchPath);

	while(bFind)
	{
		bFind = finder.FindNextFile();

		if(finder.IsDots()) continue;
		if(finder.IsDirectory()) continue;

		strRecipeName = finder.GetFileTitle();
		bRet = TRUE;
		break;
	}

	finder.Close();

	return bRet;
}

BOOL CReviewData::System_ReadSettingValue()						
{
	if(m_pSystemManager==NULL) return FALSE;

	return m_pSystemManager->ReadSystemConfigFile(_REVIEW_SERVER_SYSTEM_SETTING_FILE_PATH_);
}

int CReviewData::PGR2P_GetModuleCount()
{
	const CSystemInfo *pSystemInfo = System_GetSystemInfo();
	if(pSystemInfo == NULL) return 0;

	int nModuleIdx = 0;

	// Gantry
	for (int nGantryIdx=0; nGantryIdx<pSystemInfo->GetGantryInfoCount(); nGantryIdx++)
	{
		const CGantryInfo* pGantryInfo = pSystemInfo->GetGantryInfo(nGantryIdx);
		if (pGantryInfo==NULL) continue;
		// Header
		for (int nHeaderIdx=0; nHeaderIdx<pGantryInfo->GetHeaderInfoCount(); nHeaderIdx++)
		{
			const CHeaderInfo* pHeaderInfo = pGantryInfo->GetHeaderInfo(nHeaderIdx);
			if(pHeaderInfo == NULL) continue ;

			nModuleIdx++;
		}
	}

	return nModuleIdx;
}

// system manager
const CSystemManager* CReviewData::GetSystemManager() const					
{ 
	return m_pSystemManager; 
}

const CSys_SystemManager* CReviewData::System_GetSysSystemManager() const			
{ 
	return (m_pSystemManager==NULL) ? NULL: m_pSystemManager->GetSysSystemManager(); 
}

const CSys_GlassTypeManager* CReviewData::System_GetSysGlassTypeManager() const		
{ 
	return (m_pSystemManager==NULL) ? NULL: m_pSystemManager->GetSysGlassTypeManager(); 
}

const CSys_AlignManager* CReviewData::System_GetSysAlignManager() const			
{ 
	return (m_pSystemManager==NULL) ? NULL: m_pSystemManager->GetSysAlignManager(); 
}

const CSys_SignalManager* CReviewData::System_GetSysPCControlManager() const				
{
	return (m_pSystemManager==NULL) ? NULL: m_pSystemManager->GetSysSignalManager(); 
}

const CSys_MotorManager* CReviewData::System_GetSysMotorManager() const			
{ 
	return (m_pSystemManager==NULL) ? NULL: m_pSystemManager->GetSysMotorManager(); 
}

const CSys_NetworkManager* CReviewData::System_GetSysNetworkManager() const		
{ 
	return (m_pSystemManager==NULL) ? NULL: m_pSystemManager->GetSysNetworkManager(); 
}

// recipe manager
CRsRecipeManager* CReviewData::Recipe_GetRsRecipeManager() 				
{ 
	return m_pRsRecipeManager; 
}

CRcp_RsReviewManager* CReviewData::Recipe_GetRcpRsReviewManager() 				
{ 
	return (m_pRsRecipeManager==NULL) ? NULL: m_pRsRecipeManager->GetRcpRsReviewManager(); 
}

CRcp_RsMeasureManager* CReviewData::Recipe_GetRcpRsMeasureManager() 		
{ 
	return (m_pRsRecipeManager==NULL) ? NULL: m_pRsRecipeManager->GetRcpRsMeasureManager(); 
}

CRcp_RsAlignManager* CReviewData::Recipe_GetRcpRsAlignManager() 			
{ 
	return (m_pRsRecipeManager==NULL) ? NULL: m_pRsRecipeManager->GetRcpRsAlignManager(); 
}

CRcp_RsDefectFindManager* CReviewData::Recipe_GetRcpRsDefectFindManager() 			
{ 
	return (m_pRsRecipeManager==NULL) ? NULL: m_pRsRecipeManager->GetRcpRsDefectFindManager(); 
}

CRcp_RsGlassTypeInfoManager* CReviewData::Recipe_GetRcpRsGlassTypeInfoManager()
{
	return (m_pRsRecipeManager==NULL) ? NULL: m_pRsRecipeManager->GetRcpRsGlassTypeInfoManager(); 
}

const CRcp_RsGlassTypeInfoManager* CReviewData::Recipe_GetRcpRsGlassTypeInfoManager() const
{
	return (m_pRsRecipeManager==NULL) ? NULL: m_pRsRecipeManager->GetRcpRsGlassTypeInfoManager(); 
}

const CRsRecipeManager* CReviewData::Recipe_GetRsRecipeManager() const		
{ 
	return m_pRsRecipeManager; 
}

const CRcp_RsReviewManager*	CReviewData::Recipe_GetRcpRsReviewManager() const	
{ 
	return (m_pRsRecipeManager==NULL) ? NULL: m_pRsRecipeManager->GetRcpRsReviewManager();
}

const CRcp_RsMeasureManager* CReviewData::Recipe_GetRcpRsMeasureManager() const	
{ 
	return (m_pRsRecipeManager==NULL) ? NULL: m_pRsRecipeManager->GetRcpRsMeasureManager();
}

const CRcp_RsAlignManager* CReviewData::Recipe_GetRcpRsAlignManager() const	
{ 
	return (m_pRsRecipeManager==NULL) ? NULL: m_pRsRecipeManager->GetRcpRsAlignManager();
}

const CRcp_RsDefectFindManager*	CReviewData::Recipe_GetRcpRsDefectFindManager() const
{ 
	return (m_pRsRecipeManager==NULL) ? NULL: m_pRsRecipeManager->GetRcpRsDefectFindManager(); 
}

const CSystemInfo* CReviewData::System_GetSystemInfo() const
{
	const CSys_SystemManager *pManager = System_GetSysSystemManager();
	if (pManager==NULL) return NULL;
	return pManager->GetSystemInfo();
}

const CGlassTypeInfo* CReviewData::System_GetGlassTypeInfo(int nIndex) const
{
	const CSys_GlassTypeManager *pManager = System_GetSysGlassTypeManager();
	if (pManager==NULL) return NULL;
	return pManager->GetGlassTypeInfo(nIndex);
}

const CGlassTypeInfo* CReviewData::System_GetStandardGlassTypeInfo() const
{
	const CSys_GlassTypeManager *pManager = System_GetSysGlassTypeManager();
	if (pManager==NULL) return NULL;
	return pManager->GetStandardGlassTypeInfo();
}

const CAlignCameraInfo*	CReviewData::System_GetAlignCameraInfo(int nIndex) const
{
	const CSys_AlignManager *pManager = System_GetSysAlignManager();
	if (pManager==NULL) return NULL;
	return pManager->GetAlignCameraInfo(nIndex);
}

const CSignalControlInfo* CReviewData::System_GetSignalInfo() const
{
	const CSys_SignalManager *pManager = System_GetSysPCControlManager();
	if (pManager==NULL) return NULL;
	return pManager->GetSignalInfo();
}

const CMotorControlInfo* CReviewData::System_GetMotorInfo() const
{
	const CSys_MotorManager *pManager = System_GetSysMotorManager();
	if (pManager==NULL) return NULL;
	return pManager->GetMotorInfo();
}

const CNetworkInfo* CReviewData::System_GetNetworkInfo() const
{
	const CSys_NetworkManager *pManager = System_GetSysNetworkManager();
	if (pManager==NULL) return NULL;
	return pManager->GetNetworkInfo();
}

CRsRcpReviewInfo* CReviewData::Recipe_GetRsRcpReviewInfo()
{
	CRcp_RsReviewManager *pManager = Recipe_GetRcpRsReviewManager();
	if (pManager==NULL) return NULL;
	return pManager->GetRsRcpReviewInfo();
}

CRsRcpMeasureInfo* CReviewData::Recipe_GetRsRcpMeasureInfo()
{
	CRcp_RsMeasureManager *pManager = Recipe_GetRcpRsMeasureManager();
	if (pManager==NULL) return NULL;
	return pManager->GetRsRcpMeasureInfo();
}

CRsRcpAlignInfo* CReviewData::Recipe_GetRsRcpAlignInfo()
{
	CRcp_RsAlignManager *pManager = Recipe_GetRcpRsAlignManager();
	if (pManager==NULL) return NULL;
	return pManager->GetRsRcpAlignInfo();
}

CRsRcpDefectFindInfo* CReviewData::Recipe_GetRsRcpDefectFindInfo()
{
	CRcp_RsDefectFindManager *pManager = Recipe_GetRcpRsDefectFindManager();
	if (pManager==NULL) return NULL;
	return pManager->GetRsRcpDefectFindInfo();
}

const CRsRcpReviewInfo* CReviewData::Recipe_GetRsRcpReviewInfo() const
{
	const CRcp_RsReviewManager *pManager = Recipe_GetRcpRsReviewManager();
	if (pManager==NULL) return NULL;
	return pManager->GetRsRcpReviewInfo();
}

CRsRcpGlassTypeInfo* CReviewData::Recipe_GetRsRcpGlassTypeInfo(int nIndex)
{
	CRcp_RsGlassTypeInfoManager *pManager = Recipe_GetRcpRsGlassTypeInfoManager();
	if(pManager==NULL)	return NULL;
	return pManager->GetRcpGlassTypeInfo(nIndex);
}

const CRsRcpGlassTypeInfo* CReviewData::Recipe_GetRsRcpGlassTypeInfo(int nIndex) const
{
	const CRcp_RsGlassTypeInfoManager *pManager = Recipe_GetRcpRsGlassTypeInfoManager();
	if(pManager==NULL)	return NULL;
	return pManager->GetRcpGlassTypeInfo(nIndex);
}

const CRsRcpMeasureInfo* CReviewData::Recipe_GetRsRcpMeasureInfo() const
{
	const CRcp_RsMeasureManager *pManager = Recipe_GetRcpRsMeasureManager();
	if (pManager==NULL) return NULL;
	return pManager->GetRsRcpMeasureInfo();
}

const CRsRcpAlignInfo* CReviewData::Recipe_GetRsRcpAlignInfo() const
{
	const CRcp_RsAlignManager *pManager = Recipe_GetRcpRsAlignManager();
	if (pManager==NULL) return NULL;
	return pManager->GetRsRcpAlignInfo();
}

const CRsRcpDefectFindInfo*	CReviewData::Recipe_GetRsRcpDefectFindInfo() const
{
	const CRcp_RsDefectFindManager *pManager = Recipe_GetRcpRsDefectFindManager();
	if (pManager==NULL) return NULL;
	return pManager->GetRsRcpDefectFindInfo();
}


CGlassResult* CReviewData::GlassResult_GetNewGlassResult(int& nTotalCount)
{
//	EnterCriticalSection(&m_csReviewData);
	
/*	CGlassResult *pGlassResult = new CGlassResult();
	//m_vecGlassResult.push_back(pGlassResult);
	m_vecGlassResult.insert(m_vecGlassResult.begin(), pGlassResult);
	m_pCurGlassResult = pGlassResult;
	m_nCurGlassResultIndex = int(0);
	
	if (m_vecGlassResult.size() > MAX_GLASS_RESULT_SIZE)
	{
		VectorGlassResultIt it = m_vecGlassResult.end() - 1;
		CGlassResult* pGlassResult = *it;
		delete pGlassResult;
		m_vecGlassResult.erase(it);
	}	

	m_nTotalGlassResultCount++;

	nTotalCount = m_nTotalGlassResultCount;*/
	if(m_vecGlassResult.size() < MAX_GLASS_RESULT_SIZE)
	{
		CGlassResult *pGlassResult = new CGlassResult();
		m_vecGlassResult.push_back(pGlassResult);
		//m_vecGlassResult.insert(m_vecGlassResult.begin(), pGlassResult);
		m_pCurGlassResult = pGlassResult;
		m_nCurGlassResultIndex = int(m_vecGlassResult.size() - 1);
	}
	else
	{
		m_nCurGlassResultIndex++;
		if(m_nCurGlassResultIndex >= MAX_GLASS_RESULT_SIZE)
		{
			m_nCurGlassResultIndex = 0;
		}
		m_vecGlassResult.at(m_nCurGlassResultIndex)->Reset();	
		m_pCurGlassResult = m_vecGlassResult.at(m_nCurGlassResultIndex);
	}

	m_nTotalGlassResultCount += 1;

	nTotalCount = m_nTotalGlassResultCount;

//	LeaveCriticalSection(&m_csReviewData);	

/*	if (m_vecGlassResult.size() >= MAX_GLASS_RESULT_SIZE)
	{
		VectorGlassResultIt it = m_vecGlassResult.begin();
		CGlassResult* pGlassResult = *it;
		delete pGlassResult;
		m_vecGlassResult.erase(it);
	}

	CGlassResult *pGlassResult = new CGlassResult();
	m_vecGlassResult.push_back(pGlassResult);
	m_pCurGlassResult = pGlassResult;
	m_nCurGlassResultIndex = int(m_vecGlassResult.size() - 1);

	m_nTotalGlassResultCount++;

	nTotalCount = m_nTotalGlassResultCount;*/

	return m_pCurGlassResult;
}

CGlassResult* CReviewData::GlassResult_GetGlassResult(int nIndex)
{
	EnterCriticalSection(&m_csReviewData);
	
	CGlassResult* pGlassResult = NULL;

	if (m_vecGlassResult.size() >= MAX_GLASS_RESULT_SIZE)	// 한 번이라도 순환된경우
	{
		int nSIdx = (m_nCurGlassResultIndex + 1) % MAX_GLASS_RESULT_SIZE;
		nIndex = (nSIdx + nIndex) % MAX_GLASS_RESULT_SIZE;
	}

	int nCount = 0;
	for (VectorGlassResultIt it=m_vecGlassResult.begin(); it!=m_vecGlassResult.end(); it++)
	{
		if (nCount==nIndex)
		{
			pGlassResult = *it;
			break;
		}
		nCount++;
	}
	LeaveCriticalSection(&m_csReviewData);
	return pGlassResult;
}

CGlassResult * CReviewData::HistoryResult_GetNewHistoryResult(int & nTotalCount)
{
	if (m_vecHistoryResult.size() < MAX_GLASS_RESULT_SIZE)
	{
		CGlassResult *pHistoryResult = new CGlassResult();
		m_vecHistoryResult.push_back(pHistoryResult);
		m_pCurHistoryResult = pHistoryResult;
		m_nCurHistoryResultIndex = int(m_vecHistoryResult.size() - 1);
	}
	else
	{
		m_nCurHistoryResultIndex++;
		if (m_nCurHistoryResultIndex >= MAX_GLASS_RESULT_SIZE)
		{
			m_nCurHistoryResultIndex = 0;
		}
		m_vecHistoryResult.at(m_nCurHistoryResultIndex)->HT_Reset();
		m_pCurHistoryResult = m_vecHistoryResult.at(m_nCurHistoryResultIndex);
	}

	m_nTotalHistoryResultCount += 1;

	nTotalCount = m_nTotalHistoryResultCount;

	return m_pCurHistoryResult;
}

CGlassResult* CReviewData::HistoryResult_GetHistoryResult(int nIndex)
{
	EnterCriticalSection(&m_csReviewData);
	
	CGlassResult* pHistoryResult = NULL;

	if (m_vecHistoryResult.size() >= MAX_GLASS_RESULT_SIZE)	// 한 번이라도 순환된경우
	{
		int nSIdx = (m_nCurHistoryResultIndex + 1) % MAX_GLASS_RESULT_SIZE;
		nIndex = (nSIdx + nIndex) % MAX_GLASS_RESULT_SIZE;
	}

	int nCount = 0;
	for (VectorHistoryResultIt it=m_vecHistoryResult.begin(); it!= m_vecHistoryResult.end(); it++)
	{
		if (nCount==nIndex)
		{
			pHistoryResult = *it;
			break;
		}
		nCount++;
	}
	LeaveCriticalSection(&m_csReviewData);
	return pHistoryResult;
}

int	CReviewData::GlassResult_GetTotalGlassResultCount()			
{ 
	return m_nTotalGlassResultCount; 
}

int	CReviewData::GlassResult_GetGlassResultCount()				
{ 
	return (int)m_vecGlassResult.size(); 
}

int	CReviewData::GlassResult_GetCurrentGlassResultIndex()				
{ 
	return m_nCurGlassResultIndex; 
}

CGlassResult* CReviewData::GlassResult_GetCurrentGlassResult()				
{ 
	EnterCriticalSection(&m_csReviewData);
	
	CGlassResult *pGlassResult = m_pCurGlassResult;

	LeaveCriticalSection(&m_csReviewData);
	return pGlassResult; 
}

SDefectFilter* CReviewData::Etc_GetDefectFilter()
{
	return m_pDefectFilter;
}

SSignalIOStatus* CReviewData::Etc_GetPCControlIOSignal()
{
	return m_pSignalIOStatus;
}

STransferData* CReviewData::Etc_GetTransferData()
{
	return m_pTransferData;
}

CConnectionStatus* CReviewData::Etc_GetConnectionStatus()
{
	return m_pConnectionStatus;
}

BOOL CReviewData::ReadGlassResultFile(const CString& strResultFilePath)
{
	m_pDitRawClient = CDitGlassRawClient::GetInstance();

	BOOL bRet=0;

	if(m_pDitRawClient->ConnectServer() == FALSE)	g_pLog->DisplayMessage(_T("공유메모리 접근 실패!(Shared memory Access Fail)"));

	if(m_pCurGlassResult==NULL || m_pResultFileManager == NULL || m_pResultFileParser == NULL) return FALSE;
	
	m_pCurGlassResult->m_nSlotNum = 1;  // slot num

	//pasrshing 시작 부분
	if(m_pDitRawClient->isConnect()==TRUE)
	{
		m_pResultFileParser->MemoryParsingFileToGlassResult(m_pCurGlassResult,m_pDitRawClient);
		m_pResultFileManager->SetReadComplete(bRet);
	}
	
	else
	{
		g_pLog->DisplayMessage(_T("DitRawClient is not Connect"));
		g_pLog->DisplayMessage(_T("Find Raw Data File"));
		if(m_pResultFileManager->ReadAOIRaw(strResultFilePath)==TRUE)	bRet =1; 
		else if (bRet==FALSE) return FALSE;

		m_pResultFileParser->ParsingFileToGlassResult(m_pCurGlassResult, m_pResultFileManager);
	}
	return TRUE;
}

BOOL CReviewData::WriteGlassResultFile(CGlassResult* pGlassResult, const CString& strResultFilePath, int nStackType)
{
	BOOL bRet = FALSE;

	//2014-04-25, 결과파일 읽기 실패시 예외처리
	switch (nStackType)
	{
	case RESULT_FILE_TD:
		if(m_pResultFileManager && m_pResultFileManager->GetReadComplete())
		{
			bRet = m_pResultFileManager->WriteAOIRaw(strResultFilePath);
		}
		break;
	case RESULT_FILE_CD:
		if(m_pResultFileManagerCD && m_pResultFileManagerCD->GetReadComplete())
		{
			bRet = m_pResultFileManagerCD->WriteAOIRaw(strResultFilePath);
		}
		break;
	case RESULT_FILE_SD:
		if(m_pResultFileManagerSD && m_pResultFileManagerSD->GetReadComplete())
		{
			bRet = m_pResultFileManagerSD->WriteAOIRaw(strResultFilePath);
		}
		break;
	default:
		break;
	}

	return bRet;
}

BOOL CReviewData::WriteGlassMeasureResultFile(const CString& strResultFilePath) //Add by Juneki 2016-03-01
{
	BOOL bRet = FALSE;

	bRet = m_pResultFileManagerMeasure->WriteMeasureRaw(strResultFilePath);
	       
	return bRet;
}

BOOL CReviewData::SetReviewResultData(CGlassResult* pGlassResult)
{
	int nWriteTDCount = 0;
	int nWriteCDCount = 0;
	int nWriteSDCount = 0;

	if(m_pResultFileParser==NULL || pGlassResult==NULL) return FALSE;
	if(m_pResultFileManager==NULL || m_pResultFileManagerCD==NULL || m_pResultFileManagerSD==NULL) return FALSE;

	//20170723 ReadFail시 SW Down 예외처리
	if(m_pResultFileManager->GetReadComplete() == FALSE)
		return FALSE;

	nWriteTDCount = m_pResultFileParser->ParsingReviewResultDataToFile(pGlassResult, m_pResultFileManager);
	//nWriteCDCount = m_pResultFileParser->ParsingReviewResultDataToFile(pGlassResult, m_pResultFileManagerCD);
	//nWriteSDCount = m_pResultFileParser->ParsingReviewResultDataToFile(pGlassResult, m_pResultFileManagerSD);
	// [2017:6:21][bhs] : User Review 결과 추가 - 협의 필요.
	//nWriteTDCount += m_pResultFileParser->ParsingReflowResultData(pGlassResult, m_pResultFileManager);

	g_pLog->DisplayMessage(_T("SetReviewResultData TD[%d], SD[%d], PD[%d],SP[%d]"), nWriteTDCount, nWriteCDCount, nWriteSDCount);

	return TRUE;
}

BOOL CReviewData::SetUserResultData(CGlassResult* pGlassResult)
{
	int nWriteTDCount = 0;

	if(m_pResultFileParser==NULL || pGlassResult==NULL) return FALSE;
	if(m_pResultFileManager==NULL) return FALSE;
	int UserDefecCnt = 0;
	const CSystemInfo *pSystemInfo = System_GetSystemInfo();
	if(pSystemInfo == NULL) return 0;

	for(int nModuleIdx = 0; nModuleIdx < pSystemInfo->GetGantryInfoCount(); nModuleIdx++)
	{
		CReviewResult* pUserResult = pGlassResult->GetUserResult(nModuleIdx);
		if (pUserResult != NULL)
		{
			UserDefecCnt += pUserResult->GetSReviewResultCount(ReviewResult_Process_Complete);
		}
	}
	if (UserDefecCnt > 0)
	{
		m_pResultFileManager->AddUserDefectData(UserDefecCnt);
		//nWriteTDCount = m_pResultFileParser->(pGlassResult, m_pResultFileManager);
	}

	return TRUE;
}

BOOL CReviewData::SetWsiResultData(CGlassResult* pGlassResult)
{
	int nWriteTDCount = 0;
	int nWriteCDCount = 0;
	int nWriteSDCount = 0;

	if(m_pResultFileParser==NULL || pGlassResult==NULL) return FALSE;
	if(m_pResultFileManager==NULL || m_pResultFileManagerCD==NULL || m_pResultFileManagerSD==NULL) return FALSE;

	nWriteTDCount = m_pResultFileParser->ParsingWsiResultDataToFile(pGlassResult, m_pResultFileManager);
	//nWriteCDCount = m_pResultFileParser->ParsingWsiResultDataToFile(pGlassResult, m_pResultFileManagerCD);
	//nWriteSDCount = m_pResultFileParser->ParsingWsiResultDataToFile(pGlassResult, m_pResultFileManagerSD);

	g_pLog->DisplayMessage(_T("SetWsiResultData TD[%d], CD[%d], SD[%d]"), nWriteTDCount, nWriteCDCount, nWriteSDCount);

	return TRUE;
}

BOOL CReviewData::SetMeasureResultData(CGlassResult* pGlassResult) //Add by Juneki 2016-03-01
{
	int nWriteCount = 0;
	if(m_pResultFileParserMeasure==NULL || pGlassResult==NULL) return FALSE;
	if(m_pResultFileManagerMeasure == NULL) return FALSE;

	nWriteCount = m_pResultFileParserMeasure->ParsingMeasureResultDataToFile(pGlassResult, m_pResultFileManagerMeasure);

	g_pLog->DisplayMessage(_T("SetMeasureResultData [%d]"), nWriteCount);

	return TRUE;
}

BOOL CReviewData::SetReflowResultData( CGlassResult* pGlassResult )
{
	int nWriteTDCount = 0;

	if(m_pResultFileParser==NULL || pGlassResult==NULL) return FALSE;
	if(m_pResultFileManager==NULL) return FALSE;
	int ReflowDefecCnt = 0;
	CReviewResult* pReflowResult = pGlassResult->GetReflowResult(0);
	if (pReflowResult != NULL)
	{
		ReflowDefecCnt = pReflowResult->GetSReviewResultCount(ReviewResult_Process_Complete);
	}
	
	if (ReflowDefecCnt > 0)
	{
//kwh AddReflowDefectData error
//		m_pResultFileManager->AddReflowDefectData(ReflowDefecCnt);
		nWriteTDCount = m_pResultFileParser->ParsingReflowResultDataToFile(pGlassResult, m_pResultFileManager);
	}

	return TRUE;
}

BOOL CReviewData::SetWsiReflowResultData( CGlassResult* pGlassResult )
{
	int nWriteTDCount = 0;

	if(m_pResultFileParser==NULL || pGlassResult==NULL) return FALSE;
	if(m_pResultFileManager==NULL) return FALSE;
	int nWsiReflowDefecCnt = 0;
	CReviewResult* pWsiReflowResult = pGlassResult->GetWsiReflowResult(0);
	if (pWsiReflowResult != NULL)
	{
		nWsiReflowDefecCnt = pWsiReflowResult->GetSReviewResultCount(WsiResultSuccess);
	}

	if (nWsiReflowDefecCnt > 0)
	{
		m_pResultFileManager->AddWsiReflowDefectData(nWsiReflowDefecCnt);
		nWriteTDCount = m_pResultFileParser->ParsingWsiReflowResultDataToFile(pGlassResult, m_pResultFileManager);
	}

	return TRUE;
}

BOOL CReviewData::CreateRawDataFormat(int* pnCnt) //Add by Juneki 2016-03-01
{
	//m_pResultFileManagerMeasure->CreateRawDataFormatData(m_pResultFileManager, pnCnt);
	return TRUE;
}

void CReviewData::FindStackTypeDefectIdx(int nStackType, CDefectResult* pDefectResult)
{
	int i, nCount, nUMOriginX, nUMOriginY;

	switch (nStackType)
	{
	case RESULT_FILE_CD:
		if(m_pResultFileManagerCD)
		{
			if(m_pResultFileManagerCD->GetReadComplete())
			{
				nCount = m_pResultFileManagerCD->GetDefectCount();

				for(i = 0; i < nCount; i++)
				{
					nUMOriginX = atoi(m_pResultFileManagerCD->GetDefectData(i, 5));
					nUMOriginY = atoi(m_pResultFileManagerCD->GetDefectData(i, 6));

					if(pDefectResult->nUMOriginX == nUMOriginX && pDefectResult->nUMOriginY == nUMOriginY)
					{
						pDefectResult->nCDDefectIdx = i;
						break;
					}
				}
			}
		}
		break;
	case RESULT_FILE_SD:
		if(m_pResultFileManagerSD)
		{
			if(m_pResultFileManagerSD->GetReadComplete())
			{
				nCount = m_pResultFileManagerSD->GetDefectCount();

				for(i = 0; i < nCount; i++)
				{
					nUMOriginX = atoi(m_pResultFileManagerSD->GetDefectData(i, 5));
					nUMOriginY = atoi(m_pResultFileManagerSD->GetDefectData(i, 6));

					if(pDefectResult->nUMOriginX == nUMOriginX && pDefectResult->nUMOriginY == nUMOriginY)
					{
						pDefectResult->nSDDefectIdx = i;
						break;
					}
				}
			}
		}
		break;
	default:
		break;
	}
}

BOOL CReviewData::CompareSReviewResultYAscendingOrder(const SReviewResult& lhs, const SReviewResult& rhs)
{
	return (lhs.nUMOriginY < rhs.nUMOriginY);
}

BOOL CReviewData::CompareSReviewResultYDescendingOrder(const SReviewResult& lhs, const SReviewResult& rhs)
{
	return (lhs.nUMOriginY > rhs.nUMOriginY);
}

BOOL CReviewData::ReadResultAOIMemory()
{
	m_pDitRawClient = CDitGlassRawClient::GetInstance();

	BOOL bRet=0;

	if(m_pDitRawClient->ConnectServer() == FALSE || m_pDitRawClient->isConnect()==FALSE)
	{
		g_pLog->DisplayMessage(_T("공유메모리 접근 실패!(Shared memory Access Fail)"));
		return FALSE;
	}

	if(m_pCurGlassResult==NULL || m_pResultFileManager == NULL || m_pResultFileParser == NULL) return FALSE;

	m_pCurGlassResult->m_nSlotNum = 1;  // slot num

	m_pResultFileParser->MemoryParsingFileToGlassResult(m_pCurGlassResult,m_pDitRawClient);
	m_pResultFileManager->SetReadComplete(bRet);

	return TRUE;
}

BOOL CReviewData::ReadResultAOIMemory2(CGlassResult* pGlassResult)
{
	m_pDitRawClient = CDitGlassRawClient::GetInstance();

	BOOL bRet = 0;

	if (m_pDitRawClient->ConnectServer() == FALSE || m_pDitRawClient->isConnect() == FALSE)
	{
		g_pLog->DisplayMessage(_T("공유메모리 접근 실패!(Shared memory Access Fail)"));
		return FALSE;
	}

	if (pGlassResult == NULL || m_pResultFileManager == NULL || m_pResultFileParser == NULL) return FALSE;

	pGlassResult->m_nSlotNum = 1;  // slot num

	m_pResultFileParser->MemoryParsingFileToGlassResult(pGlassResult, m_pDitRawClient);
	m_pResultFileManager->SetReadComplete(bRet);

	return TRUE;
}