using System;
using DTS.Common.Interface.Sensors;
using DTS.Common.Settings;

namespace DTS.SensorDB
{
    public class IEPESensorDefault : DTS.Common.Base.BasePropertyChanged, IIEPESensorDefaults
    {
        #region constants
        private const string _24V_POWERLOW_KEY = "_24VPowerLow";
        private const string _24V_POWERHIGH_KEY = "_24VPowerHigh";
        private const double _24VPOWER_LOW_DEFAULT = 23D;
        private const double _24VPOWER_HIGH_DEFAULT = 26.5D;

        private const string IEPE_RANGE_LOW_KEY = "IEPERangeLowLimitScalar";
        private const string IEPE_RANGE_HIGH_KEY = "IEPERangeHighLimitScalar";
        private const double IEPE_RANGE_HIGH_LIMIT = 100D;
        private const double IEPE_RANGE_LOW_LIMIT = 1D;

        private const string DISABLE_AUTOSENSE_KEY = "DisableAutoSense";
        private const bool DISABLE_AUTOSENSE_DEFAULT = false;
        #endregion constants

        #region properties
        private bool _disableAutoSense;
        /// <summary>
        /// whether AutoSense is allowed or not
        /// 14634 Implement enable/disable of the "SLICE PRO Auto-sense" feature
        /// </summary>
        public bool DisableAutoSense
        {
            get => _disableAutoSense;
            set
            {
                SetProperty(ref _disableAutoSense, value, "DisableAutoSense");
                OnPropertyChanged("DisableAutoSense");
            }
        }
        private double __24VPowerLow;
        public double _24VPowerLow
        {
            get => __24VPowerLow;
            set
            {
                SetProperty(ref __24VPowerLow, value, "_24VPowerLow");
                OnPropertyChanged("ToleranceValid");
            }
        }

        private double __24VPowerHigh;
        public double _24VPowerHigh
        {
            get => __24VPowerHigh;
            set
            {
                SetProperty(ref __24VPowerHigh, value, "_24VPowerHigh");
                OnPropertyChanged("ToleranceValid");
            }
        }

        private double _rangeLowLimitScalar;

        /// <summary>
        /// the actual range low acceptable value (scalar applied to desired range)
        /// </summary>
        public double RangeLowLimitScalar
        {
            get => _rangeLowLimitScalar;
            set
            {
                SetProperty(ref _rangeLowLimitScalar, value, "RangeLowLimitScalar");
                OnPropertyChanged("RangeToleranceValid");
            }
        }

        private double _rangeHighLimitScalar;

        /// <summary>
        /// the actual range high acceptable value (scalar applied to desired range)
        /// </summary>
        public double RangeHighLimitScalar
        {
            get => _rangeHighLimitScalar;
            set
            {
                SetProperty(ref _rangeHighLimitScalar, value, "RangeHighLimitScalar");
                OnPropertyChanged("RangeToleranceValid");
            }
        }

        public bool ToleranceValid => _24VPowerHigh > _24VPowerLow;

        public bool RangeToleranceValid => RangeLowLimitScalar < RangeHighLimitScalar;
        #endregion properties

        #region methods
        public bool Validate()
        {
            return ToleranceValid && RangeToleranceValid;
        }
        #region static methods
        public static IIEPESensorDefaults GetIEPESensorDefaults(string user)
        {
            var low = SettingsDB.GetGlobalValueDouble(_24V_POWERLOW_KEY, _24VPOWER_LOW_DEFAULT);
            var high = SettingsDB.GetGlobalValueDouble(_24V_POWERHIGH_KEY, _24VPOWER_HIGH_DEFAULT);
            var rangeLow = SettingsDB.GetGlobalValueDouble(IEPE_RANGE_LOW_KEY, IEPE_RANGE_LOW_LIMIT);
            var rangeHigh = SettingsDB.GetGlobalValueDouble(IEPE_RANGE_HIGH_KEY, IEPE_RANGE_HIGH_LIMIT);
            var disableAutoSense = SettingsDB.GetGlobalValueBool(DISABLE_AUTOSENSE_KEY, DISABLE_AUTOSENSE_DEFAULT);
            return new IEPESensorDefault()
            {
                _24VPowerHigh = high,
                _24VPowerLow = low,
                RangeHighLimitScalar = rangeHigh,
                RangeLowLimitScalar = rangeLow,
                DisableAutoSense = disableAutoSense
            };
        }

        public static void Save(IIEPESensorDefaults defaults)
        {
            SettingsDB.SetGlobalValueDouble(_24V_POWERLOW_KEY, defaults._24VPowerLow);
            SettingsDB.SetGlobalValueDouble(_24V_POWERHIGH_KEY, defaults._24VPowerHigh);
            SettingsDB.SetGlobalValueDouble(IEPE_RANGE_HIGH_KEY, defaults.RangeHighLimitScalar);
            SettingsDB.SetGlobalValueDouble(IEPE_RANGE_LOW_KEY, defaults.RangeLowLimitScalar);
            SettingsDB.SetGlobalValueBoolean(DISABLE_AUTOSENSE_KEY, defaults.DisableAutoSense);
        }

        public static void RestoreDefaults(IIEPESensorDefaults sensorDefaults)
        {
            sensorDefaults._24VPowerHigh = _24VPOWER_HIGH_DEFAULT;
            sensorDefaults._24VPowerLow = _24VPOWER_LOW_DEFAULT;
            sensorDefaults.RangeHighLimitScalar = IEPE_RANGE_HIGH_LIMIT;
            sensorDefaults.RangeLowLimitScalar = IEPE_RANGE_LOW_LIMIT;
            sensorDefaults.DisableAutoSense = DISABLE_AUTOSENSE_DEFAULT;
        }
        #endregion static methods

        public void ReadXML(System.Xml.XmlElement root)
        {
            foreach (var node in root.ChildNodes)
            {
                if (node is System.Xml.XmlElement) { ProcessXMLElement(node as System.Xml.XmlElement); }
            }
        }
        private void ProcessXMLElement(System.Xml.XmlElement node)
        {
            if (Enum.TryParse(node.Name, out IEPEXMLFields field))
            {
                switch (field)
                {
                    case IEPEXMLFields._24PowerHigh: __24VPowerHigh = Convert.ToDouble(node.InnerText, System.Globalization.CultureInfo.InvariantCulture); break;
                    case IEPEXMLFields._24PowerLow: __24VPowerLow = Convert.ToDouble(node.InnerText, System.Globalization.CultureInfo.InvariantCulture); break;
                    case IEPEXMLFields.RangeHighLimitScalar: RangeHighLimitScalar = Convert.ToDouble(node.InnerText, System.Globalization.CultureInfo.InvariantCulture); break;
                    case IEPEXMLFields.RangeLowLimitScalar: RangeLowLimitScalar = Convert.ToDouble(node.InnerText, System.Globalization.CultureInfo.InvariantCulture); break;
                    case IEPEXMLFields.DisableAutoSense: DisableAutoSense = Convert.ToBoolean(node.InnerText); break;
                    default: throw new NotSupportedException("IEPESensorDefault::ProcessXMLElement unsupported field: " + field);
                }
            }
        }

        public void WriteXML(ref System.Xml.XmlWriter writer)
        {
            writer.WriteStartElement("IEPESettingDefaults");

            writer.WriteStartElement(IEPEXMLFields._24PowerHigh.ToString());
            writer.WriteString(_24VPowerHigh.ToString(System.Globalization.CultureInfo.InvariantCulture));
            writer.WriteEndElement();

            writer.WriteStartElement(IEPEXMLFields._24PowerLow.ToString());
            writer.WriteString(_24VPowerLow.ToString(System.Globalization.CultureInfo.InvariantCulture));
            writer.WriteEndElement();

            writer.WriteStartElement(IEPEXMLFields.RangeHighLimitScalar.ToString());
            writer.WriteString(RangeHighLimitScalar.ToString(System.Globalization.CultureInfo.InvariantCulture));
            writer.WriteEndElement();

            writer.WriteStartElement(IEPEXMLFields.RangeLowLimitScalar.ToString());
            writer.WriteString(RangeLowLimitScalar.ToString(System.Globalization.CultureInfo.InvariantCulture));
            writer.WriteEndElement();

            writer.WriteStartElement(IEPEXMLFields.DisableAutoSense.ToString());
            writer.WriteString(DisableAutoSense.ToString());
            writer.WriteEndElement();

            writer.WriteEndElement();
        }
        #endregion methods
    }

    public enum IEPEXMLFields
    {
        _24PowerHigh,
        _24PowerLow,
        RangeHighLimitScalar,
        RangeLowLimitScalar,
        DisableAutoSense
    }
}