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

namespace GenesisZeroFlow
{
    public static class EmptyPipeCheckSequences
    {
        //public static Boolean[] Total(Boolean[] enable, out Boolean aborted)
        //{
        //    #region Definitions and initializations
        //    const UInt16 WaitingTime = 60;
        //    CultureInfo Culture = GenesisZeroFlow._GenesisZeroFlow.GetGlobalCulture();
        //    Boolean[] Aborted = new Boolean[Constants.NumberOfMeters];
        //    Boolean[] TaskCompleted = new Boolean[Constants.NumberOfMeters];
        //    Boolean[] SequenceFailed = new Boolean[Constants.NumberOfMeters];
        //    aborted = false;

        //    #region avoid CA1062
        //    if (enable == null)
        //    {
        //        for (UInt16 Meter = Constants.Meter1; Meter < Constants.NumberOfMeters; Meter++)
        //            SequenceFailed[Meter] = true;
        //        return SequenceFailed;
        //    }
        //    #endregion

        //    for (UInt16 Meter = Constants.Meter1; Meter < Constants.NumberOfMeters; Meter++)
        //        SequenceFailed[Meter] = false;

        //    EmptyPipeCheck EmptyPipeCheck1 = new EmptyPipeCheck();
        //    EmptyPipeCheck EmptyPipeCheck2 = new EmptyPipeCheck();
        //    EmptyPipeCheck EmptyPipeCheck3 = new EmptyPipeCheck();
        //    EmptyPipeCheck EmptyPipeCheck4 = new EmptyPipeCheck();
        //    EmptyPipeCheck EmptyPipeCheck5 = new EmptyPipeCheck();
        //    EmptyPipeCheck EmptyPipeCheck6 = new EmptyPipeCheck();
        //    EmptyPipeCheck EmptyPipeCheck7 = new EmptyPipeCheck();
        //    EmptyPipeCheck EmptyPipeCheck8 = new EmptyPipeCheck();
        //    EmptyPipeCheck EmptyPipeCheck9 = new EmptyPipeCheck();
        //    EmptyPipeCheck EmptyPipeCheck10 = new EmptyPipeCheck();

        //    EmptyPipeCheck1.Initialize(WaitingTime, Constants.Meter1, Culture);
        //    EmptyPipeCheck2.Initialize(WaitingTime, Constants.Meter2, Culture);
        //    EmptyPipeCheck3.Initialize(WaitingTime, Constants.Meter3, Culture);
        //    EmptyPipeCheck4.Initialize(WaitingTime, Constants.Meter4, Culture);
        //    EmptyPipeCheck5.Initialize(WaitingTime, Constants.Meter5, Culture);
        //    EmptyPipeCheck6.Initialize(WaitingTime, Constants.Meter6, Culture);
        //    EmptyPipeCheck7.Initialize(WaitingTime, Constants.Meter7, Culture);
        //    EmptyPipeCheck8.Initialize(WaitingTime, Constants.Meter8, Culture);
        //    EmptyPipeCheck9.Initialize(WaitingTime, Constants.Meter9, Culture);
        //    EmptyPipeCheck10.Initialize(WaitingTime, Constants.Meter10, Culture);

        //    Task<Boolean> Task1 = new Task<Boolean>(() => { return true; });
        //    Task<Boolean> Task2 = new Task<Boolean>(() => { return true; });
        //    Task<Boolean> Task3 = new Task<Boolean>(() => { return true; });
        //    Task<Boolean> Task4 = new Task<Boolean>(() => { return true; });
        //    Task<Boolean> Task5 = new Task<Boolean>(() => { return true; });
        //    Task<Boolean> Task6 = new Task<Boolean>(() => { return true; });
        //    Task<Boolean> Task7 = new Task<Boolean>(() => { return true; });
        //    Task<Boolean> Task8 = new Task<Boolean>(() => { return true; });
        //    Task<Boolean> Task9 = new Task<Boolean>(() => { return true; });
        //    Task<Boolean> Task10 = new Task<Boolean>(() => { return true; });
        //    #endregion

        //    using (CancellationTokenSource cancellationTokenSource = new CancellationTokenSource())
        //    {
        //        CancellationToken token = cancellationTokenSource.Token;
        //        #region METER1
        //        if (enable[Constants.Meter1])
        //        {
        //            Task1 = Task.Run(() =>
        //            {
        //                SequenceFailed[Constants.Meter1] = EmptyPipeCheck1.PerformTest(out Aborted[Constants.Meter1], token);
        //                return SequenceFailed[Constants.Meter1];
        //            });
        //        }
        //        #endregion
        //        #region METER2
        //        if (enable[Constants.Meter2])
        //        {
        //            Task2 = Task.Run(() =>
        //            {
        //                SequenceFailed[Constants.Meter2] = EmptyPipeCheck2.PerformTest(out Aborted[Constants.Meter2], token);
        //                return SequenceFailed[Constants.Meter2];
        //            });
        //        }
        //        #endregion
        //        #region METER3
        //        if (enable[Constants.Meter3])
        //        {
        //            Task3 = Task.Run(() =>
        //            {
        //                SequenceFailed[Constants.Meter3] = EmptyPipeCheck3.PerformTest(out Aborted[Constants.Meter3], token);
        //                return SequenceFailed[Constants.Meter3];
        //            });
        //        }
        //        #endregion
        //        #region METER4
        //        if (enable[Constants.Meter4])
        //        {
        //            Task4 = Task.Run(() =>
        //            {
        //                SequenceFailed[Constants.Meter4] = EmptyPipeCheck4.PerformTest(out Aborted[Constants.Meter4], token);
        //                return SequenceFailed[Constants.Meter4];
        //            });
        //        }
        //        #endregion
        //        #region METER5
        //        if (enable[Constants.Meter5])
        //        {
        //            Task5 = Task.Run(() =>
        //            {
        //                SequenceFailed[Constants.Meter5] = EmptyPipeCheck5.PerformTest(out Aborted[Constants.Meter5], token);
        //                return SequenceFailed[Constants.Meter5];
        //            });
        //        }
        //        #endregion
        //        #region METER6
        //        if (enable[Constants.Meter6])
        //        {
        //            Task6 = Task.Run(() =>
        //            {
        //                SequenceFailed[Constants.Meter6] = EmptyPipeCheck6.PerformTest(out Aborted[Constants.Meter6], token);
        //                return SequenceFailed[Constants.Meter6];
        //            });
        //        }
        //        #endregion
        //        #region METER7
        //        if (enable[Constants.Meter7])
        //        {
        //            Task7 = Task.Run(() =>
        //            {
        //                SequenceFailed[Constants.Meter7] = EmptyPipeCheck7.PerformTest(out Aborted[Constants.Meter7], token);
        //                return SequenceFailed[Constants.Meter7];
        //            });
        //        }
        //        #endregion
        //        #region METER8
        //        if (enable[Constants.Meter8])
        //        {
        //            Task8 = Task.Run(() =>
        //            {
        //                SequenceFailed[Constants.Meter8] = EmptyPipeCheck8.PerformTest(out Aborted[Constants.Meter8], token);
        //                return SequenceFailed[Constants.Meter8];
        //            });
        //        }
        //        #endregion
        //        #region METER9
        //        if (enable[Constants.Meter9])
        //        {
        //            Task9 = Task.Run(() =>
        //            {
        //                SequenceFailed[Constants.Meter9] = EmptyPipeCheck9.PerformTest(out Aborted[Constants.Meter9], token);
        //                return SequenceFailed[Constants.Meter9];
        //            });
        //        }
        //        #endregion
        //        #region METER10
        //        if (enable[Constants.Meter10])
        //        {
        //            Task10 = Task.Run(() =>
        //            {
        //                SequenceFailed[Constants.Meter10] = EmptyPipeCheck10.PerformTest(out Aborted[Constants.Meter10], token);
        //                return SequenceFailed[Constants.Meter10];
        //            });
        //        }
        //        #endregion
        //        #region Wait for tasks
        //        GenesisZeroFlow.Display.ShowResultStatus("Task started = ", enable);
        //        Boolean[] SequenceOk = new Boolean[Constants.NumberOfMeters];

        //        for (UInt16 Meter = Constants.Meter1; Meter < Constants.NumberOfMeters; Meter++)
        //            SequenceOk[Meter] = false;

        //        while (!CheckArray(enable, TaskCompleted))
        //        {
        //            if (GenesisZeroFlow._GenesisZeroFlow.AbortIndicator)
        //            {
        //                cancellationTokenSource.Cancel();
        //                aborted = true;
        //                GenesisZeroFlow.Display.DebugCrcIndicatorVisible(false);
        //            }

        //            TaskCompleted[Constants.Meter1] = TaskOperations.WaitFor(enable[Constants.Meter1], Task1);
        //            TaskCompleted[Constants.Meter2] = TaskOperations.WaitFor(enable[Constants.Meter2], Task2);
        //            TaskCompleted[Constants.Meter3] = TaskOperations.WaitFor(enable[Constants.Meter3], Task3);
        //            TaskCompleted[Constants.Meter4] = TaskOperations.WaitFor(enable[Constants.Meter4], Task4);
        //            TaskCompleted[Constants.Meter5] = TaskOperations.WaitFor(enable[Constants.Meter5], Task5);
        //            TaskCompleted[Constants.Meter6] = TaskOperations.WaitFor(enable[Constants.Meter6], Task6);
        //            TaskCompleted[Constants.Meter7] = TaskOperations.WaitFor(enable[Constants.Meter7], Task7);
        //            TaskCompleted[Constants.Meter8] = TaskOperations.WaitFor(enable[Constants.Meter8], Task8);
        //            TaskCompleted[Constants.Meter9] = TaskOperations.WaitFor(enable[Constants.Meter9], Task9);
        //            TaskCompleted[Constants.Meter10] = TaskOperations.WaitFor(enable[Constants.Meter10], Task10);
        //            Misc.WaitNSeconds(1);

        //            SequenceFailed = TaskOperations.GetResultTotal(enable, Task1, Task2, Task3, Task4, Task5, Task6, Task7, Task8, Task8, Task10);
        //            for (UInt16 Meter = Constants.Meter1; Meter < Constants.NumberOfMeters; Meter++)
        //                SequenceOk[Meter] = !SequenceFailed[Meter];
        //            GenesisZeroFlow.Display.MeterStatusGreenRed(SequenceOk, enable);
        //        }
        //        GenesisZeroFlow.Display.ShowResultStatus("Sequence OK (while loop) = ", SequenceOk);
        //        SequenceFailed = TaskOperations.GetResultTotal(enable, Task1, Task2, Task3, Task4, Task5, Task6, Task7, Task8, Task8, Task10);
        //        for (UInt16 Meter = Constants.Meter1; Meter < Constants.NumberOfMeters; Meter++)
        //            SequenceOk[Meter] = !SequenceFailed[Meter];
        //        GenesisZeroFlow.Display.MeterStatusGreenRed(SequenceOk, enable);
        //        // GenesisZeroFlow.Display.ShowResultStatus("Sequence failed (not while loop) = ", TaskFailed);
        //        // GenesisZeroFlow.Display.ShowResultStatus("Task Completed = ", TaskCompleted);
        //        // GenesisZeroFlow.Display.ShowResultStatus("Amplitude total failed: ", TaskFailed);
        //        #endregion
        //        #region Destroy tasks
        //        TaskOperations.CheckAndDispose(ref Task1);
        //        TaskOperations.CheckAndDispose(ref Task2);
        //        TaskOperations.CheckAndDispose(ref Task3);
        //        TaskOperations.CheckAndDispose(ref Task4);
        //        TaskOperations.CheckAndDispose(ref Task5);
        //        TaskOperations.CheckAndDispose(ref Task6);
        //        TaskOperations.CheckAndDispose(ref Task7);
        //        TaskOperations.CheckAndDispose(ref Task8);
        //        TaskOperations.CheckAndDispose(ref Task9);
        //        TaskOperations.CheckAndDispose(ref Task10);
        //        #endregion
        //        #region Clear data
        //        for (UInt16 Meter = Constants.Meter1; Meter < Constants.NumberOfMeters; Meter++)
        //            GenesisZeroFlow._GenesisZeroFlow.SetDataToLog(Meter, String.Empty);
        //        #endregion
        //    }
        //    return SequenceFailed;
        //}
        public static Boolean[] Total(Boolean[] allEnable, out Boolean aborted, MeterBatch globalMeterBatch, MeterBatch thermoMeterBatch, CultureInfo culture)
        {
            #region Definitions and initializations
            const UInt16 WaitingTime = 60;
            Boolean[] Aborted = new Boolean[Constants.NumberOfMeters];
            Boolean[] MeterTaskCompleted = new Boolean[Constants.NumberOfMeters];
            Boolean[] MeterSequenceFailed = new Boolean[Constants.NumberOfMeters];
            MeterSequenceFailed = ArrayInit.Meter(false);
            Boolean[] ThermoAborted = new Boolean[Constants.NumberOfThermometers];
            Boolean[] ThermoTaskCompleted = new Boolean[Constants.NumberOfThermometers];
            Boolean[] ThermoSequenceFailed = new Boolean[Constants.NumberOfThermometers];
            ThermoSequenceFailed = ArrayInit.Thermo(false);
            Boolean[] MeterEnable = Misc.Subarray(allEnable, 0, Constants.NumberOfMeters);
            Boolean[] ThermoEnable = Misc.Subarray(allEnable, Constants.NumberOfMeters, Constants.NumberOfThermometers);
            aborted = false;

            #region avoid CA1062
            if (allEnable == null)
            {
                for (UInt16 Meter = Constants.Meter1; Meter < Constants.NumberOfMeters; Meter++)
                    MeterSequenceFailed[Meter] = true;
                for (UInt16 Thermo = Constants.Thermo1; Thermo < Constants.NumberOfThermometers; Thermo++)
                    ThermoSequenceFailed[Thermo] = true;
                return MeterSequenceFailed.Concat(ThermoSequenceFailed).ToArray();
            }
            #endregion

            List<EmptyPipeCheck> EmptyPipeChecks = new List<EmptyPipeCheck>();
            List<EmptyPipeCheck> ThermoEmptyPipeChecks = new List<EmptyPipeCheck>();

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

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

                if (currentMeter != null)
                    ThermoEmptyPipeChecks.Add(new EmptyPipeCheck(currentMeter, Thermo, culture));
                else
                    ThermoEmptyPipeChecks.Add(new EmptyPipeCheck(Thermo, culture));
            }
            #endregion

            foreach (var check in EmptyPipeChecks)
            {
                check.AddTask(new Task<Boolean>(() => { return true; }));
                check.Initialize(GenesisZeroFlow._GenesisZeroFlow.PcbID[check.MeterNumber], Constants.Meter, WaitingTime);
            }

            foreach (var tempcheck in ThermoEmptyPipeChecks)
            {
                tempcheck.AddTask(new Task<Boolean>(() => { return true; }));
                tempcheck.Initialize(GenesisZeroFlow._GenesisZeroFlow.ThermoID[tempcheck.MeterNumber], Constants.Thermo, WaitingTime);
            }
            #endregion

            using (CancellationTokenSource cancellationTokenSource = new CancellationTokenSource())
            {
                CancellationToken token = cancellationTokenSource.Token;

                foreach (var metercheck in EmptyPipeChecks)
                {
                    if (metercheck.CurrentMeter != null && MeterEnable[metercheck.CurrentMeter.Slot - 1])
                    {
                        metercheck.MyTask = Task.Run(() =>
                        {
                            MeterSequenceFailed[metercheck.CurrentMeter.Slot - 1] = metercheck.PerformTest(out Aborted[metercheck.CurrentMeter.Slot - 1], token);
                            return MeterSequenceFailed[metercheck.CurrentMeter.Slot - 1];
                        });
                    }
                }
                foreach (var tempcheck in ThermoEmptyPipeChecks)
                {
                    if (tempcheck.CurrentMeter != null && ThermoEnable[tempcheck.CurrentMeter.Slot - 11])
                    {
                        tempcheck.MyTask = Task.Run(() =>
                        {
                            ThermoSequenceFailed[tempcheck.CurrentMeter.Slot - 11] = tempcheck.PerformTest(out ThermoAborted[tempcheck.CurrentMeter.Slot - 11], token);
                            return ThermoSequenceFailed[tempcheck.CurrentMeter.Slot - 11];
                        });
                    }
                }

                #region Wait for tasks
                Boolean[] MeterSequenceOk = new Boolean[Constants.NumberOfMeters];
                MeterSequenceOk = ArrayInit.Meter(false);
                Boolean[] ThermoSequenceOk = new Boolean[Constants.NumberOfThermometers];
                ThermoSequenceOk = ArrayInit.Thermo(false);

                while (!CheckArray(allEnable, MeterTaskCompleted.Concat(ThermoTaskCompleted).ToArray()))
                {
                    if (GenesisZeroFlow._GenesisZeroFlow.AbortIndicator)
                    {
                        cancellationTokenSource.Cancel();
                        aborted = true;
                    }
                    foreach (var waitTask in EmptyPipeChecks)
                        MeterTaskCompleted[waitTask.MeterNumber] = TaskOperations.WaitFor(MeterEnable[waitTask.MeterNumber], waitTask.MyTask);
                    foreach (var waitTask in ThermoEmptyPipeChecks)
                        ThermoTaskCompleted[waitTask.MeterNumber] = TaskOperations.WaitFor(ThermoEnable[waitTask.MeterNumber], waitTask.MyTask);

                    Misc.WaitNSeconds(1);

                    foreach (var waitTask in EmptyPipeChecks)
                        MeterTaskCompleted[waitTask.MeterNumber] = TaskOperations.WaitFor(MeterEnable[waitTask.MeterNumber], waitTask.MyTask);
                    foreach (var waitTask in ThermoEmptyPipeChecks)
                        ThermoTaskCompleted[waitTask.MeterNumber] = TaskOperations.WaitFor(ThermoEnable[waitTask.MeterNumber], waitTask.MyTask);

                    foreach (var ResultTask in EmptyPipeChecks)
                        MeterSequenceFailed[ResultTask.MeterNumber] = TaskOperations.GetResult(MeterEnable[ResultTask.MeterNumber], ResultTask.MyTask);
                    foreach (var ResultTask in ThermoEmptyPipeChecks)
                        ThermoSequenceFailed[ResultTask.MeterNumber] = TaskOperations.GetResult(ThermoEnable[ResultTask.MeterNumber], ResultTask.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, MeterEnable);
                    GenesisZeroFlow.Display.ThermoStatusGreenRed(ThermoSequenceOk, ThermoEnable);
                }

                foreach (var ResultTask in EmptyPipeChecks)
                    MeterSequenceFailed[ResultTask.MeterNumber] = TaskOperations.GetResult(MeterEnable[ResultTask.MeterNumber], ResultTask.MyTask);
                foreach (var ResultTask in ThermoEmptyPipeChecks)
                    ThermoSequenceFailed[ResultTask.MeterNumber] = TaskOperations.GetResult(ThermoEnable[ResultTask.MeterNumber], ResultTask.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, MeterEnable);
                GenesisZeroFlow.Display.ThermoStatusGreenRed(ThermoSequenceOk, ThermoEnable);
                #endregion
                #region Destroy tasks
                foreach (var TaskToDispose in EmptyPipeChecks)
                    TaskOperations.CheckAndDispose(ref TaskToDispose.MyTask);
                foreach (var TaskToDispose in ThermoEmptyPipeChecks)
                    TaskOperations.CheckAndDispose(ref TaskToDispose.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(Boolean enable, MeterBatch globalMeterBatch, CultureInfo culture)
        {
            #region Definitions and initializations
            const UInt16 WaitingTime = 60;
            Boolean TaskCompleted = false;
            Boolean SequenceFailed = false;
            List<EmptyPipeCheck> EmptyPipeChecks = new List<EmptyPipeCheck>();

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

            foreach (var check in EmptyPipeChecks)
            {
                check.AddTask(new Task<Boolean>(() => { return true; }));
                check.Initialize(String.Empty, Constants.Meter, WaitingTime);
            }
            #endregion

            using (CancellationTokenSource cancellationTokenSource = new CancellationTokenSource())
            {
                CancellationToken token = cancellationTokenSource.Token;
                foreach (var check in EmptyPipeChecks)
                {
                    if (check.CurrentMeter != null && enable)
                    {
                        check.MyTask = Task.Run(() =>
                        {
                            SequenceFailed = check.PerformTestTempCal();
                            return SequenceFailed;
                        });
                    }
                }
                #region Wait for tasks
                Boolean SequenceOk = false;

                while (!Check(enable, TaskCompleted))
                {

                    foreach (var waitTask in EmptyPipeChecks)
                        TaskCompleted = TaskOperations.WaitFor(enable, waitTask.MyTask);

                    Misc.WaitNSeconds(1);

                    foreach (var waitTask in EmptyPipeChecks)
                    {
                        if (waitTask.CurrentMeter != null)
                        {
                            //waitTask.CurrentMeter.StartRecordData();
                        }
                        TaskCompleted = TaskOperations.WaitFor(enable, waitTask.MyTask);
                    }


                    foreach (var ResultTask in EmptyPipeChecks)
                        SequenceFailed = TaskOperations.GetResult(enable, ResultTask.MyTask);

                    SequenceOk = !SequenceFailed;
                    frmTempCalibration.DisplayTempCal.MeterStatusGreenRed(SequenceOk, enable);
                }

                foreach (var ResultTask in EmptyPipeChecks)
                    SequenceFailed = TaskOperations.GetResult(enable, ResultTask.MyTask);

                SequenceOk = !SequenceFailed;
                frmTempCalibration.DisplayTempCal.MeterStatusGreenRed(SequenceOk, enable);
                #endregion
                #region Destroy tasks
                foreach (var TaskToDispose in EmptyPipeChecks)
                    TaskOperations.CheckAndDispose(ref TaskToDispose.MyTask);
                #endregion
                #region Clear data
                //for (UInt16 Meter = Constants.Meter1; Meter < Constants.NumberOfMeters; Meter++)
                //    GenesisZeroFlow._GenesisZeroFlow.SetDataToLog(Meter, String.Empty);
                #endregion
            }
            return SequenceFailed;
        }
        private static Boolean CheckArray(Boolean[] enable, Boolean[] array)
        {
            Boolean Completed = true;

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

            return Completed;
        }

        private static Boolean Check(Boolean enable, Boolean array)
        {
            Boolean Completed = true;

            if ((Boolean.Equals(array, false)) && (Boolean.Equals(enable, true)))
                return false;

            return Completed;
        }
    }
    public class EmptyPipeCheck
    {
        public ZeroFlowGenesisMeter CurrentMeter;
        public UInt16 MeterNumber { get; set; }
        public String MeterIndex { get; set; }
        public EmptyPipeCheck(UInt16 meterNumber, CultureInfo culture)
        {
            this.MeterNumber = meterNumber;
            this.Culture = culture;
            this.MeterIndex = (meterNumber + 1).ToString(culture);
        }
        public EmptyPipeCheck(IMeter currentMeter, UInt16 meterNumber, CultureInfo culture)
        {
            if (currentMeter is ZeroFlowGenesisMeter)
            {
                this.CurrentMeter = (ZeroFlowGenesisMeter)currentMeter;
            }
            this.MeterNumber = meterNumber;
            this.Culture = culture;
            this.MeterIndex = (meterNumber + 1).ToString(culture);
        }

        String PcbID { get; set; }
        private String Metertype { get; set; }
        private UInt16 WaitingTime { get; set; }
        private CultureInfo Culture { get; set; }
        public void Initialize(String pcbID, String meterType, UInt16 waitingTime)
        {
            this.WaitingTime = waitingTime;
            this.Metertype = meterType;
            this.PcbID = pcbID;
        }
        public Boolean PerformTest(out Boolean aborted, CancellationToken token)
        {
            #region Definitions and initialization
            Boolean SequenceFailed = false;
            Boolean PerformWait = false;
            Double[] Error = new Double[Constants.NumberOfPaths];
            Error = ArrayInit.Path((Double)0.00);
            Int32 Countup = 0;
            Int32[] LinecounterFollowing = new Int32[Constants.NumberOfPaths];
            LinecounterFollowing = ArrayInit.Path(0);
            aborted = false;
            Boolean ActivityOk = false;
            #endregion
            #region Reset counter for activity check/ switch on counting
            if (String.Equals(this.Metertype, Constants.Meter))
            {
                for(UInt16 Path = Constants.PATH0; Path < Constants.NumberOfPaths; Path++)
                    GenesisZeroFlow._GenesisZeroFlow.SetLineCounterEmptyPipeTest(0, this.MeterNumber, Path);
                GenesisZeroFlow._GenesisZeroFlow.SetLoggingIndicatorEmptyPipeTest(this.MeterNumber, true);
            }
            else
            {
                for (UInt16 Path = Constants.PATH0; Path < Constants.NumberOfPaths; Path++)
                    GenesisZeroFlow._GenesisZeroFlow.SetLineCounterThermoEmptyPipeTest(0, this.MeterNumber, Path);
                GenesisZeroFlow._GenesisZeroFlow.SetLoggingIndicatorThermoEmptyPipeTest(this.MeterNumber, true);
            }
            #endregion
            #region Cancel
            if (token.IsCancellationRequested)
                return true;
            #endregion
            #region Testsequence
            for (Int32 Countdown = WaitingTime; Countdown >= 0; Countdown--)
            {
                if (Int32.Equals(Countup, 0))
                    PerformWait = true;
                else
                    PerformWait = false;
                #region Abort
                if (GenesisZeroFlow._GenesisZeroFlow.AbortIndicator)
                {
                    aborted = true;
                    return true; // all enabled meters get sequence failed
                }
                #endregion
                #region Activity check
                String Resttime = Countdown.ToString(this.Culture);
                GenesisZeroFlow.Display.StatusLabel($"{GenesisZeroFlow.PredefinedMessages.WaitForEmptyPipe(this.Culture)} {Resttime}s");
                if (String.Equals(this.Metertype, Constants.Meter))
                    ActivityOk = this.ActivityCheck(ref LinecounterFollowing, Countup);
                else
                    ActivityOk = this.ThermoActivityCheck(ref LinecounterFollowing, Countup);
                if (token.IsCancellationRequested)
                    return true;
                #endregion
                #region Time control
                Misc.WaitNSeconds(1);
                Countup++;
                #endregion
                #region Get error status
                if (String.Equals(this.Metertype, Constants.Meter))
                {
                    for (UInt16 Path = Constants.PATH0; Path < Constants.NumberOfPaths; Path++)
                        Error[Constants.PATH0] = GenesisZeroFlow._GenesisZeroFlow.GetDecodedAllMeters()[this.MeterNumber][Path].Validation;
                }
                else
                {
                    for (UInt16 Path = Constants.PATH0; Path < Constants.NumberOfPaths; Path++)
                        Error[Constants.PATH0] = GenesisZeroFlow._GenesisZeroFlow.GetDecodedAllThermometers()[this.MeterNumber][Path].Validation;
                }
                #endregion
                #region Check if wait
                for (UInt16 Path = Constants.PATH0; Path < Constants.NumberOfPaths; Path++)
                {
                    if ((!(Double.Equals(Error[Path], (Double)DataError.NoError))) || (!ActivityOk))
                        PerformWait = true;
                }
                #endregion
                #region All OK 
                if (Boolean.Equals(PerformWait, false))
                {
                    GenesisZeroFlow.Display.DebugMessage($"{this.PcbID}\tDATA CHANNEL:\t\t Leave EMPTY PIPE mode at {this.Metertype}{this.MeterIndex}\n", this.Culture);
                    return false;
                }
                #endregion
            }
            #endregion
            #region Failed
            SequenceFailed = true;
            GenesisZeroFlow.Display.DebugMessage($"{this.PcbID}\tDATA CHANNEL:\t\t Leave EMPTY PIPE mode failed at {this.Metertype}{this.MeterIndex}\n", this.Culture);
            if (this.Metertype == Constants.Meter)
                GenesisZeroFlow._GenesisZeroFlow.GenerateReturnNote($"{this.MeterIndex}", this.PcbID, GenesisZeroFlow.PredefinedMessages.EmptyPipeFailed(this.Culture), GenesisZeroFlow._GenesisZeroFlow.GetLoggingFromTextBox(), this.Culture);
            #endregion
            #region Switch off counting
            if (String.Equals(this.Metertype, Constants.Meter))
                GenesisZeroFlow._GenesisZeroFlow.SetLoggingIndicatorEmptyPipeTest(this.MeterNumber, false);
            else
                GenesisZeroFlow._GenesisZeroFlow.SetLoggingIndicatorThermoEmptyPipeTest(this.MeterNumber, false);
            #endregion

            return SequenceFailed;
        }

        public Boolean PerformTestTempCal()
        {
            #region Definitions and initialization
            Boolean SequenceFailed = false;
            Boolean PerformWait = false;
            Double[] Error = new Double[Constants.NumberOfPaths];
            Error = ArrayInit.Path(0.00);
            Int32 Countup = 0;
            Int32[] LinecounterFollowing = new Int32[Constants.NumberOfPaths];
            LinecounterFollowing = ArrayInit.Path((Int32)0);
            Boolean ActivityOk = false;
            String MeterIndex = (this.MeterNumber + 1).ToString(this.Culture);
            #endregion
            #region Reset counter for activity check/ switch on counting
            for (UInt16 Path = Constants.PATH0; Path < Constants.NumberOfPaths; Path++)
                frmTempCalibration._frmTempCalibration.SetLineCounterEmptyPipeTest(0, Path);
            frmTempCalibration._frmTempCalibration.SetEnableIndicatorEmptyPipeTest(true);
            #endregion
            #region Testsequence
            for (Int32 Countdown = WaitingTime; Countdown >= 0; Countdown--)
            {
                if (Int32.Equals(Countup, 0))
                    PerformWait = true;
                else
                    PerformWait = false;
                #region Abort
                #endregion
                #region Activity check
                frmTempCalibration.DisplayTempCal.StatusLabel($"Wait for leaving EMPTY PIPE mode: {Countdown.ToString(this.Culture)}s");
                ActivityOk = this.ActivityCheckTempCal(ref LinecounterFollowing, Countup);
                #endregion
                #region Time control
                Misc.WaitNSeconds(1);
                Countup++;
                #endregion
                #region Get error status
                for(UInt16 Path = Constants.PATH0; Path < Constants.NumberOfPaths; Path++)
                if (frmTempCalibration._frmTempCalibration.GetDecodedAllMeters()[Path] != null)
                    Error[Path] = frmTempCalibration._frmTempCalibration.GetDecodedAllMeters()[Path].Validation;
                #endregion
                #region Check if wait
                for (UInt16 Path = Constants.PATH0; Path < Constants.NumberOfPaths; Path++)
                {
                    if ((!Double.Equals(Error[Path], (Double)DataError.NoError)) || (!ActivityOk))
                        PerformWait = true;
                }
                #endregion
                #region All OK 
                if (Boolean.Equals(PerformWait, false))
                {
                    frmTempCalibration.DisplayTempCal.DebugMessage($"DATA CHANNEL:\t\t Leave EMPTY PIPE mode\n", this.Culture);
                    frmTempCalibration.DisplayTempCal.DebugMessage(Debugmessages.Line, this.Culture);
                    return false;
                }
                #endregion
            }
            #endregion
            #region Failed
            SequenceFailed = true;
            frmTempCalibration.DisplayTempCal.DebugMessage($"DATA CHANNEL:\t\t Leave EMPTY PIPE mode failed\n", this.Culture);
            frmTempCalibration.DisplayTempCal.DebugMessage($"{Debugmessages.Line}", this.Culture);
            #endregion
            #region Switch off counting
            frmTempCalibration._frmTempCalibration.SetEnableIndicatorEmptyPipeTest(false);
            #endregion

            return SequenceFailed;
        }
        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 (GenesisZeroFlow._GenesisZeroFlow.GetLineCounterEmptyPipeTest()[this.MeterNumber][Path] != 0)
                {
                    if (Int32.Equals(GenesisZeroFlow._GenesisZeroFlow.GetLineCounterEmptyPipeTest()[this.MeterNumber][Path], lineCounterFollowing[Path]))
                        return false;
                    else
                        lineCounterFollowing[Path] = GenesisZeroFlow._GenesisZeroFlow.GetLineCounterEmptyPipeTest()[this.MeterNumber][Path];
                }
                if ((seconds > 0) && (Int32.Equals(GenesisZeroFlow._GenesisZeroFlow.GetLineCounterEmptyPipeTest()[this.MeterNumber][Path], 0)))
                    return false;

            }
            #endregion
            #region Result
            Ok = !Error;
            #endregion

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

            return Ok;
        }
        public Task<Boolean> MyTask;
        internal void AddTask(Task<Boolean> task)
        {
            MyTask = task;
        }
    }
}