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

namespace Chernobyl.Reflection.Template
{
    /// <summary>
    /// A helper base test class for testing types that implement the 
    /// <see cref="IMember"/> interface.
    /// </summary>
    public abstract class MemberTests : ComponentTests
    {
        [Test, Description("A test that ensures the arguments of the IMember " + 
            "are correct.")]
        public void MemberWithArgumentsTest()
        {
            IMember member = CreateMemberWithArguments();

            IEnumerable<IInstance> arguments = member.ComponentChildren.OfType<IInstance>();
            int argumentCount = arguments.Count();

            Assert.AreEqual(1, argumentCount, "There must be at least one " + 
                "argument in the member returned by CreateMemberWithArguments().");
            Assert.AreEqual(Arguments.Length, argumentCount, 
                "The number of arguments does not match what was expected.");

            for (int i = 0; i < argumentCount; ++i)
            {
                Assert.AreEqual(Arguments[i], arguments.ElementAt(i).TheInstance, 
                    "The arguments at position " + i + " are not equal.");
            }
        }

        [Test, Description("A test that ensures the argument of the IMember " +
            "properly links to another instance.")]
        public void LinkedMemberTest()
        {
            IMember memberWithLink = CreateLinkedMember();
            IInstance actualLinkedToInstance = CreateLinkedToInstance();

            IEnumerable<IInstance> arguments = memberWithLink.ComponentChildren.OfType<IInstance>();

            if(arguments.Any() == true)
            {
                IInstance linkedInstance = memberWithLink.ComponentChildren.OfType<IInstance>().First();
                Assert.IsInstanceOf<LinkedInstance>(linkedInstance);
                Assert.AreEqual(((LinkedInstance)linkedInstance).Linked.Type, actualLinkedToInstance.Type);   
            }
            else
                Assert.AreSame(((TestType)memberWithLink.Instance.TheInstance).Child, actualLinkedToInstance.TheInstance);
        }

        /// <summary>
        /// Creates an <see cref="IMember"/> which contains at least one
        /// argument that matches with the arguments in the 
        /// <see cref="Arguments"/> property. <see cref="IMember"/>s created by 
        /// this method should not be used return more than once.
        /// </summary>
        /// <returns>The <see cref="IMember"/> to test.</returns>
        protected abstract IMember CreateMemberWithArguments();

        /// <summary>
        /// Creates an <see cref="IMember"/> that is to be tested to ensure it
        /// properly contains an argument that links to the 
        /// <see cref="IInstance"/> created by 
        /// <see cref="CreateLinkedToInstance"/>. This method will always create
        /// a new <see cref="IMember"/> and never return the same instance 
        /// twice.
        /// </summary>
        /// <returns>The instance that is to be tested.</returns>
        protected abstract IMember CreateLinkedMember();

        /// <summary>
        /// Creates an <see cref="IInstance"/> that is to be tested to ensure 
        /// it is equal to the <see cref="IInstance"/> argument contained within
        /// the <see cref="IMember"/> created by 
        /// <see cref="CreateLinkedMember()"/>. This method will always create 
        /// a new <see cref="IInstance"/> and never return the same instance 
        /// twice.
        /// </summary>
        /// <returns>The instance that is to be tested for equality against the 
        /// argument contained within the <see cref="IMember"/> created by
        /// <see cref="CreateLinkedMember()"/>.</returns>
        protected abstract IInstance CreateLinkedToInstance();

        /// <summary>
        /// <see cref="object"/>s which are equal to the arguments in the 
        /// <see cref="IMember"/> returned by 
        /// <see cref="CreateMemberWithArguments()"/>.
        /// </summary>
        protected abstract object[] Arguments { get; }

        /// <summary>
        /// Should create the <see cref="INamed"/> instance that is being tested.
        /// This method should always create a new instance and never reuse that
        /// instance.
        /// </summary>
        /// <returns>The new <see cref="INamed"/> instance to be tested.</returns>
        protected override INamed CreateNamed()
        {
            return CreateMemberWithArguments();
        }
    }
}