#include "H3DFileProcessor.h"
#include "../utils/StringHelper.h"
#include "../LanguageManager.h"
#include "JobController.h"
#include "../Logger.h"

H3DFileProcessor::H3DFileProcessor()
{
	m_ExtCfg = ConfigManager::GetInstance()->GetExtCfg();
}

H3DFileProcessor::~H3DFileProcessor()
{}

string H3DFileProcessor::ReadStringFromStream(ifstream* ifs)
{
	char buffer[1024];
	memset(buffer, '\0', sizeof(buffer));
	int flag = 0;
	char temp;
	while (!ifs->eof()) {
		ifs->get(temp);
		if (temp == '\0') {
			break;
		}
		else {
			buffer[flag] = temp;
		}
		flag++;
	}
	return string(buffer);
}

int H3DFileProcessor::Process(string jobfile)
{
	ifstream* ifs = new ifstream();
	ifs->open(jobfile.c_str(), ios::binary);
	if (!ifs->is_open()) {
		delete ifs;
		return -1;
	}
	ifstream* pfs = new ifstream();
	pfs->open(jobfile.c_str(), ios::binary);
	if (!pfs->is_open())
	{
		delete pfs;
		return -1;
	}
	H3DMetaData* metadata = &m_MetaData;
	m_TaskId = StringHelper::GenerateUUID();
	MetaData::BinaryFile* bfile = new MetaData::BinaryFile();
	bfile->id = 0;
	bfile->name = jobfile;
	metadata->binary_files[bfile->id] = bfile;
	metadata->AddHJobFile2Map(bfile->name, ifs, pfs);
	ifs->read((char*)metadata->file_info->version, sizeof(MetaData::Version));
	metadata->job_id = StringHelper::ReadString(ifs);
	metadata->general_info->job_name = StringHelper::ReadString(ifs);
	metadata->general_info->material = StringHelper::ReadString(ifs);
	ifs->read((char*)metadata->general_info->job_dimensions, sizeof(MetaData::JobDimensions));
	metadata->layers->layer_thickness_pos=ifs->tellg();
	float layerThickness = 0.0f;
	ifs->read((char*)&layerThickness, sizeof(float));
	metadata->layers->layer_thickness = (1000.0f*layerThickness + 0.5f);
	unsigned int scanfieldsize = 0;
	ifs->read((char*)&scanfieldsize, sizeof(scanfieldsize));
	for (unsigned int sfIndex = 0; sfIndex < scanfieldsize; ++sfIndex) {
		MetaData::ScanField* sf = new MetaData::ScanField();
		ifs->read((char*)&sf->id, sizeof(sf->id));
		ifs->read((char*)&sf->reference, sizeof(sf->reference));
		ifs->read((char*)sf->dimension, sizeof(MetaData::Dimension));
		metadata->machine_type->scanFields.push_back(sf);
	}
	unsigned int lasersize = 0;
	ifs->read((char*)&lasersize, sizeof(lasersize));
	for (unsigned int laserIndex = 0; laserIndex < lasersize; ++laserIndex) {
		MetaData::Laser* laser = new MetaData::Laser();
		ifs->read((char*)&laser->id, sizeof(laser->id));
		ifs->read((char*)&laser->reference, sizeof(laser->reference));
		metadata->machine_type->lasers.push_back(laser);
	}

	if (metadata->m_MachineCfg->IsDataStrategy()) {
		vector<ScannerControlCfg*>* cfgs = ConfigManager::GetInstance()->GetMatchScannerControlCfg();
		if (metadata->machine_type->scanFields.empty()) {
			MetaData::ScanField* sf = new MetaData::ScanField();
			sf->id = 0;
			sf->reference = 0;
			if (!cfgs->empty()) {
				sf->dimension->xmin = (*cfgs)[0]->m_ScanCfgWrapper.m_CorrectParamCfg.m_xmeasure_min;
				sf->dimension->xmax = (*cfgs)[0]->m_ScanCfgWrapper.m_CorrectParamCfg.m_xmeasure_max;
				sf->dimension->ymin = (*cfgs)[0]->m_ScanCfgWrapper.m_CorrectParamCfg.m_ymeasure_min;
				sf->dimension->ymax = (*cfgs)[0]->m_ScanCfgWrapper.m_CorrectParamCfg.m_ymeasure_max;
			}
			else {
				sf->dimension->xmin = metadata->general_info->job_dimensions->xmin;
				sf->dimension->xmax = metadata->general_info->job_dimensions->xmax;
				sf->dimension->ymin = metadata->general_info->job_dimensions->ymin;
				sf->dimension->ymax = metadata->general_info->job_dimensions->ymax;
			}
			metadata->machine_type->scanFields.push_back(sf);
		}

		map<int, unsigned int> hasSelected;
		int canSelectIndex = 0;
		//检测可匹配的ScanField
		for (size_t i = 0; i < metadata->machine_type->scanFields.size(); ++i)
		{
			MetaData::ScanField* sf = metadata->machine_type->scanFields[i];
			float sf_maxx = sf->dimension->xmax - sf->dimension->xmin;
			float sf_maxy = sf->dimension->ymax - sf->dimension->ymin;
			bool hasfind = false;
			queue<int> canSelectIndexs;
			for (size_t laserIndex = 0; laserIndex < cfgs->size(); ++laserIndex) {
				ScannerControlCfg* cfg = (*cfgs)[laserIndex];
				if (!cfg->m_IsEnable)continue;
				float cfg_xmin = (float)cfg->m_ScanCfgWrapper.m_CorrectParamCfg.m_xmeasure_min;
				float cfg_xmax = (float)cfg->m_ScanCfgWrapper.m_CorrectParamCfg.m_xmeasure_max;
				float cfg_ymin = (float)cfg->m_ScanCfgWrapper.m_CorrectParamCfg.m_ymeasure_min;
				float cfg_ymax = (float)cfg->m_ScanCfgWrapper.m_CorrectParamCfg.m_ymeasure_max;

				if ((sf->dimension->xmin >= cfg_xmin) && (sf->dimension->xmax <= cfg_xmax) && (sf->dimension->ymin >= cfg_ymin) && (sf->dimension->ymax <= cfg_ymax)) {
					canSelectIndexs.push(laserIndex);
					if (!hasSelected[cfg->m_SeqNo ]) {
						metadata->m_FieldRefScanLaser[sf->id] = cfg;
						hasSelected[cfg->m_SeqNo ] = 1;
						hasfind = true;
						break;
					}

				}
			}
			if (!hasfind) {
				if (canSelectIndexs.empty()) {
					char buffer[256];
					sprintf_s(buffer, sizeof(buffer), g_LngManager->Toast_ScanFileErrorInfo->ShowText(),
						sf->id);
					//EnterCriticalSection(&metadata->m_MsgCs);
					metadata->m_Errors.push_back(buffer);
					//LeaveCriticalSection(&metadata->m_MsgCs);
				}
				else {
					int firstfix = canSelectIndexs.front();
					metadata->m_FieldRefScanLaser[sf->id] = (*cfgs)[firstfix];
				}
			}
		}
		//检测是否越限
		if (!cfgs->empty()) {
			float min_x = FLT_MAX;
			float max_x = FLT_MIN;
			float min_y = FLT_MAX;
			float max_y = FLT_MIN;
			for (size_t laserindex = 0; laserindex < cfgs->size(); ++laserindex) {
				ScannerControlCfg* cfg = (*cfgs)[laserindex];
				if (cfg->m_ScanCfgWrapper.m_CorrectParamCfg.m_xmeasure_min < min_x)min_x = cfg->m_ScanCfgWrapper.m_CorrectParamCfg.m_xmeasure_min;
				if (cfg->m_ScanCfgWrapper.m_CorrectParamCfg.m_xmeasure_max > max_x)max_x = cfg->m_ScanCfgWrapper.m_CorrectParamCfg.m_xmeasure_max;
				if (cfg->m_ScanCfgWrapper.m_CorrectParamCfg.m_ymeasure_min < min_y)min_y = cfg->m_ScanCfgWrapper.m_CorrectParamCfg.m_ymeasure_min;
				if (cfg->m_ScanCfgWrapper.m_CorrectParamCfg.m_ymeasure_max > max_y)max_y = cfg->m_ScanCfgWrapper.m_CorrectParamCfg.m_ymeasure_max;
			}
			if ((metadata->general_info->job_dimensions->xmin < min_x) || (metadata->general_info->job_dimensions->xmax > max_x)) {
				//EnterCriticalSection(&metadata->m_MsgCs);
				metadata->m_Errors.push_back(g_LngManager->Toast_XDataErrorInfo->ShowText());
				//LeaveCriticalSection(&metadata->m_MsgCs);
			}

			if ((metadata->general_info->job_dimensions->ymin < min_y) || (metadata->general_info->job_dimensions->ymax > max_y)) {
				//EnterCriticalSection(&metadata->m_MsgCs);
				metadata->m_Errors.push_back(g_LngManager->Toast_YDataErrorInfo->ShowText());
				//LeaveCriticalSection(&metadata->m_MsgCs);
			}
		}
	}

	unsigned int partsize = 0;
	ifs->read((char*)&partsize, sizeof(partsize));
	for (unsigned int partIndex = 0; partIndex < partsize; ++partIndex) {
		MetaData::Part* part = new MetaData::Part();
		ifs->read((char*)&part->id, sizeof(part->id));
		part->name = StringHelper::ReadString(ifs);
		ifs->read((char*)part->dimensions, sizeof(MetaData::JobDimensions));

		part->partPosBean.m_JobId = metadata->job_id;
		part->partPosBean.m_PartCenterX = (part->dimensions->xmax + part->dimensions->xmin) / 2.0f;
		part->partPosBean.m_PartCenterY = (part->dimensions->ymax + part->dimensions->ymin) / 2.0f;
		part->partPosBean.m_SrcPartCenterX = part->partPosBean.m_PartCenterX;
		part->partPosBean.m_SrcPartCenterY = part->partPosBean.m_PartCenterY;

		metadata->partsVec.push_back(part);
		metadata->partsMap[part->id] = part;
		unsigned int paramsize = 0;
		
		ifs->read((char*)&paramsize, sizeof(paramsize));
		if (paramsize > 10000) {
			char ebuffer[200];
			sprintf_s(ebuffer, sizeof(ebuffer), _(u8"检测到零件%d参数有错误").c_str(), part->id);
			metadata->m_Errors.push_back(ebuffer);
			return -1;
		}
		//vector<int>* vec = new vector<int>();
		part->param_pos = ifs->tellg();
		for (size_t paramidIndex = 0; paramidIndex < paramsize; ++paramidIndex) {
			MetaData::ParameterSet* ps = new MetaData::ParameterSet();
			ifs->read((char*)&ps->id, sizeof(ps->id));
			ps->set_type = StringHelper::ReadString(ifs);
			ifs->read((char*)&ps->laser_speed, sizeof(ps->laser_speed));
			ifs->read((char*)&ps->scan_field, sizeof(ps->scan_field));
			ifs->read((char*)ps->laser_set, sizeof(MetaData::LaserSet) - sizeof(float));
			metadata->parameterMap[ps->id] = ps;
			//part->paramSet.insert(ps);
		}
	}

	unsigned int layersize = 0;
	ifs->read((char*)&layersize, sizeof(layersize));
	//char buffer[123];
	for (unsigned int layerIndex = 0; layerIndex < layersize; ++layerIndex) {
		MetaData::Layer* layer = new MetaData::Layer();
		metadata->layers->vector_layers.push_back(layer);
		float layerZ = 0.0f;
		ifs->read((char*)&layerZ, sizeof(layerZ));
		//float tempz = (int)(layerZ*10000.0f+0.5)/10000.0f;
		//layer->z = tempz*1000.0f+0.5f;
		layer->z = layerZ *1000.0f + 0.5f;
		//sprintf_s(buffer, sizeof(buffer), "layerIndex:%d , z:%.6f , cz:%d \n", layerIndex,  layerZ,  layer->z);
		//OutputDebugString(buffer);
		//ifs->read((char*)&layer->z, sizeof(layer->z));
		layer->layer_thickness = metadata->layers->layer_thickness;
		if (metadata->file_info->version->major == 1 && metadata->file_info->version->minor == 0)
			layer->powder = layer->layer_thickness * 2;
		else {
			layer->powder_pos = ifs->tellg();
			float layerPowder = 0.0f;
			ifs->read((char*)& layerPowder, sizeof(layerPowder));
			layer->powder = layerPowder*1000.0f + 0.5f;
		}
			
		ifs->read((char*)layer->layer_summary, sizeof(MetaData::LayerSummary));
		layer->index = layerIndex;
		unsigned int dbsize = 0;
		ifs->read((char*)&dbsize, sizeof(dbsize));
		for (unsigned int dbIndex = 0; dbIndex < dbsize; ++dbIndex) {
			MetaData::DataBlock* db = new MetaData::DataBlock();
			layer->data_blocks.push_back(db);
			ifs->read((char*)db->references, sizeof(MetaData::References));
			ifs->read((char*)db->data_block_summary, sizeof(MetaData::DataBlockSummary));
			vector<MetaData::DataBlock*>* blocks = layer->data_blocks_map[db->references->part];
			if (blocks == NULL)
			{
				blocks = new vector<MetaData::DataBlock*>();
				blocks->push_back(db);
				layer->data_blocks_map[db->references->part] = blocks;
			}
			else {
				blocks->push_back(db);
			}

			ifs->read((char*)&db->bin->pos, sizeof(db->bin->pos));
			if (metadata->parameterMap.find(db->references->process) != metadata->parameterMap.end()) {
				MetaData::ParameterSet* ps = metadata->parameterMap[db->references->process];
				if (metadata->partsMap.find(db->references->part) != metadata->partsMap.end()) {
					metadata->partsMap[db->references->part]->paramSet.insert(ps);
				}
				MetaData::Part* part = metadata->GetPart(db->references->part);
				if (!part)
				{
					char ebuffer[200];
					sprintf_s(ebuffer, sizeof(ebuffer), _(u8"检测到第%d层数据有错误").c_str(), layerIndex + 1);
					if (metadata->m_Errors.size() < 100)metadata->m_Errors.push_back(ebuffer);
					return 0;
				}
				layer->parts[part->id] = part;
				db->belongPart = part;

				ScannerControlCfg* laserCfg = NULL;
				if (metadata->m_MachineCfg->IsDataStrategy()) {
					laserCfg = metadata->m_FieldRefScanLaser[ps->scan_field];
				}

				if (laserCfg) {
					db->cno = laserCfg->m_SeqNo ;
				}
			}
			else {
				char ebuffer[200];
				sprintf_s(ebuffer, sizeof(ebuffer), _(u8"检测到第%d层数据有错误").c_str(), layerIndex + 1);
				if (metadata->m_Errors.size() < 100)metadata->m_Errors.push_back(ebuffer);
				return 0;
			}
			unsigned int bytecount = 0;
			ifs->read((char*)&bytecount, sizeof(bytecount));
			ifs->seekg(bytecount, ios::cur);
		}
		JobController::SetLoadProgress((float)layerIndex / layersize);
	}
	MetaData::Layer* llayer = NULL;
	uint32_t lthick = 0.0f;
	for (size_t i = 0; i < metadata->layers->vector_layers.size(); i++) {
		MetaData::Layer * templ = metadata->layers->vector_layers[i];
		if (llayer)
		{
			llayer->layer_thickness = templ->z - llayer->z;
			llayer->powder = llayer->layer_thickness * 2;
			lthick = llayer->layer_thickness;
		}
		llayer = templ;
	}
	if (llayer)
	{
		llayer->layer_thickness = lthick;
		llayer->powder = lthick * 2;
	}
	if (m_ExtCfg->m_CheckDataWhenInport) {
		JobController::m_LoadProgressInfoFlag = JobController::CkeckingJobData;
		JobController::SetLoadProgress(0.0f);
		unsigned int layercount = metadata->layers->vector_layers.size();
		for (size_t layerIndex = 0; layerIndex < metadata->layers->vector_layers.size(); ++layerIndex) {
			if (!metadata->LoadLayerByIndex(layerIndex)) {
				char ebuffer[200];
				sprintf_s(ebuffer, sizeof(ebuffer), _(u8"检测到第%d层数据有错误").c_str(), layerIndex + 1);
				metadata->m_Errors.push_back(ebuffer);
				break;
			}
			JobController::SetLoadProgress((float)(layerIndex + 1) / layercount);
		}
	}
	if (metadata->file_info->version->major == 1 && metadata->file_info->version->minor < 2) {
		return 0;
	}

	uint64_t cur = ifs->tellg();
	int blockCnt = 0;
	ifs->read((char*)&blockCnt, sizeof(int));
	if (ifs->eof()) {
		return 0;
	}
	if (blockCnt <= 0) {
		return 0;
	}

	int blockType = 0;
	ifs->read((char*)&blockType, sizeof(int));
	if (blockType != 0) {
		return 0;
	}
	uint64_t blockSize = 0;
	ifs->read((char*)&blockSize, sizeof(uint64_t));
	int cfgMapCnt = 0;
	ifs->read((char*)&cfgMapCnt, sizeof(int));
	int partId = 0;
	for (int i = 0; i < cfgMapCnt; i++) {
		ifs->read((char*)&partId, sizeof(int));
		StringHelper::ReadString(ifs);
	}
	int bpCfgCnt = 0;
	ifs->read((char*)&bpCfgCnt, sizeof(int));
	if (bpCfgCnt <= 0) {
		return 0;
	}

	// cfg name
	StringHelper::ReadString(ifs);
	ifs->seekg(sizeof(bool) * 2, ios::cur);
	int offsetSize = 0;
	ifs->read((char*)&offsetSize, sizeof(int));
	ifs->seekg(sizeof(float) * offsetSize + sizeof(int) + sizeof(double), ios::cur);

	if (ifs->eof()) {
		return 0;
	}

	bool scanOrderForPlatform = false;
	ifs->read((char*)&scanOrderForPlatform, sizeof(bool));
	metadata->m_IsScanOrderForPlatform = scanOrderForPlatform;

	if (metadata->file_info->version->major == 1 && metadata->file_info->version->minor < 3) {
		return 0;
	}

	if (blockCnt < 2 ) {
		return 0;
	}

	ifs->seekg(cur + sizeof(int) + sizeof(int) + blockSize, ios::beg);
	ifs->read((char*)&blockType, sizeof(int));
	if (blockType != 1) {
		return 0;
	}
	ifs->read((char*)&blockSize, sizeof(uint64_t));
	int layerCnt = 0;
	ifs->read((char*)&layerCnt, sizeof(int));
	for (int i = 0; i < layerCnt; i++) {
		int dbCnt = 0;
		ifs->read((char*)&dbCnt, sizeof(int));
		if (dbCnt > 0) {
			std::vector<order> tmp(dbCnt);
			ifs->read((char*)tmp.data(), sizeof(order) * dbCnt);
			std::map<uint64_t, int> amap;
			for (int j = 0; j < tmp.size(); j++) {
				amap[tmp[j].id] = tmp[j].scanOrder;
			}
			for (MetaData::DataBlock* db : m_MetaData.layers->vector_layers[i]->data_blocks) {
				db->order = amap[db->bin->pos];
			}
		}
	}
	if (blockCnt < 3) {
		return 0;
	}
	ifs->read((char*)&blockType, sizeof(int));
	if (blockType != 2) {
		return 0;
	}
	ifs->read((char*)&blockSize, sizeof(uint64_t));
	cur = ifs->tellg();
	ifs->seekg(cur+blockSize- sizeof(uint64_t), ios::beg);
	if (blockCnt < 4) {
		return 0;
	}
	ifs->read((char*)&blockType, sizeof(int));
	if (blockType != 3) {
		return 0;
	}
	ifs->read((char*)&blockSize, sizeof(uint64_t));
	int osV2 = 0;
	ifs->read((char*)&osV2, sizeof(osV2));
	m_MetaData.m_IsScanOrderSeqV2 = osV2>0?true:false;
	//g_log->TraceInfo("IsScanorderV2:%d", m_MetaData.m_IsScanOrderSeqV2);
	m_MetaData.m_HasOrder = true;
	return 0;
}


void H3DFileProcessor::UpdateFile()
{
	if (m_MetaData.binary_files.find(0) == m_MetaData.binary_files.end())return;
	ofstream ofs(m_MetaData.binary_files[0]->name.c_str(), ios::binary|ios::in);
	if (!ofs.is_open())return;
	int thicknessOffset = m_MetaData.layers->layer_thickness_pos;
	ofs.seekp(thicknessOffset, ios::beg);
	float lthick = (float)m_MetaData.layers->layer_thickness / 1000.0f;
	ofs.write((char*)&lthick, sizeof(float));
	int partsize = m_MetaData.GetPartVec().size();
	for (int partIndex = 0; partIndex < partsize; ++partIndex) {
		MetaData::Part* part = m_MetaData.GetPartVec()[partIndex];
		ofs.seekp(part->param_pos,ios::beg);
		for (map<int, MetaData::ParameterSet*>::iterator it = m_MetaData.parameterMap.begin(); it != m_MetaData.parameterMap.end();it++) {
			MetaData::ParameterSet* ps = it->second;
			ofs.write((char*)&ps->id, sizeof(ps->id));
			ofs.write(ps->set_type.c_str(), ps->set_type.size() + 1);
			ofs.write((char*)&ps->laser_speed, sizeof(ps->laser_speed));
			ofs.write((char*)&ps->scan_field, sizeof(ps->scan_field));
			ofs.write((char*)ps->laser_set, sizeof(MetaData::LaserSet) - sizeof(float));
		}
	}
	unsigned int layersize = m_MetaData.layers->vector_layers.size();
	for (size_t i = 0; i < m_MetaData.layers->vector_layers.size();i++) {
		MetaData::Layer* layer = m_MetaData.layers->vector_layers[i];
		if (layer->powder_pos!=0) {
			ofs.seekp(layer->powder_pos, ios::beg);
			ofs.write((char*)&layer->powder, sizeof(layer->powder));
		}
	}
	ofs.flush();
	ofs.close();
}