using System;
using System.Globalization;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Xml;

namespace SharpMap.Web
{
    internal class HttpCacheUtility
    {
        private static bool _systemWebTested;
        private static readonly DateTime NoAbsoluteExpiration = DateTime.MaxValue;
        private static readonly object LockContext = new object();

        /*
        private static Type _cacheDependencyType;
        private static PropertyInfo _cachePropertyInfo;
        private static PropertyInfo _httpContextPropertyInfo;
         */
        private static MethodInfo _insertMethodInfo;
        private static MethodInfo _getMethodInfo;

        private static object _context;
        private static object _cache;

        private static void TestSystemWeb()
        {
            if (_systemWebTested) return;

            lock (LockContext)
            {
                if (_systemWebTested) return;

                foreach (var assembly in AppDomain.CurrentDomain.GetAssemblies())
                {
                    if (assembly.GetName().Name != "System.Web") continue;

                    try
                    {
                        var httpContextType = 
                            assembly.GetType("System.Web.HttpContext");
                         var httpContextPropertyInfo = 
                            httpContextType.GetProperty("Current",
                                                        BindingFlags.Public | BindingFlags.Static);
                        _context = httpContextPropertyInfo.GetValue(null, null);

                        var cachePropertyInfo = 
                            httpContextType.GetProperty("Cache",
                                                        BindingFlags.Public | BindingFlags.Instance);
                        if (_context != null)
                        {
                            _cache = cachePropertyInfo.GetValue(_context, null);

                            var cacheType = assembly.GetType("System.Web.Caching.Cache");
                            var cacheDependencyType =
                                assembly.GetType("System.Web.Caching.CacheDependency");
                            _insertMethodInfo = cacheType.GetMethod("Insert",
                                                                    new[]
                                                                    {
                                                                        typeof (string), typeof (object),
                                                                        cacheDependencyType, typeof (DateTime),
                                                                        typeof (TimeSpan)
                                                                    });
                            _getMethodInfo = cacheType.GetMethod("Get", new[] { typeof(string) });
                        }
                        //Found it, tested it, continue with useful stuff
                        break;
                    }
                    catch (Exception /*ex*/)
                    {
                    }
                }
                _systemWebTested = true;
            }

        }

        private static object GetCurrentHttpContext()
        {
            return _context;
            /*
            if (_httpContextPropertyInfo == null)
                return null;
            return _httpContextPropertyInfo.GetValue(null, null);
             */
        }

        private static object GetHttpContextCache(/*object httpContext*/)
        {
            return _cache;
            /*
            if (_cachePropertyInfo == null)
                return null;
            return _cachePropertyInfo.GetValue(httpContext, null);
             */
        }

        private static object GetCurrentCache()
        {
            if (!_systemWebTested)
            {
                lock(LockContext)
                {
                    if (!_systemWebTested) 
                        TestSystemWeb();
                }
            }
            var httpContext = GetCurrentHttpContext();
            if (httpContext == null)
                return null;

            return GetHttpContextCache(/*httpContext*/);
        }

        [MethodImpl(MethodImplOptions.Synchronized)]
        internal static bool TryGetValue<T>(string key, out T instance)
            where T: class
        {
            var cache = GetCurrentCache();
            if (cache == null)
            {
                instance = default(T);
                return false;
            }

            instance = (T)_getMethodInfo.Invoke(cache, new object[] {key});
            return instance != null;
        }

        /// <summary>
        /// Gets a value indicating that the code is being run in a web context
        /// </summary>
        internal static bool IsWebContext { get { return GetCurrentCache() != null; } }

        /// <summary>
        /// Function that tries to get an object from the WebCache
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="key"></param>
        /// <param name="instance"></param>
        /// <returns></returns>
        internal static bool TryAddValue<T>(string key, T instance)
            where T: class
        {
            return TryAddValue(key, instance, TimeSpan.FromDays(1));
        }

        [MethodImpl(MethodImplOptions.Synchronized)]
        internal static bool TryAddValue<T>(string key, T instance, TimeSpan timeSpan)
            where T : class
        {
            var cache = GetCurrentCache();
            if (cache == null)
                return false;

            _insertMethodInfo.Invoke(cache, new object[] { key, instance, null, NoAbsoluteExpiration, timeSpan });
            return true;
        }
    }
    
    class WebUtilities
    {
        #region Reusable XML Parsing

        public static XmlNode FindEpsgNode(XmlNode bbox)
        {
            if (bbox == null || bbox.Attributes == null)
                throw new ArgumentNullException("bbox");

            XmlNode epsgNode = ((bbox.Attributes["srs"] ?? bbox.Attributes["crs"]) ?? bbox.Attributes["SRS"]) ?? bbox.Attributes["CRS"];
            return epsgNode;
        }

        public static bool TryParseNodeAsEpsg(XmlNode node, out int epsg)
        {
            epsg = default(int);
            if (node == null) return false;
            string epsgString = node.Value;
            if (String.IsNullOrEmpty(epsgString)) return false;
            const string prefix = "EPSG:";
            int index = epsgString.IndexOf(prefix, StringComparison.InvariantCulture);
            if (index < 0) return false;
            return (Int32.TryParse(epsgString.Substring(index + prefix.Length), NumberStyles.Any, Map.NumberFormatEnUs, out epsg));
        }

        public static double ParseNodeAsDouble(XmlNode node, double defaultValue)
        {
            if (node == null) return defaultValue;
            if (String.IsNullOrEmpty(node.InnerText)) return defaultValue;
            double value;
            if (Double.TryParse(node.InnerText, NumberStyles.Any, Map.NumberFormatEnUs, out value))
                return value;
            return defaultValue;
        }

        public static bool TryParseNodeAsDouble(XmlNode node, out double value)
        {
            value = default(double);
            if (node == null) return false;
            if (String.IsNullOrEmpty(node.InnerText)) return false;
            return Double.TryParse(node.InnerText, NumberStyles.Any, Map.NumberFormatEnUs, out value);
        }

        #endregion
    }
}