using System;
using System.ComponentModel.Design;
using System.Reflection;
using Chernobyl.Collections.Generic.Event;
using Chernobyl.Event;

namespace Chernobyl.Dependency
{
    /// <summary>
    /// Used to mark an instance as being "provided" to an 
    /// <see cref="IEventCollection{T}"/> instance. When this type has it's 
    /// <see cref="ProvideAttribute.Resolve(IEventCollection{object}, object, ICustomAttributeProvider)"/>
    /// method invoked, it will add the instance to the <see cref="IEventCollection{T}"/> 
    /// instance provided.
    /// </summary>
    [AttributeUsage(AttributeTargets.Property, AllowMultiple = true)]
    public class ProvideAttribute : ServiceAttribute
    {
        /// <summary>
        /// Initializes a new instance of the <see cref="ServiceAttribute"/> 
        /// class.
        /// </summary>
        public ProvideAttribute()
        { }

        /// <summary>
        /// Initializes a new instance of the <see cref="ServiceAttribute"/> 
        /// class.
        /// </summary>
        /// <param name="location">The location of the service within the
        /// <see cref="IEventCollection{T}"/> hierarchy or null if the service is at the 
        /// root of the hierarchy. This <see cref="Type"/> array represents the 
        /// "path" that must be taken through the hierarchy of 
        /// <see cref="IEventCollection{T}"/> to get to the location where the service 
        /// specified by <see cref="ServiceAttribute.Type"/> resides. Each 
        /// <see cref="Type"/> must implement the <see cref="IEventCollection{T}"/> 
        /// interface. An example of what the service path might look like 
        /// (using '/' as separators):
        /// <example>/IEventCollection{T}/IGraphicsServices/ITextureServices</example>
        /// In this example, the service represented by 
        /// <see cref="ServiceAttribute.Type"/> is located in the 
        /// <see cref="IEventCollection{T}"/> ITextureServices. That 
        /// <see cref="IEventCollection{T}"/> is located within IGraphicsServices which 
        /// is located at the root <see cref="IEventCollection{T}"/>.</param>
        public ProvideAttribute(params Type[] location)
            : base(location)
        { }

        /// <summary>
        /// Adds the service specified by the <paramref name="attributeProvider"/>
        /// to the <paramref name="services"/> instance. Note that the service
        /// is added as a <see cref="ServiceCreatorCallback"/> so that the 
        /// property is only invoked when the service is actually needed.
        /// </summary>
        /// <param name="services">The <see cref="IEventCollection{T}"/> instance that
        /// allows access to the other services and provides adding or removing
        /// of specific services.</param>
        /// <param name="instance">The instance that contained a code element that
        /// was attributed with a <see cref="InjectAttribute"/> instance.</param>
        /// <param name="attributeProvider">The code element that was attributed
        /// with a <see cref="InjectAttribute"/> and whose service needs to be
        /// added into the .</param>
        public override void Resolve(IEventCollection<Object> services, object instance, ICustomAttributeProvider attributeProvider)
        {
            _property = (PropertyInfo)attributeProvider;
            Type = Type ?? _property.PropertyType;
            _instance = instance;

            // If the service belongs at the root we'll just add it now.
            // Otherwise, we'll need to traverse down the IEventCollection{T} instance
            // till we find the IEventCollection{T} we need to add the service to.
            if (Location.Length != 0)
                services.OfType(Location[0], ServiceRetriever);
            else
                services.Add(CreateService());
        }

        /// <summary>
        /// The method that is invoked when the service of the type specified by
        /// <see cref="Type" /> is resolved and can be used.
        /// </summary>
        /// <param name="service">The service that was requested.</param>
        void ServiceRetriever(object service)
        {
            IEventCollection<Object> services = (IEventCollection<Object>)service;

            // If we we've reached the last Type in the location path
            // then we are at the IEventCollection{T} that we need to provide the service
            // to. Otherwise, continue down the IEventCollection{T} descendants until we
            // reach the IEventCollection{T} instance we need to add the service to. 
            if (_currentLocationIndex == (Location.Length - 1))
                services.Add(CreateService());
            else
            {
                ++_currentLocationIndex;
                services.OfType(Location[_currentLocationIndex], ServiceRetriever);
            }
        }

        /// <summary>
        /// Creates the service and returns it.
        /// </summary>
        /// <returns>The service or null if the service could not be created.</returns>
        object CreateService()
        {
            return _property.GetValue(_instance, null);
        }

        /// <summary>
        /// The index into the <see cref="ServiceAttribute.Location"/> array
        /// that points to the <see cref="Type"/> we are currently processing
        /// in <see cref="ServiceRetriever(object)"/>.
        /// </summary>
        int _currentLocationIndex;

        /// <summary>
        /// The property that was attributed with this attribute.
        /// </summary>
        PropertyInfo _property;

        /// <summary>
        /// The instance that whose type was attributed with this attribute.
        /// </summary>
        object _instance;
    }
}