JSONServiceDescription.h

/*
 *  Copyright (C) 2005-2018 Team Kodi
 *  This file is part of Kodi - https://kodi.tv
 *
 *  SPDX-License-Identifier: GPL-2.0-or-later
 *  See LICENSES/README.md for more information.
 */

#pragma once

#include "JSONUtils.h"
#include "utils/Variant.h"

#include <limits>
#include <memory>
#include <string>
#include <vector>

namespace JSONRPC
{
  class JSONSchemaTypeDefinition;
  typedef std::shared_ptr<JSONSchemaTypeDefinition> JSONSchemaTypeDefinitionPtr;

  class JSONSchemaTypeDefinition : protected CJSONUtils
  {
  public:
    JSONSchemaTypeDefinition();

    bool Parse(const CVariant &value, bool isParameter = false);
    JSONRPC_STATUS Check(const CVariant& value, CVariant& outputValue, CVariant& errorData) const;
    void Print(bool isParameter, bool isGlobal, bool printDefault, bool printDescriptions, CVariant &output) const;
    void ResolveReference();

    std::string missingReference;

    std::string name;

    std::string ID;

    JSONSchemaTypeDefinitionPtr referencedType;

    bool referencedTypeSet = false;

    std::vector<JSONSchemaTypeDefinitionPtr> extends;

    std::string description;

    JSONSchemaType type = AnyValue;

    std::vector<JSONSchemaTypeDefinitionPtr> unionTypes;

    bool optional = true;

    CVariant defaultValue;

    double minimum;

    double maximum;

    bool exclusiveMinimum = false;

    bool exclusiveMaximum = false;

    unsigned int divisibleBy = 0;

    int minLength = -1;

    int maxLength = -1;

    std::vector<CVariant> enums;

    std::vector<JSONSchemaTypeDefinitionPtr> items;

    unsigned int minItems = 0;

    unsigned int maxItems = 0;

    bool uniqueItems = false;

    std::vector<JSONSchemaTypeDefinitionPtr> additionalItems;

    class CJsonSchemaPropertiesMap
    {
    public:
      CJsonSchemaPropertiesMap();

      void add(const JSONSchemaTypeDefinitionPtr& property);

      typedef std::map<std::string, JSONSchemaTypeDefinitionPtr>::const_iterator JSONSchemaPropertiesIterator;
      JSONSchemaPropertiesIterator begin() const;
      JSONSchemaPropertiesIterator find(const std::string& key) const;
      JSONSchemaPropertiesIterator end() const;
      unsigned int size() const;
    private:
      std::map<std::string, JSONSchemaTypeDefinitionPtr> m_propertiesmap;
    };

    CJsonSchemaPropertiesMap properties;

    bool hasAdditionalProperties = false;

    JSONSchemaTypeDefinitionPtr additionalProperties;
  };

  class JsonRpcMethod : protected CJSONUtils
  {
  public:
    JsonRpcMethod();

    bool Parse(const CVariant &value);
    JSONRPC_STATUS Check(const CVariant &requestParameters, ITransportLayer *transport, IClient *client, bool notification, MethodCall &methodCall, CVariant &outputParameters) const;

    std::string missingReference;

    std::string name;
    MethodCall method;
    TransportLayerCapability transportneed = Response;
    OperationPermission permission = ReadData;
    std::string description;
    std::vector<JSONSchemaTypeDefinitionPtr> parameters;
    JSONSchemaTypeDefinitionPtr returns;

  private:
    bool parseParameter(const CVariant& value, const JSONSchemaTypeDefinitionPtr& parameter);
    bool parseReturn(const CVariant &value);
    static JSONRPC_STATUS checkParameter(const CVariant& requestParameters,
                                         const JSONSchemaTypeDefinitionPtr& type,
                                         unsigned int position,
                                         CVariant& outputParameters,
                                         unsigned int& handled,
                                         CVariant& errorData);
  };

  typedef struct
  {
    std::string name;
    MethodCall method;
  } JsonRpcMethodMap;

  class CJSONServiceDescription : public CJSONUtils
  {
    friend class JSONSchemaTypeDefinition;
    friend class JsonRpcMethod;
  public:
    static bool AddType(const std::string &jsonType);

    static bool AddMethod(const std::string &jsonMethod, MethodCall method);

    static bool AddBuiltinMethod(const std::string &jsonMethod);

    static bool AddNotification(const std::string &jsonNotification);

    static bool AddEnum(const std::string &name, const std::vector<CVariant> &values, CVariant::VariantType type = CVariant::VariantTypeNull, const CVariant &defaultValue = CVariant::ConstNullVariant);
    static bool AddEnum(const std::string &name, const std::vector<std::string> &values);
    static bool AddEnum(const std::string &name, const std::vector<int> &values);

    static const char* GetVersion();

    static JSONRPC_STATUS Print(CVariant &result, ITransportLayer *transport, IClient *client, bool printDescriptions = true, bool printMetadata = false, bool filterByTransport = true, const std::string &filterByName = "", const std::string &filterByType = "", bool printReferences = true);

    static JSONRPC_STATUS CheckCall(const char* method, const CVariant &requestParameters, ITransportLayer *transport, IClient *client, bool notification, MethodCall &methodCall, CVariant &outputParameters);

    static JSONSchemaTypeDefinitionPtr GetType(const std::string &identification);

    static void ResolveReferences();
    static void Cleanup();

  private:
    static bool prepareDescription(std::string &description, CVariant &descriptionObject, std::string &name);
    static bool addMethod(const std::string &jsonMethod, MethodCall method);
    static void parseHeader(const CVariant &descriptionObject);
    static bool parseJSONSchemaType(const CVariant &value, std::vector<JSONSchemaTypeDefinitionPtr>& typeDefinitions, JSONSchemaType &schemaType, std::string &missingReference);
    static void addReferenceTypeDefinition(const JSONSchemaTypeDefinitionPtr& typeDefinition);
    static void removeReferenceTypeDefinition(const std::string &typeID);

    static void getReferencedTypes(const JSONSchemaTypeDefinitionPtr& type,
                                   std::vector<std::string>& referencedTypes);

    class CJsonRpcMethodMap
    {
    public:
      CJsonRpcMethodMap();

      void add(const JsonRpcMethod &method);

      typedef std::map<std::string, JsonRpcMethod>::const_iterator JsonRpcMethodIterator;
      JsonRpcMethodIterator begin() const;
      JsonRpcMethodIterator find(const std::string& key) const;
      JsonRpcMethodIterator end() const;

      void clear();
    private:
      std::map<std::string, JsonRpcMethod> m_actionmap;
    };

    static CJsonRpcMethodMap m_actionMap;
    static std::map<std::string, JSONSchemaTypeDefinitionPtr> m_types;
    static std::map<std::string, CVariant> m_notifications;
    static JsonRpcMethodMap m_methodMaps[];

    typedef enum SchemaDefinition
    {
      SchemaDefinitionType,
      SchemaDefinitionMethod
    } SchemaDefinition;

    typedef struct IncompleteSchemaDefinition
    {
      std::string Schema;
      SchemaDefinition Type;
      MethodCall Method;
    } IncompleteSchemaDefinition;

    typedef std::map<std::string, std::vector<IncompleteSchemaDefinition> > IncompleteSchemaDefinitionMap;
    static IncompleteSchemaDefinitionMap m_incompleteDefinitions;
  };
}