using System;

namespace Utility
{
	/// <summary>
	/// A delegate used by Interpolators to scale their progress and generate their current value.
	/// </summary>
	/// <param name="progress">The current progress of the Interpolator in the range [0, 1].</param>
	/// <returns>A value representing the scaled progress used to generate the Interpolator's Value.</returns>
	public delegate float InterpolatorScaleDelegate(float progress);

	public sealed class Interpolator
	{
		private static readonly Pool<Interpolator> interpolators = new Pool<Interpolator>(10, i => i.valid)
		{
			// Initialize is invoked whenever we get an instance through New()
			Initialize = i => 
 			{
 				i.valid = true;
 				i.progress = 0f;
 			},

			// Deinitialize is invoked whenever an object is reclaimed during CleanUp()
			Deinitialize = i =>
   			{
   				i.Tag = null;
   				i.scale = null;
   				i.step = null;
   				i.completed = null;
   			}
		};

		private bool valid;
		private float progress;
		private float start;
		private float end;
		private float range;
		private float speed;
		private float value;
		private InterpolatorScaleDelegate scale;
		private Action<Interpolator> step;
		private Action<Interpolator> completed;

		/// <summary>
		/// Gets the interpolator's progress in the range of [0, 1].
		/// </summary>
		public float Progress { get { return progress; } }

		/// <summary>
		/// Gets the interpolator's starting value.
		/// </summary>
		public float Start { get { return start; } }

		/// <summary>
		/// Gets the interpolator's ending value.
		/// </summary>
		public float End { get { return end; } }

		/// <summary>
		/// Gets the interpolator's current value.
		/// </summary>
		public float Value { get { return value; } }

		/// <summary>
		/// Gets or sets some extra data to the timer.
		/// </summary>
		public object Tag { get; set; }

		/// <summary>
		/// Creates a new Interpolator.
		/// </summary>
		/// <param name="start">The starting value.</param>
		/// <param name="end">The ending value.</param>
		/// <param name="length">The length of time, in seconds, to perform the interpolation.</param>
		/// <param name="step">An optional callback to invoke when the Interpolator is updated.</param>
		/// <param name="completed">An optional callback to invoke when the Interpolator completes.</param>
		/// <returns>The Interpolator instance.</returns>
		public static Interpolator Create(
			float start,
			float end,
			float length,
			Action<Interpolator> step,
			Action<Interpolator> completed)
		{
			return Create(start, end, length, InterpolatorScales.Linear, step, completed);
		}

		/// <summary>
		/// Creates a new Interpolator.
		/// </summary>
		/// <param name="start">The starting value.</param>
		/// <param name="end">The ending value.</param>
		/// <param name="length">The length of time, in seconds, to perform the interpolation.</param>
		/// <param name="scale">A method to perform</param>
		/// <param name="step">An optional callback to invoke when the Interpolator is updated.</param>
		/// <param name="completed">An optional callback to invoke when the Interpolator completes.</param>
		/// <returns>The Interpolator instance.</returns>
		public static Interpolator Create(
			float start,
			float end,
			float length,
			InterpolatorScaleDelegate scale,
			Action<Interpolator> step,
			Action<Interpolator> completed)
		{
			if (length <= 0f)
				throw new ArgumentException("length must be greater than zero");
			if (scale == null)
				throw new ArgumentNullException("scale");

			Interpolator i = interpolators.New();
			i.start = start;
			i.end = end;
			i.range = end - start;
			i.step = step;
			i.completed = completed;
			i.scale = scale;
			i.speed = 1f / length;

			return i;
		}

		/// <summary>
		/// Stops the Interpolator.
		/// </summary>
		public void Stop()
		{
			valid = false;
		}

		/// <summary>
		/// Updates all the Interpolators.
		/// </summary>
		/// <param name="dt">The elapsed time (in seconds) to advance the timers. Generally you want to pass in (float)gameTime.ElapsedGameTime.TotalSeconds from your main Game class.</param>
		public static void Update(float dt)
		{
			for (int i = 0; i < interpolators.ValidCount; i++)
			{
				Interpolator p = interpolators[i];

				// if Stop was called, the interpolator may already be invalid, so we
				// make sure to skip those interpolators.
				if (!p.valid)
					continue;

				// update the progress, clamping at 1f
				p.progress = Math.Min(p.progress + p.speed * dt, 1f);

				// get the scaled progress and use that to generate the value
				float scaledProgress = p.scale(p.progress);
				p.value = p.start + p.range * scaledProgress;

				// invoke the step callback
				if (p.step != null)
					p.step(p);

				// if the progress is 1...
				if (p.progress == 1f)
				{
					// the interpolator is done
					p.valid = false;

					// invoke the completed callback
					if (p.completed != null)
						p.completed(p);
				}
			}

			// clean up the invalid interpolators
			interpolators.CleanUp();
		}
	}
}