#pragma once
#include "Log.h"
#include "ServoCommo.h"
#include "CCLinkIEControl.h"
#include "CSample.h"
#include "CPin.h"
#include "CEqModeStep.h"
#include "CEqStatusStep.h"
#include "CEqAlarmStep.h"
#include "CEqProcessStep.h"
#include "CEqCimModeChangeStep.h"
#include "CEqModeChangeStep.h"
#include "CEqCimMessageCmdStep.h"
#include "CEqCimMessageClearStep.h"
#include "CEqDateTimeSetCmdStep.h"
#include "CEqVCREnableStep.h"
#include "CEqPortChangeStep.h"
#include "CEqReadIntStep.h"
#include "CEqCassetteTransferStateStep.h"
#include "CEqCassetteCtrlCmdStep.h"
#include "CEqJobEventStep.h"
#include "CEqVcrEventStep.h"
#include "CEqCurrentRecipeChangeStep.h"
#include "CEqWriteStep.h"
#include "CEqReadStep.h"
#include <vector>
#include <map>
#include <list>
#include "CGlass.h"
#include "CRecipesManager.h"
#include "CJobDataA.h"
#include "CJobDataB.h"
#include "CJobDataC.h"
#include "CJobDataS.h"
#include "CProcessData.h"
#include "CPortStatusReport.h"
#include "CSlot.h"
#include "CParam.h"
#include "CSVData.h"


namespace SERVO {
#define SLOT_MAX				PATH_MAX
#define SIGNAL_UPSTREAM_INLINE	0
#define SIGNAL_UPSTREAM_TROUBLE	1
#define SIGNAL_INTERLOCK		2
#define SIGNAL_SEND_ABLE		3
#define SIGNAL_RECEIVE_ABLE		3

	typedef std::function<void(int writeCode, int retCode)> ONWRITEDRET;

	typedef std::function<void(void* pEiuipment, BOOL bAlive)> ONALIVE;
	typedef std::function<void(void* pEiuipment, int code)> ONDATACHANGED;
	typedef std::function<void(void* pEiuipment, int state, int alarmId, int unitId, int level)> ONALARM;
	typedef std::function<void(void* pEiuipment, void* pReport)> ONVCREVENTREPORT;
	typedef std::function<BOOL(void* pEiuipment, int port, CJobDataB* pJobDataB)> ONPREFETCHEDOUTJOB;
	typedef std::function<BOOL(void* pEiuipment, int port, CJobDataB* pJobDataB, short& putSlot)> ONPRESTOREDJOB;
	typedef std::function<void(void* pEiuipment, int nSlotNo, PROCESS_STATE prevState, PROCESS_STATE state)> ONPROCESSSTATE;
	typedef std::function<void(void* pEiuipment, short scanMap, short downMap)> ONMAPMISMATCH;
	typedef std::function<void(void* pEiuipment, short status, __int64 data)> ONPORTSTATUSCHANGED;
	typedef std::function<void(void* pEiuipment, const std::vector<CParam>& params)> ONPROCESSDATAREPORT;
	typedef std::function<void(void* pEiuipment, int port, CJobDataS* pJobDataS)> ONRECEIVEDJOB;
	typedef std::function<void(void* pEiuipment, int port, CJobDataS* pJobDataS)> ONSENTOUTJOB;
	typedef std::function<void(void* pEiuipment, int unitId, int status, int reason)> ONEQSTATUSCHANGED;
	
	typedef struct _EquipmentListener
	{
		ONALIVE				onAlive;
		ONALIVE				onCimStateChanged;
		ONALARM				onAlarm;
		ONDATACHANGED		onDataChanged;
		ONVCREVENTREPORT	onVcrEventReport;
		ONPREFETCHEDOUTJOB	onPreFethedOutJob;
		ONPRESTOREDJOB		onPreStoredJob;
		ONPROCESSSTATE		onProcessStateChanged;
		ONMAPMISMATCH		onMapMismatch;
		ONPORTSTATUSCHANGED	onPortStatusChanged;
		ONVCREVENTREPORT	onSVDataReport;
		ONVCREVENTREPORT	onPanelDataReport;
		ONPROCESSDATAREPORT	onProcessDataReport;
		ONRECEIVEDJOB		onReceivedJob;
		ONSENTOUTJOB		onSentOutJob;
		ONEQSTATUSCHANGED	onEqStatusChanged;
	} EquipmentListener;


	class CEquipment
	{
	public:
		CEquipment();
		virtual ~CEquipment();

	public:
		void SetEnable(BOOL bEnable);
		BOOL IsEnabled() const;
		virtual const char* getClassName() = 0;
		virtual void setListener(EquipmentListener listener);
		void setCcLink(CCCLinkIEControl* pCcLink);
		virtual BOOL isArm() { return FALSE; };
		void setArm(CEquipment* pEquipment);
		CEquipment* getArm();
		void setBaseAlarmId(int nBaseId);
		int getBaseAlarmId();
		void setID(int nID);
		int getID();
		void setName(const char* pszName);
		std::string& getName();
		void setDescription(const char* pszDescription);
		std::string& getDescription();
		void setCurrentRecipe(const std::string& recipe);
		std::string getCurrentRecipe();
		void setStation(int network, int station);
		const StationIdentifier& getStation();
		virtual void getAttributeVector(CAttributeVector& attrubutes);
		void setReadBitBlock(unsigned int start, unsigned int end);
		MemoryBlock& getReadBitBlock();
		void setWriteBitBlock(unsigned int start, unsigned int end);
		MemoryBlock& getWriteBitBlock();
		void getProperties(std::vector<std::pair<std::string, std::string>>& container);
		int addStep(unsigned int addr, CStep* pStep);
		CStep* getStep(unsigned int addr);
		CStep* getStepWithName(const char* pszName);
		std::map<unsigned int, CStep*>& getSteps();
		virtual void init();
		virtual void term();
		virtual void initPins() = 0;
		virtual void initSteps();
		virtual void initSlots() = 0;
		virtual void onTimer(UINT nTimerid);
		virtual void serialize(CArchive& ar);
		virtual void onReceiveLBData(const char* pszData, size_t size);
		virtual int onStepEvent(CStep* pStep, int code);
		virtual CPin* addPin(PinType type, char* pszName);
		virtual short getSlotUnit(short slotNo) { return 0; };
		CPin* getPin(char* pszName);
		std::vector<CPin*>& CEquipment::getInputPins();
		std::vector<CPin*>& CEquipment::getOutputPins();
		CRecipeList* getRecipeList(int unitNo);
		bool saveRecipeList(int unitNo, std::string& strFilepath);
		bool readRecipeList(int unitNo, std::string& strFilepath);
		virtual int recvIntent(CPin* pPin, CIntent* pIntent);
		virtual int fetchedOutJob(int port, CJobDataB* pJobDataB);
		virtual int storedJob(int port, CJobDataB* pJobDataB, short putSlot);
		virtual int onReceivedJob(int port, CJobDataS* pJobDataS);
		virtual int onSentOutJob(int port, CJobDataS* pJobDataS);
		virtual BOOL onPreFetchedOutJob(int port, CJobDataB* pJobDataB);
		virtual int onFetchedOutJob(int port, CJobDataB* pJobDataB);
		virtual BOOL onPreStoredJob(int port, CJobDataB* pJobDataB, short& putSlot);
		virtual int onStoredJob(int port, CJobDataB* pJobDataB);
		virtual int onProcessData(CProcessData* pProcessData);
		virtual int onSendAble(int port);
		virtual int onReceiveAble(int port);
		virtual int onProcessStateChanged(int nSlotNo, PROCESS_STATE prevState, PROCESS_STATE state);
		virtual int getIndexerOperationModeBaseValue();
		virtual bool isSlotProcessed(int slot) { return true; };
		bool isAlarmStep(SERVO::CStep* pStep);
		bool isVcrEventStep(SERVO::CStep* pStep);
		bool isCassetteTransferStateStep(SERVO::CStep* pStep);
		bool isPortTypeStep(SERVO::CStep* pStep);
		bool isPortModeStep(SERVO::CStep* pStep);
		bool isPortCassetteTypeStep(SERVO::CStep* pStep);
		bool isPortTransferModeStep(SERVO::CStep* pStep);
		bool isPortEnableStep(SERVO::CStep* pStep);
		bool isPortTypeAutoChangeEnableStep(SERVO::CStep* pStep);
		bool isCimMessageConfirmStep(SERVO::CStep* pStep);
		int setEqMode(short mode);
		int setCimMode(BOOL bOn);
		int setCimMessage(const char* pszMessage, short id, short nTouchPanelNo);
		int clearCimMessage(short id, short nTouchPanelNo);
		int setDateTime(short year, short month, short day, short hour, short minute, short second);
		int setDispatchingMode(DISPATCHING_MODE mode, ONWRITED onWritedBlock = nullptr);
		int indexerOperationModeChange(IDNEXER_OPERATION_MODE mode, ONWRITEDRET onWritedRetBlock);
		void printDebugString001();
		std::vector<SERVO::CSVData>& getSVDatas();

		// 请求主配方列表
		// unitNo: 0:local; Others:unit No
		int masterRecipeListRequest(short unitNo, ONSYNCINGSTATECHANGED block);

		// 请求配方参数
		// masterRecipeId: 主配方id
		// localRecipeId: 本地配方id
		// unitNo: 0:local; Others:unit No
		int recipeParameterRequest(short masterRecipeId, short localRecipeId, short unitNo, ONSYNCINGSTATECHANGED block);

		// 解析配方参数列表
		virtual int parsingParams(const char* pszData, size_t size, std::vector<CParam>& params) { return 0;  };
		virtual int parsingParams(const char* pszData, size_t size, std::string& strOut);
		virtual int parsingProcessData(const char* pszData, size_t size, std::vector<CParam>& params) { return 0; };
		virtual int parsingSVData(const char* pszData, size_t size, std::vector<CParam>& params) { return 0; };

		// 获取指定的Slot
		CSlot* getSlot(int index);
		CSlot* getSlotWithNo(int slotNo);

		// 获取一个可用的槽位
		CSlot* getAvailableSlot();

		// 获取一个指定物料类型(G1,G2,G1&G2)的空槽位
		CSlot* getAvailableSlotForGlass(MaterialsType type);
		CSlot* getAvailableSlotForGlassExcludeSignal(MaterialsType type);
		CSlot* isSlotAvailable(unsigned int slot);

		// 在指定的槽列表中，获取一个指定物料类型(G1,G2,G1&G2)的空槽位
		CSlot* getAvailableSlotForGlass2(MaterialsType type, const std::vector<int>& candidates);

		// 获取一个指定物料类型(G1,G2,G1&G2)的非空槽位
		CSlot* getNonEmptySlot(MaterialsType type);

		// 获取一个指定物料类型(G1,G2,G1&G2)的且已经加工处理的槽位
		CSlot* getProcessedSlot(MaterialsType putSlotType, BOOL bJobMode = FALSE);
		CSlot* getProcessedSlot2(MaterialsType putSlotType, const std::vector<int>& candidates);
		CSlot* getInspFailSlot();
		CSlot* getProcessedSlotCt(unsigned int slot);

		// 获取玻璃物料
		CGlass* getGlassFromSlot(int slotNo);
		CGlass* getGlassWithCassette(int cassetteSequenceNo, int jobSequenceNo);
		CGlass* getAnyGlass();
		CGlass* getGlass(const char* pszGlassId);
		int getAllGlass(std::vector<CGlass*>& glasses);
		CJobDataS* getJobDataSWithCassette(int cassetteSequenceNo, int jobSequenceNo);

		// 验证玻璃和槽是否匹配
		BOOL ValidateGlassSlotMatch();

		// 是否有玻璃
		BOOL hasGlass();
		BOOL slotHasGlass(int slotIndex = 0);

		// 指定槽位是否可以放置玻璃
		BOOL canPlaceGlassInSlot(const short slotIndex);

		// 手动移除物料
		int removeGlass(int slotNo);

		// 字符串检测结果转换
		InspResult judgeStringToInspResult(std::string& strJudge);

		PROCESS_STATE getProcessState(int slotNo) const;

		// for test
		void fireSetProcessState(int nSlotNo, PROCESS_STATE state) { return setProcessState(nSlotNo, state); }


	// 以下为从CC-Link读取到的Bit标志位检测函数
	public:
		BOOL isAlive();
		BOOL isCimOn();
		BOOL isUpstreamInline();
		BOOL isDownstreamInline();
		BOOL isLocalAlarm();
		BOOL isAutoRecipeChange();
		BOOL isVCREnable(unsigned int index);
		BOOL isLinkSignalUpstreamOn(unsigned int path, unsigned int signal);
		BOOL isLinkSignalDownstreamOn(unsigned int path, unsigned int signal);

		// 只在模拟测试时使用的函数，用于模拟信号
		void setLinkSignalUpstream(unsigned int path, unsigned int signal, BOOL bOn);
		void setLinkSignalUpstreamBlock(unsigned int path, BOOL* pSignal);
		void setLinkSignalDownstream(unsigned int path, unsigned int signal, BOOL bOn);
		void setLinkSignalDownstreamBlock(unsigned int path, BOOL* pSignal);

	protected:
		inline void Lock() { EnterCriticalSection(&m_criticalSection); }
		inline void Unlock() { LeaveCriticalSection(&m_criticalSection); }
		BOOL isBitOn(const char* pszData, size_t size, int index);
		inline BOOL equalBool(BOOL b1, BOOL b2);
		short decodeRecipeListReport(const char* pszData, size_t size);
		short decodeRecipeParameterReport(const char* pszData, size_t size);
		int decodeProcessDataReport(CStep* pStep, const char* pszData, size_t size);
		int decodeReceivedJobReport(CStep* pStep, int port, const char* pszData, size_t size);
		int decodeSentOutJobReport(CStep* pStep, int port, const char* pszData, size_t size);
		int decodeFetchedOutJobReport(CStep* pStep, int port, const char* pszData, size_t size);
		int decodeStoredJobReport(CStep* pStep, int port, const char* pszData, size_t size);
		int decodeVCREventReport(CStep* pStep, const char* pszData, size_t size);
		int decodePanelDataReport(CStep* pStep, const char* pszData, size_t size);
		int decodeFacDataReport(CStep* pStep, const char* pszData, size_t size);
		int decodeJobDataRequest(CStep* pStep, const char* pszData, size_t size);
		int decodeJobProcessStartReport(CStep* pStep, const char* pszData, size_t size);
		int decodeJobProcessEndReport(CStep* pStep, const char* pszData, size_t size);
		BOOL compareJobData(CJobDataB* pJobDataB, CJobDataS* pJobDataS);
		void setProcessState(int nSlotNo, PROCESS_STATE state);
		float toFloat(const char* pszAddr);

	protected:
		// 部分优化/简化代码、暂实现部分，到时平铺开
		void addFacDataReportStep(int dataDev, int writeSignalDev, int port);


	protected:
		BOOL m_bEnable;
		EquipmentListener m_listener;
		int m_nID;
		std::string m_strName;
		std::string m_strDescription;
		std::string m_currentRecipe;
		CRITICAL_SECTION m_criticalSection;
		StationIdentifier m_station;
		MemoryBlock m_blockReadBit;
		MemoryBlock m_blockWriteBit;
		std::vector<CPin*> m_inputPins;
		std::vector<CPin*> m_outputPins;


		// 以下为从CC-Link读取到的Bit标志位
	protected:
		ALIVE m_alive;
		BOOL m_bCimState;			// ON/OFF
		BOOL m_bUpstreamInline;
		BOOL m_bDownstreamInline;
		BOOL m_bLocalAlarm;
		BOOL m_bAutoRecipeChange;
		BOOL m_bVCREnable[VCR_MAX];
		BOOL m_bLinkSignalToUpstream[PATH_MAX][SIGNAL_MAX];
		BOOL m_bLinkSignalToDownstream[PATH_MAX][SIGNAL_MAX];

	protected:
		CCCLinkIEControl* m_pCclink;
		std::map<unsigned int, CStep*> m_mapStep;
		int m_nBaseAlarmId;
		CRecipesManager m_recipesManager;
		CSlot m_slot[SLOT_MAX];
		PROCESS_STATE m_processState[SLOT_MAX] = { PROCESS_STATE::Ready };
		std::vector<SERVO::CSVData> m_svDatas;

	private:
		CEquipment* m_pArm;

	public:
		int m_nTestFlag;
	};
}