#pragma once
#include <list>
#include "CEquipment.h"
#include "CEFEM.h"
#include "CBonder.h"
#include "CLoadPort.h"
#include "CFliper.h"
#include "CAligner.h"
#include "CVacuumBake.h"
#include "CBakeCooling.h"
#include "CMeasurement.h"
#include "CArm.h"
#include "CArmTray.h"
#include "CCLinkIEControl.h"
#include "CRobotTask.h"
#include "ProcessJob.h"
#include "CControlJob.h"


#define CTStep_Unknow                   0
#define CTStep_LoadPort_Aligner         1
#define CTStep_Aligner_Fliper           2
#define CTStep_Fliper_Bonder1           3
#define CTStep_Bonder1_Bonder2          4
#define CTStep_Bonder2_VacuumBake       5
#define CTStep_VacuumBake_VacuumBake    6
#define CTStep_VacuumBake_BakeCooling   7
#define CTStep_BakeCooling_BakeCooling1 8
#define CTStep_BakeCooling_BakeCooling2 9
#define CTStep_BakeCooling_BakeCooling3 10
#define CTStep_BakeCooling_Measurement  11
#define CTStep_Measurement_LoadPort     12
#define CTStep_begin                    CTStep_LoadPort_Aligner
#define CTStep_end                      CTStep_Measurement_LoadPort

namespace SERVO {
    enum class MASTERSTATE {
        READY = 0,
        STARTING,
        RUNNING,
        RUNNING_CONTINUOUS_TRANSFER,
        STOPPING,
        MSERROR
    };

    typedef std::function<void(void* pMaster, MASTERSTATE state)> ONMASTERSTATECHANGED;
    typedef std::function<void(void* pMaster, CEquipment* pEiuipment, BOOL bAlive)> ONEQALIVE;
    typedef std::function<void(CStep* pStep, int code, void* pData)> ONEQSTEPEVENT;
    typedef std::function<void(void* pMaster, CEquipment* pEquipment, int state, int alarmId, int unitId, int level)> ONEQALARM;
    typedef std::function<void(void* pMaster, CEquipment* pEquipment, CVcrEventReport* pReport)> ONEQVCREVENTREPORT;
    typedef std::function<void(void* pMaster, CEquipment* pEquipment, int code)> ONEQDATACHANGED;
    typedef std::function<void(void* pMaster, CRobotTask* pTask, int code)> ONROBOTTASKEVENT;
    typedef std::function<void(void* pMaster, CEquipment* pEquipment, short status, __int64 data)> ONLOADPORTSTATUSCHANGED;
    typedef std::function<void(void* pMaster, int round)> ONCTROUNDEND;
    typedef struct _MasterListener
    {
        ONMASTERSTATECHANGED    onMasterStateChanged;
        ONEQALIVE				onEqAlive;
        ONEQALIVE		        onEqCimStateChanged;
        ONEQALARM               onEqAlarm;
        ONEQVCREVENTREPORT	    onEqVcrEventReport;
        ONEQDATACHANGED         onEqDataChanged;
        ONROBOTTASKEVENT        onRobotTaskEvent;
        ONLOADPORTSTATUSCHANGED	onLoadPortStatusChanged;
        ONCTROUNDEND            onCTRoundEnd;
    } MasterListener;

    class CMaster : public IResourceView
    {
    public:
        CMaster();
        virtual ~CMaster();


    public:
        void setListener(MasterListener listener);
        CRobotTask* getActiveRobotTask();
        int init();
        int term();
        int start();
        int startContinuousTransfer();
        int stop();
        void clearError();
        ULONGLONG getRunTime();
        MASTERSTATE getState();
        unsigned DispatchProc();
        unsigned ReadBitsProc();
        void onTimer(UINT nTimerid);
        std::list<CEquipment*>& getEquipmentList();
        CEquipment* getEquipment(int id);
        CEquipment* getEquipment(int id) const;
        void setCacheFilepath(const char* pszFilepath);
        int abortCurrentTask();
        int restoreCurrentTask();
        int resendCurrentTask();
        void setPortType(unsigned int index, BOOL enable, int type, int mode,
            int cassetteType, int transferMode, BOOL autoChangeEnable);
        void setPortCassetteType(unsigned int index, SERVO::CassetteType type);
        void setPortEnable(unsigned int index, BOOL bEnable);
        void setCompareMapsBeforeProceeding(BOOL bCompare);
        void setJobMode(BOOL bJobMode);
        void datetimeSync(SYSTEMTIME& time);
        void enableEventReport(bool bEnable);
        void enableAlarmReport(bool bEnable);
        bool isAlarmReportEnable();
        int proceedWithCarrier(unsigned int port);
        int carrierRelease(unsigned int port);
        int getContinuousTransferCount();
        void setContinuousTransferCount(int round);
        int setProcessJobs(std::vector<CProcessJob*>& pjs);
        std::vector<CProcessJob*>& getProcessJobs();
        CProcessJob* getProcessJob(const std::string& id);
        int setControlJob(CControlJob& controlJob);
        CControlJob* getControlJob();
        CLoadPort* getPortWithCarrierId(const std::string& carrierId) const;
        bool saveState() const;
        bool loadState(const std::string& path);

    private:
        inline void lock() { EnterCriticalSection(&m_criticalSection); }
        inline void unlock() { LeaveCriticalSection(&m_criticalSection); }
        int addToEquipmentList(CEquipment* pEquipment);
        CLoadPort* addLoadPort(int index);
        CFliper* addFliper();
        CVacuumBake* addVacuumBake();
        CAligner* addAligner();
        CEFEM* addEFEM();
        CArm* addArm();
        CArmTray* addArmTray(int index);
        CBonder* addBonder(int index);
        CBakeCooling* addBakeCooling();
        CMeasurement* addMeasurement();
        void connectEquipments();
        int saveCache();
        int saveCacheAndBackups();
        int readCache();
        void serialize(CArchive& ar);
        void setState(MASTERSTATE state);
        CRobotTask* createTransferTask(CEquipment* pSrcEq, CEquipment* pTarEq,
            MaterialsType primaryType = MaterialsType::G1, MaterialsType secondaryType = MaterialsType::G2,
            int armNo = 1, BOOL bJobMode = FALSE);
        CRobotTask* createTransferTask_bonder_to_bakecooling(CEquipment* pSrcEq, CEquipment* pTarEq);
        CRobotTask* createTransferTask_bake_to_cooling(CEquipment* pSrcEq);
        CRobotTask* createTransferTask_bakecooling_to_measurement(CEquipment* pSrcEq, CEquipment* pTarEq);
        CRobotTask* createTransferTask_restore(CEquipment* pEqSrc, CLoadPort** pPorts);
        CRobotTask* createTransferTask_continuous_transfer(CEquipment* pSrcEq, int nSrcSlot,
            CEquipment* pTarEq, int nTarSlot, int armNo = 1);

    public:
        // ¡ª¡ª IResourceView ¸²Ð´ ¡ª¡ª£¨×¢Òâ const£©
        bool isProcessJobsEmpty() const override;
        bool recipeExists(const std::string& ppid) const override;
        bool carrierPresent(const std::string& carrierId) const override;
        bool slotUsable(const std::string& carrierId, uint16_t slot) const override;
        bool ceidDefined(uint32_t ceid) const override;

    private:
        CRITICAL_SECTION m_criticalSection;
        MasterListener m_listener;
        CCCLinkIEControl m_cclink;
        std::list<CEquipment*> m_listEquipment;
        std::string m_strFilepath;
        BOOL m_bDataModify;
        bool m_bContinuousTransfer;

    private:
        /* ¼à¿Ø±ÈÌØλµÄÏß³Ì*/
        HANDLE m_hEventReadBitsThreadExit[2];
        HANDLE m_hReadBitsThreadHandle;
        unsigned m_nReadBitsThreadAddr;

        // µ÷¶ÈÏß³Ì
        HANDLE m_hDispatchEvent;
        HANDLE m_hEventDispatchThreadExit[2];
        HANDLE m_hDispatchThreadHandle;
        unsigned m_nDispatchThreadAddr;

        // Æô¶¯Ê±¼ä£¬ÔËÐÐʱ¼ä£¬×´Ì¬
        ULONGLONG m_ullStartTime;
        ULONGLONG m_ullRunTime;
        MASTERSTATE m_state;

        // µ±Ç°ÈÎÎñºÍÒÑÍê³ÉÈÎÎñÁбí
        CRobotTask* m_pActiveRobotTask;
        std::list< CRobotTask* > m_listTask;

        // ´íÎó´úÂë
        int m_nLastError;
        std::string m_strLastError;

        // ÔÚ¿ªÊ¼¹¤ÒÕÇ°ÊÇ·ñÏÈÐèÒªÏȱȽÏmap
        BOOL m_isCompareMapsBeforeProceeding;
        BOOL m_bJobMode;


        // ǧ´«È¦Êý¼ÆÊý
        int m_nContinuousTransferCount;
        int m_nContinuousTransferStep;

    private:
        bool m_bEnableEventReport;
        bool m_bEnableAlarmReport;
        SERVO::CControlJob* m_pControlJob;
        std::vector<SERVO::CProcessJob*> m_processJobs;
        std::string m_strStatePath;
    };
}