#pragma once

#include <memory>
#include <set>
#include <vector>

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

namespace jvalidate::constraint {
class AllOfConstraint : public Constraint {
private:
  std::vector<schema::Node const *> children_;

public:
  AllOfConstraint(std::vector<schema::Node const *> const & children) : children_(children) {}
};

class AnyOfConstraint : public Constraint {
private:
  std::vector<schema::Node const *> children_;

public:
  AnyOfConstraint(std::vector<schema::Node const *> const & children) : children_(children) {}
};

class EnumConstraint : public Constraint {
private:
  std::vector<std::unique_ptr<adapter::Const const>> enums_;

public:
  EnumConstraint(std::unique_ptr<adapter::Const const> && constant) {
    enums_.push_back(std::move(constant));
  }

  EnumConstraint(std::vector<std::unique_ptr<adapter::Const const>> && enums)
      : enums_(std::move(enums)) {}
};

class OneOfConstraint : public Constraint {
private:
  std::vector<schema::Node const *> children_;

public:
  OneOfConstraint(std::vector<schema::Node const *> const & children) : children_(children) {}
};

class ConditionalConstraint : public Constraint {
private:
  schema::Node const * if_constraint_;
  schema::Node const * then_constraint_;
  schema::Node const * else_constraint_;

public:
  ConditionalConstraint(schema::Node const * if_constraint, schema::Node const * then_constraint,
                        schema::Node const * else_constraint)
      : if_constraint_(if_constraint), then_constraint_(then_constraint),
        else_constraint_(else_constraint) {}
};

class NotConstraint : public Constraint {
private:
  schema::Node const * child_;

public:
  NotConstraint(schema::Node const * child) : child_(child) {}
};

class TypeConstraint : public Constraint {
private:
  std::set<adapter::Type> types_;

public:
  TypeConstraint(adapter::Type type) : types_{type} {}
  TypeConstraint(std::set<adapter::Type> const & types) : types_(types) {}
};
}