using System;
using System.Configuration;

namespace ChadSoft
{
    /// <summary>
    /// Class used for parsing strings to specific types.
    /// </summary>
    /// <notes>
    /// Original version copied (without permission) from Infragistics' web site code.
    /// Hopefully the lack of any type of real business logic will excuse this atrocity.
    /// If anyone is offended by this, feel free to let me know: jesschadwick@hotmail.com.
    /// </notes>
    public static class Parse
    {
        /// <summary>
        /// Gets a string showing the byte count at the most appropriate level of granularity (up to GB).
        /// </summary>
        /// <param name="byteCount">Number of bytes.</param>
        /// <returns>Formatted string for byte count.</returns>
        public static string FormatBytes(long byteCount)
        {
            string formatString;
            decimal output;
            if (byteCount < 1024)
            {
                formatString = "{0} Bytes";
                output = byteCount;
            }
            else
                if (byteCount < 1048576)
                {
                    formatString = "{0} KB";
                    output = Math.Round(byteCount / 1024M, 2);
                }
                else
                    if (byteCount < 1073741824)
                    {
                        formatString = "{0} MB";
                        output = Math.Round(byteCount / 1048576M, 2);
                    }
                    else
                    {
                        formatString = "{0} GB";
                        output = Math.Round(byteCount / 1073741824M, 2);
                    }
            return string.Format(formatString, output.ToString("n", System.Globalization.CultureInfo.CurrentUICulture.NumberFormat));
        }

        /// <summary>
        /// Attempts to parse the given string to a 32-bit integer.
        /// </summary>
        /// <param name="inValue">Value to parse.</param>
        /// <param name="throwOnFailure">Whether or not to throw an exception on failure.</param>
        /// <returns>The parsed value or 0 if not parseable.</returns>
        /// <exception cref="FormatException">Thrown if the value for <i>inValue</i> 
        /// cannot be parsed as an integer and <i>throwOnFailure</i> is true.</exception>
        public static int ToInt32(string inValue, bool throwOnFailure)
        {
            int outValue = 0;
            if ((string.IsNullOrEmpty(inValue) || !int.TryParse(inValue, out outValue))
                && throwOnFailure)
                CannotParse(inValue, "Int32");
            return outValue;
        }

        /// <summary>
        /// Gets the specified setting from the app config and attempts to parse it to the specified type.
        /// </summary>
        /// <typeparam name="T">Type to parse to.</typeparam>
        /// <param name="name">Name of config setting.</param>
        /// <returns>Parsed setting or the default of T if could not parse.</returns>
        public static T AppSetting<T>(string name)
        {
            return To<T>(ConfigurationManager.AppSettings[name]);
        }

        /// <summary>
        /// Parses the given value, returning the default of T if it cannot parse.
        /// </summary>
        /// <typeparam name="T">Type to parse to.</typeparam>
        /// <param name="inValue">Value to parse.</param>
        /// <returns>Parsed value or the default of T.</returns>
        public static T To<T>(string inValue)
        {
            return To<T>(inValue, false);
        }

        /// <summary>
        /// Tries to parse the given value to the requested type.  Throws an exception on failure
        /// if <i>throwOnFailure</i> is true; otherwise, returns the default value for T.
        /// </summary>
        /// <typeparam name="T">Type to parse to.</typeparam>
        /// <param name="inValue">Value to parse.</param>
        /// <param name="throwOnFailure">Whether or not to throw an exception on error.</param>
        /// <returns>Parsed value or the default of T.</returns>
        public static T To<T>(string inValue, bool throwOnFailure)
        {
            Type t = typeof(T);
            if (t.IsGenericType && t.GetGenericTypeDefinition() == typeof(Nullable<>))
            {
                t = t.GetGenericArguments()[0];
            }
            object outValue = null;
            if (t.IsEnum)
            {
                try
                {
                    outValue = Enum.Parse(t, inValue, true);
                }
                catch (Exception ex)
                {
                    if (throwOnFailure)
                        CannotParse(inValue, t.Name, ex);
                }
            }
            else
                outValue = ByTypeCode(inValue, throwOnFailure, Type.GetTypeCode(t));

            return outValue == null ? default(T) : (T)outValue;
        }

        /// <summary>
        /// Attempts to parse the given string to the requested type code.
        /// </summary>
        /// <param name="inValue">Value to parse.</param>
        /// <param name="throwOnFailure">Whether or not to throw an exception on error.</param>
        /// <param name="typeCode">Type code of type to parse to.</param>
        /// <returns>Parsed value or the default of T.</returns>
        public static object ByTypeCode(string inValue, bool throwOnFailure, TypeCode typeCode)
        {
            try
            {
                switch (typeCode)
                {
                    case TypeCode.Boolean:
                        inValue = inValue.ToLower();
                        switch (inValue) // this parses the stupid Ektron Yes/No values as bools..
                        {   
                            case "yes":
                                return true;
                            case "no":
                                return false;
                            case "1":
                                return true;
                            case "0":
                                return false;
                            default:
                                return bool.Parse(inValue);
                        }
                    case TypeCode.Byte:
                        return byte.Parse(inValue);
                    case TypeCode.Char:
                        return char.Parse(inValue);
                    case TypeCode.DateTime:
                        return DateTime.Parse(inValue);
                    case TypeCode.Decimal:
                        return decimal.Parse(inValue);
                    case TypeCode.Double:
                        return double.Parse(inValue);
                    case TypeCode.Int16:
                        return short.Parse(inValue);
                    case TypeCode.Int32:
                        return int.Parse(inValue);
                    case TypeCode.Int64:
                        return long.Parse(inValue);
                    case TypeCode.SByte:
                        return sbyte.Parse(inValue);
                    case TypeCode.Single:
                        return float.Parse(inValue);
                    case TypeCode.String:
                        return inValue;
                    case TypeCode.UInt16:
                        return ushort.Parse(inValue);
                    case TypeCode.UInt32:
                        return uint.Parse(inValue);
                    case TypeCode.UInt64:
                        return ulong.Parse(inValue);
                }
            }
            catch (Exception ex)
            {
                if (throwOnFailure)
                    CannotParse(inValue, typeCode.ToString(), ex);
            }
            if (throwOnFailure)
                CannotParse(inValue, typeCode.ToString());
            return null;
        }

        #region CannotParse
        static void CannotParse(string value, string targetType)
        {
            CannotParse(value, targetType, null);
        }
        static void CannotParse(string value, string targetType, Exception innerEx)
        {
            // LOCALIZE
            throw new FormatException(string.Format("Cannot parse value '{0}' to type '{1}'!", value, targetType), innerEx);
        }
        #endregion
    }


}