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.Json.Serialization;
using System.Text.RegularExpressions;

namespace Adaptation.FileHandlers.QS408M;

public partial class ProcessData : IProcessData
{

    private readonly List<object> _Details;

    public string JobID { get; set; }
    public string MesEntity { get; set; }
    public string Batch { get; set; }
    public string Cassette { get; set; }
    public string Date { get; set; }
    public string Employee { get; set; }
    public string Layer { get; set; }
    public string MeanThickness { get; set; }
    public string PSN { get; set; }
    public string PassFail { get; set; }
    public string RDS { get; set; }
    public string RVThickness { get; set; }
    public string Reactor { get; set; }
    public string Recipe { get; set; }
    public string StdDev { get; set; }
    public string Title { get; set; }
    public string UniqueId { get; set; }
    public string Wafer { get; set; }
    public string Zone { get; set; }

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

    private int _I;
    private string _Data;
    private readonly ILog _Log;

    public ProcessData()
    {
    }

    public ProcessData(IFileRead fileRead, Logistics logistics, List<FileInfo> fileInfoCollection, string originalDataBioRad, ProcessData lastProcessData)
    {
        JobID = logistics.JobID;
        fileInfoCollection.Clear();
        _Details = new List<object>();
        MesEntity = logistics.MesEntity;
        _Log = LogManager.GetLogger(typeof(ProcessData));
        Parse(fileRead, logistics, fileInfoCollection, originalDataBioRad, lastProcessData);
    }

    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.BioRadQS408M);
        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 string GetBefore(string text)
    {
        string str;
        string str1;
        int num = _Data.IndexOf(text, _I);
        if (num <= -1)
        {
            str = _Data.Substring(_I);
            _I = _Data.Length;
            str1 = str.Trim();
        }
        else
        {
            str = _Data.Substring(_I, num - _I);
            _I = num + text.Length;
            str1 = str.Trim();
        }
        return str1;
    }

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

    private string GetToEOL()
    {
        string result;
        if (_Data.IndexOf("\n", _I) > -1)
            result = GetBefore("\n");
        else
            result = GetBefore(Environment.NewLine);
        return result;
    }

    private string GetToEOL(bool trim)
    {
        string str;
        if (_Data.IndexOf("\n", _I) > -1)
            str = !trim ? GetBefore("\n", false) : GetToEOL();
        else
            str = !trim ? GetBefore(Environment.NewLine, false) : GetToEOL();
        return str;
    }

    private string GetToken()
    {
        while (true)
        {
            if (_I >= _Data.Length || !IsNullOrWhiteSpace(_Data.Substring(_I, 1)))
            {
                break;
            }
            _I++;
        }
        int num = _I;
        while (true)
        {
            if (num >= _Data.Length || IsNullOrWhiteSpace(_Data.Substring(num, 1)))
            {
                break;
            }
            num++;
        }
        string str = _Data.Substring(_I, num - _I);
        _I = num;
        return str.Trim();
    }

    private string GetToText(string text)
    {
        string str = _Data.Substring(_I, _Data.IndexOf(text, _I) - _I).Trim();
        return str;
    }

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

    private static bool IsNullOrWhiteSpace(string text)
    {
        bool flag;
        int num = 0;
        while (true)
        {
            if (num >= text.Length)
            {
                flag = true;
                break;
            }
            else if (char.IsWhiteSpace(text[num]))
            {
                num++;
            }
            else
            {
                flag = false;
                break;
            }
        }
        return flag;
    }

    private string PeekNextLine()
    {
        int num = _I;
        string toEOL = GetToEOL();
        _I = num;
        return toEOL;
    }

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

    internal static DateTime GetDateTime(Logistics logistics, string dateTimeText)
    {
        DateTime result;
        string inputDateFormat = "ddd mmm dd HH:mm:ss yyyy";
        if (dateTimeText.Length != inputDateFormat.Length)
            result = logistics.DateTimeFromSequence;
        else
        {
            if (!DateTime.TryParseExact(dateTimeText, inputDateFormat, CultureInfo.InvariantCulture, DateTimeStyles.None, out DateTime dateTimeParsed))
                result = logistics.DateTimeFromSequence;
            else
            {
                if (dateTimeParsed < logistics.DateTimeFromSequence.AddDays(1) && dateTimeParsed > logistics.DateTimeFromSequence.AddDays(-1))
                    result = dateTimeParsed;
                else
                    result = logistics.DateTimeFromSequence;
            }
        }
        return result;
    }

    private void Parse(IFileRead fileRead, Logistics logistics, List<FileInfo> fileInfoCollection, string originalDataBioRad, ProcessData lastProcessData)
    {
        if (fileRead is null)
        { }
        _I = 0;
        _Data = string.Empty;
        List<Detail> details = new();
        string receivedData = File.ReadAllText(logistics.ReportFullPath);
        _Log.Debug($"****ParseData - Source file contents:");
        _Log.Debug(receivedData);
        string[] files = Directory.GetFiles(Path.GetDirectoryName(logistics.ReportFullPath), string.Concat(originalDataBioRad, logistics.Sequence, "*"), SearchOption.TopDirectoryOnly);
        foreach (string file in files)
            fileInfoCollection.Add(new FileInfo(file));
        // occasionally there are multiple blocks of results, get the last one as earlier ones may be aborted runs.
        int index = receivedData.LastIndexOf("Bio-Rad");
        if (index > -1)
            receivedData = receivedData.Substring(index);
        _Log.Debug($"****ParseData - Source file contents to be parsed:");
        _Log.Debug(receivedData);
        if (!string.IsNullOrEmpty(receivedData))
        {
            _I = 0;
            _Data = receivedData;
            Title = GetBefore("Recipe:");
            Recipe = GetToken();
            string dateTimeText = GetToEOL();
            if (dateTimeText.EndsWith("."))
                dateTimeText = dateTimeText.Remove(dateTimeText.Length - 1, 1);
            DateTime dateTime = GetDateTime(logistics, dateTimeText);
            Date = dateTime.ToString();
            ScanPast("operator:");
            Employee = GetBefore("batch:");
            Batch = GetToEOL();
            // Remove illegal characters \/:*?"<>| found in the Batch
            Batch = Regex.Replace(Batch, @"[\\,\/,\:,\*,\?,\"",\<,\>,\|]", "_").Split('\r')[0].Split('\n')[0];
            ScanPast("cassette:");
            Cassette = GetBefore("wafer:");
            if (string.IsNullOrEmpty(Batch))
            {
                _I = 0;
                _Data = receivedData;
                ScanPast("wafer:");
            }
            Wafer = GetToEOL();
            _ = GetToEOL();
            _ = GetToEOL();
            string token = GetToken();
            int counter = 1;
            while (true)
            {
                if (string.IsNullOrEmpty(token) || !char.IsDigit(token[0]))
                    break;
                Detail detail = new()
                {
                    Position = token,
                    Thickness = GetToken(),
                    UniqueId = string.Concat("_Point-", counter)
                };
                details.Add(detail);
                token = GetToken();
                counter++;
            }
            ScanPast("mean thickness =");
            MeanThickness = GetBefore(", std. dev =");
            StdDev = GetToken();
            PassFail = GetToEOL();
            ScanPast("thickness");
            RVThickness = GetToEOL();
        }

        if (string.IsNullOrEmpty(Wafer))
            throw new Exception("Wafer field is missing.");

        //parse out batch and validate
        string[] parsedBatch = Wafer.Split('-');
        if (parsedBatch.Length >= 1)
            Reactor = parsedBatch[0];
        if (parsedBatch.Length >= 2)
            RDS = parsedBatch[1];
        if (parsedBatch.Length >= 3)
        {
            string[] parsedPSN = parsedBatch[2].Split('.');
            if (parsedPSN.Length >= 1)
                PSN = parsedPSN[0];
            if (parsedPSN.Length >= 2)
                Layer = parsedPSN[1];
        }
        if (parsedBatch.Length >= 4)
            Zone = parsedBatch[3];

        JobID = logistics.JobID;

        if (logistics.DateTimeFromSequence > DateTime.Now.AddHours(-24))
        {
            if (string.IsNullOrEmpty(lastProcessData.Wafer))
            {
                lastProcessData.Batch = JobID;
                lastProcessData.Cassette = JobID;
                lastProcessData.Employee = JobID;
                lastProcessData.Recipe = JobID;
                lastProcessData.Title = JobID;
            }
            lastProcessData.Wafer = Wafer;
            lastProcessData.Reactor = Reactor;
            lastProcessData.RDS = RDS;

            string check = "--------";
            if (string.IsNullOrEmpty(Batch) || Batch.Contains(check))
                Batch = lastProcessData.Batch;
            else
                lastProcessData.Batch = Batch;
            if (string.IsNullOrEmpty(Cassette) || Cassette.Contains(check))
                Cassette = lastProcessData.Cassette;
            else
                lastProcessData.Cassette = Cassette;
            if (string.IsNullOrEmpty(Employee) || Employee.Contains(check))
                Employee = lastProcessData.Employee;
            else
                lastProcessData.Employee = Employee;
            if (string.IsNullOrEmpty(Recipe) || Recipe.Contains(check))
                Recipe = lastProcessData.Recipe;
            else
                lastProcessData.Recipe = Recipe;
            if (string.IsNullOrEmpty(Title) || Title.Contains(check))
                Title = lastProcessData.Title;
            else
                lastProcessData.Title = Title;
        }

        //fix title
        StringBuilder titleFixed = new();
        foreach (char c in Title)
        {
            if (char.IsLetterOrDigit(c) || c == '-' || c == '.')
                _ = titleFixed.Append(c);
        }
        Title = titleFixed.ToString();

        //fix wafer
        StringBuilder waferFixed = new();
        foreach (char c in Wafer)
        {
            if (char.IsLetterOrDigit(c) || c == '-' || c == '.')
                _ = waferFixed.Append(c);
        }
        Wafer = waferFixed.ToString();

        //create filename / unique id
        UniqueId = string.Concat(Title, '_', Wafer, '_', logistics.DateTimeFromSequence.ToString("yyyyMMddHHmmssffff"), '_', logistics.TotalSecondsSinceLastWriteTimeFromSequence);
        foreach (Detail detail in details)
        {
            detail.HeaderUniqueId = UniqueId;
            detail.UniqueId = string.Concat(UniqueId, detail.UniqueId);
        }

        //trace datatype
        _Log.Debug("BioRad parsed information:");
        _Log.Debug(string.Format("Batch: {0}", Batch));
        _Log.Debug(string.Format("Cassette: {0}", Cassette));
        _Log.Debug(string.Format("Date: {0}", Date));
        foreach (Detail bioRadDetail in details)
            _Log.Debug(string.Format("Details: {0} - {1}", bioRadDetail.Position, bioRadDetail.Thickness));
        _Log.Debug(string.Format("Mean Thickness: {0}", MeanThickness));
        _Log.Debug(string.Format("Operator: {0}", Employee));
        _Log.Debug(string.Format("Pass/Fail: {0}", PassFail));
        _Log.Debug(string.Format("Recipe: {0}", Recipe));
        _Log.Debug(string.Format("RV Thickness: {0}", RVThickness));
        _Log.Debug(string.Format("Std Dev: {0}", StdDev));
        _Log.Debug(string.Format("Title: {0}", Title));
        _Log.Debug(string.Format("Wafer: {0}", Wafer));
        fileInfoCollection.Add(new FileInfo(logistics.ReportFullPath));
        _Details.AddRange(details);
    }

    internal static List<Description> GetDescriptions(JsonElement[] jsonElements)
    {
        List<Description> results = new();
        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<Description>(jsonElement.ToString(), jsonSerializerOptions);
            results.Add(description);
        }
        return results;
    }

}