/******************************************************************************
 * Spine Runtimes License Agreement
 * Last updated April 5, 2025. Replaces all prior versions.
 *
 * Copyright (c) 2013-2026, Esoteric Software LLC
 *
 * Integration of the Spine Runtimes into software or otherwise creating
 * derivative works of the Spine Runtimes is permitted under the terms and
 * conditions of Section 2 of the Spine Editor License Agreement:
 * https://esotericsoftware.com/spine-editor-license
 *
 * Otherwise, it is permitted to integrate the Spine Runtimes into software
 * or otherwise create derivative works of the Spine Runtimes (collectively,
 * "Products"), provided that each user of the Products must obtain their own
 * Spine Editor license and redistribution of the Products in any form must
 * include this license and copyright notice.
 *
 * THE SPINE RUNTIMES ARE PROVIDED BY ESOTERIC SOFTWARE LLC "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 ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY
 * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
 * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES,
 * BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) 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
 * THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 *****************************************************************************/

using System;

namespace Spine {
	/// <summary>
	/// Takes a linear value in the range of 0-1 and outputs a (usually) non-linear, interpolated value.
	/// </summary>
	public abstract class Interpolation {
		/// <param name="a">Alpha value between 0 and 1.</param>
		abstract public float Apply (float a);

		/// <param name="a">Alpha value between 0 and 1.</param>
		public float Apply (float start, float end, float a) {
			return start + (end - start) * Apply(a);
		}

		public static readonly Interpolation Linear = new LinearInterpolation();
		/// <summary>Aka "smoothstep".</summary>
		public static readonly Interpolation Smooth = new SmoothInterpolation();
		public static readonly Interpolation Smooth2 = new Smooth2Interpolation();
		/// <summary>By Ken Perlin.</summary>
		public static readonly Interpolation Smoother = new SmootherInterpolation();
		public static readonly Interpolation Fade = Smoother;

		public static readonly PowInterpolation Pow2 = new PowInterpolation(2);
		/// <summary>Slow, then fast.</summary>
		public static readonly PowInInterpolation Pow2In = new PowInInterpolation(2);
		public static readonly PowInInterpolation SlowFast = Pow2In;
		/// <summary>Fast, then slow.</summary>
		public static readonly PowOutInterpolation Pow2Out = new PowOutInterpolation(2);
		public static readonly PowOutInterpolation FastSlow = Pow2Out;
		public static readonly Interpolation Pow2InInverse = new Pow2InInverseInterpolation();
		public static readonly Interpolation Pow2OutInverse = new Pow2OutInverseInterpolation();

		public static readonly PowInterpolation Pow3 = new PowInterpolation(3);
		public static readonly PowInInterpolation Pow3In = new PowInInterpolation(3);
		public static readonly PowOutInterpolation Pow3Out = new PowOutInterpolation(3);
		public static readonly Interpolation Pow3InInverse = new Pow3InInverseInterpolation();
		public static readonly Interpolation Pow3OutInverse = new Pow3OutInverseInterpolation();

		public static readonly PowInterpolation Pow4 = new PowInterpolation(4);
		public static readonly PowInInterpolation Pow4In = new PowInInterpolation(4);
		public static readonly PowOutInterpolation Pow4Out = new PowOutInterpolation(4);

		public static readonly PowInterpolation Pow5 = new PowInterpolation(5);
		public static readonly PowInInterpolation Pow5In = new PowInInterpolation(5);
		public static readonly PowOutInterpolation Pow5Out = new PowOutInterpolation(5);

		public static readonly Interpolation Sine = new SineInterpolation();
		public static readonly Interpolation SineIn = new SineInInterpolation();
		public static readonly Interpolation SineOut = new SineOutInterpolation();

		public static readonly ExpInterpolation Exp10 = new ExpInterpolation(2, 10);
		public static readonly ExpInInterpolation Exp10In = new ExpInInterpolation(2, 10);
		public static readonly ExpOutInterpolation Exp10Out = new ExpOutInterpolation(2, 10);

		public static readonly ExpInterpolation Exp5 = new ExpInterpolation(2, 5);
		public static readonly ExpInInterpolation Exp5In = new ExpInInterpolation(2, 5);
		public static readonly ExpOutInterpolation Exp5Out = new ExpOutInterpolation(2, 5);

		public static readonly Interpolation Circle = new CircleInterpolation();
		public static readonly Interpolation CircleIn = new CircleInInterpolation();
		public static readonly Interpolation CircleOut = new CircleOutInterpolation();

		public static readonly ElasticInterpolation Elastic = new ElasticInterpolation(2, 10, 7, 1);
		public static readonly ElasticInInterpolation ElasticIn = new ElasticInInterpolation(2, 10, 6, 1);
		public static readonly ElasticOutInterpolation ElasticOut = new ElasticOutInterpolation(2, 10, 7, 1);

		public static readonly SwingInterpolation Swing = new SwingInterpolation(1.5f);
		public static readonly SwingInInterpolation SwingIn = new SwingInInterpolation(2f);
		public static readonly SwingOutInterpolation SwingOut = new SwingOutInterpolation(2f);

		public static readonly BounceInterpolation Bounce = new BounceInterpolation(4);
		public static readonly BounceInInterpolation BounceIn = new BounceInInterpolation(4);
		public static readonly BounceOutInterpolation BounceOut = new BounceOutInterpolation(4);

		#region Implementation Classes
		class LinearInterpolation : Interpolation {
			public override float Apply (float a) {
				return a;
			}
		}

		class SmoothInterpolation : Interpolation {
			public override float Apply (float a) {
				return a * a * (3 - 2 * a);
			}
		}

		class Smooth2Interpolation : Interpolation {
			public override float Apply (float a) {
				a = a * a * (3 - 2 * a);
				return a * a * (3 - 2 * a);
			}
		}

		/// <summary>By Ken Perlin.</summary>
		class SmootherInterpolation : Interpolation {
			public override float Apply (float a) {
				return a * a * a * (a * (a * 6 - 15) + 10);
			}
		}

		public class PowInterpolation : Interpolation {
			protected readonly int power;

			public PowInterpolation (int power) {
				this.power = power;
			}

			public override float Apply (float a) {
				if (a <= 0.5f) return (float)Math.Pow(a * 2, power) / 2;
				return (float)Math.Pow((a - 1) * 2, power) / (power % 2 == 0 ? -2 : 2) + 1;
			}
		}

		public class PowInInterpolation : PowInterpolation {
			public PowInInterpolation (int power) : base(power) {
			}

			public override float Apply (float a) {
				return (float)Math.Pow(a, power);
			}
		}

		public class PowOutInterpolation : PowInterpolation {
			public PowOutInterpolation (int power) : base(power) {
			}

			public override float Apply (float a) {
				return (float)Math.Pow(a - 1, power) * (power % 2 == 0 ? -1 : 1) + 1;
			}
		}

		class Pow2InInverseInterpolation : Interpolation {
			public override float Apply (float a) {
				if (a < MathUtils.FloatRoundingError) return 0;
				return (float)Math.Sqrt(a);
			}
		}

		class Pow2OutInverseInterpolation : Interpolation {
			public override float Apply (float a) {
				if (a < MathUtils.FloatRoundingError) return 0;
				if (a > 1) return 1;
				return 1 - (float)Math.Sqrt(-(a - 1));
			}
		}

		class Pow3InInverseInterpolation : Interpolation {
			public override float Apply (float a) {
				return MathUtils.Cbrt(a);
			}
		}

		class Pow3OutInverseInterpolation : Interpolation {
			public override float Apply (float a) {
				return 1 - MathUtils.Cbrt(-(a - 1));
			}
		}

		class SineInterpolation : Interpolation {
			public override float Apply (float a) {
				return (1 - MathUtils.Cos(a * MathUtils.PI)) / 2;
			}
		}

		class SineInInterpolation : Interpolation {
			public override float Apply (float a) {
				return 1 - MathUtils.Cos(a * MathUtils.HalfPi);
			}
		}

		class SineOutInterpolation : Interpolation {
			public override float Apply (float a) {
				return MathUtils.Sin(a * MathUtils.HalfPi);
			}
		}

		public class ExpInterpolation : Interpolation {
			protected readonly float value, power, min, scale;

			public ExpInterpolation (float value, float power) {
				this.value = value;
				this.power = power;
				min = (float)Math.Pow(value, -power);
				scale = 1 / (1 - min);
			}

			public override float Apply (float a) {
				if (a <= 0.5f) return ((float)Math.Pow(value, power * (a * 2 - 1)) - min) * scale / 2;
				return (2 - ((float)Math.Pow(value, -power * (a * 2 - 1)) - min) * scale) / 2;
			}
		}

		public class ExpInInterpolation : ExpInterpolation {
			public ExpInInterpolation (float value, float power) : base(value, power) {
			}

			public override float Apply (float a) {
				return ((float)Math.Pow(value, power * (a - 1)) - min) * scale;
			}
		}

		public class ExpOutInterpolation : ExpInterpolation {
			public ExpOutInterpolation (float value, float power) : base(value, power) {
			}

			public override float Apply (float a) {
				return 1 - ((float)Math.Pow(value, -power * a) - min) * scale;
			}
		}

		class CircleInterpolation : Interpolation {
			public override float Apply (float a) {
				if (a <= 0.5f) {
					a *= 2;
					return (1 - (float)Math.Sqrt(1 - a * a)) / 2;
				}

				a--;
				a *= 2;
				return ((float)Math.Sqrt(1 - a * a) + 1) / 2;
			}
		}

		class CircleInInterpolation : Interpolation {
			public override float Apply (float a) {
				return 1 - (float)Math.Sqrt(1 - a * a);
			}
		}

		class CircleOutInterpolation : Interpolation {
			public override float Apply (float a) {
				a--;
				return (float)Math.Sqrt(1 - a * a);
			}
		}

		public class ElasticInterpolation : Interpolation {
			protected readonly float value, power, scale, bounces;

			public ElasticInterpolation (float value, float power, int bounces, float scale) {
				this.value = value;
				this.power = power;
				this.scale = scale;
				this.bounces = bounces * MathUtils.PI * (bounces % 2 == 0 ? 1 : -1);
			}

			public override float Apply (float a) {
				if (a <= 0.5f) {
					a *= 2;
					return (float)Math.Pow(value, power * (a - 1)) * MathUtils.Sin(a * bounces) * scale / 2;
				}
				a = 1 - a;
				a *= 2;
				return 1 - (float)Math.Pow(value, power * (a - 1)) * MathUtils.Sin(a * bounces) * scale / 2;
			}
		}

		public class ElasticInInterpolation : ElasticInterpolation {
			public ElasticInInterpolation (float value, float power, int bounces, float scale)
				: base(value, power, bounces, scale) {
			}

			public override float Apply (float a) {
				if (a >= 0.99) return 1;
				return (float)Math.Pow(value, power * (a - 1)) * MathUtils.Sin(a * bounces) * scale;
			}
		}

		public class ElasticOutInterpolation : ElasticInterpolation {
			public ElasticOutInterpolation (float value, float power, int bounces, float scale)
				: base(value, power, bounces, scale) {
			}

			public override float Apply (float a) {
				if (a == 0) return 0;
				a = 1 - a;
				return 1 - (float)Math.Pow(value, power * (a - 1)) * MathUtils.Sin(a * bounces) * scale;
			}
		}

		public class SwingInterpolation : Interpolation {
			readonly float scale;

			public SwingInterpolation (float scale) {
				this.scale = scale * 2;
			}

			public override float Apply (float a) {
				if (a <= 0.5f) {
					a *= 2;
					return a * a * ((scale + 1) * a - scale) / 2;
				}
				a--;
				a *= 2;
				return a * a * ((scale + 1) * a + scale) / 2 + 1;
			}
		}

		public class SwingOutInterpolation : Interpolation {
			readonly float scale;

			public SwingOutInterpolation (float scale) {
				this.scale = scale;
			}

			public override float Apply (float a) {
				a--;
				return a * a * ((scale + 1) * a + scale) + 1;
			}
		}

		public class SwingInInterpolation : Interpolation {
			readonly float scale;

			public SwingInInterpolation (float scale) {
				this.scale = scale;
			}

			public override float Apply (float a) {
				return a * a * ((scale + 1) * a - scale);
			}
		}

		public class BounceOutInterpolation : Interpolation {
			protected readonly float[] widths, heights;

			public BounceOutInterpolation (float[] widths, float[] heights) {
				if (widths.Length != heights.Length)
					throw new ArgumentException("Must be the same number of widths and heights.");
				this.widths = widths;
				this.heights = heights;
			}

			public BounceOutInterpolation (int bounces) {
				if (bounces < 2 || bounces > 5) throw new ArgumentException("bounces cannot be < 2 or > 5: " + bounces);
				widths = new float[bounces];
				heights = new float[bounces];
				heights[0] = 1;
				switch (bounces) {
				case 2:
					widths[0] = 0.6f;
					widths[1] = 0.4f;
					heights[1] = 0.33f;
					break;
				case 3:
					widths[0] = 0.4f;
					widths[1] = 0.4f;
					widths[2] = 0.2f;
					heights[1] = 0.33f;
					heights[2] = 0.1f;
					break;
				case 4:
					widths[0] = 0.34f;
					widths[1] = 0.34f;
					widths[2] = 0.2f;
					widths[3] = 0.15f;
					heights[1] = 0.26f;
					heights[2] = 0.11f;
					heights[3] = 0.03f;
					break;
				case 5:
					widths[0] = 0.3f;
					widths[1] = 0.3f;
					widths[2] = 0.2f;
					widths[3] = 0.1f;
					widths[4] = 0.1f;
					heights[1] = 0.45f;
					heights[2] = 0.3f;
					heights[3] = 0.15f;
					heights[4] = 0.06f;
					break;
				}
				widths[0] *= 2;
			}

			public override float Apply (float a) {
				if (a == 1) return 1;
				a += widths[0] / 2;
				float width = 0, height = 0;
				for (int i = 0, n = widths.Length; i < n; i++) {
					width = widths[i];
					if (a <= width) {
						height = heights[i];
						break;
					}
					a -= width;
				}
				a /= width;
				float z = 4 / width * height * a;
				return 1 - (z - z * a) * width;
			}
		}

		public class BounceInterpolation : BounceOutInterpolation {
			public BounceInterpolation (float[] widths, float[] heights) : base(widths, heights) {
			}

			public BounceInterpolation (int bounces) : base(bounces) {
			}

			float Out (float a) {
				float test = a + widths[0] / 2;
				if (test < widths[0]) return test / (widths[0] / 2) - 1;
				return base.Apply(a);
			}

			public override float Apply (float a) {
				if (a <= 0.5f) return (1 - Out(1 - a * 2)) / 2;
				return Out(a * 2 - 1) / 2 + 0.5f;
			}
		}

		public class BounceInInterpolation : BounceOutInterpolation {
			public BounceInInterpolation (float[] widths, float[] heights) : base(widths, heights) {
			}

			public BounceInInterpolation (int bounces) : base(bounces) {
			}

			public override float Apply (float a) {
				return 1 - base.Apply(1 - a);
			}
		}
		#endregion
	}
}