using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Data;

namespace DatabaseExport
{
    public class TestTemplate : TagAwareBase, IComparable<TestTemplate>
    {
        /// <summary>
        /// returns true whenever the test template is a quick test setup, false otherwise
        /// </summary>
        public bool QuickSensorCheck { get; set; }

        public const string NON_ISO_INTERNAL_GROUP_NAME = "[NONE]";
        private const int MaxRealtimeChannels = 6;
        private const int MaxErrorsToDisplay = 5;

        internal List<CalculatedValueClass> _calculatedChannels = new List<CalculatedValueClass>();
        private readonly List<string> _channelKeysInOrder = new List<string>();
        private readonly List<HardwareChannel> _hardwareChannelsInOrder = new List<HardwareChannel>();
        private string _errorMessage = "";

        /// <summary>
        /// dictionary of harware overrides for the test
        /// key is hardware id
        /// if present, then value is whether the hardware is included or removed from the test.
        /// </summary>
        internal Dictionary<string, HardwareInclusionInstruction> _hardwareOverrides = new Dictionary<string, HardwareInclusionInstruction>();
        /// <summary>
        /// cache of sensors for the test setup
        /// this keeps us from having to lookup sensors and apply changes every time we need to use them
        /// </summary>
        public Dictionary<string, Dictionary<string, Dictionary<string, SensorData>>> _sensorLookup = new Dictionary<string, Dictionary<string, Dictionary<string, SensorData>>>();
        private readonly Dictionary<string, int> _dasChannelNumberToAbsoluteNumber = null;
        private readonly Dictionary<string, DASSettings> _dasSettings = new Dictionary<string, DASSettings>();
        public DASSettings[] DASSettings
        {
            get => _dasSettings.Count < 1 ? new DASSettings[0] : _dasSettings.Values.ToArray();
            set
            {
                _dasSettings.Clear();
                foreach (var setting in value) { _dasSettings[setting.DASSerialNumber] = setting; }
            }
        }
        /// <summary>
        /// whether to upload data after data collection is completed
        /// this lets you separate out the time consumptive network data tasks from the ones you want to keep fast (export/view)
        /// </summary>
        private bool _uploadData = Properties.Settings.Default.DefaultUploadEnabled;
        public bool UploadData
        {
            get => _uploadData;
            set => SetProperty(ref _uploadData, value, TestTemplateTags.UploadData.ToString());
        }

        /// <summary>
        /// folder to upload to
        /// </summary>
        private string _uploadFolder = "";
        public string UploadFolder
        {
            get => _uploadFolder;
            set => SetProperty(ref _uploadFolder, value, TestTemplateTags.UploadFolder.ToString());
        }

        /// <summary>
        /// whether all units in the test share a common line
        /// this should be set to false if DAS in the test don't share a common line
        /// the default is true
        /// if units share a common status line and there are multiple units in the test, then each unit will monitor the status line
        /// if false or there's only one unit, the status line should not be monitored
        /// </summary>
        private bool _bCommonLine = SerializedSettings.TestSetupDefaultCommonStatusLine;
        public bool CommonLine
        {
            get => _bCommonLine;
            set => SetProperty(ref _bCommonLine, value, TestTemplateTags.CommonLine.ToString());
        }
        /// <summary>
        /// true if the test objects and other fields have already been loaded from the database, false otherwise
        /// </summary>
        internal bool _bIsLoaded = false;
        public bool IsLoaded => _bIsLoaded;

        /// <summary>
        /// when true the expectation is that any unit that can have a battery will have a battery, and the user should be warned
        /// whenever a unit that should have a battery does not have an acceptable battery voltage
        /// </summary>
        private bool _warnOnFailedBattery = SerializedSettings.TestSetupDefaultWarnOnBatteryFail;
        public bool WarnOnFailedBattery
        {
            get => _warnOnFailedBattery;
            set => SetProperty(ref _warnOnFailedBattery, value, TestTemplateTags.WarnOnFailedBattery.ToString());
        }
        public string CompletionErrorMessage => _errorMessage.Length > 250 ? _errorMessage.Substring(0, 250) : _errorMessage;

        /// <summary>
        /// returns whether the test setup is complete or not.
        /// WILL FORCE IsComplete TO BE CALCULATED IF IsDirty is true
        /// (you might not want this if you are adding a new test setup for instance...)
        /// </summary>
        public bool IsComplete
        {
            get
            {
                if (string.IsNullOrWhiteSpace(Name)) { return false; }
                //TODO: review property functionality
                if (IsDirty) { CalculateIsComplete(); }
                return _testTemplateLite.IsComplete;
            }
            set => _testTemplateLite.IsComplete = value;
        }
        /// <summary>
        /// returns whether the test setup is dirty or not (whether the is complete is calculated already or not)
        /// </summary>
        private bool _bIsDirty = true;
        public bool IsDirty
        {
            get => _bIsDirty;
            set => _bIsDirty = value;
        }
        private readonly Dictionary<string, double> _filterLookup = new Dictionary<string, double>();
        private List<TestGraph> _testGraphs = new List<TestGraph>();
        public TestGraph[] TestGraphs
        {
            get => _testGraphs.ToArray();
            set { SetProperty(ref _testGraphs, new List<TestGraph>(value), TestTemplateTags.TestGraphs.ToString()); OnPropertyChanged(TestTemplateTags.GraphCount.ToString()); }
        }
        private readonly TestTemplateLite _testTemplateLite = new TestTemplateLite();

        public string Name
        {
            get => _testTemplateLite.Name;
            set
            {
                _testTemplateLite.Name = value;
                OnPropertyChanged(TestTemplateTags.Name.ToString());
            }
        }
        private bool _bAllowMissingSensors = Properties.Settings.Default.DefaultTestAllowMissingSensors;
        public bool AllowMissingSensors
        {
            get => _bAllowMissingSensors;
            set => SetProperty(ref _bAllowMissingSensors, value, TestTemplateTags.AllowMissingSensors.ToString());
        }

        private bool _bAllowSensorIdToBlankChannel = Properties.Settings.Default.DefaultTestAllowSensorIdToBlankChannel;
        public bool AllowSensorIdToBlankChannel
        {
            get => _bAllowSensorIdToBlankChannel;
            set => SetProperty(ref _bAllowSensorIdToBlankChannel, value, TestTemplateTags.AllowSensorIdToBlankChannel.ToString());
        }
        private bool _bAutomaticProgression = SerializedSettings.TestSetupAutomaticMode; //Properties.Settings.Default.DefaultTestAutomaticProgression
        public bool AutomaticProgression
        {
            get => _bAutomaticProgression;
            set => SetProperty(ref _bAutomaticProgression, value, TestTemplateTags.AutomaticProgression.ToString());
        }

        private int _automaticProgressionDelayMs = SerializedSettings.TestSetupAutomaticProgressDelayMS;
        public int AutomaticProgressionDelayMS
        {
            get => _automaticProgressionDelayMs;
            set => SetProperty(ref _automaticProgressionDelayMs, value, TestTemplateTags.AutomaticProgressionDelayMS.ToString());
        }

        private bool _invertTriggerCompletion;
        public bool InvertTriggerCompletion
        {
            get => _invertTriggerCompletion;
            set => SetProperty(ref _invertTriggerCompletion, value, TestTemplateTags.InvertTriggerCompletion.ToString());
        }

        private bool _triggerCheckStep = Properties.Settings.Default.DefaultTestTriggerCheckStep;
        public bool TriggerCheckStep
        {
            get => _triggerCheckStep;
            set => SetProperty(ref _triggerCheckStep, value, TestTemplateTags.TriggerCheckStep.ToString());
        }

        private int _postTestDiagnosticsLevel = Properties.Settings.Default.DefaultTestRunPostTestDiagnostics ? 255 : 0;
        public bool PostTestDiagnosticsLevel
        {
            get => _postTestDiagnosticsLevel != 0;
            set
            {
                if (value) { SetProperty(ref _postTestDiagnosticsLevel, 255, TestTemplateTags.PostTestDiagnostics.ToString()); }
                else { SetProperty(ref _postTestDiagnosticsLevel, 0, TestTemplateTags.PostTestDiagnostics.ToString()); }
            }
        }

        private bool _triggerCheckRealtime;
        public bool TriggerCheckRealtime
        {
            get => _triggerCheckRealtime;
            set => SetProperty(ref _triggerCheckRealtime, value, TestTemplateTags.TriggerCheckRealtime.ToString());
        }

        private bool _invertStartRecordCompletion;
        public bool InvertStartRecordCompletion
        {
            get => _invertStartRecordCompletion;
            set => SetProperty(ref _invertStartRecordCompletion, value, TestTemplateTags.InvertStartRecordCompletion.ToString());
        }

        private bool _bViewDiagnostics = true;
        public bool ViewDiagnostics
        {
            get => _bViewDiagnostics;
            set => SetProperty(ref _bViewDiagnostics, value, TestTemplateTags.ViewDiagnostics.ToString());
        }

        private bool _bVerify = true;
        public bool VerifyChannels
        {
            get => _bVerify;
            set => SetProperty(ref _bVerify, value, TestTemplateTags.VerifyChannels.ToString());
        }

        private bool _bAutoVerifyChannels = true;
        public bool AutoVerifyChannels
        {
            get => _bAutoVerifyChannels;
            set => SetProperty(ref _bAutoVerifyChannels, value, TestTemplateTags.AutoVerifyProgress.ToString());
        }

        private double _autoVerifyDelay = 2D;
        public double AutoVerifyDelaySeconds
        {
            get => _autoVerifyDelay;
            set => SetProperty(ref _autoVerifyDelay, value, TestTemplateTags.AutoVerifyDelaySeconds.ToString());
        }
        private bool _bUseCustomerDetails;
        public bool UseCustomerDetails
        {
            get => _bUseCustomerDetails;
            set => SetProperty(ref _bUseCustomerDetails, value, TestTemplateTags.UseCustomerDetails.ToString());
        }
        private bool _bUseTestEngineerDetails;
        public bool UseTestEngineerDetails
        {
            get => _bUseTestEngineerDetails;
            set => SetProperty(ref _bUseTestEngineerDetails, value, TestTemplateTags.UseTestEngineerDetails.ToString());
        }
        private bool _bTurnOffExcitation = true;
        public bool TurnOffExcitation
        {
            get => _bTurnOffExcitation;
            set => SetProperty(ref _bTurnOffExcitation, value, TestTemplateTags.TurnOffExcitation.ToString());
        }

        private bool _bUseLabratoryDetails;
        public bool UseLabratoryDetails
        {
            get => _bUseLabratoryDetails;
            set => SetProperty(ref _bUseLabratoryDetails, value, TestTemplateTags.UseLabratoryDetails.ToString());
        }
        private bool _localOnly;
        public bool LocalOnly
        {
            get => _localOnly;
            set => SetProperty(ref _localOnly, value, TestTemplateTags.LocalOnly.ToString());
        }

        public DateTime LastModified
        {
            get => _testTemplateLite.LastModified;
            set
            {
                _testTemplateLite.LastModified = value;
                OnPropertyChanged(TestTemplateTags.LastModified.ToString());
            }
        }
        public string LastModifiedBy
        {
            get => _testTemplateLite.LastModifiedBy;
            set
            {
                _testTemplateLite.LastModifiedBy = value;
                OnPropertyChanged(TestTemplateTags.LastMmodifiedBy.ToString());
            }
        }

        public string Description
        {
            get => _testTemplateLite.Description;
            set
            {
                _testTemplateLite.Description = value;
                OnPropertyChanged(TestTemplateTags.Description.ToString());
            }
        }

        private double _samplesPerSecond = Properties.Settings.Default.DefaultTestSampleRate;
        public double SamplesPerSecond
        {
            get => _samplesPerSecond;
            set
            {
                SetProperty(ref _samplesPerSecond, value, TestTemplateTags.SamplesPerSecond.ToString());
                OnPropertyChanged(TestTemplateTags.SampleRateText.ToString());
            }
        }
        public double PreTriggerSeconds
        {
            get => _testTemplateLite.PreTriggerSeconds;
            set
            {
                _testTemplateLite.PreTriggerSeconds = value;
                OnPropertyChanged(TestTemplateTags.PreTriggerSeconds.ToString());
            }
        }

        public double PostTriggerSeconds
        {
            get => _testTemplateLite.PostTriggerSeconds;
            set
            {
                _testTemplateLite.PostTriggerSeconds = value;
                OnPropertyChanged(TestTemplateTags.PostTriggerSeconds.ToString());
            }
        }

        private string _isfFile = "";

        public string ISFFile
        {
            get => _isfFile;
            set => SetProperty(ref _isfFile, value, TestTemplateTags.ISFFile.ToString());
        }

        private bool _doAutoArm = false;
        public bool DoAutoArm
        {
            get => _doAutoArm;
            set => SetProperty(ref _doAutoArm, value, TestTemplateTags.DoAutoArm.ToString());
        }

        private bool _doStreaming = false;
        public bool DoStreaming
        {
            get => _doStreaming;
            set => SetProperty(ref _doStreaming, value, TestTemplateTags.DoStreaming.ToString());
        }

        /// <summary>
        /// CheckoutMode means a non destructive data collection
        /// squib fires will only occur internally
        /// </summary>
        private bool _checkoutMode = false;
        public bool CheckoutMode
        {
            get => _checkoutMode;
            set => SetProperty(ref _checkoutMode, value, TestTemplateTags.CheckoutMode.ToString());
        }
        /// <summary>
        /// QuitTestWithoutWarning flag will suppress warnings on exit
        /// see: 7509 add option to Quit Test Without Warning
        /// </summary>
        private bool _quitTestWithoutWarning = Properties.Settings.Default.DefaultTestQuitTestWithoutWarning;
        public bool QuitTestWithoutWarning
        {
            get => _quitTestWithoutWarning;
            set => SetProperty(ref _quitTestWithoutWarning, value, TestTemplateTags.QuitTestWithoutWarning.ToString());
        }

        /// <summary>
        /// SuppressMissingSensorsWarning flag will suppress missing sensors warnings
        /// see: 8877 Suppress modal warning in checkout mode for missing sensors.
        /// </summary>
        private bool _suppressMissingSensorsWarning = Properties.Settings.Default.DefaultSuppressMissingSensorsWarning;
        public bool SuppressMissingSensorsWarning
        {
            get => _suppressMissingSensorsWarning;
            set => SetProperty(ref _suppressMissingSensorsWarning, value, TestTemplateTags.SuppressMissingSensorsWarning.ToString());
        }
        /// <summary>
        /// suppress warnings on exit
        /// see: 7642 add two test setup option to suppress "not all channels have been viewed" warnings in both real-time and viewer.
        /// </summary>
        private bool _notAllChannelsRealTime = Properties.Settings.Default.DefaultTestSuppressNotAllChannelsViewedWarningRealTime;
        public bool NotAllChannelsRealTime
        {
            get => _notAllChannelsRealTime;
            set => SetProperty(ref _notAllChannelsRealTime, value, TestTemplateTags.NotAllChannelsRealTime.ToString());
        }
        /// <summary>
        /// suppress warnings on exit
        /// see: 7642 add two test setup option to suppress "not all channels have been viewed" warnings in both real-time and viewer.
        /// </summary>
        private bool _notAllChannelsViewer = Properties.Settings.Default.DefaultTestSuppressNotAllChannelsViewedWarningViewer;
        public bool NotAllChannelsViewer
        {
            get => _notAllChannelsViewer;
            set => SetProperty(ref _notAllChannelsViewer, value, TestTemplateTags.NotAllChannelsViewer.ToString());
        }

        public RecordingModes RecordingMode
        {
            get => _testTemplateLite.RecordingMode;
            set
            {
                if (value != _testTemplateLite.RecordingMode)
                {
                    _testTemplateLite.RecordingMode = value;
                    OnPropertyChanged(TestTemplateTags.RecordingMode.ToString());
                    OnPropertyChanged(TestTemplateTags.RecordingModeText.ToString());
                }
            }
        }

        private bool _bStrictDiagnostics = Properties.Settings.Default.DefaultTestRequireAllUnitsPassDiagnostics;
        public bool StrictDiagnostics
        {
            get => _bStrictDiagnostics;
            set => SetProperty(ref _bStrictDiagnostics, value, TestTemplateTags.StrictDiagnostics.ToString());
        }

        private readonly List<string> _checkedDASList = new List<string>();
        public TestTestObject[] TestObjectsWithChannels
        {
            get
            {
                var list = new List<TestTestObject>(_testObjects);
                for (var i = list.Count - 1; i >= 0; i--)
                {
                    var isoTO = list[i].GetISOTestObject();
                    if (0 == isoTO.AllChannels.Length) { list.RemoveAt(i); }
                }
                return list.ToArray();
            }
        }
        public List<TestObject> TestObjectsAndAddedGroupsList = new List<TestObject>();
        public TestObject[] TestObjectsAndAddedGroups => TestObjectsAndAddedGroupsList.ToArray();
        private List<TestTestObject> _testObjects = new List<TestTestObject>();
        public TestTestObject[] TestObjects
        {
            get => _testObjects.ToArray();
            set => SetTestObjects(false, value);
        }


        private List<TestTestObject> _addedGroups = new List<TestTestObject>();
        public TestTestObject[] AddedGroups
        {
            get => _addedGroups.ToArray();
            set
            {
                //MarkIsCompleteUnchecked(); Removed to fix FB 10241 with the assumption that simply Setting AddedGroups should not cause a database write.
                SetProperty(ref _addedGroups, new List<TestTestObject>(value), TestTemplateTags.SysBuiltTestObjectTypes.ToString());
                OnPropertyChanged(TestTemplateTags.AllTestObjects.ToString());//check this
                OnPropertyChanged("TestObjectsAndAddedGroups");
                OnPropertyChanged(TestTemplateTags.TestObjectsAndAddedGroups.ToString());
            }
        }
        private bool _bRequireUserConfirmationOnErrors = Properties.Settings.Default.DefaultTestRequireUserConfirmationOnErrors;
        public bool RequireUserConfirmationOnErrors
        {
            get => _bRequireUserConfirmationOnErrors;
            set => SetProperty(ref _bRequireUserConfirmationOnErrors, value, TestTemplateTags.RequireUserConfirmationOnErrors.ToString());
        }

        private bool _ROIDownload = Properties.Settings.Default.DefaultTestDownloadROI;
        public bool DoROIDownload
        {
            get => _ROIDownload;
            set
            {
                SetProperty(ref _ROIDownload, value, TestTemplateTags.DoROIDownload.ToString());
                OnPropertyChanged(TestTemplateTags.ROIButtonVisibility.ToString());
            }
        }
        private bool _ROIDownloadView = Properties.Settings.Default.DefaultTestViewROI;
        public bool ViewROIDownload
        {
            get => _ROIDownloadView;
            set
            {
                SetProperty(ref _ROIDownloadView, value, TestTemplateTags.ViewROIDownload.ToString());
                OnPropertyChanged(TestTemplateTags.ViewROIDownloadButtonVisibility.ToString());
            }
        }
        private bool _DownloadAll = Properties.Settings.Default.DefaultTestDownloadAll;
        public bool DownloadAll
        {
            get => _DownloadAll;
            set
            {
                SetProperty(ref _DownloadAll, value, TestTemplateTags.DownloadAll.ToString());
                OnPropertyChanged(TestTemplateTags.DownloadAllButtonVisibility.ToString());
            }
        }

        private bool _ViewRealtime = Properties.Settings.Default.DefaultTestViewAll;
        public bool ViewRealtime
        {
            get => 0 != GetNumberOfRealtimeSupportedChannels() && _ViewRealtime;
            set
            {
                SetProperty(ref _ViewRealtime, value, TestTemplateTags.ViewRealtime.ToString());
                OnPropertyChanged(TestTemplateTags.ViewRealtime.ToString());
            }
        }
        private double _roiStart = Properties.Settings.Default.DefaultTestROIStart;
        public double ROIStart
        {
            get => _roiStart;
            set => SetProperty(ref _roiStart, value, TestTemplateTags.ROIStart.ToString());
        }
        private double _roiEnd = Properties.Settings.Default.DefaultTestROIEnd;
        public double ROIEnd
        {
            get => _roiEnd;
            set => SetProperty(ref _roiEnd, value, TestTemplateTags.ROIEnd.ToString());
        }
        private bool _viewDownloadAll = Properties.Settings.Default.DefaultTestViewAll;
        public bool ViewDownloadAll
        {
            get => _viewDownloadAll;
            set
            {
                SetProperty(ref _viewDownloadAll, value, TestTemplateTags.ViewDownloadAll.ToString());
                OnPropertyChanged(TestTemplateTags.ViewDownloadAllButtonVisibility.ToString());
            }
        }
        private bool _viewExport = Properties.Settings.Default.DefaultTestExport;
        public bool ViewExport
        {
            get => _viewExport;
            set
            {
                SetProperty(ref _viewExport, value, TestTemplateTags.ViewExport.ToString());
                OnPropertyChanged(TestTemplateTags.ViewExportButtonVisibility.ToString());
            }
        }
        private SupportedExportFormatBitFlags _exportFormats = (SupportedExportFormatBitFlags)Properties.Settings.Default.DefaultTestExportFormat;
        public SupportedExportFormatBitFlags ExportFormats
        {
            get => _exportFormats;
            set => SetProperty(ref _exportFormats, value, TestTemplateTags.ExportFormats.ToString());
        }

        private string _downloadFolder = Properties.Settings.Default.DownloadFolder;
        public string DownloadFolder
        {
            get => _downloadFolder;
            set => SetProperty(ref _downloadFolder, value, TestTemplateTags.DownloadFolder.ToString());
        }

        private string _exportFolder = Properties.Settings.Default.DownloadFolder;
        public string ExportFolder
        {
            get => _exportFolder;
            set => SetProperty(ref _exportFolder, value, TestTemplateTags.ExportFolder.ToString());
        }

        private bool _sameAsDownloadFolder = true;
        public bool SameAsDownloadFolder
        {
            get => _sameAsDownloadFolder;
            set => SetProperty(ref _sameAsDownloadFolder, value, TestTemplateTags.SameAsDownloadFolder.ToString());
        }
        private LabratoryDetails _labDetails = null;
        public LabratoryDetails LabDetails
        {
            get => _labDetails;
            set => SetProperty(ref _labDetails, value, TestTemplateTags.LabDetails.ToString());
        }

        private CustomerDetails _customerDetails = null;
        public CustomerDetails CustomerDetails
        {
            get => _customerDetails;
            set => SetProperty(ref _customerDetails, value, TestTemplateTags.CustomerDetails.ToString());
        }

        private TestEngineerDetails _testEngineerDetails = null;
        public TestEngineerDetails TestEngineerDetails
        {
            get => _testEngineerDetails;
            set => SetProperty(ref _testEngineerDetails, value, TestTemplateTags.TestEngineerDetails.ToString());
        }
        private int _defaultNumberRealtimeGraphs = Properties.Settings.Default.DefaultTestRealtimeModeGraphCount;
        public int DefaultNumberRealtimeGraphs
        {
            get
            {
                switch (_defaultNumberRealtimeGraphs)
                {
                    case 6:
                        return 6;
                    case 3:
                        return 3;
                    case 1:
                    default:
                        return 1;
                }
            }
            set
            {
                switch (value)
                {
                    case 6:
                        _defaultNumberRealtimeGraphs = value;
                        break;
                    case 3:
                        _defaultNumberRealtimeGraphs = value;
                        break;
                    case 1:
                    default:
                        _defaultNumberRealtimeGraphs = value;
                        break;
                }
                OnPropertyChanged(TestTemplateTags.DefaultNumberRealtimeGraphs.ToString());
            }
        }
        public override ConstraintHelper[] GetConstraints()
        {
            return new[]
            {
                        new ConstraintHelper()
                        {
                            ColumnName = DbOperations.TestSetups.Fields.SetupName.ToString(),
                            DbType = SqlDbType.NVarChar,
                            DbValue = Name
                        }
                    };
        }
        public override string LookupTable => DbOperations.TestSetups.TestSetupsTable;

        /// <summary>
        /// this is a brave new world, this is the hardware for this test.
        /// now groups in this test setup may have hardware assigned, or no hardware assigned
        /// we'll take that if we find it, but then we'll also check a list we have for the test itself and intersect the two
        /// we then modify the groups IN MEMORY and change their hardware to match all hardware officially in the test
        /// </summary>
        /// <returns></returns>
        public void ApplyHardwareOverrides()
        {
            //for now don't do anything if the test setup is non iso
            var hardwareInTest = new Dictionary<string, DASHardware>();
            foreach (var group in TestObjects)
            {
                foreach (var h in group.Hardware)
                {
                    var hiso = h.GetHardware();
                    if (!hardwareInTest.ContainsKey(hiso.GetId()))
                    {
                        hardwareInTest.Add(hiso.GetId(), h);
                    }
                }
            }
            foreach (var group in AddedGroups)
            {
                foreach (var h in group.Hardware)
                {
                    var hiso = h.GetHardware();
                    if (!hardwareInTest.ContainsKey(hiso.GetId()))
                    {
                        hardwareInTest.Add(hiso.GetId(), h);
                    }
                }
            }
            var e = _hardwareOverrides.GetEnumerator();
            while (e.MoveNext())
            {
                switch (e.Current.Value.Action)
                {
                    case HardwareInclusionInstruction.Actions.Add:
                        if (!hardwareInTest.ContainsKey(e.Current.Value.HardwareId))
                        {
                            DASHardware h = null;
                            try { h = DASHardwareList.GetList().GetHardware(e.Current.Value.HardwareId); }
                            catch (DASHardwareList.HardwareTypeChangedException) 
                            {
                                //ignore
                            }
                            if (null != h) { hardwareInTest.Add(h.GetHardware().GetId(), h); }
                        }
                        break;
                    case HardwareInclusionInstruction.Actions.Remove:
                        if (hardwareInTest.ContainsKey(e.Current.Value.HardwareId)) { hardwareInTest.Remove(e.Current.Value.HardwareId); }
                        break;
                }
            }
            GetNonISOTestObject();
            foreach (var group in TestObjects)
            {
                var hardware = new List<DASHardware>();
                var e2 = hardwareInTest.GetEnumerator();
                while (e2.MoveNext())
                {
                    var newH = new DASHardware(e2.Current.Value.GetHardware());
                    newH.SetTimeStampMemory(e2.Current.Value.GetTimeStampMemory());
                    hardware.Add(newH);
                }
                group.SetHardware(hardware.ToArray());
            }
            foreach (var ag in AddedGroups)
            {
                var hardware = new List<DASHardware>();
                var e2 = hardwareInTest.GetEnumerator();
                while (e2.MoveNext())
                {
                    var newH = new DASHardware(e2.Current.Value.GetHardware());
                    newH.SetTimeStampMemory(e2.Current.Value.GetTimeStampMemory());
                    hardware.Add(newH);
                }
                ag.SetHardware(hardware.ToArray());
            }

        }
        internal Dictionary<string, LevelTriggerChannel> LevelTriggerChannels = new Dictionary<string, LevelTriggerChannel>();
        public string GetLTKey(LevelTriggerChannel ch)
        {
            return string.Format("{0}x{1}", ch.HardwareChannelId, ch.SensorSerialNumber);
        }
        public void SetLevelTrigger(LevelTriggerChannel channel)
        {
            var key = GetLTKey(channel);
            LevelTriggerChannels[key] = new LevelTriggerChannel(channel);//do a copy just for safety
        }
        public SensorData GetSensor(string serialNumber, string testObjectSerial, string channelName)
        {
            lock (SensorLock)
            {
                var tto = GetTestTestObject(testObjectSerial);
                if (_sensorLookup.ContainsKey(testObjectSerial))
                {
                    if (_sensorLookup[testObjectSerial].ContainsKey(channelName))
                    {
                        if (_sensorLookup[testObjectSerial][channelName].ContainsKey(serialNumber))
                        {
                            if (_sensorLookup[testObjectSerial][channelName][serialNumber].FilterClassIso == "?")
                            {
                                _sensorLookup[testObjectSerial][channelName][serialNumber].FilterClassIso = "P"; // "Prefiltered > CFC 1000" (Unfiltered)
                            }
                            //for some reason the Filter isn't always set, setting filterclassiso will ensure it gets set, even though it should have already _been_ set
                            _sensorLookup[testObjectSerial][channelName][serialNumber].FilterClassIso = _sensorLookup[testObjectSerial][channelName][serialNumber].FilterClassIso;
                            if (null == tto)
                            { return _sensorLookup[testObjectSerial][channelName][serialNumber]; }
                            var position = tto.Position.Position;
                            if (position != TestTestObject.UserSetKey &&
                                position != TestTestObject.ChannelDefaultsKey &&
                                position != _sensorLookup[testObjectSerial][channelName][serialNumber].Position)
                            {
                                _sensorLookup[testObjectSerial][channelName][serialNumber].Position = position;
                            }
                            return _sensorLookup[testObjectSerial][channelName][serialNumber];
                        }
                    }
                }
                if (null == tto)
                { return SensorData.IsTestSpecificDigitalOutSN(serialNumber) ? new DigitalOutputSetting { SerialNumber = serialNumber } : SensorsCollection.SensorsList.GetSensorBySerialNumber(serialNumber); }
                {
                    var ttosd = tto.GetSensor(channelName, serialNumber);
                    if (ttosd != null)
                    {
                        ttosd.TestObject = tto.TestObject.Test_Object;
                        var position = tto.Position.Position;
                        if (position != TestTestObject.UserSetKey &&
                            position != TestTestObject.ChannelDefaultsKey &&
                            position != ttosd.Position)
                        {
                            ttosd.Position = position;
                        }
                    }
                    else
                    {
                        return SensorData.IsTestSpecificDigitalOutSN(serialNumber) ? new DigitalOutputSetting { SerialNumber = serialNumber } : null;
                    }
                    return ttosd;
                }
            }
        }
        public void SetSensor(SensorData sd, string testobjectserial, string channelname)
        {
            SetSensor(sd, testobjectserial, channelname, false);
        }

        private static readonly object SensorLock = new object();

        /// <summary>
        /// sets the sensor (and custom values like range/CFC/polarity) for a channel in the test
        /// </summary>
        /// <param name="sd"></param>
        /// <param name="testobjectserial"></param>
        /// <param name="channelname"></param>
        /// <param name="bSetPositionFromSensor"></param>
        public void SetSensor(SensorData sd, string testobjectserial, string channelname, bool bSetPositionFromSensor)
        {
            lock (SensorLock)
            {
                if (!_sensorLookup.ContainsKey(testobjectserial))
                {
                    _sensorLookup.Add(testobjectserial, new Dictionary<string, Dictionary<string, SensorData>>());
                }
                if (!_sensorLookup[testobjectserial].ContainsKey(channelname))
                {
                    _sensorLookup[testobjectserial].Add(channelname, new Dictionary<string, SensorData>());
                }
                //Build out the ISO fields we know about
                // FB 5423
                var tto = GetTestTestObject(testobjectserial) ?? new TestTestObject(new TestObject());
                sd.TestObject = tto.TestObject.Test_Object;


                // ReSharper disable once InconsistentNaming
                var isoTO = tto.GetISOTestObject();
                var channel = isoTO.GetChannel(channelname);
                if (bSetPositionFromSensor)
                {
                    if (tto.Position.Position != sd.Position && tto.Position.Position != TestTestObject.UserSetKey)
                    {
                        tto.SetPosition(TestTestObject.UserSetKey);
                    }
                }
                else
                {
                    if ((tto.Position.Position != TestTestObject.ChannelDefaultsKey) && //Remove this?   
                        (tto.Position.Position != TestTestObject.UserSetKey))
                    {
                        sd.Position = tto.Position.Position;
                    }
                }
                if (null != channel)
                {
                    sd.FineLocation1 = channel.Channel.Fine_Loc_1;
                    sd.FineLocation2 = channel.Channel.Fine_Loc_2;
                    sd.FineLocation3 = channel.Channel.Fine_Loc_3;
                    sd.MainLocation = channel.Channel.Trans_Main_Loc;
                    sd.PhysicalDimension = channel.Channel.Physical_Dimension;
                    sd.Direction = channel.Channel.Direction;
                }

                _sensorLookup[testobjectserial][channelname][sd.SerialNumber] = sd;
            }
        }
        public const string HARDWAREOVERRIDE_ACTION = "Action";
        public const string HARDWAREOVERRIDE_HID = "HID";
        private const string LT_TESTSETUPNAME = "TestSetupName";
        private const string LT_TESTOBJECTCHANNELID = "TestObjectChannelId";
        private const string LT_HARDWARECHANNELID = "HardwareChannelId";
        private const string LT_GROUPSERIALNUMBER = "GroupId";
        private const string LT_SENSORSERIALNUMBER = "SensorSerialNumber";
        private const string LT_LESSTHANTHRESHOLDEU = "LessThanValue";
        private const string LT_LESSTHANENABLED = "LessThanEnabled";
        private const string LT_GREATERTHANENABLED = "GreaterThanEnabled";
        private const string LT_GREATERTHANTHRESHOLDEU = "GreaterThanValue";
        private const string LT_TRIGGEROUTSIDE = "TriggerOutside";
        private const string LT_TRIGGERINSIDE = "TriggerInside";
        private const string LT_OUTSIDEUPPEREU = "OutsideUpperEU";
        private const string LT_OUTSIDELOWEREU = "OutsideLowerEU";
        private const string LT_INSIDEUPPEREU = "InsideUpperEU";
        private const string LT_INSIDELOWEREU = "InsideLowerEU";
        private const string CC_CALCULATEDCHANNELVALUE = "ISOCODE";
        private const string CC_CFCFORINPUTCHANNELS = "CFCInputChannels";
        private const string CC_CFCFOROUTPUTCHANNELS = "CFCOutput";
        private const string CC_TESTSETUPNAME = "TestSetupName";
        private const string CC_NAME = "Name";
        private const string CC_INPUTCHANNELIDS = "InputChannelIds";
        private const string CC_ID = "ID";
        private const string CC_OPERATION = "Operation";

        public Dictionary<string, string> GetTestObjectValues(TestTestObject to)
        {
            var elementNameValuePairs = new Dictionary<string, string>();

            elementNameValuePairs[DbOperations.TestSetups.TestSetupObjectFields.TestObjectSerialNumber.ToString()] = to.SerialNumber;
            elementNameValuePairs[DbOperations.TestSetups.TestSetupObjectFields.TestSetupName.ToString()] = Name;
            elementNameValuePairs[DbOperations.TestSetups.TestSetupObjectFields.TargetSampleRate.ToString()] = to.TargetSampleRate.ToString(System.Globalization.CultureInfo.InvariantCulture);
            elementNameValuePairs[DbOperations.TestSetups.TestSetupObjectFields.ExcitationWarmupTimeMS.ToString()] = to.ExcitationWarmupTimeMS.ToString(System.Globalization.CultureInfo.InvariantCulture);
            elementNameValuePairs[DbOperations.TestSetups.TestSetupObjectFields.LocalOnly.ToString()] = to.LocalOnly.ToString();
            elementNameValuePairs[DbOperations.TestSetups.TestSetupObjectFields.TestObjectType.ToString()] = to.TestObject.Test_Object;
            elementNameValuePairs[DbOperations.TestSetups.TestSetupObjectFields.TestObjectPosition.ToString()] = to.Position.Position;

            return elementNameValuePairs;
        }
        public Dictionary<string, string> GetDASSettingsValues(DASSettings settings)
        {
            var elementNameValuePairs = new Dictionary<string, string>();

            elementNameValuePairs[DbOperations.TestSetups.TestSetupDASSettingsFields.DASSerialNumber.ToString()] = settings.DASSerialNumber;
            elementNameValuePairs[DbOperations.TestSetups.TestSetupDASSettingsFields.TestSetupName.ToString()] = Name;
            elementNameValuePairs[DbOperations.TestSetups.TestSetupDASSettingsFields.TargetSampleRate.ToString()] = settings.SampleRate.ToString(System.Globalization.CultureInfo.InvariantCulture);
            elementNameValuePairs[DbOperations.TestSetups.TestSetupDASSettingsFields.ExcitationWarmupTimeMS.ToString()] = settings.ExcitationWarmupTimeMS.ToString(System.Globalization.CultureInfo.InvariantCulture);
            elementNameValuePairs[DbOperations.TestSetups.TestSetupDASSettingsFields.AAFilterRate.ToString()] = settings.HardwareAAF.ToString(System.Globalization.CultureInfo.InvariantCulture);
            elementNameValuePairs[DbOperations.TestSetups.TestSetupDASSettingsFields.PreTriggerSeconds.ToString()] = settings.PreTriggerSeconds.ToString(System.Globalization.CultureInfo.InvariantCulture);
            elementNameValuePairs[DbOperations.TestSetups.TestSetupDASSettingsFields.PostTriggerSeconds.ToString()] = settings.PostTriggerSeconds.ToString(System.Globalization.CultureInfo.InvariantCulture);
            elementNameValuePairs[DbOperations.TestSetups.TestSetupDASSettingsFields.StatusLineCheck.ToString()] = settings.StatusLineCheck.ToString(System.Globalization.CultureInfo.InvariantCulture);
            elementNameValuePairs[DbOperations.TestSetups.TestSetupDASSettingsFields.BatteryCheck.ToString()] = settings.BatteryCheck.ToString(System.Globalization.CultureInfo.InvariantCulture);
            elementNameValuePairs[DbOperations.TestSetups.TestSetupDASSettingsFields.InputVoltageMin.ToString()] = settings.InputVoltageMin.ToString(System.Globalization.CultureInfo.InvariantCulture);
            elementNameValuePairs[DbOperations.TestSetups.TestSetupDASSettingsFields.InputVoltageMax.ToString()] = settings.InputVoltageMax.ToString(System.Globalization.CultureInfo.InvariantCulture);
            elementNameValuePairs[DbOperations.TestSetups.TestSetupDASSettingsFields.BatteryVoltageMin.ToString()] = settings.BatteryVoltageMin.ToString(System.Globalization.CultureInfo.InvariantCulture);
            elementNameValuePairs[DbOperations.TestSetups.TestSetupDASSettingsFields.BatteryVoltageMax.ToString()] = settings.BatteryVoltageMax.ToString(System.Globalization.CultureInfo.InvariantCulture);
            elementNameValuePairs[DbOperations.TestSetups.TestSetupDASSettingsFields.LocalOnly.ToString()] = false.ToString(System.Globalization.CultureInfo.InvariantCulture);

            return elementNameValuePairs;
        }
        public Dictionary<string, string> GetChannelSettingValues(TestTestObject to, TestObjectChannel channel, SensorData sd)
        {
            var elementNameValuePairs = new Dictionary<string, string>();

            elementNameValuePairs[DbOperations.TestSetups.ChannelSettingFields.TestName.ToString()] = Name;
            elementNameValuePairs[DbOperations.TestSetups.ChannelSettingFields.TestObjectName.ToString()] = to.SerialNumber;
            elementNameValuePairs[DbOperations.TestSetups.ChannelSettingFields.ChannelId.ToString()] = channel.NameOfTheChannel;
            elementNameValuePairs[DbOperations.TestSetups.ChannelSettingFields.Setting.ToString()] = TestTemplateList.GetSensorSettings(sd);
            elementNameValuePairs[DbOperations.TestSetups.ChannelSettingFields.SensorSerial.ToString()] = channel.SensorSerialNumber;

            return elementNameValuePairs;
        }
        public Dictionary<string, string> GetGraphValues(TestGraph g)
        {
            var elementNameValuePairs = new Dictionary<string, string>();

            elementNameValuePairs[DbOperations.TestSetups.GraphFields.GraphName.ToString()] = g.GraphName;
            elementNameValuePairs[DbOperations.TestSetups.GraphFields.GraphDescription.ToString()] = g.GraphDescription;
            elementNameValuePairs[DbOperations.TestSetups.GraphFields.TemplateName.ToString()] = Name;
            elementNameValuePairs[DbOperations.TestSetups.GraphFields.Channels.ToString()] = g.GetChannelsForSQL();
            elementNameValuePairs[DbOperations.TestSetups.GraphFields.UseDomainMin.ToString()] = g.UseDomainMin.ToString();
            elementNameValuePairs[DbOperations.TestSetups.GraphFields.DomainMin.ToString()] = g.DomainMin.ToString(System.Globalization.CultureInfo.InvariantCulture);
            elementNameValuePairs[DbOperations.TestSetups.GraphFields.UseDomainMax.ToString()] = g.UseDomainMax.ToString();
            elementNameValuePairs[DbOperations.TestSetups.GraphFields.DomainMax.ToString()] = g.DomainMax.ToString(System.Globalization.CultureInfo.InvariantCulture);
            elementNameValuePairs[DbOperations.TestSetups.GraphFields.UseRangeMin.ToString()] = g.UseRangeMin.ToString();
            elementNameValuePairs[DbOperations.TestSetups.GraphFields.RangeMin.ToString()] = g.RangeMin.ToString(System.Globalization.CultureInfo.InvariantCulture);
            elementNameValuePairs[DbOperations.TestSetups.GraphFields.UseRangeMax.ToString()] = g.UseRangeMax.ToString();
            elementNameValuePairs[DbOperations.TestSetups.GraphFields.RangeMax.ToString()] = g.RangeMax.ToString(System.Globalization.CultureInfo.InvariantCulture);
            elementNameValuePairs[DbOperations.TestSetups.GraphFields.Thresholds.ToString()] = g.GetThresholdsSQL();
            elementNameValuePairs[DbOperations.TestSetups.GraphFields.LocalOnly.ToString()] = LocalOnly.ToString();

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

            elementNameValuePairs[DbOperations.TestSetups.Fields.SetupName.ToString()] = Name;
            elementNameValuePairs[DbOperations.TestSetups.Fields.SetupDescription.ToString()] = Description;
            elementNameValuePairs[DbOperations.TestSetups.Fields.AutomaticTestProgression.ToString()] = AutomaticProgression.ToString();
            elementNameValuePairs[DbOperations.TestSetups.Fields.AutomaticProgressionDelayMS.ToString()] = AutomaticProgressionDelayMS.ToString(System.Globalization.CultureInfo.InvariantCulture);
            elementNameValuePairs[DbOperations.TestSetups.Fields.InvertTrigger.ToString()] = InvertTriggerCompletion.ToString();
            elementNameValuePairs[DbOperations.TestSetups.Fields.InvertStart.ToString()] = InvertStartRecordCompletion.ToString();
            elementNameValuePairs[DbOperations.TestSetups.Fields.ViewDiagnostics.ToString()] = ViewDiagnostics.ToString();
            elementNameValuePairs[DbOperations.TestSetups.Fields.VerifyChannels.ToString()] = VerifyChannels.ToString();
            elementNameValuePairs[DbOperations.TestSetups.Fields.AutoVerifyChannels.ToString()] = AutoVerifyChannels.ToString();
            elementNameValuePairs[DbOperations.TestSetups.Fields.VerifyChannelsDelayMS.ToString()] = (AutoVerifyDelaySeconds * 1000D).ToString(System.Globalization.CultureInfo.InvariantCulture);
            elementNameValuePairs[DbOperations.TestSetups.Fields.RecordingMode.ToString()] = RecordingMode.ToString();
            elementNameValuePairs[DbOperations.TestSetups.Fields.SamplesPerSecond.ToString()] = SamplesPerSecond.ToString(System.Globalization.CultureInfo.InvariantCulture);
            elementNameValuePairs[DbOperations.TestSetups.Fields.PreTriggerSeconds.ToString()] = PreTriggerSeconds.ToString(System.Globalization.CultureInfo.InvariantCulture);
            elementNameValuePairs[DbOperations.TestSetups.Fields.PostTriggerSeconds.ToString()] = PostTriggerSeconds.ToString(System.Globalization.CultureInfo.InvariantCulture);
            elementNameValuePairs[DbOperations.TestSetups.Fields.StrictDiagnostics.ToString()] = StrictDiagnostics.ToString();
            elementNameValuePairs[DbOperations.TestSetups.Fields.RequireConfirmationOnErrors.ToString()] = RequireUserConfirmationOnErrors.ToString();
            elementNameValuePairs[DbOperations.TestSetups.Fields.ROIDownload.ToString()] = DoROIDownload.ToString();
            elementNameValuePairs[DbOperations.TestSetups.Fields.ViewROIDownload.ToString()] = ViewROIDownload.ToString();
            elementNameValuePairs[DbOperations.TestSetups.Fields.DownloadAll.ToString()] = DownloadAll.ToString();
            elementNameValuePairs[DbOperations.TestSetups.Fields.ViewRealtime.ToString()] = ViewRealtime.ToString();
            elementNameValuePairs[DbOperations.TestSetups.Fields.RealtimePlotCount.ToString()] = DefaultNumberRealtimeGraphs.ToString(System.Globalization.CultureInfo.InvariantCulture);
            elementNameValuePairs[DbOperations.TestSetups.Fields.ROIStart.ToString()] = ROIStart.ToString(System.Globalization.CultureInfo.InvariantCulture);
            elementNameValuePairs[DbOperations.TestSetups.Fields.ROIEnd.ToString()] = ROIEnd.ToString(System.Globalization.CultureInfo.InvariantCulture);
            elementNameValuePairs[DbOperations.TestSetups.Fields.ViewDownloadAll.ToString()] = ViewDownloadAll.ToString();
            elementNameValuePairs[DbOperations.TestSetups.Fields.Export.ToString()] = ViewExport.ToString();
            elementNameValuePairs[DbOperations.TestSetups.Fields.ExportFormat.ToString()] = ((ulong)ExportFormats).ToString(System.Globalization.CultureInfo.InvariantCulture);
            elementNameValuePairs[DbOperations.TestSetups.Fields.LabDetails.ToString()] = (null != LabDetails) ? LabDetails.Name : "";
            elementNameValuePairs[DbOperations.TestSetups.Fields.UseLabDetails.ToString()] = UseLabratoryDetails.ToString();
            elementNameValuePairs[DbOperations.TestSetups.Fields.CustomerDetails.ToString()] = null != CustomerDetails ? CustomerDetails.Name : "";
            elementNameValuePairs[DbOperations.TestSetups.Fields.UseCustomerDetails.ToString()] = UseCustomerDetails.ToString();
            elementNameValuePairs[DbOperations.TestSetups.Fields.AllowMissingSensors.ToString()] = AllowMissingSensors.ToString();
            elementNameValuePairs[DbOperations.TestSetups.Fields.AllowSensorIdToBlankChannel.ToString()] = AllowSensorIdToBlankChannel.ToString();
            elementNameValuePairs[DbOperations.TestSetups.Fields.LocalOnly.ToString()] = LocalOnly.ToString();
            elementNameValuePairs[DbOperations.TestSetups.Fields.LastModified.ToString()] = LastModified.ToString(System.Globalization.CultureInfo.InvariantCulture);
            elementNameValuePairs[DbOperations.TestSetups.Fields.LastModifiedBy.ToString()] = LastModifiedBy;
            elementNameValuePairs[DbOperations.TestSetups.Fields.TurnOffExcitation.ToString()] = TurnOffExcitation.ToString();
            elementNameValuePairs[DbOperations.TestSetups.Fields.TriggerCheckRealtime.ToString()] = TriggerCheckRealtime.ToString();
            elementNameValuePairs[DbOperations.TestSetups.Fields.TriggerCheckStep.ToString()] = TriggerCheckStep.ToString();
            elementNameValuePairs[DbOperations.TestSetups.Fields.PostTestDiagnostics.ToString()] = PostTestDiagnosticsLevel.ToString();
            elementNameValuePairs[DbOperations.TestSetups.Fields.ExportFolder.ToString()] = ExportFolder;
            elementNameValuePairs[DbOperations.TestSetups.Fields.DownloadFolder.ToString()] = DownloadFolder;
            elementNameValuePairs[DbOperations.TestSetups.Fields.CommonStatusLine.ToString()] = CommonLine.ToString();
            elementNameValuePairs[DbOperations.TestSetups.Fields.SameAsDownloadFolder.ToString()] = SameAsDownloadFolder.ToString();
            elementNameValuePairs[DbOperations.TestSetups.Fields.UploadData.ToString()] = UploadData.ToString();
            elementNameValuePairs[DbOperations.TestSetups.Fields.UploadDataFolder.ToString()] = UploadFolder;
            elementNameValuePairs[DbOperations.TestSetups.Fields.Settings.ToString()] = _settings.ToSerializeString();
            elementNameValuePairs[DbOperations.TestSetups.Fields.WarnOnBatteryFail.ToString()] = WarnOnFailedBattery.ToString();
            elementNameValuePairs[DbOperations.TestSetups.Fields.Dirty.ToString()] = IsDirty.ToString();
            elementNameValuePairs[DbOperations.TestSetups.Fields.Complete.ToString()] = IsComplete.ToString();
            elementNameValuePairs[DbOperations.TestSetups.Fields.ErrorMessage.ToString()] = CompletionErrorMessage;
            elementNameValuePairs[DbOperations.TestSetups.Fields.TestEngineerDetails.ToString()] = null != TestEngineerDetails ? TestEngineerDetails.Name : "";
            elementNameValuePairs[DbOperations.TestSetups.Fields.UseTestEngineerDetails.ToString()] = UseTestEngineerDetails.ToString();
            elementNameValuePairs[DbOperations.TestSetups.Fields.UserTags.ToString()] = GetTagsCommaSeperatedString();
            elementNameValuePairs[DbOperations.TestSetups.Fields.DoAutoArm.ToString()] = DoAutoArm.ToString();
            elementNameValuePairs[DbOperations.TestSetups.Fields.DoStreaming.ToString()] = DoStreaming.ToString();
            elementNameValuePairs[DbOperations.TestSetups.Fields.CheckoutMode.ToString()] = CheckoutMode.ToString();
            elementNameValuePairs[DbOperations.TestSetups.Fields.QuitTestWithoutWarning.ToString()] = QuitTestWithoutWarning.ToString();
            elementNameValuePairs[DbOperations.TestSetups.Fields.SuppressMissingSensorsWarning.ToString()] = SuppressMissingSensorsWarning.ToString();
            elementNameValuePairs[DbOperations.TestSetups.Fields.ISFFile.ToString()] = ISFFile;
            elementNameValuePairs[DbOperations.TestSetups.Fields.NotAllChannelsRealTime.ToString()] = NotAllChannelsRealTime.ToString();
            elementNameValuePairs[DbOperations.TestSetups.Fields.NotAllChannelsViewer.ToString()] = NotAllChannelsViewer.ToString();

            return elementNameValuePairs;
        }
        public Dictionary<string, string> GetHardwareOverrideValues(HardwareInclusionInstruction hii)
        {
            var attributeNameValuePairs = new Dictionary<string, string>();

            attributeNameValuePairs[HARDWAREOVERRIDE_HID] = hii.HardwareId;
            attributeNameValuePairs[HARDWAREOVERRIDE_ACTION] = hii.Action.ToString();

            return attributeNameValuePairs;
        }

        public Dictionary<string, string> GetCalculatedChannelValues(CalculatedValueClass cc)
        {
            var attributeNameValuePairs = new Dictionary<string, string>();

            attributeNameValuePairs[CC_CALCULATEDCHANNELVALUE] = cc.CalculatedValueCode;
            attributeNameValuePairs[CC_CFCFORINPUTCHANNELS] = cc.CFCForInputChannels;
            attributeNameValuePairs[CC_CFCFOROUTPUTCHANNELS] = cc.ChannelFilterClassForOutput;
            attributeNameValuePairs[CC_ID] = cc.Id.ToString(System.Globalization.CultureInfo.InvariantCulture);
            attributeNameValuePairs[CC_INPUTCHANNELIDS] = string.Join(System.Globalization.CultureInfo.InvariantCulture.TextInfo.ListSeparator, cc.InputChannelIds);
            attributeNameValuePairs[CC_NAME] = cc.Name;
            attributeNameValuePairs[CC_OPERATION] = cc.Operation.ToString();
            attributeNameValuePairs[CC_TESTSETUPNAME] = cc.TestSetupName;


            return attributeNameValuePairs;
        }
        public Dictionary<string, string> GetLevelTriggerValues(LevelTriggerChannel lt)
        {
            var attributeNameValuePairs = new Dictionary<string, string>();

            attributeNameValuePairs[LT_TESTSETUPNAME] = lt.TestSetupName;
            attributeNameValuePairs[LT_GROUPSERIALNUMBER] = lt.GroupSerialNumber;
            attributeNameValuePairs[LT_TESTOBJECTCHANNELID] = lt.TestObjectChannelId;
            attributeNameValuePairs[LT_HARDWARECHANNELID] = lt.HardwareChannelId;
            attributeNameValuePairs[LT_SENSORSERIALNUMBER] = lt.SensorSerialNumber;
            attributeNameValuePairs[LT_GREATERTHANENABLED] = lt.GreaterThanEnabled.ToString(System.Globalization.CultureInfo.InvariantCulture);
            attributeNameValuePairs[LT_GREATERTHANTHRESHOLDEU] = lt.GreaterThanThresholdEU.ToString(System.Globalization.CultureInfo.InvariantCulture);
            attributeNameValuePairs[LT_LESSTHANENABLED] = lt.LessThanEnabled.ToString(System.Globalization.CultureInfo.InvariantCulture);
            attributeNameValuePairs[LT_LESSTHANTHRESHOLDEU] = lt.LessThanThresholdEU.ToString(System.Globalization.CultureInfo.InvariantCulture);
            attributeNameValuePairs[LT_TRIGGERINSIDE] = lt.TriggerBetweenBounds.ToString(System.Globalization.CultureInfo.InvariantCulture);
            attributeNameValuePairs[LT_TRIGGEROUTSIDE] = lt.TriggerOutsideBounds.ToString(System.Globalization.CultureInfo.InvariantCulture);
            attributeNameValuePairs[LT_INSIDELOWEREU] = lt.InsideLowerLevelEU.ToString(System.Globalization.CultureInfo.InvariantCulture);
            attributeNameValuePairs[LT_INSIDEUPPEREU] = lt.InsideUpperLevelEU.ToString(System.Globalization.CultureInfo.InvariantCulture);
            attributeNameValuePairs[LT_OUTSIDELOWEREU] = lt.OutsideLowerLevelEU.ToString(System.Globalization.CultureInfo.InvariantCulture);
            attributeNameValuePairs[LT_OUTSIDEUPPEREU] = lt.OutsideUpperLevelEU.ToString(System.Globalization.CultureInfo.InvariantCulture);

            return attributeNameValuePairs;
        }
        public Dictionary<string, string> GetMetaDataValues(TestSetupMetaData testMeta, MetaData prop)
        {
            var attributeNameValuePairs = new Dictionary<string, string>();

            attributeNameValuePairs[DbOperations.TestSetups.TestObjectMetaDataFields.TestObject.ToString()] = testMeta.TestObject.ToString();
            attributeNameValuePairs[DbOperations.TestSetups.TestObjectMetaDataFields.SetupName.ToString()] = Name;
            attributeNameValuePairs[DbOperations.TestSetups.TestObjectMetaDataFields.PropName.ToString()] = prop.Name;
            attributeNameValuePairs[DbOperations.TestSetups.TestObjectMetaDataFields.PropValue.ToString()] = prop.Value;
            attributeNameValuePairs[DbOperations.TestSetups.TestObjectMetaDataFields.Optional.ToString()] = prop.IsOptional.ToString();
            attributeNameValuePairs[DbOperations.TestSetups.TestObjectMetaDataFields.Version.ToString()] = prop.Version.ToString(System.Globalization.CultureInfo.InvariantCulture);

            return attributeNameValuePairs;
        }
        public Dictionary<string, string> GetMetaDataValues(TestObjectMetaData testMeta, MetaData prop)
        {
            var attributeNameValuePairs = new Dictionary<string, string>();

            attributeNameValuePairs[DbOperations.TestSetups.TestObjectMetaDataFields.TestObject.ToString()] = testMeta.TestObject.ToString();
            attributeNameValuePairs[DbOperations.TestSetups.TestObjectMetaDataFields.SetupName.ToString()] = Name;
            attributeNameValuePairs[DbOperations.TestSetups.TestObjectMetaDataFields.PropName.ToString()] = prop.Name;
            attributeNameValuePairs[DbOperations.TestSetups.TestObjectMetaDataFields.PropValue.ToString()] = prop.Value;
            attributeNameValuePairs[DbOperations.TestSetups.TestObjectMetaDataFields.Optional.ToString()] = prop.IsOptional.ToString();
            attributeNameValuePairs[DbOperations.TestSetups.TestObjectMetaDataFields.Version.ToString()] = prop.Version.ToString(System.Globalization.CultureInfo.InvariantCulture);

            return attributeNameValuePairs;
        }
        /// <summary>
        /// sets the dirty flag
        /// does NOT set the flag in the database, so this should only be called when the flag needs to be set in memory
        /// (for instance during initialization)
        /// </summary>
        /// <param name="bDirty"></param>
        public void SetIsDirty(bool bDirty)
        {
            _bIsDirty = bDirty;
        }

        /// <summary>
        /// sets the complete flag
        /// does not set the flag in the database, so this should only be called when the flag needs to be set in memory
        /// (for instance during initialization)
        /// </summary>
        /// <param name="bComplete"></param>
        public void SetIsComplete(bool bComplete)
        {
            _testTemplateLite.IsComplete = bComplete;
        }

        /// <summary>
        /// sets the completion error message.
        /// does not set the field in the db, so this should only be called when the information nets to be set in memory and not the db
        /// (for instance during initialization)
        /// </summary>
        /// <param name="msg"></param>
        public void SetCompletionErrorMessage(string msg)
        {
            _errorMessage = msg;
        }

        public int CompareTo(TestTemplate right)
        {
            if (null == right) { return 1; }
            var r = Name.CompareTo(right.Name);
            return 0 == r ? LastModified.CompareTo(right.LastModified) : r;
        }

        public TestTestObject GetTestTestObject(string testObjectSerial)
        {
            foreach (var tto in TestObjects)
            {
                if (tto.SerialNumber == testObjectSerial) { return tto; }
            }
            return Array.Find(AddedGroups, addedGroup => addedGroup.SerialNumber == testObjectSerial);
        }
        /// <summary>
        /// calculates whether the test setup is complete or not
        /// will cause the test setup to be loaded if it is not yet
        /// does not unload the test setup
        /// </summary>
        private void CalculateIsComplete()
        {
            if (!IsLoaded)
            {
                Load();
            }
            var errorMessage = string.Empty;
            var errors = new List<string>();
            var warnings = new List<string>();
            var res = Validate(ref errors, ref warnings, false, this, true, StrictLevel.UpdateTable, false, true);

            //don't limit quick sensor check to one operating mode
            if (!QuickSensorCheck)
            {
                switch (GetISOTestSetupISOSupportLevel())
                {
                    case SerializedSettings.ISOSupportLevels.NO_ISO:
                        //Only valid if exact mode
                        if (SerializedSettings.ISOSupportLevel !=
                            SerializedSettings.ISOSupportLevels.NO_ISO)
                        {
                            res = false;
                            errors.Add("TestObject_GroupNotSupportedInCurrentISOSupportLevel"/*Strings.StringResources.TestObject_GroupNotSupportedInCurrentISOSupportLevel*/);
                        }
                        break;
                    case SerializedSettings.ISOSupportLevels.ISO_ONLY:
                    case SerializedSettings.ISOSupportLevels.TRANSITORY:
                        //Allow either non-ISO modes (TRANSITORY or ISO_ONLY)
                        if (SerializedSettings.ISOSupportLevel ==
                            SerializedSettings.ISOSupportLevels.NO_ISO)
                        {
                            res = false;
                            errors.Add("TestObject_GroupNotSupportedInCurrentISOSupportLevel"/*Strings.StringResources.TestObject_GroupNotSupportedInCurrentISOSupportLevel*/);
                        }
                        break;
                }
            }

            if (errors.Count > MaxErrorsToDisplay)
            {
                errorMessage = string.Format("{0}{1}{2}", string.Join(Environment.NewLine, errors.ToArray(), 0, MaxErrorsToDisplay),
                    Environment.NewLine, string.Format("TestTemplate_MoreErrors"/*Strings.StringResources.TestTemplate_MoreErrors*/, (errors.Count - MaxErrorsToDisplay)));
            }
            else if (errors.Count > 0) { errorMessage = string.Join(System.Environment.NewLine, errors.ToArray()); }

            if (!res) { IsComplete = false; }
            IsComplete = errors.Count <= 0;
            _errorMessage = errorMessage;
            _bIsDirty = false;
            if (0 == Properties.Settings.Default.DBType && IsOutOfDate()) { return; } //DON'T UPDATE, our record is old, just leave it as it is in the db and let the user play around with the mem copy for now
            using (var cmd = DbOperations.GetCommand())
            {
                cmd.CommandText = string.Format("UPDATE {0} SET {1}=@{1}, {2}=@{2}, {3}=@{3} WHERE {4}=@{4}",
                    DbOperations.TestSetups.TestSetupsTable,
                    DbOperations.TestSetups.Fields.Complete.ToString(),
                    DbOperations.TestSetups.Fields.Dirty.ToString(),
                    DbOperations.TestSetups.Fields.ErrorMessage.ToString(),
                    DbOperations.TestSetups.Fields.SetupName.ToString());

                DbOperations.CreateParam(cmd, string.Format("@{0}", DbOperations.TestSetups.Fields.Dirty.ToString()), SqlDbType.Bit, _bIsDirty);
                DbOperations.CreateParam(cmd, string.Format("@{0}", DbOperations.TestSetups.Fields.Complete.ToString()), SqlDbType.Bit, _testTemplateLite.IsComplete);
                DbOperations.CreateParam(cmd, string.Format("@{0}", DbOperations.TestSetups.Fields.ErrorMessage.ToString()), SqlDbType.NVarChar, CompletionErrorMessage);
                DbOperations.CreateParam(cmd, string.Format("@{0}", DbOperations.TestSetups.Fields.SetupName.ToString()), SqlDbType.NVarChar, Name);

                DbOperations.Connection.ExecuteCommand(cmd);

                SetTimeStampMemory(GetTimeStampDb());
            }
        }
        /// <summary>
        /// marks a test setup as unchecked by setting the dirty flag, which means the next time completion is checked it will be calculated again
        /// this function will change that flag in the database immediately
        /// </summary>
        public void MarkIsCompleteUnchecked(bool skipMemoryCheck = false)
        {
            //Ensure that our UPDATE below will not cause us to return without resetting our memory timestamp.
            var previouslyOutOfDate = IsOutOfDate();
            IsComplete = false;
            _bIsDirty = true;
            _errorMessage = string.Empty;
            if (string.IsNullOrEmpty(Name)) { return; }
            using (var sql = DbOperations.GetCommand())
            {
                sql.CommandText = string.Format("UPDATE tblTestSetups SET Dirty=1, Complete=0 WHERE {0}=@{0}", DbOperations.TestSetups.Fields.SetupName.ToString());
                DbOperations.CreateParam(sql, string.Format("@{0}", DbOperations.TestSetups.Fields.SetupName.ToString()), SqlDbType.NVarChar, Name);
                DbOperations.Connection.ExecuteCommand(sql);

                //If this Test Setup was out-of-date before we did the above UPDATE, keep it out-of-date.
                if (!skipMemoryCheck && 0 == Properties.Settings.Default.DBType && previouslyOutOfDate) return;

                SetTimeStampMemory(GetTimeStampDb());
                //THIS FUNCTION NOT ONLY CHANGES THIS COPY OF THE TEST SETUP, BUT ALL!!!
                var original = TestTemplateList.TestTemplatesList.GetTemplate(Name);
                if (null == original) return;
                original.SetTimeStampMemory(GetTimeStampMemory());
                original.IsDirty = true;
                original.IsComplete = false;
                //delete sensor

            }
        }
        /// <summary>
        /// frees up the memory assigned during Load, this includes channels, groups, meta data, etc
        /// various things may cause us to load the information and hold the information for some setups,
        /// but in general we want to unload it if we don't need it
        /// </summary>
        public void UnLoad()
        {
            if (QuickSensorCheck) { return; }
            _bIsLoaded = false;

            if (null != _testObjects) { _testObjects.Clear(); }
            if (null != _addedGroups) { _addedGroups.Clear(); }
            if (null != TestObjectsAndAddedGroupsList) { TestObjectsAndAddedGroupsList.Clear(); }
            if (null != _channelKeysInOrder) { _channelKeysInOrder.Clear(); }
            if (null != _channelLookup) { _channelLookup.Clear(); }
            if (null != _checkedDASList) { _checkedDASList.Clear(); }

            if (null != _dasChannelNumberToAbsoluteNumber) { _dasChannelNumberToAbsoluteNumber.Clear(); }
            if (null != _dasSettings) { _dasSettings.Clear(); }
            if (null != _filterLookup) { _filterLookup.Clear(); }
            if (null != _hardwareChannelsInOrder) { _hardwareChannelsInOrder.Clear(); }

            if (null != _metaDataLookup) { _metaDataLookup.Clear(); }
            if (null != _oldChannelLookup) { _oldChannelLookup.Clear(); }
            lock (SensorLock)
            {
                if (null != _sensorLookup) { _sensorLookup.Clear(); }
            }
            if (null != _sessionOpen) { _sessionOpen.Clear(); }
            //6552 Cannot set prepare hardware delay seconds. (this information is in the root table, don't unload it)

            if (null != _testGraphs) { _testGraphs.Clear(); }
            if (null != _testSetupMeta) { _testSetupMeta.Clear(); }

            if (null != _hardwareOverrides) { _hardwareOverrides.Clear(); }
            if (null != LevelTriggerChannels) { LevelTriggerChannels.Clear(); }
        }
        /// <summary>
        /// loads all the information for the test setup from tables in the db
        /// we do this so that we can keep the minimal information on hand until we need it
        /// </summary>
        public void Load()
        {
            if (QuickSensorCheck) { return; }
            if (string.IsNullOrWhiteSpace(Name)) { return; } //nothing to load!

            //intermediate structures.  originally we loaded all test graphs at once, so these structures made sense, now they are a little
            //vestigial, but it was a clean transition from the old loading structure ...
            var tblTestGraphs = new Dictionary<string, List<Dictionary<string, object>>>(100);
            var tblTestSetupDASSettings = new Dictionary<string, List<Dictionary<string, object>>>(100);
            var tblTestObjects = new Dictionary<string, List<Dictionary<string, object>>>(100);
            var tblChannelSettings = new Dictionary<string, List<Dictionary<string, object>>>(100);
            var tblMetaData = new Dictionary<string, List<Dictionary<string, object>>>(100);

            #region Load Graphs
            try
            {
                using (var sql = DbOperations.GetCommand())
                {
                    //sp_GetTestGraphs
                    sql.CommandText = string.Format("SELECT * from [{0}] where {1}=@{1}", DbOperations.TestSetups.TestGraphsTable, DbOperations.TestSetups.GraphFields.TemplateName.ToString());
                    DbOperations.CreateParam(sql, string.Format("@{0}", DbOperations.TestSetups.GraphFields.TemplateName.ToString()), SqlDbType.NVarChar,
                        Name);
                    using (var ds = DbOperations.Connection.QueryDataSet(sql))
                    {
                        if (ds.Tables.Count > 0 && ds.Tables[0].Rows.Count > 0)
                        {
                            TestTemplateList.ConvertToDictionary(ds.Tables[0], ref tblTestGraphs, DbOperations.TestSetups.GraphFields.TemplateName.ToString());
                        }
                    }
                }
            }
            catch (Exception) 
            {
                //ignore
            }
            #endregion Graphs

            #region Load DAS Settings
            try
            {
                using (var sql = DbOperations.GetCommand())
                {
                    //sp_GetTestSetupDASSettings
                    sql.CommandText = string.Format("SELECT * FROM [{0}] WHERE TestSetupName=@TestSetupName", DbOperations.TestSetups.DASSettingsTable);
                    DbOperations.CreateParam(sql, "@TestSetupName", SqlDbType.NVarChar, Name);
                    using (var ds = DbOperations.Connection.QueryDataSet(sql))
                    {
                        if (ds.Tables.Count > 0 && ds.Tables[0].Rows.Count > 0)
                        {
                            TestTemplateList.ConvertToDictionary(ds.Tables[0], ref tblTestSetupDASSettings, "TestSetupName");
                        }
                    }
                }
            }
            catch (Exception) 
            {
                //ignore
            }
            #endregion DAS Settings

            #region Load Groups
            try
            {
                using (var sql = DbOperations.GetCommand())
                {
                    //sp_GetTestSetupObjects
                    sql.CommandText = string.Format("SELECT * FROM [{0}] WHERE {1}=@{1}", DbOperations.TestSetups.TestSetupObjectsTable,
                        DbOperations.TestSetups.TestSetupObjectFields.TestSetupName.ToString());
                    DbOperations.CreateParam(sql, string.Format("@{0}", DbOperations.TestSetups.TestSetupObjectFields.TestSetupName.ToString()),
                        SqlDbType.NVarChar, Name);
                    using (var ds = DbOperations.Connection.QueryDataSet(sql))
                    {
                        if (ds.Tables.Count > 0 && ds.Tables[0].Rows.Count > 0)
                        {
                            TestTemplateList.ConvertToDictionary(ds.Tables[0], ref tblTestObjects, DbOperations.TestSetups.TestSetupObjectFields.TestSetupName.ToString());
                        }
                    }
                }
            }
            catch (Exception) 
            {
                //ignore
            }
            #endregion Objects

            #region Load Channel Settings
            try
            {
                using (var sql = DbOperations.GetCommand())
                {
                    //sp_GetTestChannelSettings
                    sql.CommandText = string.Format("SELECT * FROM [{0}] WHERE {1}=@{1}", DbOperations.TestSetups.ChannelSettingsTable,
                        DbOperations.TestSetups.ChannelSettingFields.TestName.ToString());
                    DbOperations.CreateParam(sql, string.Format("@{0}", DbOperations.TestSetups.ChannelSettingFields.TestName.ToString()),
                        SqlDbType.NVarChar, Name);

                    using (var ds = DbOperations.Connection.QueryDataSet(sql))
                    {
                        if (ds.Tables.Count > 0 && ds.Tables[0].Rows.Count > 0)
                        {
                            TestTemplateList.ConvertToDictionary(ds.Tables[0], ref tblChannelSettings, DbOperations.TestSetups.ChannelSettingFields.TestName.ToString());
                        }
                    }
                }
            }
            catch (Exception) 
            {
                //ignore
            }
            #endregion Channel Settings

            #region Load Meta Data
            try
            {
                using (var sql = DbOperations.GetCommand())
                {
                    //sp_GetTestSetupObjectMetaData
                    sql.CommandText = string.Format("SELECT * FROM [{0}] WHERE {1}=@{1}", DbOperations.TestSetups.TestObjectMetaDataTable,
                        DbOperations.TestSetups.TestObjectMetaDataFields.SetupName.ToString());
                    DbOperations.CreateParam(sql, string.Format("@{0}", DbOperations.TestSetups.TestObjectMetaDataFields.SetupName.ToString()),
                        SqlDbType.NVarChar, Name);
                    using (var ds = DbOperations.Connection.QueryDataSet(sql))
                    {
                        if (ds.Tables.Count > 0 && ds.Tables[0].Rows.Count > 0)
                        {
                            TestTemplateList.ConvertToDictionary(ds.Tables[0], ref tblMetaData, DbOperations.TestSetups.TestObjectMetaDataFields.SetupName.ToString());
                        }
                    }
                }
            }
            catch (Exception) 
            {
                //ignore
            }
            #endregion Meta Data

            #region Load Hardware Overrides
            try
            {
                _hardwareOverrides.Clear();
                using (var sql = DbOperations.GetCommand())
                {
                    //sp_GetTestSetupHardware
                    sql.CommandText = string.Format("SELECT * FROM [{0}] WHERE {1}=@{1}",
                        DbOperations.TestSetups.HardwareTable,
                        DbOperations.TestSetups.HardwareFields.TestSetupName.ToString());

                    DbOperations.CreateParam(sql,
                        string.Format("@{0}", DbOperations.TestSetups.HardwareFields.TestSetupName.ToString()),
                        SqlDbType.NVarChar,
                        Name);

                    var columns = Enum.GetValues(typeof(DbOperations.TestSetups.HardwareFields))
                        .Cast<DbOperations.TestSetups.HardwareFields>().ToArray();

                    using (var ds = DbOperations.Connection.QueryDataSet(sql))
                    {
                        foreach (DataRow row in ds.Tables[0].Rows)
                        {
                            var bAdd = true;
                            var hid = "";

                            foreach (var column in columns)
                            {
                                var o = row[column.ToString()];
                                if (DBNull.Value.Equals(o)) { continue; }
                                switch (column)
                                {
                                    case DbOperations.TestSetups.HardwareFields.AddOrRemove:
                                        bAdd = Convert.ToBoolean(o);
                                        break;
                                    case DbOperations.TestSetups.HardwareFields.HardwareId:
                                        hid = Convert.ToString(o);
                                        break;
                                    case DbOperations.TestSetups.HardwareFields.TestSetupName:
                                        //don't need
                                        break;
                                }
                            }
                            if (!string.IsNullOrEmpty(hid))
                            {                                
                                _hardwareOverrides[hid] = new HardwareInclusionInstruction(hid,
                                    bAdd ? HardwareInclusionInstruction.Actions.Add : HardwareInclusionInstruction.Actions.Remove);
                            }
                        }
                    }
                }
            }
            catch (Exception)
            {
                //ignore
            }
            #endregion
            //now all the structures are populated from the db, we just have to process and populate into classes

            #region Load Calculated Channels
            _calculatedChannels.Clear();
            var calculatedChannels = new List<CalculatedValueClass>();
            try
            {
                using (var sql = DbOperations.GetCommand())
                {
                    //sp_GetCalculatedChannels
                    sql.CommandText = string.Format("SELECT * from {0} WHERE [{1}]=@1",
                        DbOperations.CalculatedChannels.Table,
                        DbOperations.CalculatedChannels.Fields.TestSetupName.ToString());
                    DbOperations.CreateParam(sql, "@1", SqlDbType.NVarChar, Name);
                    using (var ds = DbOperations.Connection.QueryDataSet(sql))
                    {
                        foreach (DataRow row in ds.Tables[0].Rows)
                        {
                            try
                            {
                                calculatedChannels.Add(new CalculatedValueClass(row));
                            }
                            catch (Exception)
                            {
                                //ignore
                            }
                        }
                    }
                }
            }
            catch (Exception)
            {
                //ignore
            }

            #endregion Calculated Channels

            #region Load Level Triggers
            LevelTriggerChannels.Clear();
            var levelTriggerChannels = new List<LevelTriggerChannel>();
            try
            {
                using (var sql = DbOperations.GetCommand())
                {
                    //sp_GetLevelTriggers
                    sql.CommandText = string.Format("SELECT * FROM [{0}] WHERE {1}=@1",
                        DbOperations.LevelTriggers.Table,
                        DbOperations.LevelTriggers.Fields.TestSetupName.ToString());
                    DbOperations.CreateParam(sql, "@1", SqlDbType.NVarChar, Name);
                    using (var ds = DbOperations.Connection.QueryDataSet(sql))
                    {
                        foreach (DataRow row in ds.Tables[0].Rows)
                        {
                            try
                            {
                                levelTriggerChannels.Add(new LevelTriggerChannel(row));
                            }
                            catch (Exception) 
                            {
                                //ignore
                            }
                        }
                    }
                }
            }
            catch (Exception) 
            {
                //ignore
            }
            #endregion

            #region Process Groups
            _testObjects.Clear();
            _addedGroups.Clear();
            TestObjectsAndAddedGroupsList.Clear();

            if (tblTestObjects.ContainsKey(Name))
            {
                foreach (var row in tblTestObjects[Name])
                {
                    var serialNumber = "";
                    var excitationWarmupTimeMs = 0;
                    var targetSampleRate = 20000D;
                    var testobject = "?";
                    var position = "?";
                    var tsofields = Enum.GetValues(typeof(DbOperations.TestSetups.TestSetupObjectFields))
                        .Cast<DbOperations.TestSetups.TestSetupObjectFields>().ToArray();
                    foreach (var field in tsofields)
                    {
                        var o = row[field.ToString()];
                        if (DBNull.Value.Equals(o)) { continue; }
                        switch (field)
                        {
                            case DbOperations.TestSetups.TestSetupObjectFields.TestSetupName:
                                break;
                            case DbOperations.TestSetups.TestSetupObjectFields.TestObjectType:
                                testobject = Convert.ToString(o);
                                break;
                            case DbOperations.TestSetups.TestSetupObjectFields.TestObjectSerialNumber:
                                serialNumber = Convert.ToString(o);
                                break;
                            case DbOperations.TestSetups.TestSetupObjectFields.TestObjectPosition:
                                position = Convert.ToString(o);
                                break;
                            case DbOperations.TestSetups.TestSetupObjectFields.TargetSampleRate:
                                targetSampleRate = Convert.ToDouble(o);
                                break;
                            case DbOperations.TestSetups.TestSetupObjectFields.LocalOnly:
                                break;
                            case DbOperations.TestSetups.TestSetupObjectFields.ExcitationWarmupTimeMS:
                                excitationWarmupTimeMs = Convert.ToInt32(o);
                                break;
                        }
                    }
                    try
                    {
                        if (TestTemplateList.SysBuiltObject(serialNumber))
                        {
                            AddAddedGroup(serialNumber, testobject, position);
                        }
                        else
                        {
                            AddTestObject(serialNumber, excitationWarmupTimeMs, targetSampleRate, testobject, position);
                        }
                    }
                    catch (Exception) 
                    {
                        //ignore
                    }
                }
            }
            #endregion Groups

            #region Process Graphs
            if (null != _testGraphs) { _testGraphs.Clear(); }
            if (tblTestGraphs.ContainsKey(Name))
            {
                foreach (var row in tblTestGraphs[Name])
                {
                    var tg = new TestGraph(this)
                    {
                        GraphName = Convert.ToString(row["GraphName"]),
                        GraphDescription = Convert.ToString(row["GraphDescription"]),
                        UseDomainMin = Convert.ToBoolean(row["UseDomainMin"]),
                        DomainMin = Convert.ToDouble(row["DomainMin"]),
                        UseDomainMax = Convert.ToBoolean(row["UseDomainMax"]),
                        DomainMax = Convert.ToDouble(row["DomainMax"]),
                        UseRangeMin = Convert.ToBoolean(row["UseRangeMin"]),
                        RangeMin = Convert.ToDouble(row["RangeMin"]),
                        UseRangeMax = Convert.ToBoolean(row["UseRangeMax"]),
                        RangeMax = Convert.ToDouble(row["RangeMax"]),
                    };
                    tg.SetChannelsFromSQL(Convert.ToString(row["Channels"]));
                    tg.SetThresholdsFromSQL(Convert.ToString(row["Thresholds"]));
                    AddTestGraph(tg);
                }
            }
            #endregion Graphs

            #region Process DASSettings
            var settings = new List<DASSettings>();
            if (tblTestSetupDASSettings.ContainsKey(Name))
            {
                settings.AddRange(tblTestSetupDASSettings[Name].Select(row => new DASSettings
                {
                    BatteryCheck = Convert.ToBoolean(row["BatteryCheck"])
                    ,
                    BatteryVoltageMax = Convert.ToDouble(row["BatteryVoltageMax"])
                    ,
                    BatteryVoltageMin = Convert.ToDouble(row["BatteryVoltageMin"])
                    ,
                    DASSerialNumber = Convert.ToString(row["DASSerialNumber"])
                    ,
                    ExcitationWarmupTimeMS = Convert.ToInt32(row["ExcitationWarmupTimeMS"])
                    ,
                    HardwareAAF = Convert.ToDouble(row["AAFilterRate"])
                    ,
                    InputVoltageMax = Convert.ToDouble(row["InputVoltageMax"])
                    ,
                    InputVoltageMin = Convert.ToDouble(row["InputVoltageMin"])
                    ,
                    PostTriggerSeconds = Convert.ToDouble(row["PostTriggerSeconds"])
                    ,
                    PreTriggerSeconds = Convert.ToDouble(row["PreTriggerSeconds"])
                    ,
                    SampleRate = Convert.ToDouble(row["TargetSampleRate"])
                    ,
                    StatusLineCheck = Convert.ToBoolean(row["StatusLineCheck"])
                }));
            }
            #endregion DASSettings

            #region Process ChannelSettings
            if (tblChannelSettings.ContainsKey(Name))
            {
                var cFields = Enum.GetValues(typeof(DbOperations.TestSetups.ChannelSettingFields)).Cast<DbOperations.TestSetups.ChannelSettingFields>().ToArray();

                foreach (var row in tblChannelSettings[Name])
                {
                    string testobjectname = null;
                    string channelname = null;
                    string sensorserial = null;
                    string setting = null;
                    foreach (var cf in cFields)
                    {
                        switch (cf)
                        {
                            case DbOperations.TestSetups.ChannelSettingFields.TestName: break;
                            case DbOperations.TestSetups.ChannelSettingFields.Setting:
                                setting = row[cf.ToString()] as string;
                                break;
                            case DbOperations.TestSetups.ChannelSettingFields.TestObjectName:
                                testobjectname = row[cf.ToString()] as string;
                                break;
                            case DbOperations.TestSetups.ChannelSettingFields.ChannelId:
                                channelname = row[cf.ToString()] as string;
                                break;
                            case DbOperations.TestSetups.ChannelSettingFields.SensorSerial:
                                sensorserial = row[cf.ToString()] as string;
                                break;
                        }
                    }
                    if (string.IsNullOrEmpty(testobjectname) || string.IsNullOrEmpty(channelname) ||
                        string.IsNullOrEmpty(setting)) continue;
                    try
                    {
                        var sd = TestTemplateList.GetSensorFromSettings(setting, sensorserial);
                        if (null != sd)
                        {
                            if (sd.FilterClassIso == "?")
                            {
                                sd.FilterClassIso = "P"; // "Prefiltered > CFC 1000" (Unfiltered)
                            }
                            SetSensor(sd, testobjectname, channelname);
                        }
                    }
                    catch (Exception) 
                    {
                        //ignore
                    }
                }

            }
            DASSettings = settings.ToArray();
            #endregion Channel Settings

            #region Process MetaData
            var metas = new Dictionary<char, TestObjectMetaData>();
            var setupMeta = new TestSetupMetaData(Properties.Settings.Default.RequireXCrashCompatibilityForISOExports);
            if (tblMetaData.ContainsKey(Name))
            {
                foreach (var row in tblMetaData[Name])
                {
                    var bOptional = Convert.ToBoolean(row[DbOperations.TestSetups.TestObjectMetaDataFields.Optional.ToString()]);
                    var pname = Convert.ToString(row[DbOperations.TestSetups.TestObjectMetaDataFields.PropName.ToString()]);
                    var pvalue = Convert.ToString(row[DbOperations.TestSetups.TestObjectMetaDataFields.PropValue.ToString()]);
                    var to = "?";
                    try
                    {
                        if (row[DbOperations.TestSetups.TestObjectMetaDataFields.TestObject.ToString()] is string)
                        {
                            to = (row[DbOperations.TestSetups.TestObjectMetaDataFields.TestObject.ToString()] as string);
                        }
                        else
                        {
                            to = Convert.ToString(Convert.ToChar(Convert.ToInt32(row[DbOperations.TestSetups.TestObjectMetaDataFields.TestObject.ToString()])));
                        }
                    }
                    catch (Exception) 
                    {
                        //ignore
                    }

                    //little wonky here, sometimes the character comes in as a number, sometimes as a string.
                    //if we end up with a string longer than 1 character, then we definitely need to convert it.
                    //there are no strings of length 2 that are a valid character
                    if (to.Length > 1)
                    {
                        try
                        {
                            if (int.TryParse(to, out int iTemp)) { to = Convert.ToString(Convert.ToChar(iTemp)); }
                        }
                        catch (Exception) 
                        {
                            //ignore
                        }
                    }

                    var version = Convert.ToDouble(row[DbOperations.TestSetups.TestObjectMetaDataFields.Version.ToString()]);
                    if (to == "_")
                    {
                        if ((pname == "Title") && ((pvalue == "NOVALUE") || (string.IsNullOrWhiteSpace(pvalue))))
                        {
                            pvalue = Name;
                        }
                        else if (pname == "DateOfTheTest")
                        {
                            pvalue = DateTime.Now.ToString("yyyy-MM-dd");
                        }
                        setupMeta.SetProperty(new MetaData(pname, bOptional, pvalue, version), Properties.Settings.Default.RequireXCrashCompatibilityForISOExports);
                    }
                    else
                    {
                        if (!metas.ContainsKey(to[0])) { metas.Add(to[0], new TestObjectMetaData(to[0])); }
                        metas[to[0]].SetProperty(new MetaData(pname, bOptional, pvalue, version));
                    }
                }
            }

            foreach (var v in metas.Values)
            {
                SetMetaData(v.TestObject, v);
            }
            SetTestSetupMetaData(setupMeta);
            _bIsLoaded = true;
            #endregion

            #region Process Calculated Channels
            foreach (var cc in calculatedChannels)
            {
                AddCalculatedChannel(cc);
            }
            #endregion Process Calculated Channels

            #region Process Level Triggers
            foreach (var lt in levelTriggerChannels)
            {
                SetLevelTrigger(lt);
            }
            #endregion Process Level Triggers
            ApplyHardwareOverrides();
        }

        //        #region Validate

        public static bool ValidateTestSetupName(ref List<string> errors, TestTemplate CurrentTestSetup)
        {
            if (string.IsNullOrWhiteSpace(CurrentTestSetup.Name))
            {
                errors.Add("EditTestSetup_NameRequired"/*Strings.StringResources.EditTestSetup_NameRequired*/);
                return false;
            }
            if (CurrentTestSetup.Name == "QuickSensorCheck_DefaultTestName"/*Strings.StringResources.QuickSensorCheck_DefaultTestName*/ &&
                !CurrentTestSetup.QuickSensorCheck)
            {
                errors.Add("QuickSensorCheck_DefaultTestNameInvalid"/*Strings.StringResources.QuickSensorCheck_DefaultTestNameInvalid*/);
                return false;
            }

            if (DiskUtility.ValidateFileAndPathNameChars(CurrentTestSetup.Name))
            {
                var nameToCheck = CurrentTestSetup.Name.ToLower();
                if (nameToCheck.Equals("iso") || nameToCheck.Equals("csv") || nameToCheck.Equals("realtime"))
                {
                    errors.Add("EditTestSetup_NameCannotBeISOCSVOrRealtime"/*Strings.StringResources.EditTestSetup_NameCannotBeISOCSVOrRealtime*/);
                    return false;
                }

                var encoding = Encoding.GetEncoding("UTF-8");
                var nameInBytes = encoding.GetBytes(nameToCheck);
                if (nameInBytes.Length == nameToCheck.Length) return true;
                errors.Add("EditTestSetup_NameCannotContainDoubleByteCharacters"/*Strings.StringResources.EditTestSetup_NameCannotContainDoubleByteCharacters*/);
                return false;
            }
            errors.Add("EditTestSetup_NameContainsInvalidCharacters"/*Strings.StringResources.EditTestSetup_NameContainsInvalidCharacters*/);
            //fatal
            return false;
        }
        public static bool Validate(ref List<string> errors, ref List<string> warnings, bool displayWindow, TestTemplate CurrentTestSetup, bool bValid, StrictLevel strictness, bool markIsCompleteUnchecked, bool bWarnOnNotFullyAssigned)
        {
            //I'm not sure of all the entry points into this function
            //it seems like there are many
            //however there are definite times we _don't_ want to just blindly change the iscompleteunchecked flag
            //just because we want to do some validation on the test plan ...
            //for now I just fixed the ones I know shouldn't be changing the flag blindly
            //and preserved current behavior for the rest ...            

            var bHasHardware = false;
            var bHasChannels = false;

            var testobjects = new List<TestTestObject>();
            testobjects.AddRange(CurrentTestSetup.TestObjects);
            testobjects.AddRange(CurrentTestSetup.AddedGroups);

            var serialNumbersProcessed = new Dictionary<string, bool>();
            var hardwareChannelIdsProcessed = new Dictionary<string, bool>();
            var channelLookup = new Dictionary<string, HardwareChannel>();
            var usedISOCodesLookup = new Dictionary<string, bool>();


            var availableAnalogChannels = 0;
            var availableDigitalInputChannels = 0;
            var availableDigitalOutputChannels = 0;
            var availableSquibChannels = 0;

            if (testobjects.Any())
            {
                //this is using the assumption that all testobjects now have the same list of hardware
                foreach (var lastTO in testobjects)
                {
                    lastTO.RefreshHardware();
                    foreach (var h in lastTO.Hardware)
                    {
                        if (null != h)
                        {
                            var ser = h.SerialNumber;
                            var hFromDB = DASHardwareList.GetList().GetHardware(h.GetHardware().GetId());
                            if (null == hFromDB)
                            {
                                var err = string.Format("Test includes hardware which is no longer available ({0})" /*Strings.StringResources.TestTemplate_HardwareNotFound*/, ser);
                                continue;
                            }
                        }
                        else
                        {
                            continue;
                        }

                        var hType = h.GetHardwareTypeEnum();
                        if (hType == Hardware.HardwareTypes.SLICE_EthernetController
                            || hType == Hardware.HardwareTypes.SLICE_Distributor
                            || hType == Hardware.HardwareTypes.SLICE_LabEthernet)
                        {
                            continue;
                        }
                        bHasHardware = true;

                        if (CurrentTestSetup.DoAutoArm)
                        {
                            switch (hType)
                            {
                                case Hardware.HardwareTypes.TDAS_Pro_Rack:
                                case Hardware.HardwareTypes.TDAS_LabRack:
                                case Hardware.HardwareTypes.G5INDUMMY:
                                case Hardware.HardwareTypes.G5VDS:
                                    errors.Add("Some hardware does not support auto-arming");
                                    break;
                            }
                        }
                        for (var i = 0; i < h.Channels.Length; i++)
                        {
                            var ch = h.Channels[i];
                            if (channelLookup.ContainsKey(ch.GetId())) continue;
                            channelLookup.Add(ch.GetId(), ch);
                            if (ch.IsSupportedBridgeType(Test.Module.Channel.Sensor.BridgeType.SQUIB))
                            { availableSquibChannels++; i++; /*bypass next channel as it's also a squib*/ }
                            else if (ch.IsSupportedBridgeType(Test.Module.Channel.Sensor.BridgeType.DigitalInput))
                            { availableDigitalInputChannels++; }
                            else if (ch.IsSupportedBridgeType(Test.Module.Channel.Sensor.BridgeType.TOMDigital))
                            { availableDigitalOutputChannels++; }
                            else { availableAnalogChannels++; }
                        }
                    }
                }
                if (!bHasHardware && bWarnOnNotFullyAssigned)
                {
                    errors.Add("Test requires Hardware");
                }
            }
            else
            {
                errors.Add("Test requires at least one Group");
            }

            foreach (var to in testobjects)
            {
                var isoTO = to.GetISOTestObject();
                foreach (var ch in isoTO.AllChannels)
                {
                    if (!ch.Required) { continue; }
                    bHasChannels = true;
                    if (string.IsNullOrWhiteSpace(ch.SensorSerialNumber))
                    {
                        if (!errors.Contains("Some channels have no sensor assigned." /*Strings.StringResources.EditTestSetupPage_NoSensorOnChannel*/) && bWarnOnNotFullyAssigned)
                        { errors.Add("Some channels have no sensor assigned." /*Strings.StringResources.EditTestSetupPage_NoSensorOnChannel*/); }
                    }
                    else
                    {
                        if (serialNumbersProcessed.ContainsKey(ch.SensorSerialNumber))
                        {
                            var err = string.Format("Sensor {0} appears multiple times in the test setup." /*Strings.StringResources.EditTestSetupPage_SerialNumberAppearsTwice*/, ch.SensorSerialNumber);
                            if (!errors.Contains(err)) { errors.Add(err); return false; }
                        }
                        else
                        { serialNumbersProcessed.Add(ch.SensorSerialNumber, true); }
                        var sd = CurrentTestSetup.GetSensor(ch.SensorSerialNumber, to.SerialNumber, ch.Name);
                        if (null == sd)
                        {
                            var err = string.Format("Couldn't find sensor {0} for channel {1} for group {2}" /*Strings.StringResources.EditTestSetupPage_CouldNotFindSensor*/, ch.SensorSerialNumber, ch.Name, to.DisplaySerialNumber);
                            if (!errors.Contains(err)) { errors.Add(err); }
                        }
                        else
                        {
                            if (sd.IsSquib())
                            {
                                availableSquibChannels--;
                                if (sd.SquibFireDelayMS + sd.SquibFireDurationMS > CurrentTestSetup.PostTriggerSeconds * 1000)
                                { errors.Add(string.Format("Sensor '{0}' on channel '{1}' has output that exceeds post-trigger time."/*Strings.StringResources.TestTemplate_InsufficientPostTriggerLength*/, sd.SerialNumber, ch.Name)); }
                            }
                            else if (sd.IsDigitalInput()) { availableDigitalInputChannels--; }
                            else if (sd.IsDigitalOutput())
                            {
                                availableDigitalOutputChannels--;
                                if (sd.DigitalOutputDelayMS + sd.DigitalOutputDurationMS > CurrentTestSetup.PostTriggerSeconds * 1000)
                                { errors.Add(string.Format("Sensor '{0}' on channel '{1}' has output that exceeds post-trigger time." /*Strings.StringResources.TestTemplate_InsufficientPostTriggerLength*/, sd.SerialNumber, ch.Name)); }
                            }
                            else { availableAnalogChannels--; }

                            var sensor = SensorsCollection.SensorsList.GetSensorBySerialNumber(ch.SensorSerialNumber);
                            if (sensor != null)
                            {
                                var sensorDimension = sensor.PhysicalDimension;
                                if (((ISO13499FileDb.IsoDb.GetPhysicalDimensionByIso(sensorDimension) != null) &&
                                    ((ISO13499FileDb.IsoDb.GetPhysicalDimensionByIso(ch.Channel.Physical_Dimension) != null) &&
                                    (sd.IncompatibleSensorAssignment(sensorDimension, ch.Channel.Physical_Dimension)))))
                                {
                                    var err = string.Format("Dimension ({0}) of sensor ({1}) is different than dimension ({2}) of channel ({3}) in group {4}", //Strings.StringResources.EditTestSetupPage_IncompatibleSensorNotSupported,
                                        ISO13499FileDb.IsoDb.GetPhysicalDimensionByIso(sensorDimension).Text_L1,
                                        ch.SensorSerialNumber,
                                        ISO13499FileDb.IsoDb.GetPhysicalDimensionByIso(ch.Channel.Physical_Dimension).Text_L1,
                                        ch.Name, to.DisplaySerialNumber);
                                    switch (SerializedSettings.IsoChannelSensorCompatibilityLevel)
                                    {
                                        case IsoChannelSensorCompatibilityLevels.DontAllow:
                                            if (!errors.Contains(err)) { errors.Add(err); }
                                            bValid = false;
                                            break;
                                        case IsoChannelSensorCompatibilityLevels.Warn:
                                            if (!warnings.Contains("Warning"/*Strings.StringResources.EditObjectSensorsControl_Warning*/ + ": " + err)) { warnings.Add("Warning"/*Strings.StringResources.EditObjectSensorsControl_Warning */+ ": " + err); }
                                            break;
                                    }
                                }
                            }
                            if (!sd.IsDigitalOutput() && (CurrentTestSetup.GetISOTestSetupISOSupportLevel() == SerializedSettings.ISOSupportLevels.ISO_ONLY))
                            {
                                if (sd.MainLocation.Contains('?') ||
                                    sd.FineLocation1.Contains('?') ||
                                    sd.FineLocation2.Contains('?') ||
                                    sd.FineLocation3.Contains('?') ||
                                    sd.Direction.Contains('?') ||
                                    sd.PhysicalDimension.Contains('?'))
                                {
                                    var isoto = to.GetISOTestObject();
                                    foreach (var isotoChannel in isoto.AllChannels)
                                    {
                                        //reapplying channel iso settings here with the exception of filter class, position, and test object
                                        if (ch.Name != isotoChannel.Name) continue;
                                        sd.MainLocation = ch.Channel.Trans_Main_Loc;
                                        sd.FineLocation1 = ch.Channel.Fine_Loc_1;
                                        sd.FineLocation2 = ch.Channel.Fine_Loc_2;
                                        sd.FineLocation3 = ch.Channel.Fine_Loc_3;
                                        sd.Direction = ch.Channel.Direction;
                                        sd.PhysicalDimension = ch.Channel.Physical_Dimension;
                                    }
                                }
                                if (usedISOCodesLookup.ContainsKey(sd.ISOCode))
                                {
                                    var err = $"TestTemplate_DuplicateISOCode {sd.ISOCode}";
                                    if (!errors.Contains(err)) { errors.Add(err); }
                                }
                                else { usedISOCodesLookup[sd.ISOCode] = true; }
                            }

                            SensorCalibration sc = null;
                            var preferredExcitation = sd.SupportedExcitation[0];
                            sc = SensorCalibration.GetLatestCalibrationBySerialNumberAndExcitation(sd, preferredExcitation);
                            if (null == sc)
                            {
                                bValid = false;
                                var err = $"EditTestSetupPage_MissingCalibration {ch.Name}, {sd.SerialNumber}";
                                if (!errors.Contains(err)) { errors.Add(err); }
                            }
                            else
                            {
                                var now = DateTime.Now;
                                var days = sc.CalibrationDate.AddDays(sd.CalInterval).Subtract(now).TotalDays;
                                if (SerializedSettings.TestSetupDefaultDontAllowOutOfCalSensors && ((days < 0) || (days < Properties.Settings.Default.CalWarningPeriodDays)))
                                {
                                    bValid = false;
                                    var err = $"OverdueSensors_CalibrationDateOverdueOrNear {ch.Name}, {sd.SerialNumber}";
                                    if (!errors.Contains(err)) { errors.Add(err); }
                                }
                            }

                            if (!string.IsNullOrWhiteSpace(ch.HardwareId))
                            {
                                if (!channelLookup.ContainsKey(ch.HardwareId))
                                {
                                    var err = $"EditTestSetupPage_InvalidHardware {ch.Name}, {to.DisplaySerialNumber}";
                                    if (!errors.Contains(err)) { errors.Add(err); }
                                }
                                else
                                {
                                    if (hardwareChannelIdsProcessed.ContainsKey(ch.HardwareId))
                                    {
                                        bValid = false;
                                        var err = $"EditTestSetupPage_HardwareAlreadyInUse, {ch.Name}, {to.DisplaySerialNumber}";
                                        if (!errors.Contains(err)) { errors.Add(err); }
                                    }
                                    else
                                    {
                                        hardwareChannelIdsProcessed.Add(ch.HardwareId, true);
                                        var hch = channelLookup[ch.HardwareId];
                                        if (sd.ByPassFilter &&
                                            ((hch.Hardware.GetHardwareTypeEnum() != Hardware.HardwareTypes.TDAS_Pro_Rack) &&
                                             (hch.Hardware.GetHardwareTypeEnum() != Hardware.HardwareTypes.TDAS_LabRack)))
                                        {
                                            var err = $"EditTestSetupPage_BypassAAFilterNotSupported, {ch.Name}, {to.DisplaySerialNumber}";
                                            if (!errors.Contains(err)) { errors.Add(err); }
                                        }
                                        else
                                        {
                                            if (hch.IsSupportedBridgeType(sd.Bridge)) continue;
                                            var err = $"EditTestSetupPage_BridgeNotSupported, {sd.Bridge}, {ch.Name}, {to.DisplaySerialNumber}";
                                            if (!errors.Contains(err)) { errors.Add(err); }
                                        }
                                    }
                                }
                            }
                        }
                    }
                }
            }
            if (!bHasChannels) { errors.Add("EditTestSetupPage_NoChannelsInTest"); }
            if (availableAnalogChannels < 0 && !CurrentTestSetup.AllowMissingSensors && bWarnOnNotFullyAssigned)
            {
                if (!errors.Contains("EditTestSetupPage_NeedMoreAnalogChannels") && !errors.Contains("EditTestSetupPage_NoHardwareInTest"))
                { errors.Add("EditTestSetupPage_NeedMoreAnalogChannels"); }
            }
            if (availableDigitalInputChannels < 0 && !CurrentTestSetup.AllowMissingSensors && bWarnOnNotFullyAssigned)
            {
                if (!errors.Contains("EditTestSetupPage_NeedMoreDigitalInputChannels") && !errors.Contains("EditTestSetupPage_NoHardwareInTest"))
                { errors.Add("EditTestSetupPage_NeedMoreDigitalInputChannels"); }
            }
            if (availableDigitalOutputChannels < 0 && !CurrentTestSetup.AllowMissingSensors && bWarnOnNotFullyAssigned)
            {
                if (!errors.Contains("EditTestSetupPage_NeedMoreDigitalOutputChannels"/*Strings.StringResources.EditTestSetupPage_NeedMoreDigitalOutputChannels*/) && !errors.Contains("EditTestSetupPage_NoHardwareInTest"/*Strings.StringResources.EditTestSetupPage_NoHardwareInTest */))
                { errors.Add("EditTestSetupPage_NeedMoreDigitalOutputChannels"/*Strings.StringResources.EditTestSetupPage_NeedMoreDigitalOutputChannels*/); }
            }
            if (availableSquibChannels < 0 && !CurrentTestSetup.AllowMissingSensors && bWarnOnNotFullyAssigned)
            {
                if (!errors.Contains("EditTestSetupPage_NeedMoreSquibChannels"/*Strings.StringResources.EditTestSetupPage_NeedMoreSquibChannels*/) && !errors.Contains("EditTestSetupPage_NoHardwareInTest"/*Strings.StringResources.EditTestSetupPage_NoHardwareInTest */))
                { errors.Add(""/*Strings.StringResources.EditTestSetupPage_NeedMoreSquibChannels*/); }
            }

            if (!ValidateTestSetupName(ref errors, CurrentTestSetup)) { bValid = false; }
            ValidateStorageSpace(ref errors, CurrentTestSetup);//not fatal
            ValidateUploadFolder(ref errors, CurrentTestSetup);//not fatal
            ValidateAutoArmAllowability(ref errors, CurrentTestSetup);

            return bValid;
        }

        public static bool ValidateUploadFolder(ref List<string> errors, TestTemplate currentTest)
        {
            //if we have a export ini file, we still allow a blank upload folder
            if (!currentTest.UploadData || !string.IsNullOrWhiteSpace(currentTest.UploadFolder)) return true;
            if (SerializedSettings.ExportINIFile.Length > 0) { return true; }
            errors.Add("TestTestTemplate_InvalidUploadPath"/*Strings.StringResources.TestTestTemplate_InvalidUploadPath*/);
            return false;
        }

        private static bool ValidateAutoArmAllowability(ref List<string> errors, TestTemplate currentTest)
        {
            if (!currentTest.DoAutoArm || Properties.Settings.Default.AllowAutoArm) return true;
            errors.Add("EditTestSetupInfo_AutoArmNotAllowed");
            return false;
        }

        public static bool ValidateStorageSpace(ref List<string> errors, TestTemplate currentTest)
        {
            var bStorageSpaceValid = true;
            var preTriggerSeconds = currentTest.PreTriggerSeconds;
            var postTriggerSeconds = currentTest.PostTriggerSeconds;
            var sampleRate = currentTest.SamplesPerSecond;
            var secondsToRecord = preTriggerSeconds + postTriggerSeconds;
            var sampleClocksToRecord = (ulong)(secondsToRecord * sampleRate + 1);

            var das = new List<DASHardware>();
            foreach (var to in currentTest.TestObjects)
            {
                foreach (var h in to.Hardware)
                {
                    if (!das.Contains(h)) { das.Add(h); }
                }
            }
            foreach (var to in currentTest.AddedGroups)
            {
                foreach (var h in to.Hardware)
                {
                    if (!das.Contains(h)) { das.Add(h); }
                }
            }
            foreach (var d in das)
            {
                double maxSampleClockTicks = d.GetMaxMemoryLong();
                if (!(maxSampleClockTicks > 0)) continue;
                if (!(sampleClocksToRecord > maxSampleClockTicks)) continue;
                bStorageSpaceValid = false;
                errors.Add(string.Format("TestTemplate_InsufficientMemory"/*Strings.StringResources.TestTemplate_InsufficientMemory*/, d.SerialNumber, maxSampleClockTicks));
            }
            return bStorageSpaceValid;
        }

        public void AddTestGraph(TestGraph tg)
        {
            _testGraphs.Add(tg);
        }
        /// <summary>
        /// holds test settings that don't have individual db columns
        /// </summary>
        private readonly TestSettingDictionary _settings = CreateSettingsDictionary();
        /// <summary>
        /// loads values from a serialized string into the settings table
        /// </summary>
        /// <param name="s"></param>
        public void LoadSettings(string s)
        {
            _settings.LoadSettings(s);
        }

        /// <summary>
        /// constructs a settings table with some default values
        /// default values can then have their values changed by LoadSettings if we are loading from a db
        /// </summary>
        /// <returns></returns>
        private static TestSettingDictionary CreateSettingsDictionary()
        {
            var settings = new TestSettingDictionary();

            var mySettings = Enum.GetValues(typeof(TestSettingsEnum)).Cast<TestSettingsEnum>().ToArray();
            foreach (var setting in mySettings)
            {
                switch (setting)
                {
                    case TestSettingsEnum.ArmCheckListStep:
                        settings.SetValue(new TestSetting(TestSettingsEnum.ArmCheckListStep.ToString(), Properties.Settings.Default.DefaultTestArmCheckListStep.ToString(), Properties.Settings.Default.DefaultTestArmCheckListStep.ToString()));
                        break;
                    case TestSettingsEnum.CheckListBatteryVoltageCheck:
                        settings.SetValue(new TestSetting(TestSettingsEnum.CheckListBatteryVoltageCheck.ToString(), Properties.Settings.Default.DefaultTestCheckListBatteryVoltageCheck.ToString(), Properties.Settings.Default.DefaultTestCheckListBatteryVoltageCheck.ToString()));
                        break;
                    case TestSettingsEnum.CheckListInputVoltageCheck:
                        settings.SetValue(new TestSetting(TestSettingsEnum.CheckListInputVoltageCheck.ToString(), Properties.Settings.Default.DefaultTestCheckListInputVoltageCheck.ToString(), Properties.Settings.Default.DefaultTestCheckListInputVoltageCheck.ToString()));
                        break;
                    case TestSettingsEnum.CheckListSensorIDCheck:
                        settings.SetValue(new TestSetting(TestSettingsEnum.CheckListSensorIDCheck.ToString(), Properties.Settings.Default.DefaultTestCheckListSensorIDCheck.ToString(), Properties.Settings.Default.DefaultTestCheckListSensorIDCheck.ToString()));
                        break;
                    case TestSettingsEnum.CheckListSquibResistanceCheck:
                        settings.SetValue(new TestSetting(TestSettingsEnum.CheckListSquibResistanceCheck.ToString(), Properties.Settings.Default.DefaultTestCheckListSquibResistanceCheck.ToString(), Properties.Settings.Default.DefaultTestCheckListSquibResistanceCheck.ToString()));
                        break;
                    case TestSettingsEnum.CheckListTriggerStartCheck:
                        settings.SetValue(new TestSetting(TestSettingsEnum.CheckListTriggerStartCheck.ToString(), Properties.Settings.Default.DefaultTestCheckListTriggerStartCheck.ToString(), Properties.Settings.Default.DefaultTestCheckListTriggerStartCheck.ToString()));
                        break;
                    case TestSettingsEnum.CheckListMustPass:
                        settings.SetValue(new TestSetting(TestSettingsEnum.CheckListMustPass.ToString(), Properties.Settings.Default.DefaultTestCheckListMustPass.ToString(), Properties.Settings.Default.DefaultTestCheckListMustPass.ToString()));
                        break;
                    case TestSettingsEnum.EW:
                        settings.SetValue(new TestSetting(TestSettingsEnum.EW.ToString(), Properties.Settings.Default.DefaultTestExcitationWarmupMS.ToString(System.Globalization.CultureInfo.InvariantCulture), Properties.Settings.Default.DefaultTestExcitationWarmupMS.ToString(System.Globalization.CultureInfo.InvariantCulture)));
                        break;
                    default:
                        throw new NotSupportedException("unsupported setting:" + setting.ToString());
                }
            }


            //initialize here
            return settings;
        }

        /// <summary>
        /// returns the iso support level of object (as determined by it's groups, or the current application support level)
        /// </summary>
        /// <returns></returns>
        public SerializedSettings.ISOSupportLevels GetISOTestSetupISOSupportLevel()
        {
            var nonISOTO = GetNonISOTestObject();
            foreach (var to in TestObjects)
            {
                if (to == nonISOTO)
                {
                    //if it only has digital outputs, it could be either a non iso or an iso group, so ignore it
                    var isoto = to.GetISOTestObject();
                    if (isoto.AllChannels.Where(ch => ch.Required && !string.IsNullOrWhiteSpace(ch.SensorSerialNumber)).Any(ch => !SensorData.IsTestSpecificDigitalOutSN(ch.SensorSerialNumber)))
                    {
                        return SerializedSettings.ISOSupportLevels.NO_ISO;
                    }
                }
                else
                {
                    return to.GetObjectISOLevel();
                }
            }
            foreach (var to in AddedGroups) { return SerializedSettings.ISOSupportLevels.ISO_ONLY; }
            return SerializedSettings.ISOSupportLevel;
        }
        private TestTestObject CreateNonISOGroupIfNecessary()
        {
            foreach (var group in _testObjects)
            {
                if (group.SerialNumberOrOriginalSerialNumber == NON_ISO_INTERNAL_GROUP_NAME)
                {
                    return group;
                }
            }
            //if you got here it wasn't found
            var guid = Guid.NewGuid();
            var template = new TestObjectTemplate();

            var isoTO = template.ToISOTestObjectTemplate();
            isoTO.Embedded = true;
            isoTO.TemplateName = guid.ToString();
            
            var db = ISO13499FileDb.IsoDb;
            template = new TestObjectTemplate(isoTO, ref db);

            var to = new TestObject { Template = template };
            to.GetISOTestObject().Embedded = true;
            to.GetISOTestObject().OriginalSerialNumber = NON_ISO_INTERNAL_GROUP_NAME;
            to.SerialNumber = guid.ToString();

            var g = new TestTestObject(to);
            _testObjects.Add(g);
            TestObjectsAndAddedGroupsList.Add(g);
            return g;
        }

        public TestTestObject GetNonISOTestObject()
        {
            return CreateNonISOGroupIfNecessary();
        }

        public void SetTestObjects(bool bMemoryOnly, TestTestObject[] value)
        {
            if (!bMemoryOnly)
            {
                MarkIsCompleteUnchecked();
            }

            var position = 0;
            if (SerializedSettings.ISOSupportLevel == SerializedSettings.ISOSupportLevels.NO_ISO)
            {
                foreach (var to in value)
                {
                    if (to.GetObjectISOLevel() != SerializedSettings.ISOSupportLevels.NO_ISO) continue;
                    var availablePositions = to.AvailablePositions;
                    if (position < availablePositions.Length)
                    {
                        to.Position = availablePositions[position];
                        position++;
                    }
                    else
                    {
                        throw new NotSupportedException("TestTemplate::Not enough positions for groups in test");
                    }
                }
            }

            SetProperty(ref _testObjects, new List<TestTestObject>(value), TestTemplateTags.TestObjects.ToString());
            OnPropertyChanged(TestTemplateTags.AvailableTestObjects.ToString()); //No longer needed for added test objects combobox, but still used to update the remaining list of available test objects
            OnPropertyChanged(TestTemplateTags.AllTestObjects.ToString());
            OnPropertyChanged("TestObjectsAndAddedGroups");
        }
        public void AddTestObject(TestObject to, int excitationWarmupMs, double targetSampleRate, string testobject, string position)
        {
            if (null != to)
            {
                var tto = new TestTestObject(to)
                {
                    ExcitationWarmupTimeMS = excitationWarmupMs,
                    TargetSampleRate = targetSampleRate
                };
                tto.SetPosition(position);
                tto.SetTestObject(testobject);

                //if this is the NON ISO group (which is created by default), the replace the original NONE group ...
                if (tto.SerialNumberOrOriginalSerialNumber == NON_ISO_INTERNAL_GROUP_NAME)
                {
                    var index = -1;
                    for (var i = 0; i < TestObjectsAndAddedGroupsList.Count; i++)
                    {
                        if (TestObjectsAndAddedGroupsList[i].SerialNumberOrOriginalSerialNumber != NON_ISO_INTERNAL_GROUP_NAME) continue;
                        index = i;
                        break;
                    }
                    if (index >= 0)
                    {
                        TestObjectsAndAddedGroupsList.RemoveAt(index);
                    }

                    index = -1;
                    for (var i = 0; i < _testObjects.Count; i++)
                    {
                        if (_testObjects[i].SerialNumberOrOriginalSerialNumber != NON_ISO_INTERNAL_GROUP_NAME) continue;
                        index = i;
                        break;
                    }
                    if (index >= 0)
                    {
                        _testObjects.RemoveAt(index);
                    }
                }

                _testObjects.Add(tto);
                TestObjectsAndAddedGroupsList.Add(tto);
                OnPropertyChanged(TestTemplateTags.TestObjects.ToString());
                OnPropertyChanged(TestTemplateTags.DefaultNumberRealtimeGraphs.ToString());
            }
        }

        public void AddTestObject(string serialNumber, int excitationWarmupMs, double targetSampleRate, string testobject, string position)
        {
            var to = TestObjectList.TestObjectsList.GetTestObject(serialNumber);
            AddTestObject(to, excitationWarmupMs, targetSampleRate, testobject, position);
            OnPropertyChanged(TestTemplateTags.DefaultNumberRealtimeGraphs.ToString());
        }

        public void AddAddedGroup(TestObject to, string testobject, string position)
        {
            if (null == to) return;
            var tto = new TestTestObject(to);
            tto.SetPosition(position);
            tto.SetTestObject(testobject);
            tto.SerialNumberConverted = tto.SerialNumber.Remove(0, Name.Length + 1);
            tto.TestSetupName = Name;
            _addedGroups.Add(tto);
            TestObjectsAndAddedGroupsList.Add(tto);
            OnPropertyChanged(TestTemplateTags.DefaultNumberRealtimeGraphs.ToString());
        }
        public void AddAddedGroup(string serialNumber, string testobject, string position)
        {
            var to = TestObjectList.TestObjectsList.GetAddedGroup(serialNumber);
            AddAddedGroup(to, testobject, position);
            OnPropertyChanged(TestTemplateTags.DefaultNumberRealtimeGraphs.ToString());
        }

        public int GetNumberOfRealtimeSupportedChannels()
        {
            var count = 0;
            foreach (var to in TestObjects)
            {
                var isoto = to.GetISOTestObject();
                count += isoto.AllChannels.Where(ch => ch.Required && !string.IsNullOrWhiteSpace(ch.SensorSerialNumber)).Select(ch => GetSensor(ch.SensorSerialNumber, to.SerialNumber, ch.Name)).Where(sd => null != sd).Count(sd => !sd.IsDigitalInput() && !sd.IsDigitalOutput() && !sd.IsSquib());
            }
            foreach (var to in AddedGroups)
            {
                var isoto = to.GetISOTestObject();
                count += isoto.AllChannels.Where(ch => ch.Required && !string.IsNullOrWhiteSpace(ch.SensorSerialNumber)).Select(ch => GetSensor(ch.SensorSerialNumber, to.SerialNumber, ch.Name)).Where(sd => null != sd).Count(sd => !sd.IsDigitalInput() && !sd.IsDigitalOutput() && !sd.IsSquib());
            }
            if (0 == count) { count = MaxRealtimeChannels; }
            return count;
        }
        private readonly Dictionary<string, File.PersistentChannel> _oldChannelLookup = new Dictionary<string, File.PersistentChannel>();

        private readonly Dictionary<string, Event.Module.Channel> _channelLookup = new Dictionary<string, Event.Module.Channel>();
        private readonly Dictionary<string, bool> _sessionOpen = new Dictionary<string, bool>();
        public void AddCalculatedChannel(CalculatedValueClass ch)
        {
            _calculatedChannels.Add(ch);
        }
        private readonly Dictionary<char, TestObjectMetaData> _metaDataLookup = new Dictionary<char, TestObjectMetaData>();

        private TestSetupMetaData _testSetupMeta = new TestSetupMetaData(Properties.Settings.Default.RequireXCrashCompatibilityForISOExports);
        public TestSetupMetaData GetTestMetaData()
        {
            return _testSetupMeta;
        }

        public void SetTestSetupMetaData(TestSetupMetaData meta)
        {
            _testSetupMeta = meta;
        }
        public TestObjectMetaData[] GetMetaData()
        {
            var metas = new List<TestObjectMetaData>();
            foreach (var to in TestObjects.Select(x=>x.TestObject))
            {
                if (to == null) continue;
                var m = GetMetaData(to.Test_Object[0]);
                if (!metas.Contains(m)) { metas.Add(m); }
            }
            foreach (var to in AddedGroups.Select(x=>x.TestObject))
            {
                if (to == null) continue;
                var m = GetMetaData(to.Test_Object[0]);
                if (!metas.Contains(m)) { metas.Add(m); }
            }
            metas.Sort(CompareMeta);
            return metas.ToArray();
        }
        public TestObjectMetaData GetMetaData(char testobject)
        {
            if (!_metaDataLookup.ContainsKey(testobject))
            {
                _metaDataLookup.Add(testobject, new TestObjectMetaData(testobject));
            }
            return _metaDataLookup[testobject];
        }
        private int CompareMeta(TestObjectMetaData left, TestObjectMetaData right)
        {
            if (left == right) { return 0; }
            if (null == left) { return -1; }
            return null == right ? 1 : left.TestObject.CompareTo(right.TestObject);
        }
        public void SetMetaData(char testobject, TestObjectMetaData meta)
        {
            _metaDataLookup[testobject] = meta;
        }
    }
}