#pragma once

#include <compare>
#include <cstddef>
#include <iterator>
#include <tuple>
#include <type_traits>
#include <xutility>

namespace util {

template <int I, class... Ts>
decltype(auto) get(Ts&&... ts) {
  return std::get<I>(std::forward_as_tuple(ts...));
}

template <class Iterator>
class Range {
  Iterator m_begin, m_end;

 public:
  Range(const Iterator _begin, const Iterator _end)
      : m_begin(_begin), m_end(_end) {}

  Range(const std::pair<const Iterator, const Iterator>& t) {
    m_begin = t.first;
    m_end   = t.second;
  }

  template <typename... Args>
  Range(Args&&... args) : m_begin(get<0>(args...)), m_end(get<1>(args...)) {}

  auto begin() -> Iterator { return m_begin; }
  auto begin() const -> const Iterator { return m_begin; }

  auto end() -> Iterator { return m_end; }
  auto end() const -> const Iterator { return m_end; }
};

namespace detail {

template <class C>
requires requires(const C &c) { c.read(); }
using reference_t = decltype(std::declval<const C &>().read());

namespace detail {
template <class C> struct deduced_value_t {
  template <class T> static auto deduce(int) -> typename T::value_type;
  template <class T> static auto deduce(...) -> std::decay_t<reference_t<T>>;

  using type = decltype(deduce<C>(0));
};
} // namespace detail

template <class C>
requires std::same_as<typename detail::deduced_value_t<C>::type,
                      std::decay_t<typename detail::deduced_value_t<C>::type>>
using value_type_t = typename detail::deduced_value_t<C>::type;

namespace detail {
template <class C> struct deduced_difference_t {
  template <class T> static auto deduce(int) -> typename T::difference_type;
  template <class T>
  static auto deduce(long) -> decltype(std::declval<const T &>().distance_to(
      std::declval<const T &>()));
  template <class T> static auto deduce(...) -> std::ptrdiff_t;

  using type = decltype(deduce<C>(0));
};
} // namespace detail

template <class C>
using difference_type_t = typename detail::deduced_difference_t<C>::type;

template <typename I> struct iterator_traits {
  using difference_type = difference_type_t<I>;
  using value_type = value_type_t<I>;
  using reference = reference_t<I>;
};
} // namespace detail

template <typename I> struct iterator_t {
private:
  I base_;

public:
  iterator_t() requires(std::is_default_constructible_v<I>) : base_({}) {}
  iterator_t(const I &base) : base_(base) {}
  iterator_t(I &&base) : base_(std::move(base)) {}

  auto constexpr base() const -> const I & { return base_; }
  auto constexpr base() -> I & { return base_; }

  // input_or_output_iterator
  auto constexpr operator++(int) -> iterator_t
      requires(std::input_or_output_iterator<I>) {
    const auto ret = *this;
    base()++;
    return ret;
  }
  auto constexpr operator++()
      -> iterator_t &requires(std::input_or_output_iterator<I>) {
    this ++;
    return *this;
  }

  // input_iterator
  auto constexpr operator*() const -> const std::iter_reference_t<I>
  requires(std::input_iterator<I>) { return *base(); }

  // output_iterator
  template <typename T = decltype(*base_)>
  auto constexpr operator*() -> std::iter_reference_t<I>
  requires(std::output_iterator<I, T>) { return *base(); }

  // forward_iterator
  auto constexpr operator==(const iterator_t &rhs) const
      -> bool requires(std::forward_iterator<I>) {
    return base() == rhs.base();
  }

  template <std::sentinel_for<I> S>
  auto constexpr operator==(const S &rhs) const
      -> bool requires(std::forward_iterator<I>) {
    return base() == rhs;
  }

  // bidirectional_iterator
  auto constexpr operator--(int) -> iterator_t
      requires(std::bidirectional_iterator<I>) {
    const auto ret = *this;
    base()--;
    return ret;
  }
  auto constexpr operator--()
      -> iterator_t &requires(std::bidirectional_iterator<I>) {
    base()--;
    return *this;
  }

  // random_access_iterator
  auto constexpr operator<=>(const iterator_t &rhs) const
      -> std::strong_ordering {
    return base() <=> rhs.base();
  }

  auto constexpr operator-(const iterator_t &rhs) const
      -> std::iter_difference_t<I> {
    return base() - rhs.base();
  }
  auto constexpr operator+(const std::iter_difference_t<I> &n) const
      -> iterator_t {
    return iterator_t(base() + n);
  }
  friend auto constexpr operator+(const std::iter_difference_t<I> &n,
                                  const iterator_t &rhs) -> iterator_t {
    return rhs + n;
  }
  auto constexpr operator-(const std::iter_difference_t<I> &n) const
      -> iterator_t {
    return iterator_t(base() - n);
  }

  auto operator+=(const std::iter_difference_t<I> &n) -> iterator_t & {
    *this = iterator_t(base() + n);
    return *this;
  }
  auto operator-=(const std::iter_difference_t<I> &n) -> iterator_t & {
    *this = iterator_t(base() - n);
    return *this;
  }

  auto constexpr operator[](const std::iter_difference_t<I> &n) const
      -> const std::iter_reference_t<I> {
    return base()[n];
  }
  auto operator[](const std::iter_difference_t<I> &n)
      -> std::iter_reference_t<I> {
    return base()[n];
  }
};

template <typename V, typename I = V *> struct BaseIterator {
  using value_type = V;
  using reference = V &;
  using difference_type = std::ptrdiff_t;

  I base_iter;

  BaseIterator(const I &iter) : base_iter(iter) {}
  BaseIterator(I &&iter) : base_iter(std::move(iter)) {}
};

template <typename V, typename I = V *>
struct InputOrOutputIterator : public BaseIterator<V, I> {
  InputOrOutputIterator(const I &iter) : BaseIterator<V, I>(iter) {}
  InputOrOutputIterator(I &&iter) : BaseIterator<V, I>(std::move(iter)) {}

  auto constexpr operator*() const -> void {}

  auto constexpr operator++(int) -> InputOrOutputIterator {
    const auto ret = *this;
    this->base_iter++;
    return ret;
  }
  auto constexpr operator++() -> InputOrOutputIterator & {
    this ++;
    return *this;
  }
};

template <typename V, typename I = V *>
struct InputIterator : public InputOrOutputIterator<V, I>,
                       public std::input_iterator_tag {
  InputIterator(const I &iter) : BaseIterator<V, I>(iter) {}
  InputIterator(I &&iter) : BaseIterator<V, I>(std::move(iter)) {}

  auto constexpr operator*() const -> const V & { return *this->base_iter; }
};

template <typename V, typename I = V *>
struct OutputIterator : public InputOrOutputIterator<V, I>,
                        public std::output_iterator_tag {
  OutputIterator(const I &iter) : BaseIterator<V, I>(iter) {}
  OutputIterator(I &&iter) : BaseIterator<V, I>(std::move(iter)) {}

  auto constexpr operator*() -> V & { return *this->base_iter; }
};

template <typename V, typename I = V *>
struct ForwardIterator : public InputIterator<V, I>,
                         public std::forward_iterator_tag {
  ForwardIterator(const I &iter) : BaseIterator<V, I>(iter) {}
  ForwardIterator(I &&iter) : BaseIterator<V, I>(std::move(iter)) {}

  auto constexpr operator==(const ForwardIterator &rhs) const -> bool {
    return this->base_iter == rhs.base_iter;
  }
};

template <typename V, typename I = V *>
struct BidirectionalIterator : public ForwardIterator<V, I>,
                               public std::bidirectional_iterator_tag {
  BidirectionalIterator(const I &iter) : BaseIterator<V, I>(iter) {}
  BidirectionalIterator(I &&iter) : BaseIterator<V, I>(std::move(iter)) {}

  auto constexpr operator--(int) -> BidirectionalIterator {
    const auto ret = *this;
    this->base_iter--;
    return ret;
  }
  auto constexpr operator--() -> BidirectionalIterator & {
    this --;
    return *this;
  }
};

template <typename V, typename I = V *>
struct RandomAccessIterator : public BidirectionalIterator<V, I>,
                              public std::random_access_iterator_tag {
  using difference_type = typename BaseIterator<V, I>::difference_type;

  RandomAccessIterator(const I &iter) : BaseIterator<V, I>(iter) {}
  RandomAccessIterator(I &&iter) : BaseIterator<V, I>(std::move(iter)) {}

  auto constexpr operator<=>(const RandomAccessIterator &rhs) const
      -> std::strong_ordering {
    return this->base_iter <=> rhs.base_iter;
  }

  auto constexpr operator-(const RandomAccessIterator &rhs) const
      -> difference_type {
    return this->base_iter - rhs.base_iter;
  }
  auto constexpr operator+(const difference_type &n) const
      -> RandomAccessIterator {
    return RandomAccessIterator(this->base_iter + n);
  }
  friend auto constexpr operator+(const difference_type &n,
                                  const RandomAccessIterator &rhs)
      -> RandomAccessIterator {
    return rhs + n;
  }
  auto constexpr operator-(const difference_type &n) const
      -> RandomAccessIterator {
    return RandomAccessIterator(this->base_iter - n);
  }

  auto operator+=(const difference_type &n) -> RandomAccessIterator & {
    *this = RandomAccessIterator(this->base_iter + n);
    return *this;
  }
  auto operator-=(const difference_type &n) -> RandomAccessIterator & {
    *this = RandomAccessIterator(this->base_iter - n);
    return *this;
  }

  auto constexpr operator[](const difference_type &n) const -> const V & {
    return this->base_iter[n];
  }
  auto operator[](const difference_type &n) -> V & {
    return this->base_iter[n];
  }
};

template <typename I>
using Iterator = std::conditional_t<
    std::random_access_iterator<I>,
    RandomAccessIterator<std::iter_value_t<I>, I>,
    std::conditional_t<
        std::bidirectional_iterator<I>,
        BidirectionalIterator<std::iter_value_t<I>, I>,
        std::conditional_t<
            std::forward_iterator<I>, ForwardIterator<std::iter_value_t<I>, I>,
            std::conditional_t<
                std::output_iterator<I, decltype(*std::declval<I>())>,
                OutputIterator<std::iter_value_t<I>, I>,
                std::conditional_t<
                    std::input_iterator<I>,
                    InputIterator<std::iter_value_t<I>, I>,
                    std::conditional_t<
                        std::input_or_output_iterator<I>,
                        InputOrOutputIterator<std::iter_value_t<I>, I>,
                        RandomAccessIterator<I, I *>>>>>>>;

template <std::ranges::range R>
using RangeIterator = Iterator<std::ranges::iterator_t<R>>;

}  // namespace util

namespace std {
template <typename I>
struct iterator_traits<util::iterator_t<I>> : public iterator_traits<I> {};
} // namespace std