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

#pragma once

#include "../streams.hpp"

#include <numeric>

namespace stream {
  template <typename T, typename R>
  struct map {
    template <typename F>
    explicit map(F&& f) : func(f) {}
    std::function<R(const T&)> func;
  };
  
  template <typename T, typename R>
  struct flatmap {
    template <typename F>
    explicit flatmap(F&& f) : func(f) {}
    std::function<R(const T&)> func;
  };
  
  template <typename T>
  struct filter {
    template <typename F>
    explicit filter(F&& f) : pred(f) {}
    std::function<bool(const T&)> pred;
  };

  template <typename L, typename R = L>
  struct fold_left {
    template <typename F>
    explicit fold_left(F&& f, L const & i = L()) : init(i), fold(f) {}
    L init;
    std::function<L(const L&, const R&)> fold;
  };
}

namespace stream { namespace detail {
  template <typename T, typename R>
  stream_base<R> operator|(stream_base<T> const&s, ::stream::map<typename std::decay<T>::type, R>&& f) {
    return s.map(f.func);
  }
  
  template <typename T, typename C>
  stream_base<typename C::value_type> operator|(stream_base<T> const&s, ::stream::flatmap<typename std::decay<T>::type, C>&& f) {
    return s.flatmap(f.func);
  }
  
  template <typename T>
  stream_base<T> operator|(stream_base<T> const&s, ::stream::filter<typename std::decay<T>::type>&& f) {
    return s.filter(f.pred);
  }

  template <typename L, typename R>
  L operator >(stream_base<R> const &s, ::stream::fold_left<L, typename std::decay<R>::type> && f) {
    return std::accumulate(s.begin(), s.end(), f.init, f.fold);
  }
  
  template <typename T, typename C>
  C & operator >(stream_base<T> const & s, C & c) {
    s.collect(c);
    return c;
  }
} }