/*******************************************************************************

 Copyright (c) 2009, Charles McGarvey
 All rights reserved.
 
 Redistribution   and   use  in  source  and  binary  forms,  with  or  without
 modification, are permitted provided that the following conditions are met:
 
   * Redistributions  of  source  code  must retain the above copyright notice,
     this list of conditions and the following disclaimer.
   * Redistributions  in binary form must reproduce the above copyright notice,
     this  list of conditions and the following disclaimer in the documentation
     and/or other materials provided with the distribution.
 
 THIS  SOFTWARE  IS  PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 AND  ANY  EXPRESS  OR  IMPLIED  WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
 DISCLAIMED.  IN  NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
 FOR  ANY  DIRECT,  INDIRECT,  INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 DAMAGES  (INCLUDING,  BUT  NOT  LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
 SERVICES;  LOSS  OF  USE,  DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
 CAUSED  AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
 OR  TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

*******************************************************************************/

#ifndef _MOOF_INTERPOLATOR_HH_
#define _MOOF_INTERPOLATOR_HH_

#include <Moof/Log.hh>
#include <Moof/Math.hh>


namespace Mf {


// TODO - cleanup these classes

class Interpolator
{
	void clamp(Scalar& value)
	{
		if (value > 1.0)
		{
			switch (mMode)
			{
				case STOP:
					value = 1.0;
					mDone = true;
					break;
				case REPEAT:
					value -= 1.0;
					break;
				case OSCILLATE:
					value = 2.0 - value;
					mScale *= -1.0;
					break;
			}
		}
		else if (value < 0.0)
		{
			switch (mMode)
			{
				case STOP:
					value = 0.0;
					mDone = true;
					break;
				case REPEAT:
					value += 1.0;
					break;
				case OSCILLATE:
					value = -value;
					mScale *= -1.0;
					break;
			}
		}
	}

public:

	typedef enum
	{
		STOP		= 0,
		REPEAT		= 1,
		OSCILLATE	= 2
	} Mode;

	void init(Scalar seconds = 1.0, Mode mode = STOP)
	{
		mScale = 1.0 / seconds;
		mAlpha = 0.0;
		setMode(mode);
	}


	void setMode(Mode mode)
	{
		mMode = mode;
		mDone = false;
	}


	void update(Scalar t, Scalar dt)
	{
		if (!mDone)
		{
			mAlpha += dt * mScale;
			clamp(mAlpha);
			calculate(mAlpha);
		}
	}

	bool isDone() const
	{
		return mDone;
	}

	virtual void calculate(Scalar alpha) = 0;

private:

	Scalar	mAlpha;
	Mode	mMode;
	Scalar	mScale;
	bool	mDone;
};

template <class T = Scalar>
class InterpolatorBase : public Interpolator
{
public:

	void init(Scalar seconds = 1.0, Mode mode = STOP)
	{
		Interpolator::init(seconds, mode);

		calculate(0.0);	// set value
		mPrevious = mValue;
	}

	void calculate(Scalar alpha)
	{
		mPrevious = mValue;
		calculate(mValue, alpha);
	}

	virtual void calculate(T& value, Scalar alpha) = 0;

	const T& getValue() const
	{
		return mValue;
	}

	const T getState(Scalar alpha) const
	{
		return cml::lerp(mPrevious, mValue, alpha);
	}

private:

	T mValue;
	T mPrevious;
};


template <int D, class T = Scalar>
class PolynomialInterpolator : public InterpolatorBase<T>
{
public:

	PolynomialInterpolator() {}

	PolynomialInterpolator(const T coefficients[D+1],
			Scalar seconds = 1.0, Interpolator::Mode mode = Interpolator::STOP)
	{
		init(coefficients, seconds, mode);
	}

	void init(const T coefficients[D+1], Scalar seconds = 1.0,
			Interpolator::Mode mode = Interpolator::STOP)
	{
		Scalar fac[D+1];

		fac[0] = 1.0;
		fac[1] = 1.0;

		// build an array of the computed factorials we will need
		for (int i = 2; i <= D; ++i)
		{
			fac[i] = i * fac[i - 1];
		}

		// combine the coefficients for fast updating
		for (int i = 0; i <= D; ++i)
		{
			// n! / (k! * (n - k)!)
			mCoefficients[i] = coefficients[i] * fac[D] / (fac[i] * fac[D - i]);
		}

		InterpolatorBase<T>::init(seconds, mode);
	}


	void calculate(T& value, Scalar alpha)
	{
		Scalar beta = 1.0 - alpha;

		value = mCoefficients[0] * std::pow(beta, D);

		for (int i = 1; i <= D; ++i)
		{
			value += mCoefficients[i] * std::pow(beta, D - i) *
				std::pow(alpha, i);
		}
	}

private:

	T mCoefficients[D+1];
};


// specialized linear interpolator

template <class T>
class PolynomialInterpolator<1,T> : public InterpolatorBase<T>
{
public:

	PolynomialInterpolator() {}

	PolynomialInterpolator(const T coefficients[2], Scalar seconds = 1.0,
			Interpolator::Mode mode = Interpolator::STOP)
		//InterpolatorBase<T>(seconds, mode)
	{
		init(coefficients, seconds, mode);
	}

	void init(const T coefficients[2], Scalar seconds = 1.0,
			Interpolator::Mode mode = Interpolator::STOP)
	{
		mA = coefficients[0];
		mB = coefficients[1];

		InterpolatorBase<T>::init(seconds, mode);
	}


	void calculate(T& value, Scalar alpha)
	{
		value = cml::lerp(mA, mB, alpha);
	}

private:

	T mA;
	T mB;
};


// Here are some aliases for more common interpolators.  Also see the
// interpolation functions in cml for other types of interpolation such as
// slerp and some multi-alpha interpolators.

typedef PolynomialInterpolator<1>			Lerp;	// linear
typedef PolynomialInterpolator<1,Vector2>	Lerp2;
typedef PolynomialInterpolator<1,Vector3>	Lerp3;
typedef PolynomialInterpolator<1,Vector4>	Lerp4;

typedef PolynomialInterpolator<2>			Qerp;	// quadratic
typedef PolynomialInterpolator<2,Vector2>	Qerp2;
typedef PolynomialInterpolator<2,Vector3>	Qerp3;
typedef PolynomialInterpolator<2,Vector4>	Qerp4;

typedef PolynomialInterpolator<3>			Cerp;	// cubic
typedef PolynomialInterpolator<3,Vector2>	Cerp2;
typedef PolynomialInterpolator<3,Vector3>	Cerp3;
typedef PolynomialInterpolator<3,Vector4>	Cerp4;


} // namespace Mf

#endif // _MOOF_INTERPOLATOR_HH_

/** vim: set ts=4 sw=4 tw=80: *************************************************/