using System;
using System.Collections.Concurrent;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace Tango.FSE.BL
{
    /// <summary>
    /// Represents an in-memory cache dictionary of type T.
    /// </summary>
    /// <typeparam name="TValue"></typeparam>
    /// <seealso cref="Tango.FSE.BL.IMemoryCacheDictionary" />
    public class MemoryCacheDictionary<TKey, TValue> : IMemoryCacheDictionary where TValue : class
    {
        private ConcurrentDictionary<TKey, TValue> _dictionary;

        /// <summary>
        /// Gets the cache name.
        /// </summary>
        public String Name { get; private set; }

        /// <summary>
        /// Gets the count of items.
        /// </summary>
        public int Count
        {
            get { return _dictionary.Count; }
        }

        /// <summary>
        /// Initializes a new instance of the <see cref="MemoryCacheDictionary{T}"/> class.
        /// </summary>
        /// <param name="name">The name of the cache.</param>
        public MemoryCacheDictionary(String name)
        {
            Name = name;
            _dictionary = new ConcurrentDictionary<TKey, TValue>();
        }

        /// <summary>
        /// Determines whether this cache contains an element with the specified key.
        /// </summary>
        /// <param name="key">The key.</param>
        public bool ContainsKey(TKey key)
        {
            return _dictionary.ContainsKey(key);
        }

        /// <summary>
        /// Gets a cached item by the specified key.
        /// </summary>
        /// <param name="key">The key.</param>
        /// <param name="throwIfNotFound">if set to <c>true</c> throws exception when item not found otherwise returns null.</param>
        /// <exception cref="KeyNotFoundException"></exception>
        public TValue Get(TKey key, bool throwIfNotFound = true)
        {
            TValue value = null;

            if (_dictionary.TryGetValue(key, out value))
            {
                return value;
            }
            else
            {
                if (throwIfNotFound)
                {
                    throw new KeyNotFoundException($"Could not locate key '{key}' on cache '{Name}'.");
                }
                else
                {
                    return null;
                }
            }
        }

        /// <summary>
        /// Puts a new cached item or overrides an existing one.
        /// </summary>
        /// <param name="key">The key.</param>
        /// <param name="value">The value.</param>
        public void Put(TKey key, TValue value)
        {
            _dictionary[key] = value;
        }

        /// <summary>
        /// Get all cached items as a list.
        /// </summary>
        /// <returns></returns>
        public List<TValue> ToList(bool throwOnEmpty = false)
        {
            var list = _dictionary.Select(x => x.Value).ToList();

            if (throwOnEmpty && list.Count == 0)
            {
                throw new KeyNotFoundException("The memory cache does not contain any items.");
            }

            return list;
        }

        /// <summary>
        /// Clears this all items from cache.
        /// </summary>
        public void Clear()
        {
            _dictionary.Clear();
        }
    }

    /// <summary>
    /// Represents an in-memory cache dictionary of type T.
    /// </summary>
    /// <typeparam name="TValue"></typeparam>
    /// <seealso cref="Tango.FSE.BL.IMemoryCacheDictionary" />
    public class MemoryCacheDoubleKeyDictionary<TKey1, TKey2, TValue> : IMemoryCacheDictionary where TValue : class
    {
        private ConcurrentDictionary<String, TValue> _dictionary;

        /// <summary>
        /// Gets the cache name.
        /// </summary>
        public String Name { get; private set; }

        /// <summary>
        /// Gets the count of items.
        /// </summary>
        public int Count
        {
            get { return _dictionary.Count; }
        }

        /// <summary>
        /// Initializes a new instance of the <see cref="MemoryCacheDictionary{T}"/> class.
        /// </summary>
        /// <param name="name">The name of the cache.</param>
        public MemoryCacheDoubleKeyDictionary(String name)
        {
            Name = name;
            _dictionary = new ConcurrentDictionary<String, TValue>();
        }

        /// <summary>
        /// Determines whether this cache contains an element with the specified keys.
        /// </summary>
        /// <param name="key1">The first key.</param>
        /// <param name="key2">The second key.</param>
        public bool ContainsKey(TKey1 key1, TKey2 key2)
        {
            return _dictionary.ContainsKey(key1.ToString() + key2.ToString());
        }

        /// <summary>
        /// Gets a cached item by the specified keys.
        /// </summary>
        /// <param name="key1">The first key.</param>
        /// <param name="key2">The second key.</param>
        /// <param name="throwIfNotFound">if set to <c>true</c> throws exception when item not found otherwise returns null.</param>
        /// <exception cref="KeyNotFoundException"></exception>
        public TValue Get(TKey1 key1, TKey2 key2, bool throwIfNotFound = true)
        {
            TValue value = null;

            if (_dictionary.TryGetValue(key1.ToString() + key2.ToString(), out value))
            {
                return value;
            }
            else
            {
                if (throwIfNotFound)
                {
                    throw new KeyNotFoundException($"Could not locate key '{key1 + " " + key2}' on cache '{Name}'.");
                }
                else
                {
                    return null;
                }
            }
        }

        /// <summary>
        /// Puts a new cached item or overrides an existing one.
        /// </summary>
        /// <param name="key1">The first key.</param>
        /// <param name="key2">The second key.</param>
        /// <param name="value">The value.</param>
        public void Put(TKey1 key1, TKey2 key2, TValue value)
        {
            _dictionary[key1.ToString() + key2.ToString()] = value;
        }

        /// <summary>
        /// Get all cached items as a list.
        /// </summary>
        /// <returns></returns>
        public List<TValue> ToList(bool throwOnEmpty = false)
        {
            var list = _dictionary.Select(x => x.Value).ToList();

            if (throwOnEmpty && list.Count == 0)
            {
                throw new KeyNotFoundException("The memory cache does not contain any items.");
            }

            return list;
        }

        /// <summary>
        /// Clears this all items from cache.
        /// </summary>
        public void Clear()
        {
            _dictionary.Clear();
        }
    }
}