#include "ext/NotSimmetricExpPotential.h"
 
#include <tmathutil.h>
#include <algorithm>
 
using namespace std;
 
//-----------------------------------------------------------------------------
 
namespace
{
typedef unary_function<double, double> unary_functionDD;
 
//---------------------------------------------------------------------------
 
class mySqr : unary_functionDD
{
public:
	result_type operator()(argument_type x)
	{
		return 1.0 - sq(x);
	}
};
 
//---------------------------------------------------------------------------
 
class myExp : unary_functionDD
{
public:
	result_type operator()(argument_type x)
	{
		return exp(-sq(x));
	}
};
 
//---------------------------------------------------------------------------
struct blender {
	double operator()(double a,
					  double b,
					  double t)
	{
		assert(0.0 <= t &&
			   t <= 1.0);
 
		return (a * (1.0 - t) + b * t);
	}
};
 
//---------------------------------------------------------------------------
 
struct blender_2 {
	double operator()(double a,
					  double b,
					  double t)
	{
		assert(0.0 <= t &&
			   t <= 1.0);
 
		//a(1-t)^2 + 2t*(1-t) + t^2
		double one_t = 1.0 - t;
		double num = 3.0;
		double den = 4.0;
		// solution of a(1-t)^2 + P*2t(1-t) + b*t^2 = (a+b)/2
		// with t = num/den
		double middle = sq(den) / (2.0 * num) * ((a + b) * 0.5 - (a + sq(num) * b) / sq(den));
 
		return a * sq(one_t) + middle * t * one_t + b * sq(t);
	}
};
}
 
//-----------------------------------------------------------------------------
 
void ToonzExt::NotSimmetricExpPotential::setParameters_(const TStroke *ref,
														double par,
														double al)
{
	ref_ = ref;
	par_ = par;
	actionLength_ = al;
 
	assert(ref_);
 
	strokeLength_ = ref->getLength();
	lenghtAtParam_ = ref->getLength(par);
 
	// lunghezza dal pto di click all'inizio della curva
	leftFactor_ = min(lenghtAtParam_,
					  actionLength_ * 0.5); //lenghtAtParam_ / strokeLength_;
 
	// lunghezza dal pto di click alla fine
	rightFactor_ = min(strokeLength_ - lenghtAtParam_,
					   actionLength_ * 0.5);
 
	// considero come intervallo di mapping [-range,range].
	//  4 ha come valore c.a. 10exp-6
	//  cioé sposterei un pixel su un movimento di un milione di pixel
	range_ = 2.8;
}
 
//-----------------------------------------------------------------------------
 
ToonzExt::NotSimmetricExpPotential::~NotSimmetricExpPotential()
{
}
 
//-----------------------------------------------------------------------------
 
double
ToonzExt::NotSimmetricExpPotential::value_(double value2test) const
{
	assert(0.0 <= value2test &&
		   value2test <= 1.0);
	return this->compute_value(value2test);
}
 
//-----------------------------------------------------------------------------
 
// normalization of parameter in range interval
double ToonzExt::NotSimmetricExpPotential::compute_shape(double value2test) const
{
	double x = ref_->getLength(value2test);
	double shape = this->actionLength_ * 0.5;
	if (isAlmostZero(shape))
		shape = 1.0;
	x = ((x - lenghtAtParam_) * range_) / shape;
	return x;
}
 
//-----------------------------------------------------------------------------
 
double ToonzExt::NotSimmetricExpPotential::compute_value(double value2test) const
{
	myExp me;
	mySqr ms;
	blender op;
 
	// usually use the form below
	//     (                ) 2
	//     ( (x - l)*range_ )
	//   - (--------------- )
	//     ( factor         )
	//            l,r
	//  e
	//
	//  where factor is computed like in constructor
 
	// on extremes use
	//     2
	//  1-x
	//
 
	// when is near to extreme uses a mix notation
	double x = 0.0;
	double res = 0.0;
 
	// lenght  at parameter
	x = ref_->getLength(value2test);
 
	const double tolerance = 2.0; // need to be pixel based
	// if is an extreme
	if (max(lenghtAtParam_, 0.0) < tolerance ||
		max(strokeLength_ - lenghtAtParam_, 0.0) < tolerance) {
		double tmp_al = actionLength_ * 0.5;
 
		// compute correct parameter considering offset
		// try to have a square curve like shape
		//
		//       2
		//  m = x
		//
		if (leftFactor_ <= tolerance)
			x = 1.0 - x / tmp_al;
		else
			x = (x - (strokeLength_ - tmp_al)) / tmp_al;
 
		if (x < 0.0)
			return 0.0;
		assert(0.0 <= x &&
			   x <= 1.0 + TConsts::epsilon);
		res = sq(x);
	} else // when is not an extreme
	{
		double lenght_at_value2test = ref_->getLength(value2test);
 
		const double min_level = 0.01;
		// if check a parameter over click point
		if (lenght_at_value2test >= lenghtAtParam_) {
			// check if extreme can be moved from this parameter configuration
			double tmp_x = this->compute_shape(1.0);
			double tmp_res = me(tmp_x);
			if (tmp_res > min_level) {
				// please note that in this case
				//  lenghtAtParam_ + rightFactor_ == strokeLength_
				// (by ctor).
				x = (lenght_at_value2test - lenghtAtParam_) / rightFactor_;
				assert(0.0 <= x &&
					   x <= 1.0);
 
				// then movement use another shape
				double exp_val = me(x * range_);
 
				double how_many_of_shape = (strokeLength_ - lenghtAtParam_) / (actionLength_ * 0.5);
				assert(0.0 <= how_many_of_shape &&
					   how_many_of_shape <= 1.0);
 
				//return ms(x);
				return op(ms(x), exp_val, how_many_of_shape);
			}
		} else {
			// leftFactor_
			double tmp_x = this->compute_shape(0.0);
			double tmp_res = me(tmp_x);
			if (tmp_res > min_level) {
 
				double x = lenght_at_value2test / leftFactor_;
				assert(0.0 <= x &&
					   x <= 1.0);
 
				// then movement use another shape
				double diff = x - 1.0;
				double exp_val = me(diff * range_);
				double how_many_of_shape = lenghtAtParam_ / (actionLength_ * 0.5);
				assert(0.0 <= how_many_of_shape &&
					   how_many_of_shape <= 1.0);
 
				//return ms(diff);
				return op(ms(diff), exp_val, how_many_of_shape);
			}
		}
 
		// default behaviour is an exp
		x = this->compute_shape(value2test);
		res = me(x);
	}
	return res;
}
 
//-----------------------------------------------------------------------------
 
ToonzExt::Potential *
ToonzExt::NotSimmetricExpPotential::clone()
{
	return new NotSimmetricExpPotential;
}
 
//DEL double  ToonzExt::NotSimmetricExpPotential::gradient(double value2test) const
//DEL {
//DEL   assert(false);
//DEL   //double x = this->compute_shape(value2test);
//DEL   //double res = -(2.0*range_) / actionLength_ * x * exp(-sq(x));
//DEL   //return res;
//DEL   return 0;
//DEL }
 
//-----------------------------------------------------------------------------
//  End Of File
//-----------------------------------------------------------------------------