using System;
using System.Collections.Generic;
using System.Linq;
using System.Linq.Expressions;
using System.Reflection;
using DynamicExpresso.Resolution;

namespace DynamicExpresso.Reflection
{
	internal class MemberFinder
	{
		private readonly ParserArguments _arguments;
		private readonly BindingFlags _bindingCase;
		private readonly MemberFilter _memberFilterCase;

		public MemberFinder(ParserArguments arguments)
		{
			_arguments = arguments;
			_bindingCase = arguments.Settings.CaseInsensitive ? BindingFlags.IgnoreCase : BindingFlags.Default;
			_memberFilterCase = arguments.Settings.CaseInsensitive ? Type.FilterNameIgnoreCase : Type.FilterName;
		}

		public MemberInfo FindPropertyOrField(Type type, string memberName, bool staticAccess)
		{
			var flags = BindingFlags.Public | BindingFlags.DeclaredOnly |
						(staticAccess ? BindingFlags.Static : BindingFlags.Instance) | _bindingCase;

			foreach (var t in SelfAndBaseTypes(type))
			{
				var members = t.FindMembers(MemberTypes.Property | MemberTypes.Field, flags, _memberFilterCase, memberName);
				if (members.Length != 0)
					return members[0];
			}
			return null;
		}

		public IList<MethodData> FindMethods(Type type, string methodName, bool staticAccess, Expression[] args)
		{
			var flags = BindingFlags.Public | BindingFlags.DeclaredOnly |
						(staticAccess ? BindingFlags.Static : BindingFlags.Instance) | _bindingCase;
			foreach (var t in SelfAndBaseTypes(type))
			{
				var members = t.FindMembers(MemberTypes.Method, flags, _memberFilterCase, methodName);
				var applicableMethods = MethodResolution.FindBestMethod(members.Cast<MethodBase>(), args);

				if (applicableMethods.Count > 0)
					return applicableMethods;
			}

			return Array.Empty<MethodData>();
		}

		// this method is static, because we know that the Invoke method of a delegate always has this exact name
		// and therefore we never need to search for it in case-insensitive mode
		public static MethodBase FindInvokeMethod(Type type)
		{
			var flags = BindingFlags.Public | BindingFlags.DeclaredOnly |
						BindingFlags.Instance;
			foreach (var t in SelfAndBaseTypes(type))
			{
				var method = t.FindMembers(MemberTypes.Method, flags, Type.FilterName, "Invoke")
					.Cast<MethodBase>()
					.SingleOrDefault();

				if (method != null)
					return method;
			}

			return null;
		}

		public IList<MethodData> FindExtensionMethods(string methodName, Expression[] args)
		{
			var matchMethods = _arguments.GetExtensionMethods(methodName);

			return MethodResolution.FindBestMethod(matchMethods, args);
		}

		public IList<MethodData> FindIndexer(Type type, Expression[] args)
		{
			foreach (var t in SelfAndBaseTypes(type))
			{
				var members = t.GetDefaultMembers();
				if (members.Length != 0)
				{
					var methods = members.
						OfType<PropertyInfo>().
						Select(p => (MethodData)new IndexerData(p));

					var applicableMethods = MethodResolution.FindBestMethod(methods, args);
					if (applicableMethods.Count > 0)
						return applicableMethods;
				}
			}

			return Array.Empty<MethodData>();
		}

		private static IEnumerable<Type> SelfAndBaseTypes(Type type)
		{
			if (type.IsInterface)
			{
				var types = new List<Type>();
				AddInterface(types, type);

				types.Add(typeof(object));

				return types;
			}
			return SelfAndBaseClasses(type);
		}

		private static IEnumerable<Type> SelfAndBaseClasses(Type type)
		{
			while (type != null)
			{
				yield return type;
				type = type.BaseType;
			}
		}

		private static void AddInterface(List<Type> types, Type type)
		{
			if (!types.Contains(type))
			{
				types.Add(type);
				foreach (var t in type.GetInterfaces())
				{
					AddInterface(types, t);
				}
			}
		}
	}
}