#pragma once

#include <iterator>

#include "facade.h"

namespace iterator {
  template <typename Iter, typename Self,
            typename Category =
                typename std::iterator_traits<Iter>::iterator_category>
  class proxy;

  template <typename Iter, typename Self>
  class proxy<Iter, Self, std::input_iterator_tag> : public facade<Self> {
  public:
    using single_pass_iterator = void;

  private:
    Iter impl_;

  public:
    proxy(Iter impl = {}) : impl_(impl) {}
    template <typename... Args>
    proxy(Args &&... args) : impl_(std::forward<Args>(args)...) {}

    decltype(auto) dereference() const { return *impl_; }
    void increment() { ++impl_; }
    bool equal_to(Self const & other) const { return impl_ == other.impl_; }

  protected:
    auto & impl() const { return impl_; }
  };

  template <typename Iter, typename Self>
  class proxy<Iter, Self, std::forward_iterator_tag> : public facade<Self> {
  private:
    Iter impl_;

  public:
    proxy(Iter impl = {}) : impl_(impl) {}
    template <typename... Args>
    proxy(Args &&... args) : impl_(std::forward<Args>(args)...) {}

    decltype(auto) dereference() const { return *impl_; }
    void increment() { ++impl_; }
    bool equal_to(Self const & other) const { return impl_ == other.impl_; }

  protected:
    auto & impl() const { return impl_; }
  };

  template <typename Iter, typename Self>
  class proxy<Iter, Self, std::bidirectional_iterator_tag>
      : public facade<Self> {
  private:
    Iter impl_;

  public:
    proxy(Iter impl = {}) : impl_(impl) {}
    template <typename... Args>
    proxy(Args &&... args) : impl_(std::forward<Args>(args)...) {}

    decltype(auto) dereference() const { return *impl_; }
    void increment() { ++impl_; }
    void decrement() { --impl_; }
    bool equal_to(Self const & other) const { return impl_ == other.impl_; }

  protected:
    auto & impl() const { return impl_; }
  };

  template <typename Iter, typename Self>
  class proxy<Iter, Self, std::random_access_iterator_tag>
      : public facade<Self> {
  public:
    using difference_type =
        typename std::iterator_traits<Iter>::difference_type;

  private:
    Iter impl_;

  public:
    proxy(Iter impl = {}) : impl_(impl) {}
    template <typename... Args>
    proxy(Args &&... args) : impl_(std::forward<Args>(args)...) {}

    decltype(auto) dereference() const { return *impl_; }
    void advance(difference_type off) { impl_ += off; }
    // This shouldn't need to be implemented, but for some reason my traits
    // are not correctly deducing here.
    bool equal_to(Self const & other) const { return distance_to(other) == 0; }
    difference_type distance_to(Self const & other) const {
      return other.impl_ - impl_;
    }

  protected:
    auto & impl() const { return impl_; }
  };
}