#include "morphtool.h"
#include "tgl.h"
#include "tvectorgl.h"
#include "tvectorrenderdata.h"
#include "tvectorimage.h"
#include "tstroke.h"
#include <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;
	int m_selected;
	TAffine m_aff;
	std::vector<TPointD> m_delta;

	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);
		std::vector<TStroke *> oldStrokes(n);
		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;
}