#include "MetaData.h"
#include <regex>
#include "../utils/CryptHelper.h"
#include <sstream>
#include <iomanip>
#include <openssl/evp.h>
#include "../external/minizip/zlib.h"
#include "../LanguageManager.h"
#include "../SystemInfo.h"

MetaData::MetaData()
	:evaTime(0)
	, m_RemainTime(0)
	, m_RemoteLayer(nullptr)
	, m_IsScanOrderForPlatform(false)
	, m_IsScanOrderSeqV2(false)
	, m_HasOrder(false)
{
	file_info = new FileInfo();
	general_info = new GeneralInfo();
	layers = new Layers();
	machine_type = new MachineType();

	m_CoverCfg = ConfigManager::GetInstance()->GetCoverCfg();
	m_ArmCfg = ConfigManager::GetInstance()->GetArmCfg();
	m_ExtCfg = ConfigManager::GetInstance()->GetExtCfg();
	m_RunCfg = ConfigManager::GetInstance()->GetRunCfg();
	m_MachineCfg = ConfigManager::GetInstance()->GetMachineCfg();
	m_Machine = ConfigManager::GetInstance()->GetMachine();
	//m_ProgressInfo = g_LngManager->UI_AnalyzingJobData->ShowText();
	InitializeCriticalSection(&m_DBCS);
	//InitializeCriticalSection(&m_MsgCs);
	InitializeCriticalSection(&partCs);
}

MetaData::~MetaData()
{
	if (file_info)delete file_info;
	if (general_info)delete general_info;
	for (map<int, Part*>::iterator it = partsMap.begin(); it != partsMap.end(); it++)
	{
		Part* part = it->second;
		if (part)delete part;
	}
	partsMap.clear();
	partsVec.clear();
	for (map<int, ParameterSet*>::iterator it = parameterMap.begin(); it != parameterMap.end(); it++) {
		delete it->second;
	}
	parameterMap.clear();

	ClearBFileMap();
	ClearBlockMap();
	ClearPrevBlockMap();
	ClearRemoteBlockMap();

	if (layers)delete layers;
	if (machine_type)delete machine_type;
	DeleteCriticalSection(&partCs);
	DeleteCriticalSection(&m_DBCS);
}

void MetaData::CalcRealPower(void)
{
	for (size_t partIndex = 0; partIndex < partsVec.size(); partIndex++) {
		Part* part = partsVec[partIndex];
		for (set<ParameterSet*>::iterator it = part->paramSet.begin(); it != part->paramSet.end(); it++) {
			ParameterSet* ps = (*it);
			if (m_FieldRefScanLaser.find(ps->scan_field) != m_FieldRefScanLaser.end()) {
				ScannerControlCfg* cfg = m_FieldRefScanLaser[ps->scan_field];
				if (cfg) {
					ps->laser_set->laser_real_power = cfg->m_ScanCfgWrapper.m_PowerCompensateCfg.CalcPowerCompensate(ps->laser_set->laser_power);
				}
			}
		}
	}
}

void MetaData::GetPartId(int layerIndex, set<int>& partIds)
{
	int layersize = layers->vector_layers.size();
	if (layerIndex >= layersize)return;
	Layer* layer = layers->vector_layers[layerIndex];
	for (size_t i = 0; i < layer->data_blocks.size(); ++i) {
		Part* part = partsMap[layer->data_blocks[i]->references->part];
		if (part)partIds.insert(part->id);
	}
}

BPBinary::BinDataBlock* MetaData::GetDataBlock(DataBlock* db)
{
	if (m_block_map.find(db) != m_block_map.end()) {
		return m_block_map[db];
	}
	else return NULL;
}

BPBinary::BinDataBlock* MetaData::GetPreviewData(MetaData::DataBlockList* dblist, unsigned int index)
{
	if (!dblist)
		return nullptr;

	return m_prev_block_map[(*dblist)[index]];
}

BPBinary::BinDataBlock* MetaData::GetRemoteDataBlock(DataBlock* db)
{
	return m_remote_block_map[db];
}

BPBinary::BinDataBlock* MetaData::GetPreviewDataBlock(DataBlock* db)
{
	return m_prev_block_map[db];
}

float MetaData::PowderRequiretment(void)
{
	float powder = 0.0;
	for (unsigned int i = GetCurrentLayer()->index; i < layers->vector_layers.size(); i++)
	{
		bool hasPrintPart = false;
		MetaData::Layer* layer = layers->vector_layers[i];
		for (size_t blockIndex = 0; blockIndex < layer->data_blocks.size(); ++blockIndex) {
			MetaData::DataBlock* datablock = layer->data_blocks[blockIndex];
			if (!datablock)continue;
			MetaData::Part* part = GetPart(datablock->references->part);
			if (part) {
				if (part->print_enable) {
					hasPrintPart = true;
					break;
				}
			}
		}

		if (hasPrintPart)
			powder += layer->powder;
		else
			break;
	}

	return powder;
}

MetaData::Layer* MetaData::GetLayer(unsigned int id)
{
	if (id >= layers->vector_layers.size())
		return nullptr;

	return layers->vector_layers[id];
}

unsigned int MetaData::CalcRemainTime(unsigned int index)
{
	m_RemainTime = 0;
	g_SystemInfo->m_StateBean.remainMil = m_RemainTime;
	double tTime = 0.0;
	if (index >= layers->vector_layers.size())  return m_RemainTime;
	for (size_t layerindex = index; layerindex < layers->vector_layers.size(); layerindex++) {
		tTime += layers->vector_layers[layerindex]->layer_estimate_time;
	}

	if (m_RunCfg->m_PrintRestEnable->GetValue() && m_RunCfg->m_PrintContinueMinute->GetValue() > 0) {
		double continueFlag = m_RunCfg->m_PrintContinueMinute->GetValue() * 60 * 1000;
		int pauseCount = tTime / continueFlag;
		tTime = tTime + pauseCount * m_RunCfg->m_PrintRestMinutes->GetValue() * 60 * 1000;
	}
	m_RemainTime = tTime;
	g_SystemInfo->m_StateBean.remainMil = m_RemainTime;
	return m_RemainTime;
}

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

void MetaData::GetErrorInfo(vector<string>& infos)
{
	for (size_t i = 0; i < m_Errors.size(); ++i) {
		infos.push_back(m_Errors[i]);
	}
}

string MetaData::GetErrorInfo() {
	string result;
	for (size_t i = 0; i < m_Errors.size(); ++i) {
		result +=m_Errors[i]+" ";
	}
	return result;
}



MetaData::ParameterSet* MetaData::GetParameterSet(int id)
{
	if (parameterMap.find(id) == parameterMap.end())
	{
		return NULL;
	}
	else return parameterMap[id];
}


void MetaData::ReCalcEvaTime()
{
	double perLayerpowderTime = 0.0;
	double coverMil = 0.0, shiftMil = 0.0;
	m_CoverCfg->Lock();
	if (m_CoverCfg->m_CoverDirection == CoverCfg::TWO_WAY1 || m_CoverCfg->m_CoverDirection == CoverCfg::TWO_WAY2) {
		double coverDis = (double)m_CoverCfg->m_cover_distance;
		if (m_CoverCfg->m_cover_speed != 0.0) {
			coverMil = coverDis / m_CoverCfg->m_cover_speed;
		}
	}
	else if (m_CoverCfg->m_CoverDirection == CoverCfg::ONE_WAY || m_CoverCfg->m_CoverDirection == CoverCfg::ONE_WAY2) {
		if (m_CoverCfg->m_cover_speed != 0.0) {
			coverMil = (double)m_CoverCfg->m_cover_distance / m_CoverCfg->m_cover_speed;
		}
		if (m_CoverCfg->m_cover_shift_speed != 0.0)
		{
			shiftMil = (double)m_CoverCfg->m_cover_distance / m_CoverCfg->m_cover_shift_speed;
		}
	}
	m_CoverCfg->UnLock();
	perLayerpowderTime = coverMil + shiftMil + 600.0;
	if (m_ExtCfg->m_AutoCoverSlowWind) {
		perLayerpowderTime += m_RunCfg->m_CoverWindSimulateTimeOffset->GetValue();
	}
	if (m_RunCfg->m_PrintLayerDelay != 0) {
		perLayerpowderTime = perLayerpowderTime + m_RunCfg->m_PrintLayerDelay->GetValue() * 1000;
	}
	if (m_RunCfg->m_CoverLayerDelay != 0) {
		perLayerpowderTime = perLayerpowderTime + m_RunCfg->m_CoverLayerDelay->GetValue() * 1000;
	}
	double milsec = 0.0;
	m_RemainTime = 0;
	if (m_HasOrder && m_MachineCfg->m_MachineType->GetValue() == MachineTypeCfg::HBD_1000) {
		map<int, ScannerControlCfg*>* laserCfgsMap = ConfigManager::GetInstance()->GetScannerControlCfg();
		for (size_t layerindex = 0; layerindex < layers->vector_layers.size(); ++layerindex) {
			map<int, double> areaTime;
			map<int, double> borderTime;
			for (int i = 0; i < 33; i++) {
				areaTime[i] = 0.0;
			}
			MetaData::Layer* layer = layers->vector_layers[layerindex];
			for (map<int, double>::iterator it = layer->estimateTimeMap.begin(); it != layer->estimateTimeMap.end(); it++) {
				it->second = 0.0;
			}
			layer->layer_estimate_time = 0;
			for (size_t blockIndex = 0; blockIndex < layer->data_blocks.size(); ++blockIndex) {
				MetaData::DataBlock* datablock = layer->data_blocks[blockIndex];
				if (!datablock)continue;
				MetaData::Part* part = GetPart(datablock->references->part);
				if (!part)continue;
				if (!part->print_enable)continue;
				if (datablock->cno == 0)continue;

				MetaData::ParameterSet* param = GetParameterSet(datablock->references->process);
				if (laserCfgsMap->find(datablock->cno) == laserCfgsMap->end())continue;
				ScannerControlCfg* laserCfg = (*laserCfgsMap)[datablock->cno];
				if (!laserCfg)continue;
				ScanParamCfg* scanParamCfg = laserCfg->GetScanParamCfg(param->set_type);
				if (scanParamCfg == NULL)scanParamCfg = &laserCfg->m_ScanCfgWrapper.m_ScanParamCfg;
				SkyWritingCfg* skyWritingCfg = &laserCfg->m_ScanCfgWrapper.m_SkyWritingCfg;
				double markMil = 0, jumpMil = 0, hatching = 0, jumpdelay = 0, markdelay = 0, sum = 0, flag = 0;
				if (scanParamCfg->m_jump_speed != 0) {
					jumpMil = datablock->data_block_summary->jump_distance / scanParamCfg->m_jump_speed * 1000;
					jumpMil *= 1.03;
				}
				if (param->laser_speed != 0) {
					markMil = datablock->data_block_summary->mark_distance / param->laser_speed * 1000;
					markMil *= 1.03;
				}

				int datatype = BIN_VECTOR;
				if (m_DataTypeMap.find(param->set_type) != m_DataTypeMap.end()) {
					datatype = m_DataTypeMap[param->set_type];
				}
				if (skyWritingCfg->m_Mode == 0)
				{
					if (datatype == BIN_CHAIN) {
						markdelay = (double)scanParamCfg->m_polygon_delay * datablock->data_block_summary->num_mark_segments / 1000.0;
					}
					else if (datatype == BIN_VECTOR) {
						markdelay = (double)scanParamCfg->m_scan_delay * datablock->data_block_summary->num_mark_segments / 1000.0;
					}
					else {
						markdelay = (double)scanParamCfg->m_scan_delay * datablock->data_block_summary->num_mark_segments / 1000.0;
					}
				}
				else {
					if (param->laser_set->laser_diameter < 100.0f) {
						double mseg = (double)datablock->data_block_summary->num_mark_segments;
						hatching = (mseg * (skyWritingCfg->m_Nprev + skyWritingCfg->m_Npost) / 1000.0);

					}
					else {
						if (datatype == BIN_CHAIN) {
							markdelay = (double)scanParamCfg->m_polygon_delay * datablock->data_block_summary->num_mark_segments / 1000.0;
						}
						else if (datatype == BIN_VECTOR) {
							markdelay = (double)scanParamCfg->m_scan_delay * datablock->data_block_summary->num_mark_segments / 1000.0;
						}
						else {
							markdelay = (double)scanParamCfg->m_scan_delay * datablock->data_block_summary->num_mark_segments / 1000.0;
						}
					}
				}
				if (datablock->data_block_summary->num_jump_segments > 0) {
					float avgL = (float)datablock->data_block_summary->jump_distance / datablock->data_block_summary->num_jump_segments;
					float judgL = 0.0f;
					float jump_delay = 0.0f;
					float min_jump_delay = 0.0f;
					judgL = (float)scanParamCfg->m_jump_length_limit;
					jump_delay = (float)scanParamCfg->m_jump_delay;
					min_jump_delay = (float)scanParamCfg->m_min_jump_delay;

					//float judgL =(float) scanParamCfg->m_jump_length_limit;
					if ((avgL < judgL) && (judgL != 0.0f)) {
						if (jump_delay > min_jump_delay) {
							float k = (float)(jump_delay - min_jump_delay) / judgL;
							float avgdl = k * avgL + min_jump_delay;
							if (avgdl > jump_delay)avgdl = jump_delay;
							jumpdelay = avgdl * datablock->data_block_summary->num_jump_segments / 1000.0;
						}
						else {
							jumpdelay = (double)min_jump_delay * datablock->data_block_summary->num_jump_segments / 1000.0;
						}
					}
					else {
						jumpdelay = (double)jump_delay * datablock->data_block_summary->num_jump_segments / 1000.0;
					}
				}

				sum = markMil + jumpMil + hatching + jumpdelay + markdelay + 20.0 + flag;
				datablock->scanTime = sum;
				if (datablock->order == 0)
				{
					borderTime[datablock->cno] += sum;
				}
				areaTime[datablock->order] += sum;
			}

			double topLeftSum = 0.0, topRightSum = 0.0, topSum = 0.0;
			double btnLeftSum = 0.0, btnRightSum = 0.0, btnSum = 0.0;

			for (int i = 1; i < 9; i++)
			{
				topLeftSum += areaTime[i];
			}
			for (int i = 9; i < 17; i++)
			{
				topRightSum += areaTime[i];
			}
			for (int i = 17; i < 25; i++)
			{
				btnLeftSum += areaTime[i];
			}
			for (int i = 25; i < 33; i++)
			{
				btnRightSum += areaTime[i];
			}

			topSum = topLeftSum > topRightSum ? (topLeftSum + topRightSum / 1.3) : (topRightSum + topLeftSum / 1.3);
			btnSum = btnLeftSum > btnRightSum ? (btnLeftSum + btnRightSum / 1.3) : (btnRightSum + btnLeftSum / 1.3);

			double borderSum = 0.0;
			for (map<int, double>::iterator it = borderTime.begin(); it != borderTime.end(); it++) {
				if (it->second > borderSum)borderSum = it->second;
			}
			double ss = topSum > btnSum ? topSum : btnSum;
			layer->layer_estimate_time += (ss + perLayerpowderTime);
			layer->layer_estimate_time += borderSum;
			milsec += layer->layer_estimate_time;
		}
		m_RemainTime = milsec;
		evaTime = milsec;
	}
	else {
		map<int, ScannerControlCfg*>* laserCfgsMap = ConfigManager::GetInstance()->GetScannerControlCfg();
		for (size_t layerindex = 0; layerindex < layers->vector_layers.size(); ++layerindex) {
			MetaData::Layer* layer = layers->vector_layers[layerindex];
			for (map<int, double>::iterator it = layer->estimateTimeMap.begin(); it != layer->estimateTimeMap.end(); it++) {
				it->second = 0.0;
			}
			layer->layer_estimate_time = 0;
			for (size_t blockIndex = 0; blockIndex < layer->data_blocks.size(); ++blockIndex) {
				//double milsec = 0;
				MetaData::DataBlock* datablock = layer->data_blocks[blockIndex];
				MetaData::ParameterSet* param = parameterMap[datablock->references->process];
				if (!param)continue;
				if (laserCfgsMap->find(datablock->cno) == laserCfgsMap->end())continue;
				ScannerControlCfg* laserCfg = (*laserCfgsMap)[datablock->cno];
				if (!laserCfg)continue;
				ScanParamCfg* scanParamCfg = laserCfg->GetScanParamCfg(param->set_type);
				if (scanParamCfg == NULL)scanParamCfg = &laserCfg->m_ScanCfgWrapper.m_ScanParamCfg;
				SkyWritingCfg* skyWritingCfg = &laserCfg->m_ScanCfgWrapper.m_SkyWritingCfg;
				double markMil = 0, jumpMil = 0, hatching = 0, jumpdelay = 0, markdelay = 0, sum = 0, flag = 0;
				if (scanParamCfg->m_jump_speed != 0) {
					jumpMil = datablock->data_block_summary->jump_distance / scanParamCfg->m_jump_speed * 1000;
					jumpMil *= 1.03;
				}
				if (param->laser_speed != 0) {
					markMil = datablock->data_block_summary->mark_distance / param->laser_speed * 1000;
					markMil *= 1.03;
				}
				int datatype = BIN_VECTOR;
				if (m_DataTypeMap.find(param->set_type) != m_DataTypeMap.end()) {
					datatype = m_DataTypeMap[param->set_type];
				}
				if (skyWritingCfg->m_Mode == 0)
				{

					if (datatype == BIN_CHAIN) {
						markdelay = (double)scanParamCfg->m_polygon_delay * datablock->data_block_summary->num_mark_segments / 1000.0;
					}
					else if (datatype == BIN_VECTOR) {
						markdelay = (double)scanParamCfg->m_scan_delay * datablock->data_block_summary->num_mark_segments / 1000.0;
					}
					else {
						markdelay = (double)scanParamCfg->m_scan_delay * datablock->data_block_summary->num_mark_segments / 1000.0;
					}
				}
				else {
					if (param->laser_set->laser_diameter < 100.0f) {
						double mseg = (double)datablock->data_block_summary->num_mark_segments;
						hatching = (mseg * (skyWritingCfg->m_Nprev + skyWritingCfg->m_Npost) / 1000.0);

					}
					else {

						if (datatype == BIN_CHAIN) {
							markdelay = (double)scanParamCfg->m_polygon_delay * datablock->data_block_summary->num_mark_segments / 1000.0;
						}
						else if (datatype == BIN_VECTOR) {
							markdelay = (double)scanParamCfg->m_scan_delay * datablock->data_block_summary->num_mark_segments / 1000.0;
						}
						else {
							markdelay = (double)scanParamCfg->m_scan_delay * datablock->data_block_summary->num_mark_segments / 1000.0;
						}
					}
				}
				if (datablock->data_block_summary->num_jump_segments > 0) {
					float avgL = (float)datablock->data_block_summary->jump_distance / datablock->data_block_summary->num_jump_segments;
					float judgL = 0.0f;
					float jump_delay = 0.0f;
					float min_jump_delay = 0.0f;
					judgL = (float)scanParamCfg->m_jump_length_limit;
					jump_delay = (float)scanParamCfg->m_jump_delay;
					min_jump_delay = (float)scanParamCfg->m_min_jump_delay;

					//float judgL =(float) scanParamCfg->m_jump_length_limit;
					if ((avgL < judgL) && (judgL != 0.0f)) {
						if (jump_delay > min_jump_delay) {
							float k = (float)(jump_delay - min_jump_delay) / judgL;
							float avgdl = k * avgL + min_jump_delay;
							if (avgdl > jump_delay)avgdl = jump_delay;
							jumpdelay = avgdl * datablock->data_block_summary->num_jump_segments / 1000.0;
						}
						else {
							jumpdelay = (double)min_jump_delay * datablock->data_block_summary->num_jump_segments / 1000.0;
						}
					}
					else {
						jumpdelay = (double)jump_delay * datablock->data_block_summary->num_jump_segments / 1000.0;
					}
				}
				sum = markMil + jumpMil + hatching + jumpdelay + markdelay + 20.0 + flag;
				datablock->scanTime = sum;
				//	milsec += sum;
				layer->estimateTimeMap[laserCfg->m_SeqNo ] += sum;
			}
			double max = 0.0;
			for (map<int, double>::iterator it = layer->estimateTimeMap.begin(); it != layer->estimateTimeMap.end(); it++) {
				double eve = it->second;
				if (eve > max)max = eve;
			}
			double ttemp = 0.0;
			if (max < (m_RunCfg->m_CoverSimulateTimeOffset->GetValue() + m_CoverCfg->m_SupplyTime)) {
				ttemp = (m_RunCfg->m_CoverSimulateTimeOffset->GetValue() - max) + m_CoverCfg->m_SupplyTime;
				max = 0.0;
			}
			layer->layer_estimate_time += (max + perLayerpowderTime + ttemp);
			milsec += layer->layer_estimate_time;
		}

		m_RemainTime = milsec;
		if (m_RunCfg->m_PrintRestEnable->GetValue() && m_RunCfg->m_PrintContinueMinute->GetValue() > 0) {
			double continueFlag = m_RunCfg->m_PrintContinueMinute->GetValue() * 60 * 1000;
			int pauseCount = milsec / continueFlag;
			milsec = milsec + pauseCount * m_RunCfg->m_PrintRestMinutes->GetValue() * 60 * 1000;
			m_RemainTime = m_RemainTime + pauseCount * m_RunCfg->m_PrintRestMinutes->GetValue() * 60 * 1000;
		}
		evaTime = milsec;
	}
	g_SystemInfo->m_StateBean.jobCostMil = evaTime;
	g_SystemInfo->m_StateBean.remainMil = m_RemainTime;
}

void MetaData::InitTypeMap()
{
	m_DataTypeMap["BlockSupport"] = BIN_CHAIN;
	m_DataTypeMap["DownBorder"] = BIN_CHAIN;
	m_DataTypeMap["DownBorderJ"] = BIN_CHAIN;
	m_DataTypeMap["DownBorderAd"] = BIN_CHAIN;
	m_DataTypeMap["DownBorderAdJ"] = BIN_CHAIN;
	m_DataTypeMap["DownFBorder"] = BIN_CHAIN;
	m_DataTypeMap["DownFBorderJ"] = BIN_CHAIN;
	m_DataTypeMap["DownHatching"] = BIN_VECTOR;
	m_DataTypeMap["DownHatching2"] = BIN_VECTOR;
	m_DataTypeMap["DownHatching3"] = BIN_VECTOR;
	m_DataTypeMap["DownHatching4"] = BIN_VECTOR;
	m_DataTypeMap["DownHatching5"] = BIN_VECTOR;
	m_DataTypeMap["DownThin"] = BIN_CHAIN;
	m_DataTypeMap["DownThinJ"] = BIN_CHAIN;
	m_DataTypeMap["Dummy"] = BIN_VECTOR;
	m_DataTypeMap["InBorder"] = BIN_CHAIN;
	m_DataTypeMap["InBorderJ"] = BIN_CHAIN;
	m_DataTypeMap["InBorderAd"] = BIN_CHAIN;
	m_DataTypeMap["InBorderAdJ"] = BIN_CHAIN;
	m_DataTypeMap["InFBorder"] = BIN_CHAIN;
	m_DataTypeMap["InFBorderJ"] = BIN_CHAIN;
	m_DataTypeMap["InHatching"] = BIN_VECTOR;
	m_DataTypeMap["InThin"] = BIN_CHAIN;
	m_DataTypeMap["InThinJ"] = BIN_CHAIN;
	m_DataTypeMap["Other"] = BIN_VECTOR;
	m_DataTypeMap["SupportBorder"] = BIN_CHAIN;
	m_DataTypeMap["SupportBorderAd"] = BIN_CHAIN;
	m_DataTypeMap["SupportHatching"] = BIN_VECTOR;
	m_DataTypeMap["UpBorder"] = BIN_CHAIN;
	m_DataTypeMap["UpBorderJ"] = BIN_CHAIN;
	m_DataTypeMap["UpBorderAd"] = BIN_CHAIN;
	m_DataTypeMap["UpBorderAdJ"] = BIN_CHAIN;
	m_DataTypeMap["UpFBorder"] = BIN_CHAIN;
	m_DataTypeMap["UpFBorderJ"] = BIN_CHAIN;
	m_DataTypeMap["UpHatching"] = BIN_VECTOR;
	m_DataTypeMap["UpHatching2"] = BIN_VECTOR;
	m_DataTypeMap["UpHatching3"] = BIN_VECTOR;
	m_DataTypeMap["UpHatching4"] = BIN_VECTOR;
	m_DataTypeMap["UpHatching5"] = BIN_VECTOR;
	m_DataTypeMap["UpThin"] = BIN_CHAIN;
	m_DataTypeMap["UpThinJ"] = BIN_CHAIN;
	m_DataTypeMap["LatticeHatching"] = BIN_VECTOR;
	m_DataTypeMap["LatticeBorder"] = BIN_CHAIN;
	m_DataTypeMap["LatticeBorderJ"] = BIN_CHAIN;
	m_DataTypeMap["LatticeFBorder"] = BIN_CHAIN;
	m_DataTypeMap["LatticeFBorderJ"] = BIN_CHAIN;

	m_DataTypeMap["BorderDown"] = BIN_CHAIN;
	m_DataTypeMap["FillContourDown"] = BIN_CHAIN;
	m_DataTypeMap["HatchingDown"] = BIN_VECTOR;
	m_DataTypeMap["BorderAdditionalDown"] = BIN_CHAIN;
	m_DataTypeMap["BorderBlockedDown"] = BIN_CHAIN;
	m_DataTypeMap["Border"] = BIN_CHAIN;
	m_DataTypeMap["FillContour"] = BIN_CHAIN;
	m_DataTypeMap["Hatching"] = BIN_VECTOR;
	m_DataTypeMap["BorderAdditional"] = BIN_CHAIN;
	m_DataTypeMap["BorderBlocked"] = BIN_CHAIN;
	m_DataTypeMap["BorderUp"] = BIN_CHAIN;
	m_DataTypeMap["FillContourUp"] = BIN_CHAIN;
	m_DataTypeMap["HatchingUp"] = BIN_VECTOR;
	m_DataTypeMap["BorderAdditionalUp"] = BIN_CHAIN;
	m_DataTypeMap["BorderBlockedUp"] = BIN_CHAIN;
	m_DataTypeMap["BorderSupport"] = BIN_CHAIN;
	m_DataTypeMap["HatchingBorder"] = BIN_VECTOR;
	m_DataTypeMap["BorderAdditionalSupport"] = BIN_CHAIN;
	m_DataTypeMap["WallSupport"] = BIN_VECTOR;
}

void MetaData::ClearBlockMap()
{
	for (map<DataBlock*, BPBinary::BinDataBlock*>::iterator it = m_block_map.begin(); it != m_block_map.end(); ++it) {
		delete it->second;
	}
	m_block_map.clear();
}

void MetaData::ClearPrevBlockMap()
{
	for (map<DataBlock*, BPBinary::BinDataBlock*>::iterator it = m_prev_block_map.begin(); it != m_prev_block_map.end(); ++it) {
		delete it->second;
	}
	m_prev_block_map.clear();
}

void MetaData::ClearRemoteBlockMap()
{
	for (map<DataBlock*, BPBinary::BinDataBlock*>::iterator it = m_remote_block_map.begin(); it != m_remote_block_map.end(); ++it) {
		delete it->second;
	}
	m_remote_block_map.clear();
}

void MetaData::ClearBFileMap()
{
	for (map<string, ifstream*>::iterator it = m_binary_file_map.begin(); it != m_binary_file_map.end(); ++it)
	{
		ifstream* pbfile = it->second;
		if (pbfile) {
			if (pbfile->is_open())pbfile->close();
			delete pbfile;
		}
	}
	m_binary_file_map.clear();

	for (map<string, ifstream*>::iterator it = m_pre_file_map.begin(); it != m_pre_file_map.end(); ++it)
	{
		ifstream* pbfile = it->second;
		if (pbfile) {
			pbfile->close();
			delete pbfile;
		}
	}
	m_pre_file_map.clear();

}


map<string, int> MetaData::m_DataTypeMap = map<string, int>();