using System;
using System.Collections.Generic;
using System.Text.RegularExpressions;
 
namespace System
{
    /// <summary>
    /// A comparer which can be assigned and have it's case sensitivity switched on the fly before a comparision is done.
    /// </summary>
    public class CaseComparer : IEqualityComparer<string>
    {
        public bool CaseSensitive = true;
 
        public CaseComparer() { }
 
        public CaseComparer(bool caseSensitive)
        {
            this.CaseSensitive = caseSensitive;
        }
 
        #region IEqualityComparer<string> Members
 
        public bool Equals(string x, string y)
        {
            if (CaseSensitive)
                return StringComparer.CurrentCulture.Equals(x, y);
            else
                return StringComparer.CurrentCultureIgnoreCase.Equals(x, y);
        }
 
        public int GetHashCode(string obj)
        {
            return obj.GetHashCode();
        }
 
        #endregion
    }
 
    /// <summary>
    /// Fixes the "parsing an enum returns an uncertain object" problem which occurs with standard enum objects having the same numeric value.
    /// </summary>
    /// <typeparam name="EnumType">An Enum object type. All other types are ignored.</typeparam>
    public static class Enum<EnumType>
    {
        private static Dictionary<Type, Dictionary<string, Cast>> nameLists = new Dictionary<Type, Dictionary<string, Cast>>();
        private static bool ValidType { get { return (typeof(EnumType).BaseType == typeof(global::System.Enum)); } }
        private static Regex rxStartsWithKeyWord = new Regex(@"^[0-9]|^abstract$|^as$|^base$|^bool$|^break$|^byte$|^case$|^catch$|^char$|^checked$|^class$|^const$|^continue$|^decimal$|^default$|^delegate$|^do$|^double$|^else$|^enum$|^event$|^explicit$|^extern$|^$false|^finally$|^fixed$|^float$|^for$|^foreach$|^goto$|^if$|^implicit$|^in$|^int$|^interface$|^internal$|^is$|^lock$|^long$|^namespace$|^new$|^null$|^object$|^operator$|^out$|^overrride$|^params$|^private$|^protected$|^public$|^readonly$|^ref$|^return$|^sbyte$|^sealed$|^short$|^sizeof$|^stackalloc$|^static$|^string$|^struct$|^switch$|^this$|^thorw$|^true$|^try$|^typeof$|^uint$|^ulong$|^unchecked$|^unsafe$|^ushort$|^using$|^virtual$|^volatile$|^void$|^while$", RegexOptions.Compiled);
 
        /// <summary>
        /// Fixes the "parsing an enum returns an uncertain object" problem which occurs with standard enum objects having the same numeric value.
        /// </summary>
        public sealed class Cast : IComparable, IFormattable, IConvertible
        {
            public readonly EnumType Enumeration;
            public readonly string RealName;
            public bool CaseSensitive = true;
            public static readonly Enum<EnumType>.Cast DefaultEnumeration = default(EnumType).ToString();
            public Enum<EnumType>.Cast Default { get { return DefaultEnumeration; } }
            public bool IsDefault { get { return (Enumeration.Equals(DefaultEnumeration.Enumeration)); } }
 
            internal Cast(global::System.Enum enumeration, string realName)
            {
                this.Enumeration = (EnumType)(object)enumeration;
                this.RealName = realName;
            }
 
            #region IComparable Members
 
            int IComparable.CompareTo(object obj)
            {
                if (obj is global::System.Enum)
                    return ((Enum)(object)this.Enumeration).CompareTo(obj);
                if (obj is Cast)
                    return Decimal.Compare(Convert.ToInt64(Enumeration), Convert.ToInt64(((Cast)obj).Enumeration));
                if (obj is string)
                    return (CaseSensitive) ? StringComparer.CurrentCulture.Compare(RealName, obj) : StringComparer.CurrentCultureIgnoreCase.Compare(RealName, obj);
 
                return -1;
            }
 
            #endregion
 
            #region IFormattable Members
 
            public override string ToString()
            {
                return RealName;
            }
 
            public string ToString(string format, IFormatProvider formatProvider)
            {
                if (formatProvider != null)
                    return RealName.ToString(formatProvider);
                return RealName;
            }
 
            #endregion
 
            #region IConvertible Members
 
            TypeCode IConvertible.GetTypeCode()
            {
                return ((Enum)(object)Enumeration).GetTypeCode();
            }
 
            bool IConvertible.ToBoolean(IFormatProvider provider)
            {
                return Convert.ToBoolean(Enumeration);
            }
 
            byte IConvertible.ToByte(IFormatProvider provider)
            {
                return Convert.ToByte(Enumeration);
            }
 
            char IConvertible.ToChar(IFormatProvider provider)
            {
                return Convert.ToChar(Enumeration);
            }
 
            DateTime IConvertible.ToDateTime(IFormatProvider provider)
            {
                return Convert.ToDateTime(Enumeration);
            }
 
            decimal IConvertible.ToDecimal(IFormatProvider provider)
            {
                return Convert.ToDecimal(Enumeration);
            }
 
            double IConvertible.ToDouble(IFormatProvider provider)
            {
                return Convert.ToDouble(Enumeration);
            }
 
            short IConvertible.ToInt16(IFormatProvider provider)
            {
                return Convert.ToInt16(Enumeration);
            }
 
            int IConvertible.ToInt32(IFormatProvider provider)
            {
                return Convert.ToInt32(Enumeration);
            }
 
            long IConvertible.ToInt64(IFormatProvider provider)
            {
                return Convert.ToInt64(Enumeration);
            }
 
            sbyte IConvertible.ToSByte(IFormatProvider provider)
            {
                return Convert.ToSByte(Enumeration);
            }
 
            float IConvertible.ToSingle(IFormatProvider provider)
            {
                return Convert.ToSingle(Enumeration);
            }
 
            object IConvertible.ToType(Type conversionType, IFormatProvider provider)
            {
                return Enumeration.GetType();
            }
 
            ushort IConvertible.ToUInt16(IFormatProvider provider)
            {
                return Convert.ToUInt16(Enumeration);
            }
 
            uint IConvertible.ToUInt32(IFormatProvider provider)
            {
                return Convert.ToUInt32(Enumeration);
            }
 
            ulong IConvertible.ToUInt64(IFormatProvider provider)
            {
                return Convert.ToUInt64(Enumeration);
            }
 
            string IConvertible.ToString(IFormatProvider provider)
            {
                return this.ToString(RealName, provider);
            }
 
            #endregion
 
            //underscore-decode name
            public string FriendlyName
            {
                get
                {
                    if (RealName.Contains("_"))
                        return RealName.Replace("___", ". ").Replace("__", ", ").Replace("_", " ").Trim();
                    return RealName;
                }
            }
 
            public static implicit operator Cast(string enumName)
            {
                return Parse(enumName);
            }
 
            public static implicit operator EnumType(Cast enumerationCast)
            {
                if (enumerationCast != null)
                    return enumerationCast.Enumeration;
                return DefaultEnumeration.Enumeration;
            }
 
        }
 
        /// <summary>
        /// Fixes the "parsing an enum returns an uncertain object" problem which occurs with standard enum objects having the same numeric value.
        /// Parse casts a enum name or Cast.FriendlyName to an Enum.Cast object of the proper enum type.
        /// </summary>
        /// <param name="enumName">The enumeration name to parse and cast to.</param>
        /// <param name="ignoreCase">Specifies if the parse should find and cast even if the string case is not exact.</param>
        /// <returns>An Enum.Cast object if the the generic type specified is a valid enum type. Otherwise returns null.</returns>
        public static Cast Parse(string enumName, bool ignoreCase)
        {
            if (ValidType)
            {
                Type enumType = typeof(EnumType);
                Dictionary<string, Cast> nameList;
 
                //cache or recieve from cache enum name list
                if (nameLists.ContainsKey(enumType))
                    nameList = nameLists[enumType];
                else
                {
                    nameList = new Dictionary<string, Cast>(new CaseComparer());
                    EnumType[] values = (EnumType[])global::System.Enum.GetValues(enumType);
                    string[] names = global::System.Enum.GetNames(enumType);
 
                    //store true values
                    for (int i = 0; i < names.Length; i++)
                    {
                        EnumType trueValue = values[i];
                        Cast cacheItem = new Cast((Enum)(object)trueValue, names[i]);
                        nameList.Add(names[i], cacheItem);
                    }
 
                    //store enum true name list associated with the enum type
                    nameLists.Add(enumType, nameList);
                }
 
                //set string compare method of list
                CaseComparer comparer = (CaseComparer)nameList.Comparer;
                comparer.CaseSensitive = !ignoreCase;
 
                string fixedName = enumName.Trim();
                //underscore-encode name
                if (fixedName.Contains(".") || fixedName.Contains(",") || fixedName.Contains(" "))
                    fixedName = fixedName.Replace(". ", "___").Replace(".", "___").Replace(", ", "__").Replace(",", "__").Replace(" ", "_").Trim();
                //allow enumerations that start with a number or are a keyword, as long as it is preceeded by a single underscore
                if (rxStartsWithKeyWord.Match(fixedName).Success)
                    fixedName = "_" + fixedName;
 
                if (nameList.ContainsKey(fixedName))
                    return nameList[fixedName];
 
                return Enum<EnumType>.Cast.DefaultEnumeration;
            }
            return null;
        }
 
        /// <summary>
        /// Fixes the "parsing an enum returns an uncertain object" problem which occurs with standard enum objects having the same numeric value.
        /// Parse (case sensitive) casts a enum name or Cast.FriendlyName to an Enum.Cast object of the proper enum type.
        /// </summary>
        /// <param name="enumName">The enumeration name to parse and cast to.</param>        
        /// <returns>An Enum.Cast object if the the generic type specified is a valid enum type. Otherwise returns null.</returns>
        public static Cast Parse(string enumName)
        {
            return Parse(enumName, false);
        }
 
        public static IList<EnumType> GetValues()
        {
            IList<EnumType> list = new List<EnumType>();
            foreach (object value in Enum.GetValues(typeof(EnumType)))
            {
                list.Add((EnumType)value);
            }
            return list;
        }
    }
}
 
/*
Syntax to use the class, is shown in the following advanced example:
*/
 
public class MyClass
{
 
     [DefaultValue(eOperation.Custom)]
     public enum eOperation
     {
         Custom=0,
         create,
         inspect,
         edit,
         source
     }
 
     private string operationField;
     private Enum<eOperation>.Cast operationEnum;
 
     public eOperation operation
     {
         get { return this.operationEnum; }
         set { this.operationText = value.ToString(); }
     }
 
     public string operationText
     {
         get { return this.operationField; }
         set
         {
             this.operationEnum = Enum<eOperation>.Parse(value, true);
             if (this.operationEnum.IsDefault)
                 this.operationField = value;
             else
                 this.operationField = this.operationEnum.FriendlyName;
         }
     }
 
}
 
/*
A direct assignment could also be used in the operationText (set) property, but the static Parse() function was used instead to display what is occurring behind the scenes with the implicit operator. Also, the Parse function is used to show how to use the case-insensitive Parse(), since the implicit operator is always case-sensitive.
*/