using System.Collections.Generic;
using Chernobyl.DesignPatterns.Pool;

namespace Chernobyl.Threading.Pools
{
    /// <summary>
    /// Used to make creating threading pools
    /// easier.
    /// </summary>
    public abstract class ThreadPool : IPool<Job>
    {
        /// <summary>
        /// Takes a job from the pool. If the pool has 
        /// no more jobs to give or it does not want to 
        /// give a job out then null will be returned.
        /// </summary>
        /// <param name="objectToTake">The object to fill with
        /// the taken job.</param>
        /// <returns>True if there was a job that could be 
        /// taken from the pool and that job was assigned to 
        /// <paramref name="objectToTake"/>, false if otherwise.</returns>
        public abstract bool Take(out Job objectToTake);

        /// <summary>
        /// Returns a previously taken job to the pool.
        /// </summary>
        /// <param name="objectToReturn">The job to return
        /// to the pool.</param>
        public virtual void Return(Job objectToReturn)
        {
            lock (CompletedJobs)
                CompletedJobs.AddLast(objectToReturn);
        }

        /// <summary>
        /// Adds a job to the list of uncompleted jobs.
        /// </summary>
        /// <param name="item">The job to add to the list.</param>
        public virtual void Add(Job item)
        {
            lock (UncompletedJobs)
                UncompletedJobs.AddLast(item);
        }

        /// <summary>
        /// Clears out all of the jobs in the uncompleted
        /// and completed jobs lists.
        /// </summary>
        public void Clear()
        {
            lock (UncompletedJobs)
                UncompletedJobs.Clear();

            lock (CompletedJobs)
                CompletedJobs.Clear();
        }

        /// <summary>
        /// Returns the number of jobs in the completed and uncompleted
        /// job lists.
        /// </summary>
        public int Count
        {
            get
            {
                lock (UncompletedJobs)
                    lock (CompletedJobs)
                        return UncompletedJobs.Count + CompletedJobs.Count;
            }
        }

        /// <summary>
        /// Removes one of the jobs from either the completed
        /// or uncompleted job lists.
        /// </summary>
        /// <param name="item">The job to remove.</param>
        /// <returns>True if the job was removed, false if
        /// otherwise.</returns>
        public virtual bool Remove(Job item)
        {
            bool result = false;
            lock (CompletedJobs)
                result = CompletedJobs.Remove(item);

            if (result == false)
            {
                lock (UncompletedJobs)
                    return UncompletedJobs.Remove(item);
            }

            return true;
        }

        /// <summary>
        /// The jobs that have yet to be completed.
        /// </summary>
        protected LinkedList<Job> UncompletedJobs { get; set; }

        /// <summary>
        /// A list of all the jobs that have been completed or the
        /// jobs that were returned to this pool through Return(Job).
        /// </summary>
        protected LinkedList<Job> CompletedJobs { get; set; }
    }
}