Redesign JobHandler Progress Calculation based on progress value and not on delta. Tested on PPC and Machine Studio with Emulator.

Related Work Items: #2804

3 files changed, 264 insertions, 4 deletions

diff --git a/Software/Visual_Studio/Utilities/Tango.JobProgressTester.UI/JobHandler2.cs b/Software/Visual_Studio/Utilities/Tango.JobProgressTester.UI/JobHandler2.cs
index 068a37cc3..1f6e31d84 100644
--- a/Software/Visual_Studio/Utilities/Tango.JobProgressTester.UI/JobHandler2.cs
+++ b/Software/Visual_Studio/Utilities/Tango.JobProgressTester.UI/JobHandler2.cs
@@ -5,6 +5,7 @@ using System.Text;
 using System.Threading.Tasks;
 using Tango.BL.Entities;
 using Tango.Integration.Operation;
+using Tango.Logging;
 using Tango.PMR.Printing;
 
 namespace Tango.JobProgressTester.UI
@@ -19,7 +20,258 @@ namespace Tango.JobProgressTester.UI
 
         protected override void InvalidateJobProgress(JobStatus s)
         {
-            base.InvalidateJobProgress(s); //Vica: Remove this and create new implementation.
+            //base.InvalidateJobProgress(s); //Vica: Remove this and create new implementation.
+            JobStatus = s;
+            bool invalidProgress = false;
+
+            if (_last_progress != s.Progress)
+            {
+                if (s.Progress <= PROGRESS_REPORT_RANGE_METERS || s.Progress >= Status.TotalProgress - PROGRESS_REPORT_RANGE_METERS)
+                {
+                    LogManager.Log($"Updating job progress {s.Progress}/{Status.TotalProgress}...");
+                }
+                else if (!loggedContinueMessage)
+                {
+                    loggedContinueMessage = true;
+                    LogManager.Log($"Progress logging will continue {PROGRESS_REPORT_RANGE_METERS} meters before completion...");
+                }
+            }
+
+            if (s.Progress < 0)
+            {
+                LogManager.Log($"Invalid job progress received '{s.Progress}'.", LogCategory.Error);
+                invalidProgress = true;
+            }
+
+            if (s.Progress > Status.TotalProgress)
+            {
+                LogManager.Log($"Invalid job progress received '{s.Progress}' while total progress is '{Status.TotalProgress}'.", LogCategory.Error);
+                invalidProgress = true;
+            }
+
+            if (s.Progress < _last_progress)
+            {
+                LogManager.Log($"Invalid job progress received '{s.Progress}' while last progress was '{_last_progress}'.");
+                invalidProgress = true;
+            }
+
+            if (invalidProgress)
+            {
+                return;
+            }
+
+            _last_progress = s.Progress;
+
+            List<Segment> unit_segments = new List<Segment>();
+            //double delta = s.Progress - Status.Progress;
+
+            Status.Progress = s.Progress;
+            Status.RemainingTime = Status.TotalTime - Job.TranslateProgressToTime(Status.Progress, ProcessParameters);
+            Status.RemainingProgress = Status.TotalProgress - Status.Progress;
+
+            if (Status.SettingUpProgress < Status.SettingUpTotalProgress)
+            {
+                // Status.SettingUpProgress += delta;
+                Status.SettingUpProgress = s.Progress;
+            }
+            else
+            {
+                if (Status.IsSettingUp && Status.Progress > 0)
+                {
+                    Status.IsSettingUp = false;
+                }
+
+                //Status.ProgressMinusSettingUp += delta;
+                Status.ProgressMinusSettingUp = s.Progress - Status.SettingUpProgress;
+            }
+        
+            int units = (int)Math.Max(Job.NumberOfUnits, 1);
+
+            if (s.Progress < Job.LengthIncludingNumberOfUnits || _mode == JobHandlerModes.SettingUp)
+            {
+                //Status.ProgressWithoutFinalization += delta;
+                Status.ProgressWithoutFinalization = s.Progress;
+
+                unit_segments = _effectiveSegments.ToList();
+
+                if (Job.EnableInterSegment && Job.NumberOfUnits > 1 && Status.RemainingUnits > 1)
+                {
+                    unit_segments.Add(Job.CreateInterSegment(Job.InterSegmentLength));
+                }
+
+                if (unit_segments.Count != Status.CurrentUnitSegments.Count)
+                {
+                    Status.CurrentUnitSegments = unit_segments;
+                }
+
+                Status.CurrentUnitTotalProgress = Status.RemainingUnits > 1 && Job.EnableInterSegment ? Job.Length + (Job.InterSegmentLength) : Job.Length;
+
+                double previousUnitsLengthWithoutThis = 0;
+                if (units > 1 && Status.CurrentUnit > 0)
+                {
+                    int prevUnits = (int)Math.Min(Job.NumberOfUnits - 1, Status.CurrentUnit);
+                    previousUnitsLengthWithoutThis += prevUnits * (Job.EnableInterSegment ? Job.Length + (Job.InterSegmentLength) : Job.Length);
+                }
+
+                if (_mode == JobHandlerModes.Finalization)
+                {
+                    // Status.CurrentUnitProgress += delta;
+                    Status.CurrentUnitProgress = s.Progress - previousUnitsLengthWithoutThis;
+                }
+                else
+                {
+                    if (!Status.IsSettingUp)
+                    {
+                        //Status.CurrentUnitProgress += delta;
+                        Status.CurrentUnitProgress = s.Progress - previousUnitsLengthWithoutThis - Status.SettingUpProgress;
+                    }
+                }
+                
+                if (Status.CurrentUnitProgress >= Status.CurrentUnitTotalProgress)
+                {
+                    Status.CurrentUnitProgress = 0;
+                    Status.CurrentUnit++;
+                }
+
+                Status.RemainingUnits = Job.NumberOfUnits - Status.CurrentUnit;
+
+                if (s.Message != _lastStatusMessage && s.Message != String.Empty)
+                {
+                    Status.Message = s.Message;
+                }
+                else
+                {
+                    Status.Message = null;
+                }
+
+                _lastStatusMessage = s.Message;
+
+                //RaiseStatusChanged();
+
+                //Segments Completion
+
+                if (Status.CurrentUnit > _last_unit)
+                {
+                    foreach (var segment in Status.CurrentUnitSegments)
+                    {
+                        segment.Started = false;
+                        segment.Completed = false;
+                    }
+
+                    if (Job.NumberOfUnits > 1)
+                    {
+                       // RaiseUnitCompleted();
+                    }
+                }
+
+                _last_unit = Status.CurrentUnit;
+
+
+                for (int i = 0; i < Status.CurrentUnitSegments.Count; i++)
+                {
+                    Segment segment = Status.CurrentUnitSegments[i];
+                    double previousSegmentsLengthWithThis = Status.CurrentUnitSegments.Take(i + 1).Sum(x => x.LengthWithFactor);
+                    TimeSpan segmentsDuration = Job.TranslateProgressToTime(previousSegmentsLengthWithThis, ProcessParameters);
+                    TimeSpan segmentRemainingTime = segmentsDuration - Job.TranslateProgressToTime(Status.CurrentUnitProgress, ProcessParameters);
+
+                    if (i == 0 && Status.CurrentUnitProgress > 0)
+                    {
+                        if (!segment.Started)
+                        {
+                            segment.Started = true;
+                           // RaiseSegmentStarted(segment);
+                        }
+                    }
+
+                    if (Status.CurrentUnitProgress >= previousSegmentsLengthWithThis)
+                    {
+                        if (!segment.Completed)
+                        {
+                            segment.Completed = true;
+                           // RaiseSegmentCompleted(segment);
+                        }
+
+                        if (i < Status.CurrentUnitSegments.Count - 1)
+                        {
+                            if (!Status.CurrentUnitSegments[i + 1].Started)
+                            {
+                                Status.CurrentUnitSegments[i + 1].Started = true;
+                               // RaiseSegmentStarted(Status.CurrentUnitSegments[i + 1]);
+                            }
+                        }
+                    }
+
+                    if (segment.Started && !segment.Completed)
+                    {
+                        segment.RemainingTime = segmentRemainingTime;
+                    }
+                }
+
+
+                //Set Segment Completion for All Segments List
+                for (int i = 0; i < Status.Segments.Count; i++)
+                {
+                    Segment segment = Status.Segments[i];
+                    double previousSegmentsLengthWithThis = Status.Segments.Take(i + 1).Sum(x => x.LengthWithFactor);
+                    TimeSpan segmentsDuration = Job.TranslateProgressToTime(previousSegmentsLengthWithThis, ProcessParameters);
+                    TimeSpan segmentRemainingTime = segmentsDuration - Job.TranslateProgressToTime(Status.Progress, ProcessParameters);
+
+                    segment.Progress = Math.Min(Math.Max((previousSegmentsLengthWithThis - segment.Length - Status.Progress) * -1, 0), segment.Length);
+
+                    if (i == 0 && Status.Progress > 0)
+                    {
+                        if (!segment.Started)
+                        {
+                            segment.Started = true;
+                            Status.CurrentSegment = segment;
+                        }
+                    }
+
+                    if (Status.Progress >= previousSegmentsLengthWithThis)
+                    {
+                        if (!segment.Completed)
+                        {
+                            segment.Completed = true;
+                        }
+
+                        if (i < Status.Segments.Count - 1)
+                        {
+                            if (!Status.Segments[i + 1].Started)
+                            {
+                                Status.Segments[i + 1].Started = true;
+                                Status.CurrentSegment = Status.Segments[i + 1];
+                            }
+                        }
+                    }
+
+                    if (segment.Started && !segment.Completed)
+                    {
+                        segment.RemainingTime = segmentRemainingTime;
+                    }
+                }
+            }
+            else
+            {
+                //Finalizing
+                if (!_finalizing)
+                {
+                    _finalizing = true;
+                    Status.IsFinalizing = true;
+                    var last_Segment = _effectiveSegments.Last().Clone();
+                    last_Segment.Length = ProcessParameters.DryerBufferLengthMeters;
+                    Status.CurrentUnitSegments = new List<Segment> { last_Segment };
+                    Status.CurrentUnitTotalProgress = last_Segment.Length;
+                    Status.CurrentUnitProgress = 0;
+                    Status.ProgressWithoutFinalization = Status.TotalProgressWithoutFinalization;
+                    //RaiseFinalizing();
+                }
+
+                //Status.CurrentUnitProgress += delta;
+                //Status.FinalizingProgress += delta;
+
+                Status.CurrentUnitProgress = s.Progress - Job.LengthIncludingNumberOfUnits;
+                Status.FinalizingProgress = s.Progress - Status.TotalProgressWithoutFinalization;
+            }
         }
     }
 }
diff --git a/Software/Visual_Studio/Utilities/Tango.JobProgressTester.UI/MainWindowVM.cs b/Software/Visual_Studio/Utilities/Tango.JobProgressTester.UI/MainWindowVM.cs
index 914e4cf34..dc3466971 100644
--- a/Software/Visual_Studio/Utilities/Tango.JobProgressTester.UI/MainWindowVM.cs
+++ b/Software/Visual_Studio/Utilities/Tango.JobProgressTester.UI/MainWindowVM.cs
@@ -139,10 +139,14 @@ namespace Tango.JobProgressTester.UI
 
         private void OnProgressChanged()
         {
-            JobHandler.RaiseStatusReceived(new JobStatus()
+            if(JobHandler != null)
             {
-                Progress = Progress,
-            });
+                JobHandler.RaiseStatusReceived(new JobStatus()
+                {
+                    Progress = Progress,
+                });
+            }
+            
         }
 
         private void ShowError(String message)
diff --git a/Software/Visual_Studio/Utilities/Tango.JobProgressTester.UI/Tango.JobProgressTester.UI.csproj b/Software/Visual_Studio/Utilities/Tango.JobProgressTester.UI/Tango.JobProgressTester.UI.csproj
index fdc878103..eb5297422 100644
--- a/Software/Visual_Studio/Utilities/Tango.JobProgressTester.UI/Tango.JobProgressTester.UI.csproj
+++ b/Software/Visual_Studio/Utilities/Tango.JobProgressTester.UI/Tango.JobProgressTester.UI.csproj
@@ -117,6 +117,10 @@
       <Project>{4206ac58-3b57-4699-8835-90bf6db01a61}</Project>
       <Name>Tango.Integration</Name>
     </ProjectReference>
+    <ProjectReference Include="..\..\Tango.Logging\Tango.Logging.csproj">
+      <Project>{BC932DBD-7CDB-488C-99E4-F02CF441F55E}</Project>
+      <Name>Tango.Logging</Name>
+    </ProjectReference>
     <ProjectReference Include="..\..\Tango.PMR\Tango.PMR.csproj">
       <Project>{e4927038-348d-4295-aaf4-861c58cb3943}</Project>
       <Name>Tango.PMR</Name>