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

#pragma once

#include <iterator>

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

#include <iterator/detail/macro.h>

namespace iterator {
template <typename It>
class indexed_iterator : public facade<indexed_iterator<It>> {
public:
  using reference = std::pair<size_t, DEREF_TYPE(It)>;
  using difference_type = typename std::iterator_traits<It>::difference_type;

private:
  using super_t = facade<indexed_iterator<It>>;

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

  template <typename O>
  indexed_iterator(indexed_iterator<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(indexed_iterator const & other) const {
    return base_ == other.base_;
  }

  difference_type distance_to(indexed_iterator 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 indexed_iterator;
  It base_;
  size_t index_{0};
};

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