#pragma once

#include "CHAutoDrsConnector/AutoDrsConnector.h"

#define GLASSID_LENGTH				50
#define CELLID_LENGTH				50
#define IMAGE_NAME_LENGTH			200
#define CONTROL_RESULTDATA_COUNT	650
#define STRING_LENGTH				10

namespace CHSignalControls_Network
{
	class CSignalControlResultData
	{
	public:
		CSignalControlResultData(void)
		{
			Reset();
		}
		virtual ~CSignalControlResultData(void)
		{
			Reset();
		}

		void Reset()
		{
			m_nDefectIndex	= 0;
			m_nCellIndex	= 0;
			m_nReviewType	= 0;
			m_nResultCode	= 0;
			ZeroMemory(m_strCellID, sizeof(char)*CELLID_LENGTH);
			ZeroMemory(m_strImageName, sizeof(char)*IMAGE_NAME_LENGTH);
			ZeroMemory(m_strDRSImageName, sizeof(char)*IMAGE_NAME_LENGTH);

			// // Review Module Motor Position [um]
			m_nUMMotorPosX    = 0;        
			m_nUMMotorPosY    = 0;    

			// Review Module Glass Position [um]
			m_nUMGlassPosX    = 0;
			m_nUMGlassPosY    = 0;

			// inspector info
			m_nLocation		= 0;	
			m_nSubType		= 0;
			m_nUMAreaSize	= 0;
			m_nStackInfo	= 0;
			m_nCameraID		= 0;
			m_nScanIndex	= 0;
			m_nLevelSrcMin	= 0;
			m_nLevelSrcMax	= 0;
			m_nLevelRefMin	= 0;
			m_nLevelRefMax	= 0;

			m_dataAutoDrsResult.Reset();
		}


		BOOL SaveData(FILE *fp)
		{
			USES_CONVERSION;
			if (fp==NULL) return FALSE;

			_ftprintf_s(fp, _T("%d, %d, %d, %s, %d, %d, %d, %d, %d, %d, %d, %d, %d, %d, %d, %d, %d, %d, %d, %s, %s, %d, %d, %d, %d, %d, %d, %d, %d, %d, %f, %d, %s, %s, %s, %s, %s, %s\n"),
				m_nDefectIndex,					
				m_nCellIndex,					
				m_nReviewType,					
				A2W(m_strCellID),
				m_nUMMotorPosX,  
				m_nUMMotorPosY,    
				m_nUMGlassPosX,
				m_nUMGlassPosY,
				m_nLocation,
				m_nSubType,
				m_nUMAreaSize,
				m_nStackInfo,
				m_nCameraID,
				m_nScanIndex,
				m_nLevelSrcMin,
				m_nLevelSrcMax,
				m_nLevelRefMin,
				m_nLevelRefMax,
				m_nResultCode,
				A2W(m_strImageName),
				A2W(m_strDRSImageName),

				// drs data
				m_dataAutoDrsResult.nReviewDefectIndex,
				m_dataAutoDrsResult.nSX,
				m_dataAutoDrsResult.nSY,
				m_dataAutoDrsResult.nEX,
				m_dataAutoDrsResult.nEY,
				m_dataAutoDrsResult.nFocus,
				m_dataAutoDrsResult.nBright,
				m_dataAutoDrsResult.nUniformity,
				m_dataAutoDrsResult.nWB,
				m_dataAutoDrsResult.fTilt,
				m_dataAutoDrsResult.bCopy,
				A2W(m_dataAutoDrsResult.strImageID),
				A2W(m_dataAutoDrsResult.strDefectName),
				A2W(m_dataAutoDrsResult.strDefectCode),
				A2W(m_dataAutoDrsResult.strDefect1),
				A2W(m_dataAutoDrsResult.strDefect2),
				A2W(m_dataAutoDrsResult.strDefect3)
				);

			return TRUE;
		}

		// info (server -> module)
		// point info
		int m_nDefectIndex;
		int m_nCellIndex;
		int m_nReviewType;
		char m_strCellID[CELLID_LENGTH];

		// // Review Module Motor Position [um]
		int    m_nUMMotorPosX;        
		int    m_nUMMotorPosY;    

		// Review Module Glass Position [um]
		int m_nUMGlassPosX;
		int m_nUMGlassPosY;

		// inspector info
		int m_nLocation;	
		int m_nSubType;
		int m_nUMAreaSize;
		int m_nStackInfo;
		int m_nCameraID;
		int m_nScanIndex;
		int m_nLevelSrcMin;
		int m_nLevelSrcMax;
		int m_nLevelRefMin;
		int m_nLevelRefMax;

		// result (module -> server)
		// point result
		int m_nResultCode;
		char m_strImageName[IMAGE_NAME_LENGTH];
		char m_strDRSImageName[IMAGE_NAME_LENGTH];

		// auto drs result
		CAutoDrsResultData m_dataAutoDrsResult;
	};

	class CSignalControlProcessorData
	{
	public:
		CSignalControlProcessorData(int nModuleIndex=-1)
		{
			Reset();
			m_nModuleIndex = nModuleIndex;
		}

		virtual ~CSignalControlProcessorData(void)
		{
			Reset();
		}

		void Reset()
		{
			m_nModuleIndex		= -1;
			m_nPlanIndex		= -1;
			m_nResultDataCount	= 0;
			ZeroMemory(m_strGlassID, sizeof(char)*GLASSID_LENGTH);
			ZeroMemory(m_ResultData, sizeof(CSignalControlResultData)*CONTROL_RESULTDATA_COUNT);
		}

		// getter
		int				GetModuleIndex() const		{ return m_nModuleIndex; }
		int				GetPlanIndex() const		{ return m_nPlanIndex; }
		int				GetResultDataCount() const	{ return m_nResultDataCount; }
		const char*		GetGlassID() const			{ return m_strGlassID; }
		CSignalControlResultData* GetResultData(int nIndex)
		{
			if (nIndex<0 || nIndex>=m_nResultDataCount) return NULL;
			return &m_ResultData[nIndex];
		}
		
		const CSignalControlResultData* GetResultData(int nIndex) const
		{
			if (nIndex<0 || nIndex>=m_nResultDataCount) return NULL;
			return &m_ResultData[nIndex];
		}

		CSignalControlResultData* GetResultDataRank(int nRank)
		{
			for(int i =0; i < m_nResultDataCount; i++)
			{
				CSignalControlResultData *pRessultData = GetResultData(i);
				if(pRessultData == NULL) continue;

				if(pRessultData->m_dataAutoDrsResult.nRankIndex == nRank)
				{
					return pRessultData;
				}
			}
			return NULL;
		}

		const CSignalControlResultData* GetResultDataRank(int nRank) const
		{
			for(int i =0; i < m_nResultDataCount; i++)
			{
				const CSignalControlResultData *pRessultData = GetResultData(i);
				if(pRessultData == NULL) continue;

				if(pRessultData->m_dataAutoDrsResult.nRankIndex == nRank)
				{
					return pRessultData;
				}
			}
			return NULL;
		}


		// setter
		void SetModuleIndex(int nIndex)						{ m_nModuleIndex = nIndex; }
		void SetPlanIndex(int nIndex)						{ m_nPlanIndex = nIndex; }
		void SetGlassID(const CString& strGlassID)
		{
#ifdef X
			USES_CONVERSION;
			sprintf_s(m_strGlassID, "%s", W2A(strGlassID));
#else
			USES_CONVERSION;
			sprintf_s(m_strGlassID, "%s", T2W(strGlassID));
#endif
		}
		void SetResultData(CSignalControlResultData* pResultData, int nResultCount)
		{
			if (nResultCount>CONTROL_RESULTDATA_COUNT) nResultCount = CONTROL_RESULTDATA_COUNT;

			m_nResultDataCount = 0;
			ZeroMemory(m_ResultData, sizeof(CSignalControlResultData)*CONTROL_RESULTDATA_COUNT);

			m_nResultDataCount = nResultCount;
			memcpy(m_ResultData, pResultData, sizeof(CSignalControlResultData)*m_nResultDataCount);
		}

	protected:
		int							m_nModuleIndex;
		int							m_nPlanIndex;
		int							m_nResultDataCount;
		char						m_strGlassID[GLASSID_LENGTH];
		CSignalControlResultData	m_ResultData[CONTROL_RESULTDATA_COUNT];
	};
};