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

using Aitex.Core.RT.Event;
using Caliburn.Micro.Core;
using MECF.Framework.Common.Alarms;
using MECF.Framework.Common.OperationCenter;
using MECF.Framework.UI.Client.CenterViews.Alarms;
using MECF.Framework.UI.Client.CenterViews.Configs.SystemConfig;
using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows;
using FurnaceUI.Models;

namespace FurnaceUI.Views.Parameter
{
    public class AlarmtableParameterViewModel : FurnaceUIViewModelBase
    {
        public bool IsPermission { get => this.Permission == 3; }

        private AlarmProvider _alarmProvider = new AlarmProvider();

        public Dictionary<int, ObservableCollection<AlarmParameterOperation>> TableAlarmParameterOperations = new Dictionary<int, ObservableCollection<AlarmParameterOperation>>();

        public ObservableCollection<AlarmParameterOperation> AlarmParameterOperations { get; set; } = new ObservableCollection<AlarmParameterOperation>();

        public ObservableCollection<string> AlarmGroups { get; set; } = new ObservableCollection<string>();

        public ObservableCollection<string> TableList { get; set; } = new ObservableCollection<string>();

        private int _alarmGroupsWidth = 285;

        public string SelectedAlarmGroup { get; set; }

        public int AlarmGroupsWidth
        {
            get => _alarmGroupsWidth;
            set
            {
                _alarmGroupsWidth = value;
                NotifyOfPropertyChange("AlarmGroupsWidth");
            }
        }

        private List<string> _groupNames = new List<string>
           (new string[] {
            "None Specified",
            "ALG01",
            "ALG02",
            "ALG03",
            "ALG04",
            "ALG05",
            "ALG06",
            "ALG07",
            "ALG08",
            "ALG09",
            "ALG10"
           });

        public Dictionary<string, Dictionary<string, EventItem>> AllGroupAlarmList = new Dictionary<string, Dictionary<string, EventItem>>();

        public List<string> GroupNames
        {
            get => _groupNames;
            set

            {
                _groupNames = value;
                NotifyOfPropertyChange("GroupNames");
            }
        }

        public int SelectedAlarmTableIndex = 0;

        public string EntryValue;

        public Visibility _alarmTableVisibility = Visibility.Collapsed;

        public Visibility AlarmTableVisibility
        {
            get => _alarmTableVisibility;
            set
            {
                _alarmTableVisibility = value;
                NotifyOfPropertyChange("AlarmTableVisibility");
            }
        }

        public Visibility _alarmGroupsVisibility = Visibility.Collapsed;

        public Visibility AlarmGroupsVisibility
        {
            get => _alarmGroupsVisibility;
            set
            {
                _alarmGroupsVisibility = value;
                if (_alarmGroupsVisibility == Visibility.Visible)
                { AlarmGroupsWidth = 235; }
                else
                {
                    AlarmGroupsWidth = 0;
                }
                NotifyOfPropertyChange("AlarmGroupsVisibility");
            }
        }

        protected override void OnViewLoaded(object view)
        {
            base.OnViewLoaded(view);
            var alarmDict = _alarmProvider.GetXmlAlarmList();

            AllGroupAlarmList = alarmDict;
            SetVisibility();

            // AlarmGroups.Clear();
            //alarmDict.Keys.ToList().ForEach(p => AlarmGroups.Add(new ShowAlarmGroup() { Name = p.Name, Display = p.Display }));
            //if (AlarmGroups.Where(x => x.AlarmBoolValue == true).Count() <= 0)
            //{
            //    AlarmGroups[0].AlarmBoolValue = true;
            //}

            //for (int i = 0; i < 6; i++)
            //{
            //    ObservableCollection<AlarmParameterOperation> tempAlarmParameterOperation = new ObservableCollection<AlarmParameterOperation>();
            //    int index = 1;
            //    foreach (var item in alarmDict.Keys)
            //    {
            //        foreach (var temp in alarmDict[item].Keys)
            //        {
            //            tempAlarmParameterOperation.Add(new AlarmParameterOperation()
            //            {
            //                No = index,
            //                ID = temp,
            //                IsSave = true,
            //                IsEdit = true,
            //                AlarmText = alarmDict[item][temp].Message,
            //                Group = "None Specified"
            //            });
            //            index++;
            //        }
            //    }
            //    if (!TableAlarmParameterOperations.ContainsKey(i))
            //    {
            //        TableAlarmParameterOperations.Add(i, tempAlarmParameterOperation);
            //    }
            //}
            //AlarmParameterOperations.Clear();
            ////TableAlarmParameterOperations[0].ToList().ForEach(p => AlarmParameterOperations.Add(p));
            //var findGroupAlarm = AllGroupAlarmList.Keys.Where(x => x.Name == AlarmGroups[0].Name).FirstOrDefault();
            //var idItems = AllGroupAlarmList[findGroupAlarm].Keys.ToList();
            //TableAlarmParameterOperations[SelectedAlarmTableIndex].Where(x => idItems.Contains(x.ID)).ToList().ForEach(p => AlarmParameterOperations.Add(p));
            //GetAlarmParameterFormConfig();
        }

        private void SetVisibility()
        {
            if (AllGroupAlarmList != null)
            {
                if (AllGroupAlarmList.Count < 2)
                {
                    AlarmTableVisibility = Visibility.Collapsed;
                    if (AllGroupAlarmList.Count != 0)
                    {
                        AlarmParameterOperations.Clear();
                        foreach (var subitem in AllGroupAlarmList[AllGroupAlarmList.Keys.FirstOrDefault()].Keys)
                        {
                            AlarmParameterOperations.Add(new AlarmParameterOperation(subitem, AllGroupAlarmList[AllGroupAlarmList.Keys.FirstOrDefault()][subitem]));
                        }
                    }
                }
                else
                {
                    AlarmTableVisibility = Visibility.Visible;
                    TableList.Clear();
                    foreach (var item in AllGroupAlarmList.Keys)
                    {
                        TableList.Add(item);
                    }
                    AlarmParameterOperations.Clear();
                    foreach (var subitem in AllGroupAlarmList[AllGroupAlarmList.Keys.FirstOrDefault()].Keys)
                    {
                        AlarmParameterOperations.Add(new AlarmParameterOperation(subitem, AllGroupAlarmList[AllGroupAlarmList.Keys.FirstOrDefault()][subitem]));
                    }
                }
                SetAlarmGroup(AllGroupAlarmList.Keys.FirstOrDefault());
            }
            else
            {
                AlarmTableVisibility = Visibility.Hidden;
            }

        }



        public void AlarmTableSelected(string index)
        {
            int tempValue = int.Parse(index);
            SelectedAlarmTableIndex = tempValue;
            AlarmParameterOperations.Clear();
            SetAlarmGroup(index);
            //TableAlarmParameterOperations[tempValue].ToList().ForEach(p => AlarmParameterOperations.Add(p));
        }

        private void SetAlarmGroup(string index)
        {
            AlarmGroups.Clear();
            var categoryList = AllGroupAlarmList[index].Values.Select(x => x.Category);
            foreach (var item in categoryList)
            {
                if (!AlarmGroups.Contains(item))
                {
                    AlarmGroups.Add(item);
                }
            }
            if (AlarmGroups.Count < 2)
            {
                AlarmGroupsVisibility = Visibility.Collapsed;
                AlarmParameterOperations.Clear();
                foreach (var subitem in AllGroupAlarmList[AllGroupAlarmList.Keys.FirstOrDefault()].Keys)
                {
                    AlarmParameterOperations.Add(new AlarmParameterOperation(subitem, AllGroupAlarmList[AllGroupAlarmList.Keys.FirstOrDefault()][subitem]));
                }
            }
            else
            {
                AlarmGroupsVisibility = Visibility.Visible;
                AlarmParameterOperations.Clear();
                foreach (var subitem in AllGroupAlarmList[index].Keys)
                {
                    AlarmParameterOperations.Add(new AlarmParameterOperation(subitem, AllGroupAlarmList[index][subitem]));
                }
            }
        }

        public void AlarmTableSave()
        {
            var saveStr = GetParameterStrToSave();
            InvokeClient.Instance.Service.DoOperation($"System.UpdateAlarmTable", saveStr);
        }

        /// <summary>
        /// 按照Id号或者Alarm文本查找
        /// </summary>
        /// <param name="alarmId"></param>
        /// <param name="alarmText"></param>
        public void AlarmValueFind(string alarmId, string alarmText)
        {
            if (alarmId != "" || alarmText != "")
            {
                bool bHaveValue = false;
                foreach (var alarmOperation in TableAlarmParameterOperations[SelectedAlarmTableIndex])
                {
                    if (alarmOperation.ID.ToString() == alarmId || (alarmText != "" && alarmOperation.Description.ToLower().Contains(alarmText.ToLower())))
                    {
                        if (!bHaveValue)
                        {
                            bHaveValue = true;
                            AlarmParameterOperations.Clear();
                            AlarmParameterOperations.Add(alarmOperation);
                        }
                        else
                        {
                            AlarmParameterOperations.Add(alarmOperation);
                        }
                    }
                }
            }
            else
            {
                MessageBox.Show("Please input condition! ");
            }
        }

        private string GetParameterStrToSave()
        {
            List<string> tableParameters = new List<string>();
            foreach (var item in TableAlarmParameterOperations.Keys)
            {
                List<string> ParametersStr = new List<string>();
                foreach (var alarmOperation in TableAlarmParameterOperations[item])
                {
                    ParametersStr.Add(alarmOperation.ToString());
                }
                if (ParametersStr != null && ParametersStr.Count > 0)
                {
                    tableParameters.Add($"{item}:{String.Join(";", ParametersStr)}");
                }
            }
            return String.Join("|", tableParameters);
        }


        private string GetParameterStr()
        {
            List<string> tableParameters = new List<string>();
            foreach (var item in TableAlarmParameterOperations.Keys)
            {
                List<string> ParametersStr = new List<string>();
                foreach (var alarmOperation in AlarmParameterOperations)
                {

                    if (EntryValue == "AllOn")
                        alarmOperation.Bypass = true;
                    else if (EntryValue == "AllOff")
                        alarmOperation.Bypass = false;
                    if (!alarmOperation.IsEdit || alarmOperation.Group != "None Specified" || alarmOperation.IsEdit)
                    {
                        ParametersStr.Add(alarmOperation.ToString());
                    }
                }
                EntryValue = null;
                if (ParametersStr != null && ParametersStr.Count > 0)
                {
                    tableParameters.Add($"{item}:{String.Join(";", ParametersStr)}");
                }
            }
            return String.Join("|", tableParameters);
        }

        private void GetAlarmParameterFormConfig()
        {
            string strHeader = "PM1.RecipeEditParameter.AlarmTables";
            var getConfigAlarm = SystemConfigProvider.Instance.GetValueByName($"{strHeader}.AlarmTable");
            if (getConfigAlarm != null && getConfigAlarm != "")
            {
                var dictTableAlarm = StrParameterToAlarmOperation(getConfigAlarm);
                foreach (var item in dictTableAlarm.Keys)
                {
                    foreach (var itemOP in dictTableAlarm[item])
                    {
                        var alarmOP = TableAlarmParameterOperations[item].Where(x => x.ID == itemOP.ID).FirstOrDefault();
                        alarmOP.IsEdit = itemOP.IsEdit;
                        alarmOP.Group = itemOP.Group;
                        alarmOP.SelectedIndex = GroupNames.FindIndex(x => x == itemOP.Group);
                        //  alarmOP.IsSave = itemOP.IsSave;
                    }
                }
            }
        }

        private Dictionary<int, ObservableCollection<AlarmParameterOperation>> StrParameterToAlarmOperation(string parameterStr)
        {
            Dictionary<int, ObservableCollection<AlarmParameterOperation>> tempAlarmOperation = new Dictionary<int, ObservableCollection<AlarmParameterOperation>>();
            string[] tableParameters = parameterStr.Split('|');
            if (tableParameters.Length > 0)
            {
                foreach (var item in tableParameters)
                {
                    ObservableCollection<AlarmParameterOperation> alarmParameterOperations = new ObservableCollection<AlarmParameterOperation>();
                    var tabelPar = item.Split(':');
                    var alarmstrs = tabelPar[1].Split(';');
                    if (alarmstrs != null && alarmstrs.Length > 0)
                    {
                        foreach (var alarmitem in alarmstrs)
                        {
                            alarmParameterOperations.Add(new AlarmParameterOperation(alarmitem));
                        }
                    }
                    if (alarmParameterOperations.Count > 0)
                    {
                        tempAlarmOperation.Add(int.Parse(tabelPar[0]), alarmParameterOperations);
                    }
                }
            }
            return tempAlarmOperation;
        }

        public void AlarmTableAllOn()
        {
            EntryValue = "AllOn";
            GetAlarmParameterOperations();
            //var alarmDict = _alarmProvider.GetXmlAlarmList();

            //AllGroupAlarmList = alarmDict;
            //SetVisibility();
        }

        public void AlarmTableAllOff()
        {
            EntryValue = "AllOff";
            GetAlarmParameterOperations();
        }

        public void AlarmTableCancel()
        {

        }

        public void GetAlarmParameterOperations()
        {
            //if (AllGroupAlarmList[SelectedAlarmTableIndex.ToString()].AlarmBoolValue == true)
            //{
            //    AlarmParameterOperations.Clear();
            //    //var findGroupAlarm = AllGroupAlarmList.Keys.Where(x => x.Name == AlarmGroups[0].Name).FirstOrDefault();
            //    //var idItems = AllGroupAlarmList[findGroupAlarm].Keys.ToList();
            //    //TableAlarmParameterOperations[SelectedAlarmTableIndex].Where(x => idItems.Contains(x.ID)).ToList().ForEach(p => AlarmParameterOperations.Add(p));
            //}
            if (AllGroupAlarmList == null || AllGroupAlarmList.Count == 0) return;
            foreach (var item in AllGroupAlarmList[SelectedAlarmTableIndex.ToString()])
            {
                if (AlarmGroups.Count < 2)
                {
                    if (EntryValue == "AllOn")
                        item.Value.Bypass = true;
                    else if (EntryValue == "AllOff")
                        item.Value.Bypass = false;
                }
                else
                {
                    if (SelectedAlarmGroup != null)
                    {
                        if (item.Value.Category == SelectedAlarmGroup)
                        {
                            if (EntryValue == "AllOn")
                                item.Value.Bypass = true;
                            else if (EntryValue == "AllOff")
                                item.Value.Bypass = false;
                        }
                    }
                }
            }
            AlarmParameterOperations.Clear();
            IEnumerable<KeyValuePair<string, EventItem>> findGroupAlarm;
            if (SelectedAlarmGroup != null)
            {
                findGroupAlarm = AllGroupAlarmList[SelectedAlarmTableIndex.ToString()].Where(x => x.Value.Category == SelectedAlarmGroup);
            }
            else
            {
                findGroupAlarm = AllGroupAlarmList[SelectedAlarmTableIndex.ToString()];
            }
            foreach (var item in findGroupAlarm)
            {
                AlarmParameterOperations.Add(new AlarmParameterOperation(item.Key, item.Value));
            }
            //  GetParameterStr();
        }

        public void AlarmTypeSelected(object obj)
        {
            var tempobj = obj;
            var selectedAlarmGroup = (string)tempobj;
            SelectedAlarmGroup = selectedAlarmGroup;
            AlarmParameterOperations.Clear();
            var findGroupAlarm = AllGroupAlarmList[SelectedAlarmTableIndex.ToString()].Where(x => x.Value.Category == selectedAlarmGroup);
            foreach (var item in findGroupAlarm)
            {
                AlarmParameterOperations.Add(new AlarmParameterOperation(item.Key, item.Value));
            }
        }

        public class AlarmParameterOperation : PropertyChangedBase
        {
            public AlarmParameterOperation()
            { }

            private string _alarmName;

            public string AlarmName
            {
                get => _alarmName;
                set
                {
                    _alarmName = value;
                    NotifyOfPropertyChange("AlarmName");
                }
            }
            private string _source;
            public string Source
            {
                get => _source;
                set
                {
                    _source = value;
                    NotifyOfPropertyChange("Source");
                }
            }

            private long _id;
            public long ID
            {
                get => _id;
                set
                {
                    _id = value;
                    NotifyOfPropertyChange("ID");
                }
            }

            private string _description;
            public string Description
            {
                get => _description;
                set
                {
                    _description = value;
                    NotifyOfPropertyChange("Description");
                }
            }

            private string _solution;
            public string Solution
            {
                get => _solution;
                set
                {
                    _solution = value;
                    NotifyOfPropertyChange("Solution");
                }
            }

            private string _explaination;
            public string Explaination
            {
                get => _explaination;
                set
                {
                    _explaination = value;
                    NotifyOfPropertyChange("Explaination");
                }
            }


            private bool _bypass;
            public bool Bypass
            {
                get => _bypass;
                set
                {
                    _bypass = value;
                    NotifyOfPropertyChange("Bypass");
                }
            }

            private string _group;

            public string Group
            {
                get => _group;
                set
                {
                    _group = value;
                    NotifyOfPropertyChange("Group");
                }
            }

            private bool _isEdit;
            public bool IsEdit
            {
                get => _isEdit;
                set
                {
                    _isEdit = value;
                    NotifyOfPropertyChange("IsEdit");
                }
            }

            private int _selectedIndex;

            public int SelectedIndex
            {
                get => _selectedIndex;
                set
                {
                    _selectedIndex = value;
                    NotifyOfPropertyChange("SelectedIndex");
                }
            }



            public AlarmParameterOperation(string key, EventItem eventItem)
            {
                AlarmName = key;
                if (eventItem != null)
                {
                    ID = eventItem.Id;
                    Source = eventItem.Source;
                    Description = eventItem.Description;
                    Solution = eventItem.Solution;
                    Explaination = eventItem.Explaination;
                    Bypass = eventItem.Bypass;
                    Group = eventItem.Group.ToString();
                    IsEdit = eventItem.Editable;

                }
            }

            public AlarmParameterOperation(string alarmParameterStr)
            {
                if (alarmParameterStr != null)
                {
                    var alarmPar = alarmParameterStr.Split(',');
                    if (alarmPar != null && alarmPar.Length > 0)
                    {
                        _id = int.Parse(alarmPar[0]);
                        //_isSave = bool.Parse(alarmPar[1]);
                        _group = alarmPar[2];
                        _isEdit = bool.Parse(alarmPar[3]);
                    }
                }
            }

            public override string ToString()
            {
                string rtnString = $"{_id},{_group},{_isEdit}";
                return rtnString;
            }

        }


        public class ShowAlarmGroup : PropertyChangedBase
        {
            private string _name;
            public string Name
            {
                get => _name; set
                {
                    _name = value;
                    NotifyOfPropertyChange("Name");
                }
            }

            private string _display;
            public string Display
            {
                get => _display; set
                {
                    _display = value;
                    NotifyOfPropertyChange("Display");
                }
            }

            private bool _bvalue = false;
            public bool AlarmBoolValue
            {
                get { return _bvalue; }
                set { _bvalue = value; NotifyOfPropertyChange("AlarmBoolValue"); }
            }


        }
    }
}