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

namespace Umbraco.Core.Cache
{
    internal abstract class DictionaryCacheProviderBase : ICacheProvider
    {
        protected readonly ReaderWriterLockSlim Locker = new ReaderWriterLockSlim(LockRecursionPolicy.SupportsRecursion);
        protected abstract DictionaryCacheWrapper DictionaryCache { get; }

        /// <summary>
        /// Clears everything in umbraco's runtime cache
        /// </summary>
        /// <remarks>
        /// Does not clear other stuff the user has put in httpruntime.cache!
        /// </remarks>
        public virtual void ClearAllCache()
        {
            using (new WriteLock(Locker))
            {
                var keysToRemove = DictionaryCache.Cast<object>()
                                                  .Select(item => new DictionaryItemWrapper(item))
                                                  .Where(c => c.Key is string && ((string)c.Key).StartsWith(CacheItemPrefix) && DictionaryCache[c.Key.ToString()] != null)
                                                  .Select(c => c.Key)
                                                  .ToList();

                foreach (var k in keysToRemove)
                {
                    DictionaryCache.Remove(k);
                }
            }
        }

        /// <summary>
        /// Clears the item in umbraco's runtime cache with the given key 
        /// </summary>
        /// <param name="key">Key</param>
        public virtual void ClearCacheItem(string key)
        {
            using (new WriteLock(Locker))
            {
                var cacheKey = GetCacheKey(key);
                if (DictionaryCache[cacheKey] == null) return;
                DictionaryCache.Remove(cacheKey);
            }
        }

        /// <summary>
        /// Clears all objects in the System.Web.Cache with the System.Type name as the
        /// input parameter. (using [object].GetType())
        /// </summary>
        /// <param name="typeName">The name of the System.Type which should be cleared from cache ex "System.Xml.XmlDocument"</param>
        public virtual void ClearCacheObjectTypes(string typeName)
        {
            using (new WriteLock(Locker))
            {
                var keysToRemove = DictionaryCache
                    .Cast<object>()
                    .Select(item => new DictionaryItemWrapper(item))
                    .Where(c =>
                    {
                        var k = c.Key.ToString();
                        var v = DictionaryCache[k];
                        return v != null && v.GetType().ToString().InvariantEquals(typeName);
                    })
                    .Select(c => c.Key)
                    .ToList();

                foreach (var k in keysToRemove)
                    DictionaryCache.Remove(k);
            }
        }

        public virtual void ClearCacheObjectTypes<T>()
        {
            using (new WriteLock(Locker))
            {
                var typeOfT = typeof(T);
                var keysToRemove = DictionaryCache
                    .Cast<object>()
                    .Select(item => new DictionaryItemWrapper(item))
                    .Where(c =>
                    {
                        var k = c.Key.ToString();
                        var v = DictionaryCache[k];
                        return v != null && v.GetType() == typeOfT;
                    })
                    .Select(c => c.Key)
                    .ToList();

                foreach (var k in keysToRemove)
                    DictionaryCache.Remove(k);
            }
        }

        public virtual void ClearCacheObjectTypes<T>(Func<string, T, bool> predicate)
        {
            using (new WriteLock(Locker))
            {
                var typeOfT = typeof(T);
                var keysToRemove = DictionaryCache
                    .Cast<object>()
                    .Select(item => new DictionaryItemWrapper(item))
                    .Where(c =>
                    {
                        var k = c.Key.ToString();
                        var v = DictionaryCache[k];
                        return v != null && v.GetType() == typeOfT && predicate(k, (T)v);
                    })
                    .Select(c => c.Key)
                    .ToList();

                foreach (var k in keysToRemove)
                    DictionaryCache.Remove(k);
            }
        }

        /// <summary>
        /// Clears all cache items that starts with the key passed.
        /// </summary>
        /// <param name="keyStartsWith">The start of the key</param>
        public virtual void ClearCacheByKeySearch(string keyStartsWith)
        {
            using (new WriteLock(Locker))
            {
                var keysToRemove = DictionaryCache.Cast<object>()
                    .Select(item => new DictionaryItemWrapper(item))
                    .Where(
                        c =>
                            c.Key is string &&
                            ((string) c.Key).InvariantStartsWith(string.Format("{0}-{1}", CacheItemPrefix, keyStartsWith)))
                    .Select(c => c.Key)
                    .ToList();

                foreach (var k in keysToRemove)
                {
                    DictionaryCache.Remove(k);
                }
            }
        }

        /// <summary>
        /// Clears all cache items that have a key that matches the regular expression
        /// </summary>
        /// <param name="regexString"></param>
        public virtual void ClearCacheByKeyExpression(string regexString)
        {
            using (new WriteLock(Locker))
            {
                var keysToRemove = new List<object>();
                foreach (var item in DictionaryCache)
                {
                    var c = new DictionaryItemWrapper(item);
                    var s = c.Key as string;
                    if (s != null)
                    {
                        var withoutPrefix = s.TrimStart(string.Format("{0}-", CacheItemPrefix));
                        if (Regex.IsMatch(withoutPrefix, regexString))
                        {
                            keysToRemove.Add(c.Key);
                        }
                    }
                }

                foreach (var k in keysToRemove)
                {
                    DictionaryCache.Remove(k);
                }
            }
        }

        public virtual IEnumerable<object> GetCacheItemsByKeySearch(string keyStartsWith)
        {
            using (new ReadLock(Locker))
            {
                return (from object item in DictionaryCache
                    select new DictionaryItemWrapper(item)
                    into c
                    where
                        c.Key is string &&
                        ((string) c.Key).InvariantStartsWith(string.Format("{0}-{1}", CacheItemPrefix, keyStartsWith))
                    select c.Value).ToList();
            }
        }

        public virtual IEnumerable<object> GetCacheItemsByKeyExpression(string regexString)
        {
            using (new ReadLock(Locker))
            {
                var found = new List<object>();
                foreach (var item in DictionaryCache)
                {
                    var c = new DictionaryItemWrapper(item);
                    var s = c.Key as string;
                    if (s != null)
                    {
                        var withoutPrefix = s.TrimStart(string.Format("{0}-", CacheItemPrefix));
                        if (Regex.IsMatch(withoutPrefix, regexString))
                        {
                            found.Add(c.Value);
                        }
                    }
                }

                return found;
            }
        }

        /// <summary>
        /// Returns a cache item by key, does not update the cache if it isn't there.
        /// </summary>
        /// <param name="cacheKey"></param>
        /// <returns></returns>
        public virtual object GetCacheItem(string cacheKey)
        {
            using (new ReadLock(Locker))
            {
                var result = DictionaryCache.Get(GetCacheKey(cacheKey));
                return result;
            }
        }

        public abstract object GetCacheItem(string cacheKey, Func<object> getCacheItem);        

        /// <summary>
        /// We prefix all cache keys with this so that we know which ones this class has created when 
        /// using the HttpRuntime cache so that when we clear it we don't clear other entries we didn't create.
        /// </summary>
        protected const string CacheItemPrefix = "umbrtmche";

        protected string GetCacheKey(string key)
        {
            return string.Format("{0}-{1}", CacheItemPrefix, key);
        }
    }
}