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

namespace Chernobyl.DesignPatterns.Extension
{
    /// <summary>
    /// Tests types that implement the <see cref="IExtension"/>, 
    /// <see cref="IExtension{TExtended}"/>, and/or 
    /// <see cref="IExtendable"/> interfaces.
    /// </summary>
    public abstract class ExtensionTests : NamedTests
    {
        /// <summary>
        /// Should create the <see cref="IExtension"/> 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 abstract IExtension CreateExtension();

        /// <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 CreateExtension();
        }
    }

    [TestFixture, Description("Tests types that implement the " +
        "IExtension<TExtended> interface. This class also derives from " +
        "ExtensionTest to handle the IExtension testing.")]
    public abstract class GenericExtensionTests<TExtended> : ExtensionTests
    {
        /// <summary>
        /// Initializes a new instance of the 
        /// <see cref="GenericExtensionTests{TExtended}"/> class that 
        /// uses the <see cref="EqualityComparer{T}.Default"/> to test types.
        /// </summary>
        protected GenericExtensionTests()
            : this(EqualityComparer<TExtended>.Default)
        { }

        /// <summary>
        /// Initializes a new instance of the 
        /// <see cref="GenericExtensionTests{TExtended}"/> class.
        /// </summary>
        /// <param name="extendedComparer">The <see cref="IEqualityComparer{T}"/> 
        /// used to compare <typeparamref name="TExtended"/> types.</param>
        protected GenericExtensionTests(IEqualityComparer<TExtended> extendedComparer)
        {
            ExtendedComparer = extendedComparer;
        }

        [Test, Description("Tests that the extension can be set with a specified " +
                    "extendable and then that extendable is the same after it " +
                    "has been queried.")]
        public void SettingAndQueryingExtension()
        {
            IExtension<TExtended> extension = CreateExtendedExtension();
            TExtended extended = CreateExtendable();
            extension.Extended = extended;

            Assert.True(ExtendedComparer.Equals(extended, extension.Extended),
                "The extended instance that was set on the " +
                "IExtension<TExtended>.Extended did not equal the " +
                "extended type that was set on the property.");
        }

        [Test, Description("Tests that the extension properly adds itself to " +
            "the IExtendable.Extensions list when it is attached to the extended " +
            "instance and also that it properly removes itself from the list when " +
            "it is unattached. If the extended type does not implement IExtendable, " +
            "then the test always passes.")]
        public void ExtensionIsAddedToAndRemovedFromExtensionList()
        {
            TExtended extended = CreateExtendable();
            if (extended is IExtendable)
            {
                IExtension<TExtended> extension = CreateExtendedExtension();
                extension.Extended = extended;

                Assert.True(((IExtendable)extended).Extensions.Contains(extension),
                    "The Extension is not properly contained within the IExtendable " +
                    "instances IExtendable.Extensions list even though we extended it.");

                extension.Extended = default(TExtended);

                Assert.False(((IExtendable)extended).Extensions.Contains(extension),
                    "The Extension is not properly removed within the IExtendable " +
                    "instance even though we unextended it.");
            }
            else
                Assert.Pass("The extended type does not derive from IExtendable " +
                    "so this test does not need to be run.");
        }

        /// <summary>
        /// Should create the <see cref="IExtension{TExtended}"/> that 
        /// is to be tested. This method should always create a new type and 
        /// never reuse the instances it creates.
        /// </summary>
        /// <returns>The <see cref="IExtension{TExtended}"/> to test.</returns>
        protected abstract IExtension<TExtended> CreateExtendedExtension();

        /// <summary>
        /// Should create a <typeparamref name="TExtended"/> instance that can 
        /// be extended. This method should always create a new 
        /// <typeparamref name="TExtended"/> instance and should never reuse 
        /// the instances it creates.
        /// </summary>
        /// <returns>The <typeparamref name="TExtended"/> instance that can be 
        /// extended.</returns>
        protected abstract TExtended CreateExtendable();

        protected override IExtension CreateExtension()
        {
            return CreateExtendedExtension();
        }

        /// <summary>
        /// The <see cref="IEqualityComparer{T}"/> used to compare 
        /// <typeparamref name="TExtended"/> types. By default, the 
        /// <see cref="EqualityComparer{T}.Default"/> is used.
        /// </summary>
        IEqualityComparer<TExtended> ExtendedComparer { get; set; }
    }
}