using System;
using System.Collections.Generic;
using System.Linq.Expressions;
using System.Reflection;
using System.Text.RegularExpressions;
using Developpez.Dotnet.Collections;
using Developpez.Dotnet.Properties;
using CH = Developpez.Dotnet.CompatibilityHelper;

namespace Developpez.Dotnet.Text
{
    /// <summary>
    /// Représente un modèle de chaine de caractères, où on peut utiliser des noms plutôt que des index
    /// pour les valeurs à remplacer.
    /// </summary>
    public class StringTemplate
    {
        private static readonly Regex _regex = new Regex(@"(?<open>{+)(?<key>\w+)(?<format>:[^}]+)?(?<close>}+)", CH.RegexOptions.Compiled);
        
        private readonly string _template;
        private readonly string _templateWithIndexes;
        private readonly IList<string> _placeholders;


        /// <summary>
        /// Initialise une nouvelle instance de StringTemplate avec le template à utiliser
        /// </summary>
        /// <param name="template">Le template à utiliser. Le format est identique à celui accepté par String.Format,
        /// mais avec des noms à la place des index pour les valeurs à remplacer</param>
        public StringTemplate(string template)
            : this(template, true)
        {
        }

        private StringTemplate(string template, bool lookupInCache)
        {
            template.CheckArgumentNull("template");
            _template = template;
            if (lookupInCache)
            {
                var cached = GetTemplateFromCache(template, false);
                if (cached != null)
                {
                    _placeholders = cached._placeholders;
                    _templateWithIndexes = cached._templateWithIndexes;
                    return;
                }
            }
            ParseTemplate(out _templateWithIndexes, out _placeholders);
        }

        private void ParseTemplate(out string templateWithIndexes, out IList<string> placeholders)
        {
            var tmp = new List<string>();
            MatchEvaluator evaluator = m =>
            {
                string open = m.Groups["open"].Value;
                string close = m.Groups["close"].Value;
                string key = m.Groups["key"].Value;
                string format = m.Groups["format"].Value;

                if (open.Length % 2 == 0)
                    return m.Value;

                open = RemoveLastChar(open);
                close = RemoveLastChar(close);

                if (!tmp.Contains(key))
                {
                    tmp.Add(key);
                }

                int index = tmp.IndexOf(key);
                return string.Format("{0}{{{1}{2}}}{3}", open, index, format, close);
            };
            templateWithIndexes = _regex.Replace(_template, evaluator);
            placeholders = tmp.AsReadOnly();
        }

        private static string RemoveLastChar(string str)
        {
            if (str.Length > 1)
                return str.Substring(0, str.Length - 1);
            return string.Empty;
        }

        /// <summary>
        /// Convertit une chaine en StringTemplate
        /// </summary>
        /// <param name="s">La chaine à convertir</param>
        /// <returns>Un StringTemplate utilisant la chaine convertie comme template</returns>
        public static implicit operator StringTemplate(string s)
        {
            return GetTemplateFromCache(s, true);
        }

        /// <summary>
        /// Renvoie une chaine représentant cette instance de StringTemplate.
        /// </summary>
        /// <returns>Le template utilisé par ce StringTemplate</returns>
        public override string ToString()
        {
            return _template;
        }

        /// <summary>
        /// Remplace les placeholders du template par les valeurs fournies dans le dictionnaire spécifié
        /// </summary>
        /// <param name="values">Le dictionnaire contenant les valeurs pour les placeholders</param>
        /// <returns>La chaine formatée</returns>
        /// <exception cref="System.Collections.Generic.KeyNotFoundException">Aucune valeur n'a été trouvée pour
        /// un placeholder du template</exception>
        public string Format(IDictionary<string, object> values)
        {
            return Format(values, true);
        }

        /// <summary>
        /// Remplace les placeholders du template par les valeurs fournies dans le dictionnaire spécifié
        /// </summary>
        /// <param name="values">Le dictionnaire contenant les valeurs pour les placeholders</param>
        /// <param name="throwOnMissingValue">Indique si une exception doit être levée quand aucune valeur
        /// n'est trouvée pour un placeholder du template. Si ce paramètre vaut false, le placeholder est laissé
        /// tel quel dans la chaine formatée.</param>
        /// <returns>La chaine formatée</returns>
        /// <exception cref="System.Collections.Generic.KeyNotFoundException">Le paramètre <c>throwOnMissingValue</c>
        /// vaut true et aucune valeur n'a été trouvée pour un placeholder du template</exception>
        public string Format(IDictionary<string, object> values, bool throwOnMissingValue)
        {
            values.CheckArgumentNull("values");

            object[] array = new object[_placeholders.Count];
            for(int i = 0; i < _placeholders.Count; i++)
            {
                string key = _placeholders[i];
                object value;
                if (!values.TryGetValue(key, out value))
                {
                    if (throwOnMissingValue)
                        throw new KeyNotFoundException(string.Format(ExceptionMessages.TemplateKeyNotFound, key));
                    value = string.Format("{{{0}}}", key);
                }
                array[i] = value;
            }
            return string.Format(_templateWithIndexes, array);
        }

        /// <summary>
        /// Remplace les placeholders du template par les valeurs fournies dans l'objet spécifié
        /// </summary>
        /// <param name="values">L'objet contenant les valeurs pour les placeholders. Chaque propriété de
        /// l'objet correspond à un placeholder du template</param>
        /// <returns>La chaine formatée</returns>
        /// <exception cref="System.Collections.Generic.KeyNotFoundException">Aucune valeur n'a été trouvée pour
        /// un placeholder du template</exception>
        /// <remarks>Cette méthode s'utilise typiquement avec un objet de type anonyme, créé avec la syntaxe
        /// <c>new { nom1 = valeur1, nom2 = valeur2 }</c></remarks>
        public string Format(object values)
        {
            return Format(values, true);
        }

        /// <summary>
        /// Remplace les placeholders du template par les valeurs fournies dans l'objet spécifié
        /// </summary>
        /// <param name="values">L'objet contenant les valeurs pour les placeholders. Chaque propriété de
        /// l'objet correspond à un placeholder du template</param>
        /// <param name="throwOnMissingValue">Indique si une exception doit être levée quand aucune valeur
        /// n'est trouvée pour un placeholder du template. Si ce paramètre vaut false, le placeholder est laissé
        /// tel quel dans la chaine formatée.</param>
        /// <returns>La chaine formatée</returns>
        /// <exception cref="System.Collections.Generic.KeyNotFoundException">Le paramètre <c>throwOnMissingValue</c>
        /// vaut true et aucune valeur n'a été trouvée pour un placeholder du template</exception>
        /// <remarks>Cette méthode s'utilise typiquement avec un objet de type anonyme, créé avec la syntaxe
        /// <c>new { nom1 = valeur1, nom2 = valeur2 }</c></remarks>
        public string Format(object values, bool throwOnMissingValue)
        {
            values.CheckArgumentNull("values");
            return Format(MakeDictionary(values), throwOnMissingValue);
        }

        private IDictionary<string, object> MakeDictionary(object obj)
        {
            Dictionary<string, object> dict = new Dictionary<string, object>();
            foreach (string name in _placeholders)
            {
                object value;
                if (TryGetMemberValue(obj, name, out value))
                    dict.Add(name, value);
            }
            return dict;
        }

        private static bool TryGetMemberValue(object obj, string memberName, out object value)
        {
            Type type = obj.GetType();
            Func<object, object> getter = GetGetterFromCache(type, memberName);
            if (getter != null)
            {
                value = getter(obj);
                return true;
            }
            value = null;
            return false;
        }

        /// <summary>
        /// Remplace les placeholders du template spécifié par les valeurs fournies dans le dictionnaire spécifié
        /// </summary>
        /// <param name="template">Le template à utiliser</param>
        /// <param name="values">Le dictionnaire contenant les valeurs pour les placeholders</param>
        /// <returns>La chaine formatée</returns>
        /// <exception cref="System.Collections.Generic.KeyNotFoundException">Aucune valeur n'a été trouvée pour
        /// un placeholder du template</exception>
        public static string Format(string template, IDictionary<string, object> values)
        {
            return GetTemplateFromCache(template, true).Format(values);
        }

        /// <summary>
        /// Remplace les placeholders du template spécifié par les valeurs fournies dans le dictionnaire spécifié
        /// </summary>
        /// <param name="template">Le template à utiliser</param>
        /// <param name="values">Le dictionnaire contenant les valeurs pour les placeholders</param>
        /// <param name="throwOnMissingValue">Indique si une exception doit être levée quand aucune valeur
        /// n'est trouvée pour un placeholder du template. Si ce paramètre vaut false, le placeholder est laissé
        /// tel quel dans la chaine formatée.</param>
        /// <returns>La chaine formatée</returns>
        /// <exception cref="System.Collections.Generic.KeyNotFoundException">Le paramètre <c>throwOnMissingValue</c>
        /// vaut true et aucune valeur n'a été trouvée pour un placeholder du template</exception>
        public static string Format(string template, IDictionary<string, object> values, bool throwOnMissingValue)
        {
            return GetTemplateFromCache(template, true).Format(values, throwOnMissingValue);
        }

        /// <summary>
        /// Remplace les placeholders du template par les valeurs fournies dans l'objet spécifié
        /// </summary>
        /// <param name="template">Le template à utiliser</param>
        /// <param name="values">L'objet contenant les valeurs pour les placeholders. Chaque placeholder du
        /// template est remplacé par la valeur de la propriété ou du champ de même nom</param>
        /// <returns>La chaine formatée</returns>
        /// <remarks>Cette méthode s'utilise typiquement avec un objet de type anonyme, créé avec la syntaxe
        /// <c>new { nom1 = valeur1, nom2 = valeur2 }</c></remarks>
        /// <exception cref="System.Collections.Generic.KeyNotFoundException">Aucune valeur n'a été trouvée pour
        /// un placeholder du template</exception>
        public static string Format(string template, object values)
        {
            return GetTemplateFromCache(template, true).Format(values);
        }

        /// <summary>
        /// Remplace les placeholders du template par les valeurs fournies dans l'objet spécifié
        /// </summary>
        /// <param name="template">Le template à utiliser</param>
        /// <param name="values">L'objet contenant les valeurs pour les placeholders. Chaque placeholder du
        /// template est remplacé par la valeur de la propriété ou du champ de même nom</param>
        /// <param name="throwOnMissingValue">Indique si une exception doit être levée quand aucune valeur
        /// n'est trouvée pour un placeholder du template. Si ce paramètre vaut false, le placeholder est laissé
        /// tel quel dans la chaine formatée.</param>
        /// <returns>La chaine formatée</returns>
        /// <remarks>Cette méthode s'utilise typiquement avec un objet de type anonyme, créé avec la syntaxe
        /// <c>new { nom1 = valeur1, nom2 = valeur2 }</c></remarks>
        /// <exception cref="System.Collections.Generic.KeyNotFoundException">Le paramètre <c>throwOnMissingValue</c>
        /// vaut true et aucune valeur n'a été trouvée pour un placeholder du template</exception>
        public static string Format(string template, object values, bool throwOnMissingValue)
        {
            return GetTemplateFromCache(template, true).Format(values, throwOnMissingValue);
        }

        #region Cache

        private static readonly Dictionary<string, StringTemplate> _templateCache =
            new Dictionary<string, StringTemplate>();

        private static StringTemplate GetTemplateFromCache(string template, bool create)
        {
            StringTemplate stringTemplate;
            if (!_templateCache.TryGetValue(template, out stringTemplate) && create)
            {
                stringTemplate = new StringTemplate(template, false);
                _templateCache[template] = stringTemplate;
            }
            return stringTemplate;
        }

        private static readonly Dictionary<Type, Dictionary<string, Func<object, object>>> _gettersCache =
            new Dictionary<Type, Dictionary<string, Func<object, object>>>();


        private static Func<object, object> GetGetterFromCache(Type type, string memberName)
        {
            Dictionary<string, Func<object, object>> typeGetters;
            if (!_gettersCache.TryGetValue(type, out typeGetters))
            {
                typeGetters = new Dictionary<string, Func<object, object>>();
                _gettersCache[type] = typeGetters;
            }
            Func<object, object> getter;
            if (!typeGetters.TryGetValue(memberName, out getter))
            {
                getter = CreateGetter(type, memberName);
                typeGetters[memberName] = getter;
            }
            return getter;
        }

        private static Func<object, object> CreateGetter(Type type, string memberName)
        {
            MemberInfo member = null;
            while (type != null)
            {
#if NETFX_CORE
                var prop = type.GetTypeInfo().GetDeclaredProperty(memberName);
#else
                var prop = type.GetProperty(memberName, BindingFlags.DeclaredOnly | BindingFlags.Public | BindingFlags.Instance);
#endif
                if (prop != null && prop.CanRead)
                {
                    member = prop;
                    break;
                }
#if NETFX_CORE
                var field = type.GetTypeInfo().GetDeclaredField(memberName);
#else
                var field = type.GetField(memberName, BindingFlags.DeclaredOnly | BindingFlags.Public | BindingFlags.Instance);
#endif
                if (field != null)
                {
                    member = field;
                    break;
                }
#if NETFX_CORE
                type = type.GetTypeInfo().BaseType;
#else
                type = type.BaseType;
#endif
            }
            if (member == null)
                return null;
            var param = Expression.Parameter(typeof (object), "x");
            var memberAccess = Expression.MakeMemberAccess(Expression.Convert(param, type), member);
            Expression body = memberAccess;
#if NETFX_CORE
            if (memberAccess.Type.GetTypeInfo().IsValueType)
#else
            if (memberAccess.Type.IsValueType)
#endif
                body = Expression.Convert(memberAccess, typeof (object));

            var expr = Expression.Lambda<Func<object, object>>(body, param);
            return expr.Compile();
        }

        #endregion
    }
}