OHV/Dev/OHV/OHV.Module.Interactivity/PopUp/DriveServoViewModel.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.Collections.ObjectModel;
using System.Linq;
using System.Threading.Tasks;
using System.Windows.Input;
using System.Windows.Media;

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

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

        private string _selectedPosition = string.Empty;
        public string SelectedPosition
        {
            get => this._selectedPosition;
            set
            {
                this.SetProperty(ref this._selectedPosition, value);
            }
        }

        private string _selectDirection = string.Empty;
        public string SelectDirection
        {
            get => this._selectDirection;
            set { this.SetProperty(ref this._selectDirection, value); }
        }

        #region Motor Left Binding Value
        private double _driveTargetPos;
        public double DriveTargetPos
        {
            get { return this._driveTargetPos; }
            set { this.SetProperty(ref this._driveTargetPos , value); }
        }

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

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

        private double _jogVelocity;
        public double JogVelocity
        {
            get { return this._jogVelocity; }
            set { this.SetProperty(ref this._jogVelocity, value); }
        }
        #endregion

        public event Action<IDialogResult> RequestClose;

        public ICommand SelectAxisCommand { get; set; }
        public ICommand KeyInTargetPosCommand { get; set; }
        public ICommand SelectPosCommand { get; set; }
        public ICommand MoveToCommand { get; set; }
        public ICommand CurrentToTargetCommand { get; set; }
        public ICommand ServoOnCommand { get; set; }
        public ICommand ServoOffCommand { get; set; }
        public ICommand FaultResetCommand { get; set; }
        public ICommand OriginCommand { get; set; }

        public IEventAggregator eventAggregator;
        public ICommand PositionAddCommand { get; set; }
        public ICommand PositionDeleteCommand { get; set; }
        public ICommand PositionSaveCommand { get; set; }
        public ICommand SteeringCWCommand { get; set; }
        public ICommand SteeringCCWCommand { get; set; }
        public ICommand SelectedDirection { get; set; }
        public ICommand JogVelPopupCommand { get; set; }
        public ICommand JogCommand { get; set; }

        #region Brushes
        private Brush steeringLeftBrush = Brushes.Gray;
        public Brush SteeringLeftBrushProperty
        {
            get { return steeringLeftBrush; }
            set { SetProperty(ref this.steeringLeftBrush, value); }
        }

        private Brush steeringRightBrush = Brushes.Gray;
        public Brush SteeringRightBrushProperty
        {
            get { return steeringRightBrush; }
            set { SetProperty(ref this.steeringRightBrush, value); }
        }
        #endregion

        private ObservableCollection<Route> _routeList;
        public ObservableCollection<Route> RouteList
        {
            get { return this._routeList; }
            set { SetProperty(ref this._routeList, value); }
        }

        public SqliteDAL.DAL.AxisPositionDataDAL axisPositionDataDal;
        SqliteManager sql;
        MessageController messageController;

        public DriveServoViewModel(IEventAggregator _ea, SqliteManager _sql, MessageController _messageController)
        {
            this.eventAggregator = _ea;
            this.eventAggregator.GetEvent<DriveControlPubSubEvent>().Unsubscribe( DriveControlCallBack );
            this.eventAggregator.GetEvent<DriveControlPubSubEvent>().Subscribe( DriveControlCallBack , ThreadOption.UIThread );

            /*상태 회신을 받기 위함*/
            this.eventAggregator.GetEvent<GUIMessagePubSubEvent>().Unsubscribe( UICallBackCommunication );
            this.eventAggregator.GetEvent<GUIMessagePubSubEvent>().Subscribe( UICallBackCommunication , ThreadOption.UIThread );

            this.sql = _sql;
            this.RouteList = new ObservableCollection<Route>(sql.RouteDal.All);

            this.messageController = _messageController;

            this.SelectPosCommand = new DelegateCommand<object>(ExecuteSelectPosCommand);
            this.MoveToCommand = new DelegateCommand(ExecuteMoveToCommand);
            this.CurrentToTargetCommand = new DelegateCommand(ExecuteCurrentToTargetCommand);
            this.KeyInTargetPosCommand = new DelegateCommand<object>(ExecuteKeyInCommadn);

            this.ServoOnCommand = new DelegateCommand(ExecuteServoOnCommand);
            this.ServoOffCommand = new DelegateCommand(ExecuteServoOffCommand);
            this.FaultResetCommand = new DelegateCommand(ExecuteFaultResetCommand);
            this.OriginCommand = new DelegateCommand(ExecuteOriginCommand);

            this.PositionAddCommand = new DelegateCommand(ExecutePositionAddCommand);
            this.PositionDeleteCommand = new DelegateCommand(ExecutePositionDeleteCommand);
            this.PositionSaveCommand = new DelegateCommand(ExecutePositionSaveCommand);

            this.SelectedDirection = new DelegateCommand<object>(ExecuteSelectedDirection);
            this.SteeringCWCommand = new DelegateCommand<object>(ExecuteSteeringCWCommand);
            this.SteeringCCWCommand = new DelegateCommand<object>(ExecuteSteeringCCWCommand);

            this.JogVelPopupCommand = new DelegateCommand(ExecuteJogVelPopupCommand);
            this.JogCommand = new DelegateCommand<object>(ExecuteJogCommand);
        }

        private void UICallBackCommunication( GUIMessageEventArgs obj )
        {
            //Property 상태가 바뀔때 마다 표현만 하면 된다?

            if ( obj.Kind == GUIMessageEventArgs.eGUIMessageKind.ModelPropertyChange )
            {
                if ( obj.MessageKey.Equals( MessageKey.Vehicle ) )
                {
                    switch ( obj.ModelPropertyName )
                    {
                        case "SteeringState":
                            {
                                var dir = CastTo<eSteeringState>.From<object>( obj.Args );
                                this.ChangeSteeringDirection( dir );
                            }
                            break;
                        case "VehicleStateProperty":
                            {
                                var v = CastTo<eVehicleState>.From<object>( obj.Args );
                                this.ChagneVehicleState( v );
                            }
                            break;
                        case "ObstacleStateProperty":
                            {
                                var reply = CastTo<eObstacleState>.From<object>( obj.Args );
                                this.ChangeObstacleState( reply );
                            }
                            break;
                        case "CurrentPosition":
                            {
                                var v = CastTo<double>.From<object>(obj.Args);
                                this.CurrentDrive = v;
                            }
                            break;
                        case "CurrentTag":
                            break;
                        case "CurrentSpeed":
                            break;
                        case "CurrentTorque":
                            break;
                        default:
                            break;
                    }
                }
            }
        }

        private void ChangeObstacleState( eObstacleState reply )
        {
            
        }

        private void ChagneVehicleState( eVehicleState v )
        {
            //TODO:[20/03/20 ys-hwang] Vehicle Manual Move 할때? 상태를 보고 해야?, 아니면 Manual 이니까???? 
            // 아니면 busy 상태 확인만 ?
            switch ( v )
            {
                case eVehicleState.None:
                    break;
                case eVehicleState.Idle:
                    break;
                case eVehicleState.Move:
                    break;
                case eVehicleState.Load:
                    break;
                case eVehicleState.Unload:
                    break;
                case eVehicleState.Charge:
                    break;
                case eVehicleState.Abnormal:
                    break;
                case eVehicleState.Blocked:
                    break;
                case eVehicleState.Decelerate:
                    break;
            }
        }

        private void DriveControlCallBack( DriveControlEventArgs args)
        {
            //TODO:[20/03/19 ys-hwang] Drive UI return msg popup

            if (args.EventDir == DriveControlEventArgs.eEventDir.ToFront)
            {
                switch ( args.ControlKind )
                {
                    case DriveControlEventArgs.eControlKind.MOVE:
                        ResponseMove(args);
                        break;
                    case DriveControlEventArgs.eControlKind.STOP:
                        break;
                    case DriveControlEventArgs.eControlKind.Steering:
                        //if ( args.Result.IsSuccess )
                        //{
                        //    var dir = args.Result.ToResult<DriveControlEventArgs.eMoveDir>().Value;
                        //    this.ChangeSteeringDirection( dir == DriveControlEventArgs.eMoveDir.LEFT ? true : false );
                        //}
                        break;
                    case DriveControlEventArgs.eControlKind.SteeringState:
                        //if ( args.Result.IsSuccess )
                        //{
                        //    var dir = args.Result.ToResult<DriveControlEventArgs.eMoveDir>().Value;
                        //    this.ChangeSteeringDirection( dir == DriveControlEventArgs.eMoveDir.LEFT ? true : false );
                        //}
                        break;
                    case DriveControlEventArgs.eControlKind.ReqCurrentPos:
                        this.CurrentDrive = args.CurrentPosition;
                        break;
                    case DriveControlEventArgs.eControlKind.ReqStopCurrentPos:
                        break;
                    case DriveControlEventArgs.eControlKind.FaultReset:
                        break;
                    case DriveControlEventArgs.eControlKind.DriveON:
                        break;
                    case DriveControlEventArgs.eControlKind.DriveOFF:
                        break;
                    case DriveControlEventArgs.eControlKind.JOG:
                        break;
                    case DriveControlEventArgs.eControlKind.VehicleState:
                        ResponseVehicleState(args);
                        break;
                    default:
                        break;
                }
            }
        }

        private void ResponseVehicleState(DriveControlEventArgs args)
        {
            var state = CastTo<VehicleState>.From<object>( args.Args );
            this.CurrentDrive = state.CurrentPosition;
        }

        private void ResponseMove( DriveControlEventArgs args )
        {
            var msg = string.Empty;
            if(args.Result.IsSuccess)
            {
                msg = "Move Successs";
            }
            else
            {
                var error = args.Result.Errors.FirstOrDefault();
                var alarm = error.Metadata[ "Alarm" ] as Alarm;
                msg = alarm.Name + " " + alarm.Text;
            }

            this.messageController.ShowNotificationView( msg );
        }

        void PublishEvent(DriveControlEventArgs args)
        {
            this.eventAggregator.GetEvent<DriveControlPubSubEvent>().Publish(args);
        }

        void ChangeSteeringDirection(eSteeringState state)
        {
            if ( state == eSteeringState.Left )
            {
                this.SteeringLeftBrushProperty = ( System.Windows.Media.Brush )new System.Windows.Media.BrushConverter().ConvertFromString( "#FF00FFD3" );
                this.SteeringRightBrushProperty = Brushes.Gray;
            }
            else if ( state == eSteeringState.Right )
            {
                this.SteeringLeftBrushProperty = Brushes.Gray;
                this.SteeringRightBrushProperty = ( System.Windows.Media.Brush )new System.Windows.Media.BrushConverter().ConvertFromString( "#FF00FFD3" );
            }
            else
            {
                this.SteeringLeftBrushProperty = Brushes.Gray;
                this.SteeringRightBrushProperty = Brushes.Gray;
            }
        }

        #region Execute Method
        private void ExecuteJogCommand(object obj)
        {
            var msg = new DriveControlEventArgs
            {
                EventDir = DriveControlEventArgs.eEventDir.ToBack,
                ControlKind = DriveControlEventArgs.eControlKind.JOG,
            };

            if ( obj.ToString().Equals( "+" ) )
                msg.JogDir = DriveControlEventArgs.eJogMoveDir.Positive;
            else
                msg.JogDir = DriveControlEventArgs.eJogMoveDir.Negative;

            this.PublishEvent( msg );
        }

        private void ExecuteJogVelPopupCommand()
        {
            var numPad = new CalcuratorView();
            var result = numPad.ShowDialog(this.JogVelocity);

            this.JogVelocity = result;
        }

        private void ExecuteSelectedDirection(object obj)
        {
            this.SelectDirection = obj.ToString();
        }

        private void ExecuteSteeringCCWCommand(object obj)
        {
            var msg = new DriveControlEventArgs
            {
                EventDir = DriveControlEventArgs.eEventDir.ToBack,
                ControlKind = DriveControlEventArgs.eControlKind.Steering,
            };

            if (obj.ToString().Equals("CCW"))
                msg.MoveDir = DriveControlEventArgs.eMoveDir.RIGHT;
            else
                msg.MoveDir = DriveControlEventArgs.eMoveDir.LEFT;

            this.PublishEvent(msg);
        }

        private void ExecuteSteeringCWCommand(object obj)
        {
            var msg = new DriveControlEventArgs
            {
                EventDir = DriveControlEventArgs.eEventDir.ToBack,
                ControlKind = DriveControlEventArgs.eControlKind.Steering,
            };

            if (obj.ToString().Equals("CW"))
                msg.MoveDir = DriveControlEventArgs.eMoveDir.LEFT;
            else
                msg.MoveDir = DriveControlEventArgs.eMoveDir.RIGHT;

            this.PublishEvent(msg);
        }

        private void ExecutePositionSaveCommand()
        { 
            this.messageController.ShowConfirmationPopupView("Save To Data ?", r =>
            {
              if (r.Result == ButtonResult.OK)
              {
                    //TODO:[20/03/18 ys-hwang] DB Table Update
              }
            });
        }

        private void ExecutePositionDeleteCommand()
        {
            this.messageController.ShowConfirmationPopupView( "Select To Delete ?" , r =>
            {
                if ( r.Result == ButtonResult.OK )
                {
                    var deleteList = new List<Route>();

                    foreach ( var item in this.RouteList )
                    {
                        if ( item.IsSelected )
                            deleteList.Add( item );
                    }
                    deleteList.ForEach( x => { this.RouteList.Remove( x ); } );
                }
            } );
        }

        private void ExecutePositionAddCommand()
        {
            this.messageController.ShowConfirmationPopupView( "Position Add ?" , r =>
            {
                if ( r.Result == ButtonResult.OK )
                {
                    this.RouteList.Add( new Route() );

                    this.messageController.ShowNotificationView( "Create Success" );
                }
            } );
        }

        private void ExecuteKeyInCommadn(object obj)
        {
            var numPad = new CalcuratorView();
            var result = numPad.ShowDialog(this.DriveTargetPos );
            this.DriveTargetPos = result;
        }

        private void ExecuteOriginCommand()
        {
            this.messageController.ShowConfirmationPopupView( "Origin ?" , r =>
            {
                if ( r.Result == ButtonResult.OK )
                {
                    //TODO: How to use
                }
            } );
        }

        private void ExecuteFaultResetCommand()
        {
            var msg = new DriveControlEventArgs
            {
                EventDir = DriveControlEventArgs.eEventDir.ToBack ,
                ControlKind = DriveControlEventArgs.eControlKind.FaultReset ,
            };

            this.PublishEvent( msg );
        }

        private void ExecuteServoOffCommand()
        {
            var msg = new DriveControlEventArgs
            {
                EventDir = DriveControlEventArgs.eEventDir.ToBack ,
                ControlKind = DriveControlEventArgs.eControlKind.DriveOFF ,
            };

            this.PublishEvent( msg );
        }

        private void ExecuteServoOnCommand()
        {
            var msg = new DriveControlEventArgs
            {
                EventDir = DriveControlEventArgs.eEventDir.ToBack ,
                ControlKind = DriveControlEventArgs.eControlKind.DriveON ,
            };

            this.PublishEvent( msg );
        }

        private void ExecuteCurrentToTargetCommand()
        {
            this.messageController.ShowConfirmationPopupView( "Current To Target ?" , r =>
            {
                if ( r.Result == ButtonResult.OK )
                {
                    this.DriveTargetPos = this.CurrentDrive;
                }
            } );
        }

        private void ExecuteMoveToCommand()
        {
            this.messageController.ShowConfirmationPopupView( "Move To Selected Position ?" , r =>
            {
                if ( r.Result == ButtonResult.OK )
                {
                    //TODO:[20/03/20 ys-hwang] RoutList.IsSelected Check
                    //if(this.RouteList.Any( x => x.IsSelected != true ))
                    //    return;
                    var result = this.RouteList.Any( x => x.IsSelected != false );

                    var ll = this.RouteList.Where(x => x.IsSelected).FirstOrDefault();

                    var msg = new DriveControlEventArgs
                    {
                        EventDir = DriveControlEventArgs.eEventDir.ToBack,
                        ControlKind = DriveControlEventArgs.eControlKind.MOVE,
                        TargetRouteID = ll.Id,
                    };

                    this.PublishEvent( msg );
                }
            } );
        }

        private void ExecuteSelectPosCommand(object obj)
        {
            this.SelectedPosition = obj.ToString();
        }

        #endregion

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

        public void OnDialogClosed()
        {
            this.eventAggregator.GetEvent<DriveControlPubSubEvent>().Publish( new DriveControlEventArgs { EventDir = DriveControlEventArgs.eEventDir.ToBack , ControlKind = DriveControlEventArgs.eControlKind.ReqStopCurrentPos } );
            this.eventAggregator.GetEvent<DriveControlPubSubEvent>().Unsubscribe( DriveControlCallBack );
        }

        public void OnDialogOpened(IDialogParameters parameters)
        {
            var msg = new DriveControlEventArgs
            {
                EventDir = DriveControlEventArgs.eEventDir.ToBack,
                ControlKind = DriveControlEventArgs.eControlKind.SteeringState,
            };
            this.PublishEvent(msg);

            //this.eventAggregator.GetEvent<DriveControlPubSubEvent>().Publish( new DriveControlEventArgs { EventDir = DriveControlEventArgs.eEventDir.ToBack , ControlKind = DriveControlEventArgs.eControlKind.VehicleState } );
        }

        private 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
    }
}