#include "ext/Selector.h"

#include "tgl.h"

//#include "drawutil.h"

#include "tmathutil.h"

using namespace ToonzExt;

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

namespace {

const GLfloat s_normalColor[]      = {250.0 / 255.0, 127 / 255.0, 240 / 255.0};

const GLfloat s_highlightedColor[] = {150.0 / 255.0, 255.0 / 255.0,

                                      140.0 / 255.0};

const double s_sqrt_2      = sqrt(2.0);

const double s_radius      = 5.0;

const double s_over_size   = 10;

const double s_length      = 15;

const double s_square_size = 5;

const double s_arrow_ratio = 2.5;

void drawArrow(const TPointD &from, const TPointD &direction, double length,

               const TPointD &arrowDirection = TPointD(0.0, -1.0),

               double arrowLength            = 0.0) {

  if (length <= 0 || arrowLength < 0) return;

  if (arrowLength == 0.0) arrowLength = 0.2 * length;

  TPointD pnt(from), myDir = normalize(direction);

  TPointD myArrowDirection(arrowDirection);

  if (arrowDirection.y <= 0.0) myArrowDirection = normalize(TPointD(-0.5, 0.8));

  if (direction * TPointD(1, 0) <= 0.0)

    myArrowDirection.x = -myArrowDirection.x;

  myDir            = myDir * length;

  myArrowDirection = myArrowDirection * arrowLength;

  glBegin(GL_LINES);

  tglVertex(pnt);

  pnt += myDir;

  tglVertex(pnt);

  glEnd();

  glBegin(GL_TRIANGLES);

  TPointD up = myDir + myArrowDirection;

  tglVertex(from + up);

  // tglVertex(pnt);

  tglVertex(pnt);

  myArrowDirection.y = -myArrowDirection.y;

  TPointD down       = myDir + myArrowDirection;

  tglVertex(from + down);

  glEnd();

}

}

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

Selector::Selector(double stroke_length, double min_val, double max_val) {

  original_stroke_length_ = stroke_length;

  range_                  = TPointD(min_val, max_val);

  isVisible_              = false;

  pixel_size_             = 1.0;

  w_                      = 0.5;

  this->init();

}

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

void Selector::init() {

  strokeRef_  = 0;

  signum_     = 1.0;

  isSelected_ = NONE;

}

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

Selector::~Selector() {}

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

TPointD Selector::getUp() const {

  if (!strokeRef_) return TPointD();

  TThickPoint pnt = strokeRef_->getPoint(w_);

  TPointD p = convert(pnt), p1;

  TPointD v0, v1, v = normalize(rotate90(strokeRef_->getSpeed(w_)));

  const double delta = TConsts::epsilon;

  if (w_ - delta >= 0.0)

    v0 = rotate90(strokeRef_->getSpeed(w_ - delta));

  else

    v0 = rotate90(strokeRef_->getSpeed(0));

  if (w_ + delta <= 1.0)

    v1 = rotate90(strokeRef_->getSpeed(w_ + delta));

  else

    v1 = rotate90(strokeRef_->getSpeed(1.0));

  if (!isAlmostZero(v * v0) || !isAlmostZero(v * v1)) v = normalize(v1 + v0);

  return v;

}

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

void Selector::draw(Designer *designer) {

  if (!strokeRef_ || !isVisible_) return;

  pixel_size_ = designer ? sqrt(designer->getPixelSize2()) : 1.0;

  TPointD v = this->getUp(), n = normalize(rotate90(v));

  TThickPoint pnt = strokeRef_->getThickPoint(w_);

  height_ = (pnt.thick + s_over_size) * pixel_size_;

  TPointD p(pnt.x, pnt.y), up = p + v * height_, down = p - v * height_;

  glColor3fv(s_normalColor);

  glBegin(GL_LINES);

  tglVertex(down);

  tglVertex(up);

  glEnd();

  if (isSelected_ == POSITION)

    glColor3fv(s_highlightedColor);

  else

    glColor3fv(s_normalColor);

  double radius = s_radius * pixel_size_;

  if (isSelected_ == POSITION) tglDrawDisk(up + v * radius, radius);

  tglDrawCircle(up + v * radius, radius);

  if (isSelected_ == LENGTH)

    glColor3fv(s_highlightedColor);

  else

    glColor3fv(s_normalColor);

  {

    // the circle center is in

    TPointD down = -this->getUp(), center = pnt + down * (height_);

    const double length = s_square_size * 0.5 * pixel_size_;

    TPointD

        //  offset(length, 0.0),

        offset(length, length),

        bottom_left = center - offset, top_rigth = center + offset;

    TRectD rectangle(bottom_left, top_rigth);

    if (isSelected_ == LENGTH) tglFillRect(rectangle);

    tglDrawRect(rectangle);

  }

  /*

TPointD

arrowDirection(-0.5,0.8);

if( signum_ < 0.0 )

arrowDirection.x = -arrowDirection.x;

const double

length = s_length  * pixel_size_,

arrow_length = length/s_arrow_ratio;

drawArrow(down,

      TPointD(1,0),

      length,

      arrowDirection,

      arrow_length);

drawArrow(down,

      TPointD(-1,0),

      length,

      arrowDirection,

      arrow_length);

*/

  // draw stroke related information

  if (designer && this->isSelected()) designer->draw(this);

#if 0  // def  _DEBUG

  {

  TThickPoint

    pnt = strokeRef_->getThickPoint(w_);

  TPointD

      up = this->getUp(),

      down = -up;

  double

    radius = s_radius * pixel_size_;

  // the circle center is in 

  TPointD 

    center = pnt + up * ( height_ + radius);

  glColor3d(1.0,0.0,1.0);

  tglDrawCircle(center,radius+pixel_size_);

  // one pixel of tolerance

  center = pnt + down * ( height_ );

  const double

    length = s_length * pixel_size_;

  TPointD

    offset(length, 0.0),

    bottom_left = center - offset,

    top_rigth   = center + offset;

  TRectD

    rectangle(bottom_left,

              top_rigth);

  rectangle = rectangle.enlarge( 2.0* pixel_size_);

  tglDrawRect(rectangle);

  }

#endif

}

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

void Selector::mouseDown(const TPointD &pos) {

  click_ = curr_ = pos;

  if (!strokeRef_) return;

  stroke_length_ = original_stroke_length_;

  prev_          = curr_;

}

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

void Selector::mouseUp(const TPointD &pos) {

  curr_ = pos;

  if (!strokeRef_) return;

  original_stroke_length_ = stroke_length_;

  prev_                   = curr_;

}

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

void Selector::mouseMove(const TPointD &pos) {

  curr_ = pos;

  if (!strokeRef_) return;

  isSelected_ = this->getSelection(pos);

  prev_       = curr_;

}

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

void Selector::mouseDrag(const TPointD &pos) {

  curr_ = pos;

  if (!strokeRef_) return;

  double val = original_stroke_length_;

  const double stroke_length = strokeRef_->getLength();

  double max_val = std::min(stroke_length, range_.y);

  TPointD v = curr_ - prev_;

  signum_ = 1.0;

  switch (isSelected_) {

  case POSITION:

    w_ = strokeRef_->getW(pos);

    break;

  case LENGTH:

    signum_        = v * TPointD(1.0, 0.0) < 0.0 ? -1.0 : 1.0;

    val            = original_stroke_length_ + signum_ * pixel_size_ * norm(v);

    stroke_length_ = std::max(std::min(max_val, val), range_.x);

    break;

  default:

    assert(false);

  }

  prev_ = curr_;

}

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

void Selector::setStroke(const TStroke *ref) {

  // if(strokeRef_  &&

  //   strokeRef_ != ref )

  //  w_=strokeRef_->getParameterAtLength( strokeRef_->getLength()*0.5);

  // else

  //  w_=0.5;

  this->init();

  strokeRef_ = ref;

}

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

Selector::Selection Selector::getSelection(const TPointD &pos) {

  if (!strokeRef_ || !isVisible_) return NONE;

  TThickPoint pnt = strokeRef_->getThickPoint(w_);

  TPointD up = this->getUp(), down = -up;

  double radius = s_radius * pixel_size_;

  // the circle center is in

  TPointD center = pnt + up * (height_ + radius);

  // one pixel of tolerance

  if (tdistance2(center, pos) <= sq(radius + pixel_size_)) return POSITION;

  center = pnt + down * (height_);

  // const double  length = s_length * pixel_size_;

  const double length = s_square_size * 0.5 * pixel_size_;

  TPointD

      //  offset(length, 0.0),

      offset(length, length),

      bottom_left = center - offset, top_rigth = center + offset;

  TRectD rectangle(bottom_left, top_rigth);

  rectangle = rectangle.enlarge(2.0 * pixel_size_);

  if (rectangle.contains(pos)) return LENGTH;

  return NONE;

}

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

double Selector::getLength() const { return stroke_length_; }

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

void Selector::setLength(double length) {

  stroke_length_ = original_stroke_length_ = length;

}

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

//  End Of File

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