//------------------------------------------------------------------------------
// <copyright file="BitmapSelector.cs" company="Microsoft">
//     Copyright (c) Microsoft Corporation.  All rights reserved.
// </copyright>                                                                
//------------------------------------------------------------------------------

namespace System.Drawing {
    using System;
    using System.Configuration;
    using System.Drawing.Configuration;
    using System.IO;
    using System.Reflection;

    /// <summary>
    /// Provides methods to select from multiple bitmaps depending on a "bitmapSuffix" config setting.
    /// </summary>
    internal static class BitmapSelector {

        /// <summary>
        /// Gets the bitmap ID suffix defined in the application configuration, or string.Empty if
        /// the suffix is not specified.  Internal for unit tests
        /// </summary>
        /// <remarks>
        /// For performance, the suffix is cached in a static variable so it only has to be read
        /// once per appdomain.
        /// </remarks>
        private static string _suffix;
        internal static string Suffix {
            get {
                if (_suffix == null) {
                    _suffix = string.Empty;
                    var section = ConfigurationManager.GetSection("system.drawing") as SystemDrawingSection;
                    if (section != null) {
                        var value = section.BitmapSuffix;
                        if (value != null && value is string) {
                            _suffix = (string)value;
                        }
                    }
                }
                return _suffix;
            }
            set {
                // So unit tests can clear the cached suffix
                _suffix = value;
            }
        }

        /// <summary>
        /// Appends the current suffix to <paramref name="filePath"/>.  The suffix is appended
        /// before the existing extension (if any).  Internal for unit tests.
        /// </summary>
        /// <returns>
        /// The new path with the suffix included.  If there is no suffix defined or there are
        /// invalid characters in the original path, the original path is returned.
        /// </returns>
        internal static string AppendSuffix(string filePath) {
            try {
                return Path.ChangeExtension(filePath, Suffix + Path.GetExtension(filePath));
            }
            catch (ArgumentException) { // there are invalid characters in the path
                return filePath;
            }
        }

        /// <summary>
        /// Returns <paramref name="originalPath"/> with the current suffix appended (before the
        /// existing extension) if the resulting file path exists; otherwise the original path is
        /// returned.
        /// </summary>
        public static string GetFileName(string originalPath) {
            if (Suffix == string.Empty)
                return originalPath;

            string newPath = AppendSuffix(originalPath);
            return File.Exists(newPath) ? newPath : originalPath;
        }

        // Calls assembly.GetManifestResourceStream in a try/catch and returns null if not found
        private static Stream GetResourceStreamHelper(Assembly assembly, Type type, string name) {
            Stream stream = null;
            try {
                stream = assembly.GetManifestResourceStream(type, name);
            }
            catch (FileNotFoundException) {
            }
            return stream;
        }

        private static bool DoesAssemblyHaveCustomAttribute(Assembly assembly, string typeName) {
            return DoesAssemblyHaveCustomAttribute(assembly, assembly.GetType(typeName));
        }

        private static bool DoesAssemblyHaveCustomAttribute(Assembly assembly, Type attrType) {
            if (attrType != null) {
                var attr = assembly.GetCustomAttributes(attrType, false);
                if (attr.Length > 0) {
                    return true;
                }
            }
            return false;
        }

        // internal for unit tests
        internal static bool SatelliteAssemblyOptIn(Assembly assembly) {
            // Try 4.5 public attribute type first
            if (DoesAssemblyHaveCustomAttribute(assembly, typeof(BitmapSuffixInSatelliteAssemblyAttribute))) {
                return true;
            }

            // Also load attribute type by name for dlls compiled against older frameworks
            return DoesAssemblyHaveCustomAttribute(assembly, "System.Drawing.BitmapSuffixInSatelliteAssemblyAttribute");
        }

        // internal for unit tests
        internal static bool SameAssemblyOptIn(Assembly assembly) {
            // Try 4.5 public attribute type first
            if (DoesAssemblyHaveCustomAttribute(assembly, typeof(BitmapSuffixInSameAssemblyAttribute))) {
                return true;
            }

            // Also load attribute type by name for dlls compiled against older frameworks
            return DoesAssemblyHaveCustomAttribute(assembly, "System.Drawing.BitmapSuffixInSameAssemblyAttribute");
        }

        /// <summary>
        /// Returns a resource stream loaded from the appropriate location according to the current
        /// suffix.
        /// </summary>
        /// <param name="assembly">The assembly from which the stream is loaded</param>
        /// <param name="type">The type whose namespace is used to scope the manifest resource name</param>
        /// <param name="originalName">The name of the manifest resource being requested</param>
        /// <returns>
        /// The manifest resource stream corresponding to <paramref name="originalName"/> with the
        /// current suffix applied; or if that is not found, the stream corresponding to <paramref name="originalName"/>.
        /// </returns>
        public static Stream GetResourceStream(Assembly assembly, Type type, string originalName) {
            if (Suffix != string.Empty) {
                try {
                    // Resource with suffix has highest priority
                    if (SameAssemblyOptIn(assembly)) {
                        string newName = AppendSuffix(originalName);
                        Stream stream = GetResourceStreamHelper(assembly, type, newName);
                        if (stream != null) {
                            return stream;
                        }
                    }
                }
                catch {
                    // Ignore failures and continue to try other options
                }

                try {
                    // Satellite assembly has second priority, using the original name
                    if (SatelliteAssemblyOptIn(assembly)) {
                        AssemblyName assemblyName = assembly.GetName();
                        assemblyName.Name += Suffix;
                        assemblyName.ProcessorArchitecture = ProcessorArchitecture.None;
                        Assembly satellite = Assembly.Load(assemblyName);
                        if (satellite != null) {
                            Stream stream = GetResourceStreamHelper(satellite, type, originalName);
                            if (stream != null) {
                                return stream;
                            }
                        }
                    }
                }
                catch {
                    // Ignore failures and continue to try other options
                }
            }

            // Otherwise fall back to specified assembly and original name requested
            return assembly.GetManifestResourceStream(type, originalName);
        }

        /// <summary>
        /// Returns a resource stream loaded from the appropriate location according to the current
        /// suffix.
        /// </summary>
        /// <param name="type">The type from whose assembly the stream is loaded and whose namespace is used to scope the resource name</param>
        /// <param name="originalName">The name of the manifest resource being requested</param>
        /// <returns>
        /// The manifest resource stream corresponding to <paramref name="originalName"/> with the
        /// current suffix applied; or if that is not found, the stream corresponding to <paramref name="originalName"/>.
        /// </returns>
        public static Stream GetResourceStream(Type type, string originalName) {
            return GetResourceStream(type.Module.Assembly, type, originalName);
        }

        /// <summary>
        /// Returns an Icon created  from a resource stream loaded from the appropriate location according to the current
        /// suffix.
        /// </summary>
        /// <param name="type">The type from whose assembly the stream is loaded and whose namespace is used to scope the resource name</param>
        /// <param name="originalName">The name of the manifest resource being requested</param>
        /// <returns>
        /// The icon created from a manifest resource stream corresponding to <paramref name="originalName"/> with the
        /// current suffix applied; or if that is not found, the stream corresponding to <paramref name="originalName"/>.
        /// </returns>
        public static Icon CreateIcon(Type type, string originalName) {
            return new Icon(GetResourceStream(type, originalName));
        }

        /// <summary>
        /// Returns an Bitmap created  from a resource stream loaded from the appropriate location according to the current
        /// suffix.
        /// </summary>
        /// <param name="type">The type from whose assembly the stream is loaded and whose namespace is used to scope the resource name</param>
        /// <param name="originalName">The name of the manifest resource being requested</param>
        /// <returns>
        /// The bitmap created from a manifest resource stream corresponding to <paramref name="originalName"/> with the
        /// current suffix applied; or if that is not found, the stream corresponding to <paramref name="originalName"/>.
        /// </returns>
        public static Bitmap CreateBitmap(Type type, string originalName) {
            return new Bitmap(GetResourceStream(type, originalName));
        }

    }
}