using System;
using Chernobyl.Collections.Generic.Event;

namespace Chernobyl.Dependency
{
    /// <summary>
    /// A class that can request a service, hold the service it receives, and
    /// invoke an event when that service is received.
    /// </summary>
    /// <typeparam name="TService">The type of the service to be retrieved from
    /// the <see cref="IEventCollection{T}"/> class.</typeparam>
    public class Service<TService>
    {
        /// <summary>
        /// Initializes a new instance of the <see cref="Service{TService}"/> 
        /// class.
        /// </summary>
        /// <param name="services">The instance that will provide the injection 
        /// of the service.</param>
        public Service(IEventCollection<object> services) : this(services, Array<Type>.Empty)
        {}

        /// <summary>
        /// Initializes a new instance of the <see cref="Service{TService}"/> 
        /// class.
        /// </summary>
        /// <param name="services">The instance that will provide the injection 
        /// of the service.</param>
        /// <param name="location">The location of the service as defined by
        /// <see cref="ServiceAttribute.Location"/>.</param>
        protected Service(IEventCollection<object> services, params Type[] location)
        {
            _injectAttribute = new InjectAttribute(location)
                                   {
                                       Type = typeof (TService),
                                       SetValue = (obj, value, index) => Value = (TService) value
                                   };
            _injectAttribute.Resolve(services, this, null);
        }

        /// <summary>
        /// An event that is raised right after this class has the service  
        /// specified by <see cref="Value"/> (whose type is specified by
        /// <typeparamref name="TService"/>) set onto it. If the service 
        /// has already been received, then any event handlers added to this 
        /// event will be raised.
        /// </summary>
        public event EventHandler Received
        {
            add
            {
                _received += value;
                if (_serviceReceived == true)
                    value(this, EventArgs.Empty);
            }
            remove { _received -= value; }
        }

        /// <summary>
        /// The service instance that is to be retrieved from the services 
        /// instance passed to the constructor of this class.
        /// </summary>
        public TService Value
        {
            get { return _value; }
            set
            {
                _value = value;
                _serviceReceived = true;
                if (_received != null)
                    _received(this, EventArgs.Empty);
            }
        }

        /// <summary>
        /// The backing method to <see cref="Received"/>.
        /// </summary>
        EventHandler _received;

        /// <summary>
        /// The backing field to <see cref="Value"/>.
        /// </summary>
        TService _value;

        /// <summary>
        /// True if the service has been received, false if otherwise.
        /// </summary>
        bool _serviceReceived;

        /// <summary>
        /// The <see cref="InjectAttribute"/> which is used to handle the
        /// injection of the service.
        /// </summary>
        readonly InjectAttribute _injectAttribute;
    }

    /// <summary>
    /// Performs the exact same job as <see cref="Service{TService}"/> but this
    /// class allows you to specify an <see cref="IEventCollection{T}"/> type to search for
    /// <typeparamref name="TService"/> in.
    /// </summary>
    /// <typeparam name="TServices">The type of the <see cref="IEventCollection{T}"/> 
    /// where <typeparamref name="TService"/> is contained.</typeparam>
    /// <typeparam name="TService">The type of the service to be retrieved from
    /// the <see cref="IEventCollection{T}"/> class.</typeparam>
    public class Service<TServices, TService> : Service<TService> where TServices : IEventCollection<object>
    {
        /// <summary>
        /// Initializes a new instance of the <see cref="Service{TService}"/> 
        /// class.
        /// </summary>
        /// <param name="services">The instance that will provide the injection 
        /// of the service.</param>
        public Service(IEventCollection<object> services)
            : base(services, typeof(TServices))
        { }
    }

    /// <summary>
    /// Performs the exact same job as <see cref="Service{TServices, TService}"/>
    /// but this class allows you to specify a two levels deep 
    /// <see cref="IEventCollection{T}"/> hierarchy to search in for 
    /// <typeparamref name="TService"/>.
    /// </summary>
    /// <typeparam name="TServices1">The type of the <see cref="IEventCollection{T}"/> 
    /// where <typeparamref name="TServices2"/> is contained.</typeparam>
    /// <typeparam name="TServices2">The type of the <see cref="IEventCollection{T}"/> 
    /// where <typeparamref name="TService"/> is contained.</typeparam>
    /// <typeparam name="TService">The type of the service to be retrieved from
    /// the <see cref="IEventCollection{T}"/> class.</typeparam>
    public class Service<TServices1, TServices2, TService>
        : Service<TService> 
        where TServices1 : IEventCollection<object> 
        where TServices2 : IEventCollection<object>
    {
        /// <summary>
        /// Initializes a new instance of the <see cref="Service{TService}"/> 
        /// class.
        /// </summary>
        /// <param name="services">The instance that will provide the injection 
        /// of the service.</param>
        public Service(IEventCollection<object> services)
            : base(services, typeof(TServices1), typeof(TServices2))
        { }
    }

    /// <summary>
    /// Performs the exact same job as <see cref="Service{TServices, TService}"/>
    /// but this class allows you to specify a three levels deep 
    /// <see cref="IEventCollection{T}"/> hierarchy to search in for 
    /// <typeparamref name="TService"/>.
    /// </summary>
    /// <typeparam name="TServices1">The type of the <see cref="IEventCollection{T}"/> 
    /// where <typeparamref name="TServices2"/> is contained.</typeparam>
    /// <typeparam name="TServices2">The type of the <see cref="IEventCollection{T}"/> 
    /// where <typeparamref name="TServices3"/> is contained.</typeparam>
    /// <typeparam name="TServices3">The type of the <see cref="IEventCollection{T}"/> 
    /// where <typeparamref name="TService"/> is contained.</typeparam>
    /// <typeparam name="TService">The type of the service to be retrieved from
    /// the <see cref="IEventCollection{T}"/> class.</typeparam>
    public class Service<TServices1, TServices2, TServices3, TService>
        : Service<TService>
        where TServices1 : IEventCollection<object>
        where TServices2 : IEventCollection<object>
        where TServices3 : IEventCollection<object>
    {
        /// <summary>
        /// Initializes a new instance of the <see cref="Service{TService}"/> 
        /// class.
        /// </summary>
        /// <param name="services">The instance that will provide the injection 
        /// of the service.</param>
        public Service(IEventCollection<object> services)
            : base(services, typeof(TServices1), typeof(TServices2), typeof(TServices3))
        { }
    }
}