#include "morphtool.h"

#include "tgl.h"

#include "tvectorgl.h"

#include "tvectorrenderdata.h"

#include "tvectorimage.h"

#include "tstroke.h"

#include <math.h></math.h>

#include "tools/toolhandle.h"

#include "toonz/txshlevelhandle.h"

#include "toonz/tframehandle.h"

#include "toonz/txshsimplelevel.h"

class Deformation

{

public:

	std::vector<tpointd> m_controlPoints;</tpointd>

	int m_selected;

	TAffine m_aff;

	std::vector<tpointd> m_delta;</tpointd>

	int getClosest(const TPointD &p) const;

	Deformation();

	void update()

	{

		TPointD p0 = m_controlPoints[0];

		TPointD p1 = m_controlPoints[2];

		TPointD p2 = m_controlPoints[4];

		double a00 = p0.x - p2.x, a01 = p1.x - p2.x, a10 = p0.y - p2.y, a11 = p1.y - p2.y;

		TAffine aff(a00, a01, 0, a10, a11, 0);

		aff = aff.inv();

		TPointD d = -(aff * p2);

		aff.a13 = d.x;

		aff.a23 = d.y;

		m_aff = aff;

		m_delta.resize(3);

		m_delta[0] = m_controlPoints[1] - p0;

		m_delta[1] = m_controlPoints[3] - p1;

		m_delta[2] = m_controlPoints[5] - p2;

	}

	TPointD apply(const TPointD &p, double t = 1.0)

	{

		TPointD d = m_aff * p;

		double c0 = d.x, c1 = d.y, c2 = 1 - c0 - c1;

		TPointD delta = c0 * m_delta[0] + c1 * m_delta[1] + c2 * m_delta[2];

		return p + delta * t;

	}

	void deform(TStroke *dstStroke, const TStroke *srcStroke, double t = 1.0)

	{

		int n = srcStroke->getControlPointCount();

		if (dstStroke->getControlPointCount() < n)

			n = dstStroke->getControlPointCount();

		for (int i = 0; i < n; i++) {

			TThickPoint srcPoint = srcStroke->getControlPoint(i);

			dstStroke->setControlPoint(i, apply(srcPoint, t));

		}

	}

	void deform(TVectorImage *dstImage, const TVectorImage *srcImage, double t = 1.0)

	{

		update();

		int n = srcImage->getStrokeCount();

		if ((int)dstImage->getStrokeCount() < n)

			n = dstImage->getStrokeCount();

		std::vector<int> ii(n);</int>

		std::vector<tstroke *=""> oldStrokes(n);</tstroke>

		for (int i = 0; i < n; i++) {

			ii[i] = i;

			oldStrokes[i] = srcImage->getStroke(i);

			deform(dstImage->getStroke(i), oldStrokes[i], t);

		}

		dstImage->notifyChangedStrokes(ii, oldStrokes);

	}

	void updateLevel()

	{

		TTool::Application *app = TTool::getApplication();

		if (!app->getCurrentLevel()->getLevel())

			return;

		TXshSimpleLevelP xl = app->getCurrentLevel()->getLevel()->getSimpleLevel();

		if (app->getCurrentFrame()->getFrameType() != TFrameHandle::LevelFrame)

			return;

		TFrameId fid = app->getCurrentFrame()->getFid();

		TVectorImageP src = xl->getFrame(fid, true);

		int count = src->getStrokeCount();

		for (int i = 1; i < 10; i++) {

			++fid;

			if (!xl->isFid(fid)) {

				TVectorImageP vi = new TVectorImage();

				xl->setFrame(fid, vi);

			}

			TVectorImageP vi = xl->getFrame(fid, true);

			TVectorImageP dst = src->clone();

			deform(dst.getPointer(), src.getPointer(), (double)i / (double)9);

			count = dst->getStrokeCount();

			vi->mergeImage(dst, TAffine());

			app->getCurrentTool()->getTool()->notifyImageChanged(fid);

		}

	}

};

Deformation::Deformation()

	: m_selected(-1)

{

	m_controlPoints.resize(6);

	m_controlPoints[0] = TPointD(-250, 100);

	m_controlPoints[2] = TPointD(0, -300);

	m_controlPoints[4] = TPointD(250, 100);

	for (int i = 0; i < 6; i += 2)

		m_controlPoints[i + 1] = m_controlPoints[i];

}

int Deformation::getClosest(const TPointD &p) const

{

	int k = -1;

	double closestD2 = 0;

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

		TPointD cp = m_controlPoints[i];

		double d2 = norm2(p - cp);

		if (k < 0 || d2 <= closestD2) {

			closestD2 = d2;

			k = i;

		}

	}

	return closestD2 < 100 ? k : -1;

}

Deformation deformation;

/*

TThickPoint deform(const TThickPoint &p)

{

  double r2 = p.x*p.x+p.y*p.y;

  double f = exp(-r2*0.001);

  return p + delta * f;

}

*/

MorphTool::MorphTool()

	: m_pixelSize(1)

{

}

MorphTool::~MorphTool()

{

}

void MorphTool::setImage(const TVectorImageP &vi)

{

	m_vi = vi;

}

void MorphTool::leftButtonDown(const TPointD &pos, const TMouseEvent &e)

{

	m_lastPos = m_firstPos = pos;

	int index = deformation.getClosest(pos);

	if (index >= 0)

		deformation.m_selected = index;

	else

		deformation.m_selected = -1;

	if (m_vi && index >= 0) {

		m_vi2 = m_vi->clone();

		deformation.deform(m_vi2.getPointer(), m_vi.getPointer());

	} else {

		m_vi2 = TVectorImageP();

	}

}

void MorphTool::leftButtonDrag(const TPointD &pos, const TMouseEvent &e)

{

	if (deformation.m_selected < 0)

		return;

	TPointD delta = pos - m_lastPos;

	m_lastPos = pos;

	deformation.m_controlPoints[deformation.m_selected] += delta;

	if ((deformation.m_selected & 1) == 0)

		deformation.m_controlPoints[deformation.m_selected + 1] += delta;

	if (m_vi2 && m_vi)

		deformation.deform(m_vi2.getPointer(), m_vi.getPointer());

}

void MorphTool::leftButtonUp(const TPointD &pos, const TMouseEvent &e)

{

	m_vi2 = TVectorImageP();

}

void MorphTool::draw()

{

	m_pixelSize = sqrt(tglGetPixelSize2());

	if (m_vi2) {

		TVectorRenderData rd(TTranslation(10, 10), TRect(), 0, 0);

		tglDraw(rd, m_vi2.getPointer());

	}

	double u = m_pixelSize * 5;

	for (int i = 0; i < (int)deformation.m_controlPoints.size(); i++) {

		TPointD p = deformation.m_controlPoints[i];

		bool selected = deformation.m_selected == i;

		bool base = (i & 1) == 0;

		if (base)

			if (selected)

				glColor3d(0.8, 0.8, 0.1);

			else

				glColor3d(0.5, 0.5, 0.1);

		else if (selected)

			glColor3d(0.8, 0.3, 0.1);

		else

			glColor3d(0.5, 0.1, 0.1);

		double r = base ? u * 2 : u * 1;

		tglDrawDisk(p, r);

		glColor3d(0, 0, 0);

		tglDrawCircle(p, r);

	}

	glColor3f(0, 1, 0);

	for (int i = 0; i + 1 < (int)deformation.m_controlPoints.size(); i += 2) {

		TPointD a = deformation.m_controlPoints[i];

		TPointD b = deformation.m_controlPoints[i + 1];

		tglDrawSegment(a, b);

	}

	/*

  deformation.update();

  glBegin(GL_LINES);

  for(double x = -200; x<=200; x+=20)

  for(double y = -200; y<=200; y+=20)

  {

    TPointD p0(x,y);

    TPointD p1 = deformation.apply(p0);

    glColor3d(0,1,0);

    tglVertex(p0);

    glColor3d(1,0,0);

    tglVertex(p1);

  }

  glEnd();

  */

}

bool MorphTool::keyDown(int key, TUINT32 flags, const TPoint &pos)

{

	if (key == 'A')

		deformation.updateLevel();

	else

		return false;

	return true;

}