using System;
using Microsoft.SPOT;

namespace CPF
{
    class ErrorHandler
    {
        //Count parsePOnlyErrors
        private static int parsePOnlyErrors = 0;
        private static int parsePOnlyErrorsLimit = 10;
        private static TimeSpan parsePOnlyErrorTimeout = new TimeSpan(0, 10, 0);
        private static TimeSpan lastParsePOnlyErrorTime = new TimeSpan();
        private static TimeSpan parsePOnlyTimeNow = new TimeSpan();
        public static void incrParsePOnlyErrors()
        {
            parsePOnlyTimeNow = Microsoft.SPOT.Hardware.Utility.GetMachineTime();

            if (parsePOnlyErrors == 0)
            {
                lastParsePOnlyErrorTime = parsePOnlyTimeNow;
                parsePOnlyErrors = 1;
            }
            else
            {
                if ((parsePOnlyTimeNow - lastParsePOnlyErrorTime) < parsePOnlyErrorTimeout)
                {
                    parsePOnlyErrors = parsePOnlyErrors + 1;
                    if (parsePOnlyErrors > parsePOnlyErrorsLimit)
                        Debug.Print("parsePOnly Errors exceeds limit");
                }
                else
                {
                    parsePOnlyErrors = 1;
                }
                lastParsePOnlyErrorTime = parsePOnlyTimeNow;
            }
        }

        //Count Optode Event Handler errors
        private static int optodeEHErrors = 0;
        private static int optodeEHErrorsLimit = 10;
        private static TimeSpan optodeEHErrorTimeout = new TimeSpan(0, 10, 0);
        private static TimeSpan lastoptodeEHErrorTime = new TimeSpan();
        private static TimeSpan optodeEHTimeNow = new TimeSpan();
        public static void incrOptodeEHErrors()
        {
            optodeEHTimeNow = Microsoft.SPOT.Hardware.Utility.GetMachineTime();

            if (optodeEHErrors == 0)
            {
                lastoptodeEHErrorTime = optodeEHTimeNow;
                optodeEHErrors = 1;
            }
            else
            {
                if ((optodeEHTimeNow - lastoptodeEHErrorTime) < optodeEHErrorTimeout)
                {
                    optodeEHErrors = optodeEHErrors + 1;
                    if (optodeEHErrors > optodeEHErrorsLimit)
                        Debug.Print("optodeEH Errors exceeds limit");
                }
                else
                {
                    optodeEHErrors = 1;
                }
                lastoptodeEHErrorTime = optodeEHTimeNow;
            }
        }

        //Count structured queue Enqueue errors
        private static int enqueueErrors = 0;
        private static int enqueueErrorsLimit = 10;
        private static TimeSpan enqueueErrorTimeout = new TimeSpan(0, 10, 0);
        private static TimeSpan lastEnqueueErrorTime = new TimeSpan();
        private static TimeSpan enqueueTimeNow = new TimeSpan();
        public static void incrEnqueueErrors()
        {
            enqueueTimeNow = Microsoft.SPOT.Hardware.Utility.GetMachineTime();

            if (enqueueErrors == 0)
            {
                lastEnqueueErrorTime = enqueueTimeNow;
                enqueueErrors = 1;
            }
            else
            {
                if ((enqueueTimeNow - lastEnqueueErrorTime) < enqueueErrorTimeout)
                {
                    enqueueErrors = enqueueErrors + 1;
                    if (enqueueErrors > enqueueErrorsLimit)
                        Debug.Print("enqueueError Errors exceeds limit");
                }
                else
                {
                    enqueueErrors = 1;
                }
                lastEnqueueErrorTime = enqueueTimeNow;
            }
        }

        //Check for too many sequential identical pressure values in a given time period
        private static int stuckPressureErrors = -1;
        private static int stuckPressureErrorsLimit = 17;
        private static double lastPressure = double.NaN;
        private static TimeSpan stuckPressureErrorPeriod = new TimeSpan(0, 1, 0);
        private static TimeSpan stuckPressureStartTime = new TimeSpan();
        private static TimeSpan stuckPressureTimeNow = new TimeSpan();
        public static bool isPressureStuck(double inPressure)
        {
            stuckPressureTimeNow = Microsoft.SPOT.Hardware.Utility.GetMachineTime();
            //Initialize the timer and counter
            if (stuckPressureErrors == -1)
            {
                lastPressure = inPressure;
                stuckPressureErrors = stuckPressureErrors + 1;
                stuckPressureStartTime = stuckPressureTimeNow;
            }
            else  //Increment or reset the counter
            {
                if (inPressure == lastPressure)
                    stuckPressureErrors = stuckPressureErrors + 1;
                else
                    stuckPressureErrors = -1;
            }

            //If the error Period has has expired check if error count exceeds the limit
            if ((stuckPressureTimeNow - stuckPressureStartTime) > stuckPressureErrorPeriod)
            {
                if (stuckPressureErrors > stuckPressureErrorsLimit)
                {
                    stuckPressureErrors = -1;
                    return (true);
                }
                else
                    return (false);
            }
            else
                return(false);
        }
    }
}