using System;
using System.Xml;
using System.Xml.Schema;
using System.Xml.Serialization;
using DTS.Common.DAS.Concepts;
using DTS.Common.Enums.DASFactory;
using DTS.Common.Enums.Sensors;
using DTS.Common.Interface.DASFactory.Config;

namespace DTS.DASLib.Service
{
    /// <inheritdoc />
    /// <summary>
    /// Base class for all DAS channels.
    /// </summary>
    [Serializable]
    public class DASChannel : IDASChannel, IXmlSerializable // (subset of sensor class)
    {
        public DFConstantsAndEnums.ConfigMode ConfigurationMode { get; set; }

        /// <summary>
        /// whether the channel should be put in Diagnostics mode or not
        /// </summary>
        public bool DiagnosticsMode { get; set; }

        /// <summary>
        /// Channel number with respect to it's containing module <see cref="OwningModule"/>
        /// </summary>
        public int ModuleChannelNumber { get; set; }

        public int AbsoluteDisplayOrder { get; set; } = 1;

        public double UnitConverision { get; set; } = 1D;

        public bool AtCapacity { get; set; } = false;

        public double CapacityOutputIsBasedOn { get; set; } = 1D;

        public SensorConstants.SensUnits SensitivityUnits { get; set; } =
           SensorConstants.SensUnits.NONE;

        /// <summary>
        /// A link back to the Module that contains this channel.
        /// </summary>
        [XmlIgnore]
        public DASModule OwningModule { get; set; }

        /// <summary>
        /// The "stack channel number" of this channel with respect to the owning 
        /// DAS (0 based).
        /// </summary>
        public byte Number
        {
            get
            {
                try
                {
                    return OwningModule.OwningDAS.DASInfo.MapModuleArrayIndexAndChannelNum2DASChannel(OwningModule.ModuleArrayIndex, ModuleChannelNumber);
                }
                catch (Exception ex)
                {
                    throw new ApplicationException("encountered problem getting " + GetType().FullName + ".Number property value", ex);
                }
            }
        }

        /// <summary>
        /// Array of (string, byte[]) for EID
        /// </summary>
        [XmlIgnore]
        public IEID[] IDs { get; set; }

        /// <summary>
        /// time stamp of this event
        /// </summary>
        public DateTime EventStartTime { get; set; }

        /// <summary>
        /// <see cref="bool"/> value indicating whether or not this channel has registered a level trigger.
        /// </summary>
        public bool LevelTriggerSeen { get; set; }

        public string IsoChannelName { get; set; }
        public string ChannelGroupName { get; set; }
        public string UserCode { get; set; }
        public string UserChannelName { get; set; }
        public string LinearSensorCalibration { get; set; }
        /// <summary>
        /// the number of samples to qualify over
        /// </summary>
        public int QualificationSamples { get; set; }

        ///// <summary>
        ///// Number of samples that T0 on DASes that did not directly experience the level trigger must be shifted
        ///// to time align with this channel's directly level triggered T0.  A null value indicates that this channel
        ///// did not directly receive a level trigger.
        ///// </summary>
        public int? LevelTriggerT0AdjustmentSamples { get; set; }

        public override string ToString()
        {
            return ModuleChannelNumber.ToString();
        }

        /// <summary>
        /// Is this channel configured? 'Configured' means a sensor is connected and/or there is 
        /// information in the containg device's ConfigData object, put there with a call to
        /// ConfigureService.Configure(...) in the API.
        /// </summary>
        /// <returns>True if it is configured, False otherwise.</returns>
        public virtual bool IsConfigured()
        {
            return false;
        }

        /// <summary>
        /// CTOR to populate a channel's owning module and channel WRT that module.
        /// </summary>
        /// <param name="owner">Module that contains this channel.</param>
        /// <param name="channelNumber">ChannelNumber of this channel WRT owning module.</param>
        public DASChannel(DASModule owner, int channelNumber)
        {
            ConfigurationMode = DFConstantsAndEnums.ConfigMode.Normal;
            ModuleChannelNumber = channelNumber;
            OwningModule = owner;
            IDs = null;
            EventStartTime = DateTime.Now;
            DiagnosticsMode = false;
        }

        public DASChannel()
        {
        }

        public virtual void WriteElementStart(XmlWriter writer)
        {
            writer.WriteStartElement("DASChannel");
            //writer.WriteStartAttribute("type", "xsi");
            var tgt = GetType();
            writer.WriteAttributeString("xsi", "type", null, tgt.Name);
        }

        public virtual void WriteElementEnd(XmlWriter writer)
        {
            writer.WriteEndElement();
        }
        public virtual void WriteXmlCRC32(XmlWriter writer)
        {
            // ConfigurationMode
            XMLHelper.PutString(writer, "ConfigurationMode", ConfigurationMode.ToString());

            // ModuleChannelNumber
            XMLHelper.PutInt(writer, "ModuleChannelNumber", ModuleChannelNumber);
            XMLHelper.PutInt(writer, "AbsoluteDisplayOrder", AbsoluteDisplayOrder);
            XMLHelper.PutBool(writer, "DiagnosticsMode", DiagnosticsMode);
            XMLHelper.PutDouble(writer, "UnitConversion", UnitConverision);
            // EventStartTime
            //XMLHelper.PutString(writer, "EventStartTime", EventStartTime.ToString("o", XMLHelper.InvariantCulture));
        }
        public virtual void WriteXml(XmlWriter writer)
        {
            // ConfigurationMode
            XMLHelper.PutString(writer, "ConfigurationMode", ConfigurationMode.ToString());

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

            XMLHelper.PutInt(writer, "AbsoluteDisplayOrder", AbsoluteDisplayOrder);
            // EventStartTime
            XMLHelper.PutString(writer, "EventStartTime", EventStartTime.ToString("o", XMLHelper.InvariantCulture));

            //XMLHelper.PutString(writer, "QualificationSamples", QualificationSamples.ToString());
            XMLHelper.PutInt(writer, "QualificationSamples", QualificationSamples);

            XMLHelper.PutBool(writer, "DiagnosticsMode", DiagnosticsMode);

            XMLHelper.PutDouble(writer, "UnitConversion", UnitConverision);

            XMLHelper.PutBool(writer, "AtCapacity", AtCapacity);

            XMLHelper.PutDouble(writer, "CapacityOutputIsBasedOn", CapacityOutputIsBasedOn);

            XMLHelper.PutString(writer, "SensitivityUnits", SensitivityUnits.ToString());

            XMLHelper.PutString(writer, "IsoChannelName", IsoChannelName);
            XMLHelper.PutString(writer, "UserCode", UserCode);
            XMLHelper.PutString(writer, "UserChannelName", UserChannelName);
            XMLHelper.PutString(writer, "LinearSensorCalibration", LinearSensorCalibration);
            if (!string.IsNullOrEmpty(UserValue1))
            {
                XMLHelper.PutString(writer, "UserValue1", UserValue1);
            }

            if (!string.IsNullOrEmpty(UserValue2))
            {
                XMLHelper.PutString(writer, "UserValue2", UserValue2);
            }

            if (!string.IsNullOrEmpty(UserValue3))
            {
                XMLHelper.PutString(writer, "UserValue3", UserValue3);
            }

            /*XMLHelper.PutInt(writer, "IdType", IdType);*/
        }
        private const string CONFIGUARATIONMODE_TAG = "ConfigurationMode";
        private const string MODULECHANNELNUMBER_TAG = "ModuleChannelNumber";
        private const string EVENTSTARTTIME_TAG = "EventStartTime";
        private const string QUALIFICATIONSAMPLES_TAG = "QualificationSamples";
        private const string DIAGNOSTICSMODE_TAG = "DiagnosticsMode";
        private const string ABSOLUTEDISPLAYORDER_TAG = "AbsoluteDisplayOrder";
        private const string UNITCONVERSION_TAG = "UnitConversion";
        private const string ATCAPACITY_TAG = "AtCapacity";
        private const string LINEARSENSORCALIBRATION_TAG = "LinearSensorCalibration";
        private const string USERCHANNELNAME_TAG = "UserChannelName";
        private const string USERCODE_TAG = "UserCode";
        private const string ISOCHANNELNAME_TAG = "IsoChannelName";
        private const string CAPACITYOUTPUTISBASEDON_TAG = "CapacityOutputIsBasedOn";
        private const string SENSITIVITYUNITS_TAG = "SensitivityUnits";
        private const string USERVALUE1_TAG = "UserValue1";
        private const string USERVALUE2_TAG = "UserValue2";
        private const string USERVALUE3_TAG = "UserValue3";
        protected virtual void HandleElement(XmlReader reader)
        {
            switch (reader.Name)
            {
                case CONFIGUARATIONMODE_TAG:
                    var confMode = XMLHelper.GetString(reader);
                    ConfigurationMode = (DFConstantsAndEnums.ConfigMode)Enum.Parse(typeof(DFConstantsAndEnums.ConfigMode), confMode);
                    break;
                case MODULECHANNELNUMBER_TAG:
                    ModuleChannelNumber = XMLHelper.GetInt(reader);
                    break;
                case EVENTSTARTTIME_TAG:
                    var est = XMLHelper.GetString(reader);
                    EventStartTime = DateTime.Parse(est);
                    break;
                case QUALIFICATIONSAMPLES_TAG:
                    QualificationSamples = XMLHelper.GetInt(reader);
                    break;
                case DIAGNOSTICSMODE_TAG:
                    DiagnosticsMode = XMLHelper.GetBool(reader);
                    break;
                case ABSOLUTEDISPLAYORDER_TAG:
                    try { AbsoluteDisplayOrder = XMLHelper.GetInt(reader); }
                    catch (Exception) { }
                    break;
                case UNITCONVERSION_TAG:
                    try { UnitConverision = XMLHelper.GetDouble(reader); }
                    catch (Exception) { }
                    break;
                case ATCAPACITY_TAG:
                    try { AtCapacity = XMLHelper.GetBool(reader); }
                    catch (Exception) { }
                    break;
                case LINEARSENSORCALIBRATION_TAG:
                    LinearSensorCalibration = XMLHelper.GetString(reader);
                    break;
                case USERCHANNELNAME_TAG:
                    UserChannelName = XMLHelper.GetString(reader);
                    break;
                case USERCODE_TAG:
                    UserCode = XMLHelper.GetString(reader);
                    break;
                case ISOCHANNELNAME_TAG:
                    IsoChannelName = XMLHelper.GetString(reader);
                    break;
                case CAPACITYOUTPUTISBASEDON_TAG:
                    try { CapacityOutputIsBasedOn = XMLHelper.GetDouble(reader); }
                    catch (Exception) { }
                    break;
                case SENSITIVITYUNITS_TAG:
                    var su = XMLHelper.GetString(reader);
                    SensitivityUnits = (SensorConstants.SensUnits)Enum.Parse(typeof(SensorConstants.SensUnits), su);
                    break;
                case USERVALUE1_TAG:
                    try { UserValue1 = XMLHelper.GetString(reader); }
                    catch (Exception) { }
                    break;
                case USERVALUE2_TAG:
                    try { UserValue2 = XMLHelper.GetString(reader); }
                    catch (Exception) { }
                    break;
                case USERVALUE3_TAG:
                    try { UserValue3 = XMLHelper.GetString(reader); }
                    catch (Exception) { }
                    break;

                default:
                    // let child handle it
                    return;
            }
        }
        public virtual void ReadXml(XmlReader reader)
        {
            // it must be an Element
            if (reader.NodeType != XmlNodeType.Element)
            {
                throw new XmlException("DASChannel.ReadXml: Unknown input: " + reader.NodeType.ToString());
            }

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

            // try to find our data
            do
            {
                if (reader.NodeType == XmlNodeType.Element)
                {
                    HandleElement(reader);
                }
                if (!reader.Read())
                {
                    break;
                }
            } while (!(reader.Name.Equals("DASChannel") && reader.NodeType == XmlNodeType.EndElement));

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

        /// <summary>
        /// returns true if the channel is re-programable [can be switched from IEPE to analog]
        /// </summary>
        /// <returns></returns>
        public bool CanReProgram()
        {
            if (null == OwningModule) { return false; }
            if (null == OwningModule.OwningDAS) { return false; }
            if (null == OwningModule.OwningDAS.DASInfo) { return false; }
            if (null == OwningModule.OwningDAS.DASInfo.Modules) { return false; }
            if (0 == OwningModule.OwningDAS.DASInfo.Modules.Length)
            {
                return false;
            }
            return OwningModule.OwningDAS.DASInfo.Modules[0].IsProgrammable;
        }
        public XmlSchema GetSchema()
        {
            return null;
        }

        public const int DEFAULT_ID_TYPE = 0;
        public const int BRIDGE_ID_TYPE = 1;
        public const int IEPE_ID_TYPE = 2;
        public const int BRIDGE_G5_ID_TYPE = 3;

        public int IdType { get; set; } = DEFAULT_ID_TYPE;

        public string UserValue1 { get; set; } = "";
        public string UserValue2 { get; set; } = "";
        public string UserValue3 { get; set; } = "";

    }
}