#pragma once

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

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

namespace jvalidate::constraint {
class AdditionalItemsConstraint : public SimpleConstraint<AdditionalItemsConstraint> {
public:
  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 SimpleConstraint<ContainsConstraint> {
public:
  schema::Node const * subschema;
  std::optional<size_t> minimum;
  std::optional<size_t> maximum;

public:
  ContainsConstraint(schema::Node const * subschema) : subschema(subschema) {}

  ContainsConstraint(schema::Node const * subschema, std::optional<size_t> minimum,
                     std::optional<size_t> maximum)
      : subschema(subschema), minimum(minimum), maximum(maximum) {}
};

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

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

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

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

class TupleConstraint : public SimpleConstraint<TupleConstraint> {
public:
  std::vector<schema::Node const *> items;

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

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

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

class UniqueItemsConstraint : public SimpleConstraint<UniqueItemsConstraint> {
public:
};
}