using System;
using System.Linq;
using System.Linq.Expressions;
using System.Reflection;
using System.Collections.Generic;

namespace TheFunctionFactory
{
    /// <summary>
    /// Creates and compiles a Func using expressions
    /// </summary>
    /// <remarks>
    /// Inspired from:
    /// http://abhi.dcmembers.com/blog/2009/03/25/lambda-based-reflection-vs-normal-reflection-vs-direct-call-4/
    /// </remarks>
    public static class FunctionFactory
    {
/// <summary>
/// Creates a compiled delegate function for the specified type and method name
/// </summary>
/// <typeparam name="TFunc">Delegate Func to create</typeparam>
/// <param name="obj">Constant to get method from</param>
/// <param name="methodName">Method to examine</param>
/// <returns>Delegate function of the specified methodname</returns>
public static TFunc CreateFunc<TFunc>(object obj, string methodName)
{
	List<ParameterExpression> args = new List<ParameterExpression>();

	Type targetType = obj.GetType();
	MethodInfo minfo = targetType.GetMethod(methodName, BindingFlags.Instance | BindingFlags.Public);

	if (minfo != null)
	{
		var target = Expression.Constant(obj);
		foreach (var arg in minfo.GetParameters())
			args.Add(Expression.Parameter(arg.ParameterType, arg.Name));
		var methodinvokeExpression = Expression.Call(target, minfo, args.ToArray());
		var lambda = Expression.Lambda<TFunc>(methodinvokeExpression, args.ToArray());
		
		//now the following Lambda is created:
		// (TArg1, TArg2) => obj.MethodName(TArg1, TArg2);

		return lambda.Compile();
	}
	return default(TFunc);
}

        /// <summary>
        /// Creates a compiled delegate function using expressions, 
        /// the first Func{TObject,TReturn} parameter must be the constant to be passed in
        /// </summary>
        /// <typeparam name="TFunc">Delegate Func to create</typeparam>
        /// <param name="targetType">Type of constant to pass in to the Func</param>
        /// <param name="methodName">Method to examine</param>
        /// <returns>Delegate function of the specified methodname</returns>
        /// <example>
        /// The function Func{TType,TArg1,TArg2} with a method name of "CallMe" would create the following
        /// lambda:
        /// <code>
        /// (TType, TArg1, TArg2) => TType.CallMe(TArg1, TArg2);
        /// </code>
        /// </example>
        public static TFunc CreateFunc<TFunc>(Type targetType, string methodName)
        {
            List<ParameterExpression> args = new List<ParameterExpression>();
            MethodInfo minfo = targetType.GetMethod(methodName, BindingFlags.Instance | BindingFlags.Public);

            if (minfo != null)
            {
                Type objectType = typeof(TFunc).GetGenericArguments().First();
                var targetParam = Expression.Parameter(objectType, "a");

                if (!targetType.IsAssignableFrom(objectType))
                    throw new InvalidCastException(string.Format("{0} cannot be cast to {1}", targetType.Name, objectType.Name));

                var target = Expression.Convert(targetParam, targetType);
                foreach (var arg in minfo.GetParameters())
                    args.Add(Expression.Parameter(arg.ParameterType, arg.Name));

                var methodinvokeExpression = Expression.Call(target, minfo,  args.ToArray());
                var lambda = Expression.Lambda<TFunc>(methodinvokeExpression, new ParameterExpression[]{targetParam}.Concat(args));

                //now the following Lambda is created:
                // (a, TArg1, TArg2) => a.MethodName(TArg1, TArg2);

                return lambda.Compile();
            }
            return default(TFunc);
        }
    }
}