using System;
using System.Collections.Generic;

namespace Developpez.Dotnet.ComponentModel
{
    /// <summary>
    /// Gestionnaire d'un pool d'objet générique
    /// </summary>
    /// <typeparam name="T">Type des objets à placer dans le gestionnaire</typeparam>
    public class ParameterizedGenericPool<T>
    {
        /// <summary>
        /// Conteneur contenant l'objet du pool
        /// </summary>
        public class GenericPoolItem : IDisposable
        {
            LinkedListNode<GenericPoolItem> node = null;

            /// <summary>
            /// Node utilisée pour rattacher l'objet au pool
            /// </summary>
            public virtual LinkedListNode<GenericPoolItem> Node
            {
                get
                {
                    if (node == null)
                        node = new LinkedListNode<GenericPoolItem>(this);
                    return node;
                }
                set { node = value; }
            }

            /// <summary>
            /// Objet placé dans le Pool
            /// </summary>
            public virtual T Value { get; protected set; }

            /// <summary>
            /// Gestionnaire parent
            /// </summary>
            public virtual ParameterizedGenericPool<T> Parent{get;protected set;}

            /// <summary>
            /// Initialise une nouvelle instance de conteneur
            /// </summary>
            /// <param name="newItem">Element à placer</param>
            /// <param name="parent">Gestionnaire parent</param>
            public GenericPoolItem(T newItem, ParameterizedGenericPool<T> parent)
            {
                Value = newItem;
                Parent = parent;
                Node = null;
            }

            /// <summary>
            /// Repasse l'objet d'un état "libéré" à une état "non libéré"
            /// </summary>
            public virtual void UnDispose()
            {
                disposed = false;
            }

            bool disposed = false;

            /// <summary>
            /// Destructeur
            /// </summary>
            ~GenericPoolItem()
            {
                if (Environment.HasShutdownStarted)
                    return;


                if (Parent.CanAddItem && Parent.AppendItemToPool(Node))
                {
                    GC.ReRegisterForFinalize(this);
                }
            }

            /// <summary>
            /// Passe l'objet à un état "libéré" et le replace dans le pool d'objets
            /// </summary>
            public void Dispose()
            {
                if (!disposed)
                {
                    disposed = true;
                    if (Parent.AppendItemToPool(this))
                    {
                        GC.SuppressFinalize(this);
                    }
                }
            }
        }

        /// <summary>
        /// Méthode servant à la création d'un nouvel objet dans le pool
        /// </summary>
        /// <returns>Objet crée</returns>
        public delegate T CreateNewItemMethod();

        /// <summary>
        /// Pool d'objets
        /// </summary>
        protected virtual LinkedList<GenericPoolItem> Pool { get; private set; }

        /// <summary>
        /// Nombre d'objets actuellement présents dans le pool
        /// </summary>
        public virtual int PoolCount
        {
            get
            {
                return Pool.Count;
            }
        }
        
        /// <summary>
        /// Rajoute un objet dans le pool
        /// </summary>
        /// <param name="item">Objet à rajouter</param>
        /// <returns>true si l'opération a réussit, false sinon</returns>
        protected virtual bool AppendItemToPool(GenericPoolItem item)
        {
            lock (Pool)
            {
                if (CanAddItem)
                {
                    Pool.AddFirst(item);
                    return true;
                }
                else
                {
                    return false;
                }
            }
        }

        /// <summary>
        /// Indique si l'état actuel du gestionnaire permet d'y rajouter un objet.
        /// (S'il y a déjà un nombre maximal d'éléments dans le pool, aucun ajout ne sera possible)
        /// </summary>
        public virtual bool CanAddItem
        {
            get
            {
                if (Pool.Count >= MaxCachedItemCount)
                    return false;
                else
                    return true;
            }
        }

        /// <summary>
        /// Rajoute un objet dans le pool
        /// </summary>
        /// <param name="item">Objet à rajouter</param>
        /// <returns>true si l'opération a réussit, false sinon</returns>
        protected virtual bool AppendItemToPool(LinkedListNode<GenericPoolItem> item)
        {
            lock (Pool)
            {
                if (CanAddItem)
                {
                    Pool.AddFirst(item);
                    return true;
                }
                else
                    return false;
            }
        }


        /// <summary>
        /// Renvoie un objet du pool
        /// </summary>
        /// <returns>Un objet du pool, ou null si aucun objet n'est disponible dans le pool</returns>
        protected virtual GenericPoolItem GetItemFromPool()
        {
            lock (Pool)
            {
                if (Pool.Count <= 0)
                    return null;
                else
                {
                    GenericPoolItem res = Pool.Last.Value;
                    Pool.RemoveLast();

                    res.UnDispose();
                    return res;
                }
            }
        }

        /// <summary>
        /// Nombre d'objets initialement présents dans le pool
        /// </summary>
        public virtual int BaseCachedItemCount { get; protected set; }

        /// <summary>
        /// Nombre d'objets maximum dans le pool
        /// </summary>
        public virtual int MaxCachedItemCount { get; protected set; }

        /// <summary>
        /// Function servant à créer de nouveaux objets pour le pool
        /// </summary>
        protected virtual CreateNewItemMethod NewItemAllocator { get; set; }

        /// <summary>
        /// Crée une nouvel instance du gestionnaire de pool générique
        /// </summary>
        /// <param name="basePooledItemCount">Objets alloués au démarrage</param>
        /// <param name="maxPooledItemCount">Nombre maximum d'objets avant que ceux-ci ne soient relachés</param>
        /// <param name="newItemAllocator">allocateur</param>
        public ParameterizedGenericPool(int basePooledItemCount, int maxPooledItemCount, CreateNewItemMethod newItemAllocator)
        {
            if (newItemAllocator == null)
                throw new ArgumentNullException("newItemAllocator");
            if (basePooledItemCount < 1)
                throw new ArgumentOutOfRangeException("basePooledItemCount");
            if (maxPooledItemCount < basePooledItemCount)
                throw new ArgumentOutOfRangeException("maxPooledItemCount");

            MaxCachedItemCount = maxPooledItemCount;
            BaseCachedItemCount = basePooledItemCount;
            NewItemAllocator = newItemAllocator;
            Pool = new LinkedList<ParameterizedGenericPool<T>.GenericPoolItem>();

            GenericPoolItem myItem;
            LinkedListNode<GenericPoolItem> newNode;
            for (int i = 0; i < basePooledItemCount; i++)
            {
                newNode = new LinkedListNode<GenericPoolItem>(
                       myItem = new GenericPoolItem(NewItemAllocator.Invoke(), this));
                myItem.Node = newNode;
                Pool.AddFirst(newNode);
            }
        }

        /// <summary>
        /// Obtient un objet à partir du pool, ou en crée un nouveau si aucun n'est disponible
        /// </summary>
        /// <returns>Un objet du pool, ou un nouvel objet si aucun n'est disponible</returns>
        public virtual GenericPoolItem ObtainItem()
        {
            return ObtainItem(true);
        }

        /// <summary>
        /// Obtient un objet dans le pool
        /// </summary>
        /// <param name="canCreateNew">Si le pool est vide et que canCreateNew vaut true, un nouvel
        /// objet est crée. Sinon, null est renvoyé</param>
        /// <returns>Objet du pool, ou null si aucun objet n'est disponible et canCreateNew vaut false</returns>
        public virtual GenericPoolItem ObtainItem(bool canCreateNew)
        {
            GenericPoolItem item = GetItemFromPool();
            if (item != null || !canCreateNew)
            {
                return item;
            }
            else
            {
                item = InternalNewItem();
                return item;
            }
        }

        /// <summary>
        /// Crée un nouvel objet pour le pool
        /// </summary>
        /// <returns>Nouvel objet crée</returns>
        protected virtual GenericPoolItem InternalNewItem()
        {
            return new GenericPoolItem(NewItemAllocator.Invoke(), this);
        }
    }

    /// <summary>
    /// Gestionnaire d'un pool d'objet générique. Les objets doivent avoir
    /// un constructeur sans paramètre.<br/>
    /// Si aucun constructeur sans paramètre n'est possible, utilisez la classe <see cref="ParameterizedGenericPool{T}"/>
    /// </summary>
    /// <typeparam name="T">Type d'objet à gérer</typeparam>
    public class GenericPool<T> : ParameterizedGenericPool<T> where T : new()
    {
        /// <summary>
        /// Crée une nouvel instance du gestionnaire de pool générique.<br/>
        /// Par défaut 1 objet est présent dans le pool et 10 au maximum peuvent être gérés
        /// </summary>
        public GenericPool()
            : this(1, 10)
        {
        }

        /// <summary>
        /// Crée une nouvel instance du gestionnaire de pool générique
        /// </summary>
        /// <param name="startObjectCount">Objets alloués au démarrage</param>
        /// <param name="maxObjectCount">Nombre maximum d'objets avant que ceux-ci ne soient relachés</param>
        public GenericPool(int startObjectCount, int maxObjectCount)
            : base(startObjectCount, maxObjectCount, new ParameterizedGenericPool<T>.CreateNewItemMethod(delegate
                {
                    return new T();
                }))
        {
        }
    }
}