using System;
using NUnit.Framework;
// ReSharper disable ConvertNullableToShortForm
// ReSharper disable PossibleNullReferenceException

// ReSharper disable ConvertToConstant.Local
// ReSharper disable BuiltInTypeReferenceStyle
// ReSharper disable SuggestVarOrType_BuiltInTypes

namespace DynamicExpresso.UnitTest
{
	[TestFixture]
	public class NullableTest
	{
		[Test]
		public void NullableInt32_NullableInt32()
		{
			var a = 5;
			var b = 43;

			var interpreter = new Interpreter();
			interpreter.SetVariable("a", a, typeof(Nullable<Int32>));
			interpreter.SetVariable("b", b, typeof(Nullable<Int32>));
			var expectedReturnType = typeof(Nullable<Int32>);

			// Addition
			var expected = a + b;
			var lambda = interpreter.Parse("a + b");
			Assert.That(lambda.Invoke(), Is.EqualTo(expected));
			Assert.That(lambda.ReturnType, Is.EqualTo(expectedReturnType));

			// Subtraction
			expected = a - b;
			lambda = interpreter.Parse("a - b");
			Assert.That(lambda.Invoke(), Is.EqualTo(expected));
			Assert.That(lambda.ReturnType, Is.EqualTo(expectedReturnType));

			// Division
			expected = a / b;
			lambda = interpreter.Parse("a / b");
			Assert.That(lambda.Invoke(), Is.EqualTo(expected));
			Assert.That(lambda.ReturnType, Is.EqualTo(expectedReturnType));

			// Multiplication
			expected = a * b;
			lambda = interpreter.Parse("a * b");
			Assert.That(lambda.Invoke(), Is.EqualTo(expected));
			Assert.That(lambda.ReturnType, Is.EqualTo(expectedReturnType));
		}

		[Test]
		public void NullableInt32_NullableInt32_with_left_null()
		{
			Nullable<Int32> a = null;
			var b = 43;

			var interpreter = new Interpreter();
			interpreter.SetVariable("a", a, typeof(Nullable<Int32>));
			interpreter.SetVariable("b", b, typeof(Nullable<Int32>));
			var expectedReturnType = typeof(Nullable<Int32>);

			// Addition
			var expected = a + b;
			var lambda = interpreter.Parse("a + b");
			Assert.That(lambda.Invoke(), Is.EqualTo(expected));
			Assert.That(lambda.ReturnType, Is.EqualTo(expectedReturnType));

			// Subtraction
			expected = a - b;
			lambda = interpreter.Parse("a - b");
			Assert.That(lambda.Invoke(), Is.EqualTo(expected));
			Assert.That(lambda.ReturnType, Is.EqualTo(expectedReturnType));

			// Division
			expected = a / b;
			lambda = interpreter.Parse("a / b");
			Assert.That(lambda.Invoke(), Is.EqualTo(expected));
			Assert.That(lambda.ReturnType, Is.EqualTo(expectedReturnType));

			// Multiplication
			expected = a * b;
			lambda = interpreter.Parse("a * b");
			Assert.That(lambda.Invoke(), Is.EqualTo(expected));
			Assert.That(lambda.ReturnType, Is.EqualTo(expectedReturnType));
		}

		[Test]
		public void NullableInt32_NullableInt32_with_right_null()
		{
			var a = 85;
			Nullable<Int32> b = null;

			var interpreter = new Interpreter();
			interpreter.SetVariable("a", a, typeof(Nullable<Int32>));
			interpreter.SetVariable("b", b, typeof(Nullable<Int32>));
			var expectedReturnType = typeof(Nullable<Int32>);

			// Addition
			var expected = a + b;
			var lambda = interpreter.Parse("a + b");
			Assert.That(lambda.Invoke(), Is.EqualTo(expected));
			Assert.That(lambda.ReturnType, Is.EqualTo(expectedReturnType));

			// Subtraction
			expected = a - b;
			lambda = interpreter.Parse("a - b");
			Assert.That(lambda.Invoke(), Is.EqualTo(expected));
			Assert.That(lambda.ReturnType, Is.EqualTo(expectedReturnType));

			// Division
			expected = a / b;
			lambda = interpreter.Parse("a / b");
			Assert.That(lambda.Invoke(), Is.EqualTo(expected));
			Assert.That(lambda.ReturnType, Is.EqualTo(expectedReturnType));

			// Multiplication
			expected = a * b;
			lambda = interpreter.Parse("a * b");
			Assert.That(lambda.Invoke(), Is.EqualTo(expected));
			Assert.That(lambda.ReturnType, Is.EqualTo(expectedReturnType));
		}

		[Test]
		public void NullableDouble_NullableDouble()
		{
			var a = 5.7;
			var b = 43.2;

			var interpreter = new Interpreter();
			interpreter.SetVariable("a", a, typeof(Nullable<Double>));
			interpreter.SetVariable("b", b, typeof(Nullable<Double>));
			var expectedReturnType = typeof(Nullable<Double>);

			// Addition
			var expected = a + b;
			var lambda = interpreter.Parse("a + b");
			Assert.That(lambda.Invoke(), Is.EqualTo(expected));
			Assert.That(lambda.ReturnType, Is.EqualTo(expectedReturnType));

			// Subtraction
			expected = a - b;
			lambda = interpreter.Parse("a - b");
			Assert.That(lambda.Invoke(), Is.EqualTo(expected));
			Assert.That(lambda.ReturnType, Is.EqualTo(expectedReturnType));

			// Division
			expected = a / b;
			lambda = interpreter.Parse("a / b");
			Assert.That(lambda.Invoke(), Is.EqualTo(expected));
			Assert.That(lambda.ReturnType, Is.EqualTo(expectedReturnType));

			// Multiplication
			expected = a * b;
			lambda = interpreter.Parse("a * b");
			Assert.That(lambda.Invoke(), Is.EqualTo(expected));
			Assert.That(lambda.ReturnType, Is.EqualTo(expectedReturnType));
		}

		[Test]
		public void Int32_NullableDouble()
		{
			var a = 5;
			var b = 43.5;

			var interpreter = new Interpreter();
			interpreter.SetVariable("a", a, typeof(Int32));
			interpreter.SetVariable("b", b, typeof(Nullable<Double>));
			var expectedReturnType = typeof(Nullable<Double>);

			// Addition
			var expected = a + b;
			var lambda = interpreter.Parse("a + b");
			Assert.That(lambda.Invoke(), Is.EqualTo(expected));
			Assert.That(lambda.ReturnType, Is.EqualTo(expectedReturnType));

			// Subtraction
			expected = a - b;
			lambda = interpreter.Parse("a - b");
			Assert.That(lambda.Invoke(), Is.EqualTo(expected));
			Assert.That(lambda.ReturnType, Is.EqualTo(expectedReturnType));

			// Division
			expected = a / b;
			lambda = interpreter.Parse("a / b");
			Assert.That(lambda.Invoke(), Is.EqualTo(expected));
			Assert.That(lambda.ReturnType, Is.EqualTo(expectedReturnType));

			// Multiplication
			expected = a * b;
			lambda = interpreter.Parse("a * b");
			Assert.That(lambda.Invoke(), Is.EqualTo(expected));
			Assert.That(lambda.ReturnType, Is.EqualTo(expectedReturnType));
		}

		[Test]
		public void NullableInt32_Double()
		{
			var a = 5;
			var b = 43.5;

			var interpreter = new Interpreter();
			interpreter.SetVariable("a", a, typeof(Nullable<Int32>));
			interpreter.SetVariable("b", b, typeof(Double));
			var expectedReturnType = typeof(Nullable<Double>);

			// Addition
			var expected = a + b;
			var lambda = interpreter.Parse("a + b");
			Assert.That(lambda.Invoke(), Is.EqualTo(expected));
			Assert.That(lambda.ReturnType, Is.EqualTo(expectedReturnType));

			// Subtraction
			expected = a - b;
			lambda = interpreter.Parse("a - b");
			Assert.That(lambda.Invoke(), Is.EqualTo(expected));
			Assert.That(lambda.ReturnType, Is.EqualTo(expectedReturnType));

			// Division
			expected = a / b;
			lambda = interpreter.Parse("a / b");
			Assert.That(lambda.Invoke(), Is.EqualTo(expected));
			Assert.That(lambda.ReturnType, Is.EqualTo(expectedReturnType));

			// Multiplication
			expected = a * b;
			lambda = interpreter.Parse("a * b");
			Assert.That(lambda.Invoke(), Is.EqualTo(expected));
			Assert.That(lambda.ReturnType, Is.EqualTo(expectedReturnType));
		}

		[Test]
		public void NullableDateTimeOffset_DatetimeOffset()
		{
			var a = DateTimeOffset.Now;
			DateTimeOffset? b = DateTimeOffset.Now.AddDays(1);
			var c = b.Value;

			var interpreter = new Interpreter();
			interpreter.SetVariable("a", a, typeof(DateTimeOffset));
			interpreter.SetVariable("b", b, typeof(DateTimeOffset?));
			interpreter.SetVariable("c", c, typeof(DateTimeOffset));
			var expectedReturnType = typeof(bool);

			var expected = a < b;
			var lambda = interpreter.Parse("a < b");
			Assert.That(lambda.Invoke(), Is.EqualTo(expected));
			Assert.That(lambda.ReturnType, Is.EqualTo(expectedReturnType));

			expected = a > b;
			lambda = interpreter.Parse("a > b");
			Assert.That(lambda.Invoke(), Is.EqualTo(expected));
			Assert.That(lambda.ReturnType, Is.EqualTo(expectedReturnType));

			expected = a == b;
			lambda = interpreter.Parse("a == b");
			Assert.That(lambda.Invoke(), Is.EqualTo(expected));
			Assert.That(lambda.ReturnType, Is.EqualTo(expectedReturnType));

			expected = a != b;
			lambda = interpreter.Parse("a != b");
			Assert.That(lambda.Invoke(), Is.EqualTo(expected));
			Assert.That(lambda.ReturnType, Is.EqualTo(expectedReturnType));

			expected = b == c;
			lambda = interpreter.Parse("b == b");
			Assert.That(lambda.Invoke(), Is.EqualTo(expected));
			Assert.That(lambda.ReturnType, Is.EqualTo(expectedReturnType));

			expected = b != c;
			lambda = interpreter.Parse("b != c");
			Assert.That(lambda.Invoke(), Is.EqualTo(expected));
			Assert.That(lambda.ReturnType, Is.EqualTo(expectedReturnType));

			lambda = interpreter.Parse("a - b");
			Assert.That(lambda.Invoke(), Is.EqualTo(a - b));
			Assert.That(lambda.ReturnType, Is.EqualTo(typeof(TimeSpan?)));

			b = null;
			interpreter.SetVariable("b", b, typeof(DateTimeOffset?));
			lambda = interpreter.Parse("a - b");
			Assert.That(lambda.Invoke(), Is.EqualTo(a - b));
			Assert.That(lambda.ReturnType, Is.EqualTo(typeof(TimeSpan?)));
		}
	}
}