using Adaptation.Shared;
using Adaptation.Shared.Methods;
using log4net;
using System;
using System.Collections.Generic;
using System.Data;
using System.Globalization;
using System.IO;
using System.Linq;
using System.Text;
using System.Text.Json;
using System.Text.RegularExpressions;

namespace Adaptation.FileHandlers.txt;

public class ProcessData : IProcessData
{

    private int _I;
    private string _Data;

    private readonly ILog _Log;
    private readonly List<object> _Details;

    public string JobID { get; set; }
    public string MesEntity { get; set; }
    public string Date { get; set; }
    public string Lot { get; set; }
    public string Operator { get; set; }
    public string PSN { get; set; }
    public string RDS { get; set; }
    public string Reactor { get; set; }
    public string Recipe { get; set; }
    public string Session { get; set; }
    public string UniqueID { get; set; }
    public string DcnAllMax { get; set; }
    public string DcnAllMean { get; set; }
    public string DcnAllMin { get; set; }
    public string DcnAllStdDev { get; set; }
    public string DcnAreaCountMax { get; set; }
    public string DcnAreaCountMean { get; set; }
    public string DcnAreaCountMin { get; set; }
    public string DcnAreaCountStdDev { get; set; }
    public string DcnAreaMax { get; set; }
    public string DcnAreaMean { get; set; }
    public string DcnAreaMin { get; set; }
    public string DcnAreaStdDev { get; set; }
    public string DcnBin1Max { get; set; }
    public string DcnBin1Mean { get; set; }
    public string DcnBin1Min { get; set; }
    public string DcnBin1StdDev { get; set; }
    public string DcnBin2Max { get; set; }
    public string DcnBin2Mean { get; set; }
    public string DcnBin2Min { get; set; }
    public string DcnBin2StdDev { get; set; }
    public string DcnBin3Max { get; set; }
    public string DcnBin3Mean { get; set; }
    public string DcnBin3Min { get; set; }
    public string DcnBin3StdDev { get; set; }
    public string DcnBin4Max { get; set; }
    public string DcnBin4Mean { get; set; }
    public string DcnBin4Min { get; set; }
    public string DcnBin4StdDev { get; set; }
    public string DcnBin5Max { get; set; }
    public string DcnBin5Mean { get; set; }
    public string DcnBin5Min { get; set; }
    public string DcnBin5StdDev { get; set; }
    public string DcnBin6Max { get; set; }
    public string DcnBin6Mean { get; set; }
    public string DcnBin6Min { get; set; }
    public string DcnBin6StdDev { get; set; }
    public string DcnBin7Max { get; set; }
    public string DcnBin7Mean { get; set; }
    public string DcnBin7Min { get; set; }
    public string DcnBin7StdDev { get; set; }
    public string DcnBin8Max { get; set; }
    public string DcnBin8Mean { get; set; }
    public string DcnBin8Min { get; set; }
    public string DcnBin8StdDev { get; set; }
    public string DcnHazeAvgMax { get; set; }
    public string DcnHazeAvgMean { get; set; }
    public string DcnHazeAvgMin { get; set; }
    public string DcnHazeAvgStdDev { get; set; }
    public string DcnHazeMedianMax { get; set; }
    public string DcnHazeMedianMean { get; set; }
    public string DcnHazeMedianMin { get; set; }
    public string DcnHazeMedianStdDev { get; set; }
    public string DcnHazeStdDevMax { get; set; }
    public string DcnHazeStdDevMean { get; set; }
    public string DcnHazeStdDevMin { get; set; }
    public string DcnHazeStdDevStdDev { get; set; }
    public string DcnLpdESMax { get; set; }
    public string DcnLpdESMean { get; set; }
    public string DcnLpdESMin { get; set; }
    public string DcnLpdESStdDev { get; set; }
    public string DcnLpdMax { get; set; }
    public string DcnLpdMean { get; set; }
    public string DcnLpdMin { get; set; }
    public string DcnLpdNMax { get; set; }
    public string DcnLpdNMean { get; set; }
    public string DcnLpdNMin { get; set; }
    public string DcnLpdNStdDev { get; set; }
    public string DcnLpdStdDev { get; set; }
    public string DcnMicroScrMax { get; set; }
    public string DcnMicroScrMean { get; set; }
    public string DcnMicroScrMin { get; set; }
    public string DcnMicroScrStdDev { get; set; }
    public string DcnScrMax { get; set; }
    public string DcnScrMean { get; set; }
    public string DcnScrMin { get; set; }
    public string DcnScrStdDev { get; set; }
    public string DcnSlipMax { get; set; }
    public string DcnSlipMean { get; set; }
    public string DcnSlipMin { get; set; }
    public string DcnSlipStdDev { get; set; }
    public string DnnAllMax { get; set; }
    public string DnnAllMean { get; set; }
    public string DnnAllMin { get; set; }
    public string DnnAllStdDev { get; set; }
    public string DnnAreaCountMax { get; set; }
    public string DnnAreaCountMean { get; set; }
    public string DnnAreaCountMin { get; set; }
    public string DnnAreaCountStdDev { get; set; }
    public string DnnAreaMax { get; set; }
    public string DnnAreaMean { get; set; }
    public string DnnAreaMin { get; set; }
    public string DnnAreaStdDev { get; set; }
    public string DnnBin1Max { get; set; }
    public string DnnBin1Mean { get; set; }
    public string DnnBin1Min { get; set; }
    public string DnnBin1StdDev { get; set; }
    public string DnnBin2Max { get; set; }
    public string DnnBin2Mean { get; set; }
    public string DnnBin2Min { get; set; }
    public string DnnBin2StdDev { get; set; }
    public string DnnBin3Max { get; set; }
    public string DnnBin3Mean { get; set; }
    public string DnnBin3Min { get; set; }
    public string DnnBin3StdDev { get; set; }
    public string DnnBin4Max { get; set; }
    public string DnnBin4Mean { get; set; }
    public string DnnBin4Min { get; set; }
    public string DnnBin4StdDev { get; set; }
    public string DnnBin5Max { get; set; }
    public string DnnBin5Mean { get; set; }
    public string DnnBin5Min { get; set; }
    public string DnnBin5StdDev { get; set; }
    public string DnnBin6Max { get; set; }
    public string DnnBin6Mean { get; set; }
    public string DnnBin6Min { get; set; }
    public string DnnBin6StdDev { get; set; }
    public string DnnBin7Max { get; set; }
    public string DnnBin7Mean { get; set; }
    public string DnnBin7Min { get; set; }
    public string DnnBin7StdDev { get; set; }
    public string DnnBin8Max { get; set; }
    public string DnnBin8Mean { get; set; }
    public string DnnBin8Min { get; set; }
    public string DnnBin8StdDev { get; set; }
    public string DnnHazeAvgMax { get; set; }
    public string DnnHazeAvgMean { get; set; }
    public string DnnHazeAvgMin { get; set; }
    public string DnnHazeAvgStdDev { get; set; }
    public string DnnHazeMedianMax { get; set; }
    public string DnnHazeMedianMean { get; set; }
    public string DnnHazeMedianMin { get; set; }
    public string DnnHazeMedianStdDev { get; set; }
    public string DnnHazeStdDevMax { get; set; }
    public string DnnHazeStdDevMean { get; set; }
    public string DnnHazeStdDevMin { get; set; }
    public string DnnHazeStdDevStdDev { get; set; }
    public string DnnLpdESMax { get; set; }
    public string DnnLpdESMean { get; set; }
    public string DnnLpdESMin { get; set; }
    public string DnnLpdESStdDev { get; set; }
    public string DnnLpdMax { get; set; }
    public string DnnLpdMean { get; set; }
    public string DnnLpdMin { get; set; }
    public string DnnLpdNMax { get; set; }
    public string DnnLpdNMean { get; set; }
    public string DnnLpdNMin { get; set; }
    public string DnnLpdNStdDev { get; set; }
    public string DnnLpdStdDev { get; set; }
    public string DnnMicroScrMax { get; set; }
    public string DnnMicroScrMean { get; set; }
    public string DnnMicroScrMin { get; set; }
    public string DnnMicroScrStdDev { get; set; }
    public string DnnScrMax { get; set; }
    public string DnnScrMean { get; set; }
    public string DnnScrMin { get; set; }
    public string DnnScrStdDev { get; set; }
    public string DnnSlipMax { get; set; }
    public string DnnSlipMean { get; set; }
    public string DnnSlipMin { get; set; }
    public string DnnSlipStdDev { get; set; }
    public string DwnAllMax { get; set; }
    public string DwnAllMean { get; set; }
    public string DwnAllMin { get; set; }
    public string DwnAllStdDev { get; set; }
    public string DwnAreaCountMax { get; set; }
    public string DwnAreaCountMean { get; set; }
    public string DwnAreaCountMin { get; set; }
    public string DwnAreaCountStdDev { get; set; }
    public string DwnAreaMax { get; set; }
    public string DwnAreaMean { get; set; }
    public string DwnAreaMin { get; set; }
    public string DwnAreaStdDev { get; set; }
    public string DwnBin1Max { get; set; }
    public string DwnBin1Mean { get; set; }
    public string DwnBin1Min { get; set; }
    public string DwnBin1StdDev { get; set; }
    public string DwnBin2Max { get; set; }
    public string DwnBin2Mean { get; set; }
    public string DwnBin2Min { get; set; }
    public string DwnBin2StdDev { get; set; }
    public string DwnBin3Max { get; set; }
    public string DwnBin3Mean { get; set; }
    public string DwnBin3Min { get; set; }
    public string DwnBin3StdDev { get; set; }
    public string DwnBin4Max { get; set; }
    public string DwnBin4Mean { get; set; }
    public string DwnBin4Min { get; set; }
    public string DwnBin4StdDev { get; set; }
    public string DwnBin5Max { get; set; }
    public string DwnBin5Mean { get; set; }
    public string DwnBin5Min { get; set; }
    public string DwnBin5StdDev { get; set; }
    public string DwnBin6Max { get; set; }
    public string DwnBin6Mean { get; set; }
    public string DwnBin6Min { get; set; }
    public string DwnBin6StdDev { get; set; }
    public string DwnBin7Max { get; set; }
    public string DwnBin7Mean { get; set; }
    public string DwnBin7Min { get; set; }
    public string DwnBin7StdDev { get; set; }
    public string DwnBin8Max { get; set; }
    public string DwnBin8Mean { get; set; }
    public string DwnBin8Min { get; set; }
    public string DwnBin8StdDev { get; set; }
    public string DwnHazeAvgMax { get; set; }
    public string DwnHazeAvgMean { get; set; }
    public string DwnHazeAvgMin { get; set; }
    public string DwnHazeAvgStdDev { get; set; }
    public string DwnHazeMedianMax { get; set; }
    public string DwnHazeMedianMean { get; set; }
    public string DwnHazeMedianMin { get; set; }
    public string DwnHazeMedianStdDev { get; set; }
    public string DwnHazeStdDevMax { get; set; }
    public string DwnHazeStdDevMean { get; set; }
    public string DwnHazeStdDevMin { get; set; }
    public string DwnHazeStdDevStdDev { get; set; }
    public string DwnLpdESMax { get; set; }
    public string DwnLpdESMean { get; set; }
    public string DwnLpdESMin { get; set; }
    public string DwnLpdESStdDev { get; set; }
    public string DwnLpdMax { get; set; }
    public string DwnLpdMean { get; set; }
    public string DwnLpdMin { get; set; }
    public string DwnLpdNMax { get; set; }
    public string DwnLpdNMean { get; set; }
    public string DwnLpdNMin { get; set; }
    public string DwnLpdNStdDev { get; set; }
    public string DwnLpdStdDev { get; set; }
    public string DwnMicroScrMax { get; set; }
    public string DwnMicroScrMean { get; set; }
    public string DwnMicroScrMin { get; set; }
    public string DwnMicroScrStdDev { get; set; }
    public string DwnScrMax { get; set; }
    public string DwnScrMean { get; set; }
    public string DwnScrMin { get; set; }
    public string DwnScrStdDev { get; set; }
    public string DwnSlipMax { get; set; }
    public string DwnSlipMean { get; set; }
    public string DwnSlipMin { get; set; }
    public string DwnSlipStdDev { get; set; }

    List<object> Shared.Properties.IProcessData.Details => _Details;

    public ProcessData(IFileRead fileRead, Logistics logistics, List<FileInfo> fileInfoCollection)
    {
        fileInfoCollection.Clear();
        _Details = new List<object>();
        _I = 0;
        _Data = string.Empty;
        JobID = logistics.JobID;
        MesEntity = logistics.MesEntity;
        Date = DateTime.Now.ToString();
        _Log = LogManager.GetLogger(typeof(ProcessData));
        Parse(fileRead, logistics, fileInfoCollection);
    }

    string IProcessData.GetCurrentReactor(IFileRead fileRead, Logistics logistics, Dictionary<string, string> reactors) => throw new Exception(string.Concat("See ", nameof(Parse)));

    Tuple<string, Test[], JsonElement[], List<FileInfo>> IProcessData.GetResults(IFileRead fileRead, Logistics logistics, List<FileInfo> fileInfoCollection)
    {
        Tuple<string, Test[], JsonElement[], List<FileInfo>> results;
        List<Test> tests = new();
        foreach (object item in _Details)
            tests.Add(Test.SP1);
        List<IDescription> descriptions = fileRead.GetDescriptions(fileRead, tests, this);
        if (tests.Count != descriptions.Count)
            throw new Exception();
        for (int i = 0; i < tests.Count; i++)
        {
            if (descriptions[i] is not Description description)
                throw new Exception();
            if (description.Test != (int)tests[i])
                throw new Exception();
        }
        List<Description> fileReadDescriptions = (from l in descriptions select (Description)l).ToList();
        string json = JsonSerializer.Serialize(fileReadDescriptions, fileReadDescriptions.GetType());
        JsonElement[] jsonElements = JsonSerializer.Deserialize<JsonElement[]>(json);
        results = new Tuple<string, Test[], JsonElement[], List<FileInfo>>(logistics.Logistics1[0], tests.ToArray(), jsonElements, fileInfoCollection);
        return results;
    }

    private void ScanPast(string text)
    {
        int num = _Data.IndexOf(text, _I);
        if (num > -1)
            _I = num + text.Length;
        else
            _I = _Data.Length;
    }

    private string GetBefore(string text)
    {
        int num = _Data.IndexOf(text, _I);
        if (num > -1)
        {
            string str = _Data.Substring(_I, num - _I);
            _I = num + text.Length;
            return str.Trim();
        }
        string str1 = _Data.Substring(_I);
        _I = _Data.Length;
        return str1.Trim();
    }

    private string GetBefore(string text, bool trim)
    {
        if (trim)
            return GetBefore(text);
        int num = _Data.IndexOf(text, _I);
        if (num > -1)
        {
            string str = _Data.Substring(_I, num - _I);
            _I = num + text.Length;
            return str;
        }
        string str1 = _Data.Substring(_I);
        _I = _Data.Length;
        return str1;
    }

    private static bool IsNullOrWhiteSpace(string text)
    {
        for (int index = 0; index < text.Length; ++index)
        {
            if (!char.IsWhiteSpace(text[index]))
                return false;
        }
        return true;
    }

    private bool IsBlankLine()
    {
        int num = _Data.IndexOf("\n", _I);
        return IsNullOrWhiteSpace(num > -1 ? _Data.Substring(_I, num - _I) : _Data.Substring(_I));
    }

    private string GetToEOL() => GetBefore("\n");

    private string GetToEOL(bool trim)
    {
        if (trim)
            return GetToEOL();
        return GetBefore("\n", false);
    }

    private string GetToText(string text) => _Data.Substring(_I, _Data.IndexOf(text, _I) - _I).Trim();

    private string GetToken()
    {
        while (_I < _Data.Length && IsNullOrWhiteSpace(_Data.Substring(_I, 1)))
            ++_I;
        int j = _I;
        while (j < _Data.Length && !IsNullOrWhiteSpace(_Data.Substring(j, 1)))
            ++j;
        string str = _Data.Substring(_I, j - _I);
        _I = j;
        return str.Trim();
    }

    private string PeekNextLine()
    {
        int j = _I;
        string toEol = GetToEOL();
        _I = j;
        return toEol;
    }

    private void GetWaferSummaryInfo(List<WaferSummaryInfo> waferSummaryInfos, string whichInfo)
    {
        ScanPast(whichInfo);
        _ = GetToEOL();
        _ = GetToEOL();
        _ = GetToEOL();
        _ = GetToEOL();
        string[] segments;
        WaferSummaryInfo waferSummaryInfo;
        const string grade = "F                  Grade";
        const string reject = "F                  Reject";
        const string overLoad = "F                  OverLoad";
        for (string line = PeekNextLine(); line[0] != '-'; line = PeekNextLine())
        {
            line = GetToEOL();
            waferSummaryInfo = new WaferSummaryInfo();
            if (line.StartsWith(grade))
                line = line.Replace(grade, string.Concat("F -1", grade.Substring(4)));
            else if (line.StartsWith(reject))
                line = line.Replace(reject, string.Concat("F -1", reject.Substring(4)));
            else if (line.StartsWith(overLoad))
                line = line.Replace(overLoad, string.Concat("F -1", overLoad.Substring(4)));
            segments = line.Split(new char[] { ' ' }, StringSplitOptions.RemoveEmptyEntries);
            waferSummaryInfo.Side = segments[0];
            waferSummaryInfo.WaferID = segments[1];
            waferSummaryInfo.Grade = segments[2];
            waferSummaryInfo.SrcDest = segments[3];
            if (segments.Length > 4)
            {
                waferSummaryInfo.Lpd = segments[5];
                waferSummaryInfo.LpdN = segments[6];
                waferSummaryInfo.LpdES = segments[7];
                waferSummaryInfo.MicroScr = segments[8];
                waferSummaryInfo.Scr = segments[9];
                waferSummaryInfo.Slip = segments[10];
                waferSummaryInfo.AreaNum = segments[11];
                waferSummaryInfo.Area = segments[12];
                waferSummaryInfo.HazeAvg = segments[13];
                waferSummaryInfo.HazeMedian = segments[14];
                waferSummaryInfo.HazeStdDev = segments[15];
                waferSummaryInfo.Bin1 = segments[16];
                waferSummaryInfo.Bin2 = segments[17];
                waferSummaryInfo.Bin3 = segments[18];
                waferSummaryInfo.Bin4 = segments[19];
                waferSummaryInfo.Bin5 = segments[20];
                waferSummaryInfo.Bin6 = segments[21];
                waferSummaryInfo.Bin7 = segments[22];
                waferSummaryInfo.Bin8 = segments[23];
            }
            if (waferSummaryInfo.WaferID == "-1")
            {
                segments = waferSummaryInfo.SrcDest.Split('-')[0].Split('/');
                waferSummaryInfo.WaferID = segments[segments.Length - 1];
            }
            waferSummaryInfos.Add(waferSummaryInfo);
        }
    }

    private void ParseHeader(ILogistics logistics, List<WaferSummaryInfo> dcnTotals, List<WaferSummaryInfo> dwnTotals, List<WaferSummaryInfo> dnnTotals)
    {
        _I = 0;
        _Data = string.Empty;
        string summaryReportText = File.ReadAllText(logistics.ReportFullPath);
        if (!string.IsNullOrEmpty(summaryReportText))
        {
            _Log.Debug("HeaderFile() - Beginning");
            _I = 0;
            _Data = summaryReportText;
            ScanPast("Long Wafer Summary");
            _ = GetToEOL();
            ScanPast("Session:");
            string toEOL = GetToEOL(true);
            string str = toEOL;
            Recipe = toEOL;
            Session = str;
            ScanPast("Lot ID:");
            Lot = GetToEOL(true);
            // Remove illegal characters \/:*?"<>| found in the Lot.
            Lot = Regex.Replace(Lot, @"[\\,\/,\:,\*,\?,\"",\<,\>,\|]", "_").Split('\r')[0].Split('\n')[0];
            string[] segments = Lot.Split(new char[] { '-' });
            _Log.Debug("HeaderFile() - Debug A");
            if (segments.Length > 1)
            {
                Reactor = segments[0];
                RDS = segments[1];
                if (segments.Length > 2)
                {
                    PSN = segments[2];
                    if (segments.Length > 3)
                        Operator = segments[3];
                }
            }
            _Log.Debug("HeaderFile() - Debug B");
            _I = 0;
            _Data = summaryReportText;
            GetWaferSummaryInfo(dcnTotals, "DCN Totals");
            ScanPast("Min");
            segments = GetToEOL().Split(new char[] { ' ' }, StringSplitOptions.RemoveEmptyEntries);
            DcnAllMin = segments[0];
            DcnLpdMin = segments[1];
            DcnLpdNMin = segments[2];
            DcnLpdESMin = segments[3];
            DcnMicroScrMin = segments[4];
            DcnScrMin = segments[5];
            DcnSlipMin = segments[6];
            DcnAreaCountMin = segments[7];
            DcnAreaMin = segments[8];
            DcnHazeAvgMin = segments[9];
            DcnHazeMedianMin = segments[10];
            DcnHazeStdDevMin = segments[11];
            DcnBin1Min = segments[12];
            DcnBin2Min = segments[13];
            DcnBin3Min = segments[14];
            DcnBin4Min = segments[15];
            DcnBin5Min = segments[16];
            DcnBin6Min = segments[17];
            DcnBin7Min = segments[18];
            DcnBin8Min = segments[19];
            ScanPast("Max");
            segments = GetToEOL().Split(new char[] { ' ' }, StringSplitOptions.RemoveEmptyEntries);
            DcnAllMax = segments[0];
            DcnLpdMax = segments[1];
            DcnLpdNMax = segments[2];
            DcnLpdESMax = segments[3];
            DcnMicroScrMax = segments[4];
            DcnScrMax = segments[5];
            DcnSlipMax = segments[6];
            DcnAreaCountMax = segments[7];
            DcnAreaMax = segments[8];
            DcnHazeAvgMax = segments[9];
            DcnHazeMedianMax = segments[10];
            DcnHazeStdDevMax = segments[11];
            DcnBin1Max = segments[12];
            DcnBin2Max = segments[13];
            DcnBin3Max = segments[14];
            DcnBin4Max = segments[15];
            DcnBin5Max = segments[16];
            DcnBin6Max = segments[17];
            DcnBin7Max = segments[18];
            DcnBin8Max = segments[19];
            ScanPast("Mean");
            segments = GetToEOL().Split(new char[] { ' ' }, StringSplitOptions.RemoveEmptyEntries);
            DcnAllMean = segments[0];
            DcnLpdMean = segments[1];
            DcnLpdNMean = segments[2];
            DcnLpdESMean = segments[3];
            DcnMicroScrMean = segments[4];
            DcnScrMean = segments[5];
            DcnSlipMean = segments[6];
            DcnAreaCountMean = segments[7];
            DcnAreaMean = segments[8];
            DcnHazeAvgMean = segments[9];
            DcnHazeMedianMean = segments[10];
            DcnHazeStdDevMean = segments[11];
            DcnBin1Mean = segments[12];
            DcnBin2Mean = segments[13];
            DcnBin3Mean = segments[14];
            DcnBin4Mean = segments[15];
            DcnBin5Mean = segments[16];
            DcnBin6Mean = segments[17];
            DcnBin7Mean = segments[18];
            DcnBin8Mean = segments[19];
            ScanPast("Std. Dev.");
            segments = GetToEOL().Split(new char[] { ' ' }, StringSplitOptions.RemoveEmptyEntries);
            DcnAllStdDev = segments[0];
            DcnLpdStdDev = segments[1];
            DcnLpdNStdDev = segments[2];
            DcnLpdESStdDev = segments[3];
            DcnMicroScrStdDev = segments[4];
            DcnScrStdDev = segments[5];
            DcnSlipStdDev = segments[6];
            DcnAreaCountStdDev = segments[7];
            DcnAreaStdDev = segments[8];
            DcnHazeAvgStdDev = segments[9];
            DcnHazeMedianStdDev = segments[10];
            DcnHazeStdDevStdDev = segments[11];
            DcnBin1StdDev = segments[12];
            DcnBin2StdDev = segments[13];
            DcnBin3StdDev = segments[14];
            DcnBin4StdDev = segments[15];
            DcnBin5StdDev = segments[16];
            DcnBin6StdDev = segments[17];
            DcnBin7StdDev = segments[18];
            DcnBin8StdDev = segments[19];
            _I = 0;
            _Data = summaryReportText;
            _Log.Debug("HeaderFile() - Debug C");
            if (!_Data.Contains("DWN Totals"))
            {
                for (int i = 0; i < dcnTotals.Count; i++)
                    dwnTotals.Add(new WaferSummaryInfo());
            }
            else
            {
                GetWaferSummaryInfo(dwnTotals, "DWN Totals");
                ScanPast("Min");
                segments = GetToEOL().Split(new char[] { ' ' }, StringSplitOptions.RemoveEmptyEntries);
                DwnAllMin = segments[0];
                DwnLpdMin = segments[1];
                DwnLpdNMin = segments[2];
                DwnLpdESMin = segments[3];
                DwnMicroScrMin = segments[4];
                DwnScrMin = segments[5];
                DwnSlipMin = segments[6];
                DwnAreaCountMin = segments[7];
                DwnAreaMin = segments[8];
                DwnHazeAvgMin = segments[9];
                DwnHazeMedianMin = segments[10];
                DwnHazeStdDevMin = segments[11];
                DwnBin1Min = segments[12];
                DwnBin2Min = segments[13];
                DwnBin3Min = segments[14];
                DwnBin4Min = segments[15];
                DwnBin5Min = segments[16];
                DwnBin6Min = segments[17];
                DwnBin7Min = segments[18];
                DwnBin8Min = segments[19];
                ScanPast("Max");
                segments = GetToEOL().Split(new char[] { ' ' }, StringSplitOptions.RemoveEmptyEntries);
                DwnAllMax = segments[0];
                DwnLpdMax = segments[1];
                DwnLpdNMax = segments[2];
                DwnLpdESMax = segments[3];
                DwnMicroScrMax = segments[4];
                DwnScrMax = segments[5];
                DwnSlipMax = segments[6];
                DwnAreaCountMax = segments[7];
                DwnAreaMax = segments[8];
                DwnHazeAvgMax = segments[9];
                DwnHazeMedianMax = segments[10];
                DwnHazeStdDevMax = segments[11];
                DwnBin1Max = segments[12];
                DwnBin2Max = segments[13];
                DwnBin3Max = segments[14];
                DwnBin4Max = segments[15];
                DwnBin5Max = segments[16];
                DwnBin6Max = segments[17];
                DwnBin7Max = segments[18];
                DwnBin8Max = segments[19];
                ScanPast("Mean");
                segments = GetToEOL().Split(new char[] { ' ' }, StringSplitOptions.RemoveEmptyEntries);
                DwnAllMean = segments[0];
                DwnLpdMean = segments[1];
                DwnLpdNMean = segments[2];
                DwnLpdESMean = segments[3];
                DwnMicroScrMean = segments[4];
                DwnScrMean = segments[5];
                DwnSlipMean = segments[6];
                DwnAreaCountMean = segments[7];
                DwnAreaMean = segments[8];
                DwnHazeAvgMean = segments[9];
                DwnHazeMedianMean = segments[10];
                DwnHazeStdDevMean = segments[11];
                DwnBin1Mean = segments[12];
                DwnBin2Mean = segments[13];
                DwnBin3Mean = segments[14];
                DwnBin4Mean = segments[15];
                DwnBin5Mean = segments[16];
                DwnBin6Mean = segments[17];
                DwnBin7Mean = segments[18];
                DwnBin8Mean = segments[19];
                ScanPast("Std. Dev.");
                segments = GetToEOL().Split(new char[] { ' ' }, StringSplitOptions.RemoveEmptyEntries);
                DwnAllStdDev = segments[0];
                DwnLpdStdDev = segments[1];
                DwnLpdNStdDev = segments[2];
                DwnLpdESStdDev = segments[3];
                DwnMicroScrStdDev = segments[4];
                DwnScrStdDev = segments[5];
                DwnSlipStdDev = segments[6];
                DwnAreaCountStdDev = segments[7];
                DwnAreaStdDev = segments[8];
                DwnHazeAvgStdDev = segments[9];
                DwnHazeMedianStdDev = segments[10];
                DwnHazeStdDevStdDev = segments[11];
                DwnBin1StdDev = segments[12];
                DwnBin2StdDev = segments[13];
                DwnBin3StdDev = segments[14];
                DwnBin4StdDev = segments[15];
                DwnBin5StdDev = segments[16];
                DwnBin6StdDev = segments[17];
                DwnBin7StdDev = segments[18];
                DwnBin8StdDev = segments[19];
            }
            _I = 0;
            _Data = summaryReportText;
            _Log.Debug("HeaderFile() - Debug D");
            if (!_Data.Contains("DNN Totals"))
            {
                for (int i = 0; i < dcnTotals.Count; i++)
                    dnnTotals.Add(new WaferSummaryInfo());
            }
            else
            {
                GetWaferSummaryInfo(dnnTotals, "DNN Totals");
                ScanPast("Min");
                segments = GetToEOL().Split(new char[] { ' ' }, StringSplitOptions.RemoveEmptyEntries);
                DnnAllMin = segments[0];
                DnnLpdMin = segments[1];
                DnnLpdNMin = segments[2];
                DnnLpdESMin = segments[3];
                DnnMicroScrMin = segments[4];
                DnnScrMin = segments[5];
                DnnSlipMin = segments[6];
                DnnAreaCountMin = segments[7];
                DnnAreaMin = segments[8];
                DnnHazeAvgMin = segments[9];
                DnnHazeMedianMin = segments[10];
                DnnHazeStdDevMin = segments[11];
                DnnBin1Min = segments[12];
                DnnBin2Min = segments[13];
                DnnBin3Min = segments[14];
                DnnBin4Min = segments[15];
                DnnBin5Min = segments[16];
                DnnBin6Min = segments[17];
                DnnBin7Min = segments[18];
                DnnBin8Min = segments[19];
                ScanPast("Max");
                segments = GetToEOL().Split(new char[] { ' ' }, StringSplitOptions.RemoveEmptyEntries);
                DnnAllMax = segments[0];
                DnnLpdMax = segments[1];
                DnnLpdNMax = segments[2];
                DnnLpdESMax = segments[3];
                DnnMicroScrMax = segments[4];
                DnnScrMax = segments[5];
                DnnSlipMax = segments[6];
                DnnAreaCountMax = segments[7];
                DnnAreaMax = segments[8];
                DnnHazeAvgMax = segments[9];
                DnnHazeMedianMax = segments[10];
                DnnHazeStdDevMax = segments[11];
                DnnBin1Max = segments[12];
                DnnBin2Max = segments[13];
                DnnBin3Max = segments[14];
                DnnBin4Max = segments[15];
                DnnBin5Max = segments[16];
                DnnBin6Max = segments[17];
                DnnBin7Max = segments[18];
                DnnBin8Max = segments[19];
                ScanPast("Mean");
                segments = GetToEOL().Split(new char[] { ' ' }, StringSplitOptions.RemoveEmptyEntries);
                DnnAllMean = segments[0];
                DnnLpdMean = segments[1];
                DnnLpdNMean = segments[2];
                DnnLpdESMean = segments[3];
                DnnMicroScrMean = segments[4];
                DnnScrMean = segments[5];
                DnnSlipMean = segments[6];
                DnnAreaCountMean = segments[7];
                DnnAreaMean = segments[8];
                DnnHazeAvgMean = segments[9];
                DnnHazeMedianMean = segments[10];
                DnnHazeStdDevMean = segments[11];
                DnnBin1Mean = segments[12];
                DnnBin2Mean = segments[13];
                DnnBin3Mean = segments[14];
                DnnBin4Mean = segments[15];
                DnnBin5Mean = segments[16];
                DnnBin6Mean = segments[17];
                DnnBin7Mean = segments[18];
                DnnBin8Mean = segments[19];
                ScanPast("Std. Dev.");
                segments = GetToEOL().Split(new char[] { ' ' }, StringSplitOptions.RemoveEmptyEntries);
                DnnAllStdDev = segments[0];
                DnnLpdStdDev = segments[1];
                DnnLpdNStdDev = segments[2];
                DnnLpdESStdDev = segments[3];
                DnnMicroScrStdDev = segments[4];
                DnnScrStdDev = segments[5];
                DnnSlipStdDev = segments[6];
                DnnAreaCountStdDev = segments[7];
                DnnAreaStdDev = segments[8];
                DnnHazeAvgStdDev = segments[9];
                DnnHazeMedianStdDev = segments[10];
                DnnHazeStdDevStdDev = segments[11];
                DnnBin1StdDev = segments[12];
                DnnBin2StdDev = segments[13];
                DnnBin3StdDev = segments[14];
                DnnBin4StdDev = segments[15];
                DnnBin5StdDev = segments[16];
                DnnBin6StdDev = segments[17];
                DnnBin7StdDev = segments[18];
                DnnBin8StdDev = segments[19];
            }
        }
        //UniqueID = string.Format("{0}_{1}_Summary_{2}", logistics.JobID, Lot, Date);
        UniqueID = string.Format("{0}_{1}_{2}", logistics.JobID, Lot, Path.GetFileNameWithoutExtension(logistics.ReportFullPath));
    }

    /// <summary>
    /// Parse the wafer summary data
    /// </summary>
    /// <param name="headerFile">wafer data</param>
    /// <param name="i">wafer index</param>
    /// <returns></returns>
    private Detail ParseWaferSummary(int i, List<WaferSummaryInfo> dcnTotals, List<WaferSummaryInfo> dwnTotals, List<WaferSummaryInfo> dnnTotals)
    {
        Detail result = new()
        {
            // NOTE: get the UniqueID during DataCalculation in order to retrieve the SPCToolID from the cell component Tag field.
            // id 
            //runData.UniqueID = string.Format("{0}_{1}", sp1Header.UniqueId, i + 1);
            //runData.HeaderUniqueID = sp1Header.UniqueId;

            // General Wafer Info
            Side = dcnTotals[i].Side,
            WaferID = dcnTotals[i].WaferID,
            Grade = dcnTotals[i].Grade,
            SrcDest = dcnTotals[i].SrcDest,

            // Dcn Info
            DcnAll = dcnTotals[i].All ?? string.Empty,
            DcnLpd = dcnTotals[i].Lpd ?? string.Empty,
            DcnLpdN = dcnTotals[i].LpdN ?? string.Empty,
            DcnLpdES = dcnTotals[i].LpdES ?? string.Empty,
            DcnMicroScr = dcnTotals[i].MicroScr ?? string.Empty,
            DcnScr = dcnTotals[i].Scr ?? string.Empty,
            DcnSlip = dcnTotals[i].Slip ?? string.Empty,
            DcnAreaCount = dcnTotals[i].AreaNum ?? string.Empty,
            DcnArea = dcnTotals[i].Area ?? string.Empty,
            DcnHazeAvg = dcnTotals[i].HazeAvg ?? string.Empty,
            DcnHazeMedian = dcnTotals[i].HazeMedian ?? string.Empty,
            DcnHazeStdDev = dcnTotals[i].HazeStdDev ?? string.Empty,
            DcnBin1 = dcnTotals[i].Bin1 ?? string.Empty,
            DcnBin2 = dcnTotals[i].Bin2 ?? string.Empty,
            DcnBin3 = dcnTotals[i].Bin3 ?? string.Empty,
            DcnBin4 = dcnTotals[i].Bin4 ?? string.Empty,
            DcnBin5 = dcnTotals[i].Bin5 ?? string.Empty,
            DcnBin6 = dcnTotals[i].Bin6 ?? string.Empty,
            DcnBin7 = dcnTotals[i].Bin7 ?? string.Empty,
            DcnBin8 = dcnTotals[i].Bin8 ?? string.Empty,

            // Dwn Info
            DwnAll = dwnTotals[i].All ?? string.Empty,
            DwnLpd = dwnTotals[i].Lpd ?? string.Empty,
            DwnLpdN = dwnTotals[i].LpdN ?? string.Empty,
            DwnLpdES = dwnTotals[i].LpdES ?? string.Empty,
            DwnMicroScr = dwnTotals[i].MicroScr ?? string.Empty,
            DwnScr = dwnTotals[i].Scr ?? string.Empty,
            DwnSlip = dwnTotals[i].Slip ?? string.Empty,
            DwnAreaCount = dwnTotals[i].AreaNum ?? string.Empty,
            DwnArea = dwnTotals[i].Area ?? string.Empty,
            DwnHazeAvg = dwnTotals[i].HazeAvg ?? string.Empty,
            DwnHazeMedian = dwnTotals[i].HazeMedian ?? string.Empty,
            DwnHazeStdDev = dwnTotals[i].HazeStdDev ?? string.Empty,
            DwnBin1 = dwnTotals[i].Bin1 ?? string.Empty,
            DwnBin2 = dwnTotals[i].Bin2 ?? string.Empty,
            DwnBin3 = dwnTotals[i].Bin3 ?? string.Empty,
            DwnBin4 = dwnTotals[i].Bin4 ?? string.Empty,
            DwnBin5 = dwnTotals[i].Bin5 ?? string.Empty,
            DwnBin6 = dwnTotals[i].Bin6 ?? string.Empty,
            DwnBin7 = dwnTotals[i].Bin7 ?? string.Empty,
            DwnBin8 = dwnTotals[i].Bin8 ?? string.Empty,

            // Dnn Info
            DnnAll = dnnTotals[i].All ?? string.Empty,
            DnnLpd = dnnTotals[i].Lpd ?? string.Empty,
            DnnLpdN = dnnTotals[i].LpdN ?? string.Empty,
            DnnLpdES = dnnTotals[i].LpdES ?? string.Empty,
            DnnMicroScr = dnnTotals[i].MicroScr ?? string.Empty,
            DnnScr = dnnTotals[i].Scr ?? string.Empty,
            DnnSlip = dnnTotals[i].Slip ?? string.Empty,
            DnnAreaCount = dnnTotals[i].AreaNum ?? string.Empty,
            DnnArea = dnnTotals[i].Area ?? string.Empty,
            DnnHazeAvg = dnnTotals[i].HazeAvg ?? string.Empty,
            DnnHazeMedian = dnnTotals[i].HazeMedian ?? string.Empty,
            DnnHazeStdDev = dnnTotals[i].HazeStdDev ?? string.Empty,
            DnnBin1 = dnnTotals[i].Bin1 ?? string.Empty,
            DnnBin2 = dnnTotals[i].Bin2 ?? string.Empty,
            DnnBin3 = dnnTotals[i].Bin3 ?? string.Empty,
            DnnBin4 = dnnTotals[i].Bin4 ?? string.Empty,
            DnnBin5 = dnnTotals[i].Bin5 ?? string.Empty,
            DnnBin6 = dnnTotals[i].Bin6 ?? string.Empty,
            DnnBin7 = dnnTotals[i].Bin7 ?? string.Empty,
            DnnBin8 = dnnTotals[i].Bin8 ?? string.Empty
        };
        //result.HeaderUniqueID = string.Concat(MesEntity, "_", Lot, "_Summary_", Date);
        result.HeaderUniqueID = UniqueID;
        result.UniqueID = string.Concat(result.HeaderUniqueID, "_", result.WaferID.PadLeft(2, '0'));
        return result;
    }

    private void Parse(IFileRead fileRead, Logistics logistics, List<FileInfo> fileInfoCollection)
    {
        if (fileRead is null)
        { }
        Detail dataFile;
        foreach (string file in Directory.GetFiles(Path.GetDirectoryName(logistics.ReportFullPath), "WaferMap*.prn", SearchOption.TopDirectoryOnly))
            fileInfoCollection.Add(new FileInfo(file));
        List<WaferSummaryInfo> dcnTotals = new();
        List<WaferSummaryInfo> dwnTotals = new();
        List<WaferSummaryInfo> dnnTotals = new();
        ParseHeader(logistics, dcnTotals, dwnTotals, dnnTotals);
        _Log.Debug($"Number of wafers: {dcnTotals.Count}");
        for (int i = 0; i < dcnTotals.Count; i++)
        {
            _Log.Debug($"****ParseData - Parsing wafer summary: {i}");
            dataFile = ParseWaferSummary(i, dcnTotals, dwnTotals, dnnTotals);
            _Details.Add(dataFile);
        }
        fileInfoCollection.Add(new FileInfo(logistics.ReportFullPath));
    }

}