json-validator/include/jvalidate/constraint.h

#pragma once

#include <functional>
#include <map>
#include <memory>
#include <set>
#include <string_view>
#include <unordered_map>
#include <unordered_set>

#include <jvalidate/constraint/array_constraint.h>
#include <jvalidate/constraint/general_constraint.h>
#include <jvalidate/constraint/number_constraint.h>
#include <jvalidate/constraint/object_constraint.h>
#include <jvalidate/constraint/string_constraint.h>

#include <jvalidate/detail/expect.h>
#include <jvalidate/detail/parser_context.h>
#include <jvalidate/enum.h>
#include <jvalidate/forward.h>

namespace jvalidate {
template <Adapter A> class ConstraintFactory {
public:
  using pConstraint = std::unique_ptr<constraint::Constraint>;
  using Object = decltype(std::declval<A>().as_object());

  using MakeConstraint = std::function<pConstraint(detail::ParserContext<A> const &)>;
  template <typename V> using Versioned = std::map<schema::Version, V, std::greater<>>;
  template <typename V> using Keywords = std::unordered_map<std::string_view, V>;

private:
  using Self = ConstraintFactory<A>;

private:
  Keywords<MakeConstraint> constraints_{
      {"additionalProperties", &Self::additionalProperties},
      {"enum", &Self::isInEnumuration},
      {"maxItems", &Self::maxItems},
      {"maxLength", &Self::maxLength},
      {"maximum", &Self::maximum},
      {"minItems", &Self::minItems},
      {"minLength", &Self::minLength},
      {"minimum", &Self::minimum},
      {"pattern", &Self::pattern},
      {"patternProperties", &Self::patternProperties},
      {"properties", &Self::properties},
      {"type", &Self::type},
      {"uniqueItems", &Self::uniqueItems},
  };

  Keywords<Versioned<MakeConstraint>> versioned_constraints_{
      {"additionalItems",
       {{schema::Version::Draft04, &Self::additionalItems},
        {schema::Version::Draft2020_12, nullptr}}},
      {"allOf", {{schema::Version::Draft04, &Self::allOf}}},
      {"anyOf", {{schema::Version::Draft04, &Self::anyOf}}},
      {"const", {{schema::Version::Draft06, &Self::isConstant}}},
      {"contains", {{schema::Version::Draft06, &Self::contains}}},
      {"dependencies", {{schema::Version::Draft04, &Self::dependencies}}},
      {"dependentRequired", {{schema::Version::Draft2019_09, &Self::dependentRequired}}},
      {"dependentSchemas", {{schema::Version::Draft2019_09, &Self::dependentSchemas}}},
      {"divisibleBy",
       {{schema::Version::Draft04, &Self::multipleOf}, {schema::Version::Draft04, nullptr}}},
      {"exclusiveMaximum", {{schema::Version::Draft06, &Self::exclusiveMaximum}}},
      {"exclusiveMinimum", {{schema::Version::Draft06, &Self::exclusiveMinimum}}},
      {"format",
       {{schema::Version::Draft04, &Self::warnUnimplemented},
        {schema::Version::Draft2020_12, nullptr}}},
      {"format-assertion", {{schema::Version::Draft2020_12, &Self::fatalUnimplemented}}},
      {"if", {{schema::Version::Draft07, &Self::ifThenElse}}},
      {"items",
       {{schema::Version::Draft04, &Self::itemsTupleOrVector},
        {schema::Version::Draft2020_12, &Self::additionalItems}}},
      {"maxProperties", {{schema::Version::Draft04, &Self::maxProperties}}},
      {"minProperties", {{schema::Version::Draft04, &Self::minProperties}}},
      {"multipleOf", {{schema::Version::Draft04, &Self::multipleOf}}},
      {"not", {{schema::Version::Draft04, &Self::isNot}}},
      {"oneOf", {{schema::Version::Draft04, &Self::oneOf}}},
      {"prefixItems", {{schema::Version::Draft2020_12, &Self::prefixItems}}},
      {"propertyNames", {{schema::Version::Draft06, &Self::propertyNames}}},
      {"required", {{schema::Version::Draft04, &Self::required}}},
      {"unevaluatedItems", {{schema::Version::Draft2019_09, &Self::unevaluatedItems}}},
      {"unevaluatedProperties", {{schema::Version::Draft2019_09, &Self::unevaluatedProperties}}},
  };

  Keywords<Versioned<std::set<schema::Wraps>>> keywords_{
      {"$defs", {{schema::Version::Draft2019_09, {schema::Wraps::Object}}}},
      {"additionalItems",
       {{schema::Version::Draft04, {schema::Wraps::Schema}}, {schema::Version::Draft2020_12, {}}}},
      {"additionalProperties", {{schema::Version::Draft04, {schema::Wraps::Schema}}}},
      {"allOf", {{schema::Version::Draft04, {schema::Wraps::Array}}}},
      {"anyOf", {{schema::Version::Draft04, {schema::Wraps::Array}}}},
      {"definitions",
       {{schema::Version::Draft04, {schema::Wraps::Object}}, {schema::Version::Draft2019_09, {}}}},
      {"dependencies",
       {{schema::Version::Draft04, {schema::Wraps::Object}}, {schema::Version::Draft2019_09, {}}}},
      {"dependentSchemas", {{schema::Version::Draft2019_09, {schema::Wraps::Object}}}},
      {"else", {{schema::Version::Draft04, {schema::Wraps::Schema}}}},
      {"if", {{schema::Version::Draft04, {schema::Wraps::Schema}}}},
      {"items",
       {{schema::Version::Draft04, {schema::Wraps::Array, schema::Wraps::Schema}},
        {schema::Version::Draft2020_12, {schema::Wraps::Schema}}}},
      {"not", {{schema::Version::Draft04, {schema::Wraps::Schema}}}},
      {"oneOf", {{schema::Version::Draft04, {schema::Wraps::Array}}}},
      {"patternProperties", {{schema::Version::Draft04, {schema::Wraps::Object}}}},
      {"prefixItems", {{schema::Version::Draft2020_12, {schema::Wraps::Array}}}},
      {"properties", {{schema::Version::Draft04, {schema::Wraps::Object}}}},
      {"then", {{schema::Version::Draft04, {schema::Wraps::Schema}}}},
      {"unevaluatedItems", {{schema::Version::Draft2020_12, {schema::Wraps::Schema}}}},
      {"unevaluatedProperties", {{schema::Version::Draft2020_12, {schema::Wraps::Schema}}}},
  };

public:
  ConstraintFactory() = default;

  explicit ConstraintFactory(
      Keywords<MakeConstraint> const & user_keywords,
      Keywords<Versioned<MakeConstraint>> const & user_versioned_keywords = {}) {
    constraints_.insert(constraints_.end(), user_keywords.begin(), user_keywords.end());
    versioned_constraints_.insert(versioned_constraints_.end(), user_versioned_keywords.begin(),
                                  user_versioned_keywords.end());
  }

  bool is_post_constraint(std::string_view key) const {
    return key == "unevaluatedItems" || key == "unevaluatedProperties";
  }

  Keywords<std::set<schema::Wraps>> keywords(schema::Version version) const {
    Keywords<std::set<schema::Wraps>> rval;
    for (auto const & [key, versions] : keywords_) {
      if (auto it = versions.lower_bound(version); it != versions.end()) {
        rval.emplace(key, it->second);
      }
    }
    return rval;
  }

  MakeConstraint operator()(std::string_view key, schema::Version version) const {
    if (auto it = constraints_.find(key); it != constraints_.end()) {
      return it->second;
    }
    if (auto it = versioned_constraints_.find(key); it != versioned_constraints_.end()) {
      if (auto vit = it->second.lower_bound(version); vit != it->second.end()) {
        return vit->second;
      }
    }
    return nullptr;
  }

  // SECTION: Untyped Constraints

  static pConstraint warnUnimplemented(detail::ParserContext<A> const & context) {
    std::cerr << "Unimplemented constraint " << context.where << "\n";
    return nullptr;
  }

  static pConstraint fatalUnimplemented(detail::ParserContext<A> const & context) {
    JVALIDATE_THROW(std::runtime_error, "Unimplemented constraint " << context.where);
  }

  static auto type(detail::ParserContext<A> const & context) {
    static std::unordered_map<std::string_view, adapter::Type> const s_type_names{
        {"null", adapter::Type::Null},       {"boolean", adapter::Type::Boolean},
        {"integer", adapter::Type::Integer}, {"number", adapter::Type::Number},
        {"string", adapter::Type::String},   {"array", adapter::Type::Array},
        {"object", adapter::Type::Object},
    };

    auto to_type = [](std::string_view type) {
      EXPECT_M(s_type_names.contains(type), "Unknown type " << type);
      return s_type_names.at(type);
    };

    adapter::Type const type = context.schema.type();
    if (type == adapter::Type::String) {
      return std::make_unique<constraint::TypeConstraint>(to_type(context.schema.as_string()));
    }

    EXPECT(type == adapter::Type::Array);
    std::set<adapter::Type> types;
    for (auto subschema : context.schema.as_array()) {
      types.insert(to_type(subschema.as_string()));
    }
    return std::make_unique<constraint::TypeConstraint>(types);
  }

  static pConstraint ifThenElse(detail::ParserContext<A> const & context) {
    schema::Node const * then_ = context.fixed_schema(true);
    if (context.parent->contains("then")) {
      then_ = context.neighbor("then").node();
    }

    schema::Node const * else_ = context.fixed_schema(true);
    if (context.parent->contains("else")) {
      else_ = context.neighbor("else").node();
    }

    return std::make_unique<constraint::ConditionalConstraint>(context.node(), then_, else_);
  }

  static auto isInEnumuration(detail::ParserContext<A> const & context) {
    EXPECT(context.schema.type() == adapter::Type::Array);

    std::vector<std::unique_ptr<adapter::Const const>> rval;
    for (auto subschema : context.schema.as_array()) {
      rval.push_back(subschema.freeze());
    }

    return std::make_unique<constraint::EnumConstraint>(std::move(rval));
  }

  static auto isConstant(detail::ParserContext<A> const & context) {
    return std::make_unique<constraint::EnumConstraint>(context.schema.freeze());
  }

  static auto allOf(detail::ParserContext<A> const & context) {
    EXPECT(context.schema.type() == adapter::Type::Array);

    std::vector<schema::Node const *> rval;
    size_t index = 0;
    for (auto subschema : context.schema.as_array()) {
      rval.push_back(context.child(subschema, index).node());
      ++index;
    }

    return std::make_unique<constraint::AllOfConstraint>(rval);
  }

  static auto anyOf(detail::ParserContext<A> const & context) {
    EXPECT(context.schema.type() == adapter::Type::Array);

    std::vector<schema::Node const *> rval;
    size_t index = 0;
    for (auto subschema : context.schema.as_array()) {
      rval.push_back(context.child(subschema, index).node());
      ++index;
    }

    return std::make_unique<constraint::AnyOfConstraint>(rval);
  }

  static auto oneOf(detail::ParserContext<A> const & context) {
    EXPECT(context.schema.type() == adapter::Type::Array);

    std::vector<schema::Node const *> rval;
    size_t index = 0;
    for (auto subschema : context.schema.as_array()) {
      rval.push_back(context.child(subschema, index).node());
      ++index;
    }

    return std::make_unique<constraint::OneOfConstraint>(rval);
  }

  static auto isNot(detail::ParserContext<A> const & context) {
    return std::make_unique<constraint::NotConstraint>(context.node());
  }

  // SECTION: Numeric Constraints

  static auto minimum(detail::ParserContext<A> const & context) {
    double value = context.schema.as_number();
    if (context.version < schema::Version::Draft06 &&
        context.parent->contains("exclusiveMinimum")) {
      auto exclusive = (*context.parent)["exclusiveMinimum"];
      EXPECT(exclusive.type() == adapter::Type::Boolean);
      return std::make_unique<constraint::MinimumConstraint>(value, exclusive.as_boolean());
    }
    return std::make_unique<constraint::MinimumConstraint>(value, false);
  }

  static pConstraint exclusiveMinimum(detail::ParserContext<A> const & context) {
    double value = context.schema.as_number();
    return std::make_unique<constraint::MinimumConstraint>(value, true);
  }

  static auto maximum(detail::ParserContext<A> const & context) {
    double value = context.schema.as_number();
    if (context.version < schema::Version::Draft06 &&
        context.parent->contains("exclusiveMaximum")) {
      auto exclusive = (*context.parent)["exclusiveMaximum"];
      EXPECT(exclusive.type() == adapter::Type::Boolean);
      return std::make_unique<constraint::MaximumConstraint>(value, exclusive.as_boolean());
    }
    return std::make_unique<constraint::MaximumConstraint>(value, false);
  }

  static pConstraint exclusiveMaximum(detail::ParserContext<A> const & context) {
    double value = context.schema.as_number();
    return std::make_unique<constraint::MaximumConstraint>(value, true);
  }

  static auto multipleOf(detail::ParserContext<A> const & context) {
    double value = context.schema.as_number();
    return std::make_unique<constraint::MultipleOfConstraint>(value);
  }

  // SECTION: String Constraints

  static auto minLength(detail::ParserContext<A> const & context) {
    EXPECT(context.schema.type() == adapter::Type::Integer ||
           context.schema.type() == adapter::Type::Number);
    return std::make_unique<constraint::MinLengthConstraint>(context.schema.as_integer());
  }

  static auto maxLength(detail::ParserContext<A> const & context) {
    EXPECT(context.schema.type() == adapter::Type::Integer ||
           context.schema.type() == adapter::Type::Number);
    return std::make_unique<constraint::MaxLengthConstraint>(context.schema.as_integer());
  }

  static auto pattern(detail::ParserContext<A> const & context) {
    return std::make_unique<constraint::PatternConstraint>(context.schema.as_string());
  }

  // SECTION: Array Constraints

  static auto contains(detail::ParserContext<A> const & context) {
    if (context.version < schema::Version::Draft2019_09) {
      return std::make_unique<constraint::ContainsConstraint>(context.node());
    }

    std::optional<size_t> maximum;
    std::optional<size_t> minimum;
    if (context.parent->contains("maxContains")) {
      maximum = (*context.parent)["maxContains"].as_integer();
    }
    if (context.parent->contains("minContains")) {
      minimum = (*context.parent)["minContains"].as_integer();
    }

    return std::make_unique<constraint::ContainsConstraint>(context.node(), minimum, maximum);
  }

  static auto minItems(detail::ParserContext<A> const & context) {
    EXPECT(context.schema.type() == adapter::Type::Integer ||
           context.schema.type() == adapter::Type::Number);
    return std::make_unique<constraint::MinItemsConstraint>(context.schema.as_integer());
  }

  static auto maxItems(detail::ParserContext<A> const & context) {
    EXPECT(context.schema.type() == adapter::Type::Integer ||
           context.schema.type() == adapter::Type::Number);
    return std::make_unique<constraint::MaxItemsConstraint>(context.schema.as_integer());
  }

  static auto prefixItems(detail::ParserContext<A> const & context) {
    EXPECT(context.schema.type() == adapter::Type::Array);

    std::vector<schema::Node const *> rval;
    size_t index = 0;
    for (auto subschema : context.schema.as_array()) {
      rval.push_back(context.child(subschema, index).node());
      ++index;
    }

    return std::make_unique<constraint::TupleConstraint>(rval);
  }

  static auto additionalItemsAfter(detail::ParserContext<A> const & context, size_t n) {
    using C = constraint::AdditionalItemsConstraint;
    if (context.version < schema::Version::Draft06 &&
        context.schema.type() == adapter::Type::Boolean) {
      return std::make_unique<C>(context.always(), n);
    }

    return std::make_unique<C>(context.node(), n);
  }

  static pConstraint additionalItems(detail::ParserContext<A> const & context) {
    std::string const prefix =
        context.version >= schema::Version::Draft2020_12 ? "prefixItems" : "items";

    Object const & parent = *context.parent;
    // Before Draft 2020-12, the "items" could be either a subschema or a tuple.
    // When not provided, we therefore treat it as an "accept-all" schema, and
    // thus will never have additionalItems to process. Similarly - if it is an
    // Object, then it must act on all items.
    if (context.version < schema::Version::Draft2020_12 &&
        (not parent.contains(prefix) || parent[prefix].type() == adapter::Type::Object)) {
      return nullptr;
    }

    return additionalItemsAfter(context, parent[prefix].array_size());
  }

  static pConstraint itemsTupleOrVector(detail::ParserContext<A> const & context) {
    if (context.schema.type() == adapter::Type::Array) {
      return prefixItems(context);
    }

    return additionalItemsAfter(context, 0);
  }

  static auto unevaluatedItems(detail::ParserContext<A> const & context) {
    return std::make_unique<constraint::UnevaluatedItemsConstraint>(context.node());
  }

  static pConstraint uniqueItems(detail::ParserContext<A> const & context) {
    EXPECT(context.schema.type() == adapter::Type::Boolean);
    if (not context.schema.as_boolean()) {
      return nullptr;
    }

    return std::make_unique<constraint::UniqueItemsConstraint>();
  }

  // SECTION: Object Constraints

  static auto required(detail::ParserContext<A> const & context) {
    EXPECT(context.schema.type() == adapter::Type::Array);

    std::unordered_set<std::string> rval;
    for (auto subschema : context.schema.as_array()) {
      EXPECT(subschema.type() == adapter::Type::String);
      rval.insert(subschema.as_string());
    }

    return std::make_unique<constraint::RequiredConstraint>(rval);
  }

  static auto minProperties(detail::ParserContext<A> const & context) {
    EXPECT(context.schema.type() == adapter::Type::Integer ||
           context.schema.type() == adapter::Type::Number);
    return std::make_unique<constraint::MinPropertiesConstraint>(context.schema.as_integer());
  }

  static auto maxProperties(detail::ParserContext<A> const & context) {
    EXPECT(context.schema.type() == adapter::Type::Integer ||
           context.schema.type() == adapter::Type::Number);
    return std::make_unique<constraint::MaxPropertiesConstraint>(context.schema.as_integer());
  }

  static auto patternProperties(detail::ParserContext<A> const & context) {
    EXPECT(context.schema.type() == adapter::Type::Object);

    std::vector<std::pair<std::string, schema::Node const *>> rval;
    for (auto [prop, subschema] : context.schema.as_object()) {
      rval.emplace_back(prop, context.child(subschema, prop).node());
    }

    return std::make_unique<constraint::PatternPropertiesConstraint>(rval);
  }

  static auto properties(detail::ParserContext<A> const & context) {
    EXPECT(context.schema.type() == adapter::Type::Object);

    std::map<std::string, schema::Node const *> rval;
    for (auto [prop, subschema] : context.schema.as_object()) {
      rval.emplace(prop, context.child(subschema, prop).node());
    }

    return std::make_unique<constraint::PropertiesConstraint>(rval);
  }

  static auto propertyNames(detail::ParserContext<A> const & context) {
    return std::make_unique<constraint::PropertyNamesConstraint>(context.node());
  }

  static auto unevaluatedProperties(detail::ParserContext<A> const & context) {
    return std::make_unique<constraint::UnevaluatedPropertiesConstraint>(context.node());
  }

  static auto additionalProperties(detail::ParserContext<A> const & context) {
    std::unordered_set<std::string> properties;
    std::vector<std::string> patterns;

    Object const & parent = *context.parent;
    if (parent.contains("properties")) {
      for (auto [key, _] : parent["properties"].as_object()) {
        properties.insert(key);
      }
    }
    if (parent.contains("patternProperties")) {
      for (auto [key, _] : parent["patternProperties"].as_object()) {
        patterns.push_back(key);
      }
    }

    using C = constraint::AdditionalPropertiesConstraint;
    if (context.version < schema::Version::Draft06 &&
        context.schema.type() == adapter::Type::Boolean) {
      return std::make_unique<C>(context.always(), properties, patterns);
    }

    return std::make_unique<C>(context.node(), properties, patterns);
  }

  static auto dependencies(detail::ParserContext<A> const & context) {
    EXPECT(context.schema.type() == adapter::Type::Object);

    std::map<std::string, schema::Node const *> schemas;
    std::map<std::string, std::unordered_set<std::string>> required;
    for (auto [prop, subschema] : context.schema.as_object()) {
      if (subschema.type() == adapter::Type::Array) {
        for (auto key : subschema.as_array()) {
          EXPECT(key.type() == adapter::Type::String);
          required[prop].insert(key.as_string());
        }
      } else {
        schemas.emplace(prop, context.child(subschema, prop).node());
      }
    }

    return std::make_unique<constraint::DependenciesConstraint>(schemas, required);
  }

  static auto dependentSchemas(detail::ParserContext<A> const & context) {
    EXPECT(context.schema.type() == adapter::Type::Object);

    std::map<std::string, schema::Node const *> rval;
    for (auto [prop, subschema] : context.schema.as_object()) {
      rval.emplace(prop, context.child(subschema, prop).node());
    }

    return std::make_unique<constraint::DependenciesConstraint>(rval);
  }

  static auto dependentRequired(detail::ParserContext<A> const & context) {
    EXPECT(context.schema.type() == adapter::Type::Object);

    std::map<std::string, std::unordered_set<std::string>> rval;
    for (auto [prop, subschema] : context.schema.as_object()) {
      EXPECT(subschema.type() == adapter::Type::Array);
      for (auto key : subschema.as_array()) {
        EXPECT(key.type() == adapter::Type::String);
        rval[prop].insert(key.as_string());
      }
    }

    return std::make_unique<constraint::DependenciesConstraint>(rval);
  }
};
}