#pragma once
#include <windows.h>
#include <opencv2/opencv.hpp>
#include "../config/bean/ExtCfg.h"
#include "../config/bean/CameraCalibrationCfg.h"
#include "../job/JobController.h"
#include "../camera/HBDCamera.h"
#include "../config/bean/IOCfg.h"
#include "../Logger.h"
//#include "../Render/Renderer.h"
//using namespace cv;
using namespace std;


class MatchInfo 
{

public:
	MatchInfo(){
		m_XOffset = 0.0f;
		m_YOffset = 0.0f;
		m_AimAngle = 0.0f;
	}
	~MatchInfo() {}

public:
	int m_PartId;
	float m_PartArea;
	vector<cv::Point> m_TplContours;   // 数据轮廓
	vector<cv::Point> m_MatchContours;	//基座轮廓
	//cv::Mat m_TplContourImage;
	//cv::Mat m_MatchContourImage;

	cv::Mat m_TplImage;    //数据图
	cv::Mat m_MatchImage;	//基座图

	float m_XOffset;
	float m_YOffset;
	float m_AimAngle;

	cv::Point2f m_TplCenter;
	cv::Point2f m_MatchCenter;
	//float m_AimAngle;
};


class CalibrationShowInfo {
public:
	CalibrationShowInfo()
	:m_ShowTex(0){
		m_IsColor = false;
	}
	~CalibrationShowInfo();

	void Init(cv::Mat image, unsigned char* imageData);
	void Init();
	void Update();
	uint32_t GetTex() {
		return m_ShowTex;
	}
public:
	int m_Width;
	int m_High;
	float m_PixelRatio;
	cv::Mat m_ImageMat;
	bool m_IsColor;
private:
	unsigned char* m_ImageData;
	uint32_t m_ShowTex;
};

class Calibration
{
public:
	Calibration(JobController* jc, HBDCamera* camera);
	~Calibration();
	
	bool CalibrationTest();
	void Test();
	void FindCountours();
	void Assist();
	//uint32_t GetCalibrationImage();
	//void UpdateCalibrationImage() { isDispUpdated = true; }
	void UpdateData(MetaData* metaData);
	typedef struct MatchCmp {
		bool operator ()(const cv::DMatch lhs, const cv::DMatch rhs) {
			if (lhs.distance != rhs.distance) return lhs.distance < rhs.distance;
			else return lhs.distance > rhs.distance;
		}
	};
	

	//void SetRender(VLRenderer* Renderer, VLRenderer* PrevRenderer) {
	//	m_Renderer = Renderer;
	//	m_PrevRenderer = PrevRenderer;
	//}

	void Init();
	void StartGraft();
	void StopGraft();
	void StartCalibrationCamera();
	void StopCalibrationCamera();
	void DrawUI();
//	void UpdateCalibrationImage() { isDispUpdated = true; }
private:
	static DWORD WINAPI GraftProc(Calibration* _this);
	void GraftRun();
	void GraftRunV2();
	static DWORD WINAPI CalibrationCameraProc(Calibration* _this);
	bool CalibrationCameraRun();

	cv::Mat CalibrationImage(cv::Mat image);

	cv::Mat CalibrationWithCfg(cv::Mat image);

	cv::Mat CalibrationWithCfgBin(cv::Mat image);

	cv::Mat GetCornersImage(cv::Mat image);

	cv::Mat CalibrationWithAssist(cv::Mat image);

	void SetCalibrationCameraInfo(string str) {
		EnterCriticalSection(&m_CalibrationCameraCS);
		m_CalibrationErrorInfo = str;
		LeaveCriticalSection(&m_CalibrationCameraCS);
	}
	void SetCalibrationCameraProgress(float value)
	{
		EnterCriticalSection(&m_CalibrationCameraCS);
		m_CalibrationCameraProgress = value;
		LeaveCriticalSection(&m_CalibrationCameraCS);
	}
	string GetCalibrationCameraInfo() {
		string str="";
		EnterCriticalSection(&m_CalibrationCameraCS);
		str=m_CalibrationErrorInfo ;
		LeaveCriticalSection(&m_CalibrationCameraCS);
		return str;
	}

	float GetCalibrationCameraProgress() {
		float rel = 0.0f;
		EnterCriticalSection(&m_CalibrationCameraCS);
		rel=m_CalibrationCameraProgress ;
		LeaveCriticalSection(&m_CalibrationCameraCS);
		return rel;
	}

	void SetGraftInfo(string str) {
		EnterCriticalSection(&m_GraftCS);
		m_GraftInfo = str;
		LeaveCriticalSection(&m_GraftCS);
	}
	void SetGraftProgress(float value)
	{
		EnterCriticalSection(&m_GraftCS);
		m_GraftProgress = value;
		LeaveCriticalSection(&m_GraftCS);
	}
	string GetGraftInfo() {
		string str = "";
		EnterCriticalSection(&m_GraftCS);
		str = m_GraftInfo;
		LeaveCriticalSection(&m_GraftCS);
		return str;
	}

	float GetGraftProgress() {
		float rel = 0.0f;
		EnterCriticalSection(&m_GraftCS);
		rel = m_GraftProgress;
		LeaveCriticalSection(&m_GraftCS);
		return rel;
	}

	void TackPhotoAndSave();
public:
	bool m_GraftingShow;
	static CalibrationShowInfo* m_CoverImage;
private:
	string m_ImgPath;
	string m_CoverImgPath;
	//cv::Mat m_CalibrationSrc;
	//cv::Mat m_CalibrationShow;

	//uint32_t m_DispTex;
	

	ExtCfg* m_ExtCfg;
	CameraCalibrationCfg* m_CameraCalibrationCfg;
	CRITICAL_SECTION cab_cs;

	//vector<MetaData::Part*> m_PartVec;
	//map<MetaData::DataBlock*, BPBinary::BinDataBlock*>* m_FirstLayerBlockMap;
	//MetaData::Layer* m_Layer;

	MetaData* m_MetaData;
	JobController* m_Jc;

	HBDCamera* m_Camera;

	uint32_t m_CalShowSelectIndex;
	list<CalibrationShowInfo*> m_CalibrationImages;
	string m_CalibrationErrorInfo;
	HANDLE m_CalibrationCameraThread;
	bool m_CalibrationCameraFlag;
	float m_CalibrationCameraProgress;
	CRITICAL_SECTION m_CalibrationCameraCS;

	CalibrationShowInfo* m_LocationImage;
	
	CalibrationShowInfo* m_BasePartImage;
	int m_LastMouRefImgPosX;
	int m_LastMouRefImgPosY;
	
	HANDLE m_GraftThread;
	bool m_GraftFlag;
	string m_GraftInfo;
	float m_GraftProgress;
	CRITICAL_SECTION m_GraftCS;
	map<int, vector<cv::Point2f>> m_GraftBorderSrcData;

	CalibrationShowInfo* m_GraftShowImage;
	cv::Mat m_GraftMat;
	int m_ManualGraftSelectPart;
	IOCfg* m_Light;
	IOCfg* m_Door;
	bool m_IsGraftUpdated;
	float m_LastMouRefGraftPosX;
	float m_LastMouRefGraftPosY;
	cv::Mat m_WrapMat;
	uchar m_LastGrayRef;
	//VLRenderer* m_Renderer;
	//VLRenderer* m_PrevRenderer;

	vector<cv::Scalar> m_ColorMap;
};

//extern bool MatchCmp(const cv::DMatch lhs, const cv::DMatch rhs);