#pragma once

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

template <typename T, typename R, bool B>
stream::detail::stream_base<R, true> operator|(stream::detail::stream_base<T, B> const&s, stream::map_t<T, R>&& f) {
  return s.map(f.func);
}
template <typename T, typename R, bool B>
stream::detail::stream_base<R, true> operator|(stream::detail::stream_base<T, B> &&s, stream::map_t<T, R>&& f) {
  return std::move(s).map(f.func);
}

namespace stream {
  namespace detail {
    template <typename T, typename R, bool B>
    class map_stream : public stream_impl<R> {
    public:
      class iterator : public iterator_impl<R> {
      public:
        typedef iterator_impl<R> super;
        iterator(std::function<R(T const&)> f, ::stream::iterator<T>&& impl)
        : fun_(f), impl_(std::forward<::stream::iterator<T>>(impl)) {}
        ~iterator() {}
        R operator*() override { return fun_(*impl_); }
        DELEGATE_ITERATOR_IMPL(impl_)
      private:
        std::function<R(T const&)> fun_;
        ::stream::iterator<T> impl_;
      };
      
      template <typename F>
      map_stream(F&& func, stream_base<T, B> const& sb) : fun_(func), source_(sb) {}
      template <typename F>
      map_stream(F&& func, stream_base<T, B> && sb) : fun_(func), source_(std::forward<stream_base<T, B>>(sb)) { }
      ~map_stream() override {}
      
      ::stream::iterator<R> begin() override { return new iterator{fun_, source_.begin()};}
      ::stream::iterator<R> end() override { return new iterator{fun_, source_.end()}; }
    private:
      std::function<R(T const&)> fun_;
      stream_base<T, B> source_;
    };
    
    template <typename T, bool Own>
    template <typename F>
    auto stream_base<T, Own>::map(F&& func) const& -> stream_base<map_f<F>, true>  {
      using impl_t = map_stream<T, map_f<F>, false>;
      return stream_base<map_f<F>, true>{new impl_t(func, falsify(*this))};
    }
    
    template <typename T, bool Own>
    template <typename F>
    auto stream_base<T, Own>::map(F&& func) && -> stream_base<map_f<F>, true> {
      using impl_t = map_stream<T, map_f<F>, Own>;
      return stream_base<map_f<F>, true>{new impl_t(func, std::forward<self>(*this))};
    }
  }
}