using System;
using System.Net;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Documents;
using System.Windows.Ink;
using System.Windows.Input;
using System.Windows.Media;
using System.Windows.Media.Animation;
using System.Windows.Shapes;
using System.Collections;
using System.Windows.Controls.DataVisualization.Charting;
using System.Windows.Data;
using System.Collections.Specialized;

namespace SilverlightChart
{
	/// <summary>
	/// Helper that allows for the easy setting of global chart properties and binding to multiple series.
	/// Original code is provided at http://jmorrill.hjtcentral.com/Home/tabid/428/EntryId/351/Silverlight-Charts-Binding-multiple-Series.aspx 
	/// Thanks to Jeremiah Morrill for the initial implementation.
	/// </summary>
	public class ChartHelper
	{
		#region SeriesType enum

		/// <summary>
		/// Represents the supported series types
		/// </summary>
		public enum SeriesType
		{
			/// <summary>
			/// A line chart
			/// </summary>
			Line,
			/// <summary>
			/// A bar chart (note that Bar displays its Independent and Dependent data on reversed axes)
			/// </summary>
			Bar,
			/// <summary>
			/// A column chart
			/// </summary>
			Column,
			/// <summary>
			/// A scatter chart
			/// </summary>
			Scatter,
			/// <summary>
			/// A pie chart
			/// </summary>
			Pie,
			/// <summary>
			/// An area chart
			/// </summary>
			Area,
			/// <summary>
			/// A bubble chart
			/// </summary>
			Bubble
		}

		#endregion

		#region SeriesSource

		/// <summary>
		/// Dependency property binds the source of data for the series
		/// </summary>
		public static readonly DependencyProperty SeriesSourceProperty =
				DependencyProperty.RegisterAttached("SeriesSource",
													typeof(IEnumerable),
													typeof(ChartHelper),
													new PropertyMetadata(SeriesSourceChanged));

		/// <summary>
		/// Gets the series source.
		/// </summary>
		/// <param name="d">The chart object upon which this helper acts.</param>
		/// <returns></returns>
		public static IEnumerable GetSeriesSource(DependencyObject d)
		{
			return (IEnumerable)d.GetValue(SeriesSourceProperty);
		}

		/// <summary>
		/// Sets the series source.
		/// </summary>
		/// <param name="d">The chart object upon which this helper acts.</param>
		/// <param name="value">The value.</param>
		public static void SetSeriesSource(DependencyObject d, IEnumerable value)
		{
			d.SetValue(SeriesSourceProperty, value);
		}

		#endregion

		#region DependentValueBinding

		/// <summary>
		/// Represents the Dependent Value binding (which property on the objects contained in the SeriesSource should be used as the dependent value)
		/// </summary>
		public static readonly DependencyProperty DependentValueBindingProperty =
			DependencyProperty.RegisterAttached("DependentValueBinding",
												typeof(string),
												typeof(ChartHelper),
												null);

		/// <summary>
		/// Gets the dependent value binding.
		/// </summary>
		/// <param name="d">The chart object upon which this helper acts.</param>
		/// <returns></returns>
		public static string GetDependentValueBinding(DependencyObject d)
		{
			return (string)d.GetValue(DependentValueBindingProperty);
		}

		/// <summary>
		/// Sets the dependent value binding.
		/// </summary>
		/// <param name="d">The chart object upon which this helper acts.</param>
		/// <param name="value">The value.</param>
		public static void SetDependentValueBinding(DependencyObject d, string value)
		{
			d.SetValue(DependentValueBindingProperty, value);
		}

		#endregion

		#region IndependentValueBinding

		/// <summary>
		/// Represents the Independent Value binding (which property on the objects contained in the SeriesSource should be used as the independent value)
		/// </summary>
		public static readonly DependencyProperty IndependentValueBindingProperty =
			DependencyProperty.RegisterAttached("IndependentValueBinding",
												typeof(string),
												typeof(ChartHelper),
												null);

		/// <summary>
		/// Gets the independent value binding.
		/// </summary>
		/// <param name="d">The chart object upon which this helper acts.</param>
		/// <returns></returns>
		public static string GetIndependentValueBinding(DependencyObject d)
		{
			return (string)d.GetValue(IndependentValueBindingProperty);
		}

		/// <summary>
		/// Sets the independent value binding.
		/// </summary>
		/// <param name="d">The chart object upon which this helper acts.</param>
		/// <param name="value">The value.</param>
		public static void SetIndependentValueBinding(DependencyObject d, string value)
		{
			d.SetValue(IndependentValueBindingProperty, value);
		}

		#endregion

		#region Title

		/// <summary>
		/// Represents the Title binding (which DataContext property should be bound to Title)
		/// </summary>
		public static readonly DependencyProperty TitleProperty =
			DependencyProperty.RegisterAttached("Title",
												typeof(string),
												typeof(ChartHelper),
												null);

		/// <summary>
		/// Gets the title.
		/// </summary>
		/// <param name="d">The chart object upon which this helper acts.</param>
		/// <returns></returns>
		public static string GetTitle(DependencyObject d)
		{
			return (string)d.GetValue(TitleProperty);
		}

		/// <summary>
		/// Sets the title.
		/// </summary>
		/// <param name="d">The chart object upon which this helper acts.</param>
		/// <param name="value">The value.</param>
		public static void SetTitle(DependencyObject d, string value)
		{
			d.SetValue(TitleProperty, value);
		}

		#endregion

		#region XAxisTitle

		/// <summary>
		/// Represents the X Axis Title binding (which DataContext property should be bound to X Axis Title)
		/// </summary>
		public static readonly DependencyProperty XAxisTitleProperty =
			DependencyProperty.RegisterAttached("XAxisTitle",
												typeof(string),
												typeof(ChartHelper),
												null);

		/// <summary>
		/// Gets the X axis title.
		/// </summary>
		/// <param name="d">The chart object upon which this helper acts.</param>
		/// <returns></returns>
		public static string GetXAxisTitle(DependencyObject d)
		{
			return (string)d.GetValue(XAxisTitleProperty);
		}

		/// <summary>
		/// Sets the X axis title.
		/// </summary>
		/// <param name="d">The chart object upon which this helper acts.</param>
		/// <param name="value">The value.</param>
		public static void SetXAxisTitle(DependencyObject d, string value)
		{
			d.SetValue(XAxisTitleProperty, value);
		}

		#endregion

		#region XAxisMinimum

		/// <summary>
		/// Represents the X Axis Minimum binding (which DataContext property should be bound to X Axis Minimum value)
		/// </summary>
		public static readonly DependencyProperty XAxisMinimumProperty =
		DependencyProperty.RegisterAttached("XAxisMinimum",
										typeof(string),
										typeof(ChartHelper),
										null);

		/// <summary>
		/// Gets the X axis minimum.
		/// </summary>
		/// <param name="d">The chart object upon which this helper acts.</param>
		/// <returns></returns>
		public static string GetXAxisMinimum(DependencyObject d)
		{
			return (string)d.GetValue(XAxisMinimumProperty);
		}

		/// <summary>
		/// Sets the X axis minimum.
		/// </summary>
		/// <param name="d">The chart object upon which this helper acts.</param>
		/// <param name="value">The value.</param>
		public static void SetXAxisMinimum(DependencyObject d, string value)
		{
			d.SetValue(XAxisMinimumProperty, value);
		}

		#endregion

		#region XAxisMaximum

		/// <summary>
		/// Represents the X Axis Maximum binding (which DataContext property should be bound to X Axis Maximum value)
		/// </summary>
		public static readonly DependencyProperty XAxisMaximumProperty =
		DependencyProperty.RegisterAttached("XAxisMaximum",
										typeof(string),
										typeof(ChartHelper),
										null);

		/// <summary>
		/// Gets the X axis maximum.
		/// </summary>
		/// <param name="d">The chart object upon which this helper acts.</param>
		/// <returns></returns>
		public static string GetXAxisMaximum(DependencyObject d)
		{
			return (string)d.GetValue(XAxisMaximumProperty);
		}

		/// <summary>
		/// Sets the X axis maximum.
		/// </summary>
		/// <param name="d">The chart object upon which this helper acts.</param>
		/// <param name="value">The value.</param>
		public static void SetXAxisMaximum(DependencyObject d, string value)
		{
			d.SetValue(XAxisMaximumProperty, value);
		}

		#endregion

		#region YAxisTitle

		/// <summary>
		/// Represents the Y Axis Title binding (which DataContext property should be bound to Y Axis Title)
		/// </summary>
		public static readonly DependencyProperty YAxisTitleProperty =
			DependencyProperty.RegisterAttached("YAxisTitle",
												typeof(string),
												typeof(ChartHelper),
												null);

		/// <summary>
		/// Gets the Y axis title.
		/// </summary>
		/// <param name="d">The chart object upon which this helper acts.</param>
		/// <returns></returns>
		public static string GetYAxisTitle(DependencyObject d)
		{
			return (string)d.GetValue(YAxisTitleProperty);
		}

		/// <summary>
		/// Sets the Y axis title.
		/// </summary>
		/// <param name="d">The chart object upon which this helper acts.</param>
		/// <param name="value">The value.</param>
		public static void SetYAxisTitle(DependencyObject d, string value)
		{
			d.SetValue(YAxisTitleProperty, value);
		}

		#endregion


		#region YAxisMinimum

		/// <summary>
		/// Represents the Y Axis Minimum binding (which DataContext property should be bound to Y Axis Minimum value)
		/// </summary>
		public static readonly DependencyProperty YAxisMinimumProperty =
		DependencyProperty.RegisterAttached("YAxisMinimum",
										typeof(string),
										typeof(ChartHelper),
										null);

		/// <summary>
		/// Gets the Y axis minimum.
		/// </summary>
		/// <param name="d">The chart object upon which this helper acts.</param>
		/// <returns></returns>
		public static string GetYAxisMinimum(DependencyObject d)
		{
			return (string)d.GetValue(YAxisMinimumProperty);
		}

		/// <summary>
		/// Sets the Y axis minimum.
		/// </summary>
		/// <param name="d">The chart object upon which this helper acts.</param>
		/// <param name="value">The value.</param>
		public static void SetYAxisMinimum(DependencyObject d, string value)
		{
			d.SetValue(YAxisMinimumProperty, value);
		}

		#region YAxisMaximum

		/// <summary>
		/// Represents the Y Axis Maximum binding (which DataContext property should be bound to Y Axis Maximum value)
		/// </summary>
		public static readonly DependencyProperty YAxisMaximumProperty =
		DependencyProperty.RegisterAttached("YAxisMaximum",
										typeof(string),
										typeof(ChartHelper),
										null);

		/// <summary>
		/// Gets the Y axis maximum.
		/// </summary>
		/// <param name="d">The chart object upon which this helper acts.</param>
		/// <returns></returns>
		public static string GetYAxisMaximum(DependencyObject d)
		{
			return (string)d.GetValue(YAxisMaximumProperty);
		}

		/// <summary>
		/// Sets the Y axis maximum.
		/// </summary>
		/// <param name="d">The chart object upon which this helper acts.</param>
		/// <param name="value">The value.</param>
		public static void SetYAxisMaximum(DependencyObject d, string value)
		{
			d.SetValue(YAxisMaximumProperty, value);
		}

		#endregion

		#endregion

		#region SeriesType

		/// <summary>
		/// Represents the data binding for the Series Type.  See the <see cref="SeriesType"/> enum for acceptable values.
		/// </summary>
		public static readonly DependencyProperty SeriesTypeProperty =
			DependencyProperty.RegisterAttached("SeriesType",
												typeof(SeriesType),
												typeof(ChartHelper),
												new PropertyMetadata(SeriesType.Bar, SeriesSourceChanged));

		/// <summary>
		/// Gets the type of the series.
		/// </summary>
		/// <param name="d">The chart object upon which this helper acts.</param>
		/// <returns></returns>
		public static SeriesType GetSeriesType(DependencyObject d)
		{
			return (SeriesType)d.GetValue(SeriesTypeProperty);
		}

		/// <summary>
		/// Sets the type of the series.
		/// </summary>
		/// <param name="d">The chart object upon which this helper acts.</param>
		/// <param name="value">The value.</param>
		public static void SetSeriesType(DependencyObject d, SeriesType value)
		{
			d.SetValue(SeriesTypeProperty, value);
		}

		#endregion

		#region SeriesStyle

		/// <summary>
		/// Represents the data binding for the Series Style.
		/// </summary>
		public static readonly DependencyProperty SeriesStyleProperty =
			DependencyProperty.RegisterAttached("SeriesStyle",
												typeof(Style),
												typeof(ChartHelper),
												null);

		/// <summary>
		/// Gets the series style.
		/// </summary>
		/// <param name="d">The chart object upon which this helper acts.</param>
		/// <returns></returns>
		public static Style GetSeriesStyle(DependencyObject d)
		{
			return (Style)d.GetValue(SeriesStyleProperty);
		}

		/// <summary>
		/// Sets the series style.
		/// </summary>
		/// <param name="d">The chart object upon which this helper acts.</param>
		/// <param name="value">The value.</param>
		public static void SetSeriesStyle(DependencyObject d, Style value)
		{
			d.SetValue(SeriesStyleProperty, value);
		}

		#endregion

		/// <summary>
		/// An event handler that is fired when the Series Source or other relavent values change.
		/// </summary>
		/// <param name="d">The chart object upon which this helper acts.</param>
		/// <param name="e">The <see cref="System.Windows.DependencyPropertyChangedEventArgs"/> instance containing the event data.</param>
		private static void SeriesSourceChanged(DependencyObject d,
												DependencyPropertyChangedEventArgs e)
		{
			if (!(d is Chart))
			{
				throw new Exception("Series attached property only works on a Chart type");
			}

			var chart = d as Chart;

			/* Clear out any old series in the chart */
			chart.Series.Clear();

			/* Get our collection of data we need for each series */
			var chartSeriesSource = e.NewValue as IEnumerable;

			if (chartSeriesSource == null)
			{
				if (chart.DataContext == null)
				{
					return;
				}
				chartSeriesSource = GetSeriesSource(d);
			}
			if (chartSeriesSource == null)
			{
				return;
			}

			/* Loop over each collection of data */
			foreach (var dataSource in chartSeriesSource)
			{
				DataPointSeries series;

				/* Find out what type of series we want to use */
				var seriesType = GetSeriesType(chart);

				switch (seriesType)
				{
					case SeriesType.Line:
						series = new LineSeries();
						break;
					case SeriesType.Bar:
						series = new BarSeries();
						break;
					case SeriesType.Column:
						series = new ColumnSeries();
						break;
					case SeriesType.Pie:
						series = new PieSeries();
						break;
					case SeriesType.Scatter:
						series = new ScatterSeries();
						break;
					case SeriesType.Area:
						series = new AreaSeries();
						break;
					case SeriesType.Bubble:
						series = new BubbleSeries();
						break;
					default:
						throw new ArgumentOutOfRangeException();
				}

				/* Get and set the style of the newly created series */
				var seriesStyle = GetSeriesStyle(chart);
				series.Style = seriesStyle;

				string titleBindingName = GetTitle(chart);

				if (!string.IsNullOrEmpty(titleBindingName))
				{
					/* Do some binding of the Title property */
					var titleBinding = new Binding(titleBindingName)
					{
						Source = series.Title,
						Mode = BindingMode.TwoWay
					};

					series.SetBinding(Series.TitleProperty, titleBinding);
					series.DataContext = dataSource;
				}

				/* Setup the bindings configured in the attached properties */
				series.DependentValueBinding = new Binding(GetDependentValueBinding(chart));
				series.IndependentValueBinding = new Binding(GetIndependentValueBinding(chart));

				/*Set the ItemsSource property, which gives the data to the series to be rendered */
				series.ItemsSource = dataSource as IEnumerable;
				/* Add the series to the chart */
				chart.Series.Add(series);
			}
			// NOTE: In order to change the Title, Maximum, and Minimum properties of the axes, you must handle the Axes_CollectionChanged event.
			// However, you only want this event to fire once, so we always remove our handler here, and then re-add it to make sure we don't have
			// an ever-increasing number of calls to Axes_CollectionChanged
			((ISeriesHost)chart).Axes.CollectionChanged -= new NotifyCollectionChangedEventHandler(Axes_CollectionChanged);
			((ISeriesHost)chart).Axes.CollectionChanged +=new NotifyCollectionChangedEventHandler(Axes_CollectionChanged);
		}

		/// <summary>
		/// Handles the CollectionChanged event of the Axes control.  Here, X and Y axis titles and min/max properties are set once the graph creates or assigns the axes we need.
		/// </summary>
		/// <param name="sender">The source of the event.</param>
		/// <param name="ccEventArgs">The <see cref="System.Collections.Specialized.NotifyCollectionChangedEventArgs"/> instance containing the event data.</param>
		static void Axes_CollectionChanged(object sender, NotifyCollectionChangedEventArgs ccEventArgs)
		{
			if (ccEventArgs.Action != NotifyCollectionChangedAction.Remove)
			{
				Chart chart = null;
				foreach (DisplayAxis axis in ccEventArgs.NewItems)
				{
					chart = (Chart)axis.SeriesHost;
					if ((axis.Orientation == AxisOrientation.X && GetSeriesType(chart)!=SeriesType.Bar) || (axis.Orientation == AxisOrientation.Y && GetSeriesType(chart)==SeriesType.Bar))
					{
						axis.SetBinding(DisplayAxis.TitleProperty, new Binding(GetXAxisTitle(chart)));
						if (axis is LinearAxis)
						{
							axis.SetBinding(LinearAxis.MinimumProperty, new Binding(GetXAxisMinimum(chart)));
							axis.SetBinding(LinearAxis.MaximumProperty, new Binding(GetXAxisMaximum(chart)));
						}
						else if (axis is DateTimeAxis)
						{
							axis.SetBinding(DateTimeAxis.MinimumProperty, new Binding(GetXAxisMinimum(chart)));
							axis.SetBinding(DateTimeAxis.MaximumProperty, new Binding(GetXAxisMaximum(chart)));
						}
					}
					else
					{
						axis.SetBinding(DisplayAxis.TitleProperty, new Binding(GetYAxisTitle(chart)));
						if (axis is LinearAxis)
						{
							axis.SetBinding(LinearAxis.MinimumProperty, new Binding(GetYAxisMinimum(chart)));
							axis.SetBinding(LinearAxis.MaximumProperty, new Binding(GetYAxisMaximum(chart)));
						}
						else if (axis is DateTimeAxis)
						{
							axis.SetBinding(DateTimeAxis.MinimumProperty, new Binding(GetYAxisMinimum(chart)));
							axis.SetBinding(DateTimeAxis.MaximumProperty, new Binding(GetYAxisMaximum(chart)));
						}
					}
				}
			}	
		}
	}
}