/**
 * @author  Fabrizio Morciano <fabrizio.morciano@gmail.com>
 */
#ifdef _DEBUG
#define _STLP_DEBUG 1
#endif
 
#include "ext/StrokeDeformationImpl.h"
#include "ext/StrokeDeformation.h"
#include "ext/SquarePotential.h"
#include "ext/StrokeParametricDeformer.h"
//#include "ext/NotSimmetricBezierPotential.h"
#include "ext/ContextStatus.h"
#include "ext/Designer.h"
//#include "ext/TriParam.h"
 
#include <tcurves.h>
#include <tstrokeutil.h>
//#include <tvectorimage.h>
#include <tmathutil.h>
 
#include <algorithm>
#include <iterator>
#include <vector>
 
#include "DeformationSelector.h"
 
using namespace ToonzExt;
 
namespace
{
 
/*
   * Avoid to reduce curves with great zoom out.
   * assert that pixelSize and factor > 0.0
   */
double
computeReductionFactor(double pixelSize,
					   double factor)
{
	assert(pixelSize > 0.0 &&
		   factor > 0.0);
	if (factor <= 0.0)
		factor = 1.0;
	if (pixelSize <= 0.0 ||
		pixelSize > 1.0)
		pixelSize = 1.0;
	return pixelSize * factor;
}
 
//---------------------------------------------------------------------------
double
retrieveParamAtLengthWithOffset(const TStroke *stroke2change,
								double length, // = 0.5 * strokeLength,
								double offset)
{
	if (!isValid(stroke2change) ||
		!isValid(offset) ||
		length < 0)
		return -1;
 
	double
		strokeLength = stroke2change->getLength();
	assert(strokeLength >= 0.0 &&
		   "Not valid length");
	if (strokeLength < 0) {
		return -1;
	}
 
	double
		lengthAtW = stroke2change->getLength(offset);
 
	assert(strokeLength >= lengthAtW &&
		   "Position of parameter is greater than stroke length!!!");
 
	if (strokeLength < lengthAtW)
		return -1;
 
	double
		newLength = -1;
 
	if (stroke2change->isSelfLoop()) {
		if (length >= 0)
			newLength = length > lengthAtW ? length + lengthAtW : lengthAtW - length;
	} else
		newLength = std::min(length + lengthAtW,
							 strokeLength);
 
	return stroke2change->getParameterAtLength(newLength);
}
 
//---------------------------------------------------------------------------
 
bool rotateStroke(const TStroke *stroke2change,
				  TStroke *&rotated,
				  double &from,
				  double &to,
				  TPointD &old_w0_pos)
{
	if (!stroke2change ||
		!isValid(from) ||
		!isValid(to))
		return false;
 
	rotated = 0;
 
	// save position of w=0 (useful to retrieve this
	//  position after changes)
	old_w0_pos = convert(stroke2change->getControlPoint(0));
 
	double
		rotateAtLength = stroke2change->getLength(to);
 
	assert(rotateAtLength >= 0.0);
	if (rotateAtLength < 0)
		return false;
 
	//TStroke*
	rotated = ToonzExt::rotateControlPoint(stroke2change,
										   ToonzExt::EvenInt(0),
										   rotateAtLength);
	if (!rotated)
		return false;
 
	from = rotated->getW(stroke2change->getPoint(from));
	to = rotated->getW(stroke2change->getPoint(to));
 
	// save some other information (style, etc..)
	ToonzExt::cloneStrokeStatus(stroke2change,
								rotated);
	return true; //rotated;
}
 
//---------------------------------------------------------------------------
 
TStroke *
rotateControlPointAtPoint(const TStroke *stroke,
						  const TPointD &pnt)
{
	if (!stroke ||
		tdistance2(stroke->getPoint(0.0),
				   pnt) < sq(TConsts::epsilon))
		return 0;
 
	double
		w = stroke->getW(pnt);
	TPointD
		theSamePnt = stroke->getPoint(w);
	double
		length = stroke->getLength(w);
	return ToonzExt::rotateControlPoint(stroke,
										ToonzExt::EvenInt(0),
										length);
}
 
//---------------------------------------------------------------------------
 
bool findExtremesFromActionLength(double toolActionLength,
								  const TStroke *stroke,
								  double w,
								  ToonzExt::Interval &out)
{
	out = ToonzExt::Interval(-1.0, -1.0);
 
	if (!stroke ||
		0.0 > w ||
		w > 1.0)
		return false;
 
	double
		emiToolSize = 0.5 * toolActionLength;
	double
		strokelength = stroke->getLength();
	double
		lengthAtParam = stroke->getLength(w);
 
	assert(emiToolSize >= 0.0 &&
		   strokelength >= 0.0 &&
		   lengthAtParam >= 0.0);
 
	if (emiToolSize > strokelength * 0.5) {
		if (stroke->isSelfLoop()) {
			emiToolSize = strokelength * 0.5;
 
			// first and second are the same
			lengthAtParam += emiToolSize;
 
			if (lengthAtParam > strokelength)
				lengthAtParam -= strokelength;
			out.first =
				out.second = stroke->getParameterAtLength(lengthAtParam);
		} else {
			out.first = 0.0;
			out.second = 1.0;
		}
 
		return true;
	}
 
	if (emiToolSize < 0.0 ||
		strokelength < 0.0 ||
		lengthAtParam < 0.0)
		return false;
 
	// [out] now is length, range 0,length
	out.first = lengthAtParam - emiToolSize;
	out.second = lengthAtParam + emiToolSize;
 
	if (stroke->isSelfLoop()) {
		if (out.first < 0.0) {
			out.first = strokelength + out.first;
			assert(out.first < strokelength);
		}
 
		if (out.second > strokelength) {
			out.second = out.second - strokelength;
			assert(0.0 < out.second &&
				   out.second < strokelength);
		}
	} else {
		out.first = std::max(out.first, 0.0);
		out.second = std::min(out.second, strokelength);
	}
 
	// [out] now is parameter, range 0,1
	out.first = stroke->getParameterAtLength(out.first);
	out.second = stroke->getParameterAtLength(out.second);
#ifdef _DEBUG
	if (!stroke->isSelfLoop())
		assert(out.first <= out.second);
#endif
	return true;
}
 
//---------------------------------------------------------------------------
 
bool areDifferent(const TStroke *ref1,
				  const TStroke *ref2)
{
	if (!isValid(ref1) ||
		!isValid(ref2))
		return true;
 
	int cpCount1 = ref1->getControlPointCount();
	int cpCount2 = ref2->getControlPointCount();
	if (cpCount1 != cpCount2)
		return true;
 
	while (--cpCount1 >= 0) {
		if (ref1->getControlPoint(cpCount1) !=
			ref2->getControlPoint(cpCount1))
			return true;
	}
	assert(cpCount1 == -1);
	return false;
}
 
//---------------------------------------------------------------------------
}
 
//-----------------------------------------------------------------------------
 
TStroke *
	StrokeDeformationImpl::copyOfLastSelectedStroke_ = 0; // deep copy stroke selected previously
 
//-----------------------------------------------------------------------------
 
const ContextStatus *&
StrokeDeformationImpl::getImplStatus()
{
	// if multi threading this datas need to be serialized
	// a ref to status
	static const ContextStatus *contextStatus_instance;
	return contextStatus_instance;
}
 
//-----------------------------------------------------------------------------
 
TStroke *&
StrokeDeformationImpl::getLastSelectedStroke()
{
	static TStroke *lastSelectedStroke_instance;
	return lastSelectedStroke_instance;
}
 
//-----------------------------------------------------------------------------
 
void StrokeDeformationImpl::setLastSelectedStroke(TStroke *stroke)
{
	TStroke *&lastSelStroke = getLastSelectedStroke();
	lastSelStroke = stroke;
	if (lastSelStroke) {
		delete copyOfLastSelectedStroke_;
		copyOfLastSelectedStroke_ = new TStroke(*lastSelStroke);
	}
}
 
//-----------------------------------------------------------------------------
 
int &StrokeDeformationImpl::getLastSelectedDegree()
{
	static int lastSelectedDegree_instance;
	return lastSelectedDegree_instance;
}
 
//-----------------------------------------------------------------------------
 
void StrokeDeformationImpl::setLastSelectedDegree(int degree)
{
	getLastSelectedDegree() = degree;
}
 
//-----------------------------------------------------------------------------
 
ToonzExt::Intervals &
StrokeDeformationImpl::getSpiresList()
{
	static ToonzExt::Intervals listOfSpire_instance;
	return listOfSpire_instance;
}
 
//-----------------------------------------------------------------------------
 
ToonzExt::Intervals &
StrokeDeformationImpl::getStraightsList()
{
	static ToonzExt::Intervals listOfStraight_instance;
	return listOfStraight_instance;
}
 
//-----------------------------------------------------------------------------
 
StrokeDeformationImpl::StrokeDeformationImpl()
{
	shortcutKey_ = ContextStatus::NONE;
	cursorId_ = -1;
	this->reset();
}
 
//-----------------------------------------------------------------------------
 
StrokeDeformationImpl::~StrokeDeformationImpl()
{
	clearPointerContainer(strokes_);
	delete potential_;
	potential_ = 0;
	delete deformer_;
	deformer_ = 0;
	delete copyOfLastSelectedStroke_;
	copyOfLastSelectedStroke_ = 0;
}
 
//-----------------------------------------------------------------------------
 
bool StrokeDeformationImpl::activate_impl(const ContextStatus *status)
{
	assert(status && "Not status available");
 
	if (!status ||
		!this->init(status))
		return false;
 
	double
		w = status->w_;
 
	ToonzExt::Interval
		extremes = this->getExtremes();
 
	TStroke *
		stroke2transform;
 
	if (!this->computeStroke2Transform(status,
									   stroke2transform,
									   w,
									   extremes))
		return false;
 
	// to avoid strange behaviour in limit's value
	if (areAlmostEqual(extremes.first, w))
		w = extremes.first;
 
	if (areAlmostEqual(extremes.second, w))
		w = extremes.second;
 
	assert(extremes.first <= w &&
		   w <= extremes.second);
 
	if (extremes.first > w ||
		w > extremes.second) {
		return false;
	}
 
	std::vector<double>
		splitParameter;
	splitParameter.push_back(extremes.first);
	splitParameter.push_back(extremes.second);
 
	assert(strokes_.empty());
	if (!strokes_.empty())
		clearPointerContainer(strokes_);
	splitStroke(*stroke2transform,
				splitParameter,
				strokes_);
 
	assert(strokes_.size() == 3);
 
	// I don't know how to manage properly this case
	if (strokes_.size() != 3) {
		clearPointerContainer(strokes_);
		return false;
	}
 
	// stroke to change
	stroke2manipulate_ = strokes_[1];
	assert(stroke2manipulate_ && " Not valid reference to stroke to move!!!");
	if (!stroke2manipulate_)
		return false;
 
	// remove empty stroke
	{
		TStroke *tmp_stroke = strokes_[2];
		if (isAlmostZero(tmp_stroke->getLength())) {
			std::vector<TStroke *>::iterator
				it = strokes_.begin();
			std::advance(it, 2);
			strokes_.erase(it);
			delete tmp_stroke;
		}
		tmp_stroke = strokes_[0];
		if (isAlmostZero(tmp_stroke->getLength())) {
			strokes_.erase(strokes_.begin());
			delete tmp_stroke;
		}
		// little movement of control points to have not empty
		//  length
		if (isAlmostZero(stroke2manipulate_->getLength())) {
			int
				count = stroke2manipulate_->getControlPointCount() - 1;
			assert(count > 0);
 
			TThickPoint
				pnt0 = stroke2manipulate_->getControlPoint(0),
				pntn = stroke2manipulate_->getControlPoint(count),
				delta = TThickPoint(2.0 * TConsts::epsilon,
									-2.0 * TConsts::epsilon,
									0.0);
 
			stroke2manipulate_->setControlPoint(0, pnt0 - delta);
			stroke2manipulate_->setControlPoint(count, pntn + delta);
		}
	}
 
	// simple check for empty chunk
	int
		cp_count = stroke2manipulate_->getChunkCount();
	const TThickQuadratic
		*tq;
	bool
		haveEmpty = false;
	while (--cp_count >= 0) {
		tq = stroke2manipulate_->getChunk(cp_count);
		//    assert( tq->getLength() != 0.0 );
		if (tq->getLength() == 0.0)
			haveEmpty = true;
	}
 
	if (haveEmpty) {
		const double
			reductionFactor = computeReductionFactor(getImplStatus()->pixelSize_,
													 1.0);
		stroke2manipulate_->reduceControlPoints(reductionFactor);
	}
 
	TPointD
		pntOnStroke = stroke2transform->getPoint(w);
 
	// parameter need to be recomputed to match
	// with new stroke
	w = stroke2manipulate_->getW(pntOnStroke);
 
	//  prevStyle_ = stroke2transform->getStyle();
	//  set a style for error
	//  stroke2manipulate_->setStyle( 4 );
 
	// in this deformer all stroke need to be moved
	double lengthOfAction = this->findActionLength();
 
	bool
		exception = false;
 
	try {
		// create a new stroke deformer
		delete deformer_;
		deformer_ = new StrokeParametricDeformer(lengthOfAction,
												 w,
												 stroke2manipulate_,
												 potential_->clone());
	} catch (std::invalid_argument &) {
		exception = true;
		assert(!"Invalid argument");
	} catch (...) {
		exception = true;
	}
 
	assert(deformer_ &&
		   "Deformer is not available");
 
	if (exception) {
		deformer_ = 0;
		return false;
	}
 
	assert(getImplStatus() != 0 && "ContextStatus is null???");
 
	if (!getImplStatus()) {
		delete deformer_;
		this->reset();
		return false;
	}
	// change the threshold value of increser,
	//  if value is greater than diff add control points
	deformer_->setDiff(getImplStatus()->deformerSensibility_);
 
	// just to be sure to have a control point where
	// stroke is selected
	stroke2manipulate_->insertControlPoints(w);
 
	//  two different case:
	//  (1) point at w=0 is not in stroke to transform
	//  (2) point at w=0 is in stroke to transform
	//  in case (2) it is mandatory to retrieve the
	//  parameter where stroke2transform is equal to
	//  w=0 and store it.
	//  old_w0_pos_ will be used in deactivate method
	if (old_w0_pos_ != TConsts::napd) {
		double
			w = stroke2manipulate_->getW(old_w0_pos_);
		TPointD
			pnt = stroke2manipulate_->getPoint(w);
 
		if (tdistance2(pnt, old_w0_pos_) < sq(TConsts::epsilon)) {
			// the this position can be modifyed during drag
			old_w0_ = w;
		} else
			old_w0_ = -1;
	}
 
	bool
		test = increaseControlPoints(*stroke2manipulate_,
									 *deformer_,
									 getImplStatus()->pixelSize_);
	/*
    // New Increaser behaviour
    deformer_->setMouseMove(0,100);
    extremes_ = Toonz::increase_cp (stroke2manipulate_, 
    deformer_);
  //*/
	if (!test)
		return false;
 
	stroke2manipulate_->disableComputeOfCaches();
	return true;
}
 
//-----------------------------------------------------------------------------
 
void StrokeDeformationImpl::update_impl(const TPointD &delta)
{
	assert(stroke2manipulate_ &&
		   deformer_ &&
		   "Stroke and Deformer are available");
 
	if (!stroke2manipulate_ ||
		!deformer_)
		return;
 
	// update delta in deformer
	deformer_->setMouseMove(delta.x, delta.y);
 
	modifyControlPoints(*stroke2manipulate_,
						*deformer_);
}
 
//-----------------------------------------------------------------------------
 
TStroke *
StrokeDeformationImpl::deactivate_impl()
{
	if (!stroke2manipulate_ ||
		!getImplStatus()) {
		this->reset();
		return 0;
	}
 
	// retrieve the point
	if (old_w0_ != -1)
		old_w0_pos_ = stroke2manipulate_->getPoint(old_w0_);
 
	const double
		reductionFactor = computeReductionFactor(getImplStatus()->pixelSize_,
												 3.0);
 
	//stroke2manipulate_->enableComputeOfCaches ();
	//stroke2manipulate_->reduceControlPoints (reductionFactor);
	const int
		size = stroke2manipulate_->getControlPointCount();
	std::vector<TThickPoint>
		pnt(size);
	for (int i = 0;
		 i < size;
		 ++i)
		pnt[i] = stroke2manipulate_->getControlPoint(i);
 
	std::vector<TStroke *>::iterator
		it = std::find(strokes_.begin(),
					   strokes_.end(),
					   stroke2manipulate_);
	assert(it != strokes_.end());
 
	int pos = std::distance(strokes_.begin(),
							it);
	stroke2manipulate_ = 0;
	delete strokes_[pos];
 
	TStroke *tmpStroke = new TStroke(pnt);
	assert((tmpStroke != 0) && "Not valid stroke!");
	strokes_[pos] = tmpStroke;
	strokes_[pos]->reduceControlPoints(reductionFactor);
 
	//strokes_[pos] = TStroke::interpolate(pnt,
	//                                   reductionFactor,
	//                                   false);
 
	TStroke
		*ref = Toonz::merge(strokes_);
 
	ToonzExt::cloneStrokeStatus(getImplStatus()->stroke2change_,
								ref);
 
	if (old_w0_pos_ != TConsts::napd) {
		// restore (if necessary) the initial position of
		// a stroke
		TStroke *
			rotated = rotateControlPointAtPoint(ref,
												old_w0_pos_);
		if (rotated) {
			delete ref;
			ref = rotated;
			if (getImplStatus())
				ToonzExt::cloneStrokeStatus(getImplStatus()->stroke2change_,
											ref);
			else {
				delete ref;
				ref = 0;
			}
		}
	}
 
	this->reset();
	return ref;
}
 
//-----------------------------------------------------------------------------
 
void StrokeDeformationImpl::reset()
{
	old_w0_ = -1;
	old_w0_pos_ = TConsts::napd;
 
	deformer_ = 0;
	getImplStatus() = 0;
	this->setLastSelectedDegree(-1);
	this->setLastSelectedStroke(0);
	this->getSpiresList().clear();
	this->getStraightsList().clear();
 
	stroke2manipulate_ = 0;
	clearPointerContainer(strokes_); // stroke2move is deleted here (it
									 // is in vector)
}
 
//-----------------------------------------------------------------------------
 
TStroke *
StrokeDeformationImpl::getTransformedStroke()
{
	return this->stroke2manipulate_;
}
 
//-----------------------------------------------------------------------------
 
ToonzExt::Potential *
StrokeDeformationImpl::getPotential()
{
	return this->potential_;
}
 
//-----------------------------------------------------------------------------
 
void StrokeDeformationImpl::draw(Designer *designer)
{
}
 
//-----------------------------------------------------------------------------
 
void StrokeDeformationImpl::setPotential(Potential *potential)
{
	assert(potential);
	potential_ = potential;
}
 
//-----------------------------------------------------------------------------
 
bool StrokeDeformationImpl::check(const ContextStatus *status)
{
	if (!status ||
		!this->init(status))
		return false;
 
	return this->check_(status);
}
 
//-----------------------------------------------------------------------------
 
TPointD &
StrokeDeformationImpl::oldW0()
{
	return old_w0_pos_;
}
 
//-----------------------------------------------------------------------------
 
ToonzExt::Interval
StrokeDeformationImpl::getExtremes()
{
	ToonzExt::Interval
		extremes = ToonzExt::Interval(-1.0, -1.0);
 
	if (!getImplStatus())
		return extremes;
 
	// if it is manual
	if (getImplStatus()->isManual_ == true) {
		findExtremesFromActionLength(getImplStatus()->lengthOfAction_,
									 getImplStatus()->stroke2change_,
									 getImplStatus()->w_,
									 extremes);
	} else {
		// if there are some special key down all will be managed in deformation
		this->findExtremes_(getImplStatus(),
							extremes);
	}
 
	return extremes;
}
 
//-----------------------------------------------------------------------------
 
bool StrokeDeformationImpl::init(const ContextStatus *status)
{
	if (!status ||
		!isValid(status->stroke2change_) ||
		!isValid(status->w_)) {
		this->reset();
		return false;
	}
 
	getImplStatus() = status;
 
	if (!this->getLastSelectedStroke() ||
		this->getLastSelectedStroke() != status->stroke2change_ ||
		areDifferent(copyOfLastSelectedStroke_,
					 status->stroke2change_) ||
		(this->getLastSelectedDegree() == -1) ||
		(this->getLastSelectedDegree() != status->cornerSize_)) {
		this->getSpiresList().clear();
		this->getStraightsList().clear();
		// recompute cache
		ToonzExt::findCorners(status->stroke2change_,
							  this->getSpiresList(),
							  this->getStraightsList(),
							  status->cornerSize_,
							  TConsts::epsilon);
		this->setLastSelectedStroke(status->stroke2change_);
		this->setLastSelectedDegree(status->cornerSize_);
	}
	return true;
}
 
//-----------------------------------------------------------------------------
 
bool StrokeDeformationImpl::computeStroke2Transform(const ContextStatus *status,
													TStroke *&stroke2transform,
													double &w,
													ToonzExt::Interval &extremes)
{
	if (!status ||
		!isValid(w))
		return false;
 
	stroke2transform = 0;
 
	if (status->stroke2change_->isSelfLoop()) {
		if (extremes.first > extremes.second) {
			double
				new_w = (extremes.first + extremes.second) * 0.5;
 
			if (!rotateStroke(status->stroke2change_,
							  stroke2transform,
							  w,
							  new_w,
							  old_w0_pos_))
				return false;
 
			ContextStatus
				tmpStatus = *status;
			tmpStatus.stroke2change_ = stroke2transform;
			tmpStatus.w_ = w;
			this->check(&tmpStatus);
			extremes = this->getExtremes();
			this->init(status);
			return true;
		} else if (extremes.first == extremes.second) {
			double
				positionOfFixPoint = -1;
 
			// there are two different cases
			//  a) only one corner
			//  b) only two corners
			switch (this->getSpiresList().size()) {
			case 0:
				assert(extremes.first == -1);
				positionOfFixPoint = retrieveParamAtLengthWithOffset(status->stroke2change_,
																	 status->stroke2change_->getLength() * 0.5,
																	 w);
				break;
			case 1:
				if (extremes.first != -1)
					positionOfFixPoint = retrieveParamAtLengthWithOffset(status->stroke2change_,
																		 status->stroke2change_->getLength() * 0.5,
																		 w);
				else
					positionOfFixPoint = this->getSpiresList()[0].first;
				break;
			case 2:
			// also forced mode
			default:
				assert(extremes.first != -1);
				//if( extremes.first == -1 )
				//  positionOfFixPoint=retrieveParamAtLengthWithOffset(status->stroke2change_,
				//                                                     status->stroke2change_->getLength()*0.5,
				//                                                     w);
				//else
				positionOfFixPoint = extremes.first;
				break;
			}
 
			if (!rotateStroke(status->stroke2change_,
							  stroke2transform,
							  w,
							  positionOfFixPoint,
							  old_w0_pos_))
				return false;
 
			extremes = ToonzExt::Interval(0.0, 1.0);
			return true;
		}
	}
 
	if (!isValid(extremes.first) ||
		!isValid(extremes.second))
		return false;
 
	try {
		if (!stroke2transform)
			stroke2transform = new TStroke(*status->stroke2change_);
	} catch (...) {
		return false;
	}
 
	return true;
}
//-----------------------------------------------------------------------------
//  End Of File
//-----------------------------------------------------------------------------