using System;
using System.Collections.Generic;
using System.Linq;
using System.Globalization;
using System.Threading;
using System.Threading.Tasks;
using System.Windows.Forms;
using GenesisDisplayTool;
using Xylem.Common.Hardware.WaterMeter.WaterMeterCore;
using Xylem.Common.Hardware.WaterMeter.Genesis.Registers;

namespace GenesisZeroFlow
{
    public static class AmplitudeSequences
    {
        public static Boolean[] Total(MeterBatch globalMeterBatch, MeterBatch thermoMeterBatch, Boolean[] allEnable, Int32 firstHitLevelPropMin, Int32 firstHitLevelPropMax, Int32 ampTestLowerLimit, Int32 ampTestUpperLimit, Int32 ampTestDistance, Double upperTempLimit, Double lowerTempLimit, Double tempDeviationLimit, out Boolean aborted, CultureInfo culture)
        {
            #region Definitions and initializations
            Int32 FirstHitLevelPropMin = firstHitLevelPropMin;
            Int32 FirstHitLevelPropMax = firstHitLevelPropMax;
            Boolean[] MeterEnable = Misc.Subarray(allEnable, 0, Constants.NumberOfMeters);
            Boolean[] ThermoEnable = Misc.Subarray(allEnable, Constants.NumberOfMeters, Constants.NumberOfThermometers);
            Boolean GenerateMeanFiles = GenesisZeroFlow._GenesisZeroFlow.GetCBMeanAmplitudeFiles();
            Boolean GenerateLogFiles = GenesisZeroFlow._GenesisZeroFlow.GetCBAmpLogFiles();
            const Int32 TofRecordingTime = 2;
            const Double TriggerValue = 0.5;
            Int32 NextDelayTime = 0;

            Boolean[] MeterTaskStarted = new Boolean[Constants.NumberOfMeters];
            Boolean[] MeterTaskCompleted = new Boolean[Constants.NumberOfMeters];
            Boolean[] MeterSequenceOk = new Boolean[Constants.NumberOfMeters];
            Boolean[] MeterSequenceFailed = new Boolean[Constants.NumberOfMeters];

            Boolean[] ThermoTaskStarted = new Boolean[Constants.NumberOfThermometers];
            Boolean[] ThermoTaskCompleted = new Boolean[Constants.NumberOfThermometers];
            Boolean[] ThermoSequenceOk = new Boolean[Constants.NumberOfThermometers];
            Boolean[] ThermoSequenceFailed = new Boolean[Constants.NumberOfThermometers];
         
            List<Amplitude> listAmpTest = new List<Amplitude>();
            List<Amplitude> thermoAmpTest = new List<Amplitude>();
            GenesisZeroFlow._GenesisZeroFlow.TempMonitoringFailed = false;

            MeterTaskStarted = ArrayInit.Meter(false);
            MeterTaskCompleted = ArrayInit.Meter(false);
            MeterSequenceOk = ArrayInit.Meter(false);
            MeterSequenceFailed = ArrayInit.Meter(false);

            ThermoTaskStarted = ArrayInit.Thermo(false);
            ThermoTaskCompleted = ArrayInit.Thermo(false);
            ThermoSequenceOk = ArrayInit.Thermo(false);
            ThermoSequenceFailed = ArrayInit.Thermo(false);

            aborted = false;

            for (UInt16 Meter = Constants.Meter1; Meter < Constants.NumberOfMeters; Meter++)
            {
                var currentMeter = globalMeterBatch.ListOfMeters.FirstOrDefault(m => m.Slot.Equals(Meter + 1));

                if (currentMeter != null)
                    listAmpTest.Add(new Amplitude(Meter, currentMeter, culture));
                else
                    listAmpTest.Add(new Amplitude(Meter, culture));
            }
            for (UInt16 Thermo = Constants.Thermo1; Thermo < Constants.NumberOfThermometers; Thermo++)
            {
                var currentMeter = thermoMeterBatch.ListOfMeters.FirstOrDefault(m => m.Slot.Equals(Thermo + 11));

                if (currentMeter != null)
                    thermoAmpTest.Add(new Amplitude(Thermo, currentMeter, culture));
                else
                    thermoAmpTest.Add(new Amplitude(Thermo, culture));
            }
            #region Initialize
            foreach (var meteramp in listAmpTest)
            {
                meteramp.Initialize(GenesisZeroFlow._GenesisZeroFlow.PcbID[meteramp.MeterNumber], Constants.Meter, ampTestLowerLimit, ampTestUpperLimit, ampTestDistance, FirstHitLevelPropMin, FirstHitLevelPropMax, TofRecordingTime, TriggerValue, upperTempLimit, lowerTempLimit, tempDeviationLimit, GenerateMeanFiles, GenerateLogFiles);
                meteramp.MyTask = new Task<Boolean>(() => { return true; });
            }
            foreach (var thermoamp in thermoAmpTest)
            {
                thermoamp.Initialize(GenesisZeroFlow._GenesisZeroFlow.ThermoID[thermoamp.MeterNumber], Constants.Thermo,  0, 0, 0, 0, 0, TofRecordingTime, TriggerValue, upperTempLimit, lowerTempLimit, tempDeviationLimit, GenerateMeanFiles, GenerateLogFiles);
                thermoamp.MyTask = new Task<Boolean>(() => { return true; });
            }
            #endregion
            #endregion
            #region Perform tests
            CancellationTokenSource cancellationTokenSource = new CancellationTokenSource();
            CancellationToken token = cancellationTokenSource.Token;
            // Amplitude test
            foreach (var meteramp in listAmpTest)
                meteramp.Meter(MeterEnable[meteramp.MeterNumber], ref MeterTaskStarted[meteramp.MeterNumber], ref MeterSequenceFailed[meteramp.MeterNumber], ref NextDelayTime, token);
            // Temperature Monitoring
            foreach (var thermoamp in thermoAmpTest)
            {
                if (ThermoEnable[thermoamp.MeterNumber])
                {
                    GenesisZeroFlow._GenesisZeroFlow.SetIndicatorTemperatureActivityCheck(thermoamp.MeterNumber, true);
                    GenesisZeroFlow.Display.DebugMessage($"{Constants.TwentySpaces}\tAPPLICATION:\t\tTEMPERATURE MONITORING started at {thermoamp.MeterType}{thermoamp.MeterIndex}\n", thermoamp.Culture);
                    GenesisZeroFlow._GenesisZeroFlow.SetLoggingIndicatorThermoMonitoring(thermoamp.MeterNumber, true);
                }
                Misc.WaitNMilliseconds(300);
                thermoamp.Thermometer(ThermoEnable[thermoamp.MeterNumber], ref ThermoTaskStarted[thermoamp.MeterNumber], ref ThermoSequenceFailed[thermoamp.MeterNumber], ref NextDelayTime, token);
            }
            #endregion
            #region Wait for tasks
            while (!CheckArray(MeterTaskCompleted.Concat(ThermoTaskCompleted).ToArray()))
            {
                #region Temperature check
                foreach (var thermoamp in thermoAmpTest)
                {
                    if (CheckArray(MeterTaskCompleted) && (ThermoEnable[thermoamp.MeterNumber])) // If all METERs finished, not THERMOMETERs 
                    {
                        GenesisZeroFlow._GenesisZeroFlow.SetLoggingIndicatorThermoMonitoring(thermoamp.MeterNumber, false);
                        GenesisZeroFlow.Display.DebugMessage($"{Constants.TwentySpaces}\tAPPLICATION:\t\t TEMPERATURE MONITORING stopped at {thermoamp.MeterType}{thermoamp.MeterIndex}\n", thermoamp.Culture);
                    }
                }
                #endregion
                #region Abort check
                if (GenesisZeroFlow._GenesisZeroFlow.AbortIndicator)
                {
                    cancellationTokenSource.Cancel();
                    aborted = true;
                }
                #endregion
                #region Check result
                Misc.WaitNSeconds(1);
                #region Meter
                foreach (var amp in listAmpTest)
                {
                    MeterTaskCompleted[amp.MeterNumber] = TaskOperations.WaitFor(MeterTaskStarted[amp.MeterNumber], amp.MyTask);
                    // Stop temperature check
                    GenesisZeroFlow._GenesisZeroFlow.SetIndicatorTemperatureActivityCheck(amp.MeterNumber, !MeterTaskCompleted[amp.MeterNumber]);
                }
                foreach (var amp in listAmpTest)
                    MeterSequenceFailed[amp.MeterNumber] = TaskOperations.GetResult(MeterTaskStarted[amp.MeterNumber], amp.MyTask);
                for (UInt16 Meter = Constants.Meter1; Meter < Constants.NumberOfMeters; Meter++)
                    MeterSequenceOk[Meter] = !MeterSequenceFailed[Meter];
                #endregion
                #region Thermometer
                foreach (var amp in thermoAmpTest)
                {
                   ThermoTaskCompleted[amp.MeterNumber] = TaskOperations.WaitFor(ThermoTaskStarted[amp.MeterNumber], amp.MyTask);
                   // Stop temperature check
                   GenesisZeroFlow._GenesisZeroFlow.SetIndicatorTemperatureActivityCheck(amp.MeterNumber, !MeterTaskCompleted[amp.MeterNumber]);
                }
                foreach (var amp in thermoAmpTest)
                    ThermoSequenceFailed[amp.MeterNumber] = TaskOperations.GetResult(ThermoTaskStarted[amp.MeterNumber], amp.MyTask);
                for (UInt16 Thermometer = Constants.Thermo1; Thermometer < Constants.NumberOfThermometers; Thermometer++)
                    ThermoSequenceOk[Thermometer] = !ThermoSequenceFailed[Thermometer];
                #endregion
                GenesisZeroFlow.Display.MeterStatusGreenRed(MeterSequenceOk, MeterTaskStarted);
                GenesisZeroFlow.Display.ThermoStatusGreenRed(ThermoSequenceOk, ThermoTaskStarted);
                #endregion
            }
            #region Sequence failed
            foreach (var meteramp in listAmpTest)
                MeterSequenceFailed[meteramp.MeterNumber] = TaskOperations.GetResult(MeterTaskStarted[meteramp.MeterNumber], meteramp.MyTask);
            foreach (var thermoamp in thermoAmpTest)
                ThermoSequenceFailed[thermoamp.MeterNumber] = TaskOperations.GetResult(ThermoTaskStarted[thermoamp.MeterNumber], thermoamp.MyTask);
            #endregion
            #region Sequence Ok
            for (UInt16 Meter = Constants.Meter1; Meter < Constants.NumberOfMeters; Meter++)
                MeterSequenceOk[Meter] = !MeterSequenceFailed[Meter];
            for (UInt16 Thermo = Constants.Thermo1; Thermo < Constants.NumberOfThermometers; Thermo++)
                ThermoSequenceOk[Thermo] = !ThermoSequenceFailed[Thermo];
            GenesisZeroFlow.Display.MeterStatusGreenRed(MeterSequenceOk, MeterTaskStarted);
            GenesisZeroFlow.Display.ThermoStatusGreenRed(ThermoSequenceOk, ThermoTaskStarted);
            #endregion
            #endregion
            #region Destroy tasks    
            foreach (var meteramp in listAmpTest)
                TaskOperations.CheckAndDispose(meteramp.MyTask);
            foreach (var thermoamp in thermoAmpTest)
                TaskOperations.CheckAndDispose(thermoamp.MyTask);
            #endregion

            return MeterSequenceFailed.Concat(ThermoSequenceFailed).ToArray();
        }
        private static Boolean CheckArray(Boolean[] array)
        {
            Boolean Completed = true;

            for (Int32 i = 0; i < array.Count(); i++)
            {
                if (Boolean.Equals(array[i], false))
                    return false;
            }

            return Completed;
        }
    }
    public class Amplitude
    {
        private readonly ZeroFlowGenesisMeter GenesisMeter;
        public Task<Boolean> MyTask { get; set; }
        public Amplitude(UInt16 meterNumber, CultureInfo culture)
        {
            MeterNumber = meterNumber;
            Culture = culture;
            MeterIndex = (meterNumber + 1).ToString(culture);
        }
        public Amplitude(UInt16 meterNumber, IMeter meter, CultureInfo culture)
        {
            if (meter is ZeroFlowGenesisMeter)
            {
                GenesisMeter = meter as ZeroFlowGenesisMeter;
            }
            MeterNumber = meterNumber;
            Culture = culture;
            MeterIndex = (meterNumber + 1).ToString(culture);
        }
        internal void Meter(Boolean enable, ref Boolean taskStarted, ref Boolean sequenceFailed, ref Int32 nextDelayTime, CancellationToken token)
        {
            #region Avoid CA1062
            if ((MyTask == null))
                return;
            #endregion
            #region Definitions and initializations
            Int32 DelayTime = 0;
            const Int32 DeltaDelay = 1;
            DialogResult AskForActions = DialogResult.None;
            Boolean _sequenceFailed = sequenceFailed;
            Boolean Ok = false;
            #endregion
            #region Everything else
            if ((enable) && (!TaskStatus.Equals(MyTask.Status, TaskStatus.Running)) && (!MyTask.IsCompleted))
            {
                #region Start delay
                DelayTime = nextDelayTime;
                nextDelayTime = nextDelayTime + DeltaDelay;

                taskStarted = true;
                Misc.WaitNSeconds(DelayTime);
                #endregion

                MyTask = Task.Run(() =>
                {
                    while ((DialogResult.Equals(AskForActions, DialogResult.Retry)) || (DialogResult.Equals(AskForActions, DialogResult.None)) && (!token.IsCancellationRequested) && !GenesisZeroFlow._GenesisZeroFlow.TempMonitoringFailed)
                    {
                        #region Abort
                        if (token.IsCancellationRequested)
                        {
                            GenesisZeroFlow.Display.DebugMessage($"{this.PcbID}\tAPPLICATION:\t\t AMPLITUDE TEST stopped at {this.MeterType}{this.MeterIndex}\n", this.Culture);
                            GenesisZeroFlow.Display.AbortButtonEnabled(false);
                            GenesisZeroFlow._GenesisZeroFlow.GenerateReturnNote(this.MeterIndex, this.PcbID, GenesisZeroFlow.PredefinedMessages.AmplitudeStopped(this.Culture), GenesisZeroFlow._GenesisZeroFlow.GetLoggingFromTextBox(), this.Culture);
                            return true; // sequence failed
                        }
                        else
                            GenesisZeroFlow.Display.AbortButtonEnabled(true);
                        #endregion
                        #region Testprocedure
                        if (DialogResult.Equals(AskForActions, DialogResult.None))
                            GenesisZeroFlow.Display.DebugMessage($"{this.PcbID}\tAPPLICATION:\t\t AMPLITUDE TEST started at {this.MeterType}{this.MeterIndex}\n", this.Culture);

                        Ok = this.PerformTest(token);

                        if (token.IsCancellationRequested)
                        {
                            GenesisZeroFlow.Display.DebugMessage($"{this.PcbID}\tAPPLICATION:\t\t AMPLITUDE TEST stopped at {this.MeterType}{this.MeterIndex}\n", this.Culture);
                            GenesisZeroFlow._GenesisZeroFlow.GenerateReturnNote(this.MeterIndex, this.PcbID, GenesisZeroFlow.PredefinedMessages.AmplitudeStopped(this.Culture), GenesisZeroFlow._GenesisZeroFlow.GetLoggingFromTextBox(), this.Culture);
                            GenesisZeroFlow.Display.AbortButtonEnabled(false);
                            return true; // sequence failed
                        }
                        if (Ok)
                        {
                            GenesisZeroFlow.Display.DebugMessage($"{this.PcbID}\tAPPLICATION:\t\t AMPLITUDE TEST successful at {this.MeterType}{this.MeterIndex}\n", this.Culture);
                            GenesisZeroFlow.Display.DebugMessage($"{Constants.TwentySpaces}\t{Debugmessages.Line}", this.Culture);
                            _sequenceFailed = false;
                            AskForActions = DialogResult.OK;
                        }
                        else
                        {
                            _sequenceFailed = true;
                            AskForActions = DialogResult.Cancel;
                            GenesisZeroFlow._GenesisZeroFlow.GenerateReturnNote(this.MeterIndex, this.PcbID, GenesisZeroFlow.PredefinedMessages.AmplitudeFailed(this.Culture), GenesisZeroFlow._GenesisZeroFlow.GetLoggingFromTextBox(), this.Culture);
                            GenesisZeroFlow.Display.DebugMessage($"{this.PcbID}\tAPPLICATION:\t\t AMPLITUDE TEST failed at {this.MeterType}{this.MeterIndex}\n", this.Culture);
                        }
                        #endregion
                    }
                    return _sequenceFailed;

                }, token);
            }
            #endregion
        }
        internal void Thermometer(Boolean enable, ref Boolean taskStarted, ref Boolean sequenceFailed, ref Int32 nextDelayTime, CancellationToken token)
        {
            #region avoid CA1062
            if ((MyTask == null))
                return;
            #endregion
            #region Definitions and initializations
            Int32 DelayTime = 0;
            const Int32 DeltaDelay = 30;
            const Int32 Checkinterval = 4;
            Boolean _sequenceFailed = sequenceFailed;
            Boolean Ok = true;
            #endregion
            #region Everything else
            if ((enable) && (!TaskStatus.Equals(MyTask.Status, TaskStatus.Running)) && (!MyTask.IsCompleted))
            {
                DelayTime = nextDelayTime;
                nextDelayTime = nextDelayTime + DeltaDelay;

                taskStarted = true;
                Misc.WaitNSeconds(DeltaDelay);

                MyTask = Task.Run(() =>
                {
                    Boolean LoggingIndicator = GenesisZeroFlow._GenesisZeroFlow.GetLoggingIndicatorThermoMonitoring()[this.MeterNumber];
                    while (LoggingIndicator && (Boolean.Equals(Ok, true)))
                    {
                        #region Abort
                        if (!token.IsCancellationRequested)
                            GenesisZeroFlow.Display.AbortButtonEnabled(true);
                        #endregion
                        #region Testprocedure
                        Ok = PerformTempMonitoring(token);
                        Misc.WaitNSeconds(Checkinterval);

                        if (token.IsCancellationRequested)
                        {
                            GenesisZeroFlow.Display.DebugMessage($"{this.PcbID}\tAPPLICATION:\t\t TEMPERATURE MONITORING stopped at {this.MeterType}{this.MeterIndex}\n", this.Culture);
                            GenesisZeroFlow.Display.AbortButtonEnabled(false);
                            return true; // sequence failed
                        }
                        if (Ok)
                        {
                            // GenesisZeroFlow.Display.DebugMessage($"APPLICATION:\t\t AMPLITUDE TEST successful at METER{MeterIndex}\t{AppendID}\n", this.Culture);
                            // GenesisZeroFlow.Display.DebugMessage(Debugmessages.Line, this.Culture);
                            _sequenceFailed = false;
                        }
                        else
                            _sequenceFailed = true;
                        #endregion
                        LoggingIndicator = GenesisZeroFlow._GenesisZeroFlow.GetLoggingIndicatorThermoMonitoring()[this.MeterNumber];
                    }

                    return _sequenceFailed;

                }, token);
            }
            #endregion

        }
        private Boolean PerformTest(CancellationToken token)
        {
            this.ClearData();

            #region Definitions and initializations
            String TempPcbID = this.PcbID.Replace(" ", String.Empty);
            const Int32 FirstHitShiftValue = 4;
            const Int32 FirstHitShiftValueEnd = 4;
            const Int32 FirstHitUpdatePeriodeValue = 1;
            const Int32 FirstHitUpdatePeriodeValueEnd = 10;
            const Int32 WaitBeforeLogging = 1;
            String DebugMessage = String.Empty;
            Double[] TofAvgMean = new Double[Constants.NumberOfPaths];
            TofAvgMean = ArrayInit.Path((Double)0);
            Int32[] OptimalPoint = new Int32[Constants.NumberOfPaths];
            OptimalPoint = ArrayInit.Path((Int32)0);
            List<Double>[] TofAvgMeanTotal = new List<Double>[Constants.NumberOfPaths];
            for (UInt16 Path = Constants.PATH0; Path < Constants.NumberOfPaths; Path++)
                TofAvgMeanTotal[Path] = new List<Double>();
            Boolean Ok = false;
            #endregion
            #region Test sequence
            #region StartLogging
            if (this.GenerateLogFiles)
            {
                String time = System.DateTime.Now.ToString(Formats.LogFileDateTimeString, this.Culture);
                String Header = $"Genesis ZeroFlowOffsetCalibration {this.MeterType}{this.MeterIndex}; PCB ID = {TempPcbID}; Date = {time}; Operator = {Environment.UserName}\n";
                GenesisZeroFlow._GenesisZeroFlow.SetDataToLog(this.MeterNumber, Header);   
                GenesisZeroFlow._GenesisZeroFlow.SetLoggingPathAmplitudeTest(this.MeterNumber, $"{DataLogging.DefaultPath}AmplitudeTest_RawData_{TempPcbID}_{time}.txt");
                GenesisZeroFlow._GenesisZeroFlow.SetLoggingIndicatorAmpTest(this.MeterNumber, true);
                GenesisZeroFlow.Display.DebugMessage($"{this.PcbID}\tDATA CHANNEL:\t\t Start logging at {this.MeterType}{this.MeterIndex}\n", this.Culture);
            }
            #endregion
            #region Set first hit update period
            if (GenesisZeroFlow._GenesisZeroFlow.TempMonitoringFailed)
            {
                this.LeaveSequence();
                return false;
            }
            GenesisZeroFlow.Display.StatusLabel(GenesisZeroFlow.PredefinedMessages.WaitUntilRegisterWriteFinished(this.Culture));
            Ok = false;
            if (token.IsCancellationRequested || GenesisZeroFlow._GenesisZeroFlow.TempMonitoringFailed)
            {
                this.LeaveSequence();
                return false;
            }
            Ok = WriteRegister(GenesisMeter, "First hit update period", Register.Genesisflow.FirstHitUpdatePeriod, FirstHitUpdatePeriodeValue, FirstHitUpdatePeriodeValue.ToString(this.Culture));
            if (Boolean.Equals(Ok, false) || GenesisZeroFlow._GenesisZeroFlow.TempMonitoringFailed)
            {
                this.LeaveSequence();
                return false;
            }
            #endregion
            #region Set first hit shift to 4
            GenesisZeroFlow.Display.StatusLabel(GenesisZeroFlow.PredefinedMessages.WaitUntilRegisterWriteFinished(this.Culture));
            Ok = false;
            if (token.IsCancellationRequested || GenesisZeroFlow._GenesisZeroFlow.TempMonitoringFailed)
            {
                this.LeaveSequence();
                return false;
            }
            Ok = WriteRegister(GenesisMeter, "First hit shift", Register.Genesisflow.FirstHitShift, FirstHitShiftValue, FirstHitShiftValue.ToString(this.Culture));
            if (Boolean.Equals(Ok, false) || GenesisZeroFlow._GenesisZeroFlow.TempMonitoringFailed)
            {
                this.LeaveSequence();
                return false;
            }
            #endregion
            #region Set first hit level percentage from 5 to 40
            GenesisZeroFlow.Display.DebugMessage($"{this.PcbID}\tDATA CHANNEL:\t\t Start first hit level percentage sweep at {this.MeterType}{this.MeterIndex}\n", this.Culture);

            for (Int32 FirstHitLevelPercentage = (Int32)(this.FirstHitLevelPercMin); FirstHitLevelPercentage <= (this.FirstHitLevelPercMax); FirstHitLevelPercentage++)
            {
                if (token.IsCancellationRequested || GenesisZeroFlow._GenesisZeroFlow.TempMonitoringFailed)
                {
                    this.LeaveSequence();
                    return false;
                }
                GenesisZeroFlow.Display.StatusLabel($"{GenesisZeroFlow.PredefinedMessages.WaitUntilPercentageSweepFinished(this.Culture)} {FirstHitLevelPercentage.ToString(this.Culture)}/{FirstHitLevelPercMax.ToString(this.Culture)}");
                #region Write to percentage register PATH0 
                GenesisZeroFlow.Display.StatusLabel(GenesisZeroFlow.PredefinedMessages.WaitUntilRegisterWriteFinished(this.Culture));
                Ok = false;
                if (token.IsCancellationRequested || GenesisZeroFlow._GenesisZeroFlow.TempMonitoringFailed)
                {
                    this.LeaveSequence();
                    return false;
                }
                Ok = WriteRegister(GenesisMeter, "Percentage", Register.Genesisflow.FirstHitPercent1, FirstHitLevelPercentage, FirstHitLevelPercentage.ToString(this.Culture));
                if (Boolean.Equals(Ok, false) || (GenesisZeroFlow._GenesisZeroFlow.TempMonitoringFailed))
                {
                    this.LeaveSequence();
                    return false;
                }
                #endregion
                #region Write to percentage register PATH1 
                if (Constants.NumberOfPaths > 1)
                {
                    GenesisZeroFlow.Display.StatusLabel(GenesisZeroFlow.PredefinedMessages.WaitUntilRegisterWriteFinished(this.Culture));
                    Ok = false;
                    if (token.IsCancellationRequested || GenesisZeroFlow._GenesisZeroFlow.TempMonitoringFailed)
                    {
                        this.LeaveSequence();
                        return false;
                    }
                    Ok = WriteRegister(GenesisMeter, "Percentage", Register.Genesisflow.FirstHitPercent2, FirstHitLevelPercentage, FirstHitLevelPercentage.ToString(this.Culture));
                    if (Boolean.Equals(Ok, false) || GenesisZeroFlow._GenesisZeroFlow.TempMonitoringFailed)
                    {
                        this.LeaveSequence();
                        return false;
                    }
                }
                #endregion
                #region Write to percentage register PATH2 
                if (Constants.NumberOfPaths > 2)
                {
                    GenesisZeroFlow.Display.StatusLabel(GenesisZeroFlow.PredefinedMessages.WaitUntilRegisterWriteFinished(this.Culture));
                    Ok = false;
                    if (token.IsCancellationRequested || GenesisZeroFlow._GenesisZeroFlow.TempMonitoringFailed)
                    {
                        this.LeaveSequence();
                        return false;
                    }
                    Ok = WriteRegister(GenesisMeter, "Percentage", Register.Genesisflow.FirstHitPercent3, FirstHitLevelPercentage, FirstHitLevelPercentage.ToString(this.Culture));
                    if (Boolean.Equals(Ok, false) || GenesisZeroFlow._GenesisZeroFlow.TempMonitoringFailed)
                    {
                        this.LeaveSequence();
                        return false;
                    }
                }
                #endregion
                #region Wait for 1 second
                for (Int32 i = 0; i < WaitBeforeLogging; i++)
                {
                    if ((token.IsCancellationRequested) || GenesisZeroFlow._GenesisZeroFlow.TempMonitoringFailed)
                    {
                        this.LeaveSequence();
                        return false;
                    }
                    GenesisZeroFlow.Display.StatusLabel($"{GenesisZeroFlow.PredefinedMessages.WaitUntilPercentageSweepFinished(this.Culture)} {FirstHitLevelPercentage.ToString(this.Culture)}/{FirstHitLevelPercMax.ToString(this.Culture)}; {(this.TofRecordingTime + WaitBeforeLogging - i).ToString(this.Culture)}s");
                    Misc.WaitNSeconds(1);
                }
                #endregion
                #region Record TOF
                GenesisZeroFlow._GenesisZeroFlow.SetTofIndicatorAmplitudeTest(this.MeterNumber, true);
                GenesisZeroFlow.Display.DebugMessage($"{this.PcbID}\tDATA CHANNEL:\t\t Start collecting data at {this.MeterType}{this.MeterIndex}\n", this.Culture);
                Int32[] LinecounterFollowing = new Int32[Constants.NumberOfPaths];
                LinecounterFollowing = ArrayInit.Path(0);

                for (Int32 Seconds = 0; Seconds < this.TofRecordingTime; Seconds++) // eight seconds remove /2
                {
                    if (token.IsCancellationRequested || GenesisZeroFlow._GenesisZeroFlow.TempMonitoringFailed)
                    {
                        this.LeaveSequence();
                        return false;
                    }

                    // if (Seconds % 60 == 0)
                    Int32 ActivityCheckInterval = GenesisZeroFlow._GenesisZeroFlow.GetAmplitudeActivityCheckInterval();
                    if (Int32.Equals((Seconds % ActivityCheckInterval), 0))
                        Ok = this.ActivityCheck(ref LinecounterFollowing, Seconds);
                    // else
                    //     Ok = true;
                    if (Ok && !GenesisZeroFlow._GenesisZeroFlow.TempMonitoringFailed)
                    {
                        GenesisZeroFlow.Display.StatusLabel($"{GenesisZeroFlow.PredefinedMessages.WaitUntilPercentageSweepFinished(this.Culture)} {FirstHitLevelPercentage.ToString(this.Culture)}/{ FirstHitLevelPercMax.ToString(this.Culture)}; {(this.TofRecordingTime - Seconds).ToString(this.Culture)}s");
                        Misc.WaitNSeconds(1); // replace 2 with 1
                    }
                    else
                    {
                        GenesisZeroFlow.Display.DebugMessage($"{this.PcbID}\tDATA CHANNEL:\t\t Activity check failed at {this.MeterType}{this.MeterIndex}\n", this.Culture);
                        this.LeaveSequence();
                        return false;
                    }
                }
                GenesisZeroFlow.Display.StatusLabel($"{ GenesisZeroFlow.PredefinedMessages.WaitUntilPercentageSweepFinished(this.Culture)} { FirstHitLevelPercentage.ToString(this.Culture)}/{FirstHitLevelPercMax.ToString(this.Culture)}; 0s");
              
                Ok = true;
                #endregion
                #region Calculate mean value
                for (UInt16 Path = Constants.PATH0; Path < Constants.NumberOfPaths; Path++)
                {
                    GenesisZeroFlow.Display.DebugMessage($"{this.PcbID}\tDATA CHANNEL:\t\t Calculate mean value at {this.MeterType}{this.MeterIndex}; PATH{(Path + 1).ToString(this.Culture)}\n", this.Culture);
                    TofAvgMean[Path] = GenesisZeroFlow._GenesisZeroFlow.GetTotalTimeOfFlightAverage()[this.MeterNumber][Path].Mean();
                    if(TofAvgMean[Path] == 0)
                    {
                        GenesisZeroFlow.Display.DebugMessage($"{this.PcbID}\tDATA CHANNEL:\t\t Mean value is zero at {this.MeterType}{this.MeterIndex}; PATH{(Path + 1).ToString(this.Culture)}; Value = {Math.Round(TofAvgMean[Path], 4).ToString("000.0000", this.Culture)}\n", this.Culture);
                        this.LeaveSequence();
                        return false;
                    }
                    GenesisZeroFlow._GenesisZeroFlow.SetTofIndicatorAmplitudeTest(this.MeterNumber, true);
                    GenesisZeroFlow.Display.DebugMessage($"{this.PcbID}\tDATA CHANNEL:\t\t Mean value at {this.MeterType}{this.MeterIndex}; PATH{(Path + 1).ToString(this.Culture)}; Value = {Math.Round(TofAvgMean[Path], 4).ToString("000.0000", this.Culture)}\n", this.Culture);
                    TofAvgMeanTotal[Path].Add(TofAvgMean[Path]);
                    GenesisZeroFlow._GenesisZeroFlow.SetAmpValuesToLog(this.MeterNumber, Path, $"{ GenesisZeroFlow._GenesisZeroFlow.GetAmpValuesToLog()[this.MeterNumber][Path]} {Math.Round(TofAvgMean[Path], 4).ToString("000.0000", this.Culture)}\n");
                    GenesisZeroFlow._GenesisZeroFlow.ClearTotalTimeOfFlightAverage(this.MeterNumber, Path);
                }
                #endregion
            }
            #endregion
            #region Write raw data to files
            if (this.GenerateLogFiles)
            {
                GenesisZeroFlow._GenesisZeroFlow.SetLoggingIndicatorAmpTest(this.MeterNumber, false);
                String temp = GenesisZeroFlow._GenesisZeroFlow.GetDataToLog()[this.MeterNumber];
                GenesisZeroFlow.Display.DebugMessage($"{this.PcbID}\tAPPLICATION:\t\t Write data to files at {this.MeterType}{this.MeterIndex}\n", this.Culture);
                Logging.WriteToFile(temp, GenesisZeroFlow._GenesisZeroFlow.GetLoggingPathAmplitudeTest()[this.MeterNumber]);
            }
            #endregion
            #region Write mean values to file
            String DateTime = System.DateTime.Now.ToString(Formats.LogFileDateTimeString, this.Culture);
            if (this.GenerateMeanFiles)
            {
                for(UInt16 Path = Constants.PATH0; Path < Constants.NumberOfPaths; Path++)
                    Logging.WriteToFile(GenesisZeroFlow._GenesisZeroFlow.GetAmpValuesToLog()[this.MeterNumber][Constants.PATH0], $@"..\ZeroflowCalibrationTool_MeanAmplitude_{this.MeterType}{this.MeterIndex}_PATH{Path + 1}_{TempPcbID}_{DateTime}.csv");
            }


            this.ClearData();
            #endregion
            #region Calculate optimal point
            Double[] DistanceLeft = new Double[Constants.NumberOfPaths];
            DistanceLeft = ArrayInit.Path((Double)0);
            Double[] DistanceRight = new Double[Constants.NumberOfPaths];
            DistanceRight = ArrayInit.Path((Double)0);
            Boolean[] CalculationFailed = new Boolean[Constants.NumberOfPaths];
            CalculationFailed = ArrayInit.Path(false);

            GenesisZeroFlow.Display.DebugMessage($"{this.PcbID}\tDATA CHANNEL:\t\t Start calculating optimal points at {this.MeterType}{this.MeterIndex}\n", this.Culture);
            Boolean OptPointFailed = false;
            for (UInt16 Path = Constants.PATH0; Path < Constants.NumberOfPaths; Path++)
            {
                CalculationFailed[Path] = CalculateOptimalPoint(Path, TofAvgMeanTotal[Path], out DistanceLeft[Path], out DistanceRight[Path], out OptimalPoint[Path]);
                if (Boolean.Equals(CalculationFailed[Path], false))
                    GenesisZeroFlow.Display.DebugMessage($"{this.PcbID}\tDATA CHANNEL:\t\t Optimal point calculation successful at {this.MeterType}{this.MeterIndex}, PATH{Path + 1}; Value = {OptimalPoint[Path].ToString(this.Culture)}\n", this.Culture);
                else
                {
                    GenesisZeroFlow.Display.DebugMessage($"{this.PcbID}\tDATA CHANNEL:\t\t Optimal point calculation failed at {this.MeterType}{this.MeterIndex}, PATH{Path + 1}\n", this.Culture);
                    OptPointFailed = true;
                }
                if (OptPointFailed || GenesisZeroFlow._GenesisZeroFlow.TempMonitoringFailed)
                    return false;
            }
            #endregion
            #region Check value
            GenesisZeroFlow.Display.DebugMessage($"{this.PcbID}\tDATA CHANNEL:\t\t Start optimal point values check at {this.MeterType}{this.MeterIndex}\n", this.Culture);
            Boolean OptimalPointOK = true;
            for(UInt16 Path = Constants.PATH0; Path < Constants.NumberOfPaths; Path++)
            {
                if(!this.CheckOptimalPoint(OptimalPoint[Path], out DebugMessage))
                    OptimalPointOK = false;
                GenesisZeroFlow.Display.DebugMessage($"{this.PcbID}\tDATA CHANNEL:\t\t {DebugMessage}, PATH{Path + 1}\n", this.Culture);
            }
            if ((!OptimalPointOK) || GenesisZeroFlow._GenesisZeroFlow.TempMonitoringFailed)
                return false;
            #endregion
            #region Check distance
            Boolean CheckDistOK = true;
            for (UInt16 Path = Constants.PATH0; Path < Constants.NumberOfPaths; Path++)
            {
                if (!this.CheckDistance(DistanceLeft[Path], DistanceRight[Path], out DebugMessage))
                    CheckDistOK = false;
                GenesisZeroFlow.Display.DebugMessage($"{this.PcbID}\tDATA CHANNEL:\t\t {DebugMessage}, PATH{Path +1}\n", this.Culture);
            }
            if (!CheckDistOK || GenesisZeroFlow._GenesisZeroFlow.TempMonitoringFailed)
                return false;
            #endregion
            #region Set first hit level percentage registers
            GenesisZeroFlow.Display.DebugMessage($"{this.PcbID}\tDATA CHANNEL:\t\t Start writing to percentage registers at {this.MeterType}{this.MeterIndex}\n", this.Culture);
            for (UInt16 Path = Constants.PATH0; Path < Constants.NumberOfPaths; Path++)
            {
                GenesisZeroFlow.Display.StatusLabel($"{GenesisZeroFlow.PredefinedMessages.WaitUntilRegisterWriteFinished(this.Culture)}");
                Ok = false;
                if (token.IsCancellationRequested || GenesisZeroFlow._GenesisZeroFlow.TempMonitoringFailed)
                    return false;
                
                String RegValue = String.Empty;
                switch (Path)
                {
                    case Constants.PATH0:   RegValue = Register.Genesisflow.FirstHitPercent1;
                        break;
                    case Constants.PATH1:   RegValue = Register.Genesisflow.FirstHitPercent2;
                        break;
                    case Constants.PATH2:   RegValue = Register.Genesisflow.FirstHitPercent3;
                        break;
                    default: RegValue = Register.Genesisflow.FirstHitPercent1;
                    break;
                };
                Ok = WriteRegister(GenesisMeter, "Percentage", RegValue, OptimalPoint[Path], OptimalPoint[Path].ToString(this.Culture));
                if (Boolean.Equals(Ok, false) || GenesisZeroFlow._GenesisZeroFlow.TempMonitoringFailed)
                    return false;
            }
            #endregion

            //here

            #region Set first hit update period to 10
            GenesisZeroFlow.Display.StatusLabel(GenesisZeroFlow.PredefinedMessages.WaitUntilRegisterWriteFinished(this.Culture));
            Ok = false;
            if (token.IsCancellationRequested || GenesisZeroFlow._GenesisZeroFlow.TempMonitoringFailed)
                return false;
            Ok = WriteRegister(GenesisMeter, "first hit update period", Register.Genesisflow.FirstHitUpdatePeriod, FirstHitUpdatePeriodeValueEnd, FirstHitUpdatePeriodeValueEnd.ToString(this.Culture));
            if (Boolean.Equals(Ok, false) || GenesisZeroFlow._GenesisZeroFlow.TempMonitoringFailed)
                return false;
            #endregion
            #region Set first hit shift to 4
            GenesisZeroFlow.Display.StatusLabel(GenesisZeroFlow.PredefinedMessages.WaitUntilRegisterWriteFinished(this.Culture));
            Ok = false;
            if (token.IsCancellationRequested || GenesisZeroFlow._GenesisZeroFlow.TempMonitoringFailed)
                return false;
            Ok = WriteRegister(GenesisMeter, "First hit shift", Register.Genesisflow.FirstHitShift, FirstHitShiftValueEnd, FirstHitShiftValueEnd.ToString(this.Culture));
            if (Boolean.Equals(Ok, false) || GenesisZeroFlow._GenesisZeroFlow.TempMonitoringFailed)
                return false;
            #endregion
            #endregion
            return Ok;
        }
        private Boolean PerformTempMonitoring(CancellationToken token)
        {
            #region Definitions and initializations
            Int32[] LinecounterFollowing = new Int32[Constants.NumberOfPaths];
            LinecounterFollowing = ArrayInit.Path((Int32)0);
            Boolean Ok = true;
            Int32 ActivityCheckInterval = GenesisZeroFlow._GenesisZeroFlow.GetAmplitudeActivityCheckInterval();
            Ok = this.ThermoActivityCheck(ref LinecounterFollowing, 0);
            #endregion
            #region Test sequence
            #region Check upper value

            for (UInt16 Path = 0; Path < Constants.NumberOfPaths; Path++)
            {
                Double temp = 0;

                try
                {
                    temp = GenesisZeroFlow._GenesisZeroFlow.GetTemperatures(this.MeterNumber, Path);
                    String Temperature = $"{Math.Round(temp, 2).ToString("00.00", this.Culture) }°C";

                    switch (this.MeterNumber)
                    {
                        case Constants.Meter1:
                            GenesisZeroFlow.Display.SetThermoLabel1($"{Temperature}");
                            break;
                        case Constants.Meter2:
                            GenesisZeroFlow.Display.SetThermoLabel2($"{Temperature}");
                            break;
                        default:
                            GenesisZeroFlow.Display.SetThermoLabel1($"n/a");

                            break;
                    }

                    #region Upper value
               
                    if (temp > this.UpperTempLimit)
                    {
                        GenesisZeroFlow.Display.DebugMessage($"{this.PcbID}\tDATA CHANNEL:\t\t TEMPERATURE MONITORING upper value check failed at {this.MeterType}{this.MeterIndex}; PATH{Path.ToString(this.Culture)}\t\n", this.Culture);
                        GenesisZeroFlow.Display.DebugMessage($"{this.PcbID}\tDATA CHANNEL:\t\t TEMPERATURE MONITORING upper value check values (actual/ limit) = {Temperature}/ {Math.Round(this.UpperTempLimit, 2).ToString("00.00", this.Culture)}°C\n", this.Culture);
                        GenesisZeroFlow._GenesisZeroFlow.TempMonitoringFailed = true;
                        return false;
                    }
                    GenesisZeroFlow.Display.DebugMessage($"{this.PcbID}\tDATA CHANNEL:\t\t TEMPERATURE MONITORING upper value successful at {this.MeterType}{this.MeterIndex}; PATH{Path.ToString(this.Culture)}; Value = {Temperature}\t\n", this.Culture);
                    #endregion
                    #region Lower value
                    if (temp < this.LowerTempLimit)
                    {
                        GenesisZeroFlow.Display.DebugMessage($"{this.PcbID}\tDATA CHANNEL:\t\t TEMPERATURE MONITORING lower value check failed at {this.MeterType}{this.MeterIndex}; PATH{Path.ToString(this.Culture)}\t\n", this.Culture);
                        GenesisZeroFlow.Display.DebugMessage($"{this.PcbID}\tDATA CHANNEL:\t\t TEMPERATURE MONITORING lower value check values (actual/ limit) = {Temperature}/ {Math.Round(this.LowerTempLimit, 2).ToString("00.00", this.Culture)}°C\n", this.Culture);
                        GenesisZeroFlow._GenesisZeroFlow.TempMonitoringFailed = true;
                        return false;
                    }
                    GenesisZeroFlow.Display.DebugMessage($"{this.PcbID}\tDATA CHANNEL:\t\t TEMPERATURE MONITORING lower value successful at {this.MeterType}{this.MeterIndex}; PATH{Path.ToString(this.Culture)}; Value = {Temperature}\n", this.Culture);
                    #endregion
                    #region Deviation check
                    // Lower value check
                    if (this.GetTempDeviationMin()[Path] == 0)
                        this.TempDeviationMin[Path] = temp;
                    else
                    {
                        if (temp < this.GetTempDeviationMin()[Path])
                            this.TempDeviationMin[Path] = temp;
                    }
                    // Upper value check
                    if (this.GetTempDeviationMax()[Path] == 0)
                        this.TempDeviationMax[Path] = temp;
                    else
                    {
                        if (temp > this.GetTempDeviationMax()[Path])
                            this.TempDeviationMax[Path] = temp;
                    }
                    // Deviation check

                    Double DeviationValue = this.GetTempDeviationMax()[Path] - this.GetTempDeviationMin()[Path];
                    String Deviation = $"{Math.Round(DeviationValue, 3).ToString("00.000", this.Culture)}°C";

                    if (DeviationValue > this.TempDeviationLimit)
                    {
                        GenesisZeroFlow._GenesisZeroFlow.TempMonitoringFailed = true;
                        GenesisZeroFlow.Display.DebugMessage($"{this.PcbID}\tDATA CHANNEL:\t\t TEMPERATURE MONITORING deviation check failed at {this.MeterType}{this.MeterIndex}; PATH{Path.ToString(this.Culture)}; Value = {Deviation}\n", this.Culture);
                        return false;
                    }
                    GenesisZeroFlow.Display.DebugMessage($"{this.PcbID}\tDATA CHANNEL:\t\t TEMPERATURE MONITORING deviation check successful at {this.MeterType}{this.MeterIndex}; PATH{Path.ToString(this.Culture)}; Value = {Deviation}\n", this.Culture);
                    #endregion
                }
                #endregion

                catch (Exception ex)
                {
                    GenesisZeroFlow._GenesisZeroFlow.TempMonitoringFailed = true;
                    ErrorLog.Log(LogErrReason.Exeption, "Amplitude.PerformTemperatureMonitoring() failed", $"0x{ex.HResult.ToString("X", this.Culture)}", String.Empty, this.Culture);
                    return false;
                }
                #endregion
            }
            return Ok;
        }
        private Boolean ActivityCheck(ref Int32[] lineCounterFollowing, Int32 seconds)
        {
            #region Definitions and initializations
            Boolean Ok = true;
            Boolean Error = false;
            #endregion
            #region Check activity
            for (UInt16 Path = Constants.PATH0; Path < Constants.NumberOfPaths; Path++)
            {
                if (!Int32.Equals(GenesisZeroFlow._GenesisZeroFlow.GetLineCounterAmplitudeTest()[this.MeterNumber][Path], 0))
                {
                    if (Int32.Equals(GenesisZeroFlow._GenesisZeroFlow.GetLineCounterAmplitudeTest()[this.MeterNumber][Path], lineCounterFollowing[Path]))
                        return false;
                    else
                        lineCounterFollowing[Path] = GenesisZeroFlow._GenesisZeroFlow.GetLineCounterAmplitudeTest()[this.MeterNumber][Path];

                }
                if ((seconds > 0) && (Boolean.Equals(GenesisZeroFlow._GenesisZeroFlow.GetLineCounterAmplitudeTest()[this.MeterNumber][Path], 0)))
                    return false;
            }
            #endregion
            #region Result
            Ok = !Error;
            #endregion

            return Ok;
        }
        private Boolean ThermoActivityCheck(ref Int32[] lineCounterFollowing, Int32 seconds)
        {
            #region Definitions and initializations
            Boolean Ok = true;
            Boolean Error = false;
            #endregion
            #region Check activity
            for (UInt16 Path = Constants.PATH0; Path < Constants.NumberOfPaths; Path++)
            {
                if (!Int32.Equals(GenesisZeroFlow._GenesisZeroFlow.GetLineCounterTemperatureTest()[this.MeterNumber][Path], 0))
                {
                    if (Int32.Equals(GenesisZeroFlow._GenesisZeroFlow.GetLineCounterTemperatureTest()[this.MeterNumber][Path], lineCounterFollowing[Path]))
                        return false;
                    else
                        lineCounterFollowing[Path] = GenesisZeroFlow._GenesisZeroFlow.GetLineCounterTemperatureTest()[this.MeterNumber][Path];
                }
                if ((seconds > 0) && (Boolean.Equals(GenesisZeroFlow._GenesisZeroFlow.GetLineCounterTemperatureTest()[this.MeterNumber][Path], 0)))
                    return false;
            }
            #endregion
            #region Result
            Ok = !Error;
            #endregion

            return Ok;
        }

        private Boolean WriteRegister(ZeroFlowGenesisMeter genesisMeter, String RegisterText, string reg, Int32 value,
            String ValueText)
        {
            return WriteRegister(genesisMeter, RegisterText, reg, value, ValueText, 4);
        }

        private Boolean WriteRegister(ZeroFlowGenesisMeter genesisMeter, String RegisterText, string reg, Int32 value, String ValueText, int RetrysLeft )
        {
            var Ok = false;

            GenesisZeroFlow.Display.DebugMessage($"{this.PcbID}\tCOMMAND CHANNEL:\t Writing {ValueText.ToString(this.Culture)} to '{RegisterText}'-register at {this.MeterType}{this.MeterIndex}\n", this.Culture);
            Ok = genesisMeter.WriteRegisterSafe(reg, value);
            if (Ok)
                GenesisZeroFlow.Display.DebugMessage($"{this.PcbID}\tCOMMAND CHANNEL:\t Writing {ValueText.ToString(this.Culture)} to '{RegisterText}'-register successful at {this.MeterType}{this.MeterIndex}\n", this.Culture);
            else
                GenesisZeroFlow.Display.DebugMessage($"{this.PcbID}\tCOMMAND CHANNEL:\t Writing {ValueText.ToString(this.Culture)} to '{RegisterText}'-register failed at {this.MeterType}{this.MeterIndex}\n", this.Culture);


            if (Ok == false && RetrysLeft > 0)
            {
                GenesisZeroFlow.Display.DebugMessage($"{this.PcbID}\tCOMMAND CHANNEL:\t Writing {ValueText.ToString(this.Culture)} to '{RegisterText}'-register retry at {this.MeterType}{this.MeterIndex}\n", this.Culture);
                return WriteRegister(genesisMeter, RegisterText, reg, value, ValueText, RetrysLeft - 1);
            }
            return Ok;
        }
        private Boolean CalculateOptimalPoint(UInt16 path, List<Double> TofAvg, out Double left, out Double right, out Int32 xAtOptimalPoint)
        {
            List<Double> ValuesLeft = new List<Double>();
            List<Double> ValuesRight = new List<Double>();
            List<Double> MinDistance = new List<Double>();
            xAtOptimalPoint = 0;
            Boolean Error = true;
            left = 0;
            right = 0;

            ValuesLeft = this.CalculateNearestDistanceLeft(TofAvg, out left);
            ValuesRight = this.CalculateNearestDistanceRight(TofAvg, out right);

            for (UInt16 i = 0; i < ValuesLeft.Count(); i++)
            {
                Double temp1 = ValuesLeft.ElementAt(i);
                Double temp2 = ValuesRight.ElementAt(i);
                Misc.WaitNMilliseconds(10);
                MinDistance.Add(Math.Min(temp1, temp2));
            }

            //String mindistance = $"mindistance: PATH{path.ToString(GlobalCulture)}\n";
            //for (Int16 i = 0; i < MinDistance.Count(); i++)
            //{
            //    Double temp = MinDistance.ElementAt(i);
            //    Misc.WaitNMilliseconds(10);
            //    mindistance = $"{mindistance}{temp.ToString(GlobalCulture)}\n";
            //}
            //Logging.WriteToFile(mindistance, @"..\mindistance_PATH"+ path.ToString() + ".txt");

            Double Maximum = 0;

            for (Int16 i = 0; i < MinDistance.Count(); i++)
            {
                if ((!Int16.Equals(i, 0)) && (!Int16.Equals(i, (Int16)(TofAvg.Count() - 1))))
                {
                    if (MinDistance.ElementAt(i) > Maximum)
                    {
                        Maximum = MinDistance.ElementAt(i);
                        xAtOptimalPoint = (Int32)i + this.FirstHitLevelPercMin;
                        Error = false;
                    }
                    /*
                    if ((ValuesLeft.ElementAt(i - 1) > ValuesRight.ElementAt(i - 1)) && (ValuesRight.ElementAt(i + 1) > ValuesLeft.ElementAt(i + 1)))
                    {
                        xAtOptimalPoint = i + this.FirstHitLevelPercMin;
                        Error = false;
                    }
                    */
                }
            }

            return Error;
        }
        private List<Double> CalculateNearestDistanceLeft(List<Double> TofAvg, out Double left)
        {
            List<Double> Distance = new List<Double>();
            Double NearestDistance = 0;
            Boolean Detected = false;
            left = 0;

            for (Int32 Percentage = this.FirstHitLevelPercMin; Percentage <= (this.FirstHitLevelPercMax); Percentage++)
            {
                Detected = false;
                for (Int32 PercentageFollowing = Percentage; PercentageFollowing <= this.FirstHitLevelPercMax; PercentageFollowing++)
                {
                    if ((TofAvg.ElementAt(PercentageFollowing - this.FirstHitLevelPercMin) - TofAvg.ElementAt(Percentage - FirstHitLevelPercMin)) > this.TriggerValue)
                    {
                        NearestDistance = PercentageFollowing - Percentage;
                        Detected = true;
                        break;
                    }
                }
                if (!Detected)
                    NearestDistance = this.FirstHitLevelPercMax - Percentage;

                Distance.Add(NearestDistance);
            }

            for (Int16 i = 0; i < (Int16)Distance.Count(); i++)
            {
                if (Distance.ElementAt(i) >= left)
                {
                    left = Distance.ElementAt(i);
                }
            }
            return Distance;
        }
        private List<Double> CalculateNearestDistanceRight(List<Double> TofAvg, out Double right)
        {
            List<Double> Distance = new List<Double>();
            Double NearestDistance = 0;
            Boolean Detected = false;
            right = 0;

            for (Int32 Percentage = this.FirstHitLevelPercMax; Percentage >= (this.FirstHitLevelPercMin); Percentage--)
            {
                Detected = false;

                for (Int32 ProportionFollowing = Percentage; ProportionFollowing >= this.FirstHitLevelPercMin; ProportionFollowing--)
                {
                    if ((TofAvg.ElementAt(ProportionFollowing - FirstHitLevelPercMin)) - (TofAvg.ElementAt(Percentage - FirstHitLevelPercMin)) < -this.TriggerValue)
                    {
                        NearestDistance = Percentage - ProportionFollowing;
                        Detected = true;
                        break;
                    }
                }

                if (!Detected)
                    NearestDistance = Percentage - this.FirstHitLevelPercMin;

                Distance.Add(NearestDistance);
            }


            Distance.Reverse();

            for (Int16 i = 0; i < Distance.Count(); i++)
            {
                if (Distance.ElementAt(i) >= right)
                {
                    right = Distance.ElementAt(i);
                }
            }
            return Distance;
        }
        private Boolean CheckOptimalPoint(Int32 optimalPoint, out String debugMessage)
        {
            Boolean Ok = true;
            debugMessage = $"Optimal point check successful at {this.MeterType}{this.MeterIndex}";

            //if (optimalPoint == this.ErrorValue)
            //{
            //    debugMessage = $"Optimal point check failed at METER{MeterIndex}";
            //    Ok = false;
            //    return Ok;
            //}

            if (optimalPoint > this.OptimumMaxValue)
            {
                debugMessage = $"Optimal point maximum check failed at {this.MeterType}{this.MeterIndex}";
                Ok = false;
                return Ok;
            }

            if (optimalPoint < this.OptimumMinValue)
            {
                debugMessage = $"Optimal point minimum check failed at {this.MeterType}{this.MeterIndex}";
                Ok = false;
                return Ok;
            }

            return Ok;
        }
        private Boolean CheckDistance(Double left, Double right, out String debugMessage)
        {
            Boolean Ok = true;
            debugMessage = $"Distance check successful at {this.MeterType}{this.MeterIndex}";

            if (left < this.OptimumMinDistance)
            {
                Ok = false;
                debugMessage = $"Distance check failed at {this.MeterType}{this.MeterIndex}";
                return Ok;
            }

            if (right < this.OptimumMinDistance)
            {
                Ok = false;
                debugMessage = $"Distance check failed at {this.MeterType}{this.MeterIndex}";
                return Ok;
            }

            return Ok;
        }
        private void LeaveSequence()
        {
            GenesisZeroFlow._GenesisZeroFlow.SetTofIndicatorAmplitudeTest(this.MeterNumber, false);
            
            #region Write raw data to files
            if (this.GenerateLogFiles)
            {    
                GenesisZeroFlow._GenesisZeroFlow.SetLoggingIndicatorAmpTest(this.MeterNumber, false);
                String temp = GenesisZeroFlow._GenesisZeroFlow.GetDataToLog()[this.MeterNumber];
                GenesisZeroFlow.Display.DebugMessage($"{this.PcbID}\tAPPLICATION:\t\t Write data to files at {this.MeterType}{this.MeterIndex}\n", this.Culture);
                Logging.WriteToFile(temp, GenesisZeroFlow._GenesisZeroFlow.GetLoggingPathAmplitudeTest()[this.MeterNumber]);
            }
            #endregion

            this.ClearData();
        }
        private void ClearData()
        {
            try
            {
                for (UInt16 Path = Constants.PATH0; Path < Constants.NumberOfPaths; Path++)
                {
                    GenesisZeroFlow.Display.EraseAmplitudeData(this.MeterNumber, Path);
                    GenesisZeroFlow._GenesisZeroFlow.ClearTotalTimeOfFlightAverage(this.MeterNumber, Path);
                    GenesisZeroFlow._GenesisZeroFlow.SetDataToLog(this.MeterNumber, String.Empty);
                }
            }
            catch(Exception ex)
            {
                ErrorLog.Log(LogErrReason.Exeption, "Amplitude.ClearData() failed", $"0x{ex.HResult.ToString("X", this.Culture)}", String.Empty, this.Culture);
            }
        }

        public void Initialize(String pcbID, String meterType, Int32 optimumMinValue, Int32 optimumMaxValue, Int32 optimumMinDistance, Int32 firstHitLevelPropMin, Int32 firstHitLevelPropMax, Int32 tofRecordingTime, Double triggerValue, Double upperTempLimit, Double lowerTempLimit, Double tempDeviationLimit, Boolean generateMeanFiles, Boolean generateLogFiles)
        {
            this.TofRecordingTime = tofRecordingTime;
            this.FirstHitLevelPercMin = firstHitLevelPropMin;
            this.FirstHitLevelPercMax = firstHitLevelPropMax;
            this.TriggerValue = triggerValue;
            this.OptimumMinValue = optimumMinValue;
            this.OptimumMaxValue = optimumMaxValue;
            this.OptimumMinDistance = optimumMinDistance;
            this.UpperTempLimit = upperTempLimit;
            this.LowerTempLimit = lowerTempLimit;
            this.TempDeviationLimit = tempDeviationLimit;
            this.TempDeviationMin = new Double[Constants.NumberOfPaths];
            this.TempDeviationMax = new Double[Constants.NumberOfPaths];
            this.TempDeviationMin = ArrayInit.Path((Double)0);
            this.TempDeviationMax = ArrayInit.Path((Double)0);
            this.MeterType = meterType;
            this.PcbID = pcbID;
            this.GenerateMeanFiles = generateMeanFiles;
            this.GenerateLogFiles = generateLogFiles;
        }
        public UInt16 MeterNumber { get; private set; }
        public String MeterIndex { get; private set; }
        public String MeterType { get; private set; }
        public String PcbID { get; private set; }
        public CultureInfo Culture { get; private set; }
        private Int32 FirstHitLevelPercMin { get; set; }
        private Int32 FirstHitLevelPercMax { get; set; }
        private Int32 TofRecordingTime { get; set; }
        private Double TriggerValue { get; set; }
        private Int32 OptimumMinValue { get; set; }
        private Int32 OptimumMaxValue { get; set; }
        private Double OptimumMinDistance { get; set; }
        private Double[] TempDeviationMin { get; set; }
        private Double[] GetTempDeviationMin()
        {
            return (Double[])TempDeviationMin.Clone();
        }
        private Double[] TempDeviationMax { get; set; }
        private Double[] GetTempDeviationMax()
        {
            return (Double[])TempDeviationMax.Clone();
        }
        private Double UpperTempLimit { get; set; }
        private Double LowerTempLimit { get; set; }
        private Double TempDeviationLimit { get; set; }
        private Boolean GenerateMeanFiles { get; set; }
        private Boolean GenerateLogFiles { get; set; }

    }
}