//******************************************************************************************************
//  FastObjectFactory.cs - Gbtc
//
//  Copyright © 2012, Grid Protection Alliance.  All Rights Reserved.
//
//  Licensed to the Grid Protection Alliance (GPA) under one or more contributor license agreements. See
//  the NOTICE file distributed with this work for additional information regarding copyright ownership.
//  The GPA licenses this file to you under the MIT License (MIT), the "License"; you may
//  not use this file except in compliance with the License. You may obtain a copy of the License at:
//
//      http://www.opensource.org/licenses/MIT
//
//  Unless agreed to in writing, the subject software distributed under the License is distributed on an
//  "AS-IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. Refer to the
//  License for the specific language governing permissions and limitations.
//
//  Code Modification History:
//  ----------------------------------------------------------------------------------------------------
//  01/25/2010 - James R. Carroll
//       Generated original version of source code.
//  12/14/2012 - Starlynn Danyelle Gilliam
//       Modified Header.
//  12/20/2013 - Pinal C. Patel
//       Updated the dictionary used for caching the activators returned by GetCreateObjectFunction<T>() 
//       to not use Type for the key but instead use a combined hash of Type whose activator is to be
//       created along with the Type being returned. This enables scenarios where multiple activators
//       of the same type needs to be created but the return type needs to different.
//
//******************************************************************************************************

using System;
using System.Collections.Concurrent;
using System.Reflection;
using System.Reflection.Emit;

namespace GSF
{
    /// <summary>
    /// Quickly creates new objects based on specified type.
    /// </summary>
    /// <typeparam name="T">Type of object to create quickly.</typeparam>
    /// <remarks>
    /// You can use the alternate <see cref="FastObjectFactory"/> implementation if you only have the <see cref="Type"/> of
    /// an object available (such as when you are using reflection).
    /// </remarks>
    public static class FastObjectFactory<T> where T : class, new()
    {
        // Static object creation delegate specific to type T - one instance will be created per type by the compiler
        private static readonly Func<T> s_createObjectFunction;

        static FastObjectFactory()
        {
            Type type = typeof(T);
            ConstructorInfo constructor = type.GetConstructor(Type.EmptyTypes);

            if ((object)constructor == null)
                throw new InvalidOperationException("No parameterless constructor exists for type " + type.FullName);

            // This is markedly faster than using Activator.CreateInstance
            DynamicMethod method = new DynamicMethod("ctor$" + type.Name, type, null, type);
            ILGenerator generator = method.GetILGenerator();

            generator.Emit(OpCodes.Newobj, constructor);
            generator.Emit(OpCodes.Ret);

            s_createObjectFunction = (Func<T>)method.CreateDelegate(typeof(Func<T>));
        }

        /// <summary>
        /// Gets delegate that quickly creates new instance of the specified type.
        /// </summary>
        public static Func<T> CreateObjectFunction
        {
            get
            {
                return s_createObjectFunction;
            }
        }
    }

    /// <summary>
    /// Quickly creates new objects based on specified type.
    /// </summary>
    /// <remarks>
    /// <see cref="FastObjectFactory"/> should be used when you only have the <see cref="Type"/> of an object available (such as when you are
    /// using reflection), otherwise you should use the generic <see cref="FastObjectFactory{T}"/>.
    /// </remarks>
    public static class FastObjectFactory
    {
        // We cache object creation functions by type so they are only created once
        private static readonly ConcurrentDictionary<int, Delegate> s_createObjectFunctions = new ConcurrentDictionary<int, Delegate>();

        /// <summary>
        /// Gets delegate that creates new instance of the <paramref name="type"/>.
        /// </summary>
        /// <param name="type">Type of object to create quickly.</param>
        /// <returns>Delegate to use to quickly create new objects.</returns>
        /// <exception cref="InvalidOperationException"><paramref name="type"/> does not support parameterless public constructor.</exception>
        public static Func<object> GetCreateObjectFunction(Type type)
        {
            return GetCreateObjectFunction<object>(type);
        }

        /// <summary>
        /// Gets delegate of specified return type that creates new instance of the <paramref name="type"/>.
        /// </summary>
        /// <param name="type">Type of object to create quickly.</param>
        /// <typeparam name="T">Type of returned object function used to create objects quickly.</typeparam>
        /// <returns>Delegate to use to quickly create new objects.</returns>
        /// <exception cref="InvalidOperationException">
        /// <paramref name="type"/> does not support parameterless public constructor -or- 
        /// <paramref name="type"/> is not a subclass or interface implementation of function type definition.
        /// </exception>
        /// <remarks>
        /// This function will validate that <typeparamref name="T"/> is related to <paramref name="type"/>.
        /// </remarks>
        public static Func<T> GetCreateObjectFunction<T>(Type type)
        {
            // Since user can call this function with any type, we verify that it is related to the return type. If return type
            // is a class, see if type derives from it, else if return type is an interface, see if type implements it.
            Type typeT = typeof(T);

            if (type.IsAbstract || ((!typeT.IsClass || !type.IsSubclassOf(typeT)) && (!typeT.IsInterface || (object)type.GetInterface(typeT.Name) == null)))
                throw new InvalidOperationException("Specified type parameter is not a subclass or interface implementation of function type definition");

            int key;
#if MONO
            // Type.GUID always returns zero guid on Mono
            key = type.FullName.GetHashCode() ^ typeT.FullName.GetHashCode();
#else
            key = type.GUID.GetHashCode() ^ typeT.GUID.GetHashCode();
#endif
            return (Func<T>)s_createObjectFunctions.GetOrAdd(key, k =>
            {
                // Get parameterless constructor for this type
                ConstructorInfo constructor = type.GetConstructor(Type.EmptyTypes);

                if ((object)constructor == null)
                    throw new InvalidOperationException("No parameterless constructor exists for type " + type.FullName);

                // This is markedly faster than using Activator.CreateInstance
                DynamicMethod method = new DynamicMethod("ctor_type$" + type.Name, type, null, type);
                ILGenerator generator = method.GetILGenerator();

                generator.Emit(OpCodes.Newobj, constructor);
                generator.Emit(OpCodes.Ret);

                return (Func<T>)method.CreateDelegate(typeof(Func<T>));
            });
        }
    }
}