using System.ComponentModel;
using System.Text;
using System.Windows.Threading;
using System.Windows.Controls.Primitives;
using AntDesignWPF.Win32;
using SystemCommands = System.Windows.SystemCommands;


namespace AntDesignWPF.Controls
{
    [TemplatePart(Name = PART_Min, Type = typeof(ButtonBase))]
    [TemplatePart(Name = PART_Max, Type = typeof(ButtonBase))]
    [TemplatePart(Name = PART_Close, Type = typeof(ButtonBase))]
    public class WindowButtons : ContentControl, INotifyPropertyChanged
    {
        #region Events

        public event PropertyChangedEventHandler PropertyChanged;

        protected virtual void RaisePropertyChanged(string propertyName = null)
        {
            PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(propertyName));
        }

        public event ClosingWindowEventHandler ClosingWindow;

        public delegate void ClosingWindowEventHandler(object sender, ClosingWindowEventHandlerArgs args);

        #endregion

        #region Fields

        private const string PART_Min = "PART_Min";

        private const string PART_Max = "PART_Max";

        private const string PART_Close = "PART_Close";

        private ButtonBase min;

        private ButtonBase max;

        private ButtonBase close;

        private SafeLibraryHandle user32;

        #endregion

        #region Properties

        public static readonly DependencyProperty MinimizeProperty =
            DependencyProperty.Register("Minimize", typeof(string), typeof(WindowButtons), new PropertyMetadata(null));

        /// <summary>
        /// Gets or sets the minimize button tooltip.
        /// </summary>
        public string Minimize
        {
            get { return (string)GetValue(MinimizeProperty); }
            set { SetValue(MinimizeProperty, value); }
        }

        public static readonly DependencyProperty MaximizeProperty =
            DependencyProperty.Register("Maximize", typeof(string), typeof(WindowButtons), new PropertyMetadata(null));

        /// <summary>
        /// Gets or sets the maximize button tooltip.
        /// </summary>
        public string Maximize
        {
            get { return (string)GetValue(MaximizeProperty); }
            set { SetValue(MaximizeProperty, value); }
        }

        public static readonly DependencyProperty RestoreProperty =
            DependencyProperty.Register("Restore", typeof(string), typeof(WindowButtons), new PropertyMetadata(null));

        /// <summary>
        /// Gets or sets the restore button tooltip.
        /// </summary>
        public string Restore
        {
            get { return (string)GetValue(RestoreProperty); }
            set { SetValue(RestoreProperty, value); }
        }

        public static readonly DependencyProperty CloseProperty =
            DependencyProperty.Register("Close", typeof(string), typeof(WindowButtons), new PropertyMetadata(null));

        /// <summary>
        /// Gets or sets the close button tooltip.
        /// </summary>
        public string Close
        {
            get { return (string)GetValue(CloseProperty); }
            set { SetValue(CloseProperty, value); }
        }

        public static readonly DependencyProperty MinimizeStyleProperty =
            DependencyProperty.Register("MinimizeStyle", typeof(Style), typeof(WindowButtons), new PropertyMetadata(null, OnStyleChanged));

        /// <summary>
        /// Gets or sets the style for the minimize button.
        /// </summary>
        public Style MinimizeStyle
        {
            get { return (Style)GetValue(MinimizeStyleProperty); }
            set { SetValue(MinimizeStyleProperty, value); }
        }

        public static readonly DependencyProperty MaximizeStyleProperty =
            DependencyProperty.Register("MaximizeStyle", typeof(Style), typeof(WindowButtons), new PropertyMetadata(null, OnStyleChanged));

        /// <summary>
        /// Gets or sets the style for the maximize button.
        /// </summary>
        public Style MaximizeStyle
        {
            get { return (Style)GetValue(MaximizeStyleProperty); }
            set { SetValue(MaximizeStyleProperty, value); }
        }

        public static readonly DependencyProperty CloseStyleProperty =
            DependencyProperty.Register("CloseStyle", typeof(Style), typeof(WindowButtons), new PropertyMetadata(null, OnStyleChanged));

        /// <summary>
        /// Gets or sets the style for the close button.
        /// </summary>
        public Style CloseStyle
        {
            get { return (Style)GetValue(CloseStyleProperty); }
            set { SetValue(CloseStyleProperty, value); }
        }

        private static void OnStyleChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
        {
            if (e.NewValue == e.OldValue) return;
            (d as WindowButtons).ApplyStyle();
        }

        private AntWindow parentWindow;

        public AntWindow ParentWindow
        {
            get { return parentWindow; }
            set
            {
                if (Equals(parentWindow, value))
                {
                    return;
                }

                parentWindow = value;
                RaisePropertyChanged("ParentWindow");
            }
        }

        #endregion

        #region Constructors

        static WindowButtons()
        {
            DefaultStyleKeyProperty.OverrideMetadata(typeof(WindowButtons), new FrameworkPropertyMetadata(typeof(WindowButtons)));
        }

        public WindowButtons()
        {
            Dispatcher.BeginInvoke(DispatcherPriority.Loaded,
                                        new Action(() =>
                                        {
                                            if (string.IsNullOrWhiteSpace(Minimize))
                                            {
                                                SetCurrentValue(MinimizeProperty, GetCaption(900));
                                            }
                                            if (string.IsNullOrWhiteSpace(Maximize))
                                            {
                                                SetCurrentValue(MaximizeProperty, GetCaption(901));
                                            }
                                            if (string.IsNullOrWhiteSpace(Close))
                                            {
                                                SetCurrentValue(CloseProperty, GetCaption(905));
                                            }
                                            if (string.IsNullOrWhiteSpace(Restore))
                                            {
                                                SetCurrentValue(RestoreProperty, GetCaption(903));
                                            }
                                        }));
        }

        private string GetCaption(int id)
        {
            if (user32 == null)
            {
                user32 = UnsafeNativeMethods.LoadLibrary(Environment.SystemDirectory + "\\User32.dll");
            }

            var sb = new StringBuilder(256);
            UnsafeNativeMethods.LoadString(user32, (uint)id, sb, sb.Capacity);
            return sb.ToString().Replace("&", "");
        }

        #endregion

        #region Overrides

        public override void OnApplyTemplate()
        {
            base.OnApplyTemplate();

            close = Template.FindName(PART_Close, this) as ButtonBase;

            if (close != null)
            {
                close.Click += OnClose;
            }

            max = Template.FindName(PART_Max, this) as ButtonBase;

            if (max != null)
            {
                max.Click += OnMaximize;
            }

            min = Template.FindName(PART_Min, this) as ButtonBase;

            if (min != null)
            {
                min.Click += OnMinimize;
            }

            ApplyStyle();
        }

        #endregion

        #region Methods

        private void ApplyStyle()
        {
            if (min != null)
            {
                min.Style = MinimizeStyle;
            }

            if (max != null)
            {
                max.Style = MaximizeStyle;
            }

            if (close != null)
            {
                close.Style = CloseStyle;
            }
        }

#pragma warning disable 618

        private void OnMinimize(object sender, RoutedEventArgs e)
        {
            if (ParentWindow != null)
            {
                SystemCommands.MinimizeWindow(ParentWindow);
            }
        }

        private void OnMaximize(object sender, RoutedEventArgs e)
        {
            if (null == ParentWindow) return;
            if (ParentWindow.WindowState == WindowState.Maximized)
            {
                SystemCommands.RestoreWindow(ParentWindow);
            }
            else
            {
                SystemCommands.MaximizeWindow(ParentWindow);
            }
        }

        private void OnClose(object sender, RoutedEventArgs e)
        {
            var closingWindowEventHandlerArgs = new ClosingWindowEventHandlerArgs();
            OnClosingWindow(closingWindowEventHandlerArgs);

            if (closingWindowEventHandlerArgs.Cancelled) return;
            ParentWindow?.Close();
        }

        protected void OnClosingWindow(ClosingWindowEventHandlerArgs args)
        {
            ClosingWindow?.Invoke(this, args);
        }

        #endregion
    }
}