#pragma once

#ifndef TCG_IMAGE_ITERATOR_HPP

#define TCG_IMAGE_ITERATOR_HPP

// tcg includes

#include "../image_iterator.h"

#include "../pixel_ops.h"

namespace tcg {

//***************************************************************************

//    image_edge_iterator  implementation

//***************************************************************************

template <typename _adherence="" _iei_adherence_policy="" it,=""></typename>

template <typename img=""></typename>

image_edge_iterator<it, _adherence="">::image_edge_iterator(const Img &img, int x,</it,>

                                                         int y, int dirX,

                                                         int dirY)

    : m_lx_1(image_traits::width(img) - 1)

    , m_ly_1(image_traits::height(img) - 1)

    , m_wrap(image_traits::wrap(img))

    , m_pos(x, y)

    , m_dir(dirX, dirY)

    , m_outsideColor(image_traits::outsideColor(img))

    , m_elbowColor(m_outsideColor)

    , m_pix(image_traits::pixel(img, x, y))

    , m_turn(UNKNOWN) {

  pixels(m_leftPix, m_rightPix);

  colors(m_leftColor, m_rightColor);

}

//---------------------------------------------------------------------------------------------

template <typename _adherence="" _iei_adherence_policy="" it,=""></typename>

inline void image_edge_iterator<it, _adherence="">::pixels(iter pixLeft,</it,>

                                                        iter pixRight) {

  if (m_dir.y)

    if (m_dir.y > 0)

      pixLeft = m_pix - 1, pixRight = m_pix;

    else

      pixLeft = m_pix - m_wrap, pixRight = pixLeft - 1;

  else if (m_dir.x > 0)

    pixLeft = m_pix, pixRight = m_pix - m_wrap;

  else

    pixRight = m_pix - 1, pixLeft = pixRight - m_wrap;

}

//---------------------------------------------------------------------------------------------

template <typename _adherence="" _iei_adherence_policy="" it,=""></typename>

inline void image_edge_iterator<it, _adherence="">::colors(</it,>

    value_type &leftColor, value_type &rightColor) {

  if (m_dir.y)

    if (m_dir.y > 0) {

      if (m_pos.y > m_ly_1)

        leftColor = rightColor = m_outsideColor;

      else {

        leftColor  = (m_pos.x > 0) ? *m_leftPix : m_outsideColor;

        rightColor = (m_pos.x <= m_lx_1) ? *m_rightPix : m_outsideColor;

      }

    } else {

      if (m_pos.y < 1)

        leftColor = rightColor = m_outsideColor;

      else {

        leftColor  = (m_pos.x <= m_lx_1) ? *m_leftPix : m_outsideColor;

        rightColor = (m_pos.x > 0) ? *m_rightPix : m_outsideColor;

      }

    }

  else if (m_dir.x > 0) {

    if (m_pos.x > m_lx_1)

      leftColor = rightColor = m_outsideColor;

    else {

      leftColor  = (m_pos.y <= m_ly_1) ? *m_leftPix : m_outsideColor;

      rightColor = (m_pos.y > 0) ? *m_rightPix : m_outsideColor;

    }

  } else {

    if (m_pos.x < 1)

      leftColor = rightColor = m_outsideColor;

    else {

      leftColor  = (m_pos.y > 0) ? *m_leftPix : m_outsideColor;

      rightColor = (m_pos.y <= m_ly_1) ? *m_rightPix : m_outsideColor;

    }

  }

}

//---------------------------------------------------------------------------------------------

template <typename _adherence="" _iei_adherence_policy="" it,=""></typename>

inline void image_edge_iterator<it, _adherence="">::turn(</it,>

    const value_type &newLeftColor, const value_type &newRightColor,

    policy<right_adherence>) {</right_adherence>

  if (newLeftColor == m_rightColor) {

    if (newRightColor == m_leftColor)

      turnAmbiguous(newLeftColor, newRightColor);

    else

      turnLeft();

  } else {

    if (newRightColor != m_rightColor)

      turnRight();

    else

      m_turn = STRAIGHT;

  }

  m_elbowColor = newLeftColor;

  pixels(m_leftPix, m_rightPix);

}

//---------------------------------------------------------------------------------------------

template <typename _adherence="" _iei_adherence_policy="" it,=""></typename>

inline void image_edge_iterator<it, _adherence="">::turn(</it,>

    const value_type &newLeftColor, const value_type &newRightColor,

    policy<left_adherence>) {</left_adherence>

  if (newRightColor == m_leftColor) {

    if (newLeftColor == m_rightColor)

      turnAmbiguous(newLeftColor, newRightColor);

    else

      turnRight();

  } else {

    if (newLeftColor != m_leftColor)

      turnLeft();

    else

      m_turn = STRAIGHT;

  }

  m_elbowColor = newRightColor;

  pixels(m_leftPix, m_rightPix);

}

//---------------------------------------------------------------------------------------------

template <typename _adherence="" _iei_adherence_policy="" it,=""></typename>

inline void image_edge_iterator<it, _adherence="">::turnAmbiguous(</it,>

    const value_type &newLeftColor, const value_type &newRightColor) {

  UCHAR count1 = 0, count2 = 0;

  value_type val;

  // Check the 4x4 neighbourhood and connect the minority color

  if (m_pos.x > 2) {

    val = *(m_pix - 2);

    if (val == m_leftColor)

      ++count1;

    else if (val == m_rightColor)

      ++count2;

    val = *(m_pix - 2 - m_wrap);

    if (val == m_leftColor)

      ++count1;

    else if (val == m_rightColor)

      ++count2;

  }

  if (m_pos.x < m_lx_1) {

    val = *(m_pix + 1);

    if (val == m_leftColor)

      ++count1;

    else if (val == m_rightColor)

      ++count2;

    val = *(m_pix + 1 - m_wrap);

    if (val == m_leftColor)

      ++count1;

    else if (val == m_rightColor)

      ++count2;

  }

  if (m_pos.y > 2) {

    int wrap2 = m_wrap << 1;

    val = *(m_pix - wrap2);

    if (val == m_leftColor)

      ++count1;

    else if (val == m_rightColor)

      ++count2;

    val = *(m_pix - wrap2 - 1);

    if (val == m_leftColor)

      ++count1;

    else if (val == m_rightColor)

      ++count2;

  }

  if (m_pos.y < m_ly_1) {

    val = *(m_pix + m_wrap);

    if (val == m_leftColor)

      ++count1;

    else if (val == m_rightColor)

      ++count2;

    val = *(m_pix + m_wrap - 1);

    if (val == m_leftColor)

      ++count1;

    else if (val == m_rightColor)

      ++count2;

  }

  // Minority connection - join the one with less count

  if (count1 <= count2)

    turnRight();  // Join m_leftColor == newRightColor

  else if (count1 > count2)

    turnLeft();  // Join m_rightColor == newLeftColor

  m_turn |= AMBIGUOUS;

}

//---------------------------------------------------------------------------------------------

template <typename _adherence="" _iei_adherence_policy="" it,=""></typename>

void image_edge_iterator<it, _adherence="">::advance(policy<right_adherence>) {</right_adherence></it,>

  value_type newLeftColor = m_leftColor, newRightColor = m_rightColor;

  int pixAdd = m_dir.y * m_wrap + m_dir.x;

  m_pos.x += m_dir.x, m_pos.y += m_dir.y;

  m_pix += pixAdd, m_leftPix += pixAdd, m_rightPix += pixAdd;

  m_leftColor = newLeftColor;

  colors(newLeftColor, newRightColor);

  turn(newLeftColor, newRightColor);

  colors(m_leftColor, m_rightColor);

}

//---------------------------------------------------------------------------------------------

template <typename _adherence="" _iei_adherence_policy="" it,=""></typename>

void image_edge_iterator<it, _adherence="">::advance(policy<left_adherence>) {</left_adherence></it,>

  value_type newLeftColor = m_leftColor, newRightColor = m_rightColor;

  int pixAdd = m_dir.y * m_wrap + m_dir.x;

  m_pos.x += m_dir.x, m_pos.y += m_dir.y;

  m_pix += pixAdd, m_leftPix += pixAdd, m_rightPix += pixAdd;

  m_rightColor = newRightColor;

  colors(newLeftColor, newRightColor);

  turn(newLeftColor, newRightColor);

  colors(m_leftColor, m_rightColor);

}

}  // namespace tcg

#endif  // TCG_IMAGE_ITERATOR_HPP