using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace GSF.Net.Snmp.Security
{
    /// <summary>
    /// Collection for improving performance. Using hashing of key/value pairs.
    /// Oldest elements will be removed from the Cache when the capacity of the cache is reached.
    /// This class is not thread safe.
    /// </summary>
    /// <typeparam name="TKey">The type of the keys in the dictionary.</typeparam>
    /// <typeparam name="TValue">The type of the values in the dictionary.</typeparam>
    public class Cache<TKey, TValue>
    {
        #region Data

        private readonly Dictionary<TKey, TValue> _dictionary;
        private readonly Queue<TKey> _keyQueue;
        private readonly int _capacity;

        #endregion //Data

        #region Public_Properties

        /// <summary>
        /// Gets the number of key/value pairs contained in the Cache.
        /// </summary>
        public int Count
        {
            get
            {
                return _dictionary.Count;
            }
        }

        #endregion //Public_Properties

        #region Public_Methods

        /// <summary>
        /// Caching class for improving performance. Oldest elements are removed as the 
        /// cache is filled up
        /// </summary>
        /// <param name="initialCapacity">Capacity of the cache before oldest elements start to get removed</param>
        public Cache(int initialCapacity)
        {
            _dictionary = new Dictionary<TKey, TValue>(initialCapacity);
            _keyQueue = new Queue<TKey>(initialCapacity);
            _capacity = initialCapacity;
        }

        /// <summary>
        /// Gets the value associated with the specified key.
        /// </summary>
        /// <param name="key">The key of the value to get.</param>
        /// <param name="value">When this method returns, contains the value associated with the specified key, 
        /// if the key is found; otherwise, the default value for the type of the value parameter.
        /// This parameter is passed uninitialized.
        /// </param>
        /// <returns>true if the Cache contains an element with the specified key; otherwise, false.</returns>
        public bool TryGetValue(TKey key, out TValue value)
        {
            return _dictionary.TryGetValue(key, out value);
        }

        /// <summary>
        /// Determines whether the Cache contains the specified key.
        /// </summary>
        /// <param name="key">The key to locate in the Cache</param>
        /// <returns>true if the Cache contains an element with the specified key; otherwise, false.</returns>
        public bool ContainsKey(TKey key)
        {
            return _dictionary.ContainsKey(key);
        }

        /// <summary>
        /// Gets the value associated with the specified key.
        /// </summary>
        /// <param name="key">The key of the value to get</param>
        /// <exception cref="System.ArgumentNullException"> key is null.</exception> 
        /// <exception cref="System.Collections.Generic.KeyNotFoundException">The property is retrieved and key does not exist in the collection.</exception>
        /// <returns>The value associated with the specified key.
        ///  If the specified key is not found, a get operation throws a System.Collections.Generic.KeyNotFoundException,
        ///  and a set operation creates a new element with the specified key.</returns>
        public TValue this[TKey key]
        {
            get { return _dictionary[key]; }
        }

        /// <summary>
        /// Adds the specified key and value to the dictionary. If the cache has reached 
        /// its capacity oldest element will be removed automatically 
        /// </summary>
        /// <exception cref="System.ArgumentNullException">key is null</exception>
        /// <exception cref="System.ArgumentException">An element with the same key already exists in the Cache</exception>
        /// <param name="key">The key of the element to add.</param>
        /// <param name="value">The value of the element to add.</param>
        public void Add(TKey key, TValue value)
        {
            if (IsCacheFull())
            {
                RemoveOldestElement();
            }

            _dictionary.Add(key, value);            //Order of adding is important since dictionary can throw System.ArgumentNullException or System.ArgumentException
            _keyQueue.Enqueue(key);
        }

        #endregion //Public_Methods

        #region Private_Methods

        /// <summary>
        /// Removes oldest element from the cache
        /// </summary>
        private void RemoveOldestElement()
        {
            TKey keyToRemove = _keyQueue.Dequeue();
            _dictionary.Remove(keyToRemove);
        }

        /// <summary>
        /// Checks whether cache size has reached the capacity
        /// </summary>
        /// <returns>True if reached capacity false otherwise</returns>
        private bool IsCacheFull()
        {
            return _keyQueue.Count() >= _capacity;      //using >= instead of == in case someone doesn't syncronize Cache
        }

        #endregion //Private_Methods
    }
}