using System;
using System.Collections.Specialized;
using System.Text;
using System.Text.RegularExpressions;
using System.Xml.Linq;

namespace Neo.Afx.ComponentModel
{
    /// <summary>
    /// Contains string extension methods
    /// </summary>
    public static partial class Extensions
    {
        #region ToNameValueCollection

        /// <summary>
        /// Creates a name value collection from the given query string.
        /// </summary>
        /// <param name="queryString">The query string to be converted.</param>
        /// <returns>A name value collection.</returns>
        public static NameValueCollection ToNameValueCollection(this string queryString)
        {
            var result = new NameValueCollection();

            if(string.IsNullOrEmpty(queryString))
            {
                return result;
            }

            var nameValues = queryString.TrimStart(new[]
            {
                '?'
            }).Split(new[]
            {
                '&'
            }, StringSplitOptions.RemoveEmptyEntries);

            foreach(var nameValue in nameValues)
            {
                var option = nameValue.Split(new[]
                {
                    '='
                }, StringSplitOptions.RemoveEmptyEntries);

                switch(option.Length)
                {
                    case 1:
                        result.Add(option[0], string.Empty);
                        break;
                    case 2:
                        result.Add(option[0], option[1]);
                        break;
                }
            }
            return result;
        }

        #endregion

        #region Cleanse

        /// <summary>
        /// Cleanses the specified string by removing characters below value 32 and above value 255.
        /// <remarks>
        /// Special characters are characters above value 255, 
        /// all characters below this value are ANSI compatible, 
        /// also, characters below 32 are non-printable.
        /// </remarks>
        /// </summary>
        /// <param name="str">The string to be cleansed.</param>
        /// <returns>The cleansed string.</returns>
        public static string Cleanse(this String str)
        {
            if(String.IsNullOrEmpty(str))
            {
                return String.Empty;
            }

            var sb = new StringBuilder();
            foreach(var c in str)
            {
                if(c >= 32 && c <= 255)
                {
                    sb.Append(c);
                }
                else
                {
                    sb.Append(""); // some replacement character
                }
            }
            return sb.ToString().Trim();
        }

        #endregion

        #region IsEmail

        /// <summary>
        /// Determines whether the specified string is an email address.
        /// </summary>
        /// <param name="s">The string to be validated.</param>
        /// <returns>
        /// 	<code>true</code> if the specified string is an email address; <code>false</code> otherwise.
        /// </returns>
        public static bool IsEmail(this string s)
        {
            var rx = new Regex(@"^[a-zA-Z0-9._-]+@([a-zA-Z0-9.-]+\.)+[a-zA-Z0-9.-]{2,4}$");
            return rx.IsMatch(s);
        }

        #endregion

        #region ToEnum

        ///// <summary>
        ///// Converts the string to an enum value.
        ///// </summary>
        ///// <param name="s">The string to be queried.</param>
        ///// <returns>The enum value.</returns>
        //public static T ToEnum<T>(this string s)
        //{
        //    return (T)s.ToEnum(typeof(T));
        //}

        /// <summary>
        /// Converts the string to an enum value.
        /// </summary>
        /// <param name="s">The string to be queried.</param>
        /// <param name="enumType">The type of the enum.</param>
        /// <returns>The enum value.</returns>
        public static object ToEnum(this string s, Type enumType)
        {
            int i;
            return Int32.TryParse(s, out i) ? Enum.ToObject(enumType, i) : Enum.Parse(enumType, s, true);
        }

        #endregion

        #region ToDbValue

        /// <summary>
        /// Converts the string to <code>Convert.DBNull</code> if it is <code>null</code> or empty.
        /// </summary>
        /// <param name="s">The string to be queried.</param>
        /// <returns><code>Convert.DBNull</code> if the string is <code>null</code> or empty.</returns>
        public static object ToDbValue(this string s)
        {
            return String.IsNullOrEmpty(s) ? Convert.DBNull : s;
        }

        #endregion

        #region ToXElement

        /// <summary>
        /// Converts the string to an <see cref="XElement"/>.
        /// </summary>
        /// <param name="s">The string to be queried.</param>
        /// <returns>The <see cref="XElement"/> or <code>null</code> if the string is <code>null</code> or empty.</returns>
        public static XElement ToXElement(this string s)
        {
            return String.IsNullOrEmpty(s) ? null : XElement.Parse(s);
        }

        #endregion

        #region AppendBracketed

        /// <summary>
        /// Appends the given string surround by square brackets.
        /// </summary>
        /// <param name="sb">The StringBuilder to be appended.</param>
        /// <param name="s">The string to be appended.</param>
        public static void AppendBracketed(this StringBuilder sb, string s)
        {
            sb.Append('[');
            sb.Append(s);
            sb.Append(']');
        }

        #endregion

        #region ToStringAll

        /// <summary>
        /// Returns a string containing all inner exception stack traces.
        /// </summary>
        /// <param name="ex">The exception to be queried.</param>
        /// <returns>A string containing all inner exception stack traces.</returns>
        public static string ToStringAll(this Exception ex)
        {
            var err = new StringBuilder();
            do
            {
                err.AppendLine(ex.Message);
                err.Append(Environment.NewLine);
                err.Append(ex.StackTrace);
                err.Append(Environment.NewLine);
            }
            while((ex = ex.InnerException) != null);
            return err.ToString();
        }

        #endregion

        #region Replace

        /// <summary>
        /// Returns a new string in which all occurrences of a specified string in the current instance are replaced with another specified string.
        /// </summary>
        /// <param name="searchString">The string to be searched.</param>
        /// <param name="oldValue">The string to be replaced.</param>
        /// <param name="newValue">The string that replaces <paramref name="oldValue"/>, or null.</param>
        /// <param name="comparisonType">One of the enumeration values that specifies the rules for the search.</param>
        /// <returns>A string that is equivalent to the current string except that all instances of oldValue are replaced with newValue.</returns>
        public static string Replace(this string searchString, string oldValue, string newValue, StringComparison comparisonType)
        {
            return Replace(searchString, oldValue, newValue, comparisonType, -1);
        }

        static string Replace(this string searchString, string oldValue, string newValue, StringComparison comparisonType, int stringBuilderInitialSize)
        {
            if(searchString == null)
            {
                return null;
            }

            if(String.IsNullOrEmpty(oldValue))
            {
                return searchString;
            }


            var posCurrent = 0;
            var lenPattern = oldValue.Length;
            var idxNext = searchString.IndexOf(oldValue, comparisonType);
            var result = new StringBuilder(stringBuilderInitialSize < 0 ? Math.Min(4096, searchString.Length) : stringBuilderInitialSize);

            while(idxNext >= 0)
            {
                result.Append(searchString, posCurrent, idxNext - posCurrent);
                result.Append(newValue);

                posCurrent = idxNext + lenPattern;

                idxNext = searchString.IndexOf(oldValue, posCurrent, comparisonType);
            }

            result.Append(searchString, posCurrent, searchString.Length - posCurrent);

            return result.ToString();
        }

        #endregion

    }
}