using HMI.Core.Util;
using HMI.UI.Converter;
using HMI.UI.DpUtil;
using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Data;

namespace HMI.UI.MDI
{
    public class WorkspaceSetting
    {
        public bool IsLocked { get; set; }
        public List<Position> positions { get; set; } = new List<Position>();
    }
    public class Position
    {
        public string Key { get; set; }
        public double Left { get; set; }
        public double Top { get; set; }
        public double Width { get; set; }
        public double Height { get; set; }
    }
    /// <summary>
    /// Workspace.xaml 的交互逻辑
    /// </summary>
    public partial class Workspace : UserControl
    {

        public Workspace()
        {
            InitializeComponent();
        }

        private WorkspaceSetting setting;

        private Dictionary<string, InnerWindow> nameMap
            = new Dictionary<string, InnerWindow>();

        private Dictionary<string, Position> positionMap
            = new Dictionary<string, Position>();

        public static readonly DependencyProperty SettingPathProperty = DependencyProperty.Register(
                            "SettingPath",
                            typeof(string),
                            typeof(Workspace),
                            new FrameworkPropertyMetadata(null, new PropertyChangedCallback(OnSettingChanged)));

        private static void OnSettingChanged(DependencyObject dp, DependencyPropertyChangedEventArgs e)
        {
            if (dp is Workspace ws && e.Property == SettingPathProperty)
            {
                try
                {
                    if (!File.Exists(e.NewValue.ToString()))
                    {
                        throw new Exception("Empty Workspace Setting.");
                    }
                    ws.setting = XmlHelper.DeserializeFromXml<WorkspaceSetting>(e.NewValue.ToString());
                    if (ws?.setting != null)
                    {
                        ws.IsLocked = ws.setting.IsLocked;
                        ws.positionMap = ws.setting.positions.ToDictionary(p => p.Key, p => p);
                    }
                    else
                    {
                        ws.positionMap.Clear();
                    }
                }
                catch
                {
                    ws.setting = new WorkspaceSetting();
                    ws.positionMap.Clear();
                }
            }
        }

        private CanvasPosition GetPositionByIndex(int index)
        {
            double step = 15;
            return new CanvasPosition
            {
                Left = (index + 1) * step,
                Top = (index + 1) * step,
                Width = 0.75 * ActualWidth,
                Height = 0.75 * ActualHeight
            };
        }

        public string SettingPath
        {
            get => (string)GetValue(SettingPathProperty);
            set => SetValue(SettingPathProperty, value);
        }

        private int InnerWindowCount = 0;

        public void AddInnerWindow(InnerWindow innerWindow)
        {
            AddInnerWindow(innerWindow, GetPositionByIndex(WorkArea.Children.Count));
        }

        public void AddInnerWindow(InnerWindow innerWindow, CanvasPosition canvasPosition)
        {
            HandleInnerWindow(innerWindow);
            UpdatePosition(innerWindow, canvasPosition);
        }

        public void AddInnerWindow(string key, InnerWindow innerWindow)
        {
            if (nameMap.ContainsKey(key))
            {
                throw new Exception("Key Exists");
            }
            if (positionMap.ContainsKey(key))
            {
                var position = positionMap[key];
                AddInnerWindow(innerWindow, new CanvasPosition
                {
                    Left = position.Left * WorkArea.ActualWidth,
                    Top = position.Top * WorkArea.ActualHeight,
                    Width = position.Width * WorkArea.ActualWidth,
                    Height = position.Height * WorkArea.ActualHeight
                });
            }
            else
            {
                AddInnerWindow(innerWindow);
            }
            nameMap.Add(key, innerWindow);
        }

        public void UpdatePosition(InnerWindow inner, CanvasPosition position)
        {
            inner.canvasPosition = position;
            inner.Width = position.Width;
            inner.Height = position.Height;
            Canvas.SetLeft(inner, position.Left);
            Canvas.SetTop(inner, position.Top);
        }

        /// <summary>
        /// 设置InnerWindow
        /// </summary>
        /// <param name="inner"></param>
        private void HandleInnerWindow(InnerWindow inner)
        {
            inner.MinEvent += InnerWindowMin;
            inner.MaxEvent += InnerWindowMax;
            inner.LockEvent += Inner_LockEvent;
            inner.ZIndexEvent += Inner_ZIndexEvent;
            inner.GotFocus += Inner_GotFocus;
            inner.AttachToCanvas(WorkArea);
            inner.CanResize = !IsLoaded;
            Binding binding = new Binding("IsLocked")
            {
                Source = this,
                Mode = BindingMode.OneWay,
                Converter = new ReverseBoolConverter(),
                UpdateSourceTrigger = UpdateSourceTrigger.PropertyChanged
            };
            inner.SetBinding(InnerWindow.CanResizeProperty, binding);
            inner.Zindex = InnerWindowCount++;
        }

        private void Inner_LockEvent(object sender, EventArgs e)
        {
            var inner = sender as InnerWindow;
            var left = Canvas.GetLeft(inner) / WorkArea.ActualWidth;
            var top = Canvas.GetTop(inner) / WorkArea.ActualHeight;
            var width = inner.ActualWidth / WorkArea.ActualWidth;
            var height = inner.ActualHeight / WorkArea.ActualHeight;

            positionMap[inner.Title] = new Position
            {
                Left = left,
                Top = top,
                Width = width,
                Height = height
            };

            List<Position> ps = new List<Position>();
            foreach (var key in positionMap.Keys)
            {
                positionMap[key].Key = key;
                ps.Add(positionMap[key]);
            }

            XmlHelper.SerializeToXml(SettingPath, ps);
        }

        /// <summary>
        /// 底部MinInnerWindow处理
        /// </summary>
        /// <param name="inner"></param>
        private void HandleMinInnerWindow(InnerWindow inner)
        {
            MinInnerWindow min = new MinInnerWindow(inner);
            min.MaxEvent += MinInnerWindowMax;
            min.CloseEvent += MinInnerWindowClose;
            BottomBar.AddMinWindow(min);
        }

        /// <summary>
        /// InnerWindow焦点事件
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void Inner_GotFocus(object sender, RoutedEventArgs e)
        {
            CanvasHelper.SetTopZIndex(sender as InnerWindow, WorkArea, typeof(InnerWindow));
        }

        /// <summary>
        /// InnerWindow ZIndex切换事件
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void Inner_ZIndexEvent(object sender, EventArgs e)
        {
            CanvasHelper.SetTopZIndex(sender as InnerWindow, WorkArea, typeof(InnerWindow));
        }

        /// <summary>
        /// InnerWindow最小化事件
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void InnerWindowMin(object sender, System.EventArgs e)
        {
            InnerWindow inner = sender as InnerWindow;
            inner.Visibility = Visibility.Collapsed;
            HandleMinInnerWindow(inner);
        }

        /// <summary>
        /// InnerWindow最大化事件
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void InnerWindowMax(object sender, System.EventArgs e)
        {
            InnerWindow inner = sender as InnerWindow;
            if (inner.WindowState == WindowState.Maximized)
            {
                Canvas.SetLeft(inner, inner.canvasPosition.Left);
                Canvas.SetTop(inner, inner.canvasPosition.Top);

                inner.Width = inner.canvasPosition.Width;
                inner.Height = inner.canvasPosition.Height;
                inner.WindowState = WindowState.Normal;
            }
            else
            {
                inner.canvasPosition.Left = Canvas.GetLeft(inner);
                inner.canvasPosition.Top = Canvas.GetTop(inner);
                inner.canvasPosition.Width = inner.ActualWidth;
                inner.canvasPosition.Height = inner.ActualHeight;
                Canvas.SetLeft(inner, 0);
                Canvas.SetTop(inner, 0);
                inner.Width = WorkArea.ActualWidth;
                inner.Height = WorkArea.ActualHeight;
                inner.WindowState = WindowState.Maximized;
            }
        }

        /// <summary>
        /// 底部MinInnerWindow展开
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void MinInnerWindowMax(object sender, System.EventArgs e)
        {
            MinInnerWindow min = sender as MinInnerWindow;
            min.Inner.Visibility = Visibility.Visible;
            CanvasHelper.SetTopZIndex(min.Inner, WorkArea, typeof(InnerWindow));
            BottomBar.RemoveMinWindow(min);
        }

        /// <summary>
        /// 底部MinInnerWin关闭
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void MinInnerWindowClose(object sender, System.EventArgs e)
        {
            MinInnerWindow min = sender as MinInnerWindow;
            BottomBar.RemoveMinWindow(min);
        }

        private void MenuItem_Click(object sender, RoutedEventArgs e)
        {
            foreach (var inner in nameMap.Values)
            {
                var left = Canvas.GetLeft(inner) / WorkArea.ActualWidth;
                var top = Canvas.GetTop(inner) / WorkArea.ActualHeight;
                var width = inner.ActualWidth / WorkArea.ActualWidth;
                var height = inner.ActualHeight / WorkArea.ActualHeight;
                positionMap[inner.Title] = new Position
                {
                    Left = left,
                    Top = top,
                    Width = width,
                    Height = height
                };
            }
            List<Position> ps = new List<Position>();
            foreach (var key in positionMap.Keys)
            {
                positionMap[key].Key = key;
                ps.Add(positionMap[key]);
            }
            setting.positions = ps;
            XmlHelper.SerializeToXml(SettingPath, setting);
        }

        public static readonly DependencyProperty IsLockedProperty = DependencyProperty.Register(
                            "IsLocked",
                            typeof(bool),
                            typeof(Workspace),
                            new FrameworkPropertyMetadata(false));

        public bool IsLocked
        {
            get => (bool)GetValue(IsLockedProperty);
            private set
            {
                if (setting != null)
                {
                    setting.IsLocked = value;
                }
                SetValue(IsLockedProperty, value);
            }
        }

        private void MenuItem_Checked(object sender, RoutedEventArgs e)
        {
            IsLocked = !IsLocked;
            foreach (var inner in nameMap.Values)
            {
                var left = Canvas.GetLeft(inner) / WorkArea.ActualWidth;
                var top = Canvas.GetTop(inner) / WorkArea.ActualHeight;
                var width = inner.ActualWidth / WorkArea.ActualWidth;
                var height = inner.ActualHeight / WorkArea.ActualHeight;
                positionMap[inner.Title] = new Position
                {
                    Left = left,
                    Top = top,
                    Width = width,
                    Height = height
                };
            }
            List<Position> ps = new List<Position>();
            foreach (var key in positionMap.Keys)
            {
                positionMap[key].Key = key;
                ps.Add(positionMap[key]);
            }
            setting.positions = ps;
            XmlHelper.SerializeToXml(SettingPath, setting);
        }
    }
}