using PDF_Master.ViewModels;
using Prism.Regions;
using System;
using System.Collections.Generic;
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;
using Prism.Events;
using PDF_Master.EventAggregators;
using PDF_Master.CustomControl;
using Prism.Ioc;
using PDF_Master.Helper;
using System.IO;
using ComPDFKit.PDFDocument;
using PDFSettings.Settings;
using PDF_Master.Properties;
using System.Windows.Interop;
using System.Runtime.InteropServices;
using System.Security.Cryptography;

namespace PDF_Master.Views
{
    /// <summary>
    /// MainWindow.xaml 的交互逻辑
    /// </summary>
    public partial class MainWindow : Window
    {
        public IEventAggregator aggregator;

        public IRegionManager region;

        public MainWindow()
        {
            InitializeComponent();

            this.SourceInitialized += MainWindow_SourceInitialized;
        }

        private void MainWindow_SourceInitialized(object sender, EventArgs e)
        {
            try
            {
                //限制应用多开，显示已有窗体或者直接打开文件
                IntPtr hwnd = new WindowInteropHelper(this).Handle;
                HwndSource.FromHwnd(hwnd).AddHook(new HwndSourceHook(WndProc));
            }
            catch { }
        }

        private IntPtr WndProc(IntPtr hwnd, int msg, IntPtr wParam, IntPtr lParam, ref bool handled)
        {
            if (msg == App.MsgId)
            {
                try
                {
                    int msgLength = (int)(lParam);
                    IntPtr mapHandle = Win32Helper.OpenFileMapping((int)Win32Helper.FileMapAccessType.Read, 0, "Global\\sharePathNotify");
                    IntPtr readPtr = Win32Helper.MapViewOfFileEx(mapHandle, Win32Helper.FileMapAccessType.Read, 0, 0, UIntPtr.Zero, IntPtr.Zero);
                    string filePath = Marshal.PtrToStringAuto(readPtr, msgLength);
                    Win32Helper.UnmapViewOfFile(readPtr);
                    Win32Helper.CloseHandle(mapHandle);
                    MD5 currMd5 = MD5.Create();
                    byte[] hashArray = currMd5.ComputeHash(Encoding.Default.GetBytes(filePath));
                    StringBuilder hexBuilder = new StringBuilder();
                    foreach (byte code in hashArray)
                    {
                        hexBuilder.AppendFormat("{0:X2}", code);
                    }

                    IntPtr waitPtr = Win32Helper.OpenEvent(0x0002, false, "Global\\shareWaitNotify" + hexBuilder.ToString());
                    if (waitPtr != IntPtr.Zero)
                    {
                        Win32Helper.SetEvent(waitPtr);
                        Win32Helper.CloseHandle(waitPtr);
                    }
                    if (File.Exists(filePath))
                    {
                        //打开传过来的文件路径
                        if (App.OpenedFileList.Contains(App.GuidPDFPath))
                        {
                            //如果已经打开时，则选中文档所在页签
                            App.mainWindowViewModel.SelectItem(App.GuidPDFPath);
                        }
                        else
                        {
                            (this.DataContext as MainWindowViewModel).AddTabItem(filePath);
                        }
                        if (WindowState == WindowState.Minimized)
                        {
                            WindowState = WindowState.Normal;
                        }
                        Activate();
                    }
                }
                catch (Exception ex)
                {

                }
                handled = true;
                return (IntPtr)(1);
            }
            if (msg == App.WakeId)
            {
                //将现有窗口激活 并前置
                try
                {
                    if (WindowState == WindowState.Minimized)
                    {
                        WindowState = WindowState.Normal;
                    }
                    Activate();
                    handled = true;
                }
                catch (Exception ex)
                {

                }

                return (IntPtr)(1);
            }
            return IntPtr.Zero;
        }

        /// <summary>
        /// 此类因为Dragablz控件的原因需要特殊处理
        /// </summary>
        /// <param name="eventAggregator"></param>

        public MainWindow(IEventAggregator eventAggregator, IContainerProvider container) :this()
        {
            aggregator = eventAggregator;
            eventAggregator?.GetEvent<DragablzWindowEvent>().Publish(new DragablzWindowEventArgs() { TabControl = TabablzControl, Type = DragablzWindowEventType.Opened });
        }

        private void BtnMiniSize_Click(object sender, RoutedEventArgs e)
        {
            System.Windows.SystemCommands.MinimizeWindow(this);
        }

        private void BtnClose_Click(object sender, RoutedEventArgs e)
        {
            System.Windows.SystemCommands.CloseWindow(this);
        }

        private void BtnReStore_Click(object sender, RoutedEventArgs e)
        {
            if (this.WindowState == WindowState.Maximized)
            {
                System.Windows.SystemCommands.RestoreWindow(this);
            }
            else
            {
                System.Windows.SystemCommands.MaximizeWindow(this);
            }
        }

        private void Window_Activated(object sender, EventArgs e)
        {
            App.Current.MainWindow = this;
            App.mainWindowViewModel = this.DataContext as MainWindowViewModel;
            aggregator?.GetEvent<DragablzWindowEvent>().Publish(new DragablzWindowEventArgs() { TabControl = TabablzControl, Type = DragablzWindowEventType.Activated });
        }

        private void Window_Closed(object sender, EventArgs e)
        {
            aggregator?.GetEvent<DragablzWindowEvent>().Publish(new DragablzWindowEventArgs() { TabControl = TabablzControl, Type = DragablzWindowEventType.Closed });
        }

        public void LoadPdfViewer(string[] filePaths)
        {
            var content = App.mainWindowViewModel.SelectedItem.DataContext as MainContentViewModel;
            if (filePaths.Count() == 1)
            {
                if (App.OpenedFileList.Contains(filePaths[0]))
                {
                    App.mainWindowViewModel.SelectItem(filePaths[0]);
                }
                else
                {
                    content.OpenFile(filePaths[0]);
                }
                ToolMethod.SetFileThumbImg(filePaths[0]);
            }
            else
            {
                var fileList = filePaths.ToList().Where(x => !App.OpenedFileList.Exists(y => y == x)).ToList();
                if (fileList.Count <= 0)
                    return;

                content.OpenFile(filePaths[0]);
                for (int i = 1; i < fileList.Count(); i++)
                {
                    if (!App.OpenedFileList.Contains(fileList[i]))
                    {
                        App.mainWindowViewModel.AddTabItem(fileList[i]);
                    }
                    ToolMethod.SetFileThumbImg(fileList[i]);
                }
            }

            Settings.Default.Save();
        }

        private void Window_SizeChanged(object sender, SizeChangedEventArgs e)
        {
            var width = StkPnlRight.ActualWidth;
            BtnAdd.Margin = new Thickness(8,13,width,7);

            if (this.WindowState == WindowState.Maximized)
            {
                ico_max.Visibility = Visibility.Collapsed;
            }
            else
            {
                ico_max.Visibility = Visibility.Visible;
            }
        }

        private void TxtRename_PreviewKeyDown(object sender, KeyEventArgs e)
        {
            if(e.Key == Key.Enter)
            {
                TabablzControl.Focus();
            }
        }

        private void Window_Closing(object sender, System.ComponentModel.CancelEventArgs e)
        {
            if (!(DataContext as MainWindowViewModel).closeAllTabItem())
            {
                e.Cancel = true;
            }
        }

        private void Window_PreviewMouseLeftButtonDown(object sender, MouseButtonEventArgs e)
        {
            //通过转移焦点来使文本框触发失去焦点事件
            var uiElement = FocusManager.GetFocusedElement(this);
            if (uiElement != null)
            {
                var textBox = uiElement as TextBox;
                
                //如果是下拉框本身的可输入文本框，则点击下拉框或者下拉选项时不失去焦点
                var parent = CommonHelper.FindVisualParent<ComboBox>(textBox);
                if (parent != null)
                {
                    var visual = VisualTreeHelper.HitTest(parent, e.GetPosition(parent));
                    if (visual != null)
                    {
                        //点击下拉框展开按钮时 不失去焦点
                        var item = CommonHelper.FindVisualParent<ComboBox>(visual.VisualHit);
                        if (item != null)
                        {
                            return;
                        }
                    }

                    //选择下拉选项时，返回，不失去焦点，否则下拉框的其他选项无法选中
                    if(parent.IsDropDownOpen)
                    {
                        return;
                    }
                }

                //点击其他非文本框区域时，失去焦点
                if (textBox != null)
                {
                    GridRoot.Focusable = true;
                    GridRoot.Focus();
                }
            }
        }
    }
}