#pragma once
#include "../stdafx.h"
#include "BaseCtrl.h"
#include "../Purifier/BasePurifier.h"
#include "Scanner.h"
#include "../Machine/Machine.h"
#include "../PLC/MachineCtrl.h"
#include "../camera/HBDCamera.h"
#include "../RecoatCheck/RecoatCheck.h"
#include "../Communication/ServoManager.h"
#include "ScannerPair.h"
#include "../Communication/ScannerPowerClient.h"
#include "../additional/InfraredTemp/InfraredTemp.h"

enum FUNCNAME {
	BEGINWORK = 0,
	PAUSEWORK,
	PAUSEAUTO,
	STOPWORK,
	STOPREDTEST,
	TESTLAYER,
	REMOVESCANNER,
	STARTHEATINGMOTION,
	STOPHEATINGMOTION,

	//以下是scanner函数
	STARTDEBUGTEST,  
	STOPDEBUGTEST,
	STARTHEATINGSCANNERTEST,
	STOPHEATINGSCANNERTEST,
	STARTGETSCANINFO,
	STOPGETSCANINFO,

	SETXYOFFSET,
	SETANGLE,
	UPDATESETTING,
	UPDATESKYWRITING,
	SETXYCORRECT,
	SETK,
	FIXPOINTDAOADD,
	FIXPOINTDAODEL,
};


class RemoteClient;
class ScannerCtrl : public BaseCtrl
{
	typedef ScannerCtrl thisClass;
	
public:
	ScannerCtrl();
	~ScannerCtrl();
	bool Init();

	bool BeginWork();
	bool PauseWork();
	void PauseAuto();
	bool StopWork();
	void StopWorkManual();

	bool IsTestLayerEnable();
	void StopRedTest();
	void TestLayer();
	vector<Scanner*>* GetScanners() { return &m_scan; }  //已传  被分解了
	JobController* GetJobController() { return m_job_controller; }
	void RemoveScanner(int seq);

	void SetPurifierClient(BasePurifier* purifierClient) {
		m_PurifierClient = purifierClient;
	}
	void SetScannerPowerClient(ScannerPowerClient* spc) { m_ScannerPowerClient = spc; }
	//void GetInitErrorInfos(vector<string>& vec);
	string GetInitErrorInfos();
	bool HasInitError() { return !m_InitErrorInfos.empty(); }   //不需要传客户端，先请求一次GetInitErrorInfos
	void ModelScan(void);
	void StopModelScan(void);

	void SetMachineCtrl(MachineCtrl* machineCtrl) {
		m_MachineCtrl = machineCtrl;
	}

	bool IsHeatingScannerEnable();    //在客户端判断，不传客户端

	void SetCamera(HBDCamera* camera) { m_Camera = camera; }
	//void SetRecoatCheck(RecoatCheck* rc) { m_RecoatCheck = rc; }
	void SetServoManager(ServoManager* servoManager) { m_ServoManager = servoManager; }

	void StartHeatingMotion();

	void StopHeatingMotion(bool iswait);

	void SetRemoteClient(RemoteClient* rc) { m_RemoteClient = rc; }

	void CallFunc(const ReadData& rd,  const list<Item>& lst);

	void SendToClients();

	void SetInfraredTemp(InfraredTemp* inft) {
		m_InfraredTemp = inft;
		for (size_t i = 0; i < m_scan.size(); i++) {
			m_scan[i]->SetInfTemp(inft);
		}
	}
private:
	static DWORD WINAPI PrintProc(thisClass* _this);
	static DWORD WINAPI RedPrintTestProc(thisClass* _this);
	static DWORD WINAPI ModelScanProc(thisClass* _this);
	static DWORD WINAPI ReleasePressureProc(thisClass* _this);
	static DWORD WINAPI StopWorkProc(ScannerCtrl* _this);

	static DWORD WINAPI HeatingMotionProc(ScannerCtrl* _this);
	void HeatingMotionRun();

	void PrintRun();
	bool ReadyPrint(bool startAfterPause);

	void CtrlWhenStop();
	void CtrlIoWhenExit();

	void DispatchDataBlock();

	void DispatchTestDataBlock();
	void DispatchModelDataBlock(int partId, string scanType, float power, float speed);

	void FixPointDaoAdd(const list<Item>& lst, int index);
	void FixPointDaoDel(const list<Item>& lst, int index);

public:
	string m_PauseMsg;
	string m_StopMsg;

	vector<AlarmCfg*> m_StopAlarms;
	vector<AlarmCfg*> m_PauseAlarms;
private:
	vector<Scanner*> m_scan;

	HANDLE m_print_thread;
	HANDLE m_RedPrintTestThread;
	HANDLE m_StopThread;
	bool m_StopFlag;

	CRITICAL_SECTION m_LayerTestCs;
	BasePurifier* m_PurifierClient;
	RunCfg* m_RunCfg;
	MachineCfg* m_MachineCfg;
	InfraredTempCfg* m_InfraredTempCfg;
	Machine* m_Machine;
	IOCfgWrapper* m_IOCfgWrapper;
	CoverCfg* m_CoverCfg;
	PowderEstimateCfg* m_PowderEstimateCfg;
	ExtCfg* m_ExtCfg;
	ServoManager* m_ServoManager;
	MachineCtrl* m_MachineCtrl;
	AlarmCfgWrapper* m_AlarmCfgWrapper;
	HANDLE m_PressureThread;
	bool m_PressureCtrlFlag;

	unsigned int m_DownSkinStopFlag;
	bool m_IsDownSkinContinue;

	HBDCamera* m_Camera;
	RecoatCheck* m_RecoatCheck;
	RecoatCheckCfg* m_RecoatCheckCfg;

	ScannerPowerClient* m_ScannerPowerClient;


	HANDLE m_HeatingMotionThread;
	bool m_HeatingMotionFlag;

	RemoteClient* m_RemoteClient;

	bool m_ShowFinishReport;
	time_t m_LastSendFinishReportTime;

	vector<BPBinary::BinDataBlock*> m_RedTestDBS;
	vector<BPBinary::BinDataBlock*> m_ModeTestDBS;
	
	InfraredTemp* m_InfraredTemp;
	std::shared_mutex m_mtx;

};