#region Imports

using System;
using System.Collections.Generic;
using System.Linq;
using System.ComponentModel;
using System.Collections.ObjectModel;

#endregion

public sealed class DictionaryObject<T> : 
    KeyedCollection<string, KeyValuePair<string, T>>, 
    ICustomTypeDescriptor
{
    PropertyDescriptorCollection _cachedProperties;

    public DictionaryObject() :
        this(null, null) { }

    public DictionaryObject(IEqualityComparer<string> comparer) :
        this(null, comparer) { }

    public DictionaryObject(IEnumerable<KeyValuePair<string, T>> dict) :
        this(dict, null) {}

    public DictionaryObject(IEnumerable<KeyValuePair<string, T>> dict, IEqualityComparer<string> comparer) :
        base(comparer ?? StringComparer.OrdinalIgnoreCase)
    {
        if (dict != null)
        {
            foreach (var pair in dict)
                Add(pair);
        }
    }

    public new T this[int index]
    {
        get { return base[index].Value; }
        
        set
        {
            var e = base[index];
            base[index] = new KeyValuePair<string, T>(e.Key, value);
        }
    }

    public new T this[string key]
    {
        get { return base[key].Value; }
        
        set
        {
            Remove(key);
            Add(key, value);
        }
    }

    public void Add(string key, T value)
    {
        Add(new KeyValuePair<string, T>(key, value));
    }

    protected override string GetKeyForItem(KeyValuePair<string, T> item)
    {
        return item.Key;
    }

    protected override void ClearItems()
    {
        ClearCachedProperties();
        base.ClearItems();
    }

    protected override void InsertItem(int index, KeyValuePair<string, T> item)
    {
        ClearCachedProperties();
        base.InsertItem(index, item);
    }

    protected override void RemoveItem(int index)
    {
        ClearCachedProperties();
        base.RemoveItem(index);
    }

    protected override void SetItem(int index, KeyValuePair<string, T> item)
    {
        ClearCachedProperties();
        base.SetItem(index, item);
    }

    private void ClearCachedProperties()
    {
        _cachedProperties = null;
    }

    AttributeCollection ICustomTypeDescriptor.GetAttributes()
    {
        return new AttributeCollection(null);
    }

    string ICustomTypeDescriptor.GetClassName() { return null; }
    string ICustomTypeDescriptor.GetComponentName() { return null; }
    TypeConverter ICustomTypeDescriptor.GetConverter() { return null; }
    EventDescriptor ICustomTypeDescriptor.GetDefaultEvent() { return null; }
    PropertyDescriptor ICustomTypeDescriptor.GetDefaultProperty() { return null; }
    object ICustomTypeDescriptor.GetEditor(Type editorBaseType) { return null; }
    EventDescriptorCollection ICustomTypeDescriptor.GetEvents(Attribute[] attributes) { return GetEvents(); }
    EventDescriptorCollection ICustomTypeDescriptor.GetEvents() { return GetEvents(); }
    object ICustomTypeDescriptor.GetPropertyOwner(PropertyDescriptor pd) { return null; }

    private static EventDescriptorCollection GetEvents()
    {
        return new EventDescriptorCollection(null);
    }

    PropertyDescriptorCollection ICustomTypeDescriptor.GetProperties(Attribute[] attributes)
    {
        if (attributes != null && attributes.Length > 0)
            throw new NotSupportedException();

        return GetProperties();
    }

    PropertyDescriptorCollection ICustomTypeDescriptor.GetProperties()
    {
        return GetProperties();
    }

    private PropertyDescriptorCollection GetProperties()
    {
        if (_cachedProperties == null)
        {
            _cachedProperties = new PropertyDescriptorCollection(
                this.Select(e => new DictionaryPropertyDescriptor(e.Key)).ToArray());
        }

        return _cachedProperties;
    }

    private sealed class DictionaryPropertyDescriptor : PropertyDescriptor
    {
        public DictionaryPropertyDescriptor(string name) :
            base(name, null) { }

        public override bool CanResetValue(object component)
        {
            return false;
        }

        public override Type ComponentType
        {
            get { throw new NotImplementedException(); }
        }

        public override object GetValue(object component)
        {
            return ((DictionaryObject<T>) component)[Name];
        }

        public override bool IsReadOnly
        {
            get { return false; }
        }

        public override Type PropertyType
        {
            get { return typeof(T); }
        }

        public override void ResetValue(object component)
        {
            throw new NotSupportedException();
        }

        public override void SetValue(object component, object value)
        {
            ((DictionaryObject<T>) component)[Name] = (T) value;
        }

        public override bool ShouldSerializeValue(object component)
        {
            throw new NotSupportedException();
        }
    }
}