#ifndef TCG_IMAGE_ITERATOR_H
#define TCG_IMAGE_ITERATOR_H

// tcg includes
#include "tcg_ptr.h"
#include "tcg_image_ops.h"
#include "tcg_point.h"

// STD includes
#include <iterator>

namespace tcg {

//*********************************************************************************************************
//    Image Iterator  class
//*********************************************************************************************************

/*!
  The image_iterator class models an iterator accessing pixels of an image along
  its rows.
*/

template <typename It>
class image_iterator : public iterator_traits<It>::inheritable_iterator_type {
  typedef typename iterator_traits<It>::inheritable_iterator_type iter;

public:
  typedef typename iter::iterator_category iterator_category;
  typedef typename iter::value_type value_type;
  typedef typename iter::difference_type difference_type;
  typedef typename iter::pointer pointer;
  typedef typename iter::reference reference;

public:
  image_iterator() {}

  template <typename Img>
  image_iterator(const Img &img, int x, int y)
      : iter(image_traits<Img>::pixel(img, x, y))
      , m_base(image_traits<Img>::pixel(img, 0, 0))
      , m_lx(image_traits<Img>::width(img))
      , m_ly(image_traits<Img>::height(img))
      , m_wrap(image_traits<Img>::wrap(img))
      , m_skew(m_wrap - lx) {}

  int x() const { return (iter::operator-(m_base)) % m_wrap; }
  int y() const { return (iter::operator-(m_base)) / m_wrap; }

  image_iterator &operator++() {
    iter::operator++();
    if (x() >= m_lx) iter::operator+=(m_skew);
    return *this;
  }
  image_iterator operator++(int) {
    image_iterator it(*this);
    operator++();
    return it;
  }

  image_iterator &operator--() {
    iter::operator--();
    if (x() < 0) iter::operator-=(m_skew);
    return *this;
  }
  image_iterator operator--(int) {
    image_iterator it(*this);
    operator--();
    return it;
  }

  image_iterator &operator+=(difference_type d) {
    int yCount = (x() + d) / m_lx;
    iter::operator+=((d - yCount * m_lx) + yCount * m_wrap);
    return *this;
  }
  image_iterator operator+(difference_type d) const {
    image_iterator it(*this);
    it += d;
    return it;
  }

  image_iterator operator-(difference_type d) const { return operator+(-d); }
  image_iterator &operator-=(difference_type d) { return operator+=(-d); }

  difference_type operator-(const image_iterator &other) const {
    return (x() - other.x()) + m_lx * (y() - other.y());
  }

  reference operator[](difference_type d) const {
    const image_iterator &it = operator+(d);
    return *it;
  }

protected:
  iter m_base;
  int m_lx, m_ly, m_wrap, m_skew;
};

//*********************************************************************************************************
//    image_edge_iterator class
//*********************************************************************************************************

enum _iei_adherence_policy { LEFT_ADHERENCE, RIGHT_ADHERENCE };

/*!
  The image_edge_iterator class models a forward iterator following the contour
  of
  an image area of uniform color.
*/

template <typename It, _iei_adherence_policy _adherence = RIGHT_ADHERENCE>
class image_edge_iterator {
  typedef typename iterator_traits<It>::inheritable_iterator_type iter;

public:
  typedef std::forward_iterator_tag iterator_category;
  typedef typename iter::value_type value_type;
  typedef typename iter::difference_type difference_type;
  typedef typename iter::pointer pointer;
  typedef typename iter::reference reference;

public:
  enum { adherence = _adherence };

  enum Direction {
    STRAIGHT        = 0x0,
    LEFT            = 0x1,
    RIGHT           = 0x2,
    AMBIGUOUS       = 0x4,
    UNKNOWN         = 0x8,
    AMBIGUOUS_LEFT  = LEFT | AMBIGUOUS,
    AMBIGUOUS_RIGHT = RIGHT | AMBIGUOUS
  };

public:
  image_edge_iterator() {}

  template <typename Img>
  image_edge_iterator(const Img &img, int x, int y, int dirX, int dirY);

  const Point &pos() const { return m_pos; }
  const Point &dir() const { return m_dir; }

  const value_type &leftColor() const { return m_leftColor; }
  const value_type &rightColor() const { return m_rightColor; }

  const value_type &color() const { return color(policy<_adherence>()); }
  const value_type &oppositeColor() const {
    return oppositeColor(policy<_adherence>());
  }
  const value_type &elbowColor() const { return m_elbowColor; }

  iter leftPixel() const { return m_leftPix; }
  iter rightPixel() const { return m_rightPix; }

  iter pixel() const { return pixel(policy<_adherence>()); }
  iter oppositePixel() const { return oppositePixel(policy<_adherence>()); }

  Direction turn() const { return Direction(m_turn); }

public:
  // Iterator functions

  bool operator==(const image_edge_iterator &it) const {
    return (m_pos == it.m_pos) && (m_dir == it.m_dir);
  }
  bool operator!=(const image_edge_iterator &it) const {
    return !operator==(it);
  }

  image_edge_iterator &operator++() {
    advance(policy<_adherence>());
    return *this;
  }
  image_edge_iterator operator++(int) {
    image_edge_iterator temp(*this);
    operator++();
    return temp;
  }

private:
  void pixels(iter pixLeft, iter pixRight);
  void colors(value_type &leftColor, value_type &rightColor);

  void turnLeft() {
    int temp = m_dir.x;
    m_dir.x  = -m_dir.y;
    m_dir.y  = temp;
    m_turn   = LEFT;
  }
  void turnRight() {
    int temp = m_dir.x;
    m_dir.x  = m_dir.y;
    m_dir.y  = -temp;
    m_turn   = RIGHT;
  }

  void turn(const value_type &newLeftColor, const value_type &newRightColor) {
    turn(newLeftColor, newRightColor, policy<_adherence>());
  }
  void turnAmbiguous(const value_type &newLeftColor,
                     const value_type &newRightColor);

private:
  template <_iei_adherence_policy>
  struct policy {};

  const value_type &color(policy<LEFT_ADHERENCE>) const { return m_leftColor; }
  const value_type &color(policy<RIGHT_ADHERENCE>) const {
    return m_rightColor;
  }

  const value_type &oppositeColor(policy<LEFT_ADHERENCE>) const {
    return m_rightColor;
  }
  const value_type &oppositeColor(policy<RIGHT_ADHERENCE>) const {
    return m_leftColor;
  }

  iter pixel(policy<LEFT_ADHERENCE>) const { return m_leftPix; }
  iter pixel(policy<RIGHT_ADHERENCE>) const { return m_rightPix; }

  iter oppositePixel(policy<LEFT_ADHERENCE>) const { return m_rightPix; }
  iter oppositePixel(policy<RIGHT_ADHERENCE>) const { return m_leftPix; }

  void turn(const value_type &newLeftColor, const value_type &newRightColor,
            policy<LEFT_ADHERENCE>);
  void turn(const value_type &newLeftColor, const value_type &newRightColor,
            policy<RIGHT_ADHERENCE>);

  void advance(policy<LEFT_ADHERENCE>);
  void advance(policy<RIGHT_ADHERENCE>);

private:
  int m_lx_1, m_ly_1, m_wrap;

  Point m_pos, m_dir;

  value_type m_leftColor, m_rightColor, m_outsideColor, m_elbowColor;
  iter m_pix, m_leftPix, m_rightPix;

  int m_turn;
};

}  // namespace tcg

#endif  // TCG_IMAGE_ITERATOR_H

//=====================================================================================

#ifdef INCLUDE_HPP
#include "hpp/image_iterator.hpp"
#endif  // INCLUDE_HPP