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

namespace DynamicExpresso.UnitTest
{
	[TestFixture]
	public class MemberInvocationTest
	{
		[Test]
		public void Method_Property_Field_basic_test()
		{
			var x = new MyTestService();

			var target = new Interpreter().SetVariable("x", x);

			Assert.That(target.Eval("x.HelloWorld()"), Is.EqualTo(x.HelloWorld()));
			Assert.That(target.Eval("x.AProperty"), Is.EqualTo(x.AProperty));
			Assert.That(target.Eval("x.AField"), Is.EqualTo(x.AField));
		}

		[Ignore("See issue 65")]
		[Test]
		public void Null_conditional_property()
		{
			var target = new Interpreter().SetVariable("x", null, typeof(MyTestService));
			Assert.That(target.Eval("x?.AProperty"), Is.Null);
		}

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

			var x = "ciao";
			target.SetVariable("x", x);
			var y = new MyTestService();
			target.SetVariable("y", y);
			var z = new[] { 7, 8, 9, 10 };
			target.SetVariable("z", z);

			Assert.That(target.Eval("x[2]"), Is.EqualTo(x[2]));
			Assert.That(target.Eval("y[2]"), Is.EqualTo(y[2]));
			Assert.That(target.Eval("y[2].ToString()"), Is.EqualTo(y[2].ToString()));
			Assert.That(target.Eval("y[(Int16)2]"), Is.EqualTo(y[(short)2]));
			Assert.That(target.Eval("z[2]"), Is.EqualTo(z[2]));
		}

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

			var x = new System.Text.StringBuilder("time");
			target.SetVariable("x", x);
			var y = new MyTestService();
			target.SetVariable("y", y);
			var z = new[] { 7, 8, 9, 10 };
			target.SetVariable("z", z);

			target.Eval("x[2] = 'r'");
			Assert.That(x.ToString(), Is.EqualTo("tire"));
			target.Eval("y[(Int16)9] = y.Today");
			Assert.That(y.Today.AddYears(9), Is.EqualTo(y.AField));
			target.Eval("y[(Int64)7] = y.Today");
			Assert.That(y.Today.AddSeconds(7), Is.EqualTo(y.AField));
			target.Eval("z[2] = 4");
			Assert.That(z, Is.EqualTo(new[] { 7, 8, 4, 10 }));
		}

		[Test]
		public void Cannot_assign_without_setter()
		{
			var target = new Interpreter()
				.SetVariable("x", new MyTestService());

			Assert.Throws<Exceptions.ParseException>(() => target.Parse("x[8] = x.Today"));
			Assert.Throws<Exceptions.ParseException>(() => target.Parse("x.AProperty = x.Today"));
		}

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

			var x = new List<int> { 3, 4, 5, 6 };
			target.SetVariable("x", x);
			var y = new Dictionary<string, int> { { "first", 1 }, { "second", 2 }, { "third", 3 } };
			target.SetVariable("y", y);

			Assert.That(target.Eval("x[2]"), Is.EqualTo(x[2]));
			Assert.That(target.Eval("y[\"second\"]"), Is.EqualTo(y["second"]));

			target.Eval("x[2] = 1");
			Assert.That(new List<int> { 3, 4, 1, 6 }, Is.EqualTo(x));
			target.Eval("y[\"second\"] = 2000");
			Assert.That(new Dictionary<string, int> { { "first", 1 }, { "second", 2000 }, { "third", 3 } }, Is.EqualTo(y));
		}

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

			var x = new[,] { { 11, 12, 13, 14 }, { 21, 22, 23, 24 }, { 31, 32, 33, 34 } };
			target.SetVariable("x", x);
			var y = new MyTestService();
			target.SetVariable("y", y);

			Assert.That(target.Eval("x[1, 2]"), Is.EqualTo(x[1, 2]));
			Assert.That(target.Eval("y[y.Today, 2]"), Is.EqualTo(y[y.Today, 2]));
			Assert.That(target.Eval("y[y.Today]"), Is.EqualTo(y[y.Today]));
		}

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

			var x = new[,] { { 11, 12, 13, 14 }, { 21, 22, 23, 24 }, { 31, 32, 33, 34 } };
			target.SetVariable("x", x);
			var y = new MyTestService();
			target.SetVariable("y", y);

			var span = TimeSpan.FromDays(3.5);
			target.SetVariable("span", span);

			target.Eval("x[1, 2] = 7");
			Assert.That(new[,] { { 11, 12, 13, 14 }, { 21, 22, 7, 24 }, { 31, 32, 33, 34 } }, Is.EqualTo(x));
			target.Eval("y[y.Today, 2] = span");
			Assert.That(y.Today.AddDays(2).Add(span), Is.EqualTo(y.AField));
			target.Eval("y[y.Today] = span");
			Assert.That(y.Today.AddDays(3).Add(span), Is.EqualTo(y.AField));
		}

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

			Assert.That(target.Eval("string.Format(\"ciao {0}, today is {1}\", \"mondo\", DateTime.Today.ToString())"), Is.EqualTo(string.Format("ciao {0}, today is {1}", "mondo", DateTime.Today)));
		}

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

			Assert.That(target.Eval("string.Format(\"ciao {0}, today is {1}\", \"mondo\", DateTime.Today)"), Is.EqualTo(string.Format("ciao {0}, today is {1}", "mondo", DateTime.Today)));
		}

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

			Assert.That(target.Eval("string.Format(\"ciao {0}\", \"\")"), Is.EqualTo(string.Format("ciao {0}", "")));
		}

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

			Assert.That(target.Eval("string.Format(\"ciao {0}, today is {1}\", \"mondo\", DateTime.Today)"), Is.EqualTo(string.Format("ciao mondo, today is {0}", DateTime.Today)));
		}

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

			var x = new MyTestService();
			var parameters = new[] {
							new Parameter("x", x.GetType(), x)
							};

			Assert.That(target.Eval("x.HelloWorld()", parameters), Is.EqualTo(x.HelloWorld()));
			Assert.That(target.Eval("x.HELLOWORLD()", parameters), Is.EqualTo(x.HELLOWORLD()));
			Assert.That(target.Eval("x.AProperty", parameters), Is.EqualTo(x.AProperty));
			Assert.That(target.Eval("x.APROPERTY", parameters), Is.EqualTo(x.APROPERTY));
			Assert.That(target.Eval("x.AField", parameters), Is.EqualTo(x.AField));
			Assert.That(target.Eval("x.AFIELD", parameters), Is.EqualTo(x.AFIELD));
		}

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

			var x = new MyTestServiceCaseInsensitive();
			var parameters = new[] {
							new Parameter("x", x.GetType(), x)
							};

			Assert.That(target.Eval("x.AMethod()", parameters), Is.EqualTo(x.AMethod()));
			Assert.That(target.Eval("x.AMETHOD()", parameters), Is.EqualTo(x.AMethod()));
			Assert.That(target.Eval("x.AProperty", parameters), Is.EqualTo(x.AProperty));
			Assert.That(target.Eval("x.APROPERTY", parameters), Is.EqualTo(x.AProperty));
			Assert.That(target.Eval("x.AField", parameters), Is.EqualTo(x.AField));
			Assert.That(target.Eval("x.AFIELD", parameters), Is.EqualTo(x.AField));
		}

		[Test]
		public void Void_Method()
		{
			var service = new MyTestService();
			var target = new Interpreter()
											.SetVariable("service", service);

			Assert.That(service.VoidMethodCalls, Is.EqualTo(0));
			target.Eval("service.VoidMethod()");
			Assert.That(service.VoidMethodCalls, Is.EqualTo(1));

			Assert.That(target.Parse("service.VoidMethod()").ReturnType, Is.EqualTo(typeof(void)));
		}

		[Test]
		public void ToString_Method_on_a_custom_type()
		{
			var service = new MyTestService();
			var target = new Interpreter()
											.SetVariable("service", service);

			Assert.That(target.Eval("service.ToString()"), Is.EqualTo("DynamicExpresso.UnitTest.MemberInvocationTest+MyTestService"));
		}

		[Test]
		public void ToString_Method_on_a_custom_interface_type()
		{
			MyTestInterface service = new MyTestInterfaceImp();
			var target = new Interpreter()
											.SetVariable("service", service, typeof(MyTestInterface));

			Assert.That(target.Eval("service.ToString()"), Is.EqualTo("DynamicExpresso.UnitTest.MemberInvocationTest+MyTestInterfaceImp"));
		}

		[Test]
		public void ToString_Method_on_a_primitive_type()
		{
			var target = new Interpreter();
			Assert.That(target.Eval("(3).ToString()"), Is.EqualTo("3"));
		}

		[Test]
		public void GetType_Method_on_a_custom_type()
		{
			var service = new MyTestService();
			var target = new Interpreter()
											.SetVariable("service", service);

			Assert.That(target.Eval("service.GetType()"), Is.EqualTo(typeof(MyTestService)));
		}

		[Test]
		public void GetType_Method_on_a_custom_interface_type()
		{
			MyTestInterface service = new MyTestInterfaceImp();
			var target = new Interpreter()
											.SetVariable("service", service, typeof(MyTestInterface));

			Assert.That(target.Eval("service.GetType()"), Is.EqualTo(typeof(MyTestInterfaceImp)));
		}

		[Test]
		public void GetType_Method_on_a_primitive_type()
		{
			var target = new Interpreter();
			Assert.That(target.Eval("(3).GetType()"), Is.EqualTo((3).GetType()));
		}

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

			var x = new MyTestService();
			var y = "davide";
			var z = 5;
			int? w = null;
			var parameters = new[] {
							new Parameter("x", x.GetType(), x),
							new Parameter("y", y.GetType(), y),
							new Parameter("z", z.GetType(), z),
							new Parameter("w", typeof(int?), w)
							};

			Assert.That(target.Eval("x.MethodWithNullableParam(y, z)", parameters), Is.EqualTo(x.MethodWithNullableParam(y, z)));
			Assert.That(target.Eval("x.MethodWithNullableParam(y, w)", parameters), Is.EqualTo(x.MethodWithNullableParam(y, w)));
			Assert.That(target.Eval("x.MethodWithNullableParam(y, 30)", parameters), Is.EqualTo(x.MethodWithNullableParam(y, 30)));
			Assert.That(target.Eval("x.MethodWithNullableParam(y, null)", parameters), Is.EqualTo(x.MethodWithNullableParam(y, null)));
		}

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

			var x = new MyTestService();
			var y = "davide";
			double z = 5;
			int? w = null;
			var parameters = new[] {
							new Parameter("x", x.GetType(), x),
							new Parameter("y", y.GetType(), y),
							new Parameter("z", z.GetType(), z),
							new Parameter("w", typeof(int?), w)
							};

			Assert.That(target.Eval("x.MethodWithGenericParam(x)", parameters), Is.EqualTo(x.MethodWithGenericParam(x)));
			Assert.That(target.Eval("x.MethodWithGenericParam(y)", parameters), Is.EqualTo(x.MethodWithGenericParam(y)));
			Assert.That(target.Eval("x.MethodWithGenericParam(z)", parameters), Is.EqualTo(x.MethodWithGenericParam(z)));
			Assert.That(target.Eval("x.MethodWithGenericParam(w)", parameters), Is.EqualTo(x.MethodWithGenericParam(w)));

			Assert.That(target.Eval("x.MethodWithGenericParam(y, x)", parameters), Is.EqualTo(x.MethodWithGenericParam(y, x)));
			Assert.That(target.Eval("x.MethodWithGenericParam(y, y)", parameters), Is.EqualTo(x.MethodWithGenericParam(y, y)));
			Assert.That(target.Eval("x.MethodWithGenericParam(y, z)", parameters), Is.EqualTo(x.MethodWithGenericParam(y, z)));
			Assert.That(target.Eval("x.MethodWithGenericParam(y, w)", parameters), Is.EqualTo(x.MethodWithGenericParam(y, w)));

			Assert.That(target.Eval("x.MethodWithGenericParamAndDefault(y,y)", parameters), Is.EqualTo(x.MethodWithGenericParamAndDefault(y, y)));
			Assert.That(target.Eval("x.MethodWithGenericParamAndDefault(y)", parameters), Is.EqualTo(x.MethodWithGenericParamAndDefault(y)));
			Assert.That(target.Eval("x.MethodWithGenericParamAndDefault1Levels(y)", parameters), Is.EqualTo(x.MethodWithGenericParamAndDefault1Levels(y)));
			Assert.That(target.Eval("x.MethodWithGenericParamAndDefault2Levels(y)", parameters), Is.EqualTo(x.MethodWithGenericParamAndDefault2Levels(y)));
			Assert.That(target.Eval("x.MethodWithGenericParamAndDefault2Levels(y, w)", parameters), Is.EqualTo(x.MethodWithGenericParamAndDefault2Levels(y, w)));
		}

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

			var x = new MyTestService();
			target.SetVariable("x", x);

			Assert.That(target.Eval("x.GenericMethodWithConstraint(\"works\")"), Is.EqualTo("works"));
			Assert.Throws<NoApplicableMethodException>(() => target.Eval("x.GenericMethodWithConstraint(5)"), "This shouldn't throw a System.ArgumentException \"Violates the constraint of type 'T'\"");
		}

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

			var x = new MyTestService();

			target.SetVariable("x", x);

			Assert.That(x.MethodWithParamsArrayCalls, Is.EqualTo(0));

			Assert.That(target.Eval("x.MethodWithParamsArray(DateTime.Now, 2, 1, 34)"), Is.EqualTo(x.MethodWithParamsArray(DateTime.Now, 2, 1, 34)));
			Assert.That(x.MethodWithParamsArrayCalls, Is.EqualTo(2));

			var myParamArray = new int[] { 2, 1, 34 };
			target.SetVariable("myParamArray", myParamArray);

			Assert.That(target.Eval("x.MethodWithParamsArray(DateTime.Now, myParamArray)"), Is.EqualTo(x.MethodWithParamsArray(DateTime.Now, myParamArray)));
			Assert.That(x.MethodWithParamsArrayCalls, Is.EqualTo(4));
		}

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

			var x = new MyTestService();

			target.SetVariable("x", x);

			target.Eval("x.AmbiguousMethod(DateTime.Now, 2, 3)");
			Assert.That(x.AmbiguousMethod_NormalCalls, Is.EqualTo(1));
			Assert.That(x.AmbiguousMethod_ParamsArrayCalls, Is.EqualTo(0));

			target.Eval("x.AmbiguousMethod(DateTime.Now, 2, 3, 4)");
			Assert.That(x.AmbiguousMethod_NormalCalls, Is.EqualTo(1));
			Assert.That(x.AmbiguousMethod_ParamsArrayCalls, Is.EqualTo(1));
		}

		[Test]
		public void Overload_paramsArray_methods_with_compatible_type_params()
		{
			var target = new Interpreter();
			var x = new MyTestService();
			target.SetVariable("x", x);
			Assert.That(target.Eval("x.OverloadMethodWithParamsArray(2, 3, 1)"), Is.EqualTo(3));
		}


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

			var listInt = target.Eval<List<int>>("Utils.Array(1, 2, 3)");
			Assert.That(listInt, Is.EqualTo(new[] { 1, 2, 3 }));

			// type parameter can't be inferred from usage
			Assert.Throws<ParseException>(() => target.Eval<List<int>>("Utils.Array(1,\"str\", 3)"));
		}

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

			var x = new MyTestService();
			var y = "1";
			var z = "2";
			var w = "3";
			var parameters = new[] {
				new Parameter("x", x.GetType(), x),
				new Parameter("y", y.GetType(), y),
				new Parameter("z", z.GetType(), z),
				new Parameter("w", w.GetType(), w)
			};

			Assert.That(target.Eval("x.MethodWithOptionalParam(y)", parameters), Is.EqualTo(x.MethodWithOptionalParam(y)));
			Assert.That(target.Eval("x.MethodWithOptionalParam(y, z)", parameters), Is.EqualTo(x.MethodWithOptionalParam(y, z)));
			Assert.That(target.Eval("x.MethodWithOptionalParam(z, y)", parameters), Is.EqualTo(x.MethodWithOptionalParam(z, y)));
			Assert.That(target.Eval("x.MethodWithOptionalParam(y, z, w)", parameters), Is.EqualTo(x.MethodWithOptionalParam(y, z, w)));
			Assert.That(target.Eval("x.MethodWithOptionalParam(w, y, z)", parameters), Is.EqualTo(x.MethodWithOptionalParam(w, y, z)));
		}

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

			var x = new MyTestService();
			var y = "1";
			var z = "2";
			var parameters = new[] {
				new Parameter("x", x.GetType(), x),
				new Parameter("y", y.GetType(), y),
				new Parameter("z", z.GetType(), z),
			};

			Assert.That(target.Eval("x.MethodWithOptionalNullParam(y)", parameters), Is.EqualTo(x.MethodWithOptionalNullParam(y)));
			Assert.That(target.Eval("x.MethodWithOptionalNullParam(y, z)", parameters), Is.EqualTo(x.MethodWithOptionalNullParam(y, z)));
		}

		[Test]
		public void Chaining_Methods()
		{
			var x = new MyTestService();

			var target = new Interpreter();
			target.SetVariable("x", x);

			Assert.That(target.Eval("x.HelloWorld().ToUpper()"), Is.EqualTo(x.HelloWorld().ToUpper()));
		}

		internal static class Utils
		{
			public static int GenericVsNonGeneric(int i) => 1;
			public static int GenericVsNonGeneric<T>(T i) => 2;

			public static int WithParamsArray(params int[] i) => 3;
			public static int WithParamsArray(int i, params int[] j) => 4;
			public static int WithParamsArray(int i, int j) => 5;

			public static int WithParamsArray2(string str, Exception e) => 6;
			public static int WithParamsArray2(string str, Exception e, params string[] args) => 7;
			public static int WithParamsArray2(string str, Exception e, params int[] args) => 8;


			public static List<T> Array<T>(params T[] array)
			{
				return new List<T>(array);
			}
		}

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

			Assert.That(target.Eval("Utils.GenericVsNonGeneric(12345)"), Is.EqualTo(1));
			Assert.That(target.Eval("Utils.GenericVsNonGeneric('a')"), Is.EqualTo(2));
		}

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

			var arr = new int[] { 2 };
			target.SetVariable("arr", arr);

			Assert.That(target.Eval("Utils.WithParamsArray(arr)"), Is.EqualTo(3));
			Assert.That(target.Eval("Utils.WithParamsArray(1)"), Is.EqualTo(4));
			Assert.That(target.Eval("Utils.WithParamsArray(1, arr)"), Is.EqualTo(4));
			Assert.That(target.Eval("Utils.WithParamsArray(1, 2)"), Is.EqualTo(5));
			Assert.That(target.Eval("Utils.WithParamsArray(1, 2, 3)"), Is.EqualTo(4));
			Assert.That(target.Eval("Utils.WithParamsArray(1, 2, 3, 4)"), Is.EqualTo(4));
		}

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

			var str = "str";
			var e = new Exception();
			var intg = 4;
			target.SetVariable("str", str);
			target.SetVariable("e", e);
			target.SetVariable("intg", intg);
			Assert.That(target.Eval("Utils.WithParamsArray2(str, e)"), Is.EqualTo(6));
			Assert.That(target.Eval("Utils.WithParamsArray2(str, e, str, str)"), Is.EqualTo(7));
			Assert.That(target.Eval("Utils.WithParamsArray2(str, e, intg, intg)"), Is.EqualTo(8));
		}

		private interface MyTestInterface
		{
		}

		private class MyTestInterfaceImp : MyTestInterface
		{

		}

		private class MyTestService
		{
			public DateTime AField = DateTime.Now;
			public DateTime AFIELD = DateTime.UtcNow;
			public DateTime Today = DateTime.Today;

			public int AProperty
			{
				get { return 769; }
			}

			public int APROPERTY
			{
				get { return 887; }
			}

			public string HelloWorld()
			{
				return "Ciao mondo";
			}

			public string HELLOWORLD()
			{
				return "HELLO";
			}

			public int VoidMethodCalls { get; set; }
			public void VoidMethod()
			{
				System.Diagnostics.Debug.WriteLine("VoidMethod called");
				VoidMethodCalls++;
			}

			public string MethodWithNullableParam(string param1, int? param2)
			{
				return string.Format("{0} {1}", param1, param2);
			}

			public string MethodWithGenericParam<T>(T p)
			{
				return string.Format("{0}", p);
			}

			public string MethodWithGenericParam<T>(string a, T p)
			{
				return string.Format("{0} {1}", a, p);
			}

			public T MethodWithGenericParamAndDefault<T>(T a, T b = default)
			{
				return a;
			}

			public T MethodWithGenericParamAndDefault1Levels<T>(T a, List<T> b = default)
			{
				return a;
			}

			public T MethodWithGenericParamAndDefault2Levels<T>(T a, List<List<T>> b = default)
			{
				return a;
			}

			public T MethodWithGenericParamAndDefault2Levels<T, T2>(T a, T2 b, List<T> c = default, List<List<T2>> d = default)
			{
				return a;
			}

			public string MethodWithOptionalParam(string param1, string param2 = "2", string param3 = "3")
			{
				return string.Format("{0} {1} {2}", param1, param2, param3);
			}

			public string MethodWithOptionalNullParam(string param1, string param2 = null)
			{
				return string.Format("{0} {1}", param1, param2 ?? "(null)");
			}

			public DateTime this[int i]
			{
				get { return AField.AddDays(i); }
			}

			public DateTime this[long i]
			{
				set { AField = value.AddSeconds(i); }
			}

			public DateTime this[short i]
			{
				get => AField.AddYears(i);
				set => AField = value.AddYears(i);
			}

			public TimeSpan this[DateTime dateTime, int i = 3]
			{
				get => AField.AddDays(-i).Subtract(dateTime);
				set => AField = dateTime.AddDays(i).Add(value);
			}

			public int MethodWithParamsArrayCalls { get; set; }
			public int MethodWithParamsArray(DateTime fixedParam, params int[] paramsArray)
			{
				MethodWithParamsArrayCalls++;

				return paramsArray.Sum();
			}

			public int AmbiguousMethod_ParamsArrayCalls { get; set; }
			public void AmbiguousMethod(DateTime fixedParam, params int[] paramsArray)
			{
				AmbiguousMethod_ParamsArrayCalls++;
			}
			public int AmbiguousMethod_NormalCalls { get; set; }
			public void AmbiguousMethod(DateTime fixedParam, int p1, int p2)
			{
				AmbiguousMethod_NormalCalls++;
			}

			public int OverloadMethodWithParamsArray(params int[] paramsArray)
			{
				return paramsArray.Max();
			}
			public long OverloadMethodWithParamsArray(params long[] paramsArray)
			{
				return paramsArray.Max();
			}

			public T GenericMethodWithConstraint<T>(T input) where T : class
			{
				return input;
			}
		}

		private class MyTestServiceCaseInsensitive
		{
			public DateTime AField = DateTime.Now;

			public int AProperty
			{
				get { return 769; }
			}

			public string AMethod()
			{
				return "Ciao mondo";
			}
		}
	}
}