SwitchboardObject.hpp

//
//  SwitchboardObject.hpp
//  SwitchboardSDK
//
//  Created by Balazs Kiss on 2025. 01. 22..
//
 
#pragma once
 
#include <switchboard/export.h>
#include <switchboard_core/EventEmitter.hpp>
#include <switchboard/SBAny.hpp>
#include <switchboard_core/SwitchboardCore.hpp>
#include <switchboard_core/Configuration.hpp>
#include <switchboard_core/ObjectTypeInfo.hpp>
#include <switchboard_core/Property.hpp>
#include <switchboard_core/Action.hpp>
#include <switchboard_core/Event.hpp>
 
#include <any>
#include <map>
#include <memory>
#include <string>
#include <switchboard/Result.hpp>
 
namespace switchboard {

class SWITCHBOARDSDK_EXPORT SwitchboardObject : public EventEmitter {
public:

    static SBAnyMap getObjectTypeInfo() {
        return SBAnyMap({
            { OBJECT_TYPE_FIELD_PROPERTIES,
              SBAnyMap({
                  { "hasActions",
                    SBAnyMap({
                        { PROPERTY_FIELD_TYPE, PROPERTY_TYPE_BOOLEAN },
                        { PROPERTY_FIELD_READ_ONLY, true },
                        { PROPERTY_FIELD_DESCRIPTION, "Whether the node has actions." },
                    }) },
                  { "hasEvents",
                    SBAnyMap({
                        { PROPERTY_FIELD_TYPE, PROPERTY_TYPE_BOOLEAN },
                        { PROPERTY_FIELD_READ_ONLY, true },
                        { PROPERTY_FIELD_DESCRIPTION, "Whether the node has events." },
                    }) },
              }) },
            { OBJECT_TYPE_FIELD_ACTIONS,
              SBAnyMap({
                  { "getState",
                    SBAnyMap({
                        { ACTION_FIELD_DESCRIPTION,
                          "Returns the full state of the object including identity, configuration, and current property values." },
                    }) },
                  { "getConfiguration",
                    SBAnyMap({
                        { ACTION_FIELD_DESCRIPTION, "Returns the configuration schema for this object." },
                    }) },
                  { "getProperties",
                    SBAnyMap({
                        { ACTION_FIELD_DESCRIPTION, "Returns the property schema for this object." },
                    }) },
                  { "getActions",
                    SBAnyMap({
                        { ACTION_FIELD_DESCRIPTION, "Returns the action schema for this object." },
                    }) },
                  { "getEvents",
                    SBAnyMap({
                        { ACTION_FIELD_DESCRIPTION, "Returns the event schema for this object." },
                    }) },
              }) },
        });
    }

    explicit SwitchboardObject(const std::string& objectType);

    ~SwitchboardObject() override;

    std::string getObjectID() const;

    void setObjectID(const std::string& objectID);

    std::string getURI();

    std::string getObjectType() const;

    std::optional<std::string> getObjectSubtype() const;

    void setObjectSubtype(std::optional<std::string> subtype);

    SwitchboardObject* getParentObject() const;

    void setParentObject(SwitchboardObject* parentObject);

    virtual Result<void> setValue(const std::string& key, const SBAny& value);

    virtual Result<SBAny> getValue(const std::string& key);

    virtual Result<SBAny> callAction(const std::string& actionName, const SBAnyMap& params);

    void registerConfiguration(const std::string& key, const SBAnyMap& schema, const SBAny& value);

    void setConfigurationValue(const std::string& key, const SBAny& value);

    void registerProperty(
        const std::string& key,
        const SBAnyMap& schema,
        const SBAny& getter = SBAny(),
        const SBAny& setter = SBAny()
    );

    void registerAction(const std::string& key, const SBAnyMap& schema, ActionHandler handler = {});

    void registerEvent(const std::string& eventName, const SBAnyMap& eventInfo);
 
private:
    class Impl;
    std::unique_ptr<Impl> impl;
};
 
}