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

namespace Chernobyl.Attribution
{
    /// <summary>
    /// Tests for <see cref="IProcessAttribute{TCustomAttributeProvider}" />
    /// which process attribute providers.
    /// </summary>
    /// <typeparam name="TAttributeProvider">The type of the attribute provider.</typeparam>
    /// <typeparam name="TChildAttributeProvider">The type of the child attribute provider.</typeparam>
    public abstract class ProcessAttributesTests<TAttributeProvider, TChildAttributeProvider>
        where TAttributeProvider : ICustomAttributeProvider
        where TChildAttributeProvider : ICustomAttributeProvider
    {
        [Test, Description("Ensures the IProcessAttribute<TCustomAttributeProvider> " +
                           "processes the sub IProcessAttribute<TCustomAttributeProvider> instances.")]
        public virtual void ProcessChildProcessors()
        {
            Test test = CreateTest();
            test.ProcessAttributes.Process(test.Provider);

            Assert.AreEqual(test.ExpectedItemsProcessed.Count, test.ItemsProcessed.Count,
                            "Unexpected number of types processed.");

            foreach (TChildAttributeProvider provider in test.ExpectedItemsProcessed)
            {
                Assert.IsTrue(test.ItemsProcessed.Remove(provider),
                              "The ICustomAttributeProvider \"" + provider + 
                              "\" was not processed though processing of it was " +
                              "expected.");
            }
        }

        protected abstract Test CreateTest();

        public class Test
        {
            /// <summary>
            /// Initializes a new instance of the <see cref="Test" /> class.
            /// </summary>
            /// <param name="processAttributes">The instance that is to be tested.</param>
            /// <param name="provider">The instance where <see cref="ProcessAttributes" />
            /// was found and that should be processed by <see cref="ProcessAttributes" />.</param>
            /// <param name="expectedItemsProcessed">The items that are the result 
            /// of the processing by <see cref="ProcessAttributes"/>.</param>
            /// <param name="itemsProcessed">The items that are the result of
            /// the processing by <see cref="ProcessAttributes" />.</param>
            public Test(IProcessAttribute<TAttributeProvider> processAttributes,
                        TAttributeProvider provider,
                        ICollection<TChildAttributeProvider> expectedItemsProcessed,
                        ICollection<TChildAttributeProvider> itemsProcessed)
            {
                ProcessAttributes = processAttributes;
                Provider = provider;
                ExpectedItemsProcessed = expectedItemsProcessed;
                ItemsProcessed = itemsProcessed;
            }

            /// <summary>
            /// The instance that is to be tested.
            /// </summary>
            public IProcessAttribute<TAttributeProvider> ProcessAttributes { get; private set; }

            /// <summary>
            /// The instance where <see cref="ProcessAttributes"/> was found and
            /// that should be processed by <see cref="ProcessAttributes"/>.
            /// </summary>
            public TAttributeProvider Provider { get; private set; }

            /// <summary>
            /// The items that are the result of the processing by 
            /// <see cref="ProcessAttributes"/>.
            /// </summary>
            public ICollection<TChildAttributeProvider> ExpectedItemsProcessed { get; private set; }

            /// <summary>
            /// The items that are the result of the processing by 
            /// <see cref="ProcessAttributes"/>.
            /// </summary>
            public ICollection<TChildAttributeProvider> ItemsProcessed { get; private set; }
        }
    }
}