#pragma once

#include <map>
#include <optional>
#include <string>
#include <unordered_set>
#include <utility>
#include <vector>

#include <jvalidate/constraint/constraint.h>
#include <jvalidate/forward.h>

namespace jvalidate::constraint {
class AdditionalPropertiesConstraint : public Constraint {
private:
  schema::Node const * subschema_;
  std::unordered_set<std::string> properties_;
  std::vector<std::string> patterns_;

public:
  AdditionalPropertiesConstraint(schema::Node const * subschema,
                                 std::unordered_set<std::string> const & properties,
                                 std::vector<std::string> const & patterns)
      : subschema_(subschema), properties_(properties), patterns_(patterns) {}
};

class DependenciesConstraint : public Constraint {
private:
  std::map<std::string, schema::Node const *> subschemas_;
  std::map<std::string, std::vector<std::string>> required_;

public:
  DependenciesConstraint(std::map<std::string, schema::Node const *> const & subschemas)
      : subschemas_(subschemas) {}

  DependenciesConstraint(std::map<std::string, std::vector<std::string>> const & required)
      : required_(required) {}

  DependenciesConstraint(std::map<std::string, schema::Node const *> const & subschemas,
                         std::map<std::string, std::vector<std::string>> const & required)
      : subschemas_(subschemas), required_(required) {}
};

class MaxPropertiesConstraint : public Constraint {
private:
  int64_t value_;

public:
  MaxPropertiesConstraint(int64_t value) : value_(value) {}
};

class MinPropertiesConstraint : public Constraint {
private:
  int64_t value_;

public:
  MinPropertiesConstraint(int64_t value) : value_(value) {}
};

class PatternPropertiesConstraint : public Constraint {
private:
  std::vector<std::pair<std::string, schema::Node const *>> properties_;

public:
  PatternPropertiesConstraint(
      std::vector<std::pair<std::string, schema::Node const *>> const & properties)
      : properties_(properties) {}
};

class PropertiesConstraint : public Constraint {
private:
  std::map<std::string, schema::Node const *> properties_;

public:
  PropertiesConstraint(std::map<std::string, schema::Node const *> const & properties)
      : properties_(properties) {}
};

class PropertyNamesConstraint : public Constraint {
private:
  schema::Node const * key_schema_;

public:
  PropertyNamesConstraint(schema::Node const * key_schema) : key_schema_(key_schema) {}
};

class RequiredConstraint : public Constraint {
private:
  std::unordered_set<std::string> properties_;

public:
  RequiredConstraint(std::unordered_set<std::string> const & properties)
      : properties_(properties) {}
};

class UnevaluatedPropertiesConstraint : public Constraint {
private:
  schema::Node const * subschema_;

public:
  UnevaluatedPropertiesConstraint(schema::Node const * subschema) : subschema_(subschema) {}
};
}