using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Xml;
using System.Xml.Schema;
using System.Xml.Serialization;
using DTS.Common.DAS.Concepts;
using DTS.Common.Enums;
using DTS.Common.Enums.DASFactory;
using DTS.Common.Interface.DASFactory;
using DTS.Common.Interface.DASFactory.Config;
using DTS.Common.Utils;

namespace DTS.DASLib.Service
{

    /// <summary>
    /// This represents one Module on a DAS unit.  A DAS unit can have numerous Modules and a Module can have
    /// numerous channels.  The channels that are connected to this module are in the <see cref="DASModule.Channels" />
    /// array property. See <see cref="DASChannel" />.  Another property, <see cref="DASModule.ModuleArrayIndex" /> 
    /// is the index of this object in any array of Modules in the corresponding <see cref="IDASCommunication" /> 
    /// however it may also be addressed by it's Device ID.  The first module in a DAS will have a ModuleArrayIndex
    /// of 0 but a DeviceID of 1. See <see cref="DTS.DASLib.Service.InfoResult" />.MapDASChannelNumber2ModuleDeviceID and 
    /// <see cref="DTS.DASLib.Service.InfoResult" />.MapModuleDeviceIDAndChannelNum2DASChannel
    /// </summary>
    [Serializable]
    public class DASModule : IDASModule, IXmlSerializable
    {
        /// <summary>
        /// An array of <see cref="DASChannel" /> objects representing the channels attatched to this
        /// module, indexable by ModuleChannelNumber of the Channel.
        /// </summary>
        public IDASChannel[] Channels { get; set; }

        /// <summary>
        /// EID's for the module corresponding to the sensors on each of the channels.
        /// </summary>
        [XmlIgnore]
        public IEID[] IDs { get; set; }

        /// <summary>
        /// Index of this Module in any array of Modules.  The first module in a DAS unit will have a
        /// ModuleArrayIndex of 0.
        /// </summary>
        public int ModuleArrayIndex { get; set; }

        /// <summary>
        /// For use only with Circular-Buffer mode.
        /// See <see cref="DASModule.RecordingMode" />.
        /// The number of requested seconds for this Module to sample data before a 'Trigger' event; the number of
        /// seconds to sample BEFORE time-zero.
        /// </summary>
        public double RequestedPreTriggerSeconds { get; set; }

        /// <summary>
        /// For use with all recording modes.
        /// See <see cref="DASModule.RecordingMode" />.
        /// The number of requested seconds to sample data from sensors after time-zero, that is after
        /// a trigger or start event.
        /// </summary>
        public double RequestedPostTriggerSeconds { get; set; }

        /// <summary>
        /// For use only with Circular-Buffer mode.
        /// See <see cref="DASModule.RecordingMode" />.
        /// The number of seconds for this Module to sample data before a 'Trigger' event; the number of
        /// seconds to sampel BEFORE time-zero.
        /// </summary>
        public double PreTriggerSeconds { get; set; }

        /// <summary>
        /// For use with all recording modes.
        /// See <see cref="DASModule.RecordingMode" />.
        /// The number of seconds to sample data from sensors after time-zero, that is after
        /// a trigger or start event.
        /// </summary>
        public double PostTriggerSeconds { get; set; }

        /// <summary>
        /// The number of events to collect before disarming.
        /// </summary>
        public int NumberOfEvents { get; set; }

        /// <summary>
        /// The number of seconds of inactivity before going back to sleep.
        /// </summary>
        public int WakeUpMotionTimeout { get; set; }

        /// <summary>
        /// The version of the firmware on a module.
        /// </summary>
        public string FirmwareVersion { get; set; }

        /// <summary>
        /// A string that describes the module, for example, to know if it was created for the
        /// purposes of adding it to the .dts file during download of Slice6 Distributor attributes.
        /// </summary>
        public string Description { get; set; }

        /// <summary>
        /// The maximum storage space for a module.
        /// </summary>
        public UInt64? MaxEventStorageSpaceInBytes { get; set; }

        /// <summary>
        /// This is set after a recording session and is the total number of samples this Module
        /// captured during the last data acquisition run.
        /// </summary>
        public UInt64 NumberOfSamples { get; set; }

        /// <summary>
        /// An array of sample numbers where a trigger was activated.
        /// </summary>
        [XmlIgnore]
        public UInt64[] TriggerSampleNumbers { get; set; }

        public int GetLevelTriggerT0AdjustmentSamplesAutoApplied()
        {

            try
            {
                //temporary hack/workaround to correct leveltriggert0adjustmentsamples
                if (OwningDAS is IDASReconfigure)
                {
                    //we do qualifications +1 at request of Loc/Tim, see them for details
                    var channelsWithAdjustments = Channels.Where(c => c.LevelTriggerSeen);
                    return channelsWithAdjustments.Count() > 0 ? channelsWithAdjustments.First().QualificationSamples : 0;
                }
                else
                {
                    //
                    // Figure out what the number of samples that would have been auto-applied to
                    // this module is.
                    //
                    var channelsWithAdjustments = Channels.Where(c => null != c.LevelTriggerT0AdjustmentSamples);
                    var channelsWithMaxAdjustment = channelsWithAdjustments.Max(c => c.LevelTriggerT0AdjustmentSamples);
                    return channelsWithAdjustments.Count() > 0 ? (int)(channelsWithAdjustments.First().LevelTriggerT0AdjustmentSamples) : 0;
                }
            }

            catch (System.Exception ex)
            {
                throw new ApplicationException(
                    "encountered problem getting number of level trigger T0 adjustment samples already applied to module "
                    + (null != OwningDAS && null != OwningDAS.SerialNumber ? "\"" + OwningDAS.SerialNumber + "\"" : "<NULL>")
                    + ", module "
                    + ModuleArrayIndex.ToString(),
                    ex);
            }
        }
        /// <summary>
        /// The sample number where recording started.
        /// </summary>
        public ulong StartRecordSampleNumber { get; set; }
        /// <summary>
        /// 
        /// </summary>
        public uint StartRecordTimestampSec { get; set; }
        /// <summary>
        /// 
        /// </summary>
        public uint TriggerTimestampSec { get; set; }
        /// <summary>
        /// 
        /// </summary>
        public uint StartRecordTimestampNanoSec { get; set; }
        /// <summary>
        /// 
        /// </summary>
        public uint TriggerTimestampNanoSec { get; set; }
        /// <summary>
        /// 
        /// </summary>
        public bool PTPMasterSync { get; set; }
        /// <summary>
        /// 
        /// </summary>
        public double TiltSensorAxisXDegreesPre { get; set; }
        /// <summary>
        /// 
        /// </summary>
        public double TiltSensorAxisYDegreesPre { get; set; }
        /// <summary>
        /// 
        /// </summary>
        public double TiltSensorAxisZDegreesPre { get; set; }
        /// <summary>
        /// 
        /// </summary>
        public double TiltSensorAxisXDegreesPost { get; set; }
        /// <summary>
        /// 
        /// </summary>
        public double TiltSensorAxisYDegreesPost { get; set; }
        /// <summary>
        /// 
        /// </summary>
        public double TiltSensorAxisZDegreesPost { get; set; }
        public float TemperatureLocation1Pre { get; set; } = float.NaN;

        public float TemperatureLocation2Pre { get; set; } = float.NaN;
        public float TemperatureLocation3Pre { get; set; } = float.NaN;
        public float TemperatureLocation4Pre { get; set; } = float.NaN;
        public float TemperatureLocation1Post { get; set; } = float.NaN;
        public float TemperatureLocation2Post { get; set; } = float.NaN;
        public float TemperatureLocation3Post { get; set; } = float.NaN;
        public float TemperatureLocation4Post { get; set; } = float.NaN;

        /// <summary>
        /// The sample rate in Hz at which the Module will sample sensor data.
        /// </summary>
        public uint SampleRateHz { get; set; }

        //FB 25558
        /// <summary>
        /// The actual sample rate in Hz currently used in realtime for TSR AIR  
        /// </summary>
        public uint ActualSampleRateHz { get; set; }

        /// <summary>
        /// The sample rate in Hz at which any Embedded Modules will sample sensor data.
        /// </summary>
        public uint[] EmbeddedSampleRateHz { get; set; }

        /// <summary>
        /// xml string tag for AAFilterRateHz
        /// </summary>
        public const string AAFilterRateHzTag = "AAFilterRateHz";
        /// <summary>
        /// Hardware anti-alias filter rate.
        /// </summary>
        public float AAFilterRateHz { get; set; }

        /// <summary>
        /// What type of recording mode is this Module in?
        /// See <see cref="Test.Module.RecordingMode.RecorderMode" />.
        /// </summary>
        public DFConstantsAndEnums.RecordingMode RecordingMode { get; set; }
        public DateTime ScheduledStartTime { get; set; }
        public int RecordingInterval { get; set; }

        /// <summary>
        /// FB15388: The UDP streaming profile set (for supporting DAS).
        /// </summary>
        [XmlIgnore]
        public UDPStreamProfile StreamProfile { get; set; }

        #region Slice 6 Tilt Feature

        /// <summary>
        /// Defines which 2 axis will be used for the bubble level feature for Slice 6.
        /// </summary>
        public DFConstantsAndEnums.TiltAxes TiltAxes { get; set; }

        public double TargetAxisOne { get; set; }

        public double TargetAxisTwo { get; set; }

        public float TargetAngleAxisX { get; set; }
        public float TargetAngleAxisY { get; set; }
        public float TargetAngleAxisZ { get; set; }

        public double MountOffsetAxisOne { get; set; }

        public double MountOffsetAxisTwo { get; set; }

        public string SystemLocation { get; set; }

        public string SystemID { get; set; }

        public int AxisIgnored { get; set; }

        public byte TiltID { get; set; }

        public string TiltSerialNumber { get; set; }

        public double LevelTolerance { get; set; }

        public bool UseForTiltCalculation { get; set; }
        public double InputVoltage { get; set; }
        public double BatteryVoltage { get; set; }

        #endregion

        [XmlIgnore]
        public IDASCommunication OwningDAS { get; set; }


        /// <summary>
        /// Count how many channels are configured in this Module.
        /// See <see cref="AnalogInputDASChannel.IsConfigured" />.
        /// </summary>
        /// <returns>Number of configured channels</returns>
        public int NumberOfConfiguredChannels()
        {
            if (Channels == null || Channels.Length == 0)
                return 0;
            var configuredChannels = from ch in Channels.AsParallel() where ch.IsConfigured() select ch;
            if (configuredChannels.Count() > 0)
            {
                var channels = configuredChannels.ToArray();
            }
            return configuredChannels.Count();
        }
        /// <summary>
        /// Count how many TOM channels are configured in this module
        /// </summary>
        /// <returns>Number of configured TOM channels</returns>
        public int NumberOfConfiguredTOMChannels()
        {
            if (Channels == null || Channels.Length == 0)
            {
                return 0;
            }
            var configuredTOMChannels = from ch in Channels.AsParallel() where (ch.IsConfigured() && ch is OutputSquibChannel) select ch;
            return configuredTOMChannels.Count();
        }
        public bool IsDummyArmed()
        {
            int numConfiguredChannels = NumberOfConfiguredChannels();
            return numConfiguredChannels < 1;
        }
        /// <summary>
        /// Count how many channels this module has (regardless if they are configured 
        /// or not).
        /// </summary>
        /// <returns>Total number of channels</returns>
        public int NumberOfChannels()
        {
            if (Channels == null || Channels.Length == 0)
                return 0;
            return Channels.Length;
        }

        /// <summary>
        /// Retrieve the serial number from DASInfo
        /// </summary>
        /// <returns>The serial number of this module</returns>
        public string SerialNumber()
        {
            if (OwningDAS == null)
            {
                throw new NullReferenceException("DASModule: Trying to get serialnumber but OwningDAS is null");
            }
            if (OwningDAS.DASInfo == null)
            {
                throw new NullReferenceException("DASModule: Trying to get serialnumber but OwningDAS.DASInfo is null");
            }
            if (OwningDAS.DASInfo.Modules == null)
            {
                throw new NullReferenceException("DASModule: Trying to get serialnumber but OwningDAS.DASInfo.Modules is null");
            }

            for (int i = 0; i < OwningDAS.DASInfo.Modules.Length; i++)
            {
                if (OwningDAS.DASInfo.Modules[i]?.ModuleArrayIndex == ModuleArrayIndex)
                {
                    var sn = OwningDAS.DASInfo.Modules[i].SerialNumber;
                    if (string.IsNullOrEmpty(sn))
                    {
                        throw new NullReferenceException("DASModule: Trying to get serialnumber but it's null or empty");
                    }
                    else { return sn; }
                }
            }
            throw new NullReferenceException("DASModule: Trying to get serialnumber but ModuleArrayIndex is invalid");
        }

        /// <summary>
        /// Retrieve the module type from DASInfo
        /// </summary>
        /// <returns>The type of this module</returns>
        public DFConstantsAndEnums.ModuleType ModuleType()
        {
            if (OwningDAS == null)
            {
                throw new NullReferenceException("DASModule: Trying to get module type but OwningDAS is null");
            }
            if (OwningDAS.DASInfo == null)
            {
                throw new NullReferenceException("DASModule: Trying to get module type but OwningDAS.DASInfo is null");
            }
            if (OwningDAS.DASInfo.Modules == null)
            {
                throw new NullReferenceException("DASModule: Trying to get module type but OwningDAS.DASInfo.Modules is null");
            }

            foreach (InfoResult.Module module in OwningDAS.DASInfo.Modules)
            {
                if (module.ModuleArrayIndex != ModuleArrayIndex) continue;
                var dasType = module.TypeOfModule;
                return dasType;
            }
            throw new NullReferenceException("DASModule: Trying to get module type but ModuleArrayIndex is invalid");
        }

        /// <summary>
        /// Retrieve the module type from DASInfo and return whether or not it's a clock type
        /// </summary>
        /// <returns>Whether the type of this module is a clock</returns>
        public bool IsClock()
        {
            DFConstantsAndEnums.ModuleType moduleType = ModuleType();
            return moduleType == DFConstantsAndEnums.ModuleType.EmbeddedClockNanosAndPad ||
                   moduleType == DFConstantsAndEnums.ModuleType.EmbeddedClockSecondsAndMarker;
        }

        /// <summary>
        /// Retrieve the module type from DASInfo and return whether or not it's a uart type
        /// </summary>
        /// <returns>Whether the type of this module is a uart</returns>
        public bool IsUart()
        {
            DFConstantsAndEnums.ModuleType moduleType = ModuleType();
            return moduleType == DFConstantsAndEnums.ModuleType.UART;
        }

        /// <summary>
        /// Retrieve the module type from DASInfo and return whether or not it's a stream output type
        /// </summary>
        /// <returns>Whether the type of this module is a stream output</returns>
        public bool IsStreamOut()
        {
            DFConstantsAndEnums.ModuleType moduleType = ModuleType();
            return moduleType == DFConstantsAndEnums.ModuleType.StreamOut;
        }

        /// <summary>
        /// Retrieve the module type from DASInfo and return whether or not it's a stream input type
        /// </summary>
        /// <returns>Whether the type of this module is a stream output</returns>
        public bool IsStreamIn()
        {
            DFConstantsAndEnums.ModuleType moduleType = ModuleType();
            return moduleType == DFConstantsAndEnums.ModuleType.StreamIn;
        }

        /// <summary>
        /// Retrieve the module type from DASInfo and return whether or not it's an embedded type
        /// </summary>
        /// <returns>Whether the type of this module is embedded</returns>
        public bool IsEmbedded()
        {
            DFConstantsAndEnums.ModuleType moduleType = ModuleType();
            return moduleType == DFConstantsAndEnums.ModuleType.EmbeddedLinearAccelLowG ||
                   moduleType == DFConstantsAndEnums.ModuleType.EmbeddedLinearAccelHighG ||
                   moduleType == DFConstantsAndEnums.ModuleType.EmbeddedAngularRate ||
                   moduleType == DFConstantsAndEnums.ModuleType.EmbeddedAngularAccel ||
                   moduleType == DFConstantsAndEnums.ModuleType.EmbeddedAtmospheric ||
                   moduleType == DFConstantsAndEnums.ModuleType.EmbeddedMagnetInput ||
                   moduleType == DFConstantsAndEnums.ModuleType.EmbeddedMagnetometer ||
                   moduleType == DFConstantsAndEnums.ModuleType.EmbeddedMicrophone ||
                   moduleType == DFConstantsAndEnums.ModuleType.EmbeddedOptical ||
                   moduleType == DFConstantsAndEnums.ModuleType.EmbeddedClockNanosAndPad ||
                   moduleType == DFConstantsAndEnums.ModuleType.EmbeddedClockSecondsAndMarker;
        }
        public bool IsThermocoupler()
        {
            DFConstantsAndEnums.ModuleType moduleType = ModuleType();
            return moduleType == DFConstantsAndEnums.ModuleType.Thermocoupler;
        }
        /// <summary>
        /// Constructor for a DASModule that initializes the object with a 
        /// ModuleArrayIndex and a parent DAS as an IDASCommunication.
        /// </summary>
        /// <param name="moduleArrayIdx"></param>
        /// <param name="_OwningDAS"></param>
        public DASModule(int moduleArrayIdx, IDASCommunication _OwningDAS)
        {
            Channels = null;
            IDs = null;
            ModuleArrayIndex = moduleArrayIdx;
            PreTriggerSeconds = 0;
            PostTriggerSeconds = 0;
            NumberOfSamples = 0;
            TriggerSampleNumbers = null;

            StartRecordSampleNumber = 0;
            SampleRateHz = 10000;
            AAFilterRateHz = 0;
            RecordingMode = DFConstantsAndEnums.RecordingMode.RecorderMode;
            OwningDAS = _OwningDAS;
        }

        /// <summary>
        /// Default constructor for serialization methods compliance.
        /// </summary>
        public DASModule()
        {
        }
        public virtual void WriteXmlCRC32(XmlWriter writer)
        {
            writer.WriteStartElement("DASModule");

            // Channels
            writer.WriteStartElement("Channels");
            if (Channels != null)
            {
                foreach (var channel in Channels)
                {
                    channel.WriteElementStart(writer);
                    channel.WriteXmlCRC32(writer);
                    channel.WriteElementEnd(writer);
                }
            }
            writer.WriteEndElement();

            // ModuleArrayIndex
            XMLHelper.PutInt(writer, "ModuleArrayIndex", ModuleArrayIndex);

            // PreTriggerSeconds
            //XMLHelper.PutDouble(writer, "PreTriggerSeconds", PreTriggerSeconds);

            // PostTriggerSeconds
            //XMLHelper.PutDouble(writer, "PostTriggerSeconds", PostTriggerSeconds);

            // NumberOfSamples
            //XMLHelper.PutUInt64(writer, "NumberOfSamples", NumberOfSamples);

            // StartRecordSampleNumber
            //XMLHelper.PutUInt64(writer, "StartRecordSampleNumber", StartRecordSampleNumber);

            // SampleRateHz
            //XMLHelper.PutUInt(writer, "SampleRateHz", SampleRateHz);

            // AAFilterRateHz, we write this one as a double
            //XMLHelper.PutDouble(writer, AAFilterRateHzTag, (double)AAFilterRateHz);

            // RecordingMode
            //XMLHelper.PutString(writer, "RecordingMode", RecordingMode.ToString());

            writer.WriteEndElement();
        }
        public virtual void WriteXml(XmlWriter writer)
        {
            writer.WriteStartElement("DASModule");

            // Channels
            writer.WriteStartElement("Channels");
            if (Channels != null)
            {
                foreach (var channel in Channels)
                {
                    channel.WriteElementStart(writer);
                    channel.WriteXml(writer);
                    channel.WriteElementEnd(writer);
                }
            }
            writer.WriteEndElement();

            // ModuleArrayIndex
            XMLHelper.PutInt(writer, "ModuleArrayIndex", ModuleArrayIndex);

            // PreTriggerSeconds
            XMLHelper.PutDouble(writer, "PreTriggerSeconds", PreTriggerSeconds);

            // PostTriggerSeconds
            XMLHelper.PutDouble(writer, "PostTriggerSeconds", PostTriggerSeconds);

            // NumberOfSamples
            XMLHelper.PutUInt64(writer, "NumberOfSamples", NumberOfSamples);

            // StartRecordSampleNumber
            XMLHelper.PutUInt64(writer, "StartRecordSampleNumber", StartRecordSampleNumber);

            // SampleRateHz
            XMLHelper.PutUInt(writer, "SampleRateHz", SampleRateHz);

            // AAFilterRateHz, we write this one as a double
            XMLHelper.PutDouble(writer, AAFilterRateHzTag, AAFilterRateHz);

            // RecordingMode
            XMLHelper.PutString(writer, "RecordingMode", RecordingMode.ToString());

            // ScheduledStartTime
            XMLHelper.PutString(writer, "ScheduledStartTime", ScheduledStartTime.ToString(System.Globalization.CultureInfo.InvariantCulture));

            // RecordingInterval
            XMLHelper.PutString(writer, "RecordingInterval", RecordingInterval.ToString());

            // Slice 6 Tilt variables
            XMLHelper.PutString(writer, "TiltAxes", TiltAxes.ToString());
            XMLHelper.PutString(writer, "SystemID", SystemID);
            XMLHelper.PutString(writer, "SystemLocation", SystemLocation);
            XMLHelper.PutDouble(writer, "TargetAxisOne", TargetAxisOne);
            XMLHelper.PutDouble(writer, "TargetAxisTwo", TargetAxisTwo);
            XMLHelper.PutDouble(writer, "MountOffsetAxisOne", MountOffsetAxisOne);
            XMLHelper.PutDouble(writer, "MountOffsetAxisTwo", MountOffsetAxisTwo);
            XMLHelper.PutDouble(writer, "LevelTolerance", LevelTolerance);
            XMLHelper.PutInt(writer, "AxisIgnored", AxisIgnored);
            XMLHelper.PutBool(writer, "UseForTiltCalculation", UseForTiltCalculation);
            XMLHelper.PutDouble(writer, "InputVoltage", InputVoltage);
            XMLHelper.PutDouble(writer, "BatteryVoltage", BatteryVoltage);

            // FB 26980 Write NumberOfEvents to XML
            XMLHelper.PutInt(writer, "NumberOfEvents", NumberOfEvents);
            XMLHelper.PutInt(writer, "WakeUpMotionTimeout", WakeUpMotionTimeout);

            writer.WriteEndElement();
        }
        private void ReadChannels(XmlReader reader)
        {
            var myChannels = new List<DASChannel>();
            do
            {
                if (reader.NodeType == XmlNodeType.Element && reader.Name == "DASChannel")
                {
                    var chanType = "DTS.DASLib.Service." + reader.GetAttribute("xsi:type");
                    var channelClassType = Type.GetType(chanType);
                    var deserializedChannel = Activator.CreateInstance(channelClassType) as DASChannel;
                    deserializedChannel.ReadXml(reader);
                    myChannels.Add(deserializedChannel);
                }
                //if we are at </channels> break out now, don't want to do a  read()
                if (reader.Name == "Channels" && (reader.NodeType == XmlNodeType.EndElement || reader.IsEmptyElement))
                {
                    break;
                }
                //if we are at <DASChannel> we don't want to do a read, otherwise we do
                if (!(reader.NodeType == XmlNodeType.Element && reader.Name == "DASChannel"))
                {
                    if (!reader.Read()) { break; }
                }

            } while (!(reader.Name == "Channels" && reader.NodeType == XmlNodeType.EndElement));

            Channels = myChannels.ToArray();
        }
        private const string CHANNELS_TAG = "Channels";
        private const string MODULEARRAYINDEX_TAG = "ModuleArrayIndex";
        private const string PRETRIGGERSECONDS_TAG = "PreTriggerSeconds";
        private const string POSTTRIGGERSECONDS_TAG = "PostTriggerSeconds";
        private const string NUMBEROFSECONDS_TAG = "NumberOfSamples";
        private const string TRIGGERSAMPLENUMBERS_TAG = "TriggerSampleNumbers";
        private const string STARTRECORDSAMPLENUMBER_TAG = "StartRecordSampleNumber";
        private const string SAMPLERATEHZ_TAG = "SampleRateHz";
        private const string AAFILTERRATEHZ_TAG = "AAFilterRateHz";
        private const string RECORDINGMODE_TAG = "RecordingMode";
        private const string SCHEDULEDSTARTTIME_TAG = "ScheduledStartTime";
        private const string RECORDINGINTERVAL_TAG = "RecordingInterval";
        private const string TILT_AXES_TAG = "TiltAxes";
        private const string SYSTEMID_TAG = "SystemID";
        private const string SYSTEMLOCATION_TAG = "SystemLocation";
        private const string MOUNTOFFSETAXISONE_TAG = "MountOffsetAxisOne";
        private const string MOUNTOFFSETAXISTWO_TAG = "MountOffsetAxisTwo";
        private const string TARGETAXISONE_TAG = "TargetAxisOne";
        private const string TARGETAXISTWO_TAG = "TargetAxisTwo";
        private const string LEVELTOLERANCE_TAG = "LevelTolerance";
        private const string AXISIGNORED_TAG = "AxisIgnored";
        private const string USEFORTILTCALCULATION_TAG = "UseForTiltCalculation";
        private const string INPUTVOLTAGE_TAG = "InputVoltage";
        private const string BATTERYVOLTAGE_TAG = "BatteryVoltage";
        private const string NUMBEROFEVENTS_TAG = "NumberOfEvents";
        private const string WAKEUPTIMEOUT_TAG = "WakeUpTimeout";

        protected virtual void HandleElement(XmlReader reader)
        {
            switch (reader.Name)
            {
                case CHANNELS_TAG:
                    ReadChannels(reader);
                    break;
                case MODULEARRAYINDEX_TAG:
                    ModuleArrayIndex = XMLHelper.GetInt(reader);
                    break;
                case PRETRIGGERSECONDS_TAG:
                    PreTriggerSeconds = XMLHelper.GetDouble(reader);
                    break;
                case POSTTRIGGERSECONDS_TAG:
                    PostTriggerSeconds = XMLHelper.GetDouble(reader);
                    break;
                case NUMBEROFSECONDS_TAG:
                    NumberOfSamples = XMLHelper.GetUInt64(reader);
                    break;
                case TRIGGERSAMPLENUMBERS_TAG: // UInt64[]
                    throw new XmlException("DASModule.ReadXml: Unexpected TriggerSampleNumbers tag in data");
                case STARTRECORDSAMPLENUMBER_TAG:
                    StartRecordSampleNumber = XMLHelper.GetUInt64(reader);
                    break;
                case SAMPLERATEHZ_TAG:
                    SampleRateHz = XMLHelper.GetUInt(reader);
                    break;
                case AAFilterRateHzTag:
                    AAFilterRateHz = XMLHelper.GetFloat(reader);
                    break;
                case RECORDINGMODE_TAG:
                    var value = XMLHelper.GetString(reader);
                    if (!Enum.TryParse(value, out DFConstantsAndEnums.RecordingMode mode))
                    {
                        if (value.Equals("ActiveMode"))
                        {
                            RecordingMode = DFConstantsAndEnums.RecordingMode.Aerospace;
                        }
                    }
                    else { RecordingMode = mode; }
                    break;
                case SCHEDULEDSTARTTIME_TAG:
                    var scheduledStartTime = XMLHelper.GetString(reader);
                    ScheduledStartTime = DateTime.Parse(scheduledStartTime, System.Globalization.CultureInfo.InvariantCulture);
                    break;
                case RECORDINGINTERVAL_TAG:
                    RecordingInterval = XMLHelper.GetInt(reader);
                    break;
                case TILT_AXES_TAG:
                    var ta = XMLHelper.GetString(reader);
                    TiltAxes = (DFConstantsAndEnums.TiltAxes)Enum.Parse(typeof(DFConstantsAndEnums.TiltAxes), ta);
                    break;
                case SYSTEMID_TAG:
                    SystemID = XMLHelper.GetString(reader);
                    break;
                case SYSTEMLOCATION_TAG:
                    SystemLocation = XMLHelper.GetString(reader);
                    break;
                case MOUNTOFFSETAXISONE_TAG:
                    MountOffsetAxisOne = XMLHelper.GetDouble(reader);
                    break;
                case MOUNTOFFSETAXISTWO_TAG:
                    MountOffsetAxisTwo = XMLHelper.GetDouble(reader);
                    break;
                case TARGETAXISONE_TAG:
                    TargetAxisOne = XMLHelper.GetDouble(reader);
                    break;
                case TARGETAXISTWO_TAG:
                    TargetAxisTwo = XMLHelper.GetDouble(reader);
                    break;
                case LEVELTOLERANCE_TAG:
                    LevelTolerance = XMLHelper.GetDouble(reader);
                    break;
                case AXISIGNORED_TAG:
                    AxisIgnored = XMLHelper.GetInt(reader);
                    break;
                case USEFORTILTCALCULATION_TAG:
                    UseForTiltCalculation = XMLHelper.GetBool(reader);
                    break;
                case INPUTVOLTAGE_TAG:
                    InputVoltage = XMLHelper.GetDouble(reader);
                    break;
                case BATTERYVOLTAGE_TAG:
                    BatteryVoltage = XMLHelper.GetDouble(reader);
                    break;
                //FB 26980 
                case NUMBEROFEVENTS_TAG:
                    NumberOfEvents = XMLHelper.GetInt(reader);
                    break;
                case WAKEUPTIMEOUT_TAG:
                    WakeUpMotionTimeout = XMLHelper.GetInt(reader);
                    break;
                default:
                    // let child handle it
                    break;
            }
        }
        public virtual void ReadXml(XmlReader reader)
        {
            // it must be an Element
            if (reader.NodeType != XmlNodeType.Element)
            {
                throw new XmlException("DASModule.ReadXml: Unknown input: " + reader.NodeType.ToString());
            }

            // remove our start tag
            if (reader.Name == "DASModule")
            {
                reader.Read();
            }

            do
            {
                if (reader.NodeType != XmlNodeType.EndElement)
                {
                    HandleElement(reader);
                }
                if (!reader.Read()) { break; }
            } while (!(reader.Name.Equals("DASModule") && reader.NodeType == XmlNodeType.EndElement));


            // we're going to end with an EndElement, so clean up
            if (reader.NodeType == XmlNodeType.EndElement && reader.Name.Equals("DASModule"))
            {
                reader.Read();
            }
        }

        public XmlSchema GetSchema()
        {
            return null;
        }

        public virtual ushort GetCRC32()
        {
            var sb = new StringBuilder();

            using (var writer = XmlWriter.Create(sb))
            {
                WriteXmlCRC32(writer);
                writer.Flush();
            }

            var lData = new List<byte>(Encoding.UTF8.GetBytes(sb.ToString()));

            if (0 != lData.Count % 2) { lData.Add(0x00); }
            byte[] data = lData.ToArray();

            ushort crc = 0xFFFF;
            for (int i = 0; i < data.Length; i += 2)
            {
                crc = Utils.Math_DoCRC16Step(BitConverter.ToUInt16(data, i), crc);
            }
            return crc;
        }

    }
}