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

namespace Application.Emit
{
    public class EmitTypeInfo
    {
        public EmitTypeInfo(object obj)
        {
            Member = obj;
        }

        class EmitPropertyInfoCollection
        {
            public EmitPropertyInfo[] Items;
            public Dictionary<string, EmitPropertyInfo> ByName;
        }

        class CacheDictionary : Dictionary<Type, EmitPropertyInfoCollection>
        {

        }

        CacheDictionary Cache = new CacheDictionary();

        object Member;

        public IEnumerable<EmitPropertyInfo> GetProperties()
        {
            return GetPropertiesInternalCollection(Member.GetType()).Items;
        }

        public EmitPropertyInfo GetProperty(string propertyName)
        {
            EmitPropertyInfo result;

            if (GetPropertiesInternalCollection(Member.GetType()).ByName.TryGetValue(propertyName, out result))
            {
                return result;
            }
            else
            {
                return default(EmitPropertyInfo);
            }
        }

        EmitPropertyInfoCollection GetPropertiesInternalCollection(Type type)
        {
            lock (Cache)
            {
                EmitPropertyInfoCollection result;
                if (!Cache.TryGetValue(type, out result))
                {
                    var items = CreateEmitProperties(type).ToArray();
                    result = new EmitPropertyInfoCollection
                    {
                        Items = items,
                        ByName = items.ToDictionary(v => v.Property.Name)
                    };

                    Cache.Add(type, result);
                }

                return result;
            }
        }

        IEnumerable<EmitPropertyInfo> CreateEmitProperties(Type type)
        {
            var properties = type
                .GetProperties(BindingFlags.Public | BindingFlags.Instance)
                .Where(v =>
                    (v.GetGetMethod() == null || v.GetGetMethod().GetParameters().Length == 0) &&
                    (v.GetSetMethod() == null || v.GetSetMethod().GetParameters().Length == 1)
                );

            foreach (var property in properties)
                yield return new EmitPropertyInfo(
                    property,
                    CreatePropertyGet(property),
                    CreatePropertySet(property)
                );
        }

        Func<object, object> CreatePropertyGet(PropertyInfo pi)
        {
            var getMethod = pi.GetGetMethod();

            if (getMethod == null)
                return src =>
                {
                    throw new InvalidOperationException(
                        string.Format(
                            "Getter for property {0}.{1} not found",
                            pi.DeclaringType.FullName,
                            pi.Name
                        )
                    );
                };

            var method = new DynamicMethod(GetDynamicMethodName(pi, "Get"), typeof(object), new[] { typeof(object) }, pi.Module);
            var il = method.GetILGenerator();

            il.Emit(OpCodes.Ldarg_0);
            if (pi.DeclaringType.IsValueType)
                il.Emit(OpCodes.Unbox, pi.DeclaringType);
            else
                il.Emit(OpCodes.Castclass, pi.DeclaringType);

            il.EmitCall(OpCodes.Callvirt, getMethod, null);

            if (pi.PropertyType.IsValueType)
                il.Emit(OpCodes.Box, pi.PropertyType);

            il.Emit(OpCodes.Ret);

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

        Action<object, object> CreatePropertySet(PropertyInfo pi)
        {
            var setMethod = pi.GetSetMethod();

            if (setMethod == null)
                return (src, value) =>
                {
                    throw new InvalidOperationException(
                        string.Format(
                            "Setter for property {0}.{1} not found",
                            pi.DeclaringType.FullName,
                            pi.Name
                        )
                    );
                };

            var method = new DynamicMethod(
                 GetDynamicMethodName(pi, "Set"),
                 typeof(void),
                 new[] { typeof(object), typeof(object) },
                 pi.Module
             );

            var il = method.GetILGenerator();

            il.Emit(OpCodes.Ldarg_0);
            if (pi.DeclaringType.IsValueType)
                il.Emit(OpCodes.Unbox, pi.DeclaringType);
            else
                il.Emit(OpCodes.Castclass, pi.DeclaringType);

            il.Emit(OpCodes.Ldarg_1);
            il.Emit(OpCodes.Unbox_Any, pi.PropertyType);

            il.EmitCall(OpCodes.Callvirt, setMethod, null);

            il.Emit(OpCodes.Ret);

            return (Action<object, object>)method.CreateDelegate(typeof(Action<object, object>));
        }

        string GetDynamicMethodName(PropertyInfo pi, string suffix)
        {
            return string.Join("/", typeof(EmitTypeInfo).FullName, pi.DeclaringType.FullName, pi.Name, suffix);
        }
    }

    public class EmitPropertyInfo
    {
        public PropertyInfo Property { get; private set; }
        public Func<object, object> GetValue { get; private set; }
        public Action<object, object> SetValue { get; private set; }

        public EmitPropertyInfo(PropertyInfo property, Func<object, object> getValue, Action<object, object> setValue)
        {
            Property = property;
            GetValue = getValue;
            SetValue = setValue;
        }
    }
}