using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using DTS.Common.DAS.Concepts;
using System.Threading;
using System.Windows.Forms;
using DTS.Common.DASResource;
using DTS.Common.Interface.DASFactory;
using Arm = DTS.DASLib.Command.SLICE.Arm;
using Disarm = DTS.DASLib.Command.SLICE.Disarm;
using EnableFaultChecking = DTS.DASLib.Command.SLICE.EnableFaultChecking;
using DTS.DASLib.Command.SLICE;
using DTS.Common.Utilities.Logging;
using System.Text;
using DTS.DASLib.Service.Classes.SLICE;
using System.Net.NetworkInformation;
using DTS.Common.Enums;
using DTS.Common.Enums.Sensors;
using DTS.Common.Interface.Communication;
using DTS.Common.Interface.Connection;
using DTS.Common.Enums.DASFactory;
using DTS.Common.ICommunication;
using DTS.Common.Interface.StatusAndProgressBar;
using DTS.Common.Utilities;
using DTS.DASLib.Command.SLICE.DownloadCommands;
using DTS.DASLib.Command.SLICEDB;
using DTS.Common.Constant.DASSpecific;
using DTS.Common.Enums.Hardware;
using DisableFaultChecking = DTS.DASLib.Command.SLICE.DisableFaultChecking;
using DTS.Common;

namespace DTS.DASLib.Service
{
    public class PowerPro<T> : PowerPro_Base<T>, //IDASReconfigure,
        IDASCommunication,
        IConfigurationActions,
        IDiagnosticsActions,
        ITriggerCheckActions,
        IRealTimeActions,
        IArmActions,
        IDownloadActions
        where T : IConnection, new()
    {
        protected override void AsyncConfigure(object configAsyncInfo)
        {
            var info = (SliceConfigServiceAsyncInfo)configAsyncInfo;

            if (ConfigData != null && ConfigData.Modules.Any())
            {
                try
                {
                    var saa = new SetArmAttribute(this);
                    saa.SetValue(AttributeTypes.ArmAndEventAttributes.SampleRate, ConfigData.Modules[0].SampleRateHz, true);
                    saa.SyncExecute();
                }
                catch (Exception ex)
                {
                    APILogger.Log("failed to configure", SerialNumber, ex);
                    info.Error(ex.Message);
                    return;
                }
            }
            base.AsyncConfigure(configAsyncInfo);
        }
        public override string ConvertInputVoltage2BatteryCharging(double inputVoltage)
        {
            bool isCharging;
            var SwitchQuery = new QuerySwitchImmediate(this)
            {
                DeviceID = 0,
                Switch = (byte)Switches.PowerProSwitches.ChargePower
            };
            try
            {
                SwitchQuery.SyncExecute();
                if (1 == SwitchQuery.Setting)
                {
                    isCharging = true;
                }
                else
                {
                    isCharging = false;
                }
            }
            catch (Exception)
            {
                isCharging = false;
            }

            // If we are charging
            if (isCharging)
            {
                return Resources.Charging;
            }
            // If we aren't charging and input is valid
            else if (inputVoltage > MinimumValidInputVoltage && inputVoltage < MaximumValidInputVoltage)
            {
                return Resources.NotCharging;
            }
            // If we're off input voltage and not charging
            else
            {
                return Resources.Discharging;
            }
        }
        public override bool? ChargingEnabled
        {
            get
            {
                return true;
            }
        }
        void IDASCommunication.SetIsStreamingSupported(bool supported)
        {
            IsStreamingSupported = false;
        }
        void IDASCommunication.ReadFirstUseDate()
        {
            IsFirstUseDateSupported = false;
            FirstUseDate = null;
        }
        /// <summary>
        /// indicates date of first use
        /// null indicates the hardware has not been used since calibration
        /// only valid when IsFirstUseDateSupported is true
        /// 15524 DAS "First Use Date"
        /// </summary>
        public DateTime? FirstUseDate { get; set; } = null;
        /// <summary>
        /// returns whether the hardware supports first use or not
        /// for hardware to support first use the hardware must support
        /// storage for user attributes in firmware and also have been
        /// calibrated by software support hardware first use
        /// 15524 DAS "First Use Date"
        /// </summary>
        public bool IsFirstUseDateSupported { get; set; } = false;
        /// <summary>
        /// returns true if the devices is an ethernet distributor
        /// for now that is SLICEDb, SLICE ECM, SLICE6DB
        /// these are devices that we talk through, but not to for device communication
        /// a rack we communicate with the modules by talking to the rack, so it's not a distributor
        /// </summary>
        /// <returns>returns true if the devices is an ethernet distributor</returns>
        public override bool IsEthernetDistributor()
        {
            return true;
        }
        public override bool IsSlice6Distributor()
        {
            return false;
        }
        public override bool IsBattery()
        {
            return true;
        }
        public override bool IsTSRAIR()
        {
            return false;
        }
        public bool IsSlice6Air()
        {
            return false;
        }
        public override bool IsScheduleEventCountSupported()
        {
            return false;
        }

        void IConfigurationActions.SetFirstUseDate(DateTime firstUseDate, ServiceCallback callback,
            object userData)
        {
            var info = new PowerProAsyncInfo(callback, userData);
            info.Error("Not supported");
        }
        /// <summary>
        /// Figure out if events have been downloaded
        /// </summary>
        /// <param name="callback">The function to call with information</param>
        /// <param name="userData">Whatever you want to pass along</param>
        public void QueryDownloadedStatus(ServiceCallback callback, object userData)
        {
            var info = new PowerProAsyncInfo(callback, userData);
            info.Success();
        }
        /// <summary>
        /// Verify that the ConfigData property is correctly constructed
        /// </summary>
        /// <param name="DoStrictCheck">Set to true if your're arming</param>
        public void VerifyConfig(bool DoStrictCheck)
        {
            VerifyConfig(DoStrictCheck, null);
        }
        public void VerifyConfig(bool DoStrictCheck, ErrorCallback failedChallengeFunc)
        {
            if (!DoStrictCheck) return;
            if (!IsCommandSupported(DFConstantsAndEnums.ProtocolLimitedCommands.InitHardwareInputLines)) return;
            var query = new InitializeHardwareLines(this)
            {
                CheckStartForShort = true,
                CheckTriggerForShort = true
            };

            try
            {
                query.SyncExecute();

                if (query.StartRecordShorted && !IgnoreShortedStart)
                {
                    //Start Shorted
                    throw new StartShortedException(string.Format(Strings.StartRecordShorted, SerialNumber));
                }
                if (query.TriggerInputShorted && !IgnoreShortedTrigger)
                {
                    //Trigger Shorted
                    throw new TriggerShortedException(string.Format(Strings.TriggerShorted, SerialNumber));
                }
            }
            catch (Exception ex)
            {
                InitializeHardwareLines.Log(ex, query);
            }
        }
        void IArmActions.ReArm(ServiceCallback callback, object userData, bool autoArm, bool arm, bool repeatEnable)
        {
            var info = new PowerProAsyncInfo(callback, userData);
            info.Error("NotSupported");
        }
        public void PreparedArmNow(ServiceCallback callback, object userData, Guid eventGuid, int
                armNowTimeout, bool testingMode,
            int maxNumberEvents, bool SysMode)
        {
            var info = new PowerProAsyncInfo(callback, userData);
            try
            {
                if (IsCommandSupported(DFConstantsAndEnums.ProtocolLimitedCommands.MeasurePowerProAllDiagnosticChannel))
                {
                    var mppadc = new MeasurePowerProAllDiagnosticChannel(this);
                    mppadc.SyncExecute(); // Just Log it for now
                }
            }
            catch (Exception ex) { APILogger.Log("Failed to Measure All Diagnostic Channel", ex); }

            var saa = new SetArmAttribute(this);
            var postTriggerSamples = Convert.ToUInt64(ConfigData.Modules[0].PostTriggerSeconds *
                                                      ConfigData.Modules[0].SampleRateHz);
            saa.SetValue(AttributeTypes.ArmAndEventAttributes.PostTriggerSamplesRequested, postTriggerSamples, true);
            saa.SyncExecute();

            saa = new SetArmAttribute(this);
            var preTriggerSamples = 0UL;
            if (ConfigData.Modules[0].RecordingMode == DFConstantsAndEnums.RecordingMode.CircularBuffer ||
                ConfigData.Modules[0].RecordingMode == DFConstantsAndEnums.RecordingMode.CircularBufferPlusUART)
            {
                preTriggerSamples =
                    Convert.ToUInt64(Math.Abs(ConfigData.Modules[0].PreTriggerSeconds *
                                              ConfigData.Modules[0].SampleRateHz));
            }
            saa.SetValue(AttributeTypes.ArmAndEventAttributes.PreTriggerSamplesRequested, preTriggerSamples, true);
            saa.SyncExecute();

            SetArmMode(ConfigData.Modules[0].RecordingMode);

            try
            {
                var arm = new Arm(this);
                arm.SyncExecute();
                //17812 DataPRO does not issue EnableFaultChecking when running with POWER PRO and a single DAS
                //UI code was setting this for non ethernet distributors
                DASArmStatus.IsArmed = true;
                SetDASArmStatus();
            }
            catch (Exception)
            {
                info.Success(); //TEMP until PowerPro Event line is not shorted
                return;
            }

            info.Success();
        }

        /// <summary>
        /// Perform diagnostics based on the property ChannelDiagnostics and stuff the 
        /// result in ChannelDiagnosticsResults
        /// </summary>
        /// <param name="diagnosticsSampleRateHz">sample rate</param>
        /// <param name="diagnosticsAAFilterFrequencyHz">AA Filter rate</param>
        /// <param name="whichResult"></param>
        /// <param name="callback">The function to call with information</param>
        /// <param name="userData">Whatever you want to pass along</param>
        void IDiagnosticsActions.PrepareForDiagnostics(uint diagnosticsSampleRateHz,
            float diagnosticsAAFilterFrequencyHz,
            PrePostResults whichResult,
            ServiceCallback callback, object userData)
        {
            var info = new PowerProAsyncInfo(callback, userData);
            info.Success();
        }

        /// <summary>
        /// Perform diagnostics based on the property ChannelDiagnostics and stuff the 
        /// result in ChannelDiagnosticsResults
        /// </summary>
        /// <param name="callback">The function to call with information</param>
        /// <param name="userData">Whatever you want to pass along</param>
        public void DiagnosAndGetResults(int EventNumber,
            PrePostResults WhichResult,
            ServiceCallback callback, object userData)
        {
            var info = new PowerProAsyncInfo(callback, userData);
            DiagnosticsHasBeenRun = true;
            BaseInput = new BaseInputValues();
            GetBaseInputs(true);
            ClearChannelDiagnosticsResults(false);
            info.Success();
        }
        public override double MaximumValidInputVoltage { get; set; } = 26D;
        public void PerformArmChecks(ServiceCallback callback, object userData)
        {
            var info = new PowerProAsyncInfo(callback, userData);
            LaunchAsyncWorker("PowerPro.PerformArmChecks", new WaitCallback(AsyncPerformArmChecks), info);
        }

        private void AsyncPerformArmChecks(object o)
        {
            var info = o as PowerProAsyncInfo;
            var dasResults = new ArmCheckResults();
            info.Progress(25);
            if (null != ArmCheckActions)
            {
                GetBaseInputs(true);
                if (ArmCheckActions.PerformInputVoltageCheck || ArmCheckActions.PerformBatteryVoltageCheck)
                {
                    try
                    {
                        if (IsCommandSupported(DFConstantsAndEnums.ProtocolLimitedCommands.MeasurePowerProAllDiagnosticChannel))
                        {
                            var mppadc = new MeasurePowerProAllDiagnosticChannel(this);
                            mppadc.SyncExecute(); // Just Log it for now
                        }
                    }
                    catch (Exception ex) { APILogger.Log("Failed to Measure All Diagnostic Channel", ex); }
                }
                if (ArmCheckActions.PerformBatteryVoltageCheck)
                {
                    //if (IsCommandSupported(DFConstantsAndEnums.ProtocolLimitedCommands.Diagnostics))
                    //{
                    try
                    {
                        dasResults.BatteryVoltage = new double?[1];
                        dasResults.BatteryVoltage[0] = BaseInput.BatteryMilliVolts / 1000D;
                    }
                    catch (Exception ex) { APILogger.Log("Failed to get Battery voltage", ex); }
                    //}
                }
                info.Progress(33);
                if (ArmCheckActions.PerformInputVoltageCheck)
                {
                    //if (IsCommandSupported(DFConstantsAndEnums.ProtocolLimitedCommands.Diagnostics))
                    //{
                    try
                    {
                        dasResults.InputVoltage = BaseInput.InputMilliVolts / 1000D;
                    }
                    catch (Exception ex) { APILogger.Log("Failed to get Input voltage", ex); }
                    //}
                }
                info.Progress(66);
                if (ArmCheckActions.PerformSquibResistanceCheck)
                {
                    // No Squibs in PowerPro
                }
                if (ArmCheckActions.PerformEventLineCheck)
                {
                    ((ITriggerCheckActions)this).DoTriggerCheckSync();
                }
                if (ArmCheckActions.PerformSensorIdCheck)
                {
                    //not needed
                }
                if (ArmCheckActions.PerformTemperatureCheck)
                {
                    //// Temperature
                    //dasResults.TemperaturesPre = new float[] { float.NaN, float.NaN, float.NaN, float.NaN, float.NaN, float.NaN, float.NaN, float.NaN };

                    //var measure = new MeasureS6DBDiagnosticChannel(this);

                    ////External sensor 1
                    //measure.Channel = MeasureS6DBDiagnosticChannel.S6DBDiagnosticChannelList.DiagEnv_2_Temperature;
                    //measure.SyncExecute();
                    //dasResults.TemperaturesPre[0] = measure.Measurement;

                    ////External sensor 2
                    //measure.Channel = MeasureS6DBDiagnosticChannel.S6DBDiagnosticChannelList.DiagEnv_3_Temperature;
                    //measure.SyncExecute();
                    //dasResults.TemperaturesPre[1] = measure.Measurement;

                    ////External sensor 3
                    //measure.Channel = MeasureS6DBDiagnosticChannel.S6DBDiagnosticChannelList.DiagEnv_4_Temperature;
                    //measure.SyncExecute();
                    //dasResults.TemperaturesPre[2] = measure.Measurement;

                    ////External sensor 4
                    //measure.Channel = MeasureS6DBDiagnosticChannel.S6DBDiagnosticChannelList.DiagEnv_5_Temperature;
                    //measure.SyncExecute();
                    //dasResults.TemperaturesPre[3] = measure.Measurement;
                }
            }
            info.Progress(100);
            dasResults.SensorIds = null;
            dasResults.TiltSensorDataPre = null;
            dasResults.SquibResistances = null;
            ArmCheckResults = dasResults;
            info.Success();
        }

        public void CheckAlreadyLevelTriggered(ServiceCallback callback, object userData)
        {
            var info = new PowerProAsyncInfo(callback, userData);
            LaunchAsyncWorker("PowerPro.CheckAlreadyLevelTriggered", AsyncCheckAlreadyLevelTriggered, info);
        }
        private void AsyncCheckAlreadyLevelTriggered(object asyncInfo)
        {
            var info = asyncInfo as PowerProAsyncInfo;
            Debug.Assert(info != null, "info != null");
            try
            {
                foreach (var m in ConfigData.Modules)
                {
                    foreach (var ch in m.Channels)
                    {
                        if (!(ch is AnalogInputDASChannel analog)) continue;
                        analog.AlreadyLevelTriggered = false;
                        analog.MeasuredEULevelTriggerCheck = double.NaN;
                    }
                }
                info.Success();
            }
            catch (Exception ex)
            {
                info.Error(ex.Message, ex);
            }
        }
        public void DoTriggerCheck(ServiceCallback callback, object userData)
        {
            //this was supposed to be async, why is it executing synchronously?  I dont' know
            //but I'm preserving it as is [dtm] 2019-05-23
            PowerProAsyncInfo info = null;
            if (null != callback)
            {
                info = new PowerProAsyncInfo(callback, userData);
            }
            DoTriggerCheckSync();
            info?.Success();
        }

        /// <summary>
        /// do the synchronous version of trigger check
        /// </summary>
        public void DoTriggerCheckSync()
        {
            if (IsCommandSupported(DFConstantsAndEnums.ProtocolLimitedCommands.InitHardwareInputLines))
            {
                var query = new InitializeHardwareLines(this) { LogCommands = true, CheckStartForShort = true, CheckTriggerForShort = true };
                try
                {
                    try
                    {
                        query.SyncExecute();
                    }
                    catch (Exception ex)
                    {
                        //IHL can throw an exception if the trigger is shorted, we don't want this
                        //but if it's anything else go and rethrow the exception
                        if (!ex.Message.ToLower().Contains("shorted"))
                        {
                            throw;
                        }
                    }

                    //var oldStatus = DASArmStatus;
                    var status = new ArmStatus
                    {
                        IsTriggered = query.TriggerInputShorted,
                        //IsArmed = query.TriggerInputShorted || query.StartRecordShorted
                        IsStartShorted = query.StartRecordShorted
                    };

                    //10601 Trigger Check can miss the pulse generated by HW
                    //we have to latch the trigger status for the S6DB ... since it does one shot pulse
                    //if (null != oldStatus)
                    //{
                    //    status.IsArmed = status.IsArmed || oldStatus.IsArmed;
                    //    status.IsTriggered = status.IsTriggered || oldStatus.IsTriggered;
                    //    status.IsStartShorted = status.IsStartShorted || oldStatus.IsStartShorted;
                    //}

                    status.IsTriggerShorted = status.IsTriggered;
                    //status.IsStartShorted = status.IsArmed;
                    status.IsStartShorted = status.IsStartShorted;
                    SetDASArmStatus(status, true);
                }
                catch (Exception ex)
                {
                    InitializeHardwareLines.Log(ex, query);
                }
            }
        }
        void ITriggerCheckActions.PostStartTriggerCheck(ServiceCallback callback, object userData)
        {
            var info = new PowerProAsyncInfo(callback, userData);
            info.Success();
        }
        private class EventDiagnosticsAsyncPacket
        {
            public PowerProAsyncInfo Info { get; set; }
            public int EventNumber { get; set; }
            public PrePostResults WhichResult { get; set; }
        }
        /// <summary>
        /// Retrieve the results from the implicit pre and post event diagnostics
        /// </summary>
        /// <param name="EventNumber">Which event number to Retrieve from</param>
        /// <param name="WhichResult">The pre or post test results?</param>
        /// <param name="callback">The function to call with information</param>
        /// <param name="userData">Whatever you want to pass along</param>
        public void GetEventDiagnosticsResults(int EventNumber, PrePostResults WhichResult,
            ServiceCallback callback, object userData)
        {
            var packet = new EventDiagnosticsAsyncPacket();
            packet.Info = new PowerProAsyncInfo(callback, userData);
            packet.EventNumber = EventNumber;
            packet.WhichResult = WhichResult;

            packet.Info.Success();
        }
        public void PerformVoltageCheckTAOnly(ServiceCallback callback, object userData)
        {
            var info = new PowerProAsyncInfo(callback, userData);
            LaunchAsyncWorker("PowerPro.PerformVoltageCheckTAOnly", AsyncPerformVoltageCheckTAOnly, info);
        }
        private void AsyncPerformVoltageCheckTAOnly(object o)
        {
            var info = o as PowerProAsyncInfo;
            info?.Success();
        }
        private const double SDB_ERR_VOLTAGE_REPORTING = 100000.0D;
        /// <summary>
        /// Retrieve the current arm status from the DAS
        /// </summary>
        /// <param name="callback">The function to call with information</param>
        /// <param name="userData">Whatever you want to pass along</param>
        //void IArmActions.GetArmStatus(ServiceCallback callback, object userData, uint inputVoltageCutoff)
        //{
        //    var info = new PowerProAsyncInfo(callback, userData);
        //    var status = new ArmStatus { IsArmed = false };
        //    try
        //    {
        //        try
        //        {
        //            if (IsCommandSupported(DFConstantsAndEnums.ProtocolLimitedCommands.MeasurePowerProAllDiagnosticChannel))
        //            {
        //                var mppadc = new MeasurePowerProAllDiagnosticChannel(this);
        //                mppadc.SyncExecute(); // Just Log it for now
        //            }
        //        }
        //        catch (Exception ex) { APILogger.Log("Failed to Measure All Diagnostic Channel", ex); }
        //        if (IsCommandSupported(DFConstantsAndEnums.ProtocolLimitedCommands.Diagnostics))
        //        {
        //            var batteryVoltage = 0.0;
        //            try
        //            {

        //                var query = new QueryBatteryVoltageMV(this, 3000);
        //                query.SyncExecute();
        //                var d = (double)query.BatteryVoltageMV;
        //                if (d > SDB_ERR_VOLTAGE_REPORTING)
        //                {
        //                    d /= 1000.0D;
        //                }

        //                status.BatteryMilliVolts = d;

        //                batteryVoltage = Math.Round(d / 1000, 1);
        //            }
        //            catch (Exception ex)
        //            {
        //                APILogger.Log("Failed to get battery mv", ex);
        //            }

        //            try
        //            {
        //                var query = new QueryV1VoltageMV(this, 3000);
        //                query.SyncExecute();
        //                var d = (double)query.V1VoltageMV;
        //                if (d > SDB_ERR_VOLTAGE_REPORTING)
        //                {
        //                    d /= 1000.0D;
        //                }

        //                status.InputMilliVolts = d;

        //                var inputVoltage = Math.Round(d / 1000, 1);

        //                if (batteryVoltage < MinimumValidBatteryVoltage || batteryVoltage > MaximumValidBatteryVoltage)
        //                {
        //                    batteryVoltage = 0.0;
        //                }

        //                BaseInput = new BaseInputValues();
        //                var batteryVoltageStatusColor = DFConstantsAndEnums.VoltageStatusColor.Off;
        //                batteryVoltageStatusColor = BaseInput.ChargeCapacityValid
        //                    ? ConvertBatteryCapacity2Color(batteryVoltage, BaseInput.ChargeCapacity)
        //                    : ConvertBatteryVoltage2Color(batteryVoltage);
        //                var batteryChargingStatus = string.Empty;
        //                if (batteryVoltage >= MinimumValidBatteryVoltage)
        //                {
        //                    batteryChargingStatus = ConvertInputVoltage2BatteryCharging(inputVoltage);
        //                }

        //                var statusDisplayBattery =
        //                    batteryVoltage < MinimumValidBatteryVoltage || batteryVoltage > MaximumValidBatteryVoltage
        //                        ? "---"
        //                        : batteryVoltage.ToString(System.Globalization.CultureInfo.InvariantCulture) + " V " +
        //                          batteryChargingStatus;
        //                var inputVoltageStatusColor = ConvertInputVoltage2Color(inputVoltage);
        //                BaseInput.InputVoltageStatusColor = inputVoltageStatusColor;
        //                BaseInput.StatusDisplayInput =
        //                    inputVoltage < MinimumValidInputVoltage || inputVoltage > MaximumValidInputVoltage
        //                        ? "---"
        //                        : inputVoltage.ToString(System.Globalization.CultureInfo.InvariantCulture) + " V";
        //                BaseInput.BatteryVoltageStatusColor = batteryVoltageStatusColor;
        //                BaseInput.StatusDisplayBattery = statusDisplayBattery;
        //            }
        //            catch (Exception ex)
        //            {
        //                APILogger.Log("Failed to get input mv", ex);
        //            }
        //        }
        //    }
        //    finally
        //    {
        //        SetDASArmStatus(status, true);
        //    }
        //    info.Success();
        //}
        void IConfigurationActions.CheckSafetyState(bool bArmed, ServiceCallback callback, object userData)
        {
            var info = new PowerProAsyncInfo(callback, userData);
            info.Success();
        }


        //}
        /// <summary>
        /// this is a duplicate class of SLICEDb.SDBAsyncInfo, we might want to just use that one, but it is marked private there 
        /// </summary>
        private class PowerProAsyncInfo
        {
            public ServiceCallback Callback { get; set; }
            public object UserData { get; set; }
            public object FunctionData { get; set; }

            public PowerProAsyncInfo(ServiceCallback callback, object userData)
            {
                Callback = callback;
                UserData = userData;
            }

            public void Error(string msg, Exception ex)
            {
                try
                {
                    var cbData = new ServiceCallbackData();
                    cbData.Status = ServiceCallbackData.CallbackStatus.Failure;
                    cbData.ErrorMessage = msg;
                    cbData.ErrorException = ex;
                    cbData.UserData = UserData;
                    Callback(cbData);
                }
                catch (Exception eex)
                {
                    APILogger.Log("MessageBox", "PowerPRO ERROR", eex);
                }
            }

            public void Error(string msg)
            {
                Error(msg, null);
            }

            public void Progress(int value)
            {
                try
                {
                    var progressData = new ServiceCallbackData();
                    progressData.Status = ServiceCallbackData.CallbackStatus.ProgressReport;
                    progressData.ProgressValue = value;
                    progressData.UserData = UserData;
                    Callback(progressData);
                }
                catch (Exception ex)
                {
                    APILogger.Log("MessageBox", "PowerPRO ERROR", ex);
                }
            }

            public void Success()
            {
                try
                {
                    var success = new ServiceCallbackData();
                    success.Status = ServiceCallbackData.CallbackStatus.Success;
                    success.UserData = UserData;
                    Callback(success);
                }
                catch (Exception ex)
                {
                    APILogger.Log("MessageBox", "PowerPRO ERROR", ex);
                }
            }

            public void Cancel()
            {
                try
                {
                    var cancelReport = new ServiceCallbackData();
                    cancelReport.Status = ServiceCallbackData.CallbackStatus.Canceled;
                    cancelReport.ProgressValue = 0;
                    cancelReport.UserData = UserData;
                    Callback(cancelReport);
                }
                catch (Exception ex)
                {
                    APILogger.Log("MessageBox", "PowerPRO ERROR", ex);
                }
            }
        }
    }


    public class PowerPro_Base<T> : SLICE2_Base<T> where T : IConnection, new()
    {
        protected override bool AdjustInputRange(AnalogInputDASChannel analog)
        {
            return false;
        }
        /// <summary>
        /// returns true if device supports trigger inversion, false otherwise
        /// <inheritdoc cref="IDASCommunication"/>
        /// </summary>
        /// <returns>true if device supports trigger inversion, false otherwise</returns>
        public override bool SupportsTriggerInversion() => HardwareConstants.SupportsTriggerInversion(GetHardwareType(), ProtocolVersion);
        /// <summary>
        /// returns true if device supports start inversion, false otherwise
        /// <inheritdoc cref="IDASCommunication"/>
        /// </summary>
        /// <returns>true if device supports start inversion, false otherwise</returns>
        public override bool SupportsStartInversion() => HardwareConstants.SupportsStartInversion(GetHardwareType(), ProtocolVersion);


        public override bool CheckAAF(float rate) { return true; }
        public override bool SupportsTimeSynchronization
        {
            get
            {
                return true;
            }
        }
        public override double[] GetNominalRanges(SensorConstants.BridgeType bridgeType)
        {
            switch (bridgeType)
            {
                case SensorConstants.BridgeType.IEPE:
                    return WinUSBSlice.StaticDASIEPEInfo.NominalRanges;
                default:
                    return WinUSBSlice.StaticDASBridgeInfo.NominalRanges;
            }
        }

        private readonly Dictionary<DFConstantsAndEnums.ProtocolLimitedCommands, byte> PowerPro_MinimumProtocols =
            new Dictionary<DFConstantsAndEnums.ProtocolLimitedCommands, byte>();

        public override void InitMinProto()
        {
            // SLICE 6.0 DB Protocol Limitations            
            PowerPro_MinimumProtocols[DFConstantsAndEnums.ProtocolLimitedCommands.QueryMSP430Firmware] = PowerPRO.MIN_PROTOCOL_VER;
            PowerPro_MinimumProtocols[DFConstantsAndEnums.ProtocolLimitedCommands.MultipleAndHybridEvents] = PowerPRO.MIN_PROTOCOL_VER;
            PowerPro_MinimumProtocols[DFConstantsAndEnums.ProtocolLimitedCommands.MultipleEvents] = PowerPRO.MIN_PROTOCOL_VER;
            PowerPro_MinimumProtocols[DFConstantsAndEnums.ProtocolLimitedCommands.AutoArm] = PowerPRO.MIN_PROTOCOL_VER;
            PowerPro_MinimumProtocols[DFConstantsAndEnums.ProtocolLimitedCommands.SetDefaultMIF] = PowerPRO.MIN_PROTOCOL_VER;
            PowerPro_MinimumProtocols[DFConstantsAndEnums.ProtocolLimitedCommands.FileData] = PowerPRO.MIN_PROTOCOL_VER;
            PowerPro_MinimumProtocols[DFConstantsAndEnums.ProtocolLimitedCommands.StackSensors] = PowerPRO.MIN_PROTOCOL_VER;
            PowerPro_MinimumProtocols[DFConstantsAndEnums.ProtocolLimitedCommands.BaseSystemTime] = PowerPRO.MIN_PROTOCOL_VER;
            PowerPro_MinimumProtocols[DFConstantsAndEnums.ProtocolLimitedCommands.TestCommunication] = PowerPRO.MIN_PROTOCOL_VER;
            PowerPro_MinimumProtocols[DFConstantsAndEnums.ProtocolLimitedCommands.StackLowPowerMode] = PowerPRO.MIN_PROTOCOL_VER;
            PowerPro_MinimumProtocols[DFConstantsAndEnums.ProtocolLimitedCommands.SetRealtimeSampleRate] = PowerPRO.MIN_PROTOCOL_VER;
            PowerPro_MinimumProtocols[DFConstantsAndEnums.ProtocolLimitedCommands.SLICE2_OneWireID] = PowerPRO.MIN_PROTOCOL_VER;
            PowerPro_MinimumProtocols[DFConstantsAndEnums.ProtocolLimitedCommands.HardwareRevision] = PowerPRO.MIN_PROTOCOL_VER;
            PowerPro_MinimumProtocols[DFConstantsAndEnums.ProtocolLimitedCommands.HardwareConfiguration] = PowerPRO.MIN_PROTOCOL_VER;
            PowerPro_MinimumProtocols[DFConstantsAndEnums.ProtocolLimitedCommands.EventFaultFlags] = PowerPRO.MIN_PROTOCOL_VER;
            PowerPro_MinimumProtocols[DFConstantsAndEnums.ProtocolLimitedCommands.EventArmAttempts] = PowerPRO.MIN_PROTOCOL_VER;
            PowerPro_MinimumProtocols[DFConstantsAndEnums.ProtocolLimitedCommands.QueryActualSampleRateImmediate] = PowerPRO.MIN_PROTOCOL_VER;
            PowerPro_MinimumProtocols[DFConstantsAndEnums.ProtocolLimitedCommands.InitHardwareInputLines] = PowerPRO.MIN_PROTOCOL_VER;
            PowerPro_MinimumProtocols[DFConstantsAndEnums.ProtocolLimitedCommands.VoltageSysAttributes] = PowerPRO.MIN_PROTOCOL_VER;
            PowerPro_MinimumProtocols[DFConstantsAndEnums.ProtocolLimitedCommands.LevelTrigger] = PowerPRO.MIN_PROTOCOL_VER;
            PowerPro_MinimumProtocols[DFConstantsAndEnums.ProtocolLimitedCommands.AttributeStoreBlocks] = PowerPRO.MIN_PROTOCOL_VER;
            PowerPro_MinimumProtocols[DFConstantsAndEnums.ProtocolLimitedCommands.QueryArmAndTriggerStatus_VoltageReadings] = PowerPRO.MIN_PROTOCOL_VER;
            PowerPro_MinimumProtocols[DFConstantsAndEnums.ProtocolLimitedCommands.MaxEvents] = PowerPRO.MIN_PROTOCOL_VER;
            PowerPro_MinimumProtocols[DFConstantsAndEnums.ProtocolLimitedCommands.AutoArmDiagnosticDelay] = PowerPRO.MIN_PROTOCOL_VER;
            PowerPro_MinimumProtocols[DFConstantsAndEnums.ProtocolLimitedCommands.StackChannelAutoArmDiagLevel] = PowerPRO.MIN_PROTOCOL_VER;
            PowerPro_MinimumProtocols[DFConstantsAndEnums.ProtocolLimitedCommands.MultipleSamplesRealtime] = PowerPRO.MIN_PROTOCOL_VER;
            PowerPro_MinimumProtocols[DFConstantsAndEnums.ProtocolLimitedCommands.BaseCalibrationDate] = PowerPRO.MIN_PROTOCOL_VER;
            PowerPro_MinimumProtocols[DFConstantsAndEnums.ProtocolLimitedCommands.IgnoreShortedStartEvent] = PowerPRO.MIN_PROTOCOL_VER;
            PowerPro_MinimumProtocols[DFConstantsAndEnums.ProtocolLimitedCommands.ResetAttributeStore] = PowerPRO.MIN_PROTOCOL_VER;


            PowerPro_MinimumProtocols[DFConstantsAndEnums.ProtocolLimitedCommands.DiangosShuntDAC] = PowerPRO.DIAGNOS_SHUNT_DAC;
            PowerPro_MinimumProtocols[DFConstantsAndEnums.ProtocolLimitedCommands.VoltageInsertion] = PowerPRO.DIAGNOS_SHUNT_DAC;
            PowerPro_MinimumProtocols[DFConstantsAndEnums.ProtocolLimitedCommands.QueryEthernetMacTable] = PowerPRO.MIN_PROTOCOL_QUERYMACTABLE;
            PowerPro_MinimumProtocols[DFConstantsAndEnums.ProtocolLimitedCommands.MeasurePowerProAllDiagnosticChannel] = PowerPRO.MIN_PROTOCOL_MEASUREPOWERPROALLDIAGNOSTICCHANNEL;

            PowerPro_MinimumProtocols[DFConstantsAndEnums.ProtocolLimitedCommands.Diagnostics] = PowerPRO.MIN_PROTOCOL_VER;

            MinimumProtocols = PowerPro_MinimumProtocols;
        }
        protected override Slice<T>.ConfigAttributes GetConfigAttributes(ICommunication com)
        {
            return new SLICE6ConfigAttributes(com);
        }
        /// <summary>
        /// SLICE6 config attributes, mostly inherits from SLICE.ConfigAttributes with some functionality removed
        /// </summary>
        protected class SLICE6ConfigAttributes : Slice<T>.ConfigAttributes
        {
            public SLICE6ConfigAttributes(ICommunication _com)
                : base(_com)
            {
            }
        }

        /// <summary>
        /// QueryEventData also is customized for SLICE6, it needs to perform SLICE6 specific data marshalling
        /// </summary>
        /// <returns></returns>
        protected override QueryEventDataBase GetQueryEventData()
        {
            return new QueryEventData_SLICE6(this, QueryEventData_SLICE6.Default_IO_Timeout);
        }
        /// <summary>
        /// we can probably simplify and take common items (slice6+slice1) out of this function, but for now
        /// it's mostly a copy of SLICE1.AsyncConfigure
        /// </summary>
        /// <param name="configAsyncInfo"></param>
        protected override void AsyncConfigure(object configAsyncInfo)
        {
            var info = (SliceConfigServiceAsyncInfo)configAsyncInfo;

            ConfigureHasBeenRun = true;
            if (info.DiscardDiagnostics) { DiagnosticsHasBeenRun = false; }
            info.Progress(100);
            info.Success();
        }

        #region Voltage Check
        public void PerformVoltageCheck(ServiceCallback callback, object userData)
        {
            var info = new SliceServiceAsyncInfo(callback, userData);
            LaunchAsyncWorker("PowerPro.PerformVoltageCheck", AsyncPerformVoltageCheck, info);
        }

        private void AsyncPerformVoltageCheck(object o)
        {
            var info = o as SliceServiceAsyncInfo;
            try
            {
                GetBaseInputs(true);
                info?.Success();
            }
            catch (Exception ex)
            {
                APILogger.Log(ex);
                info?.Error(ex.Message);
            }
        }
        #endregion

        /// <summary>
        /// hardcoded constants right now ... maybe these belong in attributes in the firmware! 
        /// </summary>
        protected override uint MaxAAFilterRateHz { get { return PowerPRO.MaxAAFilterRateHz; } }
        protected override uint MaxSampleRateHz { get { return 400000; } }
    }
}