MARKUS

using Markus.Service.WcfClient.StationServiceTask;

using System;

using System.Collections.Generic;

using System.ComponentModel;

using System.Linq;

using System.Text;

using System.Threading.Tasks;

using Markus.Service.Extensions;

using Markus.Service.Helper;

using Markus.Service.StationController.Extensions;

using System.Web;

namespace Markus.Service.StationController.ViewModel

{

    public class AliveViewModel :Mvvm.ToolKit.ViewModelBase

    {

        BackgroundWorker backgroundWorker;

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

        private bool isLoading;

        private System.Windows.Documents.FlowDocument connectionLog;

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

        {

            get => aliveItems; set

            {

                aliveItems = value;

                OnPropertyChanged(() => AliveItems);

            }

        }

        public bool IsLoading

        {

            get => isLoading; set

            {

                if (isLoading != value)

                {

                    isLoading = value;

                    OnPropertyChanged(() => IsLoading);

                }

            }

        }

        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 async void backgroundWorker_DoWork(object sender, DoWorkEventArgs e)

        {

            while (IsAcitve)

            {

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

                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

                                {

                                    var items = await client.AliveConvertListAsync();

                                    newitems.AddRange(items);

                                    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)

                    {

                    }

                    IsLoading = false;

                }

            }

        }

        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;

            }

            return result;

        }

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

            }

        }

        public override void Closed()

        {

            if (backgroundWorker != null)

            {

                backgroundWorker.DoWork -= backgroundWorker_DoWork;

                backgroundWorker.RunWorkerCompleted -= backgroundWorker_RunWorkerCompleted;

                backgroundWorker.WorkerReportsProgress = false;

                backgroundWorker.ProgressChanged -= new ProgressChangedEventHandler(backgroundWorker_ProgressChanged);

                backgroundWorker.Dispose();

            }

            base.Closed();

        }

    }

}