WinGetPackageManager.cs

//--------------------------------------------------//
// Created by basicx-StrgV                          //
// https://github.com/basicx-StrgV/                 //
//--------------------------------------------------//
using System;
using System.Collections.Generic;
using System.IO;
using System.Threading;
using System.Threading.Tasks;
using WGetNET.Components.Internal;
using WGetNET.Exceptions;
using WGetNET.Helper;
using WGetNET.Models;
 
namespace WGetNET
{
    public class WinGetPackageManager : WinGet
    {
        private readonly Version _downloadMinVersion = new(1, 6, 0);
        private readonly Version _repairMinVersion = new(1, 7, 0);
        private readonly Version _pinMinVersion = new(1, 5, 0);
 
        public WinGetPackageManager()
        {
            // Provide empty constructor for xlm docs
        }
 
        //---Search------------------------------------------------------------------------------------
        public List<WinGetPackage> SearchPackage(string packageId, bool exact = false)
        {
            ArgsHelper.ThrowIfStringIsNullOrWhiteSpace(packageId, "packageId");
 
            WinGetArguments cmd = WinGetArguments.Search().Query(packageId).AcceptSourceAgreements();
 
            if (exact)
            {
                cmd.Exact();
            }
 
            ProcessResult result = Execute(cmd);
 
            return ProcessOutputReader.ToPackageList(result.Output, PackageAction.Search);
        }
 
        public List<WinGetPackage> SearchPackage(string packageId, string sourceName, bool exact = false)
        {
            ArgsHelper.ThrowIfStringIsNullOrWhiteSpace(packageId, "packageId");
            ArgsHelper.ThrowIfStringIsNullOrWhiteSpace(sourceName, "sourceName");
 
            WinGetArguments cmd = WinGetArguments.Search().Query(packageId).Source(sourceName).AcceptSourceAgreements();
 
            if (exact)
            {
                cmd.Exact();
            }
 
            ProcessResult result = Execute(cmd);
 
            return ProcessOutputReader.ToPackageList(result.Output, PackageAction.SearchBySource, sourceName);
        }
 
        public async Task<List<WinGetPackage>> SearchPackageAsync(string packageId, bool exact = false, CancellationToken cancellationToken = default)
        {
            ArgsHelper.ThrowIfStringIsNullOrWhiteSpace(packageId, "packageId");
 
            WinGetArguments cmd = WinGetArguments.Search().Query(packageId).AcceptSourceAgreements();
 
            if (exact)
            {
                cmd.Exact();
            }
 
            ProcessResult result = await ExecuteAsync(cmd, false, cancellationToken);
 
            // Return empty list if the task was cancled
            if (cancellationToken.IsCancellationRequested)
            {
                return new List<WinGetPackage>();
            }
 
            return ProcessOutputReader.ToPackageList(result.Output, PackageAction.Search);
        }
 
        public async Task<List<WinGetPackage>> SearchPackageAsync(string packageId, string sourceName, bool exact = false, CancellationToken cancellationToken = default)
        {
            ArgsHelper.ThrowIfStringIsNullOrWhiteSpace(packageId, "packageId");
            ArgsHelper.ThrowIfStringIsNullOrWhiteSpace(sourceName, "sourceName");
 
            WinGetArguments cmd = WinGetArguments.Search().Query(packageId).Source(sourceName).AcceptSourceAgreements();
 
            if (exact)
            {
                cmd.Exact();
            }
 
            ProcessResult result = await ExecuteAsync(cmd, false, cancellationToken);
 
            // Return empty list if the task was cancled
            if (cancellationToken.IsCancellationRequested)
            {
                return new List<WinGetPackage>();
            }
 
            return ProcessOutputReader.ToPackageList(result.Output, PackageAction.SearchBySource, sourceName);
        }
        //---------------------------------------------------------------------------------------------
 
        //---List--------------------------------------------------------------------------------------
        public List<WinGetPackage> GetInstalledPackages()
        {
            ProcessResult result = Execute(WinGetArguments.List().AcceptSourceAgreements());
 
            return ProcessOutputReader.ToPackageList(result.Output, PackageAction.InstalledList);
        }
 
        public List<WinGetPackage> GetInstalledPackages(string packageId, bool exact = false)
        {
            ArgsHelper.ThrowIfStringIsNullOrWhiteSpace(packageId, "packageId");
 
            WinGetArguments cmd = WinGetArguments.List().Query(packageId).AcceptSourceAgreements();
 
            if (exact)
            {
                cmd.Exact();
            }
 
            ProcessResult result = Execute(cmd);
 
            return ProcessOutputReader.ToPackageList(result.Output, PackageAction.InstalledList);
        }
 
        public List<WinGetPackage> GetInstalledPackages(string packageId, string sourceName, bool exact = false)
        {
            ArgsHelper.ThrowIfStringIsNullOrWhiteSpace(packageId, "packageId");
            ArgsHelper.ThrowIfStringIsNullOrWhiteSpace(sourceName, "sourceName");
 
            WinGetArguments cmd = WinGetArguments.List().Query(packageId).Source(sourceName).AcceptSourceAgreements();
 
            if (exact)
            {
                cmd.Exact();
            }
 
            ProcessResult result = Execute(cmd);
 
            return ProcessOutputReader.ToPackageList(result.Output, PackageAction.InstalledListBySource, sourceName);
        }
 
        public async Task<List<WinGetPackage>> GetInstalledPackagesAsync(CancellationToken cancellationToken = default)
        {
            ProcessResult result = await ExecuteAsync(WinGetArguments.List().AcceptSourceAgreements(), false, cancellationToken);
 
            // Return empty list if the task was cancled
            if (cancellationToken.IsCancellationRequested)
            {
                return new List<WinGetPackage>();
            }
 
            return ProcessOutputReader.ToPackageList(result.Output, PackageAction.InstalledList);
        }
 
        public async Task<List<WinGetPackage>> GetInstalledPackagesAsync(string packageId, bool exact = false, CancellationToken cancellationToken = default)
        {
            ArgsHelper.ThrowIfStringIsNullOrWhiteSpace(packageId, "packageId");
 
            WinGetArguments cmd = WinGetArguments.List().Query(packageId).AcceptSourceAgreements();
 
            if (exact)
            {
                cmd.Exact();
            }
 
            ProcessResult result = await ExecuteAsync(cmd, false, cancellationToken);
 
            // Return empty list if the task was cancled
            if (cancellationToken.IsCancellationRequested)
            {
                return new List<WinGetPackage>();
            }
 
            return ProcessOutputReader.ToPackageList(result.Output, PackageAction.InstalledList);
        }
 
        public async Task<List<WinGetPackage>> GetInstalledPackagesAsync(string packageId, string sourceName, bool exact = false, CancellationToken cancellationToken = default)
        {
            ArgsHelper.ThrowIfStringIsNullOrWhiteSpace(packageId, "packageId");
            ArgsHelper.ThrowIfStringIsNullOrWhiteSpace(sourceName, "sourceName");
 
            WinGetArguments cmd = WinGetArguments.List().Query(packageId).Source(sourceName).AcceptSourceAgreements();
 
            if (exact)
            {
                cmd.Exact();
            }
 
            ProcessResult result = await ExecuteAsync(cmd, false, cancellationToken);
 
            // Return empty list if the task was cancled
            if (cancellationToken.IsCancellationRequested)
            {
                return new List<WinGetPackage>();
            }
 
            return ProcessOutputReader.ToPackageList(result.Output, PackageAction.InstalledListBySource, sourceName);
        }
 
        public WinGetPackage? GetExactInstalledPackage(string packageId)
        {
            ArgsHelper.ThrowIfStringIsNullOrWhiteSpace(packageId, "packageId");
 
            ProcessResult result = Execute(WinGetArguments.List().AcceptSourceAgreements());
 
            return PackageHelper.MatchExact(
                ProcessOutputReader.ToPackageList(result.Output, PackageAction.InstalledList),
                packageId.Trim()
            );
        }
 
        public WinGetPackage? GetExactInstalledPackage(string packageId, string sourceName)
        {
            ArgsHelper.ThrowIfStringIsNullOrWhiteSpace(packageId, "packageId");
            ArgsHelper.ThrowIfStringIsNullOrWhiteSpace(sourceName, "sourceName");
 
            ProcessResult result = Execute(WinGetArguments.List().Query(packageId).Source(sourceName).AcceptSourceAgreements());
 
            return PackageHelper.MatchExact(
                ProcessOutputReader.ToPackageList(result.Output, PackageAction.InstalledList),
                packageId.Trim()
            );
        }
 
        public async Task<WinGetPackage?> GetExactInstalledPackageAsync(string packageId, CancellationToken cancellationToken = default)
        {
            ArgsHelper.ThrowIfStringIsNullOrWhiteSpace(packageId, "packageId");
 
            ProcessResult result = await ExecuteAsync(WinGetArguments.List().AcceptSourceAgreements(), false, cancellationToken);
 
            // Return null if the task was cancled
            if (cancellationToken.IsCancellationRequested)
            {
                return null;
            }
 
            return PackageHelper.MatchExact(
                ProcessOutputReader.ToPackageList(result.Output, PackageAction.InstalledList),
                packageId.Trim()
            );
        }
 
        public async Task<WinGetPackage?> GetExactInstalledPackageAsync(string packageId, string sourceName, CancellationToken cancellationToken = default)
        {
            ArgsHelper.ThrowIfStringIsNullOrWhiteSpace(packageId, "packageId");
            ArgsHelper.ThrowIfStringIsNullOrWhiteSpace(sourceName, "sourceName");
 
            ProcessResult result =
                await ExecuteAsync(
                    WinGetArguments.List().Query(packageId).Source(sourceName).AcceptSourceAgreements(),
                    false, cancellationToken);
 
            // Return null if the task was cancled
            if (cancellationToken.IsCancellationRequested)
            {
                return null;
            }
 
            return PackageHelper.MatchExact(
                ProcessOutputReader.ToPackageList(result.Output, PackageAction.InstalledList),
                packageId.Trim()
            );
        }
        //---------------------------------------------------------------------------------------------
 
        //---Install-----------------------------------------------------------------------------------
        public bool InstallPackage(string packageId)
        {
            ArgsHelper.ThrowIfStringIsNullOrWhiteSpace(packageId, "packageId");
 
            ProcessResult result = Execute(WinGetArguments.Install().Query(packageId).AcceptSourceAgreements().AcceptPackageAgreements());
 
            return result.Success;
        }
 
        public bool InstallPackage(string packageId, bool silent)
        {
            ArgsHelper.ThrowIfStringIsNullOrWhiteSpace(packageId, "packageId");
 
            WinGetArguments cmd = WinGetArguments.Install().Query(packageId).AcceptSourceAgreements().AcceptPackageAgreements();
 
            if (silent)
            {
                cmd.Silent();
            }
 
            ProcessResult result = Execute(cmd);
 
            return result.Success;
        }
 
        public bool InstallPackage(WinGetPackage package)
        {
            ArgsHelper.ThrowIfWinGetObjectIsNullOrEmpty(package, "package");
 
            if (package.HasShortenedId || package.HasNoId)
            {
                return InstallPackage(package.Name);
            }
 
            return InstallPackage(package.Id);
        }
 
        public bool InstallPackage(WinGetPackage package, bool silent)
        {
            ArgsHelper.ThrowIfWinGetObjectIsNullOrEmpty(package, "package");
 
            if (package.HasShortenedId || package.HasNoId)
            {
                return InstallPackage(package.Name, silent);
            }
 
            return InstallPackage(package.Id, silent);
        }
 
        public async Task<bool> InstallPackageAsync(string packageId, CancellationToken cancellationToken = default)
        {
            ArgsHelper.ThrowIfStringIsNullOrWhiteSpace(packageId, "packageId");
 
            ProcessResult result =
                await ExecuteAsync(
                    WinGetArguments.Install().Query(packageId).AcceptSourceAgreements().AcceptPackageAgreements(),
                    false, cancellationToken);
 
            return result.Success;
        }
 
        public async Task<bool> InstallPackageAsync(string packageId, bool silent, CancellationToken cancellationToken = default)
        {
            ArgsHelper.ThrowIfStringIsNullOrWhiteSpace(packageId, "packageId");
 
            WinGetArguments cmd = WinGetArguments.Install().Query(packageId).AcceptSourceAgreements().AcceptPackageAgreements();
 
            if (silent)
            {
                cmd.Silent();
            }
 
            ProcessResult result = await ExecuteAsync(cmd, false, cancellationToken);
 
            return result.Success;
        }
 
        public async Task<bool> InstallPackageAsync(WinGetPackage package, CancellationToken cancellationToken = default)
        {
            ArgsHelper.ThrowIfWinGetObjectIsNullOrEmpty(package, "package");
 
            if (package.HasShortenedId || package.HasNoId)
            {
                return await InstallPackageAsync(package.Name, cancellationToken);
            }
 
            return await InstallPackageAsync(package.Id, cancellationToken);
        }
 
        public async Task<bool> InstallPackageAsync(WinGetPackage package, bool silent, CancellationToken cancellationToken = default)
        {
            ArgsHelper.ThrowIfWinGetObjectIsNullOrEmpty(package, "package");
 
            if (package.HasShortenedId || package.HasNoId)
            {
                return await InstallPackageAsync(package.Name, silent, cancellationToken);
            }
 
            return await InstallPackageAsync(package.Id, silent, cancellationToken);
        }
        //---------------------------------------------------------------------------------------------
 
        //---Uninstall---------------------------------------------------------------------------------
        public bool UninstallPackage(string packageId)
        {
            ArgsHelper.ThrowIfStringIsNullOrWhiteSpace(packageId, "packageId");
 
            ProcessResult result = Execute(WinGetArguments.Uninstall().Query(packageId));
 
            return result.Success;
        }
 
        public bool UninstallPackage(string packageId, bool silent)
        {
            ArgsHelper.ThrowIfStringIsNullOrWhiteSpace(packageId, "packageId");
 
            WinGetArguments cmd = WinGetArguments.Uninstall().Query(packageId);
 
            if (silent)
            {
                cmd.Silent();
            }
 
            ProcessResult result = Execute(cmd);
 
            return result.Success;
        }
 
        public bool UninstallPackage(WinGetPackage package)
        {
            ArgsHelper.ThrowIfWinGetObjectIsNullOrEmpty(package, "package");
 
            if (package.HasShortenedId || package.HasNoId)
            {
                return UninstallPackage(package.Name);
            }
 
            return UninstallPackage(package.Id);
        }
 
        public bool UninstallPackage(WinGetPackage package, bool silent)
        {
            ArgsHelper.ThrowIfWinGetObjectIsNullOrEmpty(package, "package");
 
            if (package.HasShortenedId || package.HasNoId)
            {
                return UninstallPackage(package.Name, silent);
            }
 
            return UninstallPackage(package.Id, silent);
        }
 
        public async Task<bool> UninstallPackageAsync(string packageId, CancellationToken cancellationToken = default)
        {
            ArgsHelper.ThrowIfStringIsNullOrWhiteSpace(packageId, "packageId");
 
            ProcessResult result = await ExecuteAsync(WinGetArguments.Uninstall().Query(packageId), false, cancellationToken);
 
            return result.Success;
        }
 
        public async Task<bool> UninstallPackageAsync(string packageId, bool silent, CancellationToken cancellationToken = default)
        {
            ArgsHelper.ThrowIfStringIsNullOrWhiteSpace(packageId, "packageId");
 
            WinGetArguments cmd = WinGetArguments.Uninstall().Query(packageId);
 
            if (silent)
            {
                cmd.Silent();
            }
 
            ProcessResult result =
                await ExecuteAsync(cmd, false, cancellationToken);
 
            return result.Success;
        }
 
        public async Task<bool> UninstallPackageAsync(WinGetPackage package, CancellationToken cancellationToken = default)
        {
            ArgsHelper.ThrowIfWinGetObjectIsNullOrEmpty(package, "package");
 
            if (package.HasShortenedId || package.HasNoId)
            {
                return await UninstallPackageAsync(package.Name, cancellationToken);
            }
 
            return await UninstallPackageAsync(package.Id, cancellationToken);
        }
 
        public async Task<bool> UninstallPackageAsync(WinGetPackage package, bool silent, CancellationToken cancellationToken = default)
        {
            ArgsHelper.ThrowIfWinGetObjectIsNullOrEmpty(package, "package");
 
            if (package.HasShortenedId || package.HasNoId)
            {
                return await UninstallPackageAsync(package.Name, silent, cancellationToken);
            }
 
            return await UninstallPackageAsync(package.Id, silent, cancellationToken);
        }
        //---------------------------------------------------------------------------------------------
 
        //---List Upgrades-----------------------------------------------------------------------------
        public List<WinGetPackage> GetUpgradeablePackages()
        {
            WinGetArguments cmd =
                IncludeUnknownbyVersion(
                    WinGetArguments.Upgrade().AcceptSourceAgreements());
 
            ProcessResult result = Execute(cmd);
 
            return ProcessOutputReader.ToPackageList(result.Output, PackageAction.UpgradeList);
        }
 
        public async Task<List<WinGetPackage>> GetUpgradeablePackagesAsync(CancellationToken cancellationToken = default)
        {
            WinGetArguments cmd =
                IncludeUnknownbyVersion(
                    WinGetArguments.Upgrade().AcceptSourceAgreements());
 
            ProcessResult result = await ExecuteAsync(cmd, false, cancellationToken);
 
            // Return empty list if the task was cancled
            if (cancellationToken.IsCancellationRequested)
            {
                return new List<WinGetPackage>();
            }
 
            return ProcessOutputReader.ToPackageList(result.Output, PackageAction.UpgradeList);
        }
        //---------------------------------------------------------------------------------------------
 
        //---Upgrade-----------------------------------------------------------------------------------
        public bool UpgradePackage(string packageId)
        {
            ArgsHelper.ThrowIfStringIsNullOrWhiteSpace(packageId, "packageId");
 
            ProcessResult result = Execute(WinGetArguments.Upgrade().Query(packageId).AcceptSourceAgreements().AcceptPackageAgreements());
 
            return result.Success;
        }
 
        public bool UpgradePackage(string packageId, bool silent)
        {
            ArgsHelper.ThrowIfStringIsNullOrWhiteSpace(packageId, "packageId");
 
            WinGetArguments cmd = WinGetArguments.Upgrade().Query(packageId).AcceptSourceAgreements().AcceptPackageAgreements();
 
            if (silent)
            {
                cmd.Silent();
            }
 
            ProcessResult result = Execute(cmd);
 
            return result.Success;
        }
 
        public bool UpgradePackage(WinGetPackage package)
        {
            ArgsHelper.ThrowIfWinGetObjectIsNullOrEmpty(package, "package");
 
            if (package.HasShortenedId || package.HasNoId)
            {
                return UpgradePackage(package.Name);
            }
 
            return UpgradePackage(package.Id);
        }
 
        public bool UpgradePackage(WinGetPackage package, bool silent)
        {
            ArgsHelper.ThrowIfWinGetObjectIsNullOrEmpty(package, "package");
 
            if (package.HasShortenedId || package.HasNoId)
            {
                return UpgradePackage(package.Name, silent);
            }
 
            return UpgradePackage(package.Id, silent);
        }
 
        public async Task<bool> UpgradePackageAsync(string packageId, CancellationToken cancellationToken = default)
        {
            ArgsHelper.ThrowIfStringIsNullOrWhiteSpace(packageId, "packageId");
 
            ProcessResult result =
                await ExecuteAsync(
                    WinGetArguments.Upgrade().Query(packageId).AcceptSourceAgreements().AcceptPackageAgreements(),
                    false, cancellationToken);
 
            return result.Success;
        }
 
        public async Task<bool> UpgradePackageAsync(string packageId, bool silent, CancellationToken cancellationToken = default)
        {
            ArgsHelper.ThrowIfStringIsNullOrWhiteSpace(packageId, "packageId");
 
            WinGetArguments cmd = WinGetArguments.Upgrade().Query(packageId).AcceptSourceAgreements().AcceptPackageAgreements();
 
            if (silent)
            {
                cmd.Silent();
            }
 
            ProcessResult result = await ExecuteAsync(cmd, false, cancellationToken);
 
            return result.Success;
        }
 
        public async Task<bool> UpgradePackageAsync(WinGetPackage package, CancellationToken cancellationToken = default)
        {
            ArgsHelper.ThrowIfWinGetObjectIsNullOrEmpty(package, "package");
 
            if (package.HasShortenedId || package.HasNoId)
            {
                return await UpgradePackageAsync(package.Name, cancellationToken);
            }
 
            return await UpgradePackageAsync(package.Id, cancellationToken);
        }
 
        public async Task<bool> UpgradePackageAsync(WinGetPackage package, bool silent, CancellationToken cancellationToken = default)
        {
            ArgsHelper.ThrowIfWinGetObjectIsNullOrEmpty(package, "package");
 
            if (package.HasShortenedId || package.HasNoId)
            {
                return await UpgradePackageAsync(package.Name, silent, cancellationToken);
            }
 
            return await UpgradePackageAsync(package.Id, silent, cancellationToken);
        }
 
        public bool UpgradeAllPackages()
        {
            ProcessResult result = Execute(WinGetArguments.Upgrade().All().AcceptSourceAgreements().AcceptPackageAgreements());
 
            return result.Success;
        }
 
        public bool UpgradeAllPackages(bool silent)
        {
            WinGetArguments cmd = WinGetArguments.Upgrade().All().AcceptSourceAgreements().AcceptPackageAgreements();
 
            if (silent)
            {
                cmd.Silent();
            }
 
            ProcessResult result = Execute(cmd);
 
            return result.Success;
        }
 
        public async Task<bool> UpgradeAllPackagesAsync(CancellationToken cancellationToken = default)
        {
            ProcessResult result =
                await ExecuteAsync(
                    WinGetArguments.Upgrade().All().AcceptSourceAgreements().AcceptPackageAgreements(),
                    false, cancellationToken);
 
            return result.Success;
        }
 
        public async Task<bool> UpgradeAllPackagesAsync(bool silent, CancellationToken cancellationToken = default)
        {
            WinGetArguments cmd = WinGetArguments.Upgrade().All().AcceptSourceAgreements().AcceptPackageAgreements();
 
            if (silent)
            {
                cmd.Silent();
            }
 
            ProcessResult result = await ExecuteAsync(cmd, false, cancellationToken);
 
            return result.Success;
        }
        //---------------------------------------------------------------------------------------------
 
        //---Repair------------------------------------------------------------------------------------
        public bool RepairPackage(string packageId)
        {
            if (!CheckWinGetVersion(_repairMinVersion))
            {
                throw new WinGetFeatureNotSupportedException(_repairMinVersion);
            }
 
            ArgsHelper.ThrowIfStringIsNullOrWhiteSpace(packageId, "packageId");
 
            ProcessResult result = Execute(WinGetArguments.Repair().Query(packageId).AcceptSourceAgreements().AcceptPackageAgreements());
 
            return result.Success;
        }
 
        public bool RepairPackage(string packageId, bool silent)
        {
            if (!CheckWinGetVersion(_repairMinVersion))
            {
                throw new WinGetFeatureNotSupportedException(_repairMinVersion);
            }
 
            ArgsHelper.ThrowIfStringIsNullOrWhiteSpace(packageId, "packageId");
 
            WinGetArguments cmd = WinGetArguments.Repair().Query(packageId).AcceptSourceAgreements().AcceptPackageAgreements();
 
            if (silent)
            {
                cmd.Silent();
            }
 
            ProcessResult result = Execute(cmd);
 
            return result.Success;
        }
 
        public bool RepairPackage(WinGetPackage package)
        {
            ArgsHelper.ThrowIfWinGetObjectIsNullOrEmpty(package, "package");
 
            if (package.HasShortenedId || package.HasNoId)
            {
                return RepairPackage(package.Name);
            }
 
            return RepairPackage(package.Id);
        }
 
        public bool RepairPackage(WinGetPackage package, bool silent)
        {
            ArgsHelper.ThrowIfWinGetObjectIsNullOrEmpty(package, "package");
 
            if (package.HasShortenedId || package.HasNoId)
            {
                return RepairPackage(package.Name, silent);
            }
 
            return RepairPackage(package.Id, silent);
        }
 
        public async Task<bool> RepairPackageAsync(string packageId, CancellationToken cancellationToken = default)
        {
            if (!CheckWinGetVersion(_repairMinVersion))
            {
                throw new WinGetFeatureNotSupportedException(_repairMinVersion);
            }
 
            ArgsHelper.ThrowIfStringIsNullOrWhiteSpace(packageId, "packageId");
 
            ProcessResult result =
                await ExecuteAsync(
                    WinGetArguments
                    .Repair()
                    .Query(packageId)
                    .AcceptSourceAgreements()
                    .AcceptPackageAgreements(),
                    false, cancellationToken);
 
            return result.Success;
        }
 
        public async Task<bool> RepairPackageAsync(string packageId, bool silent, CancellationToken cancellationToken = default)
        {
            if (!CheckWinGetVersion(_repairMinVersion))
            {
                throw new WinGetFeatureNotSupportedException(_repairMinVersion);
            }
 
            ArgsHelper.ThrowIfStringIsNullOrWhiteSpace(packageId, "packageId");
 
            WinGetArguments cmd = WinGetArguments.Repair().Query(packageId).AcceptSourceAgreements().AcceptPackageAgreements();
 
            if (silent)
            {
                cmd.Silent();
            }
 
            ProcessResult result = await ExecuteAsync(cmd, false, cancellationToken);
 
            return result.Success;
        }
 
        public async Task<bool> RepairPackageAsync(WinGetPackage package, CancellationToken cancellationToken = default)
        {
            ArgsHelper.ThrowIfWinGetObjectIsNullOrEmpty(package, "package");
 
            if (package.HasShortenedId || package.HasNoId)
            {
                return await RepairPackageAsync(package.Name, cancellationToken);
            }
 
            return await RepairPackageAsync(package.Id, cancellationToken);
        }
 
        public async Task<bool> RepairPackageAsync(WinGetPackage package, bool silent, CancellationToken cancellationToken = default)
        {
            ArgsHelper.ThrowIfWinGetObjectIsNullOrEmpty(package, "package");
 
            if (package.HasShortenedId || package.HasNoId)
            {
                return await RepairPackageAsync(package.Name, silent, cancellationToken);
            }
 
            return await RepairPackageAsync(package.Id, silent, cancellationToken);
        }
        //---------------------------------------------------------------------------------------------
 
        //---Export and Import-------------------------------------------------------------------------
        public bool ExportPackagesToFile(string file)
        {
            ArgsHelper.ThrowIfStringIsNullOrWhiteSpace(file, "file");
 
            ProcessResult result = Execute(WinGetArguments.Export().File(file).AcceptSourceAgreements());
 
            return result.Success;
        }
 
        public async Task<bool> ExportPackagesToFileAsync(string file, CancellationToken cancellationToken = default)
        {
            ArgsHelper.ThrowIfStringIsNullOrWhiteSpace(file, "file");
 
            ProcessResult result =
                await ExecuteAsync(WinGetArguments.Export().File(file).AcceptSourceAgreements(), false, cancellationToken);
 
            return result.Success;
        }
 
        public bool ImportPackagesFromFile(string file)
        {
            ArgsHelper.ThrowIfStringIsNullOrWhiteSpace(file, "file");
 
            ProcessResult result =
                Execute(
                    WinGetArguments
                    .Import()
                    .File(file)
                    .IgnoreUnavailable()
                    .AcceptSourceAgreements()
                    .AcceptPackageAgreements());
 
            return result.Success;
        }
 
        public async Task<bool> ImportPackagesFromFileAsync(string file, CancellationToken cancellationToken = default)
        {
            ArgsHelper.ThrowIfStringIsNullOrWhiteSpace(file, "file");
 
            ProcessResult result =
                await ExecuteAsync(
                    WinGetArguments
                    .Import()
                    .File(file)
                    .IgnoreUnavailable()
                    .AcceptSourceAgreements()
                    .AcceptPackageAgreements(),
                    false, cancellationToken);
 
            return result.Success;
        }
        //---------------------------------------------------------------------------------------------
 
        //---Hash--------------------------------------------------------------------------------------
        public string Hash(string file)
        {
            ArgsHelper.ThrowIfStringIsNullOrWhiteSpace(file, "file");
 
            if (!File.Exists(file))
            {
                throw new FileNotFoundException($"Unable to find the specified file. File:'{file}'");
            }
 
            ProcessResult result = Execute(WinGetArguments.Hash().File(file));
 
            if (!result.Success)
            {
                return string.Empty;
            }
 
            return ProcessOutputReader.ResultToHash(result);
        }
 
        public string Hash(FileInfo file)
        {
            ArgsHelper.ThrowIfObjectIsNull(file, "file");
 
            if (!file.Exists)
            {
                throw new FileNotFoundException($"Unable to find the specified file. File:'{file.FullName}'");
            }
 
            return Hash(file.FullName);
        }
 
        public async Task<string> HashAsync(string file, CancellationToken cancellationToken = default)
        {
            ArgsHelper.ThrowIfStringIsNullOrWhiteSpace(file, "file");
 
            if (!File.Exists(file))
            {
                throw new FileNotFoundException($"Unable to find the specified file. File:'{file}'");
            }
 
            ProcessResult result = await ExecuteAsync(WinGetArguments.Hash().File(file), false, cancellationToken);
 
            if (!result.Success || cancellationToken.IsCancellationRequested)
            {
                return string.Empty;
            }
 
            return ProcessOutputReader.ResultToHash(result);
        }
 
        public async Task<string> HashAsync(FileInfo file, CancellationToken cancellationToken = default)
        {
            ArgsHelper.ThrowIfObjectIsNull(file, "file");
 
            if (!file.Exists)
            {
                throw new FileNotFoundException($"Unable to find the specified file. File:'{file.FullName}'");
            }
 
            return await HashAsync(file.FullName, cancellationToken);
        }
        //---------------------------------------------------------------------------------------------
 
        //---Download----------------------------------------------------------------------------------
        public bool Download(string packageId, string directory)
        {
            if (!CheckWinGetVersion(_downloadMinVersion))
            {
                throw new WinGetFeatureNotSupportedException(_downloadMinVersion);
            }
 
            ArgsHelper.ThrowIfStringIsNullOrWhiteSpace(packageId, "packageId");
            ArgsHelper.ThrowIfStringIsNullOrWhiteSpace(directory, "directory");
 
            ProcessResult result =
                Execute(
                    WinGetArguments
                    .Download()
                    .Query(packageId)
                    .Directory(directory)
                    .AcceptSourceAgreements()
                    .AcceptPackageAgreements());
 
            return result.Success;
        }
 
        public bool Download(string packageId, DirectoryInfo directory)
        {
            ArgsHelper.ThrowIfObjectIsNull(directory, "directory");
 
            return Download(packageId, directory.FullName);
        }
 
        public bool Download(WinGetPackage package, string directory)
        {
            ArgsHelper.ThrowIfWinGetObjectIsNullOrEmpty(package, "package");
 
            if (package.HasShortenedId || package.HasNoId)
            {
                return Download(package.Name, directory);
            }
 
            return Download(package.Id, directory);
        }
 
        public bool Download(WinGetPackage package, DirectoryInfo directory)
        {
            ArgsHelper.ThrowIfWinGetObjectIsNullOrEmpty(package, "package");
            ArgsHelper.ThrowIfObjectIsNull(directory, "directory");
 
            if (package.HasShortenedId || package.HasNoId)
            {
                return Download(package.Name, directory.FullName);
            }
 
            return Download(package.Id, directory.FullName);
        }
 
        public async Task<bool> DownloadAsync(string packageId, string directory, CancellationToken cancellationToken = default)
        {
            if (!CheckWinGetVersion(_downloadMinVersion))
            {
                throw new WinGetFeatureNotSupportedException(_downloadMinVersion);
            }
 
            ArgsHelper.ThrowIfStringIsNullOrWhiteSpace(packageId, "packageId");
            ArgsHelper.ThrowIfStringIsNullOrWhiteSpace(directory, "directory");
 
            ProcessResult result =
                await ExecuteAsync(
                    WinGetArguments
                    .Download()
                    .Query(packageId)
                    .Directory(directory)
                    .AcceptSourceAgreements()
                    .AcceptPackageAgreements(),
                    false, cancellationToken);
 
            return result.Success;
        }
 
        public async Task<bool> DownloadAsync(string packageId, DirectoryInfo directory, CancellationToken cancellationToken = default)
        {
            ArgsHelper.ThrowIfObjectIsNull(directory, "directory");
 
            return await DownloadAsync(packageId, directory.FullName, cancellationToken);
        }
 
        public async Task<bool> DownloadAsync(WinGetPackage package, string directory, CancellationToken cancellationToken = default)
        {
            ArgsHelper.ThrowIfWinGetObjectIsNullOrEmpty(package, "package");
 
            if (package.HasShortenedId || package.HasNoId)
            {
                return await DownloadAsync(package.Name, directory, cancellationToken);
            }
 
            return await DownloadAsync(package.Id, directory, cancellationToken);
        }
 
        public async Task<bool> DownloadAsync(WinGetPackage package, DirectoryInfo directory, CancellationToken cancellationToken = default)
        {
            ArgsHelper.ThrowIfWinGetObjectIsNullOrEmpty(package, "package");
            ArgsHelper.ThrowIfObjectIsNull(directory, "directory");
 
            if (package.HasShortenedId || package.HasNoId)
            {
                return await DownloadAsync(package.Name, directory.FullName, cancellationToken);
            }
 
            return await DownloadAsync(package.Id, directory.FullName, cancellationToken);
        }
        //---------------------------------------------------------------------------------------------
 
        //---Pin List----------------------------------------------------------------------------------
        public List<WinGetPinnedPackage> GetPinnedPackages()
        {
            if (!CheckWinGetVersion(_pinMinVersion))
            {
                throw new WinGetFeatureNotSupportedException(_pinMinVersion);
            }
 
            ProcessResult result = Execute(WinGetArguments.PinList());
 
            return ProcessOutputReader.ToPinnedPackageList(result.Output);
        }
 
        public async Task<List<WinGetPinnedPackage>> GetPinnedPackagesAsync(CancellationToken cancellationToken = default)
        {
            if (!CheckWinGetVersion(_pinMinVersion))
            {
                throw new WinGetFeatureNotSupportedException(_pinMinVersion);
            }
 
            ProcessResult result = await ExecuteAsync(WinGetArguments.PinList(), false, cancellationToken);
 
            // Return empty list if the task was cancled
            if (cancellationToken.IsCancellationRequested)
            {
                return new List<WinGetPinnedPackage>();
            }
 
            return ProcessOutputReader.ToPinnedPackageList(result.Output);
        }
        //---------------------------------------------------------------------------------------------
 
        //---Pin Add-----------------------------------------------------------------------------------
        public bool PinAdd(string packageId, bool blocking = false)
        {
            if (!CheckWinGetVersion(_pinMinVersion))
            {
                throw new WinGetFeatureNotSupportedException(_pinMinVersion);
            }
 
            ArgsHelper.ThrowIfStringIsNullOrWhiteSpace(packageId, "packageId");
 
            WinGetArguments cmd = WinGetArguments.PinAdd().Query(packageId);
 
            if (blocking)
            {
                cmd.Blocking();
            }
 
            ProcessResult result = Execute(cmd);
 
            return result.Success;
        }
 
        public bool PinAdd(string packageId, string version)
        {
            if (!CheckWinGetVersion(_pinMinVersion))
            {
                throw new WinGetFeatureNotSupportedException(_pinMinVersion);
            }
 
            ArgsHelper.ThrowIfStringIsNullOrWhiteSpace(packageId, "packageId");
            ArgsHelper.ThrowIfStringIsNullOrWhiteSpace(version, "version");
 
            ProcessResult result = Execute(WinGetArguments.PinAdd().Query(packageId).Version(version));
 
            return result.Success;
        }
 
        public bool PinAdd(WinGetPackage package, bool blocking = false)
        {
            ArgsHelper.ThrowIfWinGetObjectIsNullOrEmpty(package, "package");
 
            if (package.HasShortenedId || package.HasNoId)
            {
                return PinAdd(package.Name, blocking);
            }
 
            return PinAdd(package.Id, blocking);
        }
 
        public bool PinAdd(WinGetPackage package, string version)
        {
            ArgsHelper.ThrowIfWinGetObjectIsNullOrEmpty(package, "package");
 
            if (package.HasShortenedId || package.HasNoId)
            {
                return PinAdd(package.Name, version);
            }
 
            return PinAdd(package.Id, version);
        }
 
        public async Task<bool> PinAddAsync(string packageId, bool blocking = false, CancellationToken cancellationToken = default)
        {
            if (!CheckWinGetVersion(_pinMinVersion))
            {
                throw new WinGetFeatureNotSupportedException(_pinMinVersion);
            }
 
            ArgsHelper.ThrowIfStringIsNullOrWhiteSpace(packageId, "packageId");
 
            WinGetArguments cmd = WinGetArguments.PinAdd().Query(packageId);
 
            if (blocking)
            {
                cmd.Blocking();
            }
 
            ProcessResult result = await ExecuteAsync(cmd, false, cancellationToken);
 
            return result.Success;
        }
 
        public async Task<bool> PinAddAsync(string packageId, string version, CancellationToken cancellationToken = default)
        {
            if (!CheckWinGetVersion(_pinMinVersion))
            {
                throw new WinGetFeatureNotSupportedException(_pinMinVersion);
            }
 
            ArgsHelper.ThrowIfStringIsNullOrWhiteSpace(packageId, "packageId");
            ArgsHelper.ThrowIfStringIsNullOrWhiteSpace(version, "version");
 
            ProcessResult result = await ExecuteAsync(WinGetArguments.PinAdd().Query(packageId).Version(version), false, cancellationToken);
 
            return result.Success;
        }
 
        public async Task<bool> PinAddAsync(WinGetPackage package, bool blocking = false, CancellationToken cancellationToken = default)
        {
            ArgsHelper.ThrowIfWinGetObjectIsNullOrEmpty(package, "package");
 
            if (package.HasShortenedId || package.HasNoId)
            {
                return await PinAddAsync(package.Name, blocking, cancellationToken);
            }
 
            return await PinAddAsync(package.Id, blocking, cancellationToken);
        }
 
        public async Task<bool> PinAddAsync(WinGetPackage package, string version, CancellationToken cancellationToken = default)
        {
            ArgsHelper.ThrowIfWinGetObjectIsNullOrEmpty(package, "package");
 
            if (package.HasShortenedId || package.HasNoId)
            {
                return await PinAddAsync(package.Name, version, cancellationToken);
            }
 
            return await PinAddAsync(package.Id, version, cancellationToken);
        }
 
        public bool PinAddInstalled(string packageId, bool blocking = false)
        {
            if (!CheckWinGetVersion(_pinMinVersion))
            {
                throw new WinGetFeatureNotSupportedException(_pinMinVersion);
            }
 
            ArgsHelper.ThrowIfStringIsNullOrWhiteSpace(packageId, "packageId");
 
            WinGetArguments cmd = WinGetArguments.PinAdd().Query(packageId).Installed();
 
            if (blocking)
            {
                cmd.Blocking();
            }
 
            ProcessResult result = Execute(cmd);
 
            return result.Success;
        }
 
        public bool PinAddInstalled(string packageId, string version)
        {
            if (!CheckWinGetVersion(_pinMinVersion))
            {
                throw new WinGetFeatureNotSupportedException(_pinMinVersion);
            }
 
            ArgsHelper.ThrowIfStringIsNullOrWhiteSpace(packageId, "packageId");
            ArgsHelper.ThrowIfStringIsNullOrWhiteSpace(version, "version");
 
            ProcessResult result = Execute(WinGetArguments.PinAdd().Query(packageId).Installed().Version(version));
 
            return result.Success;
        }
 
        public bool PinAddInstalled(WinGetPackage package, bool blocking = false)
        {
            ArgsHelper.ThrowIfWinGetObjectIsNullOrEmpty(package, "package");
 
            if (package.HasShortenedId || package.HasNoId)
            {
                return PinAddInstalled(package.Name, blocking);
            }
 
            return PinAddInstalled(package.Id, blocking);
        }
 
        public bool PinAddInstalled(WinGetPackage package, string version)
        {
            ArgsHelper.ThrowIfWinGetObjectIsNullOrEmpty(package, "package");
 
            if (package.HasShortenedId || package.HasNoId)
            {
                return PinAddInstalled(package.Name, version);
            }
 
            return PinAddInstalled(package.Id, version);
        }
 
        public async Task<bool> PinAddInstalledAsync(string packageId, bool blocking = false, CancellationToken cancellationToken = default)
        {
            if (!CheckWinGetVersion(_pinMinVersion))
            {
                throw new WinGetFeatureNotSupportedException(_pinMinVersion);
            }
 
            ArgsHelper.ThrowIfStringIsNullOrWhiteSpace(packageId, "packageId");
 
            WinGetArguments cmd = WinGetArguments.PinAdd().Query(packageId).Installed();
 
            if (blocking)
            {
                cmd.Blocking();
            }
 
            ProcessResult result = await ExecuteAsync(cmd, false, cancellationToken);
 
            return result.Success;
        }
 
        public async Task<bool> PinAddInstalledAsync(string packageId, string version, CancellationToken cancellationToken = default)
        {
            if (!CheckWinGetVersion(_pinMinVersion))
            {
                throw new WinGetFeatureNotSupportedException(_pinMinVersion);
            }
 
            ArgsHelper.ThrowIfStringIsNullOrWhiteSpace(packageId, "packageId");
            ArgsHelper.ThrowIfStringIsNullOrWhiteSpace(version, "version");
 
            ProcessResult result =
                await ExecuteAsync(
                    WinGetArguments.PinAdd().Query(packageId).Installed().Version(version),
                    false, cancellationToken);
 
            return result.Success;
        }
 
        public async Task<bool> PinAddInstalledAsync(WinGetPackage package, bool blocking = false, CancellationToken cancellationToken = default)
        {
            ArgsHelper.ThrowIfWinGetObjectIsNullOrEmpty(package, "package");
 
            if (package.HasShortenedId || package.HasNoId)
            {
                return await PinAddInstalledAsync(package.Name, blocking, cancellationToken);
            }
 
            return await PinAddInstalledAsync(package.Id, blocking, cancellationToken);
        }
 
        public async Task<bool> PinAddInstalledAsync(WinGetPackage package, string version, CancellationToken cancellationToken = default)
        {
            ArgsHelper.ThrowIfWinGetObjectIsNullOrEmpty(package, "package");
 
            if (package.HasShortenedId || package.HasNoId)
            {
                return await PinAddInstalledAsync(package.Name, version, cancellationToken);
            }
 
            return await PinAddInstalledAsync(package.Id, version, cancellationToken);
        }
        //---------------------------------------------------------------------------------------------
 
        //---Pin Remove--------------------------------------------------------------------------------
        public bool PinRemove(string packageId)
        {
            if (!CheckWinGetVersion(_pinMinVersion))
            {
                throw new WinGetFeatureNotSupportedException(_pinMinVersion);
            }
 
            ArgsHelper.ThrowIfStringIsNullOrWhiteSpace(packageId, "packageId");
 
            ProcessResult result = Execute(WinGetArguments.PinRemove().Query(packageId));
 
            return result.Success;
        }
 
        public bool PinRemove(WinGetPackage package)
        {
            ArgsHelper.ThrowIfWinGetObjectIsNullOrEmpty(package, "package");
 
            if (package.HasShortenedId || package.HasNoId)
            {
                return PinRemove(package.Name);
            }
 
            return PinRemove(package.Id);
        }
 
        public async Task<bool> PinRemoveAsync(string packageId, CancellationToken cancellationToken = default)
        {
            if (!CheckWinGetVersion(_pinMinVersion))
            {
                throw new WinGetFeatureNotSupportedException(_pinMinVersion);
            }
 
            ArgsHelper.ThrowIfStringIsNullOrWhiteSpace(packageId, "packageId");
 
            ProcessResult result = await ExecuteAsync(WinGetArguments.PinRemove().Query(packageId), false, cancellationToken);
 
            return result.Success;
        }
 
        public async Task<bool> PinRemoveAsync(WinGetPackage package, CancellationToken cancellationToken = default)
        {
            ArgsHelper.ThrowIfWinGetObjectIsNullOrEmpty(package, "package");
 
            if (package.HasShortenedId || package.HasNoId)
            {
                return await PinRemoveAsync(package.Name, cancellationToken);
            }
 
            return await PinRemoveAsync(package.Id, cancellationToken);
        }
 
        public bool PinRemoveInstalled(string packageId)
        {
            if (!CheckWinGetVersion(_pinMinVersion))
            {
                throw new WinGetFeatureNotSupportedException(_pinMinVersion);
            }
 
            ArgsHelper.ThrowIfStringIsNullOrWhiteSpace(packageId, "packageId");
 
            ProcessResult result = Execute(WinGetArguments.PinRemove().Query(packageId).Installed());
 
            return result.Success;
        }
 
        public bool PinRemoveInstalled(WinGetPackage package)
        {
            ArgsHelper.ThrowIfWinGetObjectIsNullOrEmpty(package, "package");
 
            if (package.HasShortenedId || package.HasNoId)
            {
                return PinRemoveInstalled(package.Name);
            }
 
            return PinRemoveInstalled(package.Id);
        }
 
        public async Task<bool> PinRemoveInstalledAsync(string packageId, CancellationToken cancellationToken = default)
        {
            if (!CheckWinGetVersion(_pinMinVersion))
            {
                throw new WinGetFeatureNotSupportedException(_pinMinVersion);
            }
 
            ArgsHelper.ThrowIfStringIsNullOrWhiteSpace(packageId, "packageId");
 
            ProcessResult result = await ExecuteAsync(WinGetArguments.PinRemove().Query(packageId).Installed(), false, cancellationToken);
 
            return result.Success;
        }
 
        public async Task<bool> PinRemoveInstalledAsync(WinGetPackage package, CancellationToken cancellationToken = default)
        {
            ArgsHelper.ThrowIfWinGetObjectIsNullOrEmpty(package, "package");
 
            if (package.HasShortenedId || package.HasNoId)
            {
                return await PinRemoveInstalledAsync(package.Name, cancellationToken);
            }
 
            return await PinRemoveInstalledAsync(package.Id, cancellationToken);
        }
        //---------------------------------------------------------------------------------------------
 
        //---Pin Reset---------------------------------------------------------------------------------
        public bool ResetPins()
        {
            if (!CheckWinGetVersion(_pinMinVersion))
            {
                throw new WinGetFeatureNotSupportedException(_pinMinVersion);
            }
 
            ProcessResult result = Execute(WinGetArguments.PinReset().Force());
 
            return result.Success;
        }
 
        public async Task<bool> ResetPinsAsync(CancellationToken cancellationToken = default)
        {
            if (!CheckWinGetVersion(_pinMinVersion))
            {
                throw new WinGetFeatureNotSupportedException(_pinMinVersion);
            }
 
            ProcessResult result = await ExecuteAsync(WinGetArguments.PinReset().Force(), false, cancellationToken);
 
            return result.Success;
        }
        //---------------------------------------------------------------------------------------------
 
        //---Helper Functions--------------------------------------------------------------------------
        private WinGetArguments IncludeUnknownbyVersion(WinGetArguments arguments)
        {
            // Checking version to determine if "--include-unknown" is necessary.
            if (CheckWinGetVersion(new Version(1, 4, 0)))
            {
                // Winget version supports new argument, add "--include-unknown" to arguments
                arguments.IncludeUnknown();
            }
            return arguments;
        }
        //---------------------------------------------------------------------------------------------
    }
}