MARKUS

using Markus.Service.Extensions;

using Markus.Service.StationController.Data;

using Markus.Service.StationController.Behaviors;

using Markus.Service.StationController.Extensions;

using Markus.Service.StationController.Controls;

using Microsoft.Win32;

using System;

using System.Collections.Generic;

using System.ComponentModel;

using System.Linq;

using System.Threading.Tasks;

using System.Web;

using System.Windows;

using Telerik.Windows.Controls;

using Telerik.Windows.Data;

//using ConvertItem = Markus.Service.Interface.ConvertItem;

using System.Net;

using System.Windows.Threading;

using System.Diagnostics;

using System.Windows.Input;

using Markus.Mvvm.ToolKit;

using System.Windows.Data;

using System.Windows.Controls;

using System.IO;

using Newtonsoft.Json;

//using Markus.Service.Interface;

using static Markus.Service.StationController.Data.FinalPDF;

using System.Collections.ObjectModel;

namespace Markus.Service.StationController.ViewModel

{

    class FinalPDFViewModel : Mvvm.ToolKit.ViewModelBase

    {

        #region Constructor

        /// <summary>

        /// 실행하면 처음 들어가는 부분

        /// </summary>

        public FinalPDFViewModel()

        {

            DataFilterCommand = new DelegateCommand(DataFilter);

            DataSaveFileGemBoxCommand = new DelegateCommand(DataExportData);

            ConvertCommand = new DelegateCommand(DataConvert);

            DeleteCommand = new DelegateCommand(DataDelete);

            ValidateCommand = new DelegateCommand(DataValidate);

            MarkusLinkCommand = new DelegateCommand(MarkusLink);

            RemoveCreateTimeFilterCommand = new DelegateCommand(RemoveCreateTimeFilter);

            ResetCommand = new DelegateCommand(Reset);

            ConverAddCommand = new DelegateCommand(ConverAdd);

            ConvertPathFileSearchCommand = new DelegateCommand(ConvertPathFileSearch);

        }

        #endregion

        #region Properties

        DataService.DataServiceClient WcfClient = new DataService.DataServiceClient();

        private static System.Collections.ObjectModel.ObservableCollection<FinalPDF> _ConvertSource;

        public static System.Collections.ObjectModel.ObservableCollection<FinalPDF> ConvertSource

        {

            get

            {

                if (_ConvertSource == null)

                {

                    _ConvertSource = new System.Collections.ObjectModel.ObservableCollection<FinalPDF>();

                }

                return _ConvertSource;

            }

            set

            {

                _ConvertSource = value;

            }

        }

        public ObservableCollection<ProjectName> _ProjectNames;

        public ObservableCollection<ProjectName> ProjectNames

        {

            get

            {

                if (_ProjectNames == null)

                {

                    _ProjectNames = new System.Collections.ObjectModel.ObservableCollection<ProjectName>();

                }

                return _ProjectNames;

            }

            set

            {

                _ProjectNames = value;

                OnPropertyChanged(() => ProjectNames);

            }

        }

        private System.Collections.ObjectModel.ObservableCollection<FinalPDF> _FilterSearch;

        public System.Collections.ObjectModel.ObservableCollection<FinalPDF> FilterSearch

        {

            get

            {

                if (_FilterSearch == null)

                {

                    _FilterSearch = new System.Collections.ObjectModel.ObservableCollection<FinalPDF>

                            {

                                new FinalPDF{ProjectNumber = "Filter Search"}

                            };

                }

                return _FilterSearch;

            }

        }

        private System.Collections.ObjectModel.ObservableCollection<FinalPDF> _AliveItems;

        public System.Collections.ObjectModel.ObservableCollection<FinalPDF> AliveItems

        {

            get => _AliveItems;

            set

            {

                _AliveItems = value;

                OnPropertyChanged(() => AliveItems);

            }

        }

        public ICollectionView FilterConvertSourceView

        {

            get

            {

                var view = CollectionViewSource.GetDefaultView(FilterConvertSource);

                return view;

            }

        }

        private System.Collections.ObjectModel.ObservableCollection<FinalPDF> _FilterConvertSource;

        public System.Collections.ObjectModel.ObservableCollection<FinalPDF> FilterConvertSource

        {

            get

            {

                if (_FilterConvertSource == null)

                {

                    _FilterConvertSource = new System.Collections.ObjectModel.ObservableCollection<FinalPDF>();

                }

                return _FilterConvertSource;

            }

            set

            {

                _FilterConvertSource = value;

                OnPropertyChanged(() => FilterConvertSource);

            }

        }

        private System.Collections.ObjectModel.ObservableCollection<FinalPDF> _RealConvertSource;

        public System.Collections.ObjectModel.ObservableCollection<FinalPDF> RealConvertSource

        {

            get => _RealConvertSource;

            set

            {

                _RealConvertSource = value;

                OnPropertyChanged(() => RealConvertSource);

            }

        }

        private System.Windows.Documents.FlowDocument connectionLog;

        public System.Windows.Documents.FlowDocument ConnectionLog

        {

            get => connectionLog;

            set

            {

                if (connectionLog != value)

                {

                    connectionLog = value;

                    OnPropertyChanged(() => ConnectionLog);

                }

            }

        }

        private int _SelectedInt = 4;

        public int SelectedInt

        {

            get => _SelectedInt;

            set

            {

                _SelectedInt = value;

                OnPropertyChanged(() => SelectedInt);

            }

        }

        private Telerik.Windows.Data.EnumMemberViewModel _SelectedStatus;

        public Telerik.Windows.Data.EnumMemberViewModel SelectedStatus

        {

            get => _SelectedStatus;

            set

            {

                _SelectedStatus = value;

                OnPropertyChanged(() => SelectedStatus);

            }

        }

        private SelectedCountItem _SelectedCount;

        public SelectedCountItem SelectedCount

        {

            get => _SelectedCount;

            set

            {

                _SelectedCount = value;

                OnPropertyChanged(() => SelectedCount);

            }

        }

        List<SelectedCountItem> _SelectedCountList;

        public List<SelectedCountItem> SelectedCountList

        {

            get

            {

                if (_SelectedCountList == null)

                {

                    _SelectedCountList = new List<SelectedCountItem>

                            {

                                new SelectedCountItem{DisplayMember = "50",ValueMember = 50},

                                new SelectedCountItem{DisplayMember = "100",ValueMember = 100},

                                new SelectedCountItem{DisplayMember = "150",ValueMember = 150},

                                new SelectedCountItem{DisplayMember = "200",ValueMember = 200}

                            };

                }

                return _SelectedCountList;

            }

        }

        private FinalPDF _SelectFilterConvert;

        public FinalPDF SelectFilterConvert

        {

            get => _SelectFilterConvert;

            set

            {

                _SelectFilterConvert = value;

                OnPropertyChanged(() => SelectFilterConvert);

            }

        }

        private ObservableCollection<FinalPDF> _SelectFilterConvertList;

        public ObservableCollection<FinalPDF> SelectFilterConvertList

        {

            get

            {

                if (_SelectFilterConvertList == null)

                {

                    _SelectFilterConvertList = new ObservableCollection<FinalPDF>();

                }

                return _SelectFilterConvertList;

            }

            set

            {

                _SelectFilterConvertList = value;

                OnPropertyChanged(() => SelectFilterConvertList);

            }

        }

        private FinalPDF _SelectRealConvert;

        public FinalPDF SelectRealConvert

        {

            get => _SelectRealConvert;

            set

            {

                _SelectRealConvert = value;

                OnPropertyChanged(() => SelectRealConvert);

            }

        }

        private FinalPDF _SelectAliveConvert;

        public FinalPDF SelectAliveConvert

        {

            get => _SelectAliveConvert;

            set

            {

                _SelectAliveConvert = value;

                OnPropertyChanged(() => SelectAliveConvert);

            }

        }

        private StatusTypeList _StatusType;

        public StatusTypeList StatusType

        {

            get => _StatusType;

            set

            {

                _StatusType = value;

                OnPropertyChanged(() => StatusType);

            }

        }

        private bool _IsLoading;

        public bool IsLoading

        {

            get => _IsLoading;

            set

            {

                if (_IsLoading != value)

                {

                    _IsLoading = value;

                    OnPropertyChanged(() => IsLoading);

                }

            }

        }

        IEnumerable<Telerik.Windows.Data.EnumMemberViewModel> _StatusCodeList;

        public IEnumerable<Telerik.Windows.Data.EnumMemberViewModel> StatusCodeList

        {

            get

            {

                if (_StatusCodeList == null)

                {

                    _StatusCodeList = Telerik.Windows.Data.EnumDataSource.FromType<StatusCodeType>();

                }

                return _StatusCodeList;

            }

        }

        public ProjectName _ProjectNumberFilter;

        public ProjectName ProjectNumberFilter

        {

            get

            {

                if (_ProjectNumberFilter == null)

                {

                    _ProjectNumberFilter = new ProjectName();

                }

                return _ProjectNumberFilter;

            }

            set

            {

                _ProjectNumberFilter = value;

                OnPropertyChanged(() => ProjectNumberFilter);

            }

        }

        public string _DocumentIDFilter;

        public string DocumentIDFilter

        {

            get

            {

                return _DocumentIDFilter;

            }

            set

            {

                if (_DocumentIDFilter == "")

                {

                    _DocumentIDFilter = null;

                }

                else if (_DocumentIDFilter != value)

                {

                    _DocumentIDFilter = value;

                    OnPropertyChanged(() => DocumentIDFilter);

                }

            }

        }

        public string _DOCINFO_IDFilter;

        public string DOCINFO_IDFilter

        {

            get

            {

                return _DOCINFO_IDFilter;

            }

            set

            {

                if (_DOCINFO_IDFilter == "")

                {

                    _DOCINFO_IDFilter = null;

                }

                else if (_DOCINFO_IDFilter != value)

                {

                    _DOCINFO_IDFilter = value;

                    OnPropertyChanged(() => DOCINFO_IDFilter);

                }

            }

        }

        public string _Document_URLFilter;

        public string Document_URLFilter

        {

            get

            {

                return _Document_URLFilter;

            }

            set

            {

                if (_Document_URLFilter != value)

                {

                    _Document_URLFilter = value;

                    OnPropertyChanged(() => Document_URLFilter);

                }

            }

        }

        public string _MarkupInfo_IDFilter;

        public string MarkupInfo_IDFilter

        {

            get

            {

                return _MarkupInfo_IDFilter;

            }

            set

            {

                if (_MarkupInfo_IDFilter != value)

                {

                    _MarkupInfo_IDFilter = value;

                    OnPropertyChanged(() => MarkupInfo_IDFilter);

                }

            }

        }

        public string _CreateUser_IDFilter;

        public string CreateUser_IDFilter

        {

            get

            {

                return _CreateUser_IDFilter;

            }

            set

            {

                if (_CreateUser_IDFilter == "")

                {

                    _CreateUser_IDFilter = null;

                }

                else if (_CreateUser_IDFilter != value)

                {

                    _CreateUser_IDFilter = value;

                    OnPropertyChanged(() => CreateUser_IDFilter);

                }

            }

        }

        public string _GROUP_NOFilter;

        public string GROUP_NOFilter

        {

            get

            {

                return _GROUP_NOFilter;

            }

            set

            {

                if (_GROUP_NOFilter == "")

                {

                    _GROUP_NOFilter = null;

                }

                else if (_GROUP_NOFilter != value)

                {

                    _GROUP_NOFilter = value;

                    OnPropertyChanged(() => GROUP_NOFilter);

                }

            }

        }

        public string _REVISIONFilter;

        public string REVISIONFilter

        {

            get

            {

                return _REVISIONFilter;

            }

            set

            {

                if (_REVISIONFilter == "")

                {

                    _REVISIONFilter = null;

                }

                else if (_REVISIONFilter != value)

                {

                    _REVISIONFilter = value;

                    OnPropertyChanged(() => REVISIONFilter);

                }

            }

        }

        public StatusCodeType _ConvertStateFilter;

        public StatusCodeType ConvertStateFilter

        {

            get { return _ConvertStateFilter; }

            set

            {

                if (_ConvertStateFilter != value)

                {

                    _ConvertStateFilter = value;

                    OnPropertyChanged(() => ConvertStateFilter);

                }

            }

        }

        public string _Document_NOFilter;

        public string Document_NOFilter

        {

            get { return _Document_NOFilter; }

            set

            {

                if (_Document_NOFilter == "")

                {

                    _Document_NOFilter = null;

                }

                else if (_Document_NOFilter != value)

                {

                    _Document_NOFilter = value;

                    OnPropertyChanged(() => Document_NOFilter);

                }

            }

        }

        public string _Exception;

        public string Exception

        {

            get { return _Exception; }

            set

            {

                if (_Exception == "")

                {

                    _Exception = null;

                }

                else if (_Exception != value)

                {

                    _Exception = value;

                    OnPropertyChanged(() => Exception);

                }

            }

        }

        public string _Document_NameFilter;

        public string Document_NameFilter

        {

            get { return _Document_NameFilter; }

            set

            {

                if (_Document_NameFilter == "")

                {

                    _Document_NameFilter = null;

                }

                else if (_Document_NameFilter != value)

                {

                    _Document_NameFilter = value;

                    OnPropertyChanged(() => Document_NameFilter);

                }

            }

        }

        static DateTime DefaultCreateTime = DateTime.Now;

        private DateTime _SelectedCreateTimeBegin = DefaultCreateTime;

        public DateTime SelectedCreateTimeBegin

        {

            get { return _SelectedCreateTimeBegin; }

            set

            {

                if (_SelectedCreateTimeBegin == value)

                    return;

                _SelectedCreateTimeBegin = value;

                OnPropertyChanged(() => SelectedCreateTimeBegin);

            }

        }

        private DateTime _SelectedCreateTimeEnd = DefaultCreateTime;

        public DateTime SelectedCreateTimeEnd

        {

            get { return _SelectedCreateTimeEnd; }

            set

            {

                if (_SelectedCreateTimeEnd == value)

                    return;

                _SelectedCreateTimeEnd = value;

                OnPropertyChanged(() => SelectedCreateTimeEnd);

            }

        }

        public int _DataBase_ItemsHeight = 800;

        public int DataBase_ItemsHeight

        {

            get { return _DataBase_ItemsHeight; }

            set

            {

                _DataBase_ItemsHeight = value;

                OnPropertyChanged(() => DataBase_ItemsHeight);

            }

        }

        public int _RealConvert_Height = 80;

        public int RealConvert_Height

        {

            get { return _RealConvert_Height; }

            set

            {

                _RealConvert_Height = value;

                OnPropertyChanged(() => RealConvert_Height);

            }

        }

        public int _Alive_Height = 80;

        public int Alive_Height

        {

            get { return _Alive_Height; }

            set

            {

                _Alive_Height = value;

                OnPropertyChanged(() => Alive_Height);

            }

        }

        public bool _ConvertShow;

        public bool ConvertShow

        {

            get => _ConvertShow;

            set

            {

                if (_ConvertShow = !value)

                {

                    _ConvertShow = false;

                }

                _ConvertShow = value;

                OnPropertyChanged(() => ConvertShow);

            }

        }

        private bool _ExcptionCheck = false;

        public bool ExcptionCheck

        {

            get

            {

                return _ExcptionCheck;

            }

            set

            {

                _ExcptionCheck = value;

                OnPropertyChanged(() => ExcptionCheck);

            }

        }

        #endregion

        #region Command

        public DelegateCommand ConvertCommand { get; private set; }

        public DelegateCommand DeleteCommand { get; private set; }

        public DelegateCommand ValidateCommand { get; private set; }

        public DelegateCommand DataSaveFileGemBoxCommand { get; private set; }

        public DelegateCommand MarkusLinkCommand { get; private set; }

        public DelegateCommand RemoveCreateTimeFilterCommand { get; private set; }

        public DelegateCommand DataFilterCommand { get; private set; }

        public DelegateCommand ResetCommand { get; private set; }

        public DelegateCommand ConverAddCommand { get; private set; }

        public DelegateCommand ConvertPathFileSearchCommand { get; private set; }

        #endregion

        #region Main Logic

        /// <summary>

        /// 각각의 Grid row 객체들 업데이트

        /// </summary>

        private DispatcherTimer dispatcherTimer;

        public override void Loaded()

        {

            base.Loaded();

            if (!App.IsDesignMode)

            {

                dispatcherTimer = new DispatcherTimer();

                dispatcherTimer.Tick += new EventHandler(Timer_Tick);

                dispatcherTimer.Interval = new TimeSpan(0, 0, 1);

                dispatcherTimer.Start();

            }

        }

        private async void Timer_Tick(object sender, EventArgs e)

        {

            dispatcherTimer.Stop();

            if (IsAcitve)

            {

                await App.Current.Dispatcher.InvokeAsync(() =>

                {

                    DataSelect();

                    AliveDataSelect();

                });

            }

            await Task.Delay(5000);

            System.Threading.Thread.Sleep(new TimeSpan(0, 0, 0, 0, 100));

            dispatcherTimer.Start();

        }

        private async void SearchTimer_Tick(object sender, EventArgs e)

        {

            dispatcherTimer.Stop();

            if (IsAcitve)

            {

                await App.Current.Dispatcher.InvokeAsync(() =>

                {

                    DataSearch(new[] { (StatusCodeType)(SelectedStatus.Value) }, FilterConvertSource);

                    RealDataSelect(new[] { StatusCodeType.None, StatusCodeType.Wait, StatusCodeType.PageLoading, StatusCodeType.Saving }, RealConvertSource);

                    AliveDataSelect();

                });

            }

            await Task.Delay(5000);

            //await Task.Delay(10000);

            //System.Threading.Thread.Sleep(new TimeSpan(0,0,0,0,100));

            dispatcherTimer.Start();

        }

        public override void Closed()

        {

            if (dispatcherTimer != null)

            {

                dispatcherTimer.Stop();

            }

            base.Closed();

        }

        #endregion

        #region Function

        #region Return_FilterConvertSource

        public static void Return_FilterConvertSource(ObservableCollection<FinalPDF> convertPDFs)

        {

            ConvertSource = new ObservableCollection<FinalPDF>();

            ConvertSource = convertPDFs;

        }

        public static ObservableCollection<FinalPDF> Return_FilterConvertSource()

        {

            return ConvertSource;

        }

        #endregion

        #region Data Select

        /// <summary>

        /// 상단 그리드 중앙 그리드 출력 데이터

        /// </summary>

        private void DataSelect()

        {

            if (FilterConvertSource == null)

            {

                FilterConvertSource = new System.Collections.ObjectModel.ObservableCollection<FinalPDF>();

            }

            if (RealConvertSource == null)

            {

                RealConvertSource = new System.Collections.ObjectModel.ObservableCollection<FinalPDF>();

            }

            /// combobox 에서 선택된 items

            if (SelectedStatus != null)

            {

                DataSelect(new[] { (StatusCodeType)(SelectedStatus.Value) }, FilterConvertSource);

            }

            /// 컨버터중인 items

            RealDataSelect(new[] { StatusCodeType.None, StatusCodeType.Wait, StatusCodeType.PageLoading, StatusCodeType.Saving }, RealConvertSource);

        }

        private async void RealDataSelect(IEnumerable<StatusCodeType> statusCodeTypeList, System.Collections.ObjectModel.ObservableCollection<FinalPDF> collection)

        {

            try

            {

                IEnumerable<FinalPDF> Listitems = Enumerable.Empty<FinalPDF>();

                foreach (var coll in collection)

                {

                   Listitems = from x in await WcfClient.GET_SELECT_FINAL_PDF_ITEMAsync(coll.ConvertID, coll.ProjectNumber, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null)

                                let MarkusLink = "kcom://" + CreateMarkusParam(x.PROJECT_NO, x.DOCUMENT_ID, "doftech")

                                select new FinalPDF(x.ID, x.PROJECT_NO, x.STATUS, x.DOCUMENT_ID, x.MARKUPINFO_ID, x.DOCINFO_ID, x.DOCUMENT_NAME, x.DOCUMENT_NO, x.CREATE_USER_ID, x.REVISION, x.CURRENT_PAGE,

                            x.TOTAL_PAGE, x.EXCEPTION, x.GROUP_NO, x.CREATE_DATETIME, x.START_DATETIME, x.END_DATETIME, x.ORIGINAL_FILE, x.CONVERT_PATH, MarkusLink);

                }

                foreach (var Listitem in Listitems)

                {

                    collection.UpdateWhere(changeitem =>

                    ConvertItemEx.ChangeValues(changeitem, Listitem), x => x.ProjectNumber == Listitem.ProjectNumber && x.ConvertID == Listitem.ConvertID);

                }

                RealConvert_Height = 80 + (10 * collection.Count());

                DataBase_ItemsHeight = 800 - (RealConvert_Height + Alive_Height);

            }

            catch (Exception ex)

            {

                MessageBox.Show(ex.ToString());

            }

        }

        private async void DataSelect(IEnumerable<StatusCodeType> statusCodeTypeList, System.Collections.ObjectModel.ObservableCollection<FinalPDF> collection)

        {

            try

            {

                int _status = 0;

                if (SelectedStatus != null)

                {

                    _status = (int)SelectedStatus.Value;

                }

                if (ProjectNames.Count() == 0)

                {

                    ProjectName Clear = new ProjectName("Clear", "Clear");

                    ProjectNames.Add(Clear);

                    foreach (var x in await WcfClient.GET_SELECT_RUN_PROJECTSAsync(0))

                    {

                        ProjectName projectName = new ProjectName(x.PROJECT_NO, x.PROJECT_NAME);

                        ProjectNames.Add(projectName);

                    }

                }

                var Listitems = from x in await WcfClient.GET_SELECT_FINAL_PDF_ITEMAsync(null, null, null, null, null, null, null, null, _status, SelectedCount.ValueMember, null, null, null, null, null, null, null, null, null, null)

                                let MarkusLink = "kcom://" + CreateMarkusParam(x.ID, x.DOCUMENT_ID, "doftech")

                                select new FinalPDF(x.ID, x.PROJECT_NO, x.STATUS, x.DOCUMENT_ID, x.MARKUPINFO_ID, x.DOCINFO_ID, x.DOCUMENT_NAME, x.DOCUMENT_NO, x.CREATE_USER_ID,

                        x.REVISION, x.CURRENT_PAGE, x.TOTAL_PAGE, x.EXCEPTION, x.GROUP_NO, x.CREATE_DATETIME, x.START_DATETIME, x.END_DATETIME

                     , x.ORIGINAL_FILE, x.CONVERT_PATH, MarkusLink);

                if (collection.Count() == 0)

                {

                    if (statusCodeTypeList.Count() == 1)

                    {

                        foreach (var x in Listitems)

                        {

                            collection.Add(x);

                        }

                    }

                }

                else

                {

                    foreach (var newitem in Listitems)

                    {

                        collection.UpdateWhere(changeitem =>

                        ConvertItemEx.ChangeValues(changeitem, newitem), x => x.ProjectNumber == newitem.ProjectNumber && x.ConvertID == newitem.ConvertID);

                    }

                    if (statusCodeTypeList.Count() == 1)

                    {

                        for (int i = collection.Count() - 1; i >= 0; --i)

                        {

                            var item = collection[i];

                            if (Listitems.Count(x => x.ConvertID == item.ConvertID && x.ProjectNumber == item.ProjectNumber) == 0)

                            {

                                collection.RemoveAt(i);

                            }

                        }

                    }

                    if (statusCodeTypeList.Count() == 1)

                    {

                        foreach (var item in Listitems)

                        {

                            if (collection.Count(x => x.ConvertID == item.ConvertID && x.ProjectNumber == item.ProjectNumber) == 0)

                            {

                                for (int i = 0; i < 200; i++)

                                {

                                    if (i < collection.Count() - 1)

                                    {

                                        if (DateTime.Compare(collection[i].CreateTime, item.CreateTime) < 0)

                                        {

                                            collection.Insert(i, item);

                                            break;

                                        }

                                    }

                                    else

                                    {

                                        collection.Add(item);

                                        break;

                                    }

                                }

                            }

                        }

                    }

                }

            }

            catch (Exception ex)

            {

                MessageBox.Show(ex.ToString());

                System.Diagnostics.Debug.WriteLine(ex.ToString());

            }

        }

        private async void DataSearch(IEnumerable<StatusCodeType> statusCodeTypeList, System.Collections.ObjectModel.ObservableCollection<FinalPDF> collection)

        {

            try

            {

                int _status = 0;

                if (SelectedStatus != null)

                {

                    _status = (int)SelectedStatus.Value;

                }

                DateTime? Start_CreateTime = null;

                DateTime? Finish_CreateTime = null;

                if (SelectedCreateTimeBegin != DefaultCreateTime)

                {

                    Start_CreateTime = SelectedCreateTimeBegin;

                }

                if (SelectedCreateTimeEnd != DefaultCreateTime)

                {

                    Finish_CreateTime = SelectedCreateTimeEnd;

                }

                if (ProjectNames.Count() == 0)

                {

                    foreach (var x in await WcfClient.GET_SELECT_RUN_PROJECTSAsync(0))

                    {

                        ProjectName projectName = new ProjectName(x.PROJECT_NO, x.PROJECT_NAME);

                        ProjectNames.Add(projectName);

                    }

                }

                var Listitems = from x in await WcfClient.GET_SELECT_FINAL_PDF_ITEMAsync(null, ProjectNumberFilter.Project_NO, DocumentIDFilter, MarkupInfo_IDFilter, DOCINFO_IDFilter, Document_NameFilter, Document_NOFilter,

                    CreateUser_IDFilter, _status, SelectedCount.ValueMember, GROUP_NOFilter, REVISIONFilter, Start_CreateTime, Finish_CreateTime, null, null, null, null, Document_URLFilter, ExcptionCheck)

                                let MarkusLink = "kcom://" + CreateMarkusParam(x.ID, x.DOCUMENT_ID, "doftech")

                                select new FinalPDF(x.ID, x.PROJECT_NO, _status, x.DOCUMENT_ID, x.MARKUPINFO_ID, x.DOCINFO_ID, x.DOCUMENT_NAME, x.DOCUMENT_NO, x.CREATE_USER_ID,

                                    x.REVISION, x.CURRENT_PAGE, x.TOTAL_PAGE, x.EXCEPTION, x.GROUP_NO, x.CREATE_DATETIME, x.START_DATETIME, x.END_DATETIME

                                 , x.ORIGINAL_FILE, x.CONVERT_PATH, MarkusLink);

                if (collection.Count() == 0)

                {

                    if (statusCodeTypeList.Count() == 1)

                    {

                        foreach (var x in Listitems)

                        {

                            collection.Add(x);

                        }

                    }

                }

                else

                {

                    foreach (var newitem in Listitems)

                    {

                        collection.UpdateWhere(changeitem =>

                        ConvertItemEx.ChangeValues(changeitem, newitem), x => x.ProjectNumber == newitem.ProjectNumber && x.ConvertID == newitem.ConvertID);

                    }

                    if (statusCodeTypeList.Count() == 1)

                    {

                        for (int i = collection.Count() - 1; i >= 0; --i)

                        {

                            var item = collection[i];

                            if (Listitems.Count(x => x.ConvertID == item.ConvertID && x.ProjectNumber == item.ProjectNumber) == 0)

                            {

                                collection.RemoveAt(i);

                            }

                        }

                    }

                    if (statusCodeTypeList.Count() == 1)

                    {

                        foreach (var item in Listitems)

                        {

                            if (collection.Count(x => x.ConvertID == item.ConvertID && x.ProjectNumber == item.ProjectNumber) == 0)

                            {

                                for (int i = 0; i < 200; i++)

                                {

                                    if (i < collection.Count() - 1)

                                    {

                                        if (DateTime.Compare(collection[i].CreateTime, item.CreateTime) < 0)

                                        {

                                            collection.Insert(i, item);

                                            break;

                                        }

                                    }

                                    else

                                    {

                                        collection.Add(item);

                                        break;

                                    }

                                }

                            }

                        }

                    }

                }

            }

            catch (Exception ex)

            {

                MessageBox.Show(ex.ToString());

                System.Diagnostics.Debug.WriteLine(ex.ToString());

            }

        }

        /// <summary>

        /// 서비스의 실시간 컨버터 Item

        /// </summary>

        private async void AliveDataSelect()

        {

            try

            {

                List<FinalPDF> newitems = new List<FinalPDF>();

                foreach (var client in App.StationClientList)

                {

                    if (await SimplePingAsync(client.Endpoint.Address.ToString()))

                    {

                        try

                        {

                            List<FinalPDF> itemsToList = new List<FinalPDF>();

                            var items = await client.AliveConvertListAsync();

                            string result = "";

                            foreach (var item in items)

                            {

                                FinalPDF itemsToEach = new FinalPDF();

                                itemsToEach.ConvertID = item.ConvertID;

                                itemsToEach.ProjectNumber = item.ProjectNumber;

                                var MarkusLink = "kcom://" + CreateMarkusParam(item.ProjectNumber, item.DocumentID, "doftech");

                                //var convertpath = GetSearchConvertPathAndMarkus(item.ProjectNumber, item.UniqueKey);

                                if (item.ConvertState != null)

                                {

                                    itemsToEach.ConvertState = (StatusCodeType)Enum.Parse(typeof(StatusCodeType), item.ConvertState);

                                }

                                if (item.OriginfilePath.Contains("/"))

                                {

                                    result = item.OriginfilePath.Substring(item.OriginfilePath.LastIndexOf("/") + 1);

                                }

                                else

                                {

                                    result = item.OriginfilePath.Substring(item.OriginfilePath.LastIndexOf("%") + 1);

                                }

                                itemsToEach.FileName = result;

                                itemsToEach.CurrentPageNo = item.CurrentPageNo;

                                itemsToEach.TotalPage = item.TotalPage;

                                itemsToEach.OriginfilePath = item.OriginfilePath;

                                itemsToEach.ConvertPath = item.ConvertPath;

                                itemsToEach.MarkusLink = MarkusLink;

                                itemsToEach.DocumentID = item.DocumentID;

                                itemsToEach.GroupNo = item.GroupNo;

                                itemsToEach.DocumentName = item.DocumnetName;

                                itemsToEach.Revision = item.Revision;

                                itemsToEach.Exception = item.Exception;

                                itemsToEach.ConvertPath = item.ConvertPath;

                                itemsToEach.CreateTime = item.CreateTime;

                                itemsToEach.StartTime = item.StartTime;

                                itemsToEach.EndTime = item.EndTime;

                                //itemsToEach.MarkupInfo_ID = 

                                //itemsToEach.DocInfo_ID =

                                //itemsToEach.Create_User_ID =

                                itemsToList.Add(itemsToEach);

                            }

                            newitems.AddRange(itemsToList);

                            System.Diagnostics.Trace.WriteLine($"{client.Endpoint.Address} ping");

                            if (items.Count() == 0)

                            {

                                System.Diagnostics.Trace.WriteLine($"{client.Endpoint.Address} Alive Items is zero.");

                            }

                        }

                        catch (Exception ex)

                        {

                            System.Diagnostics.Trace.Fail($"{client.Endpoint.Address} {ex.Message}");

                        }

                    }

                    else

                    {

                        System.Diagnostics.Trace.Fail($"{client.Endpoint.Address} ping Error");

                    }

                }

                ItemsUpdate(newitems);

                await System.Windows.Application.Current.Dispatcher.InvokeAsync(() => ItemsUpdate(newitems));

            }

            catch (Exception ex)

            {

                System.Diagnostics.Debug.WriteLine(ex.ToString());

            }

        }

        /// <summary>

        /// AliveDataSelect의 Data Update

        /// </summary>

        /// <param name = "newitems" ></ param >

        private void ItemsUpdate(List<FinalPDF> newitems)

        {

            foreach (var item in newitems)

            {

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

            }

            if (AliveItems == null)

            {

                AliveItems = new System.Collections.ObjectModel.ObservableCollection<FinalPDF>();

                foreach (var item in newitems)

                {

                    AliveItems.Add(item);

                }

            }

            else

            {

                // 데이터 업데이트

                newitems.ForEach(newitem =>

                {

                    AliveItems.UpdateWhere(changeitem => ConvertItemEx.ChangeValues(changeitem, newitem), x => x.ProjectNumber == newitem.ProjectNumber && x.ConvertID == newitem.ConvertID);

                });

                ///추가

                foreach (var item in newitems)

                {

                    if (AliveItems.Count(x => x.ConvertID == item.ConvertID && x.ProjectNumber == item.ProjectNumber) == 0)

                    {

                        AliveItems.Add(item);

                    }

                }

                // 삭제

                for (int i = AliveItems.Count() - 1; i > -1; --i)

                {

                    var item = AliveItems[i];

                    if (newitems.Count(x => x.ConvertID == item.ConvertID && x.ProjectNumber == item.ProjectNumber) == 0)

                    {

                        try

                        {

                            AliveItems.RemoveAt(i);

                        }

                        catch (Exception ex)

                        {

                            System.Diagnostics.Debug.WriteLine(ex.ToString());

                        }

                    }

                }

            }

            Alive_Height = 80 + (newitems.Count() * 10);

            DataBase_ItemsHeight = 800 - (RealConvert_Height + Alive_Height);

        }

        public static async Task<bool> SimplePingAsync(string uri)

        {

            bool result = false;

            try

            {

                using (System.Net.Http.HttpClient Client = new System.Net.Http.HttpClient())

                {

                    Client.Timeout = new TimeSpan(0, 0, 60);

                    var message = await Client.GetAsync(uri);

                    System.Net.HttpStatusCode StatusCode = message.StatusCode;

                    switch (StatusCode)

                    {

                        case System.Net.HttpStatusCode.Accepted:

                        case System.Net.HttpStatusCode.OK:

                            result = true;

                            break;

                    }

                }

            }

            catch (Exception ex)

            {

                result = false;

                System.Diagnostics.Debug.WriteLine(ex.ToString());

            }

            return result;

        }

        #endregion

        #region Data Convert

        private async void DataConvert(object obj)

        {

            if (SelectFilterConvert == null && SelectRealConvert == null)

            {

                MessageBox.Show("왼쪽 버튼 클릭 후 Converter 해주세요!");

            }

            else

            {

                //ConvertDatabase _DataConvert = new ConvertDatabase(App.MarkusDataBaseConnecitonString);

                var resultRealConvert = 0;

                var resultFiltertConvert = 0;

                if (SelectRealConvert != null)

                {

                    //resultRealConvert = _DataConvert.SetCleanUpItem(SelectRealConvert);//ConvertDataBase

                    resultRealConvert = SetCleanUpItem(SelectRealConvert).Result;//ConvertDataBase

                }

                else if (SelectFilterConvert != null)

                {

                    //resultFiltertConvert = _DataConvert.SetCleanUpItem(SelectFilterConvert);//ConvertDataBase

                    resultFiltertConvert = SetCleanUpItem(SelectFilterConvert).Result;

                }

                System.Diagnostics.Debug.WriteLine(resultRealConvert + "  " + resultFiltertConvert);

                var items = from x in await WcfClient.GET_SELECT_FINAL_PDF_ITEMAsync(SelectFilterConvert.ConvertID, null, null, null, null, null, null, null, null, 1, null, null, null, null, null, null, null, null, null, null)

                            let MarkusLink = "kcom://" + CreateMarkusParam(x.ID, x.DOCUMENT_ID, "doftech")

                            select new FinalPDF(x.ID, x.PROJECT_NO, x.STATUS, x.DOCUMENT_ID, x.MARKUPINFO_ID, x.DOCINFO_ID, x.DOCUMENT_NAME, x.DOCUMENT_NO, x.CREATE_USER_ID,

                        x.REVISION, x.CURRENT_PAGE, x.TOTAL_PAGE, x.EXCEPTION, x.GROUP_NO, x.CREATE_DATETIME, x.START_DATETIME, x.END_DATETIME

                     , x.ORIGINAL_FILE, x.CONVERT_PATH, MarkusLink);

                foreach (var item in items)

                {

                    RealConvertSource.Add(item);

                    if (RealConvertSource.Count() == 1)

                    {

                        ConvertShow = true;

                    }

                }

            }

        }

        public async Task<int> SetCleanUpItem(FinalPDF _ConvertItem)

        {

            int result = 0;

            var items = await WcfClient.GET_SELECT_FINAL_PDF_ITEMAsync(_ConvertItem.ConvertID, null, null, null, null, null, null, null, null, 1, null, null, null, null, null, null, null, null, null, null);

            if (items.Count() > 0)

            {

                var item = items.First();

                var _CREATE_DATETIME = DateTime.Now;

                var _STATUS = (int)StatusCodeType.None;

                await WcfClient.GET_SELECT_RERECONVERT_ITEMAsync(_ConvertItem.ConvertID, 0, _CREATE_DATETIME, _STATUS, null);//_END_DATETIME = null 에러

            }

            return result;

        }

        //public string[] GetSearchConvertPathAndMarkus(string PROJECT_NO, string DOCUMENT_ID)

        //{

        //    string[] ConvertPath = new string[2];

        //    ConvertPath[0] = GetConvertPath(PROJECT_NO, DOCUMENT_ID);

        //    ConvertPath[1] = "kcom://" + CreateMarkusParam(PROJECT_NO, DOCUMENT_ID, "doftech");

        //    return ConvertPath;

        //}

        public static string CreateMarkusParam(string projectNo, string documentID, string userID)

        {

            ViewInfo viewInfo = new ViewInfo();

            viewInfo.DocumentItemID = documentID;

            viewInfo.ProjectNO = projectNo;

            viewInfo.UserID = userID;

            return ParamEncoding(JsonConvert.SerializeObject(viewInfo));

        }

        public static string ParamEncoding(string EncodingText, System.Text.Encoding oEncoding = null)

        {

            if (oEncoding == null)

                oEncoding = System.Text.Encoding.UTF8;

            return Convert.ToBase64String(oEncoding.GetBytes(EncodingText));

        }

        #region Convert Path

        //private string GetConvertPath(string ProjectNo, string DocumentID)

        //{

        //    try

        //    {

        //        return Path.Combine(BaseStorage(ProjectNo), ProjectNo + "_Tile", (System.Convert.ToInt64(DocumentID) / 100).ToString(), DocumentID);

        //    }

        //    catch (Exception)

        //    {

        //        throw new Exception("GetConvertPath Error");

        //    }

        //}

        //private async string BaseStorage(string ProjectNo)

        //{

        //    using (markusEntities entities = new markusEntities(App.MarkusDataBaseConnecitonString))

        //    {

        //        string result = "";

        //        var properties = await WcfClient.GET_SELECT_FINAL_PDF_ITEM(null, ProjectNo, null, null, null, null, null, null, null, 1, null, null, null, null,

        //                null, null, null, null, null);

        //        if (properties.Count() > 0)

        //        {

        //            result = properties.First().PROPERTIES_VALUE;

        //        }

        //        else

        //        {

        //            throw new Exception($"Project {ProjectNo} BaseStorage Not Setting.");

        //        }

        //        return result;

        //    }

        //}

        #endregion

        #endregion

        #region Validation

        private void DataValidate(object obj)

        {

            bool result = false;

            WebRequest webRequest = WebRequest.Create(SelectFilterConvert.OriginfilePath);

            webRequest.Timeout = 1200; // miliseconds

            webRequest.Method = "HEAD";

            HttpWebResponse response = null;

            try

            {

                response = (HttpWebResponse)webRequest.GetResponse();

                result = true;

            }

            catch (WebException webException)

            {

                MessageBox.Show(SelectFilterConvert.FileName + " doesn't exist: " + webException.Message);

                result = true;

            }

            finally

            {

                if (response != null)

                {

                    response.Close();

                }

            }

            if (result == true)

            {

                MessageBox.Show("File exists");

            }

        }

        #endregion

        #region DataFilter

        public void DataFilter(object obj)

        {

            dispatcherTimer.Tick -= new EventHandler(Timer_Tick);

            dispatcherTimer.Tick += new EventHandler(SearchTimer_Tick);

            //DataSearch(new[] { (StatusCodeType)(SelectedStatus.Value) }, FilterConvertSource);

        }

        #endregion

        #region MarkusLink

        private void MarkusLink(object obj)///여기서 부터 

        {

            if (obj is FinalPDF)

            {

                if (obj != null)

                {

                    var convertitem = obj as FinalPDF;

                    //SelectFilterConvert = convertitem;

                    SelectFilterConvertList.Add(convertitem);

                    SelectRealConvert = convertitem;

                    ProcessStartInfo startInfo = null;

                    startInfo = new ProcessStartInfo("iexplore.exe", convertitem.MarkusLink);

                    Process.Start(startInfo);

                }

            }

        }

        #endregion

        #region Data Delete

        private void DataDelete(object obj)

        {

            RadWindow.Alert("do you want to delete it??", this.OnClosed);

        }

        private async void OnClosed(object sender, WindowClosedEventArgs e)

        {

            var result = e.DialogResult;

            if (result == true)

            {

                if (SelectFilterConvertList.Count() > 1)

                {

                    MessageBox.Show("하나만 클릭해 주세요!");

                }

                else

                {

                    if (SelectRealConvert != null)

                    {

                        await WcfClient.GET_SELECT_CONVERT_DELETEAsync(SelectRealConvert.ConvertID);

                    }

                    if (SelectFilterConvertList != null)

                    {

                        await WcfClient.GET_SELECT_CONVERT_DELETEAsync(SelectFilterConvertList[0].ConvertID);

                    }

                }

            }

        }

        #endregion

        #region Data Export

        /// <summary>

        /// 필터된 상단 그리드 엑셀로 출력

        /// </summary>

        public void DataExportData(object obj)

        {

            dispatcherTimer.Tick -= new EventHandler(Timer_Tick);

            Return_FilterConvertSource(FilterConvertSource);

            Views.FinalPDFExcelDialog finalPDFExcelDialog = new Views.FinalPDFExcelDialog();

            finalPDFExcelDialog.Owner = Application.Current.MainWindow;

            finalPDFExcelDialog.WindowStartupLocation = WindowStartupLocation.CenterOwner;

            finalPDFExcelDialog.ShowDialog();

            dispatcherTimer.Tick += new EventHandler(Timer_Tick);

        }

        #endregion

        #region Data Search

        public void RemoveCreateTimeFilter(object obj)

        {

            DefaultCreateTime = DateTime.Now;

            SelectedCreateTimeBegin = DefaultCreateTime;

            SelectedCreateTimeEnd = DefaultCreateTime;

        }

        #endregion

        #region Reset

        /// <summary>

        /// 그리드 상단 원상복귀 버튼

        /// 필터를 끝낸 후 다시 복귀

        /// </summary>

        public void Reset(object obj)

        {

            SelectedInt = 10;

            ProjectNumberFilter = ProjectNames[0];

            DocumentIDFilter = null;

            MarkupInfo_IDFilter = null;

            DOCINFO_IDFilter = null;

            Document_NameFilter = null;

            Document_NOFilter = null;

            CreateUser_IDFilter = null;

            GROUP_NOFilter = null;

            REVISIONFilter = null;

            DefaultCreateTime = DateTime.Now;

            SelectedCreateTimeBegin = DefaultCreateTime;

            SelectedCreateTimeEnd = DefaultCreateTime;

            dispatcherTimer.Tick -= new EventHandler(SearchTimer_Tick);

            dispatcherTimer.Tick += new EventHandler(Timer_Tick);

        }

        #endregion

        #region ConvertAddDialog

        /// <summary>

        /// 그리드 상단 Conver 추가 버튼

        /// ProjectNo, DocumentURL, DocumentID, 입력해서 저장 프로시저에서 추가 

        /// </summary>

        public void ConverAdd(object obj)

        {

            dispatcherTimer.Tick -= new EventHandler(Timer_Tick);

            Views.FinalPDFAddDialog convertAddDialog = new Views.FinalPDFAddDialog();

            convertAddDialog.WindowStartupLocation = WindowStartupLocation.CenterOwner;

            convertAddDialog.ShowDialog();

            dispatcherTimer.Tick += new EventHandler(Timer_Tick);

        }

        #endregion

        #region ConvertPathFileSearch

        /// <summary>

        ///  ConvertPath 파일 탐색기로 열리는 아이콘

        /// </summary>

        public void ConvertPathFileSearch(object obj)

        {

            if (obj is FinalPDF)

            {

                if (obj != null)

                {

                    var convertitem = obj as ConvertPDF;

                    SaveFileDialog saveFileDialog = new SaveFileDialog();

                    saveFileDialog.FileName = "Document"; // Default file name

                    saveFileDialog.DefaultExt = ".txt"; // Default file extension

                    saveFileDialog.Filter = "Csv documents (.Csv)|*.csv|Excel(2017~2019)Worksheets|*.xlsx"; // Filter files by extension

                    if (saveFileDialog.ShowDialog() == true)

                    {

                    }

                }

            }

        }