ELK/Furnace/FurnaceUI/Views/Parameter/BackUpCompareViewModel.cs

using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Xml.Linq;
using Aitex.Core.Util;
using DocumentFormat.OpenXml.Drawing.Diagrams;
using DocumentFormat.OpenXml.Wordprocessing;
using FurnaceUI.DataModule;
using FurnaceUI.Models;
using MECF.Framework.Common.OperationCenter;
using MECF.Framework.UI.Client.CenterViews.Configs.SystemConfig;
using OpenSEMI.ClientBase.Command;
using SciChart.Core.Extensions;

namespace FurnaceUI.Views.Parameter
{
    public class BackUpCompareViewModel : FurnaceUIViewModelBase
    {
        private List<string> _selectItemNames = new List<string>();
        public List<string> SelectItemNames
        {
            get { return _selectItemNames; }
            set { _selectItemNames = value; this.NotifyOfPropertyChange(nameof(SelectItemNames)); }
        }

        private bool _isShowAll = true;
        public bool IsShowAll
        {
            get { return _isShowAll; }
            set { _isShowAll = value; this.NotifyOfPropertyChange(nameof(IsShowAll)); }
        }
        private ObservableCollection<PageDataView> _historyTableDatas = new ObservableCollection<PageDataView>();
        public ObservableCollection<PageDataView> HistoryTableDatas
        {
            get { return _historyTableDatas; }
            set { _historyTableDatas = value; this.NotifyOfPropertyChange(nameof(HistoryTableDatas)); }
        }
        [Subscription("System.CompareFileDataA")]
        public Dictionary<string, string> CompareFileDataA { get; set; }
        [Subscription("System.SCDataLastWriteTime")]
        public string SCDataLastWriteTime { get; set; }
        [Subscription("System.CompareFileDataB")]
        public Dictionary<string, string> CompareFileDataB { get; set; }
        public BaseCommand<ConfigNode> TreeViewSelectedItemChangedCmd { private set; get; }
        private string _selectItemName;
        public string SelectItemName
        {
            get { return _selectItemName; }
            set { _selectItemName = value; this.NotifyOfPropertyChange(nameof(SelectItemName)); }
        }
        private bool _busyIndicatorVisibility = false;
        public bool BusyIndicatorVisibility
        {
            get { return _busyIndicatorVisibility; }
            set { _busyIndicatorVisibility = value; this.NotifyOfPropertyChange(nameof(BusyIndicatorVisibility)); }
        }
        private BackUpCompareView _view { get; set; }
        protected override void OnViewLoaded(object view)
        {
            base.OnViewLoaded(view);
            _view = view as BackUpCompareView;
            DelayData();
            ConfigNodes = SystemConfigProvider.Instance.GetConfigTree("System").SubNodes;
            TreeViewSelectedItemChangedCmd = new BaseCommand<ConfigNode>(TreeViewSelectedItemChanged);

        }
        private void TreeViewSelectedItemChanged(ConfigNode node)
        {
            BusyIndicatorVisibility = true;
            SelectItemName = string.IsNullOrEmpty(node.Path) ? node.Name : $"{node.Path}.{node.Name}";
            DelayData();

        }
        async void DelayData()
        {
            BusyIndicatorVisibility = true;
            await WaitForResultsAsync();
            GetDataItem(IsShowAll);
            if (SelectItemNames.Count == 1 )
            {
                SelectItemNames.Add(SCDataLastWriteTime);
            }
        }
        private async Task WaitForResultsAsync()
        {
            // Simulate waiting for results using a delay
            // In a real-world scenario, you might wait for an event or a specific condition
            await Task.Delay(300);

            // Here you can add logic to check if the results are ready
            // For example, polling or using a completion source
        }
        private void GetDataItem(bool isShowAll, string name = "")
        {
            HistoryTableDatas.Clear();
            if (CompareFileDataB == null || CompareFileDataA == null)
            {
                return;
            }
            if (CompareFileDataB.Count >= CompareFileDataA.Count)
            {
                foreach (var item in CompareFileDataB)
                {

                    if (CompareFileDataA.ContainsKey(item.Key))
                    {
                        var dataItem = new PageDataView() { Name = item.Key, ValueStr = item.Value, CompareValueStr = CompareFileDataA[item.Key], IsDifference = CompareFileDataA[item.Key] != item.Value };

                        if (isShowAll || (!isShowAll && dataItem.IsDifference))
                            HistoryTableDatas.Add(dataItem);

                    }
                    else
                    {
                        var dataItem = new PageDataView() { Name = item.Key, ValueStr = item.Value, CompareValueStr = "", IsDifference = true };

                        if (isShowAll || (!isShowAll && dataItem.IsDifference))
                            HistoryTableDatas.Add(dataItem);
                    }
                }
            }
            else
            {
                foreach (var item in CompareFileDataA)
                {
                    if (CompareFileDataB.ContainsKey(item.Key))
                    {
                        var dataItem = new PageDataView() { Name = item.Key, ValueStr = item.Value, CompareValueStr = CompareFileDataB[item.Key], IsDifference = CompareFileDataB[item.Key] != item.Value };

                        if (isShowAll || (!isShowAll && dataItem.IsDifference))
                            HistoryTableDatas.Add(dataItem);
                    }
                    else
                    {
                        var dataItem = new PageDataView() { Name = item.Key, ValueStr = item.Value, CompareValueStr = "", IsDifference = true };

                        if (isShowAll || (!isShowAll && dataItem.IsDifference))
                            HistoryTableDatas.Add(dataItem);
                    }
                }
            }
            if (!string.IsNullOrEmpty(SelectItemName))
            {
                HistoryTableDatas = new ObservableCollection<PageDataView>(HistoryTableDatas.Where(a => a.Name.StartsWith(SelectItemName)).ToList());
            }
            HistoryTableDatas = new ObservableCollection<PageDataView>(HistoryTableDatas.OrderByDescending(a => a.IsDifference).ToList());
            BusyIndicatorVisibility = false;

        }
        public void IsShowAllItemClick(object value)
        {
            IsShowAll = bool.Parse(value.ToString());
            GetDataItem(bool.Parse(value.ToString()));

        }
        private List<ConfigNode> _ConfigNodes = new List<ConfigNode>();
        public List<ConfigNode> ConfigNodes
        {
            get { return _ConfigNodes; }
            set { _ConfigNodes = value; NotifyOfPropertyChange("ConfigNodes"); }
        }
        protected override void InvokeAfterUpdateProperty(Dictionary<string, object> data)
        {
            base.InvokeAfterUpdateProperty(data);

        }
    }
}