using System;
using System.IO;
using System.Threading;
using Chernobyl.Collections.Generic;

namespace Chernobyl.Resources
{
    /// <summary>
    /// An interface for handling the individual nodes of a resource pipeline. 
    /// The resource processor generates or writes out a resource to or from 
    /// a stream by passing the resource and the stream through a linked list 
    /// like structure of other resource processors. 
    /// </summary>
    /// <typeparam name="TResource">The type of resource to generate or write 
    /// out.</typeparam>
    public interface IResourceProcessor<TResource> : ILinkedEnumerable<IResourceProcessor<TResource>>
    {
        /// <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. The resource can be accessed through the 
        /// <see cref="IAsyncResult.AsyncState"/> property of the 
        /// <see cref="IAsyncResult"/> passed to the <paramref name="callback"/> 
        /// (it will need to be casted to <typeparamref name="TResource"/>). </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>
        void From(ResourceProcessCallback<TResource> callback, Stream readFrom, params IOption[] 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 write out the resources data to
        /// the passed in <paramref name="writeTo"/> stream. If 
        /// it is able to write it out, then it should do so and 
        /// NOT call the next resource processor. If the next
        /// resource processor is null, then the resource processor
        /// should write out a message to the Console stating that
        /// the resource could not be written out to the stream 
        /// because no resource processor existed that could perform
        /// the task (note: <see cref="ResourceProcessor{ResourceType}"/> has
        /// methods to make this error checking easier and cleaner).
        /// </summary>
        /// <param name="resource">The resource to write out.</param>
        /// <param name="writeTo">The stream to write the resource to.</param>
        /// <param name="options">Options for the writing or processing of the resource.</param>
        void To(TResource resource, Stream writeTo, params IOption[] options);

        /// <summary>
        /// The next resource processor in the pipeline. If a resource processor
        /// is unable to generate/write out the resource, then it must call the
        /// corresponding function on this resource (provided it isn't null).
        /// </summary>
        IResourceProcessor<TResource> NextResourceProcessor { get; set; }
    }

    /// <summary>
    /// References a method to be called when a corresponding resource processing 
    /// operation completes.
    /// </summary>
    public delegate void ResourceProcessCallback<TResource>(IResourceProcessResult<TResource> result);

    /// <summary>
    /// Represents the status of the processing of a resource.
    /// 
    /// <seealso cref="ResourceProcessResult{TResource}"/>
    /// </summary>
    /// <typeparam name="TResource">The type of the resource that was loaded.</typeparam>
    public interface IResourceProcessResult<TResource> : IAsyncResult
    {
        /// <summary>
        /// The resource that was loaded. This should just return the 
        /// <see cref="IAsyncResult.AsyncState"/> casted to 
        /// <typeparamref name="TResource"/>.
        /// </summary>
        TResource Resource { get; }
    }

    /// <summary>
    /// A default implementation of the <see cref="IResourceProcessResult{TResource}"/> 
    /// interface.
    /// </summary>
    /// <typeparam name="TResource">The type of the resource that was loaded.</typeparam>
    public class ResourceProcessResult<TResource> : IResourceProcessResult<TResource>
    {
        /// <summary>
        /// Initializes a new instance of the <see cref="ResourceProcessResult&lt;TResource&gt;"/> class.
        /// </summary>
        /// <param name="resource">The resource that was loaded.</param>
        /// <param name="waitHandle">A <see cref="WaitHandle"/> that is used 
        /// to wait for an asynchronous operation to complete.</param>
        /// <param name="completedSynchronously">True if the operation was 
        /// completed synchronously, false if otherwise.</param>
        /// <param name="isCompleted">True if the operation is completed, false 
        /// if otherwise.</param>
        public ResourceProcessResult(TResource resource, WaitHandle waitHandle, bool completedSynchronously, bool isCompleted)
        {
            AsyncState = resource;
            AsyncWaitHandle = waitHandle;
            CompletedSynchronously = completedSynchronously;
            IsCompleted = isCompleted;
        }

        /// <summary>
        /// The resource that was loaded. This should just return the
        /// <see cref="IAsyncResult.AsyncState"/> casted to
        /// <typeparamref name="TResource"/>.
        /// </summary>
        public TResource Resource { get { return (TResource)AsyncState; } }

        /// <summary>
        /// Gets a user-defined object that qualifies or contains information
        /// about an asynchronous operation.
        /// </summary>
        /// <returns>A user-defined object that qualifies or contains information 
        /// about an asynchronous operation.</returns>
        public object AsyncState { get; private set; }

        /// <summary>
        /// Gets a <see cref="WaitHandle"/> that is used to wait for an
        /// asynchronous operation to complete.
        /// </summary>
        /// <returns>A <see cref="WaitHandle"/> that is used to wait for an
        /// asynchronous operation to complete.</returns>
        public WaitHandle AsyncWaitHandle { get; private set; }

        /// <summary>
        /// Gets an indication of whether the asynchronous operation completed
        /// synchronously.
        /// </summary>
        /// <returns>true if the asynchronous operation completed synchronously; 
        /// otherwise, false.</returns>
        public bool CompletedSynchronously { get; private set; }

        /// <summary>
        /// Gets an indication whether the asynchronous operation has completed.
        /// </summary>
        /// <returns>true if the operation is complete; otherwise, false.</returns>
        public bool IsCompleted { get; private set; }
    }
}