#pragma once

#include <iterator>
#include <type_traits>

namespace iterator {
struct sentinel_t;
}

namespace iterator::detail {
template <typename C> using iter = decltype(std::begin(std::declval<C>()));

// Type Helper for deducing reference types
template <typename T, typename = void> struct reference_helper {
  using type = decltype(*std::declval<T>());
};
template <typename T>
struct reference_helper<T, std::void_t<typename T::reference>> {
  using type = typename T::reference;
};

// Type Helper for deducing value types
template <typename T, typename = void> struct value_type_helper {
  using reference = typename reference_helper<T>::type;
  using type = std::remove_cv_t<std::remove_reference_t<reference>>;
};
template <typename T>
struct value_type_helper<T, std::void_t<typename T::value_type>> {
  using type = typename T::value_type;
};

// Type Helper for identifying container-like objects
template <typename C, typename = void> struct is_container : std::false_type {};
template <typename C>
struct is_container<C, std::void_t<iter<C>>> : std::true_type {};

template <typename It, typename = void>
struct has_sentinel_type : std::false_type {};
template <typename It>
struct has_sentinel_type<It, std::void_t<typename It::sentinel_type>>
    : std::true_type {};

template <typename T> using value_type = typename value_type_helper<T>::type;
template <typename T> using reference = typename reference_helper<T>::type;

template <typename C> constexpr bool is_container_v = is_container<C>{};

template <typename Iter>
constexpr bool is_rvalue_iterator_v = !std::is_reference_v<reference<Iter>>;

template <typename Iter>
using category = typename std::iterator_traits<Iter>::iterator_category;

template <typename Iter>
constexpr bool is_random_access_v =
    std::is_same_v<category<Iter>, std::random_access_iterator_tag>;

template <typename Iter>
constexpr bool is_bidirectional_v =
    std::is_same_v<category<Iter>, std::bidirectional_iterator_tag> ||
    is_random_access_v<Iter>;

template <typename Iter>
constexpr bool is_forward_v =
    std::is_same_v<category<Iter>, std::forward_iterator_tag> ||
    is_bidirectional_v<Iter>;

template <typename Iter> constexpr bool is_single_pass_v = !is_forward_v<Iter>;

template <typename It>
constexpr bool has_sentinel_type_v = has_sentinel_type<It>{};

template <typename It, typename S>
using sentinel_type = std::conditional_t<std::is_same_v<It, S>, sentinel_t, S>;
}