#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 SimpleConstraint<AdditionalPropertiesConstraint> {
public:
  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 SimpleConstraint<DependenciesConstraint> {
public:
  std::map<std::string, schema::Node const *> subschemas;
  std::map<std::string, std::unordered_set<std::string>> required;

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

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

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

class MaxPropertiesConstraint : public SimpleConstraint<MaxPropertiesConstraint> {
public:
  int64_t value;

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

class MinPropertiesConstraint : public SimpleConstraint<MinPropertiesConstraint> {
public:
  int64_t value;

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

class PatternPropertiesConstraint : public SimpleConstraint<PatternPropertiesConstraint> {
public:
  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 SimpleConstraint<PropertiesConstraint> {
public:
  std::map<std::string, schema::Node const *> properties;

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

class PropertyNamesConstraint : public SimpleConstraint<PropertyNamesConstraint> {
public:
  schema::Node const * key_schema;

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

class RequiredConstraint : public SimpleConstraint<RequiredConstraint> {
public:
  std::unordered_set<std::string> properties;

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

class UnevaluatedPropertiesConstraint : public SimpleConstraint<UnevaluatedPropertiesConstraint> {
public:
  schema::Node const * subschema;

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