#region License

/*
* Copyright © 2002-2005 the original author or authors.
* 
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
* 
*      http://www.apache.org/licenses/LICENSE-2.0
* 
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/

#endregion

#region Imports

using System;
using System.Collections;
using Spring.Util;
using Spring.Threading;

#endregion

namespace Spring.Pool.Support
{
	/// <summary>
	/// A simple pool implementation
	/// </summary>
	/// <remarks>
	/// <p>
	/// Based on the implementation found in Concurrent Programming in Java,
	/// 2nd ed., by <a href="http://gee.cs.oswego.edu/dl/">Doug Lea</a>.
	/// </p>
	/// </remarks>
	/// <author>Doug Lea</author>
	/// <author>Federico Spinazzi</author>
	/// <author>Mark Pollack</author>
	public class SimplePool : IObjectPool
	{
		private readonly IPoolableObjectFactory factory;
		private bool closed;
		private IList free = new ArrayList();
		private IList busy = new ArrayList(); // linear search !!

		/// <summary>
		/// Set of permits
		/// </summary>
		internal readonly Semaphore available;

		/// <summary>
		/// Creates a new instance of the <see cref="Spring.Pool.Support.SimplePool"/>
		/// class.
		/// </summary>
		/// <param name="factory">
		/// The factory used to instantiate and manage the lifecycle of pooled objects.
		/// </param>
		/// <param name="size">The initial size of the pool.</param>
		/// <exception cref="System.ArgumentNullException">
		/// If the supplied <paramref name="factory"/> is <see langword="null"/>.
		/// </exception>
		/// <exception cref="System.ArgumentException">
		/// If the supplied <paramref name="size"/> is less than or equal to zero.
		/// </exception>
		public SimplePool(IPoolableObjectFactory factory, int size)
		{
			AssertUtils.ArgumentNotNull(factory, "factory");
			this.available = new Semaphore(size);
			this.factory = factory;
			InitItems(size);
		}

		/// <summary>
		/// Obtain an instance from the pool.
		/// </summary>
		/// <exception cref="Spring.Pool.PoolException">
		/// In case the pool is unusable.
		/// </exception>
		/// <seealso cref="Spring.Pool.IPoolableObjectFactory.ActivateObject"/>
		/// <seealso cref="Spring.Pool.IObjectPool.BorrowObject"/>
		public object BorrowObject()
		{
			available.Acquire();
			return DoBorrow();
		}

		/// <summary>
		/// Return an instance to the pool.
		/// </summary>
		/// <param name="target">The instance to be returned to the pool.</param>
		/// <seealso cref="Spring.Pool.IPoolableObjectFactory.PassivateObject"/>
		/// <seealso cref="Spring.Pool.IObjectPool.ReturnObject"/>
		public void ReturnObject(object target)
		{
			if (DoReturn(target))
			{
				available.Release();
			}
		}

		/// <summary>
		/// Create an object using the factory set by
		/// the <see cref="PoolableObjectFactory"/> property
		/// or other implementation dependent mechanism
		/// and place it into the pool.
		/// </summary>
		/// <remarks>
		/// <p>
		/// This implementation <b>always</b> throws a
		/// <see cref="System.NotSupportedException"/>.
		/// </p>
		/// </remarks>
		/// <exception cref="NotSupportedException">
		/// If the implementation does not support the operation.
		/// </exception>
		public void AddObject()
		{
			throw new NotSupportedException();
		}

		/// <summary>
		/// Synchronized borrow logic.
		/// </summary>
		/// <seealso cref="Spring.Pool.Support.SimplePool.BorrowObject"/>
		protected object DoBorrow()
		{
			lock (this)
			{
				while (free.Count > 0)
				{
					int i = free.Count - 1;
					object o = free[i];
					free.RemoveAt(i);
					factory.ActivateObject(o);
					if (factory.ValidateObject(o))
					{
						busy.Add(o);
						return o;
					}
				}
				if (!closed)
				{
					throw new PoolException("No more valid objects in pool.");
				}
				else
				{
					throw new PoolException("Pool was closed and is unusable.");
				}
			}
		}

		/// <summary>
		/// Synchronized release logic.
		/// </summary>
		/// <param name="target">
		/// The object to release to the pool.
		/// </param>
		/// <returns>
		/// <see langword="false"/> if the object was not a busy one.
		/// </returns>
		protected bool DoReturn(object target)
		{
			lock (this)
			{
				if (busy.Contains(target))
				{
					busy.Remove(target);
					factory.PassivateObject(target);
					free.Add(target);
					return true;
				}
				return false;
			}
		}

		/// <summary>
		/// Instantiates the supplied number of instances and adds
		/// them to the pool.
		/// </summary>
		/// <param name="initialInstances">
		/// The initial number of objects to build.
		/// </param>
		/// <exception cref="System.ArgumentException">
		/// If the supplied number of <paramref name="initialInstances"/> is
		/// less than or equal to zero.
		/// </exception>
		protected void InitItems(int initialInstances)
		{
			if(initialInstances <= 0)
			{
				throw new ArgumentException("Cannot pool a negative number of instances.", "initialInstances");
			}
			for (int i = 0; i < initialInstances; ++i)
			{
				free.Add(factory.MakeObject());
			}
		}

		/// <summary>
		/// Close the pool and free any resources associated with it.
		/// </summary>
		public void Close()
		{
			lock (this)
			{
				for (IEnumerator e = busy.GetEnumerator();
				     e.MoveNext();
				     e = busy.GetEnumerator())
				{
					ReturnObject(e.Current);
				}
				foreach (object o in free)
				{
					factory.DestroyObject(o);
				}
				MakeNotUsable();
			}
		}

		/// <summary>
		/// Clear objects sitting idle in the pool, releasing any
		/// associated resources.
		/// </summary>
		/// <remarks>
		/// <p>
		/// This implementation <b>always</b> throws a
		/// <see cref="System.NotSupportedException"/>.
		/// </p>
		/// </remarks>
		/// <exception cref="NotSupportedException">
		/// If the implementation does not support the operation.
		/// </exception>
		public void Clear()
		{
			throw new NotSupportedException();
		}

		/// <summary>
		/// Change the state of the pool to unusable.
		/// </summary>
		private void MakeNotUsable()
		{
			free = busy = new ArrayList();
			closed = true;
		}

		/// <summary>
		/// Gets the number of instances currently borrowed from the pool.
		/// </summary>
		/// <exception cref="NotSupportedException">
		/// If the implementation does not support the operation.
		/// </exception>
		/// <seealso cref="Spring.Pool.IObjectPool.NumActive"/>
		public int NumActive
		{
			get { return this.busy.Count; }
		}

		/// <summary>
		/// Gets the number of instances currently idle in the pool.
		/// </summary>
		/// <exception cref="NotSupportedException">
		/// If the implementation does not support the operation.
		/// </exception>
		/// <seealso cref="Spring.Pool.IObjectPool.NumIdle"/>
		public int NumIdle
		{
			get { return this.free.Count; }
		}

		/// <summary>
		/// Set the factory used to create new instances.
		/// </summary>
		/// <remarks>
		/// <p>
		/// This implementation <b>always</b> throws a
		/// <see cref="System.NotSupportedException"/>.
		/// </p>
		/// </remarks>
		/// <exception cref="NotSupportedException">
		/// If the implementation does not support the operation.
		/// </exception>
		public IPoolableObjectFactory PoolableObjectFactory
		{
			set { throw new NotSupportedException(); }
		}
	}
}
