#pragma once

namespace stream { namespace detail {
  namespace filter {
    template <typename T>
    class iterator {
    public:
      iterator(std::function<bool(T const&)> f, ::stream::iterator<T>&& impl, ::stream::iterator<T>&& end)
      : pred_(f)
      , impl_(std::forward<::stream::iterator<T>>(impl))
      , end_(std::forward<::stream::iterator<T>>(end)) {
        advance();
      }

      T operator*() { return mem_; }
      
      iterator& operator++() {
        ++impl_;
        advance();
        return *this;
      }
      
      DELEGATE_ITERATOR_IMPL_BASE(impl_)
    private:
      void advance() {
        while (impl_ != end_ && !pred_(mem_ = *impl_)) {
          ++impl_;
        }
      }
      
      std::function<bool(T const&)> pred_;
      ref_or_val<T> mem_; // To avoid re-calcs, we store this
      ::stream::iterator<T> impl_, end_;
    };
  }
  
  template <typename T>
  class filter_stream {
  public:
    template <typename F>
    filter_stream(F&& func, stream_base<T> const& sb) : pred_(func), source_(sb) {}
    
    iterator<T> begin() {
      return {filter::iterator<T>{pred_, source_.begin(), source_.end()}};
    }
    
    iterator<T> end() {
      return {filter::iterator<T>{pred_, source_.end(), source_.end()}};
    }
  private:
    std::function<bool(T const&)> pred_;
    stream_base<T> source_;
  };
  
  template <typename T>
  template <typename F>
  auto stream_base<T>::filter(F&& pred) && -> stream_base<T>  {
    return std::make_shared<filter_stream<T>>(pred, std::move(*this));
  }
  
  template <typename T>
  template <typename F>
  auto stream_base<T>::filter(F&& pred) const & -> stream_base<T>  {
    return std::make_shared<filter_stream<T>>(pred, *this);
  }
} }