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);

                }

            }

        }

        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));

        #region 초기화 및 종료 이벤트

        public RequirementViewModel()

        {

            try

            {

                if (pemssServiceClient == null)

                {

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

                }

                OnGetRequirementDataAsync().ConfigureAwait(false);

            }

            catch (Exception EX)

            {

                throw;

            }

        }

        public override void Loaded()

        {

            base.Loaded();

        }

        public override void Closed()

        {

            base.Closed();

        }

        #endregion

        #region Command

        private async Task OnGetRequirementDataAsync()

        {

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

            requirementList.Clear();

            result.ForEach(x =>

            {

                x.IsExpanded = true;

                x.IsExpandable = false;

                RequirementList.Add(x);

            });

        }

        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(',');

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

                if (selectComments.Count() > 0)

                {

                    var infoList = Common.ViewerDataModel.Instance.MyMarkupList.Where(f => f.MarkupInfoID == selectComments.First().MarkupInfoID);

                    if (infoList.Count() > 0)

                    {

                        Common.ViewerDataModel.Instance.PageBalanceNumber = infoList.First().PageNumber;

                        selectComments.First().IsSelected = true;

                        GotoMarkup(selectComments);

                    }

                }

                //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 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);

                    //rect.Scale(4, 4);

                    main.zoomAndPanControl.ZoomTo(rect);

                  //  main.zoomAndPanControl.ZoomAboutPoint(main.zoomAndPanControl.ContentScale - 0.2, contentZoomCenter);

                }

                catch (Exception ex)

                {

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

                }

            }

        }

        private void OnVpCommentSelectCommand(object x)

        {

            throw new NotImplementedException();

        }

        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 = deleteComment.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();

            }

        }

        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();

            }

        }

        #endregion Command

    }

}