~chenluhua/Bond2.git

#pragma once
#include <string>
#include <vector>
#include <unordered_map>
#include <unordered_set>
#include <algorithm>
#include <cstdint>
#include <chrono>
#include <optional>
 
namespace SERVO {
    /// PJ ÉúÃüÖÜÆÚ£¨Ìù½ü E40 ³£¼û×´Ì¬£©
    enum class PJState : uint8_t {
        NoState = 0,
        Queued,
        SettingUp,
        InProcess,
        Paused,
        Aborting,
        Completed,
        Aborted,
        Failed
    };
 
    /// Åä·½Ö¸¶¨·½Ê½£¨¶ÔÓ¦ S16F15 Àï PRRECIPEMETHOD£©
    enum class RecipeMethod : uint8_t {
        NoTuning = 1,   // 1 - recipe without variable tuning
        WithTuning = 2  // 2 - recipe with variable tuning
    };
 
    /// Æô¶¯²ßÂÔ£¨¶ÔÓ¦ S16F15 Àï PRPROCESSSTART£©
    enum class StartPolicy : uint8_t {
        Queued = 0,   // ½¨Á¢ºóÅÅ¶Ó
        AutoStart = 1 // Ìõ¼þÂú×ãÔò×Ô¶¯Æô¶¯
    };
 
    /** Åä·½²ÎÊý¶Ô£¨S16F15 ÖÐ RCPPARNM / RCPPARVAL£© */
    struct PJParam {
        std::string name;   // RCPPARNM
        std::string value;  // RCPPARVAL
    };
 
    /**
    {L:2
        CARRIERID
        {L:j
            SLOTID
        }
    }
     */
    struct CarrierSlotInfo {
        std::string carrierId;          // CARRIERID
        std::vector<uint8_t> slots;     // SLOTID[]
        std::vector<void*> contexts;    // Glass
    };
 
    /// ¼òµ¥×ÊÔ´ÊÓÍ¼½Ó¿Ú£º¹© Validate() ²éÑ¯£¨ÓÉÉè±¸¶ËÊµÏÖÕßÔÚÍâ²¿Ìá¹©£©
    struct IResourceView {
        virtual ~IResourceView() = default;
        virtual bool isProcessJobsEmpty() const = 0;
        virtual bool recipeExists(const std::string& ppid) const = 0;
        virtual bool carrierPresent(const std::string& carrierId) const = 0;
        virtual bool slotUsable(const std::string& carrierId, uint16_t slot) const = 0;
        virtual bool ceidDefined(uint32_t ceid) const = 0;
        // ÄãÒ²¿ÉÒÔÀ©Õ¹£ºport×´Ì¬¡¢Õ¼ÓÃÇé¿ö¡¢CJ/PJ¿Õ¼äµÈ
    };
 
    /// PJ Ö÷Àà
    /**
     * ProcessJob ¡ª¡ª Óë S16F15£¨PRJobMultiCreate£©×Ö¶ÎÒ»Ò»¶ÔÓ¦µÄ³ÐÔØÀà
     *
     * S16F15 ½á¹¹£¨ºËÐÄ½ÚÑ¡£©£º
     * {L:6
     *   PRJOBID                -> m_pjId
     *   MF                     -> m_mf
     *   {L:n { CARRIERID {L:j SLOTID} } } 
     *   {L:3
     *     PRRECIPEMETHOD       -> m_recipeType
     *     RCPSPEC£¨PPID£©      -> m_recipeSpec
     *     {L:m { RCPPARNM RCPPARVAL }}     -> m_params
     *   }
     *   PRPROCESSSTART         -> m_startPolicy
     *   {L:k PRPAUSEEVENTID}   -> m_pauseEvents
     * }
     */
    class CProcessJob {
    public:
        // ¡ª¡ª ¹¹Ôì / »ù±¾ÉèÖÃ ¡ª¡ª
        CProcessJob();
        explicit CProcessJob(std::string pjId);
 
        const std::string& id() const noexcept { return m_pjId; }
        const std::string& parentCjId() const noexcept { return m_parentCjId; }
        PJState state() const noexcept { return m_state; }
        StartPolicy startPolicy() const noexcept { return m_startPolicy; }
        RecipeMethod recipeMethod() const noexcept { return m_recipeMethod; }
        const std::string& recipeSpec() const noexcept { return m_recipeSpec; } // PPID »ò Spec
        std::string getStateText();
 
        // °ó¶¨¸¸ CJ
        void setParentCjId(std::string cjId);
 
        // Åä·½
        void setRecipe(RecipeMethod method, std::string spec);
 
        // Æô¶¯²ßÂÔ
        void setStartPolicy(StartPolicy sp) { m_startPolicy = sp; }
 
        // ²ÎÊý
        void addParam(std::string name, std::string value);
        void setParams(std::vector<PJParam> params);
 
        // ÔÝÍ£ÊÂ¼þ
        void addPauseEvent(uint32_t ceid);
        void setPauseEvents(std::vector<uint32_t> ceids);
 
        // ¡ª¡ª Ð£Ñé ¡ª¡ª
        struct ValidationIssue {
            uint32_t code;      // ×Ô¶¨Òå´íÎóÂë
            std::string text;   // ÎÄ±¾ÃèÊö
        };
        // ·µ»ØÎÊÌâÇåµ¥£¨¿Õ=Í¨¹ý£©
        bool validate(const IResourceView& rv);
        const std::vector<ValidationIssue>& issues() const;
 
        // ¡ª¡ª ×´Ì¬»ú£¨´øÊØÎÀ£©¡ª¡ª
        bool queue();           // NoState -> Queued
        bool start();           // Queued/SettingUp -> InProcess
        bool enterSettingUp();  // Queued -> SettingUp
        bool pause();           // InProcess -> Paused
        bool resume();          // Paused -> InProcess
        bool complete();        // InProcess -> Completed
        bool abort();           // Any (Î´ÖÕÌ¬) -> Aborted
        bool fail(std::string reason); // ÈÎÒâÌ¬ -> Failed£¨¼ÇÂ¼Ê§°ÜÔÒò£©
 
        // ¡ª¡ª ·ÃÎÊÆ÷£¨ÓÃÓÚÉÏ±¨/²éÑ¯£©¡ª¡ª
        const std::vector<PJParam>& params() const noexcept { return m_params; }
        const std::vector<uint32_t>& pauseEvents() const noexcept { return m_pauseEvents; }
        const std::string& failReason() const noexcept { return m_failReason; }
 
        // Ê±¼ä´Á£¨¿ÉÓÃÓÚ±¨±í/×·ËÝ£©
        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; }
 
        // ³¤¶ÈÏÞÖÆ¹¤¾ß£¨¿ÉÔÚ¼¯³ÉÊ±Í³Ò»²ßÂÔ£©
        static void clampString(std::string& s, size_t maxLen);
        static bool asciiPrintable(const std::string& s);
 
        // Çå¿Õ²¢ÕûÌåÉèÖÃ
        void setCarriers(std::vector<CarrierSlotInfo> carriers);
 
        // ×·¼ÓÒ»¸öÔØ¾ß
        void addCarrier(std::string carrierId, std::vector<uint8_t> slots);
 
        // ·ÃÎÊÆ÷
        const std::vector<CarrierSlotInfo>& carriers() const noexcept { return m_carriers; }
        CarrierSlotInfo* getCarrier(const std::string& strId);
 
        // ÅÐ¶¨ÊÇ·ñ¡°°´ÔØ¾ß/¿¨Î»¡±·½Ê½
        bool usesCarrierSlots() const noexcept { return !m_carriers.empty(); }
 
 
    public:
        // ====== °æ±¾Í·³£Á¿£¨½¨Òé±£Áô£¬±ãÓÚ¼æÈÝ£©======
        static constexpr uint32_t PJ_FILE_MAGIC = 0x504A4A31; // "PJJ1"
        static constexpr uint16_t PJ_FILE_VERSION = 0x0001;
 
        // ====== Á÷Ê½ÐòÁÐ»¯½Ó¿Ú ======
        void serialize(std::ostream& os) const;
        static bool deserialize(std::istream& is, CProcessJob& out, std::string* err = nullptr);
 
    private:
        // ÄÚ²¿×´Ì¬×ªÒÆ°ïÖú
        void markQueued();
        void markStart();
        void markEnd();
 
    private:
        // ±êÊ¶
        std::string m_pjId;
        std::string m_parentCjId;
 
        // Åä·½
        RecipeMethod m_recipeMethod{ RecipeMethod::NoTuning };
        std::string  m_recipeSpec; // PPID / Spec
 
        // ÎïÁÏ
        static constexpr uint8_t MATERIAL_FORMAT = 14; // substrate
        std::vector<CarrierSlotInfo> m_carriers;   // {L:n { CARRIERID {L:j SLOTID} }}
 
        // ²ÎÊý / ÔÝÍ£ÊÂ¼þ
        std::vector<PJParam>    m_params;
        std::vector<uint32_t>   m_pauseEvents;
 
        // ×´Ì¬ & ¼ÇÂ¼
        StartPolicy m_startPolicy{ StartPolicy::Queued }; // 0=Queued, 1=AutoStart
        PJState m_state{ PJState::NoState };
        std::string m_failReason;
 
        // Ê±¼ä´Á
        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;
 
        // Ô¼Êø£¨¿É°´ÄãÃÇÐÒéµ÷Õû£©
        static constexpr size_t MAX_ID_LEN = 64;   // PJID/ CJID/ CarrierID/ MID/ PPID
        static constexpr size_t MAX_PARAM_K = 32;   // ²ÎÊýÃû
        static constexpr size_t MAX_PARAM_V = 64;   // ²ÎÊýÖµ
 
        // ´íÎóÁÐ±í
        std::vector<ValidationIssue> m_issues;
    };
}