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