MARKUS

using GemBox.Spreadsheet;

using Markus.Message;

using Markus.Service.DataBase;

using Markus.Service.Extensions;

using Markus.Service.StationController.Behaviors;

using Markus.Service.StationController.Extensions;

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;

namespace Markus.Service.StationController.ViewModel

{

    //세미

    public class DataBaseItemsModel : Mvvm.ToolKit.ViewModelBase

    {

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

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

        {

            get => _AliveItems; set

            {

                _AliveItems = value;

                OnPropertyChanged(() => AliveItems);

            }

        }

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

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

        {

            get => _FilterConvertSource;

            set

            {

                _FilterConvertSource = value;

                OnPropertyChanged(() => FilterConvertSource);

            }

        }

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

        public System.Collections.ObjectModel.ObservableCollection<ConvertItem> 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);

                }

            }

        }

        //public AliveViewModel()

        //{

        //}

        //// 진행률에 변화가 있을때 이벤트가 발생

        //private void backgroundWorker_ProgressChanged(object sender, ProgressChangedEventArgs e)

        //{

        //}

        //// 일이 모두 마쳤을때 수행되어야할 코드

        //private void backgroundWorker_RunWorkerCompleted(object sender, RunWorkerCompletedEventArgs e)

        //{

        //}

        // BackgroundWorker에서 수행할 일을 정의.

        private void AlivebackgroundWorker_ProgressChanged(object sender, ProgressChangedEventArgs e)

        {

        }

        private void AlivebackgroundWorker_RunWorkerCompleted(object sender, RunWorkerCompletedEventArgs e)

        {

        }

        private async void AlivebackgroundWorker_DoWork(object sender, DoWorkEventArgs e)

        {

            while (IsAcitve)

            {

                if (!IsLoading)

                {

                    IsLoading = true;

                    try

                    {

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

                        foreach (var client in App.StationClientList)

                        {

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

                            {

                                try

                                {

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

                                    var items = await client.AliveConvertListAsync();

                                    foreach (var item in items)

                                    {

                                        ConvertItem itemsToEach = new ConvertItem();

                                        itemsToEach.ServiceID = item.ServiceID;

                                        itemsToEach.ConvertID = item.ConvertID;

                                        itemsToEach.ProjectNumber = item.ProjectNumber;

                                        try

                                        {

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

                                        }

                                        catch (Exception ex)

                                        {

                                            throw ex;

                                        }

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

                                        itemsToEach.CurrentPageNo = item.CurrentPageNo;

                                        itemsToEach.TotalPage = item.TotalPage;

                                        itemsToEach.OriginfilePath = item.OriginfilePath;

                                        itemsToEach.ConvertPath = item.ConvertPath;

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

                            }

                        }

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

                    }

                    catch (Exception ex)

                    {

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

                    }

                    IsLoading = false;

                }

            }

        }

        private async void AliveDataSelect()

        {

            try

            {

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

                foreach (var client in App.StationClientList)

                {

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

                    {

                        try

                        {

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

                            var items = await client.AliveConvertListAsync();

                            foreach (var item in items)

                            {

                                ConvertItem itemsToEach = new ConvertItem();

                                itemsToEach.ServiceID = item.ServiceID;

                                itemsToEach.ConvertID = item.ConvertID;

                                itemsToEach.ProjectNumber = item.ProjectNumber;

                                try

                                {

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

                                }

                                catch (Exception ex)

                                {

                                    throw ex;

                                }

                                itemsToEach.CurrentPageNo = item.CurrentPageNo;

                                itemsToEach.TotalPage = item.TotalPage;

                                itemsToEach.OriginfilePath = item.OriginfilePath;

                                itemsToEach.ConvertPath = item.ConvertPath;

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

            }

        }

        private void ItemsUpdate(List<ConvertItem> newitems)

        {

            foreach (var item in newitems)

            {

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

            }

            if (AliveItems == null)

            {

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

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

                        }

                    }

                }

            }

        }

        private void LogWrite(string log, bool IsError)

        {

            if (IsError)

            {

                System.Diagnostics.Trace.Fail(log);

            }

            else

            {

                System.Diagnostics.Trace.TraceInformation(log);

            }

        }

        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;

        }

        BackgroundWorker backgroundWorker;

        private BackgroundWorker AlivebackgroundWorker;

        Random rnd = new Random();

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

            }

        }

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

                }

                else if (SelectFilterConvert != null)

                {

                    resultFiltertConvert = _DataConvert.SetCleanUpItem(SelectFilterConvert);

                }

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

                using (Markus.Service.DataBase.ConvertDatabase database = new Markus.Service.DataBase.ConvertDatabase(App.MarkusDataBaseConnecitonString))

                {

                    var items = database.GetConvertProjects(SelectFilterConvert);

                    foreach (var item in items)

                    {

                        RealConvertSource.Add(item);

                    }

                }

            }

        }

        private void DataDelete(object obj)

        {

            RadWindow.Alert("정말로 삭제 하시겠습니까?", this.OnClosed);

        }

        private void OnClosed(object sender, WindowClosedEventArgs e)

        {

            var result = e.DialogResult;

            if (result == true)

            {

                ConvertDatabase _DataConvert = new ConvertDatabase(App.MarkusDataBaseConnecitonString);

                var resultRealConvert = _DataConvert.RemoveItem(SelectRealConvert.ConvertID);

                var resultFiltertConvert = _DataConvert.RemoveItem(SelectFilterConvert.ConvertID);

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

            }

        }

        private void DataValidate(object obj)

        {

            MessageBox.Show("파일 체크 할껀데 정상인지 아닌지 ");

        }

        private ConvertItem _SelectFilterConvert;

        public ConvertItem SelectFilterConvert

        {

            get => _SelectFilterConvert;

            set

            {

                _SelectFilterConvert = value;

                OnPropertyChanged(() => SelectFilterConvert);

            }

        }

        private ConvertItem _SelectRealConvert;

        public ConvertItem SelectRealConvert

        {

            get => _SelectRealConvert;

            set

            {

                _SelectRealConvert = value;

                OnPropertyChanged(() => SelectRealConvert);

            }

        }

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

                }

            }

        }

        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;

            }

        }

        public DelegateCommand ConvertCommand { get; private set; }

        public DelegateCommand DeleteCommand { get; private set; }

        public DelegateCommand ValidateCommand { get; private set; }

        public DataBaseItemsModel()

        {

            DataSaveFileGemBoxCommand = new DelegateCommand(DataExportData);

            ConvertCommand = new DelegateCommand(DataConvert);

            DeleteCommand = new DelegateCommand(DataDelete);

            ValidateCommand = new DelegateCommand(DataValidate);

        }

        // 진행률에 변화가 있을때 이벤트가 발생

        private void backgroundWorker_ProgressChanged(object sender, ProgressChangedEventArgs e)

        {

            MessageBox.Show("진행률에 변화");

        }

        // 일이 모두 마쳤을때 수행되어야할 코드

        private void backgroundWorker_RunWorkerCompleted(object sender, RunWorkerCompletedEventArgs e)

        {

            MessageBox.Show("임무마침");

        }

        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;

            }

        }

        // BackgroundWorker에서 수행할 일을 정의.

        private void backgroundWorker_DoWork(object sender, DoWorkEventArgs e)

        {

            while (IsAcitve)

            {

                if (FilterConvertSource == null)

                {

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

                }

                if (RealConvertSource == null)

                {

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

                }

                /// combobox 에서 선택된 items

                if (SelectedStatus != null)

                {

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

                }

                /// 컨버터중인 items

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

            }

        }

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

        {

            try

            {

                using (Markus.Service.DataBase.ConvertDatabase database = new Markus.Service.DataBase.ConvertDatabase(App.MarkusDataBaseConnecitonString))

                {

                    var items = database.GetConvertProjects(collection)//x:database객체 y:statusCodeTypeList의값  Count()안에 predicator 조건 만족하면 count개수안에 넣음

                                          .Take(SelectedCount.ValueMember).ToList();//

                    items.ForEach(newitem =>

                    {

                        collection.UpdateWhere(changeitem =>

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

                    });

                }

            }

            catch (Exception ex)

            {

                MessageBox.Show(ex.ToString());

            }

        }

        //<>쓸때는 IEnumerable 

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

        {

            try

            {

                using (Markus.Service.DataBase.ConvertDatabase database = new Markus.Service.DataBase.ConvertDatabase(App.MarkusDataBaseConnecitonString))

                {

                    int _status = 0;

                    if (SelectedStatus != null)

                    {

                        _status = (int)SelectedStatus.Value;

                    }

                    var items = database.GetConvertProjects(_status)//x:database객체 y:statusCodeTypeList의값  Count()안에 predicator 조건 만족하면 count개수안에 넣음

                                          .Take(SelectedCount.ValueMember).ToList();

                    if (collection.Count() == 0)

                    {

                        if (statusCodeTypeList.Count() == 1)

                        {

                            items.ForEach(x => collection.Add(x));

                        }

                    }

                    else

                    {

                        ////세미 업데이트

                        items.ForEach(newitem =>

                        {

                            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 (items.Count(x => x.ConvertID == item.ConvertID && x.ProjectNumber == item.ProjectNumber) == 0)//디비에서 가져온 값과 마지막값부터 차례대로 비교

                                {//참=> 0제외한 모든 수

                                    collection.RemoveAt(i);

                                }

                            }

                        }

                        if (statusCodeTypeList.Count() == 1)

                        {

                            //추가 convert 후 추가됨

                            foreach (var item in items)

                            {

                                if (collection.Count(x => x.ConvertID == item.ConvertID && x.ProjectNumber == item.ProjectNumber) == 0)//그리드와 디비 변동 없으면 안들어감

                                {

                                    /*for (int i = 0; i < collection.Count()+1; i++)//위 그리드에서 카운드 개수 변함 없고 컨버터 끝난 후 추가할때 createtime 비교 하며 order by 순으로 추가*/

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

            }

        }

        public override void Loaded()

        {

            base.Loaded();

            if (!App.IsDesignMode)

            {

                backgroundWorker = new BackgroundWorker();

                backgroundWorker.DoWork += backgroundWorker_DoWork;

                backgroundWorker.RunWorkerCompleted += backgroundWorker_RunWorkerCompleted;

                backgroundWorker.WorkerReportsProgress = false;

                backgroundWorker.ProgressChanged += new ProgressChangedEventHandler(backgroundWorker_ProgressChanged);

                backgroundWorker.RunWorkerAsync();

                AlivebackgroundWorker = new BackgroundWorker();

                AlivebackgroundWorker.DoWork += AlivebackgroundWorker_DoWork;

                AlivebackgroundWorker.RunWorkerCompleted += AlivebackgroundWorker_RunWorkerCompleted;

                AlivebackgroundWorker.WorkerReportsProgress = false;

                AlivebackgroundWorker.ProgressChanged += new ProgressChangedEventHandler(AlivebackgroundWorker_ProgressChanged);

                AlivebackgroundWorker.RunWorkerAsync();

            }

        }

        public override void Closed()

        {

            if (backgroundWorker != null)

            {

                backgroundWorker.DoWork -= backgroundWorker_DoWork;

                backgroundWorker.RunWorkerCompleted -= backgroundWorker_RunWorkerCompleted;

                backgroundWorker.WorkerReportsProgress = false;

                backgroundWorker.ProgressChanged -= new ProgressChangedEventHandler(backgroundWorker_ProgressChanged);

                AlivebackgroundWorker.DoWork -= AlivebackgroundWorker_DoWork;

                AlivebackgroundWorker.RunWorkerCompleted -= AlivebackgroundWorker_RunWorkerCompleted;

                AlivebackgroundWorker.WorkerReportsProgress = false;

                AlivebackgroundWorker.ProgressChanged -= new ProgressChangedEventHandler(AlivebackgroundWorker_ProgressChanged);

                AlivebackgroundWorker.Dispose();

            }

            base.Closed();

        }

        public DelegateCommand DataSaveFileGemBoxCommand { get; private set; }

        public void DataExportData(object obj)

        {

            DataExport dataExport = new DataExport();

            dataExport.DataExportData(FilterConvertSource);

        }

        public class SelectedCountItem : INotifyPropertyChanged

        {

            public event PropertyChangedEventHandler PropertyChanged;

            private void NotifyPropertyChanged(String info)

            {

                if (PropertyChanged != null)

                {

                    PropertyChanged(this, new PropertyChangedEventArgs(info));

                }

            }

            //public string DisplayMember { get; set; }

            public string _DisplayMember;

            public string DisplayMember

            {

                get => _DisplayMember;

                set

                {

                    _DisplayMember = value;

                    NotifyPropertyChanged("DisplayMember");

                }

            }

            //public int ValueMember { get; set; }

            public int _ValueMember;

            public int ValueMember

            {

                get => _ValueMember;

                set

                {

                    _ValueMember = value;

                    NotifyPropertyChanged("ValueMember");

                }

            }

        }

    }

}