#pragma once

#include "CHReviewResult/GlassResult.h"
#include "ModuleStatus.h"
#include "CameraController.h"
#include "CHAutoLightControls/AutoLightControl.h"
#include "CHAlignFinder/AlignFinder.h"
#include "CHAlignFinder/AlignFinder_Corner.h"
#include "CHLightControls/LightControl.h"

typedef std::vector<CLightControl*>						VectorLightControl;
typedef std::vector<CLightControl*>::iterator			VectorLightControlIt;

typedef std::vector<CAutoLightControl*>					VectorAutoLightControl;
typedef std::vector<CAutoLightControl*>::iterator		VectorAutoLightControlIt;

#include <list>

class CBlobData  
{
public:
	CBlobData()
	{
		Reset();
	}

	CBlobData(int x, int y)
	{
		Reset();
		fCenterX = (float)x;
		fCenterY = (float)y;
	}

	CBlobData(int left, int top, int right, int bottom)
	{
		Reset();

		nLeft	= left;
		nTop	= top;
		nRight	= right;
		nBottom	= bottom;
		fCenterX = float(left) + float(right-left) / 2.f;
		fCenterY = float(top) + float(bottom-top) / 2.f;
	}

	void Reset()
	{
		fCenterX		= 0;
		fCenterY		= 0;
		nLeft			= 0;
		nTop			= 0;
		nRight			= 0;
		nBottom			= 0;
		fMassCenterX	= 0;
		fMassCenterY	= 0;
		nPixelCount		= 0;
		fMatchScore		= 0;
	}

	int Width()		{ return nRight - nLeft + 1; }
	int Height()	{ return nBottom - nTop + 1; }

	float	fCenterX;
	float	fCenterY;
	int		nLeft;
	int		nTop;
	int		nRight;
	int		nBottom;
	int		nPixelCount;
	float	fMassCenterX;
	float	fMassCenterY;
	float	fMatchScore;
};

typedef std::list<CBlobData*>				ListBlobData;
typedef std::list<CBlobData*>::iterator		ListBlobDataIt;

struct SLightData
{
	SLightData() 
	{
		InitializeCriticalSection(&csProcess);
		nControlLightLevel = 1;
		dExposureTime = -1.0;
		dLightValue = -1.0;
	}

	~SLightData() 
	{
		DeleteCriticalSection(&csProcess);
	}
	
	CRITICAL_SECTION	csProcess;
	int					nControlLightLevel;
	double				dExposureTime;
	double				dLightValue;
};
typedef std::vector<SLightData*>			VectorLightData;
typedef std::vector<SLightData*>::iterator	VectorLightDataIt;


enum AlignViewMode	{ View_Camera=0, View_Result, View_Template, View_Matching };
enum AlignResult	{ Align_Fail=-2, Align_TempFail=-1, Align_None=0, Align_Success=1 };
//#3357 KYH Align Image 초기화 ADD START
enum AlignFinderType { AlignFinderType_Normal = 0, AlignFinderType_Corner, AlignFinderType_Extend, AlignFinderType_count }; //210330 kyh 추가
//#3357 KYH Align Image 초기화 ADD END

interface IAlignCameraControl2Parent
{
	virtual BOOL IACC2P_GetCurrentFrame(int nCameraIndex, int nFrameWidth, int nFrameHeight, int nFrameChannels, CCHImageData *pImageData) = 0;
	virtual void IACC2P_FrameCaptured(int nCameraIndex, int nFrameIndex, CCHImageData* pImageData) = 0;
	virtual void IACC2P_AlignResult(const CAlignResult& alignResult) = 0;
	virtual void IACC2P_CameraControl(int nValue) = 0;
	virtual BOOL IACC2P_SetLightLevel(int nCameraIndex, int nValue) = 0;
	virtual BOOL IACC2P_GetLightLevel(int nCameraIndex, int& nValue) = 0;
};

class CCameraControlAlign : public CCameraController,
							public IUpdateProcessStatus,
							public IAutoLightControl2Paraent
{
public:
	CCameraControlAlign(void);
	virtual ~CCameraControlAlign(void);
	void SetACCP(IAlignCameraControl2Parent* pACC2P)		{ m_pACC2P = pACC2P; }
	void SetViewMode(int nViewMode)							{ m_nViewMode = nViewMode; }
	void SetAlignLightControl(VectorLightControl* pVectorAlignLightControl) { m_pVectorAlignLightControl = pVectorAlignLightControl; }
	int ConnectCamera(const VectorCameraControlInfo& vecCameraControlInfo);
	void DisconnectCamera();
	virtual int	Camera_Control(int nControlType);

	void SetSystemType(int nLineType, int nMachineType)		{ m_nLineType=nLineType; m_nMachineType=nMachineType; }
	BOOL SetTemplateImage(int nCameraIndex, CCHImageData* pImageData);
	BOOL GetTemplateImage(int nCameraIndex, CCHImageData* pImageData);
	BOOL GetResultImage(int nCameraIndex, CCHImageData* pImageData);
	BOOL SaveResultImage(int nCameraIndex, const CString& strFilename);
	void SetSaveImageBasePath(CString strPath);
	void SetAlignType(BOOL nAlignType);
	//#3357 KYH Align Image 초기화 ADD START
	void SetAlignClearImage(); 
	//#3357 KYH Align Image 초기화 ADD END

	CAlignResult FindAlignMark(const VectorString& vectorFilename);
	BOOL FindAlignMark(int nCameraIdx);

	BOOL SaveAutoTempImage(int nFirstAlignX, int nFristAlignY, int nSecondAlignX, int nSecondAlignY);


	BOOL GetFrameRateApply(){return m_bAlignFrameRateApply;};
	void SetFrameRateApply(BOOL bApply){m_bAlignFrameRateApply=bApply;};

	virtual BOOL	AL2P_ChangeExposure(int nCameraIndex, double dExposureTime);
	virtual BOOL	AL2P_ChangeLightLevel(int nCameraIndex, int nLightLevel);
	virtual BOOL	AL2P_ChangeGain(int nCameraIndex, double dGainValue);
	virtual BOOL	AL2P_GetCurrentLightExposure(int nCameraIndex, double& dLight, double& dExposure);
	virtual BOOL	AL2P_GetCurrentLightLevel(int nCameraIndex, double& dLight, int& nLightLevel);
	virtual void	AL2P_ProcessEnd(int nCameraIndex, int nResultCode, double dLightValue, double dExposureTime);
	virtual void	AL2P_ProcessEnd(int nCameraIndex, int nResultCode, double dLightValue, int nLightLevel);
	virtual void	AL2P_CurrentResult(int nCameraIndex, int nCount, int nResultCode, double dLightValue, double dExposureTime);
	virtual void	AL2P_CurrentResult(int nCameraIndex, int nCount, int nResultCode, double dLightValue, int nLightLevel);

	// auto light control
	virtual void	IALC2P_DisplayMessage(int nIndex, const TCHAR* lpstrFormat, ...);
	virtual BOOL	IALC2P_ChangeLightLevel(int nIndex, double dLightLevel);
	virtual BOOL	IALC2P_GetCurrentLightLevel(int nIndex, double& dLight, double& dLightLevel);
	virtual void	IALC2P_ProcessEnd(int nIndex, int nResultCode, double dLightValue, double dLightLevel);
	virtual void	IALC2P_CurrentResult(int nIndex, int nCount, int nResultCode, double dLightValue, double dLightLevel);


	CCameraControl* GetCameraControl(int nCameraIndex);
	int AlignProcess();

	BOOL SetFrameRate(int nIndex, double dRate);

	BOOL AlignCameraDisconnectCheck();

protected:
	BOOL LoadTemplateImage();
	BOOL ChangeExposureTime();
	BOOL ChangeLightLevel();	

	int							m_nLineType;
	int							m_nMachineType;

	int							m_nControlType;
	int							m_nProcessStatus;
	int							m_nViewMode;
	CString						m_strSaveImageBasePath;
	CAlignRecipe				m_AlignRecipe;
	CAlignResult				m_AlignResult; 
	VectorAutoLightControl		m_vecAutoLightControl;
	VectorLightData				m_vecLightData;
	VectorAlignFinder			m_vecAlignFinder;

	BOOL						m_nAlignType;

	CRITICAL_SECTION			m_csAlignFindProcess;

	IAlignCameraControl2Parent* m_pACC2P;
	VectorLightControl*			m_pVectorAlignLightControl;

	BOOL						m_bAlignFrameRateApply;

	// Camera 
	virtual BOOL ICC2P_GetCurrentFrame(int nCameraIndex, int nFrameWidth, int nFrameHeight, int nFrameChannels,  CCHImageData* pImageData);
	virtual BOOL ICC2P_FrameCaptured(int nCameraIndex, int nFrameIndex, int nFrameCount);
	virtual void ICC2P_DisplayMessage(int nIndex, const TCHAR* lpstrFormat, ...){};

	virtual void UpdateProcessStatus(int nLineType, int nMachineType, int nProcessStatus, const CGlassResult* pGlassResult);

	//edge detecting
	BOOL AlignProcess_EdgeDetecting(BYTE* pImageData, int nWidth, int nHeight, int nStep, int nAlignWidth, int nAlignHeight, 
									double dMatchingThreshold, int nEDBinaryThreshold, int nEDMergeRange, CPoint& ptResult, double& dScore, int nCameraIdx);
	BOOL EdgeProcess_EdgeDetecting(BYTE* pImageData, int nWidth, int nHeight, int nStep);
	int ImageThreshold_EdgeDetecting(BYTE* pImageData, int nWidth, int nHeight, int nStep, int nThreshold, BOOL bAdaptive);
	float AdaptiveThreshold_EdgeDetecting(BYTE* pImageData, int nWidth, int nHeight, int nStep, int nThresValue);
	float GetThresholdValue_EdgeDetecting(BYTE* pImageData, int nWidth, int nHeight, int nStep, int nThresValue);
	BOOL FindAlignMark_EdgeDetecting(BYTE* pImageData, int nWidth, int nHeight, int nStep, 
									 int nAlignWidth, int nAlignHeight, float fScoreThres, int nMergeRange, CBlobData& blobResult);
	BOOL BlobAnalysis_EdgeDetecting(BYTE* pImageData, int nWidth, int nHeight, int nStep, ListBlobData& blobList, int nMergeRange);
	void Hybrid_Median_Filter_nbyn(BYTE *pSrc, int nWidth, int nHeight, int nMask);


	BYTE QuickGet_rep(BYTE* src,int size, int index);
};

typedef std::vector<CCameraControlAlign*>				VectorCameraControlAlign;
typedef std::vector<CCameraControlAlign*>::iterator		VectorCameraControlAlignIt;