using System.Collections.Generic;
using System.Linq;

namespace Chernobyl.DesignPatterns.Pool
{
    /// <summary>
    /// A class that represents a simple pool or a 
    /// pool that just holds a set of objects that
    /// can be taken and returned.
    /// </summary>
    /// <typeparam name="PooledType">The type of item to pool together.</typeparam>
    public class SimplePool<PooledType> : IPool<PooledType>
    {
        /// <summary>
        /// Constructor that creates a SimplePool which holds
        /// objects in a LinkedList.
        /// </summary>
        public SimplePool() : this(new LinkedList<PooledType>())
        {
        }

        /// <summary>
        /// Constructor.
        /// </summary>
        /// <param name="collection">The collection to use to hold objects in the pool.</param>
        public SimplePool(ICollection<PooledType> collection)
        {
            PooledObjects = collection;
        }

        /// <summary>
        /// Takes an object from the pool. If the pool has 
        /// no more objects to give or it does not want to 
        /// give an object out then null will be returned.
        /// </summary>
        /// <param name="objectToTake">The object to fill with
        /// the taken object.</param>
        /// <returns>True if there was an object that could be 
        /// taken from the pool and that object was assigned to 
        /// <paramref name="objectToTake"/>, false if otherwise.</returns>
        public bool Take(out PooledType objectToTake)
        {
            if (PooledObjects.Count == 0)
            {
                objectToTake = default(PooledType);
                return false;
            }

            objectToTake = PooledObjects.First();
            PooledObjects.Remove(objectToTake);
            return true;
        }

        /// <summary>
        /// Returns a previously taken object to the pool.
        /// </summary>
        /// <param name="objectToReturn">The object to return
        /// to the pool.</param>
        public void Return(PooledType objectToReturn)
        {
            PooledObjects.Add(objectToReturn);
        }

        /// <summary>
        /// Adds an item to the collection of pooled objects.
        /// </summary>
        /// <param name="item">The item to add.</param>
        public void Add(PooledType item)
        {
            PooledObjects.Add(item);
        }

        /// <summary>
        /// Clears out the collection of pooled objects
        /// </summary>
        public void Clear()
        {
            PooledObjects.Clear();
        }

        /// <summary>
        /// The number of objects contained by the collection of pooled objects.
        /// </summary>
        public int Count
        {
            get { return PooledObjects.Count; }
        }

        /// <summary>
        /// Removes an item from the collection of pooled objects.
        /// </summary>
        /// <param name="item">The item to remove.</param>
        /// <returns>True if the item was removed, false 
        /// if otherwise.</returns>
        public bool Remove(PooledType item)
        {
            return PooledObjects.Remove(item);
        }

        /// <summary>
        /// The list of pooled objects.
        /// </summary>
        public ICollection<PooledType> PooledObjects { get; protected set; }
    }
}