namespace Chernobyl.DesignPatterns.Pool
{
    /// <summary>
    /// A pool that takes objects from one pool (called the 
    /// "drainage pool") and, if that pool runs out of objects, 
    /// it pulls from another pool (called the "main pool"). 
    /// All returned objects are placed into the "drainage pool" 
    /// instead of the main pool.
    /// </summary>
    /// <typeparam name="PooledType">The types to pool together.</typeparam>
    public class DrainagePool<PooledType> : IPool<PooledType>
    {
        /// <summary>
        /// Constructor.
        /// </summary>
        /// <param name="drainagePool">The pool to "drain" objects into.</param>
        /// <param name="mainPool">The pool to pull objects out of if the
        /// cache dries up.</param>
        public DrainagePool(IPool<PooledType> drainagePool, IPool<PooledType> mainPool)
        {
            DrainingPool = drainagePool;
            MainPool = mainPool;
        }

        /// <summary>
        /// Takes an object from the drainage pool if it still has objects
        /// left. If no objects are left, then object are taken out
        /// of the main pool.
        /// </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 (DrainingPool.Take(out objectToTake) == false)
            {
                if (MainPool.Take(out objectToTake) == false)
                    return false;
            }
            return true;
        }

        /// <summary>
        /// Returns a previously taken object to the drainage
        /// pool even if that object was taken from the main
        /// pool.
        /// </summary>
        /// <param name="objectToReturn">The object to return
        /// to the pool.</param>
        public void Return(PooledType objectToReturn)
        {
            DrainingPool.Return(objectToReturn);
        }

        /// <summary>
        /// Adds an item to the drainage pool.
        /// </summary>
        /// <param name="item">The item to add to the pool</param>
        public void Add(PooledType item)
        {
            DrainingPool.Add(item);
        }

        /// <summary>
        /// Clears out the drainage pool.
        /// </summary>
        public void Clear()
        {
            DrainingPool.Clear();
        }

        /// <summary>
        /// The size of the drainage pool.
        /// </summary>
        public int Count
        {
            get { return DrainingPool.Count; }
        }

        /// <summary>
        /// Removes an item from the drainage pool.
        /// </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 DrainingPool.Remove(item);
        }

        /// <summary>
        /// The pool to pull objects from when their
        /// are objects available. If no objects are 
        /// available then objects are taken from the
        /// <see cref="MainPool"/>.
        /// </summary>
        public IPool<PooledType> DrainingPool { get; protected set; }

        /// <summary>
        /// The pool to take objects from if the cache
        /// has no more objects left to take.
        /// </summary>
        public IPool<PooledType> MainPool { get; protected set; }
    }
}