//
//  indexed_iterator.h
//  iterator
//
//  Created by Sam Jaffe on 3/5/17.
//

#pragma once

#include <iterator>

#include <iterator/facade.h>
#include <iterator/forwards.h>

namespace iterator {
template <typename It>
class EnumerateIterator : public Facade<EnumerateIterator<It>> {
public:
  using reference = std::pair<size_t, std::iter_reference_t<It>>;
  using difference_type = typename std::iterator_traits<It>::difference_type;

private:
  using super_t = Facade<EnumerateIterator<It>>;

public:
  EnumerateIterator() = default;
  EnumerateIterator(It base) : base_(base) {}
  EnumerateIterator(It base, size_t idx) : base_(base), index_(idx) {}

  template <typename O>
  EnumerateIterator(EnumerateIterator<O> const & oiter)
      : base_(oiter.base_), index_(oiter.index_) {}

  reference dereference() const { return {index_, *base_}; }

  void increment()
    requires(std::forward_iterator<It>)
  {
    ++base_;
    ++index_;
  }

  void decrement()
    requires(std::bidirectional_iterator<It>)
  {
    --base_;
    --index_;
  }

  void advance(difference_type off)
    requires(std::random_access_iterator<It>)
  {
    base_ += off;
    index_ += off;
  }

  bool equal_to(EnumerateIterator const & other) const {
    return base_ == other.base_;
  }

  difference_type distance_to(EnumerateIterator const & other) const
    requires(std::random_access_iterator<It>)
  {
    return other.base_ - base_;
  }

  bool at_end() const
    requires(has_sentinel<It>)
  {
    return base_ == typename It::sentinel_type();
  }

private:
  template <typename O> friend class EnumerateIterator;
  It base_;
  size_t index_{0};
};

template <typename It> EnumerateIterator(It) -> EnumerateIterator<It>;
template <typename It> EnumerateIterator(It, size_t) -> EnumerateIterator<It>;
}