using Adaptation.Shared;
using Adaptation.Shared.Methods;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text.Json;

namespace Adaptation.FileHandlers.pcl;

public class Description : IDescription, Shared.Properties.IDescription
{

    public int Test { get; set; }
    public int Count { get; set; }
    public int Index { get; set; }
    //
    public string EventName { get; set; }
    public string NullData { get; set; }
    public string JobID { get; set; }
    public string Sequence { get; set; }
    public string MesEntity { get; set; }
    public string ReportFullPath { get; set; }
    public string ProcessJobID { get; set; }
    public string MID { get; set; }
    //
    public string Date { get; set; }
    public string Employee { get; set; }
    public string Lot { get; set; }
    public string PSN { get; set; }
    public string Reactor { get; set; }
    public string Recipe { get; set; }
    //
    public string Area { get; set; }
    public string Folder { get; set; }
    public string HeaderUniqueId { get; set; }
    public string Id { get; set; }
    public string Layer { get; set; }
    public string Model { get; set; }
    public string Pattern { get; set; }
    public string Phase { get; set; }
    public string Plan { get; set; }
    public string RampRate { get; set; }
    public string RDS { get; set; }
    public string SetupFile { get; set; }
    public string StartVoltage { get; set; }
    public string StopVoltage { get; set; }
    public string UniqueId { get; set; }
    public string Wafer { get; set; }
    public string WaferSize { get; set; }
    public string Zone { get; set; }
    //
    public string Ccomp { get; set; }
    public string CondType { get; set; }
    public string FlatZ { get; set; }
    public string FlatZMean { get; set; }
    public string FlatZRadialGradient { get; set; }
    public string FlatZStdDev { get; set; }
    public string GLimit { get; set; }
    public string Grade { get; set; }
    public string GradeMean { get; set; }
    public string GradeRadialGradient { get; set; }
    public string GradeStdDev { get; set; }
    public string NAvg { get; set; }
    public string NAvgMean { get; set; }
    public string NAvgRadialGradient { get; set; }
    public string NAvgStdDev { get; set; }
    public string Nsl { get; set; }
    public string NslMean { get; set; }
    public string NslRadialGradient { get; set; }
    public string NslStdDev { get; set; }
    public string PhaseMean { get; set; }
    public string PhaseRadialGradient { get; set; }
    public string PhaseStdDev { get; set; }
    public string RhoAvg { get; set; }
    public string RhoAvgMean { get; set; }
    public string RhoAvgRadialGradient { get; set; }
    public string RhoAvgStdDev { get; set; }
    public string RhoMethod { get; set; }
    public string Rhosl { get; set; }
    public string RhoslMean { get; set; }
    public string RhoslRadialGradient { get; set; }
    public string RhoslStdDev { get; set; }
    public string RsMean { get; set; }
    public string RsRadialGradient { get; set; }
    public string RsStdDev { get; set; }
    public string Vd { get; set; }
    public string VdMean { get; set; }
    public string VdRadialGradient { get; set; }
    public string VdStdDev { get; set; }

    string IDescription.GetEventDescription() => "File Has been read and parsed";

    List<string> IDescription.GetNames(IFileRead fileRead, Logistics logistics)
    {
        List<string> results = new();
        IDescription description = GetDefault(fileRead, logistics);
        string json = JsonSerializer.Serialize(description, description.GetType());
        object @object = JsonSerializer.Deserialize<object>(json);
        if (@object is not JsonElement jsonElement)
            throw new Exception();
        foreach (JsonProperty jsonProperty in jsonElement.EnumerateObject())
            results.Add(jsonProperty.Name);
        return results;
    }

    List<string> IDescription.GetDetailNames()
    {
        List<string> results = new()
        {
            nameof(Area),
            nameof(Folder),
            nameof(HeaderUniqueId),
            nameof(Id),
            nameof(Layer),
            nameof(Model),
            nameof(Pattern),
            nameof(Phase),
            nameof(Plan),
            nameof(RampRate),
            nameof(RDS),
            nameof(SetupFile),
            nameof(StartVoltage),
            nameof(StopVoltage),
            nameof(UniqueId),
            nameof(Wafer),
            nameof(WaferSize),
            nameof(Zone)
        };
        return results;
    }

    List<string> IDescription.GetHeaderNames()
    {
        List<string> results = new()
        {
            nameof(Date),
            nameof(Employee),
            nameof(Lot),
            nameof(PSN),
            nameof(Reactor),
            nameof(Recipe)
        };
        return results;
    }

    IDescription IDescription.GetDisplayNames()
    {
        Description result = GetDisplayNames();
        return result;
    }

    List<string> IDescription.GetParameterNames()
    {
        List<string> results = new()
        {
            nameof(Ccomp),
            nameof(CondType),
            nameof(FlatZ),
            nameof(FlatZMean),
            nameof(FlatZRadialGradient),
            nameof(FlatZStdDev),
            nameof(GLimit),
            nameof(Grade),
            nameof(GradeMean),
            nameof(GradeRadialGradient),
            nameof(GradeStdDev),
            nameof(NAvg),
            nameof(NAvgMean),
            nameof(NAvgRadialGradient),
            nameof(NAvgStdDev),
            nameof(Nsl),
            nameof(NslMean),
            nameof(NslRadialGradient),
            nameof(NslStdDev),
            nameof(PhaseMean),
            nameof(PhaseRadialGradient),
            nameof(PhaseStdDev),
            nameof(RhoAvg),
            nameof(RhoAvgMean),
            nameof(RhoAvgRadialGradient),
            nameof(RhoAvgStdDev),
            nameof(RhoMethod),
            nameof(Rhosl),
            nameof(RhoslMean),
            nameof(RhoslRadialGradient),
            nameof(RhoslStdDev),
            nameof(RsMean),
            nameof(RsRadialGradient),
            nameof(RsStdDev),
            nameof(Vd),
            nameof(VdMean),
            nameof(VdRadialGradient),
            nameof(VdStdDev)
        };
        return results;
    }

    JsonProperty[] IDescription.GetDefault(IFileRead fileRead, Logistics logistics)
    {
        JsonProperty[] results;
        IDescription description = GetDefault(fileRead, logistics);
        string json = JsonSerializer.Serialize(description, description.GetType());
        object @object = JsonSerializer.Deserialize<object>(json);
        results = ((JsonElement)@object).EnumerateObject().ToArray();
        return results;
    }

    List<string> IDescription.GetPairedParameterNames()
    {
        List<string> results = new();
        return results;
    }

    List<string> IDescription.GetIgnoreParameterNames(Test test)
    {
        List<string> results = new();
        return results;
    }

    IDescription IDescription.GetDefaultDescription(IFileRead fileRead, Logistics logistics)
    {
        Description result = GetDefault(fileRead, logistics);
        return result;
    }

    Dictionary<string, string> IDescription.GetDisplayNamesJsonElement(IFileRead fileRead)
    {
        Dictionary<string, string> results = new();
        IDescription description = GetDisplayNames();
        string json = JsonSerializer.Serialize(description, description.GetType());
        JsonElement jsonElement = JsonSerializer.Deserialize<JsonElement>(json);
        foreach (JsonProperty jsonProperty in jsonElement.EnumerateObject())
        {
            if (!results.ContainsKey(jsonProperty.Name))
                results.Add(jsonProperty.Name, string.Empty);
            if (jsonProperty.Value is JsonElement jsonPropertyValue)
                results[jsonProperty.Name] = jsonPropertyValue.ToString();
        }
        return results;
    }

    List<IDescription> IDescription.GetDescriptions(IFileRead fileRead, Logistics logistics, List<Test> tests, IProcessData iProcessData)
    {
        List<IDescription> results = new();
        if (iProcessData is null || !iProcessData.Details.Any() || iProcessData is not ProcessData processData)
            results.Add(GetDefault(fileRead, logistics));
        else
        {
            string nullData;
            Description description;
            object configDataNullData = fileRead.NullData;
            if (configDataNullData is null)
                nullData = string.Empty;
            else
                nullData = configDataNullData.ToString();
            for (int i = 0; i < iProcessData.Details.Count; i++)
            {
                if (iProcessData.Details[i] is not Detail detail)
                    continue;
                description = new Description
                {
                    Test = (int)tests[i],
                    Count = tests.Count,
                    Index = i,
                    //
                    EventName = fileRead.EventName,
                    NullData = nullData,
                    JobID = fileRead.CellInstanceName,
                    Sequence = logistics.Sequence.ToString(),
                    MesEntity = logistics.MesEntity,
                    ReportFullPath = logistics.ReportFullPath,
                    ProcessJobID = logistics.ProcessJobID,
                    MID = logistics.MID,
                    //
                    Date = processData.Date,
                    Employee = processData.Employee,
                    Lot = processData.Lot,
                    PSN = processData.PSN,
                    Reactor = processData.Reactor,
                    Recipe = string.Empty,
                    //
                    Area = processData.Area,
                    Folder = processData.Folder,
                    HeaderUniqueId = detail.UniqueId,
                    Id = string.Empty,
                    Layer = processData.Layer,
                    Model = processData.Model,
                    Pattern = processData.Pattern,
                    Phase = detail.Phase,
                    Plan = processData.Plan,
                    RampRate = processData.RampRate,
                    RDS = processData.RDS,
                    SetupFile = processData.SetupFile,
                    StartVoltage = processData.StartVoltage,
                    StopVoltage = processData.StopVoltage,
                    UniqueId = detail.UniqueId,
                    Wafer = processData.Wafer,
                    WaferSize = processData.WaferSize,
                    Zone = processData.Zone,
                    //
                    Ccomp = processData.Ccomp,
                    CondType = processData.CondType,
                    FlatZ = detail.FlatZ,
                    FlatZMean = processData.FlatZMean,
                    FlatZRadialGradient = processData.FlatZRadialGradient,
                    FlatZStdDev = processData.FlatZStdDev,
                    GLimit = processData.GLimit,
                    Grade = detail.Grade,
                    GradeMean = processData.GradeMean,
                    GradeRadialGradient = processData.GradeRadialGradient,
                    GradeStdDev = processData.GradeStdDev,
                    NAvg = detail.NAvg,
                    NAvgMean = processData.NAvgMean,
                    NAvgRadialGradient = processData.NAvgRadialGradient,
                    NAvgStdDev = processData.NAvgStdDev,
                    Nsl = detail.Nsl,
                    NslMean = processData.NslMean,
                    NslRadialGradient = processData.NslRadialGradient,
                    NslStdDev = processData.NslStdDev,
                    PhaseMean = processData.PhaseMean,
                    PhaseRadialGradient = processData.PhaseRadialGradient,
                    PhaseStdDev = processData.PhaseStdDev,
                    RhoAvg = detail.RhoAvg,
                    RhoAvgMean = processData.RhoAvgMean,
                    RhoAvgRadialGradient = processData.RhoAvgRadialGradient,
                    RhoAvgStdDev = processData.RhoAvgStdDev,
                    RhoMethod = processData.RhoMethod,
                    Rhosl = detail.Rhosl,
                    RhoslMean = processData.RhoslMean,
                    RhoslRadialGradient = processData.RhoslRadialGradient,
                    RhoslStdDev = processData.RhoslStdDev,
                    RsMean = processData.RsMean,
                    RsRadialGradient = processData.RsRadialGradient,
                    RsStdDev = processData.RsStdDev,
                    Vd = detail.Vd,
                    VdMean = processData.VdMean,
                    VdRadialGradient = processData.VdRadialGradient,
                    VdStdDev = processData.VdStdDev
                };
                results.Add(description);
            }
        }
        return results;
    }

    private static Description GetDisplayNames()
    {
        Description result = new();
        return result;
    }

    private Description GetDefault(IFileRead fileRead, Logistics logistics)
    {
        Description result = new()
        {
            Test = -1,
            Count = 0,
            Index = -1,
            //
            EventName = fileRead.EventName,
            NullData = fileRead.NullData,
            JobID = fileRead.CellInstanceName,
            Sequence = logistics.Sequence.ToString(),
            MesEntity = fileRead.MesEntity,
            ReportFullPath = logistics.ReportFullPath,
            ProcessJobID = logistics.ProcessJobID,
            MID = logistics.MID,
            //
            Date = nameof(Date),
            Employee = nameof(Employee),
            Lot = nameof(Lot),
            PSN = nameof(PSN),
            Reactor = nameof(Reactor),
            Recipe = nameof(Recipe),
            //
            Area = nameof(Area),
            Folder = nameof(Folder),
            HeaderUniqueId = nameof(HeaderUniqueId),
            Id = nameof(Id),
            Layer = nameof(Layer),
            Model = nameof(Model),
            Pattern = nameof(Pattern),
            Phase = nameof(Phase),
            Plan = nameof(Plan),
            RampRate = nameof(RampRate),
            RDS = nameof(RDS),
            SetupFile = nameof(SetupFile),
            StartVoltage = nameof(StartVoltage),
            StopVoltage = nameof(StopVoltage),
            UniqueId = nameof(UniqueId),
            Wafer = nameof(Wafer),
            WaferSize = nameof(WaferSize),
            Zone = nameof(Zone),
            //
            Ccomp = nameof(Ccomp),
            CondType = nameof(CondType),
            FlatZ = nameof(FlatZ),
            FlatZMean = nameof(FlatZMean),
            FlatZRadialGradient = nameof(FlatZRadialGradient),
            FlatZStdDev = nameof(FlatZStdDev),
            GLimit = nameof(GLimit),
            Grade = nameof(Grade),
            GradeMean = nameof(GradeMean),
            GradeRadialGradient = nameof(GradeRadialGradient),
            GradeStdDev = nameof(GradeStdDev),
            NAvg = nameof(NAvg),
            NAvgMean = nameof(NAvgMean),
            NAvgRadialGradient = nameof(NAvgRadialGradient),
            NAvgStdDev = nameof(NAvgStdDev),
            Nsl = nameof(Nsl),
            NslMean = nameof(NslMean),
            NslRadialGradient = nameof(NslRadialGradient),
            NslStdDev = nameof(NslStdDev),
            PhaseMean = nameof(PhaseMean),
            PhaseRadialGradient = nameof(PhaseRadialGradient),
            PhaseStdDev = nameof(PhaseStdDev),
            RhoAvg = nameof(RhoAvg),
            RhoAvgMean = nameof(RhoAvgMean),
            RhoAvgRadialGradient = nameof(RhoAvgRadialGradient),
            RhoAvgStdDev = nameof(RhoAvgStdDev),
            RhoMethod = nameof(RhoMethod),
            Rhosl = nameof(Rhosl),
            RhoslMean = nameof(RhoslMean),
            RhoslRadialGradient = nameof(RhoslRadialGradient),
            RhoslStdDev = nameof(RhoslStdDev),
            RsMean = nameof(RsMean),
            RsRadialGradient = nameof(RsRadialGradient),
            RsStdDev = nameof(RsStdDev),
            Vd = nameof(Vd),
            VdMean = nameof(VdMean),
            VdRadialGradient = nameof(VdRadialGradient),
            VdStdDev = nameof(VdStdDev),
        };
        return result;
    }

}