using Adaptation.Eaf.Management.ConfigurationData.CellAutomation;
using Adaptation.Ifx.Eaf.EquipmentConnector.File.Configuration;
using Adaptation.Shared;
using Adaptation.Shared.Duplicator;
using Adaptation.Shared.Methods;
using Adaptation.Shared.Metrology;
using Infineon.Monitoring.MonA;
using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Globalization;
using System.IO;
using System.IO.Compression;
using System.Linq;
using System.Text.Json;
using System.Text.Json.Serialization;
using System.Threading;

namespace Adaptation.FileHandlers.MET08RESIMAPCDE
{

    public class FileRead : Shared.FileRead, IFileRead
    {

        private readonly Timer _Timer;
        private int _LastDummyRunIndex;
        private readonly string _IqsFile;
        private readonly int _HyphenIsDummy;
        private readonly int _HyphenIsNaEDA;
        private readonly string _MemoryPath;
        private readonly int _HyphenIsXToAPC;
        private readonly int _HyphenIsXToIQSSi;
        private readonly int _HyphenIsXToSPaCe;
        private readonly int _HyphenIsXToOpenInsight;
        private readonly string _EventNameFileReadDaily;
        private readonly string _OpenInsightFilePattern;
        private readonly string _OpenInsightMetrologyViewerAPI;
        private readonly Dictionary<string, string> _CellNames;
        private readonly int _HyphenIsXToOpenInsightMetrologyViewer;
        private readonly int _HyphenIsXToOpenInsightMetrologyViewerAttachments;

        public FileRead(ISMTP smtp, Dictionary<string, string> fileParameter, string cellInstanceName, string cellInstanceConnectionName, FileConnectorConfiguration fileConnectorConfiguration, string equipmentTypeName, string parameterizedModelObjectDefinitionType, IList<ModelObjectParameterDefinition> modelObjectParameters, string equipmentDictionaryName, Dictionary<string, List<long>> dummyRuns, bool useCyclicalForDescription, bool isEAFHosted, int hyphenXToArchive, int hyphenIsArchive) :
            base(new Description(), false, smtp, fileParameter, cellInstanceName, cellInstanceConnectionName, fileConnectorConfiguration, equipmentTypeName, parameterizedModelObjectDefinitionType, modelObjectParameters, equipmentDictionaryName, dummyRuns, useCyclicalForDescription, isEAFHosted, hyphenXToArchive, hyphenIsArchive)
        {
            _MinFileLength = 10;
            _NullData = string.Empty;
            _Logistics = new Logistics(this);
            if (_FileParameter is null)
                throw new Exception(cellInstanceConnectionName);
            if (_ModelObjectParameterDefinitions is null)
                throw new Exception(cellInstanceConnectionName);
            if (!_IsDuplicator)
                throw new Exception(cellInstanceConnectionName);
            if (hyphenIsArchive != (int)Hyphen.IsArchive)
                throw new Exception(cellInstanceConnectionName);
            if (hyphenXToArchive != (int)Hyphen.IsXToArchive)
                throw new Exception(cellInstanceConnectionName);
            _LastDummyRunIndex = -1;
            if (_HyphenIsNaEDA == 0)
            { }
            if (_HyphenIsXToSPaCe == 0)
            { }
            if (_HyphenIsXToIQSSi == 0)
            { }
            _CellNames = new Dictionary<string, string>();
            _HyphenIsNaEDA = (int)Hyphen.IsNaEDA;
            _HyphenIsDummy = (int)Hyphen.IsDummy;
            _HyphenIsXToAPC = (int)Hyphen.IsXToAPC;
            _HyphenIsXToIQSSi = (int)Hyphen.IsXToIQSSi;
            _HyphenIsXToSPaCe = (int)Hyphen.IsXToSPaCe;
            _HyphenIsXToOpenInsight = (int)Hyphen.IsXToOpenInsight;
            _EventNameFileReadDaily = string.Concat(_EventNameFileRead, "Daily");
            _IqsFile = GetPropertyValue(cellInstanceConnectionName, modelObjectParameters, "IQS.File");
            _MemoryPath = GetPropertyValue(cellInstanceConnectionName, modelObjectParameters, "Path.Memory");
            _HyphenIsXToOpenInsightMetrologyViewer = (int)Hyphen.IsXToOpenInsightMetrologyViewer;
            _HyphenIsXToOpenInsightMetrologyViewerAttachments = (int)Hyphen.IsXToOpenInsightMetrologyViewerAttachments;
            _OpenInsightFilePattern = GetPropertyValue(cellInstanceConnectionName, modelObjectParameters, "OpenInsight.FilePattern");
            _OpenInsightMetrologyViewerAPI = GetPropertyValue(cellInstanceConnectionName, modelObjectParameters, "OpenInsight.MetrologyViewerAPI");
            ModelObjectParameterDefinition[] cellInstanceCollection = GetProperties(cellInstanceConnectionName, modelObjectParameters, "CellInstance.", ".Path");
            foreach (ModelObjectParameterDefinition modelObjectParameterDefinition in cellInstanceCollection)
                _CellNames.Add(modelObjectParameterDefinition.Name.Split('.')[1], modelObjectParameterDefinition.Value);
            if (_Hyphens == _HyphenIsDummy)
            {
                if (Debugger.IsAttached || fileConnectorConfiguration.PreProcessingMode == FileConnectorConfiguration.PreProcessingModeEnum.Process)
                {
                    _Timer = new Timer(Callback, null, Timeout.Infinite, Timeout.Infinite);
                    Callback(null);
                }
                else
                {
                    int milliSeconds;
                    milliSeconds = (int)((fileConnectorConfiguration.FileScanningIntervalInSeconds * 1000) / 2);
                    _Timer = new Timer(Callback, null, milliSeconds, Timeout.Infinite);
                    milliSeconds += 2000;
                }
            }
        }

        void IFileRead.Move(Tuple<string, Test[], JsonElement[], List<FileInfo>> extractResults, Exception exception)
        {
            Move(this, extractResults, exception);
        }

        void IFileRead.WaitForThread()
        {
            WaitForThread(thread: null, threadExceptions: null);
        }

        string IFileRead.GetEventDescription()
        {
            string result = _Description.GetEventDescription();
            return result;
        }

        List<string> IFileRead.GetHeaderNames()
        {
            List<string> results = _Description.GetHeaderNames();
            return results;
        }

        string[] IFileRead.Move(Tuple<string, Test[], JsonElement[], List<FileInfo>> extractResults, string to, string from, string resolvedFileLocation, Exception exception)
        {
            string[] results = Move(extractResults, to, from, resolvedFileLocation, exception);
            return results;
        }

        JsonProperty[] IFileRead.GetDefault()
        {
            JsonProperty[] results = _Description.GetDefault(this, _Logistics);
            return results;
        }

        Dictionary<string, string> IFileRead.GetDisplayNamesJsonElement()
        {
            Dictionary<string, string> results = _Description.GetDisplayNamesJsonElement(this);
            return results;
        }

        List<IDescription> IFileRead.GetDescriptions(IFileRead fileRead, List<Test> tests, IProcessData processData)
        {
            List<IDescription> results = _Description.GetDescriptions(fileRead, _Logistics, tests, processData);
            return results;
        }

        Tuple<string, Test[], JsonElement[], List<FileInfo>> IFileRead.GetExtractResult(string reportFullPath, string eventName)
        {
            Tuple<string, Test[], JsonElement[], List<FileInfo>> results;
            if (string.IsNullOrEmpty(eventName))
                throw new Exception();
            _ReportFullPath = reportFullPath;
            DateTime dateTime = DateTime.Now;
            results = GetExtractResult(reportFullPath, dateTime);
            if (results.Item3 is null)
                results = new Tuple<string, Test[], JsonElement[], List<FileInfo>>(results.Item1, new Test[] { }, JsonSerializer.Deserialize<JsonElement[]>("[]"), results.Item4);
            if (results.Item3.Length > 0 && _IsEAFHosted)
                WritePDSF(this, results.Item3);
            UpdateLastTicksDuration(DateTime.Now.Ticks - dateTime.Ticks);
            return results;
        }

        Tuple<string, Test[], JsonElement[], List<FileInfo>> IFileRead.ReExtract()
        {
            Tuple<string, Test[], JsonElement[], List<FileInfo>> results;
            List<string> headerNames = _Description.GetHeaderNames();
            Dictionary<string, string> keyValuePairs = _Description.GetDisplayNamesJsonElement(this);
            results = ReExtract(this, headerNames, keyValuePairs);
            return results;
        }

        void IFileRead.CheckTests(Test[] tests, bool extra)
        {
            if (!(_Description is Description))
                throw new Exception();
        }

        void IFileRead.Callback(object state)
        {
            Callback(state);
        }

        void IFileRead.MoveArchive()
        {
            string logisticsSequence = _Logistics.Sequence.ToString();
            string weekOfYear = _Calendar.GetWeekOfYear(_Logistics.DateTimeFromSequence, CalendarWeekRule.FirstDay, DayOfWeek.Sunday).ToString("00");
            string weekDirectory = string.Concat(_Logistics.DateTimeFromSequence.ToString("yyyy"), "_Week_", weekOfYear, @"\", _Logistics.DateTimeFromSequence.ToString("yyyy-MM-dd"));
            string jobIdDirectory = string.Concat(_FileConnectorConfiguration.TargetFileLocation, @"\", _Logistics.JobID);
            if (!Directory.Exists(jobIdDirectory))
                Directory.CreateDirectory(jobIdDirectory);
            //string destinationArchiveDirectory = string.Concat(jobIdDirectory, @"\!Archive\", weekDirectory);
            string destinationArchiveDirectory = string.Concat(Path.GetDirectoryName(_FileConnectorConfiguration.TargetFileLocation), @"\Archive\", _Logistics.JobID, @"\", weekDirectory);
            if (!Directory.Exists(destinationArchiveDirectory))
                Directory.CreateDirectory(destinationArchiveDirectory);
            string[] matchDirectories = new string[] { GetDirectoriesRecursively(jobIdDirectory, logisticsSequence).FirstOrDefault() };
            if ((matchDirectories is null) || matchDirectories.Length != 1)
                throw new Exception("Didn't find directory by logistics sequence");
            string sourceDirectory = Path.GetDirectoryName(matchDirectories[0]);
            destinationArchiveDirectory = string.Concat(destinationArchiveDirectory, @"\", Path.GetFileName(sourceDirectory));
            Directory.Move(sourceDirectory, destinationArchiveDirectory);
        }

        protected List<pcl.Description> GetDescriptions(JsonElement[] jsonElements)
        {
            List<pcl.Description> results = new();
            pcl.Description description;
            JsonSerializerOptions jsonSerializerOptions = new() { NumberHandling = JsonNumberHandling.AllowReadingFromString | JsonNumberHandling.WriteAsString };
            foreach (JsonElement jsonElement in jsonElements)
            {
                if (jsonElement.ValueKind != JsonValueKind.Object)
                    throw new Exception();
                description = JsonSerializer.Deserialize<pcl.Description>(jsonElement.ToString(), jsonSerializerOptions);
                results.Add(description);
            }
            return results;
        }

        private Tuple<string, Test[], JsonElement[], List<FileInfo>> GetExtractResult(string reportFullPath, DateTime dateTime)
        {
            Tuple<string, Test[], JsonElement[], List<FileInfo>> results;
            string duplicateDirectory;
            Tuple<string, string[], string[]> pdsf = ProcessDataStandardFormat.GetLogisticsColumnsAndBody(reportFullPath);
            _Logistics = new Logistics(reportFullPath, pdsf.Item1);
            SetFileParameterLotIDToLogisticsMID();
            JsonElement[] jsonElements = ProcessDataStandardFormat.GetArray(pdsf);
            List<pcl.Description> descriptions = GetDescriptions(jsonElements);
            Tuple<Test[], Dictionary<Test, List<Shared.Properties.IDescription>>> tuple = GetTuple(this, from l in descriptions select (Shared.Properties.IDescription)l, extra: false);
            results = new Tuple<string, Test[], JsonElement[], List<FileInfo>>(pdsf.Item1, tuple.Item1, jsonElements, new List<FileInfo>());
            bool isNotUsedInsightMetrologyViewerAttachments = (!(_FileConnectorConfiguration.FileScanningIntervalInSeconds > 0) && _Hyphens == _HyphenIsXToOpenInsightMetrologyViewerAttachments);
            bool isDummyRun = (_DummyRuns.Any() && _DummyRuns.ContainsKey(_Logistics.JobID) && _DummyRuns[_Logistics.JobID].Any() && (from l in _DummyRuns[_Logistics.JobID] where l == _Logistics.Sequence select 1).Any());
            if (isDummyRun)
            {
                try
                { File.SetLastWriteTime(reportFullPath, dateTime); }
                catch (Exception) { }
            }
            string[] segments = Path.GetFileNameWithoutExtension(reportFullPath).Split('_');
            if (_Hyphens != _HyphenIsXToOpenInsight)
                duplicateDirectory = string.Concat(_FileConnectorConfiguration.TargetFileLocation, @"\", segments[0]);
            else
                duplicateDirectory = string.Concat(Path.GetDirectoryName(Path.GetDirectoryName(_FileConnectorConfiguration.TargetFileLocation)), @"\Data");
            if (segments.Length > 2)
                duplicateDirectory = string.Concat(duplicateDirectory, @"-", segments[2]);
            if (!Directory.Exists(duplicateDirectory))
                Directory.CreateDirectory(duplicateDirectory);
            if ((isDummyRun || isNotUsedInsightMetrologyViewerAttachments || _FileConnectorConfiguration.FileScanningIntervalInSeconds > 0) && _Hyphens != _HyphenIsXToArchive && _Hyphens != _HyphenIsArchive)
            {
                if (!Directory.Exists(duplicateDirectory))
                    Directory.CreateDirectory(duplicateDirectory);
                string successDirectory;
                if (_Hyphens != _HyphenIsXToAPC)
                    successDirectory = string.Empty;
                else
                {
                    successDirectory = string.Concat(Path.GetDirectoryName(_FileConnectorConfiguration.TargetFileLocation), @"\ViewerPath");
                    if (!Directory.Exists(successDirectory))
                        Directory.CreateDirectory(successDirectory);
                }
                List<Tuple<Shared.Properties.IScopeInfo, string>> tuples = new();
                string duplicateFile = string.Concat(duplicateDirectory, @"\", Path.GetFileName(reportFullPath));
                string weekOfYear = _Calendar.GetWeekOfYear(_Logistics.DateTimeFromSequence, CalendarWeekRule.FirstDay, DayOfWeek.Sunday).ToString("00");
                string weekDirectory = string.Concat(_Logistics.DateTimeFromSequence.ToString("yyyy"), "_Week_", weekOfYear, @"\", _Logistics.DateTimeFromSequence.ToString("yyyy-MM-dd"));
                string logisticsSequenceMemoryDirectory = string.Concat(_MemoryPath, @"\", _EquipmentType, @"\Source\", weekDirectory, @"\", _Logistics.Sequence);
                if (!Directory.Exists(logisticsSequenceMemoryDirectory))
                    Directory.CreateDirectory(logisticsSequenceMemoryDirectory);
                if (_Hyphens == _HyphenIsXToAPC)
                {
                    if (!isDummyRun && _IsEAFHosted)
                        File.Copy(reportFullPath, duplicateFile, overwrite: true);
                }
                else
                {
                    if (_Hyphens == _HyphenIsXToOpenInsightMetrologyViewer)
                    {
                        WSRequest wsRequest = new(this, _Logistics, descriptions);
                        if (!isDummyRun && _IsEAFHosted)
                        {
                            Tuple<string, WS.Results> wsResults = WS.SendData(_OpenInsightMetrologyViewerAPI, wsRequest);
                            if (!wsResults.Item2.Success)
                                throw new Exception(wsResults.ToString());
                            _Log.Debug(wsResults.Item2.HeaderID);
                            File.WriteAllText(string.Concat(logisticsSequenceMemoryDirectory, @"\", nameof(WS.Results), ".json"), wsResults.Item1);
                        }
                    }
                    else
                    {
                        Test test;
                        string lines;
                        Shared.Properties.IScopeInfo scopeInfo;
                        foreach (KeyValuePair<Test, List<Shared.Properties.IDescription>> keyValuePair in tuple.Item2)
                        {
                            test = keyValuePair.Key;
                            //scopeInfo = new ScopeInfo(test);
                            if (_Hyphens != _HyphenIsXToOpenInsight)
                                scopeInfo = new ScopeInfo(test, _IqsFile);
                            else
                                scopeInfo = new ScopeInfo(test, _OpenInsightFilePattern);
                            //lines = ProcessDataStandardFormat.GetLines(this, scopeInfo, names, values, dateFormat: "M/d/yyyy hh:mm:ss tt", timeFormat: string.Empty, pairedColumns: ExtractResultPairedColumns);
                            lines = ProcessData.GetLines(this, _Logistics, descriptions);
                            tuples.Add(new Tuple<Shared.Properties.IScopeInfo, string>(scopeInfo, lines));
                        }
                    }
                    if (_Hyphens == _HyphenIsXToOpenInsightMetrologyViewerAttachments)
                    {
                        string[] matchDirectories = Shared1567(reportFullPath, tuples);
                        if (!isDummyRun && _IsEAFHosted && !isNotUsedInsightMetrologyViewerAttachments)
                            ProcessData.PostOpenInsightMetrologyViewerAttachments(this, dateTime, logisticsSequenceMemoryDirectory, descriptions, matchDirectories[0]);
                    }
                }
                if (_Hyphens != _HyphenIsXToOpenInsightMetrologyViewer && _Hyphens != _HyphenIsXToOpenInsightMetrologyViewerAttachments)
                    Shared0413(dateTime, isDummyRun, successDirectory, duplicateDirectory, tuples, duplicateFile);
            }
            if (_Hyphens == _HyphenIsXToOpenInsightMetrologyViewerAttachments)
            {
                string destinationDirectory;
                //string destinationDirectory = WriteScopeInfo(_ProgressPath, _Logistics, dateTime, duplicateDirectory, tuples);
                FileInfo fileInfo = new(reportFullPath);
                string logisticsSequence = _Logistics.Sequence.ToString();
                if (fileInfo.Exists && fileInfo.LastWriteTime < fileInfo.CreationTime)
                    File.SetLastWriteTime(reportFullPath, fileInfo.CreationTime);
                string jobIdDirectory = string.Concat(Path.GetDirectoryName(Path.GetDirectoryName(_FileConnectorConfiguration.TargetFileLocation)), @"\", _Logistics.JobID);
                if (!Directory.Exists(jobIdDirectory))
                    Directory.CreateDirectory(jobIdDirectory);
                string[] matchDirectories;
                if (!_IsEAFHosted)
                    matchDirectories = new string[] { Path.GetDirectoryName(Path.GetDirectoryName(reportFullPath)) };
                else
                    matchDirectories = Directory.GetDirectories(jobIdDirectory, string.Concat(_Logistics.MID, '*', logisticsSequence, '*'), SearchOption.TopDirectoryOnly);
                if ((matchDirectories is null) || matchDirectories.Length != 1)
                    throw new Exception("Didn't find directory by logistics sequence");
                destinationDirectory = matchDirectories[0];
                if (isDummyRun)
                    Shared0607(reportFullPath, duplicateDirectory, logisticsSequence, destinationDirectory);
                else
                {
                    WSRequest wsRequest = new(this, _Logistics, descriptions);
                    JsonSerializerOptions jsonSerializerOptions = new() { WriteIndented = true };
                    string json = JsonSerializer.Serialize(wsRequest, wsRequest.GetType(), jsonSerializerOptions);
                    if (_IsEAFHosted)
                        Shared1277(reportFullPath, destinationDirectory, logisticsSequence, jobIdDirectory, json);
                    else
                    {
                        string jsonFileName = Path.ChangeExtension(reportFullPath, ".json");
                        string historicalText = File.ReadAllText(jsonFileName);
                        if (json != historicalText)
                            throw new Exception("File doesn't match historical!");
                    }
                }
            }
            return results;
        }

        private void CallbackIsDummy(string traceDummyFile, List<Tuple<string, string, string, string, int>> tuples, bool fileConnectorConfigurationIncludeSubDirectories, bool includeSubDirectoriesExtra)
        {
            int fileCount;
            string[] files;
            string monARessource;
            string checkDirectory;
            string sourceArchiveFile;
            string inProcessDirectory;
            const string site = "sjc";
            string stateName = string.Concat("Dummy_", _EventName);
            const string monInURL = "http://moninhttp.sjc.infineon.com/input/text";
            MonIn monIn = MonIn.GetInstance(monInURL);
            foreach (Tuple<string, string, string, string, int> item in tuples)
            {
                monARessource = item.Item1;
                sourceArchiveFile = item.Item2;
                inProcessDirectory = item.Item3;
                checkDirectory = item.Item4;
                fileCount = item.Item5;
                try
                {
                    if (fileCount > 0 || string.IsNullOrEmpty(checkDirectory))
                    {
                        File.AppendAllLines(traceDummyFile, new string[] { site, monARessource, stateName, State.Warning.ToString() });
                        monIn.SendStatus(site, monARessource, stateName, State.Warning);
                        for (int i = 1; i < 12; i++)
                            Thread.Sleep(500);
                    }
                    else if (inProcessDirectory == checkDirectory)
                        continue;
                    if (!_IsEAFHosted)
                        continue;
                    if (!File.Exists(sourceArchiveFile))
                        continue;
                    if (!long.TryParse(Path.GetFileNameWithoutExtension(sourceArchiveFile).Replace("x", string.Empty), out long sequence))
                        continue;
                    ZipFile.ExtractToDirectory(sourceArchiveFile, inProcessDirectory);
                    if (fileConnectorConfigurationIncludeSubDirectories && includeSubDirectoriesExtra)
                    {
                        if (_EventName == _EventNameFileRead)
                            checkDirectory = string.Concat(checkDirectory, @"\", sequence);
                        else if (_EventName == _EventNameFileReadDaily)
                            checkDirectory = string.Concat(checkDirectory, @"\Source\", sequence);
                        else
                            throw new Exception();
                    }
                    if (fileConnectorConfigurationIncludeSubDirectories)
                        files = Directory.GetFiles(inProcessDirectory, "*", SearchOption.AllDirectories);
                    else
                        files = Directory.GetFiles(inProcessDirectory, "*", SearchOption.TopDirectoryOnly);
                    if (files.Length > 250)
                        throw new Exception("Safety net!");
                    foreach (string file in files)
                        File.SetLastWriteTime(file, new DateTime(sequence));
                    if (!fileConnectorConfigurationIncludeSubDirectories)
                    {
                        foreach (string file in files)
                            File.Move(file, string.Concat(checkDirectory, @"\", Path.GetFileName(file)));
                    }
                    else
                    {
                        string[] directories = Directory.GetDirectories(inProcessDirectory, "*", SearchOption.AllDirectories);
                        foreach (string directory in directories)
                            Directory.CreateDirectory(string.Concat(checkDirectory, directory.Substring(inProcessDirectory.Length)));
                        foreach (string file in files)
                            File.Move(file, string.Concat(checkDirectory, file.Substring(inProcessDirectory.Length)));
                    }
                    File.AppendAllLines(traceDummyFile, new string[] { site, monARessource, stateName, State.Ok.ToString() });
                    monIn.SendStatus(site, monARessource, stateName, State.Ok);
                }
                catch (Exception exception)
                {
                    string subject = string.Concat("Exception:", _CellInstanceConnectionName);
                    string body = string.Concat(exception.Message, Environment.NewLine, Environment.NewLine, exception.StackTrace);
                    try
                    { _SMTP.SendHighPriorityEmailMessage(subject, body); }
                    catch (Exception) { }
                    File.AppendAllLines(traceDummyFile, new string[] { site, monARessource, stateName, State.Critical.ToString(), exception.Message, exception.StackTrace });
                    monIn.SendStatus(site, monARessource, stateName, State.Critical);
                }
            }
        }

        private void Callback(object state)
        {
            if (_Hyphens != _HyphenIsDummy)
                throw new Exception();
            try
            {
                DateTime dateTime = DateTime.Now;
                bool check = (dateTime.Hour > 7 && dateTime.Hour < 18 && dateTime.DayOfWeek != DayOfWeek.Sunday && dateTime.DayOfWeek != DayOfWeek.Saturday);
                if (check)
                {
                    int fileCount;
                    string[] files;
                    string monARessource;
                    string checkDirectory;
                    string sourceArchiveFile;
                    string sourceFileLocation;
                    string inProcessDirectory;
                    string weekOfYear = _Calendar.GetWeekOfYear(dateTime, CalendarWeekRule.FirstDay, DayOfWeek.Sunday).ToString("00");
                    string traceDummyDirectory = string.Concat(Path.GetPathRoot(_TracePath), @"\TracesDummy\", _CellInstanceName, @"\Source\", dateTime.ToString("yyyy"), "___Week_", weekOfYear);
                    if (!Directory.Exists(traceDummyDirectory))
                        Directory.CreateDirectory(traceDummyDirectory);
                    string traceDummyFile = string.Concat(traceDummyDirectory, @"\", dateTime.Ticks, " - ", _CellInstanceName, ".txt");
                    File.AppendAllText(traceDummyFile, string.Empty);
                    List<Tuple<string, string, string, string, int>> tuples = new();
                    string progressDirectory = Path.GetFullPath(string.Concat(_FileConnectorConfiguration.SourceFileLocation, @"\_ Progress"));
                    if (progressDirectory != _ProgressPath || !Directory.Exists(progressDirectory))
                        throw new Exception("Invalid progress path");
                    foreach (KeyValuePair<string, string> keyValuePair in _CellNames)
                    {
                        monARessource = keyValuePair.Key;
                        if (!keyValuePair.Value.Contains(@"\"))
                            continue;
                        foreach (string sourceFileFilter in _FileConnectorConfiguration.SourceFileFilter.Split('|'))
                        {
                            if (sourceFileFilter.ToLower().StartsWith(keyValuePair.Value.Replace(@"\", string.Empty)))
                                sourceFileLocation = Path.GetFullPath(_FileConnectorConfiguration.SourceFileLocation);
                            else if (_FileConnectorConfiguration.SourceFileLocation.ToLower().EndsWith(keyValuePair.Value))
                                sourceFileLocation = Path.GetFullPath(_FileConnectorConfiguration.SourceFileLocation);
                            else
                                sourceFileLocation = Path.GetFullPath(string.Concat(_FileConnectorConfiguration.SourceFileLocation, @"\", keyValuePair.Value));
                            sourceArchiveFile = Path.GetFullPath(string.Concat(sourceFileLocation, @"\", sourceFileFilter));
                            if (!File.Exists(sourceArchiveFile))
                                continue;
                            if (!_DummyRuns.ContainsKey(monARessource))
                                _DummyRuns.Add(monARessource, new List<long>());
                            tuples.Add(new Tuple<string, string, string, string, int>(monARessource, sourceFileFilter, sourceFileLocation, sourceArchiveFile, 0));
                        }
                    }
                    File.AppendAllLines(traceDummyFile, from l in tuples select l.Item4);
                    if (tuples.Any())
                    {
                        _LastDummyRunIndex += 1;
                        if (_LastDummyRunIndex >= tuples.Count)
                            _LastDummyRunIndex = 0;
                        monARessource = tuples[_LastDummyRunIndex].Item1;
                        string sourceFileFilter = tuples[_LastDummyRunIndex].Item2;
                        sourceFileLocation = tuples[_LastDummyRunIndex].Item3;
                        sourceArchiveFile = tuples[_LastDummyRunIndex].Item4;
                        //fileCount = tuples[_LastDummyRunIndex].Item5;
                        tuples.Clear();
                        if (long.TryParse(Path.GetFileNameWithoutExtension(sourceArchiveFile).Replace("x", string.Empty), out long sequence))
                        {
                            if (!_DummyRuns[monARessource].Contains(sequence))
                                _DummyRuns[monARessource].Add(sequence);
                            inProcessDirectory = string.Concat(progressDirectory, @"\Dummy_in process\", sequence);
                            checkDirectory = inProcessDirectory;
                            if (!Directory.Exists(checkDirectory))
                                Directory.CreateDirectory(checkDirectory);
                            files = Directory.GetFiles(checkDirectory, "*", SearchOption.AllDirectories);
                            fileCount = files.Length;
                            if (files.Any())
                            {
                                if (files.Length > 250)
                                    throw new Exception("Safety net!");
                                try
                                {
                                    foreach (string file in files)
                                        File.Delete(file);
                                }
                                catch (Exception) { }
                            }
                            tuples.Add(new Tuple<string, string, string, string, int>(monARessource, sourceArchiveFile, inProcessDirectory, checkDirectory, fileCount));
                            checkDirectory = sourceFileLocation;
                            files = Directory.GetFiles(checkDirectory, string.Concat("*", sequence, "*"), SearchOption.TopDirectoryOnly);
                            fileCount = files.Length;
                            tuples.Add(new Tuple<string, string, string, string, int>(monARessource, sourceArchiveFile, inProcessDirectory, checkDirectory, fileCount));
                        }
                    }
                    if (tuples.Any())
                        //CallbackIsDummy(traceDummyFile, tuples, FileConnectorConfiguration.IncludeSubDirectories.Value, includeSubDirectoriesExtra: false);
                        CallbackIsDummy(traceDummyFile, tuples, fileConnectorConfigurationIncludeSubDirectories: true, includeSubDirectoriesExtra: true);
                }
            }
            catch (Exception exception)
            {
                string subject = string.Concat("Exception:", _CellInstanceConnectionName);
                string body = string.Concat(exception.Message, Environment.NewLine, Environment.NewLine, exception.StackTrace);
                try
                { _SMTP.SendHighPriorityEmailMessage(subject, body); }
                catch (Exception) { }
            }
            try
            {
                TimeSpan timeSpan = new(DateTime.Now.AddSeconds(_FileConnectorConfiguration.FileScanningIntervalInSeconds.Value).Ticks - DateTime.Now.Ticks);
                _Timer.Change((long)timeSpan.TotalMilliseconds, Timeout.Infinite);
            }
            catch (Exception exception)
            {
                string subject = string.Concat("Exception:", _CellInstanceConnectionName);
                string body = string.Concat(exception.Message, Environment.NewLine, Environment.NewLine, exception.StackTrace);
                try
                { _SMTP.SendHighPriorityEmailMessage(subject, body); }
                catch (Exception) { }
            }
        }

    }

}