/Main/src/DynamicDataDisplay/Charts/Axes/DateTime/TimePeriodTicksProvider.cs

using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

using Microsoft.Research.DynamicDataDisplay.Common.Auxiliary;



namespace Microsoft.Research.DynamicDataDisplay.Charts

{

	internal abstract class TimePeriodTicksProvider<T> : ITicksProvider<T>

	{

		public event EventHandler Changed;

		protected void RaiseChanged()

		{

			if (Changed != null)

			{

				Changed(this, EventArgs.Empty);

			}

		}



		protected abstract T RoundUp(T time, DifferenceIn diff);

		protected abstract T RoundDown(T time, DifferenceIn diff);



		private bool differenceInited = false;

		private DifferenceIn difference;

		protected DifferenceIn Difference

		{

			get

			{

				if (!differenceInited)

				{

					difference = GetDifferenceCore();

					differenceInited = true;

				}

				return difference;

			}

		}

		protected abstract DifferenceIn GetDifferenceCore();



		private int[] tickCounts = null;

		protected int[] TickCounts

		{

			get

			{

				if (tickCounts == null)

					tickCounts = GetTickCountsCore();

				return tickCounts;

			}

		}

		protected abstract int[] GetTickCountsCore();



		public int DecreaseTickCount(int ticksCount)

		{

			if (ticksCount > TickCounts[0]) return TickCounts[0];



			for (int i = 0; i < TickCounts.Length; i++)

				if (ticksCount > TickCounts[i])

					return TickCounts[i];



			return TickCounts.Last();

		}



		public int IncreaseTickCount(int ticksCount)

		{

			if (ticksCount >= TickCounts[0]) return TickCounts[0];



			for (int i = TickCounts.Length - 1; i >= 0; i--)

				if (ticksCount < TickCounts[i])

					return TickCounts[i];



			return TickCounts.Last();

		}



		protected abstract int GetSpecificValue(T start, T dt);

		protected abstract T GetStart(T start, int value, int step);

		protected abstract bool IsMinDate(T dt);

		protected abstract T AddStep(T dt, int step);



		public ITicksInfo<T> GetTicks(Range<T> range, int ticksCount)

		{

			T start = range.Min;

			T end = range.Max;

			DifferenceIn diff = Difference;

			start = RoundDown(start, end);

			end = RoundUp(start, end);



			RoundingInfo bounds = RoundingHelper.CreateRoundedRange(

				GetSpecificValue(start, start),

				GetSpecificValue(start, end));



			int delta = (int)(bounds.Max - bounds.Min);

			if (delta == 0)

				return new TicksInfo<T> { Ticks = new T[] { start } };



			int step = delta / ticksCount;



			if (step == 0) step = 1;



			T tick = GetStart(start, (int)bounds.Min, step);

			bool isMinDateTime = IsMinDate(tick) && step != 1;

			if (isMinDateTime)

				step--;



			List<T> ticks = new List<T>();

			T finishTick = AddStep(range.Max, step);

			while (Continue(tick, finishTick))

			{

				ticks.Add(tick);

				tick = AddStep(tick, step);

				if (isMinDateTime)

				{

					isMinDateTime = false;

					step++;

				}

			}



			ticks = Trim(ticks, range);



			TicksInfo<T> res = new TicksInfo<T> { Ticks = ticks.ToArray(), Info = diff };

			return res;

		}



		protected abstract bool Continue(T current, T end);



		protected abstract T RoundUp(T start, T end);



		protected abstract T RoundDown(T start, T end);



		protected abstract List<T> Trim(List<T> ticks, Range<T> range);



		public ITicksProvider<T> MinorProvider

		{

			get { throw new NotSupportedException(); }

		}



		public ITicksProvider<T> MajorProvider

		{

			get { throw new NotSupportedException(); }

		}

	}



	internal abstract class DatePeriodTicksProvider : TimePeriodTicksProvider<DateTime>

	{

		protected sealed override bool Continue(DateTime current, DateTime end)

		{

			return current < end;

		}



		protected sealed override List<DateTime> Trim(List<DateTime> ticks, Range<DateTime> range)

		{

			int startIndex = 0;

			for (int i = 0; i < ticks.Count - 1; i++)

			{

				if (ticks[i] <= range.Min && range.Min <= ticks[i + 1])

				{

					startIndex = i;

					break;

				}

			}



			int endIndex = ticks.Count - 1;

			for (int i = ticks.Count - 1; i >= 1; i--)

			{

				if (ticks[i] >= range.Max && range.Max > ticks[i - 1])

				{

					endIndex = i;

					break;

				}

			}



			List<DateTime> res = new List<DateTime>(endIndex - startIndex + 1);

			for (int i = startIndex; i <= endIndex; i++)

			{

				res.Add(ticks[i]);

			}



			return res;

		}



		protected sealed override DateTime RoundUp(DateTime start, DateTime end)

		{

			bool isPositive = (end - start).Ticks > 0;

			return isPositive ? SafelyRoundUp(end) : RoundDown(end, Difference);

		}



		private DateTime SafelyRoundUp(DateTime dt)

		{

			if (AddStep(dt, 1) == DateTime.MaxValue)

				return DateTime.MaxValue;



			return RoundUp(dt, Difference);

		}



		protected sealed override DateTime RoundDown(DateTime start, DateTime end)

		{

			bool isPositive = (end - start).Ticks > 0;

			return isPositive ? RoundDown(start, Difference) : SafelyRoundUp(start);

		}



		protected sealed override DateTime RoundDown(DateTime time, DifferenceIn diff)

		{

			DateTime res = time;



			switch (diff)

			{

				case DifferenceIn.Year:

					res = new DateTime(time.Year, 1, 1);

					break;

				case DifferenceIn.Month:

					res = new DateTime(time.Year, time.Month, 1);

					break;

				case DifferenceIn.Day:

					res = time.Date;

					break;

				case DifferenceIn.Hour:

					res = time.Date.AddHours(time.Hour);

					break;

				case DifferenceIn.Minute:

					res = time.Date.AddHours(time.Hour).AddMinutes(time.Minute);

					break;

				case DifferenceIn.Second:

					res = time.Date.AddHours(time.Hour).AddMinutes(time.Minute).AddSeconds(time.Second);

					break;

				case DifferenceIn.Millisecond:

					res = time.Date.AddHours(time.Hour).AddMinutes(time.Minute).AddSeconds(time.Second).AddMilliseconds(time.Millisecond);

					break;

				default:

					break;

			}



			DebugVerify.Is(res <= time);



			return res;

		}



		protected override DateTime RoundUp(DateTime dateTime, DifferenceIn diff)

		{

			DateTime res = RoundDown(dateTime, diff);



			switch (diff)

			{

				case DifferenceIn.Year:

					res = res.AddYears(1);

					break;

				case DifferenceIn.Month:

					res = res.AddMonths(1);

					break;

				case DifferenceIn.Day:

					res = res.AddDays(1);

					break;

				case DifferenceIn.Hour:

					res = res.AddHours(1);

					break;

				case DifferenceIn.Minute:

					res = res.AddMinutes(1);

					break;

				case DifferenceIn.Second:

					res = res.AddSeconds(1);

					break;

				case DifferenceIn.Millisecond:

					res = res.AddMilliseconds(1);

					break;

				default:

					break;

			}



			return res;

		}

	}

}