~chenluhua/Bond2.git

#include "stdafx.h"
#include "Unit.h"
#include <chrono>
#include <sstream>
#include <iomanip>
#include <unordered_map>
 
 
namespace BEQ {
    CUnit::CUnit()
    {
        m_eqState = EQ_STATE::IDLE;
        m_nDoorCount = 1;
        m_doorState = 0;
        m_nAlarmCode = 0;
        m_nAlarmLevel = 0;
        m_stepState = STEP_STATE::IDLE;
        m_stepSvTime = 0;
        m_stepPvTime = 0;
        m_dataTime = 0;
        m_listener.onStateChanged = nullptr;
        m_listener.onDoorStateChanged = nullptr;
        m_listener.onAlarm = nullptr;
        m_listener.onRemoveAlarm = nullptr;
        m_listener.onStepChanged = nullptr;
        m_listener.onDataChanged = nullptr;
        m_nLayerCount = 1;
        resetLoadState();
    }
 
    CUnit::CUnit(const char* pszName)
    {
        m_strName = pszName;
        m_eqState = EQ_STATE::IDLE;
        m_doorState = 0;
        m_nAlarmCode = 0;
        m_nAlarmLevel = 0;
        m_stepState = STEP_STATE::IDLE;
        m_stepSvTime = 0;
        m_stepPvTime = 0;
        m_dataTime = 0;
        m_listener.onStateChanged = nullptr;
        m_listener.onDoorStateChanged = nullptr;
        m_listener.onAlarm = nullptr;
        m_listener.onRemoveAlarm = nullptr;
        m_listener.onStepChanged = nullptr;
        m_listener.onDataChanged = nullptr;
        m_listener.onReqLoad = nullptr;
        m_listener.onReqUnload = nullptr;
        m_nLayerCount = 1;
    }
 
    CUnit::~CUnit()
    {
    }
 
    void CUnit::setListener(UnitListener listener)
    {
        m_listener.onStateChanged = listener.onStateChanged;
        m_listener.onDoorStateChanged = listener.onDoorStateChanged;
        m_listener.onAlarm = listener.onAlarm;
        m_listener.onRemoveAlarm = listener.onRemoveAlarm;
        m_listener.onStepChanged = listener.onStepChanged;
        m_listener.onDataChanged = listener.onDataChanged;
        m_listener.onReqNotReady = listener.onReqNotReady;
        m_listener.onReqLoad = listener.onReqLoad;
        m_listener.onReqUnload = listener.onReqUnload;
    }
 
    int CUnit::getName(char* pszBuffer, int nMaxCount)
    {
        return strcpy_s(pszBuffer, nMaxCount, m_strName.c_str());
    }
 
    std::string& CUnit::getName()
    {
        return m_strName;
    }
 
    void CUnit::setState(EQ_STATE state)
    {
        m_eqState = state;
        if (m_listener.onStateChanged != nullptr) {
            m_listener.onStateChanged(this, m_eqState);
        }
    }
 
    EQ_STATE CUnit::getState()
    {
        return m_eqState;
    }
 
    const char* CUnit::getStateText()
    {
        static char* eqState[] = { "IDLE", "RUN", "DOWN", "MAINTENANCE", "MCHG", "E_TIME" };
        return eqState[(int)m_eqState];
    }
 
    void CUnit::setStateFromString(std::string& strState)
    {
        static const std::unordered_map<std::string, EQ_STATE> stateMap = {
            {"IDLE", EQ_STATE::IDLE},
            {"RUN", EQ_STATE::RUN},
            {"DOWN", EQ_STATE::DOWN},
            {"MAINTENANCE", EQ_STATE::MAINTENANCE},
            {"MCHG", EQ_STATE::MCHG},
            {"E_TIME", EQ_STATE::E_TIME}
        };
 
        auto it = stateMap.find(strState);
        if (it != stateMap.end()) {
            m_eqState = it->second;
            if (m_listener.onStateChanged != nullptr) {
                m_listener.onStateChanged(this, m_eqState);
            }
        }
        else {
            // ´¦ÀíÎ´ÕÒµ½µÄ×´Ì¬£¨¸ù¾ÝÐèÇó¾ö¶¨ÊÇ·ñÅ×³öÒì³£»òÉèÖÃÄ¬ÈÏÖµ£©
            // m_eqState = EQ_STATE::UNKNOWN;
        }
    }
 
    void CUnit::setDoorCount(int count)
    {
        m_nDoorCount = count;
    }
 
    void CUnit::setDoorState(int state)
    {
        m_doorState = state;
        if (m_listener.onDoorStateChanged != nullptr) {
            m_listener.onDoorStateChanged(this, state);
        }
    }
 
    int  CUnit::getDoorState()
    {
        return m_doorState;
    }
 
    std::string& CUnit::getDoorState(std::string& strState)
    {
        static char* doorState[] = {"CLOSE", "OPEN"};
 
        strState = "";
        int temp = (int)m_doorState;
        for (int i = 0; i < m_nDoorCount; i++) {
            if (temp & 0x01) strState += "OPEN";
            else strState += "CLOSE";
            if (i != m_nDoorCount - 1) strState += ",";
 
            temp = temp >> 1;
        }
 
        return strState;
    }
 
    void CUnit::setLayerCount(int count)
    {
        m_nLayerCount = min(8, count);
    }
 
    int CUnit::getLayerCount()
    {
        return m_nLayerCount;
    }
 
    void CUnit::setIndex(int index)
    {
        m_nIndex = index;
    }
 
    int CUnit::getIndex()
    {
        return m_nIndex;
    }
 
    void CUnit::setAlarm(int code, int level, const char* pszText)
    {
        if (code == 0) {
            if (m_nAlarmCode != 0) {
                m_listener.onRemoveAlarm(this, m_nAlarmCode, m_nAlarmLevel, m_strAlarmText.c_str());
            }
 
            m_nAlarmCode = code;
            m_nAlarmLevel = level;
            m_strAlarmText = pszText;
        }
        else {
            m_nAlarmCode = code;
            m_nAlarmLevel = level;
            m_strAlarmText = pszText;
 
            if (m_listener.onAlarm != nullptr) {
                m_listener.onAlarm(this, code, level, pszText);
            }
        }
 
    }
 
    int CUnit::getAlarmCode()
    {
        return m_nAlarmCode;
    }
 
    int CUnit::getAlarmLevel()
    {
        return m_nAlarmLevel;
    }
 
    std::string& CUnit::getAlarmText()
    {
        return m_strAlarmText;
    }
 
    int CUnit::reqNotReady(int layer)
    {
        ASSERT(m_listener.onReqNotReady);
        if (layer <= 0) return -1;
        if (layer > m_nLayerCount) return -2;
 
        // ×´Ì¬¸Ä±ä²Å»Øµ÷µ½ÉÏ²ã
        if (m_nLayerLoadState[layer - 1] != LAYER_NOT_READY) {
            m_nLayerLoadState[layer - 1] = LAYER_NOT_READY;
            m_listener.onReqNotReady(this, layer);
            return 0;
        }
 
        return -3;
    }
 
    int CUnit::reqLoad(int layer)
    {
        ASSERT(m_listener.onReqLoad);
        if (layer <= 0) return -1;
        if (layer > m_nLayerCount) return -2;
 
        // ×´Ì¬¸Ä±ä²Å»Øµ÷µ½ÉÏ²ã
        if (m_nLayerLoadState[layer - 1] != LAYER_LOAD_REQ) {
            m_nLayerLoadState[layer - 1] = LAYER_LOAD_REQ;
            m_listener.onReqLoad(this, layer);
            return 0;
        }
 
        return -3;
    }
 
    int CUnit::reqUnload(int layer)
    {
        ASSERT(m_listener.onReqUnload);
        if (layer <= 0) return -1;
        if (layer > m_nLayerCount) return -2;
 
        // ×´Ì¬¸Ä±ä²Å»Øµ÷µ½ÉÏ²ã
        if (m_nLayerLoadState[layer - 1] != LAYER_UNLOAD_REQ) {
            m_nLayerLoadState[layer - 1] = LAYER_UNLOAD_REQ;
            m_listener.onReqUnload(this, layer);
            return 0;
        }
 
        return -3;
    }
 
    void CUnit::stepIdle()
    {
        m_stepState = STEP_STATE::IDLE;
        if (m_listener.onStepChanged != nullptr) {
            m_listener.onStepChanged(this, m_stepState);
        }
    }
 
    void CUnit::stepMaterialReceived(const char* pszID)
    {
        m_stepState = STEP_STATE::MATERIAL_RECEIVED;
        m_stepMaterialId = pszID;
        if (m_listener.onStepChanged != nullptr) {
            m_listener.onStepChanged(this, m_stepState);
        }
    }
 
    void CUnit::stepMaterialRemoved(const char* pszID)
    {
        m_stepState = STEP_STATE::MATERIAL_REMOVEED;
        m_stepMaterialId = pszID;
        if (m_listener.onStepChanged != nullptr) {
            m_listener.onStepChanged(this, m_stepState);
        }
    }
 
    void CUnit::stepProcessingStarted(const char* pszID)
    {
        m_stepState = STEP_STATE::PROCESSING_STARTED;
        m_stepMaterialId = pszID;
        if (m_listener.onStepChanged != nullptr) {
            m_listener.onStepChanged(this, m_stepState);
        }
    }
 
    void CUnit::stepProcessing(const char* pszID, int nSvTime, int nTvTime)
    {
        m_stepState = STEP_STATE::PROCESSING;
        m_stepMaterialId = pszID;
        m_stepSvTime = nSvTime;
        m_stepPvTime = nTvTime;
        if (m_listener.onStepChanged != nullptr) {
            m_listener.onStepChanged(this, m_stepState);
        }
    }
 
    void CUnit::stepProcessingCompleted(const char* pszID)
    {
        m_stepState = STEP_STATE::PROCESSING_COMPLETED;
        m_stepMaterialId = pszID;
        if (m_listener.onStepChanged != nullptr) {
            m_listener.onStepChanged(this, m_stepState);
        }
    }
 
    STEP_STATE CUnit::getStepState()
    {
        return m_stepState;
    }
 
    const char* CUnit::getStepStateText()
    {
        static char* stepState[] = { "IDLE", "MATERIAL_RECEIVED", "MATERIAL_REMOVED",
            "PROCESSING_STARTED", "PROCESSING", "PROCESSING_COMPLETED" };
        return stepState[(int)m_stepState];
    }
 
    std::string& CUnit::getStepMaterialId()
    {
        return m_stepMaterialId;
    }
 
    int CUnit::getStepSvTime()
    {
        return m_stepSvTime;
    }
 
    int CUnit::getSetpPvTime()
    {
        return m_stepPvTime;
    }
 
    void CUnit::setDataTime(unsigned long long time)
    {
        m_dataTime = time;
    }
 
    void CUnit::setDataTimeAndResetData(unsigned long long time)
    {
        m_dataTime = time;
        m_dataMap.clear();
    }
 
    void CUnit::addData(const char* pszName, const char* pszDataText, bool bComplete)
    {
        m_dataMap[pszName] = pszDataText;
        if (bComplete) {
            if (m_listener.onDataChanged != nullptr) {
                m_listener.onDataChanged(this, m_dataTime);
            }
        }
    }
 
    unsigned long long CUnit::getDataTime()
    {
        return m_dataTime;
    }
 
    uint64_t CUnit::stringToTimeStamp(const std::string& strTime)
    {
        std::tm tm = {};
        std::istringstream ss(strTime);
 
        ss >> std::get_time(&tm, "%Y-%m-%d %H:%M:%S");
        if (ss.fail()) {
            return 0;
        }
 
        std::time_t time = std::mktime(&tm);
        if (time == -1) {
            return 0;
        }
 
        return static_cast<uint64_t>(std::chrono::duration_cast<std::chrono::milliseconds>(
            std::chrono::system_clock::from_time_t(time).time_since_epoch()
        ).count());
    }
 
    const char* CUnit::getDataTimeText(uint64_t time)
    {
        static char buffer[32];
        auto timePoint = std::chrono::time_point<std::chrono::system_clock>(std::chrono::milliseconds(time));
        std::time_t t = std::chrono::system_clock::to_time_t(timePoint);
        std::tm tmPtr;
        if (localtime_s(&tmPtr, &t) == 0) {
            strftime(buffer, sizeof(buffer), "%Y-%m-%d %H:%M:%S", &tmPtr);
        }
        else {
            snprintf(buffer, sizeof(buffer), "Invalid Time");
        }
 
        return buffer;
    }
 
    std::map<std::string, std::string>& CUnit::getDatas()
    {
        return m_dataMap;
    }
 
    std::map<int, std::string>& CUnit::getRecipes()
    {
        return m_mapRecipe;
    }
 
    void CUnit::addRecipe(int id, const char* pszName, bool bComplete)
    {
        m_mapRecipe[id] = pszName;
    }
 
    bool CUnit::checkRecipe(int id, const char* pszName)
    {
        bool bMatched = false;
        for (auto item : m_mapRecipe) {
            if (id == item.first && strcmp(pszName, item.second.c_str()) == 0) {
                bMatched = true;
                break;
            }
        }
 
        return bMatched;
    }
 
    void CUnit::resetLoadState()
    {
        for (int i = 0; i < 8; i++) {
            m_nLayerLoadState[i] = LAYER_LOAD_INIT;
        }
    }
}