#pragma once
#include "Log.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"


namespace SERVO {
#define BLOCK_BUFFER_MAX			1024
#define ALIVE_TIMEOUT				15
#define VCR_MAX						1

	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 struct _EquipmentListener
	{
		ONALIVE				onAlive;
		ONALIVE				onCimStateChanged;
		ONALARM				onAlarm;
		ONDATACHANGED		onDataChanged;
		ONVCREVENTREPORT	onVcrEventReport;
	} EquipmentListener;

	// Memory Block ½á¹¹Ì嶨Òå
	typedef struct _MemoryBlock {
		unsigned int type;
		unsigned int start;
		unsigned int end;
		unsigned int size;
		char buffer[BLOCK_BUFFER_MAX];
	} MemoryBlock;

	// ALIVE
	typedef struct _ALIVE {
		BOOL flag;
		int count;
		BOOL alive;
	} ALIVE;

	enum DISPATCHING_MODE {
		EAS = 1,
		Local = 2
	};

	enum IDNEXER_OPERATION_MODE {
		Normal = 1,
		Clear_Out = 2,
		Cold_Run = 2,
		Start = 10,
		Stop = 11,
		Pause = 12,
		Resume = 13,
		Abort = 14,
		Cancel = 15,
	};

	enum RCMD {
		Robot_home = 1,
		Transfer, 
		Move,
		Get,
		Put,
		One_Action_Exchange,
		Two_Action_Exchange,
		Command_Clear,
		Batch_get,
		Batch_put
	};

	// Robot cmd param
#define ROBOT_CMD_PARAM_SIZE		16			/* ·ÀÖ¹ÒÔºóÐÞ¸ÄROBOT_CMD_PARAMΪ²»ÊÇ4µÄÕûÊý±¶ */
	typedef struct _ROBOT_CMD_PARAM {
		short sequenceNo;
		short rcmd;
		short armNo;
		short getPosition;
		short putPosition;
		short getSlotNo;
		short putSlotNo;
		short subCmd;
	} ROBOT_CMD_PARAM;

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


	public:
		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 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 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);
		CPin* getPin(char* pszName);
		std::vector<CPin*>& CEquipment::getInputPins();
		std::vector<CPin*>& CEquipment::getOutputPins();
		virtual int recvIntent(CPin* pPin, CIntent* pIntent);
		virtual BOOL glassWillArrive(CGlass* pGlass);
		virtual int outputGlass(int port);
		virtual int glassArrived(CGlass* pGlass);
		virtual int fetchedOutJob(CJobDataB* pJobDataB);
		virtual int storedJob(CJobDataB* pJobDataB);
		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);
		virtual int onStoredJob(int port, CJobDataB* pJobDataB);
		virtual int onProcessData(CProcessData* pProcessData);
		virtual int getIndexerOperationModeBaseValue();
		void getGlassList(std::list<CGlass*>& list);
		CGlass* getGlassFromList(const char* pszId);
		CGlass* getFrontGlass();
		BOOL removeClass(CGlass* pGlass);
		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, ONWRITED onWritedBlock = nullptr);



		// ÇëÇóÖ÷Åä·½Áбí
		// unitNo: 0:local; Others:unit No
		int masterRecipeListRequest(short unitNo);

		// ÇëÇóÅä·½²ÎÊý
		// masterRecipeId: Ö÷Åä·½id
		// localRecipeId: ±¾µØÅä·½id
		// unitNo: 0:local; Others:unit No
		int recipeParameterRequest(short masterRecipeId, short localRecipeId, short unitNo);

	public:
		BOOL isGlassListEmpty();


	// ÒÔÏÂΪ´ÓCC-Link¶ÁÈ¡µ½µÄBit±ê־λ¼ì²âº¯Êý
	public:
		BOOL isAlive();
		BOOL isCimOn();
		BOOL isUpstreamInline();
		BOOL isDownstreamInline();
		BOOL isLocalAlarm();
		BOOL isAutoRecipeChange();
		BOOL isVCREnable(unsigned int index);

	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);
		void addGlassToList(CGlass* pGlass);
		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 addJobDataB(CJobDataB* pJobDataB);
		int removeJobDataB(int nCassetteSequenceNo, int nJobSequenceNo);
		CJobDataB* getJobDataB(int nCassetteSequenceNo, int nJobSequenceNo);
		int addJobDataS(CJobDataS* pJobDataS);
		int removeJobDataS(int nCassetteSequenceNo, int nJobSequenceNo);
		CJobDataS* getJobDataS(int nCassetteSequenceNo, int nJobSequenceNo);

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


		// ÒÔÏÂΪ´Ó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];

	protected:
		CCCLinkIEControl* m_pCclink;
		std::map<unsigned int, CStep*> m_mapStep;
		int m_nBaseAlarmId;
		CRecipesManager m_recipesManager;

	private:
		CEquipment* m_pArm;
		std::list<CJobDataS> m_listJobDataS;
		std::list<CJobDataB> m_listJobDataB;
	};
}