using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using NUnit.Framework;
using Developpez.Dotnet;
using System.Collections;
using Developpez.Dotnet.Reflection;

namespace Developpez.Dotnet.Tests.Reflection
{
    [TestFixture]
    public class ReflectionExtensionsTests
    {
        [Test]
        public void Test_Is()
        {
            Assert.IsTrue(typeof(string).Is<object>());
            Assert.IsFalse(typeof(object).Is<string>());
            
            Assert.IsTrue(typeof(int).Is<ValueType>());
            Assert.IsFalse(typeof(int).Is<long>());

            Assert.IsTrue(typeof(string).Is<IEnumerable<char>>());
            Assert.IsTrue(typeof(string).Is<IEnumerable>());
            Assert.IsTrue(typeof(int).Is<IComparable>());

            Assert.IsTrue(typeof(IEnumerable<string>).Is<IEnumerable>());
            Assert.IsFalse(typeof(IEnumerable).Is<IEnumerable<string>>());

            Assert.IsTrue(typeof(EventHandler).Is<Delegate>());
            Assert.IsTrue(typeof(EventHandler).Is<MulticastDelegate>());
        }

        #region Classes de test pour les attributs

        [AttributeUsage(AttributeTargets.All, Inherited = false, AllowMultiple = false)]
        class XAttribute : Attribute { }

        [AttributeUsage(AttributeTargets.All, Inherited = true, AllowMultiple = false)]
        class YAttribute : Attribute { }

        [X, Y]
        class A { }

        class B : A { }

        #endregion

        [Test]
        public void Test_HasAttribute()
        {
            Assert.IsTrue(typeof(A).HasAttribute<XAttribute>());
            Assert.IsTrue(typeof(A).HasAttribute(typeof(XAttribute)));
            Assert.IsFalse(typeof(B).HasAttribute<XAttribute>());
            Assert.IsFalse(typeof(B).HasAttribute(typeof(XAttribute)));

            Assert.IsTrue(typeof(B).HasAttribute<YAttribute>(true));
            Assert.IsTrue(typeof(B).HasAttribute(typeof(YAttribute), true));
            Assert.IsFalse(typeof(B).HasAttribute<YAttribute>(false));
            Assert.IsFalse(typeof(B).HasAttribute(typeof(YAttribute), false));
        }

        [Test]
        public void Test_GetAttribute()
        {
            XAttribute ax1 = typeof(A).GetAttribute<XAttribute>();
            Attribute ax2 = typeof(A).GetAttribute(typeof(XAttribute));

            Assert.IsNotNull(ax1);
            Assert.IsNotNull(ax2);

            XAttribute bx1 = typeof(B).GetAttribute<XAttribute>();
            Attribute bx2 = typeof(B).GetAttribute(typeof(XAttribute));

            Assert.IsNull(bx1);
            Assert.IsNull(bx2);

            YAttribute by1 = typeof(B).GetAttribute<YAttribute>(true);
            Attribute by2 = typeof(B).GetAttribute(typeof(YAttribute), true);
            YAttribute by3 = typeof(B).GetAttribute<YAttribute>(false);
            Attribute by4 = typeof(B).GetAttribute(typeof(YAttribute), false);

            Assert.IsNotNull(by1);
            Assert.IsNotNull(by2);
            Assert.IsNull(by3);
            Assert.IsNull(by4);
        }

        [Test]
        public void Test_GetAttributes()
        {
            IEnumerable<Attribute> a1 = typeof(A).GetAttributes();
            IEnumerable<Attribute> b1 = typeof(B).GetAttributes(true);
            IEnumerable<Attribute> b2 = typeof(B).GetAttributes(false);

            Assert.AreEqual(2, a1.Count());
            Assert.AreEqual(1, b1.Count());
            Assert.AreEqual(0, b2.Count());

            IEnumerable<XAttribute> ax1 = typeof(A).GetAttributes<XAttribute>();
            IEnumerable<Attribute> ax2 = typeof(A).GetAttributes(typeof(XAttribute));
            IEnumerable<XAttribute> bx1 = typeof(B).GetAttributes<XAttribute>();
            IEnumerable<Attribute> bx2 = typeof(B).GetAttributes(typeof(XAttribute));

            Assert.AreEqual(1, ax1.Count());
            Assert.AreEqual(1, ax2.Count());
            Assert.AreEqual(0, bx1.Count());
            Assert.AreEqual(0, bx2.Count());

            IEnumerable<YAttribute> by1 = typeof(B).GetAttributes<YAttribute>();
            IEnumerable<Attribute> by2 = typeof(B).GetAttributes(typeof(YAttribute));
            IEnumerable<YAttribute> by3 = typeof(B).GetAttributes<YAttribute>(false);
            IEnumerable<Attribute> by4 = typeof(B).GetAttributes(typeof(YAttribute), false);

            Assert.AreEqual(1, by1.Count());
            Assert.AreEqual(1, by2.Count());
            Assert.AreEqual(0, by3.Count());
            Assert.AreEqual(0, by4.Count());
        }

        [Test]
        public void Test_IsNullable()
        {
            Assert.IsTrue(typeof(string).IsNullable());
            Assert.IsFalse(typeof(int).IsNullable());
            Assert.IsTrue(typeof(int?).IsNullable());
        }
    }
}