using System;
using System.Web.Compilation;
using System.Globalization;
using System.Resources;
using System.Collections;
using System.Collections.Generic;
using System.Collections.Specialized;
using System.Xml;
using System.Web;

namespace CreativePlug.Providers
{
    public sealed class XmlResourceProviderFactory : ResourceProviderFactory
    {

        public XmlResourceProviderFactory()
        {
        }

        public override IResourceProvider CreateGlobalResourceProvider(string classKey)
        {
            return new XmlResourceProvider(null, classKey);
        }

        public override IResourceProvider CreateLocalResourceProvider(string virtualPath)
        {
            virtualPath = this.GetVirtualPath(virtualPath);
            return new XmlResourceProvider(virtualPath, null);
        }

        public class XmlResourceProvider : IResourceProvider
        {
            private string _virtualPath;
            private string _className;
            private IDictionary _resource;

            public XmlResourceProvider(string virtualPath, string className)
            {
                _virtualPath = virtualPath;
                _className = className;
            }

            private IDictionary GetResource(string cultureName)
            {
                _resource = new ListDictionary();

                IDictionary resourceDict = _resource as IDictionary;

                resourceDict = XmlResourceHelper.GetResources(_virtualPath, _className, cultureName, false, null);
                _resource = resourceDict;

                return resourceDict;
            }

            public object GetObject(string resourceKey, CultureInfo culture)
            {
                if (culture == null || culture == CultureInfo.InvariantCulture)
                    culture = CultureInfo.CurrentUICulture;

                object value = GetResource(culture.Name)[resourceKey];

                return value;
            }

            public System.Resources.IResourceReader ResourceReader
            {
                get
                {
                    return new XmlResourceReader(GetResource(CultureInfo.CurrentUICulture.Name));
                }
            }
        }

        private sealed class XmlResourceReader : IResourceReader
        {
            private IDictionary _resources;

            public XmlResourceReader(IDictionary resources)
            {
                _resources = resources;
            }

            IDictionaryEnumerator IResourceReader.GetEnumerator()
            {
                return _resources.GetEnumerator();
            }

            void IResourceReader.Close()
            {
            }

            IEnumerator IEnumerable.GetEnumerator()
            {
                return _resources.GetEnumerator();
            }

            void IDisposable.Dispose()
            {
            }
        }

        internal static class XmlResourceHelper
        {
            public static IDictionary GetResources(string virtualPath, string className, string cultureName, bool designMode, IServiceProvider serviceProvider)
            {
                ListDictionary resources = new ListDictionary();

                if (!String.IsNullOrEmpty(virtualPath))
                {
                    // Get Local resources
                    XmlDocument configurationFile = new XmlDocument();
                    string xmlFilePath = HttpContext.Current.Server.MapPath(HttpContext.Current.Request.ApplicationPath + "/LocalResources/" + virtualPath + "_" + cultureName + ".xml");
                    configurationFile.Load(xmlFilePath);
                    XmlNodeList parentNodeList = configurationFile.SelectNodes("Resource/item");
                    foreach (XmlNode childNode in parentNodeList)
                    {
                        string rn = childNode.Attributes.Item(0).Value.ToString();
                        string rv = childNode.InnerText;
                        resources.Add(rn, rv);
                    }
                }
                else if (!String.IsNullOrEmpty(className))
                {
                    // Get Global resources
                    XmlDocument configurationFile = new XmlDocument();
                    string xmlFilePath = HttpContext.Current.Server.MapPath(HttpContext.Current.Request.ApplicationPath + "/GlobalResources/Global." + cultureName + ".xml");
                    configurationFile.Load(xmlFilePath);
                    XmlNodeList parentNodeList = configurationFile.SelectNodes("Resource/item");
                    foreach (XmlNode childNode in parentNodeList)
                    {
                        string rn = childNode.Attributes.Item(0).Value.ToString();
                        string rv = childNode.InnerText;
                        resources.Add(rn, rv);
                    }
                }

                return resources;
            }

        }

        private string GetVirtualPath(string virtualPath)
        {
            string virtualFileName = System.IO.Path.GetFileName(virtualPath);
            string virtualFileNameWithoutExtension = System.IO.Path.GetFileNameWithoutExtension(virtualPath);
            virtualPath = virtualPath.Remove(0, 1);
            virtualPath = virtualPath.Replace(HttpContext.Current.Request.ApplicationPath, "");
            virtualPath = virtualPath.Replace("/", "_");
            virtualPath = virtualPath.Replace(virtualFileName, virtualFileNameWithoutExtension);
            virtualPath = virtualPath.Replace("Localization_", "");

            return virtualPath;
        }
    }
}

object IResourceProvider.GetObject(string resourceKey, CultureInfo culture)
{
    if (culture == null || culture == CultureInfo.InvariantCulture)
        culture = CultureInfo.CurrentUICulture;

    object value = GetResource(culture.Name)[resourceKey];

    if (value == null)
        return "";

    return value;
}