#pragma once
#include <string>
#include <map>
#include <vector>
#include <fstream>
#include <set>
#include <limits>
#include "../config/ConfigManager.h"
#include "BPBinary.h"

#include "../log/PartPosBean.h"
#include "../protobuf/stream.pb.h"

class MetaData
{
public:

	struct Version
	{
		int major;
		int minor;
		int revision;	//ֻ�ڿ�������������,�ļ���ʽ������̶�
		explicit Version() 
		{
			major = 2;
			minor = 0;
			revision = 0;
		}
	};

	struct Application 
	{
		string name;
		string version;
	};

	struct WrittenBy
	{
		Application* application;
		WrittenBy() {
			application = new Application();
		}
		~WrittenBy() 
		{
			if (application)delete application;
		}
	};

	struct FileInfo {
		Version* version;
		WrittenBy* written_by;
		FileInfo() {
			version = new Version();
			written_by = new WrittenBy();
		}
		~FileInfo()
		{
			if (version)delete version;
			if (written_by)delete written_by;
		}
	};

	typedef struct Dim{
		float xmin;
		float ymin;
		float zmin;
		float xmax;
		float ymax;
		float zmax;
		Dim()
			:xmin(FLT_MAX)
			,xmax(-FLT_MAX)
			,ymin(FLT_MAX)
			,ymax(-FLT_MAX)
			,zmin(FLT_MAX)
			,zmax(-FLT_MAX)
		{}
	}JobDimensions,Dimensions;    //�����

	struct Property {
		string name;
		string type;
		string value;
	};

	struct GeneralInfo {
		string job_name;
		JobDimensions* job_dimensions;
		string material;
		vector<Property*> properties;
		GeneralInfo() {
			job_dimensions = new JobDimensions();
		}
		~GeneralInfo()
		{
			if (job_dimensions)delete job_dimensions;
			for (size_t i = 0; i < properties.size(); ++i)
			{
				delete properties[i];
				properties[i] = NULL;
			}
			properties.clear();
		}
	};

	struct Dimension {
		float xmin;
		float ymin;
		float xmax;
		float ymax;
	};

	struct ScanField {
		int id;
		int reference;
		Dimension* dimension;
		ScanField() {
			dimension = new Dimension();
		}
		~ScanField() {
			delete dimension;
		}
	};

	struct Laser {
		int id;
		int reference;
	};

	struct MachineType {
		vector<ScanField*> scanFields;
		vector<Laser*> lasers;

		~MachineType() {
			for (size_t i = 0; i < scanFields.size(); ++i) {
				delete scanFields[i];
			}
			scanFields.clear();
			for (size_t i = 0; i < lasers.size(); ++i) {
				delete lasers[i];
			}
			lasers.clear();
		}
	};


	struct ShowParam {
		float x_offset;
		float y_offset;
		float rotate_degree;
		float radians;
		float part_center_x;
		float part_center_y;
		explicit ShowParam() {
			x_offset = 0.0;
			y_offset = 0.0;
			rotate_degree = 0.0;
			radians = 0.0;
			part_center_x = 0.0;
			part_center_y = 0.0;
		}
	};
	

	struct LaserSet {
		int id;
		float laser_diameter;		//�Ժ���Ϊ��λ�ļ���ֱ������ǰҲ��Ϊ���㣩
		float laser_power;			//Laser power in Watt
		float laser_real_power;
	};

	struct ParameterSet {
		int scan_field;
		int id;
		string name;				//���ڿ��ӻ�
		string set_type;
		float laser_speed;			//Speed in mm/s
		LaserSet* laser_set;
		ParameterSet() {
			laser_set = new LaserSet();
		}
		~ParameterSet()
		{
			if (laser_set)delete laser_set;
		}
	};

	 struct ParamCmp {
		bool operator ()(const ParameterSet* lhs, const ParameterSet* rhs)const {
			if (lhs->id != rhs->id) return lhs->id < rhs->id;
			else return lhs->id > rhs->id;
		}
	};

	struct Part {
		int id;
		int sourceId;
		string name;
		Dimensions* dimensions;
		PartPosBean partPosBean;
		bool print_enable;
	//	float center_x;
	//	float center_y;
		uint64_t param_pos;
		set<ParameterSet*, ParamCmp> paramSet;
		bool isCopy;		//是否复制的
		Dimensions* layerDimensions;
		explicit Part() {
			dimensions = new Dimensions();
			layerDimensions = new Dimensions();
			print_enable = true;
			isCopy = false;
			sourceId = 0;
			param_pos = 0;
			//center_x = 0.0f;
			//center_y = 0.0f;
		}
		~Part()
		{
			if (dimensions) {
				delete dimensions;
				dimensions = nullptr;
			}
			if (layerDimensions) {
				delete layerDimensions;
				layerDimensions = nullptr;
			}
		}
		Part* CopyPart(int nid) {
			Part* part = new Part();
			part->id = nid;
			part->sourceId = id;
			part->dimensions->xmax = dimensions->xmax;
			part->dimensions->xmin = dimensions->xmin;
			part->dimensions->ymax = dimensions->ymax;
			part->dimensions->ymin = dimensions->ymin;
			part->partPosBean.m_JobId = partPosBean.m_JobId;
			part->partPosBean.m_PartId = nid;
			part->partPosBean.m_SrcPartCenterX = partPosBean.m_SrcPartCenterX;
			part->partPosBean.m_SrcPartCenterY = partPosBean.m_SrcPartCenterY;
			part->isCopy = true;
			part->name = "Copy_"+name;
			for (set<ParameterSet*>::iterator it = paramSet.begin(); it != paramSet.end();it++) {
				part->paramSet.insert((*it));
			}
			return part;
		}
	};

	struct BinaryFile {
		int id;
		string name;
		uint64_t filesize;    //The size of the file in bytes

		~BinaryFile()
		{
		}
	};

	struct LayerSummary {
		float total_mark_distance;	//The total length of marks for a single layer the laser makes in mm
		float total_jump_distance; //The total length of jumps for a single layer the laser makes in mm
		float xmin;				//The smallest X position the laser covers for this layer in mm
		float xmax;				//The greatest X position the laser covers for this layer in mm
		float ymin;				//The smallest Y position the laser covers for this layer in mm
		float ymax;				//The greatest Y position the laser covers for this layer in mm
		explicit LayerSummary()
			:total_mark_distance(0.0)
			,total_jump_distance(0.0)
			,xmin(FLT_MAX)
			,xmax(-FLT_MAX)
			,ymin(FLT_MAX)
			,ymax(-FLT_MAX)
		{}
	};

	struct References {
		int part;			        //Part�������ָ�����PartĿ¼�¶�Ӧ�����
		int process;
	};

	struct DataBlockSummary {
		float mark_distance;		//The length of marks in mm
		float jump_distance;		//The length of jumps in mm
		int num_mark_segments;		//The number of mark segments
		int num_jump_segments;		//The number of jump segments
		DataBlockSummary()
			:mark_distance(0.0)
			,jump_distance(0.0)
			,num_mark_segments(0)
			,num_jump_segments(0)
		{}
	};

	struct Dep
	{
		int reference;				//ָ��ǰ���0��ʼ��ij��datablock.
		float start_delay;			//������ָ���Datablock ��ʼ���������Startmode ��������������ӳ١���λ��
		string start_mode;
		explicit Dep() {
			start_mode = "wait";
		}
	};

	struct DataBlockTiming {
		vector<Dep*> deps;			//����� DataBlock ������ DataBlock��Ӱ��
		float end_delay;			//������һ�����κ���һ��datablock��ɨ��֮ǰ��Ҫ�ο���һ���ӳ�
		~DataBlockTiming()
		{
			for (size_t i = 0; i < deps.size(); ++i) {
				delete deps[i];
				deps[i] = NULL;
			}
			deps.clear();
		}
	};

	struct Bin {
		int file_id;
		uint64_t pos;			//Offset in bytes
	};


	struct DataBlock {
		int order;
		References* references;
		DataBlockSummary* data_block_summary;
		Bin* bin;
		int scanTime;
		Part* belongPart;
		DataBlock() {
			order = 0;
			references = new References();
			data_block_summary = new DataBlockSummary();
			bin = new Bin();
			belongPart = NULL;
			scanTime = 0;
		}
		~DataBlock()
		{
			if (references)delete references;
			if (data_block_summary)delete data_block_summary;
			if (bin)delete bin;
		}
	};


	typedef vector<DataBlock*> DataBlockList;
	struct Layer {
		
		int index;
		int32_t z;
		int32_t realZ;
		float layer_scan_time;				//�����������ӹ�ʱ�����.
		double layer_estimate_time;		//层估算时间 ms
		map<int, double> estimateTimeMap;
		uint64_t powder_pos;
		uint32_t powder;						//供粉量
		uint32_t layer_thickness;      //层厚
		int scan_times;
		LayerSummary* layer_summary;			//����Ϣ�洢��ÿ��������ܳ��ȣ���Ծ�ܳ��ȣ��Լ�xy���������Сֵ��
		vector<DataBlock*> data_blocks;		//����ָ��������Լ���Ӧbinary �ļ��ĵ�ָ����Ϣ.
		map<int, DataBlockList*> data_blocks_map;
		map<int, Part*> parts;
		double powderTime;
		bool isPrintable;
		
		Layer() {
			z = 0;
			realZ = 0;
			powder_pos = 0;
			layer_thickness = 0;
			layer_estimate_time = 0;
			powder = 0;
			layer_summary = new LayerSummary();
			powderTime = 0.0;
			scan_times = 1;
			isPrintable = true;
		}
		~Layer()
		{
			if (layer_summary)delete layer_summary;
			for (size_t i = 0; i < data_blocks.size(); ++i) {
				delete data_blocks[i];
				data_blocks[i] = NULL;
			}
			data_blocks.clear();

			for (map<int, DataBlockList*>::iterator it = data_blocks_map.begin(); it != data_blocks_map.end(); it++)
			{
				DataBlockList* dbl = it->second;
				if (dbl) {
					delete dbl;
					dbl = nullptr;
				}
				
			}
			data_blocks_map.clear();
		}
	};

	struct Layers
	{
		int64_t layer_thickness_pos;
		uint32_t layer_thickness;
		float layer_recoating_time;                //�ػ�����
		vector<Layer*> vector_layers;
		Layers():layer_thickness(0){
			layer_thickness_pos = 0;
		}
		~Layers()
		{
			for (size_t i = 0; i < vector_layers.size(); ++i) {
				delete vector_layers[i];
				vector_layers[i] = NULL;
			}
			vector_layers.clear();
		}
	};

public:
	MetaData();
	virtual ~MetaData();
	static void InitTypeMap();
	virtual bool LoadLayerByIndex(unsigned int lindex) = 0;
	virtual bool GetLayerByIndex(unsigned int lindex, ::stream::ResponseAny** response) = 0;
	virtual bool LoadLayer(Layer* layer) = 0;
	virtual bool LoadPrevLayer(Layer* layer) = 0;
	virtual bool LoadPrevLayerByIndex(unsigned int lindex) = 0;
	virtual bool LoadRemoteLayerByIndex(unsigned int index)=0;
	virtual bool LoadFirstLayer() = 0;
//	virtual float CalcEvaTime(float start_at = 0.0) = 0;
	virtual void ReCalcEvaTime();
	unsigned int CalcRemainTime(unsigned int index);
	virtual void AddPart(Part* part);
	virtual void DelPart(Part* part);

	BPBinary::BinDataBlock* GetDataBlock(DataBlock* db);
	BPBinary::BinDataBlock* GetPreviewDataBlock(DataBlock *db);
	BPBinary::BinDataBlock* GetPreviewData(DataBlockList *dblist, unsigned int index);
	void CalcRealPower(void);
	Layer* GetCurrentLayer() { return m_currentLayer; }
	Layer* GetPreviewLayer() { return m_previewLayer; }
	unsigned int GetEvaTime(void) { return evaTime; }
	void SetEvaTime(unsigned int time) { evaTime = time; }
	JobDimensions* GetJobDimensions(void) { return general_info->job_dimensions; }
	const char * GetMaterial(void) { return general_info->material.c_str(); }
	uint32_t* GetLayerThickness(void) { return &layers->layer_thickness; }
	vector<Part*>& GetPartVec(void) { return partsVec; }

	void GetPartIds(vector<int>& pids) {
		for (size_t i = 0; i < partsVec.size(); i++) {
			pids.push_back(partsVec[i]->id);
		}
	}
//	vector<Part*>* GetCPPartVec(void) { return &cpParts; }
	//vector<int>* GetPartRefParameter(int id) { return partRefParameterMap[id]; }
	map<int, ParameterSet*>* GetParameterMap(void) { return &parameterMap; }
	ParameterSet* GetParameterSet(int id);/* { return parameterMap[id]; }*/
	vector<Layer*>& GetLayersVec(void) { return layers->vector_layers; }
	Part* GetPart(int id) { 
		map<int, Part*>::iterator it = partsMap.find(id);
		if (it != partsMap.end()) {
			return partsMap[id];
		}
		else return NULL;
	}
	
	void LockPart() { EnterCriticalSection(&partCs); }
	void UnLockPart() { LeaveCriticalSection(&partCs); }

	string GetJobTitle(void) { return general_info->job_name; }
	unsigned int GetLayerCount(void) { return (UINT)layers->vector_layers.size(); }
	unsigned int GetComponentCount(void) { return (UINT)partsMap.size(); }
	Layer* GetLayer(unsigned int id);
	string GetJobUid(void) { return job_id; }
	void GetPartId(int layerIndex, set<int>& partIds);
//	float GetProgress(void) { return m_ProgressValue; }
	//string GetProgressInfo();
	float PowderRequiretment(void);
	unsigned int GetNumOfScanField() { return (UINT)machine_type->scanFields.size(); }
	vector<ScanField*>* GetScanFields() {
		return &machine_type->scanFields;
	}
	void GetErrorInfo(vector<string>& infos);
	void AddErrorInfo(string str);
	//string GetFirstError();
	unsigned int GetRemainTime() { return m_RemainTime; }
	void SetRemainTime(unsigned int rtime) { m_RemainTime = rtime; }
	Layer* GetRemoteLayer() { return m_RemoteLayer; }
	BPBinary::BinDataBlock* GetRemoteDataBlock(DataBlock *db);
	map<DataBlock*, int>* GetDBRefScanLaser() { return &m_DBRefScanLaser; }
	ScannerControlCfg* GetLaserCfgByPart(Part* part);
	void UpdatePartRefScanLaser(Part* part, int cno);
	void LockMainDB() {
		EnterCriticalSection(&m_DBCS);
	}

	void UnLockMainDB() {
		LeaveCriticalSection(&m_DBCS);
	}
	virtual void ResetIfs() {
		for (map<string, ifstream*>::iterator it = m_binary_file_map.begin(); it != m_binary_file_map.end(); it++)
		{
			it->second->clear();
		}
	}

public:
	
	map<DataBlock*, BPBinary::BinDataBlock*> m_FirstLayerBlockMap;
	bool m_IsScanOrderSeqV2;


	static map<string, int> m_DataTypeMap;

protected:
	void ClearBlockMap();
	void ClearPrevBlockMap();
	void ClearRemoteBlockMap();
	void ClearBFileMap();

protected:
	string job_id;
	FileInfo* file_info;
	GeneralInfo* general_info;
	MachineType* machine_type;
	map<int,Part*> partsMap;
	vector<Part*> partsVec;
	//vector<Part*> cpParts;
	
	map<string, ifstream*> m_binary_file_map;
	map<string, ifstream*> m_pre_file_map;

	CRITICAL_SECTION partCs;
	map<int,ParameterSet*> parameterMap;
	Layers* layers;
	unsigned int evaTime;
	//float m_ProgressValue;
	//string m_ProgressInfo;
	unsigned int m_RemainTime;

	Layer* m_currentLayer;
	MachineCfg* m_MachineCfg;
	CoverCfg* m_CoverCfg;
	RunCfg* m_RunCfg;
	AxisCfg* m_ArmCfg;
	ExtCfg* m_ExtCfg;
	Layer* m_previewLayer;
	Layer* m_RemoteLayer;
	Machine* m_Machine;
	map<int, ScannerControlCfg*> m_FieldRefScanLaser;   //Data策略
	//map<int, ScannerControlCfg*> m_PartRefScanLaser;			//Part策略
	map<DataBlock*, int> m_DBRefScanLaser;
	//map<int, double> m_EvaTimeMap;

	bool m_IsScanOrderForPlatform;
	
	bool m_HasOrder;
	vector<string> m_Errors;
	CRITICAL_SECTION m_DBCS;

	map<DataBlock*, BPBinary::BinDataBlock*> m_block_map;
	map<DataBlock*, BPBinary::BinDataBlock*> m_prev_block_map;
	map<DataBlock*, BPBinary::BinDataBlock*> m_remote_block_map;
	//CRITICAL_SECTION m_MsgCs;
};

extern bool ParamCmp(const MetaData::ParameterSet* lhs, const MetaData::ParameterSet* rhs);