using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Windows.Controls;
using System.Windows;
using System.Windows.Media;
using System.Diagnostics;
using Microsoft.Research.DynamicDataDisplay.Common.Auxiliary;

namespace Microsoft.Research.DynamicDataDisplay.Charts
{
	public class StackCanvas : Panel
	{
		public StackCanvas()
		{
		}

		#region EndCoordinate attached property

		[AttachedPropertyBrowsableForChildren]
		public static double GetEndCoordinate(DependencyObject obj)
		{
			return (double)obj.GetValue(EndCoordinateProperty);
		}

		public static void SetEndCoordinate(DependencyObject obj, double value)
		{
			obj.SetValue(EndCoordinateProperty, value);
		}

		public static readonly DependencyProperty EndCoordinateProperty = DependencyProperty.RegisterAttached(
			"EndCoordinate",
			typeof(double),
			typeof(StackCanvas),
			new PropertyMetadata(Double.NaN, OnCoordinateChanged));

		#endregion

		#region Coordinate attached property

		[AttachedPropertyBrowsableForChildren]
		public static double GetCoordinate(DependencyObject obj)
		{
			return (double)obj.GetValue(CoordinateProperty);
		}

		public static void SetCoordinate(DependencyObject obj, double value)
		{
			obj.SetValue(CoordinateProperty, value);
		}

		public static readonly DependencyProperty CoordinateProperty = DependencyProperty.RegisterAttached(
			"Coordinate",
			typeof(double),
			typeof(StackCanvas),
			new PropertyMetadata(0.0, OnCoordinateChanged));

		private static void OnCoordinateChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
		{
			UIElement reference = d as UIElement;
			if (reference != null)
			{
				StackCanvas parent = VisualTreeHelper.GetParent(reference) as StackCanvas;
				if (parent != null)
				{
					parent.InvalidateArrange();
				}
			}
		}
		#endregion

		#region AxisPlacement property

		public AxisPlacement Placement
		{
			get { return (AxisPlacement)GetValue(PlacementProperty); }
			set { SetValue(PlacementProperty, value); }
		}

		public static readonly DependencyProperty PlacementProperty =
			DependencyProperty.Register(
			  "Placement",
			  typeof(AxisPlacement),
			  typeof(StackCanvas),
			  new FrameworkPropertyMetadata(
				  AxisPlacement.Bottom,
				  FrameworkPropertyMetadataOptions.AffectsArrange));

		#endregion

		private bool IsHorizontal
		{
			get { return Placement == AxisPlacement.Top || Placement == AxisPlacement.Bottom; }
		}

		protected override Size MeasureOverride(Size constraint)
		{
			Size availableSize = constraint;
			Size size = new Size();

			bool isHorizontal = IsHorizontal;

			if (isHorizontal)
			{
				availableSize.Width = Double.PositiveInfinity;
				size.Width = constraint.Width;
			}
			else
			{
				availableSize.Height = Double.PositiveInfinity;
				size.Height = constraint.Height;
			}

			// measuring all children and determining self width and height
			foreach (UIElement element in base.Children)
			{
				if (element != null)
				{
					Size childSize = GetChildSize(element, availableSize);
					element.Measure(childSize);
					Size desiredSize = element.DesiredSize;

					if (isHorizontal)
					{
						size.Height = Math.Max(size.Height, desiredSize.Height);
					}
					else
					{
						size.Width = Math.Max(size.Width, desiredSize.Width);
					}
				}
			}

			if (Double.IsPositiveInfinity(size.Width)) size.Width = 0;
			if (Double.IsPositiveInfinity(size.Height)) size.Height = 0;

			return size;
		}

		private Size GetChildSize(UIElement element, Size availableSize)
		{
			var coordinate = GetCoordinate(element);
			var endCoordinate = GetEndCoordinate(element);

			if (coordinate.IsNotNaN() && endCoordinate.IsNotNaN())
			{
				if (Placement.IsBottomOrTop())
				{
					availableSize.Width = Math.Abs(endCoordinate - coordinate);
				}
				else
				{
					availableSize.Height = Math.Abs(endCoordinate - coordinate);
				}
			}

			return availableSize;
		}

		protected override Size ArrangeOverride(Size finalSize)
		{
			bool isHorizontal = IsHorizontal;

			foreach (FrameworkElement element in base.Children)
			{
				if (element == null)
				{
					continue;
				}

				Size elementSize = element.DesiredSize;
				double x = 0.0;
				double y = 0.0;

				switch (Placement)
				{
					case AxisPlacement.Left:
						x = finalSize.Width - elementSize.Width;
						break;
					case AxisPlacement.Right:
						x = 0;
						break;
					case AxisPlacement.Top:
						y = finalSize.Height - elementSize.Height;
						break;
					case AxisPlacement.Bottom:
						y = 0;
						break;
					default:
						break;
				}

				double coordinate = GetCoordinate(element);

				if (!Double.IsNaN(GetEndCoordinate(element)))
				{
					double endCoordinate = GetEndCoordinate(element);
					double size = endCoordinate - coordinate;
					if (size < 0)
					{
						size = -size;
						coordinate -= size;
					}
					if (isHorizontal)
						elementSize.Width = size;
					else
						elementSize.Height = size;
				}


				// shift for common tick labels, not for major ones.
				if (isHorizontal)
				{
					x = coordinate;
					if (element.HorizontalAlignment == HorizontalAlignment.Center)
						x = coordinate - elementSize.Width / 2;
				}
				else
				{
					y = coordinate;
					if (element.VerticalAlignment == VerticalAlignment.Center)
						y = coordinate - elementSize.Height / 2;
					else if (element.VerticalAlignment == VerticalAlignment.Bottom)
						y = coordinate - elementSize.Height;
					else if (element.VerticalAlignment == VerticalAlignment.Top)
						y = coordinate;
				}

				Rect bounds = new Rect(new Point(x, y), elementSize);
				element.Arrange(bounds);
			}

			return finalSize;
		}
	}
}