//
//  traits.hpp
//  stream
//
//  Created by Sam Jaffe on 6/24/17.
//

#pragma once

#include <type_traits>
#include <utility>

#include <iterator/detail/traits.h>
#include <iterator/facade.h>

#include <stream/forward.h>

#define _val(type) std::declval<type>()
#define exists(expr) std::void_t<decltype(expr)>

namespace stream::traits {
template <typename C> using begin_t = decltype(std::begin(_val(C)));
template <typename C> using end_t = decltype(std::end(_val(C)));

template <typename C> using ref_t = decltype(*_val(begin_t<C>));
template <typename C> using value_type = std::remove_reference_t<ref_t<C>>;
template <typename C> using cref_t = std::add_const_t<ref_t<C>>;

template <typename, typename = void> struct has_size : std::false_type {};
template <typename, typename = void> struct has_empty : std::false_type {};

template <typename C>
struct has_size<C, std::enable_if_t<std::is_integral_v<decltype(_val(C).size())>>> : std::true_type {};
template <typename C>
struct has_empty<C, std::enable_if_t<std::is_same_v<decltype(_val(C).empty()), bool>>> : std::true_type {};

template <typename It, typename S, typename = void>
struct is_comparable : std::false_type {};

template <typename It, typename S>
struct is_comparable<It, S, exists(_val(It) == _val(S))> : std::true_type {};

template <typename C> constexpr bool has_size_v = has_size<C>{};
template <typename C> constexpr bool has_empty_v = has_empty<C>{};
template <typename It, typename S>
constexpr bool is_comparable_v = is_comparable<It, S>{};

template <typename S>
constexpr bool is_sentinal_v = !std::is_same_v<begin_t<S>, end_t<S>>;
}

#undef _val
#undef exists