using System;
using System.Globalization;
using Developpez.Dotnet.Properties;

namespace Developpez.Dotnet
{
    /// <summary>
    /// Permet de formater une taille en octets de façon lisible pour l'utilisateur
    /// </summary>
    public class ByteSizeFormatter
    {
        #region Prefixes and multiples definitions

        private static readonly long[] _decimalMultiples = new[]
        {
            1L,
            1000L,
            1000000L,
            1000000000L,
            1000000000000L,
            1000000000000000L,
            1000000000000000000L
        };

        private static readonly long[] _binaryMultiples = new[]
        {
            1L,
            1024L,
            1024L * 1024L,
            1024L * 1024L * 1024L,
            1024L * 1024L * 1024L * 1024L,
            1024L * 1024L * 1024L * 1024L * 1024L,
            1024L * 1024L * 1024L * 1024L * 1024L * 1024L,
        };

        private static readonly string[] _binaryPrefixes = new[]
        {
            "",
            "Ki",
            "Mi",
            "Gi",
            "Ti",
            "Pi",
            "Ei",
        };

        private static readonly string[] _decimalPrefixes = new[]
        {
            "",
            "K",
            "M",
            "G",
            "T",
            "P",
            "E",
        };

        #endregion

        #region Private data

        private int _decimalPlaces;
        private string _numberFormat;
        private ByteSizeUnit _minUnit;
        private ByteSizeUnit _maxUnit;
        private ByteSizeRounding _roundingRule;

        #endregion

        #region Constructor

        /// <summary>
        /// Crée une nouvelle instance de ByteSizeFormatter
        /// </summary>
        public ByteSizeFormatter()
        {
            DecimalPlaces = 0;
            NumberFormat = "#,##0.###";
            Convention = ByteSizeConvention.Customary;
            MinUnit = ByteSizeUnit.Byte;
            MaxUnit = ByteSizeUnit.Exabyte;
            RoundingRule = ByteSizeRounding.Closest;
            UseFullWordForBytes = true;
        }

        #endregion

        #region Public properties

        /// <summary>
        /// Obtient ou définit la convention utilisée pour les unités de taille.
        /// </summary>
        /// <value>La convention utilisée pour les unités de taille. La valeur par défaut est ByteSizeConvention.Customary, qui correspond à l'usage courant.</value>
        public ByteSizeConvention Convention { get; set; }

        ///<summary>
        /// Obtient ou définit la culture à utiliser pour le formatage du nombre.
        ///</summary>
        /// <value>La culture à utiliser, ou null pour utiliser la culture courante. La valeur par défaut est null.</value>
        public CultureInfo Culture { get; set; }

        /// <summary>
        /// Obtient ou définit le nombre de chiffres après la virgule à afficher.
        /// </summary>
        /// <value>Le nombre de chiffres après la virgule à afficher. La valeur par défaut est 0.</value>
        public int DecimalPlaces
        {
            get { return _decimalPlaces; }
            set
            {
                value.CheckArgumentOutOfRange("value", 0, int.MaxValue);
                _decimalPlaces = value;
            }
        }

        /// <summary>
        /// Obtient ou définit le format d'affichage de la valeur.
        /// </summary>
        /// <value>Le format d'affichage de la valeur. La valeur par défaut est "#,##0.###".</value>
        public string NumberFormat
        {
            get { return _numberFormat; }
            set
            {
                value.CheckArgumentNull("value");
                _numberFormat = value;
            }
        }

        /// <summary>
        /// Obtient ou définit l'unité la plus petite à utiliser.
        /// </summary>
        /// <value>L'unité la plus petite à utiliser. La valeur par défaut est ByteSizeUnit.Byte.</value>
        public ByteSizeUnit MinUnit
        {
            get { return _minUnit; }
            set
            {
                value.CheckArgumentInEnum("value");
                _minUnit = value;
                if (_maxUnit < _minUnit)
                    _maxUnit = _minUnit;
            }
        }

        /// <summary>
        /// Obtient ou définit l'unité la plus grande à utiliser.
        /// </summary>
        /// <value>L'unité la plus grande à utiliser. La valeur par défaut est ByteSizeUnit.ExaByte.</value>
        public ByteSizeUnit MaxUnit
        {
            get { return _maxUnit; }
            set
            {
                value.CheckArgumentInEnum("value");
                _maxUnit = value;
                if (_minUnit > _maxUnit)
                    _minUnit = _maxUnit;
            }
        }

        /// <summary>
        /// Obtient ou définit la règle d'arrondi à utiliser.
        /// </summary>
        /// <value>La règle d'arrondi à utiliser. La valeur par défaut est ByteSizeRounding.Closest (arrondi au plus proche).</value>
        public ByteSizeRounding RoundingRule
        {
            get { return _roundingRule; }
            set
            {
                value.CheckArgumentInEnum("value");
                _roundingRule = value;
            }
        }

        ///<summary>
        /// Obtient ou définit une valeur indiquant si les tailles inférieures à 1 Ko
        /// sont affichées avec le mot "octet" non abrégé.
        ///</summary>
        /// <value>true pour afficher le mot "octet" non abrégé pour les tailles inférieures à 1 Ko,
        /// false pour afficher l'abréviation. La valeur par défaut est true.</value>
        public bool UseFullWordForBytes { get; set; }

        #endregion

        /// <summary>
        /// Formate la taille spécifiée.
        /// </summary>
        /// <param name="size">La taille à formater</param>
        /// <returns>La taille formatée avec les options de ce ByteSizeFormatter</returns>
        public string Format(long size)
        {
            if (size < 0)
                throw new ArgumentOutOfRangeException(
                    "size",
                    string.Format(ExceptionMessages.NumberMustBePositiveOrZero, "size"));

            long[] multiples = _binaryMultiples;
            string[] prefixes = _decimalPrefixes;

            switch (Convention)
            {
                case ByteSizeConvention.Binary:
                    //case ByteSizeConvention.IEC:
                    multiples = _binaryMultiples;
                    prefixes = _binaryPrefixes;
                    break;
                case ByteSizeConvention.Decimal:
                    //case ByteSizeConvention.SI:
                    multiples = _decimalMultiples;
                    prefixes = _decimalPrefixes;
                    break;
                case ByteSizeConvention.Customary:
                    multiples = _binaryMultiples;
                    prefixes = _decimalPrefixes;
                    break;
            }

            int k = (int)MinUnit;
            for (int i = k; i <= (int)MaxUnit; i++)
            {
                if (size < multiples[i])
                    break;
                k = i;
            }

            string byteText = Resources.ResourceManager.GetString("ByteSymbol", Culture);
            if (UseFullWordForBytes && k == 0)
            {
                byteText = size > 1
                            ? Resources.ResourceManager.GetString("Bytes", Culture)
                            : Resources.ResourceManager.GetString("Byte", Culture);
            }
            decimal valueToDisplay = Round((decimal) size / multiples[k]);

            return string.Format(
                            "{0} {1}{2}",
                            valueToDisplay.ToString(NumberFormat, Culture),
                            prefixes[k],
                            byteText);
        }

        private decimal Round(decimal value)
        {
            if (RoundingRule == ByteSizeRounding.Closest)
                return Math.Round(value, DecimalPlaces);
            decimal factor = (decimal)Math.Pow(10, DecimalPlaces);
            Func<decimal, decimal> roundFunc = decimal.Ceiling;
            if (RoundingRule == ByteSizeRounding.Down)
                roundFunc = decimal.Floor;

            return roundFunc(value * factor) / factor;
        }
    }

    /// <summary>
    /// Définit la convention utilisée pour les unités de taille en octets.
    /// </summary>
    public enum ByteSizeConvention
    {
        /// <summary>
        /// Convention d'usage courant : multiples binaires (1024), préfixes décimaux (K/M/G...).
        /// </summary>
        Customary,
        /// <summary>
        /// Convention binaire : multiples binaires (1024), préfixes binaires (Ki/Mi/Gi...).
        /// Equivalent à IEC.
        /// </summary>
        Binary,
        /// <summary>
        /// Convention décimale : multiples décimaux (1000), préfixes décimaux (K/M/G...).
        /// Equivalent à SI.
        /// </summary>
        Decimal,
        /// <summary>
        /// Convention IEC 60027 : multiples binaires (1024), préfixes binaires (Ki/Mi/Gi...).
        /// Equivalent à Binary.
        /// </summary>
        IEC = Binary,
        /// <summary>
        /// Convention du système international : multiples décimaux (1000), préfixes décimaux (K/M/G...).
        /// Equivalent à Decimal.
        /// </summary>
        SI = Decimal
    }

    /// <summary>
    /// Définit les unités de taille en octets.
    /// </summary>
    public enum ByteSizeUnit
    {
        /// <summary>
        /// Octet
        /// </summary>
        Byte,
        /// <summary>
        /// kilooctet, ou kibioctet en convention binaire
        /// </summary>
        Kilobyte,
        /// <summary>
        /// mégaoctet, ou mébioctet en convention binaire
        /// </summary>
        Megabyte,
        /// <summary>
        /// gigaoctet, ou gibioctet en convention binaire
        /// </summary>
        Gigabyte,
        /// <summary>
        /// téraoctet, ou tébioctet en convention binaire
        /// </summary>
        Terabyte,
        /// <summary>
        /// pétaoctet, ou pébioctet en convention binaire
        /// </summary>
        Petabyte,
        /// <summary>
        /// exaoctet, ou exbioctet en convention binaire
        /// </summary>
        Exabyte
    }

    /// <summary>
    /// Définit les règles d'arrondi pour les tailles en octets.
    /// </summary>
    public enum ByteSizeRounding
    {
        /// <summary>
        /// Arrondi à la valeur la plus proche
        /// </summary>
        Closest,
        /// <summary>
        /// Arrondi à la valeur inférieure
        /// </summary>
        Down,
        /// <summary>
        /// Arrondi à la valeur supérieure
        /// </summary>
        Up
    }
}