//
//  join_iterator.hpp
//  iterator
//
//  Created by Sam Jaffe on 2/7/17.
//

#pragma once

#include <iterator>
#include <utility>

#include <iterator/detail/arrow_proxy.h>
#include <iterator/end_aware_iterator.hpp>
#include <iterator/facade.h>
#include <iterator/iterator_fwd.hpp>

namespace iterator::joining {
template <typename Iter, typename = void>
class iterator {
protected:
  using inner_t = decltype(*std::declval<Iter>());

protected:
  iterator() = default;

  template <typename I>
  iterator(iterator<I> const & other)
      : iterator(other.join_iterator(), other.element_iterator()) {}

  template <typename C, typename = std::enable_if_t<detail::is_container_v<C>>>
  iterator(C && container)
      : iterator(end_aware_iterator(std::forward<C>(container))) {}

  iterator(end_aware_iterator<Iter> join) : iterator(join, {}, true) {}
  
  iterator(end_aware_iterator<Iter> join,
           end_aware_iterator<iter<inner_t>> elem, bool update = false)
      : joiner_(join), element_(elem) {
    if (update) { update_iterator(); }
  }

  void update_iterator() {
    while (!joiner_.at_end() &&
           (element_ = end_aware_iterator(*joiner_)).at_end()) {
      ++joiner_;
    }
  }

protected:
  end_aware_iterator<Iter> joiner_;
  end_aware_iterator<iter<inner_t>> element_;
};

template <typename Iter>
class iterator<Iter, std::enable_if_t<detail::is_rvalue_iterator_v<Iter>>> {
protected:
  using inner_t = decltype(*std::declval<Iter>());

protected:
  iterator() = default;
  template <typename C, typename = std::enable_if_t<detail::is_container_v<C>>>
  iterator(C && container) : joiner_(std::forward<C>(container)) {
    update_iterator();
  }

  iterator(end_aware_iterator<Iter> join) : joiner_(join) {
    update_iterator();
  }

  iterator(iterator const &other) { *this = other; }
  iterator(iterator &&other) { *this = std::move(other); }
  
  iterator &operator=(iterator const &other) {
    joiner_ = other.joiner_;
    sync(std::distance(end_aware_iterator(cache_.get()), element_));
    return *this;
  }
  
  iterator &operator=(iterator &&other) {
    joiner_ = std::move(joiner_);
    sync(std::distance(end_aware_iterator(cache_.get()), element_));
    return *this;
  }
  
  void update_iterator() {
    while (!joiner_.at_end() && sync().at_end()) {
      ++joiner_;
    }
  }
  
private:
  end_aware_iterator<iter<inner_t>> const & sync(size_t n = 0) {
    if (joiner_.at_end()) { return element_ = {}; }
    cache_ = *joiner_;
    element_ = end_aware_iterator(cache_.get());
    std::advance(element_, n);
    return element_;
  }

protected:
  end_aware_iterator<Iter> joiner_;
  detail::value_proxy<decltype(*std::declval<Iter>())> cache_;
  end_aware_iterator<iter<inner_t>> element_;
};
}

namespace iterator {
template <typename Iter>
class joining_iterator : public facade<joining_iterator<Iter>>, public joining::iterator<Iter> {
public:
  using super_t = joining::iterator<Iter>;
  
public:
  using super_t::super_t;
  
  template <typename C, typename = std::enable_if_t<detail::is_container_v<C>>>
  joining_iterator(C && container) : super_t(std::forward<C>(container)) {}

  joining_iterator(end_aware_iterator<Iter> join) : super_t(join) {}
  
  void increment() {
    if ((++super_t::element_).at_end()) {
      ++super_t::joiner_;
      super_t::update_iterator();
    }
  }

  decltype(auto) dereference() const { return *super_t::element_; }

  bool equal_to(joining_iterator const & other) const {
    return join_iterator() == other.join_iterator() &&
        element_iterator() == other.element_iterator();
  }
  
  auto const &join_iterator() const { return super_t::joiner_; }
  auto const &element_iterator() const { return super_t::element_; }
};

template <typename C> joining_iterator(C &&) -> joining_iterator<iter<C>>;
template <typename JI>
joining_iterator(end_aware_iterator<JI>) -> joining_iterator<JI>;
}

MAKE_ITERATOR_FACADE_TYPEDEFS_T(::iterator::joining_iterator);