using System;
using System.Collections.Generic;
using System.Linq;
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
{
    public class JobHandler2 : JobHandler
    {
        public JobHandler2(Action cancelAction, Job job, JobTicket jobTicket, ProcessParametersTable processParameters, JobHandlerModes mode)
            : base(cancelAction, job, jobTicket, processParameters, mode, BL.Enumerations.MachineTypes.TS1800)
        {

        }

        protected override void InvalidateJobProgress(JobStatus s)
        {
            JobStatus = s;

            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);
                return;
            }

            if (s.Progress > Status.TotalProgress)
            {
                LogManager.Log($"Invalid job progress received '{s.Progress}' while total progress is '{Status.TotalProgress}'.", LogCategory.Error);
                return;
            }

            if (s.Progress < _last_progress)
            {
                LogManager.Log($"Invalid job progress received '{s.Progress}' while last progress was '{_last_progress}'.");
            }

            _last_progress = s.Progress;

            List<Segment> unit_segments = new List<Segment>();

            Status.Progress = s.Progress;
            Status.RemainingTime = Status.TotalTime - Job.TranslateProgressToTime(Status.Progress, ProcessParameters);
            Status.RemainingProgress = Status.TotalProgress - Status.Progress;

            if (s.Progress < Status.SettingUpTotalProgress || Status.SettingUpProgress < Status.SettingUpTotalProgress)
            {
                Status.SettingUpProgress = Math.Min(s.Progress, this.Status.SettingUpTotalProgress);
                Status.IsSettingUp = true;
            }
            if (s.Progress >= Status.SettingUpTotalProgress)
            {
                if (Status.IsSettingUp && Status.Progress > 0)
                {
                    Status.IsSettingUp = false;
                }

                Status.ProgressMinusSettingUp = s.Progress - this.Status.SettingUpTotalProgress;
            }

            int units = (int)Math.Max(Job.NumberOfUnits, 1);

            if (s.Progress < Job.LengthIncludingNumberOfUnits || _mode == JobHandlerModes.SettingUp)
            {
                Status.ProgressWithoutFinalization = s.Progress;

                unit_segments = _effectiveSegments.ToList();
                Status.CurrentUnitProgress = 0.0;
                double previousUnitsLengthWithoutThis = 0.0;

                int currentUnit = Status.CurrentUnit;
                double currentUnitProgress = Status.CurrentUnitProgress;

                for (int index = 0; index < units; ++index)
                {
                    currentUnit = index;
                    double unitLength = !Job.EnableInterSegment || index >= units - 1 ? Job.Length : Job.Length + Job.InterSegmentLength;
                    if (_mode == JobHandlerModes.Finalization)
                    {
                        if (s.Progress < unitLength + previousUnitsLengthWithoutThis)
                        {
                            currentUnitProgress = s.Progress - previousUnitsLengthWithoutThis;
                            break;
                        }
                    }
                    else if (s.Progress <= previousUnitsLengthWithoutThis + unitLength + Status.SettingUpProgress)
                    {
                        if (!Status.IsSettingUp)
                        {
                            currentUnitProgress = s.Progress - previousUnitsLengthWithoutThis - this.Status.SettingUpProgress;
                            break;
                        }
                        break;
                    }
                    previousUnitsLengthWithoutThis += unitLength;
                }

                Status.CurrentUnit = currentUnit;
                Status.CurrentUnitProgress = currentUnitProgress;

                Status.RemainingUnits = this.Job.NumberOfUnits - this.Status.CurrentUnit;

                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;

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

                _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 = s.Progress - Job.LengthIncludingNumberOfUnits;
                Status.FinalizingProgress = s.Progress - Status.TotalProgressWithoutFinalization;
            }
        }
    }
}