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 PreparationSequences
    {
        public static Boolean[] Total(MeterBatch globalMeterBatch, MeterBatch thermoMeterBatch, UInt16 meterSize, Boolean setOffsetToZero, Double upperTempLimit, Double lowerTempLimit, Double tempDeviationLimit, out Boolean aborted, CultureInfo culture)
        {
            #region Definitions and initializations
            aborted = false;
            Int32 NextDelayTime = 0;
            Boolean[] MeterTaskStarted = new Boolean[Constants.NumberOfMeters];
            Boolean[] MeterSequenceFailed = new Boolean[Constants.NumberOfMeters];
            Boolean[] MeterTaskCompleted = new Boolean[Constants.NumberOfMeters];
            Boolean[] ThermoTaskStarted = new Boolean[Constants.NumberOfThermometers];
            Boolean[] ThermoSequenceFailed = new Boolean[Constants.NumberOfThermometers];
            Boolean[] ThermoTaskCompleted = new Boolean[Constants.NumberOfThermometers];
            MeterTaskStarted = ArrayInit.Meter(false);
            MeterSequenceFailed = ArrayInit.Meter(false);
            MeterTaskCompleted = ArrayInit.Meter(false);
            ThermoTaskStarted = ArrayInit.Thermo(false);
            ThermoSequenceFailed = ArrayInit.Thermo(false);
            ThermoTaskCompleted = ArrayInit.Thermo(false);

            var listPrep = new List<Preparation>();
            var listThermoPrep = new List<Preparation>();

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

                if (currentMeter != null)
                    listPrep.Add(new Preparation(currentMeter, Meter, culture));
                else
                    listPrep.Add(new Preparation(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)
                    listThermoPrep.Add(new Preparation(currentMeter, Thermo, culture));
                else
                    listThermoPrep.Add(new Preparation(Thermo, culture));
            }

            foreach (var meterprep in listPrep)
                meterprep.Initialize(GenesisZeroFlow._GenesisZeroFlow.PcbID[meterprep.MeterNumber], Constants.Meter, meterSize, setOffsetToZero, PreparationValues.Samplerate, 0, 0, 0);
            foreach (var thermoprep in listThermoPrep)
                thermoprep.Initialize(GenesisZeroFlow._GenesisZeroFlow.ThermoID[thermoprep.MeterNumber], Constants.Thermo, meterSize, setOffsetToZero, 2, upperTempLimit, lowerTempLimit, tempDeviationLimit);
            #endregion

            using (CancellationTokenSource cancellationTokenSource = new CancellationTokenSource())
            {
                #region Everything else
                CancellationToken token = cancellationTokenSource.Token;

                foreach (var item in listPrep)
                    item.AddTask(new Task<Boolean>(() => { return true; }));
                foreach (var item in listThermoPrep)
                    item.AddTask(new Task<Boolean>(() => { return true; }));
                foreach (var meterprep in listPrep)
                    meterprep.Meter(ref MeterTaskStarted[meterprep.GetMeterNumber()], ref MeterSequenceFailed[meterprep.GetMeterNumber()], ref NextDelayTime, token);    
                foreach (var thermoprep in listThermoPrep)
                    thermoprep.Thermometer(ref ThermoTaskStarted[thermoprep.GetMeterNumber()], ref ThermoSequenceFailed[thermoprep.GetMeterNumber()], ref NextDelayTime, token);
                #endregion
                #region Wait for tasks (METER)
                Boolean[] MeterSequenceOk = new Boolean[Constants.NumberOfMeters];
                MeterSequenceOk = ArrayInit.Meter(false);

                while (!CheckArray(MeterTaskCompleted))
                {
                    if (GenesisZeroFlow._GenesisZeroFlow.AbortIndicator)
                    {
                        cancellationTokenSource.Cancel();
                        aborted = true;
                    }
                    listPrep.All(p => TaskOperations.WaitFor(p.MyTask));

                    Misc.WaitNSeconds(1);

                    for (UInt16 Meter = Constants.Meter1; Meter < Constants.NumberOfMeters; Meter++)
                    {
                        var prepToCheck = listPrep.First(p => p.GetMeterNumber().Equals(Meter));

                        if (prepToCheck != null && prepToCheck.CurrentMeter != null)
                            MeterTaskCompleted[Meter] = TaskOperations.WaitFor(true, prepToCheck.MyTask);
                        else
                            MeterTaskCompleted[Meter] = true;
                    }
                }

                for (UInt16 Meter = Constants.Meter1; Meter < Constants.NumberOfMeters; Meter++)
                {
                    var prepToCheck = listPrep.First(p => p.GetMeterNumber().Equals(Meter));

                    if (prepToCheck != null)
                        MeterSequenceOk[Meter] = !TaskOperations.GetResult(true, prepToCheck.MyTask);
                    else
                        MeterSequenceOk[Meter] = true;
                }

                GenesisZeroFlow.Display.MeterStatusGreenRed(MeterSequenceOk, MeterTaskStarted);

                foreach (var item in listPrep)
                    TaskOperations.CheckAndDispose(ref item.MyTask);
                #endregion
                #region Wait for tasks (Thermometer)
                Boolean[] ThermoSequenceOk = new Boolean[Constants.NumberOfThermometers];
                ThermoSequenceOk = ArrayInit.Thermo(false);

                while (!CheckArray(MeterTaskCompleted))
                {
                    if (GenesisZeroFlow._GenesisZeroFlow.AbortIndicator)
                    {
                        cancellationTokenSource.Cancel();
                        aborted = true;
                    }
                    listThermoPrep.All(p => TaskOperations.WaitFor(p.MyTask));

                    Misc.WaitNSeconds(1);

                    for (UInt16 Thermo = Constants.Thermo1; Thermo < Constants.NumberOfThermometers; Thermo++)
                    {
                        var prepToCheck = listThermoPrep.First(p => p.GetMeterNumber().Equals(Thermo));
                        if (prepToCheck != null && prepToCheck.CurrentMeter != null)
                            MeterTaskCompleted[Thermo] = TaskOperations.WaitFor(true, prepToCheck.MyTask);
                        else
                            MeterTaskCompleted[Thermo] = true;
                    }
                }

                for (UInt16 Meter = Constants.Meter1; Meter < Constants.NumberOfMeters; Meter++)
                {
                    var prepToCheck = listPrep.First(p => p.GetMeterNumber().Equals(Meter));

                    if (prepToCheck != null)
                        MeterSequenceOk[Meter] = !TaskOperations.GetResult(true, prepToCheck.MyTask);
                    else
                        MeterSequenceOk[Meter] = true;
                }
                for (UInt16 Thermo = Constants.Thermo1; Thermo < Constants.NumberOfThermometers; Thermo++)
                {
                    var prepToCheck = listThermoPrep.First(p => p.GetMeterNumber().Equals(Thermo));

                    if (prepToCheck != null)
                        ThermoSequenceOk[Thermo] = !TaskOperations.GetResult(true, prepToCheck.MyTask);
                    else
                        ThermoSequenceOk[Thermo] = true;
                }
                GenesisZeroFlow.Display.MeterStatusGreenRed(MeterSequenceOk, MeterTaskStarted);
                GenesisZeroFlow.Display.ThermoStatusGreenRed(ThermoSequenceOk, ThermoTaskStarted);

                foreach (var item in listPrep)
                    TaskOperations.CheckAndDispose(ref item.MyTask);
                foreach (var item in listThermoPrep)
                    TaskOperations.CheckAndDispose(ref item.MyTask);
                #endregion
            }

            return MeterSequenceFailed.Concat(ThermoSequenceFailed).ToArray();
        }
        public static Boolean TotalTempCal(MeterBatch globalMeterBatch, UInt16 meterSize, Double upperTempLimit, Double lowerTempLimit, Double tempDeviationLimit, CultureInfo culture)
        {
            #region Definitions and initializations
            Boolean SequenceFailed = false;
            Boolean TaskStarted = false;
            Boolean TaskCompleted = false;

            const Int32 Samplerate = PreparationValues.Samplerate; // 10;
            var listPrep = new List<Preparation>();
            var currentMeter = globalMeterBatch.ListOfMeters.FirstOrDefault(m => m.Slot.Equals(Constants.Meter1 + 1));
            if (currentMeter != null)
                listPrep.Add(new Preparation(currentMeter, Constants.Meter1, culture));
            else
                listPrep.Add(new Preparation(Constants.Meter1, culture));

            foreach (var prep in listPrep)
                prep.Initialize(String.Empty, Constants.Thermo, meterSize, false, Samplerate, upperTempLimit, lowerTempLimit, tempDeviationLimit);
            #endregion

            //using (CancellationTokenSource cancellationTokenSource = new CancellationTokenSource())
            //{
                #region Everything else
                //CancellationToken token = cancellationTokenSource.Token;
                var PrepTaskList = new List<Task<Boolean>>();

                foreach (var item in listPrep)
                    item.AddTask(new Task<Boolean>(() => { return true; }));
                foreach (var prep in listPrep)
                    prep.MeterTempCal(ref TaskStarted, ref SequenceFailed);
                #endregion
                #region Wait for tasks
                Boolean SequenceOk = false;
 
                while (!TaskCompleted)
                {
                    listPrep.All(p => TaskOperations.WaitFor(p.MyTask));

                    Misc.WaitNSeconds(1);
                    var prepToCheckTempCal = listPrep.First(p => p.GetMeterNumber().Equals(Constants.Meter1));
                    if (prepToCheckTempCal != null && prepToCheckTempCal.CurrentMeter != null)
                        TaskCompleted = TaskOperations.WaitFor(true, prepToCheckTempCal.MyTask);
                    else
                        TaskCompleted = true;
                }

                var prepToCheck = listPrep.First(p => p.GetMeterNumber().Equals(Constants.Meter1));
                if (prepToCheck != null)
                    SequenceOk = !TaskOperations.GetResult(true, prepToCheck.MyTask);
                else
                    SequenceOk = true;

                foreach (var item in listPrep)
                    TaskOperations.CheckAndDispose(ref item.MyTask);
                #endregion
            //}

            return SequenceFailed;
        }
        private static Boolean CheckArray(Boolean[] array)
        {
            Boolean Completed = true;
            for (Int16 i = 0; i < array.Count(); i++)
            {
                if (Boolean.Equals(array[i], false))
                    return false;
            }
            return Completed;
        }
    }

    public class Preparation
    {

        public ZeroFlowGenesisMeter CurrentMeter;
        public Task<Boolean> MyTask;
        internal void AddTask(Task<Boolean> task)
        {
            MyTask = task;
        }
        public Preparation(UInt16 meterNumber, CultureInfo culture)
        {
            this.MeterNumber = meterNumber;
            this.MeterIndex = (meterNumber + 1).ToString(culture);
            this.Culture = culture;  
        }
        public Preparation(IMeter currentMeter, UInt16 meterNumber, CultureInfo culture)
        {
            if (currentMeter is ZeroFlowGenesisMeter)
                this.CurrentMeter = (ZeroFlowGenesisMeter)currentMeter;
          
            this.MeterNumber = meterNumber;
            this.MeterIndex = (meterNumber + 1).ToString(culture);
            this.Culture = culture;
        }
        internal void Meter(ref Boolean taskStarted, ref Boolean sequenceFailed, ref Int32 nextDelayTime, CancellationToken token)
        {
            #region Definitions and initializations
            Boolean Ok = false;
            Boolean enable = CurrentMeter != null;
            DialogResult AskForActions = DialogResult.None;
            Int32 DelayTime = 0;
            const Int32 DeltaDelay = 5;
            #endregion

            if (enable)
            {
                DelayTime = nextDelayTime;
                nextDelayTime = nextDelayTime + DeltaDelay;
                Int32 temp = DelayTime;
                taskStarted = true;
          
                var _sequenceFailed = sequenceFailed;

                MyTask = Task.Run(() =>
                {
                    Misc.WaitNSeconds(temp);
                    while ((DialogResult.Equals(AskForActions, DialogResult.Retry)) || (DialogResult.Equals(AskForActions, DialogResult.None)))
                    {
                        #region Cancelation token
                        if (!token.IsCancellationRequested)
                            GenesisZeroFlow.Display.AbortButtonEnabled(true);
                        #endregion
                        #region Testprocedure
                        if (DialogResult.Equals(AskForActions, DialogResult.None))
                            GenesisZeroFlow.Display.DebugMessage($"{this.PcbID}\tAPPLICATION:\t\t PREPARATION started at {this.MeterType}{this.MeterIndex}\n", this.Culture);

                        Ok = PerformPreparationMeter(token);

                        if (token.IsCancellationRequested)
                        {                       
                            GenesisZeroFlow.Display.DebugMessage($"{this.PcbID}\tAPPLICATION:\t\t PREPARATION stopped 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.PreparationStopped(this.Culture), GenesisZeroFlow._GenesisZeroFlow.GetLoggingFromTextBox(), this.Culture);
                            return true;
                        }
                        if (Ok)
                        {
                            GenesisZeroFlow.Display.DebugMessage($"{this.PcbID}\tAPPLICATION:\t\t PREPARATION successful at {this.MeterType}{this.MeterIndex}\n", this.Culture);
                            GenesisZeroFlow.Display.DebugMessage($"{Constants.TwentySpaces}\t{Debugmessages.Line}", this.Culture);
                            _sequenceFailed = false;

                            AskForActions = DialogResult.OK;
                        }
                        else
                        {
                            _sequenceFailed = true;
                            AskForActions = DialogResult.Cancel;
                            GenesisZeroFlow._GenesisZeroFlow.GenerateReturnNote(this.MeterIndex, this.PcbID, GenesisZeroFlow.PredefinedMessages.PreparationFailed(this.Culture), GenesisZeroFlow._GenesisZeroFlow.GetLoggingFromTextBox(), this.Culture);
                        }
                        #endregion
                    }

                    return _sequenceFailed;
                });
            }
        }
        internal void Thermometer(ref Boolean taskStarted, ref Boolean sequenceFailed, ref Int32 nextDelayTime, CancellationToken token)
        {
            Boolean enable = CurrentMeter != null;
            #region Definitions and initializations
            Boolean Ok = false;
            DialogResult AskForActions = DialogResult.None;
            Int32 DelayTime = 0;
            const Int32 DeltaDelay = 5;
            #endregion

            if (enable)
            {

                DelayTime = nextDelayTime;
                nextDelayTime = nextDelayTime + DeltaDelay;
                Int32 temp = DelayTime;
                taskStarted = true;
                
                var _sequenceFailed = sequenceFailed;

                MyTask = Task.Run(() =>
                {
                    Misc.WaitNSeconds(temp);
                    while ((DialogResult.Equals(AskForActions, DialogResult.Retry)) || (DialogResult.Equals(AskForActions, DialogResult.None)))
                    {
                        #region Cancelation token
                        if (!token.IsCancellationRequested)
                            GenesisZeroFlow.Display.AbortButtonEnabled(true);
                        #endregion
                        #region Testprocedure
                        if (DialogResult.Equals(AskForActions, DialogResult.None))
                            GenesisZeroFlow.Display.DebugMessage($"{this.PcbID}\tAPPLICATION:\t\t PREPARATION started at {this.MeterType}{this.MeterIndex}\n", this.Culture);

                        Ok = PerformPreparationThermometer(token);

                        if (token.IsCancellationRequested)
                        {
                            GenesisZeroFlow.Display.DebugMessage($"{this.PcbID}\tAPPLICATION:\t\t PREPARATION stopped at {this.MeterType}{this.MeterIndex}\n", this.Culture);
                            GenesisZeroFlow.Display.DebugMessage($"{Constants.TwentySpaces}\t{Debugmessages.Line}", this.Culture);
                            GenesisZeroFlow.Display.AbortButtonEnabled(false);
                            return true;
                        }
                        if (Ok)
                        {
                            GenesisZeroFlow.Display.DebugMessage($"{this.PcbID}\tAPPLICATION:\t\t PREPARATION successful at {this.MeterType}{this.MeterIndex}\n", this.Culture);
                            GenesisZeroFlow.Display.DebugMessage($"{Constants.TwentySpaces}\t{Debugmessages.Line}", this.Culture);
                            _sequenceFailed = false;

                            AskForActions = DialogResult.OK;
                        }
                        else
                        {
                            _sequenceFailed = true;
                            AskForActions = DialogResult.Cancel;
                        }
                        #endregion
                    }

                    return _sequenceFailed;
                });
            }
        }
        internal void MeterTempCal(ref Boolean taskStarted, ref Boolean sequenceFailed)
        {
            Boolean enable = CurrentMeter != null;
            #region Definitions and initializations
            Boolean Ok = false;
            String DebugMessage = String.Empty;
            DialogResult AskForActions = DialogResult.None;
            #endregion

            if (enable)
            {
                taskStarted = true;
                var _sequenceFailed = sequenceFailed;
                //var _logOn = logOn;
                //Boolean ReAuthentication = false;

                MyTask = Task.Run(() =>
                {
                    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 PREPARATION sequence started\n", this.Culture);

                        Ok = PerformPreparationTempCal();
                        if (Ok)
                        {
                            frmTempCalibration.DisplayTempCal.DebugMessage("APPLICATION:\t\t PREPARATION sequence successful\n", this.Culture);
                            frmTempCalibration.DisplayTempCal.DebugMessage(Debugmessages.Line, this.Culture);
                            _sequenceFailed = false;

                            AskForActions = DialogResult.OK;
                        }
                        else
                        {
                            frmTempCalibration.DisplayTempCal.DebugMessage("APPLICATION:\t\t PREPARATION sequence failed\n", this.Culture);
                            frmTempCalibration.DisplayTempCal.DebugMessage(Debugmessages.Line, this.Culture);
                            _sequenceFailed = true;
                        }
                        #endregion
                    }
                    AskForActions = DialogResult.None;

                    return _sequenceFailed;
                });
            }
        }
        private Boolean PerformPreparationMeter(CancellationToken token)
        {
            #region Definitions and initialisations   
            Boolean Ok = false;
            #endregion
            #region Calibration factor1
            if (Constants.NumberOfPaths > 0)
            {
                GenesisZeroFlow.Display.DebugMessage($"{this.PcbID}\tCOMMAND CHANNEL:\t Writing to 'Calibration factor1'-register at {this.MeterType}{this.MeterIndex}\n", this.Culture);
                Ok = CurrentMeter.WriteRegisterSafe(Register.Genesisflow.CalFactor1, this.CalibrationFactor1);
                if (Ok)
                    GenesisZeroFlow.Display.DebugMessage($"{this.PcbID}\tCOMMAND CHANNEL:\t Writing to 'Calibration factor1'-register successful at {this.MeterType}{this.MeterIndex}\n", this.Culture);
                else
                    GenesisZeroFlow.Display.DebugMessage($"{this.PcbID}\tCOMMAND CHANNEL:\t Writing to 'Calibration factor1'-register failed at {this.MeterType}{this.MeterIndex}\n", this.Culture);

                if (Boolean.Equals(Ok, false))
                    return false;
            }
            #endregion
            #region Calibration factor2
            if (Constants.NumberOfPaths > 1)
            {
                GenesisZeroFlow.Display.DebugMessage($"{this.PcbID}\tCOMMAND CHANNEL:\t Writing to 'Calibration factor2'-register at {this.MeterType}{this.MeterIndex}\n", this.Culture);
                Ok = CurrentMeter.WriteRegisterSafe(Register.Genesisflow.CalFactor2, this.CalibrationFactor2);
                if (Ok)
                    GenesisZeroFlow.Display.DebugMessage($"{this.PcbID}\tCOMMAND CHANNEL:\t Writing to 'Calibration factor2'-register successful at {this.MeterType}{this.MeterIndex}\n", this.Culture);
                else
                    GenesisZeroFlow.Display.DebugMessage($"{this.PcbID}\tCOMMAND CHANNEL:\t Writing to 'Calibration factor2'-register failed at {this.MeterType}{MeterIndex}\n", this.Culture);

                if (Boolean.Equals(Ok, false))
                    return false;
            }
            #endregion
            #region Calibration factor3
            if (Constants.NumberOfPaths > 2)
            {
                GenesisZeroFlow.Display.DebugMessage($"{this.PcbID}\tCOMMAND CHANNEL:\t Writing to 'Calibration factor3'-register at {this.MeterType}{this.MeterIndex}\n", this.Culture);
                Ok = CurrentMeter.WriteRegisterSafe(Register.Genesisflow.CalFactor3, this.CalibrationFactor3);
                if (Ok)
                    GenesisZeroFlow.Display.DebugMessage($"{this.PcbID}\tCOMMAND CHANNEL:\t Writing to 'Calibration factor3'-register successful at {this.MeterType}{this.MeterIndex}\n", this.Culture);
                else
                    GenesisZeroFlow.Display.DebugMessage($"{this.PcbID}\tCOMMAND CHANNEL:\t Writing to 'Calibration factor3'-register failed at {this.MeterType}{this.MeterIndex}\n", this.Culture);

                if (Boolean.Equals(Ok, false))
                    return false;
            }
            #endregion

            if (SetOffsetToZero)
            {
                if (Constants.NumberOfPaths > 0)
                {
                    #region Zeroflow Offset1
                    if (token.IsCancellationRequested)
                        return false;

                    GenesisZeroFlow.Display.DebugMessage($"{this.PcbID}\tCOMMAND CHANNEL:\t Writing to 'Zeroflow offset1'-register at {this.MeterType}{this.MeterIndex}\n", this.Culture);
                    Ok = CurrentMeter.WriteRegisterSafe(Register.Genesisflow.ZeroOffset1, this.ZeroOffset1);
                    if (Ok)
                        GenesisZeroFlow.Display.DebugMessage($"{this.PcbID}\tCOMMAND CHANNEL:\t Writing to 'Zeroflow offset1'-register successful at {this.MeterType}{this.MeterIndex}\n", this.Culture);
                    else
                        GenesisZeroFlow.Display.DebugMessage($"{this.PcbID}\tCOMMAND CHANNEL:\t Writing to 'Zeroflow offset1'-register failed at {this.MeterType}{this.MeterIndex}\n", this.Culture);

                    if (Boolean.Equals(Ok, false))
                        return false;
                }
                #endregion
                #region Zeroflow Offset2
                if (Constants.NumberOfPaths > 1)
                {
                    if (token.IsCancellationRequested)
                        return false;

                    GenesisZeroFlow.Display.DebugMessage($"{this.PcbID}\tCOMMAND CHANNEL:\t Writing to 'Zeroflow offset2'-register at {this.MeterType}{this.MeterIndex}\n", this.Culture);
                    Ok = CurrentMeter.WriteRegisterSafe(Register.Genesisflow.ZeroOffset2, this.ZeroOffset2);
                    if (Ok)
                        GenesisZeroFlow.Display.DebugMessage($"{this.PcbID}\tCOMMAND CHANNEL:\t Writing to 'Zeroflow offset2'-register successful at {this.MeterType}{this.MeterIndex}\n", this.Culture);
                    else
                        GenesisZeroFlow.Display.DebugMessage($"{this.PcbID}\tCOMMAND CHANNEL:\t Writing to 'Zeroflow offset2'-register failed at {this.MeterType}{this.MeterIndex}\n", this.Culture);

                    if (Boolean.Equals(Ok, false))
                        return false;
                }
                #endregion
                #region Zeroflow Offset3
                if (Constants.NumberOfPaths > 2)
                {
                    if (token.IsCancellationRequested)
                        return false;

                    GenesisZeroFlow.Display.DebugMessage($"{this.PcbID}\tCOMMAND CHANNEL:\t Writing to 'Zeroflow offset3'-register at {this.MeterType}{this.MeterIndex}\n", this.Culture);
                    Ok = CurrentMeter.WriteRegisterSafe(Register.Genesisflow.ZeroOffset3, this.ZeroOffset3);
                    if (Ok)
                        GenesisZeroFlow.Display.DebugMessage($"{this.PcbID}\tCOMMAND CHANNEL:\t Writing to 'Zeroflow offset3'-register successful at {this.MeterType}{this.MeterIndex}\n", this.Culture);
                    else
                        GenesisZeroFlow.Display.DebugMessage($"{this.PcbID}\tCOMMAND CHANNEL:\t Writing to 'Zeroflow offset3'-register failed at {this.MeterType}{this.MeterIndex}\n", this.Culture);

                    if (Boolean.Equals(Ok, false))
                        return false;
                }
                #endregion
            }
            #region Sample rate
            Ok = false;
            if (token.IsCancellationRequested)
                return false;

            GenesisZeroFlow.Display.DebugMessage($"{this.PcbID}\tCOMMAND CHANNEL:\t Writing to 'Samplerate'-register at {this.MeterType}{this.MeterIndex}\n", this.Culture);
            Ok = CurrentMeter.WriteRegisterSafe(Register.Genesisflow.SampleRate, this.SampleRate);

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

            if (Boolean.Equals(Ok, false))
                return false;
            #endregion
            #region MeterSize
            if (token.IsCancellationRequested)
                return false;

            GenesisZeroFlow.Display.DebugMessage($"{this.PcbID}\tCOMMAND CHANNEL:\t Writing to 'Metersize'-register at {this.MeterType}{this.MeterIndex}\n", this.Culture);
            Ok = CurrentMeter.WriteRegisterSafe(Register.Genesisflow.MeterSize, this.MeterSize);
            if (Ok)
                GenesisZeroFlow.Display.DebugMessage($"{this.PcbID}\tCOMMAND CHANNEL:\t Writing to 'Metersize'-register successful at {this.MeterType}{this.MeterIndex}\n", this.Culture);
            else
                GenesisZeroFlow.Display.DebugMessage($"{this.PcbID}\tCOMMAND CHANNEL:\t Writing to 'Metersize'-register failed at {this.MeterType}{this.MeterIndex}\n", this.Culture);

            if (Boolean.Equals(Ok, false))
                return false;
            #endregion
            #region LedMode
            if (token.IsCancellationRequested)
                return false;
            GenesisZeroFlow.Display.DebugMessage($"{this.PcbID}\tCOMMAND CHANNEL:\t Writing to 'LED mode'-register at {this.MeterType}{this.MeterIndex}\n", this.Culture);
            Ok = CurrentMeter.WriteRegisterSafe(Register.Genesisflow.LedMode, this.LedMode);
            if (Ok)
                GenesisZeroFlow.Display.DebugMessage($"{this.PcbID}\tCOMMAND CHANNEL:\t Writing to 'LED mode'-register successful at {this.MeterType}{this.MeterIndex}\n", this.Culture);
            else
                GenesisZeroFlow.Display.DebugMessage($"{this.PcbID}\tCOMMAND CHANNEL:\t Writing to 'LED mode'-register failed at {this.MeterType}{this.MeterIndex}\n", this.Culture);

            if (Boolean.Equals(Ok, false))
                return false;
            #endregion
            #region TriggerActiv
            if (token.IsCancellationRequested)
                return false;
            GenesisZeroFlow.Display.DebugMessage($"{this.PcbID}\tCOMMAND CHANNEL:\t Writing to 'LED mode'-register at {this.MeterType}{this.MeterIndex}\n", this.Culture);
            Ok = CurrentMeter.WriteRegisterUnsafe(Register.Genesisflow.TriggerActive, 1);
            if (Ok)
                GenesisZeroFlow.Display.DebugMessage($"{this.PcbID}\tCOMMAND CHANNEL:\t Writing to 'LED mode'-register successful at {this.MeterType}{this.MeterIndex}\n", this.Culture);
            else
                GenesisZeroFlow.Display.DebugMessage($"{this.PcbID}\tCOMMAND CHANNEL:\t Writing to 'LED mode'-register failed at {this.MeterType}{this.MeterIndex}\n", this.Culture);

            if (Boolean.Equals(Ok, false))
                return false;
            #endregion

            return Ok;
        }
        private Boolean PerformPreparationThermometer(CancellationToken token)
        {
            #region Definitions and initialisations   
            Boolean Ok = false;
            #endregion
            #region Sample rate
            Ok = false;
            if (token.IsCancellationRequested)
                return false;

            GenesisZeroFlow.Display.DebugMessage($"{this.PcbID}\tCOMMAND CHANNEL:\t Writing to 'Samplerate'-register at {this.MeterType}{this.MeterIndex}\n", this.Culture);
            Ok = CurrentMeter.WriteRegisterSafe(Register.Genesisflow.SampleRate, this.SampleRate);

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

            if (Boolean.Equals(Ok, false))
                return false;
            #endregion
            #region LedMode
            if (token.IsCancellationRequested)
                return false;
            GenesisZeroFlow.Display.DebugMessage($"{this.PcbID}\tCOMMAND CHANNEL:\t Writing to 'LED mode'-register at {this.MeterType}{this.MeterIndex}\n", this.Culture);
            Ok = CurrentMeter.WriteRegisterSafe(Register.Genesisflow.LedMode, this.LedMode);
            if (Ok)
                GenesisZeroFlow.Display.DebugMessage($"{this.PcbID}\tCOMMAND CHANNEL:\t Writing to 'LED mode'-register successful at {this.MeterType}{this.MeterIndex}\n", this.Culture);
            else
                GenesisZeroFlow.Display.DebugMessage($"{this.PcbID}\tCOMMAND CHANNEL:\t Writing to 'LED mode'-register failed at {this.MeterType}{this.MeterIndex}\n", this.Culture);

            if (Boolean.Equals(Ok, false))
                return false;
            #endregion
            return Ok;
        }
        private Boolean PerformPreparationTempCal()
        {
            #region Definitions and initialisations   
            Boolean Ok = false;
            #endregion

            try
            {
                String PcbID = CurrentMeter.GetPcbId();
                if (!String.IsNullOrEmpty(PcbID))
                    frmTempCalibration.DisplayTempCal.DebugMessage($"COMMAND CHANNEL:\t PcbID = {PcbID}\n", this.Culture);
                else
                {
                    frmTempCalibration.DisplayTempCal.DebugMessage($"COMMAND CHANNEL:\t PcbID not available\n", this.Culture);
                    PcbID = "n/a";
                    //return false;
                }
            }
            catch (Exception ex)
            {
                ErrorLog.Log(LogErrReason.Exeption, "Preparation.PerformPreparationTempCal() failed", $"0x{ex.HResult.ToString("X", Culture)}", String.Empty, Culture);
            }
            #region Sample rate
            Ok = false;
            frmTempCalibration.DisplayTempCal.DebugMessage($"COMMAND CHANNEL:\t Writing to 'Samplerate'-register\n", this.Culture);
            Ok = CurrentMeter.WriteRegisterSafe(Register.Genesisflow.SampleRate, this.SampleRate);

            if (Ok)
                frmTempCalibration.DisplayTempCal.DebugMessage($"COMMAND CHANNEL:\t Writing to 'Samplerate'-register successful\n", this.Culture);
            else
            {
                frmTempCalibration.DisplayTempCal.DebugMessage($"COMMAND CHANNEL:\t Writing to 'Samplerate'-register failed\n", this.Culture);
                return false;
            }
            #endregion
            #region MeterSize
            frmTempCalibration.DisplayTempCal.DebugMessage($"COMMAND CHANNEL:\t Writing to 'Metersize'-register\n", this.Culture);
            Ok = CurrentMeter.WriteRegisterSafe(Register.Genesisflow.MeterSize, this.MeterSize);
            if (Ok)
                frmTempCalibration.DisplayTempCal.DebugMessage($"COMMAND CHANNEL:\t Writing to 'Metersize'-register successful\n", this.Culture);
            else
            {
                frmTempCalibration.DisplayTempCal.DebugMessage($"COMMAND CHANNEL:\t Writing to 'Metersize'-register failed\n", this.Culture);
                return false;
            }
            #endregion
            #region LedMode
            frmTempCalibration.DisplayTempCal.DebugMessage($"COMMAND CHANNEL:\t Writing to 'LED mode'-register\n", this.Culture);
            Ok = CurrentMeter.WriteRegisterSafe(Register.Genesisflow.LedMode, this.LedMode);
            if (Ok)
                frmTempCalibration.DisplayTempCal.DebugMessage($"COMMAND CHANNEL:\t Writing to 'LED mode'-register successful\n", this.Culture);
            else
            {
                frmTempCalibration.DisplayTempCal.DebugMessage($"COMMAND CHANNEL:\t Writing to 'LED mode'-register failed\n", this.Culture);
                return false;
            }
            #endregion
            return Ok;
        }
        public Int32 GetMeterNumber()
        {
            return MeterNumber;
        }
        private Boolean SetOffsetToZero { get; set; }

        public void Initialize(String pcbID, String meterType, UInt16 meterSize, Boolean setOffsetToZero, Int32 sampleRate, Double upperTempLimit, Double lowerTempLimit, Double tempDeviationLimit)
        {
            this.CalibrationFactor1 = PreparationValues.CalFactor1;
            this.CalibrationFactor2 = PreparationValues.CalFactor2;
            this.CalibrationFactor3 = PreparationValues.CalFactor3;
            this.ZeroOffset1 = PreparationValues.ZeroOffset1;
            this.ZeroOffset2 = PreparationValues.ZeroOffset2;
            this.ZeroOffset3 = PreparationValues.ZeroOffset3;
            this.SampleRate = sampleRate;
            this.MeterSize = meterSize;
            this.LedMode = PreparationValues.LedMode;
            this.SetOffsetToZero = setOffsetToZero;
            this.TempUpperLimit = upperTempLimit;
            this.TempLowerLimit = lowerTempLimit;
            this.TempDeviationLimit = tempDeviationLimit;
            this.MeterType = meterType;
            this.PcbID = pcbID;
        }
        public Int32 MeterNumber { get; private set; }
        public String MeterIndex { get; private set; }
        public String MeterType { get; private set; }
        private String PcbID { get; set; }
        private CultureInfo Culture { get; set; }
        private Int32 CalibrationFactor1 { get; set; }
        private Int32 CalibrationFactor2 { get; set; }
        private Int32 CalibrationFactor3 { get; set; }
        private Int32 ZeroOffset1 { get; set; }
        private Int32 ZeroOffset2 { get; set; }
        private Int32 ZeroOffset3 { get; set; }
        private Int32 SampleRate { get; set; }
        private UInt16 MeterSize { get; set; }
        private Int32 LedMode { get; set; }
        private Double TempUpperLimit { get; set; }
        private Double TempLowerLimit { get; set; }
        private Double TempDeviationLimit { get; set; }
    }

}