#include "StdAfx.h"
#include "CHReviewResultParser/ParsingGlassResult_Simulation.h"

using namespace CHReviewResult;

CParsingGlassResult_Simulation::CParsingGlassResult_Simulation(IParsingGlassResultParent* pPGR2P) : CParsingGlassResult(pPGR2P)
{
}

CParsingGlassResult_Simulation::~CParsingGlassResult_Simulation(void)
{
}


void CParsingGlassResult_Simulation::ParsingFileToGlassResult(CGlassResult* pGlassResult, CResultFileManager* pResultFileMgr)
{
	if(pGlassResult==NULL || pResultFileMgr==NULL)
		return;

	CString strItem = _T("");
	CString strData = _T("");

	int nItemIndex = 0;
	int nDataIndx = 0;

	pGlassResult->m_strLotID = pResultFileMgr->GetGlassData(0, 3);

	// read cell data
	CCellResult cellResult;
	int nCellCount = pResultFileMgr->GetCellCount();
	for(int idx=0; idx<nCellCount; idx++)
	{
		cellResult.Reset();

		strItem	= pResultFileMgr->GetCellData(idx, 2);						
		strItem.TrimRight();
		//cellResult.strCellID		= strItem.Right(3);
		//cellResult.strCellID		= strItem.Right(4).Left(3);
		cellResult.strCellID		= strItem.Right(2).Left(2);

		cellResult.nUMOriginX		= atoi(pResultFileMgr->GetCellData(idx, 3));		
		cellResult.nUMOriginY		= atoi(pResultFileMgr->GetCellData(idx, 4));
		cellResult.nUMOriginWidth	= atoi(pResultFileMgr->GetCellData(idx, 5));
		cellResult.nUMOriginHeight	= atoi(pResultFileMgr->GetCellData(idx, 6));

		pGlassResult->AddCellResult(cellResult);
	}

	// read defect data
	srand((unsigned)time(NULL));
	int	strLength = 0;
	int nDefectCount = pResultFileMgr->GetDefectCount();
	CString strTemp = _T("");
	for (int i=0; i<pResultFileMgr->GetDefectCount(); i++)
	{
		CDefectResult* pDefectResult = new CDefectResult;
		if (pDefectResult==NULL) continue;

		strItem								= pResultFileMgr->GetDefectData(i, 2);			// (2) CELL_ID
		strItem.TrimRight();
		//		pDefectResult->strCellID			= strItem.Right(4).Left(3);
		pDefectResult->strCellID			= strItem.Right(2).Left(2);
		pDefectResult->nDefectIdx			= atoi(pResultFileMgr->GetDefectData(i, 3));	// (3) DEF_NO

		pDefectResult->nUMTransX			= (rand()%(pGlassResult->GetGlassSizeX()/1000))*1000;	// (4) COORD_X
		pDefectResult->nUMTransY			= (rand()%(pGlassResult->GetGlassSizeY()/1000))*1000;	// (5) COORD_Y
		pDefectResult->nUMOriginX			= pDefectResult->nUMTransX;
		pDefectResult->nUMOriginY			= pDefectResult->nUMTransY;

																							// (6) GATELINE
																							// (7) DATALINE

		pDefectResult->nAOISizeS			= atoi(pResultFileMgr->GetDefectData(i, 8));	// (8) SIZE_S
		pDefectResult->nAOISizeW			= atoi(pResultFileMgr->GetDefectData(i, 9));	// (9) SIZE_W
		pDefectResult->nAOISize				= atoi(pResultFileMgr->GetDefectData(i, 10));	// (10) SIZE_L
		pDefectResult->nAOISizeH			= atoi(pResultFileMgr->GetDefectData(i, 11));	// (11) SIZE_H

		// filtering judge type
		pDefectResult->strJudgeType			= pResultFileMgr->GetDefectData(i, 12);			// (12) GRADE (OK, PR, TR)
		pDefectResult->strJudgeType.TrimRight();
		pDefectResult->nJudgeType			= GetJudgeType(pDefectResult->strJudgeType);	// judge type

		// filter defect code
		pDefectResult->strDefectCode		= pResultFileMgr->GetDefectData(i, 13);			// (13) CODE
		pDefectResult->strDefectCode.TrimRight();

		pDefectResult->strStackType			= pResultFileMgr->GetDefectData(i, 14);			// (14) STACK_FLAG
		pDefectResult->strStackType.TrimRight();
		pDefectResult->nStackType			= GetStackType(pDefectResult->strStackType);	// stack type

		pDefectResult->nStackStepCount		= atoi(pResultFileMgr->GetDefectData(i, 15));	// (15) STACK_COUNT
		pDefectResult->strStackStep			= pResultFileMgr->GetDefectData(i, 16);			// (16) STACK_STEP 
		pDefectResult->strStackStep.TrimRight();

																							// (17) IMAGE_FILE
																							// (18) RGB_CODE
		pDefectResult->strDefectType		= pResultFileMgr->GetDefectData(i, 19);			// (19) VC_CODE (TB, TW, RB, RW)
		pDefectResult->strDefectType.TrimRight();

		pDefectResult->strDefectZone		= pResultFileMgr->GetDefectData(i, 20);			// (20) ZONE_CODE
		pDefectResult->strDefectZone		= pDefectResult->strDefectZone.Left(4);

		pDefectResult->strSizeType			= pResultFileMgr->GetDefectData(i, 21);			// (21) DEFECT_SIZE
		pDefectResult->strSizeType.TrimRight();
		pDefectResult->nSizeType			= GetSizeType(pDefectResult->strSizeType);		// size type

																							
		// filtering subtype
		pDefectResult->strSubType			= pResultFileMgr->GetDefectData(i, 22);			// (22) REPEAT_DEFECT (N, MD, CD, MC)
		pDefectResult->strSubType.TrimRight();
		pDefectResult->nSubType				= GetSubType(pDefectResult->strSubType);		// sub type
																							// (23) DEFECT_TYPE
																							// (24) D_MAX_GR
																							// (25) D_MIN_GR
																							// (26) D_AVG_GR

		pDefectResult->nAOICameraIdx		= atoi(pResultFileMgr->GetDefectData(i, 27));	// (27) CAM_NO
		pDefectResult->nAOIScanIdx			= atoi(pResultFileMgr->GetDefectData(i, 28));	// (28) SCAN_NO

																							// (29) CAM_AVG 
																							// (30) R_MAX_GR 
																							// (31) R_MIN_GR 
																							// (32) R_AVG_GR 
		pDefectResult->nAOIPeak				= atoi(pResultFileMgr->GetDefectData(i, 33));	// (33) PEAK 
																							// (34) IDSS_CODE
																							// (35) BEFORE_STACK  
																							// (36) DEF_NAME  
																							// (37) BEFORE_STACK2 	

		if (rand()%2 == 0)
		{
			//optic type
			pDefectResult->strOpticType = _T("TR");
			pDefectResult->nOpticType = DEFECT_OPTIC_A3P_EA_TRANSMIT;

			// gray type
			pDefectResult->strGrayType = _T("BL");
			pDefectResult->nGrayType = DEFECT_GRAY_BLACK;
		}
		else
		{
			//optic type
			pDefectResult->strOpticType = _T("RE");
			pDefectResult->nOpticType = DEFECT_OPTIC_A3P_EA_REFLECT;

			// gray type
			pDefectResult->strGrayType = _T("WH");
			pDefectResult->nGrayType = DEFECT_GRAY_WHITE;
		}
								
		pGlassResult->AddDefectResult(pDefectResult);
	}
}

int CParsingGlassResult_Simulation::ParsingReviewResultDataToFile(CGlassResult* pGlassResult, CResultFileManager* pResultFileMgr)
{
	CString strImageFileName = _T("");
	int nWriteCount = 0;

	int nModuleCount = 4;
	if (m_pPGR2P)
	{
		nModuleCount = m_pPGR2P->PGR2P_GetModuleCount();
	}
	else
	{
		nModuleCount =pGlassResult->GetReviewResultCount();
	}
	
	for (int nCameraIdx=0; nCameraIdx<nModuleCount; nCameraIdx++)
	{
		const CReviewResult* pCameraResult = pGlassResult->GetReviewResult(nCameraIdx);
		if (pCameraResult==NULL) continue;

		for (int nResultIdx=0; nResultIdx<pCameraResult->GetSReviewResultCount(); nResultIdx++)
		{
			const SReviewResult *pResult = pCameraResult->GetSReviewResult(nResultIdx);
			if (pResult==NULL) continue;
			if (pResult->nResultCode!=ReviewResult_Process_Complete) continue;

			// review image file name
			int nSize = 0;
			char* strTemp = NULL;
			strImageFileName = pResult->strUploadImgFileName;

#ifdef _UNICODE
			nSize = WideCharToMultiByte(CP_ACP, 0, strImageFileName.GetBuffer(), -1, NULL, 0, NULL,NULL); 
			strTemp = new char[nSize]; 
			WideCharToMultiByte(CP_ACP, 0, strImageFileName.GetBuffer(), -1, strTemp, nSize, NULL, NULL); 
#else
			nSize = strImageFileName.GetLength();
			strTemp = new char[nSize+1]; 
			memcpy(strTemp, strImageFileName.GetBuffer(), sizeof(char)*nSize);
			strTemp[nSize] = NULL;
#endif

			if (pResultFileMgr && pResult->nDefectIdx != -1)
			{
				pResultFileMgr->SetDefectData(pResult->nDefectIdx, 17, strTemp);
				nWriteCount++;
			}

			if(strTemp)
			{
				delete[] strTemp;
				strTemp = NULL;
			}

		}
	}

	return nWriteCount;
}

int CParsingGlassResult_Simulation::ParsingWsiResultDataToFile(CGlassResult* pGlassResult, CResultFileManager* pResultFileMgr)
{
	int nWriteCount = 0;

	CString strImageFileName = _T("");

	for (int nCameraIdx=0; nCameraIdx<pGlassResult->GetWsiResultCount(); nCameraIdx++)
	{
		const CReviewResult* pCameraResult = pGlassResult->GetWsiResult(nCameraIdx);
		if (pCameraResult==NULL) continue;

		for (int nResultIdx=0; nResultIdx<pCameraResult->GetSReviewResultCount(); nResultIdx++)
		{
			const SReviewResult *pResult = pCameraResult->GetSReviewResult(nResultIdx);
			if (pResult==NULL) continue;
			if (pResult->nResultCode!=WsiResultSuccess) continue;

			// wsi image file name
			int nSize = 0;
			char* strTemp = NULL;
			strImageFileName = pResult->strUploadImgFileName;
#ifdef _UNICODE
			nSize = WideCharToMultiByte(CP_ACP, 0, strImageFileName.GetBuffer(), -1, NULL, 0, NULL,NULL); 
			strTemp = new char[nSize]; 
			WideCharToMultiByte(CP_ACP, 0, strImageFileName.GetBuffer(), -1, strTemp, nSize, NULL, NULL); 
#else
			nSize = strImageFileName.GetLength();
			strTemp = new char[nSize+1]; 
			memcpy(strTemp, strImageFileName.GetBuffer(), sizeof(char)*nSize);
			strTemp[nSize] = NULL;
#endif

			if (pResultFileMgr && pResult->nDefectIdx != -1)
			{
				pResultFileMgr->SetDefectData(pResult->nDefectIdx, 43, strTemp);

				pResultFileMgr->SetDefectData(pResult->nDefectIdx, 45, pResult->nWsi_Type);
				pResultFileMgr->SetDefectData(pResult->nDefectIdx, 46, pResult->pWsi_ResultData[Wsi_X_Height]);
				pResultFileMgr->SetDefectData(pResult->nDefectIdx, 47, pResult->pWsi_ResultData[Wsi_X_Width]);
				pResultFileMgr->SetDefectData(pResult->nDefectIdx, 48, pResult->pWsi_ResultData[Wsi_X_A_Ratio]);
				pResultFileMgr->SetDefectData(pResult->nDefectIdx, 49, pResult->nWsi_SlopeWarn);
				pResultFileMgr->SetDefectData(pResult->nDefectIdx, 50, pResult->pWsi_ResultData[Wsi_X_Area]);
// 				pResultFileMgr->SetDefectData(pResult->nDefectIdx, 51, pResult->pWsi_ResultData[Wsi_X_LEFT_1_A_Ratio]);
// 				pResultFileMgr->SetDefectData(pResult->nDefectIdx, 52, pResult->pWsi_ResultData[Wsi_X_LEFT_2_A_Ratio]);
// 				pResultFileMgr->SetDefectData(pResult->nDefectIdx, 53, pResult->pWsi_ResultData[Wsi_X_LEFT_3_A_Ratio]);
// 				pResultFileMgr->SetDefectData(pResult->nDefectIdx, 54, pResult->pWsi_ResultData[Wsi_X_LEFT_4_A_Ratio]);
// 				pResultFileMgr->SetDefectData(pResult->nDefectIdx, 55, pResult->pWsi_ResultData[Wsi_X_Right_1_A_Ratio]);
// 				pResultFileMgr->SetDefectData(pResult->nDefectIdx, 56, pResult->pWsi_ResultData[Wsi_X_Right_2_A_Ratio]);
// 				pResultFileMgr->SetDefectData(pResult->nDefectIdx, 57, pResult->pWsi_ResultData[Wsi_X_Right_3_A_Ratio]);
// 				pResultFileMgr->SetDefectData(pResult->nDefectIdx, 58, pResult->pWsi_ResultData[Wsi_X_Right_4_A_Ratio]);

				nWriteCount++;
			}

			if(strTemp)
			{
				delete[] strTemp;
				strTemp = NULL;
			}
		}
	}

	return nWriteCount;
}

int  CParsingGlassResult_Simulation::ParsingMeasureResultDataToFile(CGlassResult* pGlassResult, CResultFileManager* pResultFileMgr) //Juneki 2016-03-01
{
	return 0;
}

int CParsingGlassResult_Simulation::GetDefectType(const CString& strValue)
{
	if (strValue.Compare(_T("TB"))==0)
	{
		return DEFECT_TYPE_BD;	//3
	}
	else if (strValue.Compare(_T("TW"))==0)
	{
		return DEFECT_TYPE_B;	//2
	}
	else if (strValue.Compare(_T("RB"))==0)
	{
		return DEFECT_TYPE_D;	//1
	}
	else if (strValue.Compare(_T("RW"))==0)
	{
		return DEFECT_TYPE_PBD;	//3
	}

	return 0;
}

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

	return DEFECT_GRAY_NONE;
}

int CParsingGlassResult_Simulation::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 CParsingGlassResult_Simulation::GetSizeType(const CString& strValue)
{
	if (strValue == "S")		DEFECT_SIZE_SMALL;
	else if (strValue == "M")	DEFECT_SIZE_MEDIUM;
	else if (strValue == "L")	DEFECT_SIZE_LARGE;
	else						DEFECT_SIZE_HUGE;
	return DEFECT_SIZE_NONE;
}

int CParsingGlassResult_Simulation::GetStackType(const CString& strValue)
{
	if (strValue == "TD")		return DEFECT_STACK_TD;
	else if (strValue == "CD")	return DEFECT_STACK_CD;
	else if (strValue == "SD")	return DEFECT_STACK_SD;
	else						return DEFECT_STACK_TD;

	return DEFECT_STACK_NONE;
}

int CParsingGlassResult_Simulation::GetJudgeType(const CString& strValue)
{
	if (strValue == "TR")		return DEFECT_JUDGE_TR;
	else if (strValue == "PR")	return DEFECT_JUDGE_PR;
	else if	(strValue == "OK") 	return DEFECT_JUDGE_OK;

	return DEFECT_JUDGE_NONE;	
}

int CParsingGlassResult_Simulation::GetSubType(const CString& strValue)
{
	if (strValue == "M")		return DEFECT_SUBTYPE_MD;
	else if (strValue == "C")	return DEFECT_SUBTYPE_CD;
	else if (strValue == "MC")	return DEFECT_SUBTYPE_MC;
	else if (strValue == "N")	return DEFECT_SUBTYPE_NR;

	return DEFECT_SUBTYPE_NONE;	
}

int CParsingGlassResult_Simulation::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;
}

void CParsingGlassResult_Simulation::MemoryParsingFileToGlassResult( CGlassResult* pGlassResult, CDitGlassRawClient* m_pDitRawClient )
{
 
}

int CParsingGlassResult_Simulation::MemoryParsingReviewResultDataToFile( CGlassResult* pGlassResult, CDitGlassRawClient* pRawMemoryMgr )
{
	return 0;
}

int CParsingGlassResult_Simulation::MemoryParsingWsiResultDataToFile( CGlassResult* pGlassResult, CDitGlassRawClient* pRawMemoryMgr )
{
	return 0;
}

int CParsingGlassResult_Simulation::MemoryParsingMeasureResultDataToFile( CGlassResult* pGlassResult, CDitGlassRawClient* pRawMemoryMgr )
{
	return 0;
}

int CParsingGlassResult_Simulation::MemoryParsingReflowResultDataToFile( CGlassResult* pGlassResult, CDitGlassRawClient* pRawMemoryMgr )
{
	return 0;
}