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.Genesis.Registers;
using Xylem.Common.Hardware.WaterMeter.WaterMeterCore;

namespace GenesisZeroFlow
{
    public static class ZeroOffsetSequences
    {
        public static Boolean[] Total(MeterBatch globalMeterBatch, MeterBatch thermoMeterBatch, Boolean[] allEnable, Int16 settlingTime, Int16 lowerVoltLimit, Int16 upperVoltLimit, Double offsetTimeLimit, Int32 numberOfLines, Double upperTempLimit, Double lowerTempLimit, Double tempDeviationLimit, out Boolean aborted, CultureInfo culture)
        {
            #region Definitions and initializations
            Boolean[] MeterEnable = Misc.Subarray(allEnable, 0, Constants.NumberOfMeters);
            Boolean[] ThermoEnable = Misc.Subarray(allEnable, Constants.NumberOfMeters, Constants.NumberOfThermometers);

            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];

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

            Boolean GenerateLogFiles = GenesisZeroFlow._GenesisZeroFlow.GetCBOffsetTestLogFiles();
            Int32 NextDelayTime = 0;
            aborted = false;

            List<ZeroFlowOffsetTest> ListZeroFlowOffsetMeter = new List<ZeroFlowOffsetTest>();
            List<ZeroFlowOffsetTest> ThermoListZeroFlowOffsetTest = new List<ZeroFlowOffsetTest>();
            GenesisZeroFlow._GenesisZeroFlow.TempMonitoringFailed = false;

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

                if (currentMeter != null)
                    ListZeroFlowOffsetMeter.Add(new ZeroFlowOffsetTest(Meter, culture, currentMeter));
                else
                    ListZeroFlowOffsetMeter.Add(new ZeroFlowOffsetTest(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)
                    ThermoListZeroFlowOffsetTest.Add(new ZeroFlowOffsetTest(Thermo, culture, currentMeter));
                else
                    ThermoListZeroFlowOffsetTest.Add(new ZeroFlowOffsetTest(Thermo, culture));
            }
            #region Initialize
            foreach (var zft in ListZeroFlowOffsetMeter)
            {
                zft.Initialize(GenesisZeroFlow._GenesisZeroFlow.PcbID[zft.MeterNumber], Constants.Meter, lowerVoltLimit, upperVoltLimit, offsetTimeLimit, numberOfLines, 0, 0, 0, GenerateLogFiles);
                zft.MyTask = new Task<Boolean>(() => { return true; });
            }
            foreach (var zft in ThermoListZeroFlowOffsetTest)
            {
                zft.Initialize(GenesisZeroFlow._GenesisZeroFlow.ThermoID[zft.MeterNumber], Constants.Thermo, 0, 0, 0, numberOfLines, upperTempLimit, lowerTempLimit, tempDeviationLimit, GenerateLogFiles);
                zft.MyTask = new Task<Boolean>(() => { return true; });
            }
            #endregion
            #endregion
            #region Perform test
            CancellationTokenSource cancellationTokenSource = new CancellationTokenSource();
            CancellationToken token = cancellationTokenSource.Token;
            // Zeroflow Offset test
            foreach (var zft in ListZeroFlowOffsetMeter)
                zft.Meter(MeterEnable[zft.MeterNumber], ref MeterTaskStarted[zft.MeterNumber], ref MeterSequenceFailed[zft.MeterNumber], ref NextDelayTime, settlingTime, token);
            // Temperature test
            foreach (var zft in ThermoListZeroFlowOffsetTest)
            {
                if (ThermoEnable[zft.MeterNumber])
                {
                    GenesisZeroFlow._GenesisZeroFlow.SetIndicatorTemperatureActivityCheck(zft.MeterNumber, true);
                    GenesisZeroFlow.Display.DebugMessage($"{zft.PcbID}\tAPPLICATION:\t\t TEMPERATURE MONITORING started at {zft.MeterType}{zft.MeterIndex}\n", zft.Culture);
                    GenesisZeroFlow._GenesisZeroFlow.SetLoggingIndicatorThermoMonitoring(zft.MeterNumber, true);
                }
                Misc.WaitNMilliseconds(300);
                zft.Thermometer(ThermoEnable[zft.MeterNumber], ref ThermoTaskStarted[zft.MeterNumber], ref ThermoSequenceFailed[zft.MeterNumber], ref NextDelayTime, token);
            }
            #endregion
            #region Wait for tasks
            while (!CheckArray(MeterTaskCompleted.Concat(ThermoTaskCompleted).ToArray()))
            {
                #region Temperature check
                foreach (var zft in ThermoListZeroFlowOffsetTest)
                {
                    if (CheckArray(MeterTaskCompleted) && (ThermoEnable[zft.MeterNumber])) // If all METERs finished, not THERMOMETERs 
                    {
                        GenesisZeroFlow._GenesisZeroFlow.SetLoggingIndicatorThermoMonitoring(zft.MeterNumber, false);
                        GenesisZeroFlow.Display.DebugMessage($"{zft.PcbID}\tAPPLICATION:\t\t TEMPERATURE MONITORING stopped at {zft.MeterType}{zft.MeterIndex}\n", zft.Culture);
                    }
                }
                #endregion
                #region Abort check
                if (GenesisZeroFlow._GenesisZeroFlow.AbortIndicator)
                {
                    cancellationTokenSource.Cancel();
                    aborted = true;
                }
                #endregion
                #region Check result
                Misc.WaitNSeconds(1);
                #region Meter
                foreach (var zft in ListZeroFlowOffsetMeter)
                {
                    MeterTaskCompleted[zft.MeterNumber] = TaskOperations.WaitFor(MeterTaskStarted[zft.MeterNumber], zft.MyTask);
                    // Stop temperature check
                    var tmp = !MeterTaskCompleted[zft.MeterNumber];
                    GenesisZeroFlow._GenesisZeroFlow.SetIndicatorTemperatureActivityCheck(zft.MeterNumber, tmp);
                }
                foreach (var zft in ListZeroFlowOffsetMeter)
                    MeterSequenceFailed[zft.MeterNumber] = TaskOperations.GetResult(MeterTaskStarted[zft.MeterNumber], zft.MyTask);
                for (UInt16 Meter = Constants.Meter1; Meter < Constants.NumberOfMeters; Meter++)
                    MeterSequenceOk[Meter] = !MeterSequenceFailed[Meter];
                #endregion
                #region Thermometer
                foreach (var zft in ThermoListZeroFlowOffsetTest)
                {
                    ThermoTaskCompleted[zft.MeterNumber] = TaskOperations.WaitFor(ThermoTaskStarted[zft.MeterNumber], zft.MyTask);
                    // Stop temperature check
                    GenesisZeroFlow._GenesisZeroFlow.SetIndicatorTemperatureActivityCheck(zft.MeterNumber, !MeterTaskCompleted[zft.MeterNumber]);
                }
                foreach (var zft in ThermoListZeroFlowOffsetTest)
                    ThermoSequenceFailed[zft.MeterNumber] = TaskOperations.GetResult(ThermoTaskStarted[zft.MeterNumber], zft.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 zft in ListZeroFlowOffsetMeter)
                MeterSequenceFailed[zft.MeterNumber] = TaskOperations.GetResult(MeterTaskStarted[zft.MeterNumber], zft.MyTask);
            foreach (var zft in ThermoListZeroFlowOffsetTest)
                ThermoSequenceFailed[zft.MeterNumber] = TaskOperations.GetResult(ThermoTaskStarted[zft.MeterNumber], zft.MyTask);
            #endregion
            #region SequenceOk/ ThermoSequenceOk
            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 zft in ListZeroFlowOffsetMeter)
                TaskOperations.CheckAndDispose(zft.MyTask);
            foreach (var zft in ThermoListZeroFlowOffsetTest)
                TaskOperations.CheckAndDispose(zft.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 ZeroFlowOffsetTest
    {
        private readonly ZeroFlowGenesisMeter GenesisMeter;
        public Task<Boolean> MyTask { get; internal set; }
        public ZeroFlowOffsetTest(UInt16 meterNumber, CultureInfo culture)
        {
            this.Culture = culture;
            this.MeterNumber = meterNumber;
            this.MeterIndex = (meterNumber + 1).ToString(culture);
        }
        public ZeroFlowOffsetTest(UInt16 meterNumber, CultureInfo culture, IMeter meter)
        {
            if (meter is ZeroFlowGenesisMeter)
            {
                GenesisMeter = meter as ZeroFlowGenesisMeter;
            }

            this.Culture = culture;
            this.MeterNumber = meterNumber;
            this.MeterIndex = (meterNumber + 1).ToString(culture);
        }
        internal void Meter(Boolean enable, ref Boolean taskStarted, ref Boolean sequenceFailed, ref Int32 nextDelayTime, Int16 settlingTime, CancellationToken token)
        {
            #region Avoid CA1062
            if (Task.Equals(MyTask, null))
            {
                sequenceFailed = true;
                taskStarted = false;
                return;
            }
            #endregion
            #region Definitions and initializations
            Int32 DelayTime = 0;
            const Int32 DeltaDelay = 5;
            DialogResult AskForActionsTask = DialogResult.None;
            DialogResult AskForActionsFinalization = DialogResult.None;
            var _sequenceFailed = sequenceFailed;
            Int32 temp = DelayTime;
            Boolean Ok = false;
            #endregion
            #region Everything else
            if ((enable) && (!Task.Equals(MyTask.Status, TaskStatus.Running)))
            {
                #region Start delay
                DelayTime = nextDelayTime;
                nextDelayTime = nextDelayTime + DeltaDelay;
                taskStarted = true;
                Misc.WaitNSeconds(temp);
                #endregion
                #region Run task
                MyTask = Task.Run(() =>
                {
                    while ((DialogResult.Equals(AskForActionsTask, DialogResult.Retry)) || (DialogResult.Equals(AskForActionsTask, DialogResult.None)))
                    {
                        #region Abort
                        if (token.IsCancellationRequested)
                        {
                            GenesisZeroFlow.Display.DebugMessage($"{this.PcbID}\tAPPLICATION:\t\t ZEROFLOW OFFSET TEST stopped at {this.MeterType}{this.MeterIndex}\n", this.Culture);
                            GenesisZeroFlow.Display.AbortButtonEnabled(false);
                            return true; // sequence failed
                        }
                        else
                            GenesisZeroFlow.Display.AbortButtonEnabled(true);
                        #endregion              
                        #region Start logging
                        GenesisZeroFlow.Display.DebugMessage($"{this.PcbID}\tAPPLICATION:\t\t ZEROFLOW OFFSET TEST started at {this.MeterType}{this.MeterIndex}\n", this.Culture);
                        this.StartTest();
                        #endregion
                        #region Wait for settling time (60s)
                        for (Int16 Time = settlingTime; Time >= 0; Time--)
                        {
                            if ((token.IsCancellationRequested) || (GenesisZeroFlow._GenesisZeroFlow.TempMonitoringFailed))
                            {
                                GenesisZeroFlow.Display.DebugMessage($"{this.PcbID}\tAPPLICATION:\t\t ZEROFLOW OFFSET TEST stopped at {this.MeterType}{this.MeterIndex}\n", this.Culture);
                                this.LeaveSequence();
                                return true; // sequence failed
                            }
                            GenesisZeroFlow.Display.StatusLabel($"{GenesisZeroFlow.PredefinedMessages.ZeroflowOffsetWaitForSettling(this.Culture)}{Time.ToString(this.Culture)}");
                            Misc.WaitNSeconds(1);
                        }
                        #endregion
                        #region Start collecting data for calculation
                        GenesisZeroFlow._GenesisZeroFlow.SetCalculationIndicatorZeroFlowTest(true, this.MeterNumber);
                        #endregion
                        #region Activity check
                        Boolean ActivityOk = true;
                        if (enable && ActivityOk && ((DialogResult.Equals(AskForActionsTask, DialogResult.None)) || (DialogResult.Equals(AskForActionsTask, DialogResult.Retry))))
                            ActivityOk = ActivityCheck(token);
                        GenesisZeroFlow._GenesisZeroFlow.TempMonitoringFailed = !ActivityOk;
                        #endregion
                        #region Stop logging and stop calculating ==> is also done by the 'MainloopMeterX'-Functions
                        GenesisZeroFlow._GenesisZeroFlow.SetCalculationIndicatorZeroFlowTest(false, this.MeterNumber);
                        GenesisZeroFlow._GenesisZeroFlow.SetLoggingIndicatorZeroFlowTest(false, this.MeterNumber);
                        GenesisZeroFlow.Display.DebugMessage($"{this.PcbID}\tAPPLICATION:\t\t Stop logging at {this.MeterType}{this.MeterIndex}\n", this.Culture);
                        #endregion
                        #region Write raw data to files
                        String LogData = 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(LogData, GenesisZeroFlow._GenesisZeroFlow.GetLoggingPathZeroFlowTest()[this.MeterNumber]);
                        GenesisZeroFlow._GenesisZeroFlow.SetDataToLog(this.MeterNumber, String.Empty);

                        if (token.IsCancellationRequested || GenesisZeroFlow._GenesisZeroFlow.TempMonitoringFailed)
                        {
                            GenesisZeroFlow.Display.DebugMessage($"{this.PcbID}\tAPPLICATION:\t\t ZEROFLOW OFFSET TEST stopped at {this.MeterType}{this.MeterIndex}\n", this.Culture);
                            GenesisZeroFlow.Display.AbortButtonEnabled(false);
                            return true; // sequence failed
                        }
                        #endregion
                        #region Summary
                        if (token.IsCancellationRequested || GenesisZeroFlow._GenesisZeroFlow.TempMonitoringFailed)
                        {
                            GenesisZeroFlow.Display.DebugMessage($"{this.PcbID}\tAPPLICATION:\t\t ZEROFLOW OFFSET TEST stopped at {this.MeterType}{this.MeterIndex}\n", this.Culture);
                            GenesisZeroFlow.Display.AbortButtonEnabled(false);
                            return true; // sequence failed
                        }

                        if (ActivityOk)
                        {
                            while ((DialogResult.Equals(AskForActionsFinalization, DialogResult.Retry)) || (DialogResult.Equals(AskForActionsFinalization, DialogResult.None)))
                            {
                                #region Abort
                                if (token.IsCancellationRequested || GenesisZeroFlow._GenesisZeroFlow.TempMonitoringFailed)
                                {
                                    GenesisZeroFlow._GenesisZeroFlow.GenerateReturnNote(this.MeterIndex, this.PcbID, GenesisZeroFlow.PredefinedMessages.ZeroflowOffsetTestStopped(this.Culture), GenesisZeroFlow._GenesisZeroFlow.GetLoggingFromTextBox(), this.Culture);
                                    GenesisZeroFlow.Display.DebugMessage($"{this.PcbID}\tAPPLICATION:\t\t ZEROFLOW OFFSET TEST stopped at {this.MeterType}{this.MeterIndex}\n", this.Culture);
                                    GenesisZeroFlow.Display.AbortButtonEnabled(false);
                                    return true; // sequence failed
                                }
                                else
                                    GenesisZeroFlow.Display.AbortButtonEnabled(true);
                                #endregion
                                #region Finalize test
                                GenesisZeroFlow.Display.DebugMessage($"{this.PcbID}\tAPPLICATION:\t\t Finalize ZEROFLOW OFFSET TEST at {this.MeterType}{this.MeterIndex}\n", this.Culture);
                                Ok = FinalizeTest(GenesisZeroFlow._GenesisZeroFlow.GetAmplitudeValuesUp(this.MeterNumber), GenesisZeroFlow._GenesisZeroFlow.GetAmplitudeValuesDown(this.MeterNumber), GenesisZeroFlow._GenesisZeroFlow.GetDeltaTimeOfFlightAverage(this.MeterNumber), GenesisZeroFlow._GenesisZeroFlow.GetBadDataCounter(this.MeterNumber), token, GenesisZeroFlow._GenesisZeroFlow.GetDeltaTimeOfFlightAverageRaw(this.MeterNumber));

                                if (Boolean.Equals(Ok, true))
                                {
                                    AskForActionsFinalization = DialogResult.OK;
                                    _sequenceFailed = false;//?
                                }
                                else
                                {
                                    // AskForActionsFinalization = this.AskHowToProceedSequence("ZEROFLOW OFFSET TEST");
                                    GenesisZeroFlow._GenesisZeroFlow.GenerateReturnNote(this.MeterIndex, this.PcbID, GenesisZeroFlow.PredefinedMessages.ZeroflowOffsetTestFailed(this.Culture), GenesisZeroFlow._GenesisZeroFlow.GetLoggingFromTextBox(), this.Culture);
                                    AskForActionsFinalization = DialogResult.Cancel;
                                    _sequenceFailed = true; //?
                                }
                                #endregion
                            }
                        }
                        else
                            Ok = false;

                        if (Ok)
                        {
                            GenesisZeroFlow.Display.DebugMessage($"{this.PcbID}\tAPPLICATION:\t\t ZEROFLOW OFFSET TEST successful at {this.MeterType}{this.MeterIndex}\n", this.Culture);
                            GenesisZeroFlow.Display.DebugMessage($"{Constants.TwentySpaces}\t{Debugmessages.Line}", this.Culture);
                            _sequenceFailed = false;
                            AskForActionsTask = DialogResult.OK;
                        }
                        else
                        {
                            GenesisZeroFlow.Display.DebugMessage($"{this.PcbID}\tAPPLICATION:\t\t ZEROFLOW OFFSET TEST failed at {this.MeterType}{this.MeterIndex}\n", this.Culture);
                            GenesisZeroFlow.Display.DebugMessage($"{Constants.TwentySpaces}\t{Debugmessages.Line}", this.Culture);
                            GenesisZeroFlow.Display.AbortButtonEnabled(false);
                            GenesisZeroFlow._GenesisZeroFlow.GenerateReturnNote(this.MeterIndex, this.PcbID, GenesisZeroFlow.PredefinedMessages.ZeroflowOffsetTestFailed(this.Culture), GenesisZeroFlow._GenesisZeroFlow.GetLoggingFromTextBox(), this.Culture);
                            _sequenceFailed = true;
                            AskForActionsTask = DialogResult.Cancel;
                        }
                        #endregion
                    }
                    return _sequenceFailed;
                });
                #endregion
            }
            #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 Interval = 4;
            var _sequenceFailed = sequenceFailed;
            Boolean Ok = true;
            #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
                #region Run task
                MyTask = Task.Run(() =>
                {
                    Boolean LoggingIndicator = GenesisZeroFlow._GenesisZeroFlow.GetLoggingIndicatorThermoMonitoring()[this.MeterNumber];
                    Int32 BadCycles = 0;
                    const Int32 AllowedBadCycles = 1;

                    Boolean StatusOk = true;

                    while (LoggingIndicator && (StatusOk))
                    {
                        
                        #region Abort
                        if (!token.IsCancellationRequested)
                            GenesisZeroFlow.Display.AbortButtonEnabled(true);
                        #endregion
                        #region Testprocedure
                        Ok = PerformTempMonitoring(token);
      

                        Misc.WaitNSeconds(Interval);

 
                        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)
                        {
                            BadCycles = 0;
                            GenesisZeroFlow.Display.DebugMessage($"{this.PcbID}\tAPPLICATION:\t\t TEMPERATURE MONITORING successful at {this.MeterType}{this.MeterIndex}\n", this.Culture);
                            GenesisZeroFlow.Display.DebugMessage($"{Constants.TwentySpaces}\t{Debugmessages.Line}", this.Culture);
                            _sequenceFailed = false;
                        }
                        else
                        {
                            BadCycles++;
                            if (BadCycles > AllowedBadCycles)
                                StatusOk = false;
                            GenesisZeroFlow.Display.DebugMessage($"{this.PcbID}\tAPPLICATION:\t\t TEMPERATURE MONITORING failed at {this.MeterType}{this.MeterIndex}\n", this.Culture);
                            _sequenceFailed = true;
                        }
                        #endregion
                        LoggingIndicator = GenesisZeroFlow._GenesisZeroFlow.GetLoggingIndicatorThermoMonitoring()[this.MeterNumber];
                    }
                    return _sequenceFailed;

                }, token);
                #endregion
            }
            #endregion
        }
        private Boolean StartTest()
        {
            #region Definitions and initializations
            Boolean Ok = false;
            String time = DateTime.Now.ToString(Formats.LogFileDateTimeString, this.Culture);
            String TempPcbID = this.PcbID.Replace(" ", String.Empty);
            #endregion
            #region Generate Header
            String Header = $"Genesis ZeroFlowOffsetTest {this.MeterType}{this.MeterIndex}; PCB ID = {TempPcbID}; Date = {time}; Operator = {Environment.UserName}\n";
            #endregion
            #region Start logging
            this.ClearData();
            GenesisZeroFlow._GenesisZeroFlow.SetLoggingPathZeroFlowTest(this.MeterNumber, $"{DataLogging.DefaultPath}ZeroflowOffsetTest_RawData_{TempPcbID}_{time}.txt");
            GenesisZeroFlow._GenesisZeroFlow.SetLoggingIndicatorZeroFlowTest(true, this.MeterNumber); // Start logging data
            GenesisZeroFlow.Display.DebugMessage($"{this.PcbID}\tDATA CHANNEL:\t\t Start logging at {this.MeterType}{this.MeterIndex}\n", this.Culture);
            #endregion

            return Ok;
        }


        private Boolean FinalizeTest(List<Double>[] amplitudeValuesUp, List<Double>[] amplitudeValuesDown, List<Double>[] deltaTimeOfFlightAverage, Int32[] badData, CancellationToken token, List<Int32>[] deltaTimeOfFlightAverageRAW)
        {

            #region Avoid CA1062
            if ((amplitudeValuesUp == null) || (amplitudeValuesDown == null) || (badData == null) || (deltaTimeOfFlightAverage == null) || GenesisZeroFlow._GenesisZeroFlow.TempMonitoringFailed)
                return false;
            #endregion
            #region Definitions and initializations
          
            Boolean Ok = false;
            Double[] amplitudeValuesMeanUp = new Double[Constants.NumberOfPaths];
            Double[] amplitudeValuesMeanDown = new Double[Constants.NumberOfPaths];
            Double[] DeltaTimeOfFlightAverage = new Double[Constants.NumberOfPaths];
            amplitudeValuesMeanUp = ArrayInit.Path((Double)0);
            amplitudeValuesMeanDown = ArrayInit.Path((Double)0);
            DeltaTimeOfFlightAverage = ArrayInit.Path((Double)0);
            #endregion
            #region Calculating mean values
            GenesisZeroFlow.Display.DebugMessage($"{this.PcbID}\tAPPLICATION:\t\t Calculating mean values at {this.MeterType}{this.MeterIndex}\n", this.Culture);
            for (UInt16 Path = Constants.PATH0; Path < Constants.NumberOfPaths; Path++)
            {
                amplitudeValuesMeanUp[Path] = amplitudeValuesUp[Path].Mean();
                amplitudeValuesMeanDown[Path] = amplitudeValuesDown[Path].Mean();
                DeltaTimeOfFlightAverage[Path] = deltaTimeOfFlightAverage[Path].Mean();

                if((amplitudeValuesMeanUp[Path] == 0)|| (amplitudeValuesMeanDown[Path] == 0)||(DeltaTimeOfFlightAverage[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)}\n", this.Culture);
                    this.ClearData();
                    return false;
                }
            }
            #endregion
            #region Display calculated values
            for (UInt16 Path = Constants.PATH0; Path < Constants.NumberOfPaths; Path++)
                GenesisZeroFlow.Display.DebugMessage($"{this.PcbID}\tDATA CHANNEL:\t\t Bad data at {this.MeterType}{this.MeterIndex}, PATH{(Path + 1).ToString(this.Culture)}:  {badData[Path].ToString(this.Culture)}\n", this.Culture);

            for (UInt16 Path = Constants.PATH0; Path < Constants.NumberOfPaths; Path++)
                GenesisZeroFlow.Display.DebugMessage($"{this.PcbID}\tDATA CHANNEL:\t\t Average positive amplitude value at {this.MeterType}{this.MeterIndex}, PATH{(Path + 1).ToString(this.Culture)}:  {Math.Round(amplitudeValuesMeanUp[Path], 2).ToString("000.00", this.Culture)}mV\n", this.Culture);

            for (UInt16 Path = Constants.PATH0; Path < Constants.NumberOfPaths; Path++)
                GenesisZeroFlow.Display.DebugMessage($"{this.PcbID}\tDATA CHANNEL:\t\t Average negative amplitude value at {this.MeterType}{this.MeterIndex}, PATH{(Path + 1).ToString(this.Culture)}:  {Math.Round(amplitudeValuesMeanDown[Path], 2).ToString("000.00", this.Culture)}mV\n", this.Culture);

            for (UInt16 Path = Constants.PATH0; Path < Constants.NumberOfPaths; Path++)
                GenesisZeroFlow.Display.DebugMessage($"{this.PcbID}\tDATA CHANNEL:\t\t Average delta time of flight value at {this.MeterType}{this.MeterIndex}, PATH{(Path + 1).ToString(this.Culture)}:  { Math.Round(DeltaTimeOfFlightAverage[Path] * (Math.Pow(2, 38)), 2).ToString("000.00", this.Culture)}ps\n", this.Culture);
            #endregion
            #region Check for bad data
            Boolean BadDataCheckOK = false;
            BadDataCheckOK = this.CheckForBadData(badData);
            if (BadDataCheckOK)
                GenesisZeroFlow.Display.DebugMessage($"{this.PcbID}\tAPPLICATION:\t\t Bad data check successful at {this.MeterType}{this.MeterIndex}\n", this.Culture);
            else
                GenesisZeroFlow.Display.DebugMessage($"{this.PcbID}\tAPPLICATION:\t\t Bad data check failed at {this.MeterType}{this.MeterIndex}\n", this.Culture);
            #endregion
            #region Check amplitude values
            this.ClearData();
            Boolean AmplitudeCheckOK = false;
            AmplitudeCheckOK = CheckAmplitudes(amplitudeValuesMeanUp, amplitudeValuesMeanDown);
            if (AmplitudeCheckOK)
                GenesisZeroFlow.Display.DebugMessage($"{this.PcbID}\tAPPLICATION:\t\t Amplitude check successful at {this.MeterType}{this.MeterIndex}\n", this.Culture);
            else
                GenesisZeroFlow.Display.DebugMessage($"{this.PcbID}\tAPPLICATION:\t\t Amplitude check failed at {this.MeterType}{this.MeterIndex}\n", this.Culture);
            #endregion
            #region Check if offsets are within ranges
            Boolean OffsetCheckOK = false;
            OffsetCheckOK = CheckOffset(DeltaTimeOfFlightAverage);
            if (OffsetCheckOK)
                GenesisZeroFlow.Display.DebugMessage($"{this.PcbID}\tAPPLICATION:\t\t Delta time of flight check successful at {this.MeterType}{this.MeterIndex}\n", this.Culture);
            else
                GenesisZeroFlow.Display.DebugMessage($"{this.PcbID}\tAPPLICATION:\t\t Delta time of flight check failed at {this.MeterType}{this.MeterIndex}\n", this.Culture);
            #endregion
            #region Abort if checks failed
            if ((Boolean.Equals(BadDataCheckOK, false)) || (Boolean.Equals(AmplitudeCheckOK, false)) || (Boolean.Equals(OffsetCheckOK, false) || GenesisZeroFlow._GenesisZeroFlow.TempMonitoringFailed))
            {
                this.ClearData();
                return false;
            }
            #endregion

            GenesisMeter.Login();

            #region Write new values to offset registers
            #region Write to 'ZeroOffset' register PATH0


            this.OffsetValuePath0 = (Int32)((DeltaTimeOfFlightAverage[Constants.PATH0] * Math.Pow(2, 40))); // ZeroOffsetTestConstants.DeltaTofAverageFactor)));
            GenesisZeroFlow.Display.DebugMessage($"{this.PcbID}\tCOMMAND CHANNEL:\t Writing {OffsetValuePath0.ToString(this.Culture)} to 'Zero flow offset'-register PATH1 started at {this.MeterType}{this.MeterIndex}\n", this.Culture);
            #region Write to register
            Ok = GenesisMeter.WriteRegisterSafe(Register.Genesisflow.ZeroOffset1, OffsetValuePath0);
            if (Ok)
                GenesisZeroFlow.Display.DebugMessage($"{this.PcbID}\tCOMMAND CHANNEL:\t Writing {OffsetValuePath0.ToString(this.Culture)} to 'Zero flow offset'-register successful at {this.MeterType}{this.MeterIndex}; PATH1\n", this.Culture);
            else
                GenesisZeroFlow.Display.DebugMessage($"{this.PcbID}\tCOMMAND CHANNEL:\t Writing {OffsetValuePath0.ToString(this.Culture)} to 'Zero flow offset'-register failed at {this.MeterType}{this.MeterIndex}; PATH1\n", this.Culture);

            if (Boolean.Equals(Ok, false) || GenesisZeroFlow._GenesisZeroFlow.TempMonitoringFailed)
                return false;
            #endregion
            #endregion
            #region Write to 'ZeroOffset' register PATH1
            if (Constants.NumberOfPaths > 1)
            {
                GenesisZeroFlow.Display.DebugMessage($"{this.PcbID}\tCOMMAND CHANNEL:\t calculating offset PATH2 {DeltaTimeOfFlightAverage[Constants.PATH1]} * {Math.Pow(2, 40)} started at {this.MeterType}{this.MeterIndex}\n", this.Culture);

                var p2AVG = deltaTimeOfFlightAverageRAW[Constants.PATH1].Average();
                GenesisZeroFlow.Display.DebugMessage($"{this.PcbID} AVG RAW Value is {p2AVG}", this.Culture);

                GenesisZeroFlow.Display.DebugMessage($"{this.PcbID} Value in S is {DeltaTimeOfFlightAverage[Constants.PATH1]}", this.Culture);
                GenesisZeroFlow.Display.DebugMessage(
                    $"{this.PcbID} Calculation RAW {DeltaTimeOfFlightAverage[Constants.PATH1] / (1.0 / 0x4000000000)} | RAW {DeltaTimeOfFlightAverage} in Seconds", this.Culture);

                GenesisZeroFlow.Display.DebugMessage(
                    $"{this.PcbID} Raw x4 calc  {DeltaTimeOfFlightAverage[Constants.PATH1] / (1.0 / 0x4000000000) * 4} = offset", this.Culture);
                GenesisZeroFlow.Display.DebugMessage(
                    $"{this.PcbID} Current calc DeltaTimeOfFlightAverage * 2^40 {(Int32)((DeltaTimeOfFlightAverage[Constants.PATH1] * Math.Pow(2, 40)))} = offset", this.Culture);

             

                GenesisZeroFlow.Display.StatusLabel($"{GenesisZeroFlow.PredefinedMessages.WaitUntilRegisterWriteFinished(this.Culture)}");
                this.OffsetValuePath1 = (Int32)((DeltaTimeOfFlightAverage[Constants.PATH1] * Math.Pow(2, 40))); // ZeroOffsetTestConstants.DeltaTofAverageFactor)));
                GenesisZeroFlow.Display.DebugMessage($"{this.PcbID}\tCOMMAND CHANNEL:\t Writing {OffsetValuePath1.ToString(this.Culture)} to 'Zero flow offset'-register PATH2 started at {this.MeterType}{this.MeterIndex}\n", this.Culture);
                #region Write to register
                Ok = GenesisMeter.WriteRegisterSafe(Register.Genesisflow.ZeroOffset2, OffsetValuePath1);
                if (Ok)
                    GenesisZeroFlow.Display.DebugMessage($"{this.PcbID}\tCOMMAND CHANNEL:\t Writing {OffsetValuePath1.ToString(this.Culture)} to 'Zero flow offset'-register successful at {this.MeterType}{this.MeterIndex}; PATH2\n", this.Culture);
                else
                    GenesisZeroFlow.Display.DebugMessage($"{this.PcbID}\tCOMMAND CHANNEL:\t Writing {OffsetValuePath1.ToString(this.Culture)} to 'Zero flow offset'-register failed at {this.MeterType}{this.MeterIndex}; PATH2\n", this.Culture);
                #endregion

                if (Boolean.Equals(Ok, false) || GenesisZeroFlow._GenesisZeroFlow.TempMonitoringFailed)
                    return false;
            }
            #endregion
            #region Write to 'ZeroOffset' register PATH2
            if (Constants.NumberOfPaths > 2)
            {
                this.OffsetValuePath2 = (Int32)((DeltaTimeOfFlightAverage[Constants.PATH2] * Math.Pow(2, 40)));// ZeroOffsetTestConstants.DeltaTofAverageFactor)));
                GenesisZeroFlow.Display.DebugMessage($"{this.PcbID}\tCOMMAND CHANNEL:\t Writing {OffsetValuePath2.ToString(this.Culture)} to 'Zero flow offset'-register PATH3 started at {this.MeterType}{this.MeterIndex}\n", this.Culture);
                #region Write to register
                Ok = GenesisMeter.WriteRegisterSafe(Register.Genesisflow.ZeroOffset3, OffsetValuePath2);
                if (Ok)
                    GenesisZeroFlow.Display.DebugMessage($"{this.PcbID}\tCOMMAND CHANNEL:\t Writing {OffsetValuePath2.ToString(this.Culture)} to 'Zero flow offset'-register successful at {this.MeterType}{this.MeterIndex}; PATH3\n", this.Culture);
                else
                    GenesisZeroFlow.Display.DebugMessage($"{this.PcbID}\tCOMMAND CHANNEL:\t Writing {OffsetValuePath2.ToString(this.Culture)} to 'Zero flow offset'-register failed at {this.MeterType}{this.MeterIndex}; PATH3\n", this.Culture);
                #endregion
                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[1];


            //Int32[] LinecounterFollowing = new Int32[Constants.NumberOfPaths] { 0, 0, 0 };
            Boolean Ok = true;
            Int32 ActivityCheckInterval = GenesisZeroFlow._GenesisZeroFlow.GetAmplitudeActivityCheckInterval();
            Ok = this.ThermoActivityCheck(ref LinecounterFollowing, 0);
            #endregion
            #region Test sequence
            #region Check upper temp 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)}\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}\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)}\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}\t\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
                }
                catch (Exception ex)
                {
                    GenesisZeroFlow._GenesisZeroFlow.TempMonitoringFailed = true;
                    ErrorLog.Log(LogErrReason.Exeption, "ZeroFlowOffsetTest.PerformTemperatureMonitoring() failed", $"0x{ex.HResult.ToString("X", this.Culture)}", String.Empty, this.Culture);
                }
            }
            #endregion
            #endregion
            return Ok;
        }
        private Boolean ActivityCheck(CancellationToken token)
        {
            #region Definitions and initializations
            Boolean Ok = true;
            Int32[] LineCounterFollowing = new Int32[Constants.NumberOfPaths];
            LineCounterFollowing = ArrayInit.Path((Int32)0);
            Int32[] LineCounter = new Int32[Constants.NumberOfPaths];
            LineCounter = ArrayInit.Path((Int32)0);
            Int32[] LineCounterFailed = new Int32[Constants.NumberOfPaths];
            LineCounterFailed = ArrayInit.Path((Int32)0);
            const Int32 maxLineCounterFailed = 500;
            Boolean PerformCheck = true;

            for(UInt16 Path = Constants.PATH0; Path < Constants.NumberOfPaths; Path++)
            {
                if (!(LineCounter[Path] < this.NumberOfLines - 1))
                    PerformCheck = false;
                if (GenesisZeroFlow._GenesisZeroFlow.TempMonitoringFailed)
                    PerformCheck = false;
            }

            #endregion
            #region Check activity
            while (PerformCheck)
            //while ((LineCounter[Constants.PATH0] < this.NumberOfLines - 1) && (LineCounter[Constants.PATH1] < this.NumberOfLines - 1) && (LineCounter[Constants.PATH2] < this.NumberOfLines) && (!GenesisZeroFlow._GenesisZeroFlow.TempMonitoringFailed))
            {
                if (token.IsCancellationRequested)
                    return false;
          
                LineCounterFollowing = (Int32[])LineCounter.Clone();
                GenesisZeroFlow.Display.StatusLabel($"{GenesisZeroFlow.PredefinedMessages.ZeroflowOffsetAqqFinished(this.Culture)} {LineCounterFollowing[Constants.PATH0].ToString(this.Culture)}/{this.NumberOfLines.ToString(this.Culture)}"); // "Wait until data aquisition has finished:"
                Misc.WaitNSeconds(2);
                LineCounter = (Int32[])GenesisZeroFlow._GenesisZeroFlow.GetLineCounterZeroFlow(this.MeterNumber).Clone();

                for (UInt16 Path = Constants.PATH0; Path < Constants.NumberOfPaths; Path++)
                {
                    if (Int32.Equals(LineCounterFollowing[Path], LineCounter[Path]) && (Int32.Equals((LineCounter[Path] % 3), 0)))
                    {
                        GenesisZeroFlow.Display.DebugMessage($"{this.PcbID}\tDATA CHANNEL:\t\t Data activity check failed at {this.MeterType}{this.MeterIndex}; PATH{Path + 1}; Linecounter = {LineCounter[Path].ToString(this.Culture)}\n", this.Culture);
                        LineCounterFailed[Path] = LineCounterFailed[Path] + 1;
                    }
                }

                bool testDone = true;
                for (UInt16 Path = Constants.PATH0; Path < Constants.NumberOfPaths; Path++)
                {

                    if (LineCounterFailed[Path] > maxLineCounterFailed)
                    {
                        GenesisZeroFlow.Display.DebugMessage($"{this.PcbID}\tDATA CHANNEL:\t\t To many bad data Packages {this.MeterType}{this.MeterIndex}; PATH{Path + 1}; Linecounter = {LineCounter[Path].ToString(this.Culture)}\n", this.Culture);

                        Ok = false;
                        break;
                    }
                    if (LineCounter[Path] < this.NumberOfLines)
                    {
                        testDone = false;
                    }
                }

                if (testDone)
                {
                    Ok = true;
                    PerformCheck = false;
                }
         


            }
            #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 CheckForBadData(Int32[] badData)
        {
            #region Definitions and initializations
            const Int32 BadDataLimit = ZeroOffsetTestConstants.BadDataLimit;
            Boolean Ok = true;
            #endregion
            #region Result
            for (UInt16 Path = Constants.PATH0; Path < Constants.NumberOfPaths; Path++)
            {
                if (badData[Path] >= BadDataLimit)
                    Ok = false;
            }
            #endregion

            return Ok;
        }
        private Boolean CheckOffset(Double[] deltaTimeOfFlightAvg)
        {
            #region Definitions and initializations
            Boolean Ok = true;
            #endregion
            #region Result
            for (UInt16 Path = Constants.PATH0; Path < Constants.NumberOfPaths; Path++)
            {
                if (deltaTimeOfFlightAvg[Path] > this.OffsetTimeLimit)
                    Ok = false;
                if (deltaTimeOfFlightAvg[Path] < -this.OffsetTimeLimit)
                    Ok = false;
            }
            #endregion

            return Ok;
        }
        private Boolean CheckAmplitudes(Double[] amplitudeValuesUp, Double[] amplitudeValuesDown)
        {
            #region Definitions and initializations
            Boolean Ok = true;

            #endregion
            #region Result
            for (UInt16 Path = Constants.PATH0; Path < Constants.NumberOfPaths; Path++)
            {
                if (amplitudeValuesUp[Path] > this.UpperVoltLimit)
                    return false;
                if (amplitudeValuesUp[Path] < this.LowerVoltLimit)
                    return false;
                if (amplitudeValuesDown[Path] < this.LowerVoltLimit)
                    return false;
                if (amplitudeValuesDown[Path] > this.UpperVoltLimit)
                    return false;
            }
            #endregion

            return Ok;
        }
        private DialogResult AskHowToProceedSequence(String sequenceName)
        {
            DialogResult AskForActions;

            GenesisZeroFlow.Display.AbortButtonEnabled(false);
            AskForActions = MessageBox.Show(GenesisZeroFlow.PredefinedMessages.MeterSequenceFailed(sequenceName, this.MeterIndex, this.Culture), "Retry?", MessageBoxButtons.RetryCancel, MessageBoxIcon.Question);
            switch (AskForActions)
            {
                case DialogResult.Retry:
                    GenesisZeroFlow.Display.DebugMessage($"{Constants.TwentySpaces}\tAPPLICATION:\t\t  {sequenceName} restarted at {this.MeterType}{this.MeterIndex}\n", this.Culture);
                    break;
                case DialogResult.Cancel:
                    GenesisZeroFlow.Display.DebugMessage($"{Constants.TwentySpaces}\tAPPLICATION:\t\t {sequenceName} canceled at {this.MeterType}{this.MeterIndex}\n", this.Culture);
                    GenesisZeroFlow.Display.DebugMessage($"{Constants.TwentySpaces}\t{Debugmessages.Line}", this.Culture);
                    break;
                default: break;
            }

            return AskForActions;
        }

        private void LeaveSequence()
        {
            GenesisZeroFlow._GenesisZeroFlow.SetCalculationIndicatorZeroFlowTest(false, this.MeterNumber);
            GenesisZeroFlow._GenesisZeroFlow.SetLoggingIndicatorZeroFlowTest(false, this.MeterNumber);

            #region Write raw data to files
            if (this.GenerateLogFiles)
            {
                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.GetLoggingPathZeroFlowTest()[this.MeterNumber]);
            }
            this.ClearData();
            #endregion
        }

        private void ClearData()
        {
            try
            {
                GenesisZeroFlow._GenesisZeroFlow.SetCalculationIndicatorZeroFlowTest(false, this.MeterNumber);
                GenesisZeroFlow._GenesisZeroFlow.SetLoggingIndicatorZeroFlowTest(false, this.MeterNumber);
                Misc.WaitNMilliseconds(100);

                GenesisZeroFlow._GenesisZeroFlow.SetDataToLog(this.MeterNumber, String.Empty);

                for (UInt16 Path = Constants.PATH0; Path < Constants.NumberOfPaths; Path++)
                {
                    GenesisZeroFlow._GenesisZeroFlow.ClearAmplitudeValuesUp(this.MeterNumber);
                    GenesisZeroFlow._GenesisZeroFlow.ClearAmplitudeValuesDown(this.MeterNumber);
                    GenesisZeroFlow._GenesisZeroFlow.ClearTotalTimeOfFlightAverage(this.MeterNumber, Path);
                    GenesisZeroFlow._GenesisZeroFlow.ClearLineCounterZeroFlow(this.MeterNumber);
                    GenesisZeroFlow._GenesisZeroFlow.ClearBadDataCounter(this.MeterNumber);
                }
            }
            catch(Exception ex)
            {
                ErrorLog.Log(LogErrReason.Exeption, "ZeroFlowOffsetTest.ClearData() failed", $"0x{ex.HResult.ToString("X", this.Culture)}", String.Empty, this.Culture);
            }
        }

        public void Initialize(String pcbID, String meterType, Int16 lowerVoltLimit, Int16 upperVoltLimit, Double offsetTimeLimit, Int32 numberOfLines, Double upperTempLimit, Double lowerTempLimit, Double tempDeviationLimit, Boolean generateLogFiles)
        {
            this.OffsetValuePath0 = 0;
            this.OffsetValuePath1 = 0;
            this.OffsetValuePath2 = 0;
            this.UpperVoltLimit = upperVoltLimit;
            this.LowerVoltLimit = lowerVoltLimit;
            this.OffsetTimeLimit = offsetTimeLimit;
            this.NumberOfLines = numberOfLines;
            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.ActivityInterval = GenesisZeroFlow._GenesisZeroFlow.GetZeroFlowActivityCheckInterval();
            this.PcbID = pcbID;
            this.GenerateLogFiles = generateLogFiles;
        }
        private Boolean GenerateLogFiles { get; set; }
        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 Double LowerVoltLimit { get; set; }
        private Double UpperVoltLimit { get; set; }
        private Int32 OffsetValuePath0 { get; set; }
        private Int32 OffsetValuePath1 { get; set; }
        private Int32 OffsetValuePath2 { get; set; }
        private Double OffsetTimeLimit { get; set; }
        private Int32 NumberOfLines { get; set; }
        private Int32 ActivityInterval { get; set; }
        private Double LowerTempLimit { get; set; } // usually 10.0°C
        private Double UpperTempLimit { get; set; } // usually 35.0°C
        private Double TempDeviationLimit { get; set; } // usually 0.5°C
        internal Double[] TempDeviationMin { get; set; } // to store min. measure temperature value
        private Double[] GetTempDeviationMin()
        {
            return (Double[])TempDeviationMin.Clone();
        }
        private Double[] TempDeviationMax { get; set; } // to store max. measure temperature value
        private Double[] GetTempDeviationMax()
        {
            return (Double[])TempDeviationMax.Clone();
        }

    }
}