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

namespace Chernobyl.Resources
{
    /// <summary>
    /// An <see cref="IResourceProcessor{ResourceType}"/> that is used to store 
    /// all resources that are properly loaded.
    /// </summary>
    /// <typeparam name="TResource">The type of the resource being loaded and 
    /// written out. This type must be a class because this class holds the 
    /// resources in <see cref="WeakReference{T}"/> objects </typeparam>
    public class ResourceRegistry<TResource> : ResourceProcessor<TResource> where TResource : class
    {
        /// <summary>
        /// Initializes a new instance of the <see cref="ResourceRegistry{ResourceType}"/> class.
        /// </summary>
        public ResourceRegistry()
        {
            ResourcesDecoratingEventList = new DecoratingEventList<TResource>(new WeakReferenceList<TResource>());
        }

        /// <summary>
        /// An even that is invoked when a resource has been added.
        /// </summary>
        public event EventHandler<ItemsEventArgs<TResource>> ResourcesAdded
        {
            add { ResourcesDecoratingEventList.ItemsAdded += value; }
            remove { ResourcesDecoratingEventList.ItemsAdded -= value; }
        }

        /// <summary>
        /// An even that is invoked when a resource has been removed.
        /// </summary>
        public event EventHandler<ItemsEventArgs<TResource>> ResourcesRemoved
        {
            add { ResourcesDecoratingEventList.ItemsRemoved += value; }
            remove { ResourcesDecoratingEventList.ItemsRemoved -=  value; }
        }

        /// <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>
        public override void From(ResourceProcessCallback<TResource> callback, Stream readFrom, params IOption[] options)
        {
            ResourceProcessCallback<TResource> addResourceCallback =
                result =>
                    {
                        TResource resource = result.Resource;
                        if (resource != null && Resources.Contains(resource) == false)
                            Resources.Add(resource);

                        callback(result);
                    };

            CheckedNextFrom(addResourceCallback, 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)
        {
            CheckedNextTo(resource, writeTo, options);
        }

        /// <summary>
        /// Holds the resources that have already been loaded.
        /// </summary>
        public IList<TResource> Resources { get { return ResourcesDecoratingEventList; } }

        /// <summary>
        /// The <see cref="Resources"/> list as an <see cref="DecoratingEventList{T}"/>.
        /// </summary>
        protected DecoratingEventList<TResource> ResourcesDecoratingEventList { get; set; }
    }
}