//
//  fluent.hpp
//  stream
//
//  Created by Sam Jaffe on 1/28/17.
//

#pragma once

#include "../streams.hpp"

namespace stream { namespace traits {
  template <typename T, typename P>
  using is_filter = std::is_same<bool, decltype(std::declval<P>()(std::declval<T>()))>;
  
  template <typename C, typename T, typename = void>
  struct is_collection : public std::false_type {};
  
  template <typename C, typename T>
  struct is_collection<C, T, typename std::enable_if<std::is_constructible<typename C::value_type, T>::value>::type> : public std::true_type {};
} }

namespace stream { namespace detail {
  template <typename T, typename F>
  auto operator||(stream_base<T> const&s, F && f) -> decltype(s.flatmap(f)) {
    return s.flatmap(f);
  }
  
  template <typename T, typename F, typename = typename std::enable_if<!traits::is_filter<T, F>::value>::type>
  auto operator|(stream_base<T> const&s, F && f) -> decltype(s.map(f)) {
    return s.map(f);
  }
  
  template <typename T, typename P, typename = typename std::enable_if<traits::is_filter<T, P>::value>::type>
  stream_base<T> operator|(stream_base<T> const&s, P && f) {
    return s.filter(f);
  }
  
  template <typename R>
  R operator >(stream_base<R> const &s, R const & val) {
    return s.accumulate(val);
  }

  template <typename L, typename R, typename F>
  L operator >(stream_base<R> const &s, std::pair<L, F> const & pair) {
    return s.accumulate(pair.second, pair.first);
  }
  
  template <typename T, typename F, typename = typename std::enable_if<!traits::is_collection<F, T>::value>::type>
  typename std::decay<T>::type operator >(stream_base<T> const &s, F && f) {
    return s.accumulate(f, typename std::decay<T>::type());
  }
  
  template <typename T, typename C, typename = typename std::enable_if<traits::is_collection<C, T>::value>::type>
  C & operator >(stream_base<T> const & s, C & c) {
    s.collect(c);
    return c;
  }
} }