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 partial class GenesisZeroFlow : Form
    {
        public Boolean TempMonitoringFailed;

        private Double[][] MeasuredTemps = new Double[Constants.NumberOfThermometers][];

        private Boolean[][] MeasuredTempsIndicator = new Boolean[Constants.NumberOfThermometers][];
      

        public void SetMeasuredTemps(UInt16 thermoNumber, UInt16 path, Double value)
        {
            MeasuredTemps[thermoNumber][path] = value;
        }
        public void SetMeasuredTempsIndicator(UInt16 thermoNumber, UInt16 path, Boolean value)
        {
            if (GenesisZeroFlow._GenesisZeroFlow.InvokeRequired)
            {
                GenesisZeroFlow._GenesisZeroFlow.Invoke((Action<UInt16, UInt16, Boolean>)SetMeasuredTempsIndicator, thermoNumber, path, value);
                return;
            }
            MeasuredTempsIndicator[thermoNumber][path] = value;
        }
        public Double GetMeasuredTemps(UInt16 thermoNumber, UInt16 path)
        {
            return MeasuredTemps[thermoNumber][path];
        }
        public Boolean GetMeasuredTempsIndicator(UInt16 thermoNumber, UInt16 path)
        {
            Boolean temp = MeasuredTempsIndicator[thermoNumber][path];
            return temp;
        }

    }
    public static class TempCalibrationSequences
    {
        public static Boolean[] Total(MeterBatch globalMeterBatch, MeterBatch thermoMeterBatch, Boolean[] allEnable, Boolean manTempAcquisition, 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);
            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];

            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;
      
            List<TempCalibration> listTempCalib = new List<TempCalibration>();
            List<TempCalibration> listThermoTempCalib = new List<TempCalibration>();
            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)
                    listTempCalib.Add(new TempCalibration(Meter, currentMeter, culture));
                else
                    listTempCalib.Add(new TempCalibration(Meter, culture));
            }

            for (UInt16 Thermo = Constants.Thermo1; Thermo < Constants.NumberOfThermometers; Thermo++)
            {
                var currentMeter = globalMeterBatch.ListOfMeters.FirstOrDefault(m => m.Slot.Equals(Thermo + 11));

                if (currentMeter != null)
                    listThermoTempCalib.Add(new TempCalibration(Thermo, currentMeter, culture));
                else
                    listThermoTempCalib.Add(new TempCalibration(Thermo, culture));
            }
            #region Initialize
            foreach (var tempcalib in listTempCalib)
            {
                tempcalib.Initialize(GenesisZeroFlow._GenesisZeroFlow.PcbID[tempcalib.MeterNumber], Constants.Meter, 0, upperTempLimit, lowerTempLimit, tempDeviationLimit);
                tempcalib.MyTask = new Task<Boolean>(() => { return true; });
            }
            foreach (var thermotempcalib in listThermoTempCalib)
            {
                thermotempcalib.Initialize(GenesisZeroFlow._GenesisZeroFlow.ThermoID[thermotempcalib.MeterNumber], Constants.Thermo, 0, upperTempLimit, lowerTempLimit, tempDeviationLimit);
                thermotempcalib.MyTask = new Task<Boolean>(() => { return true; });
            }
            #endregion
            #endregion
            #region Perform tests
            CancellationTokenSource cancellationTokenSource = new CancellationTokenSource();
            CancellationToken token = cancellationTokenSource.Token;
            // Temperature acquisition
            #region Get manually measured temperatures
            if(manTempAcquisition)
                GetManualTemperatures(MeterEnable, culture);

            // For what?
            Int32 NumberOfTextboxes = 0;
            for (UInt16 Meter = Constants.Meter1; Meter < Constants.NumberOfMeters; Meter++)
            {
                if (MeterEnable[Meter])
                    NumberOfTextboxes++;
            }
            if (Int32.Equals(NumberOfTextboxes, 0))
                return MeterSequenceFailed.Concat(ThermoSequenceFailed).ToArray(); 

            if (manTempAcquisition)
            {
                listTempCalib[Constants.Meter1].SetRefTemperature(TemperatureField._TemperatureField.GetValueMeter1());
                listTempCalib[Constants.Meter2].SetRefTemperature(TemperatureField._TemperatureField.GetValueMeter2());
                listTempCalib[Constants.Meter3].SetRefTemperature(TemperatureField._TemperatureField.GetValueMeter3());
                listTempCalib[Constants.Meter4].SetRefTemperature(TemperatureField._TemperatureField.GetValueMeter4());
                listTempCalib[Constants.Meter5].SetRefTemperature(TemperatureField._TemperatureField.GetValueMeter5());
                listTempCalib[Constants.Meter6].SetRefTemperature(TemperatureField._TemperatureField.GetValueMeter6());
                listTempCalib[Constants.Meter7].SetRefTemperature(TemperatureField._TemperatureField.GetValueMeter7());
                listTempCalib[Constants.Meter8].SetRefTemperature(TemperatureField._TemperatureField.GetValueMeter8());
                listTempCalib[Constants.Meter9].SetRefTemperature(TemperatureField._TemperatureField.GetValueMeter9());
                listTempCalib[Constants.Meter10].SetRefTemperature(TemperatureField._TemperatureField.GetValueMeter10());
            }
            #endregion
            // Set meter temperatures
            foreach (var tempcalib in listTempCalib)
                tempcalib.Meter(ThermoEnable, manTempAcquisition, MeterEnable[tempcalib.MeterNumber], ref MeterTaskStarted[tempcalib.MeterNumber], ref MeterSequenceFailed[tempcalib.MeterNumber], ref NextDelayTime, token);
            // Thermometers
            foreach (var tempthermocalib in listThermoTempCalib)
            {
               if (ThermoEnable[tempthermocalib.MeterNumber])
                {
                    GenesisZeroFlow._GenesisZeroFlow.SetIndicatorTemperatureActivityCheck(tempthermocalib.MeterNumber, true);
                    GenesisZeroFlow.Display.DebugMessage($"{tempthermocalib.PcbID}\tAPPLICATION:\t\t TEMPERATURE MONITORING started at {tempthermocalib.MeterType}{tempthermocalib.MeterIndex}\n", tempthermocalib.Culture);
                    GenesisZeroFlow._GenesisZeroFlow.SetLoggingIndicatorThermoMonitoring(tempthermocalib.MeterNumber, true);
                }
                Misc.WaitNMilliseconds(300);
                tempthermocalib.Thermometer(ThermoEnable[tempthermocalib.MeterNumber], ref MeterTaskStarted[tempthermocalib.MeterNumber], ref MeterSequenceFailed[tempthermocalib.MeterNumber], ref NextDelayTime, token);
            }
            #endregion
            #region Wait for tasks
            while (!CheckArray(MeterTaskCompleted.Concat(ThermoTaskCompleted).ToArray()))
            {
                #region Temperature check
                foreach (var thermotempcalib in listThermoTempCalib)
                {
                    if (CheckArray(MeterTaskCompleted) && (ThermoEnable[thermotempcalib.MeterNumber])) // If all METERs finished, not THERMOMETERs 
                    {
                        GenesisZeroFlow._GenesisZeroFlow.SetLoggingIndicatorThermoMonitoring(thermotempcalib.MeterNumber, false);
                        GenesisZeroFlow.Display.DebugMessage($"{thermotempcalib.PcbID}\tAPPLICATION:\t\t TEMPERATURE MONITORING stopped at {thermotempcalib.MeterType}{thermotempcalib.MeterIndex}\n", thermotempcalib.Culture);
                    }
                }
                #endregion
                #region Abort check
                if (GenesisZeroFlow._GenesisZeroFlow.AbortIndicator)
                {
                    cancellationTokenSource.Cancel();
                    aborted = true;
                }
                #endregion
                #region Check result
                Misc.WaitNSeconds(1);
                #region Meter
                foreach (var tempcalib in listTempCalib)
                {
                    MeterTaskCompleted[tempcalib.MeterNumber] = TaskOperations.WaitFor(MeterTaskStarted[tempcalib.MeterNumber], tempcalib.MyTask);
                    // Stop temperature check
                    GenesisZeroFlow._GenesisZeroFlow.SetIndicatorTemperatureActivityCheck(tempcalib.MeterNumber, !MeterTaskCompleted[tempcalib.MeterNumber]);
                }
                foreach (var tempcalib in listTempCalib)
                    MeterSequenceFailed[tempcalib.MeterNumber] = TaskOperations.GetResult(MeterTaskStarted[tempcalib.MeterNumber], tempcalib.MyTask);
                for (UInt16 Meter = Constants.Meter1; Meter < Constants.NumberOfMeters; Meter++)
                    MeterSequenceOk[Meter] = !MeterSequenceFailed[Meter];
                #endregion
                #region Thermometer
                foreach (var thermotempcalib in listThermoTempCalib)
                {
                    ThermoTaskCompleted[thermotempcalib.MeterNumber] = TaskOperations.WaitFor(ThermoTaskStarted[thermotempcalib.MeterNumber], thermotempcalib.MyTask);
                    // Stop temperature check
                    GenesisZeroFlow._GenesisZeroFlow.SetIndicatorTemperatureActivityCheck(thermotempcalib.MeterNumber, !MeterTaskCompleted[thermotempcalib.MeterNumber]);
                }
                foreach (var thermotempcalib in listThermoTempCalib)
                    ThermoSequenceFailed[thermotempcalib.MeterNumber] = TaskOperations.GetResult(ThermoTaskStarted[thermotempcalib.MeterNumber], thermotempcalib.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 tempcalib in listTempCalib)
                MeterSequenceFailed[tempcalib.MeterNumber] = TaskOperations.GetResult(MeterTaskStarted[tempcalib.MeterNumber], tempcalib.MyTask);
            foreach (var thermotempcalib in listThermoTempCalib)
                ThermoSequenceFailed[thermotempcalib.MeterNumber] = TaskOperations.GetResult(ThermoTaskStarted[thermotempcalib.MeterNumber], thermotempcalib.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 tempcalib in listTempCalib)
                TaskOperations.CheckAndDispose(tempcalib.MyTask);
            foreach (var thermotempcalib in listThermoTempCalib)
                TaskOperations.CheckAndDispose(thermotempcalib.MyTask);
            #endregion
            #region Clear data
            for (UInt16 Meter = Constants.Meter1; Meter < Constants.NumberOfMeters; Meter++)
                GenesisZeroFlow._GenesisZeroFlow.SetDataToLog(Meter, String.Empty);
            #endregion

            return MeterSequenceFailed.Concat(ThermoSequenceFailed).ToArray();
        }

        public static Boolean TotalTempCal(MeterBatch globalMeterBatch, Boolean enable, Boolean adjust, Double upperTempLimit, Double lowerTempLimit, Double tempDeviationLimit, CultureInfo culture, frmTempCalibration parent)
        {
            #region Definitions and initializations
            Boolean SequenceFailed = false;
            Boolean TaskStarted = false;
            Boolean TaskCompleted = false;
            Double RefTemp = 0.0;
            List<TempCalibration> listTempCalib = new List<TempCalibration>();

            var currentMeter = globalMeterBatch.ListOfMeters.FirstOrDefault(m => m.Slot.Equals(Constants.Meter1 + 1));
            if (currentMeter != null)
                listTempCalib.Add(new TempCalibration(Constants.Meter1, currentMeter, culture));
            else
                listTempCalib.Add(new TempCalibration(Constants.Meter1, culture));

            foreach (var tempcalib in listTempCalib)
            {
                tempcalib.Initialize(String.Empty, Constants.Thermo, RefTemp, upperTempLimit, lowerTempLimit, tempDeviationLimit);
                tempcalib.MyTask = new Task<Boolean>(() => { return true; });
            }
            #endregion
            #region Perform tests
            #region Get manually measured temperatures      
            if (adjust)
            {
                frmTempCalibration.DisplayTempCal.StatusLabel("Enter reference temperature value");

            }
            else
            {

                frmTempCalibration.DisplayTempCal.StatusLabel("Press OK");
            }
            GetTemperaturesTempCal(enable, parent);
            Int32 NumberOfTextboxes = 0;

            if (enable)
                NumberOfTextboxes++;
            
            if (Int32.Equals(NumberOfTextboxes, 0))
                return SequenceFailed;
            #endregion
            if (adjust)
            {
                TemperatureFieldTempCal._TemperatureFieldTempCal.SetEnabledGbLogging(false);
                listTempCalib[Constants.Meter1].SetRefTemperature(TemperatureFieldTempCal._TemperatureFieldTempCal.GetValueMeter1());
                frmTempCalibration.DisplayTempCal.TempCalRefTemperatureLabel(TemperatureFieldTempCal._TemperatureFieldTempCal.GetValueMeter1().ToString("0.00", culture));
            }
            else
                TemperatureFieldTempCal._TemperatureFieldTempCal.SetEnabledGbLogging(true);

            foreach (var tempcalib in listTempCalib)
                tempcalib.MeterTempCal(enable, ref TaskStarted, ref SequenceFailed, adjust);
            #endregion
            #region Wait for tasks
            Boolean SequenceOk = false;

            while (!TaskCompleted)
            {
                foreach (var tempcalib in listTempCalib)
                    TaskCompleted = TaskOperations.WaitFor(TaskStarted, tempcalib.MyTask);
             
                Misc.WaitNSeconds(1);

                foreach (var tempcalib in listTempCalib)
                    SequenceFailed = TaskOperations.GetResult(TaskStarted, tempcalib.MyTask);
                SequenceOk = !SequenceFailed;
                frmTempCalibration.DisplayTempCal.MeterStatusGreenRed(SequenceOk, TaskStarted);
            }

            foreach (var tempcalib in listTempCalib)
                SequenceFailed = TaskOperations.GetResult(TaskStarted, tempcalib.MyTask);

            SequenceOk = !SequenceFailed;
            frmTempCalibration.DisplayTempCal.MeterStatusGreenRed(SequenceOk, TaskStarted);
            #endregion
            #region Destroy tasks
            foreach (var tempcalib in listTempCalib)
            {
                TaskOperations.CheckAndDispose(tempcalib.MyTask);
            }
            #endregion
            #region Clear data
            if (Boolean.Equals(adjust, false))
            {
                frmTempCalibration.DisplayTempCal.DebugMessage($"APPLICATION:\t\t TEMPERATURE MEASUREMENT stopped\n", culture);
                frmTempCalibration.DisplayTempCal.DebugMessage($"{Debugmessages.Line}", culture);
            }
            #endregion

            return SequenceFailed;
        }
        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;
        }
        /// <summary>
        /// For ZeroFlowCalibration tool
        /// </summary>
        /// <param name="enable"></param>
        /// <param name="culture"></param>
        private static void GetManualTemperatures(Boolean[] enable, CultureInfo culture)
        {
            if (Boolean.Equals(GenesisZeroFlow._GenesisZeroFlow.AbortIndicator, false))
            {
                // GenesisZeroFlow.Display.SetProgressPanel(StatusPanelItems.TempCal);
                GenesisZeroFlow.Display.DebugMessage($"{Constants.TwentySpaces}\tAPPLICATION:\t\t TEMPERATURE CALIBRATION sequence started\n", culture);
                GenesisZeroFlow.Display.StatusLabel(GenesisZeroFlow.PredefinedMessages.WaitUntilTemperatureCalibrationFinished(culture));
                GenesisZeroFlow.Display.TemperatureField(enable);
            }
            else
            {
                GenesisZeroFlow.Display.DebugMessage($"{Constants.TwentySpaces}\tAPPLICATION:\t\t ZEROFLOW CALIBRATION sequence stopped\n", culture);
                GenesisZeroFlow.Display.DebugMessage($"{Constants.TwentySpaces}\t{Debugmessages.Line}", culture);
                GenesisZeroFlow._GenesisZeroFlow.StopMainSequence(GenesisZeroFlow.PredefinedMessages.ZeroflowCalibrationSequenceStopped(culture), MessageBoxIcon.Error, culture);
                return;
            }
        }

        /// <summary>
        ///  For temperature calibration tool
        /// </summary>
        /// <param name="enable"></param>
        private static void GetTemperaturesTempCal(Boolean enable, frmTempCalibration parent = null)
        {
            if (parent == null)
            {
                frmTempCalibration.DisplayTempCal.SetProgressPanel(StatusPanelItems.TempCal);
                frmTempCalibration.DisplayTempCal.TemperatureFieldTempCal();
            }
            else
            {
                parent.Invoke(new Action(() =>
                {
                    frmTempCalibration.DisplayTempCal.SetProgressPanel(StatusPanelItems.TempCal);
                    frmTempCalibration.DisplayTempCal.TemperatureFieldTempCal();
                }));
            }
            
        }
    }
    public class TempCalibration
    {
        private readonly ZeroFlowGenesisMeter GenesisMeter;
        public Task<Boolean> MyTask { get; internal set; }
        public TempCalibration(UInt16 meterNumber, CultureInfo culture)
        {
            this.MeterNumber = meterNumber;
            this.Culture = culture;
            this.MeterIndex = (meterNumber + 1).ToString(culture);
        }
        public TempCalibration(UInt16 meterNumber, IMeter meter, CultureInfo culture)
        {
            if (meter is ZeroFlowGenesisMeter)
            {
                GenesisMeter = meter as ZeroFlowGenesisMeter;
            }
            this.MeterNumber = meterNumber;
            this.Culture = culture;
            this.MeterIndex = (meterNumber + 1).ToString(culture);
        }
        internal void Meter(Boolean[] thermoEnable, Boolean manTempAcquisition, 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;
            DialogResult AskForActions = DialogResult.None;
            Boolean _sequenceFailed = sequenceFailed;
            Int32 temp = DelayTime;
            Boolean Ok = false;
            #endregion
            #region Everything else
            if ((enable) && (!TaskStatus.Equals(MyTask.Status, TaskStatus.Running)) && (!MyTask.IsCompleted))
            //if ((!TaskStatus.Equals(MyTask.Status, TaskStatus.Running)) && (!MyTask.IsCompleted))
            {
                DelayTime = nextDelayTime;
                nextDelayTime = nextDelayTime + DeltaDelay;

                taskStarted = true;
                Misc.WaitNSeconds(temp);

                MyTask = Task.Run(() =>
                {
                    //if (enable) // tbc
                    //{
                        while ((DialogResult.Equals(AskForActions, DialogResult.Retry)) || (DialogResult.Equals(AskForActions, DialogResult.None)) && (!token.IsCancellationRequested))
                        {
                            #region Abort
                            if (!token.IsCancellationRequested)
                                GenesisZeroFlow.Display.AbortButtonEnabled(true);
                            #endregion

                            String Text = String.Empty;

                            #region Testprocedure
                            if (DialogResult.Equals(AskForActions, DialogResult.None))
                                GenesisZeroFlow.Display.DebugMessage($"{this.PcbID}\tAPPLICATION:\t\t TEMPERATURE CALIBRATION started at {this.MeterType}{this.MeterIndex}\n", this.Culture);

                            Ok = this.PerformTest(thermoEnable, manTempAcquisition, PcbID, token);

                            if (token.IsCancellationRequested)
                            {
                                GenesisZeroFlow.Display.DebugMessage($"{this.PcbID}\tAPPLICATION:\t\t TEMPERATURE CALIBRATION 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
                            }
                            if (Ok)
                            {
                                GenesisZeroFlow.Display.DebugMessage($"{this.PcbID}\tAPPLICATION:\t\t TEMPERATURE CALIBRATION 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;
                                GenesisZeroFlow.Display.DebugMessage($"{this.PcbID}\tAPPLICATION:\t\t TEMPERATURE CALIBRATION failed at {this.MeterType}{this.MeterIndex}\n", this.Culture);
                                AskForActions = DialogResult.Cancel;// MessageBox.Show($"{GenesisZeroFlow.PredefinedMessages.TemCalFailed(this.Culture)}{this.MeterIndex}", "Retry?", MessageBoxButtons.RetryCancel, MessageBoxIcon.Question);
                                GenesisZeroFlow._GenesisZeroFlow.GenerateReturnNote(this.MeterIndex, this.PcbID, GenesisZeroFlow.PredefinedMessages.AmplitudeFailed(this.Culture), GenesisZeroFlow._GenesisZeroFlow.GetLoggingFromTextBox(), this.Culture);
                            }
                            #endregion
                        }
                    // }
                    return _sequenceFailed;
                    

                }, token);

            }
            #endregion
        }
        internal void MeterTempCal(Boolean enable, ref Boolean taskStarted, ref Boolean sequenceFailed, Boolean adjust)
        {
            #region Definitions and initializations
            DialogResult AskForActions = DialogResult.None;
            var _sequenceFailed = sequenceFailed;
            var _adjust = adjust;
            Boolean Ok = false;
            #endregion
            #region Avoid CA1062
            if (MyTask == null)
                return;
            #endregion
            #region Everything else
            if ((enable) && (!TaskStatus.Equals(MyTask.Status, TaskStatus.Running)) && (!MyTask.IsCompleted))
            {
                taskStarted = true;

                MyTask = Task.Run(() =>
                {
                    if (_adjust)
                    {
                        while ((DialogResult.Equals(AskForActions, DialogResult.Retry)) || (DialogResult.Equals(AskForActions, DialogResult.None)))
                        {
                            #region Testprocedure
                            if (DialogResult.Equals(AskForActions, DialogResult.None))
                                frmTempCalibration.DisplayTempCal.DebugMessage($"APPLICATION:\t\t TEMPERATURE CALIBRATION sequence started\n", this.Culture);

                            Ok = this.PerformTestTempCal();

                            if (Boolean.Equals(Ok, true))
                            {
                                frmTempCalibration.DisplayTempCal.DebugMessage($"APPLICATION:\t\t TEMPERATURE CALIBRATION sequence successful\n", this.Culture);
                                frmTempCalibration.DisplayTempCal.DebugMessage(Debugmessages.Line, this.Culture);
                                _sequenceFailed = false;
                                AskForActions = DialogResult.OK;
                            }
                            else
                            {
                                _sequenceFailed = true;
                                frmTempCalibration.DisplayTempCal.DebugMessage($"APPLICATION:\t\t TEMPERATURE CALIBRATION sequence failed\n", this.Culture);
                                AskForActions = MessageBox.Show($"TEMPERATURE CALIBRATION failed", "Retry?", MessageBoxButtons.RetryCancel, MessageBoxIcon.Question);
                            }
                            #endregion
                        }
                    }
                    else
                    {
                        frmTempCalibration.DisplayTempCal.DebugMessage($"APPLICATION:\t\t TEMPERATURE MEASUREMENT started\n", this.Culture);
                    }


                    return _sequenceFailed;
                });

            }
            #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;
            Boolean _sequenceFailed = sequenceFailed;
            Boolean Ok = true;
            #endregion
            #region Everything else
            if ((enable) && (!TaskStatus.Equals(MyTask.Status, TaskStatus.Running)) && (!MyTask.IsCompleted))
            //if (!TaskStatus.Equals(MyTask.Status, TaskStatus.Running) && (!MyTask.IsCompleted))
            {
                DelayTime = nextDelayTime;
                nextDelayTime = nextDelayTime + DeltaDelay;

                taskStarted = true;
                Misc.WaitNSeconds(DelayTime);

                MyTask = Task.Run(() =>
                {
                    //if(enable) // tbc
                    //{ 
                    Boolean LoggingIndicator = GenesisZeroFlow._GenesisZeroFlow.GetLoggingIndicatorThermoMonitoring()[MeterNumber];

                        while (LoggingIndicator && (Ok == true))
                        {
                            #region Abort
                            if (!token.IsCancellationRequested)
                                GenesisZeroFlow.Display.AbortButtonEnabled(true);
                            #endregion
                            #region Testprocedure
                            Ok = this.PerformTempMonitoring(token);
                            if (Ok == false)
                                GenesisZeroFlow._GenesisZeroFlow.TempMonitoringFailed = true;
                            //Misc.WaitNSeconds(1);

                            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
                            Misc.WaitNSeconds(1);
                            LoggingIndicator = GenesisZeroFlow._GenesisZeroFlow.GetLoggingIndicatorThermoMonitoring()[this.MeterNumber];
                        }
                    //}

                    return _sequenceFailed;

                }, token);
            }
            #endregion
            #region Write log data to file
            //String DateTime = System.DateTime.Now.ToString(Formats.LogFileDateTimeString, this.Culture);
            //if (GenesisZeroFlow._GenesisZeroFlow.GetCBMeanAmplitudeFiles())
            //{
            //    Logging.WriteToFile(GenesisZeroFlow._GenesisZeroFlow.GetNumbersToLog()[MeterNumber][Constants.PATH0], $@"..\GenesisZeroFlowTest_Temperature_THERMOMETER{MeterIndex}_PATH0_{DateTime}.csv");
            //    Logging.WriteToFile(GenesisZeroFlow._GenesisZeroFlow.GetNumbersToLog()[MeterNumber][Constants.PATH1], $@"..\GenesisZeroFlowTest_Temperature_THERMOMETER{MeterIndex}_PATH1_{DateTime}.csv");
            //    Logging.WriteToFile(GenesisZeroFlow._GenesisZeroFlow.GetNumbersToLog()[MeterNumber][Constants.PATH2], $@"..\GenesisZeroFlowTest_Temperature_THERMOMETER{MeterIndex}_PATH2_{DateTime}.csv");
            //}

            this.ClearData();
            #endregion
        }
        private Boolean PerformTest(Boolean[] thermoEnable, Boolean manTempAcquisition, String pcbID, CancellationToken token)
        {
            this.ClearData();

            #region Definitions and initializations
            Boolean Ok = false;
            const UInt16 NumberOfAvgValues = 10;
            UInt16[] Values = new UInt16[Constants.NumberOfThermometers];
            Values = ArrayInit.Thermo((UInt16)0);
            Double[][] Temperatures = new Double[Constants.NumberOfThermometers][];
            for (UInt16 Thermo = Constants.Thermo1; Thermo < Constants.NumberOfThermometers; Thermo++)
            {
                Temperatures[Thermo] = new Double[Constants.NumberOfPaths];
                for (UInt16 Path = Constants.PATH0; Path < Constants.NumberOfPaths; Path++)
                    Temperatures[Thermo][Path] = new Double();
            }
            String DebugMessage = String.Empty;
            #endregion
            #region Automatic acquisition
            if (!manTempAcquisition)
            {
                #region Wait for temperature values
                Boolean[] GotTemperature = new Boolean[Constants.NumberOfThermometers];
                Boolean[] GotTemperaturesPaths1 = new Boolean[Constants.NumberOfPaths];
                Boolean[] GotTemperaturesPaths2 = new Boolean[Constants.NumberOfPaths];

                GotTemperature = ArrayInit.Thermo(false);
                GotTemperaturesPaths1 = ArrayInit.Path(false);
                GotTemperaturesPaths2 = ArrayInit.Path(false);

                while ((!GotTemperature[Constants.Thermo1]) && (thermoEnable[Constants.Thermo1]))
                {
                    GenesisZeroFlow.Display.DebugMessage($"{this.PcbID}\tDATA CHANNEL:\t\t Waiting for Temperature data at {this.MeterType}{this.MeterIndex}\n", this.Culture);
                    for (UInt16 Path = Constants.PATH0; Path < Constants.NumberOfPaths; Path++)
                    {
                        Boolean temp = GenesisZeroFlow._GenesisZeroFlow.GetMeasuredTempsIndicator(Constants.Thermo1, Path);
                        GotTemperaturesPaths1[Path] = temp;
                        GotTemperature[Constants.Thermo1] = GotTemperaturesPaths1[Constants.PATH0] & GotTemperaturesPaths1[Constants.PATH1] & GotTemperaturesPaths1[Constants.PATH2];
                    }
                    if (GenesisZeroFlow._GenesisZeroFlow.TempMonitoringFailed)
                        return false;
                    Misc.WaitNSeconds(1);
                }

                while ((!GotTemperature[Constants.Thermo2]) && (thermoEnable[Constants.Thermo2]))
                {
                    GenesisZeroFlow.Display.DebugMessage($"{this.PcbID}\tDATA CHANNEL:\t\t Waiting for Temperature data at {this.MeterType}{this.MeterIndex}\n", this.Culture);
                    for (UInt16 Path = Constants.PATH0; Path < Constants.NumberOfPaths; Path++)
                    {
                        GotTemperaturesPaths2[Path] = GenesisZeroFlow._GenesisZeroFlow.GetMeasuredTempsIndicator(Constants.Thermo2, Path);
                        GotTemperature[Constants.Thermo2] = GotTemperaturesPaths2[Constants.PATH0] & GotTemperaturesPaths2[Constants.PATH1] & GotTemperaturesPaths2[Constants.PATH2];
                    }
                    if (GenesisZeroFlow._GenesisZeroFlow.TempMonitoringFailed)
                        return false;
                    Misc.WaitNSeconds(1);
                }
                #endregion
                #region Get temperatures
                if (thermoEnable[Constants.Thermo1])
                {
                    for (UInt16 Path = Constants.PATH0; Path < Constants.NumberOfPaths; Path++)
                    {
                        var temp = GenesisZeroFlow._GenesisZeroFlow.GetMeasuredTemps(Constants.Thermo1, Path);
                        Temperatures[Constants.Thermo1][Path] = temp;
                        GenesisZeroFlow.Display.DebugMessage($"{this.PcbID}\tDATA CHANNEL:\t\t TEMPERATURE ACQUISITION at {this.MeterType}{this.MeterIndex}; PATH{Path.ToString(this.Culture)}; Value = {Math.Round(Temperatures[Constants.Thermo1][Path], 2).ToString("00.00", this.Culture)}°C\n", this.Culture);
                        if (GenesisZeroFlow._GenesisZeroFlow.TempMonitoringFailed)
                            return false;
                    }
                }
                if (thermoEnable[Constants.Thermo2])
                {
                    for (UInt16 Path = Constants.PATH0; Path < Constants.NumberOfPaths; Path++)
                    {
                        Temperatures[Constants.Thermo2][Path] = GenesisZeroFlow._GenesisZeroFlow.GetMeasuredTemps(Constants.Thermo2, Path);
                        GenesisZeroFlow.Display.DebugMessage($"{this.PcbID}\tDATA CHANNEL:\t\t TEMPERATURE ACQUISITION at {this.MeterType}{this.MeterIndex}; PATH{Path.ToString(this.Culture)}; Value = {Math.Round(Temperatures[Constants.Thermo2][Path], 2).ToString("00.00", this.Culture)}°C\n", this.Culture);
                        if (GenesisZeroFlow._GenesisZeroFlow.TempMonitoringFailed)
                            return false;
                    }
                }
                #endregion
                #region Stop temperature monitoring
                GenesisZeroFlow._GenesisZeroFlow.SetLoggingIndicatorThermoMonitoring(Constants.Thermo1, false);
                GenesisZeroFlow._GenesisZeroFlow.SetLoggingIndicatorThermoMonitoring(Constants.Thermo2, false);
                #endregion
                #region Automatic acquisition
                List<Double> Avg = new List<Double>();
                if (thermoEnable[Constants.Thermo1])
                {
                    for (UInt16 Path = Constants.PATH0; Path < Constants.NumberOfPaths; Path++)
                        Avg.Add(Temperatures[Constants.Thermo1][Path]);
                }
                if (thermoEnable[Constants.Thermo2])
                {
                    for (UInt16 Path = Constants.PATH0; Path < Constants.NumberOfPaths; Path++)
                        Avg.Add(Temperatures[Constants.Thermo2][Path]);
                }
                if (Avg.Count() > 1)
                    this.SetRefTemperature(Avg.Average());

                else
                {
                    if ((Avg.Count() == 1) && (!GenesisZeroFlow._GenesisZeroFlow.TempMonitoringFailed))
                    {
                        this.SetRefTemperature(Avg.ElementAt(0));
                    }
                    else
                    {
                        GenesisZeroFlow.Display.DebugMessage($"{this.PcbID}\tDATA CHANNEL:\t\t Automatic temperature acquisition not possible at {this.MeterType}{this.MeterIndex}\n", this.Culture);
                        this.ClearData();
                        return false;
                    }
                }
                #endregion
            }
            #endregion
            #region Set temperature calibration register
            UInt32 TempToRegister = (UInt32)(this.RefTemp * 4096);
            GenesisZeroFlow.Display.StatusLabel(GenesisZeroFlow.PredefinedMessages.WaitUntilRegisterWriteFinished(Culture));
            GenesisZeroFlow.Display.DebugMessage($"{this.PcbID}\tCOMMAND CHANNEL:\t Writing 0x{TempToRegister.ToString("X", this.Culture)} to 'Temperature calibration'-register at {this.MeterType}{this.MeterIndex}\n", this.Culture);
            Ok = GenesisMeter.WriteRegisterUnsafe(Register.Genesisflow.ToFTempCalibrate, TempToRegister);

            if (Ok)
                GenesisZeroFlow.Display.DebugMessage($"{this.PcbID}\tCOMMAND CHANNEL:\t Writing 0x{TempToRegister.ToString("X", this.Culture)} to 'Temperature calibration'-register successful at {this.MeterType}{this.MeterIndex}\n", this.Culture);
            else
                GenesisZeroFlow.Display.DebugMessage($"{this.PcbID}\tCOMMAND CHANNEL:\t Writing 0x{TempToRegister.ToString("X", this.Culture)} to 'Temperature calibration'-register failed at {this.MeterType}{this.MeterIndex}\n", this.Culture);

            if (!Ok || GenesisZeroFlow._GenesisZeroFlow.TempMonitoringFailed)
                return false;
            #endregion
            #region Wait for some seconds
            const UInt16 WaitingTime = 10;
            Int32[] LinecounterFollowing = new Int32[Constants.NumberOfPaths];
            LinecounterFollowing = ArrayInit.Path(0);
            // GenesisZeroFlow._GenesisZeroFlow.SetLoggingIndicatorAmplitudeTest(this.MeterNumber, true);
            for (UInt16 Time = 0; Time < WaitingTime; Time++)
            {
                Ok = this.ActivityCheck(ref LinecounterFollowing, Time);
                if (Ok && !GenesisZeroFlow._GenesisZeroFlow.TempMonitoringFailed)
                {
                    var Seconds = WaitingTime - Time;

                    GenesisZeroFlow.Display.StatusLabel(GenesisZeroFlow.PredefinedMessages.WaitSeconds(Seconds, this.Culture));
                    Misc.WaitNSeconds(1);
                }
                else
                {
                    GenesisZeroFlow.Display.DebugMessage($"{this.PcbID}\tDATA CHANNEL:\t\t Activity check failed at {this.MeterType}{this.MeterIndex}\n", this.Culture);
                    GenesisZeroFlow._GenesisZeroFlow.SetTofIndicatorAmplitudeTest(this.MeterNumber, false);
                    this.ClearData();
                    
                    return false;
                }

                if (token.IsCancellationRequested || GenesisZeroFlow._GenesisZeroFlow.TempMonitoringFailed)
                    return false;
            }
            GenesisZeroFlow._GenesisZeroFlow.SetTofIndicatorAmplitudeTest(this.MeterNumber, false);
            #endregion
            #region Check temperature
            Ok = this.CheckTemperature(NumberOfAvgValues, out DebugMessage);
            if (Boolean.Equals(Ok, true))
                GenesisZeroFlow.Display.DebugMessage($"{this.PcbID}\tAPPLICATION:\t\t Temperature check OK at {this.MeterType}{this.MeterIndex}\n", this.Culture);
            else
                GenesisZeroFlow.Display.DebugMessage($"{this.PcbID}\tAPPLICATION:\t\t Temperature check failed at {this.MeterType}{this.MeterIndex}\n", this.Culture);
            GenesisZeroFlow.Display.DebugMessage($"{this.PcbID}\tAPPLICATION:\t\t Temperatures at {this.MeterType}{this.MeterIndex}: {DebugMessage}", this.Culture);
            #endregion
            #region Get 'TOF offset1' register
            if (Constants.NumberOfPaths > 0)
            {
                GenesisZeroFlow.Display.StatusLabel(GenesisZeroFlow.PredefinedMessages.WaitUntilRegisterReadFinished(this.Culture));
                Ok = false;
                if (token.IsCancellationRequested || GenesisZeroFlow._GenesisZeroFlow.TempMonitoringFailed)
                    return false;
                GenesisZeroFlow.Display.DebugMessage($"{this.PcbID}\tCOMMAND CHANNEL:\t Reading 'TOF offset1'-register at {this.MeterType}{this.MeterIndex}\n", this.Culture);
                var tmp = BitConverter.ToInt32(GenesisMeter.ReadRegister(Register.Genesisflow.ToFTempOffset1), 0);
                GenesisZeroFlow._GenesisZeroFlow.SetToFTempOffset(this.MeterNumber, Constants.PATH0, tmp);
                Ok = true;
                if (Boolean.Equals(Ok, true))
                    GenesisZeroFlow.Display.DebugMessage($"{this.PcbID}\tCOMMAND CHANNEL:\t Reading 'TOF offset1'-register successful at {this.MeterType}{this.MeterIndex}\n", this.Culture);
                else
                    GenesisZeroFlow.Display.DebugMessage($"{this.PcbID}\tCOMMAND CHANNEL:\t Reading 'TOF offset1'-register failed at {this.MeterType}{this.MeterIndex}\n", this.Culture);
                if (Boolean.Equals(Ok, false) || GenesisZeroFlow._GenesisZeroFlow.TempMonitoringFailed)
                    return false;
            }
            #endregion
            #region Get 'TOF offset2' register
            if (Constants.NumberOfPaths > 1)
            {
                GenesisZeroFlow.Display.StatusLabel(GenesisZeroFlow.PredefinedMessages.WaitUntilRegisterReadFinished(this.Culture));
                Ok = false;
                if (token.IsCancellationRequested || GenesisZeroFlow._GenesisZeroFlow.TempMonitoringFailed)
                    return false;
                GenesisZeroFlow.Display.DebugMessage($"{this.PcbID}\tCOMMAND CHANNEL:\t Reading 'TOF offset2'-register at {this.MeterType}{this.MeterIndex}\n", this.Culture);

                var tmp = BitConverter.ToInt32(GenesisMeter.ReadRegister(Register.Genesisflow.ToFTempOffset2), 0);
                GenesisZeroFlow._GenesisZeroFlow.SetToFTempOffset(this.MeterNumber, Constants.PATH1, tmp);
                Ok = true;
                if (Boolean.Equals(Ok, true) || GenesisZeroFlow._GenesisZeroFlow.TempMonitoringFailed)
                    GenesisZeroFlow.Display.DebugMessage($"{this.PcbID}\tCOMMAND CHANNEL:\t Reading 'TOF offset2'-register successful at {this.MeterType}{this.MeterIndex}\n", this.Culture);
                else
                    GenesisZeroFlow.Display.DebugMessage($"{this.PcbID}\tCOMMAND CHANNEL:\t Reading 'TOF offset2'-register failed at {this.MeterType}{this.MeterIndex}\n", this.Culture);
                if (Boolean.Equals(Ok, false) || GenesisZeroFlow._GenesisZeroFlow.TempMonitoringFailed)
                    return false;
            }
            #endregion
            #region Get 'TOF offset3' register
            if (Constants.NumberOfPaths > 2)
            {
                GenesisZeroFlow.Display.StatusLabel(GenesisZeroFlow.PredefinedMessages.WaitUntilRegisterReadFinished(this.Culture));
                Ok = false;
                if (token.IsCancellationRequested || GenesisZeroFlow._GenesisZeroFlow.TempMonitoringFailed)
                    return false;
                GenesisZeroFlow.Display.DebugMessage($"{this.PcbID}\tCOMMAND CHANNEL:\t Reading 'TOF offset3'-register at {this.MeterType}{this.MeterIndex}\n", this.Culture);
                var tmp = BitConverter.ToInt32(GenesisMeter.ReadRegister(Register.Genesisflow.ToFTempOffset3), 0);
                GenesisZeroFlow._GenesisZeroFlow.SetToFTempOffset(this.MeterNumber, Constants.PATH2, tmp);
                Ok = true;
                if (Boolean.Equals(Ok, true))
                    GenesisZeroFlow.Display.DebugMessage($"{this.PcbID}\tCOMMAND CHANNEL:\t Reading 'TOF offset3'-register successful at {this.MeterType}{this.MeterIndex}\n", this.Culture);
                else
                    GenesisZeroFlow.Display.DebugMessage($"{this.PcbID}\tCOMMAND CHANNEL:\t Reading 'TOF offset3'-register failed at {this.MeterType}{this.MeterIndex}\n", this.Culture);
                if (Boolean.Equals(Ok, false) || GenesisZeroFlow._GenesisZeroFlow.TempMonitoringFailed)
                    return false;
            }
            #endregion

            this.ClearData();
            return Ok;
        }
        private Boolean PerformTestTempCal()
        {
            this.ClearDataTempCal();

            #region Definitions and initializations
            Boolean Ok = false;
            String DebugMessage = String.Empty;
            #endregion

            UInt32 TempToRegister = (UInt32)(RefTemp * 4096);


            try
            {
                #region Set temperature calibration register
                frmTempCalibration.DisplayTempCal.StatusLabel("Wait until register write has finished");

                frmTempCalibration.DisplayTempCal.DebugMessage($"COMMAND CHANNEL:\t Writing 0x{TempToRegister.ToString("X", this.Culture)} to 'Temperature calibration'-register\n", this.Culture);
                var temp = BitConverter.GetBytes(TempToRegister);
                Ok = GenesisMeter.WriteRegisterUnsafe(Register.Genesisflow.ToFTempCalibrate, temp);

                if (Ok)
                    frmTempCalibration.DisplayTempCal.DebugMessage($"COMMAND CHANNEL:\t Writing 0x{TempToRegister.ToString("X", this.Culture)} to 'Temperature calibration'-register successful\n", this.Culture);
                else
                    frmTempCalibration.DisplayTempCal.DebugMessage($"COMMAND CHANNEL:\t Writing 0x{TempToRegister.ToString("X", this.Culture)} to 'Temperature calibration'-register failed\n", this.Culture);
                if (!Ok)
                    return false;
                #endregion
                #region Wait for some seconds
                const UInt16 WaitingTime = 20;
                Int32[] LinecounterFollowing = new Int32[Constants.NumberOfPaths];
                LinecounterFollowing = ArrayInit.Path(0);
                frmTempCalibration._frmTempCalibration.SetEnableIndicatorTempTest(true);
                for (UInt16 Time = 0; Time < WaitingTime; Time++)
                {
                    Ok = this.ActivityCheckTempCal(ref LinecounterFollowing, Time);
                    if (Ok)
                    {
                        frmTempCalibration.DisplayTempCal.StatusLabel($"Wait {(WaitingTime - Time).ToString(this.Culture)} seconds");
                        Misc.WaitNSeconds(1);
                    }
                    else
                    {
                        frmTempCalibration.DisplayTempCal.DebugMessage($"DATA CHANNEL:\t\t Activity check failed\n", this.Culture);
                        frmTempCalibration._frmTempCalibration.SetEnableIndicatorTempTest(false);
                        this.ClearDataTempCal();
                        return false;
                    }
                }
                frmTempCalibration._frmTempCalibration.SetEnableIndicatorTempTest(false);
                #endregion
                #region Check temperature
                Ok = this.CheckTemperatureTempCal(out DebugMessage);
                if (Ok)
                    frmTempCalibration.DisplayTempCal.DebugMessage($"APPLICATION:\t\t Temperature check OK\n", this.Culture);
                else
                    frmTempCalibration.DisplayTempCal.DebugMessage($"APPLICATION:\t\t Temperature check failed\n", this.Culture);
                frmTempCalibration.DisplayTempCal.DebugMessage($"APPLICATION:\t\t Temperatures: {DebugMessage}", this.Culture);
                #endregion
                this.ClearDataTempCal();
            }
            catch (Exception ex)
            {
                ErrorLog.Log(LogErrReason.Exeption, "TempCalibration.PerformTestTempCal() failed", $"0x{ex.HResult.ToString("X", Culture)}", String.Empty, Culture);
                this.ClearDataTempCal();
            }
            return Ok;
        }
        private Boolean PerformTempMonitoring(CancellationToken token)
        {
            this.ClearData();

            #region Definitions and initializations
            Int32[] LinecounterFollowing = new Int32[Constants.NumberOfPaths];
            LinecounterFollowing = ArrayInit.Path(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}");
                            GenesisZeroFlow._GenesisZeroFlow.SetMeasuredTemps(Constants.Meter1, Path, temp);
                            GenesisZeroFlow._GenesisZeroFlow.SetMeasuredTempsIndicator(Constants.Meter1, Path, true);
                            break;
                        case Constants.Meter2:
                            GenesisZeroFlow.Display.SetThermoLabel2($"{Temperature}°C");
                            GenesisZeroFlow._GenesisZeroFlow.SetMeasuredTemps(Constants.Meter2, Path, temp);
                            GenesisZeroFlow._GenesisZeroFlow.SetMeasuredTempsIndicator(Constants.Meter2, Path, true);
                            break;
                        default: break;
                    }

                    if (temp > this.UpperTempLimit)
                    {
                        GenesisZeroFlow._GenesisZeroFlow.TempMonitoringFailed = true;
                        GenesisZeroFlow.Display.DebugMessage($"{this.PcbID}\tDATA CHANNEL:\t\t TEMPERATURE MONITORING upper value check failed at {this.MeterType}{this.MeterIndex}; (actual/ limit) = {Temperature}/ {Math.Round(this.UpperTempLimit, 2).ToString("00.000", this.Culture)}°C\n", this.Culture);
                        return false;
                    }
                    GenesisZeroFlow.Display.DebugMessage($"{this.PcbID}\tDATA CHANNEL:\t\t TEMPERATURE MONITORING upper value successful at {this.MeterType}{this.MeterIndex}; Value = {Temperature}\t\n", this.Culture);

                    if (temp < this.LowerTempLimit)
                    {
                        GenesisZeroFlow._GenesisZeroFlow.TempMonitoringFailed = true;
                        GenesisZeroFlow.Display.DebugMessage($"{this.PcbID}\tDATA CHANNEL:\t\t TEMPERATURE MONITORING lower value check failed at {this.MeterType}{this.MeterIndex}; (actual/ limit) = {Temperature}/ {Math.Round(this.LowerTempLimit, 2).ToString("00.000", this.Culture)}°C\n", this.Culture);
                        return false;
                    }
                    GenesisZeroFlow.Display.DebugMessage($"{this.PcbID}\tDATA CHANNEL:\t\t TEMPERATURE MONITORING lower value successful at {this.MeterType}{this.MeterIndex}; Value = {Temperature}\n", this.Culture);
                    #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 = $"{DeviationValue.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, "TempCalibration.PerformTemperatureMonitoring() failed", $"0x{ex.HResult.ToString("X", this.Culture)}", String.Empty, this.Culture);
                }
            }
            #endregion
            #endregion
            return Ok;
        }
        private Boolean CheckTemperature(UInt16 numberOfAvgValues, out String debugMessage)
        {
            #region Definitions and initializations
            Double[] MeasTemperature = new Double[Constants.NumberOfPaths];
            Boolean TempOk = true;
            List<Double>[] AvgValues = new List<Double>[Constants.NumberOfPaths];
            Double Avg = 0;

            #endregion
            for (UInt16 Path = Constants.PATH0; Path < Constants.NumberOfPaths; Path++)
            {
                AvgValues[Path] = new List<Double>();
                for (UInt16 Values = 0; Values < numberOfAvgValues; Values++)
                {
                    MeasTemperature[Path] = GenesisZeroFlow._GenesisZeroFlow.GetDecodedAllMeters()[this.MeterNumber][Path].TemperatureDegC;
                    AvgValues[Path].Add(MeasTemperature[Path]);
                }
                Avg = AvgValues[Path].Average();
                AvgValues[Path].Clear();
                if (Math.Abs(this.RefTemp - Avg) > this.TempDeviationLimit)
                    TempOk = false;
            }

            #region Debug message
            debugMessage = $"Ref. temp = {Math.Round(this.RefTemp, 2).ToString("00.00", this.Culture)}°C at {this.MeterType}{this.MeterIndex}; meas. PATH"; // meas. temp PATH1/2/3 = {Math.Round(MeasTemperature[Constants.PATH0], 2).ToString("00.00", this.Culture)}°C/ {Math.Round(MeasTemperature[Constants.PATH1], 2).ToString("00.00", this.Culture)}°C/ {Math.Round(MeasTemperature[Constants.PATH2], 2).ToString("0.00", this.Culture)}°C\n";
            for (UInt16 Path = Constants.PATH0; Path < Constants.NumberOfPaths; Path++)
            {
                debugMessage = $"{debugMessage}{Path}";
                if ((Constants.NumberOfPaths - 1) == Path)
                    debugMessage = $"{debugMessage}/";
                else
                    debugMessage = $"{debugMessage} = ";
            }
            for (UInt16 Path = Constants.PATH0; Path < Constants.NumberOfPaths; Path++)
            {
                if ((Constants.NumberOfPaths - 1) == Path)
                    debugMessage = $"{debugMessage}{Math.Round(MeasTemperature[Path], 2).ToString("00.00", this.Culture)}°C /";
                else
                    debugMessage = $"{debugMessage}{Math.Round(MeasTemperature[Path], 2).ToString("00.00", this.Culture)}°C\n";
            }
            #endregion

            return TempOk;
        }
        private Boolean CheckTemperatureTempCal(out String debugMessage)
        {
            #region Definitions and initializations
            Double[] MeasTemperature = new Double[Constants.NumberOfPaths];
            MeasTemperature = ArrayInit.Path((Double)0);
            Boolean TempOk = true;
            #endregion
            for (UInt16 Path = Constants.PATH0; Path < Constants.NumberOfPaths; Path++)
            {
                MeasTemperature[Path] = frmTempCalibration._frmTempCalibration.GetDecodedAllMeters()[Path].TemperatureDegC;
                if (Math.Abs(this.RefTemp - MeasTemperature[Path]) > this.TempDeviationLimit)
                    TempOk = false;
            }

            #region Debug message
            debugMessage = $"ref. temperature = {this.RefTemp.ToString("00.00", this.Culture)}°C; meas. temperature ";
            for (UInt16 Path = Constants.PATH0; Path < Constants.NumberOfPaths; Path++)
                debugMessage = $"{ debugMessage} PATH{(Path + 1).ToString(this.Culture)} = {Math.Round(MeasTemperature[Path], 2).ToString("00.00", this.Culture)}°C;";
            debugMessage = $"{debugMessage}\n";
            #endregion

            for (UInt16 Path = Constants.PATH0; Path < Constants.NumberOfPaths; Path++)
                frmTempCalibration.DisplayTempCal.TempCalSetTemperatureLabel(Path, Math.Round(MeasTemperature[Path], 2).ToString("0.00", this.Culture));
       
            frmTempCalibration.DisplayTempCal.TempCalRefTemperatureLabel(this.RefTemp.ToString("0.00", this.Culture));
            return TempOk;
        }
        private void ClearData()
        {
            for (UInt16 Path = Constants.PATH0; Path < Constants.NumberOfPaths; Path++)
            {

                // GenesisZeroFlow.Display.EraseAmplitudeData(this.MeterNumber, Path);
                // GenesisZeroFlow._GenesisZeroFlow.SetLoggingIndicatorAmplitudeTest(this.MeterNumber, false);
                // GenesisZeroFlow._GenesisZeroFlow.ClearTotalTimeOfFlightAverage(this.MeterNumber, Path);
                // GenesisZeroFlow._GenesisZeroFlow.SetToFTempOffset(this.MeterNumber, Path, 0);
            }
        }
        private void ClearDataTempCal()
        {
            for (UInt16 Path = Constants.PATH0; Path < Constants.NumberOfPaths; Path++)
                frmTempCalibration._frmTempCalibration.SetToFTempOffset(Path, 0);
        }
        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.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) && (Int32.Equals(GenesisZeroFlow._GenesisZeroFlow.GetLineCounterTemperatureTest()[this.MeterNumber][Path], 0)))
            //        return false;
            //}
            #endregion
            #region Result
            Ok = !Error;
            #endregion

            return Ok;
        }
        private Boolean ActivityCheckTempCal(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(frmTempCalibration._frmTempCalibration.GetLineCounterTemperatureTest()[Path], 0)))
                {
                    if (Int32.Equals(frmTempCalibration._frmTempCalibration.GetLineCounterTemperatureTest()[Path], lineCounterFollowing[Path]))
                        return false;
                    else
                        lineCounterFollowing[Path] = frmTempCalibration._frmTempCalibration.GetLineCounterTemperatureTest()[Path];

                }
                if ((seconds > 0) && (Int32.Equals(frmTempCalibration._frmTempCalibration.GetLineCounterTemperatureTest()[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;
        }
        public void SetRefTemperature(Double temp)
        {
            this.RefTemp = temp;
        }

        public void Initialize(String pcbID, String meterType, Double refTemp, Double upperTempLimit, Double lowerTempLimit, Double tempDeviationLimit)
        {
            this.RefTemp = refTemp;
            this.UpperTempLimit = upperTempLimit;
            this.LowerTempLimit = lowerTempLimit;
            this.TempDeviationLimit = tempDeviationLimit;
            this.MeterType = meterType;
            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.PcbID = pcbID;
        }
        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 RefTemp { get; set; }
        private Double UpperTempLimit { get; set; }
        private Double LowerTempLimit { get; set; }
        private Double TempDeviationLimit { get; set; }
        private Double[] TempDeviationMin { get; set; }
        private Double[] GetTempDeviationMin()
        {
            return (Double[])this.TempDeviationMin;
        }
        private Double[] TempDeviationMax { get; set; }
        private Double[] GetTempDeviationMax()
        {
            return (Double[])this.TempDeviationMax;
        }
        
    }
}