#include "StdAfx.h"
#include "ChartGlassData.h"

CChartGlassData::CChartGlassData(void)
{
	for(int i = 0; i < MAX_GLASS_COUNT; i++)
	{
		m_szGlassID[i] = new char[MAX_STR_LEN];
		m_szRecipeID[i] = new char[MAX_STR_LEN];
		m_szDateTime[i] = new char[MAX_STR_LEN];
	}

	for (int j = 0; j < MAX_RESULT_COUNT; j++)
	{	
		m_szResultName[j] = new char[MAX_STR_LEN];
	}

	Reset();

/*	enum SymbolType
	{
		NoSymbol = 0,
		SquareSymbol = 1,
		DiamondSymbol = 2,
		TriangleSymbol = 3,
		RightTriangleSymbol = 4,
		LeftTriangleSymbol = 5,
		InvertedTriangleSymbol = 6,
		CircleSymbol = 7,
		CrossSymbol = 8,
		Cross2Symbol = 9,
		ChartDir_PolygonSymbol = 11,
		ChartDir_Polygon2Symbol = 12,
		ChartDir_StarSymbol = 13,
		ChartDir_CustomSymbol = 14 
	};
	*/
}

CChartGlassData::~CChartGlassData(void)
{
	for (int i = 0; i < MAX_GLASS_COUNT; i++)
	{
		delete [] m_szGlassID[i];
		m_szGlassID[i] = NULL;

		delete [] m_szRecipeID[i];
		m_szRecipeID[i] = NULL;

		delete [] m_szDateTime[i];
		m_szDateTime[i] = NULL;		
	}

	for (int i=0; i<MAX_RESULT_COUNT; i++)
	{	
		delete [] m_szResultName[i];
		m_szResultName[i] = NULL;
	}
}

void CChartGlassData::Reset()
{
	int i, j = 0;

	for(i = 0; i < MAX_GLASS_COUNT; i++)
	{
		ZeroMemory(m_szGlassID[i], MAX_STR_LEN);
		ZeroMemory(m_szRecipeID[i], MAX_STR_LEN);
		ZeroMemory(m_szDateTime[i], MAX_STR_LEN);

		m_dLowerThres[i] = 0.0;
		m_dUpperThres[i] = 0.0;
	}

	for (i = 0; i < MAX_RESULT_COUNT; i++)
	{	
		ZeroMemory(m_szResultName[i], MAX_STR_LEN);

		for(j = 0; j < MAX_GLASS_COUNT; j++)
		{
			m_dResultValue2[i][j] = 0.0;
		}
	}
	
	m_nResultColor[0] = RGB(255, 0, 0);
	m_nResultColor[1] = RGB(0, 0, 255);
	m_nResultColor[2] = RGB(0, 255, 0);
	m_nResultColor[3] = RGB(255, 255, 0);
	m_nResultColor[4] = RGB(0, 255, 255);
	m_nResultColor[5] = RGB(255, 0, 255);
	
	m_nResultSymbol[0] = Chart::SquareSymbol;
	m_nResultSymbol[1] = Chart::SquareSymbol;
	m_nResultSymbol[2] = Chart::DiamondSymbol;
	m_nResultSymbol[3] = Chart::DiamondSymbol;
	m_nResultSymbol[4] = Chart::TriangleSymbol;
	m_nResultSymbol[5] = Chart::TriangleSymbol;

	m_nResultCount		= MeasureResult_Count;
	m_nGlassCount		= 0;

	m_szResultName[0]= _T("AVG_DX");
	m_szResultName[1]= _T("AVG_DY");
	m_szResultName[2]= _T("MIN_DX");
	m_szResultName[3]= _T("MIN_DY");
	m_szResultName[4]= _T("MAX_DX");
	m_szResultName[5]= _T("MAX_DY");

	//WideCharToMultiByte(CP_ACP, 0, _T("AVG_DX"), -1, m_szResultName[0], MAX_STR_LEN, NULL, NULL);
	//WideCharToMultiByte(CP_ACP, 0, _T("AVG_DY"), -1, m_szResultName[1], MAX_STR_LEN, NULL, NULL);
	//WideCharToMultiByte(CP_ACP, 0, _T("MIN_DX"), -1, m_szResultName[2], MAX_STR_LEN, NULL, NULL);
	//WideCharToMultiByte(CP_ACP, 0, _T("MIN_DY"), -1, m_szResultName[3], MAX_STR_LEN, NULL, NULL);
	//WideCharToMultiByte(CP_ACP, 0, _T("MAX_DX"), -1, m_szResultName[4], MAX_STR_LEN, NULL, NULL);
	//WideCharToMultiByte(CP_ACP, 0, _T("MAX_DY"), -1, m_szResultName[5], MAX_STR_LEN, NULL, NULL);
}

BOOL CChartGlassData::CalculateReviewResult(const CGlassResult* pGlassResult, double *pResultValue)
{
	// set zero value
	memset(pResultValue, 0, sizeof(pResultValue));

	// check pointer
	if(pGlassResult == NULL) return FALSE;

	return TRUE;
}


BOOL CChartGlassData::CalculateMeasureResult(const CGlassResult* pGlassResult, double *pResultValue)
{
	// set zero value
	memset(pResultValue, 0, sizeof(pResultValue));

	// set min max value
	pResultValue[MeasureResult_MinDx] = DBL_MAX;
	pResultValue[MeasureResult_MinDy] = DBL_MAX;
	pResultValue[MeasureResult_MaxDx] = DBL_MIN;
	pResultValue[MeasureResult_MaxDy] = DBL_MIN;

	// check pointer
	if(pGlassResult == NULL) return FALSE;

	// result index
	int nDxIndex = 0;
	int nDyIndex = 1;
	int nMaxIndex = 1;

	// result count
	int pResultCount[MAX_RESULT_COUNT];
	memset(pResultCount, 0, sizeof(pResultCount));

	int nModuleCount = pGlassResult->GetMeasureResultCount();
	for(int nModuleIdx=0; nModuleIdx<nModuleCount; nModuleIdx++) // module
	{
		int nResultCnt = pGlassResult->GetSMeasureResultCount(nModuleIdx);

		for(int nResultIdx=0; nResultIdx<nResultCnt; nResultIdx++) // result
		{
			const SReviewResult* pNode = pGlassResult->GetSMeasureResult(nModuleIdx, nResultIdx);
			if (pNode==NULL) continue;

			int nFormulaCnt = (int)pNode->vecMeasure_ResultData.size();

			//DX, DY Index Change;
			for(int i=0;i<nFormulaCnt;i++)
			{
				if(pNode->vecMeasure_ResultData[i].m_nResultCode)
				{
					if(pNode->vecMeasure_ResultData[i].m_strResultName.Compare(_T("DX"))==0)
					{
						nDxIndex = i;
					}
					if(pNode->vecMeasure_ResultData[i].m_strResultName.Compare(_T("DY"))==0)
					{
						nDyIndex = i;
					}
				}
			}

			if (nFormulaCnt > nMaxIndex) // formula
			{
				double dDxValue = pNode->vecMeasure_ResultData[nDxIndex].m_dResultValue;
				double dDyValue = pNode->vecMeasure_ResultData[nDyIndex].m_dResultValue;

				pResultValue[MeasureResult_AvgDx] += dDxValue;
				pResultValue[MeasureResult_AvgDy] += dDyValue;

				pResultValue[MeasureResult_MinDx] = min(pResultValue[MeasureResult_MinDx], dDxValue);
				pResultValue[MeasureResult_MinDy] = min(pResultValue[MeasureResult_MinDy], dDyValue);

				pResultValue[MeasureResult_MaxDx] = max(pResultValue[MeasureResult_MaxDx], dDxValue);
				pResultValue[MeasureResult_MaxDy] = max(pResultValue[MeasureResult_MaxDy], dDyValue);

				pResultCount[MeasureResult_AvgDx]++;
				pResultCount[MeasureResult_AvgDy]++;
			}
			//Information
			//WideCharToMultiByte(CP_ACP, 0, pGlassResult->m_strGlassID, -1, m_szGlassID[nGlassIndex], MAX_STR_LEN, NULL, NULL);
		}
	}

	// calculate average
	pResultValue[MeasureResult_AvgDx] = pResultValue[MeasureResult_AvgDx] / pResultCount[MeasureResult_AvgDx];
	pResultValue[MeasureResult_AvgDy] = pResultValue[MeasureResult_AvgDy] / pResultCount[MeasureResult_AvgDy];

	
	return TRUE;
}

void CChartGlassData::CString_to_charA(char *Dst ,CString Src,unsigned int size)

{ //Cstring을 Dst에 복사
	size = (size*2)+1;//유니코드는 2바이트이므로 (2배 + (문자열종료 1바이트))

	unsigned int i=0;
	char* p = (char*)(*(int*)&Src);

	for(i=0;i<size;)
	{
		Dst[i/2] = p[i];//0,2,4,6,8 번째의 값을 0,1,2,3,4 번에 넣음
		i+=2;              
	}    
}

void CChartGlassData::MoveChartData(int nGlassIndex)
{
	for(int i=MAX_GLASS_COUNT - 1;i > 0; i--)
	{
		for(int j=0;j<MAX_RESULT_COUNT;j++)
		{
			m_dResultValue2[j][i] = m_dResultValue2[j][i-1];
		}
		strcpy_s(m_szGlassID[i], sizeof(m_szGlassID[i-1]), m_szGlassID[i-1]);
	}
}


void CChartGlassData::SetChartGlassData(int nMode, int nGlassIndex, const CGlassResult* pGlassResult)
{
	if(pGlassResult == NULL)	return;

	nGlassIndex %= MAX_GLASS_COUNT;
       int nLength = (sizeof(m_szGlassID) > strlen(pGlassResult->m_strGlassID)) ? strlen(pGlassResult->m_strGlassID) : sizeof(m_szGlassID);
        strncpy(*m_szGlassID, (LPSTR)(LPCSTR)pGlassResult->m_strGlassID, nLength);

	//WideCharToMultiByte(CP_ACP, 0, pGlassResult->m_strGlassID, -1, m_szGlassID[0], MAX_STR_LEN, NULL, NULL);
	//WideCharToMultiByte(CP_ACP, 0, pGlassResult->m_strRecipeID, -1, m_szRecipeID[nGlassIndex], MAX_STR_LEN, NULL, NULL);
	//WideCharToMultiByte(CP_ACP, 0, pGlassResult->m_strUnLoadingTime, -1, m_szDateTime[nGlassIndex], MAX_STR_LEN, NULL, NULL);	
	
	// set zero
	double	pResultValue[MAX_RESULT_COUNT];
	memset(pResultValue, 0, sizeof(pResultValue));

	// calculate result
	switch(nMode)
	{
	case UNIT_POINT:
		if (CalculateMeasureResult(pGlassResult, pResultValue))
		{
			for (int nResultIdx=0; nResultIdx<MAX_RESULT_COUNT; nResultIdx++)
			{
				m_dResultValue2[nResultIdx][0] = pResultValue[nResultIdx];
			}
		}
		break;

	case UNIT_GLASS:
		if (CalculateReviewResult(pGlassResult, pResultValue))
		{
			for (int nResultIdx=0; nResultIdx<MAX_RESULT_COUNT; nResultIdx++)
			{
				m_dResultValue2[nResultIdx][0] = pResultValue[nResultIdx];
			}
		}
		break;
	}
}

BaseChart* CChartGlassData::CreateChart(int nMode, int nListCnt, const char **imageMap, const CRect& rtRect, int nType)
{
	m_nGlassCount = nListCnt;
	//m_nGlassCount %= MAX_GLASS_COUNT;

	// 248,169,128 0xf8daa9
	XYChart *pChart = new XYChart(rtRect.Width(), rtRect.Height(), 0xf8daa9, 0x000000, 1);

	CRect rtGraphGab(50,30,20,70); // gab

	CRect areaRect(rtGraphGab.left, rtGraphGab.top, rtRect.Width()-rtGraphGab.right, rtRect.Height()-rtGraphGab.bottom);

	pChart->setPlotArea(areaRect.left, areaRect.top, areaRect.Width(), areaRect.Height(), 0xffffff, -1, -1, 0xcccccc, 0xcccccc);

	pChart->addLegend(areaRect.left, 2, false, "arialbd.ttf", 9)->setBackground(Chart::Transparent);
	
// 	if (m_nGlassCount<0) 
// 	{
// 		pChart->makeChart();
// 
// 		return pChart;
// 	}

	DrawGlassInfo(nMode, pChart);

	if(nType)
		DrawResultData(nMode, pChart, nType);
	else
		DrawResultData(nMode, pChart, nType);

	// Output the chart
	pChart->makeChart();	

	//include tool tip for the chart
	//imageMap = c->getHTMLImageMap("clickable", "Bold", "title='Index: {x}\nPPID: {field0}\nGlassID: {field1}\nTime: {field2}\nSucc: {field3}\nFail: {field4}'");//\nAvgValue:{field5}\nMaxValue:{field6}\nMinValue:{field7}");
	//m_MeasureGraph.setImageMap(imageMap);

	switch(nMode)
	{
	case 0:
		*imageMap = pChart->getHTMLImageMap("clickable", "Bold", "title='Date, Time : {field1|yyyy-mm-dd hh:nn:ss}\nRecipeID : {value}\nGlassID : {xLabel}\nTotal Defect : {value} ea\nReview Defect : {field3} ea'");
		break;

	case 1:
		*imageMap = pChart->getHTMLImageMap("clickable", "Bold", "title=' GlassID : {xLabel}\n Value : {value} um'");
		break;
	}	

	return pChart;
}

void CChartGlassData::DrawGlassInfo(int nMode, XYChart *pChart)
{
	int nLineWidthX = 2;
	int nLineWidthY = 2;

	char strValue[50];
	switch(nMode)
	{
	case 0:
		sprintf_s(strValue, 50, "Defect Count(ea)");
		break;
	case 1:
		sprintf_s(strValue, 50, "Measure Result(um)");
		break;
	}

	pChart->yAxis()->setAutoScale();
	pChart->yAxis()->setLabelFormat("{value}");
	pChart->yAxis()->setTitle(strValue, "arialbd.ttf", 9);
	pChart->yAxis()->setWidth(nLineWidthY);

	pChart->xAxis()->setAutoScale();
	pChart->xAxis()->setTitle("Glass ID", "arialbd.ttf", 9);
	pChart->xAxis()->setDateScale(0, MAX_GLASS_COUNT);

	pChart->xAxis()->setLabelStep(5);
	pChart->xAxis()->setWidth(nLineWidthX);

	// Draw GlassID X Axis
	//pChart->xAxis()->setLabelStep(1, 0);
	pChart->xAxis()->setLabels(StringArray(m_szGlassID, MAX_GLASS_COUNT))->setFontAngle(60);
	pChart->xAxis()->setTitle("Glass ID", "arialbi.ttf", 9);	
	
}


void CChartGlassData::DrawResultData(int nMode, XYChart *pChart, int nType)
{
	int nStartIndex = 0;
	if(nType)
		nStartIndex = 1;
	else
		nStartIndex = 0;

	for (int i = nStartIndex; i < m_nResultCount; i+=2)
	{		
		// Add a line layer to the chart
		LineLayer *layer = pChart->addLineLayer();

		// Add the first line. Plot the points with a 7 pixel square symbol
		layer->addDataSet(
			DoubleArray(m_dResultValue2[i], MAX_GLASS_COUNT), 
			m_nResultColor[i], 
			m_szResultName[i])->setDataSymbol(m_nResultSymbol[i], 5);
	}
}