using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Text.RegularExpressions;
using Chernobyl.Collections.Generic.Event;

namespace Chernobyl.Resources
{
    /// <summary>
    /// Holds a set of <see cref="IResourceProcessor{TResource}"/> each with a 
    /// file pattern that they can read or write. When this processor receives a 
    /// <see cref="Stream"/> it first tries to cast it to a <see cref="FileStream"/>, 
    /// grab the file path to the file it represents using 
    /// <see cref="FileStream.Name"/>, and looks for the 
    /// <see cref="IResourceProcessor{TResource}"/> that has a matching pattern. 
    /// If it finds one, it passes the processing onto that processor. Otherwise, 
    /// it sends the processing down to the 
    /// <see cref="IResourceProcessor{TResource}.NextResourceProcessor"/>.
    /// </summary>
    /// <typeparam name="TResource">The type of resource to process.</typeparam>
    public class FileStreamProcessor<TResource> : ResourceProcessor<TResource>
    {
        /// <summary>
        /// Constructor
        /// </summary>
        /// <param name="services">The services object whose services will be injected 
        /// into this file stream processor.</param>
        public FileStreamProcessor(IEventCollection<object> services)
        {
            FileStreamProcessors = new Dictionary<string, IResourceProcessor<TResource>>();
        }

        /// <summary>
        /// Attempts to load the resource by finding a resource processor with
        /// a file pattern that matches the path of the <see cref="FileStream"/> 
        /// path.
        /// </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. Available options for this processor:
        /// <list type="bullet">
        ///     <item><see cref="RegexSearchOption"/></item>
        /// </list></param>
        public override void From(ResourceProcessCallback<TResource> callback, Stream readFrom, params IOption[] options)
        {
            FileStream file = readFrom as FileStream;
            if (file != null)
            {
                // get the search options, if their are any
                IEnumerable<RegexSearchOption> option = options.OfType<RegexSearchOption>();

                foreach (KeyValuePair<string, IResourceProcessor<TResource>> keyValues in FileStreamProcessors)
                {
                    // if the user specified options, apply them
                    if (option.Count() == 0)
                    {
                        if (Regex.IsMatch(file.Name, keyValues.Key) == true)
                            keyValues.Value.From(callback, readFrom, options);
                    }
                    else
                        if (Regex.IsMatch(file.Name, keyValues.Key, option.First().RegexOptions) == true)
                            keyValues.Value.From(callback, readFrom, options);
                }
            }
            else
                CheckedNextFrom(callback, readFrom, options);
        }

        /// <summary>
        /// Attempts to write out the resource by finding a resource processor with
        /// a file pattern that matches the path of the FileStream path.
        /// </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.
        /// Available options for this processor:
        /// <list type="bullet">
        ///     <item><see cref="RegexSearchOption"/></item>
        /// </list>
        /// </param>
        public override void To(TResource resource, Stream writeTo, params IOption[] options)
        {
            FileStream file = writeTo as FileStream;
            if (file != null)
            {
                // get the search options, if their are any
                IEnumerable<RegexSearchOption> option = options.OfType<RegexSearchOption>();

                foreach (KeyValuePair<string, IResourceProcessor<TResource>> keyValues in FileStreamProcessors)
                {
                    // if the user specified options, apply them
                    if (option.Count() == 0)
                    {
                        if (Regex.IsMatch(file.Name, keyValues.Key) == true)
                            keyValues.Value.To(resource, writeTo, options);
                    }
                    else
                        if (Regex.IsMatch(file.Name, keyValues.Key, option.First().RegexOptions) == true)
                            keyValues.Value.To(resource, writeTo, options);
                }
            }
            else
                CheckedNextTo(resource, writeTo, options);
        }

        /// <summary>
        /// Adds a resource processor that loads a particular extension.
        /// </summary>
        /// <param name="fileExtensions">The file extensions that 
        /// <paramref name="resourceProcessor"/> loads without the initial '.'.
        /// For example: "xml", "png", etc. You can also combine multiple 
        /// extensions using the pipe character ('|') like so: "xml|png|pdf"</param>
        /// <param name="resourceProcessor"></param>
        public void AddProcessor(string fileExtensions, IResourceProcessor<TResource> resourceProcessor)
        {
            FileStreamProcessors.Add("^.*\\.(" + fileExtensions + ")$", resourceProcessor);
        }

        /// <summary>
        /// The resource processors and the file patterns (in regex form) that 
        /// they can process. If a resource processor has multiple file patterns 
        /// that it can process then it should add itself for each one or use a 
        /// regex pattern that can handle multiple file patterns.
        /// </summary>
        public Dictionary<string, IResourceProcessor<TResource>> FileStreamProcessors { get; set; }

        /// <summary>
        /// An option for the FileStreamResourceProcessor. Allows you to
        /// specify the RegexOptions used to search for the file pattern.
        /// </summary>
        public struct RegexSearchOption : IOption
        {
            /// <summary>
            /// Constructor.
            /// </summary>
            /// <param name="regexOptions">The options to apply to the Regex.IsMatch() 
            /// search against the file pattern for the ResourceProcessor.</param>
            public RegexSearchOption(RegexOptions regexOptions) : this()
            {
                RegexOptions = regexOptions;
            }

            /// <summary>
            /// The options to apply to the Regex.IsMatch() 
            /// search against the file pattern for the ResourceProcessor.
            /// </summary>
            public RegexOptions RegexOptions {get; set;}
        }
    }
}