GrpcPrint/PrintS/job/MetaData.h

#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"
class MetaData
{
public:

	struct Version
	{
		int major;
		int minor;
		int revision;	//ֻ<>ڿ<EFBFBD><DABF><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>,<2C>ļ<EFBFBD><C4BC><EFBFBD>ʽ<EFBFBD><CABD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>̶<EFBFBD>
		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;    //<2F><>λ<EFBFBD><CEBB><EFBFBD><EFBFBD>

	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;		//<2F>Ժ<EFBFBD><D4BA><EFBFBD>Ϊ<EFBFBD><CEAA>λ<EFBFBD>ļ<EFBFBD><C4BC><EFBFBD>ֱ<EFBFBD><D6B1><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ǰҲ<C7B0><D2B2>Ϊ<EFBFBD><CEAA><EFBFBD>㣩
		float laser_power;			//Laser power in Watt
		float laser_real_power;
	};

	struct ParameterSet {
		int scan_field;
		int id;
		string name;				//<2F><><EFBFBD>ڿ<EFBFBD><DABF>ӻ<EFBFBD>
		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;
		}
	};

	typedef 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<72><74><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ָ<EFBFBD><D6B8><EFBFBD><EFBFBD><EFBFBD>PartĿ¼<C4BF>¶<EFBFBD>Ӧ<EFBFBD><D3A6><EFBFBD><EFBFBD><EFBFBD>
		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;				//ָ<><D6B8>ǰ<EFBFBD><C7B0><EFBFBD>0<EFBFBD><30>ʼ<EFBFBD><CABC>ij<EFBFBD><C4B3>datablock.
		float start_delay;			//<2F><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ָ<EFBFBD><D6B8><EFBFBD>Datablock <20><>ʼ<EFBFBD><CABC><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>Startmode <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ӳ١<D3B3><D9A1><EFBFBD>λ<EFBFBD><CEBB>
		string start_mode;
		explicit Dep() {
			start_mode = "wait";
		}
	};

	struct DataBlockTiming {
		vector<Dep*> deps;			//<2F><><EFBFBD><EFBFBD><EFBFBD> DataBlock <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> DataBlock<63><6B>Ӱ<EFBFBD><D3B0>
		float end_delay;			//<2F><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>һ<EFBFBD><D2BB><EFBFBD><EFBFBD><EFBFBD>κ<EFBFBD><CEBA><EFBFBD>һ<EFBFBD><D2BB>datablock<63><6B>ɨ<EFBFBD><C9A8>֮ǰ<D6AE><C7B0>Ҫ<EFBFBD>ο<EFBFBD><CEBF><EFBFBD>һ<EFBFBD><D2BB><EFBFBD>ӳ<EFBFBD>
		~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;
		int cno;
		DataBlock() {
			order = 0;
			cno = 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;				//<2F><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ӹ<EFBFBD>ʱ<EFBFBD><CAB1><EFBFBD><EFBFBD><EFBFBD>.
		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;			//<2F><><EFBFBD><EFBFBD>Ϣ<EFBFBD>洢<EFBFBD><E6B4A2>ÿ<EFBFBD><C3BF><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ܳ<EFBFBD><DCB3>ȣ<EFBFBD><C8A3><EFBFBD>Ծ<EFBFBD>ܳ<EFBFBD><DCB3>ȣ<EFBFBD><C8A3>Լ<EFBFBD>xy<78><79><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>Сֵ<D0A1><D6B5>
		vector<DataBlock*> data_blocks;		//<2F><><EFBFBD><EFBFBD>ָ<EFBFBD><D6B8><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>Լ<EFBFBD><D4BC><EFBFBD>Ӧbinary <20>ļ<EFBFBD><C4BC>ĵ<EFBFBD>ָ<EFBFBD><D6B8><EFBFBD><EFBFBD>Ϣ.
		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;                //<2F>ػ<EFBFBD><D8BB><EFBFBD><EFBFBD><EFBFBD>
		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 layers->vector_layers.size(); }
	unsigned int GetComponentCount(void) { return 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 machine_type->scanFields.size(); }
	vector<ScanField*>* GetScanFields() {
		return &machine_type->scanFields;
	}
	void GetErrorInfo(vector<string>& infos);

	//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);
	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();
		}
	}


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


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

	static map<string, int> m_DataTypeMap;
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策略
	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);