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

using GSG.NET.Extensions;
using OHV.Common.Events;
using OHV.Common.Shareds;
using Prism.Commands;
using Prism.Events;
using Prism.Mvvm;
using Prism.Services.Dialogs;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows.Input;
using VehicleControlSystem.ControlLayer.IO;
using static OHV.Common.Events.AxisControlEventArgs;

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

        public event Action<IDialogResult> RequestClose;


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

        public ICommand ConveyorRunCommand { get; set; }
        public ICommand PosMoveCommand { get; set; }

        IEventAggregator eventAggregator;
        MessageController messageController;

        List<BitBlock> allIOList = new List<BitBlock>();

        public ConveyorControlViewModel( IEventAggregator _ea , MessageController _msg)
        {
            this.eventAggregator = _ea;

            /*IO Publish Event*/
            //this.eventAggregator.GetEvent<IOControlPubSubEvent>().Unsubscribe( UICallbackCommunivation );
            //this.eventAggregator.GetEvent<IOControlPubSubEvent>().Subscribe( UICallbackCommunivation , ThreadOption.UIThread );

            /*Lock&UnLock Publish Event*/
            this.eventAggregator.GetEvent<AxisControlPubSubEvent>().Unsubscribe( AxisUICallbackCommunication );
            this.eventAggregator.GetEvent<AxisControlPubSubEvent>().Subscribe( AxisUICallbackCommunication , ThreadOption.UIThread );

            /*GUI Pubsub Event*/
            this.eventAggregator.GetEvent<GUIMessagePubSubEvent>().Unsubscribe( UICallbackCommunication );
            this.eventAggregator.GetEvent<GUIMessagePubSubEvent>().Subscribe( UICallbackCommunication, ThreadOption.UIThread );

            this.messageController = _msg;

            this.ConveyorRunCommand = new DelegateCommand<object>( ExecuteCvCommand );
            this.PosMoveCommand = new DelegateCommand<object>( ExecutePosMoveCommand );
        }

        private void UICallbackCommunication( GUIMessageEventArgs _args )
        {
            //TODO:[20/03/20 ys-hwang] Conveyor 에서 Vehicle 상태를 쓸 항목이 있으런지? 쓴다면 State만??
            if( _args.Kind == GUIMessageEventArgs.eGUIMessageKind.ModelPropertyChange)
            {
                if( _args.MessageKey.Equals(MessageKey.Vehicle))
                {
                    switch(_args.ModelPropertyName)
                    {
                        case "ObstacleStateProperty":
                            {
                                var reply = CastTo<eObstacleState>.From<object>( _args.Args );
                                this.ChangeObstacleState( reply );
                            }
                            break;
                    }
                }
            }

            switch ( _args.Kind )
            {
                case GUIMessageEventArgs.eGUIMessageKind.ModelPropertyChange:
                    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;
            }
        }

        private void ChangeObstacleState( eObstacleState _reply )
        {
            
        }

        private void ExecutePosMoveCommand( object obj )
        {
            this.messageController.ShowConfirmationPopupView( "Carrier Move To ?" , r =>
            {
                if ( r.Result == ButtonResult.OK )
                {
                    var selectedPos = obj.ToString();

                    var msg = new AxisControlEventArgs
                    {
                        Dir = AxisControlEventArgs.eEventDir.ToBack ,
                        Kind = AxisControlEventArgs.eAxisControlKind.Move ,
                    };

                    switch ( selectedPos )
                    {
                        case "Lock":
                            msg.PosDir = AxisControlEventArgs.ePosDir.Lock;
                            break;
                        case "UnLock":
                            msg.PosDir = AxisControlEventArgs.ePosDir.UnLock;
                            break;
                    }

                    this.AxisPublishEvent( msg );
                }
            } );
        }

        private void AxisPublishEvent( AxisControlEventArgs msg )
        {
            this.eventAggregator.GetEvent<AxisControlPubSubEvent>().Publish( msg );
        }

        private void AxisUICallbackCommunication( AxisControlEventArgs _args )
        {
            if ( _args.Dir == AxisControlEventArgs.eEventDir.ToFront )
            {
                switch ( _args.Kind )
                {
                    case AxisControlEventArgs.eAxisControlKind.NONE:
                        break;
                    case AxisControlEventArgs.eAxisControlKind.OriginReturn:
                        break;
                    case AxisControlEventArgs.eAxisControlKind.Stop:
                        break;
                    case AxisControlEventArgs.eAxisControlKind.EStop:
                        break;
                    case AxisControlEventArgs.eAxisControlKind.Move:
                        //Sync Move Success Return
                        
                        break;
                    case AxisControlEventArgs.eAxisControlKind.Jog:
                        break;
                    case AxisControlEventArgs.eAxisControlKind.ServoOn:
                        break;
                    case AxisControlEventArgs.eAxisControlKind.ServoOff:
                        break;
                    case AxisControlEventArgs.eAxisControlKind.ReqCurrentPosition:
                        break;
                    case AxisControlEventArgs.eAxisControlKind.ReqStopCurrentPosition:
                        break;
                    case AxisControlEventArgs.eAxisControlKind.FaultReset:
                        break;
                    case AxisControlEventArgs.eAxisControlKind.AxisState:
                        AxisState( _args );
                        break;
                }
            }
        }

        private void AxisState( AxisControlEventArgs args )
        {
            var left = args.Args[ "Left" ] as AxisState;
            var right = args.Args[ "Right" ] as AxisState;

            //this.IsLeftServoOn = left.IsServoOn;
            //this.IsLeftServoOriginReturn = left.IsOriginReturn;
            //this.IsLeftServoFault = left.IsAmpFault;
            //this.CurrentLockLeft = left.CurrentPosition;

            //this.IsRightServoOn = right.IsServoOn;
            //this.IsRightServoOriginReturn = right.IsOriginReturn;
            //this.IsRightServoFault = right.IsAmpFault;
            //this.CurrentLockRight = right.CurrentPosition;
        }

        private void UICallbackCommunivation( IOControlEventArgs _args )
        {
            if ( _args.EventDir == IOControlEventArgs.eEventDir.ToBack )
            {
                switch ( _args.ControlKind )
                {
                    case IOControlEventArgs.eControlKind.USE:
                        break;
                    case IOControlEventArgs.eControlKind.ON:
                        break;
                    case IOControlEventArgs.eControlKind.OFF:
                        break;
                    case IOControlEventArgs.eControlKind.STATE:
                        break;
                }
            }
        }

        private void ExecuteCvCommand( object _obj )
        {
            var type = _obj.ToString();
            var order = string.Empty;

            switch(type)
            {
                case "CW":
                    order = "OUT_CV_CWCCW";
                    break;
                case "CCW":
                    order = "OUT_CV_CWCCW";
                    break;
                case "STOP":
                    order = "STOP";
                    break;
            }

            var msg = new IOControlEventArgs
            {
                EventDir = IOControlEventArgs.eEventDir.ToBack,
                OutPutTag = order.ToString()
            };

            this.PublishEvent( msg );
        }

        private void PublishEvent( IOControlEventArgs _args )
        {
            this.eventAggregator.GetEvent<IOControlPubSubEvent>().Publish( _args );
        }

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

        public void OnDialogClosed( )
        {
            this.eventAggregator.GetEvent<IOControlPubSubEvent>().Publish( new IOControlEventArgs { EventDir = IOControlEventArgs.eEventDir.ToBack } );
            this.eventAggregator.GetEvent<IOControlPubSubEvent>().Unsubscribe( UICallbackCommunivation );

            //TODO:[03-14 ys-hwang] - Closed 해제 처리해줄때 Kind == OriginReturn 값이 들어와버림 그래서 NONE 생성 
            this.eventAggregator.GetEvent<AxisControlPubSubEvent>().Publish( new AxisControlEventArgs 
            { 
                Dir = AxisControlEventArgs.eEventDir.ToBack, 
                Kind = AxisControlEventArgs.eAxisControlKind.NONE 
            } );
            this.eventAggregator.GetEvent<AxisControlPubSubEvent>().Unsubscribe( AxisUICallbackCommunication );
        }

        public void OnDialogOpened( IDialogParameters parameters )
        {
            /*IO*/
            var ioMsg = new IOControlEventArgs
            {
                EventDir = IOControlEventArgs.eEventDir.ToBack ,
                ControlKind = IOControlEventArgs.eControlKind.STATE
            };
            this.PublishEvent( ioMsg );

            this.eventAggregator.GetEvent<IOControlPubSubEvent>().Publish( new IOControlEventArgs { EventDir = IOControlEventArgs.eEventDir.ToBack } );

            /*Lock Axis*/
            var axisMsg = new AxisControlEventArgs
            {
                Dir = AxisControlEventArgs.eEventDir.ToBack ,
                Kind = AxisControlEventArgs.eAxisControlKind.NONE
            };

            this.AxisPublishEvent(axisMsg);

            this.eventAggregator.GetEvent<AxisControlPubSubEvent>().Publish( new AxisControlEventArgs { Dir = AxisControlEventArgs.eEventDir.ToBack , Kind = AxisControlEventArgs.eAxisControlKind.NONE } );
        }

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