#pragma once

#include <jvalidate/detail/expect.h>
#include <optional>
#include <vector>

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

namespace jvalidate::constraint {
class AdditionalItemsConstraint : public Constraint {
private:
  schema::Node const * subschema_;
  size_t applies_after_nth_;

public:
  AdditionalItemsConstraint(schema::Node const * subschema, size_t applies_after_nth)
      : subschema_(subschema), applies_after_nth_(applies_after_nth) {}
};

class ContainsConstraint : public Constraint {
private:
  std::unique_ptr<adapter::Const const> constant_;
  std::optional<size_t> minimum_;
  std::optional<size_t> maximum_;

public:
  ContainsConstraint(std::unique_ptr<adapter::Const const> && constant)
      : constant_(std::move(constant)) {}

  ContainsConstraint(std::unique_ptr<adapter::Const const> && constant,
                     std::optional<size_t> minimum, std::optional<size_t> maximum)
      : constant_(std::move(constant)), minimum_(minimum), maximum_(maximum) {}
};

class MaxItemsConstraint : public Constraint {
private:
  int64_t value_;

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

class MinItemsConstraint : public Constraint {
private:
  int64_t value_;

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

class TupleConstraint : public Constraint {
private:
  std::vector<schema::Node const *> items_;

public:
  TupleConstraint(std::vector<schema::Node const *> const & items) : items_(items) {}
};

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

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

class UniqueItemsConstraint : public Constraint {
public:
};
}