DP44/Common/DTS.Common.DataModel/Group.cs

using System;
using System.Collections.Generic;
using System.Data;
using System.Data.SqlClient;
using System.Globalization;
using System.IO.Ports;
using System.Linq;
using System.Windows;
using DTS.Common.Classes;
using DTS.Common.Classes.Groups;
using DTS.Common.Classes.Groups.ChannelSettings;
using DTS.Common.Classes.Sensors;
using DTS.Common.Enums.Groups.GroupList;
using DTS.Common.Enums.Sensors;
using DTS.Common.Interface.Channels;
using DTS.Common.Interface.Channels.ChannelCodes;
using DTS.Common.Interface.DataRecorders;
using DTS.Common.Interface.Groups.GroupList;
using DTS.Common.Interface.Sensors;
using DTS.Common.Interface.Tags;
using DTS.Common.Interface.Groups;
using DTS.Common.Interface.TestSetups.TestSetupsList;
using DTS.Common.ISO;
using DTS.Common.Storage;
using DTS.Common.Utilities.Logging;
using DTS.SensorDB;
using Prism.Ioc;
using IGroup = DTS.Common.Interface.Groups.GroupList.IGroup;
using DTS.Common.Enums.DASFactory;
using Newtonsoft.Json;
using DTS.Common.Enums;
using Prism.Events;
using Unity;

namespace GroupList.Model
{
    public class Group : TagAwareBase, IGroup
    {
        public override TagTypes TagType => TagTypes.Group;
        private bool _bHardwareLoaded = false;

        private int[] _includedHardware = new int[0];

        public int[] IncludedHardware
        {
            get
            {
                if (!_bHardwareLoaded)
                {
                    LoadHardware();
                }

                return _includedHardware;
            }
            set => _includedHardware = value;
        }

        public void SetIncludedHardware(int[] hardware)
        {
            _includedHardware = hardware;
            _bHardwareLoaded = true;
        }
        private List<string> _includedHarwareStringList = new List<string>();

        public string[] IncludedHardwareStringList
        {
            get => _includedHarwareStringList.ToArray();
            set => _includedHarwareStringList = new List<string>(value);
        }
        public List<DTS.Common.Interface.Channels.IGroupChannel> GroupChannelList { get; set; }

        private int _channelCount = 0;

        public int ChannelCount
        {
            get => _channelCount;
            set => SetProperty(ref _channelCount, value, "ChannelCount");
        }
        public int Id { get; set; } = -1;
        public bool HasValidId()
        {
            return Id >= 0;
        }
        public string Name { get; set; }
        public string DisplayName { get; set; }
        public string Tags { get; set; }
        public int? StaticGroupId { get; set; }
        public bool Embedded { get; set; }
        public DateTime LastModified { get; set; }
        public string LastModifiedBy { get; set; }
        private string _description = "";
        public string Description
        {
            get => _description;
            set => SetProperty(ref _description, value, "Description");
        }

        // FB14276: Add Custom ISO Key-Value Pairs
        public List<KeyValuePair<string, string>> ExtraProperties { get; set; }

        private List<TestSetupParentHelper> _associatedTestSetups;
        public List<TestSetupParentHelper> AssociatedTestSetups
        {
            get => _associatedTestSetups;
            set
            {
                _associatedTestSetups = value;
                OnPropertyChanged("UnmodifiedTestSetupStringList");
                OnPropertyChanged("ModifiedTestSetupStringList");
            }
        }

        public List<string> UnmodifiedTestSetupStringList
        {
            get
            {
                if (null == AssociatedTestSetups)
                {
                    return new List<string>();
                }
                return AssociatedTestSetups.Where(x => !x.Modified).Select(x => x.Name).ToList();
            }
        }

        public List<string> ModifiedTestSetupStringList
        {
            get
            {
                if (null == AssociatedTestSetups)
                {
                    return new List<string>();
                }
                return AssociatedTestSetups.Where(x => x.Modified).Select(x => x.Name).ToList();
            }
        }

        private bool _isDifferentThanStaticGroup;
        public bool IsDifferentThanStaticGroup
        {
            get => _isDifferentThanStaticGroup;
            set => SetProperty(ref _isDifferentThanStaticGroup, value, "IsDifferentThanStaticGroup");
        }

        public bool Filter(string term)
        {
            if (string.IsNullOrWhiteSpace(term)) { return true; }
            var index = CultureInfo.CurrentCulture.CompareInfo.IndexOf(DisplayName, term,
                CompareOptions.IgnoreCase);
            if (index >= 0) { return true; }
            index = CultureInfo.CurrentCulture.CompareInfo.IndexOf(Description, term,
                CompareOptions.IgnoreCase);
            if (index >= 0) { return true; }
            index = CultureInfo.CurrentCulture.CompareInfo.IndexOf(ChannelCount.ToString(), term,
                CompareOptions.IgnoreCase);
            if (index >= 0) { return true; }
            index = CultureInfo.CurrentCulture.CompareInfo.IndexOf(LastModifiedBy, term,
                CompareOptions.IgnoreCase);
            if (index >= 0) { return true; }

            var testSetups = new List<string>();

            if (AssociatedTestSetups == null)
            {
                return true;
            }

            foreach (var assoc in AssociatedTestSetups) { testSetups.Add(assoc.Name); }
            var associatedTestSettups = string.Join(",", testSetups.ToArray());
            index = CultureInfo.CurrentCulture.CompareInfo.IndexOf(associatedTestSettups, term, CompareOptions.IgnoreCase);
            if (index >= 0) { return true; }

            var timeString = LastModified.ToString(CultureInfo.CurrentCulture);
            index = CultureInfo.CurrentCulture.CompareInfo.IndexOf(timeString, term,
                CompareOptions.IgnoreCase);
            return index >= 0;
        }

        public Group(bool bHardwareLoaded = false)
        {
            Embedded = false;
            LastModified = DateTime.Now;
            LastModifiedBy = "---";
            Name = "";
            DisplayName = "";
            Tags = "";
            IncludedHardwareStringList = new string[0];
            GroupChannelList = new List<DTS.Common.Interface.Channels.IGroupChannel>();
            _bHardwareLoaded = bHardwareLoaded;
            ExtraProperties = new List<KeyValuePair<string, string>>();
        }

        public Group(List<string> includedHardwareStringList)
        {
            Embedded = false;
            LastModified = DateTime.Now;
            LastModifiedBy = "---";
            Name = "";
            DisplayName = "";
            Tags = "";
            IncludedHardwareStringList = includedHardwareStringList.ToArray();
            GroupChannelList = new List<DTS.Common.Interface.Channels.IGroupChannel>();
            ExtraProperties = new List<KeyValuePair<string, string>>();
        }
        public Group(IDataReader reader)
        {
            InitializeGroup(reader);
        }
        public Group(IGroupDbRecord groupRecord)
        {
            InitializeGroup(groupRecord);
        }
        public Group(IDataReader reader, List<string> includedHardwareStringList, List<int> dasIdList)
        {
            InitializeGroup(reader);
            IncludedHardwareStringList = includedHardwareStringList.ToArray();
            SetIncludedHardware(dasIdList.ToArray());
        }
        public Group(IGroupDbRecord groupRecord, List<string> includedHardwareStringList, List<int> dasIdList)
        {
            InitializeGroup(groupRecord);
            IncludedHardwareStringList = includedHardwareStringList.ToArray();
            SetIncludedHardware(dasIdList.ToArray());
        }

        public static IGroup CreateGroupIfNeeded(ITestSetup testSetup, string groupName)
        {
            var group = CreateGroupIfNeededDontAdd(testSetup, groupName);
            if (!testSetup.Groups.Contains(group))
            {
                testSetup.Groups.Add(group);
            }
            return group;
        }
        private static IGroup CreateGroupIfNeededDontAdd(ITestSetup testSetup, string groupName)
        {
            //refactored to not use loop for one element only and filter the result 
            //https://rules.sonarsource.com/csharp/RSPEC-3267/
            var groups = testSetup.Groups.Where(x => groupName.Equals(x.DisplayName));
            if (groups.Any())
            {
                return groups.FirstOrDefault();
            }

            var newGroup = new Group(true);
            var displayOrder = 1;
            if (testSetup.Groups.Any())
            {
                displayOrder = 1 + testSetup.Groups.Max(g => g.DisplayOrder);
            }
            newGroup.DisplayOrder = displayOrder;
            newGroup.DisplayName = groupName;
            newGroup.Name = Guid.NewGuid().ToString();
            testSetup.ChannelsForGroup[newGroup] = new DTS.Common.Interface.Channels.IGroupChannel[0];

            return newGroup;
        }

        private void InitializeGroup(IDataReader reader)
        {
            Id = Convert.ToInt32(reader["Id"]);
            Name = (string)reader["SerialNumber"];
            DisplayName = (string)reader["DisplayName"];
            Embedded = Convert.ToBoolean(reader["Embedded"]);
            LastModified = Convert.ToDateTime(reader["LastModified"]);
            LastModifiedBy = (string)reader["LastModifiedBy"];
            if (reader["StaticGroupId"] == DBNull.Value)
            {
                StaticGroupId = null;
            }
            else
            {
                StaticGroupId = Convert.ToInt32(reader["StaticGroupId"]);
            }
            Description = (string)reader["Description"];
            ExtraProperties = new List<KeyValuePair<string, string>>();
            try
            {
                var sExtraProperties = Utility.GetString(reader, "ExtraProperties");
                ExtraProperties = JsonConvert.DeserializeObject<List<KeyValuePair<string, string>>>(sExtraProperties);
                if (ExtraProperties == null)
                {
                    ExtraProperties = new List<KeyValuePair<string, string>>();
                }
            }
            catch (Exception ex)
            {
                APILogger.Log(ex);
            }
            var tagIdList = GetTagIdList(Id, TagType, DbOperations.TagAssignmentsGet);
            TagIDs = tagIdList.ToArray();
            Tags = GetTagsAsCommaSeparatedString(DbOperations.TagsGet);
            GroupChannelList = new List<DTS.Common.Interface.Channels.IGroupChannel>();
        }

        private void InitializeGroup(IGroupDbRecord groupRecord)
        {
            Id = groupRecord.Id;
            Name = groupRecord.SerialNumber;
            DisplayName = groupRecord.DisplayName;
            Embedded = groupRecord.Embedded;
            LastModified = groupRecord.LastModified;
            LastModifiedBy = groupRecord.LastModifiedBy;
            StaticGroupId = groupRecord.StaticGroupId;
            Description = groupRecord.Description;
            ExtraProperties = new List<KeyValuePair<string, string>>();
            try
            {
                ExtraProperties = JsonConvert.DeserializeObject<List<KeyValuePair<string, string>>>(groupRecord.ExtraProperties);
                if (ExtraProperties == null)
                {
                    ExtraProperties = new List<KeyValuePair<string, string>>();
                }
            }
            catch (Exception ex)
            {
                APILogger.Log(ex);
            }
            var tagIdList = GetTagIdList(Id, TagType, DbOperations.TagAssignmentsGet);
            TagIDs = tagIdList.ToArray();
            Tags = GetTagsAsCommaSeparatedString(DbOperations.TagsGet);
            GroupChannelList = new List<DTS.Common.Interface.Channels.IGroupChannel>();
        }

        public void SetTestSetupLists()
        {
            var testSetupsList = new List<TestSetupParentHelper>();
            GetTestSetupsUsingThisGroup(ref testSetupsList);
            AssociatedTestSetups = testSetupsList.OrderBy(tsh => tsh.Name).OrderByDescending(tsh => tsh.Modified).ToList();
        }
        public bool StaticGroupIsEqual()
        {
            var embeddedGroupHelper = new GroupHelper();
            var staticGroupHelper = new GroupHelper();
            //Set Embedded Group Id
            embeddedGroupHelper.Id = Id;
            GetStaticGroupHelper(StaticGroupId, ref staticGroupHelper);

            if (staticGroupHelper.Id == 0) return true;
            if (GroupsEqual(staticGroupHelper, embeddedGroupHelper))
            {
                return true;
            }
            return false;
        }

        private void GetEmbeddedGroupHelpers(int? staticGroupId, ref List<GroupHelper> embeddedGroupHelpers, ref Dictionary<int, TestSetupParentHelper> lookup)
        {
            //Get Ids of all embedded Groups with this StaticGroupId
            if (staticGroupId == null) return;
            using (var embeddedGroupsCmd = DbOperations.GetSQLCommand(true))
            {
                try
                {
                    embeddedGroupsCmd.CommandType = CommandType.StoredProcedure;
                    embeddedGroupsCmd.CommandText = @"sp_GroupsAndTestGet";

                    embeddedGroupsCmd.Parameters.Add(new SqlParameter("@StaticGroupId", SqlDbType.Int) { Value = staticGroupId });

                    var reader = embeddedGroupsCmd.ExecuteReader();
                    while (reader.Read())
                    {
                        var embeddedGroupHelper = new GroupHelper { Id = Convert.ToInt32(reader["Id"]) };
                        var otestId = reader["TestSetupId"];
                        if (!DBNull.Value.Equals(otestId))
                        {
                            var testSetupId = Convert.ToInt32(otestId);
                            var name = (string)reader["TestSetupName"];
                            var helper = new TestSetupParentHelper() { Id = testSetupId, Name = name };
                            lookup[embeddedGroupHelper.Id] = helper;
                        }
                        embeddedGroupHelpers.Add(embeddedGroupHelper);
                    }
                }
                finally
                {
                    embeddedGroupsCmd.Connection.Dispose();
                }
            }
        }
        private void GetStaticGroupHelper(int? staticGroupId, ref GroupHelper staticGroupHelper)
        {
            //Get Static Group Id from database
            if (staticGroupId == null) return;
            var hResult = DbOperations.GroupsGet(staticGroupId, null, null, null, null, out var dbGroups);
            if (0 == hResult && null != dbGroups && dbGroups.Any())
            {
                foreach (var groupRecord in dbGroups) //shouldn't be a loop
                {
                    staticGroupHelper.Id = (int)staticGroupId;
                    staticGroupHelper.DisplayName = groupRecord.DisplayName;
                    staticGroupHelper.Description = groupRecord.Description;
                }
            }
        }

        private class GroupHelper
        {
            public int Id;
            public string DisplayName;
            public string Description;
        }

        private void GetTestSetupsUsingThisGroup(ref List<TestSetupParentHelper> testSetupsList)
        {
            //Get Ids of all Groups (embedded and one static) with this DisplayName
            var embeddedGroupHelpers = new List<GroupHelper>();
            var staticGroupHelper = new GroupHelper();
            GetStaticGroupHelper(Id, ref staticGroupHelper);
            var lookup = new Dictionary<int, TestSetupParentHelper>();
            GetEmbeddedGroupHelpers(Id, ref embeddedGroupHelpers, ref lookup);

            //Make a list of which embedded Groups differ from the static Group, and a list of which embedded Groups are the same as the static Group
            foreach (var embeddedGroupHelper in embeddedGroupHelpers)
            {
                if (!lookup.ContainsKey(embeddedGroupHelper.Id)) { continue; }
                var tsh = lookup[embeddedGroupHelper.Id]; //GetTestSetupHelperFromEmbeddedGroupId(embeddedGroupHelper.Id);
                tsh.Modified = !GroupsEqual(staticGroupHelper, embeddedGroupHelper);
                if (!string.IsNullOrWhiteSpace(tsh.Name))
                {
                    testSetupsList.Add(tsh);
                }
            }
        }

        private bool GroupsEqual(GroupHelper staticGroupHelper, GroupHelper embeddedGroupHelper)
        {
            SqlParameter result;
            result = new SqlParameter("@Result", SqlDbType.Bit) { Direction = ParameterDirection.Output };
            using (var compareGroupsCmd = DbOperations.GetSQLCommand(true))
            {
                try
                {
                    compareGroupsCmd.CommandType = CommandType.StoredProcedure;
                    compareGroupsCmd.CommandText = @"sp_CompareGroups";

                    compareGroupsCmd.Parameters.Add(new SqlParameter("@StaticDisplayName", SqlDbType.NVarChar, 255) { Value = staticGroupHelper.DisplayName });
                    compareGroupsCmd.Parameters.Add(new SqlParameter("@StaticDescription", SqlDbType.NVarChar, 255) { Value = staticGroupHelper.Description });
                    compareGroupsCmd.Parameters.Add(new SqlParameter("@StaticGroupId", SqlDbType.Int) { Value = staticGroupHelper.Id });
                    compareGroupsCmd.Parameters.Add(new SqlParameter("@EmbeddedGroupId", SqlDbType.Int) { Value = embeddedGroupHelper.Id });
                    result = new SqlParameter("@Result", SqlDbType.Bit) { Direction = ParameterDirection.Output };
                    compareGroupsCmd.Parameters.Add(result);

                    compareGroupsCmd.ExecuteNonQuery();
                }
                catch (Exception ex)
                {
                    var temp = ex.Message;
                    result.Value = false;
                }
                finally
                {
                    compareGroupsCmd.Connection.Dispose();
                }
            }
            return (result.Value != null) && (bool)result.Value;
        }

        private int[] GetExistingHardware()
        {
            if (Id < 0) { return new int[0]; }
            var hResult = DbOperations.GroupHardwareGet(Id, null, null, out GroupHardwareDbRecord[] groupHardwareDbRecords);
            var ids = new List<int>();
            if (0 == hResult && null != groupHardwareDbRecords && groupHardwareDbRecords.Any())
            {
                foreach (var groupHardwareDbRecord in groupHardwareDbRecords)
                {
                    var dasId = groupHardwareDbRecord.DASId;
                    ids.Add(dasId);
                }
            }
            return ids.ToArray();
        }

        private int[] GetExistingHardware(out List<string> includedHardwareStringList)
        {
            includedHardwareStringList = new List<string>();
            if (Id < 0)
            {
                return new int[0];
            }
            var hResult = DbOperations.GroupHardwareGet(Id, null, null, out GroupHardwareDbRecord[] groupHardwareDbRecords);
            var ids = new List<int>();
            if (0 == hResult && null != groupHardwareDbRecords && groupHardwareDbRecords.Any())
            {
                foreach (var groupHardwareDbRecord in groupHardwareDbRecords)
                {
                    var dasId = groupHardwareDbRecord.DASId;
                    ids.Add(dasId);
                    includedHardwareStringList.Add(groupHardwareDbRecord.SerialNumber);
                }
            }
            return ids.ToArray();
        }
        public void LoadHardware()
        {
            var includedHardwareStringList = new List<string>();
            _bHardwareLoaded = true;
            IncludedHardware = GetExistingHardware(out includedHardwareStringList);
            IncludedHardwareStringList = includedHardwareStringList.ToArray();
        }

        public static void Delete(int id)
        {
            var errorNumber = DbOperations.GroupsDelete(id, out string errorMessage);
            if (errorNumber != 0)
            {
                throw new Exception(errorMessage);
            }
        }
        public static IGroup[] GetAllGroups(int? id = null)
        {
            var groups = new List<IGroup>();
            var hResult = DbOperations.GroupsGet(id, null, null, false, null, out var dbGroups);
            if (0 == hResult && null != dbGroups && dbGroups.Any())
            {
                foreach (var groupRecord in dbGroups) //shouldn't be a loop
                {
                    groups.Add(new Group(groupRecord));
                }
            }

            var lookup = GetUniqueChannelIdCountPerGroupLookup();
            foreach (var g in groups)
            {
                if (lookup.ContainsKey(g.Id))
                {
                    g.ChannelCount = lookup[g.Id];
                }
            }
            return groups.ToArray();
        }

        private static IReadOnlyDictionary<int, int> GetUniqueChannelIdCountPerGroupLookup()
        {
            var lookup = new Dictionary<int, int>();
            var hr = DbOperations.ChannelsGet(null, null, null, null, null, null, out var channels);
            if (0 == hr)
            {
                foreach (var channel in channels)
                {
                    if (!lookup.ContainsKey(channel.GroupId))
                    {
                        lookup[channel.GroupId] = 0;
                    }
                    lookup[channel.GroupId] = 1 + lookup[channel.GroupId];
                }
            }
            return lookup;
        }
        public static IGroup[] GetAllGroups(string displayName)
        {
            var groups = new List<IGroup>();
            var hResult = DbOperations.GroupsGet(null, null, displayName, false, null, out var dbGroups);
            if (0 == hResult && null != dbGroups && dbGroups.Any())
            {
                foreach (var groupRecord in dbGroups) //shouldn't be a loop
                {
                    groups.Add(new Group(groupRecord));
                }
            }
            return groups.ToArray();
        }

        public static IGroup[] GetAllRelatedEmbeddedGroups(int staticGroupId)
        {
            var groups = new List<IGroup>();
            var hResult = DbOperations.GroupsGet(null, null, null, false, staticGroupId, out var dbGroups);
            if (0 == hResult && null != dbGroups && dbGroups.Any())
            {
                foreach (var groupRecord in dbGroups) //shouldn't be a loop
                {
                    groups.Add(new Group(groupRecord));
                }
            }
            return groups.ToArray();
        }

        public static void SetNullStaticGroupId(IGroup embeddedGroup)
        {
            var group = embeddedGroup.GetIGroupDbRecord();
            _ = DbOperations.GroupsUpdate(group);
        }
        public IGroupDbRecord GetIGroupDbRecord()
        {
            return new GroupDbRecord(this, ExtraProperties);
        }
        private void SaveGroup()
        {
            if (!Embedded) //FB14600: Always overwrite Name/serialNumber with the DisplayName on static group saves. Embedded groups use guids for SN.
            {
                Name = DisplayName;
            }
            var group = GetIGroupDbRecord();
            if (Id >= 0)
            {
                _ = DbOperations.GroupsUpdate(group);
            }
            else
            {
                _ = DbOperations.GroupsInsert(ref group);
                Id = group.Id;
            }
            InsertTagsFromCommaSeparatedString(Id, TagType, Tags, DbOperations.GetSQLCommand, DbOperations.TagsGet,
                DbOperations.TagsGetId, DbOperations.TagsInsert, DbOperations.TagAssignmentsDelete, DbOperations.TagAssignmentsInsert);
        }

        public void ConvertToEmbedded(DTS.Common.Interface.Channels.IGroupChannel[] groupChannels)
        {
            if (Embedded)
            {
                return;
            }

            if (Id == -1)
            {
                StaticGroupId = null;
            }
            else
            {
                StaticGroupId = Id; // Store the Id of the static Group that we are now an embedded copy of
                Id = -1;
            }
            Name = Guid.NewGuid().ToString();
            Embedded = true;
            foreach (var channel in groupChannels)
            {
                channel.Id = -1;
            }
        }

        public void DeterminePositionAndTestObject(DTS.Common.Interface.Channels.IGroupChannel[] channels)
        {
            var testObject = string.Empty;
            var position = string.Empty;

            bool testObjectMixed = false;
            bool positionMixed = false;
            foreach (var ch in channels)
            {
                if (ch.IsBlank()) { continue; }
                //33051 UARTs, Stream Outs, and Stream Ins do not have ISOCodes, so don't include them when 
                //determining whether a Group contains channels for multiple Test Objects or multiple Positions ("Mixed")
                if (string.IsNullOrEmpty(ch.IsoCode) && (ch.IsUart || ch.IsStreamOut || ch.IsStreamIn))
                {
                    continue;
                }
                var isocode = new DTS.Common.ISO.IsoCode(ch.IsoCode);
                var chTestObject = isocode.TestObject;
                if (string.IsNullOrEmpty(ch.IsoCode))
                {
                    chTestObject = "";
                }
                if (string.IsNullOrEmpty(testObject))
                {
                    testObject = chTestObject;
                }
                else
                {
                    if (testObject != chTestObject)
                    {
                        testObjectMixed = true;
                    }
                }
                var chPosition = isocode.Position;
                if (string.IsNullOrEmpty(ch.IsoCode) || ch.IsoCode.Length < 2)
                {
                    chPosition = "";
                }
                if (string.IsNullOrEmpty(position))
                {
                    position = chPosition;
                }
                else
                {
                    if (position != chPosition)
                    {
                        positionMixed = true;
                    }
                }
            }
            PositionIsMixed = positionMixed;
            if (positionMixed)
            {
                Position = "";
            }
            else
            {
                if (!string.Empty.Equals(position))
                {
                    Position = position;
                }
                else
                {
                    if (ExtraProperties.Exists(p => p.Key == "POSITION"))
                    {
                        var match = ExtraProperties.Find(p => p.Key == "POSITION");
                        Position = match.Value;
                    }
                }
            }

            if (testObjectMixed)
            {
                TestObject = "";
            }
            else
            {
                if (!string.Empty.Equals(testObject))
                {
                    TestObject = testObject;
                }
                else
                {
                    if (ExtraProperties.Exists(p => p.Key == "TESTOBJECT"))
                    {
                        var match = ExtraProperties.Find(p => p.Key == "TESTOBJECT");
                        TestObject = match.Value;
                    }
                }
            }

            TestObjectIsMixed = testObjectMixed;
        }

        private bool _positionIsMixed = false;

        public bool PositionIsMixed
        {
            get => _positionIsMixed;
            set
            {
                SetProperty(ref _positionIsMixed, value, "PositionIsMixed");

                OnPropertyChanged("PositionIsTextbox");
                OnPropertyChanged("PositionIsCombobox");
            }
        }

        private bool _positionIsTextbox = false;
        public bool PositionIsTextbox
        {
            get
            {
                if (!DFConstantsAndEnums.UseDropDownForTestObjectAndPosition) { return true; }
                return _positionIsMixed ? false : _positionIsTextbox;
            }
            set => SetProperty(ref _positionIsTextbox, value, "PositionIsTextbox");
        }
        public bool PositionIsCombobox
        {
            get
            {
                if (!DFConstantsAndEnums.UseDropDownForTestObjectAndPosition) { return false; }
                return _positionIsMixed ? false : !_positionIsTextbox;
            }
            set => SetProperty(ref _positionIsTextbox, !value, "PositionIsCombobox");
        }

        private string _position = "?";

        public string Position
        {
            get => _position;
            set
            {
                SetProperty(ref _position, value, "Position");
                if (ExtraProperties.Exists(x => x.Key == "POSITION"))
                {
                    var match = ExtraProperties.First(x => x.Key == "POSITION");
                    ExtraProperties.Remove(match);
                }
                ExtraProperties.Add(new KeyValuePair<string, string>("POSITION", value));
            }
        }
        private List<string> _availablePositions = new List<string>();
        public List<string> AvailablePositions
        {
            get { return _availablePositions; }
            set => SetProperty(ref _availablePositions, value, "AvailablePositions");
        }

        private string _selectedPositionItem;
        public string SelectedPositionItem
        {
            get
            {
                _selectedPositionItem = _availablePositions.Where(x => x.StartsWith(Position)).FirstOrDefault();
                return _selectedPositionItem;
            }
            set
            {
                Position = value.Substring(0, 1);
                SetProperty(ref _selectedPositionItem, value, "SelectedPositionItem");
            }
        }
        private bool _testObjectIsMixed = false;

        public bool TestObjectIsMixed
        {
            get => _testObjectIsMixed;
            set
            {
                SetProperty(ref _testObjectIsMixed, value, "TestObjectIsMixed");

                OnPropertyChanged("TestObjectIsTextbox");
                OnPropertyChanged("TestObjectIsCombobox");
            }
        }
        private bool _testObjectIsTextbox = false;
        public bool TestObjectIsTextbox
        {
            get
            {
                if (!DFConstantsAndEnums.UseDropDownForTestObjectAndPosition) { return true; }
                return _testObjectIsMixed ? false : _testObjectIsTextbox;
            }
            set => SetProperty(ref _testObjectIsTextbox, value, "TestObjectIsTextbox");
        }
        public bool TestObjectIsCombobox
        {
            get
            {
                if (!DFConstantsAndEnums.UseDropDownForTestObjectAndPosition) { return false; }
                return _testObjectIsMixed ? false : !_testObjectIsTextbox;
            }
            set => SetProperty(ref _testObjectIsTextbox, !value, "TestObjectIsCombobox");
        }
        private List<string> _availableTestObjects = new List<string>();
        public List<string> AvailableTestObjects
        {
            get { return _availableTestObjects; }
            set => SetProperty(ref _availableTestObjects, value, "AvailableTestObjects");
        }

        private string _selectedTestObjectItem;
        public string SelectedTestObjectItem
        {
            get
            {
                _selectedTestObjectItem = _availableTestObjects.Where(x => x.StartsWith(TestObject)).FirstOrDefault();
                return _selectedTestObjectItem;
            }
            set
            {
                TestObject = value.Substring(0, 1);
                SetProperty(ref _selectedTestObjectItem, value, "SelectedTestObjectItem");
            }
        }

        private string _testObject = "?";

        public string TestObject
        {
            get => _testObject;
            set
            {
                SetProperty(ref _testObject, value, "TestObject");
                if (ExtraProperties.Exists(x => x.Key == "TESTOBJECT"))
                {
                    var match = ExtraProperties.First(x => x.Key == "TESTOBJECT");
                    ExtraProperties.Remove(match);
                }
                ExtraProperties.Add(new KeyValuePair<string, string>("TESTOBJECT", value));
            }
        }

        private int _displayOrder = -1;

        public static long[] GetExistingChannelIds(int Id)
        {
            var list = new List<long>();
            var hResult = DbOperations.ChannelsGet(null, Id, null, null, null, null, out var dbChannels);
            if (0 == hResult && null != dbChannels && dbChannels.Any())
            {
                foreach (var channel in dbChannels)
                {
                    var id = Convert.ToInt64(channel.Id);
                    if (!list.Contains(id))
                    {
                        list.Add(id);
                    }
                }
            }

            return list.ToArray();
        }

        public int DisplayOrder
        {
            get => _displayOrder;
            set => SetProperty(ref _displayOrder, value, "DisplayOrder");
        }

        public ISensorData GetSensor(DTS.Common.Interface.Channels.IGroupChannel channel, ISensorData sensorData, bool bUseISOFilter)
        {

            if (null == channel.ChannelSettings || !channel.ChannelSettings.Any())
            {
                return sensorData;
            }
            if (null == sensorData) { return null; }
            if (sensorData.IsSquib())
            {
                return GetSensorSquib(channel, sensorData);
            }

            if (sensorData.IsDigitalInput())
            {
                return GetSensorDigitalIn(channel, sensorData);
            }

            if (sensorData.IsDigitalOutput())
            {
                return GetSensorDigitalOut(channel, sensorData);
            }

            if (sensorData.IsUart())
            {
                return GetSensorUart(channel, sensorData);
            }

            if (sensorData.IsStreamOutput())
            {
                return GetSensorStreamOut(channel, sensorData);
            }

            if (sensorData.IsStreamInput())
            {
                return GetSensorStreamIn(channel, sensorData);
            }

            if (sensorData.IsCan())
            {
                return GetSensorCan(channel, sensorData);
            }

            if (sensorData.IsTestSpecificEmbedded) 
            {
                sensorData = GetSensorEmbeddedAnalog(channel, sensorData);
            }
            else if (sensorData.IsTestSpecificThermo)
            {
                sensorData = GetSensorEmbeddedThermo(channel, sensorData);
            }
            else
            {
                sensorData = GetSensorAnalog(channel, sensorData);
            }

            if (bUseISOFilter)
            {
                var isoCode = new DTS.Common.ISO.IsoCode(channel.IsoCode);
                sensorData.FilterClassIso = isoCode.FilterClass;
            }
            return sensorData;
        }

        private static ISensorData GetSensorSquib(DTS.Common.Interface.Channels.IGroupChannel channel, ISensorData sensorData)
        {
            foreach (var setting in channel.ChannelSettings)
            {
                switch (setting.SettingName)
                {
                    case ChannelSettingBase.SQMODE: sensorData.SquibFireMode = (DTS.Common.Enums.SquibFireMode)setting.IntValue; break;
                    case ChannelSettingBase.SQUIB_DELAY: sensorData.SquibFireDelayMS = setting.DoubleValue; break;
                    case ChannelSettingBase.SQUIB_CURRENT: sensorData.SquibOutputCurrent = setting.DoubleValue; break;
                    case ChannelSettingBase.SQUIB_DURATION: sensorData.SquibFireDurationMS = setting.DoubleValue; break;
                    case ChannelSettingBase.SQUIB_LIMIT_DURATION: sensorData.LimitSquibFireDuration = setting.BoolValue; break;
                }
            }
            return sensorData;
        }

        private ISensorData GetSensorDigitalIn(DTS.Common.Interface.Channels.IGroupChannel channel, ISensorData sensorData)
        {
            //DIMode, defaultValue,ActiveValue
            foreach (var setting in channel.ChannelSettings)
            {
                switch (setting.SettingName)
                {
                    case ChannelSettingBase.DIMODE:
                        sensorData.InputMode = (DTS.Common.Enums.DigitalInputModes)setting.IntValue;
                        break;
                    case ChannelSettingBase.DEFAULT_VALUE:
                        sensorData.InputDefaultValue = setting.DoubleValue;
                        break;
                    case ChannelSettingBase.ACTIVE_VALUE:
                        sensorData.InputActiveValue = setting.DoubleValue;
                        break;
                }
            }
            return sensorData;
        }

        private ISensorData GetSensorDigitalOut(DTS.Common.Interface.Channels.IGroupChannel channel, ISensorData sensorData)
        {
            //OutputMode
            foreach (var setting in channel.ChannelSettings)
            {
                switch (setting.SettingName)
                {
                    case ChannelSettingBase.OUTPUT_MODE:
                        sensorData.DigitalOutputMode = (DTS.Common.Enums.DigitalOutputModes)setting.IntValue;
                        break;
                    case ChannelSettingBase.DIGITALOUT_LIMIT_DURATION:
                        sensorData.DigitalOutputLimitDuration = setting.BoolValue;
                        break;
                    case ChannelSettingBase.DIGITALOUT_DURATION:
                        sensorData.DigitalOutputDurationMS = setting.DoubleValue;
                        break;
                    case ChannelSettingBase.DIGITALOUT_DELAY:
                        sensorData.DigitalOutputDelayMS = setting.DoubleValue;
                        break;
                }
            }
            return sensorData;
        }
        private ISensorData GetSensorUart(DTS.Common.Interface.Channels.IGroupChannel channel, ISensorData sensorData)
        {
            //Uart
            foreach (var setting in channel.ChannelSettings)
            {
                try
                {
                    switch (setting.SettingName)
                    {
                        case ChannelSettingBase.BAUD_RATE:
                            sensorData.UartBaudRate = (uint)setting.IntValue;
                            break;
                        case ChannelSettingBase.DATA_BITS:
                            sensorData.UartDataBits = (uint)setting.IntValue;
                            break;
                        case ChannelSettingBase.STOP_BITS:
                            sensorData.UartStopBits = (StopBits)Enum.Parse(typeof(StopBits), setting.Value);
                            break;
                        case ChannelSettingBase.PARITY:
                            sensorData.UartParity = (Parity)Enum.Parse(typeof(Parity), setting.Value);
                            break;
                        case ChannelSettingBase.FLOW_CONTROL:
                            //FB 30486 Hardcode FlowControl to NONE for UART sensor type
                            //It's always NONE
                            break;
                        case ChannelSettingBase.DATA_FORMAT:
                            sensorData.UartDataFormat = (DTS.Common.Enums.UartDataFormat)Enum.Parse(typeof(DTS.Common.Enums.UartDataFormat), setting.Value);
                            break;
                    }
                }
                catch (Exception ex)
                {
                    APILogger.Log($"Failed to process: {setting.SettingName} value: {setting.Value}", ex);
                }
            }
            return sensorData;
        }

        private ISensorData GetSensorStreamIn(DTS.Common.Interface.Channels.IGroupChannel channel, ISensorData sensorData)
        {
            //StreamInputMode
            foreach (var setting in channel.ChannelSettings)
            {
                try
                {
                    switch (setting.SettingName)
                    {
                        case ChannelSettingBase.UDP_ADDRESS_IN:
                            sensorData.StreamInUDPAddress = setting.Value;
                            break;
                    }
                }
                catch (Exception ex)
                {
                    APILogger.Log($"Failed to process: {setting.SettingName} value: {setting.Value}", ex);
                }
            }
            return sensorData;
        }
        private ISensorData GetSensorStreamOut(DTS.Common.Interface.Channels.IGroupChannel channel, ISensorData sensorData)
        {
            //StreamOutputMode
            foreach (var setting in channel.ChannelSettings)
            {
                try
                {
                    switch (setting.SettingName)
                    {
                        case ChannelSettingBase.UDP_PROFILE:
                            sensorData.StreamOutUDPProfile = (DTS.Common.Enums.UDPStreamProfile)Enum.Parse(typeof(DTS.Common.Enums.UDPStreamProfile), setting.Value);
                            break;
                        case ChannelSettingBase.UDP_ADDRESS:
                            sensorData.StreamOutUDPAddress = setting.Value;
                            break;
                        case ChannelSettingBase.UDP_TIME_CHID:
                            sensorData.StreamOutUDPTimeChannelId = (ushort)setting.IntValue;
                            break;
                        case ChannelSettingBase.UDP_DATA_CHID:
                            sensorData.StreamOutUDPDataChannelId = (ushort)setting.IntValue;
                            break;
                        case ChannelSettingBase.UDP_TMNS_CONFIG:
                            sensorData.StreamOutUDPTmNSConfig = setting.Value;
                            break;
                        case ChannelSettingBase.IRIG_TDP_INTERVAL_MS:
                            sensorData.StreamOutIRIGTimeDataPacketIntervalMs = (ushort)setting.IntValue;
                            break;
                    }
                }
                catch (Exception ex)
                {
                    APILogger.Log($"Failed to process: {setting.SettingName} value: {setting.Value}", ex);
                }
            }
            return sensorData;
        }

        private static ISensorData GetSensorCan(DTS.Common.Interface.Channels.IGroupChannel channel, ISensorData sensorData)
        {
            //CAN
            foreach (var setting in channel.ChannelSettings)
            {
                try
                {
                    switch (setting.SettingName)
                    {
                        case ChannelSettingBase.CAN_IS_FD:
                            sensorData.CanIsFD = setting.BoolValue;
                            break;
                        case ChannelSettingBase.CAN_ARB_BASE_BITRATE:
                            sensorData.CanArbBaseBitrate = setting.IntValue;
                            break;
                        case ChannelSettingBase.CAN_ARB_BASE_SJW:
                            sensorData.CanArbBaseSJW = setting.IntValue;
                            break;
                        case ChannelSettingBase.CAN_DATA_BITRATE:
                            sensorData.CanDataBitrate = setting.IntValue;
                            break;
                        case ChannelSettingBase.CAN_DATA_SJW:
                            sensorData.CanDataSJW = setting.IntValue;
                            break;
                        case ChannelSettingBase.CAN_FILE_TYPE:
                            sensorData.CanFileType = setting.ToString();
                            break;
                    }
                }
                catch (Exception ex)
                {
                    APILogger.Log($"Failed to process: {setting.SettingName} value: {setting.Value}", ex);
                }
            }
            return sensorData;
        }

        private ISensorData GetSensorAnalog(DTS.Common.Interface.Channels.IGroupChannel channel, ISensorData sensorData)
        {
            //Range,CFC,Polarity
            foreach (var setting in channel.ChannelSettings)
            {
                switch (setting.SettingName)
                {
                    case ChannelSettingBase.RANGE: sensorData.Capacity = setting.DoubleValue; break;
                    case ChannelSettingBase.CFC: sensorData.FilterClassIso = setting.Value; break;
                    //FB 13120 parse and set the filter class from setting
                    case ChannelSettingBase.FilterClass:
                        if (null == setting.Value)
                        {
                            setting.Value = setting.DefaultValue;
                        }

                        string[] settings = setting.Value.Split(',');

                        if (Enum.TryParse(settings[0], out FilterClassType filterClassType))
                        {
                            if (filterClassType == FilterClassType.AdHoc)
                            {
                                sensorData.FilterClass = new FilterClass(Convert.ToDouble(settings[1]));
                            }
                            else
                            {
                                sensorData.FilterClass = new FilterClass(filterClassType);
                            }
                        }
                        break;
                    case ChannelSettingBase.POLARITY: sensorData.Polarity = setting.Value; break;
                    case ChannelSettingBase.USERVALUE1: sensorData.UserValue1 = setting.Value; break;
                    case ChannelSettingBase.USERVALUE2: sensorData.UserValue2 = setting.Value; break;
                    case ChannelSettingBase.USERVALUE3: sensorData.UserValue3 = setting.Value; break;
                    case ChannelSettingBase.INITIAL_OFFSET:
                        {
                            sensorData.InitialOffset = new InitialOffset(setting.Value);
                        }
                        break;
                }
            }
            return sensorData;
        }
        private static ISensorData GetSensorEmbeddedThermo(DTS.Common.Interface.Channels.IGroupChannel channel, ISensorData sensorData)
        {
            sensorData.FilterClass = FilterClass.GetFilterClassFromFilterClassType(FilterClassType.Unfiltered);
           
            var units = "C";           

            sensorData.Calibration.Records.Records[0].EngineeringUnits = units;
            return sensorData;
        }
        private ISensorData GetSensorEmbeddedAnalog(DTS.Common.Interface.Channels.IGroupChannel channel, ISensorData sensorData)
        {
            //Range,CFC,Polarity
            foreach (var setting in channel.ChannelSettings)
            {
                switch (setting.SettingName)
                {
                    case ChannelSettingBase.RANGE: sensorData.Capacity = setting.DoubleValue; break;
                    case ChannelSettingBase.CFC: sensorData.FilterClassIso = setting.Value; break;
                    //FB 13120 parse and set the filter class from setting
                    case ChannelSettingBase.FilterClass:
                        if (null == setting.Value)
                        {
                            setting.Value = setting.DefaultValue;
                        }

                        string[] settings = setting.Value.Split(',');

                        if (Enum.TryParse(settings[0], out FilterClassType filterClassType))
                        {
                            if (filterClassType == FilterClassType.AdHoc)
                            {
                                sensorData.FilterClass = new FilterClass(Convert.ToDouble(settings[1]));
                            }
                            else
                            {
                                sensorData.FilterClass = new FilterClass(filterClassType);
                            }
                        }
                        break;
                    case ChannelSettingBase.ACCouplingEnabled: ((SensorData)sensorData).ACCouplingModeEnabled = setting.BoolValue; break;
                    case ChannelSettingBase.POLARITY: sensorData.Polarity = setting.Value; break;
                    case ChannelSettingBase.USERVALUE1: sensorData.UserValue1 = setting.Value; break;
                    case ChannelSettingBase.USERVALUE2: sensorData.UserValue2 = setting.Value; break;
                    case ChannelSettingBase.USERVALUE3: sensorData.UserValue3 = setting.Value; break;
                    case ChannelSettingBase.INITIAL_OFFSET:
                        {
                            sensorData.InitialOffset = new InitialOffset(setting.Value);
                        }
                        break;
                }
            }
            //TODO: REMOVE THIS HACK when we have proper get cal functions
            var units = "g";

            //http://manuscript.dts.local/f/cases/29719/change-bme-pressure-dimension-to-PSI-and-bmi-angular-rate-dimension-to-degrees-per-second
            if (channel.Sensor.Contains("Angular Rate")) units = "deg/s";
            if (channel.Sensor.Contains("Pressure")) units = "PSI";

            if (channel.Sensor.Contains("Temperature")) units = "C";
            if (channel.Sensor.Contains("Humidity")) units = "% RH";

            if (null != channel.HardwareChannel && !channel.HardwareChannel.IsTSRAIR)
            {
                units = "mV";
                sensorData.Calibration.RemoveOffset = false;
                sensorData.Calibration.ZeroMethods = new ZeroMethods(new[] { new ZeroMethod(ZeroMethodType.None, -.05, .05), new ZeroMethod(ZeroMethodType.UsePreEventDiagnosticsZero, -.05, .05), new ZeroMethod(ZeroMethodType.AverageOverTime, -.05, .05) });
                //this is another way of turning off shunt (-1 resistance)
                sensorData.BridgeResistance = -1;
            }

            sensorData.Calibration.Records.Records[0].EngineeringUnits = units;
            return sensorData;
        }
        private void SetSensorSquib(DTS.Common.Interface.Channels.IGroupChannel channel, ISensorData sensorData)
        {
            //limitduration,duration,delay,sqmode
            var dictionary = DbOperations.GetSettingsLookup();
            var settings = new List<IChannelSetting>();
            var limitDurationTuple = dictionary[ChannelSettingBase.SQUIB_LIMIT_DURATION];
            settings.Add(
                new ChannelSettingBase(limitDurationTuple.Item1, limitDurationTuple.Item2, limitDurationTuple.Item3)
                { BoolValue = sensorData.LimitSquibFireDuration });

            var durationTuple = dictionary[ChannelSettingBase.SQUIB_DURATION];
            settings.Add(new ChannelSettingBase(durationTuple.Item1, durationTuple.Item2, durationTuple.Item3)
            { DoubleValue = sensorData.SquibFireDurationMS });

            var delayTuple = dictionary[ChannelSettingBase.SQUIB_DELAY];
            settings.Add(new ChannelSettingBase(delayTuple.Item1, delayTuple.Item2, delayTuple.Item3)
            { DoubleValue = sensorData.SquibFireDelayMS });

            var currentTuple = dictionary[ChannelSettingBase.SQUIB_CURRENT];
            settings.Add(new ChannelSettingBase(currentTuple.Item1, currentTuple.Item2, currentTuple.Item3)
            { DoubleValue = sensorData.SquibOutputCurrent });

            var sqModeTuple = dictionary[ChannelSettingBase.SQMODE];
            settings.Add(new ChannelSettingBase(sqModeTuple.Item1, sqModeTuple.Item2, sqModeTuple.Item3)
            { IntValue = (int)sensorData.SquibFireMode });

            channel.ChannelSettings = settings.ToArray();
        }

        private void SetSensorDigitalIn(DTS.Common.Interface.Channels.IGroupChannel channel, ISensorData sensorData)
        {
            //DIMode, defaultValue,ActiveValue
            var dictionary = DbOperations.GetSettingsLookup();
            var settings = new List<IChannelSetting>();

            var modeTuple = dictionary[ChannelSettingBase.DIMODE];
            settings.Add(new ChannelSettingBase(modeTuple.Item1, modeTuple.Item2, modeTuple.Item3)
            { IntValue = (int)sensorData.InputMode });

            var defaultValueTuple = dictionary[ChannelSettingBase.DEFAULT_VALUE];
            settings.Add(
                new ChannelSettingBase(defaultValueTuple.Item1, defaultValueTuple.Item2, defaultValueTuple.Item3)
                { DoubleValue = sensorData.InputDefaultValue });

            var activeValueTuple = dictionary[ChannelSettingBase.ACTIVE_VALUE];
            settings.Add(new ChannelSettingBase(activeValueTuple.Item1, activeValueTuple.Item2, activeValueTuple.Item3)
            { DoubleValue = sensorData.InputActiveValue });
            channel.ChannelSettings = settings.ToArray();
        }
        private void SetSensorDigitalOut(DTS.Common.Interface.Channels.IGroupChannel channel, ISensorData sensorData)
        {
            //OutputMode
            var dictionary = DbOperations.GetSettingsLookup();
            var settings = new List<IChannelSetting>();

            var tuple = dictionary[ChannelSettingBase.OUTPUT_MODE];

            settings.Add(new ChannelSettingBase(tuple.Item1, tuple.Item2, tuple.Item3)
            { IntValue = (int)sensorData.DigitalOutputMode });

            tuple = dictionary[ChannelSettingBase.DIGITALOUT_LIMIT_DURATION];
            settings.Add(new ChannelSettingBase(tuple.Item1, tuple.Item2, tuple.Item3)
            { BoolValue = sensorData.DigitalOutputLimitDuration });


            tuple = dictionary[ChannelSettingBase.DIGITALOUT_DURATION];
            settings.Add(new ChannelSettingBase(tuple.Item1, tuple.Item2, tuple.Item3)
            { DoubleValue = (double)sensorData.DigitalOutputDurationMS });

            tuple = dictionary[ChannelSettingBase.DIGITALOUT_DELAY];
            settings.Add(new ChannelSettingBase(tuple.Item1, tuple.Item2, tuple.Item3)
            { DoubleValue = (double)sensorData.DigitalOutputDelayMS });
            channel.ChannelSettings = settings.ToArray();
        }

        private void SetSensorUart(DTS.Common.Interface.Channels.IGroupChannel channel, ISensorData sensorData)
        {
            //uartBaudRate, uartDataBits,... etc
            var dictionary = DbOperations.GetSettingsLookup();
            var settings = new List<IChannelSetting>();

            var tupleBaudRate = dictionary[ChannelSettingBase.BAUD_RATE];
            settings.Add(new ChannelSettingBase(tupleBaudRate.Item1, tupleBaudRate.Item2, tupleBaudRate.Item3)
            { IntValue = Convert.ToInt32(sensorData.UartBaudRate) });

            var tupleDataBits = dictionary[ChannelSettingBase.DATA_BITS];
            settings.Add(new ChannelSettingBase(tupleDataBits.Item1, tupleDataBits.Item2, tupleDataBits.Item3)
            { IntValue = Convert.ToInt32(sensorData.UartDataBits) });

            var tupleStopBits = dictionary[ChannelSettingBase.STOP_BITS];
            settings.Add(new ChannelSettingBase(tupleStopBits.Item1, tupleStopBits.Item2, tupleStopBits.Item3)
            { Value = sensorData.UartStopBits.ToString() });

            var tupleParity = dictionary[ChannelSettingBase.PARITY];
            settings.Add(new ChannelSettingBase(tupleParity.Item1, tupleParity.Item2, tupleParity.Item3)
            { Value = sensorData.UartParity.ToString() });

            var tupleFlowControl = dictionary[ChannelSettingBase.FLOW_CONTROL];
            settings.Add(new ChannelSettingBase(tupleFlowControl.Item1, tupleFlowControl.Item2, tupleFlowControl.Item3)
            { Value = sensorData.UartFlowControl.ToString() });

            var tupleDataFormat = dictionary[ChannelSettingBase.DATA_FORMAT];
            settings.Add(new ChannelSettingBase(tupleDataFormat.Item1, tupleDataFormat.Item2, tupleDataFormat.Item3)
            { Value = sensorData.UartDataFormat.ToString() });

            channel.ChannelSettings = settings.ToArray();
        }
        private void SetSensorCan(DTS.Common.Interface.Channels.IGroupChannel channel, ISensorData sensorData)
        {
            var dictionary = DbOperations.GetSettingsLookup();
            var settings = new List<IChannelSetting>();

            var tupleIsFD = dictionary[ChannelSettingBase.CAN_IS_FD];
            settings.Add(new ChannelSettingBase(tupleIsFD.Item1, tupleIsFD.Item2, tupleIsFD.Item3)
            { BoolValue = Convert.ToBoolean(sensorData.CanIsFD) });

            var tupleArbBaseBitrate = dictionary[ChannelSettingBase.CAN_ARB_BASE_BITRATE];
            settings.Add(new ChannelSettingBase(tupleArbBaseBitrate.Item1, tupleArbBaseBitrate.Item2, tupleArbBaseBitrate.Item3)
            { IntValue = Convert.ToInt32(sensorData.CanArbBaseBitrate) });

            var tupleArbBaseSJW = dictionary[ChannelSettingBase.CAN_ARB_BASE_SJW];
            settings.Add(new ChannelSettingBase(tupleArbBaseSJW.Item1, tupleArbBaseSJW.Item2, tupleArbBaseSJW.Item3)
            { IntValue = Convert.ToInt32(sensorData.CanArbBaseSJW) });

            var tupleDataBitrate = dictionary[ChannelSettingBase.CAN_DATA_BITRATE];
            settings.Add(new ChannelSettingBase(tupleDataBitrate.Item1, tupleDataBitrate.Item2, tupleDataBitrate.Item3)
            { IntValue = Convert.ToInt32(sensorData.CanDataBitrate) });

            var tupleDataSJW = dictionary[ChannelSettingBase.CAN_DATA_SJW];
            settings.Add(new ChannelSettingBase(tupleDataSJW.Item1, tupleDataSJW.Item2, tupleDataSJW.Item3)
            { IntValue = Convert.ToInt32(sensorData.CanDataSJW) });

            var tupleFileType = dictionary[ChannelSettingBase.CAN_FILE_TYPE];
            settings.Add(new ChannelSettingBase(tupleFileType.Item1, tupleFileType.Item2, tupleFileType.Item3)
            { Value = sensorData.CanFileType.ToString() });

            channel.ChannelSettings = settings.ToArray();
        }
        private void SetSensorAnalog(DTS.Common.Interface.Channels.IGroupChannel channel, ISensorData sensorData)
        {
            //Range,CFC,Polarity
            var settings = new List<IChannelSetting>();
            var dictionary = DbOperations.GetSettingsLookup();

            var rangeTuple = dictionary[ChannelSettingBase.RANGE];
            settings.Add(new ChannelSettingBase(rangeTuple.Item1, rangeTuple.Item2, rangeTuple.Item3)
            { DoubleValue = sensorData.Capacity });
            var CFCTuple = dictionary[ChannelSettingBase.CFC];
            settings.Add(new ChannelSettingBase(CFCTuple.Item1, CFCTuple.Item2, CFCTuple.Item3)
            { Value = sensorData.FilterClassIso });
            //FB 13120 set filter class
            var FilterClassTuple = dictionary[ChannelSettingBase.FilterClass];
            settings.Add(new ChannelSettingBase(FilterClassTuple.Item1, FilterClassTuple.Item2, FilterClassTuple.Item3)
            { Value = $"{ sensorData?.FilterClass?.FClass},{ sensorData?.FilterClass?.Frequency}" });
            var polarityTuple = dictionary[ChannelSettingBase.POLARITY];
            settings.Add(new ChannelSettingBase(polarityTuple.Item1, polarityTuple.Item2, polarityTuple.Item3)
            { Value = sensorData.Polarity });
            channel.ChannelSettings = settings.ToArray();
        }
        public void SetSensor(DTS.Common.Interface.Channels.IGroupChannel channel, ISensorData sensorData)
        {
            if (sensorData.IsSquib())
            {
                SetSensorSquib(channel, sensorData);
            }
            else if (sensorData.IsDigitalInput())
            {
                SetSensorDigitalIn(channel, sensorData);
            }
            else if (sensorData.IsDigitalOutput())
            {
                SetSensorDigitalOut(channel, sensorData);
            }
            else if (sensorData.IsUart())
            {
                SetSensorUart(channel, sensorData);
            }
            else if (sensorData.IsCan())
            {
                SetSensorCan(channel, sensorData);
            }
            else SetSensorAnalog(channel, sensorData);
        }

        private List<DTS.Common.Interface.Channels.IGroupChannel> SaveChannels(DTS.Common.Interface.Channels.IGroupChannel[] groupChannels, bool canUserSaveChannelCodes)
        {
            var newGroupChannelList = new List<DTS.Common.Interface.Channels.IGroupChannel>();
            var args = new List<DTS.Common.Events.ChannelCodes.ChannelCodeCommittedEventArgs>();

            var idsToKeep = new HashSet<long>();
            var idsToDelete = new List<long>();
            foreach (var channel in groupChannels)
            {
                if (channel.Id < 0) { continue; }
                if (channel.IsBlank())
                {
                    continue;
                }
                idsToKeep.Add(channel.Id);
            }

            var existingIds = GetExistingChannelIds(Id);
            foreach (var id in existingIds)
            {
                if (!idsToKeep.Contains(id))
                {
                    idsToDelete.Add(id);
                }
            }

            if (idsToDelete.Any())
            {
                foreach (var id in idsToDelete)
                {
                    DeleteChannel(id);
                }
            }

            //step 2, update any existing channels
            foreach (var channel in groupChannels)
            {
                if (channel.Id < 0) { continue; }
                if (channel.IsBlank())
                {
                    continue;
                }
                UpdateChannel(channel);
                args.AddRange(new[]
                    {
                        new DTS.Common.Events.ChannelCodes.ChannelCodeCommittedEventArgs(DTS.Common.Enums.Channels.ChannelEnumsAndConstants.ChannelCodeType.ISO, channel.IsoCode, channel.IsoChannelName, canUserSaveChannelCodes),
                        new DTS.Common.Events.ChannelCodes.ChannelCodeCommittedEventArgs(DTS.Common.Enums.Channels.ChannelEnumsAndConstants.ChannelCodeType.User, channel.UserCode, channel.UserChannelName, canUserSaveChannelCodes)
                    }
                );
            }
            //step 3, add any new channels
            foreach (var channel in groupChannels)
            {
                if (channel.Id >= 0) { continue; }
                if (channel.IsBlank())
                {
                    continue;
                }
                InsertChannel(channel);
                newGroupChannelList.Add(channel);
                args.AddRange(new[]
                    {
                        new DTS.Common.Events.ChannelCodes.ChannelCodeCommittedEventArgs(DTS.Common.Enums.Channels.ChannelEnumsAndConstants.ChannelCodeType.ISO, channel.IsoCode, channel.IsoChannelName, canUserSaveChannelCodes),
                        new DTS.Common.Events.ChannelCodes.ChannelCodeCommittedEventArgs(DTS.Common.Enums.Channels.ChannelEnumsAndConstants.ChannelCodeType.User, channel.UserCode, channel.UserChannelName, canUserSaveChannelCodes)
                    }
                );
            }

            PublishCodes(args.ToArray());

            return newGroupChannelList;
        }
        private static object _vm = null;
        private void PublishCodes(DTS.Common.Events.ChannelCodes.ChannelCodeCommittedEventArgs[] args)
        {
            if (!Application.Current.Dispatcher.CheckAccess())
            {
                Application.Current.Dispatcher.BeginInvoke(new Action(() => { PublishCodes(args); }));
            }
            else
            {
                if (null == _vm)
                {
                    //13868 Custom codes are added to a group, but does not appear in the channel codes tile
                    //make sure this vm is initialized and listening
                    var UnityContainer =  ContainerLocator.Container.Resolve<IUnityContainer>();
                    _vm = UnityContainer.Resolve<IChannelCodesListViewModel>();
                }
                var eg =  ContainerLocator.Container.Resolve<IEventAggregator>();
                eg.GetEvent<DTS.Common.Events.ChannelCodes.ChannelCodeCommittedEvent>().Publish(args);
            }
        }
        private void DeleteHardware(int id)
        {
            var errorNumber = DbOperations.GroupHardwareDelete(Id, id, out string errorMessage);
            if (errorNumber != 0)
            {
                throw new Exception(errorMessage);
            }
        }
        private void SaveHardware()
        {
            //step 1, delete any hardware that no longer exists
            var existingIds = GetExistingHardware();
            var hash = new HashSet<int>();
            if (existingIds.Any())
            {
                foreach (var id in existingIds)
                {
                    if (!IncludedHardware.Contains(id))
                    {
                        DeleteHardware(id);
                    }
                    else
                    {
                        hash.Add(id);
                    }
                }
            }
            //step 2, insert any new hardware
            foreach (var id in IncludedHardware)
            {
                if (hash.Contains(id))
                {
                    continue;
                }
                else
                {
                    InsertHardware(id);
                }
            }
        }

        private void InsertHardware(int id)
        {
            var groupHardwareDbRecord = new GroupHardwareDbRecord();
            groupHardwareDbRecord.GroupId = Id;
            groupHardwareDbRecord.DASId = id;
            var errorNumber = DbOperations.GroupHardwareInsert(groupHardwareDbRecord, out int newId, out string errorMessage);
            if (errorNumber != 0)
            {
                throw new Exception(errorMessage);
            }

        }
        public bool Save(DTS.Common.Interface.Channels.IGroupChannel[] groupChannels, bool canUserSaveChannelCodes)
        {
            DisplayName = DisplayName.Trim();
            Name = Name.Trim();
            Tags = Tags.Trim();
            SaveGroup();

            SaveChannels(groupChannels, canUserSaveChannelCodes);

            SaveHardware();
            return true;
        }

        public bool Save(DTS.Common.Interface.Channels.IGroupChannel[] groupChannels, bool canUserSaveChannelCodes, ref List<DTS.Common.Interface.Channels.IGroupChannel> newGroupChannelList)
        {
            DisplayName = DisplayName.Trim();
            Name = Name.Trim();
            Tags = Tags.Trim();
            SaveGroup();

            newGroupChannelList = SaveChannels(groupChannels, canUserSaveChannelCodes);

            SaveHardware();
            return true;
        }


        public DTS.Common.Interface.Channels.IGroupChannel[] GetAllChannels(bool bEditable, IDictionary<int, ISensorData> sensorLookup, IDictionary<int, IDASHardware> hardwareLookup, IChannelSetting[] channelDefaults,
            bool allowSensorPushAndPull = false)
        {
            if (Id < 0)
            {
                return new DTS.Common.Interface.Channels.IGroupChannel[0];
            }

            var list = new List<DTS.Common.Interface.Channels.IGroupChannel>();
            var hResult = DbOperations.ChannelsGet(null, Id, null, null, null, null, out var dbChannels);
            if (0 == hResult && null != dbChannels && dbChannels.Any())
            {
                foreach (var channel in dbChannels)
                {
                    list.Add(new GroupChannel(channel, this, bEditable, sensorLookup, hardwareLookup, channelDefaults, allowSensorPushAndPull));
                }
            }

            var defaults = DbOperations.GetSettingsLookup2();
            var channelIdList = new List<long>();
            foreach (var channel in list)
            {
                channelIdList.Add(channel.Id);
            }
            var channelList = LoadSettings(channelIdList, defaults);
            foreach (var channel in list)
            {
                channel.ChannelSettings = channelList[channel.Id].ToArray();
                channel.BorderShouldShowOutOfDate = allowSensorPushAndPull;
                if (channel.IsCan)
                {
                    channel.AdjustCANSources(channel.CanIsFD, channel.CanArbBaseBitrate, channel.CanDataBitrate);
                }
            }

            return list.ToArray();
        }

        private static Dictionary<long, Dictionary<long, List<IChannelSetting>>> _cachedGroupChannelSettings = new Dictionary<long, Dictionary<long, List<IChannelSetting>>>();
        private static Dictionary<long, List<IChannelSetting>> _cachedChannelSettings = new Dictionary<long, List<IChannelSetting>>();
        public void ClearGroupChannelSettingCache(long groupId)
        {
            _cachedGroupChannelSettings.Remove(groupId);
        }
        private Dictionary<long, List<IChannelSetting>> LoadSettings(List<long> channelIdList, Dictionary<int, Tuple<string, string>> defaults)
        {
            var settingsList = new Dictionary<long, List<IChannelSetting>>();
            if (channelIdList.Count <= 0) { return settingsList; }

            var channelList = new Dictionary<long, List<IChannelSetting>>();

            if (RunTestVariables.InRunTest &&
                _cachedGroupChannelSettings != null &&
                _cachedGroupChannelSettings.Any() &&
                _cachedGroupChannelSettings.ContainsKey(Id))
            {
                var cacheIsUpToDate = true;
                foreach (var channelId in channelIdList)
                {
                    if (_cachedGroupChannelSettings[Id] == null || !_cachedGroupChannelSettings[Id].ContainsKey(channelId))
                    {
                        cacheIsUpToDate = false;
                        break;
                    }
                }
                if (cacheIsUpToDate)
                {
                    DbOperations.LogDBCaching("****** Using cached group channel settings in LoadSettings");
                    channelList = _cachedGroupChannelSettings[Id];
                    return channelList;
                }
            }

            foreach (var id in channelIdList)
            {
                channelList[id] = new List<IChannelSetting>();
            }

            //Can't return the cache, so get them all
            var hr = DbOperations.GroupChannelSettingsGet(channelIdList, out var records, out var errors);
            if (0 == hr && null != records && records.Any())
            {
                foreach (var record in records)
                {
                    if (defaults.ContainsKey(record.SettingId))
                    {
                        var defaultData = defaults[record.SettingId];
                        var channelSetting = new ChannelSettingBase(record.SettingId, defaultData.Item1,
                            defaultData.Item2)
                        { Value = record.SettingValue };
                        if (!channelList.ContainsKey(record.ChannelId))
                        {
                            channelList[record.ChannelId] = new List<IChannelSetting>();
                        }
                        channelList[record.ChannelId].Add(channelSetting);
                    }
                }
            }

            if (_cachedGroupChannelSettings != null)
            {
                _cachedGroupChannelSettings[Id] = RunTestVariables.InRunTest ? channelList : null;
            }

            return channelList;
        }

        private void UpdateChannel(DTS.Common.Interface.Channels.IGroupChannel channel)
        {
            var iChannelDbRecord = (IChannelDbRecord)channel;
            iChannelDbRecord.GroupId = Id;
            iChannelDbRecord.LastModified = LastModified;
            iChannelDbRecord.LastModifiedBy = LastModifiedBy;
            _ = DbOperations.ChannelsUpdate(iChannelDbRecord);

            //delete any channel settings for channel
            DeleteSettings(channel.Id);
            //insert new channel settings for channel
            foreach (var setting in channel.ChannelSettings)
            {
                setting.ChannelId = channel.Id;
                InsertSetting(setting);
            }
        }

        private void InsertSetting(IChannelSetting setting)
        {
            if (null == setting.Value) { return; }
            _ = DbOperations.GroupChannelSettingsInsert(setting.ChannelId,
                new GroupChannelSettingRecord(setting.ChannelId, setting.SettingTypeId, setting.Value));
        }

        private void DeleteSettings(long channelId)
        {
            _ = DbOperations.GroupChannelSettingsDelete(channelId, null);
        }
        private void InsertChannel(DTS.Common.Interface.Channels.IGroupChannel channel)
        {
            var iChannelDbRecord = (IChannelDbRecord)channel;
            channel.GroupId = Id;
            channel.LastModified = LastModified;
            channel.LastModifiedBy = LastModifiedBy;
            _ = DbOperations.ChannelsInsert(ref iChannelDbRecord);

            //insert new channel settings for channel
            foreach (var setting in channel.ChannelSettings)
            {
                //When Inserting a channel, the three UserValueX settings will be "", but we want them
                //inserted because any subsequent Update will be setting them and we want them to be
                //identical when a Group is added to a Test Setup (which will do an Insert).
                if (string.IsNullOrWhiteSpace(setting.Value) &&
                    setting.SettingName != ChannelSettingBase.USERVALUE1 &&
                    setting.SettingName != ChannelSettingBase.USERVALUE2 &&
                    setting.SettingName != ChannelSettingBase.USERVALUE3) { continue; }
                setting.ChannelId = channel.Id;
                InsertSetting(setting);
            }
        }
        private static void DeleteChannel(long id)
        {
            var errorNumber = DbOperations.ChannelsDelete(id, out string errorMessage);
            if (errorNumber != 0)
            {
                throw new Exception(errorMessage);
            }
        }

        public int CompareTo(IGroup other)
        {
            var ret = DisplayOrder.CompareTo(other.DisplayOrder);
            if (0 != ret) { return ret; }

            ret = Id.CompareTo(other.Id);
            if (0 != ret) { return ret; }

            return DisplayName.CompareTo(other.DisplayName);
        }

        public override bool Equals(object o)
        {
            if (o is IGroup other)
            {
                return CompareTo(other) == 0;
            }
            return base.Equals(o);
        }

        public override int GetHashCode()
        {
            return base.GetHashCode();
        }

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

            var fields = Enum.GetValues(typeof(DbOperations.TestSetups.GroupsGroupFields)).Cast<DbOperations.TestSetups.GroupsGroupFields>().ToArray();

            foreach (var f in fields)
            {
                writer.WriteStartElement(f.ToString());
                switch (f)
                {
                    case DbOperations.TestSetups.GroupsGroupFields.Name: writer.WriteString(Name); break;
                    case DbOperations.TestSetups.GroupsGroupFields.LastModified: writer.WriteString(LastModified.ToString(CultureInfo.InvariantCulture)); break;
                    case DbOperations.TestSetups.GroupsGroupFields.LastModifiedBy: writer.WriteString(LastModifiedBy); break;
                    case DbOperations.TestSetups.GroupsGroupFields.Id: writer.WriteString(Id.ToString()); break;
                    case DbOperations.TestSetups.GroupsGroupFields.Tags: writer.WriteString(Tags); break;
                    default: throw new NotSupportedException("Group::WriteXML unsupported field: " + f.ToString());
                }
                writer.WriteEndElement(); //f.ToString()
            }

            writer.WriteStartElement("HardwareList");
            foreach (var hId in IncludedHardwareStringList)
            {
                writer.WriteStartElement("Hardware");
                writer.WriteString(hId);
                writer.WriteEndElement(); //Hardware
            }
            writer.WriteEndElement(); //hardwarelist

            var sensorLookup = new Dictionary<int, ISensorData>();
            var sensors = SensorsCollection.SensorsList.GetAllSensors(false);
            foreach (var s in sensors)
            {
                sensorLookup[s.DatabaseId] = s;
            }

            //var hardwareLookup = new Dictionary<int, IDASHardware>();
            //var hardware = DASHardwareList.GetAllHardware();
            //foreach (var h in hardware)
            //    foreach (var dasId in IncludedHardware)
            //    {
            //        //hardwareLookup[h.DASId] = h;
            //        var h = "xxx"; //Get name, etc. from id?
            //        hardwareLookup[dasId] = new DASHardware(h);
            //    }
            foreach (var ch in GroupChannelList)
            {
                writer.WriteStartElement("Channel");

                writer.WriteStartElement(DbOperations.TestSetups.GroupsGroupChannelFields.IsoChannelName.ToString());
                writer.WriteString(ch.IsoChannelName);
                writer.WriteEndElement(); //IsoChannelName

                writer.WriteStartElement(DbOperations.TestSetups.GroupsGroupChannelFields.IsoCode.ToString());
                writer.WriteString(ch.IsoCode);
                writer.WriteEndElement(); //IsoCode

                writer.WriteStartElement(DbOperations.TestSetups.GroupsGroupChannelFields.UserChannelName.ToString());
                writer.WriteString(ch.UserChannelName);
                writer.WriteEndElement(); //UserChannelName

                writer.WriteStartElement(DbOperations.TestSetups.GroupsGroupChannelFields.UserCode.ToString());
                writer.WriteString(ch.UserCode);
                writer.WriteEndElement(); //UserCode

                writer.WriteStartElement(DbOperations.TestSetups.GroupsGroupChannelFields.DASId.ToString());
                writer.WriteString(ch.DASId.ToString());
                writer.WriteEndElement(); //DASId

                writer.WriteStartElement(DbOperations.TestSetups.GroupsGroupChannelFields.DASChannelIndex.ToString());
                writer.WriteString(ch.DASChannelIndex.ToString());
                writer.WriteEndElement(); //DASChannelIndex

                writer.WriteStartElement(DbOperations.TestSetups.GroupsGroupChannelFields.GroupChannelOrder.ToString());
                writer.WriteString(ch.GroupChannelOrder.ToString());
                writer.WriteEndElement(); //DASChannelIndex

                writer.WriteStartElement(DbOperations.TestSetups.GroupsGroupChannelFields.SensorId.ToString());
                writer.WriteString(ch.SensorId.ToString());
                writer.WriteEndElement(); //SensorId

                writer.WriteStartElement(DbOperations.TestSetups.GroupsGroupChannelFields.Disabled.ToString());
                writer.WriteString(ch.IsDisabled.ToString());
                writer.WriteEndElement(); //Disabled

                writer.WriteStartElement(DbOperations.TestSetups.GroupsGroupChannelFields.LastModified.ToString());
                writer.WriteString(ch.LastModified.ToString(CultureInfo.InvariantCulture));
                writer.WriteEndElement(); //LastModified

                writer.WriteStartElement(DbOperations.TestSetups.GroupsGroupChannelFields.LastModifiedBy.ToString());
                writer.WriteString(ch.LastModifiedBy);
                writer.WriteEndElement(); //LastModifiedBy

                writer.WriteStartElement("ChannelSettings");
                foreach (var channelSetting in ch.ChannelSettings)
                {
                    writer.WriteStartElement(channelSetting.SettingName);
                    writer.WriteString(channelSetting.Value);
                    writer.WriteEndElement(); //channelSettingName (Range, etc.)
                }
                writer.WriteEndElement(); //ChannelSettings

                writer.WriteEndElement(); //Channel
            }
            writer.WriteEndElement(); //Group
        }
        private string GetHardwareString(IEnumerable<Hardware> hardwareList, int hId)
        {
            foreach (var hardware in hardwareList)
            {
                if (hardware.DASId == hId)
                {
                    return hardware.SerialNumber + "_" + hardware.DASType;
                }
            }
            return string.Empty;
        }
        public IGroup ReadXML(System.Xml.XmlElement node, Dictionary<long, DTS.Common.Interface.Channels.IGroupChannel> channelLookup, List<ISensorData> sensors)
        {
            try
            {
                var group = new Group();

                foreach (var child in node.ChildNodes)
                {
                    if (child is System.Xml.XmlElement element)
                    {
                        if (Enum.TryParse(element.Name, out DbOperations.TestSetups.GroupsGroupFields field))
                        {
                            switch (field)
                            {
                                case DbOperations.TestSetups.GroupsGroupFields.Name: group.Name = element.InnerText; break;
                                case DbOperations.TestSetups.GroupsGroupFields.LastModifiedBy: group.LastModifiedBy = element.InnerText; break;
                                case DbOperations.TestSetups.GroupsGroupFields.LastModified: group.LastModified = DateTime.Parse(element.InnerText, CultureInfo.InvariantCulture); break;
                                case DbOperations.TestSetups.GroupsGroupFields.Id: group.Id = Convert.ToInt32(element.InnerText); break;
                                case DbOperations.TestSetups.GroupsGroupFields.Tags: group.Tags = element.InnerText; break;
                                default: throw new NotSupportedException("TestObject::ProcessXMLElement unsupported field: " + field.ToString());
                            }
                        }
                        else if (element.Name == "HardwareList")
                        {
                            var list = new List<string>();
                            foreach (var hardwareChild in element.ChildNodes)
                            {
                                if (hardwareChild is System.Xml.XmlElement childElement)
                                {
                                    list.Add(childElement.InnerText);
                                }
                            }
                            group.IncludedHardwareStringList = list.ToArray();
                        }
                        else if (element.Name == "Channel")
                        {
                            var channel = new GroupChannel(false, group.Name, group, new IChannelSetting[0]);
                            foreach (var channelChild in element.ChildNodes)
                            {
                                if (channelChild is System.Xml.XmlElement childElement)
                                {
                                    if (Enum.TryParse(childElement.Name, out DbOperations.TestSetups.GroupsGroupChannelFields channelField))
                                    {
                                        switch (channelField)
                                        {
                                            case DbOperations.TestSetups.GroupsGroupChannelFields.IsoCode: channel.IsoCode = childElement.InnerText; break;
                                            case DbOperations.TestSetups.GroupsGroupChannelFields.IsoChannelName: channel.IsoChannelName = childElement.InnerText; break;
                                            case DbOperations.TestSetups.GroupsGroupChannelFields.UserCode: channel.UserCode = childElement.InnerText; break;
                                            case DbOperations.TestSetups.GroupsGroupChannelFields.UserChannelName: channel.UserChannelName = childElement.InnerText; break;
                                            case DbOperations.TestSetups.GroupsGroupChannelFields.DASId: channel.DASId = Convert.ToInt32(childElement.InnerText, CultureInfo.InvariantCulture); break;
                                            case DbOperations.TestSetups.GroupsGroupChannelFields.DASChannelIndex: channel.DASChannelIndex = Convert.ToInt32(childElement.InnerText, CultureInfo.InvariantCulture); break;
                                            case DbOperations.TestSetups.GroupsGroupChannelFields.GroupChannelOrder: channel.GroupChannelOrder = Convert.ToInt32(childElement.InnerText, CultureInfo.InvariantCulture); break;
                                            case DbOperations.TestSetups.GroupsGroupChannelFields.Sensor:
                                                /*Test Setup exports that were generated by 2.0.250 through 2.0.476 are Version=3 but contain <Sensor>*/
                                                channel.SensorId = ConvertToDatabaseId((channelChild as System.Xml.XmlElement).InnerText, sensors);
                                                break;
                                            case DbOperations.TestSetups.GroupsGroupChannelFields.SensorId:
                                                /*Test Setup exports that were generated by 2.0.477 or later contain <SensorId>*/
                                                channel.SensorId = Convert.ToInt32((channelChild as System.Xml.XmlElement).InnerText, CultureInfo.InvariantCulture);
                                                break;
                                            case DbOperations.TestSetups.GroupsGroupChannelFields.Disabled: channel.IsDisabled = Convert.ToBoolean(childElement.InnerText); break;
                                            case DbOperations.TestSetups.GroupsGroupChannelFields.LastModified: channel.LastModified = DateTime.Parse(childElement.InnerText, CultureInfo.InvariantCulture); break;
                                            case DbOperations.TestSetups.GroupsGroupChannelFields.LastModifiedBy: channel.LastModifiedBy = childElement.InnerText; break;
                                        }
                                    }
                                    else if (childElement.Name == "ChannelSettings")
                                    {
                                        ProcessSettingsNode(childElement, channel, sensors);
                                    }
                                }
                            }

                            channelLookup[group.ChannelCount] = channel;
                            group.ChannelCount++;
                        }
                    }
                }
                return group;
            }
            catch (Exception ex)
            {
                //FB 15530 Log the exception and trace log
                APILogger.LogException(ex);
                throw;
            }
        }

        private int ConvertToDatabaseId(string sensorSerialNumber, List<ISensorData> sensors)
        {
            return (from sensor in sensors where sensor.SerialNumber == sensorSerialNumber select sensor.DatabaseId).FirstOrDefault();
        }
        private void ProcessSettingsNode(System.Xml.XmlElement root, GroupChannel channel, List<ISensorData> sensors)
        {
            try
            {
                var range = "";
                var acCoupling = "";
                //FB 13120 set filter class
                var filterclass = "";
                var polarity = "";
                //33415 Voltage insertion channel should be half bridge
                var bridgeType = "";

                var limitDuration = "";
                var duration = "";
                var delay = "";

                var outputMode = "";
                var digitalOutDelay = "";
                var digitalOutDuration = "";
                var digitalOutLimitDuration = "";

                var sqMode = "";
                var squibDelay = "";
                var squibCurrent = "";
                var squibDuration = "";
                var squibLimitDuration = "";

                var diMode = "";
                var defaultValue = "";
                var activeValue = "";

                var uartBaudRate = "";
                var uartDataBits = "";
                var uartStopBits = "";
                var uartParity = "";
                var uartFlowControl = "";
                var uartDataFormat = "";
                //15270 Sensor Import does not import most channel settings
                string userValue1, userValue2, userValue3, zeroMethod, zeroStart, zeroEnd, initialOffset;
                userValue1 = userValue2 = userValue3 = zeroMethod = zeroStart = zeroEnd = initialOffset = String.Empty;

                if (root.ChildNodes.Count > 0)
                {
                    foreach (var node in root.ChildNodes)
                    {
                        if (node is System.Xml.XmlElement child)
                        {
                            if (Enum.TryParse(child.Name, out DbOperations.TestSetups.SettingsFields field))
                            {
                                switch (field)
                                {
                                    case DbOperations.TestSetups.SettingsFields.Range:
                                        range = string.IsNullOrWhiteSpace(child.InnerText) ? GetSensorRange(channel, sensors) : child.InnerText;
                                        break;
                                    //FB 13120 set filter class
                                    case DbOperations.TestSetups.SettingsFields.FilterClass: filterclass = child.InnerText; break;
                                    case DbOperations.TestSetups.SettingsFields.Polarity: polarity = child.InnerText; break;
                                    case DbOperations.TestSetups.SettingsFields.LimitDuration: limitDuration = child.InnerText; break;
                                    case DbOperations.TestSetups.SettingsFields.Duration: duration = child.InnerText; break;
                                    case DbOperations.TestSetups.SettingsFields.Delay: delay = child.InnerText; break;

                                    case DbOperations.TestSetups.SettingsFields.OutputMode: outputMode = child.InnerText; break;
                                    case DbOperations.TestSetups.SettingsFields.DigitalOutDelay: digitalOutDelay = child.InnerText; break;
                                    case DbOperations.TestSetups.SettingsFields.DigitalOutDuration: digitalOutDuration = child.InnerText; break;
                                    case DbOperations.TestSetups.SettingsFields.DigitalOutLimitDuration: digitalOutLimitDuration = child.InnerText; break;

                                    case DbOperations.TestSetups.SettingsFields.SQMode: sqMode = child.InnerText; break;
                                    case DbOperations.TestSetups.SettingsFields.SquibDelay: squibDelay = child.InnerText; break;
                                    case DbOperations.TestSetups.SettingsFields.SquibCurrent: squibCurrent = child.InnerText; break;
                                    case DbOperations.TestSetups.SettingsFields.SquibDuration: squibDuration = child.InnerText; break;
                                    case DbOperations.TestSetups.SettingsFields.SquibLimitDuration: squibLimitDuration = child.InnerText; break;

                                    case DbOperations.TestSetups.SettingsFields.DIMode: diMode = child.InnerText; break;
                                    case DbOperations.TestSetups.SettingsFields.DefaultValue: defaultValue = child.InnerText; break;
                                    case DbOperations.TestSetups.SettingsFields.ActiveValue: activeValue = child.InnerText; break;
                                    case DbOperations.TestSetups.SettingsFields.UserValue1: userValue1 = child.InnerText; break;
                                    case DbOperations.TestSetups.SettingsFields.UserValue2: userValue2 = child.InnerText; break;
                                    case DbOperations.TestSetups.SettingsFields.UserValue3: userValue3 = child.InnerText; break;
                                    case DbOperations.TestSetups.SettingsFields.ZeroMethod: zeroMethod = child.InnerText; break;
                                    case DbOperations.TestSetups.SettingsFields.ZeroMethodStart: zeroStart = child.InnerText; break;
                                    case DbOperations.TestSetups.SettingsFields.ZeroMethodEnd: zeroEnd = child.InnerText; break;
                                    case DbOperations.TestSetups.SettingsFields.InitialOffset: initialOffset = child.InnerText; break;

                                    case DbOperations.TestSetups.SettingsFields.UartBaudRate: uartBaudRate = child.InnerText; break;
                                    case DbOperations.TestSetups.SettingsFields.UartDataBits: uartDataBits = child.InnerText; break;
                                    case DbOperations.TestSetups.SettingsFields.UartStopBits: uartStopBits = child.InnerText; break;
                                    case DbOperations.TestSetups.SettingsFields.UartParity: uartParity = child.InnerText; break;
                                    case DbOperations.TestSetups.SettingsFields.UartFlowControl: uartFlowControl = child.InnerText; break;
                                    case DbOperations.TestSetups.SettingsFields.UartDataFormat: uartDataFormat = child.InnerText; break;
                                    case DbOperations.TestSetups.SettingsFields.ACCouplingEnabled: acCoupling = child.InnerText; break;
                                    //33415 Voltage insertion channel should be half bridge
                                    case DbOperations.TestSetups.SettingsFields.BridgeType: bridgeType = child.InnerText; break;
                                }
                            }
                        }
                    }
                }
                else
                {
                    //ChannelSettings is empty, so get Range from sensor's Capacity
                    range = GetSensorRange(channel, sensors);
                }

                //Range,CFC,Polarity
                var settings = new List<IChannelSetting>();
                var dictionary = DbOperations.GetSettingsLookup();
                if (!string.IsNullOrWhiteSpace(range))
                {
                    var rangeTuple = dictionary[ChannelSettingBase.RANGE];
                    settings.Add(new ChannelSettingBase(rangeTuple.Item1, rangeTuple.Item2, rangeTuple.Item3)
                    { DoubleValue = Convert.ToDouble(range, CultureInfo.InvariantCulture) });
                }

                if (!string.IsNullOrWhiteSpace(acCoupling))
                {
                    var acTuple = dictionary[ChannelSettingBase.ACCouplingEnabled];
                    var setting = new ChannelSettingBase(acTuple.Item1, acTuple.Item2, acTuple.Item3);
                    if (bool.TryParse(acCoupling, out var b))
                    {
                        setting.BoolValue = b;
                    }
                    settings.Add(setting);
                }

                //FB 13120 set filter class
                if (!string.IsNullOrWhiteSpace(filterclass))
                {
                    var FilterClassTuple = dictionary[ChannelSettingBase.FilterClass];
                    settings.Add(new ChannelSettingBase(FilterClassTuple.Item1, FilterClassTuple.Item2, FilterClassTuple.Item3) { Value = filterclass });
                }

                if (!string.IsNullOrWhiteSpace(polarity))
                {
                    var polarityTuple = dictionary[ChannelSettingBase.POLARITY];
                    settings.Add(new ChannelSettingBase(polarityTuple.Item1, polarityTuple.Item2, polarityTuple.Item3)
                    { Value = polarity });
                }
                //33415 Voltage insertion channel should be half bridge
                if (!string.IsNullOrWhiteSpace(bridgeType))
                {
                    var bridgeTypeTuple = dictionary[ChannelSettingBase.BRIDGE_TYPE];
                    settings.Add(new ChannelSettingBase(bridgeTypeTuple.Item1, bridgeTypeTuple.Item2, bridgeTypeTuple.Item3) { Value = bridgeType });
                }

                if (!string.IsNullOrWhiteSpace(limitDuration))
                {
                    var tuple = dictionary[ChannelSettingBase.DIGITALOUT_LIMIT_DURATION];
                    settings.Add(new ChannelSettingBase(tuple.Item1, tuple.Item2, tuple.Item3)
                    { BoolValue = Convert.ToBoolean(limitDuration) });
                    tuple = dictionary[ChannelSettingBase.SQUIB_LIMIT_DURATION];
                    settings.Add(new ChannelSettingBase(tuple.Item1, tuple.Item2, tuple.Item3) { BoolValue = Convert.ToBoolean(limitDuration) });
                }

                if (!string.IsNullOrWhiteSpace(duration))
                {
                    var tuple = dictionary[ChannelSettingBase.DIGITALOUT_DURATION];
                    settings.Add(new ChannelSettingBase(tuple.Item1, tuple.Item2, tuple.Item3)
                    { DoubleValue = Convert.ToDouble(duration, CultureInfo.InvariantCulture) });
                    tuple = dictionary[ChannelSettingBase.SQUIB_DURATION];
                    settings.Add(new ChannelSettingBase(tuple.Item1, tuple.Item2, tuple.Item3)
                    { DoubleValue = Convert.ToDouble(duration, CultureInfo.InvariantCulture) });
                }
                if (!string.IsNullOrWhiteSpace(delay))
                {
                    var tuple = dictionary[ChannelSettingBase.DIGITALOUT_DELAY];
                    settings.Add(new ChannelSettingBase(tuple.Item1, tuple.Item2, tuple.Item3)
                    { DoubleValue = Convert.ToDouble(delay, CultureInfo.InvariantCulture) });
                    tuple = dictionary[ChannelSettingBase.SQUIB_DELAY];
                    settings.Add(new ChannelSettingBase(tuple.Item1, tuple.Item2, tuple.Item3)
                    { DoubleValue = Convert.ToDouble(delay, CultureInfo.InvariantCulture) });
                }

                if (!string.IsNullOrWhiteSpace(outputMode))
                {
                    var tuple = dictionary[ChannelSettingBase.OUTPUT_MODE];
                    if (!int.TryParse(outputMode, out int iTemp))
                    {
                        APILogger.Log("invalid output mode: outputMode for channel", channel.IsoChannelName); //FIX THIS
                    }
                    settings.Add(new ChannelSettingBase(tuple.Item1, tuple.Item2, tuple.Item3)
                    { IntValue = iTemp });
                }
                if (!string.IsNullOrWhiteSpace(digitalOutDelay))
                {
                    var tuple = dictionary[ChannelSettingBase.DIGITALOUT_DELAY];
                    settings.Add(new ChannelSettingBase(tuple.Item1, tuple.Item2, tuple.Item3)
                    { DoubleValue = Convert.ToDouble(digitalOutDelay, CultureInfo.InvariantCulture) });
                }
                if (!string.IsNullOrWhiteSpace(digitalOutDuration))
                {
                    var tuple = dictionary[ChannelSettingBase.DIGITALOUT_DURATION];
                    settings.Add(new ChannelSettingBase(tuple.Item1, tuple.Item2, tuple.Item3)
                    { DoubleValue = Convert.ToDouble(digitalOutDuration, CultureInfo.InvariantCulture) });
                }
                if (!string.IsNullOrWhiteSpace(digitalOutLimitDuration))
                {
                    var tuple = dictionary[ChannelSettingBase.DIGITALOUT_LIMIT_DURATION];
                    settings.Add(new ChannelSettingBase(tuple.Item1, tuple.Item2, tuple.Item3)
                    { BoolValue = Convert.ToBoolean(digitalOutLimitDuration) });
                }

                if (!string.IsNullOrWhiteSpace(sqMode))
                {
                    var tuple = dictionary[ChannelSettingBase.SQMODE];
                    settings.Add(new ChannelSettingBase(tuple.Item1, tuple.Item2, tuple.Item3)
                    { IntValue = Convert.ToInt32(sqMode) });
                }
                if (!string.IsNullOrWhiteSpace(squibDelay))
                {
                    var tuple = dictionary[ChannelSettingBase.SQUIB_DELAY];
                    settings.Add(new ChannelSettingBase(tuple.Item1, tuple.Item2, tuple.Item3)
                    { DoubleValue = Convert.ToDouble(squibDelay, CultureInfo.InvariantCulture) });
                }
                if (!string.IsNullOrWhiteSpace(squibCurrent))
                {
                    var tuple = dictionary[ChannelSettingBase.SQUIB_CURRENT];
                    settings.Add(new ChannelSettingBase(tuple.Item1, tuple.Item2, tuple.Item3)
                    { DoubleValue = Convert.ToDouble(squibCurrent, CultureInfo.InvariantCulture) });
                }
                if (!string.IsNullOrWhiteSpace(squibDuration))
                {
                    var tuple = dictionary[ChannelSettingBase.SQUIB_DURATION];
                    settings.Add(new ChannelSettingBase(tuple.Item1, tuple.Item2, tuple.Item3)
                    { DoubleValue = Convert.ToDouble(squibDuration, CultureInfo.InvariantCulture) });
                }
                if (!string.IsNullOrWhiteSpace(squibLimitDuration))
                {
                    var tuple = dictionary[ChannelSettingBase.SQUIB_LIMIT_DURATION];
                    settings.Add(new ChannelSettingBase(tuple.Item1, tuple.Item2, tuple.Item3)
                    { BoolValue = Convert.ToBoolean(squibLimitDuration) });
                }

                if (!string.IsNullOrWhiteSpace(uartBaudRate))
                {
                    var tuple = dictionary[ChannelSettingBase.BAUD_RATE];
                    settings.Add(new ChannelSettingBase(tuple.Item1, tuple.Item2, tuple.Item3)
                    { IntValue = Convert.ToInt32(uartBaudRate) });
                }
                if (!string.IsNullOrWhiteSpace(uartDataBits))
                {
                    var tuple = dictionary[ChannelSettingBase.DATA_BITS];
                    settings.Add(new ChannelSettingBase(tuple.Item1, tuple.Item2, tuple.Item3)
                    { IntValue = Convert.ToInt32(uartDataBits) });
                }
                if (!string.IsNullOrWhiteSpace(uartStopBits))
                {
                    var tuple = dictionary[ChannelSettingBase.STOP_BITS];
                    settings.Add(new ChannelSettingBase(tuple.Item1, tuple.Item2, tuple.Item3)
                    { Value = uartStopBits });
                }
                if (!string.IsNullOrWhiteSpace(uartParity))
                {
                    var tuple = dictionary[ChannelSettingBase.PARITY];
                    settings.Add(new ChannelSettingBase(tuple.Item1, tuple.Item2, tuple.Item3)
                    { Value = uartParity });
                }
                if (!string.IsNullOrWhiteSpace(uartFlowControl))
                {
                    var tuple = dictionary[ChannelSettingBase.FLOW_CONTROL];
                    settings.Add(new ChannelSettingBase(tuple.Item1, tuple.Item2, tuple.Item3)
                    { Value = uartFlowControl });
                }
                if (!string.IsNullOrWhiteSpace(uartDataFormat))
                {
                    var tuple = dictionary[ChannelSettingBase.DATA_FORMAT];
                    settings.Add(new ChannelSettingBase(tuple.Item1, tuple.Item2, tuple.Item3)
                    { Value = uartDataFormat });
                }

                if (!string.IsNullOrWhiteSpace(diMode))
                {
                    var tuple = dictionary[ChannelSettingBase.DIMODE];
                    settings.Add(new ChannelSettingBase(tuple.Item1, tuple.Item2, tuple.Item3)
                    { IntValue = Convert.ToInt32(diMode) });
                }
                if (!string.IsNullOrWhiteSpace(defaultValue))
                {
                    var tuple = dictionary[ChannelSettingBase.DEFAULT_VALUE];
                    settings.Add(new ChannelSettingBase(tuple.Item1, tuple.Item2, tuple.Item3)
                    { DoubleValue = Convert.ToDouble(defaultValue, System.Globalization.CultureInfo.InvariantCulture) });
                }
                if (!string.IsNullOrWhiteSpace(activeValue))
                {
                    var tuple = dictionary[ChannelSettingBase.ACTIVE_VALUE];
                    settings.Add(new ChannelSettingBase(tuple.Item1, tuple.Item2, tuple.Item3)
                    { DoubleValue = Convert.ToDouble(activeValue, System.Globalization.CultureInfo.InvariantCulture) });
                }

                ProcessUserValues(userValue1, userValue2, userValue3, dictionary, ref settings);
                ProcessZeroMethod(zeroMethod, zeroStart, zeroEnd, dictionary, ref settings);

                if (!string.IsNullOrWhiteSpace(initialOffset))
                {
                    var tuple = dictionary[ChannelSettingBase.INITIAL_OFFSET];
                    settings.Add(new ChannelSettingBase(tuple.Item1, tuple.Item2, tuple.Item3)
                    {
                        Value = initialOffset
                    });
                }
                channel.ChannelSettings = settings.ToArray();
            }
            catch (Exception ex)
            {
                //FB 15530 Log the exception and trace log
                APILogger.LogException(ex);
                throw;
            }
        }
        /// <summary>
        /// handles processing of zero method settings for a group channel from import xml
        /// this appears to only be used for static groups and not embedded groups
        /// 15270 Sensor Import does not import most channel settings
        /// </summary>
        private void ProcessZeroMethod(string zeroMethod, string zeroStart, string zeroEnd,
            IReadOnlyDictionary<string, Tuple<int, string, string>> dictionary, ref List<IChannelSetting> settings)
        {
            if (!string.IsNullOrWhiteSpace(zeroMethod))
            {
                var tuple = dictionary[ChannelSettingBase.ZEROMETHOD];
                settings.Add(new ChannelSettingBase(tuple.Item1, tuple.Item2, tuple.Item3) { Value = zeroMethod });
            }

            if (!string.IsNullOrWhiteSpace(zeroStart))
            {
                var tuple = dictionary[ChannelSettingBase.ZEROMETHODSTART];
                if (double.TryParse(zeroStart, NumberStyles.Any, CultureInfo.InvariantCulture,
                    out var d))
                {
                    settings.Add(new ChannelSettingBase(tuple.Item1, tuple.Item2, tuple.Item3) { DoubleValue = d });
                }
            }
            if (!string.IsNullOrWhiteSpace(zeroEnd))
            {
                var tuple = dictionary[ChannelSettingBase.ZEROMETHODEND];
                if (double.TryParse(zeroEnd, NumberStyles.Any, CultureInfo.InvariantCulture,
                    out var d))
                {
                    settings.Add(new ChannelSettingBase(tuple.Item1, tuple.Item2, tuple.Item3) { DoubleValue = d });
                }
            }
        }
        /// <summary>
        /// handles processing of user values settings for a gorup channel from import xml
        /// this appears to only be used for static groups and not embedded groups
        /// 15270 Sensor Import does not import most channel settings
        /// </summary>
        private void ProcessUserValues(string userValue1, string userValue2, string userValue3,
            IReadOnlyDictionary<string, Tuple<int, string, string>> dictionary, ref List<IChannelSetting> settings)
        {
            if (!string.IsNullOrWhiteSpace(userValue1))
            {
                var tuple = dictionary[ChannelSettingBase.USERVALUE1];
                settings.Add(new ChannelSettingBase(tuple.Item1, tuple.Item2, tuple.Item3)
                { Value = userValue1 });
            }
            if (!string.IsNullOrWhiteSpace(userValue2))
            {
                var tuple = dictionary[ChannelSettingBase.USERVALUE2];
                settings.Add(new ChannelSettingBase(tuple.Item1, tuple.Item2, tuple.Item3) { Value = userValue2 });
            }

            if (!string.IsNullOrWhiteSpace(userValue3))
            {
                var tuple = dictionary[ChannelSettingBase.USERVALUE3];
                settings.Add(new ChannelSettingBase(tuple.Item1, tuple.Item2, tuple.Item3) { Value = userValue3 });
            }
        }
        private string GetSensorRange(GroupChannel channel, List<ISensorData> sensors)
        {
            foreach (var sensor in sensors)
            {
                if (sensor.DatabaseId != channel.SensorId) continue;
                return sensor.Capacity.ToString("N2"); //get sensor's capacity
            }
            return string.Empty;
        }
    }
    public class GroupComparer : IComparer<IGroup>
    {
        public GroupFields SortField { get; set; }
        public bool SortAscending { get; set; }
        public int Compare(IGroup left, IGroup 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 GroupFields.Name:
                    return string.Compare(a.Name, b.Name, StringComparison.OrdinalIgnoreCase);
                case GroupFields.LastModifiedBy:
                    return string.Compare(a.LastModifiedBy, b.LastModifiedBy, StringComparison.OrdinalIgnoreCase);
                case GroupFields.LastModified:
                    return DateTime.Compare(a.LastModified, b.LastModified);
                case GroupFields.DisplayName:
                    return string.Compare(a.DisplayName, b.DisplayName, StringComparison.OrdinalIgnoreCase);
                case GroupFields.Description:
                    return string.Compare(a.Description, b.Description, StringComparison.OrdinalIgnoreCase);
                case GroupFields.ChannelCount:
                    return a.ChannelCount.CompareTo(b.ChannelCount);
                case GroupFields.AssociatedTestSetups:
                    {
                        var aAssociatedTestSetups = new List<string>();
                        var bAssociatedTestSetups = new List<string>();
                        foreach (var assoc in a.AssociatedTestSetups) { aAssociatedTestSetups.Add(assoc.Name); }
                        foreach (var assoc in b.AssociatedTestSetups) { bAssociatedTestSetups.Add(assoc.Name); }
                        var aString = string.Join(", ", aAssociatedTestSetups.ToArray());
                        var bString = string.Join(", ", bAssociatedTestSetups.ToArray());
                        return string.Compare(aString, bString, StringComparison.OrdinalIgnoreCase);
                    }
                default:
                    throw new ArgumentOutOfRangeException();
            }
        }
    }
}