using System;
using Microsoft.VisualStudio.TestTools.UnitTesting;
using Sarand.Net.Standard.Base.Utils;

namespace Sarand.UnitTests.Core.Base.Utils
{
	//=======================================================================
	[TestClass]
	public class DateUtil_Tester
	{
		//-------------------------------------------------------------------
		// Data members.
		private Random random = new Random();
		private DateTime today = DateTime.Today;

		//-------------------------------------------------------------------
		[TestMethod]
		public void DateTime_CTR_Void ()
		{
			Assert.IsNotNull(new DateTime());
			Assert.AreEqual(new DateTime(), DateTime.MinValue);
		}

		//-------------------------------------------------------------------
		//                          S e t   T i m e
		//-------------------------------------------------------------------
		[TestMethod]
		public void SetTime_DateTime ()
		{
			for (int i = 0; i < 1000; i++)
			{
				DateTime date = new DateTime(random.Next(1970, 2100), random.Next(1, 13), random.Next(1, 28), random.Next(0, 24), random.Next(0, 60), random.Next(0, 60));
				DateTime time = new DateTime(random.Next(1970, 2100), random.Next(1, 13), random.Next(1, 28), random.Next(0, 24), random.Next(0, 60), random.Next(0, 60));
				Assert.AreEqual(DateUtil.FormatXmlDate(date), DateUtil.FormatXmlDate(date.SetTime(time)));
				Assert.AreEqual(DateUtil.FormatXmlTime(time), DateUtil.FormatXmlTime(date.SetTime(time)));
			}
		}
		[TestMethod]
		public void SetTime_TimeSpan ()
		{
			for (int i = 0; i < 1000; i++)
			{
				DateTime date = new DateTime(random.Next(1970, 2100), random.Next(1, 13), random.Next(1, 28), random.Next(0, 24), random.Next(0, 60), random.Next(0, 60));
				TimeSpan time = new TimeSpan(random.Next(0, 24), random.Next(0, 60), random.Next(0, 60));
				Assert.AreEqual(DateUtil.FormatXmlDate(date), DateUtil.FormatXmlDate(date.SetTime(time)));
				Assert.AreEqual(DateUtil.FormatXmlTime(today + time), DateUtil.FormatXmlTime(date.SetTime(time)));
			}
		}

		//-------------------------------------------------------------------
		//                        R o u n d   T i m e
		//-------------------------------------------------------------------
		[TestMethod]
		public void RoundTime ()
		{
			for (int i = 0; i < 2000; i++)
			{
				DateTime datetime = new DateTime(random.Next(1970, 2100), random.Next(1, 13), random.Next(1, 28), random.Next(0, 24), random.Next(0, 60), random.Next(0, 60));
				ushort intervalMins = (ushort)random.Next(1,61);
				{
					// Round up without seconds.
					int expectedMins = ((datetime.Minute / intervalMins) + (datetime.Minute % intervalMins > 0 ? 1 : 0)) * intervalMins;
					DateTime expected = datetime.Date + new TimeSpan(datetime.Hour,expectedMins,0);
					DateTime rounded = DateUtil.RoundTime(datetime,intervalMins,DateUtil.RoundingDirection.Up,true);
					Assert.AreEqual(DateUtil.FormatXmlDateTime(expected), DateUtil.FormatXmlDateTime(rounded));
				}
				{
					// Round up with seconds.
					int expectedMins = ((datetime.Minute / intervalMins) + ((datetime.Minute * 60 + datetime.Second) % (intervalMins * 60) > 0 ? 1 : 0)) * intervalMins;
					DateTime expected = datetime.Date + new TimeSpan(datetime.Hour,expectedMins,0);
					DateTime rounded = DateUtil.RoundTime(datetime,intervalMins,DateUtil.RoundingDirection.Up,false);
					Assert.AreEqual(DateUtil.FormatXmlDateTime(expected), DateUtil.FormatXmlDateTime(rounded));
				}
				{
					// Round down without seconds.
					int expectedMins = (datetime.Minute / intervalMins) * intervalMins;
					DateTime expected = datetime.Date + new TimeSpan(datetime.Hour,expectedMins,0);
					DateTime rounded = DateUtil.RoundTime(datetime,intervalMins,DateUtil.RoundingDirection.Down,true);
					Assert.AreEqual(DateUtil.FormatXmlDateTime(expected), DateUtil.FormatXmlDateTime(rounded));
				}
				{
					// Round down with seconds.
					int expectedMins = (datetime.Minute / intervalMins) * intervalMins;
					DateTime expected = datetime.Date + new TimeSpan(datetime.Hour,expectedMins,0);
					DateTime rounded = DateUtil.RoundTime(datetime,intervalMins,DateUtil.RoundingDirection.Down,false);
					Assert.AreEqual(DateUtil.FormatXmlDateTime(expected), DateUtil.FormatXmlDateTime(rounded));
				}
				{
					// Nearest without seconds.
					int expectedMins = ((datetime.Minute / intervalMins) + (datetime.Minute % intervalMins > (intervalMins/2) ? 1 : 0)) * intervalMins;
					DateTime expected = datetime.Date + new TimeSpan(datetime.Hour,expectedMins,0);
					DateTime rounded = DateUtil.RoundTime(datetime,intervalMins,DateUtil.RoundingDirection.Nearest,true);
					if (!DateUtil.FormatXmlDateTime(expected).Equals(DateUtil.FormatXmlDateTime(rounded)))
					{
						//String s = "";
					}
					Assert.AreEqual(DateUtil.FormatXmlDateTime(expected), DateUtil.FormatXmlDateTime(rounded));
				}
				{
					// Nearest with seconds.
					int expectedMins = ((datetime.Minute / intervalMins) + ((datetime.Minute * 60 + datetime.Second) % (intervalMins * 60) > (intervalMins*60/2) ? 1 : 0)) * intervalMins;
					DateTime expected = datetime.Date + new TimeSpan(datetime.Hour,expectedMins,0);
					DateTime rounded = DateUtil.RoundTime(datetime,intervalMins,DateUtil.RoundingDirection.Nearest,false);
					if (!DateUtil.FormatXmlDateTime(expected).Equals(DateUtil.FormatXmlDateTime(rounded)))
					{
						//String s = "";
					}
					Assert.AreEqual(DateUtil.FormatXmlDateTime(expected), DateUtil.FormatXmlDateTime(rounded));
				}
			}
		}

		//-------------------------------------------------------------------
		//               C o n v e r t   F r o m   S t r i n g
		//-------------------------------------------------------------------
		[TestMethod]
		public void DateTime_ParseXmlDate ()
		{
			String xmlDate = "2015-05-28";
			Assert.AreEqual(new DateTime(2015, 5, 28), DateUtil.ParseXmlDate(xmlDate));
		}

		//-------------------------------------------------------------------
		[TestMethod]
		public void DateTime_ParseXmlTime ()
		{
			String xmlTime = "16:25:57";
			Assert.AreEqual(new DateTime(today.Year, today.Month, today.Day, 16, 25, 57), DateUtil.ParseXmlTime(xmlTime));
		}

		//-------------------------------------------------------------------
		[TestMethod]
		public void DateTime_ParseXmlDateTime ()
		{
			String xmlDateTime = "2010-05-28T17:05:01";
			Assert.AreEqual(new DateTime(2010, 5, 28, 17, 5, 1), DateUtil.ParseXmlDateTime(xmlDateTime));
		}

		//-------------------------------------------------------------------------
		//                           V a l i d a t i o n
		//-------------------------------------------------------------------------
		[TestMethod]
		public void DateTime_IsValid ()
		{
			// Valid.
			Assert.AreEqual(true, DateUtil.IsValid(DateTime.Now));
			Assert.AreEqual(true, DateUtil.IsValid(DateTime.Today));
			Assert.AreEqual(true, DateUtil.IsValid(new DateTime(2018, 2, 12, 10, 32, 56)));

			// Invalid.
			Assert.AreEqual(false, DateUtil.IsValid(DateTime.MinValue));
			Assert.AreEqual(false, DateUtil.IsValid(DateTime.MaxValue));
			Assert.AreEqual(false, DateUtil.IsValid(new DateTime(0)));
			Assert.AreEqual(false, DateUtil.IsValid(new DateTime(1, 1, 1)));

			// Nullable.
			Assert.AreEqual(false, DateUtil.IsValid(null));
		}

		//-------------------------------------------------------------------
		// Relative dates - Week.
		// DateUtil.StartOfWeek
		[TestMethod]
		public void DateTime_StartOfWeek ()
		{
			for (int i = 0; i < 1000; i++)
			{
				// Random date between 0AD and 3000AD (or thereabouts):
				DateTime date = new DateTime(random.Next(0, 365 * 3000) * TimeSpan.TicksPerDay);
				//Trace.WriteLine("DateUtil_Tester.DateTime_StartOfWeek Date=" + date.Format("ddd d-MMM-yyyy") + ", Start of week=" + date.StartOfWeek().Format("ddd d-MMM-yyyy"));
				Assert.AreEqual(date.StartOfWeek().Format("ddd"), "Sun");
			}
		}
		// DateUtil.StartOfWeek
		[TestMethod]
		public void DateTime_StartOfWorkingWeek ()
		{
			for (int i = 0; i < 1000; i++)
			{
				// Random date between 0AD and 3000AD (or thereabouts):
				DateTime date = new DateTime(random.Next(0, 365 * 3000) * TimeSpan.TicksPerDay);
				//Trace.WriteLine("DateUtil_Tester.DateTime_StartOfWorkingWeek Date=" + date.Format("ddd d-MMM-yyyy") + ", Start of week=" + date.StartOfWorkingWeek().Format("ddd d-MMM-yyyy"));
				Assert.AreEqual(date.StartOfWorkingWeek().Format("ddd"), "Mon");
			}
		}

		//-------------------------------------------------------------------
		// Relative dates - Month.
		// DateUtil.StartOfMonth
		[TestMethod]
		public void DateTime_StartOfMonth ()
		{
			DateTime dt20160723 = new DateTime(2016, 7, 23);
			Assert.AreEqual(dt20160723.StartOfMonth(), new DateTime(2016, 7, 1));
		}
		// DateUtil.EndOfMonth
		[TestMethod]
		public void DateTime_DaysInMonth ()
		{
			DateTime dt20160723 = new DateTime(2016, 7, 23);
			Assert.AreEqual(dt20160723.DaysInMonth(), 31);
		}
		// DateUtil.EndOfMonth
		[TestMethod]
		public void DateTime_EndOfMonth ()
		{
			DateTime dt20160723 = new DateTime(2016, 7, 23);
			Assert.AreEqual(dt20160723.EndOfMonth(), new DateTime(2016, 7, 31));
		}

		//-------------------------------------------------------------------
		//                        F o r m a t t i n g
		//-------------------------------------------------------------------
		[TestMethod]
		public void DateTime_Format_Void ()
		{
			DateTime dt20160723 = new DateTime(2016, 7, 23);
			DateTime dt20160723172829 = new DateTime(2016, 7, 23, 17, 28, 39);

			Assert.AreEqual(dt20160723.Format("dd/MM/yyyy"), "23/07/2016");
			Assert.AreEqual(dt20160723.Format("dd/MM/yyyy HH:mm:ss"), "23/07/2016 00:00:00");

			Assert.AreEqual(dt20160723172829.Format("dd/MM/yyyy"), "23/07/2016");
			Assert.AreEqual(dt20160723172829.Format("dd/MM/yyyy HH:mm:ss"), "23/07/2016 17:28:39");
		}

		//-------------------------------------------------------------------
		[TestMethod]
		public void DateTime_FormatXmlDate ()
		{
			DateTime dt20160723 = new DateTime(2016, 7, 23);
			DateTime dt20160723172829 = new DateTime(2016, 7, 23, 17, 28, 39);

			Assert.AreEqual("2016-07-23", DateUtil.FormatXmlDate(dt20160723));
			Assert.AreEqual("2016-07-23", DateUtil.FormatXmlDate(dt20160723172829));
		}

		//-------------------------------------------------------------------
		[TestMethod]
		public void DateTime_FormatXmlTime ()
		{
			DateTime dt20160723172829 = new DateTime(2016, 7, 23, 17, 28, 39);

			Assert.AreEqual("17:28:39", DateUtil.FormatXmlTime(dt20160723172829));
		}

		//-------------------------------------------------------------------
		[TestMethod]
		public void DateTime_FormatXmlDateTime ()
		{
			DateTime dt20160723172829 = new DateTime(2016, 7, 23, 17, 28, 39);

			Assert.AreEqual("2016-07-23T17:28:39", DateUtil.FormatXmlDateTime(dt20160723172829));
		}

		//-------------------------------------------------------------------
	}
	//=======================================================================
}