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

namespace DynamicExpresso.UnitTest
{
	[TestFixture]
	public class TypesTest
	{
		[Test]
		public void Default_Types()
		{
			var target = new Interpreter();

			var predefinedTypes = new Dictionary<string, Type>{
                    {"Object", typeof(object)},
                    {"object", typeof(object)},
                    {"Boolean", typeof(bool)},
                    {"bool", typeof(bool)},
                    {"Char", typeof(char)},
                    {"char", typeof(char)},
                    {"String", typeof(string)},
                    {"string", typeof(string)},
                    {"SByte", typeof(sbyte)},
                    {"Byte", typeof(byte)},
                    {"byte", typeof(byte)},
                    {"Int16", typeof(short)},
                    {"UInt16", typeof(ushort)},
                    {"Int32", typeof(int)},
                    {"int", typeof(int)},
                    {"UInt32", typeof(uint)},
                    {"Int64", typeof(long)},
                    {"long", typeof(long)},
                    {"UInt64", typeof(ulong)},
                    {"Single", typeof(float)},
                    {"Double", typeof(double)},
                    {"double", typeof(double)},
                    {"Decimal", typeof(decimal)},
                    {"decimal", typeof(decimal)},
                    {"DateTime", typeof(DateTime)},
                    {"TimeSpan", typeof(TimeSpan)},
                    {"Guid", typeof(Guid)},
                    {"Math", typeof(Math)},
                    {"Convert", typeof(Convert)},
                };

			foreach (var t in predefinedTypes)
				Assert.That(target.Eval(string.Format("typeof({0})", t.Key)), Is.EqualTo(t.Value));
		}

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

			Assert.Throws<UnknownIdentifierException>(() => target.Eval("typeof(string)"));
		}

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

			Assert.That(target.Eval("typeof(Uri)"), Is.EqualTo(typeof(Uri)));
			Assert.That(target.Eval("new Uri(\"http://test\")"), Is.EqualTo(new Uri("http://test")));
		}

		[Test]
		public void Reference_the_same_type_multiple_times_doesn_t_have_effect()
		{
			var target = new Interpreter()
											.Reference(typeof(string))
											.Reference(typeof(string))
											.Reference(typeof(Uri))
											.Reference(typeof(Uri))
											.Reference(typeof(Uri));

			Assert.That(target.Eval("typeof(Uri)"), Is.EqualTo(typeof(Uri)));
			Assert.That(target.Eval("new Uri(\"http://test\")"), Is.EqualTo(new Uri("http://test")));
		}

		[Test]
		public void References_can_be_case_insensitive()
		{
			var target = new Interpreter(InterpreterOptions.DefaultCaseInsensitive)
											.Reference(typeof(string))
											.Reference(typeof(Uri));

			Assert.That(target.Eval("typeof(Uri)"), Is.EqualTo(typeof(Uri)));
			Assert.That(target.Eval("typeof(uri)"), Is.EqualTo(typeof(Uri)));
			Assert.That(target.Eval("typeof(URI)"), Is.EqualTo(typeof(Uri)));
			Assert.That(target.Eval("STRING.Empty"), Is.EqualTo(string.Empty));
		}

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

			Assert.That(target.Eval("new MyDataContract(\"davide\").Name"), Is.EqualTo(new MyDataContract("davide").Name));
			Assert.That(target.Eval("new MyDataContract(44 , 88).Name"), Is.EqualTo(new MyDataContract(44, 88).Name));
		}

		[Test]
		public void Custom_Type_Alias()
		{
			var target = new Interpreter()
											.Reference(typeof(MyDataContract), "DC");

			Assert.That(target.Parse("new DC(\"davide\")").ReturnType, Is.EqualTo(typeof(MyDataContract)));
		}

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

			Assert.That(target.Eval("MyCustomEnum.Value1"), Is.EqualTo(MyCustomEnum.Value1));
			Assert.That(target.Eval("MyCustomEnum.Value2"), Is.EqualTo(MyCustomEnum.Value2));
		}

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

			Assert.That(target.Eval("EnumCaseSensitive.Test"), Is.EqualTo(EnumCaseSensitive.Test));
			Assert.That(target.Eval("EnumCaseSensitive.TEST"), Is.EqualTo(EnumCaseSensitive.TEST));
		}

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

			var lambda = target.Parse("Math.Max(a, typeof(string).Name.Length)", new Parameter("a", 1));

			Assert.That(lambda.Types.Count(), Is.EqualTo(2));
			Assert.That(lambda.Types.ElementAt(0).Name, Is.EqualTo("Math"));
			Assert.That(lambda.Types.ElementAt(1).Name, Is.EqualTo("string"));
		}

		public enum EnumCaseSensitive
		{
			Test = 1,
			// ReSharper disable once InconsistentNaming
			TEST = 2
		}

		public enum MyCustomEnum
		{
			Value1,
			Value2
		}

		private class MyDataContract
		{
			public MyDataContract(string name)
			{
				Name = name;
			}

			public MyDataContract(int x, int y)
			{
				Name = string.Format("{0} - {1}", x, y);
			}

			public string Name { get; set; }
		}

		public class MyTestClass<T>
		{
			private T _val;
			public MyTestClass(T val)
			{
				_val = val;
			}

			public override string ToString()
			{
				if (_val == null)
					return "null";

				return _val.ToString();
			}
		}
	}
}