#pragma once

#include <iterator/filter_iterator.h>

#include <stream/forward.h>

#include <stream/detail/traits.h>
#include <stream/iterator/sentinel.h>
#include <stream/view/interface.h>

#include <stream/detail/macro.h>

namespace stream::ranges {
template <typename S, typename P>
class filter_view : public proxy_view_interface<filter_view<S, P>, S,
                                                iterator::filter_iterator, P> {
public:
  using iterator = iterator::filter_iterator<detail::begin_t<S>, P>;

private:
  S stream_;
  P predicate_;

public:
  filter_view(S && stream, P predicate)
      : stream_(FWD(stream)), predicate_(predicate) {}

  auto begin() const { return iterator(stream_, predicate_); }
  auto end() const {
    return sentinel_end(this, stream_, stream_.end(), predicate_);
  }
};

template <typename S, typename P> filter_view(S &&, P) -> filter_view<S, P>;
}

namespace stream::ranges::views {
template <typename Pred> class filter {
public:
  filter(Pred const & predicate) : predicate_(predicate) {}
  filter(Pred && predicate) : predicate_(std::move(predicate)) {}
  filter(Pred & predicate) : predicate_(predicate) {}

  template <typename Stream>
  friend auto operator|(Stream && stream, filter filt) {
    // TODO: if constexpr filter_view
    return filter_view(FWD(stream), std::move(filt.predicate_));
  }

private:
  Pred predicate_;
};
}

#include <stream/detail/undef.h>