#ifdef WIN32

#define NOMINMAX

#endif

#include "ext/OverallDesigner.h"

//#include "ext/StrokeParametricDeformer.h"

#include "ext/StrokeDeformation.h"

#include "ext/SmoothDeformation.h"

#include "ext/CornerDeformation.h"

#include "ext/StraightCornerDeformation.h"

#include "ext/Selector.h"

#include "ext/ContextStatus.h"

#include "tcurves.h"

#include <tstroke.h></tstroke.h>

#include <tgl.h></tgl.h>

#include <tgeometry.h></tgeometry.h>

#include <drawutil.h></drawutil.h>

#include <sstream></sstream>

/*

#ifdef  _DEBUG

#undef  _DEBUG

#define RESTORE_DEBUG

#endif

//*/

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

namespace

{

void extglDrawText(const TPointD &p,

				   const std::string &s,

				   void *character = GLUT_BITMAP_TIMES_ROMAN_10)

{

	glPushMatrix();

	glTranslated(p.x, p.y, 0);

	if (character <= GLUT_STROKE_MONO_ROMAN) {

		double factor = 0.07;

		glScaled(factor, factor, factor);

		for (int i = 0; i < (int)s.size(); i++)

			glutStrokeCharacter(character, s[i]);

	} else

		for (int i = 0; i < (int)s.size(); i++)

			glutBitmapCharacter(character, s[i]);

	glPopMatrix();

}

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

void drawSign(const TPointD &p,

			  const TPointD &v,

			  double size)

{

	if (size == 0.0)

		return;

	size = fabs(size);

	TPointD v90 = rotate90(v);

	TPointD v270 = rotate270(v);

	glBegin(GL_LINES);

	glVertex2d(p.x, p.y);

	v90 = normalize(v90);

	v90 = v90 * size;

	v90 = p + v90;

	glVertex2d(v90.x, v90.y);

	glEnd();

	glBegin(GL_LINES);

	glVertex2d(p.x, p.y);

	v270 = normalize(v270);

	v270 = v270 * size;

	v270 = p + v270;

	glVertex2d(v270.x, v270.y);

	glEnd();

}

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

void drawCross(const TPointD &p,

			   double size)

{

	TPointD

		v1 = TPointD(1, 1);

	TPointD

		v2 = TPointD(1, -1);

	drawSign(p, v1, size);

	drawSign(p, v2, size);

}

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

/**

   * Try to verify if it is possible to call

   * some method of this stroke.

   */

bool isValid(const TStroke *s)

{

	if (!s)

		return false;

	const int

		cpCount = s->getControlPointCount();

	int

		i;

	for (i = 0;

		 i < cpCount;

		 ++i)

		s->getControlPoint(i);

	const int

		chunkCount = s->getChunkCount();

	for (i = 0;

		 i < chunkCount;

		 ++i)

		s->getChunk(i);

	return true;

}

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

void showCP(const TStroke *s,

			double pixelSize)

{

	if (!s)

		return;

	// show control points

	const int

		countCP = s->getControlPointCount();

	TThickPoint

		p1;

	for (int i = 0;

		 i < countCP;

		 ++i) {

		p1 = s->getControlPoint(i);

		if (i & 1)

			glColor3d(1.0, 0.0, 0.0);

		else

			glColor3d(1.0, 1.0, 0.0);

		drawCross(convert(p1),

				  p1.thick * pixelSize);

		tglDrawCircle(convert(p1),

					  p1.thick * pixelSize);

	}

}

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

void drawStrokeCenterLine(const TStroke *stroke,

						  double pixelSize,

						  const ToonzExt::Interval &vals)

{

	double

		from = vals.first,

		to = vals.second;

	if (!stroke ||

		pixelSize < 0.0)

		return;

	from = std::max(std::min(from, 1.0), 0.0);

	to = std::max(std::min(to, 1.0), 0.0);

	if (from < to) {

		drawStrokeCenterline(*stroke,

							 pixelSize,

							 from,

							 to);

	} else {

		drawStrokeCenterline(*stroke,

							 pixelSize,

							 from,

							 1.0);

		drawStrokeCenterline(*stroke,

							 pixelSize,

							 0.0,

							 to);

	}

	tglDrawDisk(stroke->getPoint(from),

				5.0 * pixelSize);

	tglDrawDisk(stroke->getPoint(to),

				5.0 * pixelSize);

#ifdef _DEBUG

	glColor3d(1.0, 0.0, 0.0);

	tglDrawDisk(stroke->getPoint(0.0),

				9.0 * pixelSize);

#endif

}

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

void showCorners(const TStroke *s,

				 int cornerSize,

				 double pixelSize)

{

	if (!s)

		return;

	const TPointD

		offset(20, 20);

	// show corners

	vector<double></double>

		corners;

	ToonzExt::cornersDetector(s,

							  cornerSize,

							  corners);

	if (corners.empty())

		return;

	int

		i,

		size = corners.size();

	glColor3d(0.8, 1.0, 0.3);

	// find interval with corner like extremes

	for (i = 0;

		 i < size;

		 ++i) {

		double

			tmp = corners[i];

		TPointD

			pnt = s->getPoint(tmp);

		double

			large = 5.0;

		drawCross(pnt,

				  large * pixelSize);

		glColor3d(0.7, 0.7, 0.7);

		std::ostringstream oss;

		oss << "[" << tmp << "]";

		extglDrawText(TPointD(pnt.x, pnt.y) + offset, oss.str());

	}

	corners.clear();

	ToonzExt::straightCornersDetector(s,

									  corners);

	if (corners.empty())

		return;

	size = corners.size();

	glColor3d(0.8, 1.0, 0.3);

	// find interval with corner like extremes

	for (i = 0;

		 i < size;

		 ++i) {

		double

			tmp = corners[i];

		TPointD

			pnt = s->getPoint(tmp);

		double

			large = 5.0;

		drawCross(pnt,

				  large * pixelSize);

		glColor3d(0.7, 0.2, 0.2);

		std::ostringstream oss;

		oss << "[" << tmp << "]";

		extglDrawText(TPointD(pnt.x, pnt.y) - offset, oss.str());

	}

}

}

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

ToonzExt::OverallDesigner::OverallDesigner(int x,

										   int y)

	: x_(x), y_(y)

{

	pixelSize_ = sqrt(this->getPixelSize2());

	scale_ = pixelSize_ != 0.0 ? pixelSize_ : 1.0;

}

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

ToonzExt::OverallDesigner::~OverallDesigner()

{

}

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

void ToonzExt::OverallDesigner::draw(ToonzExt::SmoothDeformation *sd)

{

#ifdef _DEBUG

	glPushMatrix();

	{

		this->setPosition();

		TCubic c;

		c.setP0(TPointD(0.0, 0.0));

		c.setP1(TPointD(4.0, 12.0));

		c.setP2(TPointD(12.0, 12.0));

		c.setP3(TPointD(16.0, 0.0));

		glColor3d(1.0, 0.0, 1.0);

		tglDraw(c, 100, GL_LINE);

	}

	glPopMatrix();

#endif

}

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

void ToonzExt::OverallDesigner::draw(ToonzExt::CornerDeformation *sd)

{

#ifdef _DEBUG

	glPushMatrix();

	{

		this->setPosition();

		TCubic c;

		c.setP0(TPointD(0.0, 0.0));

		c.setP1(TPointD(0.0, 12.0));

		c.setP2(TPointD(6.0, 12.0));

		c.setP3(TPointD(12.0, 12.0));

		glColor3d(1.0, 0.0, 1.0);

		tglDraw(c, 100, GL_LINE);

		c.setP0(TPointD(12.0, 12.0));

		c.setP1(TPointD(6.0, 8.0));

		c.setP2(TPointD(6.0, 4.0));

		c.setP3(TPointD(12.0, 0.0));

		tglDraw(c, 100, GL_LINE);

	}

	glPopMatrix();

#endif

}

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

void ToonzExt::OverallDesigner::draw(ToonzExt::StraightCornerDeformation *sd)

{

#ifdef _DEBUG

	glPushMatrix();

	{

		this->setPosition();

		glColor3d(0.0, 1.0, 1.0);

		glBegin(GL_LINE_STRIP);

		tglVertex(TPointD(0.0, 0.0));

		tglVertex(TPointD(8.0, 12.0));

		tglVertex(TPointD(16.0, 0.0));

		glEnd();

	}

	glPopMatrix();

#endif

}

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

void ToonzExt::OverallDesigner::draw(ToonzExt::StrokeDeformation *sd)

{

	if (sd) {

		const TStroke *

			s;

		//glColor3d(1.0,0.0,1.0);

		s = sd->getCopiedStroke();

		if (s) {

			const ContextStatus *

				status = sd->getStatus();

			double

				w = 0.0,

				pixelSize = 1.0;

			if (status) {

				w = status->w_;

				pixelSize = status->pixelSize_ < 0 ? 1.0 : status->pixelSize_;

			}

#ifdef _DEBUG

			drawCross(s->getPoint(0),

					  2 * pixelSize);

			tglDrawCircle(s->getPoint(w), 8 * pixelSize);

			drawCross(s->getPoint(w), 8 * pixelSize);

#endif

			ToonzExt::Interval

				ex = sd->getExtremes();

			drawStrokeCenterLine(s,

								 pixelSize_,

								 ex);

			if (status) {

#ifdef _DEBUG

				glColor3d(0, 0, 0);

				showCorners(s,

							status->cornerSize_,

							pixelSize);

				glColor3d(0, 0, 0);

				TPointD

					offset = normalize(TPointD(1.0, 1.0)) * 20.0;

				std::ostringstream oss;

				oss << "(" << this->x_

					<< "," << this->y_

					<< ")\n{" << w

					<< ",{" << sd->getExtremes().first

					<< "," << sd->getExtremes().second

					<< "}}";

				extglDrawText(TPointD(x_, y_) + offset, oss.str());

				glColor3d(0.5, 1.0, 0.5);

				showCP(s,

					   pixelSize);

#endif

			}

		}

		/*

    glColor3d(1.0,1.0,0.0);

    s = sd->getStroke();

    if(s)

    {

      drawCross( s->getPoint(0),

                 4);

      drawStrokeCenterLine(s,

                           pixelSize_,

                           ToonzExt::Interval(0,1));

    }

    */

		s = sd->getTransformedStroke();

		glColor3d(1.0, 0.0, 0.0);

		if (s) {

#ifdef _DEBUG

			isValid(s);

#endif

			drawStrokeCenterline(*s,

								 pixelSize_);

		}

#ifdef _DEBUG

		{

			const TStroke

				*c = sd->getCopiedStroke(),

				*s = sd->getStroke();

			if (c && s) {

				//glColor3d(1,1,0);

				//tglDrawDisk(s->getPoint(0.0),

				//            5*pixelSize_);

				int count = std::min(c->getControlPointCount(),

									 s->getControlPointCount());

				for (int i = 0;

					 i < count;

					 ++i) {

					TThickPoint

						ccp = c->getControlPoint(i);

					TThickPoint

						scp = s->getControlPoint(i);

				}

			}

		}

#endif

	}

}

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

void ToonzExt::OverallDesigner::setPosition()

{

	TPointD

		offset(1, -1);

	offset = normalize(offset) * (20.0 * scale_);

	glTranslated(x_ + offset.x,

				 y_ + offset.y,

				 0.0);

	glScalef(scale_,

			 scale_,

			 scale_);

}

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

void ToonzExt::OverallDesigner::draw(ToonzExt::Selector *selector)

{

	if (!selector)

		return;

	const TStroke *

		ref = selector->getStroke();

	if (!ref)

		return;

	double

		length_at_w = ref->getLength(selector->getW()),

		emi_selector_length = selector->getLength() * 0.5,

		stroke_length = ref->getLength();

	ToonzExt::Interval

		interval;

	if (ref->isSelfLoop()) {

		interval.first = length_at_w - emi_selector_length;

		if (interval.first < 0.0)

			interval.first = stroke_length + interval.first;

		interval.first = ref->getParameterAtLength(interval.first);

		interval.second = length_at_w + emi_selector_length;

		if (interval.second > stroke_length)

			interval.second = interval.second - stroke_length;

		interval.second = ref->getParameterAtLength(interval.second);

	} else {

		interval.first = ref->getParameterAtLength(std::max(0.0, length_at_w - emi_selector_length));

		interval.second = ref->getParameterAtLength(std::min(stroke_length, length_at_w + emi_selector_length));

	}

	float

		prev_line_width = 1.0;

	glGetFloatv(GL_LINE_WIDTH,

				&prev_line_width);

	glLineWidth(2.0);

	drawStrokeCenterLine(ref,

						 pixelSize_,

						 interval);

	glLineWidth(prev_line_width);

}

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

//  End Of File

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

/*

#ifdef  RESTORE_DEBUG

#undef  RESTORE_DEBUG

#define _DEBUG  1

#endif

//*/