#pragma once

#include <vector>

enum MapDrawType { 
	MapDrawCell=0, MapDrawDefect, 
	MapDrawReviewDefect, MapDrawReviewPath, 
	MapDrawWsiDefect, MapDrawWsiPath, 
	MapDrawSelectedDefect, MapDrawCameraPosition, 
	MapDrawUserPoint, MapDrawUserPath,
	MapDrawMeasurePoint, MapDrawMeasurePath,
	MapDrawWsiReflowDefect, MapDrawWsiReflowPath, 
	MapDrawWsiUserDefect, MapDrawWsiUserPath,
	MapDrawCount 
};

struct SDefectFilter
{   
	SDefectFilter()
	{
		Reset();
	}

	void Reset()
	{
		bMeasurePoint = FALSE;
		bUseWSI = FALSE;
		bUseWSIMeasurement = FALSE;
		bAutoSelectCamera = FALSE;
		bUseSimulation = FALSE;

		for (int i=0; i<MapDrawCount; i++) pDraw[i] = TRUE;

		nOptionType		= 0;

		bOpticDark		= TRUE;
		bOpticBright	= TRUE;
		bOpticDkBr		= TRUE;

		bGrayBlack		= TRUE;
		bGrayWhite		= TRUE;

		bStackTD=TRUE;
		bStackSD = TRUE;
		bStackSP = TRUE;
		bStackCD = TRUE;
		bStackPD = TRUE;

		bSizeSmall		= TRUE;
		bSizeMedium		= TRUE;
		bSizeLarge		= TRUE;
		bSizeHuge		= TRUE;

		bJudgeOK		= TRUE;
		bJudgeTR		= TRUE;
		bJudgePR		= TRUE;
		bJudgeND		= TRUE;

		bProcessNormal	= TRUE;
		bProcessMask	= TRUE;
		bProcessCommon	= TRUE;
		bProcessCrack	= TRUE;

		bPositionFront	= TRUE;
		bPositionBack	= TRUE;
	}


	BOOL bMeasurePoint;
	BOOL bUseWSI;
	BOOL bUseWSIMeasurement;
	BOOL bAutoSelectCamera;
	BOOL bUseSimulation;

	BOOL pDraw[MapDrawCount];

	int nOptionType;

	BOOL bOpticDark;
	BOOL bOpticBright;
	BOOL bOpticDkBr;

	BOOL bGrayBlack;
	BOOL bGrayWhite;

	BOOL bStackTD;
	BOOL bStackSD;
	BOOL bStackSP;
	BOOL bStackCD;
	BOOL bStackPD; //taek

	BOOL bSizeSmall;
	BOOL bSizeMedium;
	BOOL bSizeLarge;
	BOOL bSizeHuge;

	BOOL bJudgeOK;
	BOOL bJudgeTR;
	BOOL bJudgePR;
	/*< LYW 20211220 - #0000 ADD Start >*/
	BOOL bJudgeND;
	/*< LYW 20211220 - #0000 ADD End >*/

	BOOL bProcessNormal;
	BOOL bProcessMask;
	BOOL bProcessCommon;
	BOOL bProcessCrack;

	BOOL bPositionFront;
	BOOL bPositionBack;
};

struct SCameraControl
{
	SCameraControl() 
	{
		bSelected			= FALSE;
		bAFMTracking		= FALSE;
		bDigitalZoom		= FALSE;
		nCameraControl		= 0;
		nZoomLevel			= 0;  //tEST 0702
		strAFMRecipe		= _T("");
		nAFMRecipe			= 0;
		nAFMLevel			= 0;
		nReviewedDefectCount =0;
		
		nLightLevel			= 0;
		nLightStatus		= 100;
		nLightLevelMin		= 0;
		nLightLevelMax		= 255;
		
		nExposureTime		= 500;
	}

	BOOL	bSelected;
	BOOL	bAFMTracking;
	BOOL	bDigitalZoom;
	int		nCameraControl;
	int		nZoomLevel;

	CString	strAFMRecipe;
	int		nAFMRecipe;
	int		nAFMLevel;
	int		nReviewedDefectCount;
	
	int		nLightStatus;
	int		nLightLevel;
	int		nLightLevelMin;
	int		nLightLevelMax;

	int		nExposureTime;
};

struct SCameraInfo
{
	SCameraInfo() 
	{
		nFrameWidth = 0;
		nFrameHeight = 0;
		nFrameChannels = 0;

		nDirectionX = 1;
		nDirectionY = 1;

		dOffsetX = 0.0;
		dOffsetY = 0.0;

		dTriangleGab	= 100.0;//
		dResolution		= 1.0; // um/pixel
	}
	int		nFrameWidth;
	int		nFrameHeight;
	int		nFrameChannels;

	int		nDirectionX;
	int		nDirectionY;

	double	dOffsetX;
	double	dOffsetY;

	double	dTriangleGab;
	double	dResolution;

};
typedef std::vector<SCameraInfo>			VectorSCameraInfo;
typedef std::vector<SCameraInfo>::iterator	VectorSCameraInfoIt;

struct SMotorPosition
{
	SMotorPosition() 
	{
		dMotorPosX	= 0.0;
		dMotorPosY	= 0.0;
		dMotorPosZ	= 0.0;
		dGlassPosX	= 0.0;
		dGlassPosY	= 0.0;
		dGlassPosZ	= 0.0;

		bUseWSI		= FALSE;
		dWSIOffsetX	= 0.0;
		dWSIOffsetY	= 0.0;
		dWSIPosX	= 0.0;
		dWSIPosY	= 0.0;
	}

	double	dMotorPosX;
	double	dMotorPosY;
	double	dMotorPosZ;

	double	dGlassPosX;
	double	dGlassPosY;
	double	dGlassPosZ;

	BOOL	bUseWSI;
	double	dWSIOffsetX;
	double	dWSIOffsetY;
	double	dWSIPosX;
	double	dWSIPosY;
	
};


struct SMotorStatus
{
	SMotorStatus() 
	{
		lMotorStatusX	= 0;
		lMotorStatusY	= 0;
		lMotorStatusSx	= 0;
		nBitCount		= 8;
	}

	BOOL AxisStatusX(int nIndex)
	{
		long nTemp = 1 << nIndex;
		return (lMotorStatusX & nTemp);
	}

	BOOL AxisStatusY(int nIndex)
	{
		long nTemp = 1 << nIndex;
		return (lMotorStatusY & nTemp);
	}

	BOOL AxisStatusSx(int nIndex)
	{
		long nTemp = 1 << nIndex;
		return (lMotorStatusSx & nTemp);
	}

	long	lMotorStatusX;
	long	lMotorStatusY;
	long	lMotorStatusSx;

	int		nBitCount;
};


struct SThetaMotorInfo
{
	SThetaMotorInfo() 
	{
		lStatus		= 0;
		dPosition	= 0.0;
	}

	BOOL AxisStatus(int nIndex)
	{
		long nTemp = 1 << nIndex;
		return (lStatus & nTemp);
	}

	long	lStatus;
	double	dPosition;
};

struct SSignalIOStatus
{
	SSignalIOStatus() 
	{
		Reset();
	}

	void Reset()
	{
		nSignalRead		= 0;
		nSignalWrite	= 0;
		nBitCount		= 16;
	}

	int GetBitCount() const
	{
		return nBitCount;
	}

	BOOL GetReadSignal(int nIndex) const
	{
		UINT nTemp = 1 << nIndex;
		return (nSignalRead & nTemp);
	}

	BOOL GetWriteSignal(int nIndex) const
	{
		UINT nTemp = 1 << nIndex;
		return (nSignalWrite & nTemp);		
	}

	UINT	nSignalRead;
	UINT	nSignalWrite;
	int		nBitCount;
};

struct SAxisIndex
{
	SAxisIndex() 
	{
		nAxisIndexX		= -1;
		nAxisIndexY		= -1;
		nAxisIndexSx	= -1;
	}
	int		nAxisIndexX;
	int		nAxisIndexY;
	int		nAxisIndexSx;
};

struct SCoordInfo
{
	SCoordInfo() 
	{
		bStandard	= FALSE;
		nDirectionX	= 1;
		nDirectionY	= 1;
		dDistanceX	= 0.0;
		dDistanceY	= 0.0;
		dOffsetX	= 0.0;
		dOffsetY	= 0.0;
	}

	BOOL	bStandard;
	short	nDirectionX;
	short	nDirectionY;
	double	dDistanceX;
	double	dDistanceY;
	double	dOffsetX;
	double	dOffsetY;
};

struct SExternalIndex
{
	SExternalIndex()
	{
		nLight_Index		= -1;
		nLight_Channel		= 0;
		nAFM_Index			= -1;
		nAFM_Channel		= 0;
		nRevolver_Index		= -1;
		nRevolver_Channel	= 0;
		nWSI_Index			= -1;
		nWSI_Channel		= 0;
	}

	int nLight_Index;
	int nLight_Channel;
	int nAFM_Index;
	int nAFM_Channel;
	int nRevolver_Index;
	int nRevolver_Channel;
	int nWSI_Index;
	int nWSI_Channel;
};

struct SMagnificInfo
{
	SMagnificInfo()
	{
		strMagnificName		= _T("1.0X");
		dMagnification		= 1.0;
		dMagnificOffsetX	= 0.0;
		dMagnificOffsetY	= 0.0;
		//dTestOffsetX	= 0.0;
		//dTestOffsetY	= 0.0;
		nMsgHomePosition	= 0;
	}

	double	dMagnification;
	CString strMagnificName;
	double	dMagnificOffsetX;
	double	dMagnificOffsetY;
	//double	dTestOffsetX; //배율별 오프셋
	//double	dTestOffsetY; 
	int		nMsgHomePosition;
};
//
//struct _ProtocalReviewModlueData 
//{
//	_ProtocalReviewModlueData()
//	{
//	//모듈 현재 좌표
//	int m_nModuleGlassPosX; //글라스 X위치
//	int m_nModuleGlassPosY; //글라스 Y위치
//
//	int m_nPlanDefectNum;	//리뷰할 결함 갯수
//	int m_nReviewedDefectNum; //리뷰한 결함 갯수
//
//	//리뷰할 결함 위치
//	int m_nPlanReviewPosX;
//	int m_nPlanReviewPosY;
//	}
//};

typedef std::vector<SMagnificInfo>					VectorSMagnificInfo;
typedef std::vector<SMagnificInfo>::iterator		VectorSMagnificInfoIt;
typedef std::vector<SMagnificInfo>::const_iterator	constVectorSMagnificInfoIt;



class CModuleStatus
{
public:
	CModuleStatus(int nType, int nLens, int nModuleIdx, int nGantryIdx, int nHeaderIdx);
	virtual ~CModuleStatus(void);
	void	SetStandard(BOOL bStandard)	{ sCoordInfo.bStandard = bStandard; }
	void	SetSelected(BOOL bSelected);	

	int		GetModuleType() const		{ return nModuleType; }
	int		GetLensType() const			{ return nLensType; }
	int		GetModuleIndex() const		{ return nModuleIndex; }
	int		GetGantryIndex() const		{ return nGantryIndex; }
	int		GetHeaderIndex() const		{ return nHeaderIndex; }
	BOOL	GetStandard() const			{ return sCoordInfo.bStandard; }
	BOOL	GetSelected() const			{ return sCameraControl.bSelected; }
	
	int		GetCameraInfoCount() const;	
	int		GetMagnificInfoCount() const;
	
	SExternalIndex*				GetExternalIndex();
	SCameraControl*				GetCameraControl();
	SMotorPosition*				GetMotorPosition();
	SMotorStatus*				GetMotorStatus();
	SAxisIndex*					GetAxisIndex();
	SCoordInfo*					GetCoordInfo();
	SCameraInfo*				GetCameraInfo(int nIndex);
	SCameraInfo*				GetCurrentCameraInfo();
	SMagnificInfo*				GetCurrentMagnificInfo();
	SMagnificInfo*				GetMagnificInfo(int nIndex);
	VectorSCameraInfo*			GetVectorCameraInfo();
	VectorSMagnificInfo*		GetVectorSMagnificInfo();

//	_ProtocalReviewModlueData*	GetProtocolReviewModuleData(); //181031
	
	const SExternalIndex*		GetExternalIndex() const;
	const SCameraControl*		GetCameraControl() const;
	const SMotorPosition*		GetMotorPosition() const;
	const SMotorStatus*			GetMotorStatus() const;
	const SAxisIndex*			GetAxisIndex() const;
	const SCoordInfo*			GetCoordInfo() const;
	const SCameraInfo*			GetCameraInfo(int nIndex) const;
	const SCameraInfo*			GetCurrentCameraInfo() const;
	const SMagnificInfo*		GetMagnificInfo(int nIndex) const;
	const SMagnificInfo*		GetCurrentMagnificInfo() const;
	const VectorSCameraInfo*	GetVectorCameraInfo() const;
	const VectorSMagnificInfo*	GetVectorSMagnificInfo() const;

//	_ProtocalReviewModlueData*	GetProtocolReviewModuleData()const; //181031


	void SetRevolverType(int nType);
	void SetExternalIndex(const SExternalIndex& externalIndex);
	void SetCameraControl(const SCameraControl& cameraControl);
	void SetMotorPosition(const SMotorPosition& motorPosition);
	void SetMotorStatus(const SMotorStatus& motorStatus);
	void SetAxisIndex(const SAxisIndex& axisIndex);
	void SetCoordInfo(const SCoordInfo& coordInfo);
	void SetCameraInfo(int nIndex, const SCameraInfo& cameraInfo);
	void SetVectorCameraInfo(const VectorSCameraInfo& vectorCameraInfo);
	void SetMagnificInfo(int nIndex, const SMagnificInfo& magnificInfo);
	void SetVectorMagnificInfo(const VectorSMagnificInfo& vectorMagnificInfo);

//	void SetProtocolReviewModuleData1(const _ProtocalReviewModlueData& moduleData); //181031

	void AddCameraInfo(const SCameraInfo& cameraInfo);
	void AddMagnificInfo(const SMagnificInfo& magnificInfo);

private:
	int					nModuleType;
	int					nLensType;
	int					nModuleIndex;
	int					nGantryIndex;
	int					nHeaderIndex;
	SExternalIndex		sExternalIndex;
	SCameraControl		sCameraControl;
	SMotorPosition		sMotorPosition;
	SMotorStatus		sMotorStatus;
	SAxisIndex			sAxisIndex;
	SCoordInfo			sCoordInfo;

	VectorSMagnificInfo	vectorMagnificInfo;
	VectorSCameraInfo	vectorCameraInfo;
};
typedef std::vector<CModuleStatus>					VectorModuleStatus;
typedef std::vector<CModuleStatus>::iterator		VectorModuleStatusIt;
typedef std::vector<CModuleStatus>::const_iterator	constVectorModuleStatusIt;

interface IUpdateSelectedModuleIndex
{
	virtual void	UpdateSelectedModuleIndex(int nModuleIndex, const CModuleStatus* pModuleStatus) = 0;
};
typedef std::vector<IUpdateSelectedModuleIndex*>			ObserverUpdateSelectedModuleIndex;
typedef std::vector<IUpdateSelectedModuleIndex*>::iterator	ObserverUpdateSelectedModuleIndexIt;

interface IUpdateCameraControl
{
	virtual void	UpdateCameraControl(int nModuleIndex, const SCameraControl* pCameraControl, const SCameraInfo* pCameraInfo) = 0;
};
typedef std::vector<IUpdateCameraControl*>				ObserverUpdateCameraControl;
typedef std::vector<IUpdateCameraControl*>::iterator	ObserverUpdateCameraControlIt;

interface IUpdateCameraInfo
{
	virtual void	UpdateCameraInfo(int nModuleIndex, const SCameraInfo* pCameraInfo) = 0;
};
typedef std::vector<IUpdateCameraInfo*>				ObserverUpdateCameraInfo;
typedef std::vector<IUpdateCameraInfo*>::iterator	ObserverUpdateCameraInfoIt;

interface IUpdateMotorPosition
{
	virtual void	UpdateMotorPosition(int nModuleIndex, BOOL bSelected, const SMotorPosition* pMotorPosition) = 0;
};
typedef std::vector<IUpdateMotorPosition*>				ObserverUpdateMotorPosition;
typedef std::vector<IUpdateMotorPosition*>::iterator	ObserverUpdateMotorPositionIt;

interface IUpdateMotorStatus
{
	virtual void	UpdateMotorStatus(int nModuleIndex, const SMotorStatus* pMotorStatus) = 0;
};
typedef std::vector<IUpdateMotorStatus*>				ObserverUpdateMotorStatus;
typedef std::vector<IUpdateMotorStatus*>::iterator		ObserverUpdateMotorStatusIt;

interface IUpdateThetaMotorInfo
{
	virtual void	UpdateThetaMotorInfo(const SThetaMotorInfo* pThetaMotorInfo) = 0;
};
typedef std::vector<IUpdateThetaMotorInfo*>				ObserverUpdateThetaMotorInfo;
typedef std::vector<IUpdateThetaMotorInfo*>::iterator	ObserverUpdateThetaMotorInfoIt;

interface IUpdatePCControlIOSignal
{
	virtual void	UpdateSignalIOStatus(const SSignalIOStatus* pSignalIOStatus) = 0;
};
typedef std::vector<IUpdatePCControlIOSignal*>				ObserverUpdatePCControlIOSignal;
typedef std::vector<IUpdatePCControlIOSignal*>::iterator		ObserverUpdatePCControlIOSignalIt;

interface IUpdateDefectFilter
{
	virtual void	UpdateDefectFilter(const SDefectFilter* pDefectFilter) = 0;
};
typedef std::vector<IUpdateDefectFilter*>				ObserverUpdateDefectFilter;
typedef std::vector<IUpdateDefectFilter*>::iterator		ObserverUpdateDefectFilterIt;

interface IUpdateReviewProcessStatus
{
	virtual void	UpdateReviewProcessStatus(int nReviewStatus, int nPlanIndex=0) = 0;
};
typedef std::vector<IUpdateReviewProcessStatus*>			ObserverUpdateReviewProcessStatus;
typedef std::vector<IUpdateReviewProcessStatus*>::iterator	ObserverUpdateReviewProcessStatusIt;


interface IUpdateDefocusList
{
	virtual void	UpdateDefocusList() = 0;

};

typedef std::vector<IUpdateDefocusList*>			ObserverUpdateDefocusList;
typedef std::vector<IUpdateDefocusList*>::iterator	ObserverUpdateDefocusListIt;