OHV/Dev/OHV/OHV.Vehicle/Concept/D_MainWindowViewModel.cs

using CommonServiceLocator;
using GSG.NET.Extensions;
using GSG.NET.Logging;
using GSG.NET.Utils;
using OHV.Common.Events;
using OHV.Common.Model;
using OHV.Common.Shareds;
using OHV.Module.Interactivity;
using OHV.SqliteDAL;
using Prism.Commands;
using Prism.Events;
using Prism.Mvvm;
using Prism.Regions;
using Prism.Services.Dialogs;
using System;
using System.Collections.Generic;
using System.Globalization;
using System.Linq;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
using System.Windows;
using System.Windows.Input;
using System.Windows.Media;
using System.Windows.Threading;
using VehicleControlSystem;

namespace OHV.Vehicle.Concept
{
    class D_MainWindowViewModel : BindableBase
    {
        #region Properties
        private string _title = "Prism Unity Application";
        public string Title
        {
            get { return _title; }
            set { SetProperty(ref _title, value); }
        }

        private double _cpu;
        public double CPU
        {
            get { return this._cpu; }
            set { this.SetProperty(ref this._cpu, value); }
        }

        private double _totalCPU;
        public double TotalCPU
        {
            get { return this._totalCPU; }
            set
            {
                //this._totalCPU = dti.cpuResult.ToString();
                this.SetProperty(ref this._totalCPU, value);
            }
        }

        public int UsageCPU { get; set; }
        private double _ram;
        public double RAM
        {
            get { return this._ram; }
            set { this.SetProperty(ref this._ram, value); }
        }

        private double _cDrive;
        public double CDrive
        {
            get { return this._cDrive; }
            set { this.SetProperty(ref this._cDrive, value); }
        }

        DateTime _dateTime;
        public DateTime DateTime
        {
            get { return _dateTime; }
            set
            {
                this.SetProperty(ref _dateTime, value);
            }
        }

        private string _vehicleID;
        public string VehicleID
        {
            get { return this._vehicleID; }
            set { this.SetProperty(ref this._vehicleID, value); }
        }

        private string _vehicleIP = "127.0.0.1";
        public string VehicleIP
        {
            get { return this._vehicleIP; }
            set { this.SetProperty(ref this._vehicleIP, value); }
        }
        private string _ocsIP;
        public string OcsIP
        {
            get { return this._ocsIP; }
            set { this.SetProperty(ref this._ocsIP, value); }
        }

        private string _swVersion;
        public string SwVersion
        {
            get { return this._swVersion; }
            set { this.SetProperty(ref this._swVersion, value); }
        }

        bool _startEnable = true;
        public bool StartEnable
        {
            get { return this._startEnable; }
            set { this.SetProperty(ref this._startEnable, value); }
        }

        bool _stopEnable = false;
        public bool StopEnable
        {
            get { return this._stopEnable; }
            set { this.SetProperty(ref this._stopEnable, value); }
        }

        private DateTime _lastBuildedTime;
        public DateTime LastBuildedTime
        {
            get { return this._lastBuildedTime; }
            set { this.SetProperty(ref this._lastBuildedTime, value); }
        }

        private bool isManualMode = true;
        public bool IsManualMode
        {
            get { return isManualMode; }
            set { SetProperty(ref isManualMode, value); }
        }

        private bool isVehicleAlarm = false;
        public bool IsVehicleAlarm
        {
            get { return isVehicleAlarm; }
            set { SetProperty(ref this.isVehicleAlarm, value); }
        }

        private eMachineMode machineMode = eMachineMode.LocalMode;
        public eMachineMode MachineMode
        {
            get { return machineMode; }
            set { SetProperty(ref this.machineMode, value); }
        }

        #endregion

        #region Brushes
        private Brush _ocsBrush;// = Brushes.Gray;
        private Brush _batteryBrush;// = Brushes.Gray;
        private Brush _laserBrush;// = Brushes.Gray;

        public Brush OcsBrush
        {
            get { return _ocsBrush; }
            set
            {
                SetProperty(ref _ocsBrush, value);
            }
        }
        public Brush BatteryBrush
        {
            get { return _batteryBrush; }
            set
            {
                SetProperty(ref _batteryBrush, value);
            }
        }
        public Brush LaserBrush
        {
            get { return this._laserBrush; }
            set
            {
                SetProperty(ref _laserBrush, value);
            }
        }

        #endregion

        #region Commands
        public ICommand TestCommand { get; set; }
        public ICommand NavigateCommand { get; set; }
        public ICommand SystemOffCommand { get; set; }
        public ICommand BuzzerStopCommand { get; set; }
        public ICommand EmergencyStopCommand { get; set; }
        public ICommand StartCommand { get; set; }
        public ICommand StopCommand { get; set; }
        public ICommand AlarmResetCommand { get; set; }
        public ICommand ChangeLanguage { get; set; }
        public ICommand MachineModeChgCommand { get; set; }
        #endregion

        IEventAggregator eventAggregator = null;
        VCSystem VCSystem = null;
        MessageController messageController;

        VCSMessagePubSubEvent vcsMessagePublisher;

        IRegionManager regionManager;
        public Common.Events.HostConnectedEventArgs.eConnectedState State { get; set; }

        private DeskTopInfo dti = new DeskTopInfo();
        SqliteManager sql;

        public D_MainWindowViewModel( IEventAggregator _ea , VCSystem cSystem , IRegionManager _regionManager , MessageController _msgController, SqliteManager _sql )
        {
            this.regionManager = _regionManager;

            this.eventAggregator = _ea;
            this.eventAggregator.GetEvent<GUIMessagePubSubEvent>().Subscribe( UICallbackCommunication , ThreadOption.UIThread );
            this.eventAggregator.GetEvent<HostConnectedPubSubEvent>().Subscribe( OcsConnectCallBack , ThreadOption.UIThread , false );

            vcsMessagePublisher = this.eventAggregator.GetEvent<VCSMessagePubSubEvent>();

            this.VCSystem = cSystem;
            
            this.messageController = _msgController;
            this.sql = _sql;

            this.VehicleID = sql.ConfigDal.GetK( ConstString.VehicleID ).Value;
            //this.VehicleIP = sql.ConfigDal.GetK( ConstString.Addr ).Value;
            this.OcsIP = sql.ConfigDal.GetK( ConstString.Addr ).Value;

            this.TestCommand = new DelegateCommand( ExecuteTextCommand );
            this.NavigateCommand = new DelegateCommand<object>(this.Navigate);
            this.SystemOffCommand = new DelegateCommand(ExecuteSystemOffCommand);
            this.ChangeLanguage = new DelegateCommand(Execte_ChangeLanguage);
            this.StartCommand = new DelegateCommand(ExecuteStartCommand);
            this.StopCommand = new DelegateCommand(ExecuteStopCommand);
            this.AlarmResetCommand = new DelegateCommand( ExecuteAlarmResetCommand);
            this.EmergencyStopCommand = new DelegateCommand(ExecuteEStop);
            this.BuzzerStopCommand = new DelegateCommand( ExecuteBuzzerStop );
            this.MachineModeChgCommand = new DelegateCommand<string>( ExecuteMachineModeChgCommand );

            DispatcherTimer dateTimer = new DispatcherTimer();
            dateTimer.Tick += (object sender, EventArgs e) =>
            {
                this.DateTime = DateTime.Now;
            };
            dateTimer.Interval = TimeSpan.FromMilliseconds(500);
            dateTimer.Start();

            this.SwVersion = AssemblyUtils.GetVersion();
            this.LastBuildedTime = new Helpler.AssemblyInfo().Get_BuildDateTime();

            GSG.NET.Quartz.QuartzUtils.Invoke("RESOURCE_CHECK", GSG.NET.Quartz.QuartzUtils.GetExpnSecond(1), QuzOnResourceUsage);
        }

        void QuzOnResourceUsage()
        {
            this.CPU = GSG.NET.OSView.Mgnt.CpuUseRate();
            this.RAM = GSG.NET.OSView.Mgnt.MemPhysicalUseRate();

            var ll = GSG.NET.OSView.Mgnt.HddList();
            this.CDrive = ll.FirstOrDefault().AvailableFreeSpace / ConstUtils.ONE_GIGA_BYTES;
        }

        private void ExecuteMachineModeChgCommand( string obj )
        {
            var msg = new VCSMessageEventArgs
            {
                Kind = VCSMessageEventArgs.eVCSMessageKind.ReqMachineModeChg,
            };

            if ( this.MachineMode == eMachineMode.LocalMode )
                msg.Arg = eMachineMode.HostMode;
            else
                msg.Arg = eMachineMode.LocalMode;

            this.messageController.ShowConfirmationPopupView( $"Change to {msg.Arg} ?", r => 
            { 
                if ( r.Result == ButtonResult.OK )
                    vcsMessagePublisher.Publish( msg );
            } );

        }

        private void ExecuteBuzzerStop( )
        {
            var msg = new VCSMessageEventArgs
            {
                Kind = VCSMessageEventArgs.eVCSMessageKind.ReqBuzzerStop ,
            };
            vcsMessagePublisher.Publish( msg );

            this.ExecuteTextCommand();
        }

        private void Execte_ChangeLanguage()
        {
            //LanguageHalper.LanguagesSelcter.ChangLanguage(LanguageHalper.eLanguageType.Chinese);
        }

        private void ExecuteEStop()
        {
            var msg = new VCSMessageEventArgs
            {
                Kind = VCSMessageEventArgs.eVCSMessageKind.ReqEStop ,
            };
            vcsMessagePublisher.Publish( msg );
        }

        private void ExecuteAlarmResetCommand( )
        {
            this.messageController.ShowConfirmationPopupView(" Alarm Reset ? ", r =>
            {
                if (r.Result == ButtonResult.OK)
                {
                    var msg = new VCSMessageEventArgs
                    {
                        Kind = VCSMessageEventArgs.eVCSMessageKind.ReqAlarmReset,
                    };

                    vcsMessagePublisher.Publish(msg);
                }
            });
        }

        private void ExecuteStopCommand()
        {
            this.messageController.ShowConfirmationPopupView(" Vehicle Stop ? ", r =>
            {
                if (r.Result == ButtonResult.OK)
                {
                    var msg = new VCSMessageEventArgs
                    {
                        Kind = VCSMessageEventArgs.eVCSMessageKind.ReqVehicleModeChange,
                        MessageKey = MessageKey.ManualMode,
                    };

                    vcsMessagePublisher.Publish(msg);
                }
            });
        }

        private void ExecuteStartCommand()
        {
            this.messageController.ShowConfirmationPopupView("Request Vehicle Auto Mode ?", r =>
            {
                if (r.Result == ButtonResult.OK)
                {
                    var msg = new VCSMessageEventArgs
                    {
                        Kind = VCSMessageEventArgs.eVCSMessageKind.ReqVehicleModeChange,
                        MessageKey = MessageKey.AutoMode,
                    };
                    vcsMessagePublisher.Publish(msg);
                }
            });
        }

        private void OcsConnectCallBack(HostConnectedEventArgs obj)
        {
            this.State = obj.State;

            switch (this.State)
            {
                case HostConnectedEventArgs.eConnectedState.Disconnected:
                    this.OcsBrush = Brushes.Transparent;
                    break;
                case HostConnectedEventArgs.eConnectedState.Connected:
                    this.OcsBrush = Brushes.LimeGreen;
                    break;
            }
        }

        private void ExecuteSystemOffCommand()
        {
            this.messageController.ShowConfirmationPopupView("System ShutDown ?", r =>
              {
                  if (r.Result == ButtonResult.OK)
                      App.Current.Shutdown();
              });
        }

        private void Navigate(object obj)
        {
            var selectItem = obj.ToString();
            if (!string.IsNullOrEmpty(selectItem))
                regionManager.RequestNavigate("MainView", selectItem);
        }

        void VehicleModeChange(bool isAutoMode)
        {
            if (isAutoMode)
            {
                this.StartEnable = false;
                this.StopEnable = true;
                this.IsManualMode = false;
                regionManager.RequestNavigate(RegionNames.MainView, "AutoView");
            }
            else
            {
                this.StartEnable = true;
                this.StopEnable = false;
                this.IsManualMode = true;
            }
        }

        private void UICallbackCommunication(GUIMessageEventArgs obj)
        {
            switch ( obj.Kind )
            {
                case GUIMessageEventArgs.eGUIMessageKind.ModelPropertyChange:
                    this.UICallBackModelPropertyChange( obj );
                    break;
                case GUIMessageEventArgs.eGUIMessageKind.RspIOObject:
                    break;
                case GUIMessageEventArgs.eGUIMessageKind.RspIOMapList:
                    break;
                case GUIMessageEventArgs.eGUIMessageKind.RspCommandList:
                    break;
                case GUIMessageEventArgs.eGUIMessageKind.RspAutoModeChange:
                    break;
                case GUIMessageEventArgs.eGUIMessageKind.RspManualModeChange:
                    break;
                case GUIMessageEventArgs.eGUIMessageKind.RspAlarmReset:
                    break;
                case GUIMessageEventArgs.eGUIMessageKind.RspVehicleModeChange:
                    this.RspVehicleModeChange( obj );
                    break;
                case GUIMessageEventArgs.eGUIMessageKind.RspEStop:
                    break;
                case GUIMessageEventArgs.eGUIMessageKind.RspVihicleState:
                    break;
                case GUIMessageEventArgs.eGUIMessageKind.RspMachineModeChg:
                    RspMachineModeChg(obj);
                    break;
                default:
                    break;
            }
        }

        private void RspMachineModeChg( GUIMessageEventArgs obj )
        {
            string reason = string.Empty;

            FluentResults.Result result = obj.Result;
            if ( obj.Result.IsFailed )
            {
                 reason = result.Errors.FirstOrDefault().Message;
            }
            else
            {
                var mode = CastTo<eMachineMode>.From<object>( obj.Args );
                reason = $"Change To {mode} Successes";
            }

            this.messageController.ShowNotificationView( reason );
        }

        private void RspVehicleModeChange(GUIMessageEventArgs obj)
        {
            if ( obj.Result.IsSuccess)
            {
                if (obj.MessageKey.Equals(MessageKey.AutoMode)) { this.VehicleModeChange(true); }
                if (obj.MessageKey.Equals(MessageKey.ManualMode)) { this.VehicleModeChange(false); }
            }
            else
            {

            }
        }

        void UICallBackModelPropertyChange(GUIMessageEventArgs args)
        {
            if (args.MessageKey.Equals(MessageKey.Alarm))
            {
                var hisAlarm = args.Args as HisAlarm;
                this.messageController.ShowNotificationView(args.MessageText);
                this.VehicleModeChange(false);//알람이 발생하면 자동으로 Manual Mode 로 변경됨
            }

            if (args.MessageKey.Equals(MessageKey.Vehicle))
            {
                if (args.ModelPropertyName.Equals("VehicleStateProperty"))
                {
                    var vehicleState = CastTo<eVehicleState>.From<object>(args.Args);
                    if (vehicleState == eVehicleState.Abnormal)
                        this.IsVehicleAlarm = true;
                    else
                        this.IsVehicleAlarm = false;
                }

                if ( args.ModelPropertyName.Equals( "MachineMode" ) )
                {
                    this.MachineMode = CastTo<eMachineMode>.From<object>( args.Args );
                }
            }
        }

        private void ExecuteTextCommand()
        {
            var m = new VCSMessageEventArgs();
            m.MessageKey = "";
            m.MessageText = "Test Message";
            m.Kind = VCSMessageEventArgs.eVCSMessageKind.ReqTest;
            m.Command = new Common.Model.Command() { CommandID = "TestCommand123", Type = Common.Shareds.eCommandType.Move };

            this.eventAggregator.GetEvent<VCSMessagePubSubEvent>().Publish( m );
        }

        public void InitViewModel()
        {
            //VCSystem.Instance.Init();
            //var containerRegistry = ServiceLocator.Current.GetInstance<VCSystem>();
            //if ( containerRegistry.Equals( this.VCSystem ) )
            //{
            //    Console.WriteLine( "==" );
            //}
            //var vsys = containerRegistry.GetContainer().Resolve<IContainerProvider>();

            regionManager.RequestNavigate(RegionNames.MainView, "AutoView");
        }

        public void Dispose()
        {
            //VCSystem.Instance.Dispose();
        }

        public static void SelectCulture(string culture)
        {
            if (String.IsNullOrEmpty(culture))
                return;

            //Copy all MergedDictionarys into a auxiliar list.
            var dictionaryList = Application.Current.Resources.MergedDictionaries.ToList();

            //Search for the specified culture.     
            string requestedCulture = string.Format("StringResources.{0}.xaml", culture);
            var resourceDictionary = dictionaryList.
                FirstOrDefault(d => d.Source.OriginalString == "/OHV.ResourceDic;component/Resources/StringResource.en-US.xaml");

            if (resourceDictionary == null)
            {
                //If not found, select our default language.             
                requestedCulture = "StringResources.xaml";
                resourceDictionary = dictionaryList.
                    FirstOrDefault(d => d.Source.OriginalString == requestedCulture);
            }

            //If we have the requested resource, remove it from the list and place at the end.     
            //Then this language will be our string table to use.      
            if (resourceDictionary != null)
            {
                Application.Current.Resources.MergedDictionaries.Remove(resourceDictionary);
                Application.Current.Resources.MergedDictionaries.Add(resourceDictionary);
            }

            //Inform the threads of the new culture.     
            Thread.CurrentThread.CurrentCulture = new CultureInfo(culture);
            Thread.CurrentThread.CurrentUICulture = new CultureInfo(culture);
        }
    }
}