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

#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;
	CDitGlassRawClient	GlassRawClient;
	GlassRawClient.ConnectServer();
	CDitGlassRawClient* pShared = &GlassRawClient;

	_grmDefectData* pGrmStack;

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

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

	if (pf == NULL)
		return FALSE;

	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;

		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;
			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);
			pReadPoint = getParsingData(pReadPoint, 60, &strtemp); // Stack Step m_strStackFirst	
			strncpy(StackDefect.m_strStackFirst, strtemp.GetBuffer(0), 60);
			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]
			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;
	
			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;

	AKLOG("Import Vector Size : %d", m_vecStackDefect.size());
	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 /*= "C:\\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");

	if (m_bStackUse && 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);
			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++;
				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;
}

BOOL CRawResultReader::RawMergeFileReadStart(char* pGlassID)
{
	if (m_nThreadStackFileReadFlag == 0)
	{
		_beginthread(threadResultFileRead, NULL, this);
	}

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

	m_strGlassID = pGlassID;
	m_nProcessState = RPS_CmdFileRead;
	
	return TRUE;
}

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;
}