#pragma once

#include <algorithm>
#include <memory>
#include <numeric>
#include <optional>
#include <vector>

#include "iterator.hpp"

namespace stream::detail {
  template <typename T, typename = void> class stream_base_pointer_impl {};

  template <typename T>
  class stream_base_pointer_impl<
      T, std::enable_if_t<traits::is_dereferencable_v<T>>> {
  private:
    using self_t = stream_base<T>;
    using pointer = typename std::remove_reference<T>::type;
    using element_type = typename std::pointer_traits<pointer>::element_type;

  public:
    auto deref() const & -> stream_base<element_type &> {
      return static_cast<self_t const *>(this)->map(
          [](T const & p) -> element_type & { return *p; });
    }

    auto deref() && -> stream_base<element_type &> {
      return static_cast<self_t &&>(*this).map(
          [](T const & p) -> element_type & { return *p; });
    }
  };

  template <typename T> class stream_base : public stream_base_pointer_impl<T> {
  private:
    using value_type = typename std::decay<T>::type;

  public:
    template <typename Stream> stream_base(std::shared_ptr<Stream> && impl) {
      do_begin = [](std::shared_ptr<void> p) -> iterator<T> {
        return std::static_pointer_cast<Stream>(p)->begin();
      };
      do_end = [](std::shared_ptr<void> p) -> iterator<T> {
        return std::static_pointer_cast<Stream>(p)->end();
      };
      impl_ = std::static_pointer_cast<void>(impl);
    }

    ::stream::iterator<T> begin() const { return do_begin(impl_); }
    ::stream::iterator<T> end() const { return do_end(impl_); }

    bool empty() const { return begin() == end(); }

    std::vector<value_type> collect() const {
      std::vector<value_type> coll;
      collect(coll);
      return coll;
    }

    template <typename C, typename = std::enable_if_t<
                              !std::is_void_v<typename C::value_type>>>
    C & collect(C & coll) const {
      std::copy(begin(), end(), std::inserter(coll, coll.end()));
      return coll;
    }

    std::optional<value_type> first() const {
      return begin() != end() ? std::optional(*begin()) : std::nullopt;
    }

    template <typename F> bool none(F && pred) const {
      return std::none_of(begin(), end(), pred);
    }

    template <typename F> bool all(F && pred) const {
      return std::all_of(begin(), end(), pred);
    }

    template <typename F> bool any(F && pred) const {
      return std::any_of(begin(), end(), pred);
    }

    template <typename F>
    value_type accumulate(F && fold, value_type const & accum) const {
      return std::accumulate(begin(), end(), accum, fold);
    }

    template <typename F, typename = std::enable_if_t<
                              std::is_invocable_v<F, value_type, value_type>>>
    std::optional<value_type> accumulate(F && fold) const {
      if (empty()) { return std::nullopt; }
      value_type first = *begin();
      return std::accumulate(++begin(), end(), first, fold);
    }

    value_type accumulate(value_type const & accum) const {
      return std::accumulate(begin(), end(), accum);
    }

    template <typename F> void each(F && consumer) const {
      std::for_each(begin(), end(), consumer);
    }

    template <typename F>
    stream_base<traits::mapped_t<T, F>> map(F && func) const &;
    template <typename F> stream_base<T> filter(F && func) const &;
    template <typename F>
    stream_base<traits::fmapped_t<T, F>> flatmap(F && func) const &;

    auto keys() const & {
      return map([](auto & kv) -> decltype(auto) { return kv.first; });
    }

    auto values() const & {
      return map([](auto & kv) -> decltype(auto) { return kv.second; });
    }

    template <typename F> stream_base<traits::mapped_t<T, F>> map(F && func) &&;
    template <typename F> stream_base<T> filter(F && func) &&;
    template <typename F>
    stream_base<traits::fmapped_t<T, F>> flatmap(F && func) &&;

    template <typename Cast> stream_base<Cast const &> cast() const & {
      return map([](T const & p) -> Cast const & { return p; });
    }

    template <typename Cast> stream_base<Cast const &> cast() && {
      return std::move(*this).map(
          [](T const & p) -> Cast const & { return p; });
    }

    template <typename F, typename = traits::is_memvar_t<F>>
    stream_base<traits::memvar_f<F>> map(F && memvar) const & {
      return map(map_member_object<F>{memvar});
    }

    template <typename F, typename = traits::is_memfun_t<F>>
    stream_base<traits::memfun_f<F>> map(F && memvar) const & {
      return map(map_member_function<F>{memvar});
    }

    template <typename F, typename = traits::is_memvar_t<F>>
    stream_base<traits::memvar_f<F>> map(F && memvar) && {
      return std::move(*this).map(map_member_object<F>{memvar});
    }

    template <typename F, typename = traits::is_memfun_t<F>>
    stream_base<traits::memfun_f<F>> map(F && memvar) && {
      return std::move(*this).map(map_member_function<F>{memvar});
    }

  private:
    iterator<T> (*do_begin)(std::shared_ptr<void>){nullptr};
    iterator<T> (*do_end)(std::shared_ptr<void>){nullptr};
    std::shared_ptr<void> impl_{nullptr};
  };
}