#ifdef WIN32

#define NOMINMAX

#endif

#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

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