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 && _ConfigData.Duplicator.Value != ConfigData.Level.IsManualOIEntry)
                results = GetDuplicatorExtractResult(reportFullPath, dateTime);
            else if (_ConfigData.Duplicator.HasValue && _ConfigData.Duplicator.Value == ConfigData.Level.IsManualOIEntry)
                results = _ConfigData.IsManualOIEntry(reportFullPath);
            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, fileInfoLength: 50000);
            SetFileParameterLotID(Logistics.MID);
            if (new FileInfo(reportFullPath).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.IsXToIQSSi)
                duplicateDirectory = string.Concat(_Configuration.TargetFileLocation, @"\ALL");
            else 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)
            {
                bool ganPPTST = false;
                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.OpenInsightMetrogyViewerAPI, 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);
                            ganPPTST = fileReadDescriptions[0].Recipe.Contains("GAN_PPTST");
                            lines = ProcessData.GetLines(this, fileReadDescriptions, ganPPTST);
                            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)
                {
                    bool check = false;
                    if (_ConfigData.Duplicator.Value != ConfigData.Level.IsXToIQSSi && _ConfigData.Duplicator.Value != ConfigData.Level.IsXToIQSGaN)
                        check = true;
                    else if (_ConfigData.Duplicator.Value == ConfigData.Level.IsXToIQSSi && !ganPPTST)
                        check = true;
                    else if (_ConfigData.Duplicator.Value == ConfigData.Level.IsXToIQSGaN && ganPPTST)
                        check = true;
                    //else
                    //    Don't write file(s) //throw new Exception();
                    if (check)
                        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(_Configuration.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(_Configuration.TargetFileLocation, @"\", Logistics.JobID);
            if (!Directory.Exists(jobIdDirectory))
                Directory.CreateDirectory(jobIdDirectory);
            //string destinationArchiveDirectory = string.Concat(jobIdDirectory, @"\!Archive\", weekDirectory);
            string destinationArchiveDirectory = string.Concat(Path.GetDirectoryName(_Configuration.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);
                }
            }
        }

    }

}