using System;
using System.EnterpriseServices;
using System.Threading;
using System.Runtime.Serialization;

namespace newtelligence.EnterpriseServicesTools
{
	
	/// <summary>
	/// This class implements a client-side pool for 
	/// just-in-time activated ServicedComponents. The pool
	/// is fully SMP thread safe and can be held in a 
	/// static class variable in environments like ASP.NET.
	/// Goal of this pool is to eliminate the client-side
	/// activation work for ServicedComponents which are 
	/// frequently used in such environments.
	/// </summary>
	/// <remarks>
	/// <p>Using this pool is permitted under all circumstances 
	/// where holding and reusing references to just-in-time 
	/// activated objects is appropriate. It is explicitly not 
	/// permitted (or properly functional) to use this pool when Pop() 
	/// would be invoked from within a preexisting EnterpriseServices 
	/// context other than the default context.</p>
	/// </remarks>
	public sealed class JustInTimeActivationProxyPool<SCType> where SCType : ServicedComponent, new()
	{
		/// <summary>
		/// COM+ failure code indicating that the call could not be completed and did
		/// indeed not execute on the server.
		/// </summary>
		private const UInt32 ERpcCallFailedDne = 0x800706bf;
		/// <summary>
		/// COM+ failure code indicating that the server class is currently diaabled.
		/// </summary>
        private const UInt32 EClassDisabled = 0x80004027;
		/// <summary>
		/// COM+ failure code indicating that the server class is currently paused.
		/// </summary>
        private const UInt32 EClassPaused = 0x80004025;


		private object[] pool;
		private int capacity;

		/// <summary>
		/// Public constructor for the JustInTimeActivationProxyPool object.
		/// Sets the pool capacity to a default size of 64
		/// slots.
		/// </summary>
		public JustInTimeActivationProxyPool()
		{
			Initialize( 64 );
		}

		/// <summary>
		/// Public constructor for the JustInTimeActivationProxyPool object.
		/// </summary>
		/// <param name="capacity">
		///    Capacity of the pool. This number must be less than 
		///    the number of concurrent threads using objects from 
		///    this pool.
		/// </param>
		public JustInTimeActivationProxyPool( int capacity  )
		{
			Initialize( capacity );
		}

		/// <summary>
		/// Initializes the pool. The capacity cannot and must not 
		/// be changed after initialization.
		/// </summary>
		/// <param name="Capacity">
		///    Capacity of the pool. This number must be less than 
		///    the number of concurrent threads using objects from 
		///    this pool.
		/// </param>
		private void Initialize( int Capacity  )
		{
			capacity = Capacity;
			pool = new object[capacity];
		}

		/// <summary>
		/// Returns a ServicedComponent instance from the pool. If
		/// the pool is empty, a new instance of the pool's ServicedComponentType
		/// is instantiated and returned.
		/// </summary>
		/// <returns>
		///    Pooled are newly created ServicedComponent instance of the 
		///    pool's ServicedComponentType
		/// </returns>
		public SCType Pop()
		{
			for ( int k=0;k<capacity;k++)
			{
                SCType tok = Interlocked.Exchange(ref pool[k], null) as SCType;
				if ( tok != null )
				{
					return tok;
				}
			}

			return Activator.CreateInstance<SCType>();
		}

		/// <summary>
		/// Places a ServicedComponent instance back into the pool.
		/// </summary>
		/// <param name="servicedComponent">Reference to a ServicedComponent</param>
		public void Push( SCType servicedComponent )
		{
			SCType sc = servicedComponent;
			for ( int k=0;k<capacity;k++)
			{
				SCType tok = Interlocked.CompareExchange(ref pool[k],sc,null) as SCType;
				if ( tok == null )
				{
					return;
				}
			}
			// can't take itback, pool is full. Let it just "vanish"
		}
        
		/// <summary>
		/// Empties the pool. Should not be called.
		/// </summary>
		public void Flush()
		{
			for ( int k=0;k<capacity;k++)
			{
				Interlocked.Exchange(ref pool[k],null);
			}
		}

        /// <summary>
        /// 
        /// </summary>
        /// <param name="call"></param>
        public void Using(JustInTimeActivationProxyPoolHandler<SCType> call)
        {
            // Check whether we are currently in a transaction. If that is so, we cannot reuse a pooled proxy
            if ((ContextUtil.IsInTransaction))
            {
                using (SCType component = new SCType())
                {
                    call(component);
                }
            }
            else
            {
                try
                {
                    // Try to execute the call using a proxy from the pool. This may fail is the server has been 
                    // shut down between when the proxy was created and "now" or if the server is currently paused 
                    // or stopped. The call may also fail for many other reasons, but these are the three cases we 
                    // are ready to recover from.
                    SCType component = Pop();
                    call(component);
                    Push(component);
                }
                catch (System.Runtime.InteropServices.ExternalException ex)
                {
                    if ((((uint)(ex.ErrorCode)) == ERpcCallFailedDne))
                    {
                        // The call failed because the proxy has been disconnected from the 
                        // server, likely because the server recycled or shut down. To recover 
                        // we create a new proxy, try to run the call and put the new proxy into the pool
                        SCType service = new SCType();
                        call(service);
                        Push(service);
                    }
                    else
                    {
                        if ((((uint)(ex.ErrorCode)) == EClassDisabled))
                        {
                            // The server is currently disabled. Fail out.
                            throw new ApplicationDisabledException();
                        }
                        else
                        {
                            if ((((uint)(ex.ErrorCode)) == EClassPaused))
                            {
                                // The server is currently paused. Fail out.
                                throw new ApplicationPausedException();
                            }
                            else
                            {
                                // An exception occurred that we are not ready to handle. Forward throw..
                                throw;
                            }
                        }
                    }
                }
                catch
                {
                    throw;
                }
            }
        }
	}

    /// <summary>
    /// 
    /// </summary>
    /// <typeparam name="SCType"></typeparam>
    /// <param name="component"></param>
    public delegate void JustInTimeActivationProxyPoolHandler<SCType>(SCType component);



    /// <summary>
    /// This exception is thrown when the Enterprise Services application is disabled
    /// and cannot be reached.
    /// </summary>
    [Serializable]
    public class ApplicationDisabledException : Exception
    {
        /// <summary>
        /// Constructor.
        /// </summary>
        public ApplicationDisabledException()
            : base(Properties.Resources.ApplicationDisabledMessage)
        {
        }
        /// <summary>
        /// Constructor.
        /// </summary>
        /// <param name="message">Message for the exception.</param>
        public ApplicationDisabledException(string message)
            : base(message)
        {
        }

        /// <summary>
        /// Creates a new instance of ApplicationDisabledException
        /// </summary>
        protected ApplicationDisabledException(SerializationInfo si, StreamingContext sc)
            : base(si, sc)
        {
        }

        /// <summary>
        /// Creates a new instance of ApplicationDisabledException
        /// </summary>
        public ApplicationDisabledException(string message, Exception ex)
            : base(message, ex)
        {
        }


    }

    /// <summary>
    /// This exception is thrown when the Enterprise Services application is paused
    /// and cannot be reached.
    /// </summary>
    [Serializable]
    public class ApplicationPausedException : Exception
    {
        /// <summary>
        /// Constructor.
        /// </summary>
        public ApplicationPausedException()
            : base(Properties.Resources.ApplicationPausedMessage)
        {
        }

        /// <summary>
        /// Constructor.
        /// </summary>
        /// <param name="message">Message for the exception.</param>
        public ApplicationPausedException(string message)
            : base(message)
        {
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="info"></param>
        /// <param name="context"></param>
        protected ApplicationPausedException(SerializationInfo info, StreamingContext context)
            : base(info, context)
        {
        }
        /// <summary>
        /// Creates a new instance of ApplicationDisabledException
        /// </summary>
        public ApplicationPausedException(string message, Exception e)
            : base(message, e)
        {
        }
    }

}