using System;
using System.Collections;
using System.Collections.Generic;
using System.Linq;
using NUnit.Framework;

namespace Developpez.Dotnet.Tests
{
    [TestFixture]
    public class RomanTests
    {

        #region Entiers

        [Test]
        public void MinIntLimit()
        {
            var ex = Assert.Throws<ArgumentOutOfRangeException>(() => new Roman(-1));
            Assert.AreEqual("value", ex.ParamName);
        }

        [Test]
        public void MaxIntLimit()
        {
            var ex = Assert.Throws<ArgumentOutOfRangeException>(() => new Roman(5000));
            Assert.AreEqual("value", ex.ParamName);
        }

        [Test]
        public void MinValueField()
        {
            Assert.AreEqual(1, Roman.MinValue.ToInt(), "La valeur la plus petite d'un nombre romain doit être 1.");
            Assert.AreEqual("I", Roman.MinValue.ToString(), "La valeur la plus petite d'un nombre romain doit être représentée par 'I'.");
        }
        [Test]
        public void MaxValueField()
        {
            Assert.AreEqual(4999, Roman.MaxValue.ToInt(), "La valeur la plus grande d'un chiffre romain doit être 4999.");
            Assert.AreEqual("MMMMCMXCIX", Roman.MaxValue.ToString(), "La valeur la plus grande d'un nombre romain doit être représentée par 'MMMMCMXCIX'.");
        }
        [Test]
        public void ParseInt()
        {
            Assert.AreEqual(new Roman(4999), Roman.Parse(4999));
        }
        [Test]
        public void IntValues()
        {
            Roman r;
            for (int i = 1; i < 4999; i++)
            {
                r = new Roman(i);
                Assert.AreEqual(i, r.ToInt());
            }
        }

        [Test]
        public void TryParse_When_String_null()
        {
            Roman test;
            Roman.TryParse(null, out test);
            Assert.AreEqual(Roman.Null, test);
        }

        [Test]
        public void TryParse_When_String_too_long()
        {
            Roman test;
            Roman.TryParse("MMMMMMMDCCCLXXXVIIII", out test);
            Assert.AreEqual(Roman.Null, test);
        }

        [Test]
        public void TryParse_When_String_not_valid()
        {
            Roman test;
            Roman.TryParse("NOTVALID", out test);
            Assert.AreEqual(Roman.Null, test);
            Roman.TryParse("IIIII", out test);
            Assert.AreEqual(Roman.Null, test);
            Roman.TryParse("VIVIVI", out test);
            Assert.AreEqual(Roman.Null, test);
        }

        [Test]
        public void TryParse_When_String_valid()
        {
            Roman test;
            Roman.TryParse("I", out test);
            Assert.AreEqual(1, test.ToInt());
            Roman.TryParse("III", out test);
            Assert.AreEqual(3, test.ToInt());
            Roman.TryParse("XIV", out test);
            Assert.AreEqual(14, test.ToInt());
        }

        [Test]
        public void TryParse_When_Int_Over_Max()
        {
            Roman test;
            Roman.TryParse(5000, out test);
            Assert.AreEqual(Roman.Null, test);
        }

        [Test]
        public void TryParse_When_Int_Under_Min()
        {
            Roman test;
            Roman.TryParse(-1, out test);
            Assert.AreEqual(Roman.Null, test);
        }

        [Test]
        public void TryParse_When_Int_Valid_Values()
        {
            Roman test;
            Roman.TryParse(1, out test);
            Assert.AreEqual(1, test.ToInt());
            Roman.TryParse(500, out test);
            Assert.AreEqual(500, test.ToInt());
        }

        [Test]
        public void CompareTo_Unboxed()
        {
            Roman sup = new Roman(500);
            Roman min = new Roman(2);

            Assert.IsTrue(sup > min);
        }

        [Test]
        public void CompareTo_Boxed()
        {
            Roman sup = new Roman(500);
            Object min = new Roman(2);

            ArrayList tmp = new ArrayList();
            tmp.Add(sup);
            tmp.Add(min);
            tmp.Sort();

            Assert.IsTrue(tmp[0] == min);
        }

        [Test]
        public void CompareTo_Strongly_Typed()
        {
            Roman sup = new Roman(500);
            Roman min = new Roman(2);

            List<Roman> tmp = new List<Roman>();
            tmp.Add(sup);
            tmp.Add(min);
            tmp.Sort();

            Assert.IsTrue(tmp[0] == min);
        }

        #endregion



        #region Chaînes de caractères

        [Test]
        public void StringNullException()
        {
            Roman r = new Roman(null);
            Assert.AreEqual(r, Roman.Null);
        }

        [Test]
        public void StringEmptyException()
        {
            Roman r = new Roman(string.Empty);
            Assert.AreEqual(r, Roman.Null);
        }

        [Test]
        public void StringTooLongException()
        {
            var ex = Assert.Throws<ArgumentOutOfRangeException>(() => new Roman("MMMMMDCCCLXXXVIII"));
            Assert.AreEqual("value", ex.ParamName);
        }
        [Test]
        public void FormatException()
        {
            Assert.Throws<FormatException>(
                () => new Roman("TOTO"));
        }
        [Test]
        public void IgnoreCase()
        {
            new Roman("mmmmdccclxxxviii");
        }

        [Test]
        public void ParseString()
        {
            Assert.AreEqual(new Roman("MMMMDCCCLXXXVIII"), Roman.Parse("MMMMDCCCLXXXVIII"));
        }
        [Test]
        public void StringValues()
        {
            string[] strings =
            {
                "","I","II","III","IV","V","VI","VII","VIII","IX",
                "X","XI","XII","XIII","XIV","XV","XVI","XVII","XVIII","XIX",
                "XX","XXI","XXII","XXIII","XXIV","XXV","XXVI","XXVII","XXVIII","XXIX",
                "XXX","XXXI","XXXII","XXXIII","XXXIV","XXXV","XXXVI","XXXVII","XXXVIII","XXXIX",
                "XL","XLI","XLII","XLIII","XLIV","XLV","XLVI","XLVII","XLVIII","XLIX",
                "L","LI","LII","LIII","LIV","LV","LVI","LVII","LVIII","LIX",
                "LX","LXI","LXII","LXIII","LXIV","LXV","LXVI","LXVII","LXVIII","LXIX",
                "LXX","LXXI","LXXII","LXXIII","LXXIV","LXXV","LXXVI","LXXVII","LXXVIII","LXXIX",
                "LXXX","LXXXI","LXXXII","LXXXIII","LXXXIV","LXXXV","LXXXVI","LXXXVII","LXXXVIII","LXXXIX",
                "XC","XCI","XCII","XCIII","XCIV","XCV","XCVI","XCVII","XCVIII","XCIX",
                "C","CI","CII","CIII","CIV","CV","CVI","CVII","CVIII","CIX"
            };
            for (int i = 0; i < strings.Length; i++)
            {
                Roman r = new Roman(strings[i]);
                Assert.AreEqual(strings[i], r.ToString());
            }
        }

        #endregion



        #region Opérateurs

        [Test]
        public void ExplicitFromRomanToIntConversion()
        {
            int i = 12;
            Roman r = new Roman(i);
            int j = (int)r;
            Assert.AreEqual(i, j);
        }
        [Test]
        public void ExplicitFromIntToRomanConversion()
        {
            int i = 12;
            Roman r = (Roman)i;
            Assert.AreEqual(i, r.ToInt());
        }
        [Test]
        public void ExplicitFromRomanToShortConversion()
        {
            short i = 12;
            Roman r = new Roman(i);
            short j = (short)r;
            Assert.AreEqual(i, j);
        }
        [Test]
        public void ExplicitFromShortToRomanConversion()
        {
            short i = 12;
            Roman r = (Roman)i;
            Assert.AreEqual(i, (short)r.ToInt());
        }
        [Test]
        public void ExplicitFromRomanToLongConversion()
        {
            long i = 12;
            Roman r = new Roman((int)i);
            long j = (long)r;
            Assert.AreEqual(i, j);
        }
        [Test]
        public void ExplicitFromLongToRomanConversion()
        {
            long i = 12;
            Roman r = (Roman)i;
            Assert.AreEqual(i, r.ToInt());
        }
        [Test]
        public void Roman_Number_Addition()
        {
            Roman one = new Roman(1);
            Roman two = new Roman(2);
            Assert.AreEqual(3, (one + two).ToInt());
        }
        [Test]
        public void Roman_Number_Substraction()
        {
            Roman one = new Roman(1);
            Roman two = new Roman(2);
            Assert.AreEqual(1, (two - one).ToInt());
        }

        [Test]
        public void Roman_Number_Increment()
        {
            Roman test = new Roman(1);
            Roman two = new Roman(2);
            test++;
            Assert.AreEqual(two, test);
        }

        [Test]
        public void Roman_Number_Decrement()
        {
            Roman one = new Roman(1);
            Roman test = new Roman(2);
            test--;
            Assert.AreEqual(one, test);
        }

        [Test]
        public void Roman_Number_Divide()
        {
            Roman four = new Roman(4);
            Roman two = new Roman(2);
            Assert.AreEqual(two, four / two);
        }

        [Test]
        public void Roman_Number_Multiply()
        {
            Roman four = new Roman(4);
            Roman two = new Roman(2);
            Roman one = new Roman(1);
            Assert.AreEqual(four, two * two);
            Assert.AreEqual(two, one * two);
        }
        
        [Test]
        public void Roman_Number_Modulus()
        {
            Roman three = new Roman(3);
            Roman two = new Roman(2);
            Roman one = new Roman(1);
            // no zero...

            Assert.AreEqual(Roman.Null, two % two);

            Assert.AreEqual(one, three % two);
        }

        [Test]
        public void Roman_Number_GreaterThan()
        {
            Roman four = new Roman(4);
            Roman two = new Roman(2);
            Assert.IsTrue(four > two);
            Assert.IsFalse(two > four);
        }

        [Test]
        public void Roman_Number_GreaterThanOrEqual()
        {
            Roman four = new Roman(4);
            Roman two = new Roman(2);
            Assert.IsTrue(four >= two);
#pragma warning disable 1718
// ReSharper disable EqualExpressionComparison
            Assert.IsTrue(four >= four);
// ReSharper restore EqualExpressionComparison
#pragma warning restore 1718
            Assert.IsFalse(two >= four);
        }

        [Test]
        public void Roman_Number_LesserThanOrEqual()
        {
            Roman four = new Roman(4);
            Roman two = new Roman(2);
            Assert.IsFalse(four <= two);
            Assert.IsTrue(two <= four);
#pragma warning disable 1718
// ReSharper disable EqualExpressionComparison
            Assert.IsTrue(four <= four);
            Assert.IsTrue(two <= two);
// ReSharper restore EqualExpressionComparison
#pragma warning restore 1718
        }

        [Test]
        public void Roman_Number_LesserThan()
        {
            Roman four = new Roman(4);
            Roman two = new Roman(2);
            Assert.IsTrue(two < four);
            Assert.IsFalse(four < two);
#pragma warning disable 1718
// ReSharper disable EqualExpressionComparison
            Assert.IsFalse(four < four);
            Assert.IsFalse(two < two);
// ReSharper restore EqualExpressionComparison
#pragma warning restore 1718
        }

        [Test]
        public void Roman_Number_Inequality()
        {
            Roman four = new Roman(4);
            Roman two = new Roman(2);
            Roman twoTest = new Roman(2);
            Assert.IsTrue(two != four);
            Assert.IsFalse(two != twoTest);
        }

        [Test]
        public void Roman_Two_Romans_Are_Equal_IComparable()
        {
            Roman test = new Roman(2);
            Roman two = new Roman(2);
            Assert.AreEqual(test, two);
        }
        [Test]
        public void Roman_Two_Romans_Are_Equal_IComparableGeneric()
        {
            Roman[] testList = { new Roman(1), new Roman(2) };
            Roman[] testList2 = { new Roman(2), new Roman(3) };
            List<Roman> result = testList.Intersect(testList2).ToList();

            Assert.AreEqual(result.Count, 1);
        }

        #endregion

    }
}