using System;
using System.Collections.ObjectModel;
using System.Collections.Specialized;
using System.ComponentModel;
using System.Diagnostics;
using System.Diagnostics.CodeAnalysis;
using System.Windows;
using System.Windows.Data;
using Microsoft.Research.DynamicDataDisplay.Common.Auxiliary;
using Microsoft.Research.DynamicDataDisplay.ViewportConstraints;
using Microsoft.Research.DynamicDataDisplay.Common;
using System.Windows.Threading;

namespace Microsoft.Research.DynamicDataDisplay
{
	/// <summary>
	/// Viewport2D provides virtual coordinates.
	/// </summary>
	public partial class Viewport2D : DependencyObject
	{
		private DispatcherOperation updateVisibleOperation = null;
		private int updateVisibleCounter = 0;
		private readonly RingDictionary<DataRect> prevVisibles = new RingDictionary<DataRect>(2);
		private bool fromContentBounds = false;
		private readonly DispatcherPriority invocationPriority = DispatcherPriority.Send;

		public const string VisiblePropertyName = "Visible";

		public bool FromContentBounds
		{
			get { return fromContentBounds; }
			set { fromContentBounds = value; }
		}

		private readonly Plotter2D plotter;
		internal Plotter2D Plotter2D
		{
			get { return plotter; }
		}

		private readonly FrameworkElement hostElement;
		internal FrameworkElement HostElement
		{
			get { return hostElement; }
		}

		protected internal Viewport2D(FrameworkElement host, Plotter2D plotter)
		{
			hostElement = host;
			host.ClipToBounds = true;
			host.SizeChanged += OnHostElementSizeChanged;

			this.plotter = plotter;
			plotter.Children.CollectionChanged += OnPlotterChildrenChanged;

			constraints = new ConstraintCollection(this);
			constraints.Add(new MinimalSizeConstraint());
			constraints.CollectionChanged += constraints_CollectionChanged;

			fitToViewConstraints = new ConstraintCollection(this);
			fitToViewConstraints.CollectionChanged += fitToViewConstraints_CollectionChanged;

			readonlyContentBoundsHosts = new ReadOnlyObservableCollection<DependencyObject>(contentBoundsHosts);

			UpdateVisible();
			UpdateTransform();
		}

		private void OnHostElementSizeChanged(object sender, SizeChangedEventArgs e)
		{
			SetValue(OutputPropertyKey, new Rect(e.NewSize));
			CoerceValue(VisibleProperty);
		}

		private void fitToViewConstraints_CollectionChanged(object sender, NotifyCollectionChangedEventArgs e)
		{
			if (IsFittedToView)
			{
				CoerceValue(VisibleProperty);
			}
		}

		private void constraints_CollectionChanged(object sender, NotifyCollectionChangedEventArgs e)
		{
			CoerceValue(VisibleProperty);
		}

		private static void OnPropertyChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
		{
			Viewport2D viewport = (Viewport2D)d;
			viewport.UpdateTransform();
			viewport.RaisePropertyChangedEvent(e);
		}

		public BindingExpressionBase SetBinding(DependencyProperty property, BindingBase binding)
		{
			return BindingOperations.SetBinding(this, property, binding);
		}

		/// <summary>
		/// Forces viewport to go to fit to view mode - clears locally set value of <see cref="Visible"/> property
		/// and sets it during the coercion process to a value of united content bounds of all charts inside of <see cref="Plotter"/>.
		/// </summary>
		public void FitToView()
		{
			if (!IsFittedToView)
			{
				ClearValue(VisibleProperty);
				CoerceValue(VisibleProperty);
				FittedToView.Raise(this);
			}
		}

		public event EventHandler FittedToView;

		/// <summary>
		/// Gets a value indicating whether Viewport is fitted to view.
		/// </summary>
		/// <value>
		/// 	<c>true</c> if Viewport is fitted to view; otherwise, <c>false</c>.
		/// </value>
		[DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
		public bool IsFittedToView
		{
			get { return ReadLocalValue(VisibleProperty) == DependencyProperty.UnsetValue; }
		}

		internal void UpdateVisible()
		{
			if (updateVisibleCounter == 0)
			{
				UpdateVisibleBody();
			}
			else if (updateVisibleOperation == null)
			{
				updateVisibleOperation = Dispatcher.BeginInvoke(() => UpdateVisibleBody(), invocationPriority);
				return;
			}
			else if (updateVisibleOperation.Status == DispatcherOperationStatus.Pending)
			{
				updateVisibleOperation.Abort();
				updateVisibleOperation = Dispatcher.BeginInvoke(() => UpdateVisibleBody(), invocationPriority);
			}
		}

		private void UpdateVisibleBody()
		{
			if (updateVisibleCounter > 0)
				return;

			updateVisibleCounter++;
			if (IsFittedToView)
			{
				CoerceValue(VisibleProperty);
			}
			updateVisibleOperation = null;
			updateVisibleCounter--;
		}

		[DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
		[EditorBrowsable(EditorBrowsableState.Never)]
		public Plotter2D Plotter
		{
			get { return plotter; }
		}

		private readonly ConstraintCollection constraints;
		/// <summary>
		/// Gets the collection of <see cref="ViewportConstraint"/>s that are applied each time <see cref="Visible"/> is updated.
		/// </summary>
		/// <value>The constraints.</value>
		[DesignerSerializationVisibility(DesignerSerializationVisibility.Content)]
		public ConstraintCollection Constraints
		{
			get { return constraints; }
		}


		private readonly ConstraintCollection fitToViewConstraints;

		/// <summary>
		/// Gets the collection of <see cref="ViewportConstraint"/>s that are applied only when Viewport is fitted to view.
		/// </summary>
		/// <value>The fit to view constraints.</value>
		[DesignerSerializationVisibility(DesignerSerializationVisibility.Content)]
		public ConstraintCollection FitToViewConstraints
		{
			get { return fitToViewConstraints; }
		}

		#region Output property

		/// <summary>
		/// Gets the rectangle in screen coordinates that is output.
		/// </summary>
		/// <value>The output.</value>
		public Rect Output
		{
			get { return (Rect)GetValue(OutputProperty); }
		}

		[SuppressMessage("Microsoft.Security", "CA2104:DoNotDeclareReadOnlyMutableReferenceTypes")]
		private static readonly DependencyPropertyKey OutputPropertyKey = DependencyProperty.RegisterReadOnly(
			"Output",
			typeof(Rect),
			typeof(Viewport2D),
			new FrameworkPropertyMetadata(new Rect(0, 0, 1, 1), OnPropertyChanged));

		/// <summary>
		/// Identifies the <see cref="Output"/> dependency property.
		/// </summary>
		public static readonly DependencyProperty OutputProperty = OutputPropertyKey.DependencyProperty;

		#endregion

		#region UnitedContentBounds property

		/// <summary>
		/// Gets the united content bounds of all the charts.
		/// </summary>
		/// <value>The content bounds.</value>
		public DataRect UnitedContentBounds
		{
			get { return (DataRect)GetValue(UnitedContentBoundsProperty); }
			internal set { SetValue(UnitedContentBoundsProperty, value); }
		}

		/// <summary>
		/// Identifies the <see cref="UnitedContentBounds"/> dependency property.
		/// </summary>
		public static readonly DependencyProperty UnitedContentBoundsProperty = DependencyProperty.Register(
		  "UnitedContentBounds",
		  typeof(DataRect),
		  typeof(Viewport2D),
		  new FrameworkPropertyMetadata(DataRect.Empty, OnUnitedContentBoundsChanged));

		private static void OnUnitedContentBoundsChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
		{
			Viewport2D owner = (Viewport2D)d;
			owner.ContentBoundsChanged.Raise(owner);
		}

		public event EventHandler ContentBoundsChanged;

		#endregion

		#region Visible property

		/// <summary>
		/// Gets or sets the visible rectangle.
		/// </summary>
		/// <value>The visible.</value>
		public DataRect Visible
		{
			get { return (DataRect)GetValue(VisibleProperty); }
			set { SetValue(VisibleProperty, value); }
		}

		/// <summary>
		/// Identifies the <see cref="Visible"/> dependency property.
		/// </summary>
		public static readonly DependencyProperty VisibleProperty =
			DependencyProperty.Register("Visible", typeof(DataRect), typeof(Viewport2D),
			new FrameworkPropertyMetadata(
				new DataRect(0, 0, 1, 1),
				OnPropertyChanged,
				OnCoerceVisible),
			ValidateVisibleCallback);

		private static bool ValidateVisibleCallback(object value)
		{
			DataRect rect = (DataRect)value;

			return !rect.IsNaN();
		}

		private void UpdateContentBoundsHosts()
		{
			contentBoundsHosts.Clear();
			foreach (var item in plotter.Children)
			{
				DependencyObject dependencyObject = item as DependencyObject;
				if (dependencyObject != null)
				{
					bool hasNonEmptyBounds = !Viewport2D.GetContentBounds(dependencyObject).IsEmpty;
					if (hasNonEmptyBounds && Viewport2D.GetIsContentBoundsHost(dependencyObject))
					{
						contentBoundsHosts.Add(dependencyObject);
					}
				}
			}

			bool prevFromContentBounds = FromContentBounds;
			FromContentBounds = true;
			UpdateVisible();
			FromContentBounds = prevFromContentBounds;
		}

		private readonly ObservableCollection<DependencyObject> contentBoundsHosts = new ObservableCollection<DependencyObject>();
		private readonly ReadOnlyObservableCollection<DependencyObject> readonlyContentBoundsHosts;
		/// <summary>
		/// Gets the collection of all charts that can has its own content bounds.
		/// </summary>
		/// <value>The content bounds hosts.</value>
		[DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
		public ReadOnlyObservableCollection<DependencyObject> ContentBoundsHosts
		{
			get { return readonlyContentBoundsHosts; }
		}

		private bool useApproximateContentBoundsComparison = true;
		/// <summary>
		/// Gets or sets a value indicating whether to use approximate content bounds comparison.
		/// This this property to true can increase performance, as Visible will change less often.
		/// </summary>
		/// <value>
		/// 	<c>true</c> if approximate content bounds comparison is used; otherwise, <c>false</c>.
		/// </value>
		public bool UseApproximateContentBoundsComparison
		{
			get { return useApproximateContentBoundsComparison; }
			set { useApproximateContentBoundsComparison = value; }
		}

		private double maxContentBoundsComparisonMistake = 0.02;
		public double MaxContentBoundsComparisonMistake
		{
			get { return maxContentBoundsComparisonMistake; }
			set { maxContentBoundsComparisonMistake = value; }
		}

		private DataRect prevContentBounds = DataRect.Empty;
		protected virtual DataRect CoerceVisible(DataRect newVisible)
		{
			if (Plotter == null)
			{
				return newVisible;
			}

			bool isDefaultValue = newVisible == (DataRect)VisibleProperty.DefaultMetadata.DefaultValue;
			if (isDefaultValue)
			{
				newVisible = DataRect.Empty;
			}

			if (isDefaultValue && IsFittedToView)
			{
				// determining content bounds
				DataRect bounds = DataRect.Empty;

				foreach (var item in contentBoundsHosts)
				{
					IPlotterElement plotterElement = item as IPlotterElement;
					if (plotterElement == null)
						continue;
					if (plotterElement.Plotter == null)
						continue;

					DataRect contentBounds = Viewport2D.GetContentBounds(item);
					if (contentBounds.Width.IsNaN() || contentBounds.Height.IsNaN())
						continue;

					bounds.UnionFinite(contentBounds);
				}

				if (useApproximateContentBoundsComparison)
				{
					var intersection = prevContentBounds;
					intersection.Intersect(bounds);

					double currSquare = bounds.GetSquare();
					double prevSquare = prevContentBounds.GetSquare();
					double intersectionSquare = intersection.GetSquare();

					double squareTopLimit = 1 + maxContentBoundsComparisonMistake;
					double squareBottomLimit = 1 - maxContentBoundsComparisonMistake;

					if (intersectionSquare != 0)
					{
						double currRatio = currSquare / intersectionSquare;
						double prevRatio = prevSquare / intersectionSquare;

						if (squareBottomLimit < currRatio &&
							currRatio < squareTopLimit &&
							squareBottomLimit < prevRatio &&
							prevRatio < squareTopLimit)
						{
							bounds = prevContentBounds;
						}
					}
				}

				prevContentBounds = bounds;
				UnitedContentBounds = bounds;

				// applying fit-to-view constraints
				bounds = fitToViewConstraints.Apply(Visible, bounds, this);

				// enlarging
				if (!bounds.IsEmpty)
				{
					bounds = CoordinateUtilities.RectZoom(bounds, bounds.GetCenter(), clipToBoundsEnlargeFactor);
				}
				else
				{
					bounds = (DataRect)VisibleProperty.DefaultMetadata.DefaultValue;
				}
				newVisible.Union(bounds);
			}

			if (newVisible.IsEmpty)
			{
				newVisible = (DataRect)VisibleProperty.DefaultMetadata.DefaultValue;
			}
			else if (newVisible.Width == 0 || newVisible.Height == 0 || newVisible.IsEmptyX || newVisible.IsEmptyY)
			{
				DataRect defRect = (DataRect)VisibleProperty.DefaultMetadata.DefaultValue;
				Size size = newVisible.Size;
				Point location = newVisible.Location;

				if (newVisible.Width == 0 || newVisible.IsEmptyX)
				{
					size.Width = defRect.Width;
					location.X -= size.Width / 2;
				}
				if (newVisible.Height == 0 || newVisible.IsEmptyY)
				{
					size.Height = defRect.Height;
					location.Y -= size.Height / 2;
				}

				newVisible = new DataRect(location, size);
			}

			// apply domain constraint
			newVisible = domainConstraint.Apply(Visible, newVisible, this);

			// apply other restrictions
			newVisible = constraints.Apply(Visible, newVisible, this);

			// applying transform's data domain constraint
			if (!transform.DataTransform.DataDomain.IsEmpty)
			{
				var newDataRect = newVisible.ViewportToData(transform);
				newDataRect = DataRect.Intersect(newDataRect, transform.DataTransform.DataDomain);
				newVisible = newDataRect.DataToViewport(transform);
			}

			if (newVisible.IsEmpty)
				newVisible = new Rect(0, 0, 1, 1);

			return newVisible;
		}

		private static object OnCoerceVisible(DependencyObject d, object newValue)
		{
			Viewport2D viewport = (Viewport2D)d;
			DataRect newVisible = (DataRect)newValue;

			DataRect newRect = viewport.CoerceVisible(newVisible);

			if (viewport.FromContentBounds && viewport.prevVisibles.ContainsValue(newRect))
				return DependencyProperty.UnsetValue;
			else
				viewport.prevVisibles.AddValue(newRect);

			if (newRect.Width == 0 || newRect.Height == 0)
			{
				// doesn't apply rects with zero square
				return DependencyProperty.UnsetValue;
			}
			else
			{
				return newRect;
			}
		}

		#endregion

		#region Domain

		private readonly DomainConstraint domainConstraint = new DomainConstraint { Domain = Rect.Empty };

		/// <summary>
		/// Gets or sets the domain - rectangle in viewport coordinates that limits maximal size of <see cref="Visible"/> rectangle.
		/// </summary>
		/// <value>The domain.</value>
		public DataRect Domain
		{
			get { return (DataRect)GetValue(DomainProperty); }
			set { SetValue(DomainProperty, value); }
		}

		public static readonly DependencyProperty DomainProperty = DependencyProperty.Register(
		  "Domain",
		  typeof(DataRect),
		  typeof(Viewport2D),
		  new FrameworkPropertyMetadata(DataRect.Empty, OnDomainReplaced));

		private static void OnDomainReplaced(DependencyObject d, DependencyPropertyChangedEventArgs e)
		{
			Viewport2D owner = (Viewport2D)d;
			owner.OnDomainChanged();
		}

		private void OnDomainChanged()
		{
			domainConstraint.Domain = Domain;
			DomainChanged.Raise(this);
			CoerceValue(VisibleProperty);
		}

		/// <summary>
		/// Occurs when <see cref="Domain"/> property changes.
		/// </summary>
		public event EventHandler DomainChanged;

		#endregion

		private double clipToBoundsEnlargeFactor = 1.10;
		/// <summary>
		/// Gets or sets the viewport enlarge factor.
		/// </summary>
		/// <remarks>
		/// Default value is 1.10.
		/// </remarks>
		/// <value>The clip to bounds factor.</value>
		public double ClipToBoundsEnlargeFactor
		{
			get { return clipToBoundsEnlargeFactor; }
			set
			{
				if (clipToBoundsEnlargeFactor != value)
				{
					clipToBoundsEnlargeFactor = value;
					UpdateVisible();
				}
			}
		}

		private void UpdateTransform()
		{
			transform = transform.WithRects(Visible, Output);
		}

		private CoordinateTransform transform = CoordinateTransform.CreateDefault();
		/// <summary>
		/// Gets or sets the coordinate transform of Viewport.
		/// </summary>
		/// <value>The transform.</value>
		[DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
		[NotNull]
		public virtual CoordinateTransform Transform
		{
			get { return transform; }
			set
			{
				value.VerifyNotNull();

				if (value != transform)
				{
					var oldTransform = transform;

					transform = value;

					RaisePropertyChangedEvent("Transform", oldTransform, transform);
				}
			}
		}

		/// <summary>
		/// Occurs when viewport property changes.
		/// </summary>
		public event EventHandler<ExtendedPropertyChangedEventArgs> PropertyChanged;

		private void RaisePropertyChangedEvent(string propertyName, object oldValue, object newValue)
		{
			if (PropertyChanged != null)
			{
				RaisePropertyChanged(new ExtendedPropertyChangedEventArgs { PropertyName = propertyName, OldValue = oldValue, NewValue = newValue });
			}
		}

		private void RaisePropertyChangedEvent(string propertyName)
		{
			if (PropertyChanged != null)
			{
				RaisePropertyChanged(new ExtendedPropertyChangedEventArgs { PropertyName = propertyName });
			}
		}

		/// <summary>
		/// Gets or sets the type of viewport change.
		/// </summary>
		/// <value>The type of the change.</value>
		public ChangeType ChangeType { get; internal set; }

		/// <summary>
		/// Sets the type of viewport change.
		/// </summary>
		/// <param name="changeType">Type of the change.</param>
		public void SetChangeType(ChangeType changeType = ChangeType.None)
		{
			this.ChangeType = changeType;
		}

		int propertyChangedCounter = 0;
		private DispatcherOperation notifyOperation = null;
		private void RaisePropertyChangedEvent(DependencyPropertyChangedEventArgs e)
		{
			if (notifyOperation == null)
			{
				ChangeType changeType = ChangeType;
				notifyOperation = Dispatcher.BeginInvoke(() =>
				{
					RaisePropertyChangedEventBody(e, changeType);
				}, invocationPriority);
				return;
			}
			else if (notifyOperation.Status == DispatcherOperationStatus.Pending)
			{
				notifyOperation.Abort();
				ChangeType changeType = ChangeType;
				notifyOperation = Dispatcher.BeginInvoke(() =>
				{
					RaisePropertyChangedEventBody(e, changeType);
				}, invocationPriority);
			}
		}

		private void RaisePropertyChangedEventBody(DependencyPropertyChangedEventArgs e, ChangeType changeType)
		{
			if (propertyChangedCounter > 0)
				return;

			propertyChangedCounter++;
			RaisePropertyChanged(ExtendedPropertyChangedEventArgs.FromDependencyPropertyChanged(e), changeType);
			propertyChangedCounter--;

			notifyOperation = null;
		}

		protected virtual void RaisePropertyChanged(ExtendedPropertyChangedEventArgs args, ChangeType changeType = ChangeType.None)
		{
			args.ChangeType = changeType;
			PropertyChanged.Raise(this, args);
		}

		private void OnPlotterChildrenChanged(object sender, NotifyCollectionChangedEventArgs e)
		{
			UpdateContentBoundsHosts();
		}

		#region Panning state

		private Viewport2DPanningState panningState = Viewport2DPanningState.NotPanning;
		public Viewport2DPanningState PanningState
		{
			get { return panningState; }
			set
			{
				var prevState = panningState;

				panningState = value;

				OnPanningStateChanged(prevState, panningState);
			}
		}

		private void OnPanningStateChanged(Viewport2DPanningState prevState, Viewport2DPanningState currState)
		{
			PanningStateChanged.Raise(this, prevState, currState);
			if (currState == Viewport2DPanningState.Panning)
				BeginPanning.Raise(this);
			else if (currState == Viewport2DPanningState.NotPanning)
				EndPanning.Raise(this);
		}

		internal event EventHandler<ValueChangedEventArgs<Viewport2DPanningState>> PanningStateChanged;

		public event EventHandler BeginPanning;
		public event EventHandler EndPanning;

		#endregion // end of Panning state
	}

	public enum ChangeType
	{
		None = 0,
		Pan,
		PanX,
		PanY,
		Zoom,
		ZoomX,
		ZoomY
	}
}