MARKUS

using KCOM.Common;

using KCOM.Controls;

using KCOM.Views;

using KCOMDataModel;

using KCOMDataModel.DataModel;

using MarkupToPDF.Common;

using MarkupToPDF.Controls.Parsing;

using MarkupToPDF.Serialize.Core;

using MarkupToPDF.Serialize.S_Control;

using System;

using System.Collections.Generic;

using System.ComponentModel;

using System.Diagnostics;

using System.IO;

using System.Linq;

using System.Net;

using System.Reflection;

using System.Runtime.InteropServices;

using System.Text;

using System.Threading;

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 System.Xml;

using Telerik.Windows.Controls;

using WinInterop = System.Windows.Interop;

namespace KCOM

{

    /// <summary>

    /// MainWindow.xaml에 대한 상호 작용 논리

    /// </summary>

    public partial class MainWindow : Window

    {

        bool isSaveCheck = false;

        ProgressControl progressControl = null;

        string destfilepath = string.Empty;

        public MainWindow()

        {

            App.splashString(ISplashMessage.MAINWINDOW);

            this.Loaded += MainWindow_Loaded;

            this.PreviewKeyDown += new KeyEventHandler(KeyEventDownAction);

            this.SourceInitialized += new EventHandler(win_SourceInitialized);

        }

        public static BitmapImage CursorChange()

        {

            BitmapImage bmp = new BitmapImage();

            bmp.BeginInit();

            bmp.StreamSource = System.Windows.Application.GetResourceStream(new Uri("/KCOM;Component/Resources/Cursor/customCursor2.cur", UriKind.Relative)).Stream;

            return bmp;

        }

        public void DialogMessage_Alert(string content, string header)

        {

            Telerik.Windows.Controls.DialogParameters parameters = new Telerik.Windows.Controls.DialogParameters()

            {

                Owner = Application.Current.MainWindow,

                Content = new TextBlock()

                { 

                    MinWidth = 400,

                    FontSize = 12,

                    Text = content,

                    TextWrapping = System.Windows.TextWrapping.Wrap

                },

                Header = header,

                Theme = new Telerik.Windows.Controls.VisualStudio2013Theme(),

                ModalBackground = new SolidColorBrush { Color = Colors.Black, Opacity = 0.6 },

            };

            Telerik.Windows.Controls.RadWindow.Alert(parameters);

        }

        private void MainWindow_Loaded(object sender, RoutedEventArgs e)

        {

            InitializeComponent();

            //cursor change  

            this.Cursor = new Cursor(CursorChange().StreamSource);

            double screenWidth = System.Windows.SystemParameters.PrimaryScreenWidth;

            double screenHeight = System.Windows.SystemParameters.PrimaryScreenHeight;

            //this.Width += 40;

            double windowWidth = this.Width;

            double windowHeight = this.Height;

            this.Left = (screenWidth / 2) - (windowWidth / 2);

            this.Top = (screenHeight / 2) - (windowHeight / 2);

            ViewerDataModel.Instance.SystemMain = this;

            if (!App.ParameterMode)

            {

                //App.ViewInfo = new IKCOM.ViewInfo

                //{

                //    DocumentItemID = "11111112",

                //    //DocumentItemID = "10001",

                //    bPartner = false,

                //    CreateFinalPDFPermission = true,

                //    NewCommentPermission = true,

                //    ProjectNO = "000000",

                //    UserID = "H2011357",

                //    //UserID = "H2009115",

                //    //Mode = 0 , 1 , 2

                //};

                //DialogMessage_Alert("데모버전은 단독 실행모드를 지원하지 않습니다", "안내");

                //#if DEBUG

                //                App.ViewInfo = new IKCOM.ViewInfo

                //                {

                //                    DocumentItemID = "11111112",

                //                    //DocumentItemID = "10001",

                //                    bPartner = false,

                //                    CreateFinalPDFPermission = true,

                //                    NewCommentPermission = true,

                //                    ProjectNO = "000000",

                //                    UserID = "H2011357",

                //                    //UserID = "H2009115",

                //                    //Mode = 0 , 1 , 2

                //                };

                //                App.ParameterMode = true;

                //                this.dzMainMenu.ServiceOn();

                //                this.dzMainMenu.SetView(App.ViewInfo);

                //#else

                DialogMessage_Alert("데모버전은 단독 실행모드를 지원하지 않습니다", "안내");

                this.dzMainMenu.pageNavigator.Visibility = Visibility.Collapsed;

                this.dzMainMenu.historyPane.Visibility = Visibility.Collapsed;

                this.dzMainMenu.infoListPane.Visibility = Visibility.Collapsed;

                this.dzMainMenu.searchPane.Visibility = Visibility.Collapsed;

                this.dzMainMenu.talkPane.Visibility = Visibility.Collapsed;

                //#endif

            }

            else

            {

                this.dzMainMenu.ServiceOn();

                if (!App.ViewInfo.CreateFinalPDFPermission && !App.ViewInfo.NewCommentPermission)

                {

                    this.dzTopMenu.radRibbonView.HelpButtonVisibility = Visibility.Collapsed;

                    var list = this.dzTopMenu.ChildrenOfType<RadRibbonTab>().ToList();

                    list.ForEach(item => item.Visibility = Visibility.Collapsed);

                    this.dzTopMenu.ribbontab_ReadOnly.Visibility = Visibility.Visible;

                    this.dzTopMenu.radRibbonView.SelectedItem = this.dzTopMenu.ribbontab_ReadOnly;

                    //this.dzMainMenu.SymbolPane.Visibility = Visibility.Collapsed;

                    //this.dzMainMenu.FavoritePane.Visibility = Visibility.Collapsed;

                    //this.dzMainMenu.drawingRotateCanvas.IsHitTestVisible = false;

                }

                try

                {

                    ///this.dzMainMenu.HubSet();

                    this.dzMainMenu.SetView(App.ViewInfo);

                }

                catch (Exception ex)

                {

                    MessageBox.Show(string.Format("웹 서비스 접속시 에러가 발생했습니다.\n{0}", ex.StackTrace));

                    System.Environment.Exit(0);

                }

            }

            //App.ViewInfo = new IKCOM.ViewInfo

            //{

            //    DocumentItemID = "11111112",

            //    //DocumentItemID = "10001",

            //    bPartner = false,

            //    CreateFinalPDFPermission = true,

            //    NewCommentPermission = true,

            //    ProjectNO = "000000",

            //    UserID = "H2011357",

            //    //UserID = "H2009115",

            //    //Mode = 0 , 1 , 2

            //};

            //this.dzMainMenu.ServiceOn();

            //this.dzMainMenu.SetView(App.ViewInfo);

        }

        bool restoreIfMove = false;

        private void WindowDragEvent(object sender, MouseButtonEventArgs e)

        {

            if(string.IsNullOrEmpty(destfilepath))

            {

                if (e.ClickCount == 2)

                {

                    if ((ResizeMode == ResizeMode.CanResize) ||

                        (ResizeMode == ResizeMode.CanResizeWithGrip))

                    {

                        SwitchState();

                    }

                }

                else

                {

                    if (WindowState == WindowState.Maximized)

                    {

                        restoreIfMove = true;

                    }

                    this.DragMove();

                }

            }            

        }   

        private void WindowDragEventUp(object sender, MouseButtonEventArgs e)

        {

            restoreIfMove = false;

        }

        private void WindowDragEventMove(object sender, MouseEventArgs e)

        {

            if (restoreIfMove)

            {

                if (Mouse.LeftButton == MouseButtonState.Pressed)

                {

                    //this.WindowState = WindowState.Normal;

                    restoreIfMove = false;

                    double percentHorizontal = e.GetPosition(this).X / ActualWidth;

                    double targetHorizontal = RestoreBounds.Width * percentHorizontal;

                    double percentVertical = e.GetPosition(this).Y / ActualHeight;

                    double targetVertical = RestoreBounds.Height * percentVertical;

                    POINT lMousePosition;

                    GetCursorPos(out lMousePosition);

                    Left = lMousePosition.X - targetHorizontal;

                    double top = lMousePosition.Y - targetVertical;

                    if(top < 10)

                    {

                        top = 10;

                    }

                    Top = lMousePosition.Y;

                    WindowState = WindowState.Normal;

                    this.DragMove();

                }

            }

        }

        [DllImport("user32.dll")]

        [return: MarshalAs(UnmanagedType.Bool)]

        static extern bool GetCursorPos(out POINT lpPoint);

        [StructLayout(LayoutKind.Sequential)]

        public struct POINT

        {

            public int X;

            public int Y;

            public POINT(int x, int y)

            {

                this.X = x;

                this.Y = y;

            }

        }

        private void SwitchState()

        {

            switch (WindowState)

            {

                case WindowState.Normal:

                    {

                        WindowState = WindowState.Maximized;

                        break;

                    }

                case WindowState.Maximized:

                    {

                        WindowState = WindowState.Normal;

                        break;

                    }

            }

        }

        private void RadButton_Click(object sender, RoutedEventArgs e)

        {

            Telerik.Windows.Controls.RadButton button = sender as Telerik.Windows.Controls.RadButton;

            switch (button.CommandParameter.ToString())

            {

                case ("Min"):

                    {

                        WindowState = WindowState.Minimized;

                    }

                    break;

                case ("Max"):

                    {

                        WindowState = WindowState.Maximized;

                    }

                    break;

                case ("Exit"):

                    {

                    }

                    break;

            }

        }

        private void WinState(object sender, MouseButtonEventArgs e)

        {

            switch ((e.Source as Image).Name)

            {

                case ("Win_min"):

                    {

                        WindowState = WindowState.Minimized;

                    }

                    break;

                case ("Win_max"):

                    {

                        if (WindowState == WindowState.Maximized)

                        {

                            WindowState = WindowState.Normal;

                        }

                        else

                        {

                            WindowState = WindowState.Maximized;

                        }

                    }

                    break;

                case ("Win_Close"):

                    {

                        SaveCheck();

                        //Update Check 를 통해 update url 을 Get 하고 결과값이 있을 경우에는 SmartUpdater 실행.

                        KeyValuePair<bool, string> updatecheck = UpdateCheck();

                        if (updatecheck.Key && !string.IsNullOrEmpty(updatecheck.Value))

                        {

                            CallUpdateProcess(updatecheck.Value);

                        }

                        this.Close();

                    }

                    break;

            }

        }

        private void SaveCheck()

        {

            if (ViewerDataModel.Instance.UndoDataList.Count > 0)

            {

                DateTime undoTime = ViewerDataModel.Instance.UndoDataList.OrderByDescending(order => order.EventTime).FirstOrDefault().EventTime;

                DateTime updatetime = DateTime.Now.AddDays(-1);

                if (ViewerDataModel.Instance._markupInfoList.Count > 0)

                {

                    updatetime = ViewerDataModel.Instance._markupInfoList.OrderByDescending(order => order.UpdateTime).FirstOrDefault().UpdateTime;

                }

                if (undoTime > updatetime)

                {

                    DialogParameters parameters = new DialogParameters()

                    {

                        Owner = Application.Current.MainWindow,

                        Content = new TextBlock()

                        {

                            MinWidth = 400,

                            FontSize = 11,

                            Text = "저장되지 않은 코멘트가 있습니다. 저장 하시겠습니까?",

                            TextWrapping = System.Windows.TextWrapping.Wrap

                        },

                        Header = "Confirm",

                        Theme = new VisualStudio2013Theme(),

                        ModalBackground = new SolidColorBrush { Color = Colors.Black, Opacity = 0.6 },

                        Closed = OnClosingSave,

                    };

                    RadWindow.Confirm(parameters);

                }

                else

                {

                    isSaveCheck = true;

                }                    

            }else

            {

                isSaveCheck = true;

            }

        }

        private void OnClosingSave(object sender, WindowClosedEventArgs e)

        {

            if (e.DialogResult == true)

            {

                dzTopMenu.SaveEventCallback(null, null);

            }

            isSaveCheck = true;

        }

        private void client_DownloadProgressChanged(object sender, DownloadProgressChangedEventArgs e)

        {

            Dispatcher.BeginInvoke(System.Windows.Threading.DispatcherPriority.Normal, new Action(delegate

            {

                double bytesIn = double.Parse(e.BytesReceived.ToString());

                double totalBytes = double.Parse(e.TotalBytesToReceive.ToString());

                double percentage = bytesIn / totalBytes * 100;

                progressControl.splashText.Text = "Download : " + Math.Truncate(percentage).ToString() + " %";

                progressControl.progressBar.Value = int.Parse(Math.Truncate(percentage).ToString());                

            }));

        }

        /// <summary>

        /// KCOM_API 를 통해 업데이트 URL 을 가져옴.

        /// false : 업데이트 불필요.

        /// true : 업데이트 필요. url 을 같이 Return.

        /// </summary>

        /// <returns></returns>

        private KeyValuePair<bool, string> UpdateCheck()

        {

            bool isUpdateCheck = false;

            string updateurl = string.Empty;

            try

            {

                bool is64bit = Environment.Is64BitProcess;

                string clientversion = Assembly.GetExecutingAssembly().GetName().Version.ToString();

                updateurl = Common.ViewerDataModel.Instance.SystemMain.dzMainMenu.BaseClient.GetVersionData(is64bit, clientversion);

                if (Check_Uri.isUri(updateurl))

                {                          

                    DialogParameters parameters = new DialogParameters()

                    {

                        Owner = Application.Current.MainWindow,

                        Content = new TextBlock()

                        {

                            MinWidth = 400,

                            FontSize = 11,

                            Text = "새로운 버전이 있습니다. \n업데이트 하시겠습니까?",

                            TextWrapping = System.Windows.TextWrapping.Wrap

                        },

                        Header = "Confirm",

                        Theme = new VisualStudio2013Theme(),

                        ModalBackground = new SolidColorBrush { Color = Colors.Black, Opacity = 0.6 },                        

                        Closed = delegate (object windowSender, WindowClosedEventArgs e)

                        {

                            if (e.DialogResult == true)

                            {   

                                isUpdateCheck = true;                                

                            }

                            else

                            {

                                isUpdateCheck = false;

                            }                            

                        }                    

                    };

                    RadWindow.Confirm(parameters);       

                }

                else

                {

                    isUpdateCheck = false;

                }

            }

            catch (Exception ex)

            {

                throw ex;

            }

            return new KeyValuePair<bool, string>(isUpdateCheck, updateurl);

        }

        /// <summary>

        /// SmartUpdate 를 호출.

        /// </summary>

        /// <param name="updateurl">Download 할 설치파일 경로</param>

        private void CallUpdateProcess(string updateurl)

        {

            ProcessStartInfo proInfo = new ProcessStartInfo();

            string smartupdaterpath = string.Empty;

            smartupdaterpath = System.IO.Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "SmartUpdate.exe");

            Process.Start(smartupdaterpath, updateurl);

        }

        private void Client_DownloadFileCompleted(object sender, AsyncCompletedEventArgs e)

        {

            try

            {

                Dispatcher.Invoke(System.Windows.Threading.DispatcherPriority.Normal, new Action(delegate

                {

                    progressControl.splashText.Text = "Download Completed";

                }));                

                if(progressControl != null)

                {

                    progressControl.Close();

                    progressControl = null;

                }

                if(File.Exists(destfilepath))

                {

                    ProcessStartInfo update_msi = new ProcessStartInfo();

                    update_msi.FileName = destfilepath;

                    Process.Start(update_msi);

                }                

                this.Close();

            }

            catch (Exception)

            {

                throw;

            }

        }

        void win_SourceInitialized(object sender, EventArgs e)

        {

            System.IntPtr handle = (new WinInterop.WindowInteropHelper(this)).Handle;

            WinInterop.HwndSource.FromHwnd(handle).AddHook(new WinInterop.HwndSourceHook(WindowProc));

        }

        private static System.IntPtr WindowProc(System.IntPtr hwnd, int msg, System.IntPtr wParam, System.IntPtr lParam, ref bool handled)

        {

            switch (msg)

            {

                case 0x0024:

                    WmGetMinMaxInfo(hwnd, lParam);

                    handled = true;

                    break;

            }

            return (System.IntPtr)0;

        }

        private static void WmGetMinMaxInfo(System.IntPtr hwnd, System.IntPtr lParam)

        {

            MINMAXINFO mmi = (MINMAXINFO)Marshal.PtrToStructure(lParam, typeof(MINMAXINFO));

            int MONITOR_DEFAULTTONEAREST = 0x00000002;

            System.IntPtr monitor = MonitorFromWindow(hwnd, MONITOR_DEFAULTTONEAREST);

            if (monitor != System.IntPtr.Zero)

            {

                MONITORINFO monitorInfo = new MONITORINFO();

                GetMonitorInfo(monitor, monitorInfo);

                RECT rcWorkArea = monitorInfo.rcWork;

                RECT rcMonitorArea = monitorInfo.rcMonitor;

                mmi.ptMaxPosition.x = Math.Abs(rcWorkArea.left - rcMonitorArea.left);

                mmi.ptMaxPosition.y = Math.Abs(rcWorkArea.top - rcMonitorArea.top);

                mmi.ptMaxSize.x = Math.Abs(rcWorkArea.right - rcWorkArea.left);

                mmi.ptMaxSize.y = Math.Abs(rcWorkArea.bottom - rcWorkArea.top);

            }

            Marshal.StructureToPtr(mmi, lParam, true);

        }

        [StructLayout(LayoutKind.Sequential)]

        public struct POINT2

        {

            public int x;

            public int y;

            public POINT2(int x, int y)

            {

                this.x = x;

                this.y = y;

            }

        }

        [StructLayout(LayoutKind.Sequential)]

        public struct MINMAXINFO

        {

            public POINT2 ptReserved;

            public POINT2 ptMaxSize;

            public POINT2 ptMaxPosition;

            public POINT2 ptMinTrackSize;

            public POINT2 ptMaxTrackSize;

        };

        [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Auto)]

        public class MONITORINFO

        {

            public int cbSize = Marshal.SizeOf(typeof(MONITORINFO));

            public RECT rcMonitor = new RECT();

            public RECT rcWork = new RECT();

            public int dwFlags = 0;

        }

        [StructLayout(LayoutKind.Sequential, Pack = 0)]

        public struct RECT

        {

            public int left;

            public int top;

            public int right;

            public int bottom;

            public static readonly RECT Empty = new RECT();

            public int Width

            {

                get { return Math.Abs(right - left); }  // Abs needed for BIDI OS

            }

            public int Height

            {

                get { return bottom - top; }

            }

            public RECT(int left, int top, int right, int bottom)

            {

                this.left = left;

                this.top = top;

                this.right = right;

                this.bottom = bottom;

            }

            public RECT(RECT rcSrc)

            {

                this.left = rcSrc.left;

                this.top = rcSrc.top;

                this.right = rcSrc.right;

                this.bottom = rcSrc.bottom;

            }

            public bool IsEmpty

            {

                get

                {

                    // BUGBUG : On Bidi OS (hebrew arabic) left > right

                    return left >= right || top >= bottom;

                }

            }

            public override bool Equals(object obj)

            {

                if (!(obj is Rect)) { return false; }

                return (this == (RECT)obj);

            }

            public override int GetHashCode()

            {

                return left.GetHashCode() + top.GetHashCode() + right.GetHashCode() + bottom.GetHashCode();

            }

            public static bool operator ==(RECT rect1, RECT rect2)

            {

                return (rect1.left == rect2.left && rect1.top == rect2.top && rect1.right == rect2.right && rect1.bottom == rect2.bottom);

            }

            public static bool operator !=(RECT rect1, RECT rect2)

            {

                return !(rect1 == rect2);

            }

        }

        [DllImport("user32")]

        internal static extern bool GetMonitorInfo(IntPtr hMonitor, MONITORINFO lpmi);

        [DllImport("User32")]

        internal static extern IntPtr MonitorFromWindow(IntPtr handle, int flags);

    }

}