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 CompletionSequences
    {
        public static Boolean[] Total(MeterBatch globalMeterBatch, MeterBatch thermoMeterBatch, Boolean[] allEnable, out Boolean aborted, CultureInfo culture)
        {
            #region Definitions and initializations
            Boolean[] MeterEnable = Misc.Subarray(allEnable, 0, Constants.NumberOfMeters);
            Boolean[] ThermoEnable = Misc.Subarray(allEnable, Constants.NumberOfMeters, Constants.NumberOfThermometers);

            Boolean[] MeterTaskStarted = new Boolean[Constants.NumberOfMeters];
            MeterTaskStarted = ArrayInit.Meter(false);
            Boolean[] MeterSequenceOk = new Boolean[Constants.NumberOfMeters];
            MeterSequenceOk = ArrayInit.Meter(false);
            Boolean[] MeterSequenceFailed = new Boolean[Constants.NumberOfMeters];
            MeterSequenceFailed = ArrayInit.Meter(false);
            Boolean[] MeterTaskCompleted = new Boolean[Constants.NumberOfMeters];
            MeterTaskCompleted = ArrayInit.Meter(false);
            
            Boolean[] ThermoTaskStarted = new Boolean[Constants.NumberOfThermometers];
            ThermoTaskStarted = ArrayInit.Thermo(false);
            Boolean[] ThermoSequenceOk = new Boolean[Constants.NumberOfThermometers];
            ThermoSequenceOk = ArrayInit.Thermo(false);
            Boolean[] ThermoSequenceFailed = new Boolean[Constants.NumberOfThermometers];
            ThermoSequenceFailed = ArrayInit.Thermo(false);
            Boolean[] ThermoTaskCompleted = new Boolean[Constants.NumberOfThermometers];
            ThermoTaskCompleted = ArrayInit.Thermo(false);

            Int32 NextDelayTime = 0;
            aborted = false;
            const Int16 LedMode = 6;
            const Int16 StoreCalibration = 1;
            var listCompl = new List<Completion>();
            var listMeterNumber = new List<Int32>();
            var thermolistCompl = new List<Completion>();
            var thermolistMeterNumber = new List<Int32>();
          
            for (UInt16 Meter = Constants.Meter1; Meter < Constants.NumberOfMeters; Meter++)
            {
                var currentMeter = globalMeterBatch.ListOfMeters.FirstOrDefault(m => m.Slot.Equals(Meter + 1));

                if (currentMeter != null)
                    listCompl.Add(new Completion(Meter, currentMeter, culture));
                else
                    listCompl.Add(new Completion(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)
                    thermolistCompl.Add(new Completion(Thermo, currentMeter, culture));
                else
                    thermolistCompl.Add(new Completion(Thermo, culture));
            }
            #region Initialize
            foreach (var compl in listCompl)
            {        
                compl.Initialize(GenesisZeroFlow._GenesisZeroFlow.PcbID[compl.MeterNumber], Constants.Meter, LedMode, StoreCalibration);
                compl.MyTask = new Task<Boolean>(() => { return true; });
            }
            foreach (var thermocompl in thermolistCompl)
            {
                thermocompl.Initialize(GenesisZeroFlow._GenesisZeroFlow.ThermoID[thermocompl.MeterNumber], Constants.Thermo, LedMode, StoreCalibration);
                thermocompl.MyTask = new Task<Boolean>(() => { return true; });
            }
            #endregion
            #endregion
            #region Perform tests
            CancellationTokenSource cancellationTokenSource = new CancellationTokenSource();
            CancellationToken token = cancellationTokenSource.Token;
            // Completion

            // todo move action into tasks
            foreach (var compl in listCompl)
                compl.Meter(MeterEnable[compl.MeterNumber], ref MeterTaskStarted[compl.MeterNumber], ref MeterSequenceFailed[compl.MeterNumber], ref NextDelayTime, token);
            foreach (var thermocompl in thermolistCompl)
                thermocompl.Thermometer(ThermoEnable[thermocompl.MeterNumber], ref ThermoTaskStarted[thermocompl.MeterNumber], ref ThermoSequenceFailed[thermocompl.MeterNumber], ref NextDelayTime, token);
            #endregion
            #region Wait for tasks
            for (UInt16 Meter = Constants.Meter1; Meter < Constants.NumberOfMeters; Meter++)
                MeterSequenceOk[Meter] = false;
        
            while (!CheckArray(MeterTaskCompleted.Concat(ThermoTaskCompleted).ToArray()))
            {
                if (GenesisZeroFlow._GenesisZeroFlow.AbortIndicator)
                {
                    aborted = true;
                    cancellationTokenSource.Cancel();
                }
                Misc.WaitNSeconds(1);

                foreach (var compl in listCompl)
                    MeterTaskCompleted[compl.MeterNumber] = TaskOperations.WaitFor(MeterTaskStarted[compl.MeterNumber], compl.MyTask);
                foreach (var compl in listCompl)
                    MeterSequenceFailed[compl.MeterNumber] = TaskOperations.GetResult(MeterTaskStarted[compl.MeterNumber], compl.MyTask);       
                for (UInt16 Meter = Constants.Meter1; Meter < Constants.NumberOfMeters; Meter++)
                    MeterSequenceOk[Meter] = !MeterSequenceFailed[Meter];

                foreach (var thermocompl in thermolistCompl)
                    ThermoTaskCompleted[thermocompl.MeterNumber] = TaskOperations.WaitFor(ThermoTaskStarted[thermocompl.MeterNumber], thermocompl.MyTask);
                foreach (var thermocompl in thermolistCompl)
                    ThermoSequenceFailed[thermocompl.MeterNumber] = TaskOperations.GetResult(ThermoTaskStarted[thermocompl.MeterNumber], thermocompl.MyTask);
                for (UInt16 Thermo = Constants.Thermo1; Thermo < Constants.NumberOfThermometers; Thermo++)
                    ThermoSequenceOk[Thermo] = !ThermoSequenceFailed[Thermo];

                GenesisZeroFlow.Display.MeterStatusGreenRed(MeterSequenceOk, MeterTaskStarted);
                GenesisZeroFlow.Display.ThermoStatusGreenRed(ThermoSequenceOk, ThermoTaskStarted);
            }
            #endregion

            foreach (var compl in listCompl)
                MeterSequenceFailed[compl.MeterNumber] = TaskOperations.GetResult(MeterTaskStarted[compl.MeterNumber], compl.MyTask);
            foreach (var thermocompl in thermolistCompl)
                ThermoSequenceFailed[thermocompl.MeterNumber] = TaskOperations.GetResult(MeterTaskStarted[thermocompl.MeterNumber], thermocompl.MyTask);
            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);

            #region Destroy tasks
            foreach (var metercompl in listCompl)
                TaskOperations.CheckAndDispose(metercompl.MyTask);
            foreach (var thermocompl in thermolistCompl)
                TaskOperations.CheckAndDispose(thermocompl.MyTask);
            #endregion

            return MeterSequenceFailed.Concat(ThermoSequenceFailed).ToArray();
        }
        public static Boolean TotalTempCal(MeterBatch globalMeterBatch, Boolean enable, CultureInfo culture)
        {
            #region Definitions and initializations
            Boolean SequenceFailed = false;
            Boolean TaskStarted = false;
            Boolean TaskCompleted = false;
            const Int16 LedMode = 0;
            const Int16 StoreCalibration = 1;
            var listCompl = new List<Completion>();

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

            foreach (var compl in listCompl)
            {
                UInt16 MeterNumber = 0;
                if (((Int32)currentMeter.Slot - 1) >= -1)
                    MeterNumber = (UInt16)(currentMeter.Slot - 1);

                compl.Initialize(String.Empty, Constants.Thermo, LedMode, StoreCalibration);
                compl.MyTask = new Task<Boolean>(() => { return true; });
            }
            #endregion
            #region Perform test
            foreach (var compl in listCompl)
                compl.MeterTempCal(enable, ref TaskStarted, ref SequenceFailed);
            #endregion
            #region Wait for tasks
            Boolean SequenceOk = false;

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

                foreach (var compl in listCompl)
                    SequenceFailed = TaskOperations.GetResult(TaskStarted, compl.MyTask);
                SequenceOk = !SequenceFailed;
                frmTempCalibration.DisplayTempCal.MeterStatusGreenRed(SequenceOk, TaskStarted);
            }
            #endregion

            foreach (var compl in listCompl)
                SequenceFailed = TaskOperations.GetResult(TaskStarted, compl.MyTask);
            
            SequenceOk = !SequenceFailed;

            #region Destroy tasks
            frmTempCalibration.DisplayTempCal.MeterStatusGreenRed(SequenceOk, TaskStarted);

            foreach (var compl in listCompl)
                TaskOperations.CheckAndDispose(compl.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 Completion
    {
        private readonly ZeroFlowGenesisMeter GenesisMeter;
        public Task<Boolean> MyTask { get; internal set; }
        /// <summary>
        /// For ZeroFlowCalibration tool
        /// Provides task control for Completion Sequence of 'METER'
        /// </summary>
        /// <param name="enable"></param>
        /// <param name="taskStarted"></param>
        /// <param name="sequenceFailed"></param>
        /// <param name="nextDelayTime"></param>
        /// <param name="token"></param>
        public void Meter(Boolean enable, ref Boolean taskStarted, ref Boolean sequenceFailed, ref Int32 nextDelayTime, CancellationToken token)
        {
            #region Avoid CA1062
            if (MyTask == null)
                return;
            #endregion
            #region Definitions and initializations
            DialogResult AskForActions = DialogResult.None;
            var _sequenceFailed = sequenceFailed;
            Boolean Ok = true;
            #endregion
            #region Everything else
            if ((enable) && (!TaskStatus.Equals(MyTask.Status, TaskStatus.Running)) && (!MyTask.IsCompleted))
            {
                taskStarted = true;

                #region Testprocedure
                MyTask = Task.Run(() =>
                {
                    while ((DialogResult.Equals(AskForActions, DialogResult.Retry)) || (DialogResult.Equals(AskForActions, DialogResult.None)))
                    {
                        #region Cancellation token
                        if (DialogResult.Equals(AskForActions, DialogResult.None))
                            GenesisZeroFlow.Display.DebugMessage($"{this.PcbID}\tAPPLICATION:\t\t COMPLETION started at {this.MeterType}{this.MeterIndex}\n", this.Culture);
                        #endregion
                        #region Sequence
                        Ok = this.PerformCompletion(token);
                        if (token.IsCancellationRequested)
                        {
                            GenesisZeroFlow.Display.DebugMessage($"{this.PcbID}\tAPPLICATION:\t\t COMPLETION stopped at {this.MeterType}{this.MeterIndex}\n", this.Culture);
                            GenesisZeroFlow._GenesisZeroFlow.GenerateReturnNote(this.MeterIndex, this.PcbID, GenesisZeroFlow.PredefinedMessages.CompletionStopped(this.Culture), GenesisZeroFlow._GenesisZeroFlow.GetLoggingFromTextBox(), this.Culture);
                            return false;
                        }
                        if (Ok)
                        {
                            GenesisZeroFlow.Display.DebugMessage($"{this.PcbID}\tAPPLICATION:\t\t COMPLETION 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
                        {                            
                            GenesisZeroFlow.Display.DebugMessage($"{this.PcbID}\tAPPLICATION:\t\t COMPLETION failed at {this.MeterType}{this.MeterIndex}\n", this.Culture);
                            GenesisZeroFlow._GenesisZeroFlow.GenerateReturnNote(this.MeterIndex, this.PcbID, GenesisZeroFlow.PredefinedMessages.CompletionFailed(this.Culture), GenesisZeroFlow._GenesisZeroFlow.GetLoggingFromTextBox(), this.Culture);
                            AskForActions = DialogResult.Cancel;
                            _sequenceFailed = true;
                        }
                        #endregion
                    }
                    return _sequenceFailed;
                });
                #endregion

            }
            #endregion
        }
        /// <summary>
        /// For ZeroFlowCalibration tool
        /// Provides task control for Completion Sequence of 'THERMOMETER'
        /// </summary>
        /// <param name="enable"></param>
        /// <param name="taskStarted"></param>
        /// <param name="sequenceFailed"></param>
        /// <param name="nextDelayTime"></param>
        /// <param name="token"></param>
        public 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 = 5;
            DialogResult AskForActions = DialogResult.None;
            var _sequenceFailed = sequenceFailed;
            Int32 temp = DelayTime;
            Boolean Ok = true;
            #endregion
            #region Everything else
            if ((enable) && (!TaskStatus.Equals(MyTask.Status, TaskStatus.Running)) && (!MyTask.IsCompleted))
            {
                DelayTime = nextDelayTime;
                nextDelayTime = nextDelayTime + DeltaDelay;

                taskStarted = true;
                Misc.WaitNSeconds((Int32)temp);

                #region Testprocedure
                DelayTime = nextDelayTime;
                nextDelayTime = nextDelayTime + DeltaDelay;
                taskStarted = true;
                Misc.WaitNSeconds(temp);

                MyTask = Task.Run(() =>
                {
                    while ((Byte.Equals(AskForActions, DialogResult.Retry)) || (Byte.Equals(AskForActions, DialogResult.None)))
                    {
                        #region Cancellation token
                        if (DialogResult.Equals(AskForActions, DialogResult.None))
                            GenesisZeroFlow.Display.DebugMessage($"{this.PcbID}\tAPPLICATION:\t\t COMPLETION started at {this.MeterType}{this.MeterIndex}\n", this.Culture);
                        #endregion
                        #region Sequence
                        Ok = this.PerformCompletion(token);
                        if (token.IsCancellationRequested)
                        {
                            GenesisZeroFlow.Display.DebugMessage($"{this.PcbID}\tAPPLICATION:\t\t COMPLETION stopped at {this.MeterType}{this.MeterIndex}\n", this.Culture);
                            return false;
                        }
                        if (Ok)
                        {
                            GenesisZeroFlow.Display.DebugMessage($"{this.PcbID}\tAPPLICATION:\t\t COMPLETION 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
                        {
                            GenesisZeroFlow.Display.DebugMessage($"{this.PcbID}\tAPPLICATION:\t\t COMPLETION failed at {this.MeterType}{this.MeterIndex}\n", this.Culture);
                            AskForActions = DialogResult.Cancel;
                            _sequenceFailed = true;
                        }
                        #endregion
                    }
                    return _sequenceFailed;
                });
                #endregion

            }
            #endregion
        }
        /// <summary>
        /// For temperature calibration tool
        /// 
        /// </summary>
        /// <param name="enable"></param>
        /// <param name="taskStarted"></param>
        /// <param name="sequenceFailed"></param>
        public void MeterTempCal(Boolean enable, ref Boolean taskStarted, ref Boolean sequenceFailed)
        {
            #region Avoid CA1062
            if (MyTask == null)
                return;
            #endregion
            #region Definitions and initializations
            DialogResult AskForActions = DialogResult.None;
            var _sequenceFailed = sequenceFailed;
            Boolean Ok = false;
            #endregion
            #region Everything else
            if ((enable) && (!TaskStatus.Equals(MyTask.Status, TaskStatus.Running)) && (!MyTask.IsCompleted))
            {
                taskStarted = true;

                #region Testprocedure
                taskStarted = true;

                MyTask = Task.Run(() =>
                {
                    while ((DialogResult.Equals(AskForActions, DialogResult.Retry)) || (DialogResult.Equals(AskForActions, DialogResult.None)))
                    {
                        #region Sequence
                        frmTempCalibration.DisplayTempCal.DebugMessage($"APPLICATION:\t\t COMPLETION sequence started\n", this.Culture);
                        Ok = PerformCompletionTempCal();
                        if (Ok)
                        {
                            frmTempCalibration.DisplayTempCal.DebugMessage($"APPLICATION:\t\t COMPLETION sequence successful\n", this.Culture);
                            frmTempCalibration.DisplayTempCal.DebugMessage(Debugmessages.Line, this.Culture);
                            _sequenceFailed = false;

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

            }
            #endregion
        }
        /// <summary>
        /// For ZeroFlowCalibration tool
        /// Completion sequence for Meter and Thermometer, both identical
        /// </summary>
        /// <param name="token"></param>
        /// <returns></returns>
        private Boolean PerformCompletion(CancellationToken token)
        {
            #region Definitions and initializations
            Boolean Ok = false; // Ok == true when register write successful
            List<Double>[] DeltaTimeOfFlight = new List<Double>[Constants.NumberOfPaths];
            for (UInt16 i = 0; i < Constants.NumberOfPaths; i++)
                DeltaTimeOfFlight[i] = new List<Double>();
            #endregion
            #region Completion sequence
            GenesisZeroFlow.Display.DebugMessage($"{this.PcbID}\tAPPLICATION:\t\t Start COMPLETION at {this.MeterType}{this.MeterIndex}\n", this.Culture);
            #region Write '0' to samplerate register
            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 = GenesisMeter.WriteRegisterSafe(Register.Genesisflow.SampleRate, 10);
            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 Ok;
            #endregion
            #region Write to led mode register
            Ok = false;

            if (token.IsCancellationRequested)
                return false;

            GenesisZeroFlow.Display.DebugMessage($"{this.PcbID}\tCOMMAND CHANNEL:\t Writing to '{LedMode.ToString(this.Culture)}' to 'LED mode'-register at {this.MeterType}{this.MeterIndex}\n", this.Culture);

            Ok = GenesisMeter.WriteRegisterSafe(Register.Genesisflow.LedMode, (Byte)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 Ok;
            #endregion
            #region Write '1' to store completion register
            Misc.WaitNSeconds(1);
            Ok = false;
            if (token.IsCancellationRequested)
                return false;
            GenesisZeroFlow.Display.DebugMessage($"{this.PcbID}\tCOMMAND CHANNEL:\t Writing to 'Store calibration'-register at {this.MeterType}{this.MeterIndex}\n", this.Culture);
            Ok = GenesisMeter.WriteRegisterUnsafe(Register.Genesisflow.StoreCalibration, 1);
            if (Ok)
                GenesisZeroFlow.Display.DebugMessage($"{this.PcbID}\tCOMMAND CHANNEL:\t Writing to 'Store calibration'-register successful at {this.MeterType}{this.MeterIndex}\n", this.Culture);
            else
                GenesisZeroFlow.Display.DebugMessage($"{this.PcbID}\tCOMMAND CHANNEL:\t Writing to 'Store calibration'-register failed at {this.MeterType}{this.MeterIndex}\n", this.Culture);
            #endregion
            #endregion
            #region Get registers
            GenesisZeroFlow.Display.DebugMessage($"{this.PcbID}\tAPPLICATION:\t\t Read registers at {this.MeterType}{this.MeterIndex}\n", this.Culture);
            //todo reimplement
            //#region Read zero offset register PATH0
            //Trials = 0;
            //Ok = false;
            //while ((Trials < this.NumberOfTrials) && (Ok == false) && (reAuthentication == false))
            //{
            //    if (token.IsCancellationRequested)
            //        return false;

            //    GenesisZeroFlow.Display.DebugMessage("COMMAND CHANNEL:\t Reading 'ZeroFlowOffset1'-register at METER" + MeterIndex + "; Trial: " + (Trials + 1).ToString(this.GlobalCulture) + " of " + this.NumberOfTrials + "\n");

            //    Ok = this.GetRegister(GP30Registers.ZeroOffset1(), out DebugMessage);
            //    if (Ok)
            //        GenesisZeroFlow.Display.DebugMessage("COMMAND CHANNEL:\t Reading to 'ZeroFlowOffset1'-register successful at METER" + MeterIndex + "\n");
            //    else
            //    {
            //        GenesisZeroFlow.Display.DebugMessage("COMMAND CHANNEL:\t Reading to 'ZeroFlowOffset1'-register failed at METER" + MeterIndex + "\n");
            //        if (CommandInterface.Subreason == GP30ConfigExErrors.AccessDenied)
            //            reAuthentication = true;
            //    }

            //    Trials++;
            //}
            //if (Ok == false)
            //    return Ok;
            //#endregion
            //#region Read zero offset register PATH1
            //Trials = 0;
            //Ok = false;
            //while ((Trials < this.NumberOfTrials) && (Ok == false) && (reAuthentication == false))
            //{
            //    if (token.IsCancellationRequested)
            //        return false;

            //    GenesisZeroFlow.Display.DebugMessage("COMMAND CHANNEL:\t Reading 'ZeroFlowOffset2'-register at METER" + MeterIndex + "; Trial: " + (Trials + 1).ToString(this.GlobalCulture) + " of " + this.NumberOfTrials + "\n");

            //    Ok = this.GetRegister(GP30Registers.ZeroOffset2(), out DebugMessage);
            //    if (Ok)
            //        GenesisZeroFlow.Display.DebugMessage("COMMAND CHANNEL:\t Reading to 'ZeroFlowOffset2'-register successful at METER" + MeterIndex + "\n");
            //    else
            //    {
            //        GenesisZeroFlow.Display.DebugMessage("COMMAND CHANNEL:\t Reading to 'ZeroFlowOffset2'-register failed at METER" + MeterIndex + "\n");
            //        if (this.CommandInterface.Subreason == GP30ConfigExErrors.AccessDenied)
            //            reAuthentication = true;
            //    }

            //    Trials++;
            //}
            //if (Ok == false)
            //    return Ok;
            //#endregion
            //#region Read zero offset register PATH2
            //Trials = 0;
            //Ok = false;
            //while ((Trials < this.NumberOfTrials) && (Ok == false) && (reAuthentication == false))
            //{
            //    if (token.IsCancellationRequested)
            //        return false;

            //    GenesisZeroFlow.Display.DebugMessage("COMMAND CHANNEL:\t Reading 'ZeroFlowOffset3'-register at METER" + MeterIndex + "; Trial: " + (Trials + 1).ToString(this.GlobalCulture) + " of " + this.NumberOfTrials.ToString(this.GlobalCulture) + "\n");

            //    Ok = this.GetRegister(GP30Registers.ZeroOffset3(), out DebugMessage);
            //    if (Ok)
            //        GenesisZeroFlow.Display.DebugMessage("COMMAND CHANNEL:\t Reading to 'ZeroFlowOffset3'-register successful at METER" + MeterIndex + "\n");
            //    else
            //    {
            //        GenesisZeroFlow.Display.DebugMessage("COMMAND CHANNEL:\t Reading to 'ZeroFlowOffset3'-register failed at METER" + MeterIndex + "\n");
            //        if (this.CommandInterface.Subreason == GP30ConfigExErrors.AccessDenied)
            //            reAuthentication = true;
            //    }

            //    Trials++;
            //}
            //if (Ok == false)
            //    return Ok;
            //#endregion
            //#region Read first hit percentage register PATH0
            //Trials = 0;
            //Ok = false;
            //while ((Trials < this.NumberOfTrials) && (Ok == false) && (reAuthentication == false))
            //{
            //    if (token.IsCancellationRequested)
            //        return false;

            //    GenesisZeroFlow.Display.DebugMessage("COMMAND CHANNEL:\t Reading 'FirstHitPercentage1'-register at METER" + MeterIndex + "; Trial: " + (Trials + 1).ToString(this.GlobalCulture) + " of " + this.NumberOfTrials.ToString(this.GlobalCulture) + "\n");

            //    Ok = this.GetRegister(GP30Registers.FirstHitLevelPercentagePath0(), out DebugMessage);
            //    if (Ok)
            //        GenesisZeroFlow.Display.DebugMessage("COMMAND CHANNEL:\t Reading to 'FirstHitPercentage1'-register successful at METER" + MeterIndex + "\n");
            //    else
            //    {
            //        GenesisZeroFlow.Display.DebugMessage("COMMAND CHANNEL:\t Reading to 'FirstHitPercentage1'-register failed at METER" + MeterIndex + "\n");
            //        if (this.CommandInterface.Subreason == GP30ConfigExErrors.AccessDenied)
            //            reAuthentication = true;
            //    }
            //    Trials++;
            //}
            //if (Ok == false)
            //    return Ok;
            //#endregion
            //#region Read first hit percentage register PATH1
            //Trials = 0;
            //Ok = false;
            //while ((Trials < this.NumberOfTrials) && (Ok == false) && (reAuthentication == false))
            //{
            //    if (token.IsCancellationRequested)
            //        return false;

            //    GenesisZeroFlow.Display.DebugMessage("COMMAND CHANNEL:\t Reading 'FirstHitPercentage2'-register at METER" + MeterIndex + "; Trial: " + (Trials + 1).ToString(this.GlobalCulture) + " of " + this.NumberOfTrials.ToString(this.GlobalCulture) + "\n");

            //    Ok = this.GetRegister(GP30Registers.FirstHitLevelPercentagePath1(), out DebugMessage);
            //    if (Ok)
            //        GenesisZeroFlow.Display.DebugMessage("COMMAND CHANNEL:\t Reading to 'FirstHitPercentage2'-register successful at METER" + MeterIndex + "\n");
            //    else
            //    {
            //        GenesisZeroFlow.Display.DebugMessage("COMMAND CHANNEL:\t Reading to 'FirstHitPercentage2'-register failed at METER" + MeterIndex + "\n");
            //        if (this.CommandInterface.Subreason == GP30ConfigExErrors.AccessDenied)
            //            reAuthentication = true;
            //    }
            //    Trials++;
            //}
            //if (Ok == false)
            //    return Ok;
            //#endregion
            //#region Read first hit percentage register PATH2
            //Trials = 0;
            //Ok = false;
            //while ((Trials < this.NumberOfTrials) && (Ok == false) && (reAuthentication == false))
            //{
            //    if (token.IsCancellationRequested)
            //        return false;

            //    GenesisZeroFlow.Display.DebugMessage("COMMAND CHANNEL:\t Reading 'FirstHitPercentage3'-register at METER" + MeterIndex + "; Trial: " + (Trials + 1).ToString(this.GlobalCulture) + " of " + this.NumberOfTrials.ToString(this.GlobalCulture) + "\n");

            //    Ok = this.GetRegister(GP30Registers.FirstHitLevelPercentagePath2(), out DebugMessage);
            //    if (Ok)
            //        GenesisZeroFlow.Display.DebugMessage("COMMAND CHANNEL:\t Reading to 'FirstHitPercentage3'-register successful at METER" + MeterIndex + "\n");
            //    else
            //    {
            //        GenesisZeroFlow.Display.DebugMessage("COMMAND CHANNEL:\t Reading to 'FirstHitPercentage3'-register failed at METER" + MeterIndex + "\n");
            //        if (this.CommandInterface.Subreason == GP30ConfigExErrors.AccessDenied)
            //            reAuthentication = true;
            //    }
            //    Trials++;
            //}
            //if (Ok == false)
            //    return Ok;
            //#endregion
            //#region Read tof temp offset register PATH0
            //Trials = 0;
            //Ok = false;
            //while ((Trials < this.NumberOfTrials) && (Ok == false) && (reAuthentication == false))
            //{
            //    if (token.IsCancellationRequested)
            //        return false;

            //    GenesisZeroFlow.Display.DebugMessage("COMMAND CHANNEL:\t Reading 'ToFTempOffset1'-register at METER" + MeterIndex + "; Trial: " + (Trials + 1).ToString(this.GlobalCulture) + " of " + this.NumberOfTrials.ToString(this.GlobalCulture) + "\n");

            //    Ok = this.GetRegister(GP30Registers.ToFTempOffset1(), out DebugMessage);
            //    if (Ok)
            //        GenesisZeroFlow.Display.DebugMessage("COMMAND CHANNEL:\t Reading to 'ToFTempOffset1'-register successful at METER" + MeterIndex + "\n");
            //    else
            //    {
            //        GenesisZeroFlow.Display.DebugMessage("COMMAND CHANNEL:\t Reading to 'ToFTempOffset1'-register failed at METER" + MeterIndex + "\n");
            //        if (this.CommandInterface.Subreason == GP30ConfigExErrors.AccessDenied)
            //            reAuthentication = true;
            //    }
            //    Trials++;
            //}
            //if (Ok == false)
            //    return Ok;
            //#endregion
            //#region Read tof temp offset register PATH1
            //Trials = 0;
            //Ok = false;
            //while ((Trials < this.NumberOfTrials) && (Ok == false) && (reAuthentication == false))
            //{
            //    if (token.IsCancellationRequested)
            //        return false;

            //    GenesisZeroFlow.Display.DebugMessage("COMMAND CHANNEL:\t Reading 'ToFTempOffset2'-register at METER" + MeterIndex + "; Trial: " + (Trials + 1).ToString(this.GlobalCulture) + " of " + this.NumberOfTrials.ToString(this.GlobalCulture) + "\n");

            //    Ok = this.GetRegister(GP30Registers.ToFTempOffset2(), out DebugMessage);
            //    if (Ok)
            //        GenesisZeroFlow.Display.DebugMessage("COMMAND CHANNEL:\t Reading to 'ToFTempOffset2'-register successful at METER" + MeterIndex + "\n");
            //    else
            //    {
            //        GenesisZeroFlow.Display.DebugMessage("COMMAND CHANNEL:\t Reading to 'ToFTempOffset2'-register failed at METER" + MeterIndex + "\n");
            //        if (this.CommandInterface.Subreason == GP30ConfigExErrors.AccessDenied)
            //            reAuthentication = true;
            //    }
            //    Trials++;
            //}
            //if (Ok == false)
            //    return Ok;
            //#endregion
            //#region Read tof temp offset register PATH2
            //Trials = 0;
            //Ok = false;
            //while ((Trials < this.NumberOfTrials) && (Ok == false) && (reAuthentication == false))
            //{
            //    if (token.IsCancellationRequested)
            //        return false;

            //    GenesisZeroFlow.Display.DebugMessage("COMMAND CHANNEL:\t Reading 'ToFTempOffset3'-register at METER" + MeterIndex + "; Trial: " + (Trials + 1).ToString(this.GlobalCulture) + " of " + this.NumberOfTrials.ToString(this.GlobalCulture) + "\n");

            //    Ok = this.GetRegister(GP30Registers.ToFTempOffset3(), out DebugMessage);
            //    if (Ok)
            //        GenesisZeroFlow.Display.DebugMessage("COMMAND CHANNEL:\t Reading to 'ToFTempOffset3'-register successful at METER" + MeterIndex + "\n");
            //    else
            //    {
            //        GenesisZeroFlow.Display.DebugMessage("COMMAND CHANNEL:\t Reading to 'ToFTempOffset3'-register failed at METER" + MeterIndex + "\n");
            //        if (this.CommandInterface.Subreason == GP30ConfigExErrors.AccessDenied)
            //            reAuthentication = true;
            //    }
            //    Trials++;
            //}

            //if (Ok == false)
            //    return Ok;
            //#endregion
            //#region Read calfactor register PATH0
            //Trials = 0;
            //Ok = false;
            //while ((Trials < this.NumberOfTrials) && (Ok == false) && (reAuthentication == false))
            //{
            //    if (token.IsCancellationRequested)
            //        return false;

            //    GenesisZeroFlow.Display.DebugMessage("COMMAND CHANNEL:\t Reading 'Calfactor1'-register at METER" + MeterIndex + "; Trial: " + (Trials + 1).ToString(this.GlobalCulture) + " of " + this.NumberOfTrials.ToString(this.GlobalCulture) + "\n");

            //    Ok = this.GetRegister(GP30Registers.CalFactor1(), out DebugMessage);
            //    if (Ok)
            //        GenesisZeroFlow.Display.DebugMessage("COMMAND CHANNEL:\t Reading to 'Calfactor1'-register successful at METER" + MeterIndex + "\n");
            //    else
            //    {
            //        GenesisZeroFlow.Display.DebugMessage("COMMAND CHANNEL:\t Reading to 'Calfactor1'-register failed at METER" + MeterIndex + "\n");
            //        if (this.CommandInterface.Subreason == GP30ConfigExErrors.AccessDenied)
            //            reAuthentication = true;
            //    }
            //    Trials++;
            //}
            //if (Ok == false)
            //    return Ok;
            //#endregion
            //#region Read calfactor register PATH1
            //Trials = 0;
            //Ok = false;
            //while ((Trials < this.NumberOfTrials) && (Ok == false) && (reAuthentication == false))
            //{
            //    if (token.IsCancellationRequested)
            //        return false;

            //    GenesisZeroFlow.Display.DebugMessage("COMMAND CHANNEL:\t Reading 'Calfactor2'-register at METER" + MeterIndex + "; Trial: " + (Trials + 1).ToString(this.GlobalCulture) + " of " + this.NumberOfTrials.ToString(this.GlobalCulture) + "\n");

            //    Ok = this.GetRegister(GP30Registers.CalFactor2(), out DebugMessage);
            //    if (Ok)
            //        GenesisZeroFlow.Display.DebugMessage("COMMAND CHANNEL:\t Reading to 'Calfactor2'-register successful at METER" + MeterIndex + "\n");
            //    else
            //    {
            //        GenesisZeroFlow.Display.DebugMessage("COMMAND CHANNEL:\t Reading to 'Calfactor2'-register failed at METER" + MeterIndex + "\n");
            //        if (this.CommandInterface.Subreason == GP30ConfigExErrors.AccessDenied)
            //            reAuthentication = true;
            //    }
            //    Trials++;
            //}
            //if (Ok == false)
            //    return Ok;
            //#endregion
            //#region Read calfactor register PATH2
            //Trials = 0;
            //Ok = false;
            //while ((Trials < this.NumberOfTrials) && (Ok == false) && (reAuthentication == false))
            //{
            //    if (token.IsCancellationRequested)
            //        return false;

            //    GenesisZeroFlow.Display.DebugMessage("COMMAND CHANNEL:\t Reading 'Calfactor3'-register at METER" + MeterIndex + "; Trial: " + (Trials + 1).ToString(this.GlobalCulture) + " of " + this.NumberOfTrials.ToString(this.GlobalCulture) + "\n");

            //    Ok = this.GetRegister(GP30Registers.CalFactor3(), out DebugMessage);
            //    if (Ok)
            //        GenesisZeroFlow.Display.DebugMessage("COMMAND CHANNEL:\t Reading to 'Calfactor3'-register successful at METER" + MeterIndex + "\n");
            //    else
            //    {
            //        GenesisZeroFlow.Display.DebugMessage("COMMAND CHANNEL:\t Reading to 'Calfactor3'-register failed at METER" + MeterIndex + "\n");
            //        if (this.CommandInterface.Subreason == GP30ConfigExErrors.AccessDenied)
            //            reAuthentication = true;
            //    }
            //    Trials++;
            //}
            //System.Diagnostics.Debug.WriteLine(Ok.ToString());
            //if (Ok == false)
            //{
            //    System.Diagnostics.Debug.WriteLine("Returning");
            //    return Ok;
            //}
            //System.Diagnostics.Debug.WriteLine("Write data to file");
            //#endregion
            //#region Write to file
            //DateTime Timestamp = new DateTime();
            //Timestamp = DateTime.Now;
            //String TimestampFileName = Timestamp.ToString(Formats.LogFileDateTimeString, this.GlobalCulture);
            //String LoggingText =
            //"GENESISFLOW_ZeroOffset;0x" +
            //GenesisZeroFlow._GenesisZeroFlow.GetZeroFlowOffset()[MeterNumber][Constants.PATH0].ToString("X4", this.GlobalCulture) + ";0x" +
            //GenesisZeroFlow._GenesisZeroFlow.GetZeroFlowOffset()[MeterNumber][Constants.PATH1].ToString("X4", this.GlobalCulture) + ";0x" +
            //GenesisZeroFlow._GenesisZeroFlow.GetZeroFlowOffset()[MeterNumber][Constants.PATH2].ToString("X4", this.GlobalCulture) + ";\n" +
            //"GENESISFLOW_FirstHitPercent;0x" +
            //GenesisZeroFlow._GenesisZeroFlow.GetFirstHitPercentage()[MeterNumber][Constants.PATH0].ToString("X4", this.GlobalCulture) + ";0x" +
            //GenesisZeroFlow._GenesisZeroFlow.GetFirstHitPercentage()[MeterNumber][Constants.PATH1].ToString("X4", this.GlobalCulture) + ";0x" +
            //GenesisZeroFlow._GenesisZeroFlow.GetFirstHitPercentage()[MeterNumber][Constants.PATH2].ToString("X4", this.GlobalCulture) + ";\n" +
            //"GENESISFLOW_ToFTempOffset;0x" +
            //GenesisZeroFlow._GenesisZeroFlow.GetToFTempOffset()[MeterNumber][Constants.PATH0].ToString("X4", this.GlobalCulture) + ";0x" +
            //GenesisZeroFlow._GenesisZeroFlow.GetToFTempOffset()[MeterNumber][Constants.PATH1].ToString("X4", this.GlobalCulture) + ";0x" +
            //GenesisZeroFlow._GenesisZeroFlow.GetToFTempOffset()[MeterNumber][Constants.PATH2].ToString("X4", this.GlobalCulture) + ";\n" +
            //"GENESISFLOW_Calfactor;0x" +
            //GenesisZeroFlow._GenesisZeroFlow.GetCalFactor()[MeterNumber][Constants.PATH0].ToString("X4", this.GlobalCulture) + ";0x" +
            //GenesisZeroFlow._GenesisZeroFlow.GetCalFactor()[MeterNumber][Constants.PATH1].ToString("X4", this.GlobalCulture) + ";0x" +
            //GenesisZeroFlow._GenesisZeroFlow.GetCalFactor()[MeterNumber][Constants.PATH2].ToString("X4", this.GlobalCulture) + ";\n";
            //Logging.WriteToFile(LoggingText, @"..\GenesisZeroflowTest_Registers_METER" + MeterIndex + "_" + TimestampFileName + ".csv");
            //ClearData();
            //#endregion
            #endregion

            return Ok;
        }
        /// <summary>
        /// For temperature calibration tool
        /// </summary>
        /// <returns></returns>
        private Boolean PerformCompletionTempCal()
        {
            #region Definitions and initializations
            List<Double>[] DeltaTimeOfFlight = new List<Double>[Constants.NumberOfPaths];
            for (UInt16 i = 0; i < Constants.NumberOfPaths; i++)
                DeltaTimeOfFlight[i] = new List<Double>();

            Boolean Ok = false;
            #endregion
            #region Completion sequence
            #region Write '0' to samplerate register
            Ok = false;
            frmTempCalibration.DisplayTempCal.DebugMessage("COMMAND CHANNEL:\t Writing to 'Samplerate'-register\n", this.Culture);

            Ok = GenesisMeter.WriteRegisterSafe(Register.Genesisflow.SampleRate, 0);
            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);

            if (Boolean.Equals(Ok, false))
                return Ok;
            #endregion
            #region Write to led mode register
            Ok = false;
            frmTempCalibration.DisplayTempCal.DebugMessage("COMMAND CHANNEL:\t Writing to 'LED mode'-register\n", this.Culture);
            Ok = GenesisMeter.WriteRegisterSafe(Register.Genesisflow.LedMode, (Byte)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);

            if (Boolean.Equals(Ok, false))
                return Ok;
            #endregion
            #region Write to store completion register
            Misc.WaitNSeconds(1);
            Ok = false;
            frmTempCalibration.DisplayTempCal.DebugMessage($"COMMAND CHANNEL:\t Writing to 'Store calibration'-register\n", this.Culture);
            Ok = GenesisMeter.WriteRegisterUnsafe(Register.Genesisflow.StoreCalibration, 1);
            if (Ok)
                frmTempCalibration.DisplayTempCal.DebugMessage($"COMMAND CHANNEL:\t Writing to 'Store calibration'-register successful\n", this.Culture);
            else
                frmTempCalibration.DisplayTempCal.DebugMessage($"COMMAND CHANNEL:\t Writing to 'Store calibration'-register failed\n", this.Culture);
            #endregion
            #endregion

            return Ok;
        }
        public Completion(UInt16 meterNumber, CultureInfo culture)
        {
            this.Culture = culture;
            this.MeterNumber = meterNumber;
            this.MeterIndex = (meterNumber + 1).ToString(culture);
        }
        public Completion(UInt16 meterNumber, IMeter meter, CultureInfo culture)
        {
            if (meter is ZeroFlowGenesisMeter)
            {
                GenesisMeter = meter as ZeroFlowGenesisMeter;
            }
            this.Culture = culture;
            this.MeterNumber = meterNumber;
            this.MeterIndex = (meterNumber + 1).ToString(culture);
        }
        public void Initialize(String pcbID, String meterType, Int16 ledMode, Int16 storeCalibration)
        {
            this.LedMode = ledMode;
            this.StoreCalibration = storeCalibration;
            this.MeterType = meterType;
            this.PcbID = pcbID;
        }
        public UInt16 MeterNumber { get; private set; }
        public String MeterIndex { get; set; }
        public String PcbID { get; private set; }
        private String MeterType { get; set; }
        private CultureInfo Culture { get; set; }
        private Int16 LedMode { get; set; }
        private Int16 StoreCalibration { get; set; }
    }
}