using DbAPI.Connections;
using DbAPI.Errors;
using DbAPIUI.Connections;
using DbAPIUI.Logging;
using DTS.Common.Classes.ChannelCodes;
using DTS.Common.Classes.Channels;
using DTS.Common.Classes.Groups;
using DTS.Common.Classes.Hardware;
using DTS.Common.Classes.Sensors;
using DTS.Common.Classes.Tags;
using DTS.Common.Classes.TestSetups;
using DTS.Common.Enums.Channels;
using DTS.Common.Interface.Channels;
using DTS.Common.Interface.Channels.ChannelCodes;
using DTS.Common.Interface.DataRecorders;
using DTS.Common.Interface.Groups;
using DTS.Common.Interface.Sensors;
using DTS.Common.Interface.Tags;
using DTS.Common.Interface.TestSetups.TestSetupsList;
using DTS.Common.Utilities.Logging;
using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Threading.Tasks;
using System.Windows.Forms;
namespace DbAPIUI
{
    public partial class Form1 : Form
    {
        private ConnectionDetailsEx _connectionDetails = null;
        private TextLogger _APILogger;
        private const int MAX_LOG_FILE_SIZE = 4194304;
        private void LogMessage(string message)
        {
            _APILogger.LogMessage(message);
        }
        private string GetLogStartMessage()
        {
            return $"OS:          {Environment.OSVersion}{Environment.NewLine}" +
                   $"MachineName: {Environment.MachineName}{Environment.NewLine}" +
                   $"Environment: {Environment.Version}{Environment.NewLine}" +
                    "===========================================================";                   
        }
        private void OnLoggerException(Exception ex)
        {
            Trace.WriteLine($"Exception: {ex.Message} - {ex.StackTrace}");
        }
        public Form1()
        {
            if (!Directory.Exists("Logs"))
            {
                Directory.CreateDirectory("Logs");
            }
            _APILogger = new TextLogger(@"Logs\DTS.Log", OnLoggerException, MAX_LOG_FILE_SIZE);
            DbAPI.DbAPI.InitializeLogger(MAX_LOG_FILE_SIZE, @"Logs\DBAPI.Log", 783);
            _APILogger.LogStartMessage = GetLogStartMessage();
            APILogger.Writer = LogMessage;
            _connectionDetails = new ConnectionDetailsEx() { SqlDbPath = ConnectionDetailsEx.GetSqlServerLocalDbPath(), 
                ODBCToolsPath = DTS.Common.Utils.Database.GetODBCToolsPath(APILogger.Log) };
            InitializeComponent();
            
            propertyGridConnection.SelectedObject = _connectionDetails;
        }
        protected override void OnFormClosed(FormClosedEventArgs e)
        {
            LogManager.Log(TraceEventType.Information, LogManager.LogEvents.Application, "Application closing");
            base.OnFormClosed(e);
        }
        private void tabControl1_SelectedIndexChanged(object sender, EventArgs e)
        {
        }

        private void btnConnectionConnect_Click(object sender, EventArgs e)
        {
            Enabled = false;
            LogManager.Log(TraceEventType.Information, LogManager.LogEvents.Connections, $"Connecting {_connectionDetails}");
            Task.Run(() =>
            {
                Cursor.Current = Cursors.WaitCursor;
                var ret = DbAPI.DbAPI.Connections.ConnectToDb(_connectionDetails);
                LogManager.Log(TraceEventType.Information, LogManager.LogEvents.Connections, $"Connection {_connectionDetails} result: {ret}");
            }).ContinueWith((t1) =>
            {
                BeginInvoke(new Action(() =>
                {                    
                    Enabled = true;
                    Cursor.Current = Cursors.Default;
                }));
            });

        }
        public static void UpdateScreenLog(string msg)
        {
            if( !(ActiveForm is Form1 form1)) { return; }
            form1.UpdateLog(msg);
        }
        private const int LINES_TO_SHOW = 7;
        private void UpdateLog(string msg)
        {
            BeginInvoke(new Action(() => 
            {
                var lines = rtbHistory.Lines.ToList();
                lines.Add(msg);
                while( lines.Count > LINES_TO_SHOW)
                {
                    lines.RemoveAt(0);
                }
                rtbHistory.Lines = lines.ToArray();
            }));
        }
        private void btnLoginsLogin_Click(object sender, EventArgs e)
        {
            Enabled = false;
            var connection = comboBoxConnections.SelectedItem as ConnectionDetails;
            var userName = tbUserName.Text;
            var password = tbPassword.Text;
            Task.Run(() => 
            {
                Cursor.Current = Cursors.WaitCursor;
                LogManager.Log(TraceEventType.Information, LogManager.LogEvents.Connections, $"Logging in {userName}");
                var ret = DbAPI.DbAPI.Connections.LoginUser(connection, userName, password, out var user);
                LogManager.Log(TraceEventType.Information, LogManager.LogEvents.Connections, $"Login result: {ret}");
            }).ContinueWith((t1) => 
            {
                BeginInvoke(new Action(() => 
                { 
                    Enabled = true;
                    Cursor.Current = Cursors.Default;
                }));
            });
        }

        private void LoginPage_Enter(object sender, EventArgs e)
        {
            tbUserName.Text = "";
            tbPassword.Text = "";

            comboBoxConnections.Items.Clear();

            var connections = DbAPI.DbAPI.Connections.GetActiveConnections();
            comboBoxConnections.Items.AddRange(connections);
        }

        private void button1_Click(object sender, EventArgs e)
        {

        }

        private void tabPageVersion_Enter(object sender, EventArgs e)
        {
            comboBoxConnectionsVersionSet.Items.Clear();
            comboConnectionsVersionGet.Items.Clear();

            var connections = DbAPI.DbAPI.Connections.GetLoggedInUsers();

            foreach (var con in connections)
            {
                var user = new LoggedInUser() { Details = con };
                comboBoxConnectionsVersionSet.Items.Add(user);
                comboConnectionsVersionGet.Items.Add(user);
            }
            comboBoxConnectionsVersionSet.SelectedItem = null;
            comboConnectionsVersionGet.SelectedItem = null;
        }

        private void btnVersionGet_Click(object sender, EventArgs e)
        {
            var user = comboConnectionsVersionGet.SelectedItem as LoggedInUser;

            LogManager.Log(TraceEventType.Information, LogManager.LogEvents.Application, $"Getting database version ({user}): ");
            var ret = DbAPI.DbAPI.Database.GetDatabaseVersion(user.Details.Item1, user.Details.Item2, out var version);
            
            if (ErrorCodes.ERROR_SUCCESS == ret)
            {
                LogManager.Log(TraceEventType.Information, LogManager.LogEvents.Application, $"Database version result: {ret} Version: {version}");
                tbVersionGet.Text = version.ToString();
            }
            else
            {
                LogManager.Log(TraceEventType.Information, LogManager.LogEvents.Application, $"Database version error: {ret}");
                tbVersionGet.Text = "---";
            }
            
        }

        private void btnVersionSet_Click(object sender, EventArgs e)
        {
            var user = comboBoxConnectionsVersionSet.SelectedItem as LoggedInUser;
            
            if( !int.TryParse(tbVersionSet.Text, out var version))
            {
                return;
            }

            LogManager.Log(TraceEventType.Information, LogManager.LogEvents.Application, $"Inserting database version (user): {version}");
            var ret = DbAPI.DbAPI.Database.InsertDatabaseVersion(user.Details.Item1, user.Details.Item2, version,
                0, DateTime.Now, "", user.Details.Item1.UserName);
            LogManager.Log(TraceEventType.Information, LogManager.LogEvents.Application, $"Database version insert result: {ret}");
        }

        private void tabPageDataRecorders_Enter(object sender, EventArgs e)
        {
            DASGridView.DataSource = null;
            cbDASGetConnections.Items.Clear();
            var connections = DbAPI.DbAPI.Connections.GetLoggedInUsers();

            foreach (var con in connections)
            {
                var user = new LoggedInUser() { Details = con };
                cbDASGetConnections.Items.Add(user);
            }
            cbDASGetConnections.SelectedItem = null;
        }

        private void btnDASGet_Click(object sender, EventArgs e)
        {
            try
            {
                DASGridView.DataSource = null;
                var user = cbDASGetConnections.SelectedItem as LoggedInUser;
                LogManager.Log( TraceEventType.Information, LogManager.LogEvents.DAS, $"DASGet ({user}) [all non prototypes]");
                var ret = DbAPI.DbAPI.DAS.DASGet(user.Details.Item1, user.Details.Item2, user.Details.Item2.ClientDbVersion, null, null, out var das);                
                if (ret == ErrorCodes.ERROR_SUCCESS)
                {
                    var count = 0;
                    if( null != das && das.Any()) { count = das.Length; }
                    LogManager.Log(TraceEventType.Information, LogManager.LogEvents.DAS, $"DASGet result: {ret} Count: {count}");
                    DASGridView.DataSource = das;
                    cbDASChannelsGetDAS.DisplayMember = "SerialNumber";
                    cbDASChannelsGetDAS.Items.Clear();
                    cbDASChannelsGetDAS.Items.AddRange(das);
                    cbDASDelete.DisplayMember = "SerialNumber";
                    cbDASDelete.Items.Clear();
                    cbDASDelete.Items.AddRange(das);
                }
                else { LogManager.Log(TraceEventType.Information, LogManager.LogEvents.DAS, $"DASGet result: {ret}"); }
            }
            catch( Exception ex)
            {
                LogManager.Log(TraceEventType.Error, LogManager.LogEvents.Application, ex.Message);
            }
        }

        private void btnDASChannelsGet_Click(object sender, EventArgs e)
        {
            dgDASChannels.DataSource = null;
            var user = cbDASGetConnections.SelectedItem as LoggedInUser;
            if( null == user) 
            {
                LogManager.Log(TraceEventType.Error, LogManager.LogEvents.DAS, $"DASChannelsGet - no user/connection");
                return; 
            }
            if( !(cbDASChannelsGetDAS.SelectedItem is IDASDBRecord das) )
            {
                LogManager.Log(TraceEventType.Error, LogManager.LogEvents.DAS, $"DASChannelsGet - no selected DAS");
                return;
            }
            var hr = DbAPI.DbAPI.DAS.DASChannelsGet(user.Details.Item1, user.Details.Item2, $"{das.SerialNumber}_{das.DASType}", out var channels);
            if( 0 == hr)
            {
                var count = 0;
                if( null != channels && channels.Any()) { count = channels.Length; }
                LogManager.Log(TraceEventType.Information, LogManager.LogEvents.DAS, $"DASChannelsGet - result: {hr} - count: {count}");
                dgDASChannels.DataSource = channels;
            }
            else { LogManager.Log(TraceEventType.Information, LogManager.LogEvents.DAS, $"DASChannelsGet - result: {hr}"); }
        }

        private void btnDASDelete_Click(object sender, EventArgs e)
        {
            dgDASChannels.DataSource = null;
            var user = cbDASGetConnections.SelectedItem as LoggedInUser;
            if (null == user)
            {
                LogManager.Log(TraceEventType.Error, LogManager.LogEvents.DAS, $"DASDelete - no user/connection");
                return;
            }
            if (!(cbDASDelete.SelectedItem is IDASDBRecord das))
            {
                LogManager.Log(TraceEventType.Error, LogManager.LogEvents.DAS, $"DASDelete - no selected DAS");
                return;
            }
            LogManager.Log(TraceEventType.Information, LogManager.LogEvents.DAS, $"DASDelete ({user}) - {das.SerialNumber}");
            var hr = DbAPI.DbAPI.DAS.DASDelete(user.Details.Item1, user.Details.Item2, das.DASId, das.SerialNumber, das.TestId != null);
            LogManager.Log(TraceEventType.Information, LogManager.LogEvents.DAS, $"DASDelete result: {hr}");
        }

        private void btnDASInsert_Click(object sender, EventArgs e)
        {
            dgDASChannels.DataSource = null;
            var user = cbDASGetConnections.SelectedItem as LoggedInUser;
            if (null == user)
            {
                LogManager.Log(TraceEventType.Error, LogManager.LogEvents.DAS, $"DASInsert - no user/connection");
                return;
            }
            var das = CreateFakeDAS();
            var channels = CreateFakeChannels(das);
            LogManager.Log( TraceEventType.Information, LogManager.LogEvents.DAS, $"DASInsert ({user}) : {das}");
            var hr = DbAPI.DbAPI.DAS.DASInsert(user.Details.Item1, user.Details.Item2, das);
            LogManager.Log(TraceEventType.Information, LogManager.LogEvents.DAS, $"DASInsert result: {hr}");
            if( 0 != hr) { return;  }
            foreach( var channel in channels)
            {
                LogManager.Log(TraceEventType.Information, LogManager.LogEvents.DAS, $"DASChannelsInsert ({user}) : ch#{1+channel.ChannelIdx}");
                var iCh = (IDASChannelDBRecord)channel;
                hr = DbAPI.DbAPI.DAS.DASChannelsInsert(user.Details.Item1, user.Details.Item2,
                    $"{das.SerialNumber}_{das.DASType}", ref iCh);
                LogManager.Log(TraceEventType.Information, LogManager.LogEvents.DAS, $"DASChannelsInsert result: {hr}");
            }
        }

        private DASDBRecord CreateFakeDAS()
        {
            var das = new DASDBRecord();
            das.SerialNumber = Guid.NewGuid().ToString().Substring(0, 10);
            das.Position = "";
            das.LastModifiedBy = "";
            das.LastModified = DateTime.Now;
            das.LastUsed = DateTime.Now;
            das.LastUsedBy = "NUNIT";
            das.DASType = 18;
            das.ChannelTypes = new[] { 1, 2, 3 };
            das.Channels = 3;
            das.Position = "";
            return das;
        }
        private DASChannelDBRecord[] CreateFakeChannels(DASDBRecord das)
        {
            var list = new List<DASChannelDBRecord>();

            for (var i = 0; i < das.Channels; i++)
            {
                var channel = new DASChannelDBRecord();
                channel.ChannelIdx = i;
                channel.DaschannelId = i;
                channel.DASDisplayOrder = i;
                channel.Dasid = das.DASId;
                channel.HardwareId = $"{das.SerialNumber}_{das.DASType}";
                channel.LocalOnly = false;
                channel.ModuleArrayIndex = 0;
                channel.ModuleSerialNumber = "FakeMod0";
                list.Add(channel);
            }

            return list.ToArray();
        }

        private void btnGetCalibrations_Click(object sender, EventArgs e)
        {
            dgSensorCalibrations.DataSource = null;
            var user = cbSensorCalConnections.SelectedItem as LoggedInUser;
            if (null == user)
            {
                LogManager.Log(TraceEventType.Error, LogManager.LogEvents.DAS, $"SensorsCalibrationsGet - no user/connection");
                return;
            }
            int? sensorId = null;
            string serialNumber = null;
            if(!string.IsNullOrWhiteSpace(tbSensorCalibrationsSerialNumber.Text))
            {
                serialNumber = tbSensorCalibrationsSerialNumber.Text;
            }
            if(!string.IsNullOrWhiteSpace(tbSensorCalibrationsSensorId.Text))
            {
                if( int.TryParse(tbSensorCalibrationsSensorId.Text, out var temp))
                {
                    sensorId = temp;
                }
            }
            LogManager.Log(TraceEventType.Information, LogManager.LogEvents.Sensors, $"SensorCalibrationsGet - DASId: {sensorId} - SerialNumber: {serialNumber}");
            var hr = DbAPI.DbAPI.Sensors.SensorCalibrationsGet(user.Details.Item1, user.Details.Item2, sensorId, serialNumber, out var cals);
            if (0 == hr)
            {
                int count = 0;
                if( null != cals && cals.Any()) { count = cals.Length; }
                LogManager.Log(TraceEventType.Information, LogManager.LogEvents.Sensors, $"SensorCalibrationsGet - result: {hr} - count: {count}");
                dgSensorCalibrations.DataSource = cals.ToArray();
            }
            else { LogManager.Log(TraceEventType.Information, LogManager.LogEvents.Sensors, $"SensorCalibrationsGet - result: {hr}"); }
        }

        private void tabPageSensors_Enter(object sender, EventArgs e)
        {
            var connections = DbAPI.DbAPI.Connections.GetLoggedInUsers();

            var list = new List<LoggedInUser>();
            foreach (var con in connections)
            {
                list.Add(new LoggedInUser() { Details = con });
            }
            cbSensorsConnections.Items.Clear();
            cbSensorsConnections.Items.AddRange(list.ToArray());
            propertyGridSensorAnalogInsert.SelectedObject = new AnalogDbRecord();
        }

        private void btnSensorsSensorsGet_Click(object sender, EventArgs e)
        {
            dgSensors.DataSource = null;
            var user = cbSensorsConnections.SelectedItem as LoggedInUser;
            if (null == user)
            {
                LogManager.Log(TraceEventType.Error, LogManager.LogEvents.DAS, $"SensorsAnalogGet - no user/connection");
                return;
            }
            int? sensorId = null;
            string serialNumber = null;
            string eid = null;
            if (!string.IsNullOrWhiteSpace(tbSensorsSerialNumber.Text))
            {
                serialNumber = tbSensorsSerialNumber.Text;
            }
            if (!string.IsNullOrWhiteSpace(tbSensorsSensorId.Text))
            {
                if (int.TryParse(tbSensorsSensorId.Text, out var temp))
                {
                    sensorId = temp;
                }
            }
            if(!string.IsNullOrWhiteSpace(tbSensorsEID.Text))
            {
                eid = tbSensorsEID.Text;
            }
            LogManager.Log(TraceEventType.Information, LogManager.LogEvents.Sensors, $"SensorsAnalogGet - DASId: {sensorId} - SerialNumber: {serialNumber} - EID: {eid}");

            var hr = DbAPI.DbAPI.Sensors.SensorsAnalogGet(user.Details.Item1, user.Details.Item2, sensorId, serialNumber, eid, out var records);
            if (0 == hr)
            {
                int count = 0;
                if (null != records && records.Any()) { count = records.Length; }
                LogManager.Log(TraceEventType.Information, LogManager.LogEvents.Sensors, $"SensorsAnalogGet - result: {hr} - count: {count}");
                dgSensors.DataSource = records.ToArray();
            }
            else { LogManager.Log(TraceEventType.Information, LogManager.LogEvents.Sensors, $"SensorsAnalogGet - result: {hr}"); }
        }

        private void dgSensors_ColumnAdded(object sender, DataGridViewColumnEventArgs e)
        {
            //hide the tags column as the default viewer doesn't know how to handle it
            if (e.Column.DataPropertyName == "TagsBlobBytes")
            {
                dgSensors.Columns.Remove(e.Column);
            }
        }

        private void btnSensorsAnalogInsert_Click(object sender, EventArgs e)
        {
            var user = cbSensorsConnections.SelectedItem as LoggedInUser;
            if (null == user)
            {
                LogManager.Log(TraceEventType.Error, LogManager.LogEvents.Sensors, $"SensorsAnalogInsertUpdate - no user/connection");
                return;
            }
            var record = propertyGridSensorAnalogInsert.SelectedObject as IAnalogDbRecord;
            if( null == record)
            {
                LogManager.Log(TraceEventType.Error, LogManager.LogEvents.Sensors, $"SensorsAnalogInsertUpdate - no user/connection");
                return;
            }
            var hr = DbAPI.DbAPI.Sensors.SensorsAnalogUpdateInsert(user.Details.Item1, user.Details.Item2, record);
            LogManager.Log(TraceEventType.Information, LogManager.LogEvents.Sensors, $"SensorsAnalogInsertUpdate - result: {hr}");
        }

        private void tabSensorCalibrations_Enter(object sender, EventArgs e)
        {
            var connections = DbAPI.DbAPI.Connections.GetLoggedInUsers();

            var list = new List<LoggedInUser>();
            foreach (var con in connections)
            {
                list.Add(new LoggedInUser() { Details = con });
            }
            cbSensorCalConnections.Items.Clear();
            cbSensorCalConnections.Items.AddRange(list.ToArray());
            propertyGridSensorCals.SelectedObject = new SensorCalDbRecord();
        }

        private void btnSensorCalCommit_Click(object sender, EventArgs e)
        {
            var user = cbSensorCalConnections.SelectedItem as LoggedInUser;
            if (null == user)
            {
                LogManager.Log(TraceEventType.Error, LogManager.LogEvents.Sensors, $"SensorCalibrationsInsert - no user/connection");
                return;
            }
            var record = propertyGridSensorCals.SelectedObject as ISensorCalDbRecord;
            if( null == record)
            {
                LogManager.Log(TraceEventType.Error, LogManager.LogEvents.Sensors, $"SensorCalibrationsInsert - no calibration");
                return;
            }
            var hr = DbAPI.DbAPI.Sensors.SensorCalibrationsInsert(user.Details.Item1, user.Details.Item2, record, 0, false);
            LogManager.Log(TraceEventType.Information, LogManager.LogEvents.Sensors, $"SensorCalibrationsInsert - result {hr}");
        }

        private void tabTestSetups_PageEnter(object sender, EventArgs e)
        {
            var connections = DbAPI.DbAPI.Connections.GetLoggedInUsers();

            var list = new List<LoggedInUser>();
            foreach (var con in connections)
            {
                list.Add(new LoggedInUser() { Details = con });
            }
            cbConnectionsTestSetups.Items.Clear();
            cbConnectionsTestSetups.Items.AddRange(list.ToArray());
            propertyGridTestSetup.SelectedObject = new TestSetupRecord();
        }

        private void btnGetTestSetups_Click(object sender, EventArgs e)
        {
            var user = cbConnectionsTestSetups.SelectedItem as LoggedInUser;
            if (null == user)
            {
                LogManager.Log(TraceEventType.Error, LogManager.LogEvents.Sensors, $"TestSetupsGet - no user/connection");
                return;
            }
            var hr = DbAPI.DbAPI.TestSetups.TestSetupsGet(user.Details.Item1, user.Details.Item2, user.Details.Item2.ClientDbVersion,
                null, null, double.NaN, double.NaN, false, false, out var records, out var errors);
            if( 0 != hr)
            {
                LogManager.Log(TraceEventType.Error, LogManager.LogEvents.TestSetups, $"TestSetupsGet failed, hr: {hr}");
                return;
            }
            if( null == records || 0 == records.Length)
            {
                LogManager.Log(TraceEventType.Warning, LogManager.LogEvents.TestSetups, $"TestSetupsGet - no records");
                return;
            }
            cbTestSetups.Items.Clear();
            foreach( var record in records)
            {
                cbTestSetups.Items.Add(new TestSetupHelper(record));
            }
            LogManager.Log(TraceEventType.Information, LogManager.LogEvents.TestSetups, $"TestSetupsGet - success");
        }

        public class TestSetupHelper : TestSetupRecord
        {
            public TestSetupHelper(ITestSetupRecord record) : base(record)
            {
            }
            public override string ToString()
            {
                return Name;
            }
        }

        private void btnTestSetupsGet_Click(object sender, EventArgs e)
        {
            var user = cbConnectionsTestSetups.SelectedItem as LoggedInUser;
            if (null == user)
            {
                LogManager.Log(TraceEventType.Error, LogManager.LogEvents.TestSetups, $"TestSetupGet - no user/connection");
                return;
            }
            var testSetup = cbTestSetups.SelectedItem as TestSetupHelper;
            if(null == testSetup)
            {
                LogManager.Log(TraceEventType.Error, LogManager.LogEvents.TestSetups, $"GetTestSetup - no test setup");
                return;
            }
            var hr = DbAPI.DbAPI.TestSetups.TestSetupsGet(user.Details.Item1, user.Details.Item2, user.Details.Item2.ClientDbVersion, 
                testSetup.Id, null, double.NaN, double.NaN,false, false, out var records, out var errors);
            if( 0 != hr)
            {
                LogManager.Log(TraceEventType.Error, LogManager.LogEvents.TestSetups, $"TestSetupGet - Error, hr: {hr}");
                return;
            }
            if( null == records || 0 == records.Length)
            {
                LogManager.Log(TraceEventType.Error, LogManager.LogEvents.TestSetups, $"TestSetupGet - no test setup");
                testSetupsGridView.DataSource = null;
                return;
            }
            testSetupsGridView.DataSource = records.ToArray();
            LogManager.Log(TraceEventType.Information, LogManager.LogEvents.TestSetups, $"TestSetupGet - success");
        }

        private void dgTestSetupsGridView_ColumnAdded(object sender, DataGridViewColumnEventArgs e)
        {
            //hide the tags column as the default viewer doesn't know how to handle it
            if (e.Column.DataPropertyName == "TagsBlobBytes")
            {
                testSetupsGridView.Columns.Remove(e.Column);
            }
        }

        private void btnTestSetupCommit_Click(object sender, EventArgs e)
        {
            var user = cbConnectionsTestSetups.SelectedItem as LoggedInUser;
            if (null == user)
            {
                LogManager.Log(TraceEventType.Error, LogManager.LogEvents.TestSetups, $"TestSetupGet - no user/connection");
                return;
            }
            var record = propertyGridTestSetup.SelectedObject as ITestSetupRecord;
            if( null == record)
            {
                LogManager.Log(TraceEventType.Error, LogManager.LogEvents.TestSetups, $"TestSetupCommit - no test setup");
                return;
            }
            var hr = DbAPI.DbAPI.TestSetups.TestSetupsUpdateInsert(user.Details.Item1, user.Details.Item2, user.Details.Item2.ClientDbVersion, ref record);

            if (0 == hr)
            {
                LogManager.Log(TraceEventType.Information, LogManager.LogEvents.TestSetups, $"TestSetupCommit - success");
            }
            else { LogManager.Log(TraceEventType.Error, LogManager.LogEvents.TestSetups, $"TestSetupCommit - Error: {hr}"); }
        }

        private void tabGroups_Enter(object sender, EventArgs e)
        {
            var connections = DbAPI.DbAPI.Connections.GetLoggedInUsers();

            var list = new List<LoggedInUser>();
            foreach (var con in connections)
            {
                list.Add(new LoggedInUser() { Details = con });
            }
            cbGroupsConnections.DataSource = list.ToArray();
            propertyGridGroups.SelectedObject = new GroupDbRecord();
        }
        public class GroupHelper : GroupDbRecord
        {
            public GroupHelper(IGroupDbRecord record) : base(record)
            {

            }
            public override string ToString()
            {
                if( Embedded) { return $"Embedded\\{DisplayName}"; }
                return SerialNumber;
            }
        }
        private void btnGroupsGet_Click(object sender, EventArgs e)
        {
            var user = cbGroupsConnections.SelectedItem as LoggedInUser;
            if (null == user)
            {
                LogManager.Log(TraceEventType.Error, LogManager.LogEvents.TestSetups, $"GroupsGet - no user/connection");
                return;
            }
            var hr = DbAPI.DbAPI.Groups.GroupsGet(user.Details.Item1, user.Details.Item2, null, null, null, null, null, out var records);
            if( 0 == hr)
            {
                LogManager.Log(TraceEventType.Information, LogManager.LogEvents.TestSetups, $"GroupsGet - success");
                if( null != records && records.Any())
                {
                    dgGroupsView.DataSource = records.ToArray();
                    cbGroupsToDelete.Items.Clear();
                    foreach( var record in records)
                    {
                        cbGroupsToDelete.Items.Add(new GroupHelper(record));
                    }
                }
                else { dgGroupsView.DataSource = null; }
            }
            else
            {
                LogManager.Log(TraceEventType.Error, LogManager.LogEvents.TestSetups, $"GroupsGet - hr: {hr}");
            }
        }

        private void btnGroupDelete_Click(object sender, EventArgs e)
        {
            var user = cbGroupsConnections.SelectedItem as LoggedInUser;
            if (null == user)
            {
                LogManager.Log(TraceEventType.Error, LogManager.LogEvents.TestSetups, $"GroupsDelete - no user/connection");
                return;
            }
            var groupToDelete = cbGroupsToDelete.SelectedItem as GroupHelper;
            if( null == groupToDelete)
            {
                LogManager.Log(TraceEventType.Error, LogManager.LogEvents.TestSetups, $"GroupsDelete - no group selected");
                return;
            }

            var hr = DbAPI.DbAPI.Groups.GroupsDelete(user.Details.Item1, user.Details.Item2, groupToDelete.Id, out var errorString);
            if( 0 == hr)
            {
                LogManager.Log(TraceEventType.Information, LogManager.LogEvents.TestSetups, $"GroupsDelete - success, error: {errorString}");
            }
            else
            {
                LogManager.Log(TraceEventType.Error, LogManager.LogEvents.TestSetups, $"GroupsDelete - hr: {hr}, error: {errorString}");
            }
        }

        private void btnGroupInsert_Click(object sender, EventArgs e)
        {
            var user = cbGroupsConnections.SelectedItem as LoggedInUser;
            if (null == user)
            {
                LogManager.Log(TraceEventType.Error, LogManager.LogEvents.TestSetups, $"GroupsInsert - no user/connection");
                return;
            }
            var group = propertyGridGroups.SelectedObject as IGroupDbRecord;
            if (null == group)
            {
                LogManager.Log(TraceEventType.Error, LogManager.LogEvents.TestSetups, $"GroupsInsert - no group selected");
                return;
            }
            var hr = DbAPI.DbAPI.Groups.GroupsInsert(user.Details.Item1, user.Details.Item2, ref group);
            if( 0 == hr)
            {
                LogManager.Log(TraceEventType.Information, LogManager.LogEvents.TestSetups, $"GroupsInsert - success");
                propertyGridGroups.SelectedObject = group;
            }
            else
            {
                LogManager.Log(TraceEventType.Error, LogManager.LogEvents.TestSetups, $"GroupsInsert - {hr}");
            }
        }

        private void tabChannels_Enter(object sender, EventArgs e)
        {
            var connections = DbAPI.DbAPI.Connections.GetLoggedInUsers();

            var list = new List<LoggedInUser>();
            foreach (var con in connections)
            {
                list.Add(new LoggedInUser() { Details = con });
            }
            cbChannelsConnections.DataSource = list.ToArray();
            propertyGridChannel.SelectedObject = new ChannelDbRecord();
        }
        private void btnGroupUpdate_Click(object sender, EventArgs e)
        {
            var user = cbGroupsConnections.SelectedItem as LoggedInUser;
            if (null == user)
            {
                LogManager.Log(TraceEventType.Error, LogManager.LogEvents.TestSetups, $"GroupsUpdate - no user/connection");
                return;
            }
            var group = propertyGridGroups.SelectedObject as IGroupDbRecord;
            if (null == group)
            {
                LogManager.Log(TraceEventType.Error, LogManager.LogEvents.TestSetups, $"GroupsUpdate - no group selected");
                return;
            }
            var hr = DbAPI.DbAPI.Groups.GroupsUpdate(user.Details.Item1, user.Details.Item2, group);
            if (0 == hr)
            {
                LogManager.Log(TraceEventType.Information, LogManager.LogEvents.TestSetups, $"GroupsUpdate - success");
            }
            else
            {
                LogManager.Log(TraceEventType.Error, LogManager.LogEvents.TestSetups, $"GroupsUpdate Error - {hr}");
            }
        }

        private void btnChannelsGet_Click(object sender, EventArgs e)
        {
            dgChannelsView.DataSource = null;
            var user = cbChannelsConnections.SelectedItem as LoggedInUser;
            if (null == user)
            {
                LogManager.Log(TraceEventType.Error, LogManager.LogEvents.TestSetups, $"ChannelsGet - no user/connection");
                return;
            }
            var hr = DbAPI.DbAPI.Channels.ChannelsGet(user.Details.Item1, user.Details.Item2, null, null, null, null, null, null, out var records);
            if( 0 == hr)
            {
                if( null != records && records.Any())
                {
                    dgChannelsView.DataSource = records.ToArray();
                }
                LogManager.Log(TraceEventType.Information, LogManager.LogEvents.TestSetups, $"ChannelsGet - success");
            }
            else
            {
                LogManager.Log(TraceEventType.Error, LogManager.LogEvents.TestSetups, $"ChannelsGet - Error: {hr}");
            }
        }

        private void btnChannelUpdate_Click(object sender, EventArgs e)
        {
            var user = cbChannelsConnections.SelectedItem as LoggedInUser;
            if (null == user)
            {
                LogManager.Log(TraceEventType.Error, LogManager.LogEvents.TestSetups, $"ChannelsUpdate - no user/connection");
                return;
            }
            var channel = propertyGridChannel.SelectedObject as IChannelDbRecord;
            if (null == channel)
            {
                LogManager.Log(TraceEventType.Error, LogManager.LogEvents.TestSetups, $"ChannelsUpdate - No channel to update");
                return;
            }
            var hr = DbAPI.DbAPI.Channels.ChannelsUpdate(user.Details.Item1, user.Details.Item2, channel);
            if( 0 == hr)
            {
                LogManager.Log(TraceEventType.Information, LogManager.LogEvents.TestSetups, $"ChannelsUpdate - success");
            }
            else
            {
                LogManager.Log(TraceEventType.Error, LogManager.LogEvents.TestSetups, $"ChannelsUpdate - Error - {hr}");
            }
        }

        private void btnChannelInsert_Click(object sender, EventArgs e)
        {
            var user = cbChannelsConnections.SelectedItem as LoggedInUser;
            if (null == user)
            {
                LogManager.Log(TraceEventType.Error, LogManager.LogEvents.TestSetups, $"ChannelsUpdate - no user/connection");
                return;
            }
            var channel = propertyGridChannel.SelectedObject as IChannelDbRecord;
            if (null == channel)
            {
                LogManager.Log(TraceEventType.Error, LogManager.LogEvents.TestSetups, $"ChannelsUpdate - No channel to update");
                return;
            }
            var hr = DbAPI.DbAPI.Channels.ChannelsInsert(user.Details.Item1, user.Details.Item2, ref channel);
            if (0 == hr)
            {
                LogManager.Log(TraceEventType.Information, LogManager.LogEvents.TestSetups, $"ChannelsUpdate - success");
                propertyGridChannel.SelectedObject = channel;
            }
            else
            {
                LogManager.Log(TraceEventType.Error, LogManager.LogEvents.TestSetups, $"ChannelsUpdate - Error - {hr}");
            }
        }


        private void btnTagsGet_Click(object sender, EventArgs e)
        {
            var user = cbTagsConnections.SelectedItem as LoggedInUser;
            if (null == user)
            {
                LogManager.Log(TraceEventType.Error, LogManager.LogEvents.Tags, $"TagsGet - no user/connection");
                return;
            }
            var hr = DbAPI.DbAPI.Tags.TagsGet(user.Details.Item1, user.Details.Item2, null, out var records);
            dgTagsView.DataSource = null;
            if( 0 == hr)
            {
                LogManager.Log(TraceEventType.Information, LogManager.LogEvents.Tags, $"TagsGet - success");
                if( null != records && records.Any())
                {
                    dgTagsView.DataSource = records.ToArray();
                }
            }
            else { LogManager.Log(TraceEventType.Error, LogManager.LogEvents.Tags, $"TagsGet - error - {hr}"); }
        }

        private void btnTagsDelete_Click(object sender, EventArgs e)
        {
            var user = cbTagsConnections.SelectedItem as LoggedInUser;
            if (null == user)
            {
                LogManager.Log(TraceEventType.Error, LogManager.LogEvents.Tags, $"TagsDelete - no user/connection");
                return;
            }
            int temp;
            if( !int.TryParse(tbTagIdToDelete.Text, out temp))
            {
                LogManager.Log(TraceEventType.Error, LogManager.LogEvents.Tags, $"TagsDelete not a valid integer format");
                return;
            }
            var hr = DbAPI.DbAPI.Tags.TagsDelete(user.Details.Item1, user.Details.Item2, temp);
            if( 0 == hr) { LogManager.Log(TraceEventType.Information, LogManager.LogEvents.Tags, $"TagsDelete success"); }
            else { LogManager.Log(TraceEventType.Error, LogManager.LogEvents.Tags, $"TagsDelete error - {hr}"); }
        }

        private void btnTagInsert_Click(object sender, EventArgs e)
        {
            var user = cbTagsConnections.SelectedItem as LoggedInUser;
            if (null == user)
            {
                LogManager.Log(TraceEventType.Error, LogManager.LogEvents.Tags, $"TagsInsert - no user/connection");
                return;
            }
            if( string.IsNullOrWhiteSpace(tbTagToAdd.Text))
            {
                LogManager.Log(TraceEventType.Error, LogManager.LogEvents.Tags, $"TagsInsert no tag text to insert");
                return;
            }
            var tag = new Tag();
            tag.ID = -1;
            tag.IsObsolete = false;
            tag.Text = tbTagToAdd.Text;
            var itag = (ITag)tag;
            var hr = DbAPI.DbAPI.Tags.TagsInsert(user.Details.Item1, user.Details.Item2, ref itag);
            if( 0 == hr)
            {
                LogManager.Log(TraceEventType.Information, LogManager.LogEvents.Tags, $"TagsInsert success");
            }
            else
            {
                LogManager.Log(TraceEventType.Error, LogManager.LogEvents.Tags, $"TagsInsert error - {hr}");
            }
        }

        private void tabTags_Enter(object sender, EventArgs e)
        {
            var connections = DbAPI.DbAPI.Connections.GetLoggedInUsers();

            var list = new List<LoggedInUser>();
            foreach (var con in connections)
            {
                list.Add(new LoggedInUser() { Details = con });
            }
            cbTagsConnections.DataSource = list.ToArray();
            
        }

        private void tabPageTagAssignments_Enter(object sender, EventArgs e)
        {
            var connections = DbAPI.DbAPI.Connections.GetLoggedInUsers();

            var list = new List<LoggedInUser>();
            foreach (var con in connections)
            {
                list.Add(new LoggedInUser() { Details = con });
            }
            cbTagAssignmentsConnections.DataSource = list.ToArray();
            propertyGridTagAssignmentToInsert.SelectedObject = new TagAssignment();
        }
        internal class TagAssignmentHelper : TagAssignment
        {
            public TagAssignmentHelper(ITagAssignment tagAssignment)
            {
                TagID = tagAssignment.TagID;
                ObjectID = tagAssignment.ObjectID;
                ObjectType = tagAssignment.ObjectType;
            }
            public override string ToString()
            {
                return $"{TagID}\\{ObjectType}\\{ObjectID}";
            }
        }
        private void btnTagAssignmentsGet_Click(object sender, EventArgs e)
        {
            dgTagAssignmentsView.DataSource = null;
            cbTagAssignmentsToDelete.Items.Clear();
            var user = cbTagAssignmentsConnections.SelectedItem as LoggedInUser;
            if (null == user)
            {
                LogManager.Log(TraceEventType.Error, LogManager.LogEvents.Tags, $"TagAssignmentsGet - no user/connection");
                return;
            }
            var hr = DbAPI.DbAPI.Tags.TagAssignmentsGet(user.Details.Item1, user.Details.Item2, null, out var tagAssignments);
            if( 0 == hr)
            {
                dgTagAssignmentsView.DataSource = tagAssignments.ToArray();
                foreach( var tagAssignment in tagAssignments)
                {
                    cbTagAssignmentsToDelete.Items.Add(new TagAssignmentHelper(tagAssignment));
                }
                LogManager.Log(TraceEventType.Information, LogManager.LogEvents.Tags, $"TagAssignmentsGet Success");
            }
            else
            {
                LogManager.Log(TraceEventType.Error, LogManager.LogEvents.Tags, $"TagAssignmentsGet error - {hr}");
            }
        }

        private void btnTagAssignmentInsert_Click(object sender, EventArgs e)
        {
            var user = cbTagAssignmentsConnections.SelectedItem as LoggedInUser;
            if (null == user)
            {
                LogManager.Log(TraceEventType.Error, LogManager.LogEvents.Tags, $"TagAssignmentsGet - no user/connection");
                return;
            }
            var tagAssignment = propertyGridTagAssignmentToInsert.SelectedObject as TagAssignment;
            if( null == tagAssignment)
            {
                LogManager.Log(TraceEventType.Error, LogManager.LogEvents.Tags, $"TagAssignmentsInsert error - no tag assignment to insert");
                return;
            }
            var hr = DbAPI.DbAPI.Tags.TagAssignmentsInsert(user.Details.Item1, user.Details.Item2, tagAssignment);
            if (0 == hr)
            {
                LogManager.Log(TraceEventType.Information, LogManager.LogEvents.Tags, $"TagAssignmentsInsert success");
            }
            else
            {
                LogManager.Log(TraceEventType.Error, LogManager.LogEvents.Tags, $"TagAssignmentsInsert error - {hr}");
            }
        }

        private void btnTagAssignmentDelete_Click(object sender, EventArgs e)
        {
            var user = cbTagAssignmentsConnections.SelectedItem as LoggedInUser;
            if (null == user)
            {
                LogManager.Log(TraceEventType.Error, LogManager.LogEvents.Tags, $"TagAssignmentsDelete - no user/connection");
                return;
            }
            var tagToDelete = cbTagAssignmentsToDelete.SelectedItem as TagAssignment;
            if( null == tagToDelete)
            {
                LogManager.Log(TraceEventType.Error, LogManager.LogEvents.Tags, $"TagAssignmentsDelete - nothing to delete");
                return;
            }
            var hr = DbAPI.DbAPI.Tags.TagAssignmentsDelete(user.Details.Item1, user.Details.Item2,
                tagToDelete.ObjectID, tagToDelete.ObjectType);
            if( 0 == hr)
            {
                LogManager.Log(TraceEventType.Information, LogManager.LogEvents.Tags, $"TagAssignmentsDelete success");
            }
            else
            {
                LogManager.Log(TraceEventType.Error, LogManager.LogEvents.Tags, $"TagAssignmentsDelete error - {hr}");
            }
        }

        private void TagPageChannelCodes_Enter(object sender, EventArgs e)
        {
            var connections = DbAPI.DbAPI.Connections.GetLoggedInUsers();

            var list = new List<LoggedInUser>();
            foreach (var con in connections)
            {
                list.Add(new LoggedInUser() { Details = con });
            }
            cbChannelCodesConnections.DataSource = list.ToArray();
            propertyGridChannelCode.SelectedObject = new ChannelCode();

        }

        private void btnCodeTypesGet_Click(object sender, EventArgs e)
        {
            var user = cbChannelCodesConnections.SelectedItem as LoggedInUser;
            dgCodeTypesView.DataSource = null;
            if (null == user)
            {
                LogManager.Log(TraceEventType.Error, LogManager.LogEvents.TestSetups, $"ChannelCodeTypesGet - no user/connection");
                return;
            }
            var hr = DbAPI.DbAPI.Channels.ChannelCodeTypesGet(user.Details.Item1,
                user.Details.Item2, null, null, out var records);
            if( 0 == hr)
            {
                dgCodeTypesView.DataSource = records;
                LogManager.Log(TraceEventType.Information, LogManager.LogEvents.TestSetups, $"ChannelCodeTypesGet - success");
            }
            else
            {
                LogManager.Log(TraceEventType.Error, LogManager.LogEvents.TestSetups, $"ChannelCodeTypesGet - Error - {hr}");
            }
        }

        private void btnChannelCodesGet_Click(object sender, EventArgs e)
        {
            var user = cbChannelCodesConnections.SelectedItem as LoggedInUser;
            dgChannelCodesView.DataSource = null;
            cbChannelCodeToDelete.DataSource = null;
            if (null == user)
            {
                LogManager.Log(TraceEventType.Error, LogManager.LogEvents.TestSetups, $"ChannelCodesGet - no user/connection");
                return;
            }
            var hr = DbAPI.DbAPI.Channels.ChannelCodeTypesGet(user.Details.Item1,
                user.Details.Item2, null, null, out var records);

            var lookup = new Dictionary<short, string>();
            if (0 == hr && null != records && records.Any())
            {
                foreach( var record in records)
                {
                    lookup[record.Item1] = record.Item2;
                }
            }
            var channelLookup = (IReadOnlyDictionary<short, string>)lookup;
            hr = DbAPI.DbAPI.Channels.ChannelCodesGet(user.Details.Item1,
                user.Details.Item2,
                null, null, null, null, channelLookup, out var channelCodeRecords);
            if (0 == hr && null != channelCodeRecords && channelCodeRecords.Any())
            {
                dgChannelCodesView.DataSource = channelCodeRecords.ToArray();
                LogManager.Log(TraceEventType.Information, LogManager.LogEvents.TestSetups, $"ChannelCodesGet - success");
                var list = new List<ChannelCodeHelper>();
                foreach (var record in channelCodeRecords)
                {
                    list.Add(new ChannelCodeHelper(record));
                }
                cbChannelCodeToDelete.DataSource = list.ToArray();
            }
            else
            {
                LogManager.Log(TraceEventType.Error, LogManager.LogEvents.TestSetups, $"ChannelCodesGet - Error - {hr}");
            }
        }
        internal class ChannelCodeHelper : ChannelCode
        {
            public ChannelCodeHelper(IChannelCode code) :base(code)
            { 
            }
            public override string ToString()
            {
                return $"{Id}\\{CodeType.ToString()}\\{Name}\\{Code}";
            }
        }
        private void btnChannelCodesInsert_Click(object sender, EventArgs e)
        {
            var user = cbChannelCodesConnections.SelectedItem as LoggedInUser;
            if (null == user)
            {
                LogManager.Log(TraceEventType.Error, LogManager.LogEvents.TestSetups, $"ChannelCodesInsert - no user/connection");
                return;
            }

            var channelCodeToInsert = propertyGridChannelCode.SelectedObject as ChannelCode;

            if( null == channelCodeToInsert)
            {
                LogManager.Log(TraceEventType.Error, LogManager.LogEvents.TestSetups, $"ChannelCodesInsert - no ChannelCode to insert");
                return;
            }

            var lookup = GetChannelCodeMapping(user);
            var hr = DbAPI.DbAPI.Channels.ChannelCodesInsert(user.Details.Item1,
                user.Details.Item2, lookup, channelCodeToInsert, out var id);
            if( 0 == hr)
            {
                LogManager.Log(TraceEventType.Information, LogManager.LogEvents.TestSetups, $"ChannelCodesInsert - success");
                channelCodeToInsert.Id = id;
            }
            else
            {
                LogManager.Log(TraceEventType.Error, LogManager.LogEvents.TestSetups, $"ChannelCodesInsert - Error - {hr}");
            }            
        }
        private IReadOnlyDictionary<ChannelEnumsAndConstants.ChannelCodeType, short> GetChannelCodeMapping(
            LoggedInUser user)
        {
            var hr = DbAPI.DbAPI.Channels.ChannelCodeTypesGet(user.Details.Item1,
                user.Details.Item2, null, null, out var records);
            var lookup = new Dictionary<ChannelEnumsAndConstants.ChannelCodeType, short>();
            if (0 == hr && null != records && records.Any())
            {
                foreach (var record in records)
                {
                    switch (record.Item2)
                    {
                        case ChannelEnumsAndConstants.IsoCodeTypeString:
                            lookup[ChannelEnumsAndConstants.ChannelCodeType.ISO] = record.Item1;
                            break;
                        case ChannelEnumsAndConstants.UserCodeTypeString:
                            lookup[ChannelEnumsAndConstants.ChannelCodeType.User] = record.Item1;
                            break;
                    }
                }
            }
            return lookup;
        }
        private void btnChannelCodesUpdate_Click(object sender, EventArgs e)
        {
            var user = cbChannelCodesConnections.SelectedItem as LoggedInUser;
            if (null == user)
            {
                LogManager.Log(TraceEventType.Error, LogManager.LogEvents.TestSetups, $"ChannelCodesInsert - no user/connection");
                return;
            }

            var channelCodeToUpdate = propertyGridChannelCode.SelectedObject as ChannelCode;

            if (null == channelCodeToUpdate)
            {
                LogManager.Log(TraceEventType.Error, LogManager.LogEvents.TestSetups, $"ChannelCodesUpdate - no ChannelCode to update");
                return;
            }

            var lookup = GetChannelCodeMapping(user);
            var hr = DbAPI.DbAPI.Channels.ChannelCodesUpdate(user.Details.Item1,
                user.Details.Item2, lookup, channelCodeToUpdate);
            if (0 == hr)
            {
                LogManager.Log(TraceEventType.Information, LogManager.LogEvents.TestSetups, $"ChannelCodesUpdate - success");
            }
            else
            {
                LogManager.Log(TraceEventType.Error, LogManager.LogEvents.TestSetups, $"ChannelCodesUpdate - Error - {hr}");
            }
        }

        private void btnChannelCodeDelete_Click(object sender, EventArgs e)
        {
            var user = cbChannelCodesConnections.SelectedItem as LoggedInUser;
            if (null == user)
            {
                LogManager.Log(TraceEventType.Error, LogManager.LogEvents.TestSetups, $"ChannelCodesDelete - no user/connection");
                return;
            }
            var channelCodeToDelete = cbChannelCodeToDelete.SelectedItem as IChannelCode;
            if( null == channelCodeToDelete)
            {
                LogManager.Log(TraceEventType.Error, LogManager.LogEvents.TestSetups, $"ChannelCodesDelete - no code to delete");
                return;
            }
            var hr = DbAPI.DbAPI.Channels.ChannelCodesDelete(user.Details.Item1,
                user.Details.Item2,
                channelCodeToDelete.Id, null, null, null);
            if( 0 == hr)
            {
                LogManager.Log(TraceEventType.Information, LogManager.LogEvents.TestSetups, $"ChannelCodesDelete - Success");
            }
            else
            {
                LogManager.Log(TraceEventType.Error, LogManager.LogEvents.TestSetups, $"ChannelCodesDelete - Error - {hr}");
            }
        }

        private void btnDoALotOfThings_Click(object sender, EventArgs e)
        {
            //following example shows how to get sensors and calibrations from a EQX file
            //EquipmentExchange.EQXSensorDatabase database = new EquipmentExchange.EQXSensorDatabase();
            //database.Read(@"C:\Temp\Sensors.e2x", ReportErrors, true, true);
            var sample = new DoEverythingSample();
            sample.Start();

        }
        private void ReportErrors(List<string> errors)
        {

        }
    }
}