using Adaptation.Eaf.Management.ConfigurationData.CellAutomation;
using Adaptation.Ifx.Eaf.Common.Configuration;
using Adaptation.Ifx.Eaf.EquipmentConnector.File.Configuration;
using Adaptation.Shared.Methods;
using Microsoft.VisualStudio.TestTools.UnitTesting;
using Shared.PasteSpecialXml.EAF.XML.API.CellInstance;
using Shared.PasteSpecialXml.EAF.XML.API.ConfigurationData;
using Shared.PasteSpecialXml.EAF.XML.API.EquipmentDictionary;
using Shared.PasteSpecialXml.EAF.XML.API.EquipmentType;
using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Text;
using System.Text.Json;
using System.Text.Json.Serialization;
using System.Xml;
using System.Xml.Linq;
using System.Xml.Serialization;

namespace Shared
{

    public class AdaptationTesting : ISMTP
    {

        protected readonly string _Environment;
        protected readonly string _HostNameAndPort;
        protected readonly TestContext _TestContext;
        protected readonly bool _SkipEquipmentDictionary;
        protected readonly Dictionary<string, CellInstanceVersion> _CellInstanceVersions;
        protected readonly Dictionary<string, EquipmentTypeVersion> _EquipmentTypeVersions;
        protected readonly Dictionary<string, string> _ParameterizedModelObjectDefinitionTypes;
        protected readonly Dictionary<string, EquipmentDictionaryVersion> _EquipmentDictionaryVersions;
        protected readonly Dictionary<string, FileConnectorConfiguration> _FileConnectorConfigurations;
        protected readonly Dictionary<string, IList<ModelObjectParameterDefinition>> _ModelObjectParameters;
        protected readonly Dictionary<string, List<Tuple<string, string>>> _EquipmentDictionaryEventDescriptions;

        public string Environment => _Environment;
        public TestContext TestContext => _TestContext;
        public string HostNameAndPort => _HostNameAndPort;
        public bool SkipEquipmentDictionary => _SkipEquipmentDictionary;
        public Dictionary<string, CellInstanceVersion> CellInstanceVersions => _CellInstanceVersions;
        public Dictionary<string, EquipmentTypeVersion> EquipmentTypeVersions => _EquipmentTypeVersions;
        public Dictionary<string, IList<ModelObjectParameterDefinition>> ModelObjectParameters => _ModelObjectParameters;
        public Dictionary<string, EquipmentDictionaryVersion> EquipmentDictionaryVersions => _EquipmentDictionaryVersions;
        public Dictionary<string, FileConnectorConfiguration> FileConnectorConfigurations => _FileConnectorConfigurations;
        public Dictionary<string, string> ParameterizedModelObjectDefinitionTypes => _ParameterizedModelObjectDefinitionTypes;
        public Dictionary<string, List<Tuple<string, string>>> EquipmentDictionaryEventDescriptions => _EquipmentDictionaryEventDescriptions;

        void ISMTP.SendLowPriorityEmailMessage(string subject, string body)
        {
            throw new NotImplementedException();
        }

        void ISMTP.SendHighPriorityEmailMessage(string subject, string body)
        {
            throw new NotImplementedException();
        }

        void ISMTP.SendNormalPriorityEmailMessage(string subject, string body)
        {
            throw new NotImplementedException();
        }

        public AdaptationTesting(TestContext testContext, bool skipEquipmentDictionary)
        {

            string environment = GetEnvironment(testContext);
            string hostNameAndPort = GetHostNameAndPort(environment);
            _TestContext = testContext;
            _Environment = environment;
            _HostNameAndPort = hostNameAndPort;
            _SkipEquipmentDictionary = skipEquipmentDictionary;
            _CellInstanceVersions = new Dictionary<string, CellInstanceVersion>();
            _EquipmentTypeVersions = new Dictionary<string, EquipmentTypeVersion>();
            _ParameterizedModelObjectDefinitionTypes = new Dictionary<string, string>();
            _EquipmentDictionaryVersions = new Dictionary<string, EquipmentDictionaryVersion>();
            _FileConnectorConfigurations = new Dictionary<string, FileConnectorConfiguration>();
            _ModelObjectParameters = new Dictionary<string, IList<ModelObjectParameterDefinition>>();
            _EquipmentDictionaryEventDescriptions = new Dictionary<string, List<Tuple<string, string>>>();
        }

        protected string GetEnvironment(TestContext testContext)
        {
            string result = testContext.TestName.Split('_')[0];
            return result;
        }

        protected string GetHostNameAndPort(string environment)
        {
            string result;
            result = environment switch
            {
                "LocalHost" => "localhost:9003",
                "Development" => "eaf-dev.mes.infineon.com:9003",
                "Staging" => "eaf-staging.mes.infineon.com:9003",
                "Production" => "eaf-prod.mes.infineon.com:9003",
                _ => throw new Exception(),
            };
            return result;
        }

        protected string GetTestResultsDirectory()
        {
            string result = string.Empty;
            string testResults = "05_TestResults";
            string checkDirectory = _TestContext.TestResultsDirectory;
            if (string.IsNullOrEmpty(checkDirectory) || !checkDirectory.Contains(testResults))
                throw new Exception();
            string rootDirectory = Path.GetPathRoot(checkDirectory);
            for (int i = 0; i < int.MaxValue; i++)
            {
                checkDirectory = Path.GetDirectoryName(checkDirectory);
                if (string.IsNullOrEmpty(checkDirectory) || checkDirectory == rootDirectory)
                    break;
                if (checkDirectory.EndsWith(testResults) && Directory.Exists(checkDirectory))
                {
                    result = checkDirectory;
                    break;
                }
            }
            if (string.IsNullOrEmpty(result))
                throw new Exception();
            return result;
        }

        protected string GetCellInstanceConnectionName(string cellInstanceConnectionName)
        {
            string result;
            if (string.IsNullOrEmpty(cellInstanceConnectionName) || cellInstanceConnectionName[cellInstanceConnectionName.Length - 1] != '_')
                result = cellInstanceConnectionName;
            else
            {
                bool check = false;
                List<char> chars = new List<char>();
                StringBuilder stringBuilder = new StringBuilder();
                for (int i = cellInstanceConnectionName.Length - 1; i > -1; i--)
                {
                    if (!check && cellInstanceConnectionName[i] != '_')
                        check = true;
                    else if (!check && cellInstanceConnectionName[i] == '_')
                        chars.Add('-');
                    if (check)
                        chars.Add(cellInstanceConnectionName[i]);
                }
                for (int i = chars.Count - 1; i > -1; i--)
                    stringBuilder.Append(chars[i]);
                result = stringBuilder.ToString();
            }
            return result;
        }

        private static string GetMethodBaseNameWithActualCICN(string methodBaseName, string cellInstanceName, string cellInstanceConnectionNameFromMethodBaseName, string cellInstanceConnectionName, string ticks)
        {
            string results;
            if (string.IsNullOrEmpty(cellInstanceConnectionNameFromMethodBaseName) || string.IsNullOrEmpty(cellInstanceConnectionName))
                results = methodBaseName;
            else if (cellInstanceConnectionNameFromMethodBaseName.Length != cellInstanceConnectionName.Length)
                throw new Exception();
            else
            {
                string[] segments = methodBaseName.Split(new string[] { cellInstanceName }, StringSplitOptions.None);
                if (segments.Length == 2)
                    results = methodBaseName.Replace(cellInstanceConnectionNameFromMethodBaseName, cellInstanceConnectionName);
                else if (segments.Length != 3)
                    throw new Exception();
                else if (string.IsNullOrEmpty(ticks))
                    results = string.Concat(segments[0], cellInstanceName, segments[1], cellInstanceConnectionName);
                else if (!segments[2].Contains(ticks))
                    throw new Exception();
                else
                    results = string.Concat(segments[0], cellInstanceName, segments[1], cellInstanceConnectionName, ticks, segments[2].Split(new string[] { ticks }, StringSplitOptions.None)[1]);
            }
            if (methodBaseName.Length != results.Length)
                throw new Exception();
            return results;
        }

        internal string[] GetSegments(string methodBaseName)
        {
            List<string> results;
            string fileFullName;
            string comment;
            string[] textFiles;
            string seperator = "__";
            string connectionNameAndTicks;
            string cellInstanceConnectionName;
            string ticks = DateTime.Now.Ticks.ToString();
            string cellInstanceConnectionNameFromMethodBaseName;
            string testResultsDirectory = GetTestResultsDirectory();
            string[] segments = methodBaseName.Split(new string[] { seperator }, StringSplitOptions.None);
            if (segments[0] != _Environment)
                throw new Exception();
            string rawVersionName = segments[1];
            string rawCellInstanceName = segments[2];
            string cellInstanceVersionName = segments[1].Replace('_', '.');
            string cellInstanceName = segments[2].Replace('_', '-').Replace("_EQPT", "-EQPT");
            string before = string.Concat(_Environment, seperator, rawVersionName, seperator, cellInstanceName, seperator);
            string after = methodBaseName.Substring(before.Length);
            string versionDirectory = Path.Combine(testResultsDirectory, _Environment, cellInstanceName, cellInstanceVersionName);
            if (!Directory.Exists(versionDirectory))
                Directory.CreateDirectory(versionDirectory);
            comment = segments[segments.Length - 1];
            if (after.Length < ticks.Length || after == comment)
            {
                ticks = string.Empty;
                cellInstanceConnectionNameFromMethodBaseName = string.Empty;
            }
            else
            {
                connectionNameAndTicks = after.Substring(0, after.Length - 2 - comment.Length);
                if (connectionNameAndTicks.Length - ticks.Length < 1)
                {
                    ticks = string.Empty;
                    cellInstanceConnectionNameFromMethodBaseName = string.Empty;
                }
                else
                {
                    cellInstanceConnectionNameFromMethodBaseName = connectionNameAndTicks.Substring(0, connectionNameAndTicks.Length - ticks.Length);
                    ticks = connectionNameAndTicks.Substring(cellInstanceConnectionNameFromMethodBaseName.Length);
                }
            }
            if (string.IsNullOrEmpty(ticks) || string.IsNullOrEmpty(cellInstanceConnectionNameFromMethodBaseName) || !long.TryParse(ticks, out long _))
            {
                ticks = string.Empty;
                comment = string.Empty;
                cellInstanceConnectionNameFromMethodBaseName = after;
            }
            cellInstanceConnectionName = GetCellInstanceConnectionName(cellInstanceConnectionNameFromMethodBaseName);
            string methodBaseNameWithActualCICN = GetMethodBaseNameWithActualCICN(methodBaseName, rawCellInstanceName, cellInstanceConnectionNameFromMethodBaseName, cellInstanceConnectionName, ticks);
            if (string.IsNullOrEmpty(ticks))
            {
                textFiles = new string[] { };
                fileFullName = Path.Combine(versionDirectory, methodBaseNameWithActualCICN, $"{cellInstanceConnectionNameFromMethodBaseName}.json");
            }
            else
            {
                segments = methodBaseNameWithActualCICN.Split(new string[] { ticks }, StringSplitOptions.None);
                string textDirectory = Path.Combine(versionDirectory, segments[0], string.Concat(ticks, segments[1]));
                fileFullName = Path.Combine(versionDirectory, segments[0], $"{cellInstanceConnectionNameFromMethodBaseName}.json");
                if (!Directory.Exists(textDirectory))
                {
                    textFiles = new string[] { };
                    string renameDirectory = Path.Combine(Path.GetDirectoryName(textDirectory), $"_Rename - {Path.GetFileName(textDirectory)}");
                    Directory.CreateDirectory(renameDirectory);
                    Process.Start("explorer.exe", renameDirectory);
                    File.WriteAllText(Path.Combine(renameDirectory, $"{nameof(FileConnectorConfiguration.SourceFileFilter)}.txt"), string.Empty);
                    File.WriteAllText(Path.Combine(renameDirectory, $"{nameof(FileConnectorConfiguration.SourceFileLocation)}.txt"), string.Empty);
                }
                else
                {
                    textFiles = Directory.GetFiles(textDirectory, "*.txt", SearchOption.TopDirectoryOnly);
                    if (!textFiles.Any())
                    {
                        Process.Start("explorer.exe", textDirectory);
                        File.WriteAllText(Path.Combine(textDirectory, "_ Why.why"), string.Empty);
                    }
                }
            }
            results = new List<string>
            {
                _Environment,
                rawCellInstanceName,
                cellInstanceName,
                cellInstanceVersionName,
                cellInstanceConnectionNameFromMethodBaseName,
                cellInstanceConnectionName,
                ticks,
                comment,
                fileFullName
            };
            results.AddRange(textFiles);
            return results.ToArray();
        }

        internal string[] GetSegments(MethodBase methodBase)
        {
            string[] results = GetSegments(methodBase.Name);
            return results;
        }

        internal string GetEnvironment(string[] segments)
        {
            return segments[0];
        }

        internal string GetRawCellInstanceName(string[] segments)
        {
            return segments[1];
        }

        internal string GetCellInstanceName(string[] segments)
        {
            return segments[2];
        }

        internal string GetCellInstanceVersionName(string[] segments)
        {
            return segments[3];
        }

        internal string GetCellInstanceConnectionNameFromMethodBaseName(string[] segments)
        {
            return segments[4];
        }

        internal string GetCellInstanceConnectionName(string[] segments)
        {
            return segments[5];
        }

        internal string GetTicks(string[] segments)
        {
            return segments[6];
        }

        internal string GetComment(string[] segments)
        {
            return segments[7];
        }

        internal FileInfo GetFileName(string[] segments)
        {
            return new FileInfo(segments[8]);
        }

        internal string[] GetTextFiles(string[] segments)
        {
            List<string> results = new List<string>();
            if (segments.Length > 8)
            {
                for (int i = 9; i < segments.Length; i++)
                    results.Add(segments[i]);
            }
            return results.ToArray();
        }

        protected Stream ToStream(string @this)
        {
            MemoryStream memoryStream = new MemoryStream();
            StreamWriter streamWriter = new StreamWriter(memoryStream);
            streamWriter.Write(@this);
            streamWriter.Flush();
            memoryStream.Position = 0;
            return memoryStream;
        }

        internal T ParseXML<T>(string @this, bool throwExceptions) where T : class
        {
            object result = null;
            try
            {
                Stream stream = ToStream(@this.Trim());
                XmlReader xmlReader = XmlReader.Create(stream, new XmlReaderSettings() { ConformanceLevel = ConformanceLevel.Document });
                XmlSerializer xmlSerializer = new XmlSerializer(typeof(T), typeof(T).GetNestedTypes());
                result = xmlSerializer.Deserialize(xmlReader);
                stream.Dispose();
            }
            catch (Exception)
            {
                if (throwExceptions)
                    throw;
            }
            return result as T;
        }

        protected CellInstanceVersion GetCellInstanceVersion(string url)
        {
            CellInstanceVersion result;
            byte[] byteArray;
            ConfigurationData configurationData;
            string decodedCellInstanceConfigurationData;
            string xml;
            try
            {
                xml = XDocument.Load(url).ToString();
            }
            catch (System.Exception exception)
            {
                throw new Exception(string.Concat(url, System.Environment.NewLine, exception.Message));
            }
            configurationData = ParseXML<ConfigurationData>(xml, throwExceptions: true);
            byteArray = Convert.FromBase64String(configurationData.Data);
            decodedCellInstanceConfigurationData = Encoding.Unicode.GetString(byteArray);
            if (xml.Length <= 41)
                throw new Exception(string.Concat("xml isn't valid {", xml, "}"));
            decodedCellInstanceConfigurationData = decodedCellInstanceConfigurationData.Substring(41).Replace("i:type", "i___type");
            result = ParseXML<CellInstanceVersion>(decodedCellInstanceConfigurationData, throwExceptions: true);
            return result;
        }

        protected Tuple<string, CellInstanceVersion> GetCellInstanceVersionTuple(string cellInstanceName, string cellInstanceVersionName)
        {
            Tuple<string, CellInstanceVersion> result;
            CellInstanceVersion cellInstanceVersion;
            string cellInstanceServiceV2 = string.Concat("http://", _HostNameAndPort, "/CellInstanceServiceV2/", cellInstanceName, "/", cellInstanceVersionName, "/configuration");
            if (_CellInstanceVersions.ContainsKey(cellInstanceServiceV2))
                cellInstanceVersion = _CellInstanceVersions[cellInstanceServiceV2];
            else
            {
                cellInstanceVersion = GetCellInstanceVersion(cellInstanceServiceV2);
                _CellInstanceVersions.Add(cellInstanceServiceV2, cellInstanceVersion);
            }
            result = new Tuple<string, CellInstanceVersion>(cellInstanceServiceV2, cellInstanceVersion);
            return result;
        }

        protected Dictionary<string, int[]> GetComponentModelComponentsIndexes(CellInstanceVersion cellInstanceVersion, string cellInstanceConnectionName)
        {
            Dictionary<string, int[]> results = new Dictionary<string, int[]>();
            ComponentsCellComponent componentsCellComponent;
            if (!(cellInstanceVersion.ComponentModel.Components is null))
            {
                for (int i = 0; i < cellInstanceVersion.ComponentModel.Components.Length; i++)
                {
                    componentsCellComponent = cellInstanceVersion.ComponentModel.Components[i];
                    for (int j = 0; j < componentsCellComponent.Children.Length; j++)
                    {
                        if (string.IsNullOrEmpty(componentsCellComponent.Children[j].Equipment.Name))
                            continue;
                        results.Add(componentsCellComponent.Children[j].Name, new int[] { i, j });
                    }
                }
            }
            if (!results.Any() || (!string.IsNullOrEmpty(cellInstanceConnectionName) && !results.ContainsKey(cellInstanceConnectionName)))
                throw new Exception("Match not found (check test method name matches Mango)!");
            return results;
        }

        protected int[] GetCellInstanceConnectionNameIndexes(string cellInstanceConnectionName, Dictionary<string, int[]> componentModelComponentsIndexes)
        {
            int[] result;
            if (string.IsNullOrEmpty(cellInstanceConnectionName))
                result = componentModelComponentsIndexes.ElementAt(0).Value;
            else
            {
                if (componentModelComponentsIndexes is null || !componentModelComponentsIndexes.ContainsKey(cellInstanceConnectionName))
                    throw new Exception();
                result = componentModelComponentsIndexes[cellInstanceConnectionName];
            }
            return result;
        }

        protected bool GetNoEvents(ComponentsCellComponentCellComponent componentsCellComponentCellComponent)
        {
            bool result = componentsCellComponentCellComponent.Equipment.EquipmentDictionaries?.CellEquipmentDictionaryReference?.DictionaryName is null;
            return result;
        }

        protected string GetEquipmentDictionaryName(ComponentsCellComponentCellComponent componentsCellComponentCellComponent, bool noEvents, string defaultEquipmentDictionaryName)
        {
            string result;
            if (noEvents)
                result = defaultEquipmentDictionaryName;
            else
                result = componentsCellComponentCellComponent.Equipment.EquipmentDictionaries.CellEquipmentDictionaryReference.DictionaryName;
            return result;
        }

        protected string[] GetCSharpTextB(string cellInstanceName, string cellInstanceVersionName, CellInstanceVersion cellInstanceVersion, FileInfo fileInfo)
        {
            List<string> results = new List<string>();
            string check;
            bool noEvents;
            string loopName;
            string equipmentTypeName;
            string equipmentDictionaryName;
            string methodName = string.Empty;
            string extractText = string.Empty;
            string defaultEquipmentDictionaryName;
            string createSelfDescriptionText = string.Empty;
            StringBuilder stringBuilder = new StringBuilder();
            List<string> componentsCellComponentCellComponentEquipmentNames = new();
            string cellInstanceNameWithoutHyphen = cellInstanceName.Replace('-', '_');
            ComponentsCellComponentCellComponent componentsCellComponentCellComponent;
            List<string> componentsCellComponentCellComponentEquipmentTypeNames = new();
            string cellInstanceVersionNameAsCode = cellInstanceVersionName.Replace('.', '_');
            const string sourceDirectoryCloaking = nameof(FileConnectorConfiguration.SourceDirectoryCloaking);
            for (int i = 1; i < 3; i++)
            {
                if (i == 2)
                    loopName = "Extract";
                else if (i == 1)
                    loopName = "CreateSelfDescription";
                else
                    throw new Exception();
                defaultEquipmentDictionaryName = string.Empty;
                if (i == 2)
                    stringBuilder.
                        AppendLine("using Microsoft.VisualStudio.TestTools.UnitTesting;").
                        AppendLine("using Shared;").
                        AppendLine("using System.Diagnostics;");
                else if (i == 1)
                    stringBuilder.
                        AppendLine("using Adaptation.Shared.Methods;").
                        AppendLine("using Microsoft.Extensions.Logging;").
                        AppendLine("using Microsoft.VisualStudio.TestTools.UnitTesting;").
                        AppendLine("using Shared;").
                        AppendLine("using System;").
                        AppendLine("using System.Collections.Generic;").
                        AppendLine("using System.Diagnostics;").
                        AppendLine("using System.IO;").
                        AppendLine("using System.Reflection;").
                        AppendLine("using System.Text.Json;").
                        AppendLine("using System.Threading;");
                else
                    throw new Exception();
                stringBuilder.AppendLine().
                    Append("namespace _Tests.").Append(loopName).Append('.').Append(_Environment).Append('.').AppendLine(cellInstanceVersionNameAsCode).
                    AppendLine("{").
                    AppendLine().
                    AppendLine("[TestClass]");
                if (i == 2)
                    stringBuilder.
                        Append("public class ").AppendLine(cellInstanceNameWithoutHyphen).
                        AppendLine("{").
                        AppendLine().
                        Append("private static CreateSelfDescription.").Append(_Environment).Append('.').Append(cellInstanceVersionNameAsCode).Append('.').Append(cellInstanceNameWithoutHyphen).Append(" _").Append(cellInstanceNameWithoutHyphen).AppendLine(";");
                else if (i == 1)
                    stringBuilder.
                        Append("public class ").Append(cellInstanceNameWithoutHyphen).AppendLine(" : EAFLoggingUnitTesting").
                        AppendLine("{").
                        AppendLine().
                        Append("private static ").Append(cellInstanceNameWithoutHyphen).AppendLine(" _EAFLoggingUnitTesting;").
                        Append("internal static ").Append(cellInstanceNameWithoutHyphen).AppendLine(" EAFLoggingUnitTesting => _EAFLoggingUnitTesting;");
                else
                    throw new Exception();
                if (i == 2)
                    stringBuilder.AppendLine();
                else if (i == 1)
                    stringBuilder.
                        AppendLine().
                        Append("public ").Append(cellInstanceNameWithoutHyphen).AppendLine("() : base(testContext: null, declaringType: null, skipEquipmentDictionary: false)").
                        AppendLine("{").
                        AppendLine("if (_EAFLoggingUnitTesting is null)").
                        AppendLine("throw new Exception();").
                        AppendLine("}").
                        AppendLine().
                        Append("public ").Append(cellInstanceNameWithoutHyphen).AppendLine("(TestContext testContext) : base(testContext, new StackFrame().GetMethod().DeclaringType, skipEquipmentDictionary: false)").
                        AppendLine("{").
                        AppendLine("}").
                        AppendLine();
                else
                    throw new Exception();
                stringBuilder.
                    AppendLine("[ClassInitialize]").
                    AppendLine("public static void ClassInitialize(TestContext testContext)").
                    AppendLine("{");
                if (i == 2)
                    stringBuilder.
                        Append("CreateSelfDescription.").Append(_Environment).Append('.').Append(cellInstanceVersionNameAsCode).Append('.').Append(cellInstanceNameWithoutHyphen).AppendLine(".ClassInitialize(testContext);").
                        Append("_").Append(cellInstanceNameWithoutHyphen).Append(" = CreateSelfDescription.").Append(_Environment).Append('.').Append(cellInstanceVersionNameAsCode).Append('.').Append(cellInstanceNameWithoutHyphen).AppendLine(".EAFLoggingUnitTesting;").
                        AppendLine("}");
                else if (i == 1)
                    stringBuilder.
                        AppendLine("if (_EAFLoggingUnitTesting is null)").
                        Append("_EAFLoggingUnitTesting = new ").Append(cellInstanceNameWithoutHyphen).AppendLine("(testContext);").
                        AppendLine("_EAFLoggingUnitTesting.Logger.LogInformation(string.Concat(testContext.TestName, \" - ClassInitialize\"));").
                        AppendLine("string[] fileNameAndText = _EAFLoggingUnitTesting.AdaptationTesting.GetCSharpText(testContext.TestName);").
                        AppendLine("File.WriteAllText(fileNameAndText[0], fileNameAndText[1]);").
                        AppendLine("File.WriteAllText(fileNameAndText[2], fileNameAndText[3]);").
                        AppendLine("}");
                else
                    throw new Exception();
                if (i == 2)
                    stringBuilder.AppendLine();
                else if (i == 1)
                    stringBuilder.
                        AppendLine().
                        AppendLine("[ClassCleanup()]").
                        AppendLine("public static void ClassCleanup()").
                        AppendLine("{").
                        AppendLine("if (!(_EAFLoggingUnitTesting.Logger is null))").
                        AppendLine("_EAFLoggingUnitTesting.Logger.LogInformation(\"Cleanup\");").
                        AppendLine("if (!(_EAFLoggingUnitTesting is null))").
                        AppendLine("_EAFLoggingUnitTesting.Dispose();").
                        AppendLine("}").
                        AppendLine();
                else
                    throw new Exception();
                foreach (ComponentsCellComponent componentsCellComponent in cellInstanceVersion.ComponentModel.Components)
                {
                    if (componentsCellComponent.Children.Length != 1)
                        continue;
                    componentsCellComponentCellComponent = componentsCellComponent.Children[0];
                    noEvents = GetNoEvents(componentsCellComponentCellComponent);
                    if (noEvents)
                        continue;
                    defaultEquipmentDictionaryName = GetEquipmentDictionaryName(componentsCellComponentCellComponent, noEvents, defaultEquipmentDictionaryName);
                }
                if (string.IsNullOrEmpty(defaultEquipmentDictionaryName))
                    throw new Exception("At least one dictionary name should be marked as used in EAF CI!");
                foreach (ComponentsCellComponent componentsCellComponent in cellInstanceVersion.ComponentModel.Components)
                {
                    if (componentsCellComponent.Children.Length != 1)
                        continue;
                    componentsCellComponentCellComponent = componentsCellComponent.Children[0];
                    componentsCellComponentCellComponentEquipmentNames.Add(componentsCellComponentCellComponent.Equipment.Name);
                    componentsCellComponentCellComponentEquipmentTypeNames.Add(componentsCellComponentCellComponent.Equipment.EquipmentType.Name);
                    methodName = $"{_Environment}__{cellInstanceVersionNameAsCode}__{cellInstanceNameWithoutHyphen}__{componentsCellComponentCellComponent.Equipment.Name.Replace('-', '_')}";
                    if (componentsCellComponentCellComponent?.Equipment?.ConnectionSettings?.Setting is null)
                        check = string.Empty;
                    else
                        check = (from l in componentsCellComponentCellComponent.Equipment.ConnectionSettings.Setting where l.Name == sourceDirectoryCloaking select l.Value).FirstOrDefault();
                    if (string.IsNullOrEmpty(check))
                        check = componentsCellComponentCellComponent.Equipment.SourceFileFilter;
                    stringBuilder.
                        AppendLine("[TestMethod]").
                        Append("public void ").Append(methodName).AppendLine("()").
                        AppendLine("{");
                    if (i == 2)
                        stringBuilder.Append("_").Append(cellInstanceNameWithoutHyphen).Append('.').Append(methodName).AppendLine("();");
                    else if (i == 1)
                    {
                        if (componentsCellComponentCellComponent.Equipment.EquipmentType.Version != cellInstanceVersionName)
                            throw new Exception("Versions should match!");
                        equipmentTypeName = componentsCellComponentCellComponent.Equipment.EquipmentType.Name;
                        noEvents = GetNoEvents(componentsCellComponentCellComponent);
                        equipmentDictionaryName = GetEquipmentDictionaryName(componentsCellComponentCellComponent, noEvents, defaultEquipmentDictionaryName);
                        stringBuilder.
                            Append("string check = \"").Append(check).AppendLine("\";").
                            AppendLine("MethodBase methodBase = new StackFrame().GetMethod();").
                            AppendLine("_EAFLoggingUnitTesting.Logger.LogInformation(string.Concat(methodBase.Name, \" - Getting configuration\"));").
                            AppendLine("string[] fileNameAndJson = _EAFLoggingUnitTesting.AdaptationTesting.GetConfiguration(methodBase);").
                            AppendLine("Assert.IsTrue(fileNameAndJson[1].Contains(check));").
                            AppendLine("File.WriteAllText(fileNameAndJson[0], fileNameAndJson[1]);");
                        if (componentsCellComponentCellComponent.Equipment.EquipmentType.Name == componentsCellComponentCellComponentEquipmentTypeNames[0])
                            stringBuilder.
                                AppendLine("IFileRead fileRead = _EAFLoggingUnitTesting.AdaptationTesting.Get(methodBase, sourceFileLocation: string.Empty, sourceFileFilter: string.Empty, useCyclicalForDescription: false);").
                                AppendLine("Assert.IsFalse(string.IsNullOrEmpty(fileRead.CellInstanceConnectionName));");
                        stringBuilder.
                            AppendLine("_EAFLoggingUnitTesting.Logger.LogInformation(string.Concat(methodBase.Name, \" - Exit\"));");
                    }
                    else
                        throw new Exception();
                    stringBuilder.
                        AppendLine("}").
                        AppendLine();
                }
                stringBuilder.
                    AppendLine("}").
                    AppendLine().
                    AppendLine("}").
                    AppendLine().
                    AppendLine("// dotnet build --runtime win-x64").
                    Append("// dotnet test --runtime win-x64 --no-build --filter \"FullyQualifiedName~_Tests.").Append(loopName).Append('.').Append(_Environment).Append('.').Append(cellInstanceVersionNameAsCode).AppendLine("\" --% -- TestRunParameters.Parameter(name=\\\"Debug\\\", value=\\\"Debugger.IsAttached\\\")").
                    Append("// dotnet test --runtime win-x64 --no-build --filter \"FullyQualifiedName~_Tests.").Append(loopName).Append('.').Append(_Environment).Append('.').Append(cellInstanceVersionNameAsCode).Append(" & ClassName~").Append(cellInstanceNameWithoutHyphen).AppendLine("\" --% -- TestRunParameters.Parameter(name=\\\"Debug\\\", value=\\\"Debugger.IsAttached\\\")").
                    Append("// dotnet test --runtime win-x64 --no-build --filter \"FullyQualifiedName~_Tests.").Append(loopName).Append('.').Append(_Environment).Append('.').Append(cellInstanceVersionNameAsCode).Append(" & ClassName~").Append(cellInstanceNameWithoutHyphen).Append(" & ").Append(methodName).AppendLine("\" --% -- TestRunParameters.Parameter(name=\\\"Debug\\\", value=\\\"Debugger.IsAttached\\\")");
                if (i == 2)
                    extractText = stringBuilder.ToString().Trim();
                else if (i == 1)
                    createSelfDescriptionText = stringBuilder.ToString().Trim();
                else
                    throw new Exception();
                stringBuilder.Clear();
            }
            if (string.IsNullOrEmpty(cellInstanceVersion.FrozenBy))
            {
                if (!cellInstanceVersion.CellCommunicatingRule.Contains('.') || !(from l in componentsCellComponentCellComponentEquipmentNames where l == cellInstanceVersion.CellCommunicatingRule.Split('.')[0] select true).Any())
                    throw new Exception("CellCommunicatingRule not correct in Mango!");
                if (!cellInstanceVersion.CellNotCommunicatingRule.Contains('.') || !(from l in componentsCellComponentCellComponentEquipmentNames where l == cellInstanceVersion.CellNotCommunicatingRule.Split('.')[0] select true).Any())
                    throw new Exception("CellNotCommunicatingRule not correct in Mango!");
            }
            string versionLevelDirectory = Path.GetDirectoryName(fileInfo.DirectoryName);
            results.Add(Path.Combine(versionLevelDirectory, $"{cellInstanceName}-0-CreateSelfDescription.txt"));
            results.Add(createSelfDescriptionText);
            results.Add(Path.Combine(versionLevelDirectory, $"{cellInstanceName}-1-Extract.txt"));
            results.Add(extractText);
            return results.ToArray();
        }

        protected FileConnectorConfiguration GetFileConnectorConfiguration(string json, ComponentsCellComponentCellComponent componentsCellComponentCellComponent)
        {
            FileConnectorConfiguration result;
            const string sourceDirectoryCloaking = nameof(FileConnectorConfiguration.SourceDirectoryCloaking);
            JsonSerializerOptions jsonSerializerOptions = new JsonSerializerOptions { Converters = { new JsonStringEnumConverter(JsonNamingPolicy.CamelCase) } };
            json = json.Replace(string.Concat("\"", nameof(FileConnectorConfiguration.ConnectionSettings), "\":"), string.Concat("\"Ignore", nameof(FileConnectorConfiguration.ConnectionSettings), "\":"));
            result = JsonSerializer.Deserialize<FileConnectorConfiguration>(json, jsonSerializerOptions);
            if (string.IsNullOrEmpty(result.SourceFileFilter))
                result.SourceFileFilter = string.Empty;
            if (result.ErrorTargetFileLocation is null)
                result.ErrorTargetFileLocation = string.Empty;
            if (result.SourceFileLocation is null)
                result.SourceFileLocation = string.Empty;
            if (result.TargetFileLocation is null)
                result.TargetFileLocation = string.Empty;
            if (result.FolderAgeCheckIndividualSubFolders is null)
                result.FolderAgeCheckIndividualSubFolders = false;
            result.ConnectionSettings = new List<ConnectionSetting>();
            result.SourceFileFilters = result.SourceFileFilter.Split('|').ToList();
            if (!(componentsCellComponentCellComponent.Equipment?.ConnectionSettings is null))
            {
                foreach (Setting setting in componentsCellComponentCellComponent.Equipment.ConnectionSettings.Setting)
                    result.ConnectionSettings.Add(new ConnectionSetting(null, null) { Name = setting.Name, Value = setting.Value });
            }
            IEnumerable<ConnectionSetting> sourceDirectoryCloakingCollection = (from l in result.ConnectionSettings where l.Name == sourceDirectoryCloaking select l);
            if (sourceDirectoryCloakingCollection.Any())
                result.SourceDirectoryCloaking = sourceDirectoryCloakingCollection.First().Value;
            else
            {
                result.SourceDirectoryCloaking = string.Empty;
                result.ConnectionSettings.Add(new ConnectionSetting(null, null) { Name = sourceDirectoryCloaking, Value = string.Empty });
            }
            return result;
        }

        protected Tuple<string, FileConnectorConfiguration> GetFileConnectorConfigurationTuple(Tuple<string, CellInstanceVersion> cellInstanceVersionTuple, string cellInstanceConnectionName)
        {
            Tuple<string, FileConnectorConfiguration> result;
            FileConnectorConfiguration fileConnectorConfiguration;
            string cellInstanceServiceV2With = string.Concat(cellInstanceVersionTuple.Item1, '/', cellInstanceConnectionName);
            if (_FileConnectorConfigurations.ContainsKey(cellInstanceServiceV2With))
                fileConnectorConfiguration = _FileConnectorConfigurations[cellInstanceServiceV2With];
            else
            {
                Dictionary<string, int[]> componentModelComponentsIndexes = GetComponentModelComponentsIndexes(cellInstanceVersionTuple.Item2, cellInstanceConnectionName);
                int[] cellInstanceConnectionNameIndexes = GetCellInstanceConnectionNameIndexes(cellInstanceConnectionName, componentModelComponentsIndexes);
                ComponentsCellComponentCellComponent componentsCellComponentCellComponent = cellInstanceVersionTuple.Item2.ComponentModel.Components[cellInstanceConnectionNameIndexes[0]].Children[cellInstanceConnectionNameIndexes[1]];
                string json = JsonSerializer.Serialize(componentsCellComponentCellComponent.Equipment, new JsonSerializerOptions { WriteIndented = true });
                fileConnectorConfiguration = GetFileConnectorConfiguration(json, componentsCellComponentCellComponent);
                _FileConnectorConfigurations.Add(cellInstanceServiceV2With, fileConnectorConfiguration);
            }
            result = new Tuple<string, FileConnectorConfiguration>(cellInstanceServiceV2With, fileConnectorConfiguration);
            return result;
        }

        protected EquipmentTypeVersion GetEquipmentTypeVersion(string url)
        {
            EquipmentTypeVersion result;
            byte[] byteArray;
            ConfigurationData configurationData;
            string decodedCellInstanceConfigurationData;
            string xml;
            try
            {
                xml = XDocument.Load(url).ToString();
            }
            catch (System.Exception exception)
            {
                throw new Exception(string.Concat(url, System.Environment.NewLine, exception.Message));
            }
            configurationData = ParseXML<ConfigurationData>(xml, throwExceptions: true);
            byteArray = Convert.FromBase64String(configurationData.Data);
            decodedCellInstanceConfigurationData = Encoding.Unicode.GetString(byteArray);
            if (xml.Length <= 41)
                throw new Exception(string.Concat("xml isn't valid {", xml, "}"));
            decodedCellInstanceConfigurationData = decodedCellInstanceConfigurationData.Substring(41).Replace("i:type", "i___type");
            result = ParseXML<EquipmentTypeVersion>(decodedCellInstanceConfigurationData, throwExceptions: true);
            return result;
        }

        protected Tuple<string, string, string, EquipmentTypeVersion> GetEquipmentTypeVersionTuple(string cellInstanceName, string cellInstanceVersionName, CellInstanceVersion cellInstanceVersion, string cellInstanceConnectionName)
        {
            Tuple<string, string, string, EquipmentTypeVersion> result;
            EquipmentTypeVersion equipmentTypeVersion;
            Dictionary<string, int[]> componentModelComponentsIndexes = GetComponentModelComponentsIndexes(cellInstanceVersion, cellInstanceConnectionName);
            int[] cellInstanceConnectionNameIndexes = GetCellInstanceConnectionNameIndexes(cellInstanceConnectionName, componentModelComponentsIndexes);
            ComponentsCellComponentCellComponent componentsCellComponentCellComponent = cellInstanceVersion.ComponentModel.Components[cellInstanceConnectionNameIndexes[0]].Children[cellInstanceConnectionNameIndexes[1]];
            string equipmentTypeServiceV2 = string.Concat("http://", _HostNameAndPort, "/EquipmentTypeServiceV2/", componentsCellComponentCellComponent.Equipment.EquipmentType.Name, "/", componentsCellComponentCellComponent.Equipment.EquipmentType.Version, "/configuration");
            if (_EquipmentTypeVersions.ContainsKey(equipmentTypeServiceV2))
                equipmentTypeVersion = _EquipmentTypeVersions[equipmentTypeServiceV2];
            else
            {
                equipmentTypeVersion = GetEquipmentTypeVersion(equipmentTypeServiceV2);
                _EquipmentTypeVersions.Add(equipmentTypeServiceV2, equipmentTypeVersion);
            }
            result = new Tuple<string, string, string, EquipmentTypeVersion>(equipmentTypeServiceV2, componentsCellComponentCellComponent.Equipment.EquipmentType.Name, componentsCellComponentCellComponent.Equipment.EquipmentType.Version, equipmentTypeVersion);
            return result;
        }

        protected Tuple<string, string> GetParameterizedModelObjectDefinitionTypeTuple(Tuple<string, string, string, EquipmentTypeVersion> equipmentTypeVersionTuple)
        {
            Tuple<string, string> result;
            string parameterizedModelObjectDefinitionType;
            if (_FileConnectorConfigurations.ContainsKey(equipmentTypeVersionTuple.Item1))
                parameterizedModelObjectDefinitionType = _ParameterizedModelObjectDefinitionTypes[equipmentTypeVersionTuple.Item1];
            else
                parameterizedModelObjectDefinitionType = equipmentTypeVersionTuple.Item4.FileHandlerObjectTypes.ParameterizedModelObjectDefinition.Type;
            result = new Tuple<string, string>(equipmentTypeVersionTuple.Item1, parameterizedModelObjectDefinitionType);
            return result;
        }

        protected IList<ModelObjectParameterDefinition> GetModelObjectParameters(string json)
        {
            IList<ModelObjectParameterDefinition> results;
            JsonSerializerOptions jsonSerializerOptions = new JsonSerializerOptions { Converters = { new JsonStringEnumConverter(JsonNamingPolicy.CamelCase) } };
            JsonElement jsonElement = JsonSerializer.Deserialize<JsonElement>(json);
            string parameters = "Parameters";
            string fileHandlerObjectTypes = nameof(FileHandlerObjectTypes);
            string parameterizedModelObjectDefinition = nameof(ParameterizedModelObjectDefinition);
            if (!json.Contains(fileHandlerObjectTypes) || !json.Contains(parameterizedModelObjectDefinition))
                throw new Exception();
            jsonElement = jsonElement.GetProperty(fileHandlerObjectTypes);
            if (jsonElement.ValueKind != JsonValueKind.Object)
                throw new Exception();
            jsonElement = jsonElement.GetProperty(parameterizedModelObjectDefinition);
            if (jsonElement.ValueKind != JsonValueKind.Object)
                throw new Exception();
            jsonElement = jsonElement.GetProperty(parameters);
            if (jsonElement.ValueKind != JsonValueKind.Array)
                throw new Exception();
            results = JsonSerializer.Deserialize<IList<ModelObjectParameterDefinition>>(jsonElement.ToString(), jsonSerializerOptions);
            return results;
        }

        protected Tuple<string, IList<ModelObjectParameterDefinition>> GetModelObjectParameters(Tuple<string, string, string, EquipmentTypeVersion> equipmentTypeVersionTuple)
        {
            Tuple<string, IList<ModelObjectParameterDefinition>> result;
            IList<ModelObjectParameterDefinition> modelObjectParameters;
            if (_FileConnectorConfigurations.ContainsKey(equipmentTypeVersionTuple.Item1))
                modelObjectParameters = _ModelObjectParameters[equipmentTypeVersionTuple.Item1];
            else
            {
                string json = JsonSerializer.Serialize(equipmentTypeVersionTuple.Item4, new JsonSerializerOptions { WriteIndented = true });
                modelObjectParameters = GetModelObjectParameters(json);
            }
            result = new Tuple<string, IList<ModelObjectParameterDefinition>>(equipmentTypeVersionTuple.Item1, modelObjectParameters);
            return result;
        }

        protected string[] GetEquipmentDictionaryStrings(ComponentsCellComponentCellComponentEquipment componentsCellComponentCellComponentEquipment, EquipmentTypeVersion equipmentTypeVersion)
        {
            string[] results;
            string equipmentDictionaryName;
            string equipmentDictionaryVersionName;
            if (_SkipEquipmentDictionary || equipmentTypeVersion?.EventActionSequences is null || !equipmentTypeVersion.EventActionSequences.Any() || !(from l in equipmentTypeVersion.EventActionSequences where l.HandledEvent.StartsWith("Equipment.FileRead") select 1).Any())
            {
                equipmentDictionaryName = string.Empty;
                equipmentDictionaryVersionName = string.Empty;
            }
            else
            {
                if (componentsCellComponentCellComponentEquipment?.EquipmentDictionaries.CellEquipmentDictionaryReference is null)
                {
                    equipmentDictionaryName = equipmentTypeVersion.Dictionaries.EquipmentTypeDictionaryReference.DictionaryName;
                    equipmentDictionaryVersionName = equipmentTypeVersion.Dictionaries.EquipmentTypeDictionaryReference.DictionaryVersion;
                }
                else
                {
                    equipmentDictionaryName = componentsCellComponentCellComponentEquipment.EquipmentDictionaries.CellEquipmentDictionaryReference.DictionaryName;
                    equipmentDictionaryVersionName = componentsCellComponentCellComponentEquipment.EquipmentDictionaries.CellEquipmentDictionaryReference.DictionaryVersion;
                }
            }
            results = new string[] { equipmentDictionaryName, equipmentDictionaryVersionName };
            return results;
        }

        protected EquipmentDictionaryVersion GetEquipmentDictionaryVersion(string url)
        {
            EquipmentDictionaryVersion result;
            string xml;
            try
            {
                xml = XDocument.Load(url).ToString();
            }
            catch (System.Exception exception)
            {
                throw new Exception(string.Concat(url, System.Environment.NewLine, exception.Message));
            }
            ConfigurationData configurationData = ParseXML<ConfigurationData>(xml, throwExceptions: true);
            byte[] byteArray = Convert.FromBase64String(configurationData.Data);
            string decodedCellInstanceConfigurationData = Encoding.Unicode.GetString(byteArray);
            if (xml.Length <= 41)
                throw new Exception(string.Concat("xml isn't valid {", xml, "}"));
            decodedCellInstanceConfigurationData = decodedCellInstanceConfigurationData.Substring(41).Replace("i:type", "i___type");
            result = ParseXML<EquipmentDictionaryVersion>(decodedCellInstanceConfigurationData, throwExceptions: true);
            return result;
        }

        protected Tuple<string, string, string, EquipmentDictionaryVersion> GetEquipmentDictionaryVersionTuple(string cellInstanceName, string cellInstanceVersionName, CellInstanceVersion cellInstanceVersion, string cellInstanceConnectionName, EquipmentTypeVersion equipmentTypeVersion)
        {
            Tuple<string, string, string, EquipmentDictionaryVersion> result;
            string equipmentDictionaryName;
            string equipmentDictionaryVersionName;
            EquipmentDictionaryVersion equipmentDictionaryVersion;
            Dictionary<string, int[]> componentModelComponentsIndexes = GetComponentModelComponentsIndexes(cellInstanceVersion, cellInstanceConnectionName);
            int[] cellInstanceConnectionNameIndexes = GetCellInstanceConnectionNameIndexes(cellInstanceConnectionName, componentModelComponentsIndexes);
            ComponentsCellComponentCellComponent componentsCellComponentCellComponent = cellInstanceVersion.ComponentModel.Components[cellInstanceConnectionNameIndexes[0]].Children[cellInstanceConnectionNameIndexes[1]];
            string[] segments = GetEquipmentDictionaryStrings(componentsCellComponentCellComponent.Equipment, equipmentTypeVersion);
            if (_SkipEquipmentDictionary || segments is null || segments.Length != 2 || string.IsNullOrEmpty(segments[0]) || string.IsNullOrEmpty(segments[1]))
            {
                equipmentDictionaryName = string.Empty;
                equipmentDictionaryVersionName = string.Empty;
            }
            else
            {
                equipmentDictionaryName = segments[0];
                equipmentDictionaryVersionName = segments[1];
            }
            string equipmentDictionaryServiceV2 = string.Concat("http://", _HostNameAndPort, "/EquipmentDictionaryServiceV2/", equipmentDictionaryName, "/", equipmentDictionaryVersionName, "/configuration");
            if (string.IsNullOrEmpty(equipmentDictionaryName) || string.IsNullOrEmpty(equipmentDictionaryVersionName))
                equipmentDictionaryVersion = null;
            else
            {
                if (_EquipmentDictionaryVersions.ContainsKey(equipmentDictionaryServiceV2))
                    equipmentDictionaryVersion = _EquipmentDictionaryVersions[equipmentDictionaryServiceV2];
                else
                {
                    equipmentDictionaryVersion = GetEquipmentDictionaryVersion(equipmentDictionaryServiceV2);
                    _EquipmentDictionaryVersions.Add(equipmentDictionaryServiceV2, equipmentDictionaryVersion);
                }
            }
            result = new Tuple<string, string, string, EquipmentDictionaryVersion>(equipmentDictionaryServiceV2, equipmentDictionaryName, equipmentDictionaryVersionName, equipmentDictionaryVersion);
            return result;
        }

        protected Tuple<string, List<Tuple<string, string>>> GetEquipmentDictionaryIsAlwaysEnabledEventsTuple(Tuple<string, string, string, EquipmentDictionaryVersion> equipmentDictionaryVersionTuple)
        {
            Tuple<string, List<Tuple<string, string>>> result;
            List<Tuple<string, string>> results;
            if (_SkipEquipmentDictionary)
                results = new List<Tuple<string, string>>();
            else if (string.IsNullOrEmpty(equipmentDictionaryVersionTuple.Item1))
                throw new Exception();
            else if (_EquipmentDictionaryEventDescriptions.ContainsKey(equipmentDictionaryVersionTuple.Item1))
                results = _EquipmentDictionaryEventDescriptions[equipmentDictionaryVersionTuple.Item1];
            else
            {
                results = new List<Tuple<string, string>>();
                foreach (EquipmentDictionaryVersionEventsEvent equipmentDictionaryVersionEventsEvent in equipmentDictionaryVersionTuple.Item4.Events.Event)
                {
                    if (string.IsNullOrEmpty(equipmentDictionaryVersionEventsEvent.Description))
                        continue;
                    if (!equipmentDictionaryVersionEventsEvent.IsAlwaysEnabled)
                        continue;
                    results.Add(new Tuple<string, string>(equipmentDictionaryVersionEventsEvent.Name, equipmentDictionaryVersionEventsEvent.Description));
                }
            }
            result = new Tuple<string, List<Tuple<string, string>>>(equipmentDictionaryVersionTuple.Item1, results);
            return result;
        }

        protected Dictionary<string, object> GetKeyValuePairs(string cellInstanceName, string cellInstanceVersionName, string cellInstanceConnectionName, FileConnectorConfiguration fileConnectorConfiguration, string equipmentTypeName, string parameterizedModelObjectDefinitionType, IList<ModelObjectParameterDefinition> modelObjectParameters, List<Tuple<string, string>> equipmentDictionaryIsAlwaysEnabledEvents)
        {
            Dictionary<string, object> results = new Dictionary<string, object>
            {
                { nameof(Environment), _Environment },
                { nameof(HostNameAndPort), _HostNameAndPort },
                { nameof(cellInstanceName), cellInstanceName },
                { nameof(equipmentTypeName), equipmentTypeName },
                { nameof(cellInstanceVersionName), cellInstanceVersionName },
                { nameof(cellInstanceConnectionName), cellInstanceConnectionName },
                { nameof(FileConnectorConfiguration), fileConnectorConfiguration },
                { nameof(IList<ModelObjectParameterDefinition>), modelObjectParameters },
                { nameof(parameterizedModelObjectDefinitionType), parameterizedModelObjectDefinitionType },
                { nameof(equipmentDictionaryIsAlwaysEnabledEvents), equipmentDictionaryIsAlwaysEnabledEvents }
            };
            return results;
        }

        public string[] GetCSharpText(string testName)
        {
            string[] results;
            string[] segments = GetSegments(testName);
            FileInfo fileInfo = GetFileName(segments);
            string cellInstanceName = GetCellInstanceName(segments);
            string cellInstanceVersionName = GetCellInstanceVersionName(segments);
            string cellInstanceConnectionName = GetCellInstanceConnectionName(segments);
            if (!string.IsNullOrEmpty(cellInstanceConnectionName) && !Directory.Exists(fileInfo.DirectoryName))
                Directory.CreateDirectory(fileInfo.Directory.FullName);
            Tuple<string, CellInstanceVersion> cellInstanceVersionTuple = GetCellInstanceVersionTuple(cellInstanceName, cellInstanceVersionName);
            results = GetCSharpTextB(cellInstanceName, cellInstanceVersionName, cellInstanceVersionTuple.Item2, fileInfo);
            return results;
        }

        public string[] GetConfiguration(MethodBase methodBase)
        {
            string[] results;
            string[] segments = GetSegments(methodBase.Name);
            FileInfo fileInfo = GetFileName(segments);
            string cellInstanceName = GetCellInstanceName(segments);
            string cellInstanceVersionName = GetCellInstanceVersionName(segments);
            string cellInstanceConnectionName = GetCellInstanceConnectionName(segments);
            if (!string.IsNullOrEmpty(cellInstanceConnectionName) && !Directory.Exists(fileInfo.DirectoryName))
                Directory.CreateDirectory(fileInfo.Directory.FullName);
            Tuple<string, CellInstanceVersion> cellInstanceVersionTuple = GetCellInstanceVersionTuple(cellInstanceName, cellInstanceVersionName);
            Tuple<string, FileConnectorConfiguration> fileConnectorConfigurationTuple = GetFileConnectorConfigurationTuple(cellInstanceVersionTuple, cellInstanceConnectionName);
            Tuple<string, string, string, EquipmentTypeVersion> equipmentTypeVersionTuple = GetEquipmentTypeVersionTuple(cellInstanceName, cellInstanceVersionName, cellInstanceVersionTuple.Item2, cellInstanceConnectionName);
            Tuple<string, string> parameterizedModelObjectDefinitionTypeTuple = GetParameterizedModelObjectDefinitionTypeTuple(equipmentTypeVersionTuple);
            Tuple<string, IList<ModelObjectParameterDefinition>> modelObjectParametersTuple = GetModelObjectParameters(equipmentTypeVersionTuple);
            Tuple<string, string, string, EquipmentDictionaryVersion> equipmentDictionaryVersionTuple = GetEquipmentDictionaryVersionTuple(cellInstanceName, cellInstanceVersionName, cellInstanceVersionTuple.Item2, cellInstanceConnectionName, equipmentTypeVersionTuple.Item4);
            Tuple<string, List<Tuple<string, string>>> equipmentDictionaryIsAlwaysEnabledEventsTuple = GetEquipmentDictionaryIsAlwaysEnabledEventsTuple(equipmentDictionaryVersionTuple);
            Dictionary<string, object> objects = GetKeyValuePairs(cellInstanceName, cellInstanceVersionName, cellInstanceConnectionName, fileConnectorConfigurationTuple.Item2, equipmentTypeVersionTuple.Item2, parameterizedModelObjectDefinitionTypeTuple.Item2, modelObjectParametersTuple.Item2, equipmentDictionaryIsAlwaysEnabledEventsTuple.Item2);
            string json = JsonSerializer.Serialize(objects, new JsonSerializerOptions { WriteIndented = true });
            results = new string[] { fileInfo.FullName, json };
            return results;
        }

        public IFileRead Get(MethodBase methodBase, string sourceFileLocation, string sourceFileFilter, bool useCyclicalForDescription)
        {
            IFileRead result;
            string[] segments = GetSegments(methodBase.Name);
            FileInfo fileInfo = GetFileName(segments);
            string cellInstanceName = GetCellInstanceName(segments);
            string cellInstanceVersionName = GetCellInstanceVersionName(segments);
            Dictionary<string, string> fileParameter = new Dictionary<string, string>();
            string cellInstanceConnectionName = GetCellInstanceConnectionName(segments);
            if (!string.IsNullOrEmpty(cellInstanceConnectionName) && !Directory.Exists(fileInfo.DirectoryName))
                Directory.CreateDirectory(fileInfo.Directory.FullName);
            Dictionary<string, List<long>> dummyRuns = new Dictionary<string, List<long>>();
            Tuple<string, CellInstanceVersion> cellInstanceVersionTuple = GetCellInstanceVersionTuple(cellInstanceName, cellInstanceVersionName);
            Tuple<string, FileConnectorConfiguration> fileConnectorConfigurationTuple = GetFileConnectorConfigurationTuple(cellInstanceVersionTuple, cellInstanceConnectionName);
            Tuple<string, string, string, EquipmentTypeVersion> equipmentTypeVersionTuple = GetEquipmentTypeVersionTuple(cellInstanceName, cellInstanceVersionName, cellInstanceVersionTuple.Item2, cellInstanceConnectionName);
            Tuple<string, string> parameterizedModelObjectDefinitionTypeTuple = GetParameterizedModelObjectDefinitionTypeTuple(equipmentTypeVersionTuple);
            Tuple<string, IList<ModelObjectParameterDefinition>> modelObjectParametersTuple = GetModelObjectParameters(equipmentTypeVersionTuple);
            if (!string.IsNullOrEmpty(sourceFileLocation) && sourceFileLocation != fileConnectorConfigurationTuple.Item2.SourceFileLocation)
                fileConnectorConfigurationTuple.Item2.SourceFileLocation = sourceFileLocation;
            if (!string.IsNullOrEmpty(sourceFileFilter) && sourceFileFilter != fileConnectorConfigurationTuple.Item2.SourceFileFilter)
            {
                fileConnectorConfigurationTuple.Item2.SourceFileFilter = sourceFileFilter;
                fileConnectorConfigurationTuple.Item2.SourceFileFilters = sourceFileFilter.Split('|').ToList();
            }
            result = Adaptation.FileHandlers.CellInstanceConnectionName.Get(this, fileParameter, cellInstanceName, cellInstanceConnectionName, fileConnectorConfigurationTuple.Item2, equipmentTypeVersionTuple.Item2, parameterizedModelObjectDefinitionTypeTuple.Item2, modelObjectParametersTuple.Item2, dummyRuns, useCyclicalForDescription, isEAFHosted: false);
            return result;
        }

        public string[] GetVariables(MethodBase methodBase, string check)
        {
            string[] results;
            string[] lines;
            string ipdsfFile;
            string textFileDirectory;
            string fileNameWithoutExtension;
            string searchPattern = "*.ipdsf";
            string sourceFileFilter = string.Empty;
            string sourceFileLocation = string.Empty;
            string[] segments = GetSegments(methodBase);
            string ticks = GetTicks(segments);
            FileInfo fileInfo = GetFileName(segments);
            string[] textFiles = GetTextFiles(segments);
            string cellInstanceName = GetCellInstanceName(segments);
            string rawCellInstanceName = GetRawCellInstanceName(segments);
            string cellInstanceConnectionName = GetCellInstanceConnectionName(segments);
            string cellInstanceConnectionNameFromMethodBaseName = GetCellInstanceConnectionNameFromMethodBaseName(segments);
            string methodBaseNameWithActualCICN = GetMethodBaseNameWithActualCICN(methodBase.Name, rawCellInstanceName, cellInstanceConnectionNameFromMethodBaseName, cellInstanceConnectionName, ticks);
            if (!textFiles.Any())
                textFileDirectory = string.Empty;
            else
                textFileDirectory = Path.GetDirectoryName(textFiles[0]);
            foreach (string textFile in textFiles)
            {
                lines = File.ReadAllLines(textFile);
                if (lines.Length != 1)
                    continue;
                fileNameWithoutExtension = Path.GetFileNameWithoutExtension(textFile);
                if (fileNameWithoutExtension == nameof(FileConnectorConfiguration.SourceFileFilter))
                    sourceFileFilter = lines[0];
                else if (fileNameWithoutExtension == nameof(FileConnectorConfiguration.SourceFileLocation))
                {
                    segments = lines[0].Split(new string[] { ticks }, StringSplitOptions.None);
                    if (segments.Length > 2)
                        throw new Exception("Ticks should only appear once in source file location!");
                    if (segments.Length != 2)
                        throw new Exception("Ticks missing from source file location!");
                    if (!segments[1].EndsWith(methodBaseNameWithActualCICN.Replace(ticks, string.Empty)))
                        throw new Exception("Method name missing from source file location!");
                    sourceFileLocation = lines[0];
                }
            }
            if (!Directory.Exists(fileInfo.Directory.FullName))
                Directory.CreateDirectory(fileInfo.Directory.FullName);
            if (!fileInfo.Exists)
                throw new Exception();
            string json = File.ReadAllText(fileInfo.FullName);
            if (!json.Contains(check))
                throw new Exception();
            if (!json.Contains(nameof(FileConnectorConfiguration)))
                throw new Exception();
            JsonElement jsonElement = JsonSerializer.Deserialize<JsonElement>(json);
            JsonElement fileConnectorConfigurationJsonElement = jsonElement.GetProperty(nameof(FileConnectorConfiguration));
            if (fileConnectorConfigurationJsonElement.ValueKind != JsonValueKind.Object)
                throw new Exception();
            JsonSerializerOptions jsonSerializerOptions = new JsonSerializerOptions { Converters = { new JsonStringEnumConverter(JsonNamingPolicy.CamelCase) } };
            FileConnectorConfiguration fileConnectorConfiguration = JsonSerializer.Deserialize<FileConnectorConfiguration>(fileConnectorConfigurationJsonElement.ToString(), jsonSerializerOptions);
            if (!string.IsNullOrEmpty(sourceFileFilter))
                fileConnectorConfiguration.SourceFileFilter = sourceFileFilter;
            if (!string.IsNullOrEmpty(sourceFileLocation))
                fileConnectorConfiguration.SourceFileLocation = sourceFileLocation;
            if (string.IsNullOrEmpty(sourceFileLocation))
                ipdsfFile = searchPattern;
            else
            {
                string ipdsfDirectory = Path.Combine(sourceFileLocation, "ipdsf");
                if (!Directory.Exists(ipdsfDirectory))
                    ipdsfFile = searchPattern;
                else
                {
                    string[] files = Directory.GetFiles(ipdsfDirectory, searchPattern, SearchOption.TopDirectoryOnly);
                    if (files.Any())
                        ipdsfFile = files[0];
                    else
                        ipdsfFile = searchPattern;
                }
            }
            if (ipdsfFile == searchPattern)
                throw new Exception();
            results = new string[] { fileInfo.FullName, json, fileConnectorConfiguration.SourceFileLocation, fileConnectorConfiguration.SourceFileFilter, ipdsfFile, textFileDirectory };
            if (string.IsNullOrEmpty(results[0]))
                throw new Exception();
            if (string.IsNullOrEmpty(results[1]))
                throw new Exception();
            if (string.IsNullOrEmpty(results[2]))
                throw new Exception();
            if (string.IsNullOrEmpty(results[3]))
                throw new Exception();
            if (string.IsNullOrEmpty(results[4]))
                throw new Exception();
            if (string.IsNullOrEmpty(results[5]))
                throw new Exception();
            return results;
        }

    }

}
// namespace _Tests.Helpers { public class AdaptationTesting { } }