#pragma once
#include "Context.h"
#include <string>
#include "CPath.h"
#include "CJobDataA.h"
#include "CJobDataB.h"
#include "CJobDataC.h"
#include "CJobDataS.h"
#include "ServoCommo.h"
#include "ProcessJob.h"
#include "CParam.h"


namespace SERVO {
	/// Êý¾ÝÏʱ¼ä´Á + ÊýÖµ
	struct SVDataItem {
		std::chrono::system_clock::time_point timestamp;
		double value;  // »òÕ߸ù¾Ýʵ¼ÊÇé¿öʹÓÃÆäËûÀàÐÍ

		SVDataItem(std::chrono::system_clock::time_point ts, double val)
			: timestamp(ts), value(val) {}
	};

	/// PJ ÉúÃüÖÜÆÚ£¨Ìù½ü E40 ³£¼û״̬£©
	enum class GlsState : uint8_t {
		NoState = 0,
		Queued,
		InProcess,
		Paused,
		Completed,
		Aborted,
		Failed
	};

	class CGlass : public CContext
	{
	public:
		CGlass();
		virtual ~CGlass();
		void reset();

	public:
		virtual std::string& getClassName();
		virtual std::string toString();
		short getCassetteSequenceNo() const { return m_jobDataS.getCassetteSequenceNo(); }
		short getJobSequenceNo() const { return m_jobDataS.getJobSequenceNo(); }
		MaterialsType getType() const;
		void setType(MaterialsType type);
		void setID(const char* pszID);
		const std::string& getID() const;
		void setOriginPort(int port, int slot);
		void getOrginPort(int& port, int& slot);
		BOOL isScheduledForProcessing();
		void setScheduledForProcessing(BOOL bProcessing);
		CProcessJob* getProcessJob();
		void setProcessJob(CProcessJob* pProcessJob);
		CPath* getPathWithEq(unsigned int nEqId, unsigned int nUnit) const;
		CPath* getPath();
		void addPath(unsigned int nEqId, unsigned int nUnit, unsigned int slot);
		std::string getPathDescription() const;
		std::string getParamsDescription() const;
		void serialize(CArchive& ar);
		void setJobDataS(CJobDataS* pJobDataS);
		void updateJobDataS(CJobDataS* pJobDataS);
		CJobDataS* getJobDataS();
		BOOL setBuddy(CGlass* pGlass);
		BOOL forceSetBuddy(CGlass* pGlass);
		CGlass* getBuddy();
		const std::string& getBuddyId() const;
		void setBuddyId(std::string& strId);
		int processEnd(unsigned int nEqId, unsigned int nUnit);
		BOOL isProcessed(unsigned int nEqId, unsigned int nUnit);
		int setInspResult(unsigned int nEqId, unsigned int nUnit, InspResult result);
		InspResult getInspResult(unsigned int nEqId, unsigned int nUnit) const;
		InspResult getAOIInspResult() const;

	public:
		// ÐÂÔö״̬
		GlsState state() const noexcept { return m_state; }
		std::string getStateText();
		GlsState m_state{ GlsState::NoState };
		static void clampString(std::string& s, size_t maxLen);
		static std::string trimCopy(std::string s);
		std::string m_failReason;

		// ¡ª¡ª ״̬»ú£¨´øÊØÎÀ£©¡ª¡ª
		bool queue();           // NoState -> Queued
		bool start();           // Queued -> InProcess
		bool pause();           // InProcess -> Paused
		bool resume();          // Paused -> InProcess
		bool complete();        // InProcess -> Completed
		bool abort();           // Any (δÖÕ̬) -> Aborted
		bool fail(std::string reason); // ÈÎÒâ̬ -> Failed£¨¼Ç¼ʧ°ÜÔ­Òò£©

		// ʱ¼ä´Á
		std::optional<std::chrono::system_clock::time_point> m_tQueued;
		std::optional<std::chrono::system_clock::time_point> m_tStart;
		std::optional<std::chrono::system_clock::time_point> m_tEnd;

		// ʱ¼ä´Á£¨¿ÉÓÃÓÚ±¨±í/×·ËÝ£©
		std::optional<std::chrono::system_clock::time_point> tQueued() const { return m_tQueued; }
		std::optional<std::chrono::system_clock::time_point> tStart()  const { return m_tStart; }
		std::optional<std::chrono::system_clock::time_point> tEnd()    const { return m_tEnd; }
		void markQueued();
		void markStart();
		void markEnd();

		// ¹¤ÒÕ²ÎÊý
		void addParams(std::vector<CParam>& params);
		std::vector<CParam>& getParams();

		// ========== SVÊý¾Ý¹ÜÀí½Ó¿Ú£¨ÐÂÉè¼Æ£©==========

		// Ìí¼ÓÊý¾Ýµ½Ö¸¶¨»úÆ÷µÄÖ¸¶¨Êý¾ÝÀàÐÍ
		void addSVData(int machineId, const std::string& dataType, const SVDataItem& dataItem);
		void addSVData(int machineId, const std::string& dataType, double value); // ×Ô¶¯Ê¹Óõ±Ç°Ê±¼ä
		void addSVData(int machineId, const std::string& dataType, int64_t timestamp, double value);

		// ÅúÁ¿Ìí¼ÓÊý¾Ýµ½Ö¸¶¨»úÆ÷µÄÖ¸¶¨Êý¾ÝÀàÐÍ
		void addSVData(int machineId, const std::string& dataType, const std::vector<SVDataItem>& dataItems);

		// »ñÈ¡Ö¸¶¨»úÆ÷µÄÖ¸¶¨Êý¾ÝÀàÐ͵ÄËùÓÐÊý¾Ý
		std::vector<SVDataItem> getSVData(int machineId, const std::string& dataType) const;

		// »ñÈ¡Ö¸¶¨»úÆ÷µÄËùÓÐÊý¾ÝÀàÐÍ
		std::vector<std::string> getSVDataTypes(int machineId) const;

		// »ñÈ¡Ö¸¶¨»úÆ÷µÄËùÓÐÊý¾Ý£¨°´Êý¾ÝÀàÐÍ×éÖ¯£©
		std::unordered_map<std::string, std::vector<SVDataItem>> getMachineSVData(int machineId) const;

		// »ñÈ¡ËùÓлúÆ÷µÄÊý¾Ý
		const std::unordered_map<int, std::unordered_map<std::string, std::vector<SVDataItem>>>& getAllSVData() const;

		// ¼ì²éÖ¸¶¨»úÆ÷ÊÇ·ñÓÐÖ¸¶¨ÀàÐ͵ÄÊý¾Ý
		bool hasSVData(int machineId, const std::string& dataType) const;

		// ¼ì²éÖ¸¶¨»úÆ÷ÊÇ·ñÓÐÈκÎÊý¾Ý
		bool hasMachineSVData(int machineId) const;

		// »ñÈ¡ËùÓÐÓÐSVÊý¾ÝµÄ»úÆ÷ID
		std::vector<int> getMachineIdsWithSVData() const;

		// Çå¿ÕÖ¸¶¨»úÆ÷µÄÖ¸¶¨Êý¾ÝÀàÐ͵ÄÊý¾Ý
		void clearSVData(int machineId, const std::string& dataType);

		// Çå¿ÕÖ¸¶¨»úÆ÷µÄËùÓÐÊý¾Ý
		void clearMachineSVData(int machineId);

		// Çå¿ÕËùÓлúÆ÷µÄËùÓÐÊý¾Ý
		void clearAllSVData();

		// »ñÈ¡Ö¸¶¨»úÆ÷µÄÖ¸¶¨Êý¾ÝÀàÐ͵ÄÊý¾ÝÊýÁ¿
		size_t getSVDataCount(int machineId, const std::string& dataType) const;

		// »ñÈ¡Ö¸¶¨»úÆ÷µÄ×ÜÊý¾ÝÊýÁ¿
		size_t getMachineSVDataCount(int machineId) const;

		// »ñÈ¡ËùÓлúÆ÷µÄ×ÜÊý¾ÝÊýÁ¿
		size_t getTotalSVDataCount() const;

		// »ñÈ¡Ö¸¶¨Êý¾ÝÀàÐÍÔÚËùÓлúÆ÷ÖеÄÊý¾Ý
		std::vector<std::pair<int, SVDataItem>> findSVDataByType(const std::string& dataType) const;

	private:
		MaterialsType m_type;
		std::string m_strID;
		CPath* m_pPath;
		CJobDataS m_jobDataS;
		CGlass* m_pBuddy;
		std::string m_strBuddyId;
		int m_nOriginPort;
		int m_nOriginSlot;
		BOOL m_bScheduledForProcessing;			/* ÊÇ·ñ½«¼Ó¹¤´¦Àí */
		CProcessJob* m_pProcessJob;
		std::vector<CParam> m_params;			// ¹¤ÒÕ²ÎÊý

		// еÄÈý²ãÊý¾Ý½á¹¹£º»úÆ÷ID -> Êý¾ÝÀàÐÍ -> Êý¾ÝÁбí
		std::unordered_map<int, std::unordered_map<std::string, std::vector<SVDataItem>>> m_svDatas;
	};
}