json-validator/include/jvalidate/validation_visitor.h

#pragma once

#include <tuple>
#include <type_traits>
#include <unordered_map>

#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/constraint/visitor.h>
#include <jvalidate/detail/enumerate.h>
#include <jvalidate/detail/expect.h>
#include <jvalidate/detail/iostream.h>
#include <jvalidate/detail/number.h>
#include <jvalidate/detail/pointer.h>
#include <jvalidate/detail/scoped_state.h>
#include <jvalidate/forward.h>
#include <jvalidate/schema.h>
#include <jvalidate/status.h>
#include <jvalidate/validation_config.h>
#include <jvalidate/validation_result.h>

#define VISITED(type) std::get<std::unordered_set<type>>(*visited_)

#define NOOP_UNLESS_TYPE(etype)                                                                    \
  RETURN_UNLESS(adapter::Type::etype == document_.type(), Status::Noop)

#define BREAK_EARLY_IF_NO_RESULT_TREE()                                                            \
  do {                                                                                             \
    if (rval == Status::Reject and not result_ and not visited_) {                                 \
      break;                                                                                       \
    }                                                                                              \
  } while (false)

namespace jvalidate {
template <Adapter A, RegexEngine RE>
class ValidationVisitor : public constraint::ConstraintVisitor {
private:
  using VisitedAnnotation = std::tuple<std::unordered_set<size_t>, std::unordered_set<std::string>>;
  JVALIDATE_TRIBOOL_TYPE(StoreResults, ForValid, ForInvalid, ForAnything);

private:
  A document_;
  detail::Pointer where_;
  detail::Pointer schema_path_;

  schema::Node const * schema_;

  ValidationResult * result_;

  ValidationConfig const & cfg_;
  std::unordered_map<std::string, RE> & regex_cache_;

  mutable VisitedAnnotation * visited_ = nullptr;
  mutable StoreResults tracking_ = StoreResults::ForInvalid;

public:
  ValidationVisitor(A const & json, schema::Node const & schema, ValidationConfig const & cfg,
                    std::unordered_map<std::string, RE> & regex_cache, ValidationResult * result)
      : document_(json), schema_(&schema), result_(result), cfg_(cfg), regex_cache_(regex_cache) {}

  Status visit(constraint::TypeConstraint const & cons) const {
    adapter::Type const type = document_.type();

    for (adapter::Type const accept : cons.types) {
      if (type == accept) {
        return result(Status::Accept, type, " is in types [", cons.types, "]");
      }
      if (accept == adapter::Type::Number && type == adapter::Type::Integer) {
        return result(Status::Accept, type, " is in types [", cons.types, "]");
      }
      if (accept == adapter::Type::Integer && type == adapter::Type::Number &&
          detail::is_json_integer(document_.as_number())) {
        return result(Status::Accept, type, " is in types [", cons.types, "]");
      }
    }
    return result(Status::Reject, type, " is not in types [", cons.types, "]");
  }

  Status visit(constraint::ExtensionConstraint const & cons) const {
    return cons.validate(document_, where_, result_);
  }

  Status visit(constraint::EnumConstraint const & cons) const {
    auto is_equal = [this](auto const & frozen) {
      return document_.equals(frozen, cfg_.strict_equality);
    };
    for (auto const & [index, option] : detail::enumerate(cons.enumeration)) {
      if (option->apply(is_equal)) {
        return result(Status::Accept, index);
      }
    }
    return Status::Reject;
  }

  Status visit(constraint::AllOfConstraint const & cons) const {
    Status rval = Status::Accept;

    std::set<size_t> unmatched;
    for (auto const & [index, subschema] : detail::enumerate(cons.children)) {
      if (auto stat = validate_subschema(subschema, index); stat == Status::Reject) {
        rval = Status::Reject;
        unmatched.insert(index);
      }
      BREAK_EARLY_IF_NO_RESULT_TREE();
    }

    if (rval == Status::Reject) {
      return result(rval, "does not validate subschemas ", unmatched);
    }
    return result(rval, "validates all subschemas");
  }

  Status visit(constraint::AnyOfConstraint const & cons) const {
    std::optional<size_t> first_validated;
    for (auto const & [index, subschema] : detail::enumerate(cons.children)) {
      if (validate_subschema(subschema, index)) {
        first_validated = index;
      }
      if (not visited_ && first_validated.has_value()) {
        break;
      }
    }

    if (first_validated.has_value()) {
      return result(Status::Accept, "validates subschema ", *first_validated);
    }
    return result(Status::Reject, "validates none of the subschemas");
  }

  Status visit(constraint::OneOfConstraint const & cons) const {
    std::set<size_t> matches;

    for (auto const & [index, subschema] : detail::enumerate(cons.children)) {
      scoped_state(tracking_, StoreResults::ForAnything);
      if (validate_subschema(subschema, index)) {
        matches.insert(index);
      }
    }

    if (matches.size() == 1) {
      return result(Status::Accept, "validates subschema ", *matches.begin());
    }
    return result(Status::Reject, "validates multiple subschemas ", matches);
  }

  Status visit(constraint::NotConstraint const & cons) const {
    scoped_state(visited_, nullptr);
    scoped_state(tracking_, !tracking_);
    bool const rejected = validate_subschema(cons.child) == Status::Reject;

    return rejected;
  }

  Status visit(constraint::ConditionalConstraint const & cons) const {
    Status const if_true = [this, &cons]() {
      scoped_state(tracking_, StoreResults::ForAnything);
      return validate_subschema(cons.if_constraint);
    }();
    if (if_true) {
      return validate_subschema(cons.then_constraint, detail::parent, "then");
    }
    return validate_subschema(cons.else_constraint, detail::parent, "else");
  }

  Status visit(constraint::MaximumConstraint const & cons) const {
    switch (document_.type()) {
    case adapter::Type::Integer:
      if (int64_t value = document_.as_integer(); not cons(value)) {
        return result(Status::Reject, value, cons.exclusive ? " >= " : " > ", cons.value);
      } else {
        return result(Status::Accept, value, cons.exclusive ? " < " : " <= ", cons.value);
      }
    case adapter::Type::Number:
      if (double value = document_.as_number(); not cons(value)) {
        return result(Status::Reject, value, cons.exclusive ? " >= " : " > ", cons.value);
      } else {
        return result(Status::Accept, value, cons.exclusive ? " < " : " <= ", cons.value);
      }
    default:
      return Status::Noop;
    }
  }

  Status visit(constraint::MinimumConstraint const & cons) const {
    switch (document_.type()) {
    case adapter::Type::Integer:
      if (int64_t value = document_.as_integer(); not cons(value)) {
        return result(Status::Reject, value, cons.exclusive ? " <= " : " < ", cons.value);
      } else {
        return result(Status::Accept, value, cons.exclusive ? " > " : " >= ", cons.value);
      }
    case adapter::Type::Number:
      if (double value = document_.as_number(); not cons(value)) {
        return result(Status::Reject, value, cons.exclusive ? " <= " : " < ", cons.value);
      } else {
        return result(Status::Accept, value, cons.exclusive ? " > " : " >= ", cons.value);
      }
    default:
      return Status::Noop;
    }
  }

  Status visit(constraint::MultipleOfConstraint const & cons) const {
    adapter::Type const type = document_.type();
    RETURN_UNLESS(type == adapter::Type::Number || type == adapter::Type::Integer, Status::Noop);

    if (double value = document_.as_number(); not cons(value)) {
      return result(Status::Reject, value, " is not a multiple of ", cons.value);
    } else {
      return result(Status::Accept, value, " is a multiple of ", cons.value);
    }
  }

  Status visit(constraint::MaxLengthConstraint const & cons) const {
    NOOP_UNLESS_TYPE(String);
    std::string const str = document_.as_string();
    if (int64_t len = detail::length(str); len > cons.value) {
      return result(Status::Reject, "'", str, "' of length ", len, " is >", cons.value);
    } else {
      return result(Status::Accept, "'", str, "' of length ", len, " is <=", cons.value);
    }
  }

  Status visit(constraint::MinLengthConstraint const & cons) const {
    NOOP_UNLESS_TYPE(String);
    std::string const str = document_.as_string();
    if (int64_t len = detail::length(str); len < cons.value) {
      return result(Status::Reject, "'", str, "' of length ", len, " is <", cons.value);
    } else {
      return result(Status::Accept, "'", str, "' of length ", len, " is >=", cons.value);
    }
  }

  Status visit(constraint::PatternConstraint const & cons) const {
    NOOP_UNLESS_TYPE(String);

    RE const & regex = regex_cache_.try_emplace(cons.regex, cons.regex).first->second;
    std::string const str = document_.as_string();
    if (regex.search(str)) {
      return result(Status::Accept, "'", str, "' matches pattern /", cons.regex, "/");
    }
    return result(Status::Reject, "'", str, "' does not match pattern /", cons.regex, "/");
  }

  Status visit(constraint::FormatConstraint const & cons) const {
    // https://json-schema.org/draft/2020-12/draft-bhutton-json-schema-validation-01#name-defined-formats
    NOOP_UNLESS_TYPE(String);

    // TODO(samjaffe): annotate(cons.format)
    annotate(cons.format);
    if (not cfg_.validate_format && not cons.is_assertion) {
      return true;
    }

    return result(Status::Reject, " is unimplemented");
  }

  Status visit(constraint::AdditionalItemsConstraint const & cons) const {
    NOOP_UNLESS_TYPE(Array);

    auto array = document_.as_array();

    Status rval = Status::Accept;
    for (size_t i = cons.applies_after_nth; i < array.size(); ++i) {
      rval &= validate_subschema_on(cons.subschema, array[i], i);
      BREAK_EARLY_IF_NO_RESULT_TREE();
    }

    return rval;
  }

  Status visit(constraint::ContainsConstraint const & cons) const {
    NOOP_UNLESS_TYPE(Array);

    auto array = document_.as_array();
    size_t const minimum = cons.minimum.value_or(1);
    size_t const maximum = cons.maximum.value_or(array.size());
    size_t matches = 0;
    for (size_t i = 0; i < array.size(); ++i) {
      if (validate_subschema_on(cons.subschema, array[i], i)) {
        ++matches;
      }
    }

    if (matches < minimum) {
      return result(Status::Reject, "array contains <", minimum, " matching elements");
    }
    if (matches > maximum) {
      return result(Status::Reject, "array contains >", maximum, " matching elements");
    }
    return Status::Accept;
  }

  Status visit(constraint::MaxItemsConstraint const & cons) const {
    NOOP_UNLESS_TYPE(Array);
    if (size_t size = document_.array_size(); size > cons.value) {
      return result(Status::Reject, "array of size ", size, " is >", cons.value);
    } else {
      return result(Status::Accept, "array of size ", size, " is <=", cons.value);
    }
  }

  Status visit(constraint::MinItemsConstraint const & cons) const {
    NOOP_UNLESS_TYPE(Array);
    if (size_t size = document_.array_size(); size < cons.value) {
      return result(Status::Reject, "array of size ", size, " is <", cons.value);
    } else {
      return result(Status::Accept, "array of size ", size, " is >=", cons.value);
    }
  }

  Status visit(constraint::TupleConstraint const & cons) const {
    NOOP_UNLESS_TYPE(Array);

    Status rval = Status::Accept;

    auto array = document_.as_array();
    size_t const n = std::min(cons.items.size(), array.size());
    for (size_t i = 0; i < n; ++i) {
      rval &= validate_subschema_on(cons.items[i], array[i], i);
      BREAK_EARLY_IF_NO_RESULT_TREE();
    }

    return rval;
  }

  Status visit(constraint::UniqueItemsConstraint const & cons) const {
    NOOP_UNLESS_TYPE(Array);

    if constexpr (std::totally_ordered<A>) {
      std::map<A, size_t> cache;
      for (auto const & [index, elem] : detail::enumerate(document_.as_array())) {
        if (auto [it, created] = cache.emplace(elem, index); not created) {
          return result(Status::Reject, "items ", it->second, " and ", index, " are equal");
        }
      }
    } else {
      auto array = document_.as_array();
      for (size_t i = 0; i < array.size(); ++i) {
        for (size_t j = i + 1; j < array.size(); ++j) {
          if (array[i].equals(array[j], true)) {
            return result(Status::Reject, "items ", i, " and ", j, " are equal");
          }
        }
      }
    }

    return result(Status::Accept, "all array items are unique");
  }

  Status visit(constraint::AdditionalPropertiesConstraint const & cons) const {
    NOOP_UNLESS_TYPE(Object);

    auto matches_any_pattern = [this, &cons](std::string const & key) {
      for (auto & pattern : cons.patterns) {
        RE const & regex = regex_cache_.try_emplace(pattern, pattern).first->second;
        if (regex.search(key)) {
          return true;
        }
      }
      return false;
    };

    Status rval = Status::Accept;
    for (auto const & [key, elem] : document_.as_object()) {
      if (not cons.properties.contains(key) && not matches_any_pattern(key)) {
        rval &= validate_subschema_on(cons.subschema, elem, key);
      }
      BREAK_EARLY_IF_NO_RESULT_TREE();
    }

    return rval;
  }

  Status visit(constraint::DependenciesConstraint const & cons) const {
    NOOP_UNLESS_TYPE(Object);

    auto object = document_.as_object();
    Status rval = Status::Accept;
    for (auto const & [key, subschema] : cons.subschemas) {
      if (not object.contains(key)) {
        continue;
      }

      rval &= validate_subschema(subschema, key);
      BREAK_EARLY_IF_NO_RESULT_TREE();
    }

    for (auto [key, required] : cons.required) {
      if (not object.contains(key)) {
        continue;
      }

      for (auto const & [key, _] : object) {
        required.erase(key);
      }

      rval &= required.empty();
      BREAK_EARLY_IF_NO_RESULT_TREE();
    }

    return rval;
  }

  Status visit(constraint::MaxPropertiesConstraint const & cons) const {
    NOOP_UNLESS_TYPE(Object);
    if (size_t size = document_.object_size(); size > cons.value) {
      return result(Status::Reject, "object of size ", size, " is >", cons.value);
    } else {
      return result(Status::Accept, "object of size ", size, " is <=", cons.value);
    }
  }

  Status visit(constraint::MinPropertiesConstraint const & cons) const {
    NOOP_UNLESS_TYPE(Object);
    if (size_t size = document_.object_size(); size < cons.value) {
      return result(Status::Reject, "object of size ", size, " is <", cons.value);
    } else {
      return result(Status::Accept, "object of size ", size, " is >=", cons.value);
    }
  }

  Status visit(constraint::PatternPropertiesConstraint const & cons) const {
    NOOP_UNLESS_TYPE(Object);

    Status rval = Status::Accept;
    for (auto const & [pattern, subschema] : cons.properties) {
      RE const & regex = regex_cache_.try_emplace(pattern, pattern).first->second;
      for (auto const & [key, elem] : document_.as_object()) {
        if (regex.search(key)) {
          rval &= validate_subschema_on(subschema, elem, key);
        }
        BREAK_EARLY_IF_NO_RESULT_TREE();
      }
    }

    return rval;
  }

  Status visit(constraint::PropertiesConstraint const & cons) const {
    NOOP_UNLESS_TYPE(Object);

    Status rval = Status::Accept;
    auto object = document_.as_object();

    if constexpr (MutableAdapter<A>) {
      for (auto const & [key, subschema] : cons.properties) {
        auto const * default_value = subschema->default_value();
        if (default_value && not object.contains(key)) {
          object.assign(key, *default_value);
        }
      }
    }

    for (auto const & [key, elem] : object) {
      if (auto it = cons.properties.find(key); it != cons.properties.end()) {
        rval &= validate_subschema_on(it->second, elem, key);
      }
      BREAK_EARLY_IF_NO_RESULT_TREE();
    }

    return rval;
  }

  Status visit(constraint::PropertyNamesConstraint const & cons) const {
    NOOP_UNLESS_TYPE(Object);

    Status rval = Status::Accept;
    for (auto const & [key, _] : document_.as_object()) {
      // TODO(samjaffe): Should we prefer a std::string adapter like valijson?
      typename A::value_type key_json{key};
      rval &= validate_subschema_on(cons.key_schema, A(key_json), std::string("$$key"));
    }
    return rval;
  }

  Status visit(constraint::RequiredConstraint const & cons) const {
    NOOP_UNLESS_TYPE(Object);

    auto required = cons.properties;
    for (auto const & [key, _] : document_.as_object()) {
      required.erase(key);
    }

    if (required.empty()) {
      return result(Status::Accept, "contains all required properties ", cons.properties);
    }

    return result(Status::Reject, "missing required properties ", required);
  }

  Status visit(constraint::UnevaluatedItemsConstraint const & cons) const {
    NOOP_UNLESS_TYPE(Array);
    if (not visited_) {
      return Status::Reject;
    }

    Status rval = Status::Accept;
    auto array = document_.as_array();
    for (size_t i = 0; i < array.size(); ++i) {
      if (not VISITED(size_t).contains(i)) {
        rval &= validate_subschema_on(cons.subschema, array[i], i);
      }
      BREAK_EARLY_IF_NO_RESULT_TREE();
    }

    return rval;
  }

  Status visit(constraint::UnevaluatedPropertiesConstraint const & cons) const {
    NOOP_UNLESS_TYPE(Object);
    if (not visited_) {
      return Status::Reject;
    }

    Status rval = Status::Accept;
    for (auto const & [key, elem] : document_.as_object()) {
      if (not VISITED(std::string).contains(key)) {
        rval &= validate_subschema_on(cons.subschema, elem, key);
      }
      BREAK_EARLY_IF_NO_RESULT_TREE();
    }

    return rval;
  }

  Status validate() {
    if (std::optional<std::string> const & reject = schema_->rejects_all()) {
      if (should_annotate(Status::Reject) && result_) {
        result_->error(where_, schema_path_, "", *reject);
      }
      return Status::Reject;
    }

    if (schema_->accepts_all()) {
      // An accept-all schema is not No-Op for the purpose of unevaluated*
      return Status::Accept;
    }

    VisitedAnnotation annotate;
    if (schema_->requires_result_context() and not visited_) {
      visited_ = &annotate;
    }

    Status rval = Status::Noop;
    if (std::optional<schema::Node const *> ref = schema_->reference_schema()) {
      rval = validate_subschema(*ref, "$ref");
    }

    detail::Pointer const current_schema = schema_path_;
    for (auto const & [key, p_constraint] : schema_->constraints()) {
      BREAK_EARLY_IF_NO_RESULT_TREE();
      schema_path_ = current_schema / key;
      rval &= p_constraint->accept(*this);
    }

    for (auto const & [key, p_constraint] : schema_->post_constraints()) {
      BREAK_EARLY_IF_NO_RESULT_TREE();
      schema_path_ = current_schema / key;
      rval &= p_constraint->accept(*this);
    }

    return rval;
  }

private:
  template <typename S>
  requires(std::is_constructible_v<std::string, S>) static std::string fmt(S const & str) {
    return str;
  }

  static std::string fmt(auto const &... args) {
    std::stringstream ss;
    using ::jvalidate::operator<<;
    [[maybe_unused]] int _[] = {(ss << args, 0)...};
    return ss.str();
  }

  static std::vector<std::string> fmtlist(auto const & arg) {
    std::vector<std::string> strs;
    for (auto const & elem : arg) {
      strs.push_back(fmt(elem));
    }
    return strs;
  }

  bool should_annotate(Status stat) const {
    switch (tracking_) {
    case StoreResults::ForAnything:
      return stat != Status::Noop;
    case StoreResults::ForValid:
      return stat == Status::Accept;
    case StoreResults::ForInvalid:
      return stat == Status::Reject;
    }
  }

#define ANNOTATION_HELPER(name, ADD, FMT)                                                          \
  void name(auto const &... args) const {                                                          \
    if (not result_) {                                                                             \
      return;                                                                                      \
    }                                                                                              \
    if (schema_path_.empty()) {                                                                    \
      result_->ADD(where_, schema_path_, "", FMT(args...));                                        \
    } else {                                                                                       \
      result_->ADD(where_, schema_path_.parent(), schema_path_.back(), FMT(args...));              \
    }                                                                                              \
  }

  ANNOTATION_HELPER(error, error, fmt)
  ANNOTATION_HELPER(annotate, annotate, fmt)
  ANNOTATION_HELPER(annotate_list, annotate, fmtlist)

  Status result(Status stat, auto const &... args) const {
    return (should_annotate(stat) ? error(args...) : void(), stat);
  }

  template <typename C> static void merge_visited(C & to, C const & from) {
    to.insert(from.begin(), from.end());
  }

  template <typename... K>
  Status validate_subschema(constraint::Constraint::SubConstraint const & subschema,
                            K const &... keys) const {
    if (schema::Node const * const * ppschema = std::get_if<0>(&subschema)) {
      return validate_subschema(*ppschema, keys...);
    } else {
      return std::get<1>(subschema)->accept(*this);
    }
  }

  template <typename... K>
  Status validate_subschema(schema::Node const * subschema, K const &... keys) const {
    VisitedAnnotation annotate;

    ValidationVisitor next = *this;
    ((next.schema_path_ /= keys), ...);
    std::tie(next.schema_, next.visited_) =
        std::forward_as_tuple(subschema, visited_ ? &annotate : nullptr);

    Status rval = next.validate();

    if (rval == Status::Accept and visited_) {
      merge_visited(std::get<0>(*visited_), std::get<0>(annotate));
      merge_visited(std::get<1>(*visited_), std::get<1>(annotate));
    }
    return rval;
  }

  template <typename K>
  Status validate_subschema_on(schema::Node const * subschema, A const & document,
                               K const & key) const {
    ValidationResult result;

    ValidationVisitor next = *this;
    next.where_ /= key;
    std::tie(next.document_, next.schema_, next.result_, next.visited_) =
        std::forward_as_tuple(document, subschema, result_ ? &result : nullptr, nullptr);

    auto status = next.validate();
    if (status == Status::Accept and visited_) {
      VISITED(K).insert(key);
    }
    if (status == Status::Reject and result_) {
      result_->merge(std::move(result));
    }
    return status;
  }
};
}