using System;
using System.Collections.Generic;
using System.Linq;

namespace DatabaseExport
{
    public class DASHardware : DbTimeStampBase, IComparable<DASHardware>
    {
        public override ConstraintHelper[] GetConstraints()
        {
            return new ConstraintHelper[]
            {
                        new ConstraintHelper()
                        {
                            ColumnName = DbOperations.DAS.Fields.SerialNumber.ToString(),
                            DbType = System.Data.SqlDbType.NVarChar,
                            DbValue = SerialNumber
                        }
            };
        }
        public override string LookupTable => "tblDAS";

        public enum Tags
        {
            MeasuredBatteryVoltage,
            MeasuredInputVoltage,
            Channels,
            ChannelCount,
            Selected,
            BackgroundColor,
            SerialNumber,
            DASTypeEnum,
            Connection,
            FirmwareVersion,
            MaxModules,
            ChannelTypes,
            Reprogramable,
            Reconfigurable,
            LocalOnly
        }
        public int CompareTo(DASHardware right)
        {
            if (null == right) { return 1; }
            if (this == right) { return 0; }
            return SerialNumber == right.SerialNumber ? Connection.CompareTo(right.Connection) : SerialNumber.CompareTo(right.SerialNumber);
        }

        private List<HardwareChannel> _channels = new List<HardwareChannel>();
        public HardwareChannel[] Channels
        {
            get => _channels.ToArray();
            set
            {
                var channels = new List<HardwareChannel>(value);
                channels.Sort();
                SetProperty(ref _channels, channels, Tags.Channels.ToString());
                OnPropertyChanged(Tags.ChannelCount.ToString());
            }
        }

        public string SerialNumber
        {
            get => _hardware.SerialNumber;
            set
            {
                _hardware.SerialNumber = value;
                OnPropertyChanged(Tags.SerialNumber.ToString());
            }
        }


        public int GetHardwareTypeInt() { return _hardware.DASType; }
        public Hardware.HardwareTypes GetHardwareTypeEnum() { return (Hardware.HardwareTypes)GetHardwareTypeInt(); }

        public string Connection
        {
            get => _hardware.IPAddress;
            set
            {
                _hardware.IPAddress = value;
                OnPropertyChanged(Tags.Connection.ToString());
            }
        }
        public DateTime CalDate => _hardware.CalDate;

        public long GetMaxMemoryLong() { return _hardware.MaxMemory; }

        public bool LocalOnly
        {
            get => _hardware.LocalOnly;
            set
            {
                _hardware.LocalOnly = value;
                OnPropertyChanged(Tags.LocalOnly.ToString());
            }
        }
        public DASHardware()
        {
        }
        public Dictionary<string, string> GetValues()
        {
            var elementNameValuePairs = new Dictionary<string, string>();

            var isoH = GetHardware();
            elementNameValuePairs[DbOperations.DAS.Fields.SerialNumber.ToString()] = isoH.SerialNumber;
            elementNameValuePairs[DbOperations.DAS.Fields.Type.ToString()] = isoH.DASType.ToString(System.Globalization.CultureInfo.InvariantCulture);
            elementNameValuePairs[DbOperations.DAS.Fields.MaxModules.ToString()] = isoH.MaxModules.ToString(System.Globalization.CultureInfo.InvariantCulture);
            elementNameValuePairs[DbOperations.DAS.Fields.MaxMemory.ToString()] = isoH.MaxMemory.ToString(System.Globalization.CultureInfo.InvariantCulture);
            elementNameValuePairs[DbOperations.DAS.Fields.MaxSampleRate.ToString()] = isoH.MaxSampleRate.ToString(System.Globalization.CultureInfo.InvariantCulture);
            elementNameValuePairs[DbOperations.DAS.Fields.MinSampleRate.ToString()] = isoH.MinSampleRate.ToString(System.Globalization.CultureInfo.InvariantCulture);
            elementNameValuePairs[DbOperations.DAS.Fields.FirmwareVersion.ToString()] = isoH.FirmwareVersion;
            elementNameValuePairs[DbOperations.DAS.Fields.CalDate.ToString()] = CalDate.ToString(System.Globalization.CultureInfo.InvariantCulture);
            elementNameValuePairs[DbOperations.DAS.Fields.ProtocolVersion.ToString()] = isoH.ProtocolVersion.ToString(System.Globalization.CultureInfo.InvariantCulture);
            elementNameValuePairs[DbOperations.DAS.Fields.LastModified.ToString()] = isoH.LastModified.ToString(System.Globalization.CultureInfo.InvariantCulture);
            elementNameValuePairs[DbOperations.DAS.Fields.LastModifiedBy.ToString()] = isoH.LastModifiedBy;
            elementNameValuePairs[DbOperations.DAS.Fields.Version.ToString()] = isoH.Version.ToString(System.Globalization.CultureInfo.InvariantCulture);
            elementNameValuePairs[DbOperations.DAS.Fields.LocalOnly.ToString()] = isoH.LocalOnly.ToString();
            elementNameValuePairs[DbOperations.DAS.Fields.LastUsed.ToString()] = isoH.LastUsed.ToString(System.Globalization.CultureInfo.InvariantCulture);
            elementNameValuePairs[DbOperations.DAS.Fields.LastUsedBy.ToString()] = isoH.LastUsedBy;
            elementNameValuePairs[DbOperations.DAS.Fields.Connection.ToString()] = isoH.IPAddress;
            elementNameValuePairs[DbOperations.DAS.Fields.Channels.ToString()] = isoH.Channels.ToString(System.Globalization.CultureInfo.InvariantCulture);
            elementNameValuePairs[DbOperations.DAS.Fields.Position.ToString()] = isoH.Position;

            var channeltypes = new List<string>();
            foreach (var ct in isoH.ChannelTypes) { channeltypes.Add(ct.ToString(System.Globalization.CultureInfo.InvariantCulture)); }
            elementNameValuePairs[DbOperations.DAS.Fields.ChannelTypes.ToString()] = string.Join(System.Globalization.CultureInfo.InvariantCulture.TextInfo.ListSeparator, channeltypes.ToArray());
            elementNameValuePairs[DbOperations.DAS.Fields.Reprogramable.ToString()] = isoH.IsProgrammable.ToString();
            elementNameValuePairs[DbOperations.DAS.Fields.Reconfigurable.ToString()] = isoH.IsReconfigurable.ToString();
            elementNameValuePairs[DbOperations.DAS.Fields.IsModule.ToString()] = isoH.IsModule.ToString();

            return elementNameValuePairs;
        }
        public Dictionary<string, string> GetChannelValues(HardwareChannel channel)
        {
            var elementNameValuePairs = new Dictionary<string, string>();

            var isoH = GetHardware();
            var isoChannel = channel.GetISOChannel();

            elementNameValuePairs[DbOperations.DAS.DASChannelFields.HardwareId.ToString()] = isoH.GetId();
            elementNameValuePairs[DbOperations.DAS.DASChannelFields.ChannelIdx.ToString()] = isoChannel.ChannelIdx.ToString(System.Globalization.CultureInfo.InvariantCulture);
            elementNameValuePairs[DbOperations.DAS.DASChannelFields.SupportedBridges.ToString()] = isoChannel.SupportedBridges.ToString(System.Globalization.CultureInfo.InvariantCulture);
            elementNameValuePairs[DbOperations.DAS.DASChannelFields.SupportedExcitations.ToString()] = isoChannel.SupportedExcitations.ToString(System.Globalization.CultureInfo.InvariantCulture);
            elementNameValuePairs[DbOperations.DAS.DASChannelFields.DASDisplayOrder.ToString()] = isoChannel.DASDisplayOrder.ToString(System.Globalization.CultureInfo.InvariantCulture);
            elementNameValuePairs[DbOperations.DAS.DASChannelFields.LocalOnly.ToString()] = isoChannel.LocalOnly.ToString();
            elementNameValuePairs[DbOperations.DAS.DASChannelFields.SupportedDigitalInputModes.ToString()] = isoChannel.SupportedDigitalInputModes.ToString(System.Globalization.CultureInfo.InvariantCulture);
            elementNameValuePairs[DbOperations.DAS.DASChannelFields.SupportedSquibFireModes.ToString()] = isoChannel.SupportedSquibFireModes.ToString(System.Globalization.CultureInfo.InvariantCulture);
            elementNameValuePairs[DbOperations.DAS.DASChannelFields.SupportedDigitalOutputModes.ToString()] = isoChannel.SupportedDigitalOutputModes.ToString(System.Globalization.CultureInfo.InvariantCulture);
            elementNameValuePairs[DbOperations.DAS.DASChannelFields.ModuleSerialNumber.ToString()] = isoChannel.ModuleSerialNumber;
            elementNameValuePairs[DbOperations.DAS.DASChannelFields.ModuleArrayIndex.ToString()] = isoChannel.ModuleArrayIndex.ToString(System.Globalization.CultureInfo.InvariantCulture);

            return elementNameValuePairs;
        }
        public DASHardware(DASHardware copy, DASHardware parentDAS)
        {
            if (null != copy.Channels)
            {
                var channels = new List<HardwareChannel>();
                foreach (var ch in copy.Channels) { channels.Add(new HardwareChannel(ch)); }
                Channels = channels.ToArray();
            }

            _hardware = new Hardware(copy.GetHardware());
            DbTimeStamp = copy.DbTimeStamp;
        }
        private Hardware _hardware = new Hardware();
        public Hardware GetHardware() { return _hardware; }
        /// <summary>
        /// note that if you use this constructor, you should set
        /// TimeStampDb explicitly
        /// </summary>
        /// <param name="hardware"></param>
        public DASHardware(Hardware hardware)
        {
            _hardware = new Hardware(hardware);
            _hardware.IPAddress = Connection;

            var channels = new List<HardwareChannel>();
            foreach (var channel in hardware.ISOChannels)
            {
                channels.Add(new HardwareChannel(channel, this));
            }
            Channels = channels.ToArray();
        }
        public bool IsDummy()
        {
            return SerialNumber.Contains("Dummy");
        }

    }
    public class DASHardwareList //: Common.BindableBase
    {
        private static DASHardwareList _list;
        public static DASHardwareList GetList()
        {
            if (null == _list)
            {
                _list = new DASHardwareList();
                _list.PopulateHardware();
            }

            return _list;
        }

        public DASHardware GetHardware(string id)
        {
            bool bNotUsed;
            return GetHardware(id, true, out bNotUsed);
        }
        public DASHardware GetHardware(string id, bool bThrowExceptionIfChanged, out bool changed)
        {
            changed = false;
            if (_hardware.ContainsKey(id)) { return _hardware[id]; }
            else
            {
                var matchingSerial = from h in _hardware where h.Value.SerialNumber == id select h.Value;
                if (matchingSerial.Count() > 0) { return matchingSerial.First(); }
                else
                {
                    //check to see if the type changed?
                    var index = id.IndexOf('_');
                    if (index >= 0)
                    {
                        id = id.Substring(0, index);
                    }
                    var match2 = from h in _hardware where h.Value.SerialNumber == id select h.Value;

                    if (match2.Count() > 0)
                    {
                        if (bThrowExceptionIfChanged)
                        {
                            throw new HardwareTypeChangedException();
                        }
                        else
                        {
                            changed = true;
                        }
                    }
                    return null;
                }
            }
        }
        public class HardwareTypeChangedException : Exception
        {
            public HardwareTypeChangedException() { }
        }
        private DASHardware[] GetAllHardware()
        {
            var hardware = new List<DASHardware>();
            var temp = new DASHardware();
            var allTimeStamps = temp.GetAllTimeStampDb();
            foreach (var hw in DatabaseExport.Hardware.GetAllDAS())
            {
                if (hw.Position == "Prototype" /*DbOperations.DAS.PROTOTYPE_POSITION*/) { continue; } //fix this
                else
                {
                    var newH = new DASHardware(hw);
                    newH.SetTimeStampMemory(newH.GetTimeStampDb(allTimeStamps));
                    hardware.Add(newH);
                }
            }

            return hardware.ToArray();
        }

        private Dictionary<string, DASHardware> _hardware = null;
        public DASHardware[] Hardware
        {
            get
            {
                if (null == _hardware)
                {
                    PopulateHardware();
                }
                return _hardware.Values.ToArray();
            }
        }
        private void PopulateHardware()
        {
            _hardware = new Dictionary<string, DASHardware>();
            foreach (var h in GetAllHardware())
            {
                if (!_hardware.ContainsKey(h.GetHardware().GetId())) { _hardware.Add(h.GetHardware().GetId(), h); }
                else { _hardware[h.GetHardware().GetId()] = h; }
            }
        }
    }
}