MARKUS

using System;

using System.Collections.Generic;

using System.Collections.ObjectModel;

using System.Linq;

using System.Text;

using System.Threading.Tasks;

using System.Windows;

using KCOM.Common;

using KCOM.PemssService;

using Markus.Mvvm.ToolKit;

using Telerik.Windows.Controls;

namespace KCOM.ViewModel

{

    public class RequirementViewModel : Markus.Mvvm.ToolKit.ViewModelBase

    {

        PemssService.PemssServiceClient pemssServiceClient;

        private System.Collections.ObjectModel.ObservableCollection<Requirement> requirementList;

        public ObservableCollection<Requirement> RequirementList

        {

            get

            {

                if (requirementList == null)

                {

                    requirementList = new ObservableCollection<Requirement>();

                }

                return requirementList;

            }

            set

            {

                if (requirementList != value)

                {

                    requirementList = value;

                    OnPropertyChanged(() => RequirementList);

                }

            }

        }

        private Requirement selectRequirement;

        public Requirement SelectRequirement

        {

            get

            {

                return selectRequirement;

            }

            set

            {

                if (selectRequirement != value)

                {

                    selectRequirement = value;

                    OnPropertyChanged(() => SelectRequirement);

                }

            }

        }

        private VpCommant selectVPComment;

        public VpCommant SelectVPComment

        {

            get

            {

                return selectVPComment;

            }

            set

            {

                if (selectVPComment != value)

                {

                    selectVPComment = value;

                    OnPropertyChanged(() => SelectVPComment);

                }

            }

        }

        #region UI에 대한 이벤트

        public AsyncCommand RefreshCommand => new AsyncCommand(()=> OnGetRequirementDataAsync());

        public RelayCommand AddVPCommentCommand => new RelayCommand(x => OnAddVPCommentCommand(x));

        public RelayCommand DelVPCommentCommand => new RelayCommand(x => OnDelVPCommentCommand(x));

        public RelayCommand SelectedVPCommentCommand => new RelayCommand(x => OnSelectedVPCommentCommand(x));

        public RelayCommand RequirementSearchCommand => new RelayCommand(x => OnRequirementSearchCommand(x));

        #endregion

        #region 초기화 및 종료 이벤트

        public RequirementViewModel()

        {

            if (App.IsDesignMode)

                return;

            try

            {

                if (pemssServiceClient == null)

                {

                    pemssServiceClient = new PemssServiceClient(App._binding, App._PemssEndPoint);

                }

                OnGetRequirementDataAsync().ConfigureAwait(false);

            }

            catch (Exception ex)

            {

                System.Diagnostics.Debug.WriteLine(ex);

            }

        }

        public override void Loaded()

        {

            base.Loaded();

        }

        public override void Closed()

        {

            base.Closed();

        }

        #endregion

        #region Command

        private async Task OnGetRequirementDataAsync(bool IsInit = true)

        {

            var result = await pemssServiceClient.GetrequirementListAsync(App.ViewInfo.ProjectNO, App.ViewInfo.DocumentItemID);

            if (IsInit)

            {

                requirementList.Clear();

                if (!string.IsNullOrWhiteSpace(App.PEMSSInfo.CommentID))

                {

                    Common.ViewerDataModel.Instance.OnLoadPaged += Instance_OnLoadPaged;

                }

            }

            result.ForEach(newItem =>

            {

                newItem.IsExpanded = true;

                newItem.IsExpandable = true;

                if (IsInit)

                {

                    RequirementList.Add(newItem);

                }

                else

                {

                    RequirementList.UpdateWhere(changeitem => CollectionExtensions.ChangeValues(changeitem, newItem), x => x.mdId == newItem.mdId);

                }

            });

            IsInit = true;

        }

        private void Instance_OnLoadPaged(object sender, EventArgs e)

        {

            var comment = RequirementList.SelectMany(x => x.VpComments).Where(y => y.commentId == App.PEMSSInfo.CommentID);

            if (comment.Count() > 0)

            {

                GotoMarkup(new[] { App.PEMSSInfo.CommentID });

            }

            Common.ViewerDataModel.Instance.OnLoadPaged -= Instance_OnLoadPaged;

        }

        private void OnAddVPCommentCommand(object obj)

        {

            if (obj == null)

            {

                selectedComment = null;

            }

            else

            {

                SelectRequirement = (obj as Telerik.Windows.Controls.GridView.GridViewRow).DataContext as Requirement;

            }

            if (SelectRequirement != null && SelectionSet.Instance.SelectedItems?.Count() > 0)

            {

                Views.AddRequirement addRequirement = new Views.AddRequirement();

                addRequirement.Header = "정합성 코멘트 연결 추가";

                addRequirement.Width = 600;

                addRequirement.Header = 150;

                addRequirement.Closed += new EventHandler<WindowClosedEventArgs>(OnAddVpCommantWindowClosed);

                addRequirement.ShowDialogCenter();

                //var parameters = new DialogParameters()

                //{

                //    ContentStyle = (Style)App.Current.Resources["AddVpCommantWindowStyle"],

                //    Content = "마크업에 대한 코멘트 : ",

                //    Closed = new EventHandler<WindowClosedEventArgs>(OnAddVpCommantWindowClosed),

                //    Owner = App.Current.Windows.Cast<System.Windows.Window>().FirstOrDefault()

                //};

                //RadWindow.Prompt(parameters);

            }

            else

            {

                DialogParameters parameters = null;

                if (SelectRequirement == null)

                {

                    parameters = new DialogParameters()

                    {

                        Content = "추가할 정합성을 선택해야 합니다.",

                        Owner = App.Current.Windows.Cast<System.Windows.Window>().FirstOrDefault()

                    };

                }

                if (SelectionSet.Instance.SelectedItems == null || SelectionSet.Instance.SelectedItems.Count() == 0)

                {

                    parameters = new DialogParameters()

                    {

                        Content = "선택된 마크업이 없습니다.",

                        Owner = App.Current.Windows.Cast<System.Windows.Window>().FirstOrDefault()

                    };

                }

                RadWindow.Alert(parameters);

            }

        }

        private void OnDelVPCommentCommand(object obj)

        {

            if(obj is Telerik.Windows.Controls.GridView.GridViewRow)

            {

                selectedComment = (obj as Telerik.Windows.Controls.GridView.GridViewRow).DataContext as VpCommant;

                var parameters = new DialogParameters()

                {

                    Content = "해당 Comment를 삭제 하시겠습니까?",

                    Closed = new EventHandler<WindowClosedEventArgs>(OnDelVPCommentWindowClosed),

                    Owner = App.Current.Windows.Cast<System.Windows.Window>().FirstOrDefault(),

                };

                RadWindow.Confirm(parameters);

            }

        }

        private void OnSelectedVPCommentCommand(object obj)

        {

            if (SelectVPComment != null)

            {

                var iditems = SelectVPComment.commentId.Split(',');

                GotoMarkup(iditems);

                //selectedComment

                //SelectionSet.Instance.SelectControl  = selectedComment;

                //if (instanceFavoVP.PAGE_NO == Common.ViewerDataModel.Instance.SystemMain.dzMainMenu.pageNavigator.CurrentPage.PageNumber)

                //{

                //    Common.ViewerDataModel.Instance.SystemMain.DialogMessage_Alert("You have selected the current page", "Notice");

                //}

                //else

                //{

                //    Common.ViewerDataModel.Instance.SystemMain.dzMainMenu.pageNavigator.GotoPage(instanceFavoVP.PAGE_NO);

                //}

            }

        }

        private void OnRequirementSearchCommand(object obj)

        {

            var searchView =  new Views.RequirementSearchView();

            RadWindow window = new RadWindow();

            window.Header = "정합성 목록";

            window.Content = searchView;

            window.Width = 1268;

            window.Height = 700;

            window.Closed += (snd, evt) =>

            {

                if(evt.DialogResult == true)

                {

                    if(!string.IsNullOrEmpty( evt.PromptResult))

                    {

                        SelectRequirement = RequirementList.Where(x => x.mdId == evt.PromptResult).First();

                    }

                }

            };

            window.ShowDialogCenter();

        }

        private void GotoMarkup(IEnumerable<string> CommentIdList)

        {

            // Common.ViewerDataModel.Instance.SystemMain.dzMainMenu

            ///Common.ViewerDataModel.Instance._markupInfoList

            //var gridMarkup = Common.ViewerDataModel.Instance.SystemMain.dzMainMenu.gridViewMarkup;

            //var markuplist = (gridMarkup.ItemsSource as IEnumerable<IKCOM.MarkupInfoItem>).SelectMany(x => x.MarkupList);

            var infoList = Common.ViewerDataModel.Instance._markupInfoList.Where(x=>x.MarkupList != null).SelectMany(x => x.MarkupList).Where(f => f.ID == CommentIdList.First());

            if (infoList.Count() > 0)

            {

                var pageNavigator = Common.ViewerDataModel.Instance.SystemMain.dzMainMenu.pageNavigator;

                pageNavigator.GotoPage(infoList.First().PageNumber);

                pageNavigator.PageChanged += (snd, evt) =>

                {

                    var selectComments = Common.ViewerDataModel.Instance.MarkupControls_USER.Where(x => CommentIdList.Count(y => y == x.CommentID) > 0).ToList();

                    if (selectComments.Count() > 0)

                    {

                        selectComments.ForEach(x => x.IsSelected = true);

                        GotoMarkup(selectComments);

                    }

                };

            }

        }

        private void GotoMarkup(IEnumerable<MarkupToPDF.Common.CommentUserInfo> commentUserInfo)

        {

            if (commentUserInfo?.Count() > 0)

            {

                var main = Common.ViewerDataModel.Instance.SystemMain.dzMainMenu;

                try

                {

                    Rect rect = commentUserInfo.First().ItemRect;

                    foreach (var instance in commentUserInfo)

                    {

                        rect = Rect.Union(rect, instance.ItemRect);

                    }

                    SelectionSet.Instance.SelectItemByRect(rect, main);

                    //var matrix = new System.Windows.Media.Matrix();

                    ////var CenterPoint = VectorExtentions.Rotate(new Point(centerX, centerY), Common.ViewerDataModel.Instance.Angle,

                    //// new Point(Common.ViewerDataModel.Instance.ImageViewWidth / 2, Common.ViewerDataModel.Instance.ImageViewHeight / 2));

                    ////matrix.RotateAt(Common.ViewerDataModel.Instance.Angle, Common.ViewerDataModel.Instance.ImageViewWidth/2, Common.ViewerDataModel.Instance.ImageViewHeight/2);

                    //matrix.Rotate(Common.ViewerDataModel.Instance.Angle);

                    ////if (Math.Abs(Common.ViewerDataModel.Instance.Angle) == 90)

                    ////{

                    ////    matrix.Translate(Common.ViewerDataModel.Instance.ImageViewHeight, Common.ViewerDataModel.Instance.ImageViewWidth);

                    ////}

                    //rect.Transform(matrix);

                    //if (Math.Abs(Common.ViewerDataModel.Instance.Angle) == 90)

                    //{ 

                    //    var matrix = new System.Windows.Media.Matrix();

                    //    matrix.RotateAt(Common.ViewerDataModel.Instance.Angle, Common.ViewerDataModel.Instance.ImageViewWidth / 2, Common.ViewerDataModel.Instance.ImageViewHeight / 2);

                    //    rect.Transform(matrix);

                    //}

                    //double centerX = rect.Left + rect.Width / 2;

                    //double centerY = rect.Top + rect.Height / 2;

                    var center = new Vector(Common.ViewerDataModel.Instance.ImageViewWidth / 2, Common.ViewerDataModel.Instance.ImageViewHeight / 2);

                    var matrix = MatrixHelper.Rotation(Common.ViewerDataModel.Instance.PageAngle, center);

                     rect.Transform(matrix);

                    double scaleX = Common.ViewerDataModel.Instance.ImageViewWidth / rect.Width;

                    double scaleY = Common.ViewerDataModel.Instance.ImageViewHeight / rect.Height;

                    double newScale = main.zoomAndPanControl.ContentScale * Math.Min(scaleX, scaleY);

                    double positionX = 0;

                    double positionY = 0;

                    if (Common.ViewerDataModel.Instance.PageAngle == 90)

                    {

                        positionX = Common.ViewerDataModel.Instance.ImageViewHeight - rect.X;

                        positionY = Common.ViewerDataModel.Instance.ImageViewWidth - rect.Y;

                    }

                    main.zoomAndPanControl.ContentScale = newScale;

                    main.zoomAndPanControl.ContentOffsetX = positionX;

                    main.zoomAndPanControl.ContentOffsetY = positionY;

                    main.zoomAndPanControl.ZoomTo(rect);

                    //double centerX = rect.Left + rect.Width / 2;

                    //double centerY = rect.Top + rect.Height / 2;

                    //main.zoomAndPanControl.ZoomAboutPoint(main.zoomAndPanControl.ContentScale, new Point(centerX, centerY));

                }

                catch (Exception ex)

                {

                    main.DialogMessage_Alert(ex.Message, "Error");

                }

            }

        }

        private VpCommant selectedComment;

        private async void OnDelVPCommentWindowClosed(object sender, WindowClosedEventArgs e)

        {

            VpCommant deleteComment = selectedComment;

            selectedComment = null;

            if (e.DialogResult == true)

            {

                try

                {

                    string projectNo = App.ViewInfo.ProjectNO;

                    string docId = App.ViewInfo.DocumentItemID;

                    string mdId = SelectRequirement.mdId;

                    string userId = deleteComment.createdBy;

                    string commentId = deleteComment.commentId;

                    var result = await pemssServiceClient.RemoveRequirementCommentAsync(projectNo, docId, mdId, commentId, userId);

                }

                catch (Exception)

                {

                    //MessageBox.Show("삭제 오류");

                }

                await OnGetRequirementDataAsync(false);

            }

        }

        private async void OnAddVpCommantWindowClosed(object sender, WindowClosedEventArgs e)

        {

           if(e.DialogResult == true)

            {

                var addrequirement = sender as Views.AddRequirement;

                if(string.IsNullOrWhiteSpace(addrequirement.Comment))

                {

                    var parameters = new DialogParameters()

                    {

                        Content = "코멘트가 없습니다.",

                        Owner = App.Current.Windows.Cast<System.Windows.Window>().FirstOrDefault()

                    };

                    RadWindow.Alert(parameters);

                    return;

                }

                string commentOnMarkup = addrequirement.Comment;

                string markupId = string.Join(",",SelectionSet.Instance.SelectedItems.Select(f => f.CommentID));

                string projectNo = App.ViewInfo.ProjectNO;

                string docId = App.ViewInfo.DocumentItemID;

                string mdId = SelectRequirement.mdId;

                string userId = App.PEMSSInfo.UserID;

                bool condition = addrequirement.IsContition;

                var result = await pemssServiceClient.SetRequirementCommentAsync(projectNo,docId,mdId,markupId,commentOnMarkup,condition,userId);

                await OnGetRequirementDataAsync(false);

            }

        }

        #endregion Command

    }

}