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.Core.DI;
using Tango.Integration.Operation;
using Tango.PMR.Diagnostics;
using Tango.PMR.MachineStatus;
using Tango.PPC.Common;
using Tango.PPC.Common.Diagnostics;
using Tango.PPC.Jobs;
using Tango.PPC.Jobs.NavigationObjects;
using Tango.PPC.Jobs.Views;
using Tango.PPC.UI.Models;
using System.Timers;
using System.Windows.Threading;
using System.Diagnostics;
using Tango.PMR.Printing;
using System.ComponentModel;
using RealTimeGraphX.WPF;
using RealTimeGraphX.DataPoints;
using Tango.PPC.UI.Graphs;
using Tango.BL;
using System.Data.Entity;
using System.Windows.Media;
using Tango.PPC.Common.Resume;
using Tango.Core.ExtensionMethods;
using Tango.PPC.Common.Printing;
using Tango.PPC.Common.RemoteJob;
using Tango.PPC.UI.Dialogs;
using Tango.ColorConversion;

namespace Tango.PPC.UI.ViewModels
{
    public class MachineStatusViewVM : PPCViewModel, IRemoteJobInputOutputProvider
    {
        public enum StatisticTab
        {
            [Description("Production Data")]
            Productiondata = 0,
            [Description("Temperature")]
            Temperature = 1,
            [Description("Pressure")]
            Pressure = 2,
            [Description("Motor")]
            Motor = 3
        }

        public enum ShowSetButtonsEnum
        {
            ShowDefault,
            ShowROnErrorsJob,
            ShowOnCompleteJob
        }

        public class TimeToDyeValueItem
        {
            public DateTime startTime;
            public DateTime endTime;
            public double totalValue;
        };

        public class TimeToDyeValueCollection
        {
            public DateTime StartTime { get; set; }
            public List<TimeToDyeValueItem> items;
            public TimeToDyeValueCollection()
            {
                items = new List<TimeToDyeValueItem>();
            }
        };

        private DispatcherTimer _productiondata_timer;
        private double _lastProductionDataProgress;
        private bool startingJob = false;
        private bool _jerricanDialogShowing;
        private List<ColorSpace> _colorSpaces;
        private bool _conversion_Busy;
        private bool _printingEnded;
        private double _totalProductionDataMeters;
        private DateTime productionStartTime;

        #region Properties

        [TangoInject]
        public IDiagnosticsFrameProvider DefaultDiagnosticsFrameProvider { get; set; }

        private JobHandler _handler;

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

        private RunningJobStatus _runningJobStatus;
        /// <summary>
        /// Gets or sets the running job status.
        /// </summary>
        public RunningJobStatus RunningJobStatus
        {
            get { return _runningJobStatus; }
            set
            {
                _runningJobStatus = value;

                RaisePropertyChangedAuto();
            }
        }

        private bool _isJobStatusViewEnable;

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

        private bool _isPrinting;
        /// <summary>
        /// Gets or sets a value indicating whether this instance is enabled stop button.
        /// </summary>
        public bool IsPrinting
        {
            get { return _isPrinting; }
            set { _isPrinting = 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();
                }
            }
        }

        private JobBrushStop _jobBrushStop;
        public JobBrushStop JobBrushStop
        {
            get { return _jobBrushStop; }
            set
            {
                if (_jobBrushStop != value)
                {
                    _jobBrushStop = value;
                    if (_jobBrushStop != null)
                    {
                        UpdateOutputLiquids();
                    }
                }
            }
        }


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

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

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

        private JerricanLevelModel _midTankLubLevel;
        public JerricanLevelModel MidTankLubLevel
        {
            get { return _midTankLubLevel; }
            set { _midTankLubLevel = value; RaisePropertyChangedAuto(); }
        }

        public MachineOverviewModel OverviewModel { get; set; }

        private bool _isDisplayJobOutline;
        /// <summary>
        /// Gets or sets a value indicating whether to display the job outline.
        /// </summary>
        public bool IsDisplayJobOutline
        {
            get { return _isDisplayJobOutline; }
            set { _isDisplayJobOutline = value; RaisePropertyChangedAuto(); }
        }

        private JobTicket _jobOutlineTicket;
        /// <summary>
        /// Gets or sets the job outline ticket.
        /// </summary>
        public JobTicket JobOutlineTicket
        {
            get { return _jobOutlineTicket; }
            set { _jobOutlineTicket = value; RaisePropertyChangedAuto(); }
        }

        public MachineOverviewErrorStates MachineErrorStates { get; set; }

        private bool _isExpandedNotificatios;

        public bool IsExpandedNotifications
        {
            get { return _isExpandedNotificatios; }
            set
            {
                _isExpandedNotificatios = value;
                RaisePropertyChangedAuto();
            }
        }

        private int _selectedStatisticTabIndex;
        /// <summary>
        /// Gets or sets the index of the selected category.
        /// </summary>
        public int SelectedStatisticTabIndex
        {
            get { return _selectedStatisticTabIndex; }
            set
            {
                if (_selectedStatisticTabIndex != value)
                {
                    _selectedStatisticTabIndex = value;
                    RaisePropertyChangedAuto();
                    switch (_selectedStatisticTabIndex)
                    {
                        case 0:
                            {
                                SelectedStatisticTab = StatisticTab.Productiondata;
                                break;
                            }
                        case 1:
                            {
                                SelectedStatisticTab = StatisticTab.Temperature;
                                break;
                            }
                        case 2:
                            {
                                SelectedStatisticTab = StatisticTab.Pressure;
                                break;
                            }
                        case 3:
                            {
                                SelectedStatisticTab = StatisticTab.Motor;
                                break;
                            }
                    }
                }
            }
        }

        private StatisticTab _selectedStatisticTab;
        /// <summary>
        /// Gets or sets the selected category.
        /// </summary>
        ///
        public StatisticTab SelectedStatisticTab
        {
            get
            {
                return _selectedStatisticTab;
            }
            set
            {
                if (_selectedStatisticTab != value)
                {
                    _selectedStatisticTab = value;
                    RaisePropertyChangedAuto();
                }
                _selectedStatisticTabIndex = _selectedStatisticTab.ToInt32();
                RaisePropertyChanged(nameof(SelectedStatisticTabIndex));
            }
        }

        public WpfGraphController<TimeSpanDataPoint, DoubleDataPoint> JobController { get; set; }

        private JobResumeModel _resumeModel;
        public JobResumeModel ResumeModel
        {
            get { return _resumeModel; }
            set { _resumeModel = value; RaisePropertyChangedAuto(); RaisePropertyChanged(nameof(HasResumeModel)); }
        }

        public bool HasResumeModel
        {
            get { return ResumeModel != null; }
        }

        private ShowSetButtonsEnum _showSetButtons;

        public ShowSetButtonsEnum ShowSetButtons
        {
            get { return _showSetButtons; }
            set
            {
                _showSetButtons = value;
                RaisePropertyChangedAuto();
            }
        }

        private List<LiquidOutputModel> _liquidOutputs;
        public List<LiquidOutputModel> LiquidOutputs
        {
            get { return _liquidOutputs; }
            set { _liquidOutputs = value; RaisePropertyChangedAuto(); }
        }

        #endregion

        #region Commands

        public RelayCommand StopCommand { get; set; }

        public RelayCommand AbortCommand { get; set; }

        public RelayCommand ResumeCommand { get; set; }
        public RelayCommand CaancelJobCommand { get; set; }
        public RelayCommand RestartJobCommand { get; set; }
        public RelayCommand ClearJobCommand { 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; }

        public RelayCommand DisplayJobOutlineCommand { get; set; }

        public RelayCommand HideJobOutlineCommand { get; set; }

        public RelayCommand DropResumeCommand { get; set; }

        #endregion

        public MachineStatusViewVM()
        {
            productionStartTime = DateTime.Today.AddHours(Settings.ProductionDataStartTimeHours);

            _productiondata_timer = new DispatcherTimer();
            _productiondata_timer.Interval = TimeSpan.FromSeconds(Settings.ProductionDataRefreshRateSeconds);
            _productiondata_timer.Tick += _productiondata_timer_Tick;


            StopCommand = new RelayCommand(StopJob, () => CanStopped());
            AbortCommand = new RelayCommand(AbortJob, () => CanStopped());

            ResumeCommand = new RelayCommand(ResumeJob, () => MachineProvider.MachineOperator.CanPrint);
            CaancelJobCommand = new RelayCommand(CancelJob);
            RestartJobCommand = new RelayCommand(RestartJob, () => MachineProvider.MachineOperator.CanPrint);
            ClearJobCommand = new RelayCommand(ClearJob);


            GoToJobCommand = new RelayCommand(GoToJob, () => IsEnableGoToJob());
            JobStatusViewCommand = new RelayCommand(JobStatusView);
            OverviewViewCommand = new RelayCommand(OverviewView);
            ClearAllNotificationsCommand = new RelayCommand(ClearAllNotifications);
            DisplayJobOutlineCommand = new RelayCommand(DisplayJobOutline);
            HideJobOutlineCommand = new RelayCommand(HideJobOutline);

            DropResumeCommand = new RelayCommand(DropResume);

            IsJobStatusViewEnable = true;
            IsPrinting = false;
            IsSpoolView = false;
            IsWeghtView = false;

            OverviewModel = new MachineOverviewModel();
            MachineErrorStates = new MachineOverviewErrorStates();

            IsExpandedNotifications = false;
            SelectedStatisticTabIndex = 0;

            JobController = CreateController(CreateSeries("Total", GraphHelper.GraphColor.Green));
            ShowSetButtons = ShowSetButtonsEnum.ShowDefault;
        }

        public override void OnApplicationReady()
        {
            base.OnApplicationReady();
            EventLogger.EventReceived += EventLogger_EventReceived;

            MidTankLevels = MachineProvider.Machine.Configuration.NoneEmptyIdsPacks.Where(x => x.MidTankType.HasLevelMeasure).OrderBy(x => x.PackIndex).Select(x => new JerricanLevelModel()
            {
                Max = x.MidTankType.LiterCapacity,
                IDSPack = x,
                JerricanPresent = true,
            }).ToList();

            var LubLevel = MachineProvider.Machine.Configuration.NoneEmptyIdsPacks.Where(x => x.MidTankType.Type == MidTankTypes.LubricantMidTank).FirstOrDefault();

            MidTankLubLevel = new JerricanLevelModel() { JerricanPresent = true };
            if (LubLevel != null)
            {
                MidTankLubLevel.Max = LubLevel.MidTankType.LiterCapacity;
                MidTankLubLevel.IDSPack = LubLevel;
            };

            MidTankLubLevel.PressedEvent += MidTankLevel_PressedEvent;

            foreach (var midTank in MidTankLevels)
            {
                midTank.PressedEvent += MidTankLevel_PressedEvent;
            }

            MachineProvider.MachineOperator.MachineStatusChanged += MachineOperator_MachineStatusChanged;

            GetCollectionDyePropByStartTime(productionStartTime);

            _productiondata_timer.Start();
        }

        #region Events

        private void EventLogger_EventReceived(object sender, MachinesEvent ev)
        {
            InvokeUI(() =>
            {
                if (ev.Category == EventTypeCategories.Error || ev.Category == EventTypeCategories.Critical)
                {
                    IsExpandedNotifications = true;
                }
            });
        }

        private void MachineOperator_MachineStatusChanged(object sender, MachineStatus status)
        {
            UpdateMidTankLevels(status);
            UpdateMachineStatusErrors(status);
        }
        private void UpdateMidTankLevels(MachineStatus status)
        {
            if (!IsJobStatusViewEnable)
            {
                foreach (var item in status.IDSPacksLevels)
                {
                    JerricanLevelModel model = null;
                    if (item.Index == MidTankLubLevel.IDSPack.PackIndex)//lub
                    {
                        model = MidTankLubLevel;
                    }
                    else
                    {
                        model = MidTankLevels.SingleOrDefault(x => x.IDSPack.PackIndex == item.Index);
                    }

                    if (model != null)
                    {
                        model.Level = item.MidTankLevel;

                        //Detect jerrican inserted
                        if (Settings.EnableJerricanChangePopup)
                        {
                            if (item.JerricanPresent && !model.JerricanPresent)
                            {
#pragma warning disable CS4014 // Because this call is not awaited, execution of the current method continues before the call is completed
                                ShowAutoJerricanDialog(model);
#pragma warning restore CS4014 // Because this call is not awaited, execution of the current method continues before the call is completed
                            }
                        }
                        model.JerricanPresent = item.JerricanPresent;
                        model.FillingTimeoutError = item.FillingTimeoutError;
                        model.MidTankEmpty = item.MidTankEmpty;
                        model.MidTankRefillPumpActive = item.MidTankRefillPumpActive;
                        model.RemainingTimeoutError = TimeSpan.FromSeconds(item.TimerRemainingSeconds);
                    }
                }
            }
        }

        private async Task ShowAutoJerricanDialog(JerricanLevelModel model, bool opendManually = false)
        {
            _jerricanDialogShowing = true;

            var mode = JerricanReplaceViewMode.Reinserted;

            if (model.HasRemainingTimeoutError)
            {
                mode = JerricanReplaceViewMode.Full;
            }

            var vm = await NotificationProvider.ShowDialog(new JerricanReplaceViewVM() { IsOpenedManually = opendManually, IDSPack = model.IDSPack, ViewMode = mode });
            if (vm.DialogResult && vm.ViewMode != JerricanReplaceViewMode.Reinserted)
            {
                try
                {
                    await MachineProvider.MachineOperator.SetJerricanInsertedLiters(model.IDSPack.PackIndex, vm.LitersInserted);
                }
                catch (Exception ex)
                {
                    await NotificationProvider.ShowError($"Error setting jerrican level.\n{ex.Message}");
                }
            }
            _jerricanDialogShowing = false;
        }

        private void UpdateMachineStatusErrors(MachineStatus status)
        {
            var windersInError = status.WindersInError.ToList();// to test
            MachineErrorStates.UpdateWinders(windersInError);
            var dansersInError = status.DancersInError.ToList();
            MachineErrorStates.UpdateDancers(dansersInError);
            var btsrsInErrors = status.BtsrsInError.ToList();
            MachineErrorStates.UpdateBTSRs(btsrsInErrors);
        }

        private void MachineOperator_InkFillingStatusChanged(object sender, InkFillingStatusChangedEventArgs e)
        {
            //foreach (var cartridge in e.Status.CartridgesStatuses.Where(x => x.Cartridge.Slot != CartridgeSlot.Ink))
            //{
            //    var wasteState = WasteStates.SingleOrDefault(x => x.Slot == cartridge.Cartridge.Slot);

            //    if (wasteState != null)
            //    {
            //        wasteState.State = cartridge.State;
            //    }
            //}
        }

        private void _productiondata_timer_Tick(object sender, EventArgs e)
        {
            if (MachineProvider.MachineOperator.IsPrinting)
            {
                if (RunningJobStatus != null)
                {
                    var delta = RunningJobStatus.Progress - _lastProductionDataProgress;
                    _lastProductionDataProgress = RunningJobStatus.Progress;

                    if (BuildProvider.MachineType == MachineTypes.Eureka)
                    {
                        _totalProductionDataMeters += (delta * 4);
                    }
                    else
                    { 
                        _totalProductionDataMeters += delta;
                    }

                    JobController.PushData(DateTime.Now.TimeOfDay, _totalProductionDataMeters);
                }
                else
                {
                    _lastProductionDataProgress = 0;
                }
            }
        }

        private async void MidTankLevel_PressedEvent(object sender, JerricanLevelModel e)
        {
            if (!_jerricanDialogShowing)
            {
                _jerricanDialogShowing = true;
                await ShowAutoJerricanDialog(e, true);
                _jerricanDialogShowing = false;
            }
        }

        #endregion

        #region printing

        public override async void OnApplicationStarted()
        {
            MachineProvider.MachineOperator.PrintingStarted += MachineOperator_PrintingStarted;
            MachineProvider.MachineOperator.PrintingEnded += MachineOperator_PrintingEnded;
            MachineProvider.MachineOperator.StatusChanged += MachineOperator_StatusChanged;

            DefaultDiagnosticsFrameProvider.FrameReceived += DefaultDiagnosticsFrameProvider_FrameReceived;

            JobResumeManager.JobResumeUpdated += JobResumeManager_JobResumeUpdated;
            JobResumeManager.JobResumeDropped += JobResumeManager_JobResumeDropped;

            try
            {
                using (var db = ObservablesContext.CreateDefault())
                {
                    _colorSpaces = await db.ColorSpaces.ToListAsync();
                }
            }
            catch (Exception ex)
            {
                LogManager.Log(ex);
            }
        }


        private void DefaultDiagnosticsFrameProvider_FrameReceived(object sender, PMR.Diagnostics.StartDiagnosticsResponse e)
        {
            OverviewModel.Update(e, this.Job != null ? Job.Rml : null, MachineProvider.MachineOperator.CurrentProcessParameters, MachineProvider);
        }

        private void MachineOperator_PrintingStarted(object sender, PrintingEventArgs e)
        {
            _printingEnded = false;
            _handler = e.JobHandler;
            Job = e.Job;
            CurrentBrushStop = null;
            JobBrushStop = null;

            JobController.PushData(DateTime.Now.TimeOfDay, _totalProductionDataMeters);

            List<LiquidOutputModel> outputs = new List<LiquidOutputModel>();

            var idsPacks = MachineProvider.Machine.Configuration.GetSupportedIdsPacks(Job.Rml).OrderBy(x => x.PackIndex).ToList();

            foreach (var idsPack in idsPacks.Where(x => x.LiquidType.HasPigment))
            {
                outputs.Add(new LiquidOutputModel()
                {
                    LiquidType = idsPack.LiquidType,
                    Volume = 0,
                });
            }

            LiquidOutputs = outputs;

            try
            {
                ResumeModel = JobResumeManager.GetJobResumeModel(Job.Guid);

                if (ResumeModel != null)
                {
                    LogManager.Log($"Job resume info found:\n{ResumeModel.ToJsonString()}");
                }
            }
            catch (Exception ex)
            {
                LogManager.Log(ex, "Error retrieving job resume info from db.");
            }

            e.JobHandler.StatusChanged += JobHandler_StatusChanged;
            //e.JobHandler.SpoolChangeRequired += JobHandler_SpoolChangeRequired;
            e.JobHandler.Stopped += JobHandler_Stopped;
            e.JobHandler.CanCancelChanged += JobHandler_CanCancelChanged;
            InvokeUI(() =>
            {
                IsPrinting = 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)
        {
            _printingEnded = true;

            try
            {
                CurrentBrushStop = RunningJobStatus.CurrentSegment.BrushStops.OrderBy(x => x.StopIndex).Last();
            }
            catch { }

            LogManager.Log("Printing ended");
            InvokeUI(() =>
            {
                IsPrinting = false;
                StopCommand.RaiseCanExecuteChanged();
                AbortCommand.RaiseCanExecuteChanged();
            });
        }

        private async void JobHandler_StatusChanged(object sender, RunningJobStatus e)
        {
            RunningJobStatus = e;
            if (RunningJobStatus != null && RunningJobStatus.IsFailed)
            {
                ShowSetButtons = ShowSetButtonsEnum.ShowROnErrorsJob;
            }
            else if (RunningJobStatus != null && RunningJobStatus.IsCompleted)
            {
                ShowSetButtons = ShowSetButtonsEnum.ShowOnCompleteJob;
            }

            IsDyeingProcess = (RunningJobStatus != null && RunningJobStatus.CurrentSegment != null);
            if (RunningJobStatus != null && RunningJobStatus.CurrentSegment != null)
            {
                try
                {
                    if (_runningJobStatus.CurrentSegment.IsInterSegment)
                    {
                        var stop = _runningJobStatus.CurrentSegment.BrushStops.FirstOrDefault();
                        stop.ColorSpace = CurrentBrushStop.ColorSpace;
                        CurrentBrushStop = stop;
                        JobBrushStop = null;
                    }
                    else
                    {
                        var realsegmIndex = 1;
                        if (Job.EnableInterSegment && Job.InterSegmentLength > 0)
                        {
                            int segmentIndex = _runningJobStatus.CurrentSegment.SegmentIndex - (Job.EffectiveSegments.Count * RunningJobStatus.CurrentUnit);
                            if (RunningJobStatus.CurrentUnit > 0)
                            {
                                segmentIndex -= RunningJobStatus.CurrentUnit;// inter segment between units
                            }
                            realsegmIndex = (int)(segmentIndex / 2) + 1;
                        }
                        else
                        {
                            realsegmIndex = Math.Max(_runningJobStatus.CurrentSegment.SegmentIndex - (Job.Segments.Count * RunningJobStatus.CurrentUnit), 0);
                        }

                        var segment = Job.Segments.FirstOrDefault(x => x.SegmentIndex == realsegmIndex);
                        JobSegment jobSegment = null;

                        if (segment != null)
                        {
                            if (_handler.JobTicket.Segments.Count > 0)
                            {
                                jobSegment = _handler.JobTicket.Segments[Job.OrderedSegments.IndexOf(segment)];
                                if (jobSegment.BrushStops.Count == 1)
                                {
                                    JobBrushStop = jobSegment.BrushStops.First();
                                }
                                else if (jobSegment.BrushStops.Count > 1)
                                {
                                    JobBrushStop = jobSegment.BrushStops.Last(x => x.OffsetMeters <= e.CurrentSegment.Progress);
                                }
                                else
                                {
                                    JobBrushStop = null;
                                }
                            }
                        }


                        if (segment != null && jobSegment != null && jobSegment.BrushStops.Count > 1)
                        {
                            if (!_conversion_Busy)
                            {
                                var brushStop = RunningJobStatus.CurrentSegment.FirstBrushStop;
                                await ApplyJobBrushStopToBrushStop(JobBrushStop, brushStop);

                                if (!_printingEnded)
                                {
                                    _currentBrushStop = brushStop;
                                    RaisePropertyChanged(nameof(CurrentBrushStop));
                                }
                            }
                        }
                        else
                        {
                            CurrentBrushStop = RunningJobStatus.CurrentSegment.FirstBrushStop;
                        }
                    }
                }
                catch (Exception ex)
                {
                    LogManager.Log(ex, "Error displaying job progress input output.");
                }
            }
        }

        private async Task ApplyJobBrushStopToBrushStop(JobBrushStop stop, BrushStop s)
        {
            _conversion_Busy = true;

            try
            {
                foreach (var dispenser in stop.Dispensers)
                {
                    s.SetVolume(dispenser.Index, dispenser.Volume);
                }

                s.SetLiquidVolumes(MachineProvider.Machine.Configuration, Job.Rml, MachineProvider.MachineOperator.CurrentProcessParameters);

                foreach (var liquidVolume in s.LiquidVolumes.Where(x => x.IdsPack.LiquidType.IsLightInk && x.Volume > 0).ToList())
                {
                    var darkInk = s.LiquidVolumes.FirstOrDefault(x => x.IdsPack.LiquidType.Code == liquidVolume.IdsPack.LiquidType.DarkInkCode);
                    if (darkInk != null)
                    {
                        darkInk.Volume = liquidVolume.Volume / 10d;
                        liquidVolume.Volume = 0;
                    }
                }

                if (_colorSpaces != null)
                {
                    if ((s.BrushColorSpace == ColorSpaces.RGB || s.BrushColorSpace == ColorSpaces.LAB) && (!s.IsLast && !s.IsFirst))
                    {
                        var converter = new DefaultColorConverter();

                        var previousSpace = s.ColorSpace;
                        s.SetColorSpaceSilent(_colorSpaces.First(x => x.Space == ColorSpaces.Volume));

                        try
                        {
                            var output = await converter.ConvertAsync(s, false, false);
                            s.SetColorSpaceSilent(previousSpace);
                            if (!_printingEnded)
                            {
                                output.ApplyOnBrushStop(s, MachineProvider.MachineOperator.CurrentProcessParameters);
                            }
                        }
                        catch (Exception ex)
                        {
                            s.SetColorSpaceSilent(previousSpace);
                            throw ex;
                        }
                    }
                }

                _conversion_Busy = false;
            }
            catch (Exception ex)
            {
                _conversion_Busy = false;
                throw ex;
            }
        }


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

        private void MachineOperator_StatusChanged(object sender, MachineStatuses e)
        {
            InvokeUI(() =>
            {
                ResumeCommand.RaiseCanExecuteChanged();
                RestartJobCommand.RaiseCanExecuteChanged();
            });
        }

        #endregion

        #region Methods


        private bool IsEnableGoToJob()
        {
            return Job != null && _handler != null;
        }

        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 (JobBrushStop != null && JobBrushStop.Dispensers != null && JobBrushStop.Dispensers.Count > 0)
            {
                var lt = JobBrushStop.Dispensers.FirstOrDefault(x => x.DispenserLiquidType == (DispenserLiquidType)liquidType);

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

        private bool CanStopped()
        {
            return IsPrinting;
        }

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

        private void AbortJob()
        {
            _handler?.Cancel();
            if (Job != null && HasResumeModel)
            {
                JobResumeManager.DropResume(Job.Guid);

            }
        }

        private void ResumeJob()
        {
            ShowSetButtons = ShowSetButtonsEnum.ShowDefault;
            if (Job != null && HasResumeModel)
            {
                StartJob();
            }
        }

        private async void StartJob()
        {

            if (startingJob) return;

            RunningJobStatus = null;

            try
            {
                startingJob = true;
                LogManager.Log("Start job command pressed. Starting job and navigating to job progress view...");

                var printConfig = new PrintingConfiguration();

                if (HasResumeModel)
                {
                    printConfig.FirstUnitStartPosition = ResumeModel.FirstUnitStartPosition;
                    printConfig.GlobalStartPosition = ResumeModel.GlobalStartPosition;
                    printConfig.RemainingUnits = ResumeModel.RemainingUnits;
                }
                using (var db = ObservablesContext.CreateDefault())
                {
                    var handler = await PrintingManager.Print(Job, db, printConfig);
                }

                startingJob = false;
            }
            catch (InsufficientLiquidQuantityException)
            {
                //Ignore..
            }
            catch (OperationCanceledException)
            {
                //Ignore..
            }
            catch (Exception ex)
            {
                LogManager.Log(ex, "Could not start the current job.");
                await NotificationProvider.ShowError($"{ex.Message}.");
            }
            finally
            {
                startingJob = false;
            }
        }

        private void CancelJob()
        {
            ClearJob();
        }

        private void RestartJob()
        {
            ShowSetButtons = ShowSetButtonsEnum.ShowDefault;
            if (Job != null)
            {
                if (HasResumeModel)
                {
                    DropResume();
                }
                RunningJobStatus = null;
                StartJob();
            }
        }

        private void ClearJob()
        {
            ShowSetButtons = ShowSetButtonsEnum.ShowDefault;
            DropResume();
            RunningJobStatus = null;
            Job = null;
        }

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

        protected void OnUpdateCurrentBrush()
        {
            CurrentBrushStop?.SetLiquidVolumes(MachineProvider.Machine.Configuration, Job.Rml, MachineProvider.MachineOperator.CurrentProcessParameters);

            RaisePropertyChanged(nameof(CurrentBrushStop));

            UpdateOutputLiquids();
        }

        private void UpdateOutputLiquids()
        {
            foreach (var output in LiquidOutputs)
            {
                output.Volume = GetVolumeLiquidType(output.LiquidType.Type);
            }
        }

        private void HideJobOutline()
        {
            IsDisplayJobOutline = false;
        }

        private void DisplayJobOutline()
        {
            if (_handler != null && _handler.JobTicket != null)
            {
                JobOutlineTicket = _handler.JobTicket;
                IsDisplayJobOutline = true;
            }
        }

        #endregion

        #region graph

        public TimeToDyeValueCollection graphDyeingValuesCollection = new TimeToDyeValueCollection();

        private WpfGraphController<TimeSpanDataPoint, DoubleDataPoint> CreateController(params WpfGraphDataSeries[] seriesCollection)
        {
            var controller = new WpfGraphController<TimeSpanDataPoint, DoubleDataPoint>();

            foreach (var series in seriesCollection)
            {
                controller.DataSeriesCollection.Add(series);
            }

            controller.Range.AutoY = true;
            controller.Range.MaximumY = 100;
            controller.Range.MinimumY = 0;
            controller.Range.MaximumX = TimeSpan.FromHours(24);

            controller.RefreshRate = TimeSpan.FromSeconds(Settings.ProductionDataRefreshRateSeconds);

            return controller;
        }

        private WpfGraphDataSeries CreateSeries(String name, GraphHelper.GraphColor fill)
        {
            WpfGraphDataSeries series = new WpfGraphDataSeries()
            {
                Stroke = Colors.DodgerBlue,
            };
            series.Name = name;
            series.Fill = GraphHelper.GetGraphBrush(fill);
            series.StrokeThickness = 1;
            series.Stroke = GraphHelper.GetGraphStrokeColor();
            return series;
        }

        public async void GetCollectionDyePropByStartTime(DateTime starttime)
        {
            try
            {
                using (ObservablesContext db = ObservablesContext.CreateDefault())
                {
                    DateTime startTimeUTC = starttime.ToUniversalTime();

                    var jobRuns = await db.JobRuns.Where(x => x.StartDate >= startTimeUTC).Select(x => new { x.StartDate, x.EndDate, x.ActualStartPosition, x.ActualEndPosition }).OrderBy(y => y.StartDate).ToListAsync();

                    JobController.PushData(starttime.TimeOfDay, _totalProductionDataMeters);

                    foreach (var jobRun in jobRuns)
                    {
                        JobController.PushData(jobRun.StartDate.ToLocalTime().TimeOfDay, _totalProductionDataMeters);

                        if (BuildProvider.MachineType == MachineTypes.Eureka)
                        {
                            _totalProductionDataMeters += (jobRun.ActualEndPosition - jobRun.ActualStartPosition) * 4;
                        }
                        else
                        {
                            _totalProductionDataMeters += jobRun.ActualEndPosition - jobRun.ActualStartPosition;
                        }

                        JobController.PushData(jobRun.EndDate.ToLocalTime().TimeOfDay, _totalProductionDataMeters);
                    }
                }
            }
            catch (Exception ex)
            {
                LogManager.Log(ex, "Error loading production data.");

            }
        }
        #endregion

        #region Resume

        private void JobResumeManager_JobResumeUpdated(object sender, Common.Resume.JobResumeUpdatedEventArgs e)
        {
            if (Job != null && Job.Guid == e.JobGuid)
            {
                ResumeModel = e.ResumeModel;
            }
        }

        private void JobResumeManager_JobResumeDropped(object sender, Common.Resume.JobResumeDroppedEventArgs e)
        {
            if (Job != null && Job.Guid == e.JobGuid)
            {
                ResumeModel = null;
            }
        }

        private async void DropResume()
        {
            if (Job != null && HasResumeModel)
            {
                // if (await NotificationProvider.ShowQuestion("Drop resume information and enable job editing?"))
                {
                    JobResumeManager.DropResume(Job.Guid);
                }
            }
        }

        #endregion
    }
}