/// Copyright (c) 2021 Iiro Iivanainen, Harri Linna, Jere Pakkanen, Riikka Vilavaara
/// 
/// Permission is hereby granted, free of charge, to any person obtaining
/// a copy of this software and associated documentation files (the
/// "Software"), to deal in the Software without restriction, including
/// without limitation the rights to use, copy, modify, merge, publish,
/// distribute, sublicense, and/or sell copies of the Software, and to
/// permit persons to whom the Software is furnished to do so, subject to
/// the following conditions:
/// 
/// The above copyright notice and this permission notice shall be included
/// in all copies or substantial portions of the Software.
/// 
/// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
/// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
/// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
/// IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
/// CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
/// TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
/// SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
/// 

using CoreLibrary;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Numerics;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Input;
using System.Windows.Media;
using System.Windows.Media.Imaging;
using System.Windows.Shapes;

namespace GroundhogApp
{
    /// <summary>
    /// Interaction logic for MapControl.xaml
    /// </summary>
    public partial class MapControl : UserControl
    {


        public event MouseButtonEventHandler MapMouseDown;
        public event MouseButtonEventHandler DataPointMouseDown;

        public double Xpos { get; set; }
        public double Ypos { get; set; }
        public enum Axis
        {
            X,
            Y,
            Z
        }
        public Axis HorizAxis { get; set; }
        public Axis VerticAxis { get; set; }


        /// <summary>
        /// Main constructor for the user control MapControl.
        /// </summary>
        public MapControl()
        {
            InitializeComponent();
            Scale = 100;
        }

        #region Source image for the slice

        public static readonly DependencyProperty SliceSourceProperty 
            = DependencyProperty.Register("SliceSource", 
                                          typeof(BitmapImage),
                                          typeof(MapControl),
                                          new UIPropertyMetadata(null,
                                                        ImageChangedCallback));


        /// <summary>
        /// What happens when SliceSource changes.
        /// </summary>
        /// <param name="d">Root Element</param>
        /// <param name="e">New value argument</param>
        private static void ImageChangedCallback(DependencyObject d,
                                          DependencyPropertyChangedEventArgs e)
        {
            var input = (MapControl)d;
            input.sliceImg.Source = e.NewValue as BitmapImage;
            input.UpdateAxes();
            input.ResizeCanvas();

        }


        /// <summary>
        /// Source image for the slice.
        /// </summary>
        public BitmapImage SliceSource
        {
            get { return (BitmapImage)GetValue(SliceSourceProperty); }
            set { SetValue(SliceSourceProperty, value); }
        }

        #endregion

        #region Showing Color-coded axes

        public static readonly DependencyProperty ShowAxesProperty 
            = DependencyProperty.Register("ShowAxes",
                typeof(bool),
                typeof(MapControl),
                new FrameworkPropertyMetadata(ShowAxesPropertyChangedCallback));


        /// <summary>
        /// What happens when ShowAxes changes.
        /// </summary>
        /// <param name="d">Root element</param>
        /// <param name="e">New value argument</param>
        public static void ShowAxesPropertyChangedCallback(DependencyObject d,
            DependencyPropertyChangedEventArgs e)
        {
            var input = (MapControl)d;
            input.UpdateAxes();
        }


        /// <summary>
        /// Wether color-coded axes are shown or not.
        /// </summary>
        public bool ShowAxes
        {
            get { return (bool)GetValue(ShowAxesProperty); }
            set { SetValue(ShowAxesProperty, value); }
        }

        #endregion

        #region Horizontal Axis Color

        public static readonly DependencyProperty HorizontalAxisColorProperty
            = DependencyProperty.Register("HorizontalAxisColor", 
                typeof(Brush),
                typeof(MapControl),
                new UIPropertyMetadata(null, HorizontalColorChangedCallback));
       

        /// <summary>
        /// What happens when HorizontalColor changes.
        /// </summary>
        /// <param name="d">Root element</param>
        /// <param name="e">New value argument</param>
        public static void HorizontalColorChangedCallback(DependencyObject d,
            DependencyPropertyChangedEventArgs e)
        {
            var input = (MapControl)d;
            input.HorizontalAxis.Stroke = e.NewValue as Brush;
        }


        /// <summary>
        /// Color for the horizontal axis.
        /// </summary>
        public Brush HorizontalAxisColor
        {
            get { return (Brush)GetValue(HorizontalAxisColorProperty); }
            set { SetValue(HorizontalAxisColorProperty, value); }
        }

        #endregion

        #region Vertical Axis Color

        public static readonly DependencyProperty VerticalAxisColorProperty
            = DependencyProperty.Register("VerticalAxisColor",
                typeof(Brush),
                typeof(MapControl),
                new UIPropertyMetadata(null, VerticalColorChangedCallback));
        

        /// <summary>
        /// What happens when VerticalColor changes.
        /// </summary>
        /// <param name="d">Root element</param>
        /// <param name="e">New value argument</param>
        public static void VerticalColorChangedCallback(DependencyObject d,
                                          DependencyPropertyChangedEventArgs e)
        {
            var input = (MapControl)d;
            input.VerticalAxis.Stroke = e.NewValue as Brush;
        }


        /// <summary>
        /// Color for the vertical axis.
        /// </summary>
        public Brush VerticalAxisColor
        {
            get { return (Brush)GetValue(VerticalAxisColorProperty); }
            set { SetValue(VerticalAxisColorProperty, value); }
        }

        #endregion

        #region Attached Data Color

        public static readonly DependencyProperty AttachedDataColorProperty
            = DependencyProperty.Register("AttachedDataColor", 
                                          typeof(Brush),
                                          typeof(MapControl),
                                          new UIPropertyMetadata(null, 
                                          AttachedDataColorChangedCallback));


        /// <summary>
        /// What happens when AttachedDataColor changes.
        /// </summary>
        /// <param name="d">Root Element</param>
        /// <param name="e">New value argument</param>
        public static void AttachedDataColorChangedCallback(DependencyObject d,
            DependencyPropertyChangedEventArgs e)
        {
            var input = (MapControl)d;
            if (input.ShowAttachedData)
            {
                input.RemoveAttDataPoints();
                input.DrawAttDataPoints();
            }
        }


        /// <summary>
        /// Color for AttachedData points.
        /// </summary>
        public Brush AttachedDataColor
        {
            get { return (Brush)GetValue(AttachedDataColorProperty); }
            set { SetValue(AttachedDataColorProperty, value); }
        }


        public static readonly DependencyProperty AttachedDataHighlightColorProperty
            = DependencyProperty.Register("AttachedDataHighlightColor",
                typeof(Brush),
                typeof(MapControl),
                new UIPropertyMetadata(null,
                    AttachedDataHighlightColorChangedCallback));


        /// <summary>
        /// What happens when AttachedDataHighlightColor changes
        /// </summary>
        /// <param name="d"></param>
        /// <param name="e"></param>
        public static void AttachedDataHighlightColorChangedCallback(DependencyObject d,
            DependencyPropertyChangedEventArgs e)
        {
            var input = (MapControl)d;
            if (input.ShowAttachedData)
            {
                input.RemoveAttDataPoints();
                input.DrawAttDataPoints();
            }
        }


        /// <summary>
        /// Color for highlighted AttachedData.
        /// </summary>
        public Brush AttachedDataHighlightColor
        {
            get { return (Brush)GetValue(AttachedDataHighlightColorProperty); }
            set { SetValue(AttachedDataHighlightColorProperty, value); }
        }

        #endregion

        #region Showing Data points on map

        public static readonly DependencyProperty ShowAttachedDataProperty
            = DependencyProperty.Register("ShowAttachedData",
                typeof(bool),
                typeof(MapControl),
                new FrameworkPropertyMetadata(ShowAttachedDataPropertyChangedCallback));


        /// <summary>
        /// What happens when ShowAttachedData changes.
        /// </summary>
        /// <param name="d">Root Element</param>
        /// <param name="e">New value argument</param>
        public static void ShowAttachedDataPropertyChangedCallback(DependencyObject d,
            DependencyPropertyChangedEventArgs e)
        {
            var input = (MapControl)d;
            if (input.ShowAttachedData)
            {
                input.DrawAttDataPoints();
                return;
            }
            input.RemoveAttDataPoints();
        }


        /// <summary>
        /// Is Attached Data shown on Map or not.
        /// </summary>
        public bool ShowAttachedData
        {
            get { return (bool)GetValue(ShowAttachedDataProperty); }
            set { SetValue(ShowAttachedDataProperty, value); }
        }

        #endregion

        #region Color for the slice's borders

        public static readonly DependencyProperty SliceColorProperty
            = DependencyProperty.Register("SliceColor",
                typeof(Brush),
                typeof(MapControl),
                new UIPropertyMetadata(null, SliceColorChangedCallback));
        

        /// <summary>
        /// What happens when SliceColor is changed.
        /// </summary>
        /// <param name="d">Root Element</param>
        /// <param name="e">New value argument</param>
        public static void SliceColorChangedCallback(DependencyObject d,
            DependencyPropertyChangedEventArgs e)
        {
            var input = (MapControl)d;
            input.SliceAxis.Stroke = e.NewValue as Brush;
            input.ColoredRectangle.Fill = e.NewValue as Brush;
        }


        /// <summary>
        /// Color of the axis that the slice represents.
        /// </summary>
        public Brush SliceColor
        {
            get { return (Brush)GetValue(SliceColorProperty); }
            set { SetValue(SliceColorProperty, value); }
        }

        #endregion

        #region Slice Name

        public static readonly DependencyProperty SliceNameProperty
            = DependencyProperty.Register("SliceName",
                typeof(string),
                typeof(MapControl),
                new UIPropertyMetadata(null, SliceNameChangedCallback));


        /// <summary>
        /// What happens when SliceName changes.
        /// </summary>
        /// <param name="d">Root element</param>
        /// <param name="e">New value argument</param>
        public static void SliceNameChangedCallback(DependencyObject d,
            DependencyPropertyChangedEventArgs e)
        {
            var input = (MapControl)d;
            input.TextName.Text = e.NewValue as string;
        }


        /// <summary>
        /// Name of the slice being viewed.
        /// </summary>
        public string SliceName
        {
            get { return (string)GetValue(SliceNameProperty); }
            set { SetValue(SliceNameProperty, value); }
        }

        #endregion

        #region Horizontal axis location

        public static readonly DependencyProperty HorizontalDepthProperty
            = DependencyProperty.Register("HorizontalDepth",
                typeof(int),
                typeof(MapControl),
                new FrameworkPropertyMetadata(HorizontalDepthChangedCallback));
        

        /// <summary>
        /// What happens when HorizontalDepth changes.
        /// </summary>
        /// <param name="d">Root element</param>
        /// <param name="e">New value argument</param>
        public static void HorizontalDepthChangedCallback(DependencyObject d,
            DependencyPropertyChangedEventArgs e)
        {
            var input = (MapControl)d;
            input.UpdateAxes();
        }


        /// <summary>
        /// Location of Horizontal axis.
        /// </summary>
        public int HorizontalDepth
        {
            get { return (int)GetValue(HorizontalDepthProperty); }
            set { SetValue(HorizontalDepthProperty, value); }
        }

        #endregion

        #region Vertixal axis location

        public static readonly DependencyProperty VerticalDepthProperty
            = DependencyProperty.Register("VerticalDepth",
                typeof(int),
                typeof(MapControl),
                new FrameworkPropertyMetadata(VerticalDepthChangedCallback));


        /// <summary>
        /// What happens when VerticalDepth changes.
        /// </summary>
        /// <param name="d">Root element</param>
        /// <param name="e">New value argument</param>
        public static void VerticalDepthChangedCallback(DependencyObject d,
            DependencyPropertyChangedEventArgs e)
        {
            var input = (MapControl)d;
            input.UpdateAxes();
        }


        /// <summary>
        /// Location of Vertical axis.
        /// </summary>
        public int VerticalDepth
        {
            get { return (int)GetValue(VerticalDepthProperty); }
            set { SetValue(VerticalDepthProperty, value); }
        }

        #endregion

        #region Edit-mode on / off

        public static readonly DependencyProperty CanEditConnectorsProperty
            = DependencyProperty.Register("CanEditConnectors",
                typeof(bool),
                typeof(MapControl),
                new FrameworkPropertyMetadata(CanEditConnectorsPropertyChanged));


        /// <summary>
        /// Adding event handler for mouse clicks if option is on.
        /// </summary>
        /// <param name="d">Root Element</param>
        /// <param name="e">New value argument</param>
        public static void CanEditConnectorsPropertyChanged(DependencyObject d,
            DependencyPropertyChangedEventArgs e)
        {
            var input = (MapControl)d;
            if (input.CanEditConnectors)
            {
                input.Canv.MouseDown
                    += new MouseButtonEventHandler(input.Canv_MouseDown);
                return;
            }
            input.Canv.MouseDown
                -= new MouseButtonEventHandler(input.Canv_MouseDown);
        }


        /// <summary>
        /// Can add connectors for the Map shown or not.
        /// </summary>
        public bool CanEditConnectors
        {
            get { return (bool)GetValue(CanEditConnectorsProperty); }
            set { SetValue(CanEditConnectorsProperty, value); }
        }

        #endregion

        #region Map scaling

        public static readonly DependencyProperty ScaleProperty
            = DependencyProperty.Register("Scale",
                typeof(double),
                typeof(MapControl),
                new FrameworkPropertyMetadata(ScalePropertyChangedCallback));


        /// <summary>
        /// What happens when Scale changes.
        /// </summary>
        /// <param name="d">Root Element</param>
        /// <param name="e">New value argument</param>
        public static void ScalePropertyChangedCallback(DependencyObject d,
            DependencyPropertyChangedEventArgs e)
        {
            var input = (MapControl)d;
            input.ResizeCanvas();
            input.RemoveAttDataPoints();
            input.UpdateAxes();
            if (input.ShowAttachedData) input.DrawAttDataPoints();
        }


        /// <summary>
        /// Map scale
        /// </summary>
        public double Scale
        {
            get { return (double)GetValue(ScaleProperty); }
            set { SetValue(ScaleProperty, value); }
        }


        /// <summary>
        /// Resizes Canvas and Map according to Scale.
        /// </summary>
        public void ResizeCanvas()
        {
            if (SliceSource == null) return;
            SliceBorder.Width = (Scale / 100.0) * SliceSource.Width;
            SliceBorder.Height = (Scale / 100.0) * SliceSource.Height;
        }

        #endregion

        #region Attached Data list

        public static readonly DependencyProperty DataListProperty
            = DependencyProperty.Register("DataList",
                typeof(List<AttachedData>),
                typeof(MapControl),
                new UIPropertyMetadata(null, DataListChangedCallback));


        /// <summary>
        /// What happens when DataList changes.
        /// </summary>
        /// <param name="d">Root Element</param>
        /// <param name="e">New value argument</param>
        public static void DataListChangedCallback(DependencyObject d,
            DependencyPropertyChangedEventArgs e)
        {
            var input = (MapControl)d;
            if (!input.ShowAttachedData) return;
            input.RemoveAttDataPoints();
            input.DrawAttDataPoints();
        }


        /// <summary>
        /// List of Attached data.
        /// </summary>
        public List<AttachedData> DataList
        {
            get { return (List<AttachedData>)GetValue(DataListProperty); }
            set { SetValue(DataListProperty, value); }
        }

        #endregion


        /// <summary>
        /// Invoking DataPointMouseDown event.
        /// </summary>
        /// <param name="sender">Event sender.</param>
        /// <param name="e">Event arguments.</param>
        private void DataPoint_MouseDown(object sender, MouseButtonEventArgs e)
        {
            if (CanEditConnectors) return;
            DataPointMouseDown?.Invoke(sender, e);
        }


        /// <summary>
        /// Highlighting Attached Data Point with mouseover.
        /// </summary>
        /// <param name="sender">Event sender.</param>
        /// <param name="e">Event arguments. Not used.</param>
        private void DataPoint_MouseEnter(object sender, MouseEventArgs e)
        {
            Rectangle rec = sender as Rectangle;
            rec.Stroke = AttachedDataHighlightColor;
        }


        /// <summary>
        /// Removing highlight from Attached Data Point when mouse leaves.
        /// </summary>
        /// <param name="sender">Event sender.</param>
        /// <param name="e">Event arguments. Not used.</param>
        private void DataPoint_MouseLeave(object sender, MouseEventArgs e)
        {
            Rectangle rec = sender as Rectangle;
            rec.Stroke = AttachedDataColor;
        }


        /// <summary>
        /// Invoking a MouseDown event on Canvas.
        /// </summary>
        /// <param name="sender">Event sender.</param>
        /// <param name="e">Event arguments.</param>
        private void Canv_MouseDown(object sender, MouseButtonEventArgs e)
        {
            Point p = Mouse.GetPosition(Canv);
            Xpos = (int)(p.X / (Scale / 100.0)) + 1;
            Ypos = (int)(p.Y / (Scale / 100.0)) + 1;

            MapMouseDown?.Invoke(sender, e);
        }


        /// <summary>
        /// Event handler for text changing on ZoomBox element.
        /// </summary>
        /// <param name="sender">Event sender. Not used.</param>
        /// <param name="e">Event arguments. Not used.</param>
        private void ZoomBox_TextChanged(object sender, RoutedEventArgs e)
        {
            if (!this.IsInitialized) return;
            if (uint.TryParse(ZoomBox.Text.Trim(), out uint value) && value > 0)
            {
                ZoomBox.Style = (Style)FindResource("DefaultTextBox");
                ZoomBox.ToolTip = null;
                ZoomSlider.Value = Math.Log(((double)value/100.0)) / Math.Log(10);
                Scale = value;
            }
            else
            {
                ZoomBox.Style = (Style)FindResource("ErrorTextBox");
                ZoomBox.ToolTip = "Integrals above 0";
            }
        }


        /// <summary>
        /// Event handler for ZoomSlider value changing.
        /// </summary>
        /// <param name="sender">Event sender. Not used.</param>
        /// <param name="e">Event arguments. Not used.</param>
        private void ZoomSlider_ValueChanged(object sender,
            RoutedPropertyChangedEventArgs<double> e)
        {
            double val = (double)Math.Pow(10,(ZoomSlider.Value));
            ZoomBox.Text = ((int)(val * 100)).ToString();
        }


        /// <summary>
        /// Updating color-coded axes
        /// </summary>
        private void UpdateAxes()
        {
            if (ShowAxes)
            {
                HorizontalAxis.Visibility = Visibility.Visible;
                VerticalAxis.Visibility = Visibility.Visible;
                SliceAxis.Visibility = Visibility.Visible;
            }
            else
            {
                HorizontalAxis.Visibility = Visibility.Hidden;
                VerticalAxis.Visibility = Visibility.Hidden;
                SliceAxis.Visibility = Visibility.Hidden;
            }

            HorizontalAxis.Y1 = (Scale / 100.0) * (HorizontalDepth - 1);
            HorizontalAxis.Y2 = (Scale / 100.0) * (HorizontalDepth - 1);
            VerticalAxis.X1 = (Scale / 100.0) * (VerticalDepth - 1);
            VerticalAxis.X2 = (Scale / 100.0) * (VerticalDepth - 1);
            if (SliceSource != null)
            {
                SliceAxis.Width = (Scale / 100.0) * SliceSource.Width;
                SliceAxis.Height = (Scale / 100.0) * SliceSource.Height;
                HorizontalAxis.X2 = (Scale / 100.0) * SliceSource.Width;
                VerticalAxis.Y2 = (Scale / 100.0) * SliceSource.Height;

            }
            
        }


        #region Draw / undraw attached data points

        /// <summary>
        /// Removing attached data points from Map.
        /// </summary>
        private void RemoveAttDataPoints()
        {
            var children = Canv.Children.OfType<Rectangle>().ToList();
            foreach (var child in children)
            {
                if ("AttData".Equals(child.Tag)) Canv.Children.Remove(child);
            }
        }


        /// <summary>
        /// Drawing attached data points on Map from DataList.
        /// </summary>
        private void DrawAttDataPoints()
        {
            if (DataList == null) return;
            foreach (AttachedData att in DataList)
            {
                float x = 0;
                float y = 0;
                if (att.AttachmentPoints.Count == 0) return;
                Vector3 vec = att.AttachmentPoints[0];
                switch (HorizAxis)
                {
                    case Axis.X:
                        y = (float)(Scale / 100.0) * vec.X;
                        break;
                    case Axis.Y:
                        y = (float)(Scale / 100.0) * vec.Y;
                        break;
                    case Axis.Z:
                        y = (float)(Scale / 100.0) * vec.Z;
                        break;
                    default:
                        break;
                }
                switch (VerticAxis)
                {
                    case Axis.X:
                        x = (float)(Scale / 100.0) * vec.X;
                        break;
                    case Axis.Y:
                        x = (float)(Scale / 100.0) * vec.Y;
                        break;
                    case Axis.Z:
                        x = (float)(Scale / 100.0) * vec.Z;
                        break;
                    default:
                        break;
                }
                DrawPoint(x, y, att.DataName);
            }

        }


        /// <summary>
        /// Drawing a single Attached Data Point to specified location.
        /// </summary>
        /// <param name="x">Horizontal position</param>
        /// <param name="y">Vertical position</param>
        /// <param name="id">Data Point's unique ID</param>
        private void DrawPoint(float x, float y, string id)
        {
            Rectangle point = new();
            point.StrokeThickness = 2;
            point.Stroke = AttachedDataColor;
            point.Width = 5;
            point.Height = 5;
            point.Tag = "AttData";
            point.Fill = Brushes.Black;
            point.MouseEnter += DataPoint_MouseEnter;
            point.MouseLeave += DataPoint_MouseLeave;
            point.Uid = id;
            point.MouseDown += DataPoint_MouseDown;
            Canv.Children.Add(point);
            Panel.SetZIndex(point, 1);
            Canvas.SetTop(point, x - (point.Width / 2.0));
            Canvas.SetLeft(point, y - (point.Height / 2.0));

        }

        #endregion
    }
}