SwitchboardObject.hpp

//
//  SwitchboardObject.hpp
//  SwitchboardSDK
//
//  Created by Balazs Kiss on 2025. 01. 22..
//
 
#pragma once
 
#include <any>
#include <map>
#include <memory>
#include <string>
#include <switchboard/Result.hpp>
#include <switchboard/SBAny.hpp>
#include <switchboard/export.h>
#include <switchboard_core/Action.hpp>
#include <switchboard_core/Configuration.hpp>
#include <switchboard_core/Event.hpp>
#include <switchboard_core/EventEmitter.hpp>
#include <switchboard_core/ObjectTypeInfo.hpp>
#include <switchboard_core/Property.hpp>
#include <switchboard_core/SwitchboardCore.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." },
                                    { ACTION_FIELD_RETURN_TYPE, ACTION_RETURN_TYPE_OBJECT },
                                    { ACTION_FIELD_RETURN_DESCRIPTION,
                                      "The object's state: objectID, objectURI, objectType and objectSubtype, plus a "
                                      "configuration map and a properties map holding the current values." },
                                }
                            ) },
                          { "getConfiguration",
                            SBAnyMap(
                                {
                                    { ACTION_FIELD_DESCRIPTION, "Returns the configuration schema for this object." },
                                    { ACTION_FIELD_RETURN_TYPE, ACTION_RETURN_TYPE_OBJECT },
                                    { ACTION_FIELD_RETURN_DESCRIPTION,
                                      "The construction-time parameters this object accepts, keyed by parameter name." },
                                }
                            ) },
                          { "getProperties",
                            SBAnyMap(
                                {
                                    { ACTION_FIELD_DESCRIPTION, "Returns the property schema for this object." },
                                    { ACTION_FIELD_RETURN_TYPE, ACTION_RETURN_TYPE_OBJECT },
                                    { ACTION_FIELD_RETURN_DESCRIPTION,
                                      "The runtime properties this object exposes, keyed by property name." },
                                }
                            ) },
                          { "getActions",
                            SBAnyMap(
                                {
                                    { ACTION_FIELD_DESCRIPTION, "Returns the action schema for this object." },
                                    { ACTION_FIELD_RETURN_TYPE, ACTION_RETURN_TYPE_OBJECT },
                                    { ACTION_FIELD_RETURN_DESCRIPTION,
                                      "The actions this object can perform, keyed by action name." },
                                }
                            ) },
                          { "getEvents",
                            SBAnyMap(
                                {
                                    { ACTION_FIELD_DESCRIPTION, "Returns the event schema for this object." },
                                    { ACTION_FIELD_RETURN_TYPE, ACTION_RETURN_TYPE_OBJECT },
                                    { ACTION_FIELD_RETURN_DESCRIPTION,
                                      "The events this object emits, keyed by event name." },
                                }
                            ) },
                          { "setProperty",
                            SBAnyMap(
                                {
                                    { ACTION_FIELD_DESCRIPTION, "Sets a property to a new value by name." },
                                    { ACTION_FIELD_PARAMETERS,
                                      SBAnyMap(
                                          {
                                              { "name",
                                                SBAnyMap(
                                                    {
                                                        { ACTION_PARAMETER_FIELD_NAME, "name" },
                                                        { ACTION_PARAMETER_FIELD_DESCRIPTION,
                                                          "The name of the property to set." },
                                                        { ACTION_PARAMETER_FIELD_TYPE, ACTION_PARAMETER_TYPE_STRING },
                                                        { ACTION_PARAMETER_FIELD_IS_OPTIONAL, false },
                                                    }
                                                ) },
                                              { "value",
                                                SBAnyMap(
                                                    {
                                                        { ACTION_PARAMETER_FIELD_NAME, "value" },
                                                        { ACTION_PARAMETER_FIELD_DESCRIPTION,
                                                          "The new value for the property." },
                                                        { ACTION_PARAMETER_FIELD_TYPE, ACTION_PARAMETER_TYPE_OBJECT },
                                                        { ACTION_PARAMETER_FIELD_IS_OPTIONAL, false },
                                                    }
                                                ) },
                                          }
                                      ) },
                                }
                            ) },
                      }
                  ) },
            }
        );
    }

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