using CommonModel;
using System;
using System.ComponentModel;
using System.Runtime.CompilerServices;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Controls.Primitives;
using System.Windows.Documents;
using System.Windows.Input;
using System.Windows.Media;
using System.Windows.Shapes;
using WPFProject.Models;
using WPFProject.UI.Test;
using WPFProject.Utils;
using static WPFProject.Utils.Resize.Resizeable;

namespace WPFProject.Controls
{
    /// <summary>
    /// InnerWindow.xaml 的交互逻辑
    /// </summary>
    public partial class InnerWindow : UserControl, INotifyPropertyChanged
    {
        public virtual event PropertyChangedEventHandler PropertyChanged;

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

        protected void RaiseAndSetIfChanged<T>(ref T old, T @new, [CallerMemberName] string propertyName = null)
        {
            old = @new;
            if (propertyName != null)
            {
                RaisePropertyChanged(propertyName);
            }
        }

        public CanvasPosition canvasPosition;

        public DragType DragType { get; set; } = DragType.Canvas;

        public int Zindex
        {
            set
            {
                Canvas.SetZIndex(this, value);
            } 
        }

        public AdornerDecorator ResizeAdornerDecorator { get => VisualTreeHelper.GetChild(this, 0) as AdornerDecorator; }


        public event EventHandler MinEvent;
        public event EventHandler MaxEvent;
        public event EventHandler CloseEvent;
        public event EventHandler ZIndexEvent;

        public WindowState WindowState { get; set; } = WindowState.Normal;

        private string _Title;

        public string Title
        {
            get { return _Title; }
            set => RaiseAndSetIfChanged(ref _Title, value);
        }

        public Brush HeaderBackground
        {
            get { return (Brush)GetValue(HeaderBackgroundProperty); }
            set { SetValue(HeaderBackgroundProperty, value); }
        }

        public static readonly DependencyProperty HeaderBackgroundProperty =
            DependencyProperty.Register("HeaderBackground", typeof(Brush), typeof(ProgramList),
                new PropertyMetadata(new SolidColorBrush(Color.FromRgb(54, 146, 225))));

        public Brush HeaderFontColor
        {
            get { return (Brush)GetValue(HeaderFontColorProperty); }
            set { SetValue(HeaderFontColorProperty, value); }
        }

        public static readonly DependencyProperty HeaderFontColorProperty =
            DependencyProperty.Register("HeaderFontColor", typeof(Brush), typeof(ProgramList),
                new PropertyMetadata(new SolidColorBrush(Color.FromRgb(255, 255, 225))));

        public InnerWindow() : this(null)
        {

        }

        public InnerWindow(CanvasPosition canvasPosition)
        {
            this.canvasPosition = canvasPosition;
            if (canvasPosition != null)
            {
                Width = canvasPosition.Width;
                Height = canvasPosition.Height;
            }

            DataContext = this;
            InitializeComponent();
            SizeChanged += InnerWindow_SizeChanged;
            Loaded += InnerWindow_Loaded;
        }

        private void InnerWindow_SizeChanged(object sender, SizeChangedEventArgs e)
        {
            //throw new NotImplementedException();
        }

        private void InitThumb()
        {
            
        }

        // 方形工厂      
        FrameworkElementFactory GetFactory(Brush back)
        {
            FrameworkElementFactory fac = new FrameworkElementFactory(typeof(Rectangle));
            fac.SetValue(Rectangle.FillProperty, back);
            return fac;
        }

        private void InnerWindow_Loaded(object sender, RoutedEventArgs e)
        {
            if (canvasPosition == null)
            {
                canvasPosition = new CanvasPosition
                {
                    Left = Canvas.GetLeft(this),
                    Top = Canvas.GetTop(this),
                    Width = ActualWidth,
                    Height = ActualHeight
                };
            }
            Loaded -= InnerWindow_Loaded;
        }

        private Canvas canvas;

        private void Button_Click(object sender, RoutedEventArgs e)
        {
            Visibility = Visibility == Visibility.Visible ? Visibility.Collapsed : Visibility.Visible;
        }

        private void DragDelta(object sender, System.Windows.Controls.Primitives.DragDeltaEventArgs e)
        {
            switch (DragType)
            {
                case DragType.Canvas:
                    {
                        double offsetX = e.HorizontalChange;
                        double offsetY = e.VerticalChange;

                        Width = ActualWidth > canvas.ActualWidth ? canvas.ActualWidth : Width;
                        Height = ActualHeight > canvas.ActualHeight ? canvas.ActualHeight : Height;

                        double newLeft = Canvas.GetLeft(this) + e.HorizontalChange;
                        newLeft = newLeft < 0 ? 0 : newLeft;


                        double newTop = Canvas.GetTop(this) + e.VerticalChange;
                        newTop = newTop < 0 ? 0 : newTop;

                        double fixLeft = canvasPosition == null || canvasPosition.LimitWidth <= 0 ? ActualWidth : canvasPosition.LimitWidth;
                        double fixTop = canvasPosition == null || canvasPosition.LimitHeight <= 0 ? ActualHeight : canvasPosition.LimitHeight;

                        if (canvas != null)
                        {
                            newLeft = offsetX > 0 && newLeft > canvas.ActualWidth - fixLeft ? canvas.ActualWidth - fixLeft : newLeft;
                            newTop = offsetY > 0 && newTop > canvas.ActualHeight - fixTop ? canvas.ActualHeight - fixTop : newTop;
                        }

                        Canvas.SetLeft(this, newLeft);
                        Canvas.SetTop(this, newTop);
                        break;
                    }
            }
        }

        private void DragStarted(object sender, System.Windows.Controls.Primitives.DragStartedEventArgs e)
        {
            ZIndexEvent?.Invoke(this, null);
            // thumb1.Background = Brushes.White;
        }

        private void DragCompleted(object sender, System.Windows.Controls.Primitives.DragCompletedEventArgs e)
        {
            canvasPosition.Top = Canvas.GetTop(this);
            canvasPosition.Left = Canvas.GetLeft(this);
        }

        private void UserControl_SizeChanged(object sender, SizeChangedEventArgs e)
        {

        }

        /// <summary>
        /// 添加到画布上
        /// </summary>
        /// <param name="canvas"></param>
        public void AttachToCanvas(Canvas canvas)
        {
            if (true)
            {
               Resize.SetIsResizeable(this, true);
            }
            canvas.Children.Add(this);
            this.canvas = canvas;
            if (ActualWidth < MinWidth)
            {
                Width = MinWidth;
            }
            if (ActualHeight < MinHeight)
            {
                Height = MinHeight;
            }
            Canvas.SetLeft(this, canvasPosition == null ? 0 : canvasPosition.Left);
            Canvas.SetTop(this, canvasPosition == null ? 0 : canvasPosition.Top);
        }

        private void Min_Click(object sender, RoutedEventArgs e)
        {
            MinEvent?.Invoke(this, null);
        }

        private void Max_Click(object sender, RoutedEventArgs e)
        {
            MaxEvent?.Invoke(this, null);
        }

        private void CLose_Click(object sender, RoutedEventArgs e)
        {

        }

        private void Grid_GotFocus(object sender, RoutedEventArgs e)
        {

        }

        private void Grid_MouseLeftButtonDown(object sender, System.Windows.Input.MouseButtonEventArgs e)
        {

        }
    }

    public class InnerWindowProp : NotifyBase
    {


    }

    public enum DragType
    {
        Canvas = 0,
        Dock = 1
    }

}