using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Globalization;
using System.IO;
using System.Linq;
using System.Threading.Tasks;
using System.Xml.Linq;
using DTS.Common.Base;
using DTS.Common.Enums;
using DTS.Common.Enums.Sensors;
using DTS.Common.Enums.Viewer;
using DTS.Common.Interface;
using DTS.Common.Interface.TestDefinition;
using DTS.Common.Utilities;
using DTS.Common.Utils;
using DTS.Common.XMLUtils;
using Prism.Events;
using Prism.Ioc;
// ReSharper disable UnusedVariable
// ReSharper disable UnusedMember.Local
// ReSharper disable SuggestBaseTypeForParameter
// ReSharper disable RedundantAssignment
// ReSharper disable CheckNamespace

namespace DTS.Common.Classes.Viewer.TestMetadata
{
    public class TestMetadataList
    {
#pragma warning disable 1998
        public async Task<ObservableCollection<ITestSummary>> GetTestSummaryListAsync(IBaseViewModel parent, string path, string file, string pattern = "")
#pragma warning restore 1998
        {
            return GetTestSummaryList(parent, path, file, pattern);
        }
        public ObservableCollection<ITestSummary> GetTestSummaryList(IBaseViewModel parent, string path, string file = "", string pattern = "")
        {
            return new ObservableCollection<ITestSummary>(BuildITestSummary(GetTestMetadataList(TestMetadataXml.GetTestMetadataXml(path, file, string.IsNullOrEmpty(pattern) ? ".dts" : pattern), path, file), parent));
        }
        public ObservableCollection<ITestSummary> GetTestSummaryList(string path, string file = "", string pattern = "")
        {
            return new ObservableCollection<ITestSummary>(BuildITestSummary(GetTestMetadataList(TestMetadataXml.GetTestMetadataXml(path, file, string.IsNullOrEmpty(pattern) ? ".dts" : pattern), path, file)));
        }
        private static string ParseEventNumber(string path)
        {
            var segments = path.Split('\\');
            return Array.Find(segments, p => p.StartsWith($"{DTS.Common.Constants.EventNumber}"));
        }
        private static List<ITestSummary> BuildITestSummary(IEnumerable<ITestMetadata> metadata, IBaseViewModel parent)
        {
            List<ITestSummary> ts;
            try
            {
                ts = metadata.Select(md => new TestSummary
                {
                    TestMetadata = md,
                    SetupName = md.TestSetup.SetupName,
                    Id = md.TestRun.Id + ParseEventNumber(md.TestRun.FilePath),
                    Description = md.TestRun.Description,
                    FileDate = md.TestRun.FileDate,
                    TimeStamp = GetTimestamp(md),
                    ChannelCount = md.TestRun.Channels.Count,
                    DataType = md.TestRun.DataType,
                    IsSelected = false,
                    Parent = parent,
                    Graphs = md.TestSetup.TestGraphs,
                    Channels = md.TestRun.Channels,
                    CalculatedChannels = md.TestRun.CalculatedChannels,
                    CalibrationBehavior = md.TestSetup.CalibrationBehavior
                }).Cast<ITestSummary>().OrderByDescending(x => x.TimeStamp.Ticks).ToList();
            }
            catch (Exception ex)
            {
                var error = ex.Message;
                ts = new List<ITestSummary>();
            }
            return ts;
        }
        //FB 29410 Get DateTime with milli seconds if the date is before 1/1/1990 then use the TimeStamp from testsetup 
        private static DateTime GetTimestamp(ITestMetadata md)
        {
            var basemodules = md.TestRun.Modules.GroupBy(module => module.BaseSerialNumber).Select(group => group.First());

            List<TestModuleTimeStamp> testModuleTimeStamps = new List<TestModuleTimeStamp>();
            foreach (var module in basemodules)
            {
                TestModuleTimeStamp testModuleTimeStamp =
                    new TestModuleTimeStamp { TriggerTimestampSec = module.TriggerTimestampSec, TriggerTimestampNanoSec = module.TriggerTimestampNanoSec };

                if ( testModuleTimeStamp.TriggerTimestampSec == 0 && testModuleTimeStamp.TriggerTimestampNanoSec == 0)
                {
                    testModuleTimeStamp = new TestModuleTimeStamp() { TriggerTimestampSec = module.StartRecordTimestampSec, TriggerTimestampNanoSec = module.StartRecordTimestampNanoSec };
                }

                testModuleTimeStamps.Add(testModuleTimeStamp);
            }

            var tuplesTime = TestUtils.MinUnixTime(testModuleTimeStamps);
            if (null != tuplesTime && PTP1588Timestamps.IsValidTimeStamp(tuplesTime.Item1))
            {
                var time = PTP1588Timestamps.UnixTimeStampToDateTimeLocal(tuplesTime.Item1);
                double ticks = tuplesTime.Item2 / 100.00;
                var timeWithTicks = time.AddTicks((long)ticks);
                return timeWithTicks;
            }

            return md.TestSetup.TimeStamp;
        }

        private static List<ITestSummary> BuildITestSummary(IEnumerable<ITestMetadata> metadata)
        {
            List<ITestSummary> ts;
            try
            {
                ts = metadata.Select(md => new TestSummary
                {
                    TestMetadata = md,
                    SetupName = md.TestSetup.SetupName,
                    Id = md.TestRun.Id + ParseEventNumber(md.TestRun.FilePath),
                    Description = md.TestRun.Description,
                    FileDate = md.TestRun.FileDate,
                    TimeStamp = GetTimestamp(md),
                    ChannelCount = md.TestRun.Channels.Count,
                    DataType = md.TestRun.DataType,
                    IsSelected = false,
                    //Parent = parent,
                    Graphs = md.TestSetup.TestGraphs,
                    Channels = md.TestRun.Channels,
                    CalculatedChannels = md.TestRun.CalculatedChannels,
                    CalibrationBehavior = md.TestSetup.CalibrationBehavior
                }).Cast<ITestSummary>().OrderByDescending(x => x.TimeStamp.Ticks).ToList();
            }
            catch (Exception ex)
            {
                var error = ex.Message;
                ts = new List<ITestSummary>();
            }
            return ts;
        }
        private const string TEST_NAME = "TSRAIR_GO_TEST";
        /// <summary>
        /// Return list of files
        /// </summary>
        /// <param name="xDoc">.dts file in xml format</param>
        /// <param name="path">.dts file path</param>
        /// <param name="file">.dts file name</param>
        /// <returns></returns>
        public List<ITestMetadata> GetTestMetadataList(XDocument xDoc, string path, string file)
        {
            List<ITestMetadata> tm;
            //keep track of any tests that fail to load and warn of them
            List<ITestMetadata> tmToRemove = new List<ITestMetadata>();
            try
            {
                var items = xDoc.Elements("Tests").Elements("TestMetadata")
                .Select(x => new TestMetadata
                {
                    TestRun = GetTestRunMetadata(x),
                    TestSetup = GetTestSetupMetadata(x)
                }).Cast<ITestMetadata>();
                if (RunTestVariables.IsTSRAIRGo)
                {
                    tm = items.Where(x => x.TestRun.FilePath.Contains(TEST_NAME)).ToList();
                }
                else { tm = items.ToList(); }
                
                var errors = new List<string>();
                foreach (var testMetadata in tm)
                {

                    try
                    {
                        testMetadata.TestRun.Channels =
                            new ITestChannel[testMetadata.TestRun.Modules.Select(x => x.NumberOfChannels).ToList()
                                .Sum()].ToList();
                    }
                    catch (Exception ex)
                    {
                        errors.Add($"Failed to load channels from {testMetadata.TestSetup.SetupName} - {ex.Message}");
                        tmToRemove.Add(testMetadata);
                    }
                }

                if (errors.Any())
                {
                    var eventAggregator = ContainerLocator.Container.Resolve<IEventAggregator>();
                    eventAggregator.GetEvent<Events.PageErrorEvent>()
                        .Publish(new Events.PageErrorArg(errors.ToArray(), null));
                }

                foreach (var metaData in tmToRemove)
                {
                    tm.Remove(metaData);
                }

            }
            catch (Exception ex)
            {
                var error = ex.Message;
                tm = new List<ITestMetadata>();
            }
            return tm;
        }

        #region TestMetadata

        private static DateTime GetDateTime(string dataString)
        {
            if (string.Equals("NOVALUE", dataString)) return DateTime.MinValue;
            return Convert.ToDateTime(dataString, CultureInfo.InvariantCulture);
        }

        #region TestSetupMetadata
        /// <summary>
        /// Returns Test setup metadata 
        /// </summary>
        /// <param name="x"></param>
        /// <returns></returns>
        private TestSetupMetadata GetTestSetupMetadata(XElement x)
        {

            TestSetupMetadata ts;
            try
            {
                if (x.Element("TestSetup") != null)
                {
                    ts = (from c in x.Descendants("TestSetup")
                          select new TestSetupMetadata
                          {
                              SetupName = c.Element(TestSetupMetadataFields.Name.ToString())?.Value,
                              TimeStamp = GetDateTime(c.Element(TestSetupMetadataFields.Timestamp.ToString())?.Value),
                              TestGraphs = GetTestSetupGraphs(c.Element(TestSetupMetadataFields.Graphs.ToString())),
                              CalibrationBehavior = (CalibrationBehaviors)Enum.Parse(typeof(CalibrationBehaviors), c.Element(TestSetupMetadataFields.CalibrationBehavior.ToString())?.Value ?? CalibrationBehaviors.NonLinearIfAvailable.ToString())
                          }).FirstOrDefault();
                }
                else
                {
                    ts = new TestSetupMetadata
                    {
                        SetupName = "N/A",
                        TimeStamp = DateTime.MinValue,
                        TestGraphs = new List<ITestGraphs>(),
                        CalibrationBehavior = CalibrationBehaviors.NonLinearIfAvailable
                    };
                }

            }
            catch (Exception ex)
            {
                var error = ex.Message;
                ts = new TestSetupMetadata();
            }
            return ts;
        }

        /// <summary>
        /// Returns graphs
        /// </summary>
        /// <param name="xTestGraphs"></param>
        /// <returns></returns>
        private List<ITestGraphs> GetTestSetupGraphs(XElement xTestGraphs)
        {
            List<ITestGraphs> tg;
            try
            {
                tg = (from c in xTestGraphs.Descendants("Graph")
                      select new TestGraphs
                      {
                          Name = c.Element(TestGraphsFields.Name.ToString())?.Value,
                          HardwareChannelName = c.Element(TestGraphsFields.HardwareChannelName.ToString())?.Value,
                          ChannelIds = GetChannelIds(c.Element(TestGraphsFields.Channels.ToString()))
                      }).Cast<ITestGraphs>().ToList();

            }
            catch (Exception ex)
            {
                var error = ex.Message;
                tg = new List<ITestGraphs>();
            }
            return tg;
        }

        /// <summary>
        /// Returns graph's list of ChannelIds
        /// </summary>
        /// <param name="xChannelIds"></param>
        /// <returns></returns>
        private List<string> GetChannelIds(XElement xChannelIds)
        {
            try
            {
                return (from c in xChannelIds.Descendants(TestGraphsFields.Channel.ToString()) select c.Element(TestGraphsFields.ChannelId.ToString())?.Value).ToList();

            }
            catch (Exception ex)
            {
                var error = ex.Message;
                return new List<string>();
            }
        }

        #endregion TestSetupMetadata

        #region TestRunMetadata

        /// <summary>
        /// returns TestRun Metadata
        /// </summary>
        /// <param name="x">DataPRO data folder</param>
        /// <returns></returns>
        private TestRunMetadata GetTestRunMetadata(XElement x)
        {
            TestRunMetadata td;
            try
            {
                td = (from c in x.Descendants("Test")
                      select new TestRunMetadata
                      {
                          /* Name is id in DTS file, id is a file name */

                          Id = Path.GetFileNameWithoutExtension(c.Attribute(TestRunMetadataFields.FilePath.ToString())?.Value),
                          Name = c.Attribute(TestRunMetadataFields.Id.ToString())?.Value,

                          Description = c.Attribute(TestRunMetadataFields.Description.ToString())?.Value,
                          InlineSerializedData = ParseBoolean(c.Attribute(TestRunMetadataFields.InlineSerializedData.ToString())?.Value),
                          TestGuid = c.Attribute(TestRunMetadataFields.Guid.ToString())?.Value,
                          FaultFlags = ParseInt(c.Attribute(TestRunMetadataFields.FaultFlags.ToString())?.Value),
                          Software = c.Attribute(TestRunMetadataFields.Software.ToString())?.Value,
                          SoftwareVersion = c.Attribute(TestRunMetadataFields.SoftwareVersion.ToString())?.Value,
                          DataType = c.Attribute(TestRunMetadataFields.DataType.ToString())?.Value,
                          FilePath = c.Attribute(TestRunMetadataFields.FilePath.ToString())?.Value,
                          FileDate = ParseDateTime(c.Attribute(TestRunMetadataFields.FileDate.ToString())?.Value),
                          Modules = LoadTestModules(c.Element(TestRunMetadataFields.Modules.ToString()), c.Attribute(TestRunMetadataFields.Id.ToString())?.Value, Path.GetFileNameWithoutExtension(c.Attribute(TestRunMetadataFields.FilePath.ToString())?.Value)),
                          //Channels = LoadTestChannels(c.Elements(TestRunMetadataFields.Modules.ToString()).Elements(TestRunMetadataFields.Module.ToString()).Elements(TestRunMetadataFields.Channels.ToString())),
                          //CalculatedChannels = LoadTestCalculatedChannel(c.Elements(TestRunMetadataFields.Modules.ToString()).Elements(TestRunMetadataFields.Module.ToString()).Elements(TestRunMetadataFields.CalculatedChannels.ToString())),
                      }).FirstOrDefault();

            }
            catch (Exception ex)
            {
                var error = ex.Message;
                td = new TestRunMetadata();
            }
            return td;
        }

        /// <summary>
        /// Returns list of all Test Modules
        /// </summary>
        /// <param name="xTestModules">Modules xml node</param>
        /// <param name="testSetupName"></param>
        /// <param name="testId"></param>
        /// <returns></returns>
        private List<ITestModule> LoadTestModules(XElement xTestModules, string testSetupName, string testId)
        {
            List<ITestModule> tm;
            try
            {
                tm = (from m in xTestModules.Descendants("Module")
                      select new TestModule
                      {
                          SerialNumber = m.Attribute(TestModuleFields.SerialNumber.ToString())?.Value,
                          BaseSerialNumber = m.Attribute(TestModuleFields.BaseSerialNumber.ToString())?.Value,
                          AaFilterRateHz = ParseInt(m.Attribute(TestModuleFields.AaFilterRateHz.ToString())?.Value),
                          Number = ParseInt(m.Attribute(TestModuleFields.Number.ToString())?.Value),
                          NumberOfSamples = ParseInt(m.Attribute(TestModuleFields.NumberOfSamples.ToString())?.Value),
                          UnsubsampledNumberOfSamples = ParseInt(m.Attribute(TestModuleFields.UnsubsampledNumberOfSamples.ToString())?.Value),
                          RequestedPostTriggerSeconds = ParseDouble(m.Attribute(TestModuleFields.RequestedPostTriggerSeconds.ToString())?.Value),
                          RequestedPreTriggerSeconds = ParseDouble(m.Attribute(TestModuleFields.RequestedPreTriggerSeconds.ToString())?.Value),
                          PostTriggerSeconds = ParseDouble(m.Attribute(TestModuleFields.PostTriggerSeconds.ToString())?.Value),
                          PreTriggerSeconds = ParseDouble(m.Attribute(TestModuleFields.PreTriggerSeconds.ToString())?.Value),
                          RecordingMode = m.Attribute(TestModuleFields.RecordingMode.ToString())?.Value,
                          SampleRateHz = ParseInt(m.Attribute(TestModuleFields.SampleRateHz.ToString())?.Value),
                          StartRecordSampleNumber = ParseInt(m.Attribute(TestModuleFields.StartRecordSampleNumber.ToString())?.Value),
                          NumberOfChannels = ParseInt(m.Attribute(TestModuleFields.NumberOfChannels.ToString())?.Value),
                          InlineSerializedData = ParseBoolean(m.Attribute(TestModuleFields.InlineSerializedData.ToString())?.Value),
                          StartRecordTimestampSec = ParseInt(m.Attribute(TestModuleFields.StartRecordTimestampSec.ToString())?.Value),
                          StartRecordTimestampNanoSec = ParseInt(m.Attribute(TestModuleFields.StartRecordTimestampNanoSec.ToString())?.Value),
                          TriggerTimestampSec = ParseInt(m.Attribute(TestModuleFields.TriggerTimestampSec.ToString())?.Value),
                          TriggerTimestampNanoSec = ParseInt(m.Attribute(TestModuleFields.TriggerTimestampNanoSec.ToString())?.Value),

                          TriggerSampleNumbers = LoadTriggerSampleNumbers(m.Elements("TriggerSampleNumbers")),


                          PTPMasterSync = ParseBoolean(m.Attribute(TestModuleFields.PTPMasterSync.ToString())?.Value),
                          TiltSensorAxisXDegreesPre = ParseInt(m.Attribute(TestModuleFields.TiltSensorAxisXDegreesPre.ToString())?.Value),
                          TiltSensorAxisYDegreesPre = ParseInt(m.Attribute(TestModuleFields.TiltSensorAxisYDegreesPre.ToString())?.Value),
                          TiltSensorAxisZDegreesPre = ParseInt(m.Attribute(TestModuleFields.TiltSensorAxisZDegreesPre.ToString())?.Value),
                          TiltSensorAxisXDegreesPost = ParseInt(m.Attribute(TestModuleFields.TiltSensorAxisXDegreesPost.ToString())?.Value),
                          TiltSensorAxisYDegreesPost = ParseInt(m.Attribute(TestModuleFields.TiltSensorAxisYDegreesPost.ToString())?.Value),
                          TiltSensorAxisZDegreesPost = ParseInt(m.Attribute(TestModuleFields.TiltSensorAxisZDegreesPost.ToString())?.Value),
                          TemperatureLocation1Pre = ParseInt(m.Attribute(TestModuleFields.TemperatureLocation1Pre.ToString())?.Value),
                          TemperatureLocation2Pre = ParseInt(m.Attribute(TestModuleFields.TemperatureLocation2Pre.ToString())?.Value),
                          TemperatureLocation3Pre = ParseInt(m.Attribute(TestModuleFields.TemperatureLocation3Pre.ToString())?.Value),
                          TemperatureLocation4Pre = ParseInt(m.Attribute(TestModuleFields.TemperatureLocation4Pre.ToString())?.Value),
                          TemperatureLocation1Post = ParseInt(m.Attribute(TestModuleFields.TemperatureLocation1Post.ToString())?.Value),
                          TemperatureLocation2Post = ParseInt(m.Attribute(TestModuleFields.TemperatureLocation2Post.ToString())?.Value),
                          TemperatureLocation3Post = ParseInt(m.Attribute(TestModuleFields.TemperatureLocation3Post.ToString())?.Value),
                          TemperatureLocation4Post = ParseInt(m.Attribute(TestModuleFields.TemperatureLocation4Post.ToString())?.Value),
                          Channels = LoadTestChannels(m.Elements("Channels"), m.Attribute(TestModuleFields.SerialNumber.ToString())?.Value, testSetupName, testId),
                          CalculatedChannels = LoadTestCalculatedChannels(m.Elements("CalculatedChannels"), testSetupName, testId)
                      }).Cast<ITestModule>().ToList();
            }
            catch (Exception ex)
            {
                var error = ex.Message;
                tm = new List<ITestModule>();
            }
            return tm;
        }
        /// <summary>
        /// ?
        /// </summary>
        /// <param name="xTriggerSampleNumbers"></param>
        /// <returns></returns>
        // ReSharper disable once UnusedParameter.Local
        private List<ulong> LoadTriggerSampleNumbers(IEnumerable<XElement> xTriggerSampleNumbers)
        {
            return new List<ulong>();
        }

        /// <summary>
        /// Returns list (IEnumerable) of all test channels 
        /// </summary>
        /// <param name="xTestChannels">Channels xml node</param>
        /// <param name="moduleId"></param>
        /// <param name="testSetupName"></param>
        /// <param name="testId"></param>
        /// <returns></returns>
        private List<ITestChannel> LoadTestChannels(IEnumerable<XElement> xTestChannels, string moduleId, string testSetupName, string testId)
        {
            List<ITestChannel> tc;
            try
            {
                tc = (from m in xTestChannels.Descendants("AnalogInputChanel")
                      select new TestChannel
                      {
                          TestId = testId,
                          TestSetupName = testSetupName,
                          ModuleSerialNumber = moduleId,
                          SerialNumber = m.Attribute(TestChannelFields.SerialNumber.ToString())?.Value,
                          ChannelId = m.Attribute(TestChannelFields.ChannelId.ToString()) == null || ParseInt(m.Attribute(TestChannelFields.ChannelId.ToString())?.Value) == -1 ? m.GetHashCode().ToString() : m.Attribute(TestChannelFields.ChannelId.ToString())?.Value,
                          Description = m.Attribute(TestChannelFields.Description.ToString())?.Value,
                          ChannelType = m.Attribute(TestChannelFields.ChannelType.ToString())?.Value,
                          Number = ParseInt(m.Attribute(TestChannelFields.Number.ToString())?.Value),
                          DigitalMultiplier = m.Attribute(TestChannelFields.DigitalMultiplier.ToString())?.Value,
                          DigitalMode = m.Attribute(TestChannelFields.DigitalMode.ToString())?.Value,
                          Start = GetDateTime(m.Attribute(TestChannelFields.Start.ToString())?.Value),
                          Bridge = m.Attribute(TestChannelFields.Bridge.ToString())?.Value,
                          BridgeResistanceOhms = ParseDouble(m.Attribute(TestChannelFields.BridgeResistanceOhms.ToString())?.Value),
                          ZeroPoint = ParseDouble(m.Attribute(TestChannelFields.ZeroPoint.ToString())?.Value),
                          ChannelDescriptionString = m.Attribute(TestChannelFields.ChannelDescriptionString.ToString())?.Value,
                          ChannelName2 = m.Attribute(TestChannelFields.ChannelName2.ToString())?.Value,
                          HardwareChannelName = m.Attribute(TestChannelFields.HardwareChannelName.ToString())?.Value,
                          DesiredRange = ParseDouble(m.Attribute(TestChannelFields.DesiredRange.ToString())?.Value),
                          Sensitivity = ParseDouble(m.Attribute(TestChannelFields.Sensitivity.ToString())?.Value),
                          SoftwareFilter = m.Attribute(TestChannelFields.SoftwareFilter.ToString())?.Value,
                          ProportionalToExcitation = ParseBoolean(m.Attribute(TestChannelFields.ProportionalToExcitation.ToString())?.Value),
                          IsInverted = ParseBoolean(m.Attribute(TestChannelFields.IsInverted.ToString())?.Value),
                          LinearizationFormula = m.Attribute(TestChannelFields.LinearizationFormula.ToString())?.Value,
                          IsSubsampled = ParseBoolean(m.Attribute(TestChannelFields.IsSubsampled.ToString())?.Value),
                          AbsoluteDisplayOrder = ParseInt(m.Attribute(TestChannelFields.AbsoluteDisplayOrder.ToString())?.Value),
                          LastCalibrationDate = GetDateTime(m.Attribute(TestChannelFields.LastCalibrationDate.ToString())?.Value),
                          SensorId = m.Attribute(TestChannelFields.SensorId.ToString())?.Value,
                          OffsetToleranceLowMv = ParseInt(m.Attribute(TestChannelFields.OffsetToleranceLowMv.ToString())?.Value),
                          OffsetToleranceHighMv = ParseInt(m.Attribute(TestChannelFields.OffsetToleranceHighMv.ToString())?.Value),
                          DataFlag = ParseInt(m.Attribute(TestChannelFields.DataFlag.ToString())?.Value),
                          ExcitationVoltage = m.Attribute(TestChannelFields.ExcitationVoltage.ToString())?.Value,
                          Eu = m.Attribute(TestChannelFields.Eu.ToString())?.Value,
                          CalSignalEnabled = ParseBoolean(m.Attribute(TestChannelFields.CalSignalEnabled.ToString())?.Value),
                          ShuntEnabled = ParseBoolean(m.Attribute(TestChannelFields.ShuntEnabled.ToString())?.Value),
                          VoltageInsertionCheckEnabled = ParseBoolean(m.Attribute(TestChannelFields.VoltageInsertionCheckEnabled.ToString())?.Value),
                          RemoveOffset = ParseBoolean(m.Attribute(TestChannelFields.RemoveOffset.ToString())?.Value),
                          ZeroMethod = m.Attribute(TestChannelFields.ZeroMethod.ToString())?.Value,
                          ZeroAverageWindowBegin = ParseDouble(m.Attribute(TestChannelFields.ZeroAverageWindowBegin.ToString())?.Value),
                          ZeroAverageWindowEnd = ParseDouble(m.Attribute(TestChannelFields.ZeroAverageWindowEnd.ToString())?.Value),
                          InitialEu = ParseInt(m.Attribute(TestChannelFields.InitialEu.ToString())?.Value),
                          InitialOffset = m.Attribute(TestChannelFields.InitialOffset.ToString())?.Value,
                          UnsubsampledSampleRateHz = ParseInt(m.Attribute(TestChannelFields.UnsubsampledSampleRateHz.ToString())?.Value),
                          MeasuredShuntDeflectionMv = ParseDouble(m.Attribute(TestChannelFields.MeasuredShuntDeflectionMv.ToString())?.Value),
                          TargetShuntDeflectionMv = ParseDouble(m.Attribute(TestChannelFields.TargetShuntDeflectionMv.ToString())?.Value),
                          MeasuredExcitationVoltage = ParseDouble(m.Attribute(TestChannelFields.MeasuredExcitationVoltage.ToString())?.Value),
                          FactoryExcitationVoltage = ParseDouble(m.Attribute(TestChannelFields.FactoryExcitationVoltage.ToString())?.Value),
                          TimeOfFirstSample = ParseDouble(m.Attribute(TestChannelFields.TimeOfFirstSample.ToString())?.Value),
                          Multiplier = m.Attribute(TestChannelFields.Multiplier.ToString()) == null ? 1 : ParseDouble(m.Attribute(TestChannelFields.Multiplier.ToString())?.Value),
                          UserOffsetEu = ParseDouble(m.Attribute(TestChannelFields.UserOffsetEU.ToString())?.Value),
                          UnitConversion = m.Attribute(TestChannelFields.UnitConversion.ToString()) == null ? 1 : ParseInt(m.Attribute(TestChannelFields.UnitConversion.ToString())?.Value),
                          AtCapacity = ParseBoolean(m.Attribute(TestChannelFields.AtCapacity.ToString())?.Value),
                          CapacityOutputIsBasedOn = ParseInt(m.Attribute(TestChannelFields.CapacityOutputIsBasedOn.ToString())?.Value),
                          SensitivityUnits = m.Attribute(TestChannelFields.SensitivityUnits.ToString())?.Value,
                          SensorCapacity = ParseInt(m.Attribute(TestChannelFields.SensorCapacity.ToString())?.Value),
                          SensorPolarity = m.Attribute(TestChannelFields.SensorPolarity.ToString())?.Value,
                          IsoCode = m.Attribute(TestChannelFields.IsoCode.ToString())?.Value ?? string.Empty,
                          IsoChannelName = m.Attribute(TestChannelFields.IsoChannelName.ToString())?.Value ?? string.Empty,
                          UserCode = m.Attribute(TestChannelFields.UserCode.ToString())?.Value ?? string.Empty,
                          UserChannelName = m.Attribute(TestChannelFields.UserChannelName.ToString())?.Value ?? string.Empty,
                          UseEUScaler = ParseBoolean(m.Attribute(TestChannelFields.UseEUScaler.ToString())?.Value),
                          ScaleFactorEU = ParseDouble(m.Attribute(TestChannelFields.ScaleFactorEU.ToString())?.Value),
                      }).Cast<ITestChannel>().ToList();
            }
            catch (Exception ex)
            {
                var error = ex.Message;
                tc = new List<ITestChannel>();
            }
            return tc;
        }


        /// <summary>
        /// Load Calculated Channels
        /// </summary>
        /// <param name="xTestCalculatedChannel"></param>
        /// <param name="testSetupName"></param>
        /// <param name="testId"></param>
        /// <returns></returns>
        private List<ITestChannel> LoadTestCalculatedChannels(IEnumerable<XElement> xTestCalculatedChannel, string testSetupName, string testId)
        {
            List<ITestChannel> list = new List<ITestChannel>();
            try
            {
                var calculatedChannelsPart = xTestCalculatedChannel.Descendants("CalculatedChannel");
                foreach (var m in calculatedChannelsPart)
                {
                    var tc = new TestChannel()
                    {
                        TestId = testId,
                        TestSetupName = testSetupName,
                        IsCalculatedChannel = true,
                        ChannelId =
                            m.Attribute(TestChannelFields.ChannelId.ToString()) == null ||
                            ParseInt(m.Attribute(TestChannelFields.ChannelId.ToString())?.Value) == -1
                                ? m.GetHashCode().ToString()
                                : m.Attribute(TestChannelFields.ChannelId.ToString())?.Value,
                        //37943, wipe info for calculated channels that's just the first channel's info
                        SerialNumber = Strings.Strings.Table_NA,
                        Description = m.Attribute(TestChannelFields.Description.ToString())?.Value,
                        ChannelType = m.Attribute(TestChannelFields.ChannelType.ToString())?.Value,
                        Number = ParseInt(m.Attribute(TestChannelFields.Number.ToString())?.Value),
                        DigitalMultiplier = m.Attribute(TestChannelFields.DigitalMultiplier.ToString())?.Value,
                        DigitalMode = m.Attribute(TestChannelFields.DigitalMode.ToString())?.Value,
                        Start = GetDateTime(m.Attribute(TestChannelFields.Start.ToString())?.Value),
                        Bridge = m.Attribute(TestChannelFields.Bridge.ToString())?.Value,
                        BridgeResistanceOhms =
                            ParseDouble(m.Attribute(TestChannelFields.BridgeResistanceOhms.ToString())?.Value),
                        ChannelDescriptionString =
                            m.Attribute(TestChannelFields.ChannelDescriptionString.ToString())?.Value,
                        ChannelName2 = m.Attribute(TestChannelFields.ChannelName2.ToString())?.Value,
                        HardwareChannelName = Strings.Strings.Table_NA,
                        DesiredRange = ParseDouble(m.Attribute(TestChannelFields.DesiredRange.ToString())?.Value),
                        Sensitivity = ParseDouble(m.Attribute(TestChannelFields.Sensitivity.ToString())?.Value),
                        SoftwareFilter = m.Attribute(TestChannelFields.SoftwareFilter.ToString())?.Value,
                        ProportionalToExcitation =
                            ParseBoolean(m.Attribute(TestChannelFields.ProportionalToExcitation.ToString())?.Value),
                        IsInverted = ParseBoolean(m.Attribute(TestChannelFields.IsInverted.ToString())?.Value),
                        LinearizationFormula = m.Attribute(TestChannelFields.LinearizationFormula.ToString())?.Value,
                        IsSubsampled = ParseBoolean(m.Attribute(TestChannelFields.IsSubsampled.ToString())?.Value),
                        AbsoluteDisplayOrder =
                            ParseInt(m.Attribute(TestChannelFields.AbsoluteDisplayOrder.ToString())?.Value),
                        LastCalibrationDate =
                            GetDateTime(m.Attribute(TestChannelFields.LastCalibrationDate.ToString())?.Value),
                        SensorId = m.Attribute(TestChannelFields.SensorId.ToString())?.Value,
                        OffsetToleranceLowMv =
                            ParseInt(m.Attribute(TestChannelFields.OffsetToleranceLowMv.ToString())?.Value),
                        OffsetToleranceHighMv =
                            ParseInt(m.Attribute(TestChannelFields.OffsetToleranceHighMv.ToString())?.Value),
                        DataFlag = ParseInt(m.Attribute(TestChannelFields.DataFlag.ToString())?.Value),
                        ExcitationVoltage = m.Attribute(TestChannelFields.ExcitationVoltage.ToString())?.Value,
                        Eu = m.Attribute(TestChannelFields.Eu.ToString())?.Value,
                        CalSignalEnabled =
                            ParseBoolean(m.Attribute(TestChannelFields.CalSignalEnabled.ToString())?.Value),
                        ShuntEnabled = ParseBoolean(m.Attribute(TestChannelFields.ShuntEnabled.ToString())?.Value),
                        VoltageInsertionCheckEnabled =
                            ParseBoolean(m.Attribute(TestChannelFields.VoltageInsertionCheckEnabled.ToString())?.Value),
                        RemoveOffset = ParseBoolean(m.Attribute(TestChannelFields.RemoveOffset.ToString())?.Value),
                        ZeroMethod = m.Attribute(TestChannelFields.ZeroMethod.ToString())?.Value,
                        ZeroAverageWindowBegin =
                            ParseDouble(m.Attribute(TestChannelFields.ZeroAverageWindowBegin.ToString())?.Value),
                        ZeroAverageWindowEnd =
                            ParseDouble(m.Attribute(TestChannelFields.ZeroAverageWindowEnd.ToString())?.Value),
                        InitialEu = ParseInt(m.Attribute(TestChannelFields.InitialEu.ToString())?.Value),
                        InitialOffset = m.Attribute(TestChannelFields.InitialOffset.ToString())?.Value,
                        UnsubsampledSampleRateHz =
                            ParseInt(m.Attribute(TestChannelFields.UnsubsampledSampleRateHz.ToString())?.Value),
                        MeasuredShuntDeflectionMv =
                            ParseDouble(m.Attribute(TestChannelFields.MeasuredShuntDeflectionMv.ToString())?.Value),
                        MeasuredExcitationVoltage =
                            ParseDouble(m.Attribute(TestChannelFields.MeasuredExcitationVoltage.ToString())?.Value),

                        FactoryExcitationVoltage =
                            ParseInt(m.Attribute(TestChannelFields.UnsubsampledSampleRateHz.ToString())?.Value),
                        TimeOfFirstSample =
                            ParseDouble(m.Attribute(TestChannelFields.MeasuredShuntDeflectionMv.ToString())?.Value),

                        Multiplier = m.Attribute(TestChannelFields.Multiplier.ToString()) == null
                            ? 1
                            : ParseDouble(m.Attribute(TestChannelFields.Multiplier.ToString())?.Value),
                        UserOffsetEu = ParseDouble(m.Attribute(TestChannelFields.UserOffsetEU.ToString())?.Value),
                        UnitConversion = m.Attribute(TestChannelFields.UnitConversion.ToString()) == null
                            ? 1
                            : ParseInt(m.Attribute(TestChannelFields.UnitConversion.ToString())?.Value),
                        AtCapacity = ParseBoolean(m.Attribute(TestChannelFields.AtCapacity.ToString())?.Value),
                        CapacityOutputIsBasedOn =
                            ParseInt(m.Attribute(TestChannelFields.CapacityOutputIsBasedOn.ToString())?.Value),

                        SourceChannelNumber = m.Attribute(TestChannelFields.SourceChannelNumber.ToString())?.Value,
                        SourceModuleNumber = m.Attribute(TestChannelFields.SourceModuleNumber.ToString())?.Value,
                        SourceModuleSerialNumber =
                            m.Attribute(TestChannelFields.SourceModuleSerialNumber.ToString())?.Value,
                        Calculation = m.Attribute(TestChannelFields.Calculation.ToString())?.Value,
                        SampleRateHz = ParseInt(m.Attribute(TestChannelFields.SampleRateHz.ToString())?.Value),
                        //37943, wipe info for calculated channels that's just the first channel's info
                        IsoCode = Strings.Strings.Table_NA,
                        //37943, wipe info for calculated channels that's just the first channel's info
                        IsoChannelName = Strings.Strings.Table_NA,
                        //37943, wipe info for calculated channels that's just the first channel's info
                        UserCode = Strings.Strings.Table_NA,
                        //37943, wipe info for calculated channels that's just the first channel's info
                        UserChannelName = Strings.Strings.Table_NA,
                        UseEUScaler = ParseBoolean(m.Attribute(TestChannelFields.UseEUScaler.ToString())?.Value),
                        ScaleFactorEU = ParseDouble(m.Attribute(TestChannelFields.ScaleFactorEU.ToString())?.Value),
                    };
                    var hic = m.Attribute("HIC");
                    if (null != hic)
                    {
                        if (double.TryParse(hic.Value, out var d))
                        {
                            tc.HIC = d;
                            tc.T1Sample = ulong.Parse(m.Attribute("T1").Value);
                            tc.T2Sample = ulong.Parse(m.Attribute("T2").Value);
                        }
                    }

                    list.Add(tc);
                }
            }
            catch (Exception ex)
            {
                var error = ex.Message;
                list = new List<ITestChannel>();
            }
            return list;
        }
        #endregion TestRunMetadata

        #endregion TestMetadata

        #region Support functions



        /// <summary>
        /// Safer way to parse 
        /// </summary>
        /// <param name="param"></param>
        /// <returns></returns>
        private int ParseInt(string param)
        {
            var result = 0;
            int.TryParse(param, out result);
            return result;
        }
        /// <summary>
        /// Safer way to parse 
        /// </summary>
        /// <param name="param"></param>
        /// <returns></returns>
        private double ParseDouble(string param)
        {
            double.TryParse(param, NumberStyles.Any, CultureInfo.InvariantCulture, out var result);
            return result;
        }
        /// <summary>
        /// Safer way to parse 
        /// </summary>
        /// <param name="param"></param>
        /// <returns></returns>
        private bool ParseBoolean(string param)
        {
            bool.TryParse(param, out var result);
            return result;
        }

        private DateTime ParseDateTime(string param)
        {
            DateTime.TryParse(param, out var result);
            return result;
        }



        #endregion Support functions
    }
}