OHV/Dev/OHV/OHV.Module.Interactivity/PopUp/ServoConfigViewModel.cs

using GSG.NET.Extensions;
using OHV.Common.Events;
using OHV.Common.Model;
using OHV.Common.Shareds;
using OHV.SqliteDAL;
using Prism.Commands;
using Prism.Events;
using Prism.Mvvm;
using Prism.Services.Dialogs;
using System;
using System.Collections.Generic;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows;
using System.Windows.Input;
using System.Windows.Threading;

namespace OHV.Module.Interactivity.PopUp
{
    public class ServoConfigViewModel : BindableBase, IDialogAware
    {
        private DelegateCommand<string> _closeDialogCommand;
        public DelegateCommand<string> CloseDialogCommand =>
            _closeDialogCommand ?? ( _closeDialogCommand = new DelegateCommand<string>( CloseDialog ) );

        private string _title = "ServoConfigView";

        public event Action<IDialogResult> RequestClose;

        public string Title
        {
            get { return this._title; }
            set
            {
                this.SetProperty( ref this._title , value );
            }
        }

        #region Drive Property

        #region Auto
        private double acceleration;

        public double Acceleration
        {
            get { return acceleration; }
            set
            {
                SetProperty( ref this.acceleration , value );
            }
        }

        private double deceleration;

        public double Deceleration
        {
            get { return deceleration; }
            set 
            {
                SetProperty( ref this.deceleration , value );
            }
        }

        private double creepSpeed;

        public double CreepSpeed
        {
            get { return creepSpeed; }
            set 
            {
                SetProperty( ref this.creepSpeed , value );
            }
        }

        private double creepDistance;

        public double CreepDistance
        {
            get { return creepDistance; }
            set 
            {
                SetProperty( ref this.creepDistance , value );
            }
        }

        private double linearSpeed;

        public double LinearSpeed
        {
            get { return linearSpeed; }
            set 
            {
                SetProperty( ref this.linearSpeed , value );
            }
        }

        private double curveSpeed;

        public double CurveSpeed
        {
            get { return curveSpeed; }
            set 
            {
                SetProperty( ref this.curveSpeed , value );
            }
        }

        private int steeringChangeTimeout;

        public int SteeringChangeTimeout
        {
            get { return steeringChangeTimeout; }
            set 
            {
                SetProperty( ref this.steeringChangeTimeout , value );
            }
        }

        private double jogSpeed;

        public double JogSpeed
        {
            get { return jogSpeed; }
            set 
            {
                this.SetProperty(ref this.jogSpeed, value);
            }
        }

        #endregion

        #region Manual
        private double manualMaxLinearSpeed;

        public double ManualMaxLinearSpeed
        {
            get { return manualMaxLinearSpeed; }
            set 
            {
                SetProperty( ref this.manualMaxLinearSpeed , value );
            }
        }

        private double manualMaxCurveSpeed;

        public double ManualMaxCurveSpeed
        {
            get { return manualMaxCurveSpeed; }
            set 
            {
                SetProperty( ref this.manualMaxCurveSpeed , value );
            }
        }

        private int manualCommandTimeout;

        public int ManualCommandTimeout
        {
            get { return manualCommandTimeout; }
            set 
            {
                SetProperty( ref this.manualCommandTimeout , value );
            }
        }
        #endregion
        #endregion

        public ICommand SaveDriveSpeed { get; set; }
        public ICommand SaveSpeedProfile { get; set; }
        public ICommand SaveJogSpeed { get; set; }
        public ICommand InputNumberCommand { get; set; }

        IEventAggregator eventAggregator = null;
        SqliteManager sql;
        MessageController messageController;

        VCSMessagePubSubEvent vcsMessagePublisher;

        public ServoConfigViewModel(IEventAggregator ea, SqliteManager _sql, MessageController _messageController)
        {
            this.eventAggregator = ea;
            this.eventAggregator.GetEvent<GUIMessagePubSubEvent>().Unsubscribe( UICallbackCommunication );
            this.eventAggregator.GetEvent<GUIMessagePubSubEvent>().Subscribe( UICallbackCommunication , ThreadOption.UIThread );

            this.messageController = _messageController;

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

            InputNumberCommand = new DelegateCommand<object>(ExecuteInputNumberCommand);

            SaveDriveSpeed = new DelegateCommand(SaveToDriveSpeed);
            SaveSpeedProfile = new DelegateCommand(SaveToSpeedProfile);
            SaveJogSpeed = new DelegateCommand(SaveToJogSpeed);

            this.sql = _sql;
        }
        
        private void ExecuteInputNumberCommand(object obj)
        {
            var numPad = new CalcuratorView();
            var result = numPad.ShowDialog(0);

            if(result < 0)
            {
                this.messageController.ShowNotificationView("Value Error");
                return;
            }
            
            if (obj.Equals("Linear"))
                this.LinearSpeed = Convert.ToDouble(result);
            else if (obj.Equals("Curve"))
                this.CurveSpeed = Convert.ToDouble(result);
            else if (obj.Equals("Accel"))
                this.Acceleration = Convert.ToDouble(result);
            else if (obj.Equals("Decel"))
                this.Deceleration = Convert.ToDouble(result);
            else if (obj.Equals("Creep"))
                this.CreepSpeed = Convert.ToDouble(result);
            else if (obj.Equals("CreepDistance"))
                this.CreepDistance = Convert.ToDouble(result);
            else if (obj.Equals("JogSpeed"))
                this.JogSpeed = Convert.ToDouble(result);
        }

        private void SaveToJogSpeed()
        {
            var msg = new VCSMessageEventArgs
            {
                Kind = VCSMessageEventArgs.eVCSMessageKind.ReqJogSpeed,
                Args = new Dictionary<string, object>(),
            };

            msg.Args.Add("JogSpeed", JogSpeed);

            this.Publish(msg);
        }

        private void SaveToSpeedProfile()
        {
            var msg = new VCSMessageEventArgs
            {
                Kind = VCSMessageEventArgs.eVCSMessageKind.ReqSpeedProfile,
                Args = new Dictionary<string, object>(),
            };

            msg.Args.Add("Accel", this.Acceleration);
            msg.Args.Add("Decel", this.Deceleration);
            msg.Args.Add("Creep", this.CreepSpeed);
            msg.Args.Add("CreepDistance", this.CreepDistance);

            this.Publish(msg);
        }

        private void SaveToDriveSpeed()
        {
            var msg = new VCSMessageEventArgs
            {
                Kind = VCSMessageEventArgs.eVCSMessageKind.ReqDirveSpeed,
                Args = new Dictionary<string, object>(),
            };

            msg.Args.Add("Linear", this.LinearSpeed);
            msg.Args.Add("Curve", this.CurveSpeed);

            this.Publish(msg);
        }

        void Publish(VCSMessageEventArgs msg)
        {
            this.vcsMessagePublisher.Publish(msg);
        }

        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:
                    break;
                case GUIMessageEventArgs.eGUIMessageKind.RspEStop:
                    break;
                case GUIMessageEventArgs.eGUIMessageKind.RspVihicleState:
                    break;
                case GUIMessageEventArgs.eGUIMessageKind.RspMachineModeChg:
                    break;
                case GUIMessageEventArgs.eGUIMessageKind.RspAddCommand:
                    break;
                case GUIMessageEventArgs.eGUIMessageKind.RspConveyorMove:
                    break;
                case GUIMessageEventArgs.eGUIMessageKind.RspConveyorLoad:
                    break;
                case GUIMessageEventArgs.eGUIMessageKind.RspConveyorUnload:
                    break;
                case GUIMessageEventArgs.eGUIMessageKind.RspPIOConveyor:
                    break;
                case GUIMessageEventArgs.eGUIMessageKind.RspPIOBatteryCharge:
                    break;
                case GUIMessageEventArgs.eGUIMessageKind.RsqPIOBatteryChargeStop:
                    break;
                case GUIMessageEventArgs.eGUIMessageKind.RspObstaclePatternChg:
                    break;
                case GUIMessageEventArgs.eGUIMessageKind.RspObstaclePatternNo:
                    break;
                case GUIMessageEventArgs.eGUIMessageKind.RspBatteryState:
                    break;
                case GUIMessageEventArgs.eGUIMessageKind.RspRouteManager:
                    break;
                case GUIMessageEventArgs.eGUIMessageKind.ReqDirveSpeed:
                    {
                        if (obj.Result.IsFailed)
                            this.messageController.ShowNotificationView("Fail!! Set Drive Speed", false);
                        else
                            this.messageController.ShowNotificationView("Success");
                    }
                    break;
                case GUIMessageEventArgs.eGUIMessageKind.ReqSpeedProfile:
                    {
                        if (obj.Result.IsFailed)
                            this.messageController.ShowNotificationView("Fail!! Set SpeedProfile", false);
                        else
                            this.messageController.ShowNotificationView("Success");
                    }
                    break;
                case GUIMessageEventArgs.eGUIMessageKind.ReqJogSpeed:
                    {
                        if (obj.Result.IsFailed)
                            this.messageController.ShowNotificationView("Fail!! Set JogSpeed", false);
                        else
                            this.messageController.ShowNotificationView("Success");
                    }
                    break;
            }
        }

        void UICallBackModelPropertyChange(GUIMessageEventArgs args)
        {
            if (args.MessageKey.Equals(MessageKey.Vehicle))
            {
                switch(args.ModelPropertyName)
                {
                    case "LinearSpeed":
                        this.LinearSpeed = CastTo<double>.From<object>(args);
                        break;
                    case "CurveSpeed":
                        this.CurveSpeed = CastTo<double>.From<object>(args);
                        break;
                    case "JogSPeed":
                        this.JogSpeed = CastTo<double>.From<object>(args);
                        break;
                    case "AccelSpeed":
                        this.Acceleration = CastTo<double>.From<object>(args);
                        break;
                    case "DecelSpeed":
                        this.Deceleration = CastTo<double>.From<object>(args);
                        break;
                    case "CreepSpeed":
                        this.CreepSpeed = CastTo<double>.From<object>(args);
                        break;
                    case "CreepDistance":
                        this.CreepDistance = CastTo<double>.From<object>(args);
                        break;
                    default:
                        break;
                }
            }
        }

        #region Dialog 
        public bool CanCloseDialog( )
        {
            return true;
        }

        public void OnDialogClosed( )
        {
        }

        public void OnDialogOpened( IDialogParameters parameters )
        {
            //Requst
        }

        protected virtual void CloseDialog( string parameter )
        {
            ButtonResult result = ButtonResult.None;

            if ( parameter?.ToLower() == "true" )
                result = ButtonResult.OK;
            else if ( parameter?.ToLower() == "false" )
                result = ButtonResult.Cancel;

            RaiseRequestClose( new DialogResult( result ) );
        }
        public virtual void RaiseRequestClose( IDialogResult dialogResult )
        {
            RequestClose?.Invoke( dialogResult );
        }
        #endregion

        public void Init( ) { }
    }
}