using DynamicExpresso.Exceptions;
using NUnit.Framework;
using System;
using System.Collections.Generic;
using System.Linq;

namespace DynamicExpresso.UnitTest
{
	[TestFixture]
	public class LambdaExpressionTest
	{
		private const InterpreterOptions _options = InterpreterOptions.Default | InterpreterOptions.LambdaExpressions;

		[Test]
		public void Invalid_Lambda_Should_Produce_a_ParseException()
		{
			var target = new Interpreter(_options);
			var list = new List<string> { "abc", "dfe", "test" };
			target.SetVariable("list", list);

			Assert.Throws<ParseException>(() => target.Parse("list.Select(str => str.Legnth)") );
		}

		[Test]
		public void Check_Lambda_Return_Type()
		{
			var target = new Interpreter(_options);
			var list = new List<string> { "abc", "dfe", "test" };
			target.SetVariable("list", list);

			var lambda = target.Parse("list.Select(str => str.Length)");

			Assert.That(lambda.ReturnType, Is.EqualTo(typeof(IEnumerable<int>)));
		}

		[Test]
		public void Where_inferred_parameter_type()
		{
			var target = new Interpreter(_options);
			var list = new List<int> { 1, 10, 19, 21 };
			target.SetVariable("myList", list);

			var results = target.Eval<IEnumerable<int>>("myList.Where(x => x >= 19)");

			Assert.That(results.Count(), Is.EqualTo(2));
			Assert.That(results, Is.EqualTo(new[] { 19, 21 }));
		}

		[Test]
		public void Where_explicit_parameter_type()
		{
			var target = new Interpreter(_options);
			var list = new List<int> { 1, 10, 19, 21 };
			target.SetVariable("myList", list);

			var results = target.Eval<IEnumerable<int>>("myList.Where((int x) => x >= 19)");

			Assert.That(results.Count(), Is.EqualTo(2));
			Assert.That(results, Is.EqualTo(new[] { 19, 21 }));
		}

		[Test]
		public void Select_inferred_return_type()
		{
			var target = new Interpreter(_options);
			var list = new List<int> { 1, 10, 19, 21 };
			target.SetVariable("myList", list);

			var results = target.Eval<IEnumerable<char>>("myList.Select(i => i.ToString()).Select(str => str[0])");

			Assert.That(results.Count(), Is.EqualTo(4));
			Assert.That(results, Is.EqualTo(new[] { '1', '1', '1', '2' }));
		}

		[Test]
		public void Where_select()
		{
			var target = new Interpreter(_options);
			var list = new List<string> { "this", "is", "awesome" };
			target.SetVariable("myList", list);

			var results = target.Eval<IEnumerable<string>>("myList.Where(str => str.Length > 5).Select(str => str.ToUpper())");

			Assert.That(results.Count(), Is.EqualTo(1));
			Assert.That(results, Is.EqualTo(new[] { "AWESOME" }));
		}

		[Test]
		public void Lambda_expression_to_delegate()
		{
			var target = new Interpreter(_options);
			var lambda = target.Eval<Func<string, string>>("str => str.ToUpper()");
			Assert.That(lambda.Invoke("test"), Is.EqualTo("TEST"));
		}

		[Test]
		public void Lambda_expression_no_arguments()
		{
			var target = new Interpreter(_options);
			var lambda = target.Eval<Func<int>>("() => 5 + 6");
			Assert.That(lambda.Invoke(), Is.EqualTo(11));
		}

		[Test]
		public void Lambda_expression_to_delegate_multi_params()
		{
			var target = new Interpreter(_options);
			target.SetVariable("increment", 3);
			var lambda = target.Eval<Func<int, string, string>>("(i, str) => str.ToUpper() + (i + increment)");
			Assert.That(lambda.Invoke(5, "test"), Is.EqualTo("TEST8"));
		}

		[Test]
		public void Select_many_str()
		{
			var target = new Interpreter(_options);
			var list = new List<string> { "ab", "cd" };
			target.SetVariable("myList", list);

			var results = target.Eval<IEnumerable<char>>("myList.SelectMany(str => str)");

			Assert.That(results.Count(), Is.EqualTo(4));
			Assert.That(results, Is.EqualTo(new[] { 'a', 'b', 'c', 'd' }));
		}

		[Test]
		public void Select_many()
		{
			var target = new Interpreter(_options);
			var list = new[]{
				new { Strings = new[] { "ab", "cd" } },
				new { Strings = new[] { "ef", "gh" } },
			};

			target.SetVariable("myList", list);

			var results = target.Eval<IEnumerable<string>>("myList.SelectMany(obj => obj.Strings)");

			Assert.That(results.Count(), Is.EqualTo(4));
			Assert.That(results, Is.EqualTo(new[] { "ab", "cd", "ef", "gh" }));
		}

		[Test]
		public void Nested_lambda()
		{
			var target = new Interpreter(_options);
			var list = new List<string> { "ab", "cd" };
			target.SetVariable("myList", list);

			var results = target.Eval<IEnumerable<char>>("myList.Select(str => str.SingleOrDefault(c => c == 'd')).Where(c => c != '\0')");

			Assert.That(results.Count(), Is.EqualTo(1));
			Assert.That(results, Is.EqualTo(new[] { 'd' }));
		}

		[Test]
		public void Lambda_candidate_is_generic_parameter()
		{
			var target = new Interpreter(_options).Reference(typeof(ExtensionMethodExt));
			var str = "cd";
			target.SetVariable("str", str);

			var result = target.Eval<char>("str.MySingleOrDefault(c => c == 'd')");
			Assert.That(result, Is.EqualTo(str.SingleOrDefault(c => c == 'd')));
		}

		[Test]
		public void Lambda_candidate_with_multiple_parameters()
		{
			var target = new Interpreter(_options).Reference(typeof(ExtensionMethodExt));
			var str = "cd";
			target.SetVariable("str", str);

			var result = target.Eval<char>("str.WithSeveralParams((c) => c == 'd')");
			Assert.That(result, Is.EqualTo('d'));

			result = target.Eval<char>("str.WithSeveralParams((c, i) => c == 'd')");
			Assert.That(result, Is.EqualTo('d'));

			result = target.Eval<char>("str.WithSeveralParams((c, i, str2) => c == 'd')");
			Assert.That(result, Is.EqualTo('d'));
		}

		[Test]
		public void Sum()
		{
			var target = new Interpreter(_options);
			var list = new List<int> { 1, 2, 3 };
			target.SetVariable("myList", list);

			var results = target.Eval<int>("myList.Sum()");

			Assert.That(results, Is.EqualTo(6));
		}

		[Test]
		public void Max()
		{
			var target = new Interpreter(_options);
			var list = new List<int> { 1, 2, 3 };
			target.SetVariable("myList", list);

			var results = target.Eval<int>("myList.Max()");

			Assert.That(results, Is.EqualTo(3));
		}

		[Test]
		public void Sum_string_length()
		{
			var target = new Interpreter(_options);
			var list = new List<string> { "abc", "dfe", "test" };
			target.SetVariable("myList", list);

			var results = target.Eval<int>("myList.Sum(str => str.Length)");

			Assert.That(results, Is.EqualTo(10));
		}

		[Test]
		public void Parent_scope_variable()
		{
			var target = new Interpreter(_options);
			var list = new List<int> { 1, 2, 3 };
			target.SetVariable("myList", list);
			target.SetVariable("increment", 3);

			var results = target.Eval<IEnumerable<int>>("myList.Select(i => i + increment)");

			Assert.That(results.Count(), Is.EqualTo(3));
			Assert.That(results, Is.EqualTo(new[] { 4, 5, 6 }));
		}

		[Test]
		public void Lambda_with_multiple_params()
		{
			var target = new Interpreter(_options);
			var list = new List<string> { "aaaaa", "bbbb", "ccc", "ddd" };
			target.SetVariable("myList", list);

			var results = target.Eval<IEnumerable<string>>("myList.TakeWhile((item, idx) => idx <= 2 && item.Length >= 3)");

			Assert.That(results.Count(), Is.EqualTo(3));
			Assert.That(results, Is.EqualTo(new[] { "aaaaa", "bbbb", "ccc" }));
		}

		[Test]
		public void Two_lambda_parameters()
		{
			var target = new Interpreter(_options);
			target.Reference(typeof(WithProp));

			var list = new List<string> { "aaaaa", "bbbb", "ccc", "ddd" };
			target.SetVariable("myList", list);
			var results = target.Eval<Dictionary<string, int>>("myList.ToDictionary(str => new WithProp { MyStr = str }.MyStr, str => str.Length)");

			Assert.That(results.Count, Is.EqualTo(4));
			Assert.That(results, Is.EqualTo(list.ToDictionary(str => new WithProp { MyStr = str }.MyStr, str => str.Length)));
		}

		private class WithProp
		{
			public string MyStr { get; set; }
		}

		[Test]
		public void Zip()
		{
			var target = new Interpreter(_options);
			var strList = new List<string> { "aa", "bb", "cc", "dd" };
			var intList = new List<int> { 1, 2, 3 };
			target.SetVariable("strList", strList);
			target.SetVariable("intList", intList);
			var results = target.Eval<IEnumerable<string>>("strList.Zip(intList, (str, i) => str + i)");

			Assert.That(results.Count(), Is.EqualTo(3));
			Assert.That(results, Is.EqualTo(strList.Zip(intList, (str, i) => str + i)));
		}

		[Test]
		public void Lambda_with_parameter()
		{
			var target = new Interpreter(InterpreterOptions.Default | InterpreterOptions.LambdaExpressions);
			var listInt = target.Eval<IEnumerable<int>>("list.Where(n => n > x)", new Parameter("list", new[] { 1, 2, 3 }), new Parameter("x", 1));
			Assert.That(listInt, Is.EqualTo(new[] { 2, 3 }));

			// ensure the parameters can be reused with different values
			listInt = target.Eval<IEnumerable<int>>("list.Where(n => n > x)", new Parameter("list", new[] { 2, 4, 5 }), new Parameter("x", 2));
			Assert.That(listInt, Is.EqualTo(new[] { 4, 5 }));
		}

		[Test]
		public void Lambda_with_parameter_AsCompiledLambda()
		{
			var target = new Interpreter(InterpreterOptions.Default | InterpreterOptions.LambdaExpressions);
			var parm = new Parameter("x", 1);
			var list = new Parameter("list", new[] { 1, 2, 3 });
			var listLamba = target.Parse("list.Where(n => n > x)", list, parm).Compile<Func<int[], int, IEnumerable<int>>>();
			var result = listLamba(list.Value as int[], 2);
			Assert.That(result, Is.EqualTo(new[] { 3 }));

			var listInt = listLamba(list.Value as int[], 1);
			Assert.That(listInt, Is.EqualTo(new[] { 2, 3 }));

			// ensure the parameters can be reused with different values
			listInt = target.Eval<IEnumerable<int>>("list.Where(n => n > x)", new Parameter("list", new[] { 2, 4, 5 }), new Parameter("x", 2));
			Assert.That(listInt, Is.EqualTo(new[] { 4, 5 }));
		}

		[Test]
		public void Lambda_with_parameter_2()
		{
			var target = new Interpreter(InterpreterOptions.Default | InterpreterOptions.LambdaExpressions);
			var listInt = target.Eval<IEnumerable<int>>("list.Select(n => n - 1).Where(n => n > x).Select(n => n + x)", new Parameter("list", new[] { 1, 2, 3 }), new Parameter("x", 1));
			Assert.That(listInt, Is.EqualTo(new[] { 3 }));
		}

		[Test]
		public void Lambda_with_variable()
		{
			var target = new Interpreter(InterpreterOptions.Default | InterpreterOptions.LambdaExpressions);
			target.SetVariable("list", new[] { 1, 2, 3 });
			target.SetVariable("x", 1);

			var listInt = target.Eval<IEnumerable<int>>("list.Where(n => n > x)");
			Assert.That(listInt, Is.EqualTo(new[] { 2, 3 }));
		}

		public class NestedLambdaTestClass
		{
			public NestedLambdaTestClass()
			{
			}

			public List<NestedLambdaTestClass> Children
			{
				get; set;
			}

			public string Name
			{
				get; set;
			}

			// TODO
			// Add support for non generics with our lambda evaluation
			// The below fails to compile
			// public string GetChildrenIdentifiers<T>(Func<NestedLambdaTestClass, T> f)
			public string GetChildrenIdentifiers<T>(Func<NestedLambdaTestClass, T> f)
			{
				if (Children == null)
				{
					return string.Empty;
				}
				return string.Join(",", Children.Select(f));
			}
		}

		[Test]
		public void Lambda_WithMultipleNestedExpressions()
		{
			var root = BuildNestedTestClassHierarchy();
			var expectedResult = root.GetChildrenIdentifiers(
				// root
				l1 => l1.Name + l1.GetChildrenIdentifiers(
					// level 2, references my parameter, plus original lamda
					l2 => l2.Name + l1.Name + l2.GetChildrenIdentifiers(
						// level 3, references my parameter, plus parameter from l1 lamda
						l3 => l3.Name + l2.Name + l3.GetChildrenIdentifiers(
							// level 4, references my parameter, plus all parameters that have been used 
							l4 => l4.Name + l2.Name + l3.Name + l1.Name + root.Name)
							)));

			var target = new Interpreter(InterpreterOptions.Default | InterpreterOptions.LambdaExpressions);

			var evalResult = target.Eval<string>(@"root.GetChildrenIdentifiers(
				l1 => l1.Name + l1.GetChildrenIdentifiers(
					l2 => l2.Name + l1.Name + l2.GetChildrenIdentifiers(
						l3 => l3.Name + l2.Name + l3.GetChildrenIdentifiers(
							l4 => l4.Name + l2.Name + l3.Name + l1.Name + root.Name)
							)))", new Parameter(nameof(root), root));
			Assert.That(evalResult, Is.EqualTo(expectedResult));
		}

		[Test]
		public void Lambda_SameParameterNameInDifferentLambdas()
		{
			var root = BuildNestedTestClassHierarchy();
			var expectedResult = root.GetChildrenIdentifiers(
				// root
				l1 => l1.Name + l1.GetChildrenIdentifiers(
					// level 2, references my parameter, plus original lamda
					l2 => l2.Name + l1.Name + l2.GetChildrenIdentifiers(l3 => l2.Name) + l2.GetChildrenIdentifiers(
						// level 3, references my parameter, plus parameter from l1 lamda
						l3 => l3.Name + l2.Name + l3.GetChildrenIdentifiers(
							// level 4, references my parameter, plus all parameters that have been used 
							l4 => l4.Name + l2.Name + l3.Name + l1.Name + root.Name)
							)));

			var target = new Interpreter(InterpreterOptions.Default | InterpreterOptions.LambdaExpressions);

			var evalResult = target.Eval<string>(@"root.GetChildrenIdentifiers(
				l1 => l1.Name + l1.GetChildrenIdentifiers(
					l2 => l2.Name + l1.Name + l2.GetChildrenIdentifiers(l3 => l2.Name) + + l2.GetChildrenIdentifiers(
						l3 => l3.Name + l2.Name + l3.GetChildrenIdentifiers(
							l4 => l4.Name + l2.Name + l3.Name + l1.Name + root.Name)
							)))", new Parameter(nameof(root), root));
			Assert.That(evalResult, Is.EqualTo(expectedResult));
		}

		[Test]
		public void Lambda_CannotUseDuplicateParameterInSubLambda()
		{
			var target = new Interpreter(InterpreterOptions.Default | InterpreterOptions.LambdaExpressions);
			Assert.Throws<ParseException>(() => target.Parse(@"root.GetChildrenIdentifiers(
				l1 => l1.Name + l1.GetChildrenIdentifiers(
					l2 => l2.Name + l1.Name + l2.GetChildrenIdentifiers(l2 => l2.Name) + l2.GetChildrenIdentifiers(
						l3 => l3.Name + l2.Name + l3.GetChildrenIdentifiers(
							l4 => l4.Name + l2.Name + l3.Name + l1.Name + root.Name)
							)))", new Parameter("root", typeof(NestedLambdaTestClass))));
		}

		private class Npc
		{
			public int Money { get; set; }
			public void AddMoney(Action<Npc, int, string> action)
			{
				action(this, 10, "test");
			}
		}

		[Test]
		public void Lambda_ShouldAllowActionLambda()
		{
			var target = new Interpreter(InterpreterOptions.LambdaExpressions);

			var list = new List<Npc>() { new Npc { Money = 10 } };
			target.SetVariable("list", list);

			var result = target.Eval(@"list.ForEach(n => n.Money = 5)");
			Assert.That(result, Is.Null);
			Assert.That(list[0].Money, Is.EqualTo(5));
		}

		[Test]
		public void Lambda_MultipleActionLambdaParameters()
		{
			var target = new Interpreter(InterpreterOptions.LambdaExpressions);

			var npc = new Npc { Money = 10 };
			target.SetVariable("npc", npc);

			var result = target.Eval(@"npc.AddMoney((n, i, str) => n.Money = i + str.Length)");
			Assert.That(result, Is.Null);
			Assert.That(npc.Money, Is.EqualTo(14));
		}

		private static NestedLambdaTestClass BuildNestedTestClassHierarchy()
		{
			return new NestedLambdaTestClass()
			{
				Name = "Root",
				Children = new List<NestedLambdaTestClass>()
				{
					new NestedLambdaTestClass()
					{
						Name = "A",
						Children = new List<NestedLambdaTestClass>()
						{
							new NestedLambdaTestClass()
							{
								Name = "B",
								Children = new List<NestedLambdaTestClass>()
								{
									new NestedLambdaTestClass()
									{
										Name = "C",
								Children = new List<NestedLambdaTestClass>()
								{
									new NestedLambdaTestClass()
									{
										Name = "C"
									},
									new NestedLambdaTestClass()
									{
										Name = "F"
									}
								}
									},
									new NestedLambdaTestClass()
									{
										Name = "F",
								Children = new List<NestedLambdaTestClass>()
								{
									new NestedLambdaTestClass()
									{
										Name = "C"
									},
									new NestedLambdaTestClass()
									{
										Name = "F"
									}
								}
									}
								}
							},
							new NestedLambdaTestClass()
							{
								Name = "D",
								Children = new List<NestedLambdaTestClass>()
								{
									new NestedLambdaTestClass()
									{
										Name = "E",
								Children = new List<NestedLambdaTestClass>()
								{
									new NestedLambdaTestClass()
									{
										Name = "C"
									},
									new NestedLambdaTestClass()
									{
										Name = "F"
									}
								}
									},
									new NestedLambdaTestClass()
									{
										Name = "G",
								Children = new List<NestedLambdaTestClass>()
								{
									new NestedLambdaTestClass()
									{
										Name = "C"
									},
									new NestedLambdaTestClass()
									{
										Name = "F"
									}
								}
									}
								}
							}
						}
					},
					new NestedLambdaTestClass()
					{
						Name = "B",
						Children = new List<NestedLambdaTestClass>()
						{
							new NestedLambdaTestClass()
							{
								Name = "B",
								Children = new List<NestedLambdaTestClass>()
								{
									new NestedLambdaTestClass()
									{
										Name = "C",
								Children = new List<NestedLambdaTestClass>()
								{
									new NestedLambdaTestClass()
									{
										Name = "C"
									},
									new NestedLambdaTestClass()
									{
										Name = "F"
									}
								}
									},
									new NestedLambdaTestClass()
									{
										Name = "F",
								Children = new List<NestedLambdaTestClass>()
								{
									new NestedLambdaTestClass()
									{
										Name = "C"
									},
									new NestedLambdaTestClass()
									{
										Name = "F"
									}
								}
									}
								}
							},
							new NestedLambdaTestClass()
							{
								Name = "D",
								Children = new List<NestedLambdaTestClass>()
								{
									new NestedLambdaTestClass()
									{
										Name = "E",
								Children = new List<NestedLambdaTestClass>()
								{
									new NestedLambdaTestClass()
									{
										Name = "C"
									},
									new NestedLambdaTestClass()
									{
										Name = "F",
								Children = new List<NestedLambdaTestClass>()
								{
									new NestedLambdaTestClass()
									{
										Name = "C"
									},
									new NestedLambdaTestClass()
									{
										Name = "F"
									}
								}
									}
								}
									},
									new NestedLambdaTestClass()
									{
										Name = "G"
									}
								}
							}
						}
					}
				}
			};
		}
	}

	/// <summary>
	/// Ensure that a lambda expression is matched to a parameter of type delegate
	/// (so the 1st overload shouldn't be considered during resolution)
	/// </summary>
	internal static class ExtensionMethodExt
	{
		public static TSource MySingleOrDefault<TSource>(this IEnumerable<TSource> source, TSource defaultValue)
		{
			return source.SingleOrDefault();
		}

		public static TSource MySingleOrDefault<TSource>(this IEnumerable<TSource> source, Func<TSource, bool> predicate)
		{
			return source.SingleOrDefault(predicate);
		}

		public static TSource WithSeveralParams<TSource>(this IEnumerable<TSource> source, Func<TSource, bool> predicate)
		{
			return source.SingleOrDefault(predicate);
		}

		public static TSource WithSeveralParams<TSource>(this IEnumerable<TSource> source, Func<TSource, int, bool> predicate)
		{
			return source.SingleOrDefault(_ => predicate(_, 0));
		}

		public static TSource WithSeveralParams<TSource>(this IEnumerable<TSource> source, Func<TSource, int, string, bool> predicate)
		{
			return source.SingleOrDefault(_ => predicate(_, 0, string.Empty));
		}
	}
}