// Copyright (c) Microsoft Corporation. All rights reserved. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Dynamic;
using System.Linq.Expressions;
using System.Reflection;
using System.Runtime.Serialization.Json;

namespace System.Json
{
    /// <summary>
    /// This class provides dynamic behavior support for the JsonValue types.
    /// </summary>
    internal class JsonValueDynamicMetaObject : DynamicMetaObject
    {
        private static readonly MethodInfo _getValueByIndexMethodInfo = typeof(JsonValue).GetMethod("GetValue", new Type[] { typeof(int) });
        private static readonly MethodInfo _getValueByKeyMethodInfo = typeof(JsonValue).GetMethod("GetValue", new Type[] { typeof(string) });
        private static readonly MethodInfo _setValueByIndexMethodInfo = typeof(JsonValue).GetMethod("SetValue", new Type[] { typeof(int), typeof(object) });
        private static readonly MethodInfo _setValueByKeyMethodInfo = typeof(JsonValue).GetMethod("SetValue", new Type[] { typeof(string), typeof(object) });
        private static readonly MethodInfo _castValueMethodInfo = typeof(JsonValue).GetMethod("CastValue", new Type[] { typeof(JsonValue) });
        private static readonly MethodInfo _changeTypeMethodInfo = typeof(Convert).GetMethod("ChangeType", new Type[] { typeof(object), typeof(Type) });

        /// <summary>
        /// Class constructor.
        /// </summary>
        /// <param name="parameter">The expression representing this <see cref="DynamicMetaObject"/> during the dynamic binding process.</param>
        /// <param name="value">The runtime value represented by the <see cref="DynamicMetaObject"/>.</param>
        internal JsonValueDynamicMetaObject(Expression parameter, JsonValue value)
            : base(parameter, BindingRestrictions.Empty, value)
        {
        }

        /// <summary>
        /// Gets the default binding restrictions for this type.
        /// </summary>
        private BindingRestrictions DefaultRestrictions
        {
            get { return BindingRestrictions.GetTypeRestriction(Expression, LimitType); }
        }

        /// <summary>
        /// Implements dynamic cast for JsonValue types.
        /// </summary>
        /// <param name="binder">An instance of the <see cref="ConvertBinder"/> that represents the details of the dynamic operation.</param>
        /// <returns>The new <see cref="DynamicMetaObject"/> representing the result of the binding.</returns>
        public override DynamicMetaObject BindConvert(ConvertBinder binder)
        {
            if (binder == null)
            {
                throw new ArgumentNullException("binder");
            }

            Expression expression = Expression;

            bool implicitCastSupported =
                binder.Type.IsAssignableFrom(LimitType) ||
                binder.Type == typeof(IEnumerable<KeyValuePair<string, JsonValue>>) ||
                binder.Type == typeof(IDynamicMetaObjectProvider) ||
                binder.Type == typeof(object);

            if (!implicitCastSupported)
            {
                if (JsonValue.IsSupportedExplicitCastType(binder.Type))
                {
                    Expression instance = Expression.Convert(Expression, LimitType);
                    expression = Expression.Call(_castValueMethodInfo.MakeGenericMethod(binder.Type), new Expression[] { instance });
                }
                else
                {
                    string exceptionMessage = RS.Format(Properties.Resources.CannotCastJsonValue, LimitType.FullName, binder.Type.FullName);
                    expression = Expression.Throw(Expression.Constant(new InvalidCastException(exceptionMessage)), typeof(object));
                }
            }

            expression = Expression.Convert(expression, binder.Type);

            return new DynamicMetaObject(expression, DefaultRestrictions);
        }

        /// <summary>
        /// Implements setter for dynamic indexer by index (JsonArray)
        /// </summary>
        /// <param name="binder">An instance of the <see cref="GetIndexBinder"/> that represents the details of the dynamic operation.</param>
        /// <param name="indexes">An array of <see cref="DynamicMetaObject"/> instances - indexes for the get index operation.</param>
        /// <returns>The new <see cref="DynamicMetaObject"/> representing the result of the binding.</returns>
        public override DynamicMetaObject BindGetIndex(GetIndexBinder binder, DynamicMetaObject[] indexes)
        {
            if (binder == null)
            {
                throw new ArgumentNullException("binder");
            }

            if (indexes == null)
            {
                throw new ArgumentNullException("indexes");
            }

            Expression indexExpression;
            if (!JsonValueDynamicMetaObject.TryGetIndexExpression(indexes, out indexExpression))
            {
                return new DynamicMetaObject(indexExpression, DefaultRestrictions);
            }

            MethodInfo methodInfo = indexExpression.Type == typeof(string) ? _getValueByKeyMethodInfo : _getValueByIndexMethodInfo;
            Expression[] args = new Expression[] { indexExpression };

            return GetMethodMetaObject(methodInfo, args);
        }

        /// <summary>
        /// Implements getter for dynamic indexer by index (JsonArray).
        /// </summary>
        /// <param name="binder">An instance of the <see cref="SetIndexBinder"/> that represents the details of the dynamic operation.</param>
        /// <param name="indexes">An array of <see cref="DynamicMetaObject"/> instances - indexes for the set index operation.</param>
        /// <param name="value">The <see cref="DynamicMetaObject"/> representing the value for the set index operation.</param>
        /// <returns>The new <see cref="DynamicMetaObject"/> representing the result of the binding.</returns>
        public override DynamicMetaObject BindSetIndex(SetIndexBinder binder, DynamicMetaObject[] indexes, DynamicMetaObject value)
        {
            if (binder == null)
            {
                throw new ArgumentNullException("binder");
            }

            if (indexes == null)
            {
                throw new ArgumentNullException("indexes");
            }

            if (value == null)
            {
                throw new ArgumentNullException("value");
            }

            Expression indexExpression;
            if (!JsonValueDynamicMetaObject.TryGetIndexExpression(indexes, out indexExpression))
            {
                return new DynamicMetaObject(indexExpression, DefaultRestrictions);
            }

            MethodInfo methodInfo = indexExpression.Type == typeof(string) ? _setValueByKeyMethodInfo : _setValueByIndexMethodInfo;
            Expression[] args = new Expression[] { indexExpression, Expression.Convert(value.Expression, typeof(object)) };

            return GetMethodMetaObject(methodInfo, args);
        }

        /// <summary>
        /// Implements getter for dynamic indexer by key (JsonObject).
        /// </summary>
        /// <param name="binder">An instance of the <see cref="GetMemberBinder"/> that represents the details of the dynamic operation.</param>
        /// <returns>The new <see cref="DynamicMetaObject"/> representing the result of the binding.</returns>
        public override DynamicMetaObject BindGetMember(GetMemberBinder binder)
        {
            if (binder == null)
            {
                throw new ArgumentNullException("binder");
            }

            PropertyInfo propInfo = LimitType.GetProperty(binder.Name, BindingFlags.Instance | BindingFlags.Public);

            if (propInfo != null)
            {
                return base.BindGetMember(binder);
            }

            Expression[] args = new Expression[] { Expression.Constant(binder.Name) };

            return GetMethodMetaObject(_getValueByKeyMethodInfo, args);
        }

        /// <summary>
        /// Implements setter for dynamic indexer by key (JsonObject).
        /// </summary>
        /// <param name="binder">An instance of the <see cref="SetMemberBinder"/> that represents the details of the dynamic operation.</param>
        /// <param name="value">The <see cref="DynamicMetaObject"/> representing the value for the set member operation.</param>
        /// <returns>The new <see cref="DynamicMetaObject"/> representing the result of the binding.</returns>
        public override DynamicMetaObject BindSetMember(SetMemberBinder binder, DynamicMetaObject value)
        {
            if (binder == null)
            {
                throw new ArgumentNullException("binder");
            }

            if (value == null)
            {
                throw new ArgumentNullException("value");
            }

            Expression[] args = new Expression[] { Expression.Constant(binder.Name), Expression.Convert(value.Expression, typeof(object)) };

            return GetMethodMetaObject(_setValueByKeyMethodInfo, args);
        }

        /// <summary>
        /// Performs the binding of the dynamic invoke member operation.
        /// Implemented to support extension methods defined in <see cref="JsonValueExtensions"/> type.
        /// </summary>
        /// <param name="binder">An instance of the InvokeMemberBinder that represents the details of the dynamic operation.</param>
        /// <param name="args">An array of DynamicMetaObject instances - arguments to the invoke member operation.</param>
        /// <returns>The new DynamicMetaObject representing the result of the binding.</returns>
        public override DynamicMetaObject BindInvokeMember(InvokeMemberBinder binder, DynamicMetaObject[] args)
        {
            if (binder == null)
            {
                throw new ArgumentNullException("binder");
            }

            if (args == null)
            {
                throw new ArgumentNullException("args");
            }

            List<Type> argTypeList = new List<Type>();

            for (int idx = 0; idx < args.Length; idx++)
            {
                argTypeList.Add(args[idx].LimitType);
            }

            MethodInfo methodInfo = Value.GetType().GetMethod(binder.Name, argTypeList.ToArray());

            if (methodInfo == null)
            {
                argTypeList.Insert(0, typeof(JsonValue));

                Type[] argTypes = argTypeList.ToArray();

                methodInfo = JsonValueDynamicMetaObject.GetExtensionMethod(typeof(JsonValueExtensions), binder.Name, argTypes);

                if (methodInfo != null)
                {
                    Expression thisInstance = Expression.Convert(Expression, LimitType);
                    Expression[] argsExpression = new Expression[argTypes.Length];

                    argsExpression[0] = thisInstance;
                    for (int i = 0; i < args.Length; i++)
                    {
                        argsExpression[i + 1] = args[i].Expression;
                    }

                    Expression callExpression = Expression.Call(methodInfo, argsExpression);

                    if (methodInfo.ReturnType == typeof(void))
                    {
                        callExpression = Expression.Block(callExpression, Expression.Default(binder.ReturnType));
                    }
                    else
                    {
                        callExpression = Expression.Convert(Expression.Call(methodInfo, argsExpression), binder.ReturnType);
                    }

                    return new DynamicMetaObject(callExpression, DefaultRestrictions);
                }
            }

            return base.BindInvokeMember(binder, args);
        }

        /// <summary>
        /// Returns the enumeration of all dynamic member names.
        /// </summary>
        /// <returns>An <see cref="IEnumerable{T}"/> of string reprenseting the dynamic member names.</returns>
        public override IEnumerable<string> GetDynamicMemberNames()
        {
            JsonValue jsonValue = Value as JsonValue;

            if (jsonValue != null)
            {
                List<string> names = new List<string>();

                foreach (KeyValuePair<string, JsonValue> pair in jsonValue)
                {
                    names.Add(pair.Key);
                }

                return names;
            }

            return base.GetDynamicMemberNames();
        }

        /// <summary>
        /// Gets a <see cref="MethodInfo"/> instance for the specified method name in the specified type.
        /// </summary>
        /// <param name="extensionProviderType">The extension provider type.</param>
        /// <param name="methodName">The name of the method to get the info for.</param>
        /// <param name="argTypes">The types of the method arguments.</param>
        /// <returns>A <see cref="MethodInfo"/>instance or null if the method cannot be resolved.</returns>
        private static MethodInfo GetExtensionMethod(Type extensionProviderType, string methodName, Type[] argTypes)
        {
            MethodInfo methodInfo = null;
            MethodInfo[] methods = extensionProviderType.GetMethods();

            foreach (MethodInfo info in methods)
            {
                if (info.Name == methodName)
                {
                    methodInfo = info;

                    if (!info.IsGenericMethodDefinition)
                    {
                        bool paramsMatch = true;
                        ParameterInfo[] args = methodInfo.GetParameters();

                        if (args.Length == argTypes.Length)
                        {
                            for (int idx = 0; idx < args.Length; idx++)
                            {
                                if (!args[idx].ParameterType.IsAssignableFrom(argTypes[idx]))
                                {
                                    paramsMatch = false;
                                    break;
                                }
                            }

                            if (paramsMatch)
                            {
                                break;
                            }
                        }
                    }
                }
            }

            return methodInfo;
        }

        /// <summary>
        /// Attempts to get an expression for an index parameter.
        /// </summary>
        /// <param name="indexes">The operation indexes parameter.</param>
        /// <param name="expression">A <see cref="Expression"/> to be initialized to the index expression if the operation is successful, otherwise an error expression.</param>
        /// <returns>true the operation is successful, false otherwise.</returns>
        private static bool TryGetIndexExpression(DynamicMetaObject[] indexes, out Expression expression)
        {
            if (indexes.Length == 1 && indexes[0] != null && indexes[0].Value != null)
            {
                DynamicMetaObject index = indexes[0];
                Type indexType = indexes[0].Value.GetType();

                switch (Type.GetTypeCode(indexType))
                {
                    case TypeCode.Char:
                    case TypeCode.Int16:
                    case TypeCode.UInt16:
                    case TypeCode.Byte:
                    case TypeCode.SByte:
                        Expression argExp = Expression.Convert(index.Expression, typeof(object));
                        Expression typeExp = Expression.Constant(typeof(int));
                        expression = Expression.Convert(Expression.Call(_changeTypeMethodInfo, new Expression[] { argExp, typeExp }), typeof(int));
                        return true;

                    case TypeCode.Int32:
                    case TypeCode.String:
                        expression = index.Expression;
                        return true;
                }

                expression = Expression.Throw(Expression.Constant(new ArgumentException(RS.Format(Properties.Resources.InvalidIndexType, indexType))), typeof(object));
                return false;
            }

            expression = Expression.Throw(Expression.Constant(new ArgumentException(Properties.Resources.NonSingleNonNullIndexNotSupported)), typeof(object));
            return false;
        }

        /// <summary>
        /// Gets a <see cref="DynamicMetaObject"/> for a method call.
        /// </summary>
        /// <param name="methodInfo">Info for the method to be performed.</param>
        /// <param name="args">expression array representing the method arguments</param>
        /// <returns>A meta object for the method call.</returns>
        private DynamicMetaObject GetMethodMetaObject(MethodInfo methodInfo, Expression[] args)
        {
            Expression instance = Expression.Convert(Expression, LimitType);
            Expression methodCall = Expression.Call(instance, methodInfo, args);
            BindingRestrictions restrictions = DefaultRestrictions;

            DynamicMetaObject metaObj = new DynamicMetaObject(methodCall, restrictions);

            return metaObj;
        }
    }
}
