//using Adaptation.Helpers;
//using Adaptation.Shared;
//using Adaptation.Shared.Metrology;
//using log4net;
//using System;
//using System.Collections.Generic;
//using System.Globalization;
//using System.IO;
//using System.Linq;
//using System.Text.Json;
//using System.Text.RegularExpressions;

//namespace Adaptation.FileHandlers
//{

//    public partial class FileRead : ILogic
//    {

//        private ConfigData _ConfigData;

//        public FileRead()
//        {
//            Logistics = new Logistics();
//            _Log = LogManager.GetLogger(typeof(FileRead));
//        }

//        public ILogic ShallowCopy()
//        {
//            return (ILogic)MemberwiseClone();
//        }

//        public void WaitForThread()
//        {
//            WaitForThread(thread: null, threadExceptions: null);
//        }

//        public Tuple<string, ConfigDataBase> GetOpenInsightTuple()
//        {
//            Tuple<string, ConfigDataBase> restuls = new Tuple<string, ConfigDataBase>(_ConfigData.OpenInsightSiViewer, _ConfigData);
//            return restuls;
//        }

//        public Tuple<string, JsonElement?, List<FileInfo>> GetExtractResult(string reportFullPath, string eventName)
//        {
//            Tuple<string, JsonElement?, List<FileInfo>> results;
//            _FileParameter.Clear();
//            DateTime dateTime = DateTime.Now;
//            if (_ConfigData.IsEvent && _ConfigData.Duplicator is null)
//                results = GetExtractResult(reportFullPath);
//            else if (_ConfigData.Duplicator.HasValue)
//                results = GetDuplicatorExtractResult(reportFullPath, dateTime);
//            else
//                throw new Exception();
//            if (results.Item2 is null)
//                results = new Tuple<string, JsonElement?, List<FileInfo>>(results.Item1, JsonSerializer.Deserialize<JsonElement>("[]"), results.Item3);
//            int count = results.Item2.Value.GetArrayLength();
//            if (count > 0 && _ConfigData.EafHosted)
//                WritePDSF(results.Item2.Value);
//            UpdateLastTicksDuration(DateTime.Now.Ticks - dateTime.Ticks);
//            return results;
//        }

//        private Tuple<string, JsonElement?, List<FileInfo>> GetExtractResult(string reportFullPath)
//        {
//            Tuple<string, JsonElement?, List<FileInfo>> results = new Tuple<string, JsonElement?, List<FileInfo>>(string.Empty, null, new List<FileInfo>());
//            FileInfo fileInfo = new FileInfo(reportFullPath);
//            Logistics = new Logistics(ConfigData.NullData, _ConfigData.CellNames, _ConfigData.MesEntities, fileInfo, useSplitForMID: false);
//            SetFileParameterLotID(Logistics.MID);
//            if (fileInfo.Length < ConfigData.MinFileLength)
//                results.Item3.Add(fileInfo);
//            else
//            {
//                ProcessData processData = new ProcessData(this, _ConfigData, results.Item3);
//                if (!(processData.Header is null))
//                {
//                    string mid = string.Concat(processData.Header.Reactor, "-", processData.Header.RDS, "-", processData.Header.PSN);
//                    mid = Regex.Replace(mid, @"[\\,\/,\:,\*,\?,\"",\<,\>,\|]", "_").Split('\r')[0].Split('\n')[0];
//                    Logistics.MID = mid;
//                    SetFileParameterLotID(mid);
//                    Logistics.ProcessJobID = processData.Header.Reactor;
//                }
//                if (processData.Header is null || !processData.Details.Any())
//                    throw new Exception();
//                results = processData.GetResults(this, _ConfigData, results.Item3);
//            }
//            return results;
//        }

//        private Tuple<string, JsonElement?, List<FileInfo>> GetDuplicatorExtractResult(string reportFullPath, DateTime dateTime)
//        {
//            Tuple<string, JsonElement?, List<FileInfo>> results;
//            Tuple<string, string[], string[]> pdsf = ProcessDataStandardFormat.GetLogisticsColumnsAndBody(reportFullPath);
//            Logistics = new Logistics(reportFullPath, pdsf.Item1);
//            SetFileParameterLotIDToLogisticsMID();
//            JsonElement pdsdBodyValues = ProcessDataStandardFormat.GetArray(pdsf);
//            results = new Tuple<string, JsonElement?, List<FileInfo>>(pdsf.Item1, pdsdBodyValues, new List<FileInfo>());
//            List<Duplicator.Description> processDataDescriptions = _ConfigData.GetProcessDataDescriptions(pdsdBodyValues);
//            Dictionary<Test, List<Duplicator.Description>> keyValuePairs = ProcessData.GetKeyValuePairs(_ConfigData, pdsdBodyValues, processDataDescriptions, extra: false);
//            bool isNotUsedInsightMetrologyViewerAttachments = (!(_Configuration.FileScanningIntervalInSeconds > 0) && _ConfigData.Duplicator.Value == ConfigData.Level.IsXToOpenInsightMetrologyViewerAttachments);
//            bool isDummyRun = (ConfigData.DummyRuns.Any() && ConfigData.DummyRuns.ContainsKey(Logistics.JobID) && ConfigData.DummyRuns[Logistics.JobID].Any() && (from l in ConfigData.DummyRuns[Logistics.JobID] where l == Logistics.Sequence select 1).Any());
//            if (isDummyRun)
//            {
//                try { File.SetLastWriteTime(reportFullPath, dateTime); } catch (Exception) { }
//            }
//            string duplicateDirectory;
//            string[] segments = Path.GetFileNameWithoutExtension(reportFullPath).Split('_');
//            if (_ConfigData.Duplicator.Value != ConfigData.Level.IsXToOpenInsight)
//                duplicateDirectory = string.Concat(_Configuration.TargetFileLocation, @"\", segments[0]);
//            else
//                duplicateDirectory = string.Concat(Path.GetDirectoryName(Path.GetDirectoryName(_Configuration.TargetFileLocation)), @"\Data");
//            if (segments.Length > 2)
//                duplicateDirectory = string.Concat(duplicateDirectory, @"-", segments[2]);
//            if (!Directory.Exists(duplicateDirectory))
//                Directory.CreateDirectory(duplicateDirectory);
//            if ((isDummyRun || isNotUsedInsightMetrologyViewerAttachments || _Configuration.FileScanningIntervalInSeconds > 0) && _ConfigData.Duplicator.Value != ConfigData.Level.IsXToArchive && _ConfigData.Duplicator.Value != ConfigData.Level.IsArchive)
//            {
//                string successDirectory;
//                if (_ConfigData.Duplicator.Value != ConfigData.Level.IsXToAPC)
//                    successDirectory = string.Empty;
//                else
//                {
//                    successDirectory = string.Concat(Path.GetDirectoryName(_Configuration.TargetFileLocation), @"\ViewerPath");
//                    if (!Directory.Exists(successDirectory))
//                        Directory.CreateDirectory(successDirectory);
//                }
//                CultureInfo cultureInfo = new CultureInfo("en-US");
//                Calendar calendar = cultureInfo.Calendar;
//                List<Tuple<IScopeInfo, string>> tuples = new List<Tuple<IScopeInfo, string>>();
//                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(_ConfigData.MemoryPath, @"\", _ConfigData.GetEquipmentType(), @"\Source\", weekDirectory, @"\", Logistics.Sequence);
//                if (!Directory.Exists(logisticsSequenceMemoryDirectory))
//                    Directory.CreateDirectory(logisticsSequenceMemoryDirectory);
//                if (_ConfigData.Duplicator.Value == ConfigData.Level.IsXToAPC)
//                {
//                    if (!isDummyRun && _ConfigData.EafHosted)
//                        File.Copy(reportFullPath, duplicateFile, overwrite: true);
//                }
//                else
//                {
//                    if (_ConfigData.Duplicator.Value == ConfigData.Level.IsXToOpenInsightMetrologyViewer)
//                    {
//                        List<ProcessData.FileRead.Description> fileReadDescriptions = ProcessData.GetProcessDataFileReadDescriptions(_ConfigData, pdsdBodyValues);
//                        ProcessData.WSRequest wsRequest = new ProcessData.WSRequest(this, fileReadDescriptions);
//                        if (!isDummyRun && _ConfigData.EafHosted)
//                        {
//                            Tuple<string, WS.Results> wsResults = WS.SendData(_ConfigData.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;
//                        IScopeInfo scopeInfo;
//                        foreach (KeyValuePair<Test, List<Duplicator.Description>> keyValuePair in keyValuePairs)
//                        {
//                            test = keyValuePair.Key;
//                            //scopeInfo = new ScopeInfo(this, _ConfigData, test);
//                            if (_ConfigData.Duplicator.Value != ConfigData.Level.IsXToOpenInsight)
//                                scopeInfo = new ScopeInfo(this, _ConfigData, test, _ConfigData.IqsFile, _ConfigData.IqsQueryFilter);
//                            else
//                                scopeInfo = new ScopeInfo(this, _ConfigData, test, _ConfigData.OpenInsightFilePattern, _ConfigData.IqsQueryFilter);
//                            //lines = ProcessDataStandardFormat.GetLines(Logistics, scopeInfo, names, values, dateFormat: "M/d/yyyy hh:mm:ss tt", timeFormat: string.Empty, pairedColumns: ExtractResultPairedColumns);
//                            List<ProcessData.FileRead.Description> fileReadDescriptions = ProcessData.GetProcessDataFileReadDescriptions(_ConfigData, pdsdBodyValues);
//                            lines = ProcessData.GetLines(this, fileReadDescriptions);
//                            tuples.Add(new Tuple<IScopeInfo, string>(scopeInfo, lines));
//                        }
//                    }
//                    if (_ConfigData.Duplicator.Value == ConfigData.Level.IsXToOpenInsightMetrologyViewerAttachments)
//                    {
//                        string[] matchDirectories = Shared1567(reportFullPath, tuples);
//                        if (!isDummyRun && _ConfigData.EafHosted && !isNotUsedInsightMetrologyViewerAttachments)
//                        {
//                            List<ProcessData.FileRead.Description> fileReadDescriptions = ProcessData.GetProcessDataFileReadDescriptions(_ConfigData, pdsdBodyValues);
//                            ProcessData.PostOpenInsightMetrologyViewerAttachments(_Log, _ConfigData, Logistics, dateTime, logisticsSequenceMemoryDirectory, fileReadDescriptions, matchDirectories[0]);
//                        }
//                    }
//                }
//                if (_ConfigData.Duplicator.Value != ConfigData.Level.IsXToOpenInsightMetrologyViewer && _ConfigData.Duplicator.Value != ConfigData.Level.IsXToOpenInsightMetrologyViewerAttachments)
//                    Shared0413(dateTime, isDummyRun, successDirectory, duplicateDirectory, tuples, duplicateFile);
//            }
//            if (_ConfigData.Duplicator.Value == ConfigData.Level.IsXToOpenInsightMetrologyViewerAttachments)
//            {
//                string destinationDirectory;
//                //string destinationDirectory = WriteScopeInfo(_ConfigData.ProgressPath, Logistics, dateTime, duplicateDirectory, tuples);
//                FileInfo fileInfo = new FileInfo(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(_ConfigData.FileConnectorConfiguration.TargetFileLocation)), @"\", Logistics.JobID);
//                if (!Directory.Exists(jobIdDirectory))
//                    Directory.CreateDirectory(jobIdDirectory);
//                string[] matchDirectories;
//                if (!_ConfigData.EafHosted)
//                    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
//                {
//                    List<ProcessData.FileRead.Description> fileReadDescriptions = ProcessData.GetProcessDataFileReadDescriptions(_ConfigData, pdsdBodyValues);
//                    ProcessData.WSRequest wsRequest = new ProcessData.WSRequest(this, fileReadDescriptions);
//                    JsonSerializerOptions jsonSerializerOptions = new JsonSerializerOptions { WriteIndented = true };
//                    string json = JsonSerializer.Serialize(wsRequest, wsRequest.GetType(), jsonSerializerOptions);
//                    if (_ConfigData.EafHosted)
//                        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 MoveArchive()
//        {
//            CultureInfo cultureInfo = new CultureInfo("en-US");
//            Calendar calendar = cultureInfo.Calendar;
//            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(_ConfigData.FileConnectorConfiguration.TargetFileLocation, @"\", Logistics.JobID);
//            if (!Directory.Exists(jobIdDirectory))
//                Directory.CreateDirectory(jobIdDirectory);
//            //string destinationArchiveDirectory = string.Concat(jobIdDirectory, @"\!Archive\", weekDirectory);
//            string destinationArchiveDirectory = string.Concat(Path.GetDirectoryName(_ConfigData.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);
//        }

//        public void Move(string reportFullPath, Tuple<string, JsonElement?, List<FileInfo>> extractResults, Exception exception = null)
//        {
//            Shared1872(reportFullPath, exception);
//            bool isErrorFile = !(exception is null);
//            if (!isErrorFile && _ConfigData.Duplicator.HasValue)
//            {
//                if (_ConfigData.Duplicator.Value == ConfigData.Level.IsXToArchive)
//                    Shared0192(reportFullPath);
//                else if (_ConfigData.EafHosted && _ConfigData.Duplicator.Value == ConfigData.Level.IsArchive)
//                    MoveArchive();
//                if (_ConfigData.EafHosted && !string.IsNullOrEmpty(_ConfigData.ProgressPath))
//                    CreateProgressDirectory(_ConfigData.ProgressPath, Logistics, (int?)_ConfigData.Duplicator, exceptionLines: null);
//            }
//            if (!isErrorFile && _ConfigData.Duplicator is null)
//                WriteIO(reportFullPath);
//            if (!_ConfigData.EafHosted)
//            {
//                object @object = GetFilePathGeneratorInfo(reportFullPath, isErrorFile: false);
//                if (!(@object is null) && @object is string to)
//                {
//                    if (to.Contains("%"))
//                        _Log.Debug("Can't debug without EAF Hosting");
//                    else
//                        Shared1124(reportFullPath, extractResults, to, _Configuration.SourceFileLocation, resolvedFileLocation: string.Empty, exception: null);
//                }
//            }
//        }

//    }

//}