#pragma once

#include <functional>

#include <iterator/filter_iterator.hpp>

#include <stream/detail/sentinal.h>
#include <stream/detail/traits.h>

#define FWD(x) std::forward<decltype(x)>(x)

namespace stream::ranges {
template <typename S> class filter_view {
private:
  using Pred = std::function<bool(traits::cref_t<S>)>;
  using iterator = ::iterator::filter_iterator<iter<S>, true>;

private:
  S stream_;
  Pred predicate_;

public:
  template <typename F>
  filter_view(S && stream, F predicate)
      : stream_(FWD(stream)), predicate_(predicate) {}

  auto begin() const { return iterator(predicate_, stream_); }
  auto end() const { return sentinal; }
};

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

namespace stream::ranges::views {
template <typename Pred> class filter {
public:
  filter(Pred const & predicate) : predicate_(predicate) {}
  filter(Pred & predicate) : predicate_(std::move(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_;
};
}

#undef FWD