using RealTimeGraphX.EventArguments;
using System;
using System.Collections;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Data;
using System.Windows.Documents;
using System.Windows.Input;
using System.Windows.Media;
using System.Windows.Media.Imaging;
using System.Windows.Navigation;
using System.Windows.Shapes;

namespace RealTimeGraphX.WPF.Components
{
    /// <summary>
    /// Represents a horizontal/vertical graph axis control.
    /// </summary>
    /// <seealso cref="RealTimeGraphX.GraphSurfaceComponentBase" />
    public class GraphAxisControl : GraphSurfaceComponentBase
    {
        private ItemsControl _items_control;

        /// <summary>
        /// Initializes the <see cref="GraphAxisControl"/> class.
        /// </summary>
        static GraphAxisControl()
        {
            DefaultStyleKeyProperty.OverrideMetadata(typeof(GraphAxisControl), new FrameworkPropertyMetadata(typeof(GraphAxisControl)));
        }

        /// <summary>
        /// Gets or sets the control orientation.
        /// </summary>
        public Orientation Orientation
        {
            get { return (Orientation)GetValue(OrientationProperty); }
            set { SetValue(OrientationProperty, value); }
        }
        public static readonly DependencyProperty OrientationProperty =
            DependencyProperty.Register("Orientation", typeof(Orientation), typeof(GraphAxisControl), new PropertyMetadata(Orientation.Vertical));

        /// <summary>
        /// Gets or sets the tick item template.
        /// </summary>
        public DataTemplate ItemTemplate
        {
            get { return (DataTemplate)GetValue(ItemTemplateProperty); }
            set { SetValue(ItemTemplateProperty, value); }
        }
        public static readonly DependencyProperty ItemTemplateProperty =
            DependencyProperty.Register("ItemTemplate", typeof(DataTemplate), typeof(GraphAxisControl), new PropertyMetadata(null));

        /// <summary>
        /// Gets or sets the tick items.
        /// </summary>
        internal ObservableCollection<GraphAxisTickData> Items
        {
            get { return (ObservableCollection<GraphAxisTickData>)GetValue(ItemsProperty); }
            set { SetValue(ItemsProperty, value); }
        }
        public static readonly DependencyProperty ItemsProperty =
            DependencyProperty.Register("Items", typeof(ObservableCollection<GraphAxisTickData>), typeof(GraphAxisControl), new PropertyMetadata(null));

        /// <summary>
        /// Gets or sets the number of ticks to display on the control.
        /// </summary>
        public int Ticks
        {
            get { return (int)GetValue(TicksProperty); }
            set { SetValue(TicksProperty, value); }
        }
        public static readonly DependencyProperty TicksProperty =
            DependencyProperty.Register("Ticks", typeof(int), typeof(GraphAxisControl), new PropertyMetadata(9, (d, e) => (d as GraphAxisControl).OnTicksChanged()));

        /// <summary>
        /// Gets or sets the string format which is used to format the ticks value.
        /// </summary>
        public String StringFormat
        {
            get { return (String)GetValue(StringFormatProperty); }
            set { SetValue(StringFormatProperty, value); }
        }
        public static readonly DependencyProperty StringFormatProperty =
            DependencyProperty.Register("StringFormat", typeof(String), typeof(GraphAxisControl), new PropertyMetadata(null));

        /// <summary>
        /// When overridden in a derived class, is invoked whenever application code or internal processes call <see cref="M:System.Windows.FrameworkElement.ApplyTemplate" />.
        /// </summary>
        public override void OnApplyTemplate()
        {
            base.OnApplyTemplate();

            _items_control = GetTemplateChild("PART_ItemsControl") as ItemsControl;
            OnTicksChanged();
        }

        /// <summary>
        /// Called when the <see cref="Ticks"/> property has changed.
        /// </summary>
        protected virtual void OnTicksChanged()
        {
            Items = new ObservableCollection<GraphAxisTickData>(Enumerable.Range(0, Ticks).Select(x => new GraphAxisTickData()));
        }

        /// <summary>
        /// Called when surface painter has changed.
        /// </summary>
        /// <param name="painter">The painter.</param>
        protected override void OnSurfacePainterChanged(IGraphPainter painter)
        {
            base.OnSurfacePainterChanged(painter);

            if (!this.IsInDesignMode())
            {
                painter.VirtualRangeXChanged += Painter_VirtualRangeXChanged;
                painter.VirtualRangeYChanged += Painter_VirtualRangeYChanged;
            }
        }

        /// <summary>
        /// Handles the VirtualRangeYChanged event of the surface painter.
        /// </summary>
        /// <param name="sender">The source of the event.</param>
        /// <param name="e">The <see cref="RangeChangedEventArgs"/> instance containing the event data.</param>
        private void Painter_VirtualRangeYChanged(object sender, RangeChangedEventArgs e)
        {
            InvokeUI(() =>
            {
                if (Orientation == Orientation.Vertical)
                {
                    if (Items != null && e.Minimum != null && e.Maximum != null)
                    {
                        var steps = e.Minimum.CreateRange(e.Minimum, e.Maximum, Ticks).Reverse().ToList();

                        for (int i = 0; i < steps.Count; i++)
                        {
                            var tick_data = Items[i];
                            tick_data.Data = steps[i];
                            tick_data.IsFirst = i == 0;
                            tick_data.IsLast = i == steps.Count - 1;
                            tick_data.IsEven = i % 2 == 0;
                        }
                    }
                }
            });
        }

        /// <summary>
        /// Handles the VirtualRangeXChanged event of the surface painter.
        /// </summary>
        /// <param name="sender">The source of the event.</param>
        /// <param name="e">The <see cref="RangeChangedEventArgs"/> instance containing the event data.</param>
        private void Painter_VirtualRangeXChanged(object sender, RangeChangedEventArgs e)
        {
            InvokeUI(() =>
            {
                if (Orientation == Orientation.Horizontal)
                {
                    if (Items != null)
                    {
                        var steps = e.Minimum.CreateRange(e.Minimum, e.Maximum, Ticks).ToList();

                        for (int i = 0; i < steps.Count; i++)
                        {
                            var tick_data = Items[i];
                            tick_data.Data = steps[i];
                            tick_data.IsFirst = i == 0;
                            tick_data.IsLast = i == steps.Count - 1;
                            tick_data.IsEven = i % 2 == 0;
                        }
                    }
                }
            });
        }

    }
}