using System;
using System.Collections.Generic;
using System.Globalization;
using System.Linq;
using System.Reflection;
using Developpez.Dotnet.Language;
using Developpez.Dotnet.Language.Grammar;
using Developpez.Dotnet.Properties;
#if !NETFX_CORE
using Developpez.Dotnet.Reflection;
#endif
using CH = Developpez.Dotnet.CompatibilityHelper;

namespace Developpez.Dotnet
{
    /// <summary>
    /// Fournit des méthodes de conversion d'un nombre en toutes lettres.
    /// </summary>
    public static class NumberConverter
    {

        #region Private data

        private static readonly object _spellerLock = new object();
        private static readonly IDictionary<string, INumberSpeller> _spellers;
        private static readonly IDictionary<string, INumberSpeller> _bestSpellers;
        
        #endregion

        #region Constructor

        static NumberConverter()
        {
            _spellers = new Dictionary<string, INumberSpeller>(CH.StringComparer.InvariantCultureIgnoreCase);
            _bestSpellers = new Dictionary<string, INumberSpeller>(CH.StringComparer.InvariantCulture);
#if NETFX_CORE
            LoadSpellers(typeof (NumberConverter).GetTypeInfo().Assembly);
#else
            LoadSpellers(typeof (NumberConverter).Assembly);
#endif
        }

        #endregion

        #region Private methods

        private static INumberSpeller GetSpeller()
        {
            return GetSpeller(CultureInfo.CurrentCulture);
        }

        /// <summary>
        /// Renvoie un convertisseur de nombre en toutes lettres pour la culture spécifiée
        /// </summary>
        /// <param name="culture">Culture pour laquelle obtenir un convertisseur</param>
        /// <returns>Un convertisseur de nombre en toutes lettres pour la culture spécifiée</returns>
        public static INumberSpeller GetSpeller(CultureInfo culture)
        {
            culture.CheckArgumentNull("culture");
            INumberSpeller bestAvailable;
            lock (_spellerLock)
            {
                if (!_bestSpellers.TryGetValue(culture.Name, out bestAvailable))
                {
                    bestAvailable = FindBestAvailableSpeller(culture);
                    _bestSpellers[culture.Name] = bestAvailable;
                }
            }
            return bestAvailable;
        }

        /// <summary>
        /// Renvoie un convertisseur de nombre en toutes lettres pour la culture spécifiée
        /// </summary>
        /// <param name="culture">Culture pour laquelle obtenir un convertisseur</param>
        /// <returns>Un convertisseur de nombre en toutes lettres pour la culture spécifiée</returns>
        public static INumberSpeller GetSpeller(string culture)
        {
#if SILVERLIGHT || NETFX_CORE
            var c = new CultureInfo(culture);
#else
            var c = CultureInfo.GetCultureInfo(culture);
#endif
            return GetSpeller(c);
        }

        private static INumberSpeller FindBestAvailableSpeller(CultureInfo culture)
        {
            var candidates = SpellerHelper.GetCultureAndParents(culture).Join(
                                _spellers,
                                c => c.Name,
                                kvp => kvp.Key,
                                (c, kvp) => kvp.Value,
                                CH.StringComparer.InvariantCultureIgnoreCase);

            INumberSpeller bestAvailable = candidates.FirstOrDefault();
            if (bestAvailable == null)
                throw new NotSupportedException(string.Format(ExceptionMessages.NumberConverter_NoSpellerAvailable, culture.Name));
            return bestAvailable;
        }

        #endregion

        #region Public methods

        /// <summary>
        /// Recherche tous les convertisseurs de nombre en lettres
        /// dans l'assembly spécifié. Utilisez cette méthode pour
        /// détecter un convertisseur personnalisé.
        /// </summary>
        /// <param name="assembly">L'assembly dans lequel les convertisseurs sont définis</param>
        /// <remarks>
        /// Les convertisseurs prédéfinis sont chargés automatiquement,
        /// il n'est donc pas nécessaire d'appeler LoadSpellers pour
        /// les utiliser.
        /// </remarks>
        public static void LoadSpellers(Assembly assembly)
        {
            var spellers =
#if NETFX_CORE
                from a in assembly.GetCustomAttributes<NumberSpellerTypeAttribute>()
#else
                from a in assembly.GetAttributes<NumberSpellerTypeAttribute>()
#endif
                group a.Culture by a.Implementation into g
                let speller = (INumberSpeller)Activator.CreateInstance(g.Key)
                from culture in g
                select new
                    {
                        Culture = culture,
                        Speller = speller
                    };

            lock (_spellerLock)
            {
                foreach (var s in spellers)
                {
                    _spellers[s.Culture] = s.Speller;
                }

                // Clear best choice cache in case a better speller is
                // now available for a language
                _bestSpellers.Clear();
            }
        }

        /// <summary>
        /// Convertit un nombre entier en toutes lettres.
        /// </summary>
        /// <param name="value">Nombre entier.</param>
        /// <returns>Le nombre en toutes lettres.</returns>
        public static string Spell(long value)
        {
            return Spell(value, Gender.Masculine);
        }


        /// <summary>
        /// Convertit un nombre entier en toutes lettres.
        /// </summary>
        /// <param name="value">Nombre entier.</param>
        /// <param name="gender">Genre du nombre entier.</param>
        /// <returns>Le nombre en toutes lettres.</returns>
        public static string Spell(long value, Gender gender)
        {
            return Spell(value, gender, NumeralAdjective.Cardinal);
        }


        /// <summary>
        /// Convertit un nombre entier en toutes lettres.
        /// </summary>
        /// <param name="value">Nombre entier.</param>
        /// <param name="gender">Genre du nombre entier.</param>
        /// <param name="numeralAdjective">Nature de l'adjectif numéral.</param>
        /// <returns>Le nombre en toutes lettres.</returns>
        public static string Spell(long value, Gender gender, NumeralAdjective numeralAdjective)
        {
            return GetSpeller().Spell(value, gender, numeralAdjective);
        }


        /// <summary>
        /// Convertit un nombre entier en toutes lettres.
        /// </summary>
        /// <param name="value">Nombre entier.</param>
        /// <returns>Le nombre en toutes lettres.</returns>
        public static string Spell(ulong value)
        {
            return Spell(value, Gender.Masculine);
        }


        /// <summary>
        /// Convertit un nombre entier en toutes lettres.
        /// </summary>
        /// <param name="value">Nombre entier.</param>
        /// <param name="gender">Genre du nombre entier.</param>
        /// <returns>Le nombre en toutes lettres.</returns>
        public static string Spell(ulong value, Gender gender)
        {
            return Spell(value, gender, NumeralAdjective.Cardinal);
        }


        /// <summary>
        /// Convertit un nombre entier en toutes lettres.
        /// </summary>
        /// <param name="value">Nombre entier.</param>
        /// <param name="gender">Genre du nombre entier.</param>
        /// <param name="numeralAdjective">Nature de l'adjectif numéral.</param>
        /// <returns>Le nombre en toutes lettres.</returns>
        public static string Spell(ulong value, Gender gender, NumeralAdjective numeralAdjective)
        {
            return GetSpeller().Spell(value, gender, numeralAdjective);
        }

        /// <summary>
        /// Convertit un nombre en virgule flottante en toutes lettres, avec le nombre de chiffres spécifié après la virgule.
        /// </summary>
        /// <param name="value">Nombre en virgule flottante</param>
        /// <param name="decimalPlaces">Nombre de chiffres après la virgule</param>
        /// <returns>Le nombre en toutes lettres</returns>
        public static string Spell(double value, int decimalPlaces)
        {
            return GetSpeller().Spell(value, decimalPlaces);
        }

        /// <summary>
        /// Convertit un nombre décimal en toutes lettres, avec le nombre de chiffres spécifié après la virgule.
        /// </summary>
        /// <param name="value">Nombre décimal</param>
        /// <param name="decimalPlaces">Nombre de chiffres après la virgule</param>
        /// <returns>Le nombre en toutes lettres</returns>
        public static string Spell(decimal value, int decimalPlaces)
        {
            return GetSpeller().Spell(value, decimalPlaces);
        }

        /// <summary>
        /// Convertit un montant en toutes lettres, avec la devise spécifiée.
        /// </summary>
        /// <param name="value">Montant en virgule flottante</param>
        /// <param name="currency">Devise utilisée</param>
        /// <returns>Le montant en toutes lettres</returns>
        public static string SpellAmount(double value, CurrencyDescriptor currency)
        {
            return GetSpeller().SpellAmount(value, currency);
        }

        /// <summary>
        /// Convertit un montant en toutes lettres, avec la devise spécifiée.
        /// </summary>
        /// <param name="value">Montant décimal</param>
        /// <param name="currency">Devise utilisée</param>
        /// <returns>Le montant en toutes lettres</returns>
        public static string SpellAmount(decimal value, CurrencyDescriptor currency)
        {
            return GetSpeller().SpellAmount(value, currency);
        }

        #endregion

    }
}