#include "RemoteClient.h"
#include <atlbase.h>
#include "../global.h"
#include "../ScannerCtrl/BaseCtrl.h"
#include <bitset>
#include "proto_msg.h"
#include "../camera/GalaxyCamera.h"
#include "../SystemInfo.h"
#include "../Logger.h"
#include "../utils/TimeHelper.h"
#include "../utils/StringHelper.h"
//#include <rapidjson/document.h>
#include "../utils/MathHelper.h"

RemoteClient::RemoteClient(JobController* jobController, ScannerCtrl* sc)
:m_RemoteThread(INVALID_HANDLE_VALUE)
,m_WriteThread(INVALID_HANDLE_VALUE)
, m_ReadThread(INVALID_HANDLE_VALUE)
, m_RunFlag(false)
, m_WriteFlag(false)
,m_ReadFlag(false)
,m_IsLogin(false)
,m_Config(nullptr)
,m_JobController(jobController)
,m_ScannerCtrl(sc)
, m_Camera(NULL)
{
	InitializeCriticalSection(&m_MessageCS);
}


RemoteClient::~RemoteClient()
{
	StopRemote();
	DeleteCriticalSection(&m_MessageCS);
}

void RemoteClient::Init()
{
	map<string, CommunicationCfg*>* cfgs = ConfigManager::GetInstance()->GetCommunicationCfg();
	if (cfgs->find("REMOTE") != cfgs->end()) {
		m_Config=(*cfgs)["REMOTE"];
	}
	m_MachineCfg = ConfigManager::GetInstance()->GetMachineCfg();
	m_RunCfg = ConfigManager::GetInstance()->GetRunCfg();
	m_ExtCfg = ConfigManager::GetInstance()->GetExtCfg();
	m_HandleMap[PrinterMsg::STATE_REQUEST] = &RemoteClient::HandleStateRequest;
	m_HandleMap[PrinterMsg::JOB_INFO_REQUEST] = &RemoteClient::HandleJobInfoRequest;
	m_HandleMap[PrinterMsg::CTRL_SYSTEM_PAUSE] = &RemoteClient::HandleCtrlSystemPause;
	m_HandleMap[PrinterMsg::CRTL_SYSTEM_STOP] = &RemoteClient::HandleCtrlSystemStop;
	m_HandleMap[PrinterMsg::LAYER_DATA_REQUEST] = &RemoteClient::HandleLayerDataRequest;
	m_HandleMap[PrinterMsg::CAMERA_DATA_REQUEST] = &RemoteClient::HandleCameraDataRequest;
	
	m_HandleMap[PrinterMsg::ALARM_NOTIFY_RESPONSE] = &RemoteClient::HandleAlarmNotifyResponse;
	m_HandleMap[PrinterMsg::STATE_CHANGE_RESPONSE] = &RemoteClient::HandleStateChangeResponse;
	m_HandleMap[PrinterMsg::LOG_REQUEST_RECORD_TASK] = &RemoteClient::HandleRecordTasksMsg;
	m_HandleMap[PrinterMsg::LOG_REQUEST_RECORD_TASK_LIST] = &RemoteClient::HandleRecordTasksListMsg;
	m_HandleMap[PrinterMsg::VERSION_REQUEST] = &RemoteClient::HandleVersionResMsg;
	//m_HandleMap[PrinterMsg::REMOTE_JOB_LIST_RESPONSE] = &RemoteClient::HandleRemoteJobResMsg;
	ConfigManager::GetInstance()->AddComRefCfg(m_Config, this);
}

void RemoteClient::StartRemote()
{
	StopRemote();
	m_RunFlag = true;
	m_RemoteThread = AtlCreateThread(RemoteProc, this);
}

void RemoteClient::StopRemote()
{
	m_RunFlag = false;
	StopWrite();
	StopRead();
	if (m_Client.IsOpen()) {
		m_Client.Close();
	}
	if (m_RemoteThread !=INVALID_HANDLE_VALUE) {
		if (WaitForSingleObject(m_RemoteThread, 500) == WAIT_TIMEOUT) {
			TerminateThread(m_RemoteThread, 1);
		}
		CloseHandle(m_RemoteThread);
		m_RemoteThread = INVALID_HANDLE_VALUE;
	}
	m_IsLogin = false;
}

DWORD WINAPI RemoteClient::RemoteProc(RemoteClient* _this)
{
	if (_this) {
		_this->RemoteRun();
	}
	return 0;
}

void RemoteClient::RemoteRun()
{
	while (m_RunFlag) {
		if (!m_Client.IsOpen()) {
			if (!m_Client.ConnectTo(m_Config->m_IP.c_str(), m_Config->m_Port, AF_INET, SOCK_STREAM,2000)) {
				int count = 0;
				while (m_RunFlag && count<30) {
					count++;
					Sleep(100);
				}
				continue;
			}
		}
		if (!CheckLogin())continue;
		StartWrite();
		StartRead();
		WaitForSingleObject(m_ReadThread, INFINITE);
		m_WriteFlag = false;
		WaitForSingleObject(m_WriteThread, INFINITE);
		m_Client.Close();
		m_IsLogin = false;
	}
}

void RemoteClient::StartWrite()
{
	StopWrite();
	m_WriteFlag = true;
	m_WriteThread = AtlCreateThread(WriteProc, this);
}

void RemoteClient::StopWrite()
{
	m_WriteFlag = false;
	if (m_WriteThread != INVALID_HANDLE_VALUE) {
		if (WaitForSingleObject(m_WriteThread, 500) == WAIT_TIMEOUT) {
			TerminateThread(m_WriteThread, 1);
		}
		CloseHandle(m_WriteThread);
		m_WriteThread = INVALID_HANDLE_VALUE;
	}
	EnterCriticalSection(&m_MessageCS);
	while (!m_MessageQueue.empty()) {
		PrinterMsg::HMessage* message=m_MessageQueue.front();
		delete message;
		message = nullptr;
		m_MessageQueue.pop();
	}
	LeaveCriticalSection(&m_MessageCS);
}

DWORD WINAPI RemoteClient::WriteProc(RemoteClient* _this)
{
	if (_this) {
		_this->WriteRun();
	}
	return 0;
}

void RemoteClient::WriteRun()
{
	while (m_RunFlag && m_WriteFlag ) {
		PrinterMsg::HMessage* message = nullptr;
		EnterCriticalSection(&m_MessageCS);
		if (!m_MessageQueue.empty())
		{
			message = m_MessageQueue.front();
			m_MessageQueue.pop();
		}
		LeaveCriticalSection(&m_MessageCS);
		if (message != nullptr)
		{
			size_t msgSize;
			unsigned char* buf = ProtoMsgCodec::encode(message, msgSize);
			if (buf != nullptr && msgSize > 0) {
				int scount=m_Client.Write(buf, msgSize, 0, 500);
				delete[] buf;
				delete message;
				message = nullptr;
				if (scount ==-1) {
					m_WriteFlag = false;
					m_Client.Close();
					m_IsLogin = false;
					break;
				}
			}
		}
		Sleep(50);
	}
}

void RemoteClient::StartRead()
{
	StopRead();
	m_ReadFlag = true;
	m_ReadThread = AtlCreateThread(ReadProc, this);
}

void RemoteClient::StopRead()
{
	m_ReadFlag = false;
	if (m_ReadThread != INVALID_HANDLE_VALUE) {
		if (WaitForSingleObject(m_ReadThread, 500) == WAIT_TIMEOUT) {
			TerminateThread(m_ReadThread, 1);
		}
		CloseHandle(m_ReadThread);
		m_ReadThread = INVALID_HANDLE_VALUE;
	}
}

DWORD WINAPI RemoteClient::ReadProc(RemoteClient* _this)
{
	if (_this) {
		_this->ReadRun();
	}
	return 0;
}

void RemoteClient::ReadRun()
{
	unsigned char recvBuffer[2048];
	int retry = 0;
	while (m_RunFlag&& m_ReadFlag) {
		int rcount=m_Client.Read(recvBuffer, sizeof(recvBuffer), 0, 3000);
		if (rcount == -1) {
			m_ReadFlag = false;
			m_Client.Close();
			m_IsLogin = false;
			break;
		}
		else if (rcount == 0) {
			if (++retry > 30) {
				m_ReadFlag = false;
				m_Client.Close();
				m_IsLogin = false;
				break;
			}
			continue;
		}
		retry = 0;
		ProtoMessage* tmp_msg = ProtoMsgCodec::decode(recvBuffer, rcount);
		if (tmp_msg == nullptr) {
			continue;
		}

		PrinterMsg::HMessage* msg = dynamic_cast<PrinterMsg::HMessage*>(tmp_msg);
		PrinterMsg::MSG mtype=msg->type();
		if (m_HandleMap.find(mtype) != m_HandleMap.end()) {
			m_HandleMap[mtype](this,msg);
		}
		delete msg;
	}
}

bool RemoteClient::CheckLogin()
{
	if (m_IsLogin)return true;
	if (!m_Client.IsOpen())return false;
	PrinterMsg::HMessage message;
	MachineMsg* machineMsg=message.mutable_request()->mutable_machinemsg();
	machineMsg->set_machineid(m_MachineCfg->m_serial->GetValueStr());
	machineMsg->set_machinetype(MachineMsg_MachineType(m_MachineCfg->m_MachineType->GetValue()));
	machineMsg->set_purifiertype(MachineMsg_PurifierType(m_MachineCfg->m_PulifierType->GetValue()));
	machineMsg->set_laststarttime(m_MachineCfg->m_lastStartTime->GetValue());
	machineMsg->set_lastshutdowntime(m_MachineCfg->m_lastShutdownTime->GetValue());
	//machineMsg->set_language(m_MachineCfg->m_language);
	machineMsg->set_language(0);
	machineMsg->set_password(m_MachineCfg->m_ConnectPassword->GetValueStr());
	machineMsg->set_name(m_MachineCfg->m_Name->GetValueStr());
	machineMsg->set_location(m_MachineCfg->m_Location->GetValueStr());
	message.set_type(PrinterMsg::LOGIN_REQUEST);
	message.set_mcode(m_MachineCfg->m_MachineCode->GetValueStr());
//	unsigned char sendBuffer[2048];
	unsigned char rendBuffer[1024];

	size_t msgSize;
	unsigned char* buf = ProtoMsgCodec::encode(&message, msgSize);
	if (buf != nullptr && msgSize > 0)
	{
		int scount=m_Client.Write(buf, msgSize, 0, 3000);
		if (scount == msgSize) {
			int rcount=m_Client.Read(rendBuffer, sizeof(rendBuffer), 0, 5000);
			if (rcount > 0) {
				ProtoMessage* tmp_msg = ProtoMsgCodec::decode(rendBuffer, rcount);
				if (tmp_msg) {
					PrinterMsg::HMessage* loginResp = dynamic_cast<PrinterMsg::HMessage*>(tmp_msg);
					if (loginResp->type() == PrinterMsg::LOGIN_RESPONSE) {
						if (loginResp->mutable_response()->result()) {
							m_IsLogin = true;
						}
					}
				}
				else {
					Sleep(3000);
				}
			}
			else if(rcount==-1){
				m_Client.Close();
			}
		}
		else if (scount==-1) {
			m_Client.Close();
		}
	}
	//delete machineMsg;
	return m_IsLogin;
}

bool RemoteClient::AddSendMessage(PrinterMsg::HMessage* msg)
{
	if (!msg)return false;
	if (!m_WriteFlag) {
		delete msg;
		msg = NULL;
		return false;
	}
	EnterCriticalSection(&m_MessageCS);
	if (m_MessageQueue.size() > 100) {
		LeaveCriticalSection(&m_MessageCS);
		delete msg;
		msg = NULL;
		return false;
	}
	m_MessageQueue.push(msg);
	LeaveCriticalSection(&m_MessageCS);
	return true;
}

void RemoteClient::PushError(PrinterMsg::MSG msg,string id)
{
	PrinterMsg::HMessage* respMsg = new PrinterMsg::HMessage();
	respMsg->set_type(msg);
	respMsg->set_id(id);
	respMsg->set_mcode(m_MachineCfg->m_MachineCode->GetValueStr());
	PrinterMsg::Response* resp = respMsg->mutable_response();
	resp->set_result(false);
	ErrorMsg* emsg = resp->mutable_errormsg();
	emsg->set_machineid(m_MachineCfg->m_serial->GetValueStr());
	AddSendMessage(respMsg);
}


void RemoteClient::HandleStateRequest(RemoteClient* client,PrinterMsg::HMessage* msg)
{
	PrinterMsg::HMessage* respMsg = new PrinterMsg::HMessage();
	respMsg->set_type(PrinterMsg::STATE_RESPONSE);
	respMsg->set_id(msg->id());
	respMsg->set_mcode(client->m_MachineCfg->m_MachineCode->GetValueStr());
	EnvInfo info;
	g_SystemInfo->GetEnvInfo(info);
	StateMsg* stateMsg= respMsg->mutable_response()->mutable_statemsg();
	stateMsg->set_oxygenvalue(info.m_OxygenRealTimeValue1);
	stateMsg->set_ambienttemp(info.m_AmbientTemp);
	stateMsg->set_innertemp(info.m_InnerTemp);
	stateMsg->set_windvalue(info.m_WindValue);
	stateMsg->set_platformtempvalue(info.m_PlatformTemp);
	stateMsg->set_platformtempsettingvalue(info.m_PlatformTempSettingValue);
	stateMsg->set_moldpos(info.m_MoldPos/1000.0f);
	stateMsg->set_powderpos(info.m_PowderPos);
	stateMsg->set_armpos(info.m_ArmPos/1000.0f);
	stateMsg->set_printstate(StateMsg::PrintState(BaseCtrl::GetState()));
	stateMsg->set_layerindex(g_SystemInfo->m_StateBean.layerIndex);
	

	std::bitset<32> limit;
	stateMsg->set_limitflag(limit.to_ulong());
	stateMsg->set_machineid(client->m_MachineCfg->m_serial->GetValueStr());
	stateMsg->set_isdoorclose(info.m_EnvState.m_IsPrintCabinDoorClose);
	stateMsg->set_acctime(g_SystemInfo->m_StateBean.realCostSeconds*1000);
	stateMsg->set_remaintime(g_SystemInfo->m_StateBean.remainMil);
	stateMsg->set_totaltime(g_SystemInfo->m_StateBean.jobCostMil);
	stateMsg->set_layercount(g_SystemInfo->m_StateBean.maxLayerIndex);
	stateMsg->set_remainpowder(info.m_PowderQty);
	EnterCriticalSection(&client->m_JobController->m_cs);
	if (client->m_JobController->GetJob()) {
		stateMsg->set_material(client->m_JobController->GetJob()->GetMaterialName());
		stateMsg->set_jobname(client->m_JobController->GetJob()->GetJobTitle());
		stateMsg->set_jobid(client->m_JobController->GetJob()->GetJobUid());
		stateMsg->set_taskid(client->m_JobController->GetJob()->m_TaskId);
	}
	LeaveCriticalSection(&client->m_JobController->m_cs);
	respMsg->mutable_response()->set_result(true);
	time_t tnow;
	time(&tnow);
	respMsg->set_sendtime(tnow);
	client->AddSendMessage(respMsg);
}

void RemoteClient::HandleJobInfoRequest(RemoteClient* client, PrinterMsg::HMessage* msg)
{
	PrinterMsg::HMessage* respMsg = new PrinterMsg::HMessage();
	respMsg->set_type(PrinterMsg::JOB_INFO_RESPONSE);
	respMsg->set_id(msg->id());
	respMsg->set_mcode(client->m_MachineCfg->m_MachineCode->GetValueStr());
	EnterCriticalSection(&client->m_JobController->m_cs);
	if (client->m_JobController->GetJob()==nullptr) {
		PrinterMsg::Response* resp = respMsg->mutable_response();
		resp->set_result(false);
		ErrorMsg* emsg = resp->mutable_errormsg();
		emsg->set_machineid(client->m_MachineCfg->m_serial->GetValueStr());
		client->AddSendMessage(respMsg);
		LeaveCriticalSection(&client->m_JobController->m_cs);
		return;
	}
	FileProcessor* job = client->m_JobController->GetJob();
	MetaData* metaData = job->GetMetaData();
	JobMsg* jobmsg = respMsg->mutable_response()->mutable_jobmsg();
	JobInfoMsg* info= jobmsg->mutable_jobinfomsg();
	info->set_jobid(job->GetJobUid());
	info->set_taskid(job->m_TaskId);
	info->set_name(StringHelper::AsciiToUtf8(job->GetJobTitle()));
	info->set_material(StringHelper::AsciiToUtf8(job->GetMaterialName()));
	info->set_layercount(job->GetLayerCount());
	info->set_layerthickness(job->GetLayerThickness());
	MetaData::JobDimensions *jd = metaData->GetJobDimensions();
	info->set_xsize(jd->xmax - jd->xmin);
	info->set_ysize(jd->ymax - jd->ymin);
	info->set_zsize(jd->zmax - jd->zmin);
	info->set_componentcount(job->GetComponentCount());
	
	metaData->LockPart();
	vector<MetaData::Part*> parts= metaData->GetPartVec();
	char buffer[123];
	//map<int, MetaData::ParameterSet*>* paramMap = metaData->GetParameterMap();
	for (size_t i = 0; i < parts.size();i++) {
		MetaData::Part* part = parts[i];
		PartMsg* pm= jobmsg->add_partmsg();
		//sprintf_s(buffer, sizeof(buffer), "%d",i);
		pm->set_name(StringHelper::AsciiToUtf8(part->name));
		//vector<int>* params= metaData->GetPartRefParameter(part->id);
		for (set<MetaData::ParameterSet*>::iterator it = part->paramSet.begin(); it != part->paramSet.end();it++) {
			MetaData::ParameterSet* ps = (*it);
			ParameterMsg* paramMsg = pm->add_param();
			paramMsg->set_type(ps->set_type);
			paramMsg->set_laserdiameter(ps->laser_set->laser_diameter);
			paramMsg->set_laserpower(ps->laser_set->laser_power);
			paramMsg->set_laserspeed(ps->laser_speed);
		}
	}
	metaData->UnLockPart();
	respMsg->mutable_response()->set_result(true);
	jobmsg->set_machineid(client->m_MachineCfg->m_serial->GetValueStr());
	LeaveCriticalSection(&client->m_JobController->m_cs);
	time_t tnow;
	time(&tnow);
	respMsg->set_sendtime(tnow);
	client->AddSendMessage(respMsg);
}

void RemoteClient::HandleCtrlSystemPause(RemoteClient* client, PrinterMsg::HMessage* msg)
{
	PrinterMsg::HMessage* respMsg = new PrinterMsg::HMessage();
	respMsg->set_type(PrinterMsg::CTRL_SYSTEM_PAUSE);
	respMsg->set_id(msg->id());
	respMsg->set_mcode(client->m_MachineCfg->m_MachineCode->GetValueStr());
	PrinterMsg::Response* resp = respMsg->mutable_response();
	if (!BaseCtrl::IsStandBy()) {
		bool rel=client->m_ScannerCtrl->PauseWork();
		BaseCtrl::SetPauseState(BaseCtrl::ManualPause);
		if (rel) {
			resp->set_result(true);
		}
		else {
			resp->set_result(false);
			ErrorMsg* emsg = resp->mutable_errormsg();
			emsg->set_machineid(client->m_MachineCfg->m_serial->GetValueStr());
			emsg->set_errormsg(client->m_ScannerCtrl->m_PauseMsg);
		}
	}
	else {
		resp->set_result(false);
		ErrorMsg* emsg = resp->mutable_errormsg();
		emsg->set_machineid(client->m_MachineCfg->m_serial->GetValueStr());
		emsg->set_errormsg(u8"就绪状态不能暂停");
	}
	client->AddSendMessage(respMsg);
}

void RemoteClient::HandleCtrlSystemStop(RemoteClient* client, PrinterMsg::HMessage* msg)
{
	PrinterMsg::HMessage* respMsg = new PrinterMsg::HMessage();
	respMsg->set_type(PrinterMsg::CRTL_SYSTEM_STOP);
	respMsg->set_id(msg->id());
	respMsg->set_mcode(client->m_MachineCfg->m_MachineCode->GetValueStr());
	PrinterMsg::Response* resp = respMsg->mutable_response();
	if (!BaseCtrl::IsStop() && (BaseCtrl::GetState() != BaseCtrl::STANDBY_STOP)) {
		bool rel = client->m_ScannerCtrl->StopWork();
		if (rel) {
			respMsg->mutable_response()->set_result(true);
		}
		else {
			resp->set_result(false);
			ErrorMsg* emsg = resp->mutable_errormsg();
			emsg->set_machineid(client->m_MachineCfg->m_serial->GetValueStr());
			emsg->set_errormsg(client->m_ScannerCtrl->m_StopMsg);
		}
	}
	else {
		resp->set_result(false);
		ErrorMsg* emsg = resp->mutable_errormsg();
		emsg->set_machineid(client->m_MachineCfg->m_serial->GetValueStr());
		emsg->set_errormsg(u8"状态不能暂停");
	}
	client->AddSendMessage(respMsg);
}

void RemoteClient::HandleLayerDataRequest(RemoteClient* client, PrinterMsg::HMessage* msg)
{
	EnterCriticalSection(&client->m_JobController->m_cs);
	if (client->m_JobController->GetJob() == nullptr) {
		client->PushError(PrinterMsg::LAYER_DATA_RESPONSE,msg->id());
		LeaveCriticalSection(&client->m_JobController->m_cs);
		return;
	}
	FileProcessor* job = client->m_JobController->GetJob();
	MetaData* job_meta_data = job->GetMetaData();
	unsigned int reqindex=msg->request().layerdatamsg().layerindex();
	if (!job_meta_data->LoadRemoteLayerByIndex(reqindex)) {
		client->PushError(PrinterMsg::LAYER_DATA_RESPONSE, msg->id());
		LeaveCriticalSection(&client->m_JobController->m_cs);
		return;
	}
	MetaData::Layer* layer = job_meta_data->GetRemoteLayer();
	if (!layer) {
		client->PushError(PrinterMsg::LAYER_DATA_RESPONSE, msg->id());
		LeaveCriticalSection(&client->m_JobController->m_cs);
		return;
	}

	unsigned int total = 0;
	for (size_t blockIndex = 0; blockIndex < layer->data_blocks.size(); ++blockIndex) {
		MetaData::DataBlock* datablock = layer->data_blocks[blockIndex];
		if (!datablock)continue;
		MetaData::ParameterSet* paramSet = job_meta_data->GetParameterSet(datablock->references->process);
		if (!paramSet)continue;
		//if (paramSet->set_type.find("Border") == std::string::npos && paramSet->set_type.find("BorderSupport") == std::string::npos && paramSet->set_type.find("WallSupport") == std::string::npos) {
		if ((paramSet->set_type.find("Border") == std::string::npos && paramSet->set_type.find("Support") == std::string::npos) || paramSet->set_type.find("Additional") != std::string::npos)  {
			continue;
		}
		MetaData::Part* part = job_meta_data->GetPart(datablock->references->part);
		if (part) {
			if (!part->print_enable) {
				continue;
			}
		}
		
		BPBinary::BinDataBlock* pdb = job_meta_data->GetRemoteDataBlock(datablock);
		if (!pdb) continue;
		total++;
	}
	unsigned int index = 0;

	for (size_t blockIndex = 0; blockIndex < layer->data_blocks.size(); ++blockIndex) {
		MetaData::DataBlock* datablock = layer->data_blocks[blockIndex];
		if (!datablock)continue;
		MetaData::ParameterSet* paramSet = job_meta_data->GetParameterSet(datablock->references->process);
		if (!paramSet)continue;
		//if (paramSet->set_type.find("Border") == std::string::npos && paramSet->set_type.find("BorderSupport") == std::string::npos && paramSet->set_type.find("WallSupport") == std::string::npos) {
		if ((paramSet->set_type.find("Border") == std::string::npos && paramSet->set_type.find("Support") == std::string::npos) || paramSet->set_type.find("Additional") != std::string::npos)  {
			continue;
		}
		MetaData::Part* part = job_meta_data->GetPart(datablock->references->part);
		if (part) {
			if (!part->print_enable) {
				continue;
			}
		}
		bool ischange = false;
		if (client->m_RunCfg->m_OffsetRotateEnable->GetValue()) {
			if (part->partPosBean.m_XOffset != 0.0 || part->partPosBean.m_YOffset != 0.0 || part->partPosBean.m_RotateAngle != 0.0) {
				ischange = true;
			}
		}
		BPBinary::BinDataBlock* pdb = job_meta_data->GetRemoteDataBlock(datablock);
		if (!pdb) continue;

		PrinterMsg::HMessage* respMsg = new PrinterMsg::HMessage();
		respMsg->set_type(PrinterMsg::LAYER_DATA_RESPONSE);
		respMsg->set_id(msg->id());
		respMsg->set_mcode(client->m_MachineCfg->m_MachineCode->GetValueStr());
		PrinterMsg::Response* rep= respMsg->mutable_response();
		rep->set_result(true);
		LayerDataRespMsg* ldrm= rep->mutable_layerdatamsg();
		ldrm->set_machineid(client->m_MachineCfg->m_serial->GetValueStr());
		ldrm->set_total(total);
		ldrm->set_index(index);
		ldrm->set_partid(part->id);
		ldrm->set_type(pdb->type);
		ldrm->set_paramtype(paramSet->set_type);

		std::vector<float> data;
		if (pdb->type == BIN_VECTOR) {
			//ldrm->add_data(pdb->point_indexs.size());
			data.push_back(pdb->point_indexs.size());
			for (size_t j = 0; j < pdb->point_indexs.size(); ++j) {
				BPBinary::VectorPoint* pvp = (BPBinary::VectorPoint*)pdb->point_indexs[j];
				float real_x1 = pvp->x1;
				float real_y1 = pvp->y1;
				float real_x2 = pvp->x2;
				float real_y2 = pvp->y2;
				if (ischange) {
					double mov_x1 = part->partPosBean.m_XOffset + pvp->x1;
					double mov_y1 = part->partPosBean.m_YOffset + pvp->y1;
					double mov_x2 = part->partPosBean.m_XOffset + pvp->x2;
					double mov_y2 = part->partPosBean.m_YOffset + pvp->y2;

					real_x1 = (mov_x1 - part->partPosBean.m_PartCenterX)*cos(part->partPosBean.m_Radians) - (mov_y1 - part->partPosBean.m_PartCenterY)*sin(part->partPosBean.m_Radians) + part->partPosBean.m_PartCenterX;
					real_y1 = (mov_x1 - part->partPosBean.m_PartCenterX)*sin(part->partPosBean.m_Radians) + (mov_y1 - part->partPosBean.m_PartCenterY)*cos(part->partPosBean.m_Radians) + part->partPosBean.m_PartCenterY;
					real_x2 = (mov_x2 - part->partPosBean.m_PartCenterX)*cos(part->partPosBean.m_Radians) - (mov_y2 - part->partPosBean.m_PartCenterY)*sin(part->partPosBean.m_Radians) + part->partPosBean.m_PartCenterX;
					real_y2 = (mov_x2 - part->partPosBean.m_PartCenterX)*sin(part->partPosBean.m_Radians) + (mov_y2 - part->partPosBean.m_PartCenterY)*cos(part->partPosBean.m_Radians) + part->partPosBean.m_PartCenterY;
				}
				//ldrm->add_data(real_x1);
				//ldrm->add_data(real_y1);
				//ldrm->add_data(real_x2);
				//ldrm->add_data(real_y2);
				data.push_back(real_x1);
				data.push_back(real_y1);
				data.push_back(real_x2);
				data.push_back(real_y2);
			}
		}
		else if (pdb->type == BIN_CHAIN) {
			//ldrm->add_data(pdb->point_indexs.size());
			data.push_back(pdb->point_indexs.size());
			for (unsigned int j = 0; j < pdb->point_indexs.size(); ++j) {
				BPBinary::ChainPoint* point = (BPBinary::ChainPoint*)pdb->point_indexs[j];
				//ldrm->add_data(point->points.size());
				data.push_back(point->points.size());
				for (unsigned int k = 0; k < point->points.size(); ++k) {
					float real_x = point->points[k]->x;
					float real_y = point->points[k]->y;
					if (ischange) {
						double mov_x1 = part->partPosBean.m_XOffset + point->points[k]->x;
						double mov_y1 = part->partPosBean.m_YOffset + point->points[k]->y;
						real_x = (mov_x1 - part->partPosBean.m_PartCenterX)*cos(part->partPosBean.m_Radians) - (mov_y1 - part->partPosBean.m_PartCenterY)*sin(part->partPosBean.m_Radians) + part->partPosBean.m_PartCenterX;
						real_y = (mov_x1 - part->partPosBean.m_PartCenterX)*sin(part->partPosBean.m_Radians) + (mov_y1 - part->partPosBean.m_PartCenterY)*cos(part->partPosBean.m_Radians) + part->partPosBean.m_PartCenterY;
					}
					//ldrm->add_data(real_x);
					//ldrm->add_data(real_y);
					data.push_back(real_x);
					data.push_back(real_y);
				}
			}
		}

		std::string *datas_str = new std::string((const char*)&data[0], data.size()*sizeof(float));
		ldrm->set_allocated_datas(datas_str);
		time_t tnow;
		time(&tnow);
		respMsg->set_sendtime(tnow);
		client->AddSendMessage(respMsg);
		index++;
	}
	
	LeaveCriticalSection(&client->m_JobController->m_cs);
}

void RemoteClient::HandleCameraStopRequest(RemoteClient* client, PrinterMsg::HMessage* msg)
{
	//GalaxyCamera* cam = GalaxyCamera::GetInstance();
	if (client->m_Camera && client->m_Camera->IsConnect() && client->m_Camera->GetDemandCatpure() && !client->m_ScannerCtrl->IsStart()) {
		client->m_Camera->SetDemandCatpure(false);
	}
}

void RemoteClient::HandleCameraDataRequest(RemoteClient* client, PrinterMsg::HMessage* msg)
{
	PrinterMsg::HMessage* respMsg = new PrinterMsg::HMessage();
	respMsg->set_type(PrinterMsg::CAMERA_DATA_RESPONSE);
	respMsg->set_id(msg->id());
	respMsg->set_mcode(client->m_MachineCfg->m_MachineCode->GetValueStr());
	HBDCamera* cam = client->m_Camera;
	PrinterMsg::Response* resp = respMsg->mutable_response();
	CameraDataMsg* cdm = resp->mutable_cameradata();
	if (!cam->IsConnect())
	{
		if (!cam->GetDemandCatpure())
			cam->SetDemandCatpure(true);
		resp->set_result(false);
		time_t tnow;
		time(&tnow);
		respMsg->set_sendtime(tnow);
		client->AddSendMessage(respMsg);
		return;
	}
	cv::Mat image;
	cam->GetRemoteShowImageMat(image);
	if (image.data)
	{
		bool needReduceImage = false;
		if (image.cols * image.rows > 1200000) {
			needReduceImage = true;
		}
		float ratio = ConfigManager::GetInstance()->GetExtCfg()->m_LogRatio;

		cv::Mat fixImage;
		if (!client->m_ExtCfg->m_UseShowImageWarpPerspective) {
			if (needReduceImage) {
				cv::resize(image, fixImage, cv::Size(0, 0), ratio, ratio);
			}
			else {
				image.copyTo(fixImage);
			}

			int cols = fixImage.cols - 1;
			int rows = fixImage.rows - 1;
			cv::Point2f center(cols / 2.0, rows / 2.0);
			double rad = MathHelper::DegreesToRadians(client->m_ExtCfg->m_ShowImageAngle);

			int topLeftx = (0 - center.x) * cos(rad) - (0 - center.y) * sin(rad) + center.x;
			int topLefty = (0 - center.y) * cos(rad) + (0 - center.x) * sin(rad) + center.y;
			if (topLeftx < 0)topLeftx = 0; if (topLeftx > cols)topLeftx = cols;
			if (topLefty < 0)topLefty = 0; if (topLefty > rows)topLefty = rows;

			int topRightx = (cols - center.x) * cos(rad) - (0 - center.y) * sin(rad) + center.x;
			int topRighty = (0 - center.y) * cos(rad) + (cols - center.x) * sin(rad) + center.y;
			if (topRightx < 0)topRightx = 0; if (topRightx > cols)topRightx = cols;
			if (topRighty < 0)topRighty = 0; if (topRighty > rows)topRighty = rows;

			int btnRightx = (cols - center.x) * cos(rad) - (rows - center.y) * sin(rad) + center.x;
			int btnRighty = (rows - center.y) * cos(rad) + (cols - center.x) * sin(rad) + center.y;
			if (btnRightx < 0)btnRightx = 0; if (btnRightx > cols)btnRightx = cols;
			if (btnRighty < 0)btnRighty = 0; if (btnRighty > rows)btnRighty = rows;

			int btnLeftx = (0 - center.x) * cos(rad) - (rows - center.y) * sin(rad) + center.x;
			int btnLefty = (rows - center.y) * cos(rad) + (0 - center.x) * sin(rad) + center.y;
			if (btnLeftx < 0)btnLeftx = 0; if (btnLeftx > cols)btnLeftx = cols;
			if (btnLefty < 0)btnLefty = 0; if (btnLefty > rows)btnLefty = rows;


			cv::Point2f srcTri[4];
			srcTri[0] = cv::Point2f(topLeftx, topLefty);
			srcTri[1] = cv::Point2f(topRightx, topRighty);
			srcTri[2] = cv::Point2f(btnRightx, btnRighty);
			srcTri[3] = cv::Point2f(btnLeftx, btnLefty);
			cv::Point2f tempTri[4];
			tempTri[0] = cv::Point2f(0.0f, 0.0f);
			tempTri[1] = cv::Point2f((float)client->m_ExtCfg->m_ShowImagePerspectiveWidth, 0.0f);
			tempTri[2] = cv::Point2f((float)client->m_ExtCfg->m_ShowImagePerspectiveWidth, (float)client->m_ExtCfg->m_ShowImagePerspectiveHeigh);
			tempTri[3] = cv::Point2f(0.0f, (float)client->m_ExtCfg->m_ShowImagePerspectiveHeigh);
			cv::Mat warp_mat = cv::getPerspectiveTransform(srcTri, tempTri);

			cv::Mat tempImage = cv::Mat(cv::Size(client->m_ExtCfg->m_ShowImagePerspectiveWidth, client->m_ExtCfg->m_ShowImagePerspectiveHeigh), CV_8U);
			warpPerspective(fixImage, tempImage, warp_mat, tempImage.size());
			fixImage.release();
			fixImage = tempImage;
		}
		else {
			cv::Point2f srcTri[4];
			if (needReduceImage) {
				cv::resize(image, fixImage, cv::Size(0, 0), ratio, ratio);
				srcTri[0] = cv::Point2f((float)client->m_ExtCfg->m_ShowImageTopLeftX*ratio, (float)client->m_ExtCfg->m_ShowImageTopLeftY*ratio);
				srcTri[1] = cv::Point2f((float)client->m_ExtCfg->m_ShowImageTopRightX*ratio, (float)client->m_ExtCfg->m_ShowImageTopRightY*ratio);
				srcTri[2] = cv::Point2f((float)client->m_ExtCfg->m_ShowImageBottomRightX*ratio, (float)client->m_ExtCfg->m_ShowImageBottomRightY*ratio);
				srcTri[3] = cv::Point2f((float)client->m_ExtCfg->m_ShowImageBottomLeftX*ratio, (float)client->m_ExtCfg->m_ShowImageBottomLeftY*ratio);
			}
			else {
				image.copyTo(fixImage);
				srcTri[0] = cv::Point2f((float)client->m_ExtCfg->m_ShowImageTopLeftX, (float)client->m_ExtCfg->m_ShowImageTopLeftY);
				srcTri[1] = cv::Point2f((float)client->m_ExtCfg->m_ShowImageTopRightX, (float)client->m_ExtCfg->m_ShowImageTopRightY);
				srcTri[2] = cv::Point2f((float)client->m_ExtCfg->m_ShowImageBottomRightX, (float)client->m_ExtCfg->m_ShowImageBottomRightY);
				srcTri[3] = cv::Point2f((float)client->m_ExtCfg->m_ShowImageBottomLeftX, (float)client->m_ExtCfg->m_ShowImageBottomLeftY);
			}

			cv::Point2f tempTri[4];
			tempTri[0] = cv::Point2f(0.0f, 0.0f);
			tempTri[1] = cv::Point2f((float)client->m_ExtCfg->m_ShowImagePerspectiveWidth, 0.0f);
			tempTri[2] = cv::Point2f((float)client->m_ExtCfg->m_ShowImagePerspectiveWidth, (float)client->m_ExtCfg->m_ShowImagePerspectiveHeigh);
			tempTri[3] = cv::Point2f(0.0f, (float)client->m_ExtCfg->m_ShowImagePerspectiveHeigh);
			cv::Mat warp_mat = cv::getPerspectiveTransform(srcTri, tempTri);
			cv::Mat tempImage = cv::Mat(cv::Size(client->m_ExtCfg->m_ShowImagePerspectiveWidth, client->m_ExtCfg->m_ShowImagePerspectiveHeigh), CV_8U);
			warpPerspective(fixImage, tempImage, warp_mat, tempImage.size());
			fixImage.release();
			fixImage = tempImage;
		}
		image.release();
		std::vector<unsigned char> dataEncode;
		vector<int> compression_params;
		compression_params.push_back(cv::IMWRITE_JPEG_QUALITY);
		compression_params.push_back(60);
		cv::imencode(".jpg", fixImage, dataEncode, compression_params);
		if (dataEncode.empty()) {
			resp->set_result(false);
		}
		else {
			resp->set_result(true);
			cdm->set_machineid(client->m_MachineCfg->m_serial->GetValueStr());
			cdm->set_imageformat("jpg");
			cdm->set_imagewidth(fixImage.cols);
			cdm->set_imageheight(fixImage.rows);
			cdm->set_imagedatasize(dataEncode.size());
			string* imageData = new string((char*)&dataEncode[0], dataEncode.size());
			cdm->set_allocated_imagedatas(imageData);
			dataEncode.clear();
		}
		fixImage.release();
	}
	else {
		resp->set_result(false);
	}
	time_t tnow;
	time(&tnow);
	respMsg->set_sendtime(tnow);
	client->AddSendMessage(respMsg);
}

void RemoteClient::HandleAlarmNotifyResponse(RemoteClient* client, PrinterMsg::HMessage* msg)
{
	client->SetNeedSendAlarm(false);
}


void RemoteClient::HandleStateChangeResponse(RemoteClient* client, PrinterMsg::HMessage* msg)
{
	client->SetNeedSendFinish(false);
}

void RemoteClient::SendStateChangeMsg()
{
	if (!m_IsLogin)
		return;
	PrinterMsg::HMessage* respMsg = new PrinterMsg::HMessage();
	respMsg->set_type(PrinterMsg::STATE_CHANGE);
	respMsg->set_id(m_MachineCfg->m_serial->GetValueStr());
	respMsg->set_mcode(m_MachineCfg->m_MachineCode->GetValueStr());
	EnvInfo info;
	g_SystemInfo->GetEnvInfo(info);
	StateChangeMsg* stateMsg = respMsg->mutable_response()->mutable_statechangemsg();
	stateMsg->set_oxygenvalue(info.m_OxygenRealTimeValue1);
	stateMsg->set_ambienttemp(info.m_AmbientTemp);
	stateMsg->set_innertemp(info.m_InnerTemp);
	stateMsg->set_windvalue(info.m_WindValue);
	stateMsg->set_platformtempvalue(info.m_PlatformTemp);
	stateMsg->set_platformtempsettingvalue(info.m_PlatformTempSettingValue);
	stateMsg->set_moldpos(info.m_MoldPos/1000.0f);
	stateMsg->set_powderpos(info.m_PowderPos);
	stateMsg->set_armpos(info.m_ArmPos/1000.0f);
	stateMsg->set_printstate(StateChangeMsg::PrintState(BaseCtrl::GetState()));
	stateMsg->set_layerindex(g_SystemInfo->m_StateBean.layerIndex);

	std::bitset<32> limit;
	stateMsg->set_limitflag(limit.to_ulong());
	stateMsg->set_machineid(m_MachineCfg->m_serial->GetValueStr());
	stateMsg->set_isdoorclose(info.m_EnvState.m_IsPrintCabinDoorClose);
	stateMsg->set_acctime(g_SystemInfo->m_StateBean.realCostSeconds * 1000);
	stateMsg->set_remaintime(g_SystemInfo->m_StateBean.remainMil);
	stateMsg->set_totaltime(g_SystemInfo->m_StateBean.jobCostMil);
	stateMsg->set_layercount(g_SystemInfo->m_StateBean.maxLayerIndex);
	stateMsg->set_remainpowder(info.m_PowderQty);
	EnterCriticalSection(&m_JobController->m_cs);
	if (m_JobController->GetJob()) {
		stateMsg->set_material(m_JobController->GetJob()->GetMaterialName());
		stateMsg->set_jobname(m_JobController->GetJob()->GetJobTitle());
		stateMsg->set_jobid(m_JobController->GetJob()->GetJobUid());
		stateMsg->set_taskid(m_JobController->GetJob()->m_TaskId);
	}
	LeaveCriticalSection(&m_JobController->m_cs);
	respMsg->mutable_response()->set_result(true);
	time_t tnow;
	time(&tnow);
	respMsg->set_sendtime(tnow);
	AddSendMessage(respMsg);
}

void RemoteClient::SendAlarmMsg(AlarmShowInfo* info)
{
	if (!info)return;
	if (!m_IsLogin)return;
	m_AlarmInfo.m_AlarmCode = info->m_AlarmCode;
	m_AlarmInfo.m_JobName = info->m_JobName;
	m_AlarmInfo.m_JobId = info->m_JobId;
	m_AlarmInfo.m_HappenTime = info->m_HappenTime;
	m_AlarmInfo.m_LayerIndex = info->m_LayerIndex;
	m_AlarmInfo.m_AlarmName = info->m_AlarmName;
	m_AlarmInfo.m_AlarmContent = info->m_AlarmContent;
	m_AlarmInfo.m_AlarmShowInfo = info->m_AlarmShowInfo;
	m_AlarmInfo.m_AlarmType = info->m_AlarmType;
	m_AlarmInfo.m_TFlag = info->m_TFlag;
	m_AlarmInfo.m_HadSendEmail = info->m_HadSendEmail;

	PrinterMsg::HMessage* respMsg = new PrinterMsg::HMessage();
	respMsg->set_type(PrinterMsg::ALARM_NOTIFY_REQUEST);
	respMsg->set_id(m_MachineCfg->m_serial->GetValueStr());
	respMsg->set_mcode(m_MachineCfg->m_MachineCode->GetValueStr());
	AlarmNotifyMsg* msg = respMsg->mutable_request()->mutable_alarmnotifymsg();

	msg->set_jobname(m_AlarmInfo.m_JobName);
	msg->set_jobid(m_AlarmInfo.m_JobId);
	msg->set_happentime(m_AlarmInfo.m_HappenTime);
	msg->set_layerindex(m_AlarmInfo.m_LayerIndex);
	msg->set_alarmtype(m_AlarmInfo.m_AlarmType);
	msg->set_alarmcode(m_AlarmInfo.m_AlarmCode);
	msg->set_alarmcontent(m_AlarmInfo.m_AlarmContent);
	
	time_t tnow;
	time(&tnow);
	respMsg->set_sendtime(tnow);
	AddSendMessage(respMsg);
}

void RemoteClient::HandleRecordTasksMsg(RemoteClient* client, PrinterMsg::HMessage* msg)
{
	if (!msg->request().has_reqrecordtaskmsg())return;

	PrinterMsg::HMessage* respMsg = new PrinterMsg::HMessage();
	respMsg->set_type(PrinterMsg::LOG_RESPONSE_RECORD_TASK);
	respMsg->set_id(msg->id());
	respMsg->set_mcode(client->m_MachineCfg->m_MachineCode->GetValueStr());
	PrinterMsg::Response* resp = respMsg->mutable_response();

	vector<JobBean*> logs;
	g_log->m_LogDao->GetJobsByTaskId(msg->request().reqrecordtaskmsg().taskid(),logs);
	RecordTasksMsg* rtm= resp->mutable_recordtasksmsg();
	for (size_t i = 0; i < logs.size();i++) {
		JobBean* job = logs[i];
		RecordTaskMsg* record = rtm->add_recordtasks();
		record->set_id(job->m_Id);
		record->set_taskid(job->m_TaskID);
		record->set_name(job->m_Name);
		record->set_begintime(TimeHelper::Time2Str(job->m_StartTime));
		record->set_endtime(TimeHelper::Time2Str(job->m_StopTime));
		record->set_deoxygensecond(job->m_DeoxygenSecond);
		record->set_totalusesecond(job->m_SpendSecond);
		record->set_logmoldposition(job->m_MoldPos);
		record->set_finishlayer(job->m_PrintedLayerIndex);
		record->set_isfinish(job->m_IsFinished);
		record->set_iscontinueprint(job->m_IsContinue);
	}
	respMsg->mutable_response()->set_result(true);
	time_t tnow;
	time(&tnow);
	respMsg->set_sendtime(tnow);
	client->AddSendMessage(respMsg);

	for (size_t i = 0; i < logs.size(); i++) {
		delete logs[i];
	}
	logs.clear();
}

void RemoteClient::HandleRecordTasksListMsg(RemoteClient* client, PrinterMsg::HMessage* msg)
{
	if (!msg->request().has_reqrecordtaskmsg())return;
	PrinterMsg::HMessage* respMsg = new PrinterMsg::HMessage();
	respMsg->set_type(PrinterMsg::LOG_RESPONSE_RECORD_TASK_LIST);
	respMsg->set_id(msg->id());
	respMsg->set_mcode(client->m_MachineCfg->m_MachineCode->GetValueStr());
	PrinterMsg::Response* resp = respMsg->mutable_response();
	tm begin;
	time_t begin_t = msg->request().reqrecordtasklistmsg().beginsecond();
	localtime_s(&begin, &begin_t);
	tm end;
	time_t end_t = msg->request().reqrecordtasklistmsg().endsecond();
	localtime_s(&end, &end_t);

	if (end_t <= begin_t || (end_t-begin_t)>60*60*24*90) {
		respMsg->mutable_response()->set_result(true);
		ErrorMsg* emsg = resp->mutable_errormsg();
		emsg->set_machineid(client->m_MachineCfg->m_serial->GetValueStr());
		emsg->set_errormsg("error time params");
		time_t tnow;
		time(&tnow);
		respMsg->set_sendtime(tnow);
		client->AddSendMessage(respMsg);
		return;
	}

	
	vector<JobBean*> logs;
	g_log->m_LogDao->GetJobsByTime(begin, end, logs);

	RecordTasksListMsg* rtm = resp->mutable_recordtasklistmsg();
	for (size_t i = 0; i < logs.size(); i++) {
		JobBean* job = logs[i];
		RecordTaskMsg* record = rtm->add_recordtaskslist();
		record->set_id(job->m_Id);
		record->set_taskid(job->m_TaskID);
		record->set_name(job->m_Name);
		record->set_begintime(TimeHelper::Time2Str(job->m_StartTime));
		record->set_endtime(TimeHelper::Time2Str(job->m_StopTime));
		record->set_deoxygensecond(job->m_DeoxygenSecond);
		record->set_totalusesecond(job->m_SpendSecond);
		record->set_logmoldposition(job->m_MoldPos);
		record->set_finishlayer(job->m_PrintedLayerIndex);
		record->set_isfinish(job->m_IsFinished);
		record->set_iscontinueprint(job->m_IsContinue);
	}
	respMsg->mutable_response()->set_result(true);
	time_t tnow;
	time(&tnow);
	respMsg->set_sendtime(tnow);
	client->AddSendMessage(respMsg);

	for (size_t i = 0; i < logs.size(); i++) {
		delete logs[i];
	}
	logs.clear();
}


void RemoteClient::HandleVersionResMsg(RemoteClient* client, PrinterMsg::HMessage* msg)
{
	PrinterMsg::HMessage* respMsg = new PrinterMsg::HMessage();
	respMsg->set_type(PrinterMsg::VERSION_RESPONSE);
	respMsg->set_id(msg->id());
	respMsg->set_mcode(client->m_MachineCfg->m_MachineCode->GetValueStr());
	PrinterMsg::Response* resp = respMsg->mutable_response();
	VersionInfoResMsg* versionInfo = resp->mutable_versioninforesmsg();
	versionInfo->set_version(g_SystemInfo->m_ProductVersion);
	resp->set_result(true);
	time_t tnow;
	time(&tnow);
	respMsg->set_sendtime(tnow);
	client->AddSendMessage(respMsg);
}