using System;

using System.Linq;

using System.ComponentModel;

using System.Windows;

using System.Windows.Controls;

using Microsoft.Research.DynamicDataDisplay.Charts;

using Microsoft.Research.DynamicDataDisplay.Charts.Navigation;

using Microsoft.Research.DynamicDataDisplay.Navigation;

using Microsoft.Research.DynamicDataDisplay.Common;

using Microsoft.Research.DynamicDataDisplay.Charts.Axes;



namespace Microsoft.Research.DynamicDataDisplay

{

	/// <summary>

	/// Chart plotter is a plotter that renders axis and grid

	/// </summary>

	public class ChartPlotter : Plotter2D

	{

		private GeneralAxis horizontalAxis = new HorizontalAxis();

		private GeneralAxis verticalAxis = new VerticalAxis();

		private AxisGrid axisGrid = new AxisGrid();



		private Legend legend = new Legend();



		public ItemsPanelTemplate LegendPanelTemplate

		{

			get { return legend.ItemsPanel; }

			set

			{

				if (legend == null)

					throw new ArgumentNullException("LegendPanelTemplate");



				legend.ItemsPanel = value;

			}

		}



		public Style LegendStyle

		{

			get { return legend.Style; }

			set { legend.Style = value; }

		}



		/// <summary>

		/// Sets a value indicating whether to enable smooth axes panning for numeric axes.

		/// </summary>

		/// <value>

		/// 	<c>true</c> if enable smooth axes panning for numeric axes; otherwise, <c>false</c>.

		/// </value>

		[DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]

		public bool EnableSmoothPanningForNumericAxes

		{

			// todo improve returned value

			get { return false; }// throw new NotImplementedException(); }

			set

			{

				foreach (var axis in Children.OfType<NumericAxis>())

				{

					axis.UseSmoothPanning = value;

				}

			}

		}



		/// <summary>

		/// Initializes a new instance of the <see cref="ChartPlotter"/> class.

		/// </summary>

		public ChartPlotter()

			: base()

		{

			horizontalAxis.TicksChanged += OnHorizontalAxisTicksChanged;

			verticalAxis.TicksChanged += OnVerticalAxisTicksChanged;



			SetIsDefaultAxis(horizontalAxis as DependencyObject, true);

			SetIsDefaultAxis(verticalAxis as DependencyObject, true);



			mouseNavigation = new MouseNavigation();

			keyboardNavigation = new KeyboardNavigation();

			defaultContextMenu = new DefaultContextMenu();

			horizontalAxisNavigation = new AxisNavigation { Placement = AxisPlacement.Bottom };

			verticalAxisNavigation = new AxisNavigation { Placement = AxisPlacement.Left };



			Children.AddMany(

				horizontalAxis,

				verticalAxis,

				axisGrid,

				mouseNavigation,

				keyboardNavigation,

				defaultContextMenu,

				horizontalAxisNavigation,

				verticalAxisNavigation,

				new LongOperationsIndicator(),

				legend

				);



#if DEBUG

			Children.Add(new DebugMenu());

#endif



			SetAllChildrenAsDefault();

		}



		/// <summary>

		/// Creates generic plotter from this ChartPlotter.

		/// </summary>

		/// <returns></returns>

		public GenericChartPlotter<double, double> GetGenericPlotter()

		{

			return new GenericChartPlotter<double, double>(this);

		}



		/// <summary>

		/// Creates generic plotter from this ChartPlotter.

		/// Horizontal and Vertical types of GenericPlotter should correspond to ChartPlotter's actual main axes types.

		/// </summary>

		/// <typeparam name="THorizontal">The type of horizontal values.</typeparam>

		/// <typeparam name="TVertical">The type of vertical values.</typeparam>

		/// <returns>GenericChartPlotter, associated to this ChartPlotter.</returns>

		public GenericChartPlotter<THorizontal, TVertical> GetGenericPlotter<THorizontal, TVertical>()

		{

			return new GenericChartPlotter<THorizontal, TVertical>(this);

		}



		/// <summary>

		/// Creates generic plotter from this ChartPlotter.

		/// </summary>

		/// <typeparam name="THorizontal">The type of the horizontal axis.</typeparam>

		/// <typeparam name="TVertical">The type of the vertical axis.</typeparam>

		/// <param name="horizontalAxis">The horizontal axis to use as data conversion source.</param>

		/// <param name="verticalAxis">The vertical axis to use as data conversion source.</param>

		/// <returns>GenericChartPlotter, associated to this ChartPlotter</returns>

		public GenericChartPlotter<THorizontal, TVertical> GetGenericPlotter<THorizontal, TVertical>(AxisBase<THorizontal> horizontalAxis, AxisBase<TVertical> verticalAxis)

		{

			return new GenericChartPlotter<THorizontal, TVertical>(this, horizontalAxis, verticalAxis);

		}



		protected ChartPlotter(PlotterLoadMode loadMode) : base(loadMode) { }



		/// <summary>

		/// Creates empty plotter without any axes, navigation, etc.

		/// </summary>

		/// <returns>Empty plotter without any axes, navigation, etc.</returns>

		public static ChartPlotter CreateEmpty()

		{

			return new ChartPlotter(PlotterLoadMode.OnlyViewport);

		}



		public void BeginLongOperation()

		{

			LongOperationsIndicator.BeginLongOperation(this);

		}



		public void EndLongOperation()

		{

			LongOperationsIndicator.EndLongOperation(this);

		}



		#region Default charts



		private MouseNavigation mouseNavigation;

		/// <summary>

		/// Gets the default mouse navigation of ChartPlotter.

		/// </summary>

		/// <value>The mouse navigation.</value>

		[DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]

		public MouseNavigation MouseNavigation

		{

			get { return mouseNavigation; }

		}



		private KeyboardNavigation keyboardNavigation;

		/// <summary>

		/// Gets the default keyboard navigation of ChartPlotter.

		/// </summary>

		/// <value>The keyboard navigation.</value>

		[DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]

		public KeyboardNavigation KeyboardNavigation

		{

			get { return keyboardNavigation; }

		}



		private DefaultContextMenu defaultContextMenu;

		/// <summary>

		/// Gets the default context menu of ChartPlotter.

		/// </summary>

		/// <value>The default context menu.</value>

		[DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]

		public DefaultContextMenu DefaultContextMenu

		{

			get { return defaultContextMenu; }

		}



		private AxisNavigation horizontalAxisNavigation;

		/// <summary>

		/// Gets the default horizontal axis navigation of ChartPlotter.

		/// </summary>

		/// <value>The horizontal axis navigation.</value>

		[DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]

		public AxisNavigation HorizontalAxisNavigation

		{

			get { return horizontalAxisNavigation; }

		}



		private AxisNavigation verticalAxisNavigation;

		/// <summary>

		/// Gets the default vertical axis navigation of ChartPlotter.

		/// </summary>

		/// <value>The vertical axis navigation.</value>

		[DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]

		public AxisNavigation VerticalAxisNavigation

		{

			get { return verticalAxisNavigation; }

		}



		/// <summary>

		/// Gets the default axis grid of ChartPlotter.

		/// </summary>

		/// <value>The axis grid.</value>

		[DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]

		public AxisGrid AxisGrid

		{

			get { return axisGrid; }

		}



		#endregion



		private void OnHorizontalAxisTicksChanged(object sender, EventArgs e)

		{

			GeneralAxis axis = (GeneralAxis)sender;

			UpdateHorizontalTicks(axis);

		}



		private void UpdateHorizontalTicks(GeneralAxis axis)

		{

			axisGrid.BeginTicksUpdate();



			if (axis != null)

			{

				axisGrid.HorizontalTicks = axis.ScreenTicks;

				axisGrid.MinorHorizontalTicks = axis.MinorScreenTicks;

			}

			else

			{

				axisGrid.HorizontalTicks = null;

				axisGrid.MinorHorizontalTicks = null;

			}



			axisGrid.EndTicksUpdate();

		}



		private void OnVerticalAxisTicksChanged(object sender, EventArgs e)

		{

			GeneralAxis axis = (GeneralAxis)sender;

			UpdateVerticalTicks(axis);

		}



		private void UpdateVerticalTicks(GeneralAxis axis)

		{

			axisGrid.BeginTicksUpdate();



			if (axis != null)

			{

				axisGrid.VerticalTicks = axis.ScreenTicks;

				axisGrid.MinorVerticalTicks = axis.MinorScreenTicks;

			}

			else

			{

				axisGrid.VerticalTicks = null;

				axisGrid.MinorVerticalTicks = null;

			}



			axisGrid.EndTicksUpdate();

		}



		bool keepOldAxis = false;

		bool updatingAxis = false;



		/// <summary>

		/// Gets or sets the main vertical axis of ChartPlotter.

		/// Main vertical axis of ChartPlotter is axis which ticks are used to draw horizontal lines on AxisGrid.

		/// Value can be set to null to completely remove main vertical axis.

		/// </summary>

		/// <value>The main vertical axis.</value>

		[DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]

		public GeneralAxis MainVerticalAxis

		{

			get { return verticalAxis; }

			set

			{

				if (updatingAxis)

					return;



				if (value == null && verticalAxis != null)

				{

					if (!keepOldAxis)

					{

						Children.Remove(verticalAxis);

					}

					verticalAxis.TicksChanged -= OnVerticalAxisTicksChanged;

					verticalAxis = null;



					UpdateVerticalTicks(verticalAxis);



					return;

				}



				VerifyAxisType(value.Placement, AxisType.Vertical);



				if (value != verticalAxis)

				{

					ValidateVerticalAxis(value);



					updatingAxis = true;



					if (verticalAxis != null)

					{

						verticalAxis.TicksChanged -= OnVerticalAxisTicksChanged;

						SetIsDefaultAxis(verticalAxis, false);

						if (!keepOldAxis)

						{

							Children.Remove(verticalAxis);

						}

						value.Visibility = verticalAxis.Visibility;

					}

					SetIsDefaultAxis(value, true);



					verticalAxis = value;

					verticalAxis.TicksChanged += OnVerticalAxisTicksChanged;



					if (!Children.Contains(value))

					{

						Children.Add(value);

					}



					UpdateVerticalTicks(value);

					OnVerticalAxisChanged();



					updatingAxis = false;

				}

			}

		}



		protected virtual void OnVerticalAxisChanged() { }

		protected virtual void ValidateVerticalAxis(GeneralAxis axis) { }



		/// <summary>

		/// Gets or sets the main horizontal axis visibility.

		/// </summary>

		/// <value>The main horizontal axis visibility.</value>

		public Visibility MainHorizontalAxisVisibility

		{

			get { return MainHorizontalAxis != null ? ((UIElement)MainHorizontalAxis).Visibility : Visibility.Hidden; }

			set

			{

				if (MainHorizontalAxis != null)

				{

					((UIElement)MainHorizontalAxis).Visibility = value;

				}

			}

		}



		/// <summary>

		/// Gets or sets the main vertical axis visibility.

		/// </summary>

		/// <value>The main vertical axis visibility.</value>

		public Visibility MainVerticalAxisVisibility

		{

			get { return MainVerticalAxis != null ? ((UIElement)MainVerticalAxis).Visibility : Visibility.Hidden; }

			set

			{

				if (MainVerticalAxis != null)

				{

					((UIElement)MainVerticalAxis).Visibility = value;

				}

			}

		}



		/// <summary>

		/// Gets or sets the main horizontal axis of ChartPlotter.

		/// Main horizontal axis of ChartPlotter is axis which ticks are used to draw vertical lines on AxisGrid.

		/// Value can be set to null to completely remove main horizontal axis.

		/// </summary>

		/// <value>The main horizontal axis.</value>

		[DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]

		public GeneralAxis MainHorizontalAxis

		{

			get { return horizontalAxis; }

			set

			{

				if (updatingAxis)

					return;



				if (value == null && horizontalAxis != null)

				{

					Children.Remove(horizontalAxis);

					horizontalAxis.TicksChanged -= OnHorizontalAxisTicksChanged;

					horizontalAxis = null;



					UpdateHorizontalTicks(horizontalAxis);



					return;

				}



				VerifyAxisType(value.Placement, AxisType.Horizontal);



				if (value != horizontalAxis)

				{

					ValidateHorizontalAxis(value);



					updatingAxis = true;



					if (horizontalAxis != null)

					{

						horizontalAxis.TicksChanged -= OnHorizontalAxisTicksChanged;

						SetIsDefaultAxis(horizontalAxis, false);

						if (!keepOldAxis)

						{

							Children.Remove(horizontalAxis);

						}

						value.Visibility = horizontalAxis.Visibility;

					}

					SetIsDefaultAxis(value, true);



					horizontalAxis = value;

					horizontalAxis.TicksChanged += OnHorizontalAxisTicksChanged;



					if (!Children.Contains(value))

					{

						Children.Add(value);

					}



					UpdateHorizontalTicks(value);

					OnHorizontalAxisChanged();



					updatingAxis = false;

				}

			}

		}



		protected virtual void OnHorizontalAxisChanged() { }

		protected virtual void ValidateHorizontalAxis(GeneralAxis axis) { }



		private static void VerifyAxisType(AxisPlacement axisPlacement, AxisType axisType)

		{

			bool result = false;

			switch (axisPlacement)

			{

				case AxisPlacement.Left:

				case AxisPlacement.Right:

					result = axisType == AxisType.Vertical;

					break;

				case AxisPlacement.Top:

				case AxisPlacement.Bottom:

					result = axisType == AxisType.Horizontal;

					break;

				default:

					break;

			}



			if (!result)

				throw new ArgumentException(Strings.Exceptions.InvalidAxisPlacement);

		}



		protected override void OnIsDefaultAxisChangedCore(DependencyObject d, DependencyPropertyChangedEventArgs e)

		{

			GeneralAxis axis = d as GeneralAxis;

			if (axis != null)

			{

				bool value = (bool)e.NewValue;

				bool oldKeepOldAxis = keepOldAxis;



				bool horizontal = axis.Placement == AxisPlacement.Bottom || axis.Placement == AxisPlacement.Top;

				keepOldAxis = true;



				if (value && horizontal)

				{

					MainHorizontalAxis = axis;

				}

				else if (value && !horizontal)

				{

					MainVerticalAxis = axis;

				}

				else if (!value && horizontal)

				{

					MainHorizontalAxis = null;

				}

				else if (!value && !horizontal)

				{

					MainVerticalAxis = null;

				}



				keepOldAxis = oldKeepOldAxis;

			}

		}



		/// <summary>

		/// Gets the default legend of ChartPlotter.

		/// </summary>

		/// <value>The legend.</value>

		[DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]

		public Legend Legend

		{

			get { return legend; }

		}



		/// <summary>

		/// Gets or sets the visibility of legend.

		/// </summary>

		/// <value>The legend visibility.</value>

		public Visibility LegendVisibility

		{

			get { return legend.Visibility; }

			set { legend.Visibility = value; }

		}



		public bool LegendVisible

		{

			get { return legend.LegendVisible; }

			set { legend.LegendVisible = value; }

		}



		private enum AxisType

		{

			Horizontal,

			Vertical

		}

	}

}