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

namespace Developpez.Dotnet.Tests
{
    [TestFixture]
    public class EnumExtensionTests
    {
        [Flags]
        private enum FlagsEnum
        {
            Valeur1 = 1,
            Valeur2 = 2,
            Valeur3 = 4,
            Valeur4 = 8,
            Valeurs1Et2 = Valeur1 | Valeur2
        }

        private enum NoFlagsEnum
        {
            [System.ComponentModel.Description("Un")]
            Valeur1,
            [System.ComponentModel.Description("Deux")]
            Valeur2,
            [System.ComponentModel.Description("Trois")]
            Valeur3,
            [System.ComponentModel.Description("Quatre")]
            Valeur4,
            Valeur5
        }

        [Test(Description = "Vérifie qu'une exception est levée si le type n'est pas un Enum")]
        public void Test_NotEnum()
        {
            int x = 42;
            Assert.Throws<ArgumentException>(
                () => x.GetDescription());
        }

        [Test(Description = "Vérifie qu'une exception est levée si l'enum n'a pas l'attribut Flags")]
        public void Test_NoFlagsEnum()
        {
            NoFlagsEnum x = NoFlagsEnum.Valeur1;
            NoFlagsEnum y = NoFlagsEnum.Valeur2;

            NoFlagsEnum z = default(NoFlagsEnum);
            Assert.Throws<ArgumentException>(
                () => z = x.SetFlags(y));
        }

        [Test(Description = "Vérifie la méthode HasFlag")]
        public void Test_HasFlag()
        {
            FlagsEnum x = FlagsEnum.Valeur1 | FlagsEnum.Valeur2;
            Assert.IsTrue(x.HasFlag(FlagsEnum.Valeur2));
            Assert.IsFalse(x.HasFlag(FlagsEnum.Valeur3));
        }

        [Test(Description = "Vérifie les méthodes SetFlags et ClearFlags")]
        public void Test_SetFlags()
        {
            FlagsEnum x = FlagsEnum.Valeur1.SetFlags(FlagsEnum.Valeur2);
            FlagsEnum y = FlagsEnum.Valeur4.SetFlags(x).ClearFlags(FlagsEnum.Valeur1);

            Assert.IsTrue(x.HasFlag(FlagsEnum.Valeur2));
            Assert.IsFalse(x.HasFlag(FlagsEnum.Valeur3));
            Assert.IsTrue(y.HasFlag(FlagsEnum.Valeur2 | FlagsEnum.Valeur4));
            Assert.IsFalse(y.HasFlag(FlagsEnum.Valeur1 | FlagsEnum.Valeur3));
        }

        [Test(Description = "Vérifie la méthode GetFlags")]
        public void Test_GetFlags()
        {
            FlagsEnum x = FlagsEnum.Valeur1 | FlagsEnum.Valeur2 | FlagsEnum.Valeur4;

            var lst = x.GetFlags();
            Assert.IsTrue(lst.Contains(FlagsEnum.Valeur1));
            Assert.IsTrue(lst.Contains(FlagsEnum.Valeur2));
            Assert.IsFalse(lst.Contains(FlagsEnum.Valeur3));
            Assert.IsTrue(lst.Contains(FlagsEnum.Valeur4));
            Assert.IsFalse(lst.Contains(FlagsEnum.Valeurs1Et2));

            lst = x.GetFlags(false);
            Assert.IsTrue(lst.Contains(FlagsEnum.Valeur1));
            Assert.IsTrue(lst.Contains(FlagsEnum.Valeur2));
            Assert.IsFalse(lst.Contains(FlagsEnum.Valeur3));
            Assert.IsTrue(lst.Contains(FlagsEnum.Valeur4));
            Assert.IsTrue(lst.Contains(FlagsEnum.Valeurs1Et2));
        }

        [Test(Description = "Vérifie la méthode CombineFlags")]
        public void Test_CombineFlags()
        {
            IEnumerable<FlagsEnum> lst = new FlagsEnum[] { FlagsEnum.Valeur1, FlagsEnum.Valeur2, FlagsEnum.Valeur4 };
            FlagsEnum x = lst.CombineFlags();
            Assert.IsTrue(x.HasFlag(FlagsEnum.Valeur1));
            Assert.IsTrue(x.HasFlag(FlagsEnum.Valeur2));
            Assert.IsFalse(x.HasFlag(FlagsEnum.Valeur3));
            Assert.IsTrue(x.HasFlag(FlagsEnum.Valeur4));
        }

        [Test(Description = "Vérifie la méthode GetDescription")]
        public void Test_GetDescription()
        {
            Assert.AreEqual("Un", NoFlagsEnum.Valeur1.GetDescription());
            Assert.AreEqual("Deux", NoFlagsEnum.Valeur2.GetDescription());
            Assert.AreEqual("Trois", NoFlagsEnum.Valeur3.GetDescription());
            Assert.AreEqual("Quatre", NoFlagsEnum.Valeur4.GetDescription());
            Assert.AreEqual(null, NoFlagsEnum.Valeur5.GetDescription());
            Assert.AreEqual(null, ((NoFlagsEnum)42).GetDescription());
        }

        [Test]
        public void Test_ToEnum_String()
        {
            string input = "Valeur3";
            NoFlagsEnum expected = NoFlagsEnum.Valeur3;
            NoFlagsEnum actual = input.ToEnum<NoFlagsEnum>();
            Assert.AreEqual(expected, actual);

            input = "valeur3";
            actual = input.ToEnum<NoFlagsEnum>(true);
            Assert.AreEqual(expected, actual);

            Assert.Throws<ArgumentException>(
                () => input.ToEnum<NoFlagsEnum>(false));
        }

        [Test]
        public void Test_ToEnum()
        {
            int i = 4;
            FlagsEnum expected = FlagsEnum.Valeur3;
            FlagsEnum actual = i.ToEnum<FlagsEnum>();
            Assert.AreEqual(expected, actual);
        }
    }
}