using DTS.Common.Enums.DASFactory;
using System;
using System.Xml;
using System.Xml.Schema;
using DTS.Common.Enums;

namespace DTS.Common.Interface.DASFactory.Config
{
    public interface IDASModule
    {
        /// <summary>
        /// An array of <see cref="DASChannel" /> objects representing the channels attatched to this
        /// module, indexable by ModuleChannelNumber of the Channel.
        /// </summary>
        IDASChannel[] Channels { get; set; }

        /// <summary>
        /// EID's for the module corresponding to the sensors on each of the channels.
        /// </summary>
        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>
        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>
        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>
        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>
        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>
        double PostTriggerSeconds { get; set; }

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

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

        /// <summary>
        /// The version of the firmware on a module.
        /// </summary>
        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>
        string Description { get; set; }

        /// <summary>
        /// The maximum storage space for a module.
        /// </summary>
        ulong? 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>
        ulong NumberOfSamples { get; set; }

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

        int GetLevelTriggerT0AdjustmentSamplesAutoApplied();

        /// <summary>
        /// The sample number where recording started.
        /// </summary>
        ulong StartRecordSampleNumber { get; set; }

        /// <summary>
        /// 
        /// </summary>
        uint StartRecordTimestampSec { get; set; }

        /// <summary>
        /// 
        /// </summary>
        uint TriggerTimestampSec { get; set; }

        /// <summary>
        /// 
        /// </summary>
        uint StartRecordTimestampNanoSec { get; set; }

        /// <summary>
        /// 
        /// </summary>
        uint TriggerTimestampNanoSec { get; set; }

        /// <summary>
        /// 
        /// </summary>
        bool PTPMasterSync { get; set; }

        /// <summary>
        /// 
        /// </summary>
        double TiltSensorAxisXDegreesPre { get; set; }

        /// <summary>
        /// 
        /// </summary>
        double TiltSensorAxisYDegreesPre { get; set; }

        /// <summary>
        /// 
        /// </summary>
        double TiltSensorAxisZDegreesPre { get; set; }

        /// <summary>
        /// 
        /// </summary>
        double TiltSensorAxisXDegreesPost { get; set; }

        /// <summary>
        /// 
        /// </summary>
        double TiltSensorAxisYDegreesPost { get; set; }
        /// <summary>
        /// 
        /// </summary>
        double TiltSensorAxisZDegreesPost { get; set; }
        float TemperatureLocation1Pre { get; set; }
        float TemperatureLocation2Pre { get; set; }
        float TemperatureLocation3Pre { get; set; }
        float TemperatureLocation4Pre { get; set; }
        float TemperatureLocation1Post { get; set; }
        float TemperatureLocation2Post { get; set; }
        float TemperatureLocation3Post { get; set; }
        float TemperatureLocation4Post { get; set; }

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

        /// <summary>
        /// FB 25558 Actual sample rate currently is used in realtime for TSR AIR type only in future it might be used for other hardware types
        /// </summary>
        uint ActualSampleRateHz { get; set; }

        /// <summary>
        /// Hardware anti-alias filter rate.
        /// </summary>
        float AAFilterRateHz { get; set; }

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

        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>
        DFConstantsAndEnums.TiltAxes TiltAxes { get; set; }

        double TargetAxisOne { get; set; }

        double TargetAxisTwo { get; set; }

        /// <summary>
        /// The target angle threshold in degrees for Axis 1
        /// </summary>
        float TargetAngleAxisX { get; set; }
        /// <summary>
        /// The target angle threshold in degrees for Axis 2
        /// </summary>
        float TargetAngleAxisY { get; set; }
        /// <summary>
        /// The target angle threshold in degrees for Axis 3
        /// </summary>
        float TargetAngleAxisZ { get; set; }

        double MountOffsetAxisOne { get; set; }

        double MountOffsetAxisTwo { get; set; }

        string SystemLocation { get; set; }

        string SystemID { get; set; }

        int AxisIgnored { get; set; }

        double LevelTolerance { get; set; }

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

        /// <summary>
        /// The external tilt enumeration given by the attached DAS
        /// </summary>
        byte TiltID { get; set; }
        /// <summary>
        /// The serial number of the external tilt
        /// </summary>
        string TiltSerialNumber { get; set; }
        #endregion

        //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>
        int NumberOfConfiguredChannels();

        /// <summary>
        /// Count how many TOM channels are configured in this module
        /// </summary>
        /// <returns>Number of configured TOM channels</returns>
        int NumberOfConfiguredTOMChannels();

        bool IsDummyArmed();

        /// <summary>
        /// Count how many channels this module has (regardless if they are configured 
        /// or not).
        /// </summary>
        /// <returns>Total number of channels</returns>
        int NumberOfChannels();

        /// <summary>
        /// Retrieve the serial number from DASInfo
        /// </summary>
        /// <returns>The serial number of this module</returns>
        string SerialNumber();

        /// <summary>
        /// Retrieve the module type from DASInfo
        /// </summary>
        /// <returns>The type of this module</returns>
        DFConstantsAndEnums.ModuleType ModuleType();
        /// <summary>
        /// Retrieve the module type from DASInfo and return whether or not it's a stream in type
        /// </summary>
        /// <returns>Whether the type of this module is a stream in</returns>
        bool IsStreamIn();
        /// <summary>
        /// Retrieve the module type from DASInfo and return whether or not it's a stream out type
        /// </summary>
        /// <returns>Whether the type of this module is a stream out</returns>
        bool IsStreamOut();
        /// <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>
        bool IsUart();
        /// <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>
        bool IsClock();
        /// <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>
        bool IsEmbedded();
        void WriteXmlCRC32(XmlWriter writer);
        void WriteXml(XmlWriter writer);
        void ReadXml(XmlReader reader);
        XmlSchema GetSchema();

        ushort GetCRC32();
    }
}