Kepler-Release/Venus/Venus_MainPages/ViewModels/TopViewModel.cs

using Aitex.Core.RT.Event;
using Aitex.Core.WCF;
using MECF.Framework.Common.DataCenter;
using MECF.Framework.Common.OperationCenter;
using Prism.Commands;
using Prism.Mvvm;
using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Linq;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
using System.Windows;
using System.Windows.Threading;

namespace Venus_MainPages.ViewModels
{
    internal class TopViewModel : BindableBase
    {
        #region 私有字段
        private string m_Title;
        private string m_SoftwareVersion;

        private List<string> m_RtDataKeys=new List<string>();
        private Dictionary<string, object> m_RtDataValues;

        private string ModuleName;

        private ObservableCollection<EventItem> m_EventLogList = new ObservableCollection<EventItem>();
        private EventItem m_CurrentEventItem=new EventItem ();
        private string m_CurrentEventItemValue;
        private object _lockObj = new object();
        private int m_EventLogListSelectedIndex;
        private Queue<EventItem> alarmQuery = new Queue<EventItem>();//控制alarm log 在 top UI显示

        private int logMaxCount = 50;//log在ui最多显示数量

        #endregion

        #region  属性
        public string Title
        {
            get { return m_Title; }
            set { SetProperty(ref m_Title, value); }
        }
        public string SoftwareVersion
        {
            get { return m_SoftwareVersion; }
            set { SetProperty(ref m_SoftwareVersion, value); }
        }

        public Dictionary<string, object> RtDataValues
        {
            get { return m_RtDataValues; }
            set { SetProperty(ref m_RtDataValues, value); }
        }

        public ObservableCollection<EventItem> EventLogList
        {
            get { return m_EventLogList; }
            set { SetProperty(ref m_EventLogList, value); }
        }

        public EventItem CurrentEventItem
        {
            get { return m_CurrentEventItem; }
            set { SetProperty(ref m_CurrentEventItem, value); }
        }
        public int EventLogListSelectedIndex
        {
            get { return m_EventLogListSelectedIndex; }
            set { SetProperty(ref m_EventLogListSelectedIndex, value); }
        }

        public string CurrentEventItemValue
        {
            get { return m_CurrentEventItemValue; }
            set { SetProperty(ref m_CurrentEventItemValue, value); }
        }
        #endregion

        #region 命令
        private DelegateCommand _SwichLanguageCommand;
        public DelegateCommand SwichLanguageCommand =>
                 _SwichLanguageCommand ?? (_SwichLanguageCommand = new DelegateCommand(OnSwitchLanguage));

        private DelegateCommand _ResetCommand;
        public DelegateCommand ResetCommand =>
                 _ResetCommand ?? (_ResetCommand = new DelegateCommand(OnReset));

        private DelegateCommand _ClearCommand;
        public DelegateCommand ClearCommand =>
                 _ClearCommand ?? (_ClearCommand = new DelegateCommand(OnClear));

        private DelegateCommand _BuzzerOffCommand;
        public DelegateCommand BuzzerOffCommand =>
                 _BuzzerOffCommand ?? (_BuzzerOffCommand = new DelegateCommand(OnBuzzerOff));
        
        #endregion

        #region 构造函数
        public TopViewModel()
        {
            Title = "Venus";
            m_SoftwareVersion = System.Reflection.Assembly.GetExecutingAssembly().GetName().Version.ToString();
            ModuleName = "PMA";
            addDataKeys();

            DispatcherTimer timer = new DispatcherTimer();
            timer.Interval = TimeSpan.FromSeconds(1);
            timer.Tick += timer_Tick;
            timer.Start();

            EventClient.Instance.OnEvent += Instance_OnEvent;
            EventClient.Instance.Start();

        }
        #endregion

        #region 方法

        void timer_Tick(object sender, EventArgs e)
        {
            RtDataValues = QueryDataClient.Instance.Service.PollData(m_RtDataKeys);
        }

        private void OnSwitchLanguage()
        {
            
            List<ResourceDictionary> dictionaryList = new List<ResourceDictionary>();
            foreach (ResourceDictionary dictionary in Application.Current.Resources.MergedDictionaries)
            {
                if (dictionary.Source != null)
                {
                    dictionaryList.Add(dictionary);
                }
            }
            string requestedCulture1 = @"/Venus_Themes;component/Languages/StringResources.en-US.xaml";
            string requestedCulture2 = @"/Venus_Themes;component/Languages/StringResources.zh-CN.xaml";
            ResourceDictionary resourceDictionary1 = dictionaryList.FirstOrDefault(d => d.Source.OriginalString.Equals(requestedCulture1));
            ResourceDictionary resourceDictionary2 = dictionaryList.FirstOrDefault(d => d.Source.OriginalString.Equals(requestedCulture2));
            if (dictionaryList.IndexOf(resourceDictionary1) < dictionaryList.IndexOf(resourceDictionary2))
            {
                Application.Current.Resources.MergedDictionaries.Remove(resourceDictionary1);
                Application.Current.Resources.MergedDictionaries.Add(resourceDictionary1);
            }
            else
            {
                Application.Current.Resources.MergedDictionaries.Remove(resourceDictionary2);
                Application.Current.Resources.MergedDictionaries.Add(resourceDictionary2);
            }
        }
        private void OnReset()
        {
            InvokeClient.Instance.Service.DoOperation("System.Reset");
        }
        private void addDataKeys()
        {
            m_RtDataKeys.Add($"{ModuleName}.FsmState");

            m_RtDataKeys.Add($"{ModuleName}.SignalTower.IsRedLightOn");
            m_RtDataKeys.Add($"{ModuleName}.SignalTower.IsYellowLightOn");
            m_RtDataKeys.Add($"{ModuleName}.SignalTower.IsGreenLightOn");
            m_RtDataKeys.Add($"{ModuleName}.SignalTower.IsBlueLightOn");
            m_RtDataKeys.Add($"{ModuleName}.SignalTower.IsBuzzerOn");
        }

        private void Instance_OnEvent(EventItem eventItem)
        {
            switch (eventItem.Type)
            {
                case EventType.EventUI_Notify:
                    Application.Current.Dispatcher.Invoke(delegate
                    {
                        EventLogList.Add(eventItem);
                        if (EventLogList.Count > logMaxCount)
                        { 
                            EventLogList.RemoveAt(0);
                        }
                        
                        if (eventItem.Level == EventLevel.Alarm)
                        {
                            alarmQuery.Enqueue(eventItem);
                        }
                        if (alarmQuery.Count > 0)
                        {
                            CurrentEventItem = alarmQuery.First();
                        }
                        else
                        {
                            CurrentEventItem = eventItem;
                        }
                        EventLogListSelectedIndex = 0;
                    });
                    break;
                case EventType.Dialog_Nofity:
                    //PopDialog(obj);
                    break;
                case EventType.KickOut_Notify:
                    break;
                case EventType.Sound_Notify:
                    break;
                case EventType.UIMessage_Notify:
                    //PopUIMessage(obj);
                    break;
            }

           
            
        }

        private void OnClear()
        {
            if (alarmQuery.Count > 0)
            {
                alarmQuery.Dequeue();
                if (alarmQuery.Count > 0)
                {
                    CurrentEventItem = alarmQuery.First();
                }
                else
                {
                    CurrentEventItem = null;
                }
            }
        }

        private void OnBuzzerOff()
        {
            InvokeClient.Instance.Service.DoOperation($"{ModuleName}.SignalTower.SwitchOffBuzzer");
        }
        #endregion

    }
}