using System;

using System.ComponentModel;

using Delta.Utilities.Helpers;

using Delta.Utilities.Math;

using NUnit.Framework;



namespace Delta.Utilities.Tests

{

	/// <summary>

	/// Test class for the EnumHelper.

	/// </summary>

	public class EnumHelperTests

	{

		#region Helpers

		/// <summary>

		/// Test enum

		/// </summary>

		private enum TestEnum

		{

			[Description("Some entry")]

			SomeEntry,



			[Description("Another one")]

			AnotherOne,



			[Description("Hey stop it now")]

			HeyStopItNow,



			[Description("Okay okay")]

			OkayOkay,

		}

		#endregion



		#region Helpers

		/// <summary>

		/// Test combined enum

		/// </summary>

		[Flags]

		private enum TestCombinedEnum

		{

			Zero = 0,



			NumberOne = 1,



			NumberTwo = 2,



			NumberFour = 4,

		}

		#endregion



		#region GetNames (Static)

		/// <summary>

		/// Get names

		/// </summary>

		[Test]

		public static void GetNames()

		{

			string[] names = EnumHelper.GetNames(typeof(StringSplitOptions));

			Assert.Equal(names.Length, 2);

			Assert.Equal(names[0], "None");

			Assert.Equal(names[1], "RemoveEmptyEntries");



			string[] genericNames = EnumHelper.GetNames<StringSplitOptions>();

			Assert.Equal(genericNames.Length, 2);

			Assert.Equal(genericNames[0], "None");

			Assert.Equal(genericNames[1], "RemoveEmptyEntries");

		}

		#endregion



		#region TestEnumStuff (LongRunning)

		/// <summary>

		/// Test enum stuff. Note: Too slow for a dynamic unit test.

		/// </summary>

		[Test]

		[NUnit.Framework.Category("LongRunning")]

		public static void TestEnumStuff()

		{

			// First get size of TestEnum (with type of enum)

			Assert.Equal(EnumHelper.GetCount<TestEnum>(), 4);



			// Now try with some enum member (should give the same result)

			Assert.Equal(EnumHelper.GetCount(TestEnum.SomeEntry), 4);



			// Test with extension

			Assert.Equal(TestEnum.SomeEntry.GetCount(), 4);

			Assert.Equal(TestEnum.SomeEntry.GetCount(), 4);



			// Try to get enum from name

			Assert.Equal(TestEnum.OkayOkay, EnumHelper.ToEnum<TestEnum>("OkayOkay"));



			// Get description of an enum members

			Assert.Equal(TestEnum.OkayOkay.GetEnumDescription(),

				"Okay okay");

			Assert.Equal(TestEnum.OkayOkay.Description(), "Okay okay");



			// Test enum enumerator stuff

			string allEnumNames = EnumHelper.GetEnumerator(typeof(TestEnum)).Write();

			Assert.Equal("SomeEntry, AnotherOne, HeyStopItNow, OkayOkay",

				allEnumNames);



			// Test same with description values

			string allEnumDescNames = "";

			foreach (TestEnum enumValue in

				EnumHelper.GetEnumerator(typeof(TestEnum)))

			{

				allEnumDescNames +=

					(allEnumDescNames.Length == 0

					 	? ""

					 	: ", ") +

					enumValue.GetEnumDescription();

			}

			Assert.Equal(

				"Some entry, Another one, Hey stop it now, Okay okay",

				allEnumDescNames);



			// Same check with GetAllEnumDescriptions

			Assert.Equal(

				"Some entry, Another one, Hey stop it now, Okay okay",

				EnumHelper.GetAllEnumDescriptions(typeof(TestEnum)).Write());

		}

		#endregion



		#region TestNextAndPreviousEnum (LongRunning)

		/// <summary>

		/// Test next and previous enum. Note: Too slow for a dynamic unit test.

		/// </summary>

		[Test]

		[NUnit.Framework.Category("LongRunning")]

		public static void TestNextAndPreviousEnum()

		{

			TestEnum someEnum = TestEnum.SomeEntry;

			Assert.Equal(TestEnum.SomeEntry, someEnum);



			// Check next entry

			someEnum = (TestEnum)someEnum.SelectNextEnum();

			Assert.Equal(TestEnum.AnotherOne, someEnum);

			Assert.Equal(TestEnum.AnotherOne, TestEnum.SomeEntry.Next());



			// Go back 2 entries, this will select the last enum entry

			someEnum = (TestEnum)someEnum.SelectPreviousEnum();

			someEnum = (TestEnum)someEnum.SelectPreviousEnum();

			Assert.Equal(TestEnum.OkayOkay, someEnum);

			Assert.Equal(TestEnum.AnotherOne, TestEnum.HeyStopItNow.Previous());

		}

		#endregion



		#region GetEnumFromName (LongRunning)

		/// <summary>

		/// Get enum from name

		/// </summary>

		[Test]

		[NUnit.Framework.Category("LongRunning")]

		public void GetEnumFromName()

		{

			Assert.Equal(TestEnum.OkayOkay,

			  EnumHelper.ToEnum<TestEnum>("OkayOkay"));

			Assert.Equal(TestCombinedEnum.NumberFour,

			  EnumHelper.ToEnum<TestCombinedEnum>("NumberFour"));

		}

		#endregion



		#region GetValues (LongRunning)

		/// <summary>

		/// Get values

		/// </summary>

		[Test]

		[NUnit.Framework.Category("LongRunning")]

		public static void GetValues()

		{

			object[] values = typeof(StringSplitOptions).GetValues();

			Assert.Equal(values.Length, 2);

			Assert.Equal(values[0], StringSplitOptions.None);

			Assert.Equal(values[1], StringSplitOptions.RemoveEmptyEntries);



			StringSplitOptions[] genericValues =

				EnumHelper.GetValues<StringSplitOptions>();

			Assert.Equal(genericValues.Length, 2);

			Assert.Equal(genericValues[0], StringSplitOptions.None);

			Assert.Equal(genericValues[1], StringSplitOptions.RemoveEmptyEntries);

		}

		#endregion



		#region GetCount

		/// <summary>

		/// Get count

		/// </summary>

		[Test]

		public void GetCount()

		{

			Assert.Equal(7, EnumHelper.GetCount<DayOfWeek>());

		}

		#endregion



		#region NextValue

		/// <summary>

		/// Next value

		/// </summary>

		[Test]

		public void NextValue()

		{

			Assert.Equal(DayOfWeek.Monday, DayOfWeek.Sunday.NextValue());

		}

		#endregion



		#region ConvertToNumber

		/// <summary>

		/// Convert to number

		/// </summary>

		[Test]

		public void ConvertToNumber()

		{

			Assert.Equal(0,

			  EnumHelper.ToInt(TestCombinedEnum.Zero));

			Assert.Equal(2,

				EnumHelper.ToInt(TestCombinedEnum.NumberTwo));



			Assert.Equal(4,

				EnumHelper.ToInt(TestCombinedEnum.NumberFour));

			Assert.Equal(6, EnumHelper.ToInt(

				TestCombinedEnum.NumberTwo | TestCombinedEnum.NumberFour));

			Assert.Equal(TestCombinedEnum.NumberFour,

				EnumHelper.ToEnum<TestCombinedEnum>("4"));

			

			Assert.Equal(TestCombinedEnum.NumberTwo | TestCombinedEnum.NumberFour,

				EnumHelper.ToEnum<TestCombinedEnum>("6"));

		}

		#endregion



		#region ConvertToNumberWithCombinedEnum

		/// <summary>

		/// Convert to number

		/// </summary>

		[Test]

		public void ConvertToNumberWithCombinedEnum()

		{

			// Reproduce test with standard methods

			Assert.Equal(4, (int)"NumberFour".ToEnum<TestCombinedEnum>());

			Assert.Equal(6,

				(int)"NumberTwo, NumberFour".ToEnum<TestCombinedEnum>());

			Assert.Equal(

				(int)(TestCombinedEnum.NumberTwo | TestCombinedEnum.NumberFour),

				(int)"6".ToEnum<TestCombinedEnum>());

			Assert.Equal("NumberTwo, NumberFour",

				(TestCombinedEnum.NumberTwo |

				 TestCombinedEnum.NumberFour).ToString());

			Assert.Equal(TestCombinedEnum.Zero, "bla".ToEnum<TestCombinedEnum>());

			Assert.Equal("Zero", TestCombinedEnum.Zero.ToString());



			Assert.Equal(0,

				(int)(TestCombinedEnum.Zero.ToString().

							ToEnum<TestCombinedEnum>()));

			Assert.Equal(

				(int)(TestCombinedEnum.NumberTwo |

							TestCombinedEnum.NumberFour),

				(int)(TestCombinedEnum.NumberTwo |

							TestCombinedEnum.NumberFour.ToString().

								ToEnum<TestCombinedEnum>()));



			// Finally write down a combined enum.

			TestCombinedEnum combinedValue =

				TestCombinedEnum.NumberTwo |

				TestCombinedEnum.NumberFour;

			Assert.Equal("NumberTwo, NumberFour", combinedValue.ToString());

			Assert.Equal(combinedValue.ToStringArray(), new string[]

				{

					"NumberTwo", "NumberFour"

				});

			// This can be useful to build a combined enum name as a filename!

			Assert.Equal(combinedValue.ToStringArray().Write("_"),

				"NumberTwo_NumberFour");

			Assert.Equal(combinedValue,

				combinedValue.ToStringArray().ToEnum<TestCombinedEnum>());

		}

		#endregion



		#region ToBlablabla

		/// <summary>

		/// To string

		/// </summary>

		[Test]

		public void ToBlablabla()

		{

			Assert.Equal("5 + i * 2", new Complex(5.0f, 2.0f).ToString());

		}

		#endregion

	}

}