using System;
using System.Text.RegularExpressions;
using Developpez.Dotnet.Properties;
using CH = Developpez.Dotnet.CompatibilityHelper;

namespace Developpez.Dotnet
{
    /// <summary>
    /// Un nombre en chiffres romains.
    /// </summary>
#if NETFX_CORE
    public struct Roman : IComparable, IComparable<Roman>, IEquatable<Roman>
#else
    public struct Roman : IComparable, IConvertible, IComparable<Roman>, IEquatable<Roman>
#endif
    {

        #region Private fields

        /// <summary>
        /// "M", "CM", "D", "CD", "C", "XC", "L", "XL", "X", "IX", "V", "IV", "I"
        /// </summary>
        private static readonly string[] _symbols;

        /// <summary>
        /// 1000, 900, 500, 400, 100, 90, 50, 40, 10, 9, 5, 4, 1
        /// </summary>
        private static readonly int[] _values;

        /// <summary>
        /// Expression régulière de validation d'un nombre romain.
        /// </summary>
        private static readonly Regex _standardPattern;

        /// <summary>
        /// Représente un nombre romain nul.
        /// </summary>
        private static readonly int _nullInnerValue;

        /// <summary>
        /// Représente le nombre romain le plus petit.
        /// </summary>
        private static readonly int _minInnerValue;

        /// <summary>
        /// Représente le nombre romain le plus grand.
        /// </summary>
        private static readonly int _maxInnerValue;

        /// <summary>
        /// La valeur interne du nombre romain.
        /// </summary>
        private readonly int _innerValue;

        #endregion



        #region Public fields

        /// <summary>
        /// Représente la valeur nulle 
        /// (cette valeur n'a aucun équivalent
        /// en chiffres romains).
        /// </summary>
        public static readonly Roman Null;

        /// <summary>
        /// Représente le nombre romain le plus petit.
        /// </summary>
        public static readonly Roman MinValue;

        /// <summary>
        /// Représente le nombre romain le plus grand.
        /// </summary>
        public static readonly Roman MaxValue;

        #endregion



        #region Constructors

        static Roman()
        {
            _nullInnerValue = 0;
            _minInnerValue = 1;
            _maxInnerValue = 4999;
            _standardPattern = new Regex("^(M{1,4})?(CM|CD|D?C{0,3})?(XC|XL|L?X{0,3})?(IX|IV|V?I{0,3})?$", CH.RegexOptions.Compiled | RegexOptions.CultureInvariant | RegexOptions.ExplicitCapture | RegexOptions.IgnoreCase | RegexOptions.Singleline);

            _symbols = new string[13] { "M", "CM", "D", "CD", "C", "XC", "L", "XL", "X", "IX", "V", "IV", "I" };
            _values = new int[13] { 1000, 900, 500, 400, 100, 90, 50, 40, 10, 9, 5, 4, 1 };

            Null = new Roman(_nullInnerValue);
            MinValue = new Roman(_minInnerValue);
            MaxValue = new Roman(_maxInnerValue);
        }


        /// <summary>
        /// Initialise une nouvelle instance de la structure <see cref="Roman"/>
        /// à partir d'un nombre entier.
        /// </summary>
        /// <param name="value">Entier.</param>
        public Roman(int value)
        {
            CheckValue(value);

            this._innerValue = value;
        }


        /// <summary>
        /// Initialise une nouvelle instance de la structure <see cref="Roman"/>
        /// à partir d'une chaîne de caractères.
        /// </summary>
        /// <param name="value">Chaîne de caractères.</param>
        public Roman(string value)
        {
            this._innerValue = ToInt(value);
        }

        #endregion



        #region Private static methods

        /// <summary>
        /// Vérifie si la valeur donnée respecte les spécifications d'un nombre romain.
        /// </summary>
        /// <param name="value">Valeur.</param>
        private static void CheckValue(int value)
        {
            CheckValue(value, true);
        }


        /// <summary>
        /// Vérifie si la valeur donnée respecte les spécifications d'un nombre romain.
        /// </summary>
        /// <param name="value">Valeur.</param>
        /// <param name="raiseException">Indique si la méthode doit lever une exception ou pas.</param>
        /// <returns>Vrai si la valeur donnée respecte les spécifications d'un nombre romain, faux sinon.</returns>
        private static bool CheckValue(int value, bool raiseException)
        {
            if (value == _nullInnerValue)
            {
                return true;
            }
            if (value < _minInnerValue)
            {
                if (raiseException)
                    throw new ArgumentOutOfRangeException("value", string.Format(ExceptionMessages.RomanMinValue, _minInnerValue));
                return false;
            }
            if (value > _maxInnerValue)
            {
                if (raiseException)
                    throw new ArgumentOutOfRangeException("value", string.Format(ExceptionMessages.RomanMaxValue, _maxInnerValue));
                return false;
            }

            return true;
        }


        /// <summary>
        /// Vérifie si la valeur donnée respecte les spécifications d'un nombre romain.
        /// </summary>
        /// <param name="value">Valeur.</param>
        private static void CheckValue(string value)
        {
            CheckValue(value, true);
        }


        /// <summary>
        /// Vérifie si la valeur donnée respecte les spécifications d'un nombre romain.
        /// </summary>
        /// <param name="value">Valeur.</param>
        /// <param name="raiseException">Indique si la méthode doit lever une exception ou pas.</param>
        /// <returns>Vrai si la valeur donnée respecte les spécifications d'un nombre romain, faux sinon.</returns>
        private static bool CheckValue(string value, bool raiseException)
        {
            if (string.IsNullOrEmpty(value))
            {
                return true;
                //if (raiseException)
                //    throw new ArgumentNullException("value");
                //else
                //    return false;
            }
            if (value.Length > 16)// Le chiffre romain le plus long ne dépasse pas 16 caractères : MMMMDCCCLXXXVIII (4888)
            {
                if (raiseException)
                    throw new ArgumentOutOfRangeException("value", string.Format(ExceptionMessages.RomanMaxValue, _maxInnerValue));
                return false;
            }
            if (!_standardPattern.Match(value).Success)
            {
                if (raiseException)
                    throw new FormatException(ExceptionMessages.BadInputStringFormat);
                return false;
            }

            return true;
        }


        /// <summary>
        /// Retourne un entier à partir d'une chaîne de caractères donnée représentant un nombre romain.
        /// </summary>
        /// <param name="value">Valeur.</param>
        /// <returns>L'entier correspondant à la chaîne de caractères.</returns>
        private static int ToInt(string value)
        {
            CheckValue(value);

            if (string.IsNullOrEmpty(value))
                return _nullInnerValue;

            int index = 0;
            int result = 0;

            for (int i = 0; i < _symbols.Length; i++)
            {
                while (value.Substring(index).StartsWith(_symbols[i], StringComparison.CurrentCultureIgnoreCase))
                {
                    result += _values[i];
                    index += _symbols[i].Length;
                }
            }

            if (index == value.Length)
                return result;
            throw new FormatException(ExceptionMessages.BadInputStringFormat);
        }


        /// <summary>
        /// Retourne une chaîne de caractères représentant un nombre romain à partir d'un entier donné.
        /// </summary>
        /// <param name="value">Valeur.</param>
        /// <returns>La chaîne de caractères représentant un nombre romain.</returns>
        private static string ToString(int value)
        {
            CheckValue(value);

            if (value == _nullInnerValue)
                return string.Empty;

            string result = string.Empty;
            int remainder = value;

            for (int i = 0; i < _values.Length; i++)
            {
                while (remainder >= _values[i])
                {
                    result += _symbols[i];
                    remainder -= _values[i];
                }
            }

            return result;
        }

        #endregion



        #region Public static methods

        /// <summary>
        /// Convertit la chaîne de caractères représentant un nombre romain en nombre romain.
        /// </summary>
        /// <param name="s">Chaîne de caractères représentant un nombre romain.</param>
        /// <returns>Le nombre romain correspondant à la chaîne de caractères.</returns>
        public static Roman Parse(string s)
        {
            return new Roman(s);
        }


        /// <summary>
        /// Convertit l'entier représentant un nombre romain en nombre romain.
        /// </summary>
        /// <param name="i">Entier représentant un nombre romain.</param>
        /// <returns>Le nombre romain correspondant à l'entier.</returns>
        public static Roman Parse(int i)
        {
            return new Roman(i);
        }


        /// <summary>
        /// Indique si la chaîne de caractères représente un nombre romain.
        /// Une valeur de retour renvoie ce nombre romain.
        /// </summary>
        /// <param name="s">Chaîne de caractères représentant un nombre romain.</param>
        /// <param name="result">Le nombre romain correspondant à la chaîne de caractères.</param>
        /// <returns>Vrai si la chaîne de caractères représente un nombre romain, faux sinon.</returns>
        public static bool TryParse(string s, out Roman result)
        {
            if (CheckValue(s, false))
            {
                result = new Roman(s);
                return true;
            }
            result = Null;
            return false;
        }


        /// <summary>
        /// Indique si l'entier représente un nombre romain.
        /// Une valeur de retour renvoie ce nombre romain.
        /// </summary>
        /// <param name="i">Entier représentant un nombre romain.</param>
        /// <param name="result">Le nombre romain correspondant à l'entier.</param>
        /// <returns>Vrai si l'entier représente un nombre romain, faux sinon.</returns>
        public static bool TryParse(int i, out Roman result)
        {
            if (CheckValue(i, false))
            {
                result = new Roman(i);
                return true;
            }
            result = Null;
            return false;
        }

        #endregion



        #region Public instance methods

        /// <summary>
        /// Retourne l'entier correspondant à l'instance de la structure <see cref="Roman"/>.
        /// </summary>
        /// <returns>L'entier correspondant à l'instance de la structure <see cref="Roman"/>.</returns>
        public int ToInt()
        {
            return this._innerValue;
        }

        #region Object Members

        /// <summary>
        /// Retourne le code de hachage de l'instance actuelle.
        /// </summary>
        /// <returns>le code de hachage de l'instance actuelle</returns>
        public override int GetHashCode()
        {
            return this.ToInt().GetHashCode();
        }

        /// <summary>
        /// Détermine si l'objet spécifié a la même valeur que l'instance actuelle.
        /// </summary>
        /// <param name="obj">objet à comparer</param>
        /// <returns>true si l'objet spécifié est égal à l'instance actuelle, false sinon</returns>
        public override bool Equals(object obj)
        {
            return this.ToInt().Equals(((Roman)obj).ToInt());
        }

        /// <summary>
        /// Retourne une représentation textuelle de l'instance actuelle
        /// </summary>
        /// <returns>une représentation textuelle de l'instance actuelle</returns>
        public override string ToString()
        {
            return ToString(this.ToInt());
        }

        #endregion

        #region IComparable Members

        /// <summary>
        /// Compare cette instance à l'objet spécifié et retourne une indication de leurs valeurs relatives
        /// </summary>
        /// <param name="value">objet à comparer</param>
        /// <returns>Nombre signé indiquant les valeurs relatives de cette instance et value
        /// <list type="table">
        /// <listheader>
        /// <term>Valeur de retour</term>
        /// <description>Description</description>
        /// </listheader>
        /// <item>
        /// <term>Inférieure à zéro </term>
        /// <description>Cette instance est inférieure à value.</description>
        /// </item>
        /// <item>
        /// <term>Zéro</term>
        /// <description>Cette instance est égale à value.</description>
        /// </item>
        /// <item>
        /// <term>Supérieure à zéro</term>
        /// <description>Cette instance est supérieure à value.</description>
        /// </item>
        /// </list>
        /// </returns>
        public int CompareTo(object value)
        {
            return this.ToInt().CompareTo(((Roman)value).ToInt());
        }

        #endregion

#if !NETFX_CORE
        #region IConvertible Members

        /// <summary>
        /// Retourne le TypeCode  du type Roman. 
        /// </summary>
        /// <returns>le TypeCode  du type Roman</returns>
        public TypeCode GetTypeCode()
        {
            return TypeCode.Int32;// Correct ?
        }

        /// <summary>
        /// Pour obtenir une description de ce membre, consultez <see cref="IConvertible.ToBoolean"/>
        /// </summary>
        /// <param name="provider">Implémentation de l'interface IFormatProvider  qui fournit des informations de mise en forme propres à la culture</param>
        /// <returns>true si la valeur de ce Roman est différente de 0, false sinon</returns>
        bool IConvertible.ToBoolean(IFormatProvider provider)
        {
            return Convert.ToBoolean(this.ToInt(), provider);
        }

        /// <summary>
        /// Pour obtenir une description de ce membre, consultez <see cref="IConvertible.ToByte"/>
        /// </summary>
        /// <param name="provider">Implémentation de l'interface IFormatProvider  qui fournit des informations de mise en forme propres à la culture</param>
        /// <returns>Valeur de l'instance actuelle, convertie en Byte</returns>
        byte IConvertible.ToByte(IFormatProvider provider)
        {
            return Convert.ToByte(this.ToInt(), provider);
        }

        /// <summary>
        /// Pour obtenir une description de ce membre, consultez <see cref="IConvertible.ToChar"/>
        /// </summary>
        /// <param name="provider">Implémentation de l'interface IFormatProvider  qui fournit des informations de mise en forme propres à la culture</param>
        /// <returns>Valeur de l'instance actuelle, convertie en Char</returns>
        char IConvertible.ToChar(IFormatProvider provider)
        {
            return Convert.ToChar(this.ToInt(), provider);
        }

        /// <summary>
        /// Pour obtenir une description de ce membre, consultez <see cref="IConvertible.ToDateTime"/>
        /// </summary>
        /// <param name="provider">Implémentation de l'interface IFormatProvider  qui fournit des informations de mise en forme propres à la culture</param>
        /// <returns>Valeur de l'instance actuelle, convertie en DateTime</returns>
        DateTime IConvertible.ToDateTime(IFormatProvider provider)
        {
            throw new InvalidCastException(string.Format(ExceptionMessages.InvalidCastFromTo, typeof(Roman).FullName, typeof(DateTime).FullName));
        }

        /// <summary>
        /// Pour obtenir une description de ce membre, consultez <see cref="IConvertible.ToDecimal"/>
        /// </summary>
        /// <param name="provider">Implémentation de l'interface IFormatProvider  qui fournit des informations de mise en forme propres à la culture</param>
        /// <returns>Valeur de l'instance actuelle, convertie en Decimal</returns>
        decimal IConvertible.ToDecimal(IFormatProvider provider)
        {
            return Convert.ToDecimal(this.ToInt());
        }

        /// <summary>
        /// Pour obtenir une description de ce membre, consultez <see cref="IConvertible.ToDouble"/>
        /// </summary>
        /// <param name="provider">Implémentation de l'interface IFormatProvider  qui fournit des informations de mise en forme propres à la culture</param>
        /// <returns>Valeur de l'instance actuelle, convertie en Double</returns>
        double IConvertible.ToDouble(IFormatProvider provider)
        {
            return Convert.ToDouble(this.ToInt());
        }

        /// <summary>
        /// Pour obtenir une description de ce membre, consultez <see cref="IConvertible.ToInt16"/>
        /// </summary>
        /// <param name="provider">Implémentation de l'interface IFormatProvider  qui fournit des informations de mise en forme propres à la culture</param>
        /// <returns>Valeur de l'instance actuelle, convertie en Int16</returns>
        short IConvertible.ToInt16(IFormatProvider provider)
        {
            return Convert.ToInt16(this.ToInt());
        }

        /// <summary>
        /// Pour obtenir une description de ce membre, consultez <see cref="IConvertible.ToInt32"/>
        /// </summary>
        /// <param name="provider">Implémentation de l'interface IFormatProvider  qui fournit des informations de mise en forme propres à la culture</param>
        /// <returns>Valeur de l'instance actuelle, convertie en Int32</returns>
        int IConvertible.ToInt32(IFormatProvider provider)
        {
            return this.ToInt();
        }

        /// <summary>
        /// Pour obtenir une description de ce membre, consultez <see cref="IConvertible.ToInt64"/>
        /// </summary>
        /// <param name="provider">Implémentation de l'interface IFormatProvider  qui fournit des informations de mise en forme propres à la culture</param>
        /// <returns>Valeur de l'instance actuelle, convertie en Int64</returns>
        long IConvertible.ToInt64(IFormatProvider provider)
        {
            return Convert.ToInt64(this.ToInt());
        }

        /// <summary>
        /// Pour obtenir une description de ce membre, consultez <see cref="IConvertible.ToSByte"/>
        /// </summary>
        /// <param name="provider">Implémentation de l'interface IFormatProvider  qui fournit des informations de mise en forme propres à la culture</param>
        /// <returns>Valeur de l'instance actuelle, convertie en SByte</returns>
        sbyte IConvertible.ToSByte(IFormatProvider provider)
        {
            return Convert.ToSByte(this.ToInt());
        }

        /// <summary>
        /// Pour obtenir une description de ce membre, consultez <see cref="IConvertible.ToSingle"/>
        /// </summary>
        /// <param name="provider">Implémentation de l'interface IFormatProvider  qui fournit des informations de mise en forme propres à la culture</param>
        /// <returns>Valeur de l'instance actuelle, convertie en Single</returns>
        float IConvertible.ToSingle(IFormatProvider provider)
        {
            return Convert.ToSingle(this.ToInt());
        }

        /// <summary>
        /// Pour obtenir une description de ce membre, consultez <see cref="IConvertible.ToString(IFormatProvider)"/>
        /// </summary>
        /// <param name="provider">Implémentation de l'interface IFormatProvider  qui fournit des informations de mise en forme propres à la culture</param>
        /// <returns>Valeur de l'instance actuelle, convertie en String</returns>
        string IConvertible.ToString(IFormatProvider provider)
        {
            return Convert.ToString(this.ToString(), provider);
        }

        /// <summary>
        /// Pour obtenir une description de ce membre, consultez <see cref="IConvertible.ToType"/>
        /// </summary>
        /// <param name="conversionType">Type dans lequel convertir cette valeur Roman.</param>
        /// <param name="provider">Implémentation de l'interface IFormatProvider  qui fournit des informations de mise en forme propres à la culture</param>
        /// <returns>Valeur de l'instance actuelle, convertie vers le type spécifié</returns>
        object IConvertible.ToType(Type conversionType, IFormatProvider provider)
        {
            return Convert.ChangeType(this.ToInt(), conversionType, provider);
        }

        /// <summary>
        /// Pour obtenir une description de ce membre, consultez <see cref="IConvertible.ToUInt16"/>
        /// </summary>
        /// <param name="provider">Implémentation de l'interface IFormatProvider  qui fournit des informations de mise en forme propres à la culture</param>
        /// <returns>Valeur de l'instance actuelle, convertie en UInt16</returns>
        ushort IConvertible.ToUInt16(IFormatProvider provider)
        {
            return Convert.ToUInt16(this.ToInt());
        }

        /// <summary>
        /// Pour obtenir une description de ce membre, consultez <see cref="IConvertible.ToUInt32"/>
        /// </summary>
        /// <param name="provider">Implémentation de l'interface IFormatProvider  qui fournit des informations de mise en forme propres à la culture</param>
        /// <returns>Valeur de l'instance actuelle, convertie en UInt32</returns>
        uint IConvertible.ToUInt32(IFormatProvider provider)
        {
            return Convert.ToUInt32(this.ToInt());
        }

        /// <summary>
        /// Pour obtenir une description de ce membre, consultez <see cref="IConvertible.ToUInt64"/>
        /// </summary>
        /// <param name="provider">Implémentation de l'interface IFormatProvider  qui fournit des informations de mise en forme propres à la culture</param>
        /// <returns>Valeur de l'instance actuelle, convertie en UInt64</returns>
        ulong IConvertible.ToUInt64(IFormatProvider provider)
        {
            return Convert.ToUInt64(this.ToInt());
        }

        #endregion
#endif

        #region IComparable<Roman> Members

        /// <summary>
        /// Compare cette instance au Roman spécifié et retourne une indication de leurs valeurs relatives
        /// </summary>
        /// <param name="other">objet à comparer</param>
        /// <returns>Nombre signé indiquant les valeurs relatives de cette instance et other
        /// <list type="table">
        /// <listheader>
        /// <term>Valeur de retour</term>
        /// <description>Description</description>
        /// </listheader>
        /// <item>
        /// <term>Inférieure à zéro </term>
        /// <description>Cette instance est inférieure à other.</description>
        /// </item>
        /// <item>
        /// <term>Zéro</term>
        /// <description>Cette instance est égale à other.</description>
        /// </item>
        /// <item>
        /// <term>Supérieure à zéro</term>
        /// <description>Cette instance est supérieure à other.</description>
        /// </item>
        /// </list>
        /// </returns>
        public int CompareTo(Roman other)
        {
            return this.ToInt().CompareTo(other.ToInt());
        }

        #endregion

        #region IEquatable<Roman> Members

        /// <summary>
        /// Retourne une valeur indiquant si cette instance équivaut à une valeur Roman spécifiée.
        /// </summary>
        /// <param name="other">Valeur Int32  à comparer à cette instance.</param>
        /// <returns>true si other possède la même valeur que cette instance ; sinon, false. </returns>
        public bool Equals(Roman other)
        {
            return (this.CompareTo(other) == 0);
        }

        #endregion

        #endregion



        #region Operators

        /// <summary>
        /// Additionne deux nombres romains.
        /// </summary>
        /// <param name="r1">Nombre romain.</param>
        /// <param name="r2">Nombre romain.</param>
        /// <returns>Un nombre romain dont la valeur est la somme de r1 et r2.</returns>
        public static Roman operator +(Roman r1, Roman r2)
        {
            return new Roman(r1.ToInt() + r2.ToInt());
        }


        /// <summary>
        /// Incrémente un nombre romain de un.
        /// </summary>
        /// <param name="r">Nombre romain.</param>
        /// <returns>Le nombre romain incrémenté de un.</returns>
        public static Roman operator ++(Roman r)
        {
            return new Roman(r.ToInt() + 1);
        }


        /// <summary>
        /// Soustrait un nombre romain d'un autre nombre romain
        /// pour donner un troisième nombre romain.
        /// </summary>
        /// <param name="r1">Nombre romain.</param>
        /// <param name="r2">Nombre romain.</param>
        /// <returns>Un nombre romain dont la valeur est la différence de r1 par rapport à r2.</returns>
        public static Roman operator -(Roman r1, Roman r2)
        {
            return new Roman(r1.ToInt() - r2.ToInt());
        }


        /// <summary>
        /// Décrémente un nombre romain de un.
        /// </summary>
        /// <param name="r">Nombre romain.</param>
        /// <returns>Le nombre romain décrémenté de un.</returns>
        public static Roman operator --(Roman r)
        {
            return new Roman(r.ToInt() - 1);
        }


        /// <summary>
        /// Retourne le reste d'une division d'un nombre romain par un autre nombre romain.
        /// </summary>
        /// <param name="r1">Nombre romain.</param>
        /// <param name="r2">Nombre romain.</param>
        /// <returns>Un nombre romain dont la valeur est le modulo de r1 par rapport à r2.</returns>
        public static Roman operator %(Roman r1, Roman r2)
        {
            return new Roman(r1.ToInt() % r2.ToInt());
        }


        /// <summary>
        /// Multiplie deux nombres romains
        /// pour donner un troisième nombre romain.
        /// </summary>
        /// <param name="r1">Nombre romain.</param>
        /// <param name="r2">Nombre romain.</param>
        /// <returns>Un nombre romain dont la valeur est le produit de r1 et r2.</returns>
        public static Roman operator *(Roman r1, Roman r2)
        {
            return new Roman(r1.ToInt() * r2.ToInt());
        }


        /// <summary>
        /// Divise un nombre romain par un autre nombre romain
        /// pour donner un troisième nombre romain (partie entière du quotient).
        /// </summary>
        /// <param name="r1">Nombre romain.</param>
        /// <param name="r2">Nombre romain.</param>
        /// <returns>Un nombre romain dont la valeur est la partie entière du quotient de r1 par rapport à r2.</returns>
        public static Roman operator /(Roman r1, Roman r2)
        {
            return new Roman(r1.ToInt() / r2.ToInt());
        }


        /// <summary>
        /// Indique si les deux nombre romains donnés sont égaux.
        /// </summary>
        /// <param name="r1">Nombre romain.</param>
        /// <param name="r2">Nombre romain.</param>
        /// <returns>Vrai si les deux nombre romains donnés sont égaux, faux sinon.</returns>
        public static bool operator ==(Roman r1, Roman r2)
        {
            return (r1.ToInt().CompareTo(r2.ToInt()) == 0);
        }


        /// <summary>
        /// Indique si r1 est strictement supérieur à r2.
        /// </summary>
        /// <param name="r1">Nombre romain.</param>
        /// <param name="r2">Nombre romain.</param>
        /// <returns>Vrai si r1 est strictement supérieur à r2, faux sinon.</returns>
        public static bool operator >(Roman r1, Roman r2)
        {
            return (r1.ToInt().CompareTo(r2.ToInt()) > 0);
        }


        /// <summary>
        /// Indique si r1 est supérieur ou égal à r2.
        /// </summary>
        /// <param name="r1">Nombre romain.</param>
        /// <param name="r2">Nombre romain.</param>
        /// <returns>Vrai si r1 est supérieur ou égal à r2, faux sinon.</returns>
        public static bool operator >=(Roman r1, Roman r2)
        {
            return (r1.ToInt().CompareTo(r2.ToInt()) >= 0);
        }


        /// <summary>
        /// Indique si r1 est différent de r2.
        /// </summary>
        /// <param name="r1">Nombre romain.</param>
        /// <param name="r2">Nombre romain.</param>
        /// <returns>Vrai si r1 est différent de r2, faux sinon.</returns>
        public static bool operator !=(Roman r1, Roman r2)
        {
            return (r1.ToInt().CompareTo(r2.ToInt()) != 0);
        }


        /// <summary>
        /// Indique si r1 est strictement inférieur à r2.
        /// </summary>
        /// <param name="r1">Nombre romain.</param>
        /// <param name="r2">Nombre romain.</param>
        /// <returns>Vrai si r1 est strictement inférieur à r2, faux sinon.</returns>
        public static bool operator <(Roman r1, Roman r2)
        {
            return (r1.ToInt().CompareTo(r2.ToInt()) < 0);
        }


        /// <summary>
        /// Indique si r1 est inférieur ou égal à r2.
        /// </summary>
        /// <param name="r1">Nombre romain.</param>
        /// <param name="r2">Nombre romain.</param>
        /// <returns>Vrai si r1 est inférieur ou égal à r2, faux sinon.</returns>
        public static bool operator <=(Roman r1, Roman r2)
        {
            return (r1.ToInt().CompareTo(r2.ToInt()) <= 0);
        }

        #endregion



        #region Implicit conversions

        /// <summary>
        /// Convertit un nombre romain en entier.
        /// </summary>
        /// <param name="r">Nombre romain.</param>
        /// <returns>L'entier correspondant au nombre romain.</returns>
        public static explicit operator int(Roman r)
        {
            return r.ToInt();
        }

        /// <summary>
        /// Convertit un entier en nombre romain.
        /// </summary>
        /// <param name="i">Entier.</param>
        /// <returns>Le nombre romain correspondant à l'entier.</returns>
        public static explicit operator Roman(int i)
        {
            return new Roman(i);
        }


        /// <summary>
        /// Convertit un nombre romain en entier 16 bits.
        /// </summary>
        /// <param name="r">Nombre romain.</param>
        /// <returns>L'entier 16 bits correspondant au nombre romain.</returns>
        public static explicit operator short(Roman r)
        {
            return (short)r.ToInt();
        }

        /// <summary>
        /// Convertit un entier en nombre romain.
        /// </summary>
        /// <param name="i">Entier 16 bits.</param>
        /// <returns>Le nombre romain correspondant à l'entier 16 bits.</returns>
        public static explicit operator Roman(short i)
        {
            return new Roman(i);
        }


        /// <summary>
        /// Convertit un nombre romain en entier 64 bits.
        /// </summary>
        /// <param name="r">Nombre romain.</param>
        /// <returns>L'entier 64 bits correspondant au nombre romain.</returns>
        public static explicit operator long(Roman r)
        {
            return r.ToInt();
        }

        /// <summary>
        /// Convertit un entier 64 bits en nombre romain.
        /// </summary>
        /// <param name="i">Entier 64 bits.</param>
        /// <returns>Le nombre romain correspondant à l'entier 64 bits.</returns>
        public static explicit operator Roman(long i)
        {
            return new Roman((int)i);
        }

        #endregion

    }
}