MARKUS

using Microsoft.AspNet.SignalR.Client;

using IKCOM;

using KCOM.Common;

using KCOM.ServiceDeepView;

using KCOMDataModel.DataModel;

using Newtonsoft.Json;

using RestSharp;

using System;

using System.Collections.Generic;

using System.Collections.ObjectModel;

using System.ComponentModel;

using System.Linq;

using System.Runtime.CompilerServices;

using System.Text;

using System.Windows;

using System.Windows.Controls;

using Telerik.Windows.Controls;

using MarkupToPDF.Controls.Parsing;

using Telerik.Windows.Data;

using System.Web;

namespace KCOM.Views

{

    public partial class MainMenu : UserControl, INotifyPropertyChanged

    {

        //const string DeepZoomUrl = @"http://{baseUrl}/TileSource/{TileSourcePath}/{ItemsPath}/{SharepointItemID}/{PageNo}.jpg";

        public ServiceDeepViewClient BaseClient;

        public KcomService.ServiceDeepViewClient BaseTaskClient;

        public ViewInfo _ViewInfo;

        public DOCINFO _DocInfo;

        public DOCUMENT_ITEM _DocItem;

        public MEMBER userData;

        public event PropertyChangedEventHandler PropertyChanged;

        private void NotifyPropertyChanged([CallerMemberName] String propertyName = "")

        {

            if (PropertyChanged != null)

            {

                PropertyChanged(this, new PropertyChangedEventArgs(propertyName));

            }

        }

        private Common.DocumentSet _CurrentDoc { get; set; }

        public Common.DocumentSet CurrentDoc

        {

            get

            {

                return _CurrentDoc;

            }

            set

            {

                if (value != CurrentDoc)

                {

                    _CurrentDoc = value;

                    NotifyPropertyChanged();

                }

            }

        }

        public void ServiceOn()

        {

            BaseTaskClient = new KcomService.ServiceDeepViewClient(App._binding, App._EndPoint);

            BaseClient = new ServiceDeepViewClient(App._binding, App._EndPoint);

            BaseClient.GetDocInfoCompleted += BaseClient_GetDocInfoCompleted; //문서 섬네일, 페이지크기, 마크업 정보 [3]

            BaseClient.GetConversionStateCompleted += BaseClient_GetConversionStateCompleted;  //컨버팅의 여부 [2] 

            BaseClient.GetSystemDataCompleted += BaseClient_GetSystemDataCompleted; //시스템 정보 [1] 

            BaseClient.GetDocumentItemInfoCompleted += BaseClient_GetDocumentItemInfoCompleted; // 문서 자체의 정보 [4]

            BaseClient.GetMarkupInfoItemsCompleted += BaseClient_GetMarkupInfoItemsCompleted;

            BaseClient.GetDeptDataCompleted += BaseClient_GetDeptDataCompleted;

            BaseClient.DeleteMarkupCompleted += BaseClient_DeleteMarkupCompleted;

            BaseClient.GetVPRevisionHistoryCompleted += BaseClient_GetVPRevisionHistoryCompleted;

            BaseClient.SetFinalPDFCompleted += BaseClient_SetFinalPDFCompleted;

            BaseClient.GetCompareRectCompleted += BaseClient_GetCompareRectCompleted;

            BaseClient.DeleteMarkupCompleted += BaseClient_DeleteMarkupCompleted;

            BaseClient.DelFavoriteVPCompleted += BaseClient_DelFavoriteVPCompleted;

            BaseClient.EditFavoriteVPCompleted += BaseClient_EditFavoriteVPCompleted;

        }

        private void BaseClient_EditFavoriteVPCompleted(object sender, EditFavoriteVPCompletedEventArgs e)

        {

            Logger.sendResLog("EditFavoriteVPCompleted", "UserState : " + e.UserState + "\r Result :" + e.Result + "\r Cancelled :" + e.Cancelled + "\r Error :" + e.Error, 1);

            if (e.Error == null && e.Result != false)

            {

                Logger.sendReqLog("GetFavoriteVPAsync", App.ViewInfo.ProjectNO + "," + App.ViewInfo.UserID + "," + App.ViewInfo.DocumentItemID, 1);

                BaseClient.GetFavoriteVPAsync(App.ViewInfo.ProjectNO, App.ViewInfo.UserID, App.ViewInfo.DocumentItemID);

            }

            else

            {

                DialogMessage_Alert("Unable to delete the file due to a system failure", "Warning");

            }

        }

        private void BaseClient_DelFavoriteVPCompleted(object sender, DelFavoriteVPCompletedEventArgs e)

        {

            Logger.sendResLog("DelFavoriteVPCompleted", "UserState : " + e.UserState + "\r Result :" + e.Result + "\r Cancelled :" + e.Cancelled + "\r Error :" + e.Error, 1);

            if (e.Error == null && e.Result != false)

            {

                Logger.sendReqLog("GetFavoriteVPAsync", App.ViewInfo.ProjectNO + "," + App.ViewInfo.UserID + "," + App.ViewInfo.DocumentItemID, 1);

                BaseClient.GetFavoriteVPAsync(App.ViewInfo.ProjectNO, App.ViewInfo.UserID, App.ViewInfo.DocumentItemID);

            }

            else

            {

                DialogMessage_Alert("Unable to delete the file due to a system failure", "Warning");

            }

        }

        /// <summary>

        /// Compare 결과를 받아 화면에 표시한다

        /// </summary>

        /// <param name="sender"></param>

        /// <param name="e"></param>

        private void BaseClient_GetCompareRectCompleted(object sender, GetCompareRectCompletedEventArgs e)

        {

            if (e.Error != null || e.Result == null)

            {

                if (e.Error != null)

                {

                    DialogMessage_Alert(e.Error.ToString(), "Error");

                }

                else

                {

                    DialogMessage_Alert("Compare 기능을 원활히 실행하기 위한 데이터가 부족합니다", "안내");

                }

            }

            else

            {

                e.Result.ForEach(d =>

                {

                    d.Width = d.Width * 3;

                    d.Height = d.Height * 3;

                    var point = MarkupToPDF.Controls.Common.MathSet.getRectMiddlePoint(d);

                    System.Windows.Shapes.Rectangle myEllipse = new System.Windows.Shapes.Rectangle();

                    myEllipse.Fill = new System.Windows.Media.SolidColorBrush(System.Windows.Media.Color.FromArgb(100,255,8,0));

                    myEllipse.Opacity = 0.8;

                    myEllipse.Width = d.Width;

                    myEllipse.Height = d.Height;

                    Canvas.SetLeft(myEllipse, d.X - ((point.X - d.X) / 2.0));

                    Canvas.SetTop(myEllipse, d.Y - ((point.Y - d.Y) / 2.0));

                    myEllipse.RenderTransformOrigin = point;

                    canvas_compareBorder.Children.Add(myEllipse);

                });

                da.From = 0.8;

                da.To = 0.1;

                da.Duration = new Duration(TimeSpan.FromSeconds(1));

                da.AutoReverse = true;

                canvas_compareBorder.BeginAnimation(OpacityProperty, da);

            }

        }

        private void BaseClient_SetFinalPDFCompleted(object sender, SetFinalPDFCompletedEventArgs e)

        {

            Logger.sendResLog("SetFinalPDFCompleted", "UserState : " + e.UserState + "\r Result :" + e.Result + "\r Cancelled :" + e.Cancelled + "\r Error :" + e.Error, 1);

            string errormsg = CommonLib.Common.GetAlertMessageString("SetFinalPDFError", "MSG", "최종 파일을 만드는데 문제가 발생하였습니다");

            string successmsg = CommonLib.Common.GetAlertMessageString("SetFinalPDFSuccess", "MSG", "최종 파일 생성 중입니다. 문서관리시스템을 확인해주세요");

            if (e.Error != null || e.Result.Status == FinalStatus.Error)

            {

                DialogMessage_Alert(errormsg, "안내");

            }

            else

            {

                DialogMessage_Alert(successmsg, "안내");

            }

        }

        private void BaseClient_GetVPRevisionHistoryCompleted(object sender, GetVPRevisionHistoryCompletedEventArgs e)

        {

            Logger.sendResLog("GetVPRevisionHistoryCompleted", "UserState : " + e.UserState + "\r Result :" + e.Result + "\r Cancelled :" + e.Cancelled + "\r Error :" + e.Error, 1);

            if (e.Result != null && e.Error == null)

            {

                List<VPRevision> list = e.Result;

                foreach (var item in list)

                {

                    if (App.isExternal)

                    {

                        var sBaseServiceURL = CommonLib.Common.GetConfigString("ExternalOriginalFileUrl", "URL", "", App.isExternal);

                        if (!string.IsNullOrWhiteSpace(item.TO_VENDOR))

                        {

                            var toUri = new Uri(HttpUtility.UrlDecode(item.TO_VENDOR));

                            item.TO_VENDOR = $"{sBaseServiceURL}{toUri.LocalPath}";

                        }

                        if (!string.IsNullOrWhiteSpace(item.FROM_VENDOR))

                        {

                            var fromUri = new Uri(HttpUtility.UrlDecode(item.FROM_VENDOR));

                            item.FROM_VENDOR = $"{sBaseServiceURL}{fromUri.LocalPath}";

                        }

                    }

                    else

                    {

                        item.FROM_VENDOR = HttpUtility.UrlDecode(item.FROM_VENDOR);

                    }

                }

                gridViewHistory.ItemsSource = list;

            }

            //TempFile.TempLoad();

        }

        private void BaseClient_DeleteMarkupCompleted(object sender, DeleteMarkupCompletedEventArgs e)

        {

            Logger.sendResLog("DeleteMarkupCompleted", "UserState : " + e.UserState + "\r Result :" + e.Result + "\r Cancelled :" + e.Cancelled + "\r Error :" + e.Error, 1);

            foreach(var info in ViewerDataModel.Instance._markupInfoList)

            {

                if(info.UserID == App.ViewInfo.UserID)

                {

                    info.userDelete = true;

                    info.DisplayColor = "FFFF0000";

                }

                else

                {

                    info.userDelete = false;

                }

            }

        }

        private void BaseClient_GetDeptDataCompleted(object sender, GetDeptDataCompletedEventArgs e)

        {

            if (e.Error == null)

            {

                Logger.sendResLog("GetDeptDataCompleted", "UserState : " + e.UserState + "\r Result :" + e.Result + "\r Cancelled :" + e.Cancelled + "\r Error :" + e.Error, 1);

            }

            else

            {

                Logger.sendResLog("GetDeptDataCompleted",  "\r Error :" + e.Error, 1);

            }

            if (e.Result != null)

            {

                e.Result.Sort();

                //cbSymbolPublic.ItemsSource = e.Result.ToList();

            }

        }

        public MarkupInfoItem PreviewUserMarkupInfoItem { get; set; }

        /// <summary>

        /// 문서 정보를 가져온다

        /// </summary>

        /// <param name="sender"></param>

        /// <param name="e"></param>

        private async void BaseClient_GetDocInfoCompleted(object sender, GetDocInfoCompletedEventArgs e)

        {

            //Logger.sendResLog("GetDocInfoCompleted", "UserState : " + e.UserState + "\r Result :" + e.Result + "\r Cancelled :" + e.Cancelled + "\r Error :" + e.Error, 1);

            if (e.Error != null)

            {

                DialogMessage_Alert("The page cannot be displayed.", "Alert");

                return;

            }

            string sFolder = _ViewInfo.DocumentItemID.All(char.IsDigit) ? (Convert.ToUInt32(_ViewInfo.DocumentItemID) / 100).ToString() : (_ViewInfo.DocumentItemID.Length >= 5 ? _ViewInfo.DocumentItemID.Substring(0, 5) : _ViewInfo.DocumentItemID);

            var MainUrl = string.Format(CommonLib.Common.GetConfigString("mainServerImageWebPath", "URL", "", App.isExternal).Replace("png","jpg"), _ViewInfo.ProjectNO, sFolder, _ViewInfo.DocumentItemID, "{PageNo}");

            _DocInfo = e.Result;

            _DocInfo.ORIGINAL_FILE = HttpUtility.UrlDecode(_DocInfo.ORIGINAL_FILE);

            foreach (var item in _DocInfo.DOCPAGE.OrderBy(order => order.PAGE_NUMBER))

            {

                ViewerDataModel.Instance.Document_Info.Add(item);

            }

            Logger.sendReqLog("GetMarkupInfoItemsAsync", _ViewInfo.ProjectNO + "," + _DocInfo.ID, 1);

           CurrentDoc = new Common.DocumentSet

            {

                docInfo = _DocInfo,

                Document_Id = _DocInfo.DOCUMENT_ID,

                File_Original = _DocInfo.ORIGINAL_FILE,

                Document_NO = _DocItem?.DOCUMENT_NO,

                File_Result = _DocItem?.RESULT_FILE,

                Group_No = _DocItem?.GROUP_NO,

                ProjectNo = _DocItem?.PROJECT_NO,

                Revision = _DocItem?.REVISION,

            };

            var instanceMain = this.ParentOfType<MainWindow>();

            string firstpage = "1";

            string lastpage = _DocInfo.PAGE_COUNT.ToString();

            instanceMain.dzTopMenu.tlcurrentPage.Text = firstpage;

            instanceMain.dzTopMenu.tlcurrentPage_readonly.Text = lastpage;

            string apptitle = string.Format("MARKUS(ver.{2}) - {0}(Rev.{1})", _DocItem?.DOCUMENT_NO, _DocItem?.REVISION, System.Reflection.Assembly.GetExecutingAssembly().GetName().Version.ToString());

            instanceMain.Title = apptitle;

            #region 페이지 이미지를 로컬에 저장

            string tempStoragePath = System.IO.Path.Combine(System.IO.Path.GetTempPath(),"MARKUS", System.IO.Path.GetRandomFileName());

            //.Replace("jpg", "png")을 붙이는 이유는 MainUrl에 확장명이 jpg로 설정한 경우가 있기 때문

            #endregion

            App.PageStorage = new PageManager.PageStorage(MainUrl.Replace("jpg","png"), tempStoragePath,"png", _DocInfo.PAGE_COUNT);

            await this.pageNavigator.SetPageNaviAsync(CurrentDoc.docInfo.DOCPAGE.ToList(), MainUrl);

        }

        private async void pageNavigator_ThumbInitialized(object sender,EventArgs e)

        {

            BaseClient.GetMarkupInfoItemsAsync(_ViewInfo.ProjectNO, _DocInfo.ID);

            ViewerDataModel.Instance.MarkupControls_USER.Clear();

            //ViewerDataModel.Instance.SystemMain.dzMainMenu.TempLoad();

            #region 단어 검색용 파일 다운로드

            await DownloadOriginalFileAsync();

            #endregion

            Logger.sendReqLog("GetVPRevisionHistoryAsync", CurrentDoc.ProjectNo + "," + CurrentDoc.Document_NO + "," + CurrentDoc.Document_Id, 1);

            BaseClient.GetVPRevisionHistoryAsync(CurrentDoc.ProjectNo, CurrentDoc.Document_NO, CurrentDoc.Document_Id);

        }

        /// <summary>

        /// get markupinfo and markupitem from database

        ///  - 1. called when document is loaded

        ///  - 2. called when user do consolidation

        /// </summary>

        /// <param name="sender"></param>

        /// <param name="e"></param>

        private void BaseClient_GetMarkupInfoItemsCompleted(object sender, GetMarkupInfoItemsCompletedEventArgs e)

        {

            Logger.sendResLog("GetMarkupInfoItemsCompleted", "UserState : " + e.UserState + "\r Result :" + e.Result + "\r Cancelled :" + e.Cancelled + "\r Error :" + e.Error, 1);

            ViewerDataModel.Instance.MarkupControls_USER.Clear();

            ViewerDataModel.Instance.MarkupControls.Clear();

            if (e.Result != null)

            {

                ViewerDataModel.Instance._markupInfoList.Clear();

                if (e.Result.Count > 0) ViewerDataModel.Instance.MyMarkupList.Clear();

                foreach (var info in e.Result)

                {

                    if (info.UserID == App.ViewInfo.UserID)

                    {

                        info.userDelete = true;

                        info.DisplayColor = "#FFFF0000";

                    }

                    else

                    {

                        info.userDelete = false;

                    }

                    ViewerDataModel.Instance._markupInfoList.Add(info);

                }

                var userInfoList = ViewerDataModel.Instance._markupInfoList.GroupBy(f => f.UserID).Select(f => new MarkupUserInfo { UserId = f.Key, UserName = f.First().UserName });

                userInfoList.ToList().ForEach(x => ViewerDataModel.Instance._markupUserList.Add(x));

                e.Result.ToList().ForEach(d =>

                {

                    if (d.MarkupList != null)

                    {

                        d.MarkupList.ForEach(p =>

                        {

                            if (d.UserID == App.ViewInfo.UserID)

                            {

                                d.userDelete = true;

                                d.DisplayColor = "#FFFF0000";

                                MarkupItemEx markup = new MarkupItemEx

                                {

                                    Data = p.Data,

                                    Data_Type = p.Data_Type,

                                    ID = p.ID,

                                    IsUpdate = false,

                                    MarkupInfoID = d.MarkupInfoID,

                                    PageNumber = p.PageNumber,

                                    Symbol_ID = p.Symbol_ID,

                                //Group_ID = p.Group_ID

                            };

                                ViewerDataModel.Instance.MyMarkupList.Add(markup);

                            }

                            else

                            {

                                MarkupItemEx markup = new MarkupItemEx

                                {

                                    Data = p.Data,

                                    Data_Type = p.Data_Type,

                                    ID = p.ID,

                                    IsUpdate = false,

                                    MarkupInfoID = d.MarkupInfoID,

                                    PageNumber = p.PageNumber,

                                    Symbol_ID = p.Symbol_ID,

                                //Group_ID = p.Group_ID

                            };

                                ViewerDataModel.Instance.MarkupList_Pre.Add(markup);

                            }

                        });

                    }

                });

                var currentUser = e.Result.Where(data => data.UserID == App.ViewInfo.UserID && data.AvoidConsolidate == 0).FirstOrDefault();

                if (currentUser == null)

                {

                    /// create a new markupinfo to do comments

                    var infoId = Commons.shortGuid();

                    PreviewUserMarkupInfoItem = new MarkupInfoItem

                    {

                        CreateTime = DateTime.Now,

                        UpdateTime = DateTime.Now,

                        Depatment = userData.DEPARTMENT,

                        DisplayColor = "#FFFF0000",

                        UserID = userData.ID,

                        UserName = userData.NAME,

                        PageCount = 1,

                        Description = "",

                        MarkupInfoID = infoId,

                        MarkupList = null,

                        MarkupVersionID = Commons.shortGuid(),

                        Consolidate = 0,

                        PartConsolidate = 0,

                        userDelete = true,

                        AvoidConsolidate = 0,

                        IsPreviewUser = false

                    };

                    App.Custom_ViewInfoId = infoId;

                    ViewerDataModel.Instance._markupInfoList.Insert(0, PreviewUserMarkupInfoItem);

                }

                else

                {

                    App.Custom_ViewInfoId = currentUser.MarkupInfoID;

                }

                foreach(var info in e.Result)

                {

                    if (info.UserID == App.ViewInfo.UserID) info.DisplayColor = "#FFFF0000";

                }

                ViewerDataModel.Instance.PageNumber = 1;

                /// Consolidation 된 데이터가 최상단에 올 수 있도록 변경

                var markupItem = ViewerDataModel.Instance._markupInfoList.OrderByDescending(p => p.Consolidate == Convert.ToInt32(true)).ToList();

                markupItem.ForEach(data =>

                {

                    if (data.Depatment == null) data.Depatment = "Unknown";

                });

                gridViewMarkup.ItemsSource = ViewerDataModel.Instance._markupInfoList;

                SetCommentPages();

                var SelectedItem = ViewerDataModel.Instance._markupInfoList.Where(info => info.UserID == App.ViewInfo.UserID).OrderByDescending(order => order.UpdateTime).FirstOrDefault();

                this.gridViewMarkup.SelectedItem = (PreviewUserMarkupInfoItem != null) ? PreviewUserMarkupInfoItem : SelectedItem;

                /// create a group descriptor

                gridViewMarkup.GroupDescriptors.Clear();

                GroupDescriptor descriptor = new GroupDescriptor();

                descriptor.Member = "Depatment";

                descriptor.DisplayContent = "DEPT";

                //descriptor.SortDirection = ListSortDirection.Ascending;

                gridViewMarkup.GroupDescriptors.Add(descriptor);

                /// up to here

            }

        }

        private async void gridViewRevMarkup_SelectionChanged(object sender, Telerik.Windows.Controls.SelectionChangeEventArgs e)

        {

            List<MarkupInfoItem> gridSelectionItem = gridViewRevMarkup.SelectedItems.Cast<MarkupInfoItem>().ToList(); //선택 된 마크업

            //if (ViewerDataModel.Instance.PageBalanceNumber == 0)

            //{

            //    ViewerDataModel.Instance.PageBalanceNumber = 1;

            //}

            if (ViewerDataModel.Instance.PageNumber == 0)

            {

                ViewerDataModel.Instance.PageNumber = 1;

            }

            if (e.AddedItems.Count() > 0)

            {

                foreach (var item in gridSelectionItem)

                {

                    //item.MarkupList.Where(pageItem => pageItem.PageNumber == ViewerDataModel.Instance.PageBalanceNumber).ToList().ForEach(delegate (MarkupItem markupitem)

                    //{

                    //    layerControl.markupParse(markupitem.Data, Common.ViewerDataModel.Instance.MarkupControls_Sync, item.DisplayColor, "", item.MarkupInfoID);

                    //});

                    var pageItems = item.MarkupList.Where(pageItem => pageItem.PageNumber == ViewerDataModel.Instance.PageNumber).ToList();

                    foreach (var markupitem in pageItems)

                    {

                       await MarkupParser.ParseExAsync(App.ViewInfo.ProjectNO, markupitem.Data, Common.ViewerDataModel.Instance.MarkupControls_Sync, item.DisplayColor, "", item.MarkupInfoID);

                    }

                }

            }

            else if (e.RemovedItems.Count > 0)

            {

                var _infoItem = e.RemovedItems.Cast<MarkupInfoItem>().ToList();

                (from A in _infoItem

                 from B in Common.ViewerDataModel.Instance.MarkupControls_Sync

                 where A.MarkupInfoID == B.MarkupInfoID

                 select B).ToList().ForEach(data =>

                 {

                     Common.ViewerDataModel.Instance.MarkupControls_Sync.Remove(data);

                 });

            }

        }

        /// <summary>

        /// 선택한 항목은 Visibility = Visible, 해제한 항목은 Visibility = Hidden 처리한다.

        /// </summary>

        /// <param name="sender"></param>

        /// <param name="e"></param>

        private async void gridViewMarkup_SelectionChanged(object sender, Telerik.Windows.Controls.SelectionChangeEventArgs e)

        {

            SelectionSet.Instance.UnSelect(Common.ViewerDataModel.Instance.SystemMain.dzMainMenu);

            var dataSet = gridViewMarkup.SelectedItems.Cast<MarkupInfoItem>().Where(data => data.UserID == _ViewInfo.UserID);

            var dataSet_User = gridViewMarkup.Items.Cast<MarkupInfoItem>().Where(data => data.UserID == _ViewInfo.UserID);

            var resultA = (from item_Select in dataSet

                           from item_Non in dataSet_User

                           where item_Select == item_Non

                           select item_Non).ToList();

            if (resultA.Count() >= 2)

            {

                // 동일한 사용자 데이터가 두개 이상 선택됩니다. Consolidation을 선택할까요?

                RadWindow.Confirm(new DialogParameters

                {

                    Owner = Application.Current.MainWindow,

                    Header = "Info",

                    Content = "Selected more than two identical user data. Do you want to select consolidation?",

                    Closed = new EventHandler<WindowClosedEventArgs>((sen, ea) =>

                    {

                        if (e.AddedItems.Count() == 1)

                        {

                            MarkupInfoItem instanceItem = e.AddedItems.FirstOrDefault() as MarkupInfoItem;

                            gridViewMarkup.SelectedItem = null;

                            if (ea.DialogResult.Value)

                            {

                                if (instanceItem.Consolidate == 1 || instanceItem.PartConsolidate == 1)

                                {

                                    gridViewMarkup.SelectedItem = instanceItem;

                                }

                                else

                                {

                                    //1. Consolidations이 있다면 하나 선택

                                    var Consolidations = resultA.Where(item => (item.Consolidate == 1 || item.PartConsolidate == 1));

                                    if (Consolidations.Count() > 0)

                                    {

                                        gridViewMarkup.SelectedItem = Consolidations.First();

                                    }

                                }

                            }

                            else {

                                //1. Consolidations 아닌게 있다면 Change

                                var notConsolidations = resultA.Where(item => !(item.Consolidate == 1 || item.PartConsolidate == 1));

                                if(notConsolidations.Count() > 0) {

                                    gridViewMarkup.SelectedItem = notConsolidations.First();

                                }

                                else {//1. Consolidations 아닌게 없다면 그대로

                                    gridViewMarkup.SelectedItem = instanceItem;

                                }

                            }

                        }

                    }),

                    Theme = new Windows8Theme(),

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

                });

            }

            else //파라미터로 넘어온 사용자가 걸리지 않은 경우

            {

                List<MarkupInfoItem> gridItem = gridViewMarkup.Items.Cast<MarkupInfoItem>().ToList(); //전체 마크업

                List<MarkupInfoItem> gridSelectionItem = gridViewMarkup.SelectedItems.Cast<MarkupInfoItem>().ToList(); //선택 된 마크업

                List<MarkupInfoItem> gridNonSelectionItem = gridItem.Except(gridSelectionItem).ToList(); //선택 되지 않은 마크업

                #region 코멘트 보기

                if (e.AddedItems.Count() > 0)

                {

                    foreach (var item in gridSelectionItem)

                    {

                        if (item.UserID == App.ViewInfo.UserID)

                        {

                            var controls = Common.ViewerDataModel.Instance.MarkupControls_USER.Where(d => d.MarkupInfoID == item.MarkupInfoID).ToList();

                            if (controls.Count == 0)

                            {

                                var instance = ViewerDataModel.Instance.MyMarkupList.Where(d => d.PageNumber == this.pageNavigator.CurrentPage.PageNumber && d.MarkupInfoID == item.MarkupInfoID).ToList();

                                foreach (var markup in instance)

                                {

                                    await MarkupParser.ParseExAsync(App.ViewInfo.ProjectNO, markup.Data, Common.ViewerDataModel.Instance.MarkupControls_USER, item.DisplayColor, "", 

                                        item.MarkupInfoID, markup.ID);

                                }

                            }

                            controls = Common.ViewerDataModel.Instance.MarkupControls_USER.Where(d => d.MarkupInfoID == item.MarkupInfoID).ToList();

                            foreach (var control in controls)

                            {

                                Logger.sendCheckLog(String.Format("=={0}", control), 1);

                                control.Visibility = Visibility.Visible;

                            }

                        }

                        else

                        {

                            var controls = Common.ViewerDataModel.Instance.MarkupControls.Where(d => d.MarkupInfoID == item.MarkupInfoID).ToList();

                            if (controls.Count == 0)

                            {

                                var instance = ViewerDataModel.Instance.MarkupList_Pre.Where(d => d.PageNumber == this.pageNavigator.CurrentPage.PageNumber && d.MarkupInfoID == item.MarkupInfoID).ToList();

                                foreach (var markup in instance)

                                {

                                    await MarkupParser.ParseExAsync(App.ViewInfo.ProjectNO, markup.Data, Common.ViewerDataModel.Instance.MarkupControls, item.DisplayColor, "",

                                        item.MarkupInfoID, markup.ID);

                                }

                            }

                            controls = Common.ViewerDataModel.Instance.MarkupControls.Where(d => d.MarkupInfoID == item.MarkupInfoID).ToList();

                            foreach (var control in controls)

                            {

                                control.Visibility = Visibility.Visible;

                            }

                        }

                    }

                }

                #endregion

                #region 코멘트 숨기기

                else if (e.RemovedItems.Count > 0)

                {

                    var _infoItem = e.RemovedItems.Cast<MarkupInfoItem>().ToList();

                    (from A in _infoItem

                     from B in Common.ViewerDataModel.Instance.MarkupControls

                     where A.MarkupInfoID == B.MarkupInfoID

                     select B).ToList().ForEach(data =>

                     {

                         data.Visibility = Visibility.Hidden;                         

                     });

                    var myComment = _infoItem.Where(d => d.UserID == App.ViewInfo.UserID).FirstOrDefault();

                    if (myComment != null)

                    {

                        Common.ViewerDataModel.Instance.MarkupControls_USER.ToList().ForEach(delegate (MarkupToPDF.Common.CommentUserInfo markupitem)

                        {

                            markupitem.Visibility = Visibility.Hidden;

                        });

                    }

                }

                #endregion

            }

        }

        private void BaseClient_GetDocumentItemInfoCompleted(object sender, GetDocumentItemInfoCompletedEventArgs e)

        {

            Logger.sendResLog("GetDocumentItemInfoCompleted", "UserState : " + e.UserState + "\r Result :" + e.Result + "\r Cancelled :" + e.Cancelled + "\r Error :" + e.Error, 1);

            if (e.Result != null)

            {

                _DocItem = e.Result;

                if (e.Result.DOCUMENT_NO == "" && e.Result.DOCUMENT_NAME == "" && e.Result.GROUP_NO == "0")

                {

                    //장원

                    _ViewInfo.UserID = _ViewInfo.UserID.Replace(@"DAELIM\", "");

                }

                Logger.sendReqLog("GetDocInfoAsync", _ViewInfo.ProjectNO + "," + _ViewInfo.DocumentItemID, 1);

                BaseClient.GetDocInfoAsync(new KCOM_BasicParam { projectNo = _ViewInfo.ProjectNO, documentID = _ViewInfo.DocumentItemID });

            }

            else

            {

                DialogMessage_Alert("Document Information Not Found.", "Error");

                BaseClient.GetCheckSystemAdminCompleted += (sen, ea) =>

                {

                    Logger.sendResLog("GetCheckSystemAdminCompleted", "UserState : " + ea.UserState + "\r Result :" + ea.Result + "\r Cancelled :" + ea.Cancelled + "\r Error :" + ea.Error, 1);

                    if (ea.Error == null)

                    {

                        if (ea.Result)

                        {

                            this._ViewInfo.isAdmin = true;

                            Logger.sendReqLog("GetDocInfoAsync", _ViewInfo.ProjectNO + "," + _ViewInfo.DocumentItemID, 1);

                            BaseClient.GetDocInfoAsync(new KCOM_BasicParam { projectNo = _ViewInfo.ProjectNO, documentID = _ViewInfo.DocumentItemID });

                        }

                        else

                        {

                            //System.Windows.Forms.MessageBox.Show("해당 프로젝트에 가입되지 않은 유저입니다. 관리자에게 등록신청을 해주세요", "안내");

                            DialogMessage_Alert("You are not belong to this project. Please ask admin for an authority.", "Info");

                            //this.ParentOfType<MainPage>().DialogMessage_Alert("해당 프로젝트에 가입되지 않은 유저입니다. 관리자에게 등록신청을 해주세요", "안내");

                        }

                    }

                    else

                    {

                        //System.Windows.Browser.HtmlPage.Window.Invoke("close");

                    }

                };

                Logger.sendReqLog("GetCheckSystemAdminAsync", _ViewInfo.UserID, 1);

                BaseClient.GetCheckSystemAdminAsync(this._ViewInfo.UserID);

            }

        }

        private void BaseClient_GetSystemDataCompleted(object sender, GetSystemDataCompletedEventArgs e)

        {

            Logger.sendResLog("GetSystemDataCompleted", "UserState : " + e.UserState + "\r Result :" + e.Result + "\r Cancelled :" + e.Cancelled + "\r Error :" + e.Error, 1);

            if (e.Error == null && e.Result != null)

            {

                App.SystemInfo = e.Result;

                //App.urlPort_DB = App.SystemInfo.HostPort;

                //App.urlHost_DB = App.SystemInfo.HostName;

                Logger.sendReqLog("GetConversionStateAsync", _ViewInfo.ProjectNO + "," + _ViewInfo.DocumentItemID, 1);

                BaseClient.GetConversionStateAsync(new KCOM_BasicParam { projectNo = _ViewInfo.ProjectNO, documentID = _ViewInfo.DocumentItemID });

                //if (App.urlHost.Contains("localhost"))

                //{

                //    App.urlHost = App.urlHost_DB;

                //}

            }

        }

        private void BaseClient_GetConversionStateCompleted(object sender, GetConversionStateCompletedEventArgs e)

        {

            Logger.sendResLog("GetConversionStateCompleted", "UserState : " + e.UserState + "\r Result :" + e.Result + "\r Cancelled :" + e.Cancelled + "\r Error :" + e.Error, 1);

            string failedmsg = CommonLib.Common.GetAlertMessageString("GetConversionStateFailed", "MSG", "Too Many V/P Files are uploading instantaneously, This V/P file can not be open now. Please feel free to re-open wait a moment again!\n\n현재 일시적으로 많은 양의 V/P가 등록되고 있어 이 문서를 열람할 수 없습니다.\n잠시만 기다려 주신 후 다시 열람하여 주시기 바랍니다");

            if (e.Error == null && e.Result == true)

            {

                Logger.sendReqLog("GetDocumentItemInfoAsync", _ViewInfo.ProjectNO + "," + _ViewInfo.DocumentItemID + "," + _ViewInfo.UserID, 1);

                BaseClient.GetDocumentItemInfoAsync(new KCOM_BasicParam { projectNo = _ViewInfo.ProjectNO, documentID = _ViewInfo.DocumentItemID, userID = _ViewInfo.UserID });

                if (App.ViewInfo != null && App.ViewInfo.ProjectNO != "")

                {

                    Logger.sendReqLog("GetMember", _ViewInfo.ProjectNO + "," + _ViewInfo.UserID, 1);

                    userData = BaseClient.GetMember(App.ViewInfo.ProjectNO, App.ViewInfo.UserID);

                    if (userData != null)

                    {

                        Logger.sendReqLog("GetDeptDataAsync", userData.DEPARTMENT, 1);

                        BaseClient.GetDeptDataAsync(userData.DEPARTMENT);

                    }

                    else

                    {

                        userData = new MEMBER();

                        userData.DEPARTMENT = "ALL";

                        Logger.sendReqLog("GetDeptDataAsync", userData.DEPARTMENT, 1);

                        BaseClient.GetDeptDataAsync(userData.DEPARTMENT);

                    }

                }

            }

            else

            {

                DialogMessage_Alert(failedmsg, "Warning");

            }

        }

        public void SetView(ViewInfo info)

        { 

            this._ViewInfo = info;

            try

            {

                /// 대림의 경우 EnsembleID를 가지고 DocumentItemID를 구함

                /// 다른 Site를 대비하여 에러 처리함

                string docid = BaseClient.GetDocItemID(info.EnsembleID);

                if (!string.IsNullOrEmpty(docid))

                {

                    this._ViewInfo.DocumentItemID = docid;

                }

            }

            catch(Exception ex)

            {

                App.FileLogger.Fatal(ex);

            }

            Logger.sendReqLog("GetSystemDataAsync", "", 1);

            BaseClient.GetSystemDataAsync();

        }

        public void HubSet()

        {

            // 허브 연결 구성

            var hubConnection = new HubConnection(CommonLib.Common.GetConfigString("HubAddress", "URL", "", App.isExternal));

            IHubProxy MarkusLicenseProxy = hubConnection.CreateHubProxy("MarkusLicenseHub");

            // 허브 연결 

            hubConnection.Start().ContinueWith(task =>

            {

                if (task.IsFaulted)

                {

                    Console.WriteLine("There was an error opening the connection:{0}",

                                      task.Exception.GetBaseException());

                    //throw task.Exception.GetBaseException();

                }

                else

                {

                    Console.WriteLine("Connected :: " + task.Id);

                }

            }).Wait();

            // [ 프로그램 시작 ]

            // 클라이언트에서 서버를 호출 ( 접속 시 )  : 라이센스 체크

            //( "method name", arg1, arg2 )

            //MarkusLicenseProxy.Invoke<string>("ConnectionMarkus", "H2009115", "고동균").ContinueWith(task =>

            //{

            //    if (task.IsFaulted)

            //    {

            //        Console.WriteLine("ConnectionMarkus :: There was an error calling send: {0}", task.Exception.GetBaseException());

            //    }

            //    else

            //    {

            //        Console.WriteLine(task.Result);

            //    }

            //});

            MarkusLicenseProxy.Invoke<string>("ConnectionMarkus", App.ViewInfo.UserID,App.ViewInfo.ProjectNO).ContinueWith(task =>

            {

                if (task.IsFaulted)

                {

                    Console.WriteLine("ConnectionMarkus :: There was an error calling send: {0}", task.Exception.GetBaseException());

                    //throw task.Exception.GetBaseException();

                }

                else

                {

                    switch (task.Result)

                    {

                        case "2":

                            {

                                var result = MessageBox.Show("권한이 없습니다.");

                                if (result == MessageBoxResult.OK)

                                    System.Diagnostics.Process.GetCurrentProcess().Kill();

                            }

                            break;

                        case "404":

                            {

                                var result = MessageBox.Show("등록된 사용자가 아닙니다.");

                                if(result == MessageBoxResult.OK)

                                    System.Diagnostics.Process.GetCurrentProcess().Kill();

                            }

                            break;

                    }

                }

            });

            // 서버에서 클라이언트 호출 ( 프로그램 구동여부 ) : 라이센스 체크 후 응답 ( 반환값 : true, false ) 

            //MarkusLicenseProxy.On<bool>("IsConnection", status =>

            //{

            //    if (status)

            //    {

            //        // 프로그램 시작 

            //        Console.WriteLine("connection status : " + status);

            //    }

            //    else

            //    {

            //        // 프로그램 종료 ( signalr 접속 끊기 )  

            //        hubConnection.Stop();

            //    }

            //});

            // 공지 메세지 ( 서버에서 클라이언트 호출 ) 

            MarkusLicenseProxy.On<string>("MarkusNotification", msg =>

                Console.WriteLine("Noficiation Message : " + msg)

            );

            // 서버 메서드 호출 

            //MarkusLicenseProxy.Invoke<string>("DoSomething", "I'm doing something!!!").Wait();

            //Console.ReadKey();

            //hubConnection.Stop();

        }

        public async void MarkupUserListDisplay()

        {

            List<MarkupInfoItem> gridItem = gridViewMarkup.Items.Cast<MarkupInfoItem>().ToList(); //전체 마크업

            List<MarkupInfoItem> gridSelectionItem = gridViewMarkup.SelectedItems.Cast<MarkupInfoItem>().ToList(); //선택 된 마크업

            List<MarkupInfoItem> gridNonSelectionItem = gridItem.Except(gridSelectionItem).ToList(); //선택 되지 않은 마크업

                                                                                                     //MarkupToPDF.Controls.Parsing.LayerControl layerControl = new MarkupToPDF.Controls.Parsing.LayerControl();

            Common.ViewerDataModel.Instance.MarkupControls_USER.Clear();  //전체 제거

            Common.ViewerDataModel.Instance.MarkupControls.Clear();  //전체 제거

            //foreach (var item in gridSelectionItem)

            //{

            //    if (item.UserID == App.ViewInfo.UserID)

            //    {

            //        ViewerDataModel.Instance.MyMarkupList.Where(data => data.PageNumber == pageNavigator.CurrentPage.PageNumber && data.MarkupInfoID == item.MarkupInfoID).ToList().ForEach(delegate (MarkupItemEx markupitem)

            //        {

            //            layerControl.markupParseEx(markupitem.Data, Common.ViewerDataModel.Instance.MarkupControls_USER, item.DisplayColor, "", item.MarkupInfoID, markupitem.ID);

            //        });

            //    }

            //    else

            //    {

            //        ViewerDataModel.Instance.MarkupList_Pre.Where(data => data.PageNumber == pageNavigator.CurrentPage.PageNumber && data.MarkupInfoID == item.MarkupInfoID).ToList().ForEach(delegate (MarkupItemEx markupitem)

            //        {

            //            layerControl.markupParse(markupitem.Data, Common.ViewerDataModel.Instance.MarkupControls, item.DisplayColor, "", item.MarkupInfoID);

            //        });

            //    }

            //}

                (from A in gridSelectionItem

                 from B in Common.ViewerDataModel.Instance.MarkupControls_USER

                 where A.MarkupInfoID == B.MarkupInfoID

                 select B).ToList().ForEach(data =>

                 {

                     Common.ViewerDataModel.Instance.MarkupControls_USER.Remove(data);

                 });

            (from A in gridSelectionItem

             from B in Common.ViewerDataModel.Instance.MarkupControls

             where A.MarkupInfoID == B.MarkupInfoID

             select B).ToList().ForEach(data =>

             {

                 Common.ViewerDataModel.Instance.MarkupControls.Remove(data);

             });

            foreach (var item in gridSelectionItem)

            {

                if (item.UserID == App.ViewInfo.UserID)

                {

                    var markupItems = ViewerDataModel.Instance.MyMarkupList.Where(data => data.PageNumber == pageNavigator.CurrentPage.PageNumber && data.MarkupInfoID == item.MarkupInfoID).ToList();

                    foreach (var markupitem in markupItems)

                    {

                        await MarkupParser.ParseExAsync(App.ViewInfo.ProjectNO, markupitem.Data, Common.ViewerDataModel.Instance.MarkupControls_USER, item.DisplayColor, "", 

                                item.MarkupInfoID, markupitem.ID);

                    }

                }

                else

                {

                    var markupItems = ViewerDataModel.Instance.MarkupList_Pre.Where(data => data.PageNumber == pageNavigator.CurrentPage.PageNumber && data.MarkupInfoID == item.MarkupInfoID).ToList();

                    foreach (var markupitem in markupItems)

                    {

                        await MarkupParser.ParseExAsync(App.ViewInfo.ProjectNO, markupitem.Data, Common.ViewerDataModel.Instance.MarkupControls, item.DisplayColor, "", item.MarkupInfoID);

                    }

                }

            }

        }

    }

}