using System;
using System.Collections;
using System.Collections.Generic;
using System.Dynamic;
using System.Linq;
using System.Reflection;
using System.Text.RegularExpressions;
using DynamicExpresso.Exceptions;
using NUnit.Framework;

// ReSharper disable SpecifyACultureInStringConversionExplicitly

namespace DynamicExpresso.UnitTest
{
	[TestFixture]
	public class GithubIssues
	{
		[Test]
		public void GitHub_Issue_19()
		{
			var interpreter = new Interpreter();

			Assert.That(interpreter.Eval("5.0.ToString()"), Is.EqualTo(5.0.ToString()));
			Assert.That(interpreter.Eval("(5).ToString()"), Is.EqualTo((5).ToString()));
			Assert.That(interpreter.Eval("(5.0).ToString()"), Is.EqualTo((5.0).ToString()));
			Assert.That(interpreter.Eval("5.ToString()"), Is.EqualTo(5.ToString()));
		}

		[Test]
		public void GitHub_Issue_43()
		{
			var interpreter = new Interpreter();

			Assert.That(interpreter.Eval("-.5.ToString()"), Is.EqualTo((-.5).ToString()));
			Assert.That(interpreter.Eval(".1.ToString()"), Is.EqualTo((.1).ToString()));
			Assert.That(interpreter.Eval("(-1-.1-0.1).ToString()"), Is.EqualTo((-1 - .1 - 0.1).ToString()));
		}

		[Test]
		public void GitHub_Issue_68()
		{
			var interpreter = new Interpreter();

			var array = new[] { 5, 10, 6 };

			interpreter.SetVariable("array", array);

			Assert.That(interpreter.Eval("array.Contains(5)"), Is.EqualTo(array.Contains(5)));
			Assert.That(interpreter.Eval("array.Contains(3)"), Is.EqualTo(array.Contains(3)));
		}

		[Test]
		public void GitHub_Issue_64()
		{
			var interpreter = new Interpreter();
			Assert.That(interpreter.Eval("null ?? null"), Is.Null);
			Assert.That(interpreter.Eval("\"hallo\" ?? null"), Is.EqualTo("hallo"));
			Assert.That(interpreter.Eval("null ?? \"hallo\""), Is.EqualTo("hallo"));
		}

		[Test]
		public void GitHub_Issue_65_Part1()
		{
			var interpreter = new Interpreter();

			var x = new
			{
				var1 = "hallo",
				var2 = (string)null
			};

			interpreter.SetVariable("x", x);
			Assert.That(interpreter.Eval("x.var1?.ToString()"), Is.EqualTo("hallo"));
			Assert.That(interpreter.Eval("x.var2?.ToString()"), Is.Null);
			Assert.That(interpreter.Eval("x.var1?.Substring(1)"), Is.EqualTo("allo"));
		}

		[Test]
		public void GitHub_Issue_65_Part2()
		{
			var interpreter = new Interpreter();

			var x = new
			{
				var1 = "hallo",
				var2 = (string)null
			};

			interpreter.SetVariable("x", x);
			Assert.That(interpreter.Eval("x.var1?[2]"), Is.EqualTo(x.var1?[2]));
			Assert.That(interpreter.Eval("x.var2?[2]"), Is.EqualTo(x.var2?[2]));
			Assert.That(interpreter.Eval("x.var1?[2] == 'l'"), Is.EqualTo(x.var1?[2] == 'l'));
			Assert.That(interpreter.Eval("x.var2?[2] == null"), Is.EqualTo(x.var2?[2] == null));
		}

		[Test]
		public void GitHub_Issue_88()
		{
			var interpreter = new Interpreter();

			interpreter.SetVariable("a", 1, typeof(int));
			interpreter.SetVariable("b", 1.2, typeof(double?));
			var result = interpreter.Eval("a + b");

			Assert.That(result, Is.EqualTo(2.2));
		}

		[Test]
		public void GitHub_Issue_128()
		{
			var target = new Interpreter();

			Assert.Throws<ParseException>(() => target.Eval("1+1*"));
			Assert.Throws<ParseException>(() => target.Eval("1+1*'a'"));
		}

		[Test]
		public void GitHub_Issue_133()
		{
			var interpreter = new Interpreter();

			Assert.That(interpreter.Eval("1+1e10"), Is.EqualTo(10000000001));
			Assert.That(interpreter.Eval("1+1e+10"), Is.EqualTo(10000000001));
			Assert.That(interpreter.Eval("1+1e-10"), Is.EqualTo(1.0000000001));
			Assert.That(interpreter.Eval("1 - 2.02e10"), Is.EqualTo(-20199999999));
			Assert.That(interpreter.Eval("1 - 2.02e+10"), Is.EqualTo(-20199999999));
			Assert.That(interpreter.Eval("1 - 2.02e-10"), Is.EqualTo(0.999999999798));
			Assert.That(interpreter.Eval("1/1e+10"), Is.EqualTo(1e-10));

			interpreter.SetVariable("@Var1", 1);
			interpreter.SetVariable("@Var2", 1e+10);
			Assert.That(interpreter.Eval("@Var1+@Var2"), Is.EqualTo(10000000001));

			interpreter.SetVariable("e", 2);
			Assert.That(interpreter.Eval("@Var1+@Var2+e"), Is.EqualTo(10000000003));
		}

		private delegate bool GFunction(string arg = null);

		static bool GetGFunction1(string arg = null)
		{
			return arg != null;
		}

		[Test]
		public void GitHub_Issue_144_1()
		{
			// GetGFunction1 is defined outside the test function
			GFunction gFunc1 = GetGFunction1;

			Assert.That(gFunc1.Method.GetParameters()[0].HasDefaultValue, Is.True);

			var flags = BindingFlags.Public | BindingFlags.DeclaredOnly | BindingFlags.Instance;
			var invokeMethod1 = (MethodInfo)gFunc1.GetType().FindMembers(MemberTypes.Method, flags, Type.FilterName, "Invoke")[0];
			Assert.That(invokeMethod1.GetParameters()[0].HasDefaultValue, Is.True);

			var interpreter = new Interpreter();
			interpreter.SetFunction("GFunction", gFunc1);
			interpreter.SetVariable("arg", "arg");

			Assert.That((bool)interpreter.Eval("GFunction(arg)"), Is.True);
			Assert.That((bool)interpreter.Eval("GFunction()"), Is.False);
		}

		[Test]
		public void GitHub_Issue_148()
		{
			Func<object[], double, double, object[]> subArray = (entries, skipFirst, skipLast) => entries.Take(entries.Length - (int)skipLast).Skip((int)skipFirst).ToArray();

			var target = new Interpreter();

			target.SetVariable("arr1", new object[] { 1d, 2d, 3d });
			target.SetFunction("SubArray", subArray);

			Assert.That(target.Eval("SubArray(arr1, 1, 1).First()"), Is.EqualTo(2));
		}

		[Test]
		public void GitHub_Issue_159_ambiguous_call()
		{
			Func<double?, int> f1 = d => 1;
			Func<string, int> f2 = o => 2;

			var interpreter = new Interpreter();
			interpreter.SetFunction("f", f1);
			interpreter.SetFunction("f", f2);

			// we should properly throw an ambiguous invocation exception (multiple matching overloads found)
			// and not an Argument list incompatible with delegate expression (no matching overload found)
			var exc = Assert.Throws<ParseException>(() => interpreter.Eval("f(null)"));
			Assert.That(exc.Message, Does.StartWith("Ambiguous invocation of delegate (multiple overloads found)"));
		}


		[Test]
		public void GitHub_Issue_159_unset_identifier()
		{
			Func<int> f1 = () => 1;

			var interpreter = new Interpreter();
			interpreter.SetFunction("f", f1);

			Assert.That(interpreter.Eval("f()"), Is.EqualTo(1));

			// calls to f should lead to an unknown identifier exception
			interpreter.UnsetFunction("f");
			Assert.Throws<UnknownIdentifierException>(() => interpreter.Eval("f()"));
		}


#if NETCOREAPP2_1_OR_GREATER

		[Test]
		public void GitHub_Issue_144_2()
		{
			// GetGFunction2 is defined inside the test function
			static bool GetGFunction2(string arg = null)
			{
				return arg != null;
			}

			GFunction gFunc2 = GetGFunction2;

			var flags = BindingFlags.Public | BindingFlags.DeclaredOnly | BindingFlags.Instance;
			var invokeMethod2 = (MethodInfo)gFunc2.GetType().FindMembers(MemberTypes.Method, flags, Type.FilterName, "Invoke")[0];
			Assert.That(invokeMethod2.GetParameters()[0].HasDefaultValue, Is.True);

			var interpreter = new Interpreter();
			interpreter.SetFunction("GFunction", gFunc2);
			interpreter.SetVariable("arg", "arg");

			Assert.That((bool)interpreter.Eval("GFunction(arg)"), Is.True);
			Assert.That((bool)interpreter.Eval("GFunction()"), Is.False);
		}

		[Test]
		public void GitHub_Issue_144_3()
		{
			// GetGFunction2 is defined inside the test function
			static bool GetGFunction2(string arg)
			{
				return arg == null;
			}

			GFunction gFunc1 = GetGFunction1;
			GFunction gFunc2 = GetGFunction2;

			var interpreter = new Interpreter();
			interpreter.SetFunction("GFunction", gFunc1);
			interpreter.SetFunction("GFunction", gFunc2);
			interpreter.SetVariable("arg", "arg");

			// ambiguous call
			Assert.Throws<ParseException>(() => interpreter.Eval("GFunction(arg)"));

			// GFunction1 is used
			// because gFunc1.Method.GetParameters()[0].HasDefaultValue == true
			// and     gFunc2.Method.GetParameters()[0].HasDefaultValue == false
			Assert.That((bool)interpreter.Eval("GFunction()"), Is.False);
		}

#endif

		[Test]
		public void GitHub_Issue_164()
		{
			var interpreter = new Interpreter();

			var str = "str";

			interpreter.SetVariable("str", str);
			Assert.That(interpreter.Eval("str?.Length"), Is.EqualTo(str?.Length));
			Assert.That(interpreter.Eval<bool>("str?.Length == 3"), Is.EqualTo(str?.Length == 3));

			str = null;
			interpreter.SetVariable("str", str);
			Assert.That(interpreter.Eval("str?.Length"), Is.EqualTo(str?.Length));
			Assert.That(interpreter.Eval<bool>("str?.Length == 0"), Is.EqualTo(str?.Length == 0));
		}

		[Test]
		public void GitHub_Issue_164_bis()
		{
			var interpreter = new Interpreter();

			var lambda = interpreter.Parse("Scope?.ValueInt", new Parameter("Scope", typeof(Scope)));

			var result = lambda.Invoke((Scope)null);
			Assert.That(result, Is.Null);

			result = lambda.Invoke(new Scope { ValueInt = 5 });
			Assert.That(result, Is.EqualTo(5));

			var scope = new Scope { Value = 5 };
			interpreter.SetVariable("scope", scope);
			Assert.That(interpreter.Eval<bool>("scope?.Value.HasValue"), Is.EqualTo(scope?.Value.HasValue));

			// must throw, because scope.ValueInt is not a nullable type
			Assert.Throws<ParseException>(() => interpreter.Eval<bool>("scope.ValueInt.HasValue"));
		}

		private class Scope
		{
			public int ValueInt { get; set; }
			public int? Value { get; set; }

			public int[] ArrInt { get; set; }
			public int?[] Arr { get; set; }
		}

		[Test]
		public void GitHub_Issue_169()
		{
			var interpreter = new Interpreter();

			var lambda = interpreter.Parse("Scope?.Value", new Parameter("Scope", typeof(Scope)));

			var result = lambda.Invoke((Scope)null);
			Assert.That(result, Is.Null);

			result = lambda.Invoke(new Scope());
			Assert.That(result, Is.Null);

			result = lambda.Invoke(new Scope { Value = null });
			Assert.That(result, Is.Null);

			result = lambda.Invoke(new Scope { Value = 5 });
			Assert.That(result, Is.EqualTo(5));
		}

		[Test]
		public void GitHub_Issue_169_bis()
		{
			var interpreter = new Interpreter();

			var lambda = interpreter.Parse("Scope?.Arr?[0]", new Parameter("Scope", typeof(Scope)));

			var result = lambda.Invoke(new Scope());
			Assert.That(result, Is.Null);

			result = lambda.Invoke(new Scope { Arr = null });
			Assert.That(result, Is.Null);

			result = lambda.Invoke(new Scope { Arr = new int?[] { 5 } });
			Assert.That(result, Is.EqualTo(5));
		}

		[Test]
		public void GitHub_Issue_169_ter()
		{
			var interpreter = new Interpreter();

			var lambda = interpreter.Parse("Scope?.ArrInt?[0]", new Parameter("Scope", typeof(Scope)));

			var result = lambda.Invoke(new Scope());
			Assert.That(result, Is.Null);

			result = lambda.Invoke(new Scope { ArrInt = new int[] { 5 } });
			Assert.That(result, Is.EqualTo(5));

			interpreter.SetVariable("scope", new Scope { ArrInt = new int[] { 5 } });
			var resultNullableBool = interpreter.Eval<bool>("scope?.ArrInt?[0].HasValue");
			Assert.That(resultNullableBool, Is.True);

			// must throw, because scope.ValueInt is not a nullable type
			Assert.Throws<ParseException>(() => interpreter.Eval<bool>("scope.ArrInt[0].HasValue"));
		}

		[Test]
		public void GitHub_Issue_169_quatro()
		{
			var interpreter = new Interpreter();

			interpreter.SetVariable("x", (int?)null);
			var result = interpreter.Eval<string>("x?.ToString()");
			Assert.That(result, Is.Null);

			interpreter.SetVariable("x", (int?)56);
			result = interpreter.Eval<string>("x?.ToString()");
			Assert.That(result, Is.EqualTo("56"));
		}

		[Test]
		public void GitHub_Issue_197()
		{
			var interpreterWithLambdas = new Interpreter(InterpreterOptions.DefaultCaseInsensitive | InterpreterOptions.LambdaExpressions);
			var interpreterWithoutLambdas = new Interpreter(InterpreterOptions.DefaultCaseInsensitive);

			var stringExpression = "booleanValue ? someStringValue : \".\"";
			var parameters = new List<Parameter>
			{
				new Parameter($"someStringValue", typeof(string), $"E33"),
				new Parameter("booleanValue", typeof(bool), true)
			};

			var expressionWithoutLambdas = interpreterWithoutLambdas.Parse(stringExpression, typeof(void), parameters.ToArray());
			Assert.That(expressionWithoutLambdas.Invoke(parameters.ToArray()), Is.EqualTo("E33"));

			var expressionWithLambdas = interpreterWithLambdas.Parse(stringExpression, typeof(void), parameters.ToArray());
			Assert.That(expressionWithLambdas.Invoke(parameters.ToArray()), Is.EqualTo("E33"));
		}

		[Test]
		public void GitHub_Issue_185()
		{
			var interpreter = new Interpreter().SetVariable("a", 123L);

			// forcing the return type to object should work
			// (ie a conversion expression should be emitted from long to object)
			var del = interpreter.ParseAsDelegate<Func<object>>("a*2");
			var result = del();
			Assert.That(result, Is.EqualTo(246));
		}

		[Test]
		public void GitHub_Issue_185_2()
		{
			var interpreter = new Interpreter().SetVariable("a", 123L);
			var del = interpreter.ParseAsDelegate<Func<dynamic>>("a*2");
			var result = del();
			Assert.That(result, Is.EqualTo(246));
		}

		[Test]
		public void GitHub_Issue_191()
		{
			var interpreter = new Interpreter();
			interpreter.Reference(typeof(Utils));

			var result = interpreter.Eval<object>("Utils.Select(Utils.Array(\"a\", \"b\"), \"x+x\")");
			Assert.That(result, Is.Not.Null);
		}

		[Test]
		public void GitHub_Issue_203()
		{
			var target = new Interpreter();
			target.Reference(typeof(Utils));

			var list = new[] { 1, 2, 3 };

			var listInt = target.Eval<List<int>>("Utils.Array(list)", new Parameter("list", list));
			Assert.That(listInt, Is.EqualTo(Utils.Array(list)));
		}

		[Test]
		public void GitHub_Issue_205_Property_on_nullable()
		{
			var interpreter = new Interpreter();

			DateTime? date = DateTime.UtcNow;
			interpreter.SetVariable("date", date);

			Assert.That(interpreter.Eval("date?.Day"), Is.EqualTo(date?.Day));
			Assert.That(interpreter.Eval("date?.IsDaylightSavingTime()"), Is.EqualTo(date?.IsDaylightSavingTime()));

			date = null;
			interpreter.SetVariable("date", date);

			Assert.That(interpreter.Eval("date?.Day"), Is.EqualTo(date?.Day));
			Assert.That(interpreter.Eval("date?.IsDaylightSavingTime()"), Is.EqualTo(date?.IsDaylightSavingTime()));
		}

		[Test]
		public void GitHub_Issue_205()
		{
			var interpreter = new Interpreter();

			var date1 = DateTimeOffset.UtcNow;
			DateTimeOffset? date2 = null;

			interpreter.SetVariable("date1", date1);
			interpreter.SetVariable("date2", date2);

			Assert.That(interpreter.Eval("(date1 - date2)?.Days"), Is.Null);
			Assert.That(interpreter.Eval("(date2 - date1)?.Days"), Is.Null);

			date2 = date1.AddDays(1);
			interpreter.SetVariable("date2", date2);
			Assert.That(interpreter.Eval("(date1 - date2)?.Days"), Is.EqualTo(-1));
			Assert.That(interpreter.Eval("(date2 - date1)?.Days"), Is.EqualTo(1));
		}

		[Test]
		public void GitHub_Issue_217()
		{
			var target = new Interpreter();
			target.Reference(typeof(Utils));
			target.Reference(typeof(IEnumerable<>));

			Assert.That(Utils.Any((IEnumerable<object>)null), Is.EqualTo(1));
			Assert.That(Utils.Any((IEnumerable)null), Is.EqualTo(2));
			Assert.That(Utils.Any(null), Is.EqualTo(2));
			Assert.That(target.Eval("Utils.Any(list)", new Parameter("list", typeof(IEnumerable<object>), null)), Is.EqualTo(1));
			Assert.That(target.Eval("Utils.Any(list)", new Parameter("list", typeof(IEnumerable), null)), Is.EqualTo(2));
			Assert.That(target.Eval("Utils.Any(null)"), Is.EqualTo(2));
		}

		[Test]
		public void GitHub_Issue_221_Case_insensitivity()
		{
			var interpreter = new Interpreter(InterpreterOptions.LambdaExpressions | InterpreterOptions.DefaultCaseInsensitive)
				.Reference(typeof(DateTimeOffset))
				.Reference(typeof(GithubIssuesTestExtensionsMethods))
				.SetFunction("Now", (Func<DateTimeOffset>)(() => DateTimeOffset.UtcNow))
				.SetVariable("List", new List<DateTimeOffset> { DateTimeOffset.UtcNow.AddDays(5) })
				.SetVariable("DateInThePast", DateTimeOffset.UtcNow.AddDays(-5));

			// actual case
			Assert.That(interpreter.Eval<bool>("List.Any(x => x > Now())"), Is.True);
			Assert.That(interpreter.Eval<bool>("List.Any(x => x is DateTimeOffset)"), Is.True);
			Assert.That(interpreter.Eval<bool>("DateInThePast.IsInFuture()"), Is.False);

			// case insensivity outside lambda expressions
			Assert.That(interpreter.Eval<bool>("dateinthepast > now()"), Is.False); // identifier
			Assert.That(interpreter.Eval<bool>("dateinthepast is datetimeoffset"), Is.True); // known type
			Assert.That(interpreter.Eval<bool>("dateinthepast.isinfuture()"), Is.False); // extension method

			// ensure the case insensitivity option is also used in the lambda expression
			Assert.That(interpreter.Eval<bool>("list.Any(x => x > now())"), Is.True); // identifier
			Assert.That(interpreter.Eval<bool>("list.Any(x => x is datetimeoffset)"), Is.True); // known type
			Assert.That(interpreter.Eval<bool>("list.Any(x => x.isinfuture())"), Is.True); // extension method
		}

		[Test]
		public void GitHub_Issue_221_Reflection_not_allowed()
		{
			var interpreter = new Interpreter(InterpreterOptions.LambdaExpressions | InterpreterOptions.Default)
				.SetVariable("list", new List<Type> { typeof(double) });

			Assert.Throws<ReflectionNotAllowedException>(() => interpreter.Parse("typeof(double).GetMethods()"));
			Assert.Throws<ReflectionNotAllowedException>(() => interpreter.Parse("list.SelectMany(t => t.GetMethods())"));
		}

		public static class Utils
		{
			public static List<T> Array<T>(IEnumerable<T> collection) => new List<T>(collection);
			public static List<dynamic> Array(params dynamic[] array) => Array((IEnumerable<dynamic>)array);
			public static int ParamArrayObjects(params object[] values) => values.Length;
			public static IEnumerable<dynamic> Select<TSource>(IEnumerable<TSource> collection, string expression) => new List<dynamic>();
			public static IEnumerable<dynamic> Select(IEnumerable collection, string expression) => new List<dynamic>();
			public static int Any<T>(IEnumerable<T> collection) => 1;
			public static int Any(IEnumerable collection) => 2;
		}

		[Test]
		public void GitHub_Issue_235()
		{
			var target = new Interpreter();
			target.Reference(typeof(RegexOptions));
			target.Reference(typeof(DateTimeKind));

			var result = target.Eval<RegexOptions>("RegexOptions.Compiled | RegexOptions.Singleline");
			Assert.That(result.HasFlag(RegexOptions.Compiled), Is.True);
			Assert.That(result.HasFlag(RegexOptions.Singleline), Is.True);

			// DateTimeKind doesn't have the Flags attribute: the bitwise operation returns an integer
			var result2 = target.Eval<DateTimeKind>("DateTimeKind.Local | DateTimeKind.Utc");
			Assert.That(result2, Is.EqualTo((DateTimeKind)3));
		}

		[Test]
		public void GitHub_Issue_212()
		{
			var target = new Interpreter(InterpreterOptions.Default | InterpreterOptions.LambdaExpressions);
			var list = new Parameter("list", new[] { 1, 2, 3 });
			var value1 = new Parameter("value", 1);
			var value2 = new Parameter("value", 2);
			var expression = "list.Where(x => x > value)";
			var lambda = target.Parse(expression, list, value1);
			var result = lambda.Invoke(list, value2);
			Assert.That(result, Is.EqualTo(new[] { 3 }));
		}

		[Test]
		public void GitHub_Issue_212_bis()
		{
			var target = new Interpreter(InterpreterOptions.Default | InterpreterOptions.LambdaExpressions);
			var list = new Parameter("list", new[] { 1, 2, 3 });
			var value1 = new Parameter("value", 1);
			var value2 = new Parameter("value", 2);
			var expression = "list.Where(x => x > value)";
			var lambda = target.Parse(expression, (new[] { list, value1 }).Select(p => new Parameter(p.Name, p.Type)).ToArray());
			var result = lambda.Invoke(list, value1);
			Assert.That(result, Is.EqualTo(new[] { 2, 3 }));
		}

		[Test]
		public void GitHub_Issue_200_capture()
		{
			var target = new Interpreter(InterpreterOptions.Default | InterpreterOptions.LambdaExpressions);
			var list = new List<string> { "ab", "cdc" };
			target.SetVariable("myList", list);

			// the str parameter is captured, and can be used in the nested lambda
			var results = target.Eval("myList.Select(str => str.Select(c => str.Length))");
			Assert.That(results, Is.EqualTo(new[] { new[] { 2, 2 }, new[] { 3, 3, 3 } }));
		}

		[Test]
		public void Lambda_Issue_256()
		{
			ICollection<BonusMatrix> annualBonus = new List<BonusMatrix> {
				new BonusMatrix() { Grade = 1, BonusFactor = 7 },
				new BonusMatrix() { Grade = 2, BonusFactor = 5.5 },
				new BonusMatrix() { Grade = 3, BonusFactor = 4 },
				new BonusMatrix() { Grade = 4, BonusFactor = 3.5 },
				new BonusMatrix() { Grade = 5, BonusFactor = 3 }
			};

			ICollection<Employee> employees = new List<Employee> {
				new Employee() { Id = "01", Name = "A", Grade = 5, Salary = 20000}, //bonus = 20000 * 7   = 60000
                new Employee() { Id = "02", Name = "B", Grade = 5, Salary = 18000}, //bonus = 18000 * 7   = 54000
                new Employee() { Id = "03", Name = "C", Grade = 4, Salary = 12000}, //bonus = 12000 * 5.5 = 42000
                new Employee() { Id = "04", Name = "D", Grade = 4, Salary = 10000}, //bonus = 10000 * 5.5 = 35000
                new Employee() { Id = "05", Name = "E", Grade = 3, Salary = 8500},  //bonus = 8500  * 4   = 34000
                new Employee() { Id = "06", Name = "F", Grade = 3, Salary = 8000},  //bonus = 8000  * 4   = 32000
                new Employee() { Id = "07", Name = "G", Grade = 2, Salary = 5000},  //bonus = 5000  * 3.5 = 27500
                new Employee() { Id = "08", Name = "H", Grade = 2, Salary = 4750},  //bonus = 4750  * 3.5 = 26125
                new Employee() { Id = "09", Name = "I", Grade = 1, Salary = 3500},  //bonus = 3500  * 3   = 24500
                new Employee() { Id = "10", Name = "J", Grade = 1, Salary = 3250}   //bonus = 3250  * 3   = 22750
            };

			var interpreter = new Interpreter(InterpreterOptions.LambdaExpressions | InterpreterOptions.Default);
			interpreter.SetVariable(nameof(annualBonus), annualBonus);
			interpreter.SetVariable(nameof(employees), employees);

			var totalBonus = employees.Sum(x => x.Salary * (annualBonus.SingleOrDefault(y => y.Grade == x.Grade).BonusFactor)); //total = 357875

			var evalSum = interpreter.Eval("employees.Sum(x => x.Salary * (annualBonus.SingleOrDefault(y => y.Grade == x.Grade).BonusFactor))");
			Assert.That(evalSum, Is.EqualTo(totalBonus));
		}

		public class Employee
		{
			public string Id { get; set; }
			public string Name { get; set; }
			public int Grade { get; set; }
			public double Salary { get; set; }
		}

		public class BonusMatrix
		{
			public int Grade { get; set; }
			public double BonusFactor { get; set; }
		}

		[Test]
		public void Lambda_Issue_259()
		{
			var options = InterpreterOptions.Default | InterpreterOptions.LambdaExpressions;
			var interpreter = new Interpreter(options);
			interpreter.SetVariable("courseList", new[] { new { PageName = "Test" } });
			interpreter.Reference(typeof(PageType));

			var results = interpreter.Eval<IEnumerable<PageType>>(@"courseList.Select(x => new PageType() { PageName = x.PageName, VisualCount = 5 })");
			Assert.That(results.Count(), Is.EqualTo(1));

			var result = results.Single();
			Assert.That(result.PageName, Is.EqualTo("Test"));
			Assert.That(result.VisualCount, Is.EqualTo(5));
		}

		public class PageType
		{
			public string PageName { get; set; }
			public int VisualCount { get; set; }
		}

		[Test]
		public void GitHub_Issue_261()
		{
			var target = new Interpreter();
			target.Reference(typeof(RegexOptions));
			target.Reference(typeof(DateTimeKind));

			var result = target.Eval<RegexOptions>("~RegexOptions.None");
			Assert.That(result, Is.EqualTo(~RegexOptions.None));

			// DateTimeKind doesn't have the Flags attribute: the bitwise operation returns an integer
			var result2 = target.Eval<DateTimeKind>("~DateTimeKind.Local");
			Assert.That(result2, Is.EqualTo((DateTimeKind)(-3)));
		}

		[Test]
		public void GitHub_Issue_262()
		{
			var list = new List<int> { 10, 30, 4 };

			var options = InterpreterOptions.Default | InterpreterOptions.LambdaExpressions;
			var interpreter = new Interpreter(options);
			interpreter.SetVariable("b", new Functions());
			interpreter.SetVariable("list", list);

			var results = interpreter.Eval<List<int>>(@"b.Add(list, (int t) => t + 10)");
			Assert.That(results, Is.EqualTo(new List<int> { 20, 40, 14 }));

			// ensure that list, t are not parsed as two arguments of a lambda expression
			results = interpreter.Eval<List<int>>(@"b.Add(list, t => t + 10)");
			Assert.That(results, Is.EqualTo(new List<int> { 20, 40, 14 }));
		}

		public class Functions
		{
			public List<int> Add(List<int> list, Func<int, int> transform)
			{
				return list.Select(i => transform(i)).ToList();
			}

			public Guid ReturnsGuid(Guid guid = default)
			{
				return guid;
			}
		}

		[Test]
		[TestCase("0, null, 0, 0")]
		[TestCase("null, null, 0, 0")]
		[TestCase("new object[] { null, null, null, null }")]
		public void GitHub_Issue_263(string paramsArguments)
		{
			var interpreter = new Interpreter();
			interpreter.Reference(typeof(Utils));

			Assert.Throws<NullReferenceException>(() => interpreter.Eval<int>("Utils.ParamArrayObjects(null)"));

			var result = interpreter.Eval<int>($"Utils.ParamArrayObjects({paramsArguments})");
			Assert.That(result, Is.EqualTo(4));
		}

		[Test]
		public void GitHub_Issue_276()
		{
			var interpreter = new Interpreter();

			var result = interpreter.Eval<bool>("((int?)5)>((double?)4)");
			Assert.That(result, Is.True);
		}

		[Test]
		public void GitHub_Issue_287()
		{
			var interpreter = new Interpreter();
			interpreter.Reference(typeof(IEnumerable<>));

			object str = "test";
			interpreter.SetVariable("str", str, typeof(object));

			Assert.That(interpreter.Eval("string.IsNullOrEmpty(str as string)"), Is.EqualTo(string.IsNullOrEmpty(str as string)));
			Assert.That(interpreter.Eval("str is string"), Is.EqualTo(str is string));
			Assert.That(interpreter.Eval("str is int?"), Is.EqualTo(str is int?));
			Assert.That(interpreter.Eval("(str is int[])"), Is.EqualTo(str is int[]));
			Assert.That(interpreter.Eval("(str is int?[])"), Is.EqualTo(str is int?[]));
			Assert.That(interpreter.Eval("(str is int?[][])"), Is.EqualTo(str is int?[][]));
			Assert.That(interpreter.Eval("(str is IEnumerable<int>[][])"), Is.EqualTo(str is IEnumerable<int>[][]));
			Assert.That(interpreter.Eval("(str is IEnumerable<int?>[][])"), Is.EqualTo(str is IEnumerable<int?>[][]));
			Assert.That(interpreter.Eval("(str is IEnumerable<int[]>[][])"), Is.EqualTo(str is IEnumerable<int[]>[][]));
			Assert.That(interpreter.Eval("(str is IEnumerable<int?[][]>[][])"), Is.EqualTo(str is IEnumerable<int?[][]>[][]));
		}

		private class Npc
		{
			public int money { get; set; }
		}

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

			var testnpcs = new List<Npc>();
			for (var i = 0; i < 5; i++)
				testnpcs.Add(new Npc { money = 0 });

			interpreter.Reference(typeof(GithubIssuesTestExtensionsMethods));
			interpreter.SetVariable("NearNpcs", testnpcs);

			var func = interpreter.ParseAsDelegate<Action>("NearNpcs.ActionToAll(n => n.money = 10)");
			func.Invoke();

			Assert.That(testnpcs.All(n => n.money == 10), Is.True);
		}

		[Test]
		public void GitHub_Issue_295()
		{
			var evaluator = new Interpreter();

			// create path helper functions in expressions...
			Func<string, string, string> pathCombine = string.Concat;
			evaluator.SetFunction("StringConcat", pathCombine);

			// add a GlobalSettings dynamic object...
			dynamic globalSettings = new ExpandoObject();
			globalSettings.MyTestPath = "C:\\delme\\";
			evaluator.SetVariable("GlobalSettings", globalSettings);

			var worksWithCast = (string)evaluator.Eval("StringConcat((string)GlobalSettings.MyTestPath,\"test.txt\")");
			Assert.That(worksWithCast, Is.EqualTo("C:\\delme\\test.txt"));

			var worksWithoutCast = (string)evaluator.Eval("StringConcat(GlobalSettings.MyTestPath,\"test.txt\")");
			Assert.That(worksWithoutCast, Is.EqualTo("C:\\delme\\test.txt"));
		}

		#region GitHub_Issue_305

		public class _305_A
		{
			public string this[int index] => "some string";
		}

		public class _305_B : _305_A
		{
			public new int this[int index] => 25;
		}

		[Test]
		public void GitHub_Issue_305()
		{
			var b = new _305_B();

			var interpreter = new Interpreter();
			var lambda = interpreter.Parse("this[0]", new Parameter("this", b));
			var res = lambda.Invoke(b);

			Assert.That(res, Is.EqualTo(25));
		}

		#endregion

		[Test]
		public void GitHub_Issue_311()
		{
			var a = "AABB";

			var interpreter1 = new Interpreter();
			interpreter1.SetVariable("a", a);
			Assert.That(interpreter1.Eval("a.Substring(0, 2)"), Is.EqualTo("AA"));

			var interpreter2 = new Interpreter().SetDefaultNumberType(DefaultNumberType.Decimal);
			interpreter2.SetVariable("a", a);
			// expected to throw because Substring is not defined for decimal
			Assert.Throws<NoApplicableMethodException>(() => interpreter2.Eval("a.Substring(0, 2)"));
			// It works if we cast to int
			Assert.That(interpreter2.Eval("a.Substring((int)0, (int)2)"), Is.EqualTo("AA"));
		}

		[Test]
		public void GitHub_Issue_314()
		{
			var interpreter = new Interpreter();

			var exception1 = Assert.Throws<UnknownIdentifierException>(() => interpreter.Eval("b < 1"));
			Assert.That(exception1.Identifier, Is.EqualTo("b"));

			var exception2 = Assert.Throws<UnknownIdentifierException>(() => interpreter.Eval("b > 1"));
			Assert.That(exception2.Identifier, Is.EqualTo("b"));
		}

		[Test]
		public void GitHub_Issue_325()
		{
			var options = InterpreterOptions.Default | InterpreterOptions.LateBindObject;
			var interpreter = new Interpreter(options);

			var input = new
			{
				Prop1 = 4,
			};

			var expressionDelegate = interpreter.ParseAsDelegate<Func<object, bool>>($"input.Prop1 == null", "input");
			Assert.That(expressionDelegate(input), Is.False);
		}

		[Test]
		public void GitHub_Issue_341()
		{
			var interpreter = new Interpreter();

			var x = 1L;
			interpreter.SetVariable("x", x);

			Assert.That(interpreter.Eval<bool>("(int)x == 1"), Is.EqualTo((int)x == 1));
		}

		[Test]
		public void GitHub_Issue_354()
		{
			var interpreter = new Interpreter();
			interpreter.SetVariable("b", new Functions());

			Assert.That(interpreter.Eval<Guid>("b.ReturnsGuid()"), Is.EqualTo(Guid.Empty));
		}

		[Test]
		public void GitHub_Issue_367()
		{
			var interpreter = new DynamicExpresso.Interpreter();
			interpreter.SetVariable("MyValue", null, typeof(int?));

			var result = interpreter.Eval<int>("MyValue ?? 10");
			Assert.That(result, Is.EqualTo(10));
		}
	}

	internal static class GithubIssuesTestExtensionsMethods
	{
		public static bool IsInFuture(this DateTimeOffset date) => date > DateTimeOffset.UtcNow;
		public static void ActionToAll<T>(this IEnumerable<T> source, Action<T> action)
		{
			foreach (var item in source)
				action(item);
		}
	}
}