namespace Views
{
    using System;
    using System.Collections.Generic;
    using System.ComponentModel;
    using System.Windows.Markup;

    /// <summary>
    /// Markup extension that provides a list of the members of a given enum.
    /// </summary>
    public class EnumSourceExtension : MarkupExtension
    {
        private Type enumType;

        /// <summary>
        /// Initializes a new <see cref=”EnumListExtension”/>
        /// </summary>
        public EnumSourceExtension()
        {
        }

        /// <summary>
        /// Initializes a new <see cref=”EnumListExtension”/>
        /// </summary>
        /// <param name=”enumType”>The type of enum whose members are to be returned.</param>
        public EnumSourceExtension(Type enumType)
        {
            this.EnumType = enumType;
        }

        /// <summary>
        /// Gets/sets the type of enumeration to return
        /// </summary>
        public Type EnumType
        {
            get { return this.enumType; }
            set
            {
                if (enumType != value) {
                    if (value != null) {
                        var underlyingType = Nullable.GetUnderlyingType(value) ?? value;
                        if (!underlyingType.IsEnum)
                            throw new ArgumentException("Type must be for an Enum.");
                    }

                    enumType = value;
                }
            }
        }


        /// <summary>
        /// Gets/sets a value indicating whether to display the enumeration members as strings using the Description on the member if available.
        /// </summary>
        public bool AsString { get; set; }


        /// <summary>
        /// Returns a list of items for the specified <see cref=”EnumType”/>. Depending on the <see cref=”AsString”/> property, the
        /// items will be returned as the enum member value or as strings.
        /// </summary>
        /// <param name=”serviceProvider”>An object that provides services for the markup extension.</param>
        /// <returns></returns>
        public override object ProvideValue(IServiceProvider serviceProvider)
        {
            if (enumType == null)
                throw new InvalidOperationException("The EnumType must be specified.");

            var actualEnumType = Nullable.GetUnderlyingType(this.enumType) ?? this.enumType;
            var enumValues = Enum.GetValues(actualEnumType);


            // if the object itself is to be returned then just use GetValues
            //
            if (!AsString) {
                if (actualEnumType == enumType)
                    return enumValues;


                var tempArray = Array.CreateInstance(actualEnumType, enumValues.Length + 1);
                enumValues.CopyTo(tempArray, 1);
                return tempArray;
            }


            var items = new List<string>();

            if (actualEnumType != enumType)
                items.Add(null);

            // otherwise we must process the list
            foreach (var item in Enum.GetValues(enumType)) {
                var itemString = item.ToString();
                var field = this.enumType.GetField(itemString);
                var attribs = field.GetCustomAttributes(typeof(DescriptionAttribute), false);

                if (attribs != null && attribs.Length > 0)
                    itemString = ((DescriptionAttribute)attribs[0]).Description;

                items.Add(itemString);
            }

            return items.ToArray();
        }
    }
}

namespace Views
{
    using System;
    using System.ComponentModel;
    using System.Globalization;
    using System.Linq;
    using System.Windows.Data;
    using System.Windows.Markup;

    public class EnumConverter : MarkupExtension, IValueConverter
    {
        private static readonly EnumConverter instance = new EnumConverter();

        public override object ProvideValue(IServiceProvider serviceProvider)
        {
            return instance;
        }

        public object Convert(object value, Type targetType, object parameter, CultureInfo culture)
        {
            if (value == null)
                return null;

            var enumType = value.GetType();
            var valueString = value.ToString();
            var valueField = enumType.GetField(valueString);
            var valueDescription = valueField.GetCustomAttributes(typeof(DescriptionAttribute), false).
                Cast<DescriptionAttribute>().
                Select(attribute => attribute.Description).
                FirstOrDefault();

            return String.IsNullOrEmpty(valueDescription) ? valueString : valueDescription;
        }

        public object ConvertBack(object value, Type targetType, object parameter, CultureInfo culture)
        {
            if (value == null)
                return null;

            var valueString = (string)value;

            foreach (var enumValue in Enum.GetValues(targetType)) {
                var enumValueString = enumValue.ToString();
                var enumField = targetType.GetField(enumValueString);
                var enumValueDescription = enumField.GetCustomAttributes(typeof(DescriptionAttribute), false).
                    Cast<DescriptionAttribute>().
                    Select(attribute => attribute.Description).
                    FirstOrDefault();

                if (String.IsNullOrEmpty(enumValueDescription)) {
                    if (enumValueString == valueString)
                        return enumValue;
                }
                else {
                    if (enumValueDescription == valueString)
                        return enumValue;
                }
            }

            throw new InvalidOperationException();
        }
    }
}