using System;
using System.Linq.Expressions;
using System.Reflection;
using System.Collections.Generic;
using Pfz.Threading;
using Pfz.Extensions;
using Pfz.DataTypes;

namespace Pfz
{
	/// <summary>
	/// This class allows you to get members from types more safely than using
	/// string literals. It only exists because C# does not have fieldinfoof,
	/// propertyinfoof and methodinfoof.
	/// </summary>
	public static class ReflectionHelper
	{
		#region GetMember
			/// <summary>
			/// Gets a member by it's expression usage.
			/// For example, GetMember(() => obj.GetType()) will return the
			/// GetType method.
			/// </summary>
			public static MemberInfo GetMember<T>(Expression<Func<T>> expression)
			{
				if (expression == null)
					throw new ArgumentNullException("expression");
				
				var body = expression.Body;
			
				switch(body.NodeType)
				{
					case ExpressionType.MemberAccess:
						MemberExpression memberExpression = (MemberExpression)body;
						return memberExpression.Member;
				
					case ExpressionType.Call:
						MethodCallExpression callExpression = (MethodCallExpression)body;
						return callExpression.Method;
				
					case ExpressionType.New:
						NewExpression newExpression = (NewExpression)body;
						return newExpression.Constructor;
				}
			
				throw new ArgumentException("expression.Body must be a member or call expression.", "expression");
			}
		#endregion
		#region GetConstructor
			/// <summary>
			/// Gets the constructor info from a sample construction call expression.
			/// Example: GetConstructor(() => new Control()) will return the constructor
			/// info for the default constructor of Control.
			/// </summary>
			public static ConstructorInfo GetConstructor<T>(Expression<Func<T>> expression)
			{
				return (ConstructorInfo)GetMember(expression);
			}
		#endregion
		#region GetField
			/// <summary>
			/// Gets a field from a sample usage.
			/// Example: GetField(() => Type.EmptyTypes) will return the FieldInfo of
			/// EmptyTypes.
			/// </summary>
			public static FieldInfo GetField<T>(Expression<Func<T>> expression)
			{
				return (FieldInfo)GetMember(expression);
			}
		#endregion
		#region GetProperty
			/// <summary>
			/// Gets a property from a sample usage.
			/// Example: GetProperty(() => str.Length) will return the property info 
			/// of Length.
			/// </summary>
			public static PropertyInfo GetProperty<T>(Expression<Func<T>> expression)
			{
				return (PropertyInfo)GetMember(expression);
			}
		#endregion
		#region GetMethod
			/// <summary>
			/// Gets a method info of a void method.
			/// Example: GetMethod(() => Console.WriteLine("")); will return the
			/// MethodInfo of WriteLine that receives a single argument.
			/// </summary>
			public static MethodInfo GetMethod(Expression<Action> expression)
			{
				if (expression == null)
					throw new ArgumentNullException("expression");
			
				var body = expression.Body;
				if (body.NodeType != ExpressionType.Call)
					throw new ArgumentException("expression.Body must be a Call expression.", "expression");
			
				MethodCallExpression callExpression = (MethodCallExpression)body;
				return callExpression.Method;
			}
		
			/// <summary>
			/// Gets the MethodInfo of a method that returns a value.
			/// Example: GetMethod(() => Console.ReadLine()); will return the method info
			/// of ReadLine.
			/// </summary>
			public static MethodInfo GetMethod<T>(Expression<Func<T>> expression)
			{
				return (MethodInfo)GetMember(expression);
			}
		#endregion

		#region GetDefaultConstructorDelegate
			private static YieldReaderWriterLockSlim _defaultConstructorsLock;
			private static readonly Dictionary<Type, Func<object>> _defaultConstructorsDictionary = new Dictionary<Type, Func<object>>();
			private static readonly Func<Type, Func<object>> _getDefaultConstructorDelegate = GetDefaultConstructorDelegate<object>;

			/// <summary>
			/// Gets a function that creates objects of the given type.
			/// The object must have a default constructor.
			/// </summary>
			public static Func<object> GetDefaultConstructorDelegate(Type objectType)
			{
				var result = _defaultConstructorsDictionary.GetOrCreateValue(ref _defaultConstructorsLock, objectType, _getDefaultConstructorDelegate);
				return result;
			}

			private static YieldReaderWriterLockSlim _typedDefaultConstructorsLock;
			private static readonly Dictionary<KeyValuePair<Type, Type>, Delegate> _typedDefaultConstructorsDictionary = new Dictionary<KeyValuePair<Type, Type>, Delegate>();
			private static readonly Func<KeyValuePair<Type, Type>, Delegate> _getTypedDefaultConstructorDelegate = _GetDefaultConstructorDelegate;
			/// <summary>
			/// Gets the default constructor for the given objectType, but return
			/// it already casted to a given "T".
			/// </summary>
			public static Func<T> GetDefaultConstructorDelegate<T>(Type objectType)
			{
				if (objectType == null)
					throw new ArgumentNullException("objectType");
					
				var pair = Pair.Create(typeof(Func<T>), objectType);
				var result = _typedDefaultConstructorsDictionary.GetOrCreateValue(ref _typedDefaultConstructorsLock, pair, _getTypedDefaultConstructorDelegate);
				return (Func<T>)result;
			}
			
			private static Delegate _GetDefaultConstructorDelegate(KeyValuePair<Type, Type> pair)
			{
				var funcType = pair.Key;
				var objectType = pair.Value;
				var resultType = funcType.GetGenericArguments()[0];

				Expression expression = Expression.New(objectType);
			
				if 
				(
					resultType != objectType &&
					(
						objectType.IsValueType ||
						!resultType.IsAssignableFrom(objectType)
					)
				)
				{
					expression = Expression.Convert(expression, resultType);
				}
				
				var lambdaExpression = Expression.Lambda(funcType, expression);
				var func = lambdaExpression.Compile();

				return func;
			}
		#endregion
		#region GetConstructorDelegate<T>
			/// <summary>
			/// Creates a delegate (of type T) for the given constructor.
			/// The delegate type should match the number of parameters in the constructor.
			/// Casts are done if required but no other conversions are done.
			/// </summary>
			public static T GetConstructorDelegate<T>(ConstructorInfo constructor)
			{
				object result = GetConstructorDelegate(constructor, typeof(T));
				return (T)result;
			}
			
			private static YieldReaderWriterLockSlim _getTypedConstructorLock;
			private static readonly Dictionary<KeyValuePair<ConstructorInfo, Type>, Delegate> _typedConstructors = new Dictionary<KeyValuePair<ConstructorInfo, Type>, Delegate>();
			private static readonly Func<KeyValuePair<ConstructorInfo, Type>, Delegate> _getTypedConstructorDelegate = _GetConstructorDelegate;
			/// <summary>
			/// Creates a delegate for the given constructor.
			/// The delegate type should match the number of parameters in the constructor.
			/// Casts are done if required but no other conversions are done.
			/// </summary>
			public static Delegate GetConstructorDelegate(ConstructorInfo constructor, Type delegateType)
			{
				if (constructor == null)
					throw new ArgumentNullException("constructor");
					
				if (!delegateType.IsSubclassOf(typeof(Delegate)))
					throw new ArgumentException("delegateType is not a Delegate.", "delegateType");
					
				var pair = Pair.Create(constructor, delegateType);
				var result = _typedConstructors.GetOrCreateValue(ref _getTypedConstructorLock, pair, _getTypedConstructorDelegate);
				return result;
			}
					
			private static Delegate _GetConstructorDelegate(KeyValuePair<ConstructorInfo, Type> pair)
			{
				var constructor = pair.Key;
				var delegateType = pair.Value;
				
				var invokeMethod = delegateType.GetMethod("Invoke");
				if (invokeMethod == null)
					throw new InvalidOperationException("The given delegate type does not have an Invoke method. Is this a compilation error?");
					
				var constructorType = constructor.DeclaringType;
				var invokeReturnType = invokeMethod.ReturnType;
				
				bool isInvokeVoid = invokeReturnType == typeof(void);
				if (isInvokeVoid)
					throw new InvalidOperationException("The return type the delegate is incompatible.");
					
				var invokeParameterTypes = invokeMethod.GetParameterTypes();
				var constructorParameterTypes = constructor.GetParameterTypes();
					
				int count = invokeParameterTypes.Length;
				if (constructorParameterTypes.Length != count)
					throw new InvalidOperationException("The number of parameters between the constructor and the delegate is not compatible.");
				
				var parameterExpressions = new ParameterExpression[count];
				var arguments = new Expression[count];
				for(int i=0; i<count; i++)
				{
					var argument = _GetArgumentExpression(i, constructorParameterTypes, invokeParameterTypes, parameterExpressions);
					arguments[i] = argument;
				}
					
				Expression resultExpression = Expression.New(constructor, arguments);

				if (constructorType != invokeReturnType)
					resultExpression = Expression.Convert(resultExpression, invokeReturnType);
					
				var lambda = Expression.Lambda(delegateType, resultExpression, parameterExpressions);
				var compiled = lambda.Compile();
				return compiled;
			}
		#endregion

		#if !WINDOWS_PHONE
		#region GetConstructorDelegate
			private static YieldReaderWriterLockSlim _constructorsLock;
			private static readonly Dictionary<ConstructorInfo, FastDynamicDelegate> _constructors = new Dictionary<ConstructorInfo, FastDynamicDelegate>();
			private static readonly Func<ConstructorInfo, FastDynamicDelegate> _getConstructorDelegate = _CreateConstructorDelegate;
			/// <summary>
			/// Gets a constructor invoker delegate for the given constructor info.
			/// Using the delegate is much faster than calling the Invoke method on the constructor,
			/// but if you invoke it only once, it will do no good as some time is spent compiling
			/// such delegate.
			/// </summary>
			public static FastDynamicDelegate GetConstructorDelegate(ConstructorInfo constructor)
			{
				if (constructor == null)
					throw new ArgumentNullException("constructor");
			
				var result = _constructors.GetOrCreateValue(ref _constructorsLock, constructor, _getConstructorDelegate);
				return result;
			}


			private static FastDynamicDelegate _CreateConstructorDelegate(ConstructorInfo constructor)
			{
				var parametersExpression = Expression.Parameter(typeof(object[]), "parameters");

				var variables = new List<ParameterExpression>();
				var beforeInstructions = new List<Expression>();
				var afterInstructions = new List<Expression>();

				Expression[] arrayAccesses = null;
				var parameters = constructor.GetParameters();
				int count = parameters.Length;
				if (count != 0)
				{
					arrayAccesses = new Expression[count];
					for (int i = 0; i < count; i++)
					{
						var parameter = parameters[i];
						var parameterType = parameter.ParameterType;

						var constantExpression = Expression.Constant(i);
						Expression accessParameterExpression = Expression.ArrayAccess(parametersExpression, constantExpression);

						if (parameterType.IsByRef)
						{
							parameterType = parameterType.GetElementType();

							if (parameterType != typeof(object))
							{
								var variable = Expression.Variable(parameterType);
								variables.Add(variable);
								arrayAccesses[i] = variable;

								if (!parameter.IsOut)
								{
									var effectiveAccessParameterExpression = accessParameterExpression;
									if (parameterType != typeof(object))
										effectiveAccessParameterExpression = Expression.Convert(accessParameterExpression, parameterType);

									var setIn = Expression.Assign(variable, effectiveAccessParameterExpression);
									beforeInstructions.Add(setIn);
								}

								Expression accessVariable = variable;
								if (parameterType != typeof(object))
									accessVariable = Expression.Convert(variable, typeof(object));

								var setOut = Expression.Assign(accessParameterExpression, accessVariable);
								afterInstructions.Add(setOut);
								continue;
							}
						}

						if (parameterType != typeof(object))
							accessParameterExpression = Expression.Convert(accessParameterExpression, parameterType);

						arrayAccesses[i] = accessParameterExpression;
					}
				}

				var newExpression = Expression.New(constructor, arrayAccesses);
				var returnTarget = Expression.Label(typeof(object));
				var instructions = new List<Expression>();
				instructions.AddRange(beforeInstructions);

				ParameterExpression resultVariable = null;
				Expression body = newExpression;
				if (constructor.DeclaringType != typeof(object))
					body = Expression.Convert(newExpression, typeof(object));

				resultVariable = Expression.Variable(typeof(object));
				variables.Add(resultVariable);
				body = Expression.Assign(resultVariable, body);
				instructions.Add(body);

				instructions.AddRange(afterInstructions);
				var returnExpression = Expression.Return(returnTarget, resultVariable);
				instructions.Add(returnExpression);

				instructions.Add(Expression.Label(returnTarget, Expression.Constant(null, typeof(object))));
				body = Expression.Block(typeof(object), variables, instructions);

				var result = Expression.Lambda<FastDynamicDelegate>(body, parametersExpression);
				return result.Compile();
			}
		#endregion
		#region GetMethodCallDelegate
			private static YieldReaderWriterLockSlim _methodsLock;
			private static readonly Dictionary<MethodInfo, FastMethodCallDelegate> _methodsDictionary = new Dictionary<MethodInfo, FastMethodCallDelegate>();
			/// <summary>
			/// Gets a delegate to call the given method in a fast manner.
			/// </summary>
			public static FastMethodCallDelegate GetMethodCallDelegate(MethodInfo method)
			{
				var result = _methodsDictionary.GetOrCreateValue(ref _methodsLock, method, _CreateMethodCallDelegate);
				return result;
			}
			private static FastMethodCallDelegate _CreateMethodCallDelegate(MethodInfo method)
			{
				var parametersExpression = Expression.Parameter(typeof(object[]));

				ParameterExpression targetExpression = Expression.Parameter(typeof(object));

				Expression castTarget = null;

				if (!method.IsStatic)
				{
					castTarget = targetExpression;
					if (method.ReturnType != typeof(object))
						castTarget = Expression.Convert(targetExpression, method.DeclaringType);
				}

				var variables = new List<ParameterExpression>();
				var beforeInstructions = new List<Expression>();
				var afterInstructions = new List<Expression>();

				Expression[] arrayAccesses = null;
				var parameters = method.GetParameters();
				int count = parameters.Length;
				if (count != 0)
				{
					arrayAccesses = new Expression[count];
					for (int i = 0; i < count; i++)
					{
						var parameter = parameters[i];
						var parameterType = parameter.ParameterType;

						var constantExpression = Expression.Constant(i);
						Expression accessParameterExpression = Expression.ArrayAccess(parametersExpression, constantExpression);

						if (parameterType.IsByRef)
						{
							parameterType = parameterType.GetElementType();

							if (parameterType != typeof(object))
							{
								var variable = Expression.Variable(parameterType);
								variables.Add(variable);
								arrayAccesses[i] = variable;

								if (!parameter.IsOut)
								{
									var effectiveAccessParameterExpression = accessParameterExpression;
									if (parameterType != typeof(object))
										effectiveAccessParameterExpression = Expression.Convert(accessParameterExpression, parameterType);

									var setIn = Expression.Assign(variable, effectiveAccessParameterExpression);
									beforeInstructions.Add(setIn);
								}

								Expression accessVariable = variable;
								if (parameterType != typeof(object))
									accessVariable = Expression.Convert(variable, typeof(object));

								var setOut = Expression.Assign(accessParameterExpression, accessVariable);
								afterInstructions.Add(setOut);
								continue;
							}
						}

						if (parameterType != typeof(object))
							accessParameterExpression = Expression.Convert(accessParameterExpression, parameterType);

						arrayAccesses[i] = accessParameterExpression;
					}
				}

				MethodCallExpression callExpression;

				if (method.IsStatic)
					callExpression = Expression.Call(method, arrayAccesses);
				else
					callExpression = Expression.Call(castTarget, method, arrayAccesses);

				var returnTarget = Expression.Label(typeof(object));
				var instructions = new List<Expression>();
				instructions.AddRange(beforeInstructions);

				ParameterExpression resultVariable = null;
				Expression body = callExpression;
				if (method.ReturnType != typeof(void))
				{
					if (method.ReturnType != typeof(object))
						body = Expression.Convert(callExpression, typeof(object));

					resultVariable = Expression.Variable(typeof(object));
					variables.Add(resultVariable);
					body = Expression.Assign(resultVariable, body);
				}
				instructions.Add(body);

				instructions.AddRange(afterInstructions);

				if (method.ReturnType == typeof(void))
				{
					var returnExpression = Expression.Return(returnTarget, Expression.Constant(null, typeof(object)), typeof(object));
					instructions.Add(returnExpression);
				}
				else
				{
					var returnExpression = Expression.Return(returnTarget, resultVariable);
					instructions.Add(returnExpression);
				}

				instructions.Add(Expression.Label(returnTarget, Expression.Constant(null, typeof(object))));
				body = Expression.Block(typeof(object), variables, instructions);

				var result = Expression.Lambda<FastMethodCallDelegate>(body, targetExpression, parametersExpression);

				return result.Compile();
			}
		#endregion
		#endif


		#region GetMethodCallDelegate<T>
			/// <summary>
			/// Creates a method call delegate for the given method info.
			/// The delegateType (T) should have the same amount of parameters as the method. Note
			/// that non-static methods have a first parameter to represent the instance.
			/// </summary>
			public static T GetMethodCallDelegate<T>(MethodInfo method)
			{
				object result = GetMethodCallDelegate(method, typeof(T));
				return (T)result;
			}
			
			private static YieldReaderWriterLockSlim _getTypedMethodCallLock;
			private static readonly Dictionary<KeyValuePair<MethodInfo, Type>, Delegate> _getTypedMethodCallDictionary = new Dictionary<KeyValuePair<MethodInfo, Type>, Delegate>();
			private static readonly Func<KeyValuePair<MethodInfo, Type>, Delegate> _getTypedMethodCallDelegate = _GetTypedMethodCallDelegate;
			/// <summary>
			/// Creates a method call delegate for the given method info.
			/// The delegateType should have the same amount of parameters as the method. Note
			/// that non-static methods have a first parameter to represent the instance.
			/// </summary>
			public static Delegate GetMethodCallDelegate(MethodInfo method, Type delegateType)
			{
				if (method == null)
					throw new ArgumentNullException("method");
					
				if (!delegateType.IsSubclassOf(typeof(Delegate)))
					throw new ArgumentException("delegateType is not a Delegate.", "delegateType");
				
				var pair = Pair.Create(method, delegateType);	
				var result = _getTypedMethodCallDictionary.GetOrCreateValue(ref _getTypedMethodCallLock, pair, _getTypedMethodCallDelegate);
				return result;
			}
			private static Delegate _GetTypedMethodCallDelegate(KeyValuePair<MethodInfo, Type> pair)
			{
				var method = pair.Key;
				var delegateType = pair.Value;
				
				var invokeMethod = delegateType.GetMethod("Invoke");
				if (invokeMethod == null)
					throw new InvalidOperationException("The given delegate type does not have an Invoke method. Is this a compilation error?");
					
				var methodReturnType = method.ReturnType;
				var invokeReturnType = invokeMethod.ReturnType;
				
				bool isMethodVoid = methodReturnType == typeof(void);
				bool isInvokeVoid = invokeReturnType == typeof(void);
				if (isMethodVoid != isInvokeVoid)
					throw new InvalidOperationException("The return type of the method and the delegate is incompatible.");
					
				var invokeParameterTypes = invokeMethod.GetParameterTypes();
				var methodParameterTypes = new List<Type>();
				if (!method.IsStatic)
					methodParameterTypes.Add(method.DeclaringType);
					
				methodParameterTypes.AddRange(method.GetParameterTypes());
				
				int count = invokeParameterTypes.Length;
				if (methodParameterTypes.Count != count)
					throw new InvalidOperationException("The number of parameters between the method and the delegate is not compatible. Note that non-static methods have the additional \"this\" parameter as the first one.");
				
				var parameterExpressions = new ParameterExpression[count];

				int startIndex = 0;	
				int argumentCount = count;
				if (!method.IsStatic)
				{
					startIndex = 1;
					argumentCount--;
				}
				
				var arguments = new Expression[argumentCount];
				for(int i=0; i<argumentCount; i++)
				{
					var argument = _GetArgumentExpression(i+startIndex, methodParameterTypes, invokeParameterTypes, parameterExpressions);
					arguments[i] = argument;
				}
					
				MethodCallExpression callExpression;
				if (method.IsStatic)
					callExpression = Expression.Call(method, arguments);
				else
				{
					var instanceExpression = _GetArgumentExpression(0, methodParameterTypes, invokeParameterTypes, parameterExpressions);
					callExpression = Expression.Call(instanceExpression, method, arguments);
				}
				
				Expression resultExpression = callExpression;
				if (methodReturnType != invokeReturnType)
					resultExpression = Expression.Convert(resultExpression, invokeReturnType);
					
				var lambda = Expression.Lambda(delegateType, resultExpression, parameterExpressions);
				var compiled = lambda.Compile();
				return compiled;
			}
			private static Expression _GetArgumentExpression(int index, IList<Type> methodParameterTypes, Type[] invokeParameterTypes, ParameterExpression[] parameterExpressions)
			{
				var invokeParameterType = invokeParameterTypes[index];
				var methodParameterType = methodParameterTypes[index];
				
				var parameter = Expression.Parameter(invokeParameterType, "P" + index);
				parameterExpressions[index] = parameter;
				if (methodParameterType == invokeParameterType)
					return parameter;
					
				var convert = Expression.Convert(parameter, methodParameterType);
				return convert;
			}
		#endregion

		#region GetPropertyGetterDelegate
			private static YieldReaderWriterLockSlim _getPropertyLock;
			private static readonly Dictionary<PropertyInfo, Func<object, object>> _getPropertiesDictionary = new Dictionary<PropertyInfo,Func<object, object>>();
			private static readonly Func<PropertyInfo, Func<object, object>> _getPropertyGetterDelegate = GetPropertyGetterDelegate<object, object>;
			/// <summary>
			/// Gets a delegate to read values from the given property in a very fast manner.
			/// </summary>
			public static Func<object, object> GetPropertyGetterDelegate(PropertyInfo property)
			{
				var result = _getPropertiesDictionary.GetOrCreateValue(ref _getPropertyLock, property, _getPropertyGetterDelegate); 
				return result;
			}

			private static YieldReaderWriterLockSlim _getTypedPropertyLock;
			private static readonly Dictionary<KeyValuePair<Type, PropertyInfo>, Delegate> _getTypedPropertiesDictionary = new Dictionary<KeyValuePair<Type, PropertyInfo>, Delegate>();
			private static readonly Func<KeyValuePair<Type, PropertyInfo>, Delegate> _getTypedPropertyGetterDelegate = _GetPropertyGetterDelegate;
			/// <summary>
			/// Gets a delegate to read values from the given property in a very fast manner.
			/// The result will be already cast or will even avoid casts if the 
			/// generic types are correct.
			/// </summary>
			public static Func<TInstance, TOutput> GetPropertyGetterDelegate<TInstance, TOutput>(PropertyInfo property)
			{
				if (property == null)
					throw new ArgumentNullException("property");
					
				var pair = Pair.Create(typeof(Func<TInstance, TOutput>), property);
				var result = _getTypedPropertiesDictionary.GetOrCreateValue(ref _getTypedPropertyLock, pair, _getTypedPropertyGetterDelegate);
				return (Func<TInstance, TOutput>)result;
			}
			
			private static Delegate _GetPropertyGetterDelegate(KeyValuePair<Type, PropertyInfo> pair)
			{
				var funcType = pair.Key;
				var property = pair.Value;
				
				var funcArguments = funcType.GetGenericArguments();
				var instanceType = funcArguments[0];
				var resultType = funcArguments[1];
				
				var parameter = Expression.Parameter(instanceType, "instance");
				Expression resultExpression;

				var getMethod = property.GetGetMethod();
				if (getMethod == null)
					throw new ArgumentException("Property " + property.Name +  " can't be read.", "read");

				if (getMethod.IsStatic)
					resultExpression = Expression.MakeMemberAccess(null, property);
				else
				{
					Expression readParameter = parameter;
			
					if (property.DeclaringType != instanceType)
						readParameter = Expression.Convert(parameter, property.DeclaringType);
			
					resultExpression = Expression.MakeMemberAccess(readParameter, property);
				}

				if (property.PropertyType != resultType)
					resultExpression = Expression.Convert(resultExpression, resultType);
				
				var lambda = Expression.Lambda(funcType, resultExpression, parameter);

				var result = lambda.Compile();
				return result;
			}
		#endregion
		#region GetPropertySetterDelegate
			private static YieldReaderWriterLockSlim _setPropertyLock;
			private static readonly Dictionary<PropertyInfo, Action<object, object>> _setPropertiesDictionary = new Dictionary<PropertyInfo, Action<object, object>>();
			private static readonly Func<PropertyInfo, Action<object, object>> _getPropertySetterDelegate = GetPropertySetterDelegate<object, object>;
			/// <summary>
			/// Gets a delegate that can be used to do very fast sets on the given property.
			/// </summary>
			public static Action<object, object> GetPropertySetterDelegate(PropertyInfo property)
			{
				var result = _setPropertiesDictionary.GetOrCreateValue(ref _setPropertyLock, property, _getPropertySetterDelegate);
				return result;
			}

			private static YieldReaderWriterLockSlim _typedPropertySetterDelegatesLock;
			private static readonly Dictionary<KeyValuePair<Type, PropertyInfo>, Delegate> _typedPropertySetterDelegatesDictionary = new Dictionary<KeyValuePair<Type, PropertyInfo>, Delegate>();
			private static Func<KeyValuePair<Type, PropertyInfo>, Delegate> _typedGetPropertySetterDelegate = _TypedGetPropertySetterDelegate;
			/// <summary>
			/// Gets a delegate that can be used to do very fast sets on the given property.
			/// If the generic types are correct, casts can be avoided to improve performance
			/// even further.
			/// </summary>
			public static Action<TInstance, TValue> GetPropertySetterDelegate<TInstance, TValue>(PropertyInfo property)
			{
				if (property == null)
					throw new ArgumentNullException("property");
					
				var pair = Pair.Create(typeof(Action<TInstance, TValue>), property);
				var result = _typedPropertySetterDelegatesDictionary.GetOrCreateValue(ref _typedPropertySetterDelegatesLock, pair, _typedGetPropertySetterDelegate);
				return (Action<TInstance, TValue>)result;
			}
			
			private static Delegate _TypedGetPropertySetterDelegate(KeyValuePair<Type, PropertyInfo> pair)
			{
				var actionType = pair.Key;
				var property = pair.Value;
				var actionArguments = actionType.GetGenericArguments();
				var instanceType = actionArguments[0];
				var valueType = actionArguments[1];
				
				var instanceParameter = Expression.Parameter(instanceType, "instance");

				var valueParameter = Expression.Parameter(valueType, "value");
				Expression readValueParameter = valueParameter;
				if (property.PropertyType != valueType)
					readValueParameter = Expression.Convert(valueParameter, property.PropertyType);

				// .Net 3.5 does not have assign
				// but we can call the set method directly (and we need it to test for static).
				var setMethod = property.GetSetMethod(true);
				if (setMethod == null)
					throw new ArgumentException("Property " + property.Name + " is read-only.", "property");

				Expression setExpression;
				if (setMethod.IsStatic)
					setExpression = Expression.Call(setMethod, readValueParameter);
				else
				{
					Expression readInstanceParameter = instanceParameter;
					if (property.DeclaringType != instanceType)
						readInstanceParameter = Expression.Convert(instanceParameter, property.DeclaringType);
				
					setExpression = Expression.Call(readInstanceParameter, setMethod, readValueParameter);
				}

				var lambda = Expression.Lambda(actionType, setExpression, instanceParameter, valueParameter);
				var result = lambda.Compile();
				return result;
			}
		#endregion
		#region GetEventAdder
			private static YieldReaderWriterLockSlim _addEventLock;
			private static readonly Dictionary<EventInfo, Action<object, Delegate>> _addEventDictionary = new Dictionary<EventInfo, Action<object, Delegate>>();
			private static readonly Func<EventInfo, Action<object, Delegate>> _getEventAdderDelegate = GetEventAdderDelegate<object, Delegate>;

			/// <summary>
			/// Gets a delegate to do fast "event add"
			/// </summary>
			public static Action<object, Delegate> GetEventAdderDelegate(EventInfo eventInfo)
			{
				var result = _addEventDictionary.GetOrCreateValue(ref _addEventLock, eventInfo, _getEventAdderDelegate);
				return result;
			}

			/// <summary>
			/// Gets a delegate to do fast "event add".
			/// Can avoid casts if the right generic types are given.
			/// </summary>
			public static Action<TInstance, TDelegate> GetEventAdderDelegate<TInstance, TDelegate>(EventInfo eventInfo)
			{
				return _GetEventDelegate<TInstance, TDelegate>(eventInfo.GetAddMethod(), eventInfo.EventHandlerType);
			}
		#endregion
		#region GetEventRemoverDelegate
			private static YieldReaderWriterLockSlim _removeEventLock;
			private static readonly Dictionary<EventInfo, Action<object, Delegate>> _removeEventDictionary = new Dictionary<EventInfo, Action<object, Delegate>>();
			private static readonly Func<EventInfo, Action<object, Delegate>> _getEventRemoverDelegate = GetEventRemoverDelegate<object, Delegate>;

			/// <summary>
			/// Gets a delegate to do fast "event remove" calls.
			/// </summary>
			public static Action<object, Delegate> GetEventRemoverDelegate(EventInfo eventInfo)
			{
				var result = _removeEventDictionary.GetOrCreateValue(ref _removeEventLock, eventInfo, _getEventRemoverDelegate);
				return result;
			}
			/// <summary>
			/// Gets a delegate to do fast "event remove" calls.
			/// Can avoid casts if the right generic types are given.
			/// </summary>
			public static Action<TInstance, TDelegate> GetEventRemoverDelegate<TInstance, TDelegate>(EventInfo eventInfo)
			{
				return _GetEventDelegate<TInstance, TDelegate>(eventInfo.GetRemoveMethod(), eventInfo.EventHandlerType);
			}
		#endregion
		#region _GetEventDelegate
			private static Action<TInstance, TDelegate> _GetEventDelegate<TInstance, TDelegate>(MethodInfo method, Type handlerType)
			{
				var instanceParameter = Expression.Parameter(typeof(TInstance), "instance");
				var handlerParameter = Expression.Parameter(typeof(TDelegate), "handler");
				Expression readHandlerParameter = handlerParameter;
				if (handlerType != typeof(TDelegate))
					readHandlerParameter = Expression.Convert(handlerParameter, handlerType);

				Expression callExpression;
				if (method.IsStatic)
					callExpression = Expression.Call(method, readHandlerParameter);
				else
				{
					Expression readInstanceParameter = instanceParameter;
					if (method.DeclaringType != typeof(TInstance))
						readInstanceParameter = Expression.Convert(instanceParameter, method.DeclaringType);
				
					callExpression = Expression.Call(readInstanceParameter, method, readHandlerParameter);
				}

				var lambda = Expression.Lambda<Action<TInstance, TDelegate>>(callExpression, instanceParameter, handlerParameter);
				var result = lambda.Compile();
				return result;
			}
		#endregion

		#region GetFieldGetterDelegate
			private static YieldReaderWriterLockSlim _getFieldLock;
			private static readonly Dictionary<FieldInfo, Func<object, object>> _getFieldsDictionary = new Dictionary<FieldInfo,Func<object, object>>();
			private static readonly Func<FieldInfo, Func<object, object>> _getFieldGetterDelegate = GetFieldGetterDelegate<object, object>;
			/// <summary>
			/// Gets a delegate to read values from the given field in a very fast manner.
			/// </summary>
			public static Func<object, object> GetFieldGetterDelegate(FieldInfo field)
			{
				var result = _getFieldsDictionary.GetOrCreateValue(ref _getFieldLock, field, _getFieldGetterDelegate); 
				return result;
			}

			private static YieldReaderWriterLockSlim _getTypedFieldLock;
			private static readonly Dictionary<KeyValuePair<Type, FieldInfo>, Delegate> _getTypedFieldsDictionary = new Dictionary<KeyValuePair<Type, FieldInfo>, Delegate>();
			private static readonly Func<KeyValuePair<Type, FieldInfo>, Delegate> _getTypedFieldGetterDelegate = _GetFieldGetterDelegate;
			/// <summary>
			/// Gets a delegate to read values from the given field in a very fast manner.
			/// The result will be already cast or will even avoid casts if the 
			/// generic types are correct.
			/// </summary>
			public static Func<TInstance, TOutput> GetFieldGetterDelegate<TInstance, TOutput>(FieldInfo field)
			{
				if (field == null)
					throw new ArgumentNullException("field");
					
				var pair = Pair.Create(typeof(Func<TInstance, TOutput>), field);
				var result = _getTypedFieldsDictionary.GetOrCreateValue(ref _getTypedFieldLock, pair, _getTypedFieldGetterDelegate);
				return (Func<TInstance, TOutput>)result;
			}
			private static Delegate _GetFieldGetterDelegate(KeyValuePair<Type, FieldInfo> pair)
			{
				var funcType = pair.Key;
				var field = pair.Value;
				
				var funcArguments = funcType.GetGenericArguments();
				var instanceType = funcArguments[0];
				var resultType = funcArguments[1];
				
				var parameter = Expression.Parameter(instanceType, "instance");
				Expression resultExpression;

				if (field.IsStatic)
					resultExpression = Expression.MakeMemberAccess(null, field);
				else
				{
					Expression readParameter = parameter;
			
					if (field.DeclaringType != instanceType)
						readParameter = Expression.Convert(parameter, field.DeclaringType);
			
					resultExpression = Expression.MakeMemberAccess(readParameter, field);
				}

				if (field.FieldType != resultType)
					resultExpression = Expression.Convert(resultExpression, resultType);
				
				var lambda = Expression.Lambda(funcType, resultExpression, parameter);

				var result = lambda.Compile();
				return result;
			}
		#endregion

		#if !WINDOWS_PHONE
		#region GetFastDynamicDelegate
			/// <summary>
			/// You have an untyped delegate? Then get another delegate to invoke it faster.
			/// </summary>
			public static FastDynamicDelegate GetFastDynamicDelegate(Delegate realDelegate)
			{
				var result = ReflectionHelper.GetMethodCallDelegate(realDelegate.Method);
				return (parameters) => result(realDelegate.Target, parameters);
			}
		#endregion
		#endif
	}

	/// <summary>
	/// This is a typed version of reflection helper, so your expression already starts with a know
	/// object type (used when you don't have an already instantiated object).
	/// </summary>
	public static class ReflectionHelper<ForType>
	{
		#region GetMember
			/// <summary>
			/// Gets a member by it's expression usage.
			/// For example, GetMember((obj) => obj.GetType()) will return the
			/// GetType method.
			/// </summary>
			public static MemberInfo GetMember<T>(Expression<Func<ForType, T>> expression)
			{
				if (expression == null)
					throw new ArgumentNullException("expression");
				
				var body = expression.Body;
			
				switch(body.NodeType)
				{
					case ExpressionType.MemberAccess:
						MemberExpression memberExpression = (MemberExpression)body;
						return memberExpression.Member;
				
					case ExpressionType.Call:
						MethodCallExpression callExpression = (MethodCallExpression)body;
						return callExpression.Method;
				
					case ExpressionType.New:
						NewExpression newExpression = (NewExpression)body;
						return newExpression.Constructor;
				}
			
				throw new ArgumentException("expression.Body must be a member or call expression.", "expression");
			}
		#endregion
		#region GetField
			/// <summary>
			/// Gets a field from a sample usage.
			/// Example: GetField((obj) => obj.SomeField) will return the FieldInfo of
			/// EmptyTypes.
			/// </summary>
			public static FieldInfo GetField<T>(Expression<Func<ForType, T>> expression)
			{
				return (FieldInfo)GetMember(expression);
			}
		#endregion
		#region GetProperty
			/// <summary>
			/// Gets a property from a sample usage.
			/// Example: GetProperty((str) => str.Length) will return the property info 
			/// of Length.
			/// </summary>
			public static PropertyInfo GetProperty<T>(Expression<Func<ForType, T>> expression)
			{
				return (PropertyInfo)GetMember(expression);
			}
		#endregion
		#region GetMethod
			/// <summary>
			/// Gets a method info of a void method.
			/// Example: GetMethod((obj) => obj.SomeCall("")); will return the
			/// MethodInfo of SomeCall that receives a single argument.
			/// </summary>
			public static MethodInfo GetMethod(Expression<Action<ForType>> expression)
			{
				if (expression == null)
					throw new ArgumentNullException("expression");
			
				var body = expression.Body;
				if (body.NodeType != ExpressionType.Call)
					throw new ArgumentException("expression.Body must be a Call expression.", "expression");
			
				MethodCallExpression callExpression = (MethodCallExpression)body;
				return callExpression.Method;
			}
		
			/// <summary>
			/// Gets the MethodInfo of a method that returns a value.
			/// Example: GetMethod((obj) => obj.SomeCall()); will return the method info
			/// of SomeCall.
			/// </summary>
			public static MethodInfo GetMethod<T>(Expression<Func<ForType, T>> expression)
			{
				return (MethodInfo)GetMember(expression);
			}
		#endregion
	}
}