WinGetArguments.cs

//--------------------------------------------------//
// Created by basicx-StrgV                          //
// https://github.com/basicx-StrgV/                 //
//--------------------------------------------------//
using System;
using WGetNET.Helper;
 
namespace WGetNET
{
    public class WinGetArguments : IWinGetObject
    {
        internal enum WinGetAction
        {
            Unspecified,
            Download,
            Export,
            Import,
            Hash,
        }
 
        public string Arguments
        {
            get
            {
                return _arguments.Trim();
            }
        }
 
        public bool IsEmpty
        {
            get
            {
                return string.IsNullOrWhiteSpace(_arguments);
            }
        }
 
        private readonly WinGetAction _action;
 
        private string _arguments;
 
        internal WinGetArguments(string baseCmd, WinGetAction action = WinGetAction.Unspecified)
        {
            _arguments = baseCmd;
            _action = action;
        }
 
        //---Base Cmd's--------------------------------------------------------------------------------
        public static WinGetArguments WinGet()
        {
            return new WinGetArguments("");
        }
 
        public static WinGetArguments Settings()
        {
            return new WinGetArguments("settings");
        }
 
        public static WinGetArguments SettingsExport()
        {
            return new WinGetArguments("settings export");
        }
 
        public static WinGetArguments List()
        {
            return new WinGetArguments("list");
        }
 
        public static WinGetArguments Search()
        {
            return new WinGetArguments("search");
        }
 
        public static WinGetArguments Install()
        {
            return new WinGetArguments("install");
        }
 
        public static WinGetArguments Upgrade()
        {
            return new WinGetArguments("upgrade");
        }
 
        public static WinGetArguments Uninstall()
        {
            return new WinGetArguments("uninstall");
        }
 
        public static WinGetArguments Download()
        {
            return new WinGetArguments("download", WinGetAction.Download);
        }
 
        public static WinGetArguments Repair()
        {
            return new WinGetArguments("repair");
        }
 
        public static WinGetArguments Export()
        {
            return new WinGetArguments("export", WinGetAction.Export);
        }
 
        public static WinGetArguments Import()
        {
            return new WinGetArguments("import", WinGetAction.Import);
        }
 
        public static WinGetArguments Hash()
        {
            return new WinGetArguments("hash", WinGetAction.Hash);
        }
 
        public static WinGetArguments PinList()
        {
            return new WinGetArguments("pin list");
        }
 
        public static WinGetArguments PinAdd()
        {
            return new WinGetArguments("pin add");
        }
 
        public static WinGetArguments PinRemove()
        {
            return new WinGetArguments("pin remove");
        }
 
        public static WinGetArguments PinReset()
        {
            return new WinGetArguments("pin reset");
        }
 
        public static WinGetArguments SourceAdd()
        {
            return new WinGetArguments("source add");
        }
 
        public static WinGetArguments SourceRemove()
        {
            return new WinGetArguments("source remove");
        }
 
        public static WinGetArguments SourceUpdate()
        {
            return new WinGetArguments("source update");
        }
 
        public static WinGetArguments SourceReset()
        {
            return new WinGetArguments("source reset");
        }
 
        public static WinGetArguments SourceExport()
        {
            return new WinGetArguments("source export");
        }
 
        public static WinGetArguments CustomCmd(string cmd)
        {
            ArgsHelper.ThrowIfStringIsNullOrWhiteSpace(cmd, "cmd");
 
            cmd = cmd.ToLower().Trim();
            if (cmd.StartsWith("winget"))
            {
#if NETCOREAPP3_1_OR_GREATER
                cmd = cmd[6..];
#elif NETSTANDARD2_0
                cmd = cmd.Substring(6);
#endif
            }
 
            return new WinGetArguments(cmd);
        }
 
        //---Flags-------------------------------------------------------------------------------------
        public WinGetArguments Custom(string custom)
        {
            ArgsHelper.ThrowIfStringIsNullOrWhiteSpace(custom, "custom");
 
            _arguments += $" {custom.ToLower().Trim()}";
            return this;
        }
 
        public WinGetArguments Query(string query)
        {
            ArgsHelper.ThrowIfStringIsNullOrWhiteSpace(query, "query");
 
            _arguments += $" --query \"{query}\"";
            return this;
        }
 
        public WinGetArguments Source(string source)
        {
            ArgsHelper.ThrowIfStringIsNullOrWhiteSpace(source, "source");
 
            _arguments += $" --source \"{source}\"";
            return this;
        }
 
        public WinGetArguments File(string file)
        {
            ArgsHelper.ThrowIfStringIsNullOrWhiteSpace(file, "file");
 
            switch (_action)
            {
                case WinGetAction.Hash:
                    _arguments += $" --file \"{file}\"";
                    break;
                case WinGetAction.Import:
                    _arguments += $" --import-file \"{file}\"";
                    break;
                case WinGetAction.Export:
                    _arguments += $" --output \"{file}\"";
                    break;
            }
 
            return this;
        }
 
        public WinGetArguments Directory(string directory)
        {
            ArgsHelper.ThrowIfStringIsNullOrWhiteSpace(directory, "directory");
 
            // Remove backslash chars at the end of the path,
            // because they are not needed and will interfere with winget argument string by negating the last quotation mark char,
            // used for encasing the directory path.
#if NETCOREAPP3_1_OR_GREATER
            while (directory.EndsWith('\\'))
            {
                directory = directory[..^1];
            }
#elif NETSTANDARD2_0
            while (directory.EndsWith("\\"))
            {
                directory = directory.Substring(0, directory.Length - 1);
            }
#endif
 
            switch (_action)
            {
                case WinGetAction.Download:
                    _arguments += $" --download-directory \"{directory}\"";
                    break;
            }
 
            return this;
        }
 
        public WinGetArguments Enable(string query)
        {
            ArgsHelper.ThrowIfStringIsNullOrWhiteSpace(query, "query");
 
            _arguments += $" --enable \"{query}\"";
            return this;
        }
 
        public WinGetArguments Disable(string query)
        {
            ArgsHelper.ThrowIfStringIsNullOrWhiteSpace(query, "query");
 
            _arguments += $" --disable \"{query}\"";
            return this;
        }
 
        public WinGetArguments Name(string name)
        {
            ArgsHelper.ThrowIfStringIsNullOrWhiteSpace(name, "name");
 
            _arguments += $" --name \"{name}\"";
            return this;
        }
 
        public WinGetArguments Arg(string arg)
        {
            ArgsHelper.ThrowIfStringIsNullOrWhiteSpace(arg, "arg");
 
            _arguments += $" --arg \"{arg}\"";
            return this;
        }
 
        public WinGetArguments Type(string type)
        {
            ArgsHelper.ThrowIfStringIsNullOrWhiteSpace(type, "type");
 
            _arguments += $" --type \"{type}\"";
            return this;
        }
 
        public WinGetArguments Version(string version)
        {
            ArgsHelper.ThrowIfStringIsNullOrWhiteSpace(version, "version");
 
            _arguments += $" --version \"{version}\"";
            return this;
        }
 
        public WinGetArguments Version(Version version)
        {
            ArgsHelper.ThrowIfObjectIsNull(version, "version");
 
            _arguments += $" --version \"{version.ToString()}\"";
            return this;
        }
 
        public WinGetArguments Version()
        {
            _arguments += $" --version";
            return this;
        }
 
        public WinGetArguments Exact()
        {
            _arguments += " --exact";
            return this;
        }
 
        public WinGetArguments Silent()
        {
            _arguments += " --silent";
            return this;
        }
 
        public WinGetArguments All()
        {
            _arguments += " --all";
            return this;
        }
 
        public WinGetArguments IncludeUnknown()
        {
            _arguments += " --include-unknown";
            return this;
        }
 
        public WinGetArguments AcceptSourceAgreements()
        {
            _arguments += " --accept-source-agreements";
            return this;
        }
 
        public WinGetArguments AcceptPackageAgreements()
        {
            _arguments += " --accept-package-agreements";
            return this;
        }
 
        public WinGetArguments IgnoreUnavailable()
        {
            _arguments += " --ignore-unavailable";
            return this;
        }
 
        public WinGetArguments Installed()
        {
            _arguments += " --installed";
            return this;
        }
 
        public WinGetArguments Blocking()
        {
            _arguments += " --blocking";
            return this;
        }
 
        public WinGetArguments Force()
        {
            _arguments += " --force";
            return this;
        }
 
        public WinGetArguments Info()
        {
            _arguments += " --info";
            return this;
        }
 
        //---Others------------------------------------------------------------------------------------
        public override string ToString()
        {
            return _arguments.Trim();
        }
    }
}