using System.ComponentModel;

namespace Simple.Data

{

using System;

using System.Collections;

using System.Collections.Generic;

using System.Linq;

using System.Linq.Expressions;

using System.Reflection;

class PropertySetterBuilder

{

private static readonly MethodInfo DictionaryContainsKeyMethod = typeof(IDictionary<string, object>).GetMethod("ContainsKey", new[] { typeof(string) });

private static readonly PropertyInfo DictionaryIndexerProperty = typeof(IDictionary<string, object>).GetProperty("Item");

private static readonly MethodInfo ToArrayDictionaryMethod = typeof(Enumerable).GetMethod("ToArray",

BindingFlags.Public |

BindingFlags.Static).MakeGenericMethod(typeof(IDictionary<string, object>));

private static readonly MethodInfo ToArrayObjectMethod = typeof(Enumerable).GetMethod("ToArray",

BindingFlags.Public |

BindingFlags.Static).MakeGenericMethod(typeof(object));

private static readonly PropertyInfo ArrayDictionaryLengthProperty =

typeof(IDictionary<string, object>[]).GetProperty("Length");

private static readonly PropertyInfo ArrayObjectLengthProperty =

typeof(object[]).GetProperty("Length");

private readonly ParameterExpression _param;

private readonly ParameterExpression _obj;

private readonly PropertyInfo _property;

private MemberExpression _nameProperty;

private IndexExpression _itemProperty;

private MethodCallExpression _containsKey;

private static readonly MethodInfo CreatorCreateMethod = typeof(ConcreteTypeCreator).GetMethod("Create");

public PropertySetterBuilder(ParameterExpression param, ParameterExpression obj, PropertyInfo property)

{

_param = param;

_obj = obj;

_property = property;

}

public ConditionalExpression CreatePropertySetter()

{

CreatePropertyExpressions();

if (PropertyIsPrimitive())

{

return Expression.IfThen(_containsKey, CreateTrySimpleAssign());

}

if (_property.PropertyType.IsArray)

{

return Expression.IfThen(_containsKey, CreateTrySimpleArrayAssign());

}

if (_property.PropertyType.IsGenericCollection())

{

var collectionCreator = BuildCollectionCreator();

if (collectionCreator != null)

{

return Expression.IfThen(_containsKey, collectionCreator);

}

}

var isDictionary = Expression.TypeIs(_itemProperty, typeof(IDictionary<string, object>));

var tryComplexAssign = Expression.TryCatch(CreateComplexAssign(),

CreateCatchBlock());

var ifThen = Expression.IfThen(_containsKey, // if (dict.ContainsKey(propertyName)) {

Expression.IfThenElse(isDictionary, tryComplexAssign, CreateTrySimpleAssign()));

return ifThen;

}

private Expression BuildArrayCreator()

{

if (!_property.CanWrite) return null;

var genericType = _property.PropertyType.GetGenericArguments().Single();

var creatorInstance = ConcreteTypeCreator.Get(genericType);

var collection = Expression.Variable(_property.PropertyType);

var createCollection = MakeCreateNewCollection(collection, genericType);

if (createCollection == null) return null;

var addMethod = _property.PropertyType.GetMethod("Add");

if (addMethod == null) return null;

return BuildCollectionCreatorExpression(genericType, creatorInstance, collection, createCollection, addMethod);

}

private Expression BuildCollectionCreator()

{

var genericType = _property.PropertyType.GetGenericArguments().Single();

var creatorInstance = ConcreteTypeCreator.Get(genericType);

var collection = Expression.Variable(_property.PropertyType);

BinaryExpression createCollection = null;

if (_property.CanWrite)

{

createCollection = MakeCreateNewCollection(collection, genericType);

}

else

{

createCollection = Expression.Assign(collection, _nameProperty);

}

var addMethod = _property.PropertyType.GetInterfaceMethod("Add");

if (createCollection != null && addMethod != null)

{

return BuildCollectionCreatorExpression(genericType, creatorInstance, collection, createCollection, addMethod);

}

return null;

}

private Expression BuildCollectionCreatorExpression(Type genericType, ConcreteTypeCreator creatorInstance, ParameterExpression collection, BinaryExpression createCollection, MethodInfo addMethod)

{

BlockExpression dictionaryBlock;

var isDictionaryCollection = BuildComplexTypeCollectionPopulator(collection, genericType, addMethod, createCollection, creatorInstance, out dictionaryBlock);

BlockExpression objectBlock;

var isObjectcollection = BuildSimpleTypeCollectionPopulator(collection, genericType, addMethod, createCollection, creatorInstance, out objectBlock);

return Expression.IfThenElse(isDictionaryCollection, dictionaryBlock,

Expression.IfThen(isObjectcollection, objectBlock));

}

private TypeBinaryExpression BuildComplexTypeCollectionPopulator(ParameterExpression collection, Type genericType,

MethodInfo addMethod, BinaryExpression createCollection,

ConcreteTypeCreator creatorInstance, out BlockExpression block)

{

var creator = Expression.Constant(creatorInstance);

var array = Expression.Variable(typeof (IDictionary<string, object>[]));

var i = Expression.Variable(typeof (int));

var current = Expression.Variable(typeof (IDictionary<string, object>));

var isDictionaryCollection = Expression.TypeIs(_itemProperty,

typeof (IEnumerable<IDictionary<string, object>>));

var toArray = Expression.Assign(array,

Expression.Call(ToArrayDictionaryMethod,

Expression.Convert(_itemProperty,

typeof (IEnumerable<IDictionary<string, object>>))));

var start = Expression.Assign(i, Expression.Constant(0));

var label = Expression.Label();

var loop = Expression.Loop(

Expression.IfThenElse(

Expression.LessThan(i, Expression.Property(array, ArrayDictionaryLengthProperty)),

Expression.Block(

Expression.Assign(current, Expression.ArrayIndex(array, i)),

Expression.Call(collection, addMethod,

Expression.Convert(Expression.Call(creator, CreatorCreateMethod, current), genericType)),

Expression.PreIncrementAssign(i)

),

Expression.Break(label)

),

label

);

block = Expression.Block(

new[] {array, i, collection, current},

createCollection,

toArray,

start,

loop,

_property.CanWrite ? (Expression) Expression.Assign(_nameProperty, collection) : Expression.Empty());

return isDictionaryCollection;

}

private TypeBinaryExpression BuildSimpleTypeCollectionPopulator(ParameterExpression collection, Type genericType,

MethodInfo addMethod, BinaryExpression createCollection,

ConcreteTypeCreator creatorInstance, out BlockExpression block)

{

var creator = Expression.Constant(creatorInstance);

var array = Expression.Variable(typeof(object[]));

var i = Expression.Variable(typeof(int));

var current = Expression.Variable(typeof(object));

var isObjectCollection = Expression.TypeIs(_itemProperty,

typeof(IEnumerable<object>));

var toArray = Expression.Assign(array,

Expression.Call(ToArrayObjectMethod,

Expression.Convert(_itemProperty,

typeof(IEnumerable<object>))));

var start = Expression.Assign(i, Expression.Constant(0));

var label = Expression.Label();

var loop = Expression.Loop(

Expression.IfThenElse(

Expression.LessThan(i, Expression.Property(array, ArrayObjectLengthProperty)),

Expression.Block(

Expression.Assign(current, Expression.ArrayIndex(array, i)),

Expression.IfThenElse(

Expression.TypeIs(current, typeof(IDictionary<string,object>)),

Expression.Call(collection, addMethod,

Expression.Convert(Expression.Call(creator, CreatorCreateMethod,

Expression.Convert(current, typeof(IDictionary<string,object>))),

genericType)),

Expression.Call(collection, addMethod,

Expression.Convert(current, genericType))),

Expression.PreIncrementAssign(i)

),

Expression.Break(label)

),

label

);

block = Expression.Block(

new[] { array, i, collection, current },

createCollection,

toArray,

start,

loop,

_property.CanWrite ? (Expression)Expression.Assign(_nameProperty, collection) : Expression.Empty());

return isObjectCollection;

}

private BinaryExpression MakeCreateNewCollection(ParameterExpression collection, Type genericType)

{

BinaryExpression createCollection;

if (_property.PropertyType.IsInterface)

{

createCollection = Expression.Assign(collection,

Expression.Call(

typeof (PropertySetterBuilder).GetMethod("CreateList",

BindingFlags.

NonPublic |

BindingFlags.

Static).

MakeGenericMethod(genericType)));

}

else

{

var defaultConstructor = _property.PropertyType.GetConstructor(Type.EmptyTypes);

if (defaultConstructor != null)

{

createCollection = Expression.Assign(collection, Expression.New(defaultConstructor));

}

else

{

createCollection = null;

}

}

return createCollection;

}

private bool PropertyIsPrimitive()

{

return _property.PropertyType.IsPrimitive || _property.PropertyType == typeof(string) ||

_property.PropertyType == typeof(DateTime) || _property.PropertyType == typeof(byte[]) ||

_property.PropertyType.IsEnum ||

(_property.PropertyType.IsGenericType && _property.PropertyType.GetGenericTypeDefinition() == typeof(Nullable<>));

}

private void CreatePropertyExpressions()

{

var name = Expression.Constant(_property.Name, typeof(string));

_containsKey = Expression.Call(_param, DictionaryContainsKeyMethod, name);

_nameProperty = Expression.Property(_obj, _property);

_itemProperty = Expression.Property(_param, DictionaryIndexerProperty, name);

}

private CatchBlock CreateCatchBlock()

{

return Expression.Catch(typeof(Exception), Expression.Assign(_nameProperty,

Expression.Default(_property.PropertyType)));

}

private BinaryExpression CreateComplexAssign()

{

var creator = Expression.Constant(ConcreteTypeCreator.Get(_property.PropertyType));

var methodCallExpression = Expression.Call(creator, CreatorCreateMethod,

// ReSharper disable PossiblyMistakenUseOfParamsMethod

Expression.Convert(_itemProperty,

typeof(IDictionary<string, object>)));

// ReSharper restore PossiblyMistakenUseOfParamsMethod

var complexAssign = Expression.Assign(_nameProperty,

Expression.Convert(

methodCallExpression, _property.PropertyType));

return complexAssign;

}

private TryExpression CreateTrySimpleAssign()

{

MethodCallExpression callConvert;

if (_property.PropertyType.IsEnum)

{

var changeTypeMethod = typeof (PropertySetterBuilder).GetMethod("SafeConvert",

BindingFlags.Static | BindingFlags.NonPublic);

callConvert = Expression.Call(changeTypeMethod, _itemProperty,

Expression.Constant(_property.PropertyType.GetEnumUnderlyingType(), typeof(Type)));

}

else if (_property.PropertyType.IsGenericType && _property.PropertyType.GetGenericTypeDefinition() == typeof(Nullable<>))

{

var changeTypeMethod = typeof (PropertySetterBuilder)

.GetMethod("SafeConvertNullable", BindingFlags.Static | BindingFlags.NonPublic)

.MakeGenericMethod(_property.PropertyType.GetGenericArguments().Single());

callConvert = Expression.Call(changeTypeMethod, _itemProperty);

}

else

{

var changeTypeMethod = typeof (PropertySetterBuilder).GetMethod("SafeConvert",

BindingFlags.Static | BindingFlags.NonPublic);

callConvert = Expression.Call(changeTypeMethod, _itemProperty,

Expression.Constant(_property.PropertyType, typeof(Type)));

}

var assign = Expression.Assign(_nameProperty, Expression.Convert(callConvert, _property.PropertyType));

if (_property.PropertyType.IsEnum)

{

return Expression.TryCatch( // try {

Expression.IfThenElse(Expression.TypeIs(_itemProperty, typeof (string)),

Expression.Assign(_nameProperty,

Expression.Convert(Expression.Call(typeof (Enum).GetMethod("Parse", new[] {typeof(Type), typeof(string), typeof(bool)}),

Expression.Constant(_property.PropertyType, typeof(Type)),

Expression.Call(_itemProperty, typeof(object).GetMethod("ToString")), Expression.Constant(true)), _property.PropertyType)),

assign), Expression.Catch(typeof(Exception), Expression.Empty()));

}

return Expression.TryCatch( // try {

assign,

CreateCatchBlock());

}

private TryExpression CreateTrySimpleArrayAssign()

{

var createArrayMethod = typeof (PropertySetterBuilder).GetMethod("CreateArray", BindingFlags.Static | BindingFlags.NonPublic)

.MakeGenericMethod(_property.PropertyType.GetElementType());

var callConvert = Expression.Call(createArrayMethod, _itemProperty);

var assign = Expression.Assign(_nameProperty, Expression.Convert(callConvert, _property.PropertyType));

return Expression.TryCatch( // try {

Expression.IfThenElse(Expression.TypeIs(_itemProperty, typeof (string)),

Expression.Assign(_nameProperty,

Expression.Convert(Expression.Call(typeof (Enum).GetMethod("Parse", new[] {typeof(Type), typeof(string), typeof(bool)}),

Expression.Constant(_property.PropertyType, typeof(Type)),

Expression.Call(_itemProperty, typeof(object).GetMethod("ToString")), Expression.Constant(true)), _property.PropertyType)),

assign), Expression.Catch(typeof(Exception), Expression.Empty()));

}

// ReSharper disable UnusedMember.Local

// Because they're used from runtime-generated code, you see.

internal static object SafeConvert(object source, Type targetType)

{

if (ReferenceEquals(source, null)) return null;

if (targetType.IsInstanceOfType(source)) return source;

if (source is string && targetType == typeof(Guid)) return TypeDescriptor.GetConverter(typeof(Guid)).ConvertFromInvariantString(source.ToString());

return Convert.ChangeType(source, targetType);

}

internal static T? SafeConvertNullable<T>(object source)

where T : struct

{

if (ReferenceEquals(source, null)) return default(T?);

return (T) source;

}

private static T[] CreateArray<T>(object source)

{

if (ReferenceEquals(source, null)) return null;

var enumerable = source as IEnumerable;

if (ReferenceEquals(enumerable, null)) return null;

try

{

return enumerable.Cast<T>().ToArray();

}

catch (InvalidCastException)

{

return null;

}

}

private static List<T> CreateList<T>()

{

return new List<T>();

}

// ReSharper restore UnusedMember.Local

}

}