using System.Collections.Generic;

namespace TestPooling.Pool {
  using System;
  using System.Collections.Concurrent;
  using System.Linq;

  public class ManagedPool<T> : IDisposable where T : class {

    private static readonly ConcurrentStack<LinkedList<T>> Pool = new ConcurrentStack<LinkedList<T>>();
    private readonly Func<T> Factory;
    public readonly int PartitionSize;

    private readonly IList<LinkedList<T>> partitions = new List<LinkedList<T>>();
    private LinkedList<T> currentPartition;
    private LinkedListNode<T> currentNode;

    private int entryIndex = 0;

    public static int InstanceCount { get { return Pool.Sum(p => p.Count); } }

    public ManagedPool(int partitionSize, Func<T> factory) {
      PartitionSize = partitionSize;
      Factory = factory;
    }

    public T Get() {
      if (currentPartition == null || entryIndex == PartitionSize) {
        currentPartition = GetPartition();
        currentNode = currentPartition.First;
        entryIndex = 0;

        partitions.Add(currentPartition);
      }

      T entry;
      if (currentNode == null) {
        entry = Factory();
        currentPartition.AddLast(entry);
      } else {
        entry = currentNode.Value;
        currentNode = currentNode.Next;
      }

      entryIndex++;

      return entry;
    }

    private LinkedList<T> GetPartition() {
      LinkedList<T> partition;

      return Pool.TryPop(out partition) ? partition : new LinkedList<T>();
    }

    public void Dispose() {
      Pool.PushRange(partitions.ToArray());
    }
  }
}