#include "StdAfx.h"
#include "RawResultReader.h"
#include "akLoggerExt.h"
#include "akCore/akFileDB.h"
#include <process.h>
#include "DitGlassRawClient.h"
#include "GlassRawBase.h"
#include <sstream>

#ifdef _DEBUG
#undef THIS_FILE
static char THIS_FILE[] = __FILE__;
#define new DEBUG_NEW
#endif

CRawResultReader::CRawResultReader(void)
{
	m_nThreadStackFileReadFlag = 0;
	m_nProcessState = RPS_StateIdle;

	m_strConfigFile;
	{
		GetModuleFileName(NULL, m_strConfigFile, MAX_PATH);
		char* ext = CakFileUtil::getFileExt(m_strConfigFile);
		strcpy(ext, "ini");
	}
	CreateDirectory("D:\\DIT_ResultData\\RawMerge", NULL);
	m_nProcessState = RPS_StateIdle;
	readOptionFile();
}

CRawResultReader::~CRawResultReader(void)
{
	
	if (m_nThreadStackFileReadFlag == 1)
	{
		m_nThreadStackFileReadFlag = 2;
		while (m_nThreadStackFileReadFlag != 0)
		{
			Sleep(1);
		}
	}

	m_vecStackDefect.clear();
	
}

BOOL CRawResultReader::openFile(char* pGlassID)
{
	CString strFileName;
	
	/*< KJG 20211208 : #3696 DEL Start >*/
	//CDitGlassRawClient	GlassRawClient;
	//GlassRawClient.ConnectServer();
	//CDitGlassRawClient* pShared = &GlassRawClient;

	//_grmDefectData* pGrmStack;
	/*< KJG 20211208 : #3696 DEL End >*/

	strFileName.Format("%s\\%s", m_strLocalPath, pGlassID);


	FILE* pf = fopen(strFileName.GetBuffer(0), "r");

	if (pf == NULL)
		return FALSE;
		
	/* <KMH 20220407 : #4053 ADD Start> */
	AKLOG("Function : Read File Path: %s" , strFileName);
	/* <KMH 20220407 : #4053 ADD End> */
	/*< KJG 20211208 : #3696 ADD Start >*/
	CDitGlassRawClient	GlassRawClient;
	GlassRawClient.ConnectServer();
	CDitGlassRawClient* pShared = &GlassRawClient;

	_grmDefectData* pGrmStack;
	/*< KJG 20211208 : #3696 ADD End >*/

	std::vector<_grmDefectData> vecStackDefect;
	_grmDefectData StackDefect;
	char buffer[2048];

	char* pReadPoint = NULL;
	char *pStr;
	CString tempStr, strRight;

	while (!feof(pf)) //Data ½ÃÀÛ
	{
		pStr = fgets(buffer, 2048, pf);

		if (strncmp(buffer, "DATA", 4)) continue; 

		if (strlen(buffer) <= 0 || pStr == NULL)
			break;

		/* < KJG 20220225 - #3850 ADD Start >*/ 
		if (strncmp(buffer, "DATA PANEL", 10) == 0)
		{
			pReadPoint = buffer;
			CString strtemp;
			pReadPoint = getParsingData(pReadPoint, 4, &strtemp);
			pReadPoint = getParsingData(pReadPoint, 5, &strtemp);
			pReadPoint = getParsingData(pReadPoint, 5, &strtemp);
			pReadPoint = getParsingData(pReadPoint, 27, &strtemp);
			pReadPoint = getParsingData(pReadPoint, 20, &strtemp);
			pReadPoint = getParsingData(pReadPoint, 20, &strtemp);
			pReadPoint = getParsingData(pReadPoint, 10, &strtemp);
			strncpy(pShared->GetGlassData()->m_strRawMergeStepID, strtemp.GetBuffer(0), 10 + 1); // Null ¹®ÀÚ ‹š¹®¿¡ +1
		}
		/* < KJG 20220225 - #3850 ADD End >*/
		if (strncmp(buffer, "DATA DEFECT", 10)) continue; 

		//Defect Stack Start
		{
			pReadPoint = buffer;
			int temp;
			CString strtemp;

			pReadPoint = getParsingData(pReadPoint, 4, &temp);
			pReadPoint = getParsingData(pReadPoint, 6, &temp);
			pReadPoint = getParsingData(pReadPoint, 12, &strtemp);


			//Cell ID·Î idx ã±â
			{
				tempStr = strtemp.Right(2);
				int nUpper = atoi(tempStr.Left(1));
				nUpper *= 36;

				char ctemp[2];
				strRight = tempStr.Right(1);
				strcpy(ctemp, strRight);
				int nLower = static_cast<int>(ctemp[0]);
				if (48 <= nLower && nLower <= 57)
					nLower = 43 /* 65+26+17 */ + nLower;
				nLower -= 65;

				StackDefect.m_nCellIdx = nUpper + nLower;
			}
			

			pReadPoint = getParsingData(pReadPoint, 5, &temp);
			pReadPoint = getParsingData(pReadPoint, 8, &StackDefect.m_nUMCenterAlignX);
			pReadPoint = getParsingData(pReadPoint, 8, &StackDefect.m_nUMCenterAlignY);
			StackDefect.m_nUMCenterAlignY = StackDefect.m_nUMCenterAlignY*-1;
			pReadPoint = getParsingData(pReadPoint, 6, &StackDefect.m_nCellGate);
			pReadPoint = getParsingData(pReadPoint, 6, &StackDefect.m_nCellData);
			pReadPoint = getParsingData(pReadPoint, 4, &StackDefect.m_nPixelSize);
			pReadPoint = getParsingData(pReadPoint, 4, &StackDefect.m_nUMSizeX);
			pReadPoint = getParsingData(pReadPoint, 4, &StackDefect.m_nUMSizeY);
			pReadPoint = getParsingData(pReadPoint, 4, &StackDefect.m_nDefectRScale);
			pReadPoint = getParsingData(pReadPoint, 4, &strtemp); //StackDefect.m_DefectJudgement
			if (strtemp == "OK")
				StackDefect.m_DefectJudgement = Judge_OK;
			else if (strtemp == "TR")
				StackDefect.m_DefectJudgement = Judge_TR;
			else if (strtemp == "PR")
				StackDefect.m_DefectJudgement = Judge_PR;
			/* < KJG 20220225 - #Index ADD Start >*/ 			
			else if (strtemp == "NG")
				StackDefect.m_DefectJudgement = Judge_NG;
			else if (strtemp == "ND")
				StackDefect.m_DefectJudgement = Judge_ND;
			/* < KJG 20220225 - #Index ADD End >*/
			else
				StackDefect.m_StackInfo = Stack_Unknown;

			pReadPoint = getParsingData(pReadPoint, 4, &strtemp);
			strncpy(StackDefect.m_strDefectCode, strtemp.GetBuffer(0), 4+1); // Null ¹®ÀÚ ‹š¹®¿¡ +1
			pReadPoint = getParsingData(pReadPoint, 2, &strtemp);
			if (strtemp == "UK")			
				StackDefect.m_StackInfo = Stack_Unknown;		
			else if (strtemp == "TD")
				StackDefect.m_StackInfo = Stack_TD;
			else if (strtemp == "SD")			
				StackDefect.m_StackInfo = Stack_SD;			
			else if (strtemp == "PD")
				StackDefect.m_StackInfo = Stack_PD;
			else if (strtemp == "SP")
				StackDefect.m_StackInfo = Stack_SP;
			else
				StackDefect.m_StackInfo = Stack_Unknown;

			pReadPoint = getParsingData(pReadPoint, 2, &StackDefect.m_nStackStepCount);
		/* < KMH 20220712 : #4230 MOD Start > */
			//pReadPoint = getParsingData(pReadPoint, 60, &strtemp); // Stack Step m_strStackFirst	
			//strncpy(StackDefect.m_strStackFirst, strtemp.GetBuffer(0), 60);
			pReadPoint = getParsingData(pReadPoint, 400, &strtemp); // Stack Step m_strStackFirst
			strncpy(StackDefect.m_strStackFirst, strtemp.GetBuffer(0), 400);
		/* < KMH 20220712 : #4230 MOD End > */
			pReadPoint = getParsingData(pReadPoint, 16, &strtemp); // ReviewImageName m_strRevImageName
			pReadPoint = getParsingData(pReadPoint, 12, &temp); // ¹Ì»ç¿ë
			pReadPoint = getParsingData(pReadPoint, 12, &temp); // ¹Ì»ç¿ë
			pReadPoint = getParsingData(pReadPoint, 12, &strtemp); // ZoneNum m_sZonePixelCount[i]
			
			stringstream ConvertZone(strtemp.GetBuffer(0));
			unsigned int nZoneHexValue;
			short sZonePixelCount[16] = { 0 };
			ConvertZone >> std::hex >> nZoneHexValue;
			for (int i = 0; i < 16; i++)
			{
				if (nZoneHexValue & 1)
				{
					sZonePixelCount[i] = 1;
				}
				nZoneHexValue = nZoneHexValue >> 1;
			}
			memcpy_s(StackDefect.m_sZonePixelCount, sizeof(StackDefect.m_sZonePixelCount), sZonePixelCount, sizeof(sZonePixelCount));

			pReadPoint = getParsingData(pReadPoint, 12, &strtemp);//m_DefectSizeType
			if (strtemp == "S")
				StackDefect.m_DefectSizeType = SizeType_Small;
			else if (strtemp == "M")
				StackDefect.m_DefectSizeType = SizeType_Mid;
			else if (strtemp == "L")
				StackDefect.m_DefectSizeType = SizeType_Large;
			else if (strtemp == "H")
				StackDefect.m_DefectSizeType = SizeType_Huge;
			else if (strtemp == "U")
				StackDefect.m_DefectSizeType = SizeType_Ultra;
			else
				StackDefect.m_DefectSizeType = SizeType_Small;	

			pReadPoint = getParsingData(pReadPoint, 12, &strtemp);//m_DefectSubType
			if (strtemp == "MC")
				StackDefect.m_DefectSubType = DefectSubType_MC;
			else if (strtemp == "MD")
				StackDefect.m_DefectSubType = DefectSubType_Mask;
			else if (strtemp == "CD")
				StackDefect.m_DefectSubType = DefectSubType_Common;
			else if (strtemp == "NO")
				StackDefect.m_DefectSubType = DefectSubType_NoDefect;
			else if (strtemp == "N")
				StackDefect.m_DefectSubType = DefectSubType_Normal;
			else
				StackDefect.m_DefectSubType = DefectSubType_Normal;

			pReadPoint = getParsingData(pReadPoint, 12, &temp);//m_ReviewDefect.m_fWsi_ResultData[1]
			pReadPoint = getParsingData(pReadPoint, 12, &temp);//m_ReviewDefect.m_fWsi_ResultData[3]
			pReadPoint = getParsingData(pReadPoint, 12, &strtemp);//¹Ì»ç¿ë
			pReadPoint = getParsingData(pReadPoint, 12, &StackDefect.m_nLevelSrcMin);//m_nLevelSrcMin
			pReadPoint = getParsingData(pReadPoint, 12, &StackDefect.m_nLevelSrcMax);//m_nLevelSrcMax
			pReadPoint = getParsingData(pReadPoint, 12, &StackDefect.m_nLevelSrcAvg);//m_nLevelSrcAvg
			pReadPoint = getParsingData(pReadPoint, 12, &StackDefect.m_sDefectPeak);//m_sDefectPeak
			pReadPoint = getParsingData(pReadPoint, 12, &strtemp);//m_ReviewDefect.m_strWsi_3DImageFilename
			pReadPoint = getParsingData(pReadPoint, 12, &strtemp);//m_strAoiImageName
			strncpy(StackDefect.m_strAoiImageName, strtemp.GetBuffer(0), 12);
			pReadPoint = getParsingData(pReadPoint, 12, &StackDefect.m_nScanIdx);//m_nScanIdx
			pReadPoint = getParsingData(pReadPoint, 12, &StackDefect.m_nCameraID);//m_nCameraID
			pReadPoint = getParsingData(pReadPoint, 12, &temp);//m_nDefectIdx
			pReadPoint = getParsingData(pReadPoint, 12, &StackDefect.m_nLevelRefMin);//m_nLevelRefMin
			pReadPoint = getParsingData(pReadPoint, 12, &StackDefect.m_nLevelRefMax);//m_nLevelRefMax
			pReadPoint = getParsingData(pReadPoint, 12, &StackDefect.m_nLevelRefAvg);//m_nLevelRefAvg
			pReadPoint = getParsingData(pReadPoint, 12, &strtemp);//m_ReviewDefect.m_fWsi_ResultData[4]
			pReadPoint = getParsingData(pReadPoint, 12, &strtemp);//m_ReviewDefect.m_fWsi_ResultData[5]
			pReadPoint = getParsingData(pReadPoint, 12, &strtemp);//m_ReviewDefect.m_fWsi_ResultData[6]
			pReadPoint = getParsingData(pReadPoint, 12, &strtemp);//m_nHliLayers
			StackDefect.m_nHliLayers = 0;
			{
				CString   resToken;
				int curPos = 0, idx = 0;
				resToken = strtemp.Tokenize(_T(","), curPos);
				while (resToken != "")
				{
					int nShiftCnt = atoi(resToken);
					StackDefect.m_nHliLayers = StackDefect.m_nHliLayers +( 1 << nShiftCnt );
					resToken = strtemp.Tokenize(_T(","), curPos);
				}
			}
			pReadPoint = getParsingData(pReadPoint, 12, &StackDefect.m_nCompact);//m_nCompact
			pReadPoint = getParsingData(pReadPoint, 12, &StackDefect.m_nThickness);//m_nThickness
			pReadPoint = getParsingData(pReadPoint, 12, &StackDefect.m_nMajor);//m_nMajor
			pReadPoint = getParsingData(pReadPoint, 12, &StackDefect.m_nMinor);//m_nMinor
			pReadPoint = getParsingData(pReadPoint, 12, &strtemp);//m_ReviewDefect.m_fWsi_ResultData[0]
			pReadPoint = getParsingData(pReadPoint, 12, &strtemp);//m_DefectType
			if (strtemp == "RB")
				StackDefect.m_DefectType = DefectType_RBlack;
			else if (strtemp == "RW")
				StackDefect.m_DefectType = DefectType_RWhite;
			else if (strtemp == "TB")
				StackDefect.m_DefectType = DefectType_TBlack;
			else if (strtemp == "TW")
				StackDefect.m_DefectType = DefectType_TWhite;
			else if (strtemp == "UN")
				StackDefect.m_DefectType = DefectType_Unknown;
			else
				StackDefect.m_DefectType = DefectType_Unknown;
	

			pReadPoint = getParsingData(pReadPoint, 12, &strtemp); // Shrink
			pReadPoint = getParsingData(pReadPoint, 12, &strtemp); // ZoneClassNum m_sZoneClassPixelCount[i]
			stringstream ConvertClass(strtemp.GetBuffer(0));
			unsigned int nClassHexValue;
			short sZoneClassPixelCount[16] = { 0 };
			ConvertClass >> std::hex >> nClassHexValue;
			for (int i = 0; i < 16; i++)
			{
				if (nClassHexValue & 1)
				{
					sZoneClassPixelCount[i] = 1;
				}
				nClassHexValue = nClassHexValue >> 1;
			}
			memcpy_s(StackDefect.m_sZoneClassPixelCount, sizeof(StackDefect.m_sZoneClassPixelCount), sZoneClassPixelCount, sizeof(sZoneClassPixelCount));


			vecStackDefect.push_back(StackDefect);
		}
	}

	AKLOG("Read RawMerge Size : %d", vecStackDefect.size());

	fclose(pf);

	m_vecStackDefect = vecStackDefect;

	for (int i = 0; i < m_vecStackDefect.size(); i++)
	{
		pGrmStack = pShared->GetRawMergeData(i);
		pGrmStack->clear();
		memcpy(pGrmStack, &m_vecStackDefect[i], sizeof(_grmDefectData));
	}

	pShared->GetGlassData()->m_nRawMergeNum = m_vecStackDefect.size(); // RawMerge
	pShared->GetGlassData()->m_bRawMergeRead = TRUE;

	/* < KJG 20220225 - #3850 MOD Start >*/ 
	//AKLOG("Import Vector Size : %d", m_vecStackDefect.size());
	AKLOG("Import Vector Size : [%s]%d", pShared->GetGlassData()->m_strRawMergeStepID, m_vecStackDefect.size());
	/* < KJG 20220225 - #3850 MOD End >*/
	return TRUE;
}

char* CRawResultReader::getParsingData(char* pBuf, int nLen, CString* pOutData)
{

	for (int i = nLen - 1; i >= 0; i--)
	{
		if (pBuf[i] != ' ')
		{
			pBuf[i + 1] = 0;
			break;
		}
	}
	*pOutData = pBuf;
	
	return &pBuf[nLen + 1]; //±¸ºÐÀÚ °Ç³Ê ¶Ù¾î¼­ ´ÙÀ½ ÀÐÀ» Æ÷ÀÎÆ® ³Ñ°ÜÁØ´Ù

}

char* CRawResultReader::getParsingData(char* pBuf, int nLen, short* pOutData)
{

	pBuf[nLen] = 0;
	*pOutData = atoi(pBuf);

	return &pBuf[nLen + 1]; //±¸ºÐÀÚ °Ç³Ê ¶Ù¾î¼­ ´ÙÀ½ ÀÐÀ» Æ÷ÀÎÆ® ³Ñ°ÜÁØ´Ù
}

char* CRawResultReader::getParsingData(char* pBuf, int nLen, int* pOutData)
{

	pBuf[nLen] = 0;
	*pOutData = atoi(pBuf);

	return &pBuf[nLen + 1]; //±¸ºÐÀÚ °Ç³Ê ¶Ù¾î¼­ ´ÙÀ½ ÀÐÀ» Æ÷ÀÎÆ® ³Ñ°ÜÁØ´Ù
}

BOOL CRawResultReader::readOptionFile(char* pFileName /*= "D:\\AOIServer\\ConfigFile\\MacroInfo.cfg"*/)
{
	if (pFileName == NULL) pFileName = m_strConfigFile;

	CakFileDB akFileDB;
	akFileDB.openfile(pFileName);

	akFileDB.getItem("RawMerge_Use", &m_bStackUse, 0);
	akFileDB.getItem("RawMerge_LocalPath", m_strLocalPath, "D:\\DIT_ResultData\\RawMerge");

	//< SWK 20220413 - #4053 MOD >
//	if (/*m_bStackUse && */m_nThreadStackFileReadFlag == 0)
	if (m_nThreadStackFileReadFlag == 0)
	{
		_beginthread(threadResultFileRead, NULL, this);
	}
	return TRUE;
}

void CRawResultReader::threadResultFileRead(void* pArg)
{
	CRawResultReader* pThis = (CRawResultReader*)pArg;

	pThis->m_nThreadStackFileReadFlag = 1;
	int nReadFailCount = 0;
	int nThreadCount = 0;
	CString strGlassID;

	while (pThis->m_nThreadStackFileReadFlag == 1)
	{
		if (pThis->m_nProcessState == RPS_CmdFileRead) //½ºÅÃÆÄÀÏ Àб⠼öÇà [±èÅÂÇö 2019/1/12]
		{
			strGlassID = pThis->m_strGlassID;

			pThis->m_nProcessState = RPS_StateFileRead;
			nThreadCount = 0;
			nReadFailCount = 0;

			AKLOG("RawMerge File Read Start : %s\\%s", pThis->m_strLocalPath, strGlassID);
			//< SWK 20220413 - #4053 DEL >
//			Sleep(3000);
			while (pThis->m_nProcessState == RPS_StateFileRead && pThis->m_nThreadStackFileReadFlag == 1)
			{
				if ((nThreadCount++ % 20) != 0) //¸í·É ¼öÇàÀ» ºü¸£°Ô °¨Áö À§ÇÑ Á¶Ä¡
				{
					Sleep(50);
					continue;
				}
				if (pThis->openFile(strGlassID.GetBuffer(0)) == TRUE)
				{
					pThis->m_nProcessState = RPS_ResultReadOK;
					AKLOG("RawMerge File Read Complete ");
					break;
				}

				nReadFailCount++;
				//< SWK 20220413 - #4053 DEL >
//				AKLOG("RawMerge File Read Try : %d", nReadFailCount);

				if (nReadFailCount > 10)
				{
					pThis->m_nProcessState = RPS_ResultReadFail;
					break;
				}
				//< SWK 20220413 - #4053 ADD >
				AKLOG("RawMerge File Read Try : %d", nReadFailCount);

				//< SWK 20220413 - #4053 DEL >
//				Sleep(50);
			}
			if (pThis->m_nProcessState != RPS_ResultReadOK)
			{
				pThis->m_nProcessState = RPS_ResultReadFail;
			}
		}
		if (nReadFailCount)
			Sleep(500);
	}

	pThis->m_nThreadStackFileReadFlag = 0;
}
/* <LJC 20211122 : #3820 ADD Start> */
/*< SWK 20220413 - #4053 MOD Start >*/
//void CRawResultReader::ProcessResultFileRead(void * pArg)
void CRawResultReader::ProcessResultFileRead()
/*< SWK 20220413 - #4053 MOD End >*/
{
	/*< SWK 20220413 - #4053 MOD Start >*/
//	CRawResultReader* pThis = (CRawResultReader*)pArg;
//
//	pThis->m_nThreadStackFileReadFlag = 1;
// 	int nReadFailCount = 0;
// 	int nThreadCount = 0;
//	CString strGlassID;
//
// 	while (pThis->m_nThreadStackFileReadFlag == 1)
// 	{
//		if (pThis->m_nProcessState == RPS_CmdFileRead) //½ºÅÃÆÄÀÏ Àб⠼öÇà [±èÅÂÇö 2019/1/12]
//		{
//			strGlassID = pThis->m_strGlassID;
//
//			pThis->m_nProcessState = RPS_StateFileRead;
// 			nThreadCount = 0;
// 			nReadFailCount = 0;
//			AKLOG("RawMerge File Read Start : %s\\%s", pThis->m_strLocalPath, strGlassID);
//			Sleep(3000);
// 			while (pThis->m_nProcessState == RPS_StateFileRead && pThis->m_nThreadStackFileReadFlag == 1)
// 			{
// 				if (pThis->openFile(strGlassID.GetBuffer(0)) == TRUE)
// 				{
// 					pThis->m_nProcessState = RPS_ResultReadOK;
// 					AKLOG("RawMerge File Read Complete ");
// 					break;
// 				}
// 				nReadFailCount++;
//				AKLOG("RawMerge File Read Try : %d", nReadFailCount);
// 				if (nReadFailCount > 10)
// 				{
// 					pThis->m_nProcessState = RPS_ResultReadFail;
// 					break;
// 				}
//				Sleep(50);
// 			}
// 			if (pThis->m_nProcessState != RPS_ResultReadOK)
// 			{
// 				pThis->m_nProcessState = RPS_ResultReadFail;
// 			}
//		}
// 		if (nReadFailCount)
// 			Sleep(500);
// 	}
// 	pThis->m_nThreadStackFileReadFlag = 0;
	m_nProcessState = RPS_StateFileRead;
	int nReadFailCount = 0;
	int nThreadCount = 0;
	AKLOG("RawMerge File Read Start : %s\\%s", m_strLocalPath, m_strGlassID);
	while (m_nProcessState == RPS_StateFileRead && m_nThreadStackFileReadFlag == 1)
	{
		if (openFile(m_strGlassID.GetBuffer(0)) == TRUE)
		{
			m_nProcessState = RPS_ResultReadOK;
			AKLOG("RawMerge File Read Complete ");
			break;
		}
		nReadFailCount++;
		if (nReadFailCount > 10)
		{
			m_nProcessState = RPS_ResultReadFail;
			break;
		}
		AKLOG("RawMerge File Read Try : %d", nReadFailCount);
	}
	if (m_nProcessState != RPS_ResultReadOK)
	{
		m_nProcessState = RPS_ResultReadFail;
	}
	/*< SWK 20220413 - #4053 MOD End >*/
}
/* <LJC 20211122 : #3820 ADD End> */
BOOL CRawResultReader::RawMergeFileReadStart(char* pGlassID)
{
	/*< SWK 20220413 - #4053 ADD Start >*/
	m_strGlassID = pGlassID;
	m_nProcessState = RPS_CmdFileRead;
	/*< SWK 20220413 - #4053 ADD End >*/

	if (m_nThreadStackFileReadFlag == 0)
	{
		_beginthread(threadResultFileRead, NULL, this);
	}

	if (m_nProcessState == RPS_StateFileRead)
	{
		m_nProcessState = RPS_CmdFileStop;
		while (m_nProcessState == RPS_CmdFileStop) Sleep(0);
	}

	/*< SWK 20220413 - #4053 DEL Start >
// 	m_strGlassID = pGlassID;
// 	m_nProcessState = RPS_CmdFileRead;
	< SWK 20220413 - #4053 DEL End >*/
	
	return TRUE;
}
/* <LJC 20211122 : #3820 ADD Start> */
BOOL CRawResultReader::ProcessRawMergeFileReadStart(char * pGlassID)
{
	if (m_nThreadStackFileReadFlag == 0)
	{
		//< SWK 20220413 - #4053 MOD >
//		ProcessResultFileRead(this);
		ProcessResultFileRead();
	}
	/*< SWK 20220413 - #4053 MOD Start >*/
// 	if (m_nProcessState == RPS_StateFileRead)
// 	{
// 		m_nProcessState = RPS_CmdFileStop;
// 		while (m_nProcessState == RPS_CmdFileStop) Sleep(0);
// 	}
// 
// 	m_strGlassID = pGlassID;
// 	m_nProcessState = RPS_CmdFileRead;
	else
	{
		if (m_nProcessState == RPS_StateFileRead)
		{
			m_nProcessState = RPS_CmdFileStop;
			while (!(m_nProcessState == RPS_ResultReadOK || m_nProcessState == RPS_ResultReadFail)) Sleep(0);
		}

		m_strGlassID = pGlassID;
		m_nProcessState = RPS_CmdFileRead;
	}
	/*< SWK 20220413 - #4053 MOD End >*/

	return TRUE;
}
/* <LJC 20211122 : #3820 ADD End> */
BOOL CRawResultReader::RawMergeFileReadStop(BOOL bWait/*=TRUE*/)
{
	/*
	if (bWait == TRUE && m_nProcessState == SPS_StateFileRead)
	{
		m_nProcessState = SPS_CmdFileStop;
		while (m_nProcessState == SPS_CmdFileStop) Sleep(0);
	}
	*/
	return TRUE;
}