using System;

namespace Chernobyl.Threading.Pools
{
    /// <summary>
    /// A pool that is used with SynchronizedPools to 
    /// synchronize data safes.
    /// </summary>
    public class DataSafeSynchronizePool : SynchronizedPool
    {
        /// <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 override bool Take(out Job objectToTake)
        {
            // we don't give out jobs
            objectToTake = null;
            return false;
        }

        /// <summary>
        /// Requests a job from this job pool. If this job pool
        /// does not have a job then RequestJob() is called on it
        /// until the 
        /// </summary>
        /// <param name="requestingPool">The first pool to call this method. This is
        /// the pool that wants a job.</param>
        /// <param name="callingPool">The pool that is calling this function. You should 
        /// always pass 'this' as the parameter.</param>
        /// <param name="poolCount">The number of times this method was called.</param>
        /// <returns>A job if one is available from our pool or any of the other pools; 
        /// null if no pool has a job.</returns>
        public override Job RequestJob(SynchronizedPool requestingPool, SynchronizedPool callingPool, ref uint poolCount)
        {
            // check to see if we have looped back around to ourself
            // requestingPool and callingPool will be equal if we 
            // have called this function on ourself.
            if (requestingPool != callingPool)
                if (requestingPool == this)
                    return null;    // we have looped all the way around

            // increment the pool count for this pool and
            // the request count
            poolCount++;
            RequestCount++;

            if(RequestCount == SynchronizedPoolCount)
            {
                RequestCount = 0;

                // we need to synchronize all of the 
                if (OnSynchronize != null)
                    OnSynchronize(this, EventArgs.Empty);
            }

            if (Next == null)
                throw new Exception("SynchronizedPools must be linked together in a circular referencing fashion.");

            return Next.RequestJob(requestingPool, this, ref poolCount);
        }

        /// <summary>
        /// The event that gets fired when data in the DataSafes should
        /// be synchronized.
        /// </summary>
        public event EventHandler OnSynchronize;

        /// <summary>
        /// The number of times a request for a job has been made
        /// through the method <see cref="RequestJob()"/>.
        /// </summary>
        uint RequestCount {get; set;}
    }
}