using System;

using System.Windows;

using Microsoft.Research.DynamicDataDisplay.DataSources;

using System.Collections.Generic;

using System.Collections.ObjectModel;

using Microsoft.Research.DynamicDataDisplay.Common;

using Microsoft.Research.DynamicDataDisplay.Charts;



namespace Microsoft.Research.DynamicDataDisplay

{

	public abstract class PointsGraphBase : ViewportElement2D, IOneDimensionalChart

	{

		/// <summary>

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

		/// </summary>

		protected PointsGraphBase()

		{

			Viewport2D.SetIsContentBoundsHost(this, true);

		}



		#region DataSource



		public IPointDataSource DataSource

		{

			get { return (IPointDataSource)GetValue(DataSourceProperty); }

			set { SetValue(DataSourceProperty, value); }

		}



		public static readonly DependencyProperty DataSourceProperty =

			DependencyProperty.Register(

			  "DataSource",

			  typeof(IPointDataSource),

			  typeof(PointsGraphBase),

			  new FrameworkPropertyMetadata

			  {

				  AffectsRender = true,

				  DefaultValue = null,

				  PropertyChangedCallback = OnDataSourceChangedCallback

			  }

			);



		private static void OnDataSourceChangedCallback(DependencyObject d, DependencyPropertyChangedEventArgs e)

		{

			PointsGraphBase graph = (PointsGraphBase)d;

			if (e.NewValue != e.OldValue)

			{

				graph.DetachDataSource(e.OldValue as IPointDataSource);

				graph.AttachDataSource(e.NewValue as IPointDataSource);

			}

			graph.OnDataSourceChanged(e);

		}



		private void AttachDataSource(IPointDataSource source)

		{

			if (source != null)

			{

				source.DataChanged += OnDataChanged;

			}

		}



		private void DetachDataSource(IPointDataSource source)

		{

			if (source != null)

			{

				source.DataChanged -= OnDataChanged;

			}

		}



		private void OnDataChanged(object sender, EventArgs e)

		{

			OnDataChanged();

		}



		protected virtual void OnDataChanged()

		{

			UpdateBounds(DataSource);



			RaiseDataChanged();

			Update();

		}



		private void RaiseDataChanged()

		{

			if (DataChanged != null)

			{

				DataChanged(this, EventArgs.Empty);

			}

		}

		public event EventHandler DataChanged;



		protected virtual void OnDataSourceChanged(DependencyPropertyChangedEventArgs args)

		{

			IPointDataSource newDataSource = (IPointDataSource)args.NewValue;

			if (newDataSource != null)

			{

				UpdateBounds(newDataSource);

			}



			Update();

		}



		private void UpdateBounds(IPointDataSource dataSource)

		{

			if (Plotter2D != null)

			{

				var transform = GetTransform();

				DataRect bounds = BoundsHelper.GetViewportBounds(dataSource.GetPoints(), transform.DataTransform);

				Viewport2D.SetContentBounds(this, bounds);

			}

		}



		#endregion



		#region DataTransform



		private DataTransform dataTransform = null;

		public DataTransform DataTransform

		{

			get { return dataTransform; }

			set

			{

				if (dataTransform != value)

				{

					dataTransform = value;

					Update();

				}

			}

		}



		protected CoordinateTransform GetTransform()

		{

			if (Plotter == null)

				return null;



			var transform = Plotter2D.Viewport.Transform;

			if (dataTransform != null)

				transform = transform.WithDataTransform(dataTransform);



			return transform;

		}



		#endregion



		#region VisiblePoints



		public ReadOnlyCollection<Point> VisiblePoints

		{

			get { return GetVisiblePoints(this); }

			protected set { SetVisiblePoints(this, value); }

		}



		public static ReadOnlyCollection<Point> GetVisiblePoints(DependencyObject obj)

		{

			return (ReadOnlyCollection<Point>)obj.GetValue(VisiblePointsProperty);

		}



		public static void SetVisiblePoints(DependencyObject obj, ReadOnlyCollection<Point> value)

		{

			obj.SetValue(VisiblePointsProperty, value);

		}



		public static readonly DependencyProperty VisiblePointsProperty = DependencyProperty.RegisterAttached(

		  "VisiblePoints",

		  typeof(ReadOnlyCollection<Point>),

		  typeof(PointsGraphBase),

		  new FrameworkPropertyMetadata(null, OnVisiblePointsChanged));



		private static void OnVisiblePointsChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)

		{

			PointsGraphBase graph = d as PointsGraphBase;

			if (graph != null)

			{

				graph.RaiseVisiblePointsChanged();

			}

		}



		public event EventHandler VisiblePointsChanged;

		protected void RaiseVisiblePointsChanged()

		{

			VisiblePointsChanged.Raise(this);

		}



		private bool provideVisiblePoints = false;

		public bool ProvideVisiblePoints

		{

			get { return provideVisiblePoints; }

			set

			{

				provideVisiblePoints = value;

				UpdateCore();

			}

		}



		#endregion



		protected IEnumerable<Point> GetPoints()

		{

			return DataSource.GetPoints(GetContext());

		}



		private readonly DataSource2dContext context = new DataSource2dContext();

		protected DependencyObject GetContext()

		{

			//context.VisibleRect = Plotter2D.Viewport.Visible;

			//context.ScreenRect = Plotter2D.Viewport.Output;



			return context;

		}

	}

}