using System;
using System.Collections.Generic;
using System.Text;
using System.Configuration;

namespace NCindy.Util
{
    internal sealed class NCindyConfigurationSectionGroup : ConfigurationSectionGroup
    {

    }


    internal sealed class BufferPoolTrunkConfiguration
    {

    }

    internal sealed class BufferPoolConfigurationSection : ConfigurationSection
    {
        [ConfigurationProperty("", IsDefaultCollection = true)]
        internal BufferPoolConfigurationCollection BufferPool
        {
            get
            {
                return (BufferPoolConfigurationCollection)this[""];
            }
        }


        [ConfigurationProperty("class", IsRequired = true)]
        public string Class
        {
            get
            {
                return (string)this["class"];
            }
        }
    }



    internal sealed class NCindyConfigurationSection : ConfigurationSection
    {
        [ConfigurationProperty("", IsDefaultCollection = true)]
        internal NCindyConfigurationCollection NCindy
        {
            get
            {
                return (NCindyConfigurationCollection)this[""];
            }
        }
    }


    internal sealed class BufferPoolConfigurationCollection : ConfigurationElementCollection
    {
        protected override ConfigurationElement CreateNewElement()
        {
            return new BufferPoolConfigurationElement();
        }
        protected override object GetElementKey(ConfigurationElement element)
        {
            return ((BufferPoolConfigurationElement)element).BufferCapacity;
        }
        public override ConfigurationElementCollectionType CollectionType
        {
            get
            {
                return ConfigurationElementCollectionType.BasicMap;
            }
        }
        protected override string ElementName
        {
            get
            {
                return "trunk";
            }
        }
    }


    internal sealed class NCindyConfigurationCollection : ConfigurationElementCollection
    {
        protected override ConfigurationElement CreateNewElement()
        {
            return new NCindyConfigurationElement();
        }
        protected override object GetElementKey(ConfigurationElement element)
        {
            return ((NCindyConfigurationElement)element).Key;
        }
        public override ConfigurationElementCollectionType CollectionType
        {
            get
            {
                return ConfigurationElementCollectionType.BasicMap;
            }
        }

        protected override string ElementName
        {
            get
            {
                return "add";
            }
        }
    }


    internal sealed class BufferPoolConfigurationElement : ConfigurationElement
    {
        [ConfigurationProperty("bufferCapacity", IsKey = true, IsRequired = true)]
        public string BufferCapacity
        {
            get
            {
                return (string)base["bufferCapacity"];
            }
            set
            {
                base["bufferCapacity"] = value;
            }
        }
        [ConfigurationProperty("maxElementsCount", IsRequired = true)]
        public string MaxElementsCount
        {
            get
            {
                return (string)base["maxElementsCount"];
            }
            set
            {
                base["maxElementsCount"] = value;
            }
        }

        [ConfigurationProperty("initialElementsCount", IsRequired = true)]
        public string InitialElementsCount
        {
            get
            {
                return (string)base["initialElementsCount"];
            }
            set
            {
                base["initialElementsCount"] = value;
            }
        }
    }


    internal sealed class NCindyConfigurationElement : ConfigurationElement
    {
        [ConfigurationProperty("key", IsKey = true, IsRequired = true)]
        public string Key
        {
            get
            {
                return (string)base["key"];
            }
            set
            {
                base["key"] = value;
            }
        }
        [ConfigurationProperty("value", IsRequired = true)]
        public string Value
        {
            get
            {
                return (string)base["value"];
            }
            set
            {
                base["value"] = value;
            }
        }
    }

    public static class Configuration
    {
        private static readonly System.Collections.Specialized.NameValueCollection properties;

        static Configuration()
        {
            properties = new System.Collections.Specialized.NameValueCollection();

            System.Configuration.Configuration config = 
                ConfigurationManager.OpenExeConfiguration(ConfigurationUserLevel.None);

            ConfigurationSectionGroup ncindyGroup = 
                config.GetSectionGroup("NCindy") as NCindyConfigurationSectionGroup;

            foreach (ConfigurationSection cs in ncindyGroup.Sections)
            {
                if (cs is NCindyConfigurationSection)
                {
                    foreach (NCindyConfigurationElement ncindyElement in
                        ((NCindyConfigurationSection)cs).NCindy)
                    {
                        properties.Add(cs.SectionInformation.Name + "." + ncindyElement.Key,
                            ncindyElement.Value);
                    }
                }
            }
        }

        #region Static Methods

        public static String Get(String key)
        {
            return properties.Get(key);
        }

        public static String Get(String key, String defaultValue)
        {
            string value = properties.Get(key);
            if (value != null)
            {
                return value;
            }

            return defaultValue;
        }

        public static int GetInt(String key, int defaultValue)
        {
            String value = Get(key);
            if (value != null)
            {
                try
                {
                    return Int32.Parse(value);
                }
                catch (FormatException)
                {
                }
            }
            return defaultValue;
        }

        public static bool GetBoolean(String key, bool defaultValue)
        {
            String value = Get(key);
            if (value != null)
            {
                try
                {
                    return bool.Parse(key);
                }
                catch (FormatException)
                {
                }
            }
            return defaultValue;
        }

        #endregion

        #region Global
        public static bool DisableInnerException
        {
            get
            {
                return GetBoolean("Global.DisableInnerException", false);
            }
        }


        public static string LoggingLevel
        {
            get
            {
                return Get("Global.LoggingLevel", "Fatal");
            }
        }
        #endregion

        #region Buffer
        public static int MaxBufferPoolSize
        {
            get
            {
                return GetInt("Buffer.MaxBufferPoolSize", 1024);
            }
        }

        public static String DefaultBufferPoolClass
        {
            get
            {
                return Get("Buffer.DefaultBufferPoolClass", "NCindy.Buffer.DefaultBufferPool");
            }
        }

        public static bool UseLinkedBuffer
        {
            get
            {
                //TODO: To use this config, add linked buffer support.
                return false;
                //return GetBoolean("Buffer.UseLinkedBuffer", false);
            }
        }
        #endregion

        #region Dispatcher
        public static String DefaultDispatcherClass
        {
            get
            {
                return Get("Dispatcher.DefaultDispatcherClass", "DefaultDispatcher");
            }
        }

        public static int DispatcherConcurrent
        {
            get
            {
                return GetInt("Dispatcher.Concurrent", 1);
            }
        }

        public static int DispatcherCapacity
        {
            get
            {
                return GetInt("Dispatcher.Capacity", 1000);
            }
        }

        public static int DispatcherKeepAliveTime
        {
            get
            {
                return GetInt("Dispatcher.KeepAliveTime", 5000);
            }
        }
        #endregion

        #region Session

        public static int SessionTimeout
        {
            get
            {
                return GetInt("Session.Timeout", 0);
            }
        }

        public static int ReceiveBufferSize
        {
            get
            {
                return GetInt("Session.ReceiveBufferSize", -1);
            }
        }

        public static int SendBufferSize
        {
            get
            {
                return GetInt("Session.SendBufferSize", -1);
            }
        }

        public static bool ReuseSessionAddress
        {
            get
            {
                return GetBoolean("Session.ReuseAddress", false);
            }
        }

        public static bool TcpNoDelay
        {
            get
            {
                return GetBoolean("Session.TcpNoDelay", true);
            }
        }

        public static int SoLinger
        {
            get
            {
                return GetInt("Session.SoLinger", -1);
            }
        }

        public static int ReadPacketSize
        {
            get
            {
                return GetInt("Session.ReadPacketSize", 8192);
            }
        }

        public static int WritePacketSize
        {
            // NIO channel do not handle WSAENOBUFS, so we can't direct write the
            // whole packet to channel.
            get
            {
                return GetInt("Session.WritePacketSize", 1024 * 1024);
            }
        }

        public static String DefaultTcpSessionClass
        {
            get
            {
                return Get("Session.DefaultTcpSessionClass", "AsyncSocketSession");
            }
        }

        public static String DefaultUdpSessionClass
        {
            get
            {
                return Get("Session.DefaultUdpSessionClass", "AsyncSocketSession");
            }
        }

        public static String DefaultPipeSessionClass
        {
            get
            {
                return Get("Session.DefaultPipeSessionClass", "PipeSession");
            }
        }

        //public static String DefaultFileSessionClass
        //{
        //    get
        //    {
        //        return Get("Session.DefaultFileSessionClass");
        //    }
        //} 
        #endregion

        #region Acceptor

        public static String DefaultTcpAcceptorClass
        {
            get
            {
                return Get("Acceptor.DefaultTcpAcceptorClass", "AsyncSocketSessionAcceptor");
            }
        }

        public static int AcceptorBacklog
        {
            get
            {
                return GetInt("Acceptor.Backlog", 100);
            }
        }

        public static bool ReuseAcceptorAddress
        {
            get
            {
                return GetBoolean("Acceptor.ReuseAddress", false);
            }
        }

        #endregion
    }
}