using System;
using System.IO;
using Chernobyl.Collections.Generic.Event;
using Chernobyl.Dependency;
using Chernobyl.Reflection.Template;
using Chernobyl.Resources;

namespace Chernobyl.Reflection.Resources
{
    /// <summary>
    /// An <see cref="ResourceProcessor{TResource}"/> that loads in 
    /// <see cref="IComponent"/> instances from the 
    /// <see cref="ResourceProcessor{ResourceType}"/> and then returns the value
    /// of the <see cref="IInstance.TheInstance"/> property. This is helper  
    /// class to make loading in instances from XML files easier. This 
    /// <see cref="IResourceProcessor{ResourceType}"/> accepts the 
    /// <see cref="ResourceName"/> <see cref="IOption"/> if an object with a 
    /// specific name is needed from an content file.
    /// </summary>
    public class ObjectContentResourceProcessor : ResourceProcessor<object>
    {
        /// <summary>
        /// Initializes a new instance of the 
        /// <see cref="ObjectContentResourceProcessor"/> class.
        /// </summary>
        /// <param name="services">The <see cref="IEventCollection{T}"/> instance that 
        /// gives and takes services.</param>
        public ObjectContentResourceProcessor(IEventCollection<object> services)
        {
            services.Inject<ObjectContentResourceProcessor>(this);
        }

        /// <summary>
        /// Should process the stream or resource that is passed to it. A
        /// resource processor must call its next resource processor (provided
        /// it isn't null) if it is unable to generate the resource from the
        /// passed in <paramref name="readFrom"/> stream. If it is able to
        /// generate it, then it should do so, invoke the
        /// <paramref name="callback"/> method, and NOT call the next resource
        /// processor. If the next resource processor is null, then the resource
        /// processor should throw an exception stating that the resource could
        /// not be generated from the stream because no resource processor
        /// existed that could perform the task.
        /// </summary>
        /// <param name="callback">The callback that will be invoked when the
        /// resource has been loaded.</param>
        /// <param name="readFrom">The stream to load the resource from.</param>
        /// <param name="options">Options for the loading or processing of the
        /// resource.</param>
        public void From<TInstance>(ResourceProcessCallback<TInstance> callback, Stream readFrom, params IOption[] options)
        {
            ResourceProcessCallback<object> objectCallback =
                result => callback(new ResourceProcessResult<TInstance>((TInstance)result.Resource, 
                    result.AsyncWaitHandle, result.CompletedSynchronously, result.IsCompleted));

            // Cast to a ResourceProcessor<object> to prevent a recursive call.
            ((ResourceProcessor<object>)this).From(objectCallback, readFrom, options);
        }

        /// <summary>
        /// Should process the stream or resource that is passed to it. A
        /// resource processor must call its next resource processor (provided
        /// it isn't null) if it is unable to generate the resource from the
        /// passed in <paramref name="readFrom"/> stream. If it is able to
        /// generate it, then it should do so, invoke the
        /// <paramref name="callback"/> method, and NOT call the next resource
        /// processor. If the next resource processor is null, then the resource
        /// processor should throw an exception stating that the resource could
        /// not be generated from the stream because no resource processor
        /// existed that could perform the task.
        /// </summary>
        /// <param name="callback">The callback that will be invoked when the
        /// resource has been loaded.</param>
        /// <param name="readFrom">The stream to load the resource from.</param>
        /// <param name="options">Options for the loading or processing of the
        /// resource.</param>
        public override void From(ResourceProcessCallback<object> callback, Stream readFrom, params IOption[] options)
        {
            ResourceProcessCallback<IComponent> componentCallback =
                result =>
                    {
                        IComponent component = result.Resource;
                        if (component != null)
                        {
                            object objectResource = ((IInstance)component).TheInstance;
                            callback(new ResourceProcessResult<object>(objectResource, result.AsyncWaitHandle, result.CompletedSynchronously, result.IsCompleted));
                        }
                        else
                            CheckedNextFrom(callback, readFrom, options);
                    };

            ComponentResourceProcessor.From(componentCallback, readFrom, options);
        }

        /// <summary>
        /// This method is currently not supported. 
        /// </summary>
        /// <param name="resource">The resource to write to the stream.</param>
        /// <param name="writeTo">The stream to have the resource written to.</param>
        /// <param name="options">Options for the writing or processing of the resource.</param>
        public override void To(object resource, Stream writeTo, params IOption[] options)
        {
            throw new NotImplementedException();
        }

        /// <summary>
        /// The <see cref="IResourceProcessor{ResourceType}"/> that loads in 
        /// <see cref="IComponent"/> instances. This resource processor is used 
        /// to load in the objects.
        /// </summary>
        [Inject]
        public IResourceProcessor<IComponent> ComponentResourceProcessor { get; set; }
    }
}