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

namespace Chernobyl.Dependency
{
    [TestFixture, Description("Tests for the ServiceAttributeExtensions type.")]
    public class ServiceAttributeExtensionsTests
    {
        [Test, Description("A test that ensures the IEventCollection<object>.Inject<T>(T) method " +
            "sets a property as a service when it is attribute with the Provide " +
            "attribute. This test also ensures the IEventCollection<object>.GetService(Type) " +
            "returns the service that was set.")]
        public void InjectProvideGetServiceTest()
        {
            IEventCollection<object> services = CreateServices();

            ICollection<String> expectedCollection = new List<String>();
            TestServices testServices = new TestServices();
            testServices.ProvidedService = expectedCollection;
            services.Inject(testServices);

            object collectionService = services.OfType<ICollection<String>>().First();
            Assert.AreEqual(expectedCollection, collectionService, "Unexpected service " +
                "was retrieved.");
        }

        [Test, Description("A test that ensures the IEventCollection<object>.Inject<T>(T) method " +
            "sets a property with a service when it is attribute with the Inject " +
            "attribute.")]
        public void InjectTest()
        {
            IEventCollection<object> services = CreateServices();

            // Note that we call Inject before we add the service to ensure that
            // a service is properly injected even if it was added at a later 
            // point in time.

            TestServices testServices = new TestServices();
            services.Inject(testServices);

            ICollection<int> expectedCollection = new List<int>();
            services.Add(expectedCollection);

            Assert.AreEqual(expectedCollection, testServices.InjectedService,
                "Unexpected service was retrieved.");
        }

        [Test, Description("A test that ensures the IEventCollection<object>.Inject<T>(T) method " +
            "does not inject/provide services in base classes.")]
        public void DontInjectBaseClassTest()
        {
            IEventCollection<object> services = CreateServices();

            ICollection<float> expectedInjectedCollection = new List<float>();
            services.Add(expectedInjectedCollection);

            TestServicesDerived testServices = new TestServicesDerived();
            ICollection<Type> expectedProvidedCollection = new List<Type>();
            testServices.ProvidedService2 = expectedProvidedCollection;

            services.Inject(testServices);

            Assert.AreEqual(expectedInjectedCollection, testServices.InjectedService2,
                "Unexpected service was retrieved.");

            object providedService = services.OfType<ICollection<Type>>().First();
            Assert.AreEqual(expectedProvidedCollection, providedService,
                "Unexpected service was retrieved.");

            Assert.AreEqual(null, testServices.InjectedService,
                "The base class's property should not have been set.");

            object notProvidedService = services.OfType<ICollection<String>>().FirstOrDefault();
            Assert.AreEqual(null, notProvidedService,
                "The base class's provided service should not have been set.");
        }

        [Test, Description("A test that ensures the IEventCollection<object> class can handle " +
            "the ServiceAttribute.Type property.")]
        public void ServiceTypeTest()
        {
            IEventCollection<object> services = CreateServices();

            ICollection<float> expectedInjectCollection = new List<float>();
            services.Add(expectedInjectCollection);

            TestServiceType testServiceType = new TestServiceType();
            ICollection<Type> expectedProvideCollection = new List<Type>();
            testServiceType.ProvidedService = expectedProvideCollection;
            services.Inject(testServiceType);

            Assert.AreEqual(expectedInjectCollection, testServiceType.InjectedService,
                "Unexpected service was retrieved.");

            object enumerableService = services.OfType<IEnumerable<Type>>().First();
            Assert.AreEqual(expectedProvideCollection, enumerableService, "Unexpected service " +
                "was retrieved.");
        }

        [Test, Description("A test that ensures the IEventCollection<object> class can handle " +
            "the ServiceAttribute.Location property.")]
        public void ServiceLocationTest()
        {
            IEventCollection<object> services = CreateServices();

            // Create a child services instance that will contain the service 
            // to be injected.
            ChildServices childServices = new ChildServices();
            services.Add(childServices);

            GrandchildServices grandchildServices = new GrandchildServices();
            childServices.Add(grandchildServices);

            ICollection<int> expectedInjectService = new List<int>();
            grandchildServices.Add(expectedInjectService);


            // Create the test instance and it's provided services instance that
            // will be injected into the services class.
            TestServicePathing servicePathing = new TestServicePathing();
            ICollection<String> expectedProvidedService = new List<String>();
            servicePathing.ProvidedService = expectedProvidedService;

            services.Inject(servicePathing);

            // Ensure the ICollection<int> service was injected.
            Assert.AreEqual(expectedInjectService, servicePathing.InjectedService,
                "The injected service was not the service that was expected.");

            // Ensure the ICollection<String> service was provided
            object providedService = grandchildServices.OfType<ICollection<String>>().First();
            Assert.AreEqual(expectedProvidedService, providedService,
                "The provided service was not the service expected.");
        }

        /// <summary>
        /// This class is attributed with the <see cref="ProvideAttribute"/> and 
        /// <see cref="InjectAttribute"/> attributes to help with testing 
        /// <see cref="IEventCollection<object>"/> classes.
        /// </summary>
        public class TestServices
        {
            [Provide]
            public ICollection<String> ProvidedService { get; set; }

            [Inject]
            public ICollection<int> InjectedService { get; set; }
        }

        /// <summary>
        /// This class is attributed with the <see cref="ProvideAttribute"/> and 
        /// <see cref="InjectAttribute"/> attributes to help with testing 
        /// <see cref="IEventCollection<object>"/> classes. This class is used to ensure the
        /// <see cref="IEventCollection<object>"/> does not provide/inject services for base
        /// classes.
        /// </summary>
        public class TestServicesDerived : TestServices
        {
            [Provide]
            public ICollection<Type> ProvidedService2 { get; set; }

            [Inject]
            public ICollection<float> InjectedService2 { get; set; }
        }

        /// <summary>
        /// This class is attributed with the <see cref="ProvideAttribute"/> and 
        /// <see cref="InjectAttribute"/> attributes to help with testing 
        /// <see cref="IEventCollection<object>"/> classes. This class is used to ensure the
        /// <see cref="IEventCollection<object>"/> handles the 
        /// <see cref="ServiceAttribute.Type"/> property.
        /// </summary>
        public class TestServiceType
        {
            [Provide(Type = typeof(IEnumerable<Type>))]
            public ICollection<Type> ProvidedService { get; set; }

            [Inject(Type = typeof(ICollection<float>))]
            public IEnumerable<float> InjectedService { get; set; }
        }

        public class TestServicePathing
        {
            [Provide(typeof(ChildServices), typeof(GrandchildServices))]
            public ICollection<String> ProvidedService { get; set; }

            [Inject(typeof(ChildServices), typeof(GrandchildServices))]
            public ICollection<int> InjectedService { get; set; }
        }

        public class ChildServices : DecoratingEventList<object>
        {}

        public class GrandchildServices : DecoratingEventList<object>
        {}

        /// <summary>
        /// Creates the <see cref="IEventCollection{T}"/> instance to test. This method
        /// should always return a new <see cref="IEventCollection{T}"/> instance. The 
        /// <see cref="IEventCollection{T}"/> must have the number of ancestors
        /// specified by 
        /// <see cref="ServicesTests.ExpectedServiceAncestorCount"/>.
        /// </summary>
        /// <returns>The <see cref="IEventCollection{T}"/> instance to test.</returns>
        protected virtual IEventCollection<object> CreateServices()
        {
            IEventCollection<object> grandfather = new DecoratingEventList<object>();
            IEventCollection<object> dad = new DecoratingEventList<object>();
            IEventCollection<object> services = new DecoratingEventList<object>();

            grandfather.Add(dad);
            dad.Add(services);

            return services;
        }
    }
}