using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Linq;
using DTS.Common.Base;
using DTS.Common.Classes.Hardware;
using DTS.Common.Converters;
using DTS.Common.Enums;
using DTS.Common.Enums.Hardware;
using DTS.Common.Interface.DASFactory.Diagnostics;
using DTS.Common.Interface.DASFactory.Diagnostics.HardwareList;

namespace HardareList.Model
{
    public class HardwareModel : BasePropertyChanged, IHardware
    {
        /// <summary>
        /// first date of use after calibration
        /// only valid if IsFirstUseValid is true
        /// null value indicates hardware has not been used since calibration
        /// (once again, only if IsFirstUseValid is true)
        /// 15524 DAS "First Use Date"
        /// </summary>
        public DateTime? FirstUseDate { get; set; } = null;
        /// <summary>
        /// whether hardware supports and is using first use date
        /// 15524 DAS "First Use Date"
        /// </summary>
        public bool IsFirstUseValid { get; set; } = false;
        public int DASId { get; set; }
        public bool Disabled { get; set; }
        public string SerialNumber { get; set; }
        public string HardwareType { get; set; }
        public string ChannelCount { get; set; }
        public bool HasIncludedChildren { get; set; } = false;
        public string Firmware { get; set; }
        public double? MaxSampleRate { get; set; }
        private double _testSampleRate = 0;
        public double TestSampleRate
        {
            get => _testSampleRate;
            set
            {
                SetProperty(ref _testSampleRate, value, "TestSampleRate");
                OnPropertyChanged("SelectedSampleRateIndex");
            }
        }
        private double _testAafilterRateHz = 0;
        public double TestAAFilterRateHz
        {
            get => _testAafilterRateHz;
            set
            {
                SetProperty(ref _testAafilterRateHz, value, "TestAAFilterRateHz");
                _vm.FireAAFilterRate(this, value.ToString());
            }
        }

        public DateTime? CalDate { get; set; }
        public DateTime? CalDueDate { get; set; }
        public List<double> _availableSampleRates { get; set; }
        public string[] AvailableSampleRates { get; set; }
        public string SelectedSampleRateItem { get; set; } = string.Empty;
        public int SelectedSampleRateIndex
        {
            get
            {
                if (null == _availableSampleRates) { return -1; }
                if (_availableSampleRates.IndexOf(TestSampleRate) == -1)
                {
                    return -1;
                }
                SelectedSampleRateItem = AvailableSampleRates[_availableSampleRates.IndexOf(TestSampleRate)]; //They're all the same
                return _availableSampleRates.IndexOf(TestSampleRate);
            }
            set
            {
                if (SelectedSampleRateIndex == value) return;
                TestSampleRate = _availableSampleRates[value];
                _vm.FireSampleRate(this, _availableSampleRates[value].ToString());
                TestAAFilterRateHz = _vm.GetAAFForHardware((IISOHardware)Hardware, (int)TestSampleRate);
                OnPropertyChanged("SelectedSampleRateIndex");
            }
        }
        public object Hardware { get; set; }
        public int AnalogChannels { get; set; }
        public int SquibChannels { get; set; }
        public int DigitalInChannels { get; set; }
        public int DigitalOutChannels { get; set; }
        public int UartChannels { get; set; }
        public int StreamOutChannels { get; set; }
        public int StreamInChannels { get; set; }
        public int CanChannels { get; set; }
        public string IPAddress { get; set; }

        private bool _bIncluded = false;
        public bool Included
        {
            get => _bIncluded;
            set
            {
                _bIncluded = value;
                OnPropertyChanged("Included");
                _vm.FireIncluded(this);
                OnPropertyChanged("MixedRates");
                OnPropertyChanged("IncludedAndNotMixedRatesAndCompactOrNotDistributor");
                OnPropertyChanged("IncludedAndMixedRatesAndCompact");
            }
        }

        private double _dspStreamingFilter = double.NaN;
        public double DSPStreamingFilter
        {
            get => _dspStreamingFilter;
            set => SetProperty(ref _dspStreamingFilter, value, "DSPStreamingFilter");
        }
        public DTS.Common.ClockSyncProfile MasterProfile { get; set; } = DTS.Common.ClockSyncProfile.None;
        public DTS.Common.ClockSyncProfile SlaveProfile { get; set; } = DTS.Common.ClockSyncProfile.None;
        private bool _bIsClockMaster = false;
        public bool IsClockMaster
        {
            get => IsClockedDAS && _bIsClockMaster;
            set
            {
                SetProperty(ref _bIsClockMaster, value, "IsClockMaster");
                _vm.FireClockMaster(this, IsClockMaster);
                OnPropertyChanged("IsPTPSync");
            }
        }

        public bool IsClockedDAS
        {
            get
            {
                switch(((IISOHardware)Hardware)?.DASTypeEnum)
                {
                    case HardwareTypes.SLICE6_AIR:
                    case HardwareTypes.S6A_EthernetRecorder:
                    case HardwareTypes.SLICE6_Base:
                    case HardwareTypes.SLICE6_AIR_BR:
                    case HardwareTypes.SLICE6DB:
                    case HardwareTypes.SLICE6DB3:
                    case HardwareTypes.SLICE6DB_InDummy:
                    case HardwareTypes.TSR_AIR:
                    case HardwareTypes.TSR_AIR_RevB:
                    case HardwareTypes.SLICE6_AIR_TC:
                        return true;
                }
                return false;
            }
        }

        private byte _ptpDomainId = 0;
        public byte PTPDomainID
        {
            get => _ptpDomainId;
            set
            {
                SetProperty(ref _ptpDomainId, value, "PTPDomainID");
                _vm.FirePTPDomainID(this, PTPDomainID);
            }
        }

        public bool IsPTPSync => (IsClockMaster && MasterProfile.GetDescription().Contains("E2E")) || (!IsClockMaster && SlaveProfile.GetDescription().Contains("E2E"));

        private bool _mixedRates = false;
        public bool MixedRates
        {
            get => _mixedRates;
            set
            {
                _mixedRates = value;
                OnPropertyChanged("MixedRates");
                OnPropertyChanged("IncludedAndNotMixedRatesAndCompactOrNotDistributor");
                OnPropertyChanged("IncludedAndMixedRatesAndCompact");
            }
        }
        public bool IsDistributor => (Hardware as IISOHardware).DASTypeEnum == HardwareTypes.SLICE_EthernetController ||
                       (Hardware as IISOHardware).DASTypeEnum == HardwareTypes.SLICE_Distributor ||
                       (Hardware as IISOHardware).DASTypeEnum == HardwareTypes.SLICE_Mini_Distributor ||
                       (Hardware as IISOHardware).DASTypeEnum == HardwareTypes.SLICE6DB ||
                       (Hardware as IISOHardware).DASTypeEnum == HardwareTypes.SLICE_LabEthernet ||
                       (Hardware as IISOHardware).DASTypeEnum == HardwareTypes.SLICE6DB3 ||
                       (Hardware as IISOHardware).DASTypeEnum == HardwareTypes.SLICE6DB_InDummy ||
                       (Hardware as IISOHardware).DASTypeEnum == HardwareTypes.SLICE_Pro_Distributor;

        public bool IsBattery => (Hardware as IISOHardware).DASTypeEnum == HardwareTypes.PowerPro;
        public bool IsTSRAIR => (Hardware as IISOHardware).DASTypeEnum == HardwareTypes.TSR_AIR ||
                                (Hardware as IISOHardware).DASTypeEnum == HardwareTypes.TSR_AIR_RevB ||
                                (Hardware as IISOHardware).DASTypeEnum == HardwareTypes.DKR ||
                                (Hardware as IISOHardware).DASTypeEnum == HardwareTypes.DIR;
        public bool IncludedAndNotMixedRatesAndCompactOrNotDistributor => Included && !MixedRates && ((_vm.ShowCompact && HasIncludedChildren) || !IsDistributor) && !IsBattery;
        public bool IncludedAndMixedRatesAndCompact => Included && MixedRates && _vm.ShowCompact && !IsBattery;
        private HardwareList.HardwareListViewModel _vm;
        public HardwareModel(IISOHardware d, int tdasCalPeriod, int g5CalPeriod, int slice1CalPeriod, int slice2CalPeriod, int slice15CalPeriod, int slice6CalPeriod,
            int powerProCalPeriod, int slice6AirCalPeriod, int slice6AirBridgeCalPeriod, int slice6DBCalPeriod, int tsrAirCalPeriod, int sliceTcCalPeriod,
            int sliceProCanFdPeriod, HardwareList.HardwareListViewModel vm)
        {
            FirstUseDate = d.FirstUseDate;
            IsFirstUseValid = d.IsFirstUseValid;
            _vm = vm;
            Hardware = d;
            DASId = d.DASId;
            SerialNumber = d.SerialNumber;
            Port = d.Port;
            ParentDAS = d.ParentDAS;
            PositionOnChain = d.PositionOnChain;
            PositionOnDistributor = d.PositionOnDistributor;
            HardwareType = HardwareList.Resources.StringResources.ResourceManager.GetString(d.DASTypeEnum.ToString());
            if (string.IsNullOrEmpty(HardwareType))
            {
                HardwareType = EnumDescriptionTypeConverter.GetEnumDescription(d.DASTypeEnum);
            }
            Firmware = d.FirmwareVersion;
            if ((d.MaxSampleRate > 0.0D) && !Equals(d.MaxSampleRate, (double)uint.MaxValue))
            {
                MaxSampleRate = d.MaxSampleRate;
            }
            else
            {
                MaxSampleRate = null;
            }

            if (d.CalDate > DASDBRecord.INVALID_DATE)
            {
                CalDate = d.CalDate;
            }
            else
            {
                CalDate = null;
            }

            d.GetChannelsString(out var analog, out var digitalIn, out var digitalOut, out var squib, out var uart, out var streamOut, out var streamIn, out var can);

            AnalogChannels = analog;
            DigitalInChannels = digitalIn;
            DigitalOutChannels = digitalOut;
            SquibChannels = squib;
            UartChannels = uart;
            StreamOutChannels = streamOut;
            StreamInChannels = streamIn;
            CanChannels = can;

            var dateOfFirstUse = CalDate;
            if (IsFirstUseValid)
            {
                if (null == FirstUseDate)
                {
                    dateOfFirstUse = DateTime.Today;
                }
                else { dateOfFirstUse = FirstUseDate; }
            }

            switch (d.DASTypeEnum)
            {
                case HardwareTypes.SLICE_Base:
                case HardwareTypes.SLICE_Bridge:
                case HardwareTypes.SLICE_Distributor:
                //FB 16148 similar to slice db 
                case HardwareTypes.SLICE_Mini_Distributor:
                case HardwareTypes.SLICE_IEPE:
                case HardwareTypes.Ribeye:
                case HardwareTypes.RibeyeLED:
                case HardwareTypes.SLICE_Micro_Base:
                case HardwareTypes.SLICE_NANO_Base:
                case HardwareTypes.SLICE1_G5Stack:
                    CalDueDate = dateOfFirstUse?.AddDays(slice1CalPeriod);
                    break;
                case HardwareTypes.TDAS_Pro_Rack:
                case HardwareTypes.TDAS_LabRack:
                case HardwareTypes.TOM:
                case HardwareTypes.SIM:
                case HardwareTypes.DIM:
                    CalDueDate = dateOfFirstUse?.AddDays(tdasCalPeriod);
                    break;
                case HardwareTypes.SLICE2_IEPE_Hi:
                case HardwareTypes.SLICE2_IEPE_Lo:
                case HardwareTypes.SLICE2_Bridge_Hi:
                case HardwareTypes.SLICE2_Bridge_Lo:
                case HardwareTypes.SLICE2_Base:
                case HardwareTypes.SLICE2_SIM:
                case HardwareTypes.SLICE2_DIM:
                case HardwareTypes.SLICE2_TOM:
                case HardwareTypes.SLICE_EthernetController:
                case HardwareTypes.SLICE_LabEthernet:
                case HardwareTypes.SLICE2_SLS:
                case HardwareTypes.SLICE2_SLT:
                case HardwareTypes.SLICE2_SLD:
                    CalDueDate = dateOfFirstUse?.AddDays(slice2CalPeriod);
                    break;
                case HardwareTypes.TSR_AIR:
                case HardwareTypes.TSR_AIR_RevB:
                case HardwareTypes.DKR:
                case HardwareTypes.DIR:
                case HardwareTypes.EMB_ANG_ACC:
                case HardwareTypes.EMB_ANG_ARS:
                case HardwareTypes.EMB_ATM:
                case HardwareTypes.EMB_LIN_ACC_LO:
                case HardwareTypes.EMB_LIN_ACC_HI:
                case HardwareTypes.EMB_MAG:
                case HardwareTypes.EMB_MAG_SWITCH:
                case HardwareTypes.EMB_MIC:
                case HardwareTypes.EMB_OPT:
                case HardwareTypes.EMB_RTC_S_MARK:
                case HardwareTypes.EMB_RTC_NS_PAD:
                    CalDueDate = dateOfFirstUse?.AddDays(tsrAirCalPeriod);
                    break;
                case HardwareTypes.G5VDS:
                case HardwareTypes.G5INDUMMY:
                    CalDueDate = dateOfFirstUse?.AddDays(g5CalPeriod);
                    break;
                case HardwareTypes.SLICE1_5_Nano_Base:
                case HardwareTypes.SLICE1_5_Micro_Base:
                    CalDueDate = dateOfFirstUse?.AddDays(slice15CalPeriod);
                    break;
                case HardwareTypes.SLICE6_Base:
                    //put some fall-through logic here
                    CalDueDate = dateOfFirstUse?.AddDays(slice6CalPeriod);
                    break;
                case HardwareTypes.SLICE6_AIR:
                case HardwareTypes.S6A_EthernetRecorder:
                    CalDueDate = dateOfFirstUse?.AddDays(slice6AirCalPeriod);
                    break;
                case HardwareTypes.SLICE6_AIR_BR:
                    //put some fall-through logic here
                    CalDueDate = dateOfFirstUse?.AddDays(slice6AirBridgeCalPeriod);
                    break;
                case HardwareTypes.SLICE_Pro_Distributor:
                    CalDueDate = dateOfFirstUse?.AddDays(slice6DBCalPeriod);
                    break;
                case HardwareTypes.SLICE6DB:
                case HardwareTypes.SLICE6DB3:
                case HardwareTypes.SLICE6DB_InDummy:
                    CalDueDate = dateOfFirstUse?.AddDays(slice6DBCalPeriod);
                    HasTreeView = true;
                    break;
                case HardwareTypes.PowerPro:
                    CalDueDate = dateOfFirstUse?.AddDays(powerProCalPeriod);
                    break;
                case HardwareTypes.SLICE6_AIR_TC:
                    CalDueDate = dateOfFirstUse?.AddDays(sliceTcCalPeriod);
                    break;
                case HardwareTypes.SLICE_PRO_CAN_FD:
                    CalDueDate = dateOfFirstUse?.AddDays(sliceProCanFdPeriod);
                    break;
                default:
                    throw new ArgumentOutOfRangeException();
            }
            if (d.IPAddress.ToLower().Contains("usb"))
            {
                IPAddress = HardwareList.Resources.StringResources.USB;
            }
            else
            {
                IPAddress = d.IPAddress;
            }
        }

        public void DetermineChannelCount(bool showCompact, IHardware[] allHardware)
        {
            var channelsText = new List<string>();
            if (AnalogChannels > 0)
            {
                channelsText.Add($"{AnalogChannels} {HardwareList.Resources.StringResources.Analog}");
            }
            if (DigitalInChannels > 0)
            {
                channelsText.Add($"{DigitalInChannels} {HardwareList.Resources.StringResources.DigitalIn}");
            }
            if (SquibChannels > 0)
            {
                channelsText.Add($"{SquibChannels / 2} {HardwareList.Resources.StringResources.Squib}");
            }
            if (DigitalOutChannels > 0)
            {
                channelsText.Add($"{DigitalOutChannels} {HardwareList.Resources.StringResources.DigitalOut}");
            }
            if (UartChannels > 0)
            {
                channelsText.Add($"{UartChannels} {HardwareList.Resources.StringResources.UART}");
            }
            if (StreamOutChannels > 0)
            {
                channelsText.Add($"{StreamOutChannels} {HardwareList.Resources.StringResources.StreamOut}");
            }
            if (StreamInChannels > 0)
            {
                channelsText.Add($"{StreamInChannels} {HardwareList.Resources.StringResources.StreamIn}");
            }
            if (CanChannels > 0)
            {
                channelsText.Add($"{CanChannels} {HardwareList.Resources.StringResources.CAN}");
            }

            ChannelCount = string.Join(System.Globalization.CultureInfo.CurrentCulture.TextInfo.ListSeparator,
                channelsText.ToArray()) + " " + HardwareList.Resources.StringResources.DAS_Channels;

            if (Hardware is IISOHardware hardware)
            {
                if (hardware.DASTypeEnum == HardwareTypes.SLICE_EthernetController ||
                    hardware.DASTypeEnum == HardwareTypes.SLICE_Distributor ||
                    hardware.DASTypeEnum == HardwareTypes.PowerPro ||
                    hardware.DASTypeEnum == HardwareTypes.SLICE_Mini_Distributor ||
                    hardware.DASTypeEnum == HardwareTypes.SLICE6DB ||
                    hardware.DASTypeEnum == HardwareTypes.SLICE6DB3 ||
                    hardware.DASTypeEnum == HardwareTypes.SLICE_Pro_Distributor

                    ) //add SLICE6DB and others here?
                {
                    if (!showCompact || hardware.DASTypeEnum == HardwareTypes.PowerPro || string.IsNullOrWhiteSpace(ChannelCount))
                    {
                        ChannelCount = HardwareList.Resources.StringResources.Table_NA;
                        MaxSampleRate = null;
                    }
                    else
                    {
                        var minRate = hardware.MaxSampleRate;
                        var matches = from h in allHardware where h.ParentDAS == SerialNumber && null != h.MaxSampleRate select (double)h.MaxSampleRate;
                        if (matches.Any())
                        {
                            minRate = Math.Min(minRate, matches.Min());
                            MaxSampleRate = minRate;
                        }
                        else
                        {
                            //no DAS associated, so rate is unknown
                            ChannelCount = HardwareList.Resources.StringResources.Table_NA;
                            MaxSampleRate = null;
                        }

                    }
                }
                else if (hardware.IsTSRAIR())
                {
                    ChannelCount = HardwareList.Resources.StringResources.EmbeddedSensors
                                   + (UartChannels > 0 ? $", {UartChannels} {HardwareList.Resources.StringResources.UART}" : String.Empty)
                                   + (StreamOutChannels > 0 ? $", {StreamOutChannels} {HardwareList.Resources.StringResources.StreamOut} {HardwareList.Resources.StringResources.DAS_Channels}" : String.Empty);
                }
            }
        }
        public void SetIncluded(bool bIncluded)
        {
            _bIncluded = bIncluded;
            OnPropertyChanged("Included");
            OnPropertyChanged("MixedRates");
            OnPropertyChanged("IncludedAndNotMixedRatesAndCompactOrNotDistributor");
            OnPropertyChanged("IncludedAndMixedRatesAndCompact");
        }
        public void SetMixedRates(bool mixedRates)
        {
            _mixedRates = mixedRates;
            OnPropertyChanged("MixedRates");
            OnPropertyChanged("IncludedAndNotMixedRatesAndCompactOrNotDistributor");
            OnPropertyChanged("IncludedAndMixedRatesAndCompact");
        }

        public bool Filter(string term)
        {
            if (string.IsNullOrWhiteSpace(term)) { return true; }
            term = term.ToLower();
            if (SerialNumber.ToLower().Contains(term)) { return true; }
            if (Firmware.ToLower().Contains(term)) { return true; }
            if (HardwareType.ToLower().Contains(term)) { return true; }
            return false;
        }

        public string ParentDAS { get; set; }
        public int PositionOnChain { get; set; }
        public int PositionOnDistributor { get; set; }
        public int Port { get; set; }

        private bool _bHasTreeView = false;
        public bool HasTreeView
        {
            get => _bHasTreeView;
            set
            {
                _bHasTreeView = value;
                OnPropertyChanged("HasTreeView");
            }
        }
        public override string ToString()
        {
            return SerialNumberDisplay;
        }
        protected HardwareModel() { }
        /// <summary>
        /// returns all SLICE6DB available (except any matching the serial number indicated)
        /// </summary>
        /// <param name="serialNumber"></param>
        /// <returns></returns>
        public static IHardware[] GetAvailableSLICE6DB(string serialNumber)
        {
            if (string.IsNullOrWhiteSpace(serialNumber))
            {
                return new IHardware[0];
            }
            serialNumber = serialNumber.ToUpper();
            var list = new List<IHardware>();

            using (var sql = DTS.Common.Storage.DbOperations.GetSQLCommand(true))
            {
                try
                {
                    sql.CommandType = System.Data.CommandType.Text;
                    sql.CommandText = $"SELECT [DASId], [SerialNumber] FROM [DAS] where [Type] in ({(int)HardwareTypes.SLICE6DB},{(int)HardwareTypes.SLICE6DB_InDummy}) AND [Position]=''";
                    var reader = sql.ExecuteReader();
                    while (reader.Read())
                    {
                        var h = new HardwareModel();
                        h.DASId = Convert.ToInt32(reader["DASId"]);
                        h.SerialNumber = Convert.ToString(reader["SerialNumber"]);
                        if (h.SerialNumber.ToUpper() == serialNumber) { continue; }
                        list.Add(h);
                    }
                }
                finally
                {
                    sql.Connection.Dispose();
                }
            }
            return list.ToArray();
        }

        public string SerialNumberDisplay
        {
            get
            {
                if (!(Hardware is IISOHardware isoHW)) { return SerialNumber; }
                return isoHW.StandIn ? EnumDescriptionTypeConverter.GetEnumDescription(isoHW.DASTypeEnum) : SerialNumber;
            }
        }
    }
    public class HardwareComparer : IComparer<IHardware>
    {
        public HardwareListTags SortField { get; set; }
        private bool _bSortAscending = true;

        public bool SortAscending
        {
            get => _bSortAscending;
            set => _bSortAscending = value;
        }

        public int Compare(IHardware left, IHardware right)
        {
            if (left == right)
            {
                return 0;
            }

            var a = left; var b = right;
            if (!SortAscending) { a = right; b = left; }
            if (null == a)
            {
                return 1;
            }
            if (null == b)
            {
                return -1;
            }

            switch (SortField)
            {
                case HardwareListTags.Included:
                    return a.Included.CompareTo(b.Included);
                case HardwareListTags.DSPStreamingFilter:
                    return a.DSPStreamingFilter.CompareTo(b.DSPStreamingFilter);
                case HardwareListTags.SerialNumber:
                    if (a is HardwareModel hmA && b is HardwareModel hmB)
                    {
                        return string.Compare(hmA.SerialNumberDisplay, hmB.SerialNumberDisplay,
                            StringComparison.OrdinalIgnoreCase);
                    }
                    else { return string.Compare(a.SerialNumber, b.SerialNumber, StringComparison.OrdinalIgnoreCase); }
                case HardwareListTags.HardwareType:
                    return string.Compare(a.HardwareType, b.HardwareType, StringComparison.OrdinalIgnoreCase);
                case HardwareListTags.ChannelCount:
                    return string.Compare(a.ChannelCount, b.ChannelCount, StringComparison.OrdinalIgnoreCase);
                case HardwareListTags.Firmware:
                    return string.Compare(a.Firmware, b.Firmware, StringComparison.OrdinalIgnoreCase);
                case HardwareListTags.MaxSampleRate:
                    {
                        return NumericCompare(a.MaxSampleRate, b.MaxSampleRate);
                    }
                case HardwareListTags.CalDate:
                    {
                        return NumericCompare(a.CalDate, b.CalDate);
                    }
                case HardwareListTags.CalDueDate:
                    {
                        return NumericCompare(a.CalDueDate, b.CalDueDate);
                    }
                case HardwareListTags.IPAddress:
                    {
                        return string.Compare(a.IPAddress, b.IPAddress, StringComparison.OrdinalIgnoreCase);
                    }
                case HardwareListTags.FirstUseDate:
                    {
                        if (!a.IsFirstUseValid)
                        {
                            if (!b.IsFirstUseValid)
                            {
                                return 0;
                            }
                            else
                            {
                                return 1;
                            }
                        }
                        else
                        {
                            if (!b.IsFirstUseValid)
                            {
                                return -1;
                            }

                            if (null == a.FirstUseDate)
                            {
                                if (null == b.FirstUseDate)
                                {
                                    return 0;
                                }

                                return 1;
                            }

                            if (null == b.FirstUseDate)
                            {
                                return -1;
                            }
                            return ((DateTime)a.FirstUseDate).CompareTo((DateTime)b.FirstUseDate);
                        }
                    }
            }
            return a.GetHashCode().CompareTo(b.GetHashCode());
        }
        private static int NumericCompare(object a, object b)
        {
            if (a == null && b == null) return 0;
            if (a == null) return 1;
            if (b == null) return -1;
            if (Equals(a, b)) return 0;
            switch (a)
            {
                case double d:
                    if (d > (double)b) return -1;
                    break;
                case DateTime dt:
                    if (dt > (DateTime)b) return -1;
                    break;
            }
            return 1;
        }
    }
}