#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
//-----------------------------------------------------------------------------