using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;

namespace Chernobyl.Resources
{
    /// <summary>
    /// Used to cache resources that were loaded in from a FileStream so that
    /// they can be retrieved quickly on the next call to From(). This is done
    /// by mapping the filepath from the FileStream to the loaded in resource.
    /// </summary>
    /// <typeparam name="TResource">The resource type to load in.</typeparam>
    public class FileStreamResourceMapper<TResource> : ResourceProcessor<TResource>
    {
        /// <summary>
        /// Constructor.
        /// </summary>
        public FileStreamResourceMapper()
        {
            // On Windows, we want case-insensitive comparisons but not on Unix
            // where case sensitivity is expected.
            if (Environment.OSVersion.Platform != PlatformID.Unix)
                ResourceMap = new Dictionary<string, TResource>(StringComparer.OrdinalIgnoreCase);
            else
                ResourceMap = new Dictionary<string, TResource>();
        }

        /// <summary>
        /// Attempts to cast the <see cref="Stream"/> passed in to a 
        /// <see cref="FileStream"/> and uses the file path in 
        /// <see cref="FileStream.Name"/> to locate and return the resource in 
        /// case it has already been processed.
        /// </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. This <see cref="IResourceProcessor{TResource}"/> does not 
        /// currently use any options.</param>
        public override void From(ResourceProcessCallback<TResource> callback, Stream readFrom, params IOption[] options)
        {
            // try to retrieve the resource
            FileStream file = readFrom as FileStream;
            if (file != null)
            {
                // We use Path.GetFullPath(String) to ensure the names stored
                // and compared to in the map are all full paths. This avoids 
                // any issues where you reference the same file but with different
                // string values. Additionally, we cut out any trailing slashes
                // as Path.GetFullPath(String) doesn't seem to standardize on 
                // trailing slashes very well. See here for more details:
                // http://stackoverflow.com/questions/2281531/how-can-i-compare-directory-paths-in-c
                String filePath = Path.GetFullPath(file.Name).TrimEnd('\\');

                // If we have a ResourceName append that to the end of the file
                // path so we can properly differentiate between resources that 
                // belong to the same file but have different names.
                ResourceName resourceName = options.OfType<ResourceName>().FirstOrDefault();
                if (resourceName != null)
                    filePath = filePath + resourceName.Name;

                TResource resource;
                if (ResourceMap.TryGetValue(filePath, out resource) == true)
                    callback(new ResourceProcessResult<TResource>(resource, null, true, true));
                else
                {
                    // the resource was not in the map so we are going to allow 
                    // the other resource processors to process it and map the result.
                    // To do this, we will create a callback wrapper around the 
                    // callback we received.
                    ResourceProcessCallback<TResource> addResource =
                            result =>
                            {
                                ResourceMap.Add(filePath, result.Resource);
                                callback(result);
                            };

                    CheckedNextFrom(addResource, readFrom, options);
                }
            }
            else
            {
                // the stream passed in is not a FileStream so we just allow the other processors
                // to work their magic
                CheckedNextFrom(callback, readFrom, options);   
            }
        }

        /// <summary>
        /// Passes on processing to the next resource.
        /// </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 and the file paths that they were loaded from.
        /// </summary>
        Dictionary<string, TResource> ResourceMap {get; set;}
    }
}