#ifndef ITERATOR_ITERATOR_HPP_

#define ITERATOR_ITERATOR_HPP_

#include <iterator>

#include <type_traits>

#include <utility>

#include "iterbase.hpp"

// IterIterWrapper and IteratorIterator provide a means to have a container

// of iterators act like a container of the pointed to objects. This is useful

// for combinatorics and similar itertools which need to keep track of

// more than one element at a time.

// an IterIterWrapper<some_collection_type<collection<T>::iterator>>

// behave like some_collection<T> when iterated over or indexed

namespace iter {

  namespace impl {

    template <typename T, typename = void>

    struct HasConstDeref : std::false_type {};

    template <typename T>

    struct HasConstDeref<T, std::void_t<decltype(*std::declval<const T&>())>>

        : std::true_type {};

    template <typename TopIter>

    class IteratorIterator {

      template <typename>

      friend class IteratorIterator;

      using Diff = std::ptrdiff_t;

      static_assert(

          std::is_same<

              typename std::iterator_traits<TopIter>::iterator_category,

              std::random_access_iterator_tag>::value,

          "IteratorIterator only works with random access iterators");

     private:

      TopIter sub_iter;

     public:

      using iterator_category = std::random_access_iterator_tag;

      using value_type = std::remove_cv_t<

          std::remove_reference_t<decltype(**std::declval<TopIter>())>>;

      using difference_type = std::ptrdiff_t;

      using pointer =

          std::remove_reference_t<decltype(**std::declval<TopIter>())>*;

      using reference = std::add_lvalue_reference_t<

          std::remove_reference_t<decltype(**std::declval<TopIter>())>>;

      IteratorIterator() = default;

      IteratorIterator(const TopIter& it) : sub_iter{it} {}

      const TopIter& get() const {

        return sub_iter;

      }

      template <typename T>

      bool operator==(const IteratorIterator<T>& other) const {

        return !(*this != other);

      }

      template <typename T>

      bool operator!=(const IteratorIterator<T>& other) const {

        return this->sub_iter != other.sub_iter;

      }

      IteratorIterator& operator++() {

        ++this->sub_iter;

        return *this;

      }

      IteratorIterator operator++(int) {

        auto ret = *this;

        ++*this;

        return ret;

      }

      IteratorIterator& operator--() {

        --this->sub_iter;

        return *this;

      }

      IteratorIterator operator--(int) {

        auto ret = *this;

        --*this;

        return ret;

      }

      auto operator*() const -> decltype(**sub_iter) {

        return **this->sub_iter;

      }

      auto operator->() const -> decltype(*sub_iter) {

        return *this->sub_iter;

      }

      IteratorIterator& operator+=(Diff n) {

        this->sub_iter += n;

        return *this;

      }

      IteratorIterator operator+(Diff n) const {

        auto it = *this;

        it += n;

        return it;

      }

      friend IteratorIterator operator+(Diff n, IteratorIterator it) {

        it += n;

        return it;

      }

      IteratorIterator& operator-=(Diff n) {

        this->sub_iter -= n;

        return *this;

      }

      IteratorIterator operator-(Diff n) const {

        auto it = *this;

        it -= n;

        return it;

      }

      Diff operator-(const IteratorIterator& rhs) const {

        return this->sub_iter - rhs.sub_iter;

      }

      auto operator[](Diff idx) const -> decltype(*sub_iter[idx]) {

        return *sub_iter[idx];

      }

      bool operator<(const IteratorIterator& rhs) const {

        return this->sub_iter < rhs.sub_iter;

      }

      bool operator>(const IteratorIterator& rhs) const {

        return this->sub_iter > rhs.sub_iter;

      }

      bool operator<=(const IteratorIterator& rhs) const {

        return this->sub_iter <= rhs.sub_iter;

      }

      bool operator>=(const IteratorIterator& rhs) const {

        return this->sub_iter >= rhs.sub_iter;

      }

    };

    template <typename Container>

    class IterIterWrapper {

     private:

      Container container;

      using contained_iter = typename Container::value_type;

      using size_type = typename Container::size_type;

      using iterator = IteratorIterator<typename Container::iterator>;

      using const_iterator =

          IteratorIterator<typename Container::const_iterator>;

      using reverse_iterator =

          IteratorIterator<typename Container::reverse_iterator>;

      using const_reverse_iterator =

          IteratorIterator<typename Container::const_reverse_iterator>;

      template <typename U = Container, typename = void>

      struct ConstAtTypeOrVoid : type_is<void> {};

      template <typename U>

      struct ConstAtTypeOrVoid<U,

          std::void_t<decltype(*std::declval<const U&>().at(0))>>

          : type_is<decltype(*std::declval<const U&>().at(0))> {};

      using const_at_type_or_void_t = typename ConstAtTypeOrVoid<>::type;

      template <typename U = Container, typename = void>

      struct ConstIndexTypeOrVoid : type_is<void> {};

      template <typename U>

      struct ConstIndexTypeOrVoid<U,

          std::void_t<decltype(*std::declval<const U&>()[0])>>

          : type_is<decltype(*std::declval<const U&>()[0])> {};

      using const_index_type_or_void_t = typename ConstIndexTypeOrVoid<>::type;

     public:

      IterIterWrapper() = default;

      explicit IterIterWrapper(size_type sz) : container(sz) {}

      IterIterWrapper(size_type sz, const contained_iter& val)

          : container(sz, val) {}

      auto at(size_type pos) -> decltype(*container.at(pos)) {

        return *container.at(pos);

      }

      auto at(size_type pos) const -> const_at_type_or_void_t {

        return *container.at(pos);

      }

      auto operator[](size_type pos) noexcept(noexcept(*container[pos]))

          -> decltype(*container[pos]) {

        return *container[pos];

      }

      auto operator[](size_type pos) const noexcept(noexcept(*container[pos]))

          -> const_index_type_or_void_t {

        return *container[pos];

      }

      bool empty() const noexcept {

        return container.empty();

      }

      size_type size() const noexcept {

        return container.size();

      }

      iterator begin() noexcept {

        return {container.begin()};

      }

      iterator end() noexcept {

        return {container.end()};

      }

      const_iterator begin() const noexcept {

        return {container.begin()};

      }

      const_iterator end() const noexcept {

        return {container.end()};

      }

      const_iterator cbegin() const noexcept {

        return {container.cbegin()};

      }

      const_iterator cend() const noexcept {

        return {container.cend()};

      }

      reverse_iterator rbegin() noexcept {

        return {container.rbegin()};

      }

      reverse_iterator rend() noexcept {

        return {container.rend()};

      }

      const_reverse_iterator rbegin() const noexcept {

        return {container.rbegin()};

      }

      const_reverse_iterator rend() const noexcept {

        return {container.rend()};

      }

      const_reverse_iterator crbegin() const noexcept {

        return {container.rbegin()};

      }

      const_reverse_iterator crend() const noexcept {

        return {container.rend()};

      }

      // get() exposes the underlying container.  this allows the

      // itertools to manipulate the iterators in the container

      // and should not be depended on anywhere else.

      Container& get() noexcept {

        return container;

      }

      const Container& get() const noexcept {

        return container;

      }

    };

  }

}

#endif