//----------------------------------------------------------------
// Copyright (c) Microsoft Corporation.  All rights reserved.
//----------------------------------------------------------------
 
namespace System.ServiceModel.Channels
{
    using System;
    using System.Collections;
    using System.Collections.Generic;
    using System.Collections.ObjectModel;
    using System.Runtime;
 
    [Serializable]
    class ContextDictionary : IDictionary<string, string>
    {
        static ContextDictionary empty;
 
        IDictionary<string, string> dictionaryStore;
 
        public ContextDictionary()
        {
            this.dictionaryStore = new Dictionary<string, string>();
        }
 
        public ContextDictionary(IDictionary<string, string> context)
        {
            this.dictionaryStore = new Dictionary<string, string>();
 
            if (context != null)
            {
                bool ignoreValidation = context is ContextDictionary;
 
                foreach (KeyValuePair<string, string> pair in context)
                {
                    if (ignoreValidation)
                    {
                        this.dictionaryStore.Add(pair);
                    }
                    else
                    {
                        this.Add(pair);
                    }
                }
            }
        }
 
        internal static ContextDictionary Empty
        {
            get
            {
                if (empty == null)
                {
                    ContextDictionary localEmpty = new ContextDictionary();
                    localEmpty.dictionaryStore = new ReadOnlyDictionaryInternal<string, string>(new Dictionary<string, string>(0));
                    empty = localEmpty;
                }
 
                return empty;
            }
        }
 
        public int Count
        {
            get { return this.dictionaryStore.Count; }
        }
 
        public bool IsReadOnly
        {
            get { return this.dictionaryStore.IsReadOnly; }
        }
 
        public ICollection<string> Keys
        {
            get { return this.dictionaryStore.Keys; }
        }
 
        public ICollection<string> Values
        {
            get { return this.dictionaryStore.Values; }
        }
 
        public string this[string key]
        {
            get
            {
                ValidateKeyValueSpace(key);
                return this.dictionaryStore[key];
            }
            set
            {
                if (value == null)
                {
                    throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("value");
                }
                ValidateKeyValueSpace(key);
                this.dictionaryStore[key] = value;
            }
        }
 
        public void Add(string key, string value)
        {
            if (value == null)
            {
                throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("value");
            }
 
            ValidateKeyValueSpace(key);
            this.dictionaryStore.Add(key, value);
        }
 
 
        public void Add(KeyValuePair<string, string> item)
        {
            if (item.Key == null)
            {
                throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("item.Key");
            }
            if (item.Value == null)
            {
                throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("item.Value");
            }
            ValidateKeyValueSpace(item.Key);
            this.dictionaryStore.Add(item);
        }
 
        public void Clear()
        {
            this.dictionaryStore.Clear();
        }
 
        public bool Contains(KeyValuePair<string, string> item)
        {
            if (item.Key == null)
            {
                throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("item.Key");
            }
            if (item.Value == null)
            {
                throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("item.Value");
            }
 
            ValidateKeyValueSpace(item.Key);
            return this.dictionaryStore.Contains(item);
        }
 
 
        public bool ContainsKey(string key)
        {
            ValidateKeyValueSpace(key);
            return this.dictionaryStore.ContainsKey(key);
        }
 
        public void CopyTo(KeyValuePair<string, string>[] array, int arrayIndex)
        {
            this.dictionaryStore.CopyTo(array, arrayIndex);
        }
 
 
        public IEnumerator<KeyValuePair<string, string>> GetEnumerator()
        {
            return this.dictionaryStore.GetEnumerator();
        }
 
        IEnumerator IEnumerable.GetEnumerator()
        {
            return ((IEnumerable)this.dictionaryStore).GetEnumerator();
        }
 
        public bool Remove(string key)
        {
            ValidateKeyValueSpace(key);
            return this.dictionaryStore.Remove(key);
        }
 
        public bool Remove(KeyValuePair<string, string> item)
        {
            if (item.Key == null)
            {
                throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("item.Key");
            }
            if (item.Value == null)
            {
                throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("item.Value");
            }
 
            ValidateKeyValueSpace(item.Key);
            return this.dictionaryStore.Remove(item);
        }
 
        public bool TryGetValue(string key, out string value)
        {
            ValidateKeyValueSpace(key);
            return this.dictionaryStore.TryGetValue(key, out value);
        }
 
        internal static bool TryValidateKeyValueSpace(string key)
        {
            if (string.IsNullOrEmpty(key))
            {
                throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("key");
            }
 
            for (int counter = 0; counter < key.Length; ++counter)
            {
                char currentCharacter = key[counter];
 
                if (!IsLetterOrDigit(currentCharacter) && currentCharacter != '-' && currentCharacter != '_' && currentCharacter != '.')
                {
                    return false;
                }
            }
            return true;
        }
 
        static bool IsLetterOrDigit(char c)
        {
            return (('A' <= c) && (c <= 'Z')) ||
                (('a' <= c) && (c <= 'z')) ||
                (('0' <= c) && (c <= '9'));
        }
 
        static void ValidateKeyValueSpace(string key)
        {
            if (!TryValidateKeyValueSpace(key))
            {
                throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentOutOfRangeException("key", SR.GetString(SR.InvalidCookieContent, key)));
            }
        }
    }
}