ProcessOutputReader.cs

//--------------------------------------------------//
// Created by basicx-StrgV                          //
// https://github.com/basicx-StrgV/                 //
//--------------------------------------------------//
using System;
using System.Collections.Generic;
using System.Text;
using WGetNET.Builder;
using WGetNET.Extensions;
using WGetNET.Helper;
using WGetNET.Models;
 
namespace WGetNET.Components.Internal
{
    internal static class ProcessOutputReader
    {
        //---To Package List------------------------------------------------------------------------------------------
        public static List<WinGetPackage> ToPackageList(string[] output, PackageAction action = PackageAction.Default, string? sourceName = null)
        {
            //Get top line index.
            //The array should always contain this line.
            //If it dose not contain this line the resulting out of range exception,
            //that will be thrown later, will be catched in the calling method.
            int labelLine = output.GetEntryContains("------") - 1;
 
            if (labelLine < 0)
            {
                // Output does not contain any entries
                return new List<WinGetPackage>();
            }
 
            int[] columnList = GetColumnList(output[labelLine]);
 
            //Remove unneeded output Lines
            output = output.RemoveRange(0, labelLine + 2);
 
            return CreatePackageListFromOutput(output, columnList, action, sourceName);
        }
 
        private static List<WinGetPackage> CreatePackageListFromOutput(string[] output, int[] columnList, PackageAction action = PackageAction.Default, string? sourceName = null)
        {
            List<WinGetPackage> resultList = new();
 
            if (columnList.Length < 3)
            {
                return resultList;
            }
 
            WinGetPackageBuilder builder = new();
 
            for (int i = 0; i < output.Length; i++)
            {
                builder.Clear();
 
                // Stop parsing the output when the end of the list is reached.
#if NETCOREAPP3_1_OR_GREATER
                if (string.IsNullOrWhiteSpace(output[i]) || output[i].Length < columnList[^1])
                {
                    break;
                }
#elif NETSTANDARD2_0
                if (string.IsNullOrWhiteSpace(output[i]) || output[i].Length < columnList[columnList.Length - 1])
                {
                    break;
                }
#endif
 
#if NETCOREAPP3_1_OR_GREATER
                builder.AddId(output[i][columnList[1]..columnList[2]].Trim());
#elif NETSTANDARD2_0
                builder.AddId(output[i].Substring(columnList[1], (columnList[2] - columnList[1])).Trim());
#endif
 
#if NETCOREAPP3_1_OR_GREATER
                builder.AddName(output[i][columnList[0]..columnList[1]].Trim());
#elif NETSTANDARD2_0
                builder.AddName(output[i].Substring(columnList[0], (columnList[1] - columnList[0])).Trim());
#endif
 
                //Set version info depending on the column count.
                if (columnList.Length > 3)
                {
#if NETCOREAPP3_1_OR_GREATER
                    builder.AddVersion(output[i][columnList[2]..columnList[3]].Trim());
                    builder.AddAvailableVersion(output[i][columnList[2]..columnList[3]].Trim());
#elif NETSTANDARD2_0
                    builder.AddVersion(output[i].Substring(columnList[2], (columnList[3] - columnList[2])).Trim());
                    builder.AddAvailableVersion(output[i].Substring(columnList[2], (columnList[3] - columnList[2])).Trim());
#endif
                }
                else
                {
#if NETCOREAPP3_1_OR_GREATER
                    builder.AddVersion(output[i][columnList[2]..].Trim());
                    builder.AddAvailableVersion(output[i][columnList[2]..].Trim());
#elif NETSTANDARD2_0
                    builder.AddVersion(output[i].Substring(columnList[2]).Trim());
                    builder.AddAvailableVersion(output[i].Substring(columnList[2]).Trim());
#endif
                }
 
                //Set information, depending on the action and the column count.
                if ((action == PackageAction.UpgradeList || action == PackageAction.InstalledList || action == PackageAction.Search) && columnList.Length >= 5)
                {
#if NETCOREAPP3_1_OR_GREATER
                    string availableVersion = output[i][columnList[3]..columnList[4]].Trim();
#elif NETSTANDARD2_0
                    string availableVersion = output[i].Substring(columnList[3], (columnList[4] - columnList[3])).Trim();
#endif
                    if (!string.IsNullOrWhiteSpace(availableVersion) && action != PackageAction.Search)
                    {
                        builder.AddAvailableVersion(availableVersion);
                    }
 
#if NETCOREAPP3_1_OR_GREATER
                    builder.AddSourceName(output[i][columnList[4]..].Trim());
#elif NETSTANDARD2_0
                    builder.AddSourceName(output[i].Substring(columnList[4]).Trim());
#endif
                }
                else if ((action == PackageAction.InstalledList || action == PackageAction.Search) && columnList.Length == 4)
                {
#if NETCOREAPP3_1_OR_GREATER
                    builder.AddSourceName(output[i][columnList[3]..].Trim());
#elif NETSTANDARD2_0
                    builder.AddSourceName(output[i].Substring(columnList[3]).Trim());
#endif
                }
                else if ((action == PackageAction.SearchBySource || action == PackageAction.InstalledListBySource)
                    && sourceName != null && !string.IsNullOrWhiteSpace(sourceName))
                {
                    // "sourceName" source name cant't be null here because of the following check "!string.IsNullOrWhiteSpace(sourceName)".
                    // But .NET Standard 2.0 thinks it knows better (Or I'm stupid). Therefore a second null check comes befor it.
                    builder.AddSourceName(sourceName);
                }
 
                resultList.Add(builder.GetInstance());
            }
 
            // Check for secondery list in output.
            if (output.GetEntryContains("------") != -1)
            {
                List<WinGetPackage> seconderyList = ToPackageList(output, action);
                resultList.AddRange(seconderyList);
            }
 
            return resultList;
        }
        //------------------------------------------------------------------------------------------------------------
 
        //---To Pinned Package List-----------------------------------------------------------------------------------
        public static List<WinGetPinnedPackage> ToPinnedPackageList(string[] output)
        {
            //Get top line index.
            //The array should always contain this line.
            //If it dose not contain this line the resulting out of range exception,
            //that will be thrown later, will be catched in the calling method.
            int labelLine = output.GetEntryContains("------") - 1;
 
            if (labelLine < 0)
            {
                // Output does not contain any entries
                return new List<WinGetPinnedPackage>();
            }
 
            int[] columnList = GetColumnList(output[labelLine], true);
 
            //Remove unneeded output Lines
            output = output.RemoveRange(0, labelLine + 2);
 
            return CreatePinnedPackageListFromOutput(output, columnList);
        }
 
        private static List<WinGetPinnedPackage> CreatePinnedPackageListFromOutput(string[] output, int[] columnList)
        {
            List<WinGetPinnedPackage> resultList = new();
 
            if (columnList.Length < 3)
            {
                return resultList;
            }
 
            WinGetPinnedPackageBuilder builder = new();
 
            for (int i = 0; i < output.Length; i++)
            {
                builder.Clear();
 
                // Stop parsing the output when the end of the list is reached.
#if NETCOREAPP3_1_OR_GREATER
                if (string.IsNullOrWhiteSpace(output[i]) || output[i].Length < columnList[^1])
                {
                    break;
                }
#elif NETSTANDARD2_0
                if (string.IsNullOrWhiteSpace(output[i]) || output[i].Length < columnList[columnList.Length - 1])
                {
                    break;
                }
#endif
 
#if NETCOREAPP3_1_OR_GREATER
                builder.AddName(output[i][columnList[0]..columnList[1]].Trim());
                builder.AddId(output[i][columnList[1]..columnList[2]].Trim());
                builder.AddVersion(output[i][columnList[2]..columnList[3]].Trim());
                builder.AddSourceName(output[i][columnList[3]..columnList[4]].Trim());
 
#elif NETSTANDARD2_0
                builder.AddName(output[i].Substring(columnList[0], (columnList[1] - columnList[0])).Trim());
                builder.AddId(output[i].Substring(columnList[1], (columnList[2] - columnList[1])).Trim());
                builder.AddVersion(output[i].Substring(columnList[2], (columnList[3] - columnList[2])).Trim());
                builder.AddSourceName(output[i].Substring(columnList[3], (columnList[4] - columnList[3])).Trim());
#endif
 
                // Workaround for getting the pin data from the output.
                // The normal method will not work, because "Pin type" and "Pinned version" contain spaces.
#if NETCOREAPP3_1_OR_GREATER
                string pinInfoString = output[i][columnList[4]..].TrimStart();
#elif NETSTANDARD2_0
                string pinInfoString = output[i].Substring(columnList[4]).TrimStart();
#endif
                int endOfTypeIndex = -1;
                for (int j = 0; j < pinInfoString.Length; j++)
                {
                    if (pinInfoString[j] == (char)32)
                    {
                        endOfTypeIndex = j;
                        break;
                    }
                }
 
#if NETCOREAPP3_1_OR_GREATER
                if (endOfTypeIndex == -1)
                {
                    builder.AddPinType(pinInfoString.Trim());
                }
                else
                {
                    builder.AddPinType(pinInfoString[0..endOfTypeIndex].Trim());
                    builder.AddPinnedVersion(pinInfoString[endOfTypeIndex..].Trim());
                }
#elif NETSTANDARD2_0
                if (endOfTypeIndex == -1)
                {
                    builder.AddPinType(pinInfoString.Trim());
                }
                else
                {
                    builder.AddPinType(pinInfoString.Substring(0, endOfTypeIndex).Trim());
                    builder.AddPinnedVersion(pinInfoString.Substring(endOfTypeIndex));
                }
#endif
                // End of workaround
 
                resultList.Add(builder.GetInstance());
            }
 
            // Check for secondery list in output.
            if (output.GetEntryContains("------") != -1)
            {
                List<WinGetPinnedPackage> seconderyList = ToPinnedPackageList(output);
                resultList.AddRange(seconderyList);
            }
 
            return resultList;
        }
        //------------------------------------------------------------------------------------------------------------
 
        //---To Source List-------------------------------------------------------------------------------------------
        public static List<WinGetSource> ToSourceList(string[] output)
        {
            List<WinGetSource> sourceList = new();
 
            for (int i = 0; i < output.Length; i++)
            {
                SourceModel? source =
                    JsonHelper.StringToObject<SourceModel>(output[i]);
 
                if (source != null)
                {
                    sourceList.Add(WinGetSource.FromSourceModel(source));
                }
            }
 
            return sourceList;
        }
        //------------------------------------------------------------------------------------------------------------
 
        //---To WinGet info-------------------------------------------------------------------------------------------
        public static WinGetInfo ToWingetInfo(string[] output, InfoActionVersionId actionVersionId)
        {
            if (output.Length <= 0)
            {
                return WinGetInfo.Empty;
            }
 
            return ReadDataByRange(output, actionVersionId);
        }
 
        private static string ReadVersionFromData(string[] output)
        {
            string version = string.Empty;
 
            string[] versionLineContent = output[0].Split((char)32);
            for (int i = 0; i < versionLineContent.Length; i++)
            {
#if NETCOREAPP3_1_OR_GREATER
                if (versionLineContent[i].Trim().StartsWith('v'))
                {
                    version = versionLineContent[i].Trim()[1..];
                    break;
                }
#elif NETSTANDARD2_0
                if (versionLineContent[i].Trim().StartsWith("v"))
                {
                    version = versionLineContent[i].Trim().Substring(1);
                    break;
                }
#endif
            }
 
            return version;
        }
 
        private static WinGetInfo ReadDataByRange(string[] output, InfoActionVersionId actionVersionId)
        {
            return actionVersionId switch
            {
                InfoActionVersionId.VersionRange1 => ReadDataForRange1(output),
                InfoActionVersionId.VersionRange2 => ReadDataForRange2(output),
                InfoActionVersionId.VersionRange3 => ReadDataForRange3(output),
                InfoActionVersionId.VersionRange4 => ReadDataForRange4(output),
                _ => WinGetInfo.Empty,
            };
        }
 
        private static WinGetInfo ReadDataForRange1(string[] output)
        {
            WinGetInfoBuilder builder = new();
 
            string version = ReadVersionFromData(output);
 
            if (string.IsNullOrWhiteSpace(version))
            {
                // Return if version number could not be determined, because the outupt is probably not correct.
                return WinGetInfo.Empty;
            }
 
            builder.AddVersion(version);
 
            // Logs directory
            builder.AddDirectory(ReadSingleDirectoryEntry(output, 7));
 
            // Remove unnasesary range from output
            output = output.RemoveRange(0, 11);
 
            builder.AddLinks(ReadLinks(output));
 
            return builder.GetInstance();
        }
 
        private static WinGetInfo ReadDataForRange2(string[] output)
        {
            WinGetInfoBuilder builder = new();
 
            string version = ReadVersionFromData(output);
 
            if (string.IsNullOrWhiteSpace(version))
            {
                // Return if version number could not be determined, because the outupt is probably not correct.
                return WinGetInfo.Empty;
            }
 
            builder.AddVersion(version);
 
            // Logs directory
            builder.AddDirectory(ReadSingleDirectoryEntry(output, 7));
 
            // User Settings directory
            builder.AddDirectory(ReadSingleDirectoryEntry(output, 9));
 
            // Remove unnasesary range from output
            output = output.RemoveRange(0, 13);
 
            builder.AddLinks(ReadLinks(output));
 
            return builder.GetInstance();
        }
 
        private static WinGetInfo ReadDataForRange3(string[] output)
        {
            WinGetInfoBuilder builder = new();
 
            string version = ReadVersionFromData(output);
 
            if (string.IsNullOrWhiteSpace(version))
            {
                // Return if version number could not be determined, because the outupt is probably not correct.
                return WinGetInfo.Empty;
            }
 
            builder.AddVersion(version);
 
            // Logs directory
            builder.AddDirectory(ReadSingleDirectoryEntry(output, 7));
 
            // User Settings directory
            builder.AddDirectory(ReadSingleDirectoryEntry(output, 9));
 
            // Remove unnasesary range from output
            output = output.RemoveRange(0, 13);
 
            builder.AddLinks(ReadLinks(output));
 
            // Remove links area and admin settings header range from output
            output = output.RemoveRange(0, output.GetEntryContains("----") + 1);
 
            builder.AddAdminOptions(ReadAdminSettings(output));
 
            return builder.GetInstance();
        }
 
        private static WinGetInfo ReadDataForRange4(string[] output)
        {
            WinGetInfoBuilder builder = new();
 
            string version = ReadVersionFromData(output);
 
            if (string.IsNullOrWhiteSpace(version))
            {
                // Return if version number could not be determined, because the outupt is probably not correct.
                return WinGetInfo.Empty;
            }
 
            builder.AddVersion(version);
 
            // Remove unnasesary range from output
            output = output.RemoveRange(0, 9);
 
            builder.AddDirectories(ReadDirectories(output));
 
            // Remove directories area and links header range from output
            output = output.RemoveRange(0, output.GetEntryContains("----") + 1);
 
            builder.AddLinks(ReadLinks(output));
 
            // Remove links area and admin settings header range from output
            output = output.RemoveRange(0, output.GetEntryContains("----") + 1);
 
            builder.AddAdminOptions(ReadAdminSettings(output));
 
            return builder.GetInstance();
        }
 
        private static WinGetDirectory? ReadSingleDirectoryEntry(string[] output, int index)
        {
            string[] entry = output[index].Split(':');
            if (entry.Length == 2)
            {
                WinGetDirectoryBuilder builder = new();
 
                builder.AddEntryName(entry[0].Trim());
                builder.AddRawContent(entry[1].Trim());
 
                return builder.GetInstance();
            }
            return null;
        }
 
        private static List<WinGetDirectory> ReadDirectories(string[] output)
        {
            List<WinGetDirectory> directories = new();
 
            StringBuilder nameBuilder = new();
            StringBuilder contentBuilder = new();
 
            WinGetDirectoryBuilder directoryBuilder = new();
 
            for (int i = 0; i < output.Length; i++)
            {
                directoryBuilder.Clear();
 
                if (string.IsNullOrWhiteSpace(output[i]))
                {
                    break;
                }
 
                string[] directoryEntry = output[i].Split((char)32).RemoveEmptyEntries();
 
                nameBuilder.Clear();
                int startOfDirectory = 0;
                for (int j = 0; j < directoryEntry.Length; j++)
                {
#if NETCOREAPP3_1_OR_GREATER
                    if (directoryEntry[j].StartsWith('%') || directoryEntry[j].Contains(":\\"))
                    {
                        // Start of the directory reached, stop building name.
                        startOfDirectory = j;
                        break;
                    }
#elif NETSTANDARD2_0
                    if (directoryEntry[j].StartsWith("%") || directoryEntry[j].Contains(":\\"))
                    {
                        // Start of the directory reached, stop building name.
                        startOfDirectory = j;
                        break;
                    }
#endif
 
                    if (j > 0)
                    {
                        // Add a space in front of every part of the name that comes after the first on.
                        nameBuilder.Append((char)32);
                    }
 
                    nameBuilder.Append(directoryEntry[j].Trim());
                }
 
                directoryBuilder.AddEntryName(nameBuilder.ToString());
 
                directoryEntry = directoryEntry.RemoveRange(0, startOfDirectory);
 
                contentBuilder.Clear();
                for (int j = 0; j < directoryEntry.Length; j++)
                {
                    if (j > 0)
                    {
                        // Add a space in front of every part of the directory that comes after the first on.
                        contentBuilder.Append((char)32);
                    }
 
                    contentBuilder.Append(directoryEntry[j].Trim());
                }
 
                directoryBuilder.AddRawContent(contentBuilder.ToString());
 
                WinGetDirectory? winGetDirectory = directoryBuilder.GetInstance();
                if (winGetDirectory != null)
                {
                    directories.Add(winGetDirectory);
                }
            }
 
            return directories;
        }
 
        private static List<WinGetLink> ReadLinks(string[] output)
        {
            List<WinGetLink> links = new();
 
            StringBuilder nameBuilder = new();
 
            WinGetLinkBuilder linkBuilder = new();
 
            for (int i = 0; i < output.Length; i++)
            {
                linkBuilder.Clear();
 
                if (string.IsNullOrWhiteSpace(output[i]))
                {
                    break;
                }
 
                string[] linksEntry = output[i].Split((char)32).RemoveEmptyEntries();
 
#if NETCOREAPP3_1_OR_GREATER
                linkBuilder.AddRawContent(linksEntry[^1].Trim());
#elif NETSTANDARD2_0
                linkBuilder.AddRawContent(linksEntry[linksEntry.Length - 1].Trim());
#endif
 
                // Remove link from entry, so it only contains the name
                linksEntry = linksEntry.RemoveRange(linksEntry.Length - 1, 1);
 
                nameBuilder.Clear();
                for (int j = 0; j < linksEntry.Length; j++)
                {
                    if (j > 0)
                    {
                        // Add a space in front of every part of the name that comes after the first on.
                        nameBuilder.Append((char)32);
                    }
                    nameBuilder.Append(linksEntry[j].Trim());
                }
 
                linkBuilder.AddEntryName(nameBuilder.ToString());
 
                WinGetLink? winGetLink = linkBuilder.GetInstance();
                if (winGetLink != null)
                {
                    links.Add(winGetLink);
                }
            }
 
            return links;
        }
 
        private static List<WinGetAdminSetting> ReadAdminSettings(string[] output)
        {
            List<WinGetAdminSetting> adminSetting = new();
 
            WinGetAdminSettingBuilder adminOptionBuilder = new();
 
            for (int i = 0; i < output.Length; i++)
            {
                adminOptionBuilder.Clear();
 
                if (string.IsNullOrWhiteSpace(output[i]))
                {
                    break;
                }
 
                string[] settingsEntry = output[i].Split((char)32).RemoveEmptyEntries();
 
                if (settingsEntry.Length == 2)
                {
                    adminOptionBuilder.AddEntryName(settingsEntry[0].Trim());
                    adminOptionBuilder.AddRawContent(settingsEntry[1].Trim());
 
                    WinGetAdminSetting? adminOption = adminOptionBuilder.GetInstance();
                    if (adminOption != null)
                    {
                        adminSetting.Add(adminOption);
                    }
                }
            }
 
            return adminSetting;
        }
        //------------------------------------------------------------------------------------------------------------
 
        //---To Hash--------------------------------------------------------------------------------------------------
        public static string ResultToHash(ProcessResult result)
        {
            string hash = "";
 
#if NETCOREAPP3_1_OR_GREATER
            if (result.Output.Length > 0 && result.Output[0].Contains(':'))
            {
                string[] splitOutput = result.Output[0].Split(':');
                if (splitOutput.Length >= 2)
                {
                    hash = splitOutput[1].Trim();
                }
            }
#elif NETSTANDARD2_0
            if (result.Output.Length > 0 && result.Output[0].Contains(":"))
            {
                string[] splitOutput = result.Output[0].Split(':');
                if (splitOutput.Length >= 2)
                {
                    hash = splitOutput[1].Trim();
                }
            }
#endif
 
            return hash;
        }
        //------------------------------------------------------------------------------------------------------------
 
        //---Other----------------------------------------------------------------------------------------------------
        public static string ExportOutputToString(ProcessResult result)
        {
            if (result.Success)
            {
                StringBuilder outputBuilder = new();
                foreach (string line in result.Output)
                {
                    outputBuilder.Append(line);
                }
 
                return outputBuilder.ToString().Trim();
            }
            else
            {
                return string.Empty;
            }
        }
        //------------------------------------------------------------------------------------------------------------
 
        //---Helper---------------------------------------------------------------------------------------------------
        private static int[] GetColumnList(string line, bool isPinnedPackageTable = false)
        {
            int[] columns = Array.Empty<int>();
 
            bool checkForColumn = true;
            for (int i = 0; i < line.Length; i++)
            {
                if (isPinnedPackageTable && columns.Length >= 5)
                {
                    // Workaround for the pinned package table
                    break;
                }
 
                if (line[i] != ((char)32) && checkForColumn)
                {
                    columns = columns.Add(i);
                    checkForColumn = false;
                }
                else if (line[i] == ((char)32))
                {
                    checkForColumn = true;
                }
            }
 
            return columns;
        }
        //------------------------------------------------------------------------------------------------------------
    }
}