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

namespace GSF.Net.Snmp.Security
{
    /// <summary>
    /// Class for holding computed crypto values which are referenced by password/engineId combination
    /// This class is not thread safe, it does not contain any static parameters.
    /// </summary>
    public class CryptoKeyCache
    {
        /// <summary>
        /// Number of elements that Cache will hold before deleting old elements
        /// </summary>
        private const int CacheCapacity = 100;

        #region InternalClasses
        /// <summary>
        /// Class for holding cached crypto keys computed values, since every password/engine id 
        /// combination will produce a different key this class is modeled using
        /// Dictionary of Dictionaries. This class is not thread safe.
        /// </summary>
        private class EngineIdCache
        {
            /// <summary>
            /// Cache to map engineId to keys
            /// </summary>
            private Cache<string, byte[]> _engineIdCache;

            /// <summary>
            /// Default ctor initializes EngineIdCache
            /// </summary>
            public EngineIdCache(int capacity)
            {
                _engineIdCache = new Cache<string, byte[]>(capacity);
            }


            /// <summary>
            /// Gets the cached value associated with the specified key.
            /// </summary>
            /// <param name="engineId"> The engineId of the cached value to get.</param>
            /// <param name="cachedValue">
            ///  When this method returns, contains the cachedValue associated with the specified
            ///  engineId, if the engineId is found; otherwise, the default value for the type of the
            ///  cachedValue parameter. This parameter is passed uninitialized.
            /// </param>
            /// <returns> True if the cache contains an element with the specified engineId; otherwise, false.</returns>
            public bool TryGetCachedValue(byte[] engineId, out byte[] cachedValue)
            {
                bool success = _engineIdCache.TryGetValue(Stringanize(engineId), out cachedValue);
                return success;
            }

            /// <summary>
            /// Adds value to cache
            /// </summary>
            /// <param name="engineId">engine id associated with the value</param>
            /// <param name="valueToCache">value to cache</param>
            public void AddValueToCache(byte[] engineId, byte[] valueToCache)
            {
                _engineIdCache.Add(Stringanize(engineId), valueToCache);
            }
        }
        #endregion

        private Cache<string, EngineIdCache> _cryptoCache;

        /// <summary>
        /// Ctor
        /// </summary>
        public CryptoKeyCache(int capacity)
        {
            _cryptoCache = new Cache<string, EngineIdCache>(CacheCapacity);
        }

        /// <summary>
        /// Get the cached value if it exists in the cache
        /// </summary>
        /// <param name="password">password associated with cached value</param>
        /// <param name="engineId">engine id associated with cached value</param>
        /// <param name="cachedValue">cached value, if no cache exists for specified password/engine id 
        /// combination default value is assigned to cachedValue </param>
        /// <returns>True if value exists in cache for specified password/engine id combination, false otherwise</returns>
        public bool TryGetCachedValue(byte[] password, byte[] engineId, out byte[] cachedValue)
        {
            EngineIdCache engineCache;
            string strPassword = Stringanize(password);
            bool success = false;
            cachedValue = null;
            success = _cryptoCache.TryGetValue(strPassword, out engineCache);
            if (success)
            {
                success = engineCache.TryGetCachedValue(engineId, out cachedValue);
            }

            return success;
        }

        /// <summary>
        /// Adds computed value to the cache
        /// </summary>
        /// <param name="password">password to associate cached value with </param>
        /// <param name="engineId">engine id to associate cached value with</param>
        /// <param name="valueToCache">value being cached</param>
        public void AddValueToCache(byte[] password, byte[] engineId, byte[] valueToCache)
        {
            string strPassword = Stringanize(password);
            if (!_cryptoCache.ContainsKey(strPassword))
            {
                _cryptoCache.Add(strPassword, new EngineIdCache(CacheCapacity));
            }

            EngineIdCache engineCache = _cryptoCache[strPassword];
            engineCache.AddValueToCache(engineId, valueToCache);
        }

        /// <summary>
        /// Converts an array of bytes into a string this way we can use
        /// string.GetHashCode and string.Equals to allow the array of bytes 
        /// be the key in a hash table
        /// </summary>
        /// <param name="bytes"></param>
        /// <returns></returns>
        private static string Stringanize(byte[] bytes)
        {
            StringBuilder builder = new StringBuilder();
            foreach (byte b in bytes)
            {
                builder.Append(b.ToString());
            }
            return builder.ToString();
        }
    }
}