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

using GSG.NET.Extensions;
using OHV.Common.Events;
using OHV.Common.Model;
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 System.Windows.Media;
using VehicleControlSystem;
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 );
            }
        }

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

        private Brush _cvStop = Brushes.Gray;
        public Brush CvStop { get { return _cvStop; } set { SetProperty( ref _cvStop , value ); } }

        private Brush _cvSlowStop = Brushes.Gray;
        public Brush CvSlowStop { get { return _cvSlowStop; } set { SetProperty( ref _cvSlowStop , value ); } }

        private Brush _cvEntryIn = Brushes.Gray;
        public Brush CvEntryIn { get { return _cvEntryIn; } set { SetProperty( ref _cvEntryIn , value ); } }
        private Brush _cvRun = Brushes.Gray;
        public Brush CvRun { get { return _cvRun; } set { SetProperty( ref _cvRun , value ); } }

        private Brush _cvCW = Brushes.Gray;
        public Brush CvCW { get { return _cvCW; } set { SetProperty( ref _cvCW , value ); } }

        private Brush _cvCCW = Brushes.Gray;
        public Brush CvCCW { get { return _cvCCW; } set { SetProperty( ref _cvCCW , value ); } }

        private Brush _axisLeftIsOrg = Brushes.Red;// = Brushes.Gray;
        private Brush _axisLeftAmpFault = Brushes.Gray;// = Brushes.Gray;

        private Brush _axisRightIsOrg = Brushes.Red;// = Brushes.Gray;
        private Brush _axisRightAmpFault = Brushes.Gray;// = Brushes.Gray;

        public Brush AxisLeftIsOrg
        {
            get { return _axisLeftIsOrg; }
            set
            {
                SetProperty( ref _axisLeftIsOrg , value );
            }
        }
        public Brush AxisLeftAmpFault
        {
            get { return _axisLeftAmpFault; }
            set
            {
                SetProperty( ref _axisLeftAmpFault , value );
            }
        }
        public Brush AxisRightIsOrg
        {
            get { return _axisRightIsOrg; }
            set
            {
                SetProperty( ref _axisRightIsOrg , value );
            }
        }
        public Brush AxisRightAmpFault
        {
            get { return _axisRightAmpFault; }
            set
            {
                SetProperty( ref _axisRightAmpFault , value );
            }
        }

        #endregion

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

        IEventAggregator eventAggregator;
        MessageController messageController;

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

        VCSystem VCSystem;
        EzIO IO = null;

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

            this.VCSystem = _vcSystem;
            this.IO = VCSystem.IO as EzIO;
            this.IO.OnChangedIO += IO_OnChangedIO;

            this.GetSensorState(this.IO);
            //if ( this.IO.IsOn( "IN_CV_ERROR" ) )
            //    this.CvError = Brushes.LimeGreen;

            /*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 GetSensorState( EzIO _iO )
        {
            //IO_OnChangedIO 중복됨 어쩌지
            if ( _iO.IsOn( "IN_CV_ERROR" ) )
                this.CvError = Brushes.LimeGreen;

            if(_iO.IsOn( "IN_CV_DETECT_00" ) )
                this.CvEntryIn = Brushes.LimeGreen;

            if ( _iO.IsOn( "IN_CV_DETECT_01" ) )
                this.CvSlowStop = Brushes.LimeGreen;

            if ( _iO.IsOn( "IN_CV_DETECT_02" ) )
                this.CvStop = Brushes.LimeGreen;
        }

        private void IO_OnChangedIO( BitBlock bit )
        {
            if ( bit.Tag.Equals( "IN_CV_ERROR" ) )
                this.CvError = Brushes.LimeGreen;
            else
                this.CvError = Brushes.Gray;

            if ( bit.Tag.Equals( "IN_CV_DETECT_00" ) )
                this.CvEntryIn = Brushes.LimeGreen;
            else
                this.CvEntryIn = Brushes.Gray;

            if ( bit.Tag.Equals( "IN_CV_DETECT_01" ) )
                this.CvSlowStop = Brushes.LimeGreen;
            else
                this.CvSlowStop = Brushes.Gray;

            if ( bit.Tag.Equals( "IN_CV_DETECT_02" ) )
                this.CvStop = Brushes.LimeGreen;
            else
                this.CvStop = Brushes.Gray;

            if ( bit.Tag.Equals( "OUT_CV_CWCCW" ) )
            {
                this.CvCW = Brushes.LimeGreen;
                this.CvCCW = Brushes.Gray;
            }
            else
            {
                this.CvCW = Brushes.Gray;
                this.CvCCW = Brushes.LimeGreen;
            }
        }

        private void RspIOState( VCSMessageEventArgs args )
        {
            //var ioAll = args.Args as EzIO;
        }

        private void UICallbackCommunication( GUIMessageEventArgs _args )
        {
            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;
                    }
                }
            }
        }

        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.SyncMove ,
                    };

                    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:
                        ResponseMove( _args );
                        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;
                    case eAxisControlKind.SyncMove:
                        if ( _args.Result.IsSuccess )
                            this.messageController.ShowNotificationView( "Success" );
                        else
                            this.messageController.ShowNotificationView( "Fail" );
                        break;
                }
            }
        }

        private void ResponseMove( AxisControlEventArgs _args )
        {
            var msg = string.Empty;

            if ( _args.Result.IsSuccess )
                msg = ( "Move Success" );
            else
            {
                var error = _args.Result.Errors.FirstOrDefault();
                var alarm = error.Metadata[ "Alarm" ] as Alarm;
                msg = alarm.Name + " " + alarm.Text;
            }

            this.messageController.ShowNotificationView( msg );
        }

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

            if ( left.IsOriginReturn )
                this.AxisLeftIsOrg = Brushes.LimeGreen;
            else
                this.AxisLeftIsOrg = Brushes.Red;

            if ( left.IsAmpFault )
                this.AxisLeftAmpFault = Brushes.Red;
            else
                this.AxisLeftAmpFault = Brushes.Gray;

            if ( right.IsOriginReturn )
                this.AxisRightIsOrg = Brushes.LimeGreen;
            else
                this.AxisRightIsOrg = Brushes.Red;

            if ( right.IsAmpFault )
                this.AxisRightAmpFault = Brushes.Red;
            else
                this.AxisRightAmpFault = Brushes.Gray;
        }

        private void ExecuteCvCommand( object _obj )
        {
            var type = _obj.ToString();
            DriveControlEventArgs.eCvDir dir = DriveControlEventArgs.eCvDir.NONE;

            switch ( type )
            {
                case "CW":
                    dir = DriveControlEventArgs.eCvDir.CW;
                    break;
                case "CCW":
                    dir = DriveControlEventArgs.eCvDir.CCW;
                    break;
                case "STOP":
                    dir = DriveControlEventArgs.eCvDir.STOP;
                    break;
            }

            var msg = new DriveControlEventArgs
            {
                EventDir = DriveControlEventArgs.eEventDir.ToBack ,
                ControlKind = DriveControlEventArgs.eControlKind.Conveyor ,
                CvDir = dir
            };
            this.PublishEvent( msg );
        }

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

        private void IOPublish( VCSMessageEventArgs _args )
        {
            this.eventAggregator.GetEvent<VCSMessagePubSubEvent>().Publish( _args );
        }

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

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

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

            this.eventAggregator.GetEvent<GUIMessagePubSubEvent>().Unsubscribe( UICallbackCommunication );
        }

        public void OnDialogOpened( IDialogParameters parameters )
        {
            /*IO*/
            var msg = new VCSMessageEventArgs() { Kind = VCSMessageEventArgs.eVCSMessageKind.ReqIOObject };
            this.eventAggregator.GetEvent<VCSMessagePubSubEvent>().Publish( msg );

            /*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.ReqCurrentPosition } );
        }


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