using System;
using System.Collections.Generic;
using System.Linq;
using System.Linq.Expressions;
using System.Reflection;
using System.Security;
using DynamicExpresso.Exceptions;
using DynamicExpresso.Parsing;
using DynamicExpresso.Reflection;
using DynamicExpresso.Resources;

namespace DynamicExpresso.Resolution
{
	internal static class MethodResolution
	{
		public static IList<MethodData> FindBestMethod(IEnumerable<MethodBase> methods, Expression[] args)
		{
			return FindBestMethod(methods.Select(MethodData.Gen), args);
		}

		public static IList<MethodData> FindBestMethod(IEnumerable<MethodData> methods, Expression[] args)
		{
			var applicable = new List<MethodData>();
			foreach (var method in methods)
			{
				if (CheckIfMethodIsApplicableAndPrepareIt(method, args))
					applicable.Add(method);
			}

			if (applicable.Count > 1)
			{
				var bestCandidates = new List<MethodData>(applicable.Count);
				foreach (var candidate in applicable)
				{
					if (IsBetterThanAllCandidates(candidate, applicable, args))
						bestCandidates.Add(candidate);
				}

				// bestCandidates.Count == 0 means that no applicable method has priority
				// we don't return bestCandidates to prevent callers from thinking no method was found
				if (bestCandidates.Count > 0)
					return bestCandidates;
			}

			return applicable;
		}

		private static bool IsBetterThanAllCandidates(MethodData candidate, IList<MethodData> otherCandidates, Expression[] args)
		{
			foreach (var other in otherCandidates)
			{
				if (candidate != other && !MethodHasPriority(args, candidate, other))
					return false;
			}

			return true;
		}

		public static bool CheckIfMethodIsApplicableAndPrepareIt(MethodData method, Expression[] args)
		{
			if (method.Parameters.Count(y => !y.HasDefaultValue && !ReflectionExtensions.HasParamsArrayType(y)) > args.Length)
				return false;

			var promotedArgs = new List<Expression>(method.Parameters.Count);
			var declaredWorkingParameters = 0;

			Type paramsArrayTypeFound = null;
			List<Expression> paramsArrayPromotedArgument = null;

			foreach (var currentArgument in args)
			{
				Type parameterType;

				if (paramsArrayTypeFound != null)
				{
					parameterType = paramsArrayTypeFound;
				}
				else
				{
					if (declaredWorkingParameters >= method.Parameters.Count)
					{
						return false;
					}

					var parameterDeclaration = method.Parameters[declaredWorkingParameters];
					if (parameterDeclaration.IsOut)
					{
						return false;
					}

					parameterType = parameterDeclaration.ParameterType;

					if (ReflectionExtensions.HasParamsArrayType(parameterDeclaration))
					{
						paramsArrayTypeFound = parameterType;
					}

					declaredWorkingParameters++;
				}

				if (paramsArrayPromotedArgument == null && (paramsArrayTypeFound == null || args.Length == method.Parameters.Count))
				{
					if (parameterType.IsGenericParameter)
					{
						// an interpreter expression can only be matched to a parameter of type Func
						if (currentArgument is InterpreterExpression)
							return false;

						promotedArgs.Add(currentArgument);
						continue;
					}

					var promoted = ExpressionUtils.PromoteExpression(currentArgument, parameterType);
					if (promoted != null)
					{
						promotedArgs.Add(promoted);
						continue;
					}
				}

				if (paramsArrayTypeFound != null)
				{
					var paramsArrayElementType = paramsArrayTypeFound.GetElementType();
					if (paramsArrayElementType.IsGenericParameter)
					{
						paramsArrayPromotedArgument = paramsArrayPromotedArgument ?? new List<Expression>();
						paramsArrayPromotedArgument.Add(currentArgument);
						continue;
					}

					var promoted = ExpressionUtils.PromoteExpression(currentArgument, paramsArrayElementType);
					if (promoted != null)
					{
						paramsArrayPromotedArgument = paramsArrayPromotedArgument ?? new List<Expression>();
						paramsArrayPromotedArgument.Add(promoted);
						continue;
					}
				}

				return false;
			}

			if (paramsArrayPromotedArgument != null)
			{
				method.HasParamsArray = true;
				var paramsArrayElementType = paramsArrayTypeFound.GetElementType();
				if (paramsArrayElementType == null)
					throw ParseException.Create(-1, ErrorMessages.ParamsArrayTypeNotAnArray);

				if (paramsArrayElementType.IsGenericParameter)
				{
					var actualTypes = paramsArrayPromotedArgument.Select(_ => _.Type).Distinct().ToArray();
					if (actualTypes.Length != 1)
						throw ParseException.Create(-1, ErrorMessages.MethodTypeParametersCantBeInferred, method.MethodBase);

					paramsArrayElementType = actualTypes[0];
				}

				promotedArgs.Add(Expression.NewArrayInit(paramsArrayElementType, paramsArrayPromotedArgument));
			}

			// Add default params, if needed.
			foreach (var parameter in method.Parameters.Skip(promotedArgs.Count))
			{
				if (parameter.HasDefaultValue)
				{
					var parameterType = TypeUtils.GetConcreteTypeForGenericMethod(parameter.ParameterType, promotedArgs, method);

					var defaultValue = parameter.DefaultValue;
					if (defaultValue is null && parameterType.IsValueType)
						defaultValue = Activator.CreateInstance(parameterType);

					promotedArgs.Add(Expression.Constant(defaultValue, parameterType));
				}
				else if (ReflectionExtensions.HasParamsArrayType(parameter))
				{
					method.HasParamsArray = true;
					promotedArgs.Add(Expression.NewArrayInit(parameter.ParameterType.GetElementType()));
				}
				else
				{
					throw new Exception("No default value found!");
				}
			}

			method.PromotedParameters = promotedArgs;

			if (method.MethodBase != null && method.MethodBase.IsGenericMethodDefinition &&
				method.MethodBase is MethodInfo)
			{
				var genericMethod = MakeGenericMethod(method);
				if (genericMethod == null)
					return false;

				// we have all the type information we can get, update interpreter expressions and evaluate them
				var actualMethodParameters = genericMethod.GetParameters();
				for (var i = 0; i < method.PromotedParameters.Count; i++)
				{
					if (method.PromotedParameters[i] is InterpreterExpression ie)
					{
						var actualParamInfo = actualMethodParameters[i];
						var lambdaExpr = ie.EvalAs(actualParamInfo.ParameterType);
						if (lambdaExpr == null)
							return false;

						method.PromotedParameters[i] = lambdaExpr;

						// we have inferred all types, update the method definition
						genericMethod = MakeGenericMethod(method);
					}
				}

				method.MethodBase = genericMethod;
			}

			return true;
		}

		private static bool MethodHasPriority(Expression[] args, MethodData method, MethodData otherMethod)
		{
			var better = false;

			// check conversion from argument list to parameter list
			for (int i = 0, m = 0, o = 0; i < args.Length; i++)
			{
				var arg = args[i];
				var methodParam = method.Parameters[m];
				var otherMethodParam = otherMethod.Parameters[o];
				var methodParamType = ReflectionExtensions.GetParameterType(methodParam);
				var otherMethodParamType = ReflectionExtensions.GetParameterType(otherMethodParam);

				if (methodParamType.ContainsGenericParameters)
					methodParamType = method.PromotedParameters[i].Type;

				if (otherMethodParamType.ContainsGenericParameters)
					otherMethodParamType = otherMethod.PromotedParameters[i].Type;

				var c = TypeUtils.CompareConversions(arg.Type, methodParamType, otherMethodParamType);
				if (c < 0)
					return false;
				if (c > 0)
					better = true;

				if (!ReflectionExtensions.HasParamsArrayType(methodParam)) m++;
				if (!ReflectionExtensions.HasParamsArrayType(otherMethodParam)) o++;
			}

			if (better)
				return true;

			if (method.MethodBase != null &&
				otherMethod.MethodBase != null &&
				!method.MethodBase.IsGenericMethod &&
				otherMethod.MethodBase.IsGenericMethod)
				return true;

			if (!method.HasParamsArray && otherMethod.HasParamsArray)
				return true;

			// if a method has a params parameter, it can have less parameters than the number of arguments
			if (method.HasParamsArray && otherMethod.HasParamsArray && method.Parameters.Count > otherMethod.Parameters.Count)
				return true;

			if (method is IndexerData indexer && otherMethod is IndexerData otherIndexer)
			{
				var declaringType = indexer.Indexer.DeclaringType;
				var otherDeclaringType = otherIndexer.Indexer.DeclaringType;

				var isOtherIndexerIsInParentType = otherDeclaringType.IsAssignableFrom(declaringType);
				if (isOtherIndexerIsInParentType)
				{
					var isIndexerIsInDescendantType = !declaringType.IsAssignableFrom(otherDeclaringType);
					return isIndexerIsInDescendantType;
				}
			}

			return better;
		}

		private static MethodInfo MakeGenericMethod(MethodData method)
		{
			var methodInfo = (MethodInfo)method.MethodBase;
			var actualGenericArgs = ExtractActualGenericArguments(
				method.Parameters.Select(p => p.ParameterType).ToArray(),
				method.PromotedParameters.Select(p => p.Type).ToArray());

			var genericArgs = methodInfo.GetGenericArguments()
				.Select(p => actualGenericArgs.TryGetValue(p.Name, out var typ) ? typ : typeof(object))
				.ToArray();

			MethodInfo genericMethod = null;
			try
			{
				genericMethod = methodInfo.MakeGenericMethod(genericArgs);
			}
			catch (ArgumentException e) when (e.InnerException is VerificationException)
			{
				// this exception is thrown when a generic argument violates the generic constraints
				return null;
			}

			return genericMethod;
		}

		private static Dictionary<string, Type> ExtractActualGenericArguments(
			Type[] methodGenericParameters,
			Type[] methodActualParameters)
		{
			var extractedGenericTypes = new Dictionary<string, Type>();

			for (var i = 0; i < methodGenericParameters.Length; i++)
			{
				var requestedType = methodGenericParameters[i];
				var actualType = methodActualParameters[i];

				if (requestedType.IsGenericParameter)
				{
					if (!actualType.IsGenericParameter)
						extractedGenericTypes[requestedType.Name] = actualType;
				}
				else if (requestedType.IsArray && actualType.IsArray)
				{
					var innerGenericTypes = ExtractActualGenericArguments(
						new[] { requestedType.GetElementType() },
						new[] { actualType.GetElementType()
					});

					foreach (var innerGenericType in innerGenericTypes)
						extractedGenericTypes[innerGenericType.Key] = innerGenericType.Value;
				}
				else if (requestedType.ContainsGenericParameters)
				{
					if (actualType.IsGenericParameter)
					{
						extractedGenericTypes[actualType.Name] = requestedType;
					}
					else
					{
						var requestedInnerGenericArgs = requestedType.GetGenericArguments();
						var actualInnerGenericArgs = actualType.GetGenericArguments();
						if (requestedInnerGenericArgs.Length != actualInnerGenericArgs.Length)
							continue;

						var innerGenericTypes = ExtractActualGenericArguments(requestedInnerGenericArgs, actualInnerGenericArgs);
						foreach (var innerGenericType in innerGenericTypes)
							extractedGenericTypes[innerGenericType.Key] = innerGenericType.Value;
					}
				}
			}

			return extractedGenericTypes;
		}
	}
}