#include "StdAfx.h"
#include "PathSchedulerResult.h"

CPathSchedulerResult::CPathSchedulerResult(int nModuleIdx, int nScanIdx) : nModuleIndex(nModuleIdx), nScanIndex(nScanIdx)	
{ 
	pScheduleResult = NULL; 
	Reset(); 
}

CPathSchedulerResult::~CPathSchedulerResult(void)	
{ 
	Reset(); 
}

void CPathSchedulerResult::Reset()
{
	if (pScheduleResult) delete [] pScheduleResult;
	pScheduleResult = NULL;
	nScheduleResultCount = 0;

	nCollisionResultIndex	= -1;
	dCollisionResultTime	= 0.0;
	nCollisionPositionX		= -1; // -1Àº Ãæµ¹À§Ä¡ °è»ê¾ÈµÊ.
	nCollisionPositionY		= -1; // -1Àº Ãæµ¹À§Ä¡ °è»ê¾ÈµÊ.
}

CPathSchedulerResult::CPathSchedulerResult(const CPathSchedulerResult& rhs)
{
	pScheduleResult = NULL;
	Reset();
	if (this != &rhs)
	{
		nModuleIndex			= rhs.nModuleIndex;
		nScanIndex				= rhs.nScanIndex;
		nScheduleResultCount	= rhs.nScheduleResultCount;
		if (nScheduleResultCount>0)
		{
			pScheduleResult = new SSchedulerResult[nScheduleResultCount];
			memcpy(pScheduleResult, rhs.pScheduleResult, sizeof(SSchedulerResult)*nScheduleResultCount);
		}

		nCollisionResultIndex	= rhs.nCollisionResultIndex;
		dCollisionResultTime	= rhs.dCollisionResultTime;
		nCollisionPositionX		= rhs.nCollisionPositionX;
		nCollisionPositionY		= rhs.nCollisionPositionY;
	}
}

CPathSchedulerResult& CPathSchedulerResult::operator=(const CPathSchedulerResult& rhs)
{
	if (this != &rhs)
	{
		Reset();
		nModuleIndex			= rhs.nModuleIndex;
		nScanIndex				= rhs.nScanIndex;
		nScheduleResultCount	= rhs.nScheduleResultCount;
		if (nScheduleResultCount>0)
		{
			pScheduleResult = new SSchedulerResult[nScheduleResultCount];
			memcpy(pScheduleResult, rhs.pScheduleResult, sizeof(SSchedulerResult)*nScheduleResultCount);
		}

		nCollisionResultIndex	= rhs.nCollisionResultIndex;
		dCollisionResultTime	= rhs.dCollisionResultTime;
		nCollisionPositionX		= rhs.nCollisionPositionX;
		nCollisionPositionY		= rhs.nCollisionPositionY;
	}
	return *this;
}

void CPathSchedulerResult::AddHeadScheduleResult(CPathSchedulerResult& reviewResult)
{
	int nAddCount = 0;
	if ((nAddCount=reviewResult.GetPathSchedulerResultCount())<1) return;

	CPathSchedulerResult tempResult(*this);
	int nOldCount = tempResult.GetPathSchedulerResultCount();

	int nIndex		= nCollisionResultIndex;
	double dTime	= dCollisionResultTime;
	int nColliX		= nCollisionPositionX;
	int nColliY		= nCollisionPositionY;

	Reset();

	int nTotalCount = nAddCount + nOldCount;
	pScheduleResult = new SSchedulerResult[nTotalCount];

	nScheduleResultCount = nTotalCount;
	memcpy(pScheduleResult, reviewResult.GetPathSchedulerResult(), sizeof(SSchedulerResult)*nAddCount);
	memcpy(&pScheduleResult[nAddCount], tempResult.GetPathSchedulerResult(), sizeof(SSchedulerResult)*nOldCount);

	nCollisionResultIndex	= nIndex;
	dCollisionResultTime	= dTime;
	nCollisionPositionX		= nColliX; // -1Àº Ãæµ¹À§Ä¡ °è»ê¾ÈµÊ.
	nCollisionPositionY		= nColliY; // -1Àº Ãæµ¹À§Ä¡ °è»ê¾ÈµÊ.
	
}

void CPathSchedulerResult::AddTailScheduleResult(CPathSchedulerResult& reviewResult)
{
	int nAddCount = 0;
	if ((nAddCount=reviewResult.GetPathSchedulerResultCount())<1) return;

	for (int i=0; i<nAddCount; i++)
	{
		reviewResult.pScheduleResult[i].nPointIndex += nScheduleResultCount;
	}

	CPathSchedulerResult tempResult(*this);
	int nOldCount = tempResult.GetPathSchedulerResultCount();

	int nIndex		= nCollisionResultIndex;
	double dTime	= dCollisionResultTime;
	int nColliX		= nCollisionPositionX;
	int nColliY		= nCollisionPositionY;

	Reset();

	int nTotalCount = nOldCount + nAddCount;
	pScheduleResult = new SSchedulerResult[nTotalCount];

	nScheduleResultCount = nTotalCount;
	memcpy(pScheduleResult, tempResult.GetPathSchedulerResult(), sizeof(SSchedulerResult)*nOldCount);
	memcpy(&pScheduleResult[nOldCount], reviewResult.GetPathSchedulerResult(), sizeof(SSchedulerResult)*nAddCount);


	nCollisionResultIndex	= nIndex;
	dCollisionResultTime	= dTime;
	nCollisionPositionX		= nColliX; // -1Àº Ãæµ¹À§Ä¡ °è»ê¾ÈµÊ.
	nCollisionPositionY		= nColliY; // -1Àº Ãæµ¹À§Ä¡ °è»ê¾ÈµÊ.
}

void CPathSchedulerResult::SetScheduleResultCount(int nCount)
{
	if (nCount<1) return;

	int nIndex		= nCollisionResultIndex;
	double dTime	= dCollisionResultTime;
	int nColliX		= nCollisionPositionX;
	int nColliY		= nCollisionPositionY;

	Reset();

	nScheduleResultCount = nCount;

	if (pScheduleResult) delete [] pScheduleResult;
	pScheduleResult = NULL;
	pScheduleResult = new SSchedulerResult[nScheduleResultCount];

	nCollisionResultIndex	= nIndex;
	dCollisionResultTime	= dTime;
	nCollisionPositionX		= nColliX; // -1Àº Ãæµ¹À§Ä¡ °è»ê¾ÈµÊ.
	nCollisionPositionY		= nColliY; // -1Àº Ãæµ¹À§Ä¡ °è»ê¾ÈµÊ.
}

void CPathSchedulerResult::ResizeScheduleResult(int nCount)
{
	if (nCount>=nScheduleResultCount) return;

	CPathSchedulerResult tempResult(*this);

	int nIndex		= nCollisionResultIndex;
	double dTime	= dCollisionResultTime;
	int nColliX		= nCollisionPositionX;
	int nColliY		= nCollisionPositionY;

	Reset();

	nScheduleResultCount = nCount;
	pScheduleResult = new SSchedulerResult[nScheduleResultCount];

	memcpy(pScheduleResult, tempResult.GetPathSchedulerResult(), sizeof(SSchedulerResult)*nScheduleResultCount);

	nCollisionResultIndex	= nIndex;
	dCollisionResultTime	= dTime;
	nCollisionPositionX		= nColliX; // -1Àº Ãæµ¹À§Ä¡ °è»ê¾ÈµÊ.
	nCollisionPositionY		= nColliY; // -1Àº Ãæµ¹À§Ä¡ °è»ê¾ÈµÊ.
}

void CPathSchedulerResult::SetScheduleResult(int nIndex, const SSchedulerResult& scheduleResult)
{
	if (nIndex<0 || nIndex>=nScheduleResultCount) return;
	pScheduleResult[nIndex] = scheduleResult;
}

SSchedulerResult* CPathSchedulerResult::GetPathSchedulerResult(int nIndex)
{
	if (nIndex<0 || nIndex>=nScheduleResultCount) return NULL;
	return &pScheduleResult[nIndex];
}

const  SSchedulerResult* CPathSchedulerResult::GetPathSchedulerResult(int nIndex) const
{
	if (nIndex<0 || nIndex>=nScheduleResultCount) return NULL;
	return &pScheduleResult[nIndex];
}

int CPathSchedulerResult::GetModuleIndex() const
{
	return nModuleIndex;
}

int	CPathSchedulerResult::GetPathSchedulerResultCount()	const
{ 
	return nScheduleResultCount; 
}

SSchedulerResult* CPathSchedulerResult::GetPathSchedulerResult()	
{ 
	return pScheduleResult; 
}

const SSchedulerResult* CPathSchedulerResult::GetPathSchedulerResult() const
{ 
	return pScheduleResult; 
}


double CPathSchedulerResult::GetTotalSchedulerTime() const
{
	double dTime = 0.0;
	for (int i=0; i<nScheduleResultCount; i++)
	{
		dTime += pScheduleResult[i].GetDurationTime();

		if (nCollisionResultIndex==i)
		{
			if (dTime < dCollisionResultTime)
			{
				dTime = dCollisionResultTime;
			}
		}
	}

	return dTime;
}

double CPathSchedulerResult::GetTotalSchedulerTime(int nIndex) const
{
	if (nIndex<0 || nIndex>=nScheduleResultCount) return -1.0;
	double dTime = 0.0;
	for (int i=0; i<=nIndex; i++)
	{
		dTime += pScheduleResult[i].GetDurationTime();

		if (nCollisionResultIndex==i)
		{
			if (dTime < dCollisionResultTime)
			{
				dTime = dCollisionResultTime;
			}
		}
	}
	return dTime;
}

double CPathSchedulerResult::GetScheduleTime(int nIndex) const
{
	if (nIndex<0 || nIndex>=nScheduleResultCount) return -1.0;

	return pScheduleResult[nIndex].GetDurationTime();
}

double CPathSchedulerResult::GetScheduleTime(int nStartIdx, int nEndIdx) const
{
	if (nStartIdx<0) return -1.0;

	if (nStartIdx > nEndIdx) return -1.0;

	if (nEndIdx>=nScheduleResultCount) return -1.0;

	double dTime = 0.0;
	for (int i=nStartIdx; i<=nEndIdx; i++)
	{
		dTime += pScheduleResult[i].GetDurationTime();
	}

	return dTime;
}


double CPathSchedulerResult::GetTotalSchedulerDistance() const
{
	double dDist = 0.0;
	for (int i=0; i<nScheduleResultCount; i++)
	{
		dDist += pScheduleResult[i].dMoveDistance; 
	}
	return dDist;
}

double CPathSchedulerResult::GetTotalSchedulerDistance(int nIndex) const
{
	if (nIndex>=nScheduleResultCount) return -1.0;
	double dDist = 0.0;
	for (int i=0; i<=nIndex; i++)
	{
		dDist += pScheduleResult[i].dMoveDistance; 
	}
	return dDist;
}


BOOL CPathSchedulerResult::LoadResult(const CString& strFilename, CPathSchedulerResult& reviewResult)
{
	FILE *fp = NULL;

	_tfopen_s(&fp, strFilename, _T("r"));

	if (fp==NULL) return FALSE;

	int nValue = 0;
	TCHAR strValue[200];
	double dValue = 0.0;

	_ftscanf_s(fp, _T("%s,"), strValue, 13);
	_ftscanf_s(fp, _T("%d\n"), &nValue);

	if (nValue<1) 
	{
		fclose(fp);
		return FALSE;
	}


	//for (int i=0; i<13; i++)
	_ftscanf_s(fp, _T("%s\n"), strValue, 104);

	reviewResult.SetScheduleResultCount(nValue);
	for (int i=0; i<nValue; i++)
	{
		SSchedulerResult *pNode = reviewResult.GetPathSchedulerResult(i);
		if (pNode==NULL) continue;

		_ftscanf_s(fp, _T("%d,%d,%lf,%lf,%d,%lf,%lf,%lf,%lf,%lf,%lf,%lf,%lf\n"), 
			&nValue, 
			&pNode->nPointIndex, 
			&pNode->dPositionX, 
			&pNode->dPositionY, 
			&pNode->nAxisType,
			&pNode->dMoveDistance, 
			&pNode->dMoveSpeed, 
			&pNode->dMoveAccel,
			&pNode->dMoveDecel,
			&pNode->dMoveTime,
			&pNode->dAutoFocusTime,
			&pNode->dImageGrabTime,
			&dValue );
	}

	fclose(fp);

	return TRUE;
}

BOOL CPathSchedulerResult::SaveResult(const CString& strFilename, CPathSchedulerResult& reviewResult)
{
	int nResultCount = 0;
	if ((nResultCount=reviewResult.GetPathSchedulerResultCount())<1) return FALSE;

	FILE *fp = NULL;

	_tfopen_s(&fp, strFilename, _T("w"));

	if (fp==NULL) return FALSE;

	_ftprintf_s(fp, _T("result_count,%d\n"), nResultCount);

	_ftprintf_s(fp, _T("index,prev_index,pos_x,pos_y,axis_type,distance,speed,accel,decel,move_time,af_time,grab_time,motion_time,total_time\n"));

	double dTotalDistance, dTotalSpeed, dTotalAccel, dTotalDecel, dTotalMoveTime, dTotalAFTime, dTotalImageTime, dTotalMotionTime, dTotalTime;
	dTotalDistance=dTotalSpeed=dTotalAccel=dTotalDecel=dTotalMoveTime=dTotalAFTime=dTotalImageTime=dTotalMotionTime=dTotalTime=0.0;

	for (int i=0; i<nResultCount; i++)
	{
		SSchedulerResult *pNode = reviewResult.GetPathSchedulerResult(i);
		if (pNode==NULL) continue;

		_ftprintf_s(fp, _T("%d,%d,%.3lf,%.3lf,%d,%.3lf,%.3lf,%.3lf,%.3lf,%.3lf,%.3lf,%.3lf,%.3lf,%.3lf\n"), 
			i, 
			pNode->nPointIndex, 
			pNode->dPositionX, 
			pNode->dPositionY, 
			pNode->nAxisType,
			pNode->dMoveDistance, 
			pNode->dMoveSpeed, 
			pNode->dMoveAccel,
			pNode->dMoveDecel,
			pNode->dMoveTime,
			pNode->dAutoFocusTime,
			pNode->dImageGrabTime,
			pNode->dMotionDelayTime,
			pNode->GetDurationTime() );

		dTotalDistance	+= pNode->dMoveDistance;
		dTotalSpeed		+= pNode->dMoveSpeed;
		dTotalAccel		+= pNode->dMoveAccel;
		dTotalDecel		+= pNode->dMoveDecel;
		dTotalMoveTime	+= pNode->dMoveTime;
		dTotalAFTime	+= pNode->dAutoFocusTime;
		dTotalImageTime += pNode->dImageGrabTime;
		dTotalMotionTime += pNode->dMotionDelayTime;
		dTotalTime		+= pNode->GetDurationTime();
	}

	_ftprintf_s(fp, _T("Total,,,,,%.3lf,%.3lf,%.3lf,%.3lf,%.3lf,%.3lf,%.3lf,%.3lf,%.3lf\n"), 
		dTotalDistance, dTotalSpeed, dTotalAccel, dTotalDecel, dTotalMoveTime, dTotalAFTime, dTotalImageTime, dTotalMotionTime, dTotalTime);

	_ftprintf_s(fp, _T("Average,,,,,%.3lf,%.3lf,%.3lf,%.3lf,%.3lf,%.3lf,%.3lf,%.3lf,%.3lf"), 
		dTotalDistance/double(nResultCount), dTotalSpeed/double(nResultCount), dTotalAccel/double(nResultCount), dTotalDecel/double(nResultCount), 
		dTotalMoveTime/double(nResultCount), dTotalAFTime/double(nResultCount), dTotalImageTime/double(nResultCount), dTotalMotionTime/double(nResultCount), dTotalTime/double(nResultCount));

	fclose(fp);

	return TRUE;
}

void CPathSchedulerResult::SetCollisionResultIndex( int nIndex )
{
	nCollisionResultIndex = nIndex;
}

void CPathSchedulerResult::SetCollisionResultTime( double dTime )
{
	dCollisionResultTime = dTime;
}

int CPathSchedulerResult::GetCollisionResultIndex() const
{
	return nCollisionResultIndex;
}

double CPathSchedulerResult::GetCollisionResultTime() const
{
	return dCollisionResultTime;
}

int CPathSchedulerResult::GetScanIndex() const
{
	return nScanIndex;
}

void CPathSchedulerResult::SetCollisionPositionX( int nPos )
{
	nCollisionPositionX = nPos;
}

int CPathSchedulerResult::GetCollisionPositionX() const
{
	return nCollisionPositionX;
}

void CPathSchedulerResult::SetCollisionPositionY( int nPos )
{
	nCollisionPositionY = nPos;
}

int CPathSchedulerResult::GetCollisionPositionY() const
{
	return nCollisionPositionY;
}