using System;
using System.Linq;
using System.Threading.Tasks;
using System.Windows.Forms;
using System.Threading;
using System.Globalization;

namespace GenesisZeroFlow
{

    public static class TaskOperations
    {

        public static Boolean[] GetResultTotal(Boolean[] enable, Task<Boolean> Task1, Task<Boolean> Task2, Task<Boolean> Task3, Task<Boolean> Task4, Task<Boolean> Task5, Task<Boolean> Task6, Task<Boolean> Task7, Task<Boolean> Task8, Task<Boolean> Task9, Task<Boolean> Task10)
        {
            #region Definitions and initializations
            Boolean[] failed = new Boolean[Constants.NumberOfMeters];
            for (UInt16 Meter = Constants.Meter1; Meter < Constants.NumberOfMeters; Meter++)
                failed[Meter] = false;
            #endregion
            #region Individual tasks
            failed[Constants.Meter1] = GetResult(enable[Constants.Meter1], Task1);
            failed[Constants.Meter2] = GetResult(enable[Constants.Meter2], Task2);
            failed[Constants.Meter3] = GetResult(enable[Constants.Meter3], Task3);
            failed[Constants.Meter4] = GetResult(enable[Constants.Meter4], Task4);
            failed[Constants.Meter5] = GetResult(enable[Constants.Meter5], Task5);
            failed[Constants.Meter6] = GetResult(enable[Constants.Meter6], Task6);
            failed[Constants.Meter7] = GetResult(enable[Constants.Meter7], Task7);
            failed[Constants.Meter8] = GetResult(enable[Constants.Meter8], Task8);
            failed[Constants.Meter9] = GetResult(enable[Constants.Meter9], Task9);
            failed[Constants.Meter10] = GetResult(enable[Constants.Meter10], Task10);
            #endregion

            return failed;
        }
        public static Boolean GetResult(Boolean enable, Task<Boolean> CurrentTask)
        {
            Boolean failed = false;

            if (enable)
            {
                if (!TaskStatus.Equals(CurrentTask.Status, TaskStatus.Running))
                {
                    if (TaskStatus.Equals(CurrentTask.Status, TaskStatus.RanToCompletion))
                        return CurrentTask.Result;
                    if (TaskStatus.Equals(CurrentTask.Status, TaskStatus.Faulted))
                        return true;
                    if (TaskStatus.Equals(CurrentTask.Status, TaskStatus.Canceled))
                        return true;
                }
                /*
                else
                {
                    if (CurrentTask.Status == TaskStatus.Created)
                    {
                        CurrentTask = Task.Run(() =>
                        {
                            return true;
                        });
                        while (CurrentTask.Status != TaskStatus.RanToCompletion) { };
                        CurrentTask.Dispose();
                    }
                }
                */
            }
            return failed;
        }
        public static void CheckAndDispose(ref Task<Boolean> CurrentTask)
        {
            if ((TaskStatus.Equals(CurrentTask.Status, TaskStatus.RanToCompletion)) || (TaskStatus.Equals(CurrentTask.Status, TaskStatus.Canceled)) || (TaskStatus.Equals(CurrentTask.Status, TaskStatus.Faulted)))
                CurrentTask.Dispose();
        }
        public static void CheckAndDispose(Task<Boolean> CurrentTask)
        {
            if ((TaskStatus.Equals(CurrentTask.Status, TaskStatus.RanToCompletion)) || (TaskStatus.Equals(CurrentTask.Status, TaskStatus.Canceled)) || (TaskStatus.Equals(CurrentTask.Status, TaskStatus.Faulted)))
                CurrentTask.Dispose();
        }
        public static Boolean WaitFor(Task<Boolean> task)
        {
            return WaitFor(true, task);
        }
        public static Boolean WaitFor(Boolean taskStarted, Task<Boolean> task)
        {
            #region CA1062
            if (task == null)
                return false;
            #endregion
            Boolean Completed = true;

            if (taskStarted)
            {
                if ((TaskStatus.Equals(task.Status, TaskStatus.RanToCompletion)) || (TaskStatus.Equals(task.Status, TaskStatus.Faulted)) || (TaskStatus.Equals(task.Status, TaskStatus.Canceled)))
                    Completed = true;
                else
                    Completed = false;

            }
            /*
            else
            {
                task = Task.Run(() =>
                {
                    return true;
                });

                while( task.Status != TaskStatus.RanToCompletion){ };
                return true;
            }   */

            return Completed;
        }
    }

    public static partial class ArrayInit
    {
        public static UInt16[] Path(UInt16 value)
        {
            UInt16[] array = new UInt16[Constants.NumberOfPaths];

            try
            {
                for (UInt16 Path = Constants.PATH0; Path < Constants.NumberOfPaths; Path++)
                    array[Path] = value;
            }
            catch
            {

            }

            return array;
        }

        public static Int32[] Path(Int32 value)
        {
            Int32[] array = new Int32[Constants.NumberOfPaths];

            try
            {
                for (UInt16 Path = Constants.PATH0; Path < Constants.NumberOfPaths; Path++)
                    array[Path] = value;
            }
            catch
            {

            }

            return array;
        }

        public static Double[] Path(Double value)
        {
            Double[] array = new Double[Constants.NumberOfPaths];

            try
            {
                for (UInt16 Path = Constants.PATH0; Path < Constants.NumberOfPaths; Path++)
                    array[Path] = value;
            }
            catch
            {

            }

            return array;
        }

        public static Boolean[] Path(Boolean value)
        {
            Boolean[] array = new Boolean[Constants.NumberOfPaths];

            try
            {
                for (UInt16 Path = Constants.PATH0; Path < Constants.NumberOfPaths; Path++)
                    array[Path] = value;
            }
            catch
            {

            }

            return array;
        }

        public static UInt16[] Thermo(UInt16 value)
        {
            UInt16[] array = new UInt16[Constants.NumberOfThermometers];

            try
            {
                for (UInt16 Thermo = Constants.Thermo1; Thermo < Constants.NumberOfThermometers; Thermo++)
                    array[Thermo] = value;
            }
            catch
            {

            }

            return array;
        }

        public static Int32[] Thermo(Int32 value)
        {
            Int32[] array = new Int32[Constants.NumberOfThermometers];

            try
            {
                for (UInt16 Thermo = Constants.Thermo1; Thermo < Constants.NumberOfThermometers; Thermo++)
                    array[Thermo] = value;
            }
            catch
            {

            }

            return array;
        }

        public static Double[] Thermo(Double value)
        {
            Double[] array = new Double[Constants.NumberOfThermometers];

            try
            {
                for (UInt16 Thermo = Constants.Thermo1; Thermo < Constants.NumberOfThermometers; Thermo++)
                    array[Thermo] = value;
            }
            catch
            {

            }

            return array;
        }

        public static Boolean[] Thermo(Boolean value)
        {
            Boolean[] array = new Boolean[Constants.NumberOfThermometers];

            try
            {
                for (UInt16 Thermo = Constants.PATH0; Thermo < Constants.NumberOfThermometers; Thermo++)
                    array[Thermo] = value;
            }
            catch
            {

            }

            return array;
        }

        public static UInt16[] Meter(UInt16 value)
        {
            UInt16[] array = new UInt16[Constants.NumberOfMeters];

            try
            {
                for (UInt16 Meter = Constants.Meter1; Meter < Constants.NumberOfMeters; Meter++)
                    array[Meter] = value;
            }
            catch
            {

            }

            return array;
        }

        public static Int32[] Meter(Int32 value)
        {
            Int32[] array = new Int32[Constants.NumberOfMeters];

            try
            {
                for (UInt16 Meter = Constants.Meter1; Meter < Constants.NumberOfMeters; Meter++)
                    array[Meter] = value;
            }
            catch
            {

            }

            return array;
        }

        public static Double[] Meter(Double value)
        {
            Double[] array = new Double[Constants.NumberOfMeters];

            try
            {
                for (UInt16 Meter = Constants.Meter1; Meter < Constants.NumberOfMeters; Meter++)
                    array[Meter] = value;
            }
            catch
            {

            }

            return array;
        }

        public static Boolean[] Meter(Boolean value)
        {
            Boolean[] array = new Boolean[Constants.NumberOfMeters];

            try
            {
                for (UInt16 Meter = Constants.Meter1; Meter < Constants.NumberOfMeters; Meter++)
                    array[Meter] = value;
            }
            catch
            {

            }

            return array;
        }
    }

    public static partial class Misc
    {

     

        public static Double Minimum(Double valueA, Double valueB)
        {
            if (valueA < valueB)
                return valueA;
            else
                return valueB;
        }

        public static Boolean[] Subarray(Boolean[] data, Int32 offset, Int32 width)
        {
            if (data.Count() < width + offset)
                return null;

            Boolean[] subdata = new Boolean[width];

            for (UInt16 i = 0; i < width; i++)
                subdata[i] = data[offset + i];
            return subdata;
        }

        public static Byte[] Subarray(Byte[] data, Int32 offset, Int32 width)
        {
            if (data.Count() < width + offset)
                return null;

            Byte[] subdata = new Byte[width];

            for (UInt16 i = 0; i < width; i++)
                subdata[i] = data[offset + i];
            return subdata;
        }

        public static void WaitForDebuging(Int32 value, CultureInfo culture)
        {
            for (Int32 i = value; i > 0; i--)
            {
                GenesisZeroFlow.Display.StatusLabel(i.ToString(culture));
                WaitNSeconds(1);
            }
        }

        public static Boolean OnlyDecimalInString(String data)
        {
            return (System.Text.RegularExpressions.Regex.IsMatch(data, @"^[0-9]+(\.[0-9]+)?$"));
        }

        public static Boolean OnlyHexInString(String data)
        {
            // For C-style hex notation (0xFF) you can use @"\A\b(0[xX])?[0-9a-fA-F]+\b\Z"
            return System.Text.RegularExpressions.Regex.IsMatch(data, @"\A\b[0-9a-fA-F]+\b\Z");
        }


        public static void WaitCondition(Boolean condition)
        {
            if (condition)
                Application.DoEvents();
        }


        public static void WaitNSeconds(Int32 seconds, bool fromGui = false)
        {
            fromGui = true;
            if (fromGui)
            {
                if (seconds < 1) return;
                TimeSpan ts = new TimeSpan();
                DateTime _desired = DateTime.Now.AddSeconds(seconds);
                while (DateTime.Now < _desired)
                {
                    Application.DoEvents();
                    Thread.Sleep(100);

                }
            }
            else
            {
                Thread.Sleep(seconds * 1000);
            }
        }


        [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1011:ConsiderPassingBaseTypesAsParameters")]


        public static void WaitNMilliseconds(Int32 milliseconds, bool fromGui = false)
        {
            //if (fromGui)
            //{
            //    if (milliseconds < 1) return;
            //    TimeSpan ts = new TimeSpan();
            //    DateTime _desired = DateTime.Now.AddMilliseconds(milliseconds);
            //    while (DateTime.Now < _desired)
            //    {
            //        Application.DoEvents();
            //        Thread.Sleep(1);

            //    }
            //}
            //else
            //{
                Thread.Sleep(milliseconds);
           // }
        }





    }
}