using System;
using System.IO;
using System.Linq;
using Chernobyl.Collections.Generic.Event;
using Chernobyl.Dependency;
using Chernobyl.Resources;
using Microsoft.Xna.Framework.Content;

namespace Chernobyl.Graphics.Xna.Resources
{
    /// <summary>
    /// A IResourceProcessor that uses XNA ContentManager to load resources 
    /// (using <see cref="ContentManager.Load{XnaResourceType}(string)"/>). The
    /// resources loaded by this processor must be added to the Visual Studio
    /// project that you used to compile your application. Note that, this 
    /// processor does not load from the Stream passed into the From method. For
    /// this reason, you can pass in null for the Stream parameter on the From 
    /// method. In order to load a resource with this processor, you will need to 
    /// pass in a ResourceName option into the options parameter where the
    /// ResourceName.Name property is set to the name of the resource you want 
    /// to load.
    /// </summary>
    /// <typeparam name="ResourceType">The Chernobyl resource that is being 
    /// loaded. For example, if textures were being loaded with this processor
    /// then this type would be set to 'ITexture'.</typeparam>
    /// <typeparam name="XnaResourceType">The XNA resource that is loaded from
    /// <see cref="ContentManager.Load{XnaResourceType}(string)"/>. For example,
    /// if a font was being loaded then this type would be set to 'SpriteFont'.</typeparam>
    public class XnaResourceProcessor<ResourceType, XnaResourceType> : ResourceProcessor<ResourceType>
    {
        /// <summary>
        /// Constructor.
        /// </summary>
        /// <param name="services">The services instance to grab services from 
        /// and give services to.</param>
        /// <param name="factory">A method that can take an XNA resource 
        /// (XnaResourceType) and turn it into the resource type you want to 
        /// load (ResourceType).</param>
        public XnaResourceProcessor(IEventCollection<object> services, Func<XnaResourceType, ResourceType> factory)
        {
            services.Inject(this);
            Factory = factory;
        }

        /// <summary>
        /// Loads the specified XNA resource type.
        /// </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<ResourceType> callback, Stream readFrom, params IOption[] options)
        {
            ResourceName resourceName = options.OfType<ResourceName>().FirstOrDefault();
            if (resourceName != null)
            {
                ResourceType resource = Factory(Content.Load<XnaResourceType>(resourceName.Name));
                callback(new ResourceProcessResult<ResourceType>(resource, null, true, true));
            }
            else
                CheckedNextFrom(callback, readFrom, options);
        }

        /// <summary>
        /// Because XNA cannot write out resources using the ContentManager, this
        /// method just sends the processing to the next resource processing using
        /// ResourceProcessor.CheckedNextTo().
        /// </summary>
        /// <param name="resource">The resource to write out to the stream.</param>
        /// <param name="writeTo">The stream to write the resource out to.</param>
        /// <param name="options">Options for controlling the writing of the resource.</param>
        public override void To(ResourceType resource, System.IO.Stream writeTo, params IOption[] options)
        {
            CheckedNextTo(resource, writeTo, options);
        }

        /// <summary>
        /// The XNA ContentManager to load content with.
        /// </summary>
        [Inject]
        public ContentManager Content { get; set; }

        /// <summary>
        /// The method that creates the ResourceType from the XnaResourceType
        /// that was loaded from a call to 
        /// <see cref="ContentManager.Load{XnaResourceType}(string)"/>.
        /// </summary>
        public Func<XnaResourceType, ResourceType> Factory { get; set; }
    }
}