path: root/Software/Visual_Studio/PPC/Tango.PPC.UI/ViewModels/MachineStatusViewVM.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using Tango.BL.Entities;
using Tango.BL.Enumerations;
using Tango.Core.Commands;
using Tango.Integration.Operation;
using Tango.PPC.Common;
using Tango.PPC.Jobs;
using Tango.PPC.Jobs.NavigationObjects;
using Tango.PPC.Jobs.Views;
using Tango.PPC.Maintenance.Models;

namespace Tango.PPC.UI.ViewModels
{
    public class MachineStatusViewVM : PPCViewModel
    {
        #region Properties

        private JobHandler _handler;

        private Job _job;
        /// <summary>
        /// Gets or sets the job.
        /// </summary>
        public Job Job
        {
            get { return _job; }
            set { _job = value;
                if(_job == null)
                    IsDyeingProcess = false;
                RaisePropertyChangedAuto(); }
        }

        private RunningJobStatus _runningJobStatus;
        /// <summary>
        /// Gets or sets the running job status.
        /// </summary>
        public RunningJobStatus RunningJobStatus
        {
            get { return _runningJobStatus; }
            set {
                _runningJobStatus = value;
                 IsDyeingProcess = (_runningJobStatus != null && _runningJobStatus.CurrentSegment != null);
                if(_runningJobStatus != null && _runningJobStatus.CurrentSegment != null)
                {
                    var segment = Job.Segments.FirstOrDefault(x=>x.SegmentIndex == _runningJobStatus.CurrentSegment.SegmentIndex);
                    if(segment != null)
                        CurrentBrushStop = segment.FirstBrushStop;
                }
                RaisePropertyChangedAuto();
            }
        }

        private bool _isJobStatusViewEnable;

        public bool IsJobStatusViewEnable
        {
            get { return _isJobStatusViewEnable; }
            set { _isJobStatusViewEnable = value; RaisePropertyChangedAuto(); }
        }

        private bool _isEnabledStopButton;
        /// <summary>
        /// Gets or sets a value indicating whether this instance is enabled stop button.
        /// </summary>
        public bool IsEnabledStopButton
        {
            get { return _isEnabledStopButton; }
            set { _isEnabledStopButton = value; RaisePropertyChangedAuto(); }
        }

        private bool _isSpoolView;
        /// <summary>
        /// Gets or sets a value indicating whether this instance is spool view.
        /// </summary>
        public bool IsSpoolView
        {
            get { return _isSpoolView; }
            set { _isSpoolView = value; RaisePropertyChangedAuto(); }
        }

        private bool _isWeightView;
        /// <summary>
        /// Gets or sets a value indicating whether this instance is length. Show indicator values in length or weight.
        /// </summary>
        public bool IsWeghtView
        {
            get { return _isWeightView; }
            set { _isWeightView = value; RaisePropertyChangedAuto(); }
        }


        private bool _isDyeingProcess;

        public bool IsDyeingProcess
        {
            get { return _isDyeingProcess; }
            set {
                if(_isDyeingProcess != value)
                {
                    _isDyeingProcess = value;
                    RaisePropertyChangedAuto();
                }
            }
        }

        private BrushStop _currentBrushStop;

        public BrushStop CurrentBrushStop
        {
            get { return _currentBrushStop; }
            set {
                if(_currentBrushStop != value)
                {
                    _currentBrushStop = value;
                    OnUpdateCurrentBrush();
                    RaisePropertyChangedAuto();
                }
            }
        }

        public double CyanOutput
        {
            get { return GetVolumeLiquidType(LiquidTypes.Cyan); }
        }

        public double MagentaOutput
        {
            get { return GetVolumeLiquidType(LiquidTypes.Magenta); }
        }

        public double YellowOutput
        {
            get { return GetVolumeLiquidType(LiquidTypes.Yellow); }
        }

        public double BlackOutput
        {
            get { return GetVolumeLiquidType(LiquidTypes.Black); }
        }
        
        public double LightCyanOutput
        {
            get { return GetVolumeLiquidType(LiquidTypes.LightCyan); }
        }

        public double LightMagentaOutput
        {
            get { return GetVolumeLiquidType(LiquidTypes.LightMagenta); }
        }

        public double LightYellowOutput
        {
            get { return GetVolumeLiquidType(LiquidTypes.LightYellow); }
        }

        //public double TransparentInkOutput
        //{
        //    get { return GetVolumeLiquidType(LiquidTypes.TransparentInk); }
        //}

        //public double LubricantOutput
        //{
        //    get { return GetVolumeLiquidType(LiquidTypes.Lubricant); }
        //}

        private List<MidTankLevelModel> _midTankLevels;
        public List<MidTankLevelModel> MidTankLevels
        {
            get { return _midTankLevels; }
            set { _midTankLevels = value; RaisePropertyChangedAuto(); }
        }

        #endregion

        #region Commands

        public RelayCommand StopCommand { get; set; }

        public RelayCommand AbortCommand { get; set; }

        public RelayCommand GoToJobCommand { get; set; }

        /// <summary>
        /// Gets or sets the job status view command.
        /// </summary>
        public RelayCommand JobStatusViewCommand { get; set; }

        /// <summary>
        /// Gets or sets the overview view command.
        /// </summary>
        public RelayCommand OverviewViewCommand { get; set; }

        public RelayCommand ClearAllNotificationsCommand { get; set; }

        #endregion

        public MachineStatusViewVM()
        {
            StopCommand = new RelayCommand(StopJob, ()=>CanStopped());
            AbortCommand = new RelayCommand(AbortJob, () => CanStopped());
            GoToJobCommand = new RelayCommand(GoToJob);
            JobStatusViewCommand = new RelayCommand(JobStatusView);
            OverviewViewCommand = new RelayCommand(OverviewView);
            ClearAllNotificationsCommand = new RelayCommand(ClearAllNotifications);

            IsJobStatusViewEnable = true;
            IsEnabledStopButton = false;
            IsSpoolView = false;
            IsWeghtView = false;
        }

        public override void OnApplicationReady()
        {
            base.OnApplicationReady();

            MidTankLevels = MachineProvider.Machine.Configuration.NoneEmptyIdsPacks.Where(x => x.MidTankType.HasLevelMeasure).OrderBy(x => x.PackIndex).Select(x => new MidTankLevelModel()
            {
                Max = MachineOperator.MAX_MIDTANK_LITERS,
                IDSPack = x,
            }).OrderBy(y => y.IDSPack.LiquidType.Code).ToList();
        }

        #region printing

        public override void OnApplicationStarted()
        {
            MachineProvider.MachineOperator.PrintingStarted += MachineOperator_PrintingStarted;
            MachineProvider.MachineOperator.PrintingEnded += MachineOperator_PrintingEnded;
        }
        
        private void MachineOperator_PrintingStarted(object sender, PrintingEventArgs e)
        {
            _handler = e.JobHandler;
            Job = e.Job;
            e.JobHandler.StatusChanged += JobHandler_StatusChanged;
            //e.JobHandler.SpoolChangeRequired += JobHandler_SpoolChangeRequired;
            e.JobHandler.Stopped += JobHandler_Stopped;
            e.JobHandler.CanCancelChanged += JobHandler_CanCancelChanged;
            InvokeUI(() =>
            {
                IsEnabledStopButton = true;
                StopCommand.RaiseCanExecuteChanged();
                AbortCommand.RaiseCanExecuteChanged();
            });


        }

        private void JobHandler_Stopped(object sender, EventArgs e)
        {
            if (_handler != null)
            {
                _handler.StatusChanged -= JobHandler_StatusChanged;
                //_handler.SpoolChangeRequired -= JobHandler_SpoolChangeRequired;
                _handler.Stopped -= JobHandler_Stopped;
                _handler.StatusChanged -= JobHandler_StatusChanged;
                _handler.CanCancelChanged -= JobHandler_CanCancelChanged;
            }
        }

        private void MachineOperator_PrintingEnded(object sender, PrintingEventArgs e)
        {
            LogManager.Log("Printing ended");
            InvokeUI(() =>
            {
                IsEnabledStopButton = false;
                StopCommand.RaiseCanExecuteChanged();
                AbortCommand.RaiseCanExecuteChanged();
            });
        }

        private void JobHandler_StatusChanged(object sender, RunningJobStatus e)
        {
            InvokeUI(() =>
            {
                RunningJobStatus = e;
            });
        }

        private void JobHandler_CanCancelChanged(object sender, EventArgs e)
        {
            InvokeUI( () =>
            {
                IsEnabledStopButton = _handler.CanCancel;
                StopCommand.RaiseCanExecuteChanged();
                AbortCommand.RaiseCanExecuteChanged();
            });
        }
        
        #endregion

        #region Methods

        private void GoToJob()
        {
            
            NavigationManager.NavigateWithObject<JobsV2Module, JobEurekaView, JobNavigationObject>(new JobNavigationObject() { Job = _handler.Job });
            NavigationManager.ClearHistoryExcept<JobsView>();
           
        }
        /// <summary>
        /// Toggles the application technician mode.
        /// </summary>
        public void ToggleTechnicianMode()
        {
            if (!ApplicationManager.IsInTechnicianMode)
            {
                ApplicationManager.EnterTechnicianMode();
            }
            else
            {
                ApplicationManager.ExitTechnicianMode();
            }
        }
        
        protected void JobStatusView()
        {
            IsJobStatusViewEnable = true;
        }

        protected void OverviewView()
        {
            IsJobStatusViewEnable = false;
        }

        private double GetVolumeLiquidType(LiquidTypes liquidType)
        {
            if(CurrentBrushStop != null && CurrentBrushStop.LiquidVolumes != null && CurrentBrushStop.LiquidVolumes.Count > 0)
            {
                var lt = CurrentBrushStop.LiquidVolumes.FirstOrDefault(x => x.LiquidType == liquidType);

                if (lt != null)
                {
                    return Math.Round(lt.Volume, 2);
                }
            }
            return 0;
        }

        private bool CanStopped()
        {
            return IsEnabledStopButton;
        }

        private void StopJob()
        {
            _handler?.Cancel();
        }

        private void AbortJob()
        {
            _handler?.Cancel();
            Job = null;
        }

        protected void ClearAllNotifications()
        {
            NotificationProvider.NotificationItems.Where(x=>x.CanClose).ToList().ForEach(y=> NotificationProvider.PopNotification(y));
        }

        protected void OnUpdateCurrentBrush()
        {
            RaisePropertyChanged(nameof(CyanOutput));
            RaisePropertyChanged(nameof(LightCyanOutput));
            RaisePropertyChanged(nameof(MagentaOutput));
            RaisePropertyChanged(nameof(LightMagentaOutput));
            RaisePropertyChanged(nameof(YellowOutput));
            RaisePropertyChanged(nameof(LightYellowOutput));
            RaisePropertyChanged(nameof(BlackOutput));
        }

        #endregion
    }
}