using System;
using System.Collections;
using System.Collections.Generic;
using System.Reflection;

namespace Interpolation
{
	/// <summary>
	/// A collection that maintains a finite set of class instances to allow for recycling
	/// instances and minimizing the effects of garbage collection.
	/// </summary>
	/// <typeparam name="T">The type of object to store in the Pool. Pools can only hold class types.</typeparam>
	public class Pool<T> : IEnumerable<T> where T : class
	{
		// the actual items of the pool
		private readonly T[] items;

		// we keep track of a list so we can provide an enumerator that only includes active objects
		private readonly List<T> enumerableItemList = new List<T>();

		// used for checking if a given object is still valid
		private readonly Predicate<T> validate;

		// used for allocating instances of the object
		private readonly Allocate allocate;

		// a constructor the default allocate method can use to create instances
		private readonly ConstructorInfo constructor;

		/// <summary>
		/// Gets or sets a delegate used for initializing objects before returning them from the New method.
		/// </summary>
		public Action<T> Initialize { get; set; }

		/// <summary>
		/// Gets or sets a delegate that is run when an object is moved from being valid to invalid
		/// in the CleanUp method.
		/// </summary>
		public Action<T> Deinitialize { get; set; }

		/// <summary>
		/// Gets the maximum number of items capable of fitting in the pool.
		/// </summary>
		public int MaximumSize { get { return items.Length; } }

		/// <summary>
		/// Gets the current number of allocated instances in the pool.
		/// </summary>
		/// <remarks>
		/// This value includes invalid objects and is only exposed for debugging and profiling
		/// purposes by providing a method for games to know how many objects are actually
		/// being allocated by the pool.
		/// </remarks>
		public int AllocationSize { get; private set; }

		/// <summary>
		/// Gets the number of valid objects in the pool.
		/// </summary>
		public int ValidCount { get { return items.Length - InvalidCount; } }

		/// <summary>
		/// Gets the number of invalid objects in the pool.
		/// </summary>
		public int InvalidCount { get; private set; }

		/// <summary>
		/// Returns a valid object at the given index. The index must fall in the range of [0, ValidCount].
		/// </summary>
		/// <param name="index">The index of the valid object to get</param>
		/// <returns>A valid object found at the index</returns>
		public T this[int index]
		{
			get
			{
				index += InvalidCount;

				if (index < InvalidCount || index >= MaximumSize)
					throw new IndexOutOfRangeException("The index must be less than or equal to ValidCount");

				return items[index];
			}
		}

		/// <summary>
		/// Creates a new pool of allocated instances.
		/// </summary>
		/// <remarks>
		/// This will instantiate the entire array of objects for the pool. If you wish
		/// to perform lazy instantiation, use one of the constructors that takes in an
		/// initialAllocation parameter to set how many instances to create in the
		/// constructor.
		/// </remarks>
		/// <param name="size">The maximum size of the pool.</param>
		/// <param name="validateFunc">A predicate used to determine if a given object is still valid.</param>
		public Pool(int size, Predicate<T> validateFunc) : this(size, size, validateFunc) { }

		/// <summary>
		/// Creates a new pool with a specific number of pre-allocated instances.
		/// </summary>
		/// <param name="size">The maximum size of the pool.</param>
		/// <param name="initialAllocation">The number of items to instantiate at construction time.</param>
		/// <param name="validateFunc">A predicate used to determine if a given object is still valid.</param>
		public Pool(int size, int initialAllocation, Predicate<T> validateFunc) : this(size, initialAllocation, validateFunc, null) { }

		/// <summary>
		/// Creates a new pool with a specific number of pre-allocated instances.
		/// </summary>
		/// <param name="size">The maximum size of the pool.</param>
		/// <param name="initialAllocation">The number of items to instantiate at construction time.</param>
		/// <param name="validateFunc">A predicate used to determine if a given object is still valid.</param>
		/// <param name="allocateFunc">A function used to allocate an instance for the pool.</param>
		public Pool(int size, int initialAllocation, Predicate<T> validateFunc, Allocate allocateFunc)
		{
			// validate some parameters
			if (size < 1)
				throw new ArgumentException("size must be greater than zero");
			if (initialAllocation < 0 || initialAllocation > size)
				throw new ArgumentException("initialAllocation must be non-negative and cannot be larger than size");
			if (validateFunc == null)
				throw new ArgumentNullException("validateFunc");

			items = new T[size];
			validate = validateFunc;
			InvalidCount = size;

			// default to using a parameterless constructor if no allocateFunc was given
			allocate = allocateFunc ?? ConstructorAllocate;

			// if we are using the ConstructorAllocate method, make sure we have a valid parameterless constructor
			if (allocate == ConstructorAllocate)
			{
				// we want to find any parameterless constructor, public or not
				constructor = typeof(T).GetConstructor(BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance, null, new Type[] { }, null);

				if (constructor == null)
					throw new InvalidOperationException("No allocateFunc was provided and " + typeof(T) + " does not have a parameterless constructor.");
			}

			// allocate the initial set of instances
			AllocationSize = initialAllocation;
			for (int i = 0; i < initialAllocation; i++)
			{
				T obj = allocate();

				if (obj == null)
					throw new InvalidOperationException("The pool's allocate method returned a null object reference.");

				items[i] = obj;
			}
		}

		/// <summary>
		/// Cleans up the pool by checking each valid object to ensure it is still actually valid.
		/// </summary>
		public void CleanUp()
		{
			for (int i = InvalidCount; i < items.Length; i++)
			{
				T obj = items[i];

				// if it's still valid, keep going
				if (validate(obj)) 
					continue;

				// otherwise if we're not at the start of the invalid objects, we have to move
				// the object to the invalid object section of the array
				if (i != InvalidCount)
				{
					items[i] = items[InvalidCount];
					items[InvalidCount] = obj;
				}

				// remove the item from the enumerable list
				enumerableItemList.Remove(obj);

				// clean the object if desired
				if (Deinitialize != null)
					Deinitialize(obj);

				InvalidCount++;
			}
		}

		/// <summary>
		/// Returns a new object from the Pool.
		/// </summary>
		/// <returns>The next object in the pool if available, null if all instances are valid.</returns>
		public T New()
		{
			if (InvalidCount > 0)
			{
				// decrement the counter
				InvalidCount--;

				// get the next item in the list
				T obj = items[InvalidCount];

				// if the item is null, we need to allocate a new instance
				if (obj == null)
				{
					obj = allocate();

					if (obj == null)
						throw new InvalidOperationException("The pool's allocate method returned a null object reference.");

					items[InvalidCount] = obj;
					AllocationSize++;
				}

				// initialize the object if a delegate was provided
				if (Initialize != null)
					Initialize(obj);

				// add it to our enumerable list
				enumerableItemList.Add(obj);

				return obj;
			}

			return null;
		}

		/// <summary>
		/// Returns an enumerator that iterates through the collection.
		/// </summary>
		/// <returns>
		/// A <see cref="T:System.Collections.Generic.IEnumerator`1"/> that can be used to iterate through the collection.
		/// </returns>
		/// <filterpriority>1</filterpriority>
		public IEnumerator<T> GetEnumerator()
		{
			return enumerableItemList.GetEnumerator();
		}

		/// <summary>
		/// Returns an enumerator that iterates through a collection.
		/// </summary>
		/// <returns>
		/// An <see cref="T:System.Collections.IEnumerator"/> object that can be used to iterate through the collection.
		/// </returns>
		/// <filterpriority>2</filterpriority>
		IEnumerator IEnumerable.GetEnumerator()
		{
			return GetEnumerator();
		}

		// a default Allocate delegate for use when no custom allocate delegate is provided
		private T ConstructorAllocate()
		{
			return constructor.Invoke(null) as T;
		}

		/// <summary>
		/// A delegate that returns a new object instance for the Pool.
		/// </summary>
		/// <returns>A new object instance.</returns>
		public delegate T Allocate();
	}
}