using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Security.Cryptography;
using Developpez.Dotnet.Collections;
using System.IO;
using System.Globalization;

namespace Developpez.Dotnet
{
    /// <summary>
    /// Fournit des méthodes d'extension pour les chaines de caractères
    /// </summary>
    public static class StringExtensions
    {
        /// <summary>
        /// Indique si une chaine est nulle ou vide
        /// </summary>
        /// <param name="s">la chaine à tester</param>
        /// <returns>true si la chaine est nulle ou vide, false sinon</returns>
        public static bool IsNullOrEmpty(this string s)
        {
            return string.IsNullOrEmpty(s);
        }

        /// <summary>
        /// Indique si une chaîne est nulle, vide ou composée uniquement d'espaces blancs.
        /// </summary>
        /// <param name="s">la chaine à tester</param>
        /// <returns>true si la chaine est nulle, vide ou composée uniquement d'espaces blancs, false sinon</returns>
        public static bool IsNullOrWhiteSpace(this string s)
        {
            if (s != null)
                s = s.Trim();
            return string.IsNullOrEmpty(s);
        }

        /// <summary>
        /// Formate la chaine avec les valeurs spécifiées, de la même façon que
        /// String.Format
        /// </summary>
        /// <param name="format">La chaine de format</param>
        /// <param name="args">les valeurs à utiliser</param>
        /// <returns>La chaine formatée</returns>
        public static string FormatWith(this string format, params object[] args)
        {
            return string.Format(format, args);
        }

        /// <summary>
        /// Inverse l'ordre des caractères d'une chaine
        /// </summary>
        /// <param name="s">La chaine à inverser</param>
        /// <returns>La chaine inversée</returns>
        public static string Reverse(this string s)
        {
            s.CheckArgumentNull("s");

            bool wasFormD = false;
            if (s.IsNormalized(NormalizationForm.FormD))
            {
                wasFormD = true;
                s = s.Normalize(NormalizationForm.FormC);
            }

            s = new String((s as IEnumerable<char>).Reverse().ToArray());

            if (wasFormD)
            {
                s = s.Normalize(NormalizationForm.FormD);
            }
            return s;
        }

        /// <summary>
        /// Concatène toutes les chaines de la liste en plaçant le séparateur
        /// spécifié entre chaque chaine
        /// </summary>
        /// <param name="list">La liste de chaines à concaténer</param>
        /// <param name="separator">Le séparateur à utiliser</param>
        /// <returns>La concaténation des chaines de la liste</returns>
        public static string Join(this IEnumerable<string> list, string separator)
        {
            list.CheckArgumentNull("list");
            return string.Join(separator, list.ToArray());
        }

        /// <summary>
        /// Renvoie une chaine construite à partir d'une séquence de caractères
        /// </summary>
        /// <param name="chars">La séquence de caractères à transformer en chaine</param>
        /// <returns>Une chaine constituée des caractères de la séquence</returns>
        public static string Join(this IEnumerable<char> chars)
        {
            return new string(chars.ToArray());
        }

        /// <summary>
        /// Enumère les lignes d'une chaine de caractères
        /// </summary>
        /// <param name="s">La chaine à découper en lignes</param>
        /// <returns>La liste des lignes de cette chaine</returns>
        public static IEnumerable<string> ReadLines(this string s)
        {
            s.CheckArgumentNull("s");
            return ReadLinesIterator(s);
        }

        private static IEnumerable<string> ReadLinesIterator(string s)
        {
            using (StringReader reader = new StringReader(s))
            {
                string line;
                while ((line = reader.ReadLine()) != null)
                {
                    yield return line;
                }
            }
        }

        private static MD5 _md5;

        /// <summary>
        /// Renvoie le hash MD5 de la chaîne sous forme d'une chaine hexadécimale, en
        /// se basant sur l'encodage ASCII
        /// </summary>
        /// <param name="s">la chaine dont on veut obtenir le hash MD5</param>
        /// <returns>le hash MD5 sous forme d'une chaine hexadécimale</returns>
        public static string GetMD5Digest(this string s)
        {
            return s.GetMD5Digest(Encoding.ASCII);
        }

        /// <summary>
        /// Renvoie le hash MD5 de la chaîne sous forme d'une chaine hexadécimale, en
        /// se basant sur l'encodage spécifié
        /// </summary>
        /// <param name="s">la chaine dont on veut obtenir le hash MD5</param>
        /// <param name="encoding">L'encodage à utiliser</param>
        /// <returns>le hash MD5 sous forme d'une chaine hexadécimale</returns>
        public static string GetMD5Digest(this string s, Encoding encoding)
        {
            if (_md5 == null)
            {
                _md5 = MD5.Create();
            }

            byte[] stringBytes = encoding.GetBytes(s);
            byte[] hashBytes = _md5.ComputeHash(stringBytes);
            string hash = hashBytes.FormatAll("x2", null);
            return hash;
        }

        /// <summary>
        /// Enlève les caractères diacritiques (accents, cédilles...) d'une chaine en les remplaçant par le
        /// caractère de base.
        /// </summary>
        /// <param name="s">La chaine dont on veut enlever les diacritiques</param>
        /// <returns>La chaine sans les diacritiques</returns>
        public static string RemoveDiacritics(this string s)
        {
            s.CheckArgumentNull("s");
            string formD = s.Normalize(NormalizationForm.FormD);
            string noDiacriticsFormD = new string(
                formD.Where(c => CharUnicodeInfo.GetUnicodeCategory(c) != UnicodeCategory.NonSpacingMark)
                     .ToArray());
            string noDiacritics = noDiacriticsFormD.Normalize(NormalizationForm.FormC);
            return noDiacritics;
        }

        /// <summary>
        /// Retourne une chaîne contenant un nombre spécifié de caractères en partant de la gauche d'une chaîne.
        /// </summary>
        /// <param name="s">chaine dont les caractères situés le plus à gauche sont retournés</param>
        /// <param name="count">Nombre de caractères à retourner</param>
        /// <returns>une chaîne contenant le nombre spécifié de caractères en partant de la gauche de s</returns>
        public static string Left(this string s, int count)
        {
            if (count < 0 || count > s.Length)
                throw new ArgumentOutOfRangeException("count", ExceptionMessages.SubstringCountOutOfRange);
            return s.Substring(0, count);
        }

        /// <summary>
        /// Retourne une chaîne contenant un nombre spécifié de caractères en partant de la droite d'une chaîne.
        /// </summary>
        /// <param name="s">chaine dont les caractères situés le plus à droite sont retournés</param>
        /// <param name="count">Nombre de caractères à retourner</param>
        /// <returns>une chaîne contenant le nombre spécifié de caractères en partant de la droite de s</returns>
        public static string Right(this string s, int count)
        {
            if (count < 0 || count > s.Length)
                throw new ArgumentOutOfRangeException("count", ExceptionMessages.SubstringCountOutOfRange); 
            return s.Substring(s.Length - count, count);
        }

        /// <summary>
        /// Renvoie un dictionnaire contenant le nombre d'occurences de chaque caractère de la chaine
        /// </summary>
        /// <param name="s">La chaine pour laquelle on veut compter les caractères</param>
        /// <returns>Un dictionnaire contenant le nombre d'occurences de chaque caractère</returns>
        public static IDictionary<char, int> GetCharFrequencies(this string s)
        {
            var frequencies = new DefaultDictionary<char, int>();
            foreach (char c in s) frequencies[c]++;
            return frequencies;
        }

        #region From/To

        /// <summary>
        /// Renvoie une portion de chaine à partir de la position spécifiée
        /// </summary>
        /// <param name="s">Chaine dont on veut extraire une portion</param>
        /// <param name="start">Position de début de la portion</param>
        /// <returns>La portion de chaine demandée </returns>
        public static SubStringFrom From(this string s, int start)
        {
            return new SubStringFrom(s, start);
        }

        /// <summary>
        /// Termine une portion de chaine à la position spécifiée
        /// </summary>
        /// <param name="subStringFrom">Portion de chaine à terminer</param>
        /// <param name="end">Position de fin</param>
        /// <returns>La portion de chaine demandée</returns>
        public static string To(this SubStringFrom subStringFrom, int end)
        {
            return subStringFrom.String.Substring(subStringFrom.Start, end - subStringFrom.Start + 1);
        }

        /// <summary>
        /// Prend le nombre de caractères spécifié à partir du début de la portion
        /// </summary>
        /// <param name="subStringFrom">Portion de chaine à partir de laquelle prendre les caractères</param>
        /// <param name="count">Nombre de caractères à prendre</param>
        /// <returns>La portion de chaine demandée</returns>
        public static string Take(this SubStringFrom subStringFrom, int count)
        {
            return subStringFrom.String.Substring(subStringFrom.Start, count);
        }

        /// <summary>
        /// Renvoie une portion de chaine à partir de la sous-chaine spécifiée, sans inclure cette dernière
        /// </summary>
        /// <param name="s">Chaine dont on veut extraire une portion</param>
        /// <param name="start">Sous-chaine de début de la portion</param>
        /// <returns>La portion de chaine demandée </returns>
        public static SubStringFrom From(this string s, string start)
        {
            return s.From(start, false);
        }

        /// <summary>
        /// Renvoie une portion de chaine à partir de la sous-chaine spécifiée, en incluant éventuellement cette dernière
        /// </summary>
        /// <param name="s">Chaine dont on veut extraire une portion</param>
        /// <param name="start">Sous-chaine de début de la portion</param>
        /// <param name="includeBoundary">true pour inclure la chaine de début spécifiée dans le résultat, false sinon</param>
        /// <returns>La portion de chaine demandée </returns>
        public static SubStringFrom From(this string s, string start, bool includeBoundary)
        {
            int iStart = s.IndexOf(start);
            if (!includeBoundary && iStart >= 0)
                iStart += start.Length;
            return new SubStringFrom(s, iStart);
        }

        /// <summary>
        /// Termine une portion de chaine à la sous-chaine spécifiée, sans inclure cette dernière
        /// </summary>
        /// <param name="subStringFrom">Portion de chaine à terminer</param>
        /// <param name="end">Sous-chaine de fin</param>
        /// <returns>La portion de chaine demandée</returns>
        public static string To(this SubStringFrom subStringFrom, string end)
        {
            return subStringFrom.To(end, false);
        }

        /// <summary>
        /// Termine une portion de chaine à la sous-chaine spécifiée, en incluant éventuellement cette dernière
        /// </summary>
        /// <param name="subStringFrom">Portion de chaine à terminer</param>
        /// <param name="end">Sous-chaine de fin</param>
        /// <param name="includeBoundary">true pour inclure la chaine de fin spécifiée, false sinon</param>
        /// <returns>La portion de chaine demandée</returns>
        public static string To(this SubStringFrom subStringFrom, string end, bool includeBoundary)
        {
            string s = subStringFrom.String;
            int iStart = subStringFrom.Start;
            int iEnd = s.IndexOf(end, iStart);
            if (includeBoundary && iEnd > 0)
                iEnd += end.Length;
            if (iStart < 0 || iEnd < 0)
                return String.Empty;
            return s.Substring(iStart, iEnd - iStart);
        }

        /// <summary>
        /// Représente une portion d'une chaine de caractères à partir d'une position donnée
        /// </summary>
        public struct SubStringFrom
        {
            internal SubStringFrom(string s, int start)
                : this()
            {
                this.String = s;
                this.Start = start;
            }

            /// <summary>
            /// La chaine dont cet objet représente une portion
            /// </summary>
            public string String { get; private set; }

            /// <summary>
            /// La position de départ de la portion de chaine
            /// </summary>
            public int Start { get; private set; }

            /// <summary>
            /// Convertit implicitement un SubStringForm en String
            /// </summary>
            /// <param name="subStringFrom">SubStringForm à convertir</param>
            /// <returns>La chaine correspondante</returns>
            public static implicit operator string(SubStringFrom subStringFrom)
            {
                return subStringFrom.ToString();
            }

            /// <summary>
            /// Renvoie une chaine équivalente à la portion de chaine
            /// </summary>
            /// <returns>Une chaine équivalente à la portion de chaine</returns>
            public override string ToString()
            {
                if (this.Start < 0)
                    return String.Empty;
                return this.String.Substring(this.Start);
            }
        }

        #endregion
    }
}