//******************************************************************************************************
//  PIConnectionPool.cs - Gbtc
//
//  Copyright © 2010, Grid Protection Alliance.  All Rights Reserved.
//
//  Licensed to the Grid Protection Alliance (GPA) under one or more contributor license agreements. See
//  the NOTICE file distributed with this work for additional information regarding copyright ownership.
//  The GPA licenses this file to you under the MIT License (MIT), 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.opensource.org/licenses/MIT
//
//  Unless agreed to in writing, the subject software distributed under the License is distributed on an
//  "AS-IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. Refer to the
//  License for the specific language governing permissions and limitations.
//
//  Code Modification History:
//  ----------------------------------------------------------------------------------------------------
//  06/24/2014 - J. Ritchie Carroll
//       Generated original version of source code.
//
//******************************************************************************************************

using System;
using System.Collections.Generic;
using System.Linq;
using GSF;

namespace PIAdapters
{
    /// <summary>
    /// Represents a pool of <see cref="PIConnection"/> instances.
    /// </summary>
    [Obsolete("Pooling connections was a PI-SDK optimization technique, this is not required for AF-SDK implementations.", false)]
    public class PIConnectionPool : IDisposable
    {
        #region [ Members ]

        // Constants

        /// <summary>
        /// Default value for <see cref="AccessCountPerConnection"/>.
        /// </summary>
        public const int DefaultAccessCountPerConnection = 100;

        /// <summary>
        /// Default value for <see cref="MinimumPoolSize"/>.
        /// </summary>
        public const int DefaultMinimumPoolSize = 10;

        // Events

        /// <summary>
        /// Raised when a <see cref="PIConnection"/> has been disconnected from server.
        /// </summary>
        public event EventHandler<EventArgs<PIConnection>> Disconnected;

        // Fields
        private readonly List<PIConnection> m_connectionPool;
        private int m_accessCountPerConnection;
        private bool m_disposed;

        #endregion

        #region [ Constructors ]

        /// <summary>
        /// Creates a new <see cref="PIConnectionPool"/>.
        /// </summary>
        public PIConnectionPool()
            : this(DefaultMinimumPoolSize)
        {
        }

        /// <summary>
        /// Creates a new <see cref="PIConnectionPool"/>.
        /// </summary>
        /// <param name="minimumPoolSize">Minimum pool size to maintain.</param>
        public PIConnectionPool(int minimumPoolSize)
        {
            if (minimumPoolSize < 1)
                throw new ArgumentOutOfRangeException(nameof(minimumPoolSize));

            m_connectionPool = new List<PIConnection>();
            MinimumPoolSize = minimumPoolSize;
            m_accessCountPerConnection = DefaultAccessCountPerConnection;
        }

        /// <summary>
        /// Releases the unmanaged resources before the <see cref="PIConnectionPool"/> object is reclaimed by <see cref="GC"/>.
        /// </summary>
        ~PIConnectionPool()
        {
            Dispose(false);
        }

        #endregion

        #region [ Properties ]

        /// <summary>
        /// Gets minimum pool size for the <see cref="PIConnectionPool"/>.
        /// </summary>
        public int MinimumPoolSize { get; }

        /// <summary>
        /// Gets or sets maximum accessibility count for each <see cref="PIConnection"/>.
        /// </summary>
        public int AccessCountPerConnection
        {
            get => m_accessCountPerConnection;
            set
            {
                if (value < 1)
                    throw new ArgumentOutOfRangeException(nameof(value));

                m_accessCountPerConnection = value;
            }
        }

        /// <summary>
        /// Gets current size of connection pool.
        /// </summary>
        public int Size => m_connectionPool.Count;

        #endregion

        #region [ Methods ]

        /// <summary>
        /// Releases all the resources used by the <see cref="PIConnectionPool"/> object.
        /// </summary>
        public void Dispose()
        {
            Dispose(true);
            GC.SuppressFinalize(this);
        }

        /// <summary>
        /// Releases the unmanaged resources used by the <see cref="PIConnectionPool"/> object and optionally releases the managed resources.
        /// </summary>
        /// <param name="disposing">true to release both managed and unmanaged resources; false to release only unmanaged resources.</param>
        protected virtual void Dispose(bool disposing)
        {
            if (m_disposed)
                return;

            try
            {
                if (!disposing)
                    return;

                if (m_connectionPool is not null)
                {
                    foreach (PIConnection connection in m_connectionPool)
                    {
                        connection.Disconnected -= connection_Disconnected;
                        connection.Dispose();
                    }

                    m_connectionPool.Clear();
                }
            }
            finally
            {
                m_disposed = true;  // Prevent duplicate dispose.
            }
        }

        /// <summary>
        /// Gets a connection from the pool or creates a new one if all current connections are being used at peak access.
        /// </summary>
        /// <param name="serverName">Name of the PI server for the adapter's PI connection.</param>
        /// <param name="userName">Name of the PI user ID for the adapter's PI connection.</param>
        /// <param name="password">Password used for the adapter's PI connection.</param>
        /// <param name="connectTimeout">Timeout interval (in milliseconds) for the adapter's connection.</param>
        /// <returns>A <see cref="PIConnection"/> from the pool.</returns>
        /// <exception cref="InvalidOperationException">Failed to get a pooled PI connection.</exception>
        public PIConnection GetPooledConnection(string serverName, string userName = null, string password = null, int connectTimeout = PIConnection.DefaultConnectTimeout)
        {
            PIConnection connection = null;

            // We dynamically allocate pooled PI server connections each having a maximum accessibility count.
            // PI's threading model can handle many connections each archiving a small volume of points, but
            // falls behind under load when archiving a large volume of points from a single connection.
            try
            {
                lock (m_connectionPool)
                {
                    while (connection is null)
                    {
                        // Get next connection from the pool with lowest accessibility count
                        if (m_connectionPool.Count > 0)
                        {
                            PIConnection[] availableConnections = m_connectionPool.Where(c => c.AccessCount < m_accessCountPerConnection).ToArray();

                            if (availableConnections.Length > 0)
                                connection = availableConnections.Aggregate((currentMin, nextItem) => nextItem is not null && currentMin.AccessCount < nextItem.AccessCount ? currentMin : nextItem);
                        }

                        if (connection is null)
                        {
                            // Add pooled connections in groups for better distribution
                            for (int i = 0; i < MinimumPoolSize; i++)
                            {
                                // Create a new connection
                                connection = new PIConnection
                                {
                                    ServerName = serverName,
                                    UserName = userName,
                                    Password = password,
                                    ConnectTimeout = connectTimeout
                                };

                                // Since PI doesn't detect disconnection until an operation is attempted,
                                // we must monitor for disconnections from the pooled connections as well
                                connection.Disconnected += connection_Disconnected;
                                connection.Open();

                                // Add the new connection to the server pool
                                m_connectionPool.Add(connection);
                            }
                        }
                    }

                    // Increment current connection access count
                    connection.AccessCount++;
                }
            }
            catch (Exception ex)
            {
                throw new InvalidOperationException(string.Format("Failed to get a pooled PI connection: {0}", ex.Message), ex);
            }

            return connection;
        }

        /// <summary>
        /// Returns <see cref="PIConnection"/> to the pool.
        /// </summary>
        /// <param name="connection"><see cref="PIConnection"/> to return to the pool.</param>
        /// <exception cref="InvalidOperationException">Provided PIConnection does not belong to this connection pool.</exception>
        public void ReturnPooledConnection(PIConnection connection)
        {
            if (connection is null)
                return;

            lock (m_connectionPool)
            {
                if (!m_connectionPool.Contains(connection))
                    throw new InvalidOperationException("Provided PIConnection does not belong to this connection pool");

                if (connection.AccessCount > 0)
                    connection.AccessCount--;

                if (connection.AccessCount < 1)
                {
                    if (m_connectionPool.Count > MinimumPoolSize && m_connectionPool.Remove(connection))
                    {
                        connection.Disconnected -= connection_Disconnected;
                        connection.Dispose();
                    }
                }
            }
        }

        private void connection_Disconnected(object sender, EventArgs e) => 
            Disconnected?.Invoke(this, new EventArgs<PIConnection>(sender as PIConnection));

        #endregion
    }
}