json-validator/include/jvalidate/validation_result.h

#pragma once

#include <algorithm>
#include <cstdlib>
#include <map>
#include <ostream>
#include <string>
#include <utility>
#include <variant>
#include <vector>

#include <jvalidate/detail/pointer.h>
#include <jvalidate/forward.h>

namespace jvalidate {
class ValidationResult {
public:
  // Only allow ValidationVisitor to construct the elements of a validation result
  template <Adapter, RegexEngine, typename> friend class ValidationVisitor;

  using DocPointer = detail::Pointer;
  using SchemaPointer = detail::Pointer;
  using Annotation = std::variant<std::string, std::vector<std::string>>;

  /**
   * @brief The result info at any given (DocPointer, SchemaPointer) path.
   * The key for errors/annotations represents the leaf element of SchemaPointer
   * instead of including it in the map.
   *
   * This allows better locality of error info. For example:
   * {
   *   "valid": false,
   *   "evaluationPath": "/definitions/EvenPercent",
   *   "instanceLocation": "/foo/bar/percentages/2",
   *   "errors": {
   *     "max": "105 > 100",
   *     "multipleOf": "105 is not a multiple of 2"
   *   }
   * }
   */
  struct LocalResult {
    bool valid = true;
    std::map<std::string, Annotation> errors;
    std::map<std::string, Annotation> annotations;
  };

  static auto indent(size_t depth) { return std::string(depth * 2, ' '); }

private:
  bool valid_;
  std::map<DocPointer, std::map<SchemaPointer, LocalResult>> results_;

public:
  /**
   * @brief Writes this object to an osteam in the list format as described in
   * https://json-schema.org/blog/posts/interpreting-output
   * This means that the json-schema for a ValidationResult looks like this:
   * {
   *   "$defs": {
   *     "Pointer": {
   *       "format": "json-pointer",
   *       "type": "string"
   *     },
   *     "Annotation": {
   *       "items": { "type": "string" },
   *       "type": [ "string", "array" ]
   *     }
   *   },
   *   "properties": {
   *     "valid": { "type": "boolean" },
   *     "details": {
   *       "items": {
   *         "properties": {
   *           "valid": { "type": "boolean" },
   *           "evaluationPath": { "$ref": "#/$defs/Pointer" },
   *           "instanceLocation": { "$ref": "#/$defs/Pointer" },
   *           "annotations": { "$ref": "#/$defs/Annotation" },
   *           "errors": { "$ref": "#/$defs/Annotation" }
   *         }
   *         "type": "object"
   *       },
   *       "type": "array"
   *     }
   *   }
   *   "type": "object"
   * }
   */
  friend std::ostream & operator<<(std::ostream & os, ValidationResult const & result) {
    char const * div = "\n";
    os << "{\n" << indent(1) << R"("valid": )" << (result.valid_ ? "true" : "false") << ',' << '\n';
    os << indent(1) << R"("details": [)";
    for (auto const & [doc_path, by_schema] : result.results_) {
      for (auto const & [schema_path, local] : by_schema) {
        os << std::exchange(div, ",\n") << indent(2) << '{' << '\n';
        os << indent(3) << R"("valid": )" << (local.valid ? "true" : "false") << ',' << '\n';
        os << indent(3) << R"("evaluationPath": ")" << schema_path << '"' << ',' << '\n';
        os << indent(3) << R"("instanceLocation": ")" << doc_path << '"';
        print(os, local.annotations, "annotations", 3);
        print(os, local.errors, "errors", 3);
        os << '\n' << indent(2) << '}';
      }
    }
    return os << '\n' << indent(1) << ']' << '\n' << '}';
  }

  static void print(std::ostream & os, std::map<std::string, Annotation> const & named,
                    std::string_view name, int const depth) {
    if (named.empty()) {
      return;
    }
    os << ',' << '\n';
    os << indent(depth) << '"' << name << '"' << ':' << ' ' << '{' << '\n';
    char const * odiv = "";
    for (auto const & [key, anno] : named) {
      os << std::exchange(odiv, ",\n") << indent(depth + 1) << '"' << key << '"' << ':' << ' ';
      if (auto const * str = std::get_if<0>(&anno)) {
        os << '"' << *str << '"';
      } else if (std::vector<std::string> const * vec = std::get_if<1>(&anno)) {
        os << '[';
        char const * div = "\n";
        for (std::string const & elem : *vec) {
          os << std::exchange(div, ",\n") << indent(depth + 2) << '"' << elem << '"';
        }
        os << '\n' << indent(depth + 1) << ']';
      }
    }
    os << '\n' << indent(depth) << '}';
  }

  bool valid() const { return valid_; }

  /**
   * @brief Are there any validation details associated with the given document
   * location and schema section.
   *
   * @param where A path into the document being validated
   * @param schema_path The schema path (not counting the leaf element that
   * actually evaluates the document)
   *
   * @return true if the schema path has produced an annotation or error for the
   * document path
   */
  bool has(detail::Pointer const & where, detail::Pointer const & schema_path) const {
    return has(where) && results_.at(where).contains(schema_path);
  }

  /**
   * @brief Are there any validation details associated with the given document
   * location
   *
   * @param where A path into the document being validated
   *
   * @return true if any rule has produced an annotation or error for the
   * document path
   */
  bool has(detail::Pointer const & where) const { return results_.contains(where); }

  /**
   * @brief Extracts the annotation for requested document and schema location, if it exists
   *
   * @param where A path into the document being validated
   * @param schema_path The schema path, without its leaf element
   * @param name The leaf schema path (i.e. the rule being evaluated).
   * @pre name.empty() == schema_path.empty()
   *
   * @returns An Annotation for the given path info provided, or nullptr if no annotation exists
   */
  Annotation const * annotation(detail::Pointer const & where, detail::Pointer const & schema_path,
                                std::string const & name) const {
    if (not results_.contains(where)) {
      return nullptr;
    }
    auto const & by_schema = results_.at(where);
    if (not by_schema.contains(schema_path)) {
      return nullptr;
    }
    auto const & local = by_schema.at(schema_path);
    if (not local.annotations.contains(name)) {
      return nullptr;
    }
    return &local.annotations.at(name);
  }

  /**
   * @brief Extracts the error for requested document and schema location, if it exists
   *
   * @param where A path into the document being validated
   * @param schema_path The schema path, without its leaf element
   * @param name The leaf schema path (i.e. the rule being evaluated).
   * @pre name.empty() == schema_path.empty()
   *
   * @returns An Annotation for the given path info provided, or nullptr if no annotation exists
   */
  Annotation const * error(detail::Pointer const & where, detail::Pointer const & schema_path,
                           std::string const & name) const {
    if (not results_.contains(where)) {
      return nullptr;
    }
    auto const & by_schema = results_.at(where);
    if (not by_schema.contains(schema_path)) {
      return nullptr;
    }
    auto const & local = by_schema.at(schema_path);
    if (not local.errors.contains(name)) {
      return nullptr;
    }
    return &local.errors.at(name);
  }

  ValidationResult only_errors() const {
    ValidationResult rval;
    rval.valid_ = valid_;

    for (auto const & [doc, results] : results_) {
      for (auto const & [schema, result] : results) {
        if (!result.errors.empty()) {
          rval.results_[doc][schema] = result;
        }
      }
    }

    return rval;
  }

private:
  /**
   * @brief Transfer the contents of another ValidationResult into this one using
   * {@see std::map::merge} to transfer the data minimizing the need for copy/move.
   *
   * @param result The ValidationResult being consumed
   */
  void merge(ValidationResult && result) & {
    for (auto && [where, by_schema] : std::move(result).results_) {
      for (auto && [schema_path, local] : by_schema) {
        results_[where][schema_path].valid &= local.valid;
        results_[where][schema_path].annotations.merge(local.annotations);
        results_[where][schema_path].errors.merge(local.errors);
      }
    }
  }

  /**
   * @brief Declare that the document is accepted/rejected by the given schema
   *
   * @param where A path into the document being validated
   * @param schema_path The schema path
   * @param valid Is this location valid according to the schema
   */
  void valid(detail::Pointer const & where, detail::Pointer const & schema_path, bool valid) {
    if (has(where, schema_path)) {
      results_[where][schema_path].valid = valid;
    }
    if (where.empty() && schema_path.empty()) {
      valid_ = valid;
    }
  }

  /**
   * @brief Attach an error message for part of the document.
   * Because of the existance of things like "not" schemas, error() can also be
   * called to add an Annotation for a gate that is passed, but was within a
   * "not" schema.
   *
   * @param where A path into the document being validated
   * @param schema_path The schema path, without its leaf element
   * @param name The leaf schema path (i.e. the rule being evaluated).
   * @pre name.empty() == schema_path.empty()
   * @param message The annotation(s) being placed as an error
   */
  void error(detail::Pointer const & where, detail::Pointer const & schema_path,
             std::string const & name, Annotation message) {
    if (std::visit([](auto const & val) { return val.empty(); }, message)) {
      return;
    }
    std::visit([](auto & msg) { sanitize(msg); }, message);
    results_[where][schema_path].errors.emplace(name, std::move(message));
  }

  /**
   * @brief Attach some contextual annotations for part of the document
   *
   * @param where A path into the document being validated
   * @param schema_path The schema path, without its leaf element
   * @param name The leaf schema path (i.e. the rule being evaluated).
   * @pre name.empty() == schema_path.empty()
   * @param message The annotation(s) being placed for context
   */
  void annotate(detail::Pointer const & where, detail::Pointer const & schema_path,
                std::string const & name, Annotation message) {
    if (std::visit([](auto const & val) { return val.empty(); }, message)) {
      return;
    }
    std::visit([](auto & msg) { sanitize(msg); }, message);
    results_[where][schema_path].annotations.emplace(name, std::move(message));
  }

  /**
   * @brief Remove annotations that we added without knowing if they were
   * needed, now that we know that they are not required.
   *
   * @param where A path into the document being validated
   * @param schema_path The schema path to remove
   */
  void unannotate(detail::Pointer const & where, detail::Pointer const & schema_path) {
    results_[where].erase(schema_path);
  }

  static void sanitize(std::string & message) {
    for (auto it = message.begin(); it != message.end(); ++it) {
      if (*it == '"' || *it == '\\') {
        it = ++message.insert(it, '\\');
      }
    }
  }

  static void sanitize(std::vector<std::string> & message) {
    std::ranges::for_each(message, [](std::string & val) { sanitize(val); });
  }
};
}