#include "JobController.h"
#include <commdlg.h>
#include <time.h>
#include "../Toast.h"
#include "../LanguageManager.h"
#include "../global.h"
#include <fstream>

JobController::JobController()
	:m_CurrentJob(NULL)
	, m_LoadThead(INVALID_HANDLE_VALUE)
	, m_LoadFlag(false)
	, m_FilePath("")
	, m_TempJob(NULL)
	,m_PrepareJob(NULL)
	, m_SavePreJobThread(INVALID_HANDLE_VALUE)
{
	InitializeCriticalSection(&m_cs);
	InitializeCriticalSection(&m_PreJobCS);

	g_LngManager->m_LoadProgressInfoMap[AnalyzingJobData] = _(u8"正在解析任务数据");
	g_LngManager->m_LoadProgressInfoMap[CkeckingJobData] = _(u8"正在检验数据");
	m_RunCfg = ConfigManager::GetInstance()->GetRunCfg();
}


JobController::~JobController()
{
	RemoveAllJob();
	DeleteCriticalSection(&m_cs);
	DeleteCriticalSection(&m_PreJobCS);
}

void JobController::StartLoadPrepareJob()
{
	HANDLE lp = AtlCreateThread(LoadPrepareJobProc, this);
	CloseHandle(lp);
}

DWORD WINAPI JobController::LoadPrepareJobProc(JobController* _this) {
	if (!_this)return 0;
	char buffer[512];
	MachineCfg* mcfg = ConfigManager::GetInstance()->GetMachineCfg();
	sprintf_s(buffer, sizeof(buffer), "%sPrepareJob/%d.h3d", g_AppPath.c_str(), mcfg->m_MachineType);
	H3DFileProcessor* fp = new H3DFileProcessor();
	if (fp->Process(buffer) != BP_SUCCESS)
	{
		delete fp;
		return NULL;
	}
	map<int,bool>* precfgs=ConfigManager::GetInstance()->GetPreJobParamCfg();
	vector<MetaData::Layer*> layers = fp->GetMetaData()->GetLayersVec();
	for (map<int, bool>::iterator it = precfgs->begin(); it != precfgs->end();it++) {
		if (it->first < layers.size()) {
			layers[it->first]->isPrintable = it->second;
		}
	}
	EnterCriticalSection(&_this->m_PreJobCS);
	if (_this->m_PrepareJob) {
		delete _this->m_PrepareJob;
	}
	_this->m_PrepareJob = fp;
	LeaveCriticalSection(&_this->m_PreJobCS);
	return 0;
}

bool JobController::LoadJob(string filepath)
{
	SetLoadProgress(0.0f);
	JobController::m_LoadProgressInfoFlag = CkeckingJobData;
	string filename = filepath.substr(filepath.find_last_of("\\") + 1, filepath.length() - 1);
	EnterCriticalSection(&m_cs);
	if (m_CurrentJob != NULL && m_CurrentJob->GetJobFileName() == filename) {
		g_Toast->AddToast(new ToastBean(_(u8"添加任务失败：重复添加").c_str(), 3000));
		LeaveCriticalSection(&m_cs);
		return false;
	}

	
	if (m_CurrentJob != NULL) {
		delete m_CurrentJob;
		m_CurrentJob = NULL;
		m_TempJob = NULL;
	}
	m_LoadFlag = true;
	LeaveCriticalSection(&m_cs);

	m_FilePath = filepath;
	m_LoadThead = AtlCreateThread(LoadProc, this);
	return true;
}

DWORD WINAPI JobController::LoadProc(JobController* _this)
{
	if (_this) {
		_this->LoadRun();
		EnterCriticalSection(&_this->m_cs);
		_this->m_LoadFlag = false;
		LeaveCriticalSection(&_this->m_cs);
	}

	return 0;
}

void JobController::LoadRun()
{
	if (m_FilePath.find(".h3d") != string::npos)
	{
		m_TempJob = new H3DFileProcessor();
	}
	else
		m_TempJob = new JobFileProcessor();

	if (m_TempJob->Process(m_FilePath) != BP_SUCCESS) {
		delete m_TempJob;
		m_TempJob = NULL;
		g_Toast->AddToast(new ToastBean(_(u8"添加任务失败：不支持的数据").c_str(), 3000, Toast::COLOR_RED));
		return;
	}
	else {
		EnterCriticalSection(&m_cs);
		m_CurrentJob = m_TempJob;
		m_CurrentJob->GetMetaData()->ResetIfs();
		// 根据工艺参数设置层的默认供粉量
		ParamSetCfg::ParamSet* ps = ConfigManager::GetInstance()->GetParamSetCfg()->ParamSetVec[0];
		std::vector<MetaData::Layer*>& layers = m_CurrentJob->GetMetaData()->GetLayersVec();
		for (unsigned int i = 0; i < ps->PowderSets.size(); i++)
		{
			for (unsigned int layer = ps->PowderSets[i]->start_layer;
				layer < m_CurrentJob->GetLayerCount() && layer <= ps->PowderSets[i]->end_layer;
				layer++)
			{
				layers[layer - 1]->powder = ps->PowderSets[i]->powder * layers[layer - 1]->layer_thickness;
			}
		}

		m_CurrentJob->GetMetaData()->GetLayer(0)->scan_times = 2;

		for (size_t i = 0; i < layers.size(); i++) {
			MetaData::Layer* templ = layers[i];
			if (templ->layer_thickness > 1000) {
				char ebuffer[200];
				sprintf_s(ebuffer, sizeof(ebuffer), _(u8"检测到第%d层层厚异常：%u").c_str(), i + 1, templ->layer_thickness);
				m_CurrentJob->GetMetaData()->AddErrorInfo(ebuffer);
				break;
			}
			if (templ->powder > 1000) {
				char ebuffer[200];
				sprintf_s(ebuffer, sizeof(ebuffer), _(u8"检测到第%d层供粉量有异常：%u").c_str(), i + 1, templ->powder);
				m_CurrentJob->GetMetaData()->AddErrorInfo(ebuffer);
				break;
			}
		}
		LeaveCriticalSection(&m_cs);
	}
}


float JobController::GetLoadProgress()
{
	float rel = 0;
	EnterCriticalSection(&m_LoadInfoCS);
	rel = m_LoadProgress;
	LeaveCriticalSection(&m_LoadInfoCS);
	return rel;
}

string JobController::GetLoadInfo()
{
	return g_LngManager->m_LoadProgressInfoMap[m_LoadProgressInfoFlag];
}

bool JobController::IsLoadFinished()
{
	bool rel = false;
	EnterCriticalSection(&m_cs);
	rel = !m_LoadFlag;
	LeaveCriticalSection(&m_cs);
	return rel;
}

void JobController::RemoveJob(string job_titel)
{
	EnterCriticalSection(&m_cs);
	if (m_CurrentJob != NULL) {
		delete m_CurrentJob;
		m_CurrentJob = NULL;
		m_TempJob = NULL;
	}
	LeaveCriticalSection(&m_cs);
}

void JobController::RemoveAllJob()
{
	EnterCriticalSection(&m_cs);
	if (m_CurrentJob != NULL) {
		delete m_CurrentJob;
		m_CurrentJob = NULL;
		m_TempJob = NULL;
	}
	LeaveCriticalSection(&m_cs);
}

FileProcessor* JobController::GetUnFinishedJob()
{
	if (m_CurrentJob->IsFinished())
		return m_CurrentJob;
	else
		return NULL;
}


void JobController::StartSavePrepareJob()
{
	if (m_SavePreJobThread != INVALID_HANDLE_VALUE)return;
	m_SavePreJobThread = AtlCreateThread(SavePrepareJobProc, this);
}

DWORD WINAPI JobController::SavePrepareJobProc(JobController* _this)
{
	if (!_this || !_this->m_PrepareJob) {
		if(_this->m_SavePreJobThread!=INVALID_HANDLE_VALUE)CloseHandle(_this->m_SavePreJobThread);
		_this->m_SavePreJobThread = INVALID_HANDLE_VALUE;
		return 0;
	}
	_this->m_PrepareJob->UpdateFile();
	if (_this->m_SavePreJobThread != INVALID_HANDLE_VALUE)CloseHandle(_this->m_SavePreJobThread);
	_this->m_SavePreJobThread = INVALID_HANDLE_VALUE;
	ConfigManager::GetInstance()->SavePreJobParamCfg();
	g_Toast->AddToast(new ToastBean(_(u8"写入成功").c_str(),3000,Toast::COLOR_GREEN));
	return 0;
}

bool JobController::IsSavingPrepareJob() {
	if (m_SavePreJobThread!=INVALID_HANDLE_VALUE) {
		return true;
	}
	else return false;
}

bool JobController::CheckDiskSpace()
{
	int layerCount = 0;
	EnterCriticalSection(&m_cs);
	if (m_CurrentJob)
	{
		layerCount = m_CurrentJob->GetLayerCount() - m_CurrentJob->GetStartIndex();
	}
	LeaveCriticalSection(&m_cs);
	if (layerCount <= 1)return true;

	ULARGE_INTEGER freeBytesAvailable, totalNumberOfBytes, totalNumberOfFreeBytes;
	if (GetDiskFreeSpaceEx(g_AppDisk.c_str(), &freeBytesAvailable, &totalNumberOfBytes, &totalNumberOfFreeBytes)) {
		unsigned long long totalSpace = totalNumberOfBytes.QuadPart;
		unsigned long long freeSpace = totalNumberOfFreeBytes.QuadPart;
		double freeSpaceK = (double)freeSpace / 1024.0;
		double freeSpaceM = freeSpaceK / 1024.0;
		double freeSpaceG = freeSpaceM / 1024.0;
		if (freeSpaceG < m_RunCfg->m_CheckDiskSpaceG) {
			return false;
		}
		double needSpaceK = m_RunCfg->m_PerlayerSpaceK * layerCount;
		if (freeSpaceK < needSpaceK) {
			return false;
		}
		return true;
	}
	else return false;
}


JobController::LoadProgressInfoFlag JobController::m_LoadProgressInfoFlag = CkeckingJobData;
//vector<string> JobController::m_LoadErrorInfo = vector<string>();
CRITICAL_SECTION JobController::m_LoadInfoCS;

float JobController::m_LoadProgress = 0.0f;