#pragma once
#include <string>
#include <list>
#include "IRemoteEquipment.h"
#include "Action.h"
#include "Data.h"
#include "Unit.h"


#define ACTION_GETNAME			    1
#define ACTION_GETVERSION		    2
#define ACTION_GETDEVICESTATE	    3
#define ACTION_GETDOORSTATE		    4
#define ACTION_GETALARMINFO		    5
#define ACTION_GETSTEP				6
#define ACTION_GETDATA				7
#define ACTION_GETRECIPELIST		8
#define ACTION_RUNRECIPE			9
#define ACTION_LOADREADY			10
#define ACTION_LOADCOMPLETE			11
#define ACTION_UNLOADCOMPLETE		12


namespace BEQ {
	typedef std::function<void(void* pRemoteEiuipment)> ONREQCONNECTEDEX;
	typedef std::function<void(void* pRemoteEiuipment, int errorCode)> ONREQCONNECTFAILEDEX;
	typedef std::function<void(void* pRemoteEiuipment, const char* pszData, int len)> ONREQREADEX;
	typedef std::function<void(void* pRemoteEquipment, void* pUnit, REMOTE_EQ_EVENT eventCode)> ONREQEVENTUPDATE_EX;

	typedef struct _RemoteEquipmentListener
	{
		ONREQCONNECTEDEX		onConnecting;
		ONREQCONNECTEDEX		onConnected;
		ONREQCONNECTFAILEDEX	onConnectFailed;
		ONREQCONNECTEDEX		onDisconnecting;
		ONREQCONNECTEDEX		onDisconnected;
		ONREQREADEX				onRead;
		ONREQEVENTUPDATE_EX		onEventUpdate;
	} RemoteEquipmentListener;

	enum class REMOTE_EQ_NET_STATE
	{
		DISCONNECTED = 0,
		CONNECTING,
		CONNECTED,
		DISCONNECTING
	};

	class CRemoteEquipment :
		public IRemoteEquipment
	{
	public:
		CRemoteEquipment();
		CRemoteEquipment(const char* pszAddr, int port);
		~CRemoteEquipment();

	public:
		virtual void setRemoteEquipmentListener(RemoteEquipmentListener listener);
		virtual int getAddr(char* pszBuffer, int nMaxCount);
		virtual int getPort();
		virtual int getName(char* pszBuffer, int nMaxCount);
		virtual int getVersion(char* pszBuffer, int nMaxCount);
		virtual bool isConnected();
		virtual int connect();
		virtual int close();
		virtual int reqGetAction(int type, const char* pszCommand, const char* pszUnitName = nullptr, const char* pszParams = nullptr);
		virtual int reqGetName();
		virtual int reqGetVersion();
		virtual int reqGetState(const char* pszUnitName);
		virtual int reqGetDoorState(const char* pszUnitName);
		virtual int reqGetAlarmInfo(const char* pszUnitName);
		virtual int reqGetStep(const char* pszUnitName);
		virtual int reqGetData(const char* pszUnitName);
		virtual int reqRecipeList(const char* pszUnitName);
		virtual int reqRunRecipe(const char* pszUnitName, int nRecipeId, const char* pszRecipeName);
		virtual IUnit* addUnit(const char* pszName, int nDoorCount);
		virtual IUnit* getUnit(const char* pszName);
		virtual const char** getAllUnitNames();
		virtual int getUnitCount() const;
		virtual ULONGLONG getConnectTick();

	public:
		inline void lock() { ::EnterCriticalSection(&m_cs); };
		inline void unlock() { ::LeaveCriticalSection(&m_cs); };

	private:
		void splitCString(const CString& strText, TCHAR delimiter = ',', std::function<void(const CString&, int)> callback = nullptr);
		void notifyEventUpdate(REMOTE_EQ_EVENT eventCode, CUnit* pUnit);
		void processDoorState(const CString& strPart, int index, int& doorState);
		void updateDoorState(const CString& strText, int& doorState, CUnit* pUnit);
		void parseAlarm(const CString& strText, CUnit* pUnit);
		void handleIdle(CUnit* pUnit);
		void handleMaterialReceived(const std::string& strMaterialId, CUnit* pUnit);
		void handleMaterialRemoved(const std::string& strMaterialId, CUnit* pUnit);
		void handleProcessingStarted(const std::string& strMaterialId, CUnit* pUnit);
		void handleProcessing(const std::string& strMaterialId, CUnit* pUnit, int svTime, int pvTime);
		void handleProcessingCompleted(const std::string& strMaterialId, CUnit* pUnit);
		void handleMachineProcess(const std::string& strMaterialId, const std::string& strStep, CUnit* pUnit, int svTime = 0, int pvTime = 0);

	private:
		void handleState(const std::map<std::string, std::string>& params, CUnit* pUnit);
		void handleDoorState(const std::map<std::string, std::string>& params, CUnit* pUnit);
		void handleAlarmInfo(const std::map<std::string, std::string>& params, CUnit* pUnit);
		void handleStep(const std::map<std::string, std::string>& params, CUnit* pUnit);
		void handleData(const std::map<std::string, std::string>& params, CUnit* pUnit);
		void handleRecipeList(const std::map<std::string, std::string>& params, CUnit* pUnit);

	private:
		BOOL initClient();
		static UINT WorkerThreadFunction(LPVOID lpvData);
		static UINT ActionsThreadFunction(LPVOID lpvData);
		static UINT TimeoutCheckThreadFunction(LPVOID lpvData);
		UINT WorkerThreadFunctionInner();
		UINT ActionsThreadFunctionInner();
		UINT TimeoutCheckThreadFunctionInner();
		void CurrentActionTimeout();
		int decode(char* pszBuffer, int nBufferSize);

	private:
		CRITICAL_SECTION m_cs;		// ͬ²½Ëø
		RemoteEquipmentListener m_listener;
		std::string m_strAddr;
		int m_nPort;
		int m_nLocalPort;
		std::string m_strName;
		std::string m_strVersion;

	private:
		SOCKET m_hSocket;
		REMOTE_EQ_NET_STATE m_remoteEqNetState;
		BOOL m_bWorking;
		WSAEVENT m_hWSAEvent;
		HANDLE m_hEventClose;		// µÈ´ýworkerÏß³ÌÍ˳öºó, Closeº¯Êý·µ»Ø
		HANDLE m_hEventWrite;
		HANDLE m_hEventActions;
		HANDLE m_hEventActionsThreadExit;
		HANDLE m_hEventTimeoutCheckThreadExit;
		CAction * m_pCurrentAction;
		std::list<CAction*> m_actions;
		BEQ::CData m_data;

	private:
		std::map<std::string, BEQ::CUnit*> m_units;
		ULONGLONG m_ullConnectTick;
	};
}