#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;
		}
	}
}