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

namespace System.ComponentModel.Design
{
    /// <summary>
    /// A set of reusable tests for testing types that implement 
    /// <see cref="IServiceContainer"/>.
    /// </summary>
    public abstract class ServiceContainerTests : ServiceProviderTests
    {
        [Test, Description("A test that ensures the " +
            "IServiceContainer.AddService(Type, Object) method sets the service " +
            "properly.")]
        public void AddServiceTypeObjectTest()
        {
            IServiceContainer serviceContainer = CreateServiceContainer();

            ICollection<int> collection = new List<int>();
            Type collectionType = typeof(ICollection<int>);
            serviceContainer.AddService(collectionType, collection);

            object collectionService = serviceContainer.GetService(collectionType);
            Assert.AreEqual(collection, collectionService, "Unexpected service " +
                "was retrieved.");
        }

        [Test, Description("A test that ensures the " +
            "IServiceContainer.AddService(Type, Object, Boolean) method sets " + 
            "the service properly and does so on the parents if told to do so.")]
        public void AddServiceTypeObjectBoolTest()
        {
            ICollection<int> service = new List<int>();
            Type serviceType = typeof(ICollection<int>);

            // Check the promotion of a service
            {
                IServiceContainer serviceContainer = CreateServiceContainer();
                serviceContainer.AddService(serviceType, service, true);
                CheckServicesInHierarchy(serviceContainer, serviceType, service);
            }

            // Check the lack of promotion of a service
            {
                IServiceContainer serviceContainer = CreateServiceContainer();
                serviceContainer.AddService(serviceType, service, false);
                CheckServicesInHierarchy(serviceContainer, serviceType, null);
            }
        }

        [Test, Description("A test that ensures the " + 
            "IServiceContainer.AddService(Type, ServiceCreatorCallback) method " +
            "sets the service properly.")]
        public void AddServiceTypeServiceCreatorCallbackTest()
        {
            IServiceContainer serviceContainer = CreateServiceContainer();

            ServiceCreatorCallbackTester tester = new ServiceCreatorCallbackTester();
            Type collectionType = typeof(ICollection<String>);
            serviceContainer.AddService(collectionType, tester.Callback);

            Assert.AreEqual(false, tester.Invoked, "The ServiceCreatorCallback should " + 
                "not have been invoked.");

            object collectionService = serviceContainer.GetService(collectionType);

            Assert.AreEqual(true, tester.Invoked, "The ServiceCreatorCallback should " +
                "have been invoked.");
            Assert.AreEqual(tester.Service, collectionService, "Unexpected service " +
                "was retrieved.");
        }

        /// <summary>
        /// A helper class for use in the 
        /// <see cref="AddServiceTypeServiceCreatorCallbackTest"/> method. This
        /// class stores the <see cref="Service"/> being injected as well as the 
        /// <see cref="Invoked"/> property which indicates whether the callback 
        /// method was invoked or not.
        /// </summary>
        class ServiceCreatorCallbackTester
        {
            public ServiceCreatorCallbackTester()
            {
                Invoked = false;
                Service = new List<String>();
            }

            public object Callback(IServiceContainer servCont, Type type)
            {
                Invoked = true;
                return Service;
            }

            public bool Invoked { get; private set; }
            public ICollection<String> Service { get; private set; }
        }

        [Test, Description("A test that ensures the " +
            "IServiceContainer.AddService(Type, ServiceCreatorCallback, Boolean) " +
            "method sets the service properly and does so on the parents if told " +
            "to do so.")]
        public void AddServiceTypeServiceCreatorCallbackBooleanTest()
        {
            ICollection<int> service = new List<int>();
            Type serviceType = typeof(ICollection<int>);
            
            // Check the promotion of a service
            {
                IServiceContainer serviceContainer = CreateServiceContainer();
                serviceContainer.AddService(serviceType, (servCont, type) => service, true);
                CheckServicesInHierarchy(serviceContainer, serviceType, service);
            }

            // Check the lack of promotion of a service
            {
                IServiceContainer serviceContainer = CreateServiceContainer();
                serviceContainer.AddService(serviceType, (servCont, type) => service, false);
                CheckServicesInHierarchy(serviceContainer, serviceType, null);
            }
        }

        [Test, Description("A test that ensures IServiceContainer.Remove(Type) " +
            "properly removes a service from the IServicesContainer container.")]
        public void RemoveServiceTypeTest()
        {
            IServiceContainer serviceContainer = CreateServiceContainer();

            ICollection<int> collection = new List<int>();
            Type serviceType = typeof(ICollection<int>);
            serviceContainer.AddService(serviceType, collection);

            RemoveServiceCheck(serviceContainer, collection, serviceType, (servCont, type) => serviceContainer.RemoveService(type));
        }

        [Test, Description("A test that ensures " +
            "IServiceContainer.Remove(Type, Boolean) properly removes a service " + 
            "from the IServicesContainer container and propagates the change to " +
            "the parent IServiceContainer.")]
        public void RemoveServiceTypeBooleanTest()
        {
            ICollection<String> collection = new List<String>();
            Type serviceType = typeof(ICollection<String>);
            
            // Check the promotion of service removal.
            {
                IServiceContainer serviceContainer = CreateServiceContainer();
                serviceContainer.AddService(serviceType, collection, true);
                RemoveServiceCheck(serviceContainer, collection, serviceType, (servCont, type) => serviceContainer.RemoveService(type, true));
                CheckServicesInHierarchy(serviceContainer, serviceType, null);
            }
            
            // Check the lack of promotion of a service removal.
            {
                IServiceContainer serviceContainer = CreateServiceContainer();
                serviceContainer.AddService(serviceType, collection, true);
                RemoveServiceCheck(serviceContainer, collection, serviceType, (servCont, type) => serviceContainer.RemoveService(type, false));
                CheckServicesInHierarchy(serviceContainer, serviceType, collection);
            }
        }

        [Test, Description("A test that ensures IServiceContainers can properly " + 
            "override properly added services.")]
        public void OverrideServiceTest()
        {
            IServiceContainer serviceContainer = CreateServiceContainer();

            Type serviceType = typeof (ICollection<String>);
            ICollection<String> service1 = new List<String>();
            ICollection<String> service2 = new List<String>();

            // Add the service and ensure we can retrieve it as expected.
            {
                serviceContainer.AddService(serviceType, service1);
                object service = serviceContainer.GetService(serviceType);
                Assert.AreEqual(service1, service);
            }

            // Now override the service we just added and ensure we can retrieve
            // it as expected.
            {
                serviceContainer.AddService(serviceType, service2);
                object service = serviceContainer.GetService(serviceType);
                Assert.AreEqual(service2, service);
            }
        }

        /// <summary>
        /// Creates the <see cref="IServiceContainer"/> to test. This method 
        /// should always create a new instance. The <see cref="IServiceContainer"/>
        /// must contain a service of type <see cref="ICollection{Int32}"/> that
        /// is not null and equal to <see cref="ServiceProviderTests.ExpectedService"/>.
        /// The <see cref="IServiceContainer"/> must also have the number of 
        /// ancestors specified by <see cref="ExpectedServiceAncestorCount"/>.
        /// </summary>
        /// <returns>The <see cref="IServiceProvider"/> instance to test.</returns>
        protected abstract IServiceContainer CreateServiceContainer();

        /// <summary>
        /// Retrieves the parent <see cref="IServiceContainer"/> of the 
        /// <see cref="IServiceContainer"/> passed in.
        /// </summary>
        /// <param name="serviceContainer">The <see cref="IServiceContainer"/> 
        /// whose parent is to be retrieved.</param>
        /// <returns>The parent of the <paramref name="serviceContainer"/> 
        /// instance or null if they instance has no parent.</returns>
        protected abstract IServiceContainer GetParent(IServiceContainer serviceContainer);

        protected override IServiceProvider CreateServiceProvider()
        {
            return CreateServiceContainer();
        }

        /// <summary>
        /// The number of ancestors the <see cref="IServiceContainer"/> returned
        /// by <see cref="CreateServiceContainer()"/> is expected to have. The
        /// value of this field is 2.
        /// </summary>
        protected const int ExpectedServiceAncestorCount = 2;

        /// <summary>
        /// Ensures the <paramref name="serviceContainer"/> and its ancestors 
        /// can handle the promotion of services, or lack thereof.
        /// </summary>
        /// <param name="serviceContainer">The service container whose 
        /// ancestors are to be checked to see if they contain the 
        /// <paramref name="expectedService"/>.</param>
        /// <param name="serviceType">The type of the service to check for in 
        /// the <paramref name="serviceContainer"/>.</param>
        /// <param name="expectedService">The service that is expected in the
        /// <paramref name="serviceContainer"/>.</param>
        void CheckServicesInHierarchy(IServiceContainer serviceContainer, Type serviceType, object expectedService)
        {
            serviceContainer = GetParent(serviceContainer);

            // Check the ancestors of the serviceContainer to see if the service 
            // was added to them. While we are doing that, we'll keep a count to 
            // ensure the IServiceContainer has the proper number of ancestors.
            int serviceContainerCount = 0;
            do
            {
                ++serviceContainerCount;

                object actualService = serviceContainer.GetService(serviceType);
                Assert.AreEqual(expectedService, actualService, "Unexpected service " +
                    "was retrieved.");

                serviceContainer = GetParent(serviceContainer);
            } while (serviceContainer != null);

            Assert.AreEqual(ExpectedServiceAncestorCount, serviceContainerCount);
        }

        /// <summary>
        /// Tests an <see cref="IServiceContainer"/> to see if it can handle 
        /// the removal of a service.
        /// </summary>
        /// <param name="serviceContainer">The <see cref="IServiceContainer"/> 
        /// to test.</param>
        /// <param name="serviceToBeRemoved">The service that is to be removed
        /// from the <paramref name="serviceContainer"/>. Before the service is
        /// removed, the <paramref name="serviceContainer"/> is checked to see 
        /// if it exists. </param>
        /// <param name="serviceType">The <see cref="Type"/> of the service to
        /// remove.</param>
        /// <param name="removeService">The method to be invoked that will 
        /// remove the service of <see cref="Type"/> from the 
        /// <see cref="IServiceContainer"/> specified.</param>
        static void RemoveServiceCheck(IServiceContainer serviceContainer, object serviceToBeRemoved, Type serviceType, Action<IServiceContainer, Type> removeService)
        {
            object collectionService = serviceContainer.GetService(serviceType);
            Assert.AreEqual(serviceToBeRemoved, collectionService, "Unexpected service " +
                                                           "was retrieved.");

            removeService(serviceContainer, serviceType);

            collectionService = serviceContainer.GetService(serviceType);
            Assert.AreEqual(null, collectionService, "Service should have been " +
                                                     "null");
        }
    }
}