using Chernobyl.DesignPatterns.Visitor;

namespace Chernobyl.Threading.Pools.Visitors
{
    /// <summary>
    /// A visitor that adds a new synchronized pool to the
    /// circular reference chain of synchronized pools.
    /// </summary>
    public class AddSynchronizedPoolVisitor : IVisitor<SynchronizedPool>
    {
        /// <summary>
        /// Constructor.
        /// </summary>
        /// <param name="poolToAdd">The pool to add to the circular reference chain.</param>
        public AddSynchronizedPoolVisitor(SynchronizedPool poolToAdd)
        {
            PoolToAdd = poolToAdd;
        }

        /// <summary>
        /// Visits a synchronized pool and adds the requested pool
        /// to this pools' circular reference chain.
        /// </summary>
        /// <param name="host">The host to visit</param>
        public void Visit(SynchronizedPool host)
        {
            if (StartHost == null)
            {
                StartHost = host;

                // set the new next pool and set the 
                host.Next = PoolToAdd;
                PoolToAdd.SynchronizingObject = host.SynchronizingObject;
            }
            else if(host.Next == null)
            {
                // this is the end of the reference chain
                // so we need to hook it back up to the start
                host.Next = StartHost;
            }
            else if (StartHost == host) // don't loop forever
                return;

            host.SynchronizedPoolCount++;

            host.Accept(this);
        }

        /// <summary>
        /// The first pool that we visited.
        /// </summary>
        public SynchronizedPool StartHost { get; protected set; }

        /// <summary>
        /// The pool to add to the circular reference chain.
        /// </summary>
        public SynchronizedPool PoolToAdd { get; protected set; }
    }
}