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 cWOnBrush = Brushes.DodgerBlue;

        public Brush CWOnBrush
        {
            get { return cWOnBrush; }
            set { SetProperty(ref this.cWOnBrush, value); }
        }

        private Brush cCWOnBrush = Brushes.DodgerBlue;

        public Brush CCWOnBrush
        {
            get { return cCWOnBrush; }
            set { SetProperty(ref this.cCWOnBrush, value); }
        }



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

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

        public Brush AxisLeftIsServoOn
        {
            get { return this._axisLeftIsServoOn; }
            set
            {
                this.SetProperty(ref this._axisLeftIsServoOn, value);
            }
        }

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

        public Brush AxisRightIsServoOn
        {
            get { return this._axisRightIsServoOn; }
            set
            {
                this.SetProperty(ref this._axisRightIsServoOn, 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; }
        public ICommand LoadUnloadCommand { get; set; }
        public ICommand PIOCharge { 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;

            /*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);
            this.LoadUnloadCommand = new DelegateCommand<string>(ExecuteLoadUnloadCommand);
            this.PIOCharge = new DelegateCommand<string>(ExecutePIOChargeCommand);

        }

        private void ExecutePIOChargeCommand(string obj)
        {
            this.messageController.ShowConfirmationPopupView($"PIO Battery Charge ?", r =>
          {
              if (r.Result == ButtonResult.OK)
              {
                  var msg = new VCSMessageEventArgs();

                  switch (obj)
                  {
                      case "PB":
                          msg.Kind = VCSMessageEventArgs.eVCSMessageKind.ReqPIOBatteryCharge;
                          msg.MessageText = obj.ToString();
                          break;
                      case "PBStop":
                          msg.Kind = VCSMessageEventArgs.eVCSMessageKind.ReqPIOBatteryChargeStop;
                          msg.MessageText = obj.ToString();
                          break;

                      default:
                          break;
                  }

                  this.VcsMessagePublish(msg);
              }
          });
        }

        private void ExecuteLoadUnloadCommand(string obj)
        {
            this.messageController.ShowConfirmationPopupView($"Conveyor Move Start ?", r =>
            {
                if (r.Result == ButtonResult.OK)
                {
                    var msg = new VCSMessageEventArgs();

                    switch (obj)
                    {
                        case "Load":
                            msg.Kind = VCSMessageEventArgs.eVCSMessageKind.ReqConveyorLoad;
                            break;
                        case "Unload":
                            msg.Kind = VCSMessageEventArgs.eVCSMessageKind.ReqConveyorUnload;
                            break;
                        case "PL":
                            msg.Kind = VCSMessageEventArgs.eVCSMessageKind.ReqPIOConveyor;
                            msg.MessageText = obj.ToString();
                            break;
                        case "PU":
                            msg.Kind = VCSMessageEventArgs.eVCSMessageKind.ReqPIOConveyor;
                            msg.MessageText = obj.ToString();
                            break;

                        default:
                            break;
                    }

                    this.VcsMessagePublish(msg);
                }
            });
        }

        void VcsMessagePublish(VCSMessageEventArgs msg)
        {
            this.eventAggregator.GetEvent<VCSMessagePubSubEvent>().Publish(msg);
        }

        private void IO_OnChangedIO(BitBlock bit)
        {
            if (bit.Tag.Equals("OUT_CV_RUN"))
            {
                if (IO.IsOn("OUT_CV_RUN", false))
                {
                    if (IO.IsOn("OUT_CV_CWCCW", false))
                    {
                        this.CWOnBrush = Brushes.DodgerBlue;
                        this.CCWOnBrush = Brushes.LimeGreen;
                    }
                    else
                    {
                        this.CWOnBrush = Brushes.LimeGreen;
                        this.CCWOnBrush = Brushes.DodgerBlue;
                    }
                }
                else
                {
                    this.CWOnBrush = Brushes.DodgerBlue;
                    this.CCWOnBrush = Brushes.DodgerBlue;
                }
            }
        }

        private void UICallbackCommunication(GUIMessageEventArgs _args)
        {
            var msg = string.Empty;

            if (_args.Kind == GUIMessageEventArgs.eGUIMessageKind.RspPIOConveyor)
            {
                switch (_args.MessageText)
                {
                    //PIO Load
                    case "PL":
                        {
                            if (_args.Result.IsSuccess)
                                msg = "SUCCESS";
                            else
                                msg = "FAIL";
                        }
                        break;

                    //PIO Unload
                    case "PU":
                        {
                            if (_args.Result.IsSuccess)
                                msg = "SUCCESS";
                            else
                                msg = "FAIL";

                        }
                        break;
                }

                this.messageController.ShowNotificationView(msg);

            }
            else if (_args.Kind == GUIMessageEventArgs.eGUIMessageKind.RspPIOBatteryCharge)
            {
                if (_args.Result.IsSuccess)
                    msg = "SUCCESS";
                else
                    msg = "FAIL";

                this.messageController.ShowNotificationView(msg);
            }
        }

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

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

                  switch (selectedPos)
                  {
                      case "Lock":
                          msg.PosDir = ePosDir.Lock;
                          break;
                      case "UnLock":
                          msg.PosDir = 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 == eEventDir.ToFront)
            {
                switch (_args.Kind)
                {
                    case eAxisControlKind.NONE:
                        break;
                    case eAxisControlKind.OriginReturn:
                        break;
                    case eAxisControlKind.Stop:
                        break;
                    case eAxisControlKind.EStop:
                        break;
                    case eAxisControlKind.Move:
                        ResponseMove(_args);
                        break;
                    case eAxisControlKind.Jog:
                        break;
                    case eAxisControlKind.ServoOn:
                        break;
                    case eAxisControlKind.ServoOff:
                        break;
                    case eAxisControlKind.ReqCurrentPosition:
                        break;
                    case eAxisControlKind.ReqStopCurrentPosition:
                        break;
                    case eAxisControlKind.FaultReset:
                        break;
                    case 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;

            /*Left*/
            if (left.IsServoOn)
                this.AxisLeftIsServoOn = Brushes.LimeGreen;
            else
                this.AxisLeftIsServoOn = Brushes.Gray;

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

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

            /*Right*/
            if (right.IsServoOn)
                this.AxisRightIsServoOn = Brushes.LimeGreen;
            else
                this.AxisRightIsServoOn = Brushes.Gray;

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

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

        private void ExecuteCvCommand(object _obj)
        {
            var dir = _obj.ToString();
            var msg = new VCSMessageEventArgs()
            {
                Kind = VCSMessageEventArgs.eVCSMessageKind.ReqConveyorMove,
                MessageText = dir
            };

            this.VcsMessagePublish(msg);
        }

        #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<GUIMessagePubSubEvent>().Unsubscribe(UICallbackCommunication);
        }

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

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