using System;
using System.IO;
using Chernobyl.DesignPatterns.Command;

namespace Chernobyl.Resources
{
    /// <summary>
    /// An <see cref="IResourceProcessor{TResource}"/> that holds onto resource
    /// processing requests until it is told to let them through using the
    /// <see cref="AllowThrough()"/> or <see cref="AllowThrough(object, EventArgs)"/>
    /// methods.
    /// </summary>
    /// <typeparam name="TResource">The type of the resource.</typeparam>
    public class WaitResourceProcessor<TResource> : ResourceProcessor<TResource>
    {
        /// <summary>
        /// Initializes a new instance of the 
        /// <see cref="WaitResourceProcessor{TResource}"/> class.
        /// </summary>
        public WaitResourceProcessor()
        {
            FromCommands = new CommandCollection();
            ToCommands = new CommandCollection();
        }

        /// <summary>
        /// Allows all of the previously stopped processing requests to be handled.
        /// </summary>
        public void AllowThrough()
        {
            AreBeingAllowedThrough = true;
            
            FromCommands.Execute();
            FromCommands.Clear();

            ToCommands.Execute();
            ToCommands.Clear();
        }

        /// <summary>
        /// An event handler that can be assigned to an event. This method does 
        /// the same thing as the <see cref="AllowThrough()"/> method.
        /// </summary>
        /// <param name="sender">The sender of the event.</param>
        /// <param name="e">The <see cref="EventArgs"/> instance containing 
        /// the event data.</param>
        public void AllowThrough(object sender, EventArgs e)
        {
            AllowThrough();
        }

        /// <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<TResource> callback, Stream readFrom, params IOption[] options)
        {
            if(AreBeingAllowedThrough == true)
                CheckedNextFrom(callback, readFrom, options);
            else
                FromCommands.Add(new FromRequest(this, callback, readFrom, options));
        }

        /// <summary>
        /// Writes the resource to the stream specified.
        /// </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(TResource resource, Stream writeTo, params IOption[] options)
        {
            if(AreBeingAllowedThrough == true)
                CheckedNextTo(resource, writeTo, options);
            else
                ToCommands.Add(new ToRequest(this, resource, writeTo, options));
        }

        /// <summary>
        /// True if the requests are being allowed through, false if otherwise.
        /// </summary>
        public bool AreBeingAllowedThrough { get; private set; }

        /// <summary>
        /// The 'from' requests to this <see cref="IResourceProcessor{T}"/>.
        /// </summary>
        CommandCollection FromCommands { get; set; }

        /// <summary>
        /// The 'to' requests to this <see cref="IResourceProcessor{T}"/>.
        /// </summary>
        CommandCollection ToCommands { get; set; }

        /// <summary>
        /// Represents a request made to an <see cref="WaitResourceProcessor{T}"/>.
        /// </summary>
        abstract class Request : ICommand
        {
            /// <summary>
            /// Initializes a new instance of the 
            /// <see cref="WaitResourceProcessor{TResource}.Request"/> struct.
            /// </summary>
            /// <param name="resourceProcessor">The 
            /// <see cref="IResourceProcessor{TResource}"/> that will be used 
            /// to process the request.</param>
            /// <param name="stream">The stream to load or write the resource 
            /// from or to.</param>
            /// <param name="options">Options for the loading or processing of the
            /// resource.</param>
            public Request(IResourceProcessor<TResource> resourceProcessor, Stream stream, params IOption[] options)
            {
                ResourceProcessor = resourceProcessor;
                Stream = stream;
                Options = options;
            }

            /// <summary>
            /// The <see cref="IResourceProcessor{TResource}"/> that will be used 
            /// to process the request.
            /// </summary>
           protected IResourceProcessor<TResource> ResourceProcessor { get; private set; }

            /// <summary>
            /// The stream to load or write the resource from or to.
            /// </summary>
           protected Stream Stream { get; private set; }

            /// <summary>
            /// Options for the loading or processing of the resource.
            /// </summary>
           protected IOption[] Options { get; private set; }

            /// <summary>
            /// Performs the command in question.
            /// </summary>
            public abstract void Execute();

            /// <summary>
            /// Causes the command to be reverted if it was previously executed. This
            /// method only works if <see cref="CanUndo"/> is equal to <c>true</c>.
            /// By default, this method throws an <see cref="CannotUndoException"/>.
            /// </summary>
            /// <exception cref="CannotUndoException">Thrown if this
            /// <see cref="ICommand"/> does not support undo (i.e.,
            /// <see cref="CanUndo"/> is false).</exception>
            public virtual void Undo()
            {
                throw new CannotUndoException();
            }

            /// <summary>
            /// True if this <see cref="ICommand"/> can be reverted after a call to
            /// <see cref="Execute()"/>, false if otherwise. By default, this 
            /// property returns false.
            /// </summary>
            public virtual bool CanUndo { get { return false; } }
        }

        /// <summary>
        /// Represents a 
        /// <see cref="IResourceProcessor{T}.From(ResourceProcessCallback{T}, Stream, IOption[])"/> 
        /// request made to an <see cref="WaitResourceProcessor{T}"/>.
        /// </summary>
        class FromRequest : Request
        {
            /// <summary>
            /// Initializes a new instance of the 
            /// <see cref="WaitResourceProcessor{TResource}.FromRequest"/> class.
            /// </summary>
            /// <param name="resourceProcessor">The 
            /// <see cref="IResourceProcessor{TResource}"/> that will be used 
            /// to process the request.</param>
            /// <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 FromRequest(IResourceProcessor<TResource> resourceProcessor, ResourceProcessCallback<TResource> callback, Stream readFrom, params IOption[] options)
                : base(resourceProcessor, readFrom, options)
            {
                Callback = callback;
            }

            /// <summary>
            /// Performs the command in question.
            /// </summary>
            public override void Execute()
            {
                ResourceProcessor.From(Callback, Stream, Options);
            }

            /// <summary>
            /// The callback that will be invoked when the resource has been 
            /// loaded.
            /// </summary>
            protected ResourceProcessCallback<TResource> Callback { get; private set; }
        }

        /// <summary>
        /// Represents a 
        /// <see cref="IResourceProcessor{T}.To(T, Stream, IOption[])"/> 
        /// request made to an <see cref="WaitResourceProcessor{T}"/>.
        /// </summary>
        class ToRequest : Request
        {
            /// <summary>
            /// Initializes a new instance of the 
            /// <see cref="WaitResourceProcessor{TResource}.FromRequest"/> class.
            /// </summary>
            /// <param name="resourceProcessor">The 
            /// <see cref="IResourceProcessor{TResource}"/> that will be used 
            /// to process the request.</param>
            /// <param name="resource">The resource that is to be written to the 
            /// stream.</param>
            /// <param name="writeTo">The stream to write the resource to.</param>
            /// <param name="options">Options for the loading or processing of the
            /// resource.</param>
            public ToRequest(IResourceProcessor<TResource> resourceProcessor, TResource resource, Stream writeTo, params IOption[] options)
                : base(resourceProcessor, writeTo, options)
            {
                Resource = resource;
            }

            /// <summary>
            /// Performs the command in question.
            /// </summary>
            public override void Execute()
            {
                ResourceProcessor.To(Resource, Stream, Options);
            }

            /// <summary>
            /// The resource that is to be written to the stream.
            /// </summary>
            protected TResource Resource { get; private set; }
        }
    }
}