#pragma once

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

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

namespace jvalidate::constraint {
class PolyConstraint : public Constraint {
private:
  std::vector<std::unique_ptr<Constraint>> children_;
  bool match_all_;
  bool invert_{false};

public:
  template <typename... Cs> static auto AllOf(Cs &&... cs) {
    return std::make_unique<PolyConstraint>(PolyConstraint(true, false, std::forward<Cs>(cs)...));
  }

  template <typename... Cs> static auto AnyOf(Cs &&... cs) {
    return std::make_unique<PolyConstraint>(PolyConstraint(false, false, std::forward<Cs>(cs)...));
  }

  static auto Not(std::unique_ptr<Constraint> child) {
    return std::make_unique<PolyConstraint>(PolyConstraint(false, true, std::move(child)));
  }

  Status accept(ConstraintVisitor const & visitor) const final {
    Status rval = Status::Noop;
    for (auto const & child : children_) {
      if (match_all_) {
        rval &= child->accept(visitor);
      } else {
        rval |= child->accept(visitor);
      }
    }
    return invert_ ? !rval : rval;
  }

private:
  template <typename... Cs>
  PolyConstraint(bool match_all, bool invert, Cs &&... cs)
      : match_all_(match_all), invert_(invert) {
    (children_.push_back(std::forward<Cs>(cs)), ...);
  }
};

class AllOfConstraint : public SimpleConstraint<AllOfConstraint> {
public:
  std::vector<schema::Node const *> children;

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

class AnyOfConstraint : public SimpleConstraint<AnyOfConstraint> {
public:
  std::vector<schema::Node const *> children;

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

class EnumConstraint : public SimpleConstraint<EnumConstraint> {
public:
  std::vector<std::unique_ptr<adapter::Const const>> enumeration;

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

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

class OneOfConstraint : public SimpleConstraint<OneOfConstraint> {
public:
  std::vector<schema::Node const *> children;

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

class ConditionalConstraint : public SimpleConstraint<ConditionalConstraint> {
public:
  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 SimpleConstraint<NotConstraint> {
public:
  schema::Node const * child;

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

class TypeConstraint : public SimpleConstraint<TypeConstraint> {
public:
  std::set<adapter::Type> types;

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