// Copyright Epic Games, Inc. All Rights Reserved.

#include "Channels/MovieSceneInterpolation.h"
#include "Curves/CurveEvaluation.h"
#include "Algo/Partition.h"

namespace UE::MovieScene::Interpolation
{

bool FInterpolationExtents::IsValid() const
{
	return MinValue != std::numeric_limits<double>::max() && MaxValue != std::numeric_limits<double>::lowest();
}

void FInterpolationExtents::AddPoint(double Value, FFrameTime Time)
{
	if (Value < MinValue)
	{
		MinValue = Value;
		MinValueTime = Time;
	}
	if (Value > MaxValue)
	{
		MaxValue = Value;
		MaxValueTime = Time;
	}
}

void FInterpolationExtents::Combine(const FInterpolationExtents& Other)
{
	if (Other.IsValid())
	{
		AddPoint(Other.MinValue, Other.MinValueTime);
		AddPoint(Other.MaxValue, Other.MaxValueTime);
	}
}

FCachedInterpolationRange FCachedInterpolationRange::Empty()
{
	return FCachedInterpolationRange{ 0, -1 };
}
FCachedInterpolationRange FCachedInterpolationRange::Finite(FFrameNumber InStart, FFrameNumber InEnd)
{
	return FCachedInterpolationRange{ InStart, InEnd };
}
FCachedInterpolationRange FCachedInterpolationRange::Infinite()
{
	return FCachedInterpolationRange{ TNumericLimits<FFrameNumber>::Lowest(), TNumericLimits<FFrameNumber>::Max() };
}
FCachedInterpolationRange FCachedInterpolationRange::Only(FFrameNumber InTime)
{
	const FFrameNumber EndTime = InTime < TNumericLimits<FFrameNumber>::Max()
		? InTime + 1
		: InTime;

	return FCachedInterpolationRange{ InTime, EndTime };
}
FCachedInterpolationRange FCachedInterpolationRange::From(FFrameNumber InStart)
{
	return FCachedInterpolationRange{ InStart, TNumericLimits<FFrameNumber>::Max() };
}
FCachedInterpolationRange FCachedInterpolationRange::Until(FFrameNumber InEnd) 
{
	return FCachedInterpolationRange{ TNumericLimits<FFrameNumber>::Lowest(), InEnd };
}
bool FCachedInterpolationRange::Contains(FFrameNumber FrameNumber) const
{
	return FrameNumber >= Start && (FrameNumber < End || End == TNumericLimits<FFrameNumber>::Max());
}

bool FCachedInterpolationRange::IsEmpty() const
{
	return Start >= End;
}

FCachedInterpolation::FCachedInterpolation()
	: Data(TInPlaceType<FInvalidValue>())
	, Range(FCachedInterpolationRange::Empty())
{
}

FCachedInterpolation::FCachedInterpolation(const FCachedInterpolationRange& InRange, const FConstantValue& Constant)
	: Data(TInPlaceType<FConstantValue>(), Constant)
	, Range(InRange)
{
}

FCachedInterpolation::FCachedInterpolation(const FCachedInterpolationRange& InRange, const FLinearInterpolation& Linear)
	: Data(TInPlaceType<FLinearInterpolation>(), Linear)
	, Range(InRange)
{
}

FCachedInterpolation::FCachedInterpolation(const FCachedInterpolationRange& InRange, const FQuadraticInterpolation& Quadratic)
	: Data(TInPlaceType<FQuadraticInterpolation>(), Quadratic)
	, Range(InRange)
{
}

FCachedInterpolation::FCachedInterpolation(const FCachedInterpolationRange& InRange, const FCubicInterpolation& Cubic)
	: Data(TInPlaceType<FCubicInterpolation>(), Cubic)
	, Range(InRange)
{
}

FCachedInterpolation::FCachedInterpolation(const FCachedInterpolationRange& InRange, const FQuarticInterpolation& Quartic)
	: Data(TInPlaceType<FQuarticInterpolation>(), Quartic)
	, Range(InRange)
{
}

FCachedInterpolation::FCachedInterpolation(const FCachedInterpolationRange& InRange, const FCubicBezierInterpolation& Cubic)
	: Data(TInPlaceType<FCubicBezierInterpolation>(), Cubic)
	, Range(InRange)
{
}

FCachedInterpolation::FCachedInterpolation(const FCachedInterpolationRange& InRange, const FWeightedCubicInterpolation& WeightedCubic)
	: Data(TInPlaceType<FWeightedCubicInterpolation>(), WeightedCubic)
	, Range(InRange)
{
}

bool FCachedInterpolation::IsValid() const
{
	return !Range.IsEmpty();
}

bool FCachedInterpolation::IsCacheValidForTime(FFrameNumber FrameNumber) const
{
	return Range.Contains(FrameNumber);
}

FCachedInterpolationRange FCachedInterpolation::GetRange() const
{
	return Range;
}

FInterpolationExtents FCachedInterpolation::ComputeExtents() const
{
	return ComputeExtents(Range.Start, Range.End);
}

FInterpolationExtents FCachedInterpolation::ComputeExtents(FFrameTime From, FFrameTime To) const
{
	FInterpolationExtents Extents;

	if (const FConstantValue* Constant = Data.TryGet<FConstantValue>())
	{
		Extents.AddPoint(Constant->Value, From);
		Extents.AddPoint(Constant->Value, To);
	}
	else if (const FLinearInterpolation* Linear = Data.TryGet<FLinearInterpolation>())
	{
		Extents.AddPoint(Linear->Evaluate(From), From);
		Extents.AddPoint(Linear->Evaluate(To), To);
	}
	else if (const FQuadraticInterpolation* Quadratic = Data.TryGet<FQuadraticInterpolation>())
	{
		Extents.AddPoint(Quadratic->Evaluate(From), From);
		Extents.AddPoint(Quadratic->Evaluate(To), To);

		FLinearInterpolation Derivative = Quadratic->Derivative();

		FFrameTime Solutions[1];
		const int32 NumSolutions = Derivative.SolveWithin(From, To, 0.0, Solutions);
		check(NumSolutions <= 1);
		for (int32 Index = 0; Index < NumSolutions; ++Index)
		{
			Extents.AddPoint(Quadratic->Evaluate(Solutions[Index]), Solutions[Index]);
		}
	}
	else if (const FCubicInterpolation* Cubic = Data.TryGet<FCubicInterpolation>())
	{
		Extents.AddPoint(Cubic->Evaluate(From), From);
		Extents.AddPoint(Cubic->Evaluate(To), To);

		FQuadraticInterpolation Derivative = Cubic->Derivative();

		FFrameTime Solutions[2];
		const int32 NumSolutions = Derivative.SolveWithin(From, To, 0.0, Solutions);
		check(NumSolutions <= 2);
		for (int32 Index = 0; Index < NumSolutions; ++Index)
		{
			Extents.AddPoint(Cubic->Evaluate(Solutions[Index]), Solutions[Index]);
		}
	}
	else if (const FQuarticInterpolation* Quartic = Data.TryGet<FQuarticInterpolation>())
	{
		Extents.AddPoint(Quartic->Evaluate(From), From);
		Extents.AddPoint(Quartic->Evaluate(To), To);

		FCubicInterpolation Derivative = Quartic->Derivative();

		FFrameTime Solutions[3];
		const int32 NumSolutions = Derivative.SolveWithin(From, To, 0.0, Solutions);
		check(NumSolutions <= 3);
		for (int32 Index = 0; Index < NumSolutions; ++Index)
		{
			Extents.AddPoint(Quartic->Evaluate(Solutions[Index]), Solutions[Index]);
		}
	}
	else if (const FCubicBezierInterpolation* CubicBezier = Data.TryGet<FCubicBezierInterpolation>())
	{
		const double Origin = CubicBezier->Origin.Value;
		const double DX = CubicBezier->DX;

		Extents.AddPoint(CubicBezier->Evaluate(From), From);
		Extents.AddPoint(CubicBezier->Evaluate(To), To);

		FQuadraticInterpolation Derivative = CubicBezier->Derivative();

		FFrameTime Solutions[2];
		const int32 NumSolutions = Derivative.SolveWithin(From, To, 0.0, Solutions);
		check(NumSolutions <= 2);
		for (int32 Index = 0; Index < NumSolutions; ++Index)
		{
			Extents.AddPoint(CubicBezier->Evaluate(Solutions[Index]), Solutions[Index]);
		}
	}
	else if (const FWeightedCubicInterpolation* WeightedCubic = Data.TryGet<FWeightedCubicInterpolation>())
	{
		Extents.AddPoint(WeightedCubic->Evaluate(From), From);
		Extents.AddPoint(WeightedCubic->Evaluate(To),   To);
	}

	ensureMsgf(
		Extents.MinValueTime >= From && Extents.MinValueTime <= To &&
		Extents.MaxValueTime >= From && Extents.MaxValueTime <= To,
		TEXT("ComputeExtents resulted in Min: %f and Max: %f, but expected to be between From: %f To: %f"),
		Extents.MinValueTime.AsDecimal(), Extents.MaxValueTime.AsDecimal(), From.AsDecimal(), To.AsDecimal());

	return Extents;
}

bool FCachedInterpolation::Evaluate(FFrameTime Time, double& OutResult) const
{
	if (const FConstantValue* Constant = Data.TryGet<FConstantValue>())
	{
		OutResult = Constant->Value;
		return true;
	}
	else if (const FLinearInterpolation* Linear = Data.TryGet<FLinearInterpolation>())
	{
		OutResult = Linear->Evaluate(Time);
		return true;
	}
	else if (const FQuadraticInterpolation* Quadratic = Data.TryGet<FQuadraticInterpolation>())
	{
		OutResult = Quadratic->Evaluate(Time);
		return true;
	}
	else if (const FCubicInterpolation* Cubic = Data.TryGet<FCubicInterpolation>())
	{
		OutResult = Cubic->Evaluate(Time);
		return true;
	}
	else if (const FQuarticInterpolation* Quartic = Data.TryGet<FQuarticInterpolation>())
	{
		OutResult = Quartic->Evaluate(Time);
		return true;
	}
	else if (const FCubicBezierInterpolation* CubicBezier = Data.TryGet<FCubicBezierInterpolation>())
	{
		OutResult = CubicBezier->Evaluate(Time);
		return true;
	}
	else if (const FWeightedCubicInterpolation* WeightedCubic = Data.TryGet<FWeightedCubicInterpolation>())
	{
		OutResult = WeightedCubic->Evaluate(Time);
		return true;
	}

	return false;
}

void FCachedInterpolation::Offset(double Amount)
{
	if (FConstantValue* Constant = Data.TryGet<FConstantValue>())
	{
		Constant->Value += Amount;
	}
	else if (FLinearInterpolation* Linear = Data.TryGet<FLinearInterpolation>())
	{
		Linear->Constant += Amount;
	}
	else if (FQuadraticInterpolation* Quadratic = Data.TryGet<FQuadraticInterpolation>())
	{
		Quadratic->Constant += Amount;
	}
	else if (FCubicInterpolation* Cubic = Data.TryGet<FCubicInterpolation>())
	{
		Cubic->Constant += Amount;
	}
	else if (FQuarticInterpolation* Quartic = Data.TryGet<FQuarticInterpolation>())
	{
		Quartic->Constant += Amount;
	}
	else if (FCubicBezierInterpolation* CubicBezier = Data.TryGet<FCubicBezierInterpolation>())
	{
		CubicBezier->P0 += Amount;
		CubicBezier->P1 += Amount;
		CubicBezier->P2 += Amount;
		CubicBezier->P3 += Amount;
	}
	else if (FWeightedCubicInterpolation* WeightedCubic = Data.TryGet<FWeightedCubicInterpolation>())
	{
		WeightedCubic->StartKeyValue += Amount;
		WeightedCubic->EndKeyValue   += Amount;
	}
}

TOptional<FCachedInterpolation> FCachedInterpolation::ComputeIntegral(double ConstantOffset) const
{
	if (const FConstantValue* Constant = Data.TryGet<FConstantValue>())
	{
		return FCachedInterpolation(Range, Constant->Integral(ConstantOffset));
	}
	else if (const FLinearInterpolation* Linear = Data.TryGet<FLinearInterpolation>())
	{
		return FCachedInterpolation(Range, Linear->Integral(ConstantOffset));
	}
	else if (const FQuadraticInterpolation* Quadratic = Data.TryGet<FQuadraticInterpolation>())
	{
		return FCachedInterpolation(Range, Quadratic->Integral(ConstantOffset));
	}
	else if (const FCubicInterpolation* Cubic = Data.TryGet<FCubicInterpolation>())
	{
		return FCachedInterpolation(Range, Cubic->Integral(ConstantOffset));
	}
	else if (const FQuarticInterpolation* Quartic = Data.TryGet<FQuarticInterpolation>())
	{
		checkf(false, TEXT("Unable to compute the integral of a quartic. Although the math is easy, quintic curves are practically impossible to solve."));
	}
	else if (const FCubicBezierInterpolation* CubicBezier = Data.TryGet<FCubicBezierInterpolation>())
	{
		return FCachedInterpolation(Range, CubicBezier->Integral(ConstantOffset));
	}
	else if (const FWeightedCubicInterpolation* WeightedCubic = Data.TryGet<FWeightedCubicInterpolation>())
	{
	}

	return TOptional<FCachedInterpolation>();
}

TOptional<FCachedInterpolation> FCachedInterpolation::ComputeDerivative() const
{
	if (const FConstantValue* Constant = Data.TryGet<FConstantValue>())
	{
		return FCachedInterpolation(Range, Constant->Derivative());
	}
	else if (const FLinearInterpolation* Linear = Data.TryGet<FLinearInterpolation>())
	{
		return FCachedInterpolation(Range, Linear->Derivative());
	}
	else if (const FQuadraticInterpolation* Quadratic = Data.TryGet<FQuadraticInterpolation>())
	{
		return FCachedInterpolation(Range, Quadratic->Derivative());
	}
	else if (const FCubicInterpolation* Cubic = Data.TryGet<FCubicInterpolation>())
	{
		return FCachedInterpolation(Range, Cubic->Derivative());
	}
	else if (const FQuarticInterpolation* Quartic = Data.TryGet<FQuarticInterpolation>())
	{
		return FCachedInterpolation(Range, Quartic->Derivative());
	}
	else if (const FCubicBezierInterpolation* CubicBezier = Data.TryGet<FCubicBezierInterpolation>())
	{
		return FCachedInterpolation(Range, CubicBezier->Derivative());
	}
	else if (const FWeightedCubicInterpolation* WeightedCubic = Data.TryGet<FWeightedCubicInterpolation>())
	{
	}

	return TOptional<FCachedInterpolation>();
}

int32 FCachedInterpolation::InverseEvaluate(double InValue, TInterpSolutions<FFrameTime, 4> OutResults) const
{
	int32 NumSolutions = 0;
	if (const FConstantValue* Constant = Data.TryGet<FConstantValue>())
	{
		if (InValue == Constant->Value)
		{
			if (Range.Start == TNumericLimits<FFrameNumber>::Lowest())
			{
				if (Range.End == TNumericLimits<FFrameNumber>::Lowest())
				{
					OutResults[0] = FFrameTime();
				}
				else
				{
					OutResults[0] = Range.End;
				}
			}
			else
			{
				OutResults[0] = Range.Start;
			}
			NumSolutions = 1;
		}

		check(NumSolutions <= 1);
	}
	else if (const FLinearInterpolation* Linear = Data.TryGet<FLinearInterpolation>())
	{
		NumSolutions = Linear->Solve(InValue, OutResults);
		check(NumSolutions <= 1);
	}
	else if (const FQuadraticInterpolation* Quadratic = Data.TryGet<FQuadraticInterpolation>())
	{
		NumSolutions = Quadratic->Solve(InValue, OutResults);
		check(NumSolutions <= 2);
	}
	else if (const FCubicInterpolation* Cubic = Data.TryGet<FCubicInterpolation>())
	{
		NumSolutions = Cubic->Solve(InValue, OutResults);
		check(NumSolutions <= 3);
	}
	else if (const FQuarticInterpolation* Quartic = Data.TryGet<FQuarticInterpolation>())
	{
		NumSolutions = Quartic->Solve(InValue, OutResults);
		check(NumSolutions <= 4);
	}
	else if (const FCubicBezierInterpolation* CubicBezier = Data.TryGet<FCubicBezierInterpolation>())
	{
		NumSolutions = CubicBezier->Solve(InValue, OutResults);
		check(NumSolutions <= 2);
	}
	else if (const FWeightedCubicInterpolation* WeightedCubic = Data.TryGet<FWeightedCubicInterpolation>())
	{
		NumSolutions = WeightedCubic->Solve(InValue, OutResults);
		check(NumSolutions <= 2);
	}

	// Only accept solutions within our acceptable range
	int32 WritePos = 0;
	for (int32 Index = 0; Index < NumSolutions; ++Index)
	{
		if (OutResults[Index] >= Range.Start && OutResults[Index] <= Range.End)
		{
			if (Index != WritePos)
			{
				OutResults[WritePos] = OutResults[Index];
			}
			++WritePos;
		}
	}

	return WritePos;
}

FConstantValue FConstantValue::Derivative() const
{
	return FConstantValue(Origin, 0.0);
}

FLinearInterpolation FConstantValue::Integral(double ConstantOffset) const
{
	return FLinearInterpolation(Origin, Value, ConstantOffset);
}

double FLinearInterpolation::Evaluate(FFrameTime InTime) const
{
	return Coefficient*(InTime - Origin).AsDecimal() + Constant;
}

int32 FLinearInterpolation::Solve(double Value, TInterpSolutions<FFrameTime, 1> OutResults) const
{
	if (Coefficient != 0.0)
	{
		OutResults[0] = FFrameTime::FromDecimal((Value - Constant) / Coefficient) + Origin;
		return 1;
	}
	else if (Value == Constant)
	{
		OutResults[0] = FFrameTime::FromDecimal(Constant);
		return 1;
	}
	return 0;
}

int32 FLinearInterpolation::SolveWithin(FFrameTime Start, FFrameTime End, double Value, TInterpSolutions<FFrameTime, 1> OutResults) const
{
	if (Value == Constant)
	{
		OutResults[0] = Start;
		return 1;
	}
	if (Solve(Value, OutResults) == 1 && OutResults[0] >= Start && OutResults[0] < End)
	{
		return 1;
	}
	return 0;
}

FConstantValue FLinearInterpolation::Derivative() const
{
	return FConstantValue(Origin, Coefficient);
}

FQuadraticInterpolation FLinearInterpolation::Integral(double ConstantOffset) const
{
	return FQuadraticInterpolation(Origin, 0.5*Coefficient, Constant, ConstantOffset);
}

double FQuadraticInterpolation::Evaluate(FFrameTime InTime) const
{
	const double X = (InTime - Origin).AsDecimal();
	return A*X*X + B*X + Constant;
}

int32 FQuadraticInterpolation::Solve(double Value, TInterpSolutions<FFrameTime, 2> OutResults) const
{
	const double C = Constant - Value;

	// Solve using the quadratic formula
	OutResults[0] = FFrameTime::FromDecimal( (-B + FMath::Sqrt(B*B - 4.0*A*C)) / (2.0*A) ) + Origin;
	OutResults[1] = FFrameTime::FromDecimal( (-B - FMath::Sqrt(B*B - 4.0*A*C)) / (2.0*A) ) + Origin;

	return 2;
}

int32 FQuadraticInterpolation::SolveWithin(FFrameTime Start, FFrameTime End, double Value, TInterpSolutions<FFrameTime, 2> OutResults) const
{
	Solve(Value, OutResults);

	if (OutResults[0] < Start || OutResults[0] >= End)
	{
		if (OutResults[1] < Start || OutResults[1] >= End)
		{
			return 0;
		}
		OutResults[0] = OutResults[1];
		return 1;
	}
	if (OutResults[1] < Start || OutResults[1] >= End)
	{
		return 1;
	}
	return 2;
}

FLinearInterpolation FQuadraticInterpolation::Derivative() const
{
	return FLinearInterpolation(Origin, 2.0*A, B);
}

FCubicInterpolation FQuadraticInterpolation::Integral(double ConstantOffset) const
{
	return FCubicInterpolation(Origin, A/3.0, B/2.0, Constant, ConstantOffset);
}

double FCubicInterpolation::Evaluate(FFrameTime InTime) const
{
	if (FMath::IsNearlyEqual(DX, 0.0))
	{
		return A;
	}

	const double X = (InTime - Origin).AsDecimal() / DX;
	return A*X*X*X + B*X*X + C*X + Constant;
}

int32 FCubicInterpolation::Solve(double Value, TInterpSolutions<FFrameTime, 3> OutResults) const
{
	double Coefficients[4] = {
		Constant-Value,
		C,
		B,
		A,
	};

	double Solutions[3];
	const int32 NumRealSolutions = UE::Curves::SolveCubic(Coefficients, Solutions);

	for (int32 Index = 0; Index < NumRealSolutions; ++Index)
	{
		OutResults[Index] = DX*FFrameTime::FromDecimal(Solutions[Index])+Origin;
	}

	return NumRealSolutions;
}

int32 FCubicInterpolation::SolveWithin(FFrameTime Start, FFrameTime End, double Value, TInterpSolutions<FFrameTime, 3> OutResults) const
{
	int32 NumSolutions = Solve(Value, OutResults);

	// Only accept solutions within our acceptable range
	int32 WritePos = 0;
	for (int32 Index = 0; Index < NumSolutions; ++Index)
	{
		if (OutResults[Index] >= Start && OutResults[Index] <= End)
		{
			if (Index != WritePos)
			{
				OutResults[WritePos] = OutResults[Index];
			}
			++WritePos;
		}
	}

	return WritePos;
}

FQuadraticInterpolation FCubicInterpolation::Derivative() const
{
	return FQuadraticInterpolation(Origin, 3.0*A/(DX*DX*DX), 2.0*B/(DX*DX), C/DX);
}

FQuarticInterpolation FCubicInterpolation::Integral(double ConstantOffset) const
{
	return FQuarticInterpolation(Origin, A*DX/4.0, B*DX/3.0, C*DX/2.0, DX*Constant, ConstantOffset, DX);
}

double FQuarticInterpolation::Evaluate(FFrameTime InTime) const
{
	if (FMath::IsNearlyEqual(DX, 0.0))
	{
		return A;
	}

	const double X = (InTime - Origin).AsDecimal() / DX;
	return A*X*X*X*X + B*X*X*X + C*X*X + D*X + Constant;
}

FCubicInterpolation FQuarticInterpolation::Derivative() const
{
	return FCubicInterpolation(Origin, 4.0*A, 3.0*B, 2.0*C, D, DX);
}

int32 FQuarticInterpolation::Solve(double Value, TInterpSolutions<FFrameTime, 4> OutResults) const
{
	// Solving ax^4 + bx^3 + cx^2 + dx + e = 0 is very difficult, but we can solve it using some tricks.
	// First off, convert our coefficients to make this a monic quartic of the form X^4 + bx^3 + cx^2 + dx + e:
	const double A_ = 1.0;
	const double B_ = B/A;
	const double C_ = C/A;
	const double D_ = D/A;
	const double E_ = (Constant - Value)/A;

	// Now convert the monic quartic to a depressed quartic of the form y^4 + py^2 + qy + r by substituting x = y - b/4 (since a=1.0)
	const double P = C_ - (3.0*B_*B_) / 8.0;
	const double Q = D_ - (B_*C_)/2.0 + (B_*B_*B_)/8.0;
	const double R = E_ - (B_*D_)/4.0 + (B_*B_*C_)/16.0 - (3.0*B_*B_*B_*B_)/256.0;

	// Step 2: Factor the depressed quartic into two quadratics:
	//         (y^2 + sy + t)(y^2 + uy + v)
	//
	//         which results in
	//         y^4 + (s+u)y^3 + (t+v+su)y^2 + (sv+tu)y + tv
	//
	//         Since y^3 is 0 in our depressed quartic, we can deduce that
	//         s+u = 0
	//           p = t + v + su
	//           q = sv + tu
	//           r = tv
	//
	//         From this we can deduce that s = -u:
	//         p + u^2 = t + v
	//               q = u(t-v)
	//               r = tv
	//
	//         Eliminating t and v by substitution and substituting U = u^2:
	//         U^3 + 2pU^2 + (p^2 - 4r)U - q^2 = 0

	// Solve the cubic for U using Cardano's algorithm:
	// SolveCubic expects coefficients in increasing exponent order
	//    ie d + cx + bx^2 + ax^3
	double Coefficients[4] = {
		-(Q*Q),         // d
		(P*P - 4.0*R),  // c
		(2.0*P),        // b
		1.0,            // a
	};

	double Solutions[3];
	const int32 NumSolutions = UE::Curves::SolveCubic(Coefficients, Solutions);

	int32 SolutionToUse = INDEX_NONE;

	// Any real solution will do, but fallback to a complex solution if there's only one
	for (int32 Index = 0; Index < NumSolutions; ++Index)
	{
		SolutionToUse = Index;

		// Use first real solution if possible
		if (Solutions[Index] > 0.0)
		{
			break;
		}
	}

	int32 SolutionIndex = 0;
	if (SolutionToUse != INDEX_NONE)
	{
		const double U = FMath::Sqrt(FMath::Abs(Solutions[0]));
		const double S = -U;
		const double T = (U*U*U + P*U + Q) / (2.0*U);
		const double V = T - (Q / U);

		const double USquaredMinusFourV = U*U - 4.0*V;
		const double SSquaredMinusFourT = S*S - 4.0*T;
		const double BOverFourA         = B_ / (4.0*A_);

		if (USquaredMinusFourV >= 0.0)
		{
			OutResults[SolutionIndex++] = FFrameTime::FromDecimal(( (-U + FMath::Sqrt(USquaredMinusFourV)) / 2.0 ) - BOverFourA) + Origin;
			OutResults[SolutionIndex++] = FFrameTime::FromDecimal(( (-U - FMath::Sqrt(USquaredMinusFourV)) / 2.0 ) - BOverFourA) + Origin;
		}
		if (SSquaredMinusFourT >= 0.0)
		{
			OutResults[SolutionIndex++] = FFrameTime::FromDecimal(( (-S + FMath::Sqrt(SSquaredMinusFourT)) / 2.0 ) - BOverFourA) + Origin;
			OutResults[SolutionIndex++] = FFrameTime::FromDecimal(( (-S - FMath::Sqrt(SSquaredMinusFourT)) / 2.0 ) - BOverFourA) + Origin;
		}
	}

	return SolutionIndex;
}

int32 FQuarticInterpolation::SolveWithin(FFrameTime Start, FFrameTime End, double Value, TInterpSolutions<FFrameTime, 4> OutResults) const
{
	int32 NumSolutions = Solve(Value, OutResults);

	// Only accept solutions within our acceptable range
	int32 WritePos = 0;
	for (int32 Index = 0; Index < NumSolutions; ++Index)
	{
		if (OutResults[Index] >= Start && OutResults[Index] <= End)
		{
			if (Index != WritePos)
			{
				OutResults[WritePos] = OutResults[Index];
			}
			++WritePos;
		}
	}

	return WritePos;
}

FCubicBezierInterpolation::FCubicBezierInterpolation(FFrameNumber InOrigin, double InDX, double InStartValue, double InEndValue, double InStartTangent, double InEndTangent)
	: DX(InDX)
	, Origin(InOrigin)
{
	constexpr double OneThird = 1.0 / 3.0;

	P0 = InStartValue;
	P1 = P0 + (InStartTangent * DX * OneThird);
	P3 = InEndValue;
	P2 = P3 - (InEndTangent * DX * OneThird);
}

FCubicInterpolation FCubicBezierInterpolation::AsCubic() const
{
	// Beziers are interpolated using a normalized input so we have to factor out that normalization to
	//    each term of the resulting polynomial.

	const double OneOverDxCubed   = 1.0 / (DX * DX * DX);
	const double OneOverDxSquared = 1.0 / (DX * DX);
	const double OneOverDx        = 1.0 / (DX);

	const double A = OneOverDxCubed*(-P0 + 3.0*P1 - 3.0*P2 + P3);
	const double B = OneOverDxSquared*(3.0*P0 - 6.0*P1 + 3.0*P2);
	const double C = OneOverDx*3.0*(-P0 + P1);
	const double D = P0;

	return FCubicInterpolation(
		Origin,
		A,
		B,
		C,
		D,
		1.0);// DX);
}

double FCubicBezierInterpolation::Evaluate(FFrameTime InTime) const
{
	if (FMath::IsNearlyEqual(DX, 0.0))
	{
		return P3;
	}

	const float Interp = static_cast<float>((InTime - Origin).AsDecimal() / DX);
	return UE::Curves::BezierInterp(P0, P1, P2, P3, Interp);
}

FQuadraticInterpolation FCubicBezierInterpolation::Derivative() const
{
	return AsCubic().Derivative();
}
FQuarticInterpolation FCubicBezierInterpolation::Integral(double ConstantOffset) const
{
	return AsCubic().Integral(ConstantOffset);
}

int32 FCubicBezierInterpolation::Solve(double InValue, TInterpSolutions<FFrameTime, 4> OutResults) const
{
	// Offset the curve by InValue to find roots

	// SolveCubic expects coefficients in increasing exponent order
	//    ie d + cx + bx^2 + ax^3
	double Coefficients[4] = {
		(P0-InValue),                       // d
		(-3.0 * P0 + 3.0 * P1),             // c
		(3.0 * P0 - 6.0 * P1 + 3.0 * P2),   // b
		(-P0 + 3.0 * P1 - 3.0 * P2 + P3),   // a
	};

	double Solutions[3];
	const int32 NumRealSolutions = UE::Curves::SolveCubic(Coefficients, Solutions);

	int32 NumSolutionsWithinRange = 0;
	for (int32 Index = 0; Index < NumRealSolutions; ++Index)
	{
		double Solution = Solutions[Index];
		// Only accept solutions within the 0-1 range, allowing for some rounding discrepancies
		if (Solution >= -UE_SMALL_NUMBER && Solution <= 1.0 + UE_SMALL_NUMBER)
		{
			Solution = FMath::Clamp(Solution, 0.0, 1.0);
			OutResults[NumSolutionsWithinRange++] = FFrameTime::FromDecimal(Solution*DX) + Origin;
		}
	}

	return NumSolutionsWithinRange;
}

FWeightedCubicInterpolation::FWeightedCubicInterpolation(
	FFrameRate TickResolution,
	FFrameNumber InOrigin,

	FFrameNumber StartTime,
	double StartValue,
	double StartTangent,
	double StartTangentWeight,
	bool bStartIsWeighted,

	FFrameNumber EndTime,
	double EndValue,
	double EndTangent,
	double EndTangentWeight,
	bool bEndIsWeighted)
{
	constexpr double OneThird = 1.0 / 3.0;

	const float TimeInterval = TickResolution.AsInterval();
	const float ToSeconds = 1.0f / TimeInterval;

	const double Time1 = TickResolution.AsSeconds(StartTime);
	const double Time2 = TickResolution.AsSeconds(EndTime);
	const double DXInSeconds = Time2 - Time1;

	Origin = InOrigin;
	DX = (EndTime - StartTime).Value;
	StartKeyValue = StartValue;
	EndKeyValue = EndValue;

	double CosAngle, SinAngle, Angle;

	// ---------------------------------------------------------------------------------
	// Initialize the start key parameters
	Angle = FMath::Atan(StartTangent * ToSeconds);
	FMath::SinCos(&SinAngle, &CosAngle, Angle);

	if (bStartIsWeighted)
	{
		StartWeight = StartTangentWeight;
	}
	else
	{
		const double LeaveTangentNormalized = StartTangent / TimeInterval;
		const double DY = LeaveTangentNormalized * DXInSeconds;
		StartWeight = FMath::Sqrt(DXInSeconds*DXInSeconds + DY*DY) * OneThird;
	}

	const double StartKeyTanX = CosAngle * StartWeight + Time1;
	StartKeyTanY              = SinAngle * StartWeight + StartValue;
	NormalizedStartTanDX = (StartKeyTanX - Time1) / DXInSeconds;

	// ---------------------------------------------------------------------------------
	// Initialize the end key parameters
	Angle = FMath::Atan(EndTangent * ToSeconds);
	FMath::SinCos(&SinAngle, &CosAngle, Angle);

	if (bEndIsWeighted)
	{
		EndWeight =  EndTangentWeight;
	}
	else
	{
		const double ArriveTangentNormalized = EndTangent / TimeInterval;
		const double DY = ArriveTangentNormalized * DXInSeconds;
		EndWeight = FMath::Sqrt(DXInSeconds*DXInSeconds + DY*DY) * OneThird;
	}

	const double EndKeyTanX = -CosAngle * EndWeight + Time2;
	EndKeyTanY              = -SinAngle * EndWeight + EndValue;

	NormalizedEndTanDX = (EndKeyTanX - Time1) / DXInSeconds;
}

double FWeightedCubicInterpolation::Evaluate(FFrameTime InTime) const
{
	const double Interp = (InTime - Origin).AsDecimal() / DX;

	double Coeff[4];
	double Results[3];

	//Convert Bezier to Power basis, also float to double for precision for root finding.
	UE::Curves::BezierToPower(
		0.0, NormalizedStartTanDX, NormalizedEndTanDX, 1.0,
		&(Coeff[3]), &(Coeff[2]), &(Coeff[1]), &(Coeff[0])
	);

	Coeff[0] = Coeff[0] - Interp;

	const int32 NumResults = UE::Curves::SolveCubic(Coeff, Results);
	double NewInterp = Interp;
	if (NumResults == 1)
	{
		NewInterp = Results[0];
	}
	else
	{
		NewInterp = TNumericLimits<double>::Lowest(); //just need to be out of range
		for (double Result : Results)
		{
			if ((Result > 0.0 || FMath::IsNearlyEqual(Result, 0.0)) && (Result < 1.0 || FMath::IsNearlyEqual(Result, 1.0))) 
			{
				if (NewInterp < 0.0 || Result > NewInterp)
				{
					NewInterp = Result;
				}
			}
		}

		if (NewInterp == TNumericLimits<double>::Lowest())
		{
			NewInterp = 0.0;
		}
	}

	//now use NewInterp and adjusted tangents plugged into the Y (Value) part of the graph.
	const double P0 = StartKeyValue;
	const double P1 = StartKeyTanY;
	const double P3 = EndKeyValue;
	const double P2 = EndKeyTanY;

	return UE::Curves::BezierInterp(P0, P1, P2, P3, static_cast<float>(NewInterp));
}

int32 FWeightedCubicInterpolation::Solve(double InValue, TInterpSolutions<FFrameTime, 4> OutResults) const
{
	// Solve the control points first
	const double P0 = StartKeyValue;
	const double P1 = StartKeyTanY;
	const double P3 = EndKeyValue;
	const double P2 = EndKeyTanY;

	// Offset the curve by InValue to find roots

	// SolveCubic expects coefficients in increasing exponent order
	//    ie d + cx + bx^2 + ax^3
	double Coefficients[4] = {
		(P0-InValue),                       // d
		(-3.0 * P0 + 3.0 * P1),             // c
		(3.0 * P0 - 6.0 * P1 + 3.0 * P2),   // b
		(-P0 + 3.0 * P1 - 3.0 * P2 + P3),   // a
	};

	double Solutions[3];
	const int32 NumRealSolutions = UE::Curves::SolveCubic(Coefficients, Solutions);

	FFrameTime InitialSolutions[3];
	int32 NumSolutionsWithinRange = 0;
	for (int32 Index = 0; Index < NumRealSolutions; ++Index)
	{
		double Solution = Solutions[Index];
		// Only accept solutions within the 0-1 range, allowing for some rounding discrepancies
		if (Solution >= -UE_SMALL_NUMBER && Solution <= 1.0 + UE_SMALL_NUMBER)
		{
			Solution = FMath::Clamp(Solution, 0.0, 1.0);

			// Now solve this interp for the power basis
			Solution = UE::Curves::BezierInterp(0.0, NormalizedStartTanDX, NormalizedEndTanDX, 1.0, static_cast<float>(Solution));
			OutResults[NumSolutionsWithinRange++] = FFrameTime::FromDecimal(Solution*DX) + Origin;
		}
	}

	return NumSolutionsWithinRange;
}

} // namespace UE::MovieScene