System.Console.ResetColor()

static void replacedyzeTools()
        {
            string[] toolList = Directory.GetFiles("Tools", "*.yml");
            foreach (string tool in toolList)
            {
                string outputFolder = string.Empty;
                string toolPath = string.Empty;
                string text = File.ReadAllText(tool);
                var stringReader = new StringReader(text);
                var yaml = new YamlStream();
                yaml.Load(stringReader);
                var mapping = (YamlMappingNode)yaml.Doreplacedents[0].RootNode;

                foreach (var entry in mapping.Children)
                {
                    var items = (YamlSequenceNode)mapping.Children[new YamlScalarNode("tool")];
                    foreach (YamlMappingNode item in items)
                    {
                        Console.ForegroundColor = ConsoleColor.Cyan;
                        Console.WriteLine("\n[+] Name: {0}", item.Children[new YamlScalarNode("name")]);
                        Console.ResetColor();
                        Console.WriteLine("     - Description: {0}\n     - Git link: {1}\n     - Solution file: {2}\n",
                            item.Children[new YamlScalarNode("description")],
                            item.Children[new YamlScalarNode("gitLink")],
                            item.Children[new YamlScalarNode("solutionPath")]);

                        try
                        {
                            toolPath = Build.DownloadRepository(item.Children[new YamlScalarNode("name")].ToString()
                            , item.Children[new YamlScalarNode("gitLink")].ToString());
                            outputFolder = Build.BuildTool(
                                item.Children[new YamlScalarNode("solutionPath")].ToString(),
                                item.Children[new YamlScalarNode("name")].ToString());
                            if (Helpers.ExecuteCommand("RMDIR \"" + toolPath + "\" /S /Q") != 0)
                            {
                                Console.ForegroundColor = ConsoleColor.Red;
                                Console.WriteLine("         Error -> RMDIR: {0}", toolPath);
                                Helpers.LogToFile("replacedyzeTools", "ERROR", "RMDIR: <" + toolPath + ">");
                                Console.ResetColor();
                            }
                            Build.Confuse(outputFolder);
                            Helpers.CalculateMD5Files(outputFolder);
                            Console.ForegroundColor = ConsoleColor.Magenta;
                            Console.WriteLine("     Output folder: {0}", outputFolder);
                            Console.ResetColor();
                        } 
                        catch (Exception ex)
                        {
                            Console.WriteLine("         Error -> replacedyzing: <{0}> -> {1}", item.Children[new YamlScalarNode("name")], ex.ToString());
                            Helpers.LogToFile("replacedyzeTools", "ERROR", "replacedyzing: <" + item.Children[new YamlScalarNode("name")] + "> -> " + ex.ToString());
                        }
                    }
                }
            }
        }

public void Log<TState>(LogLevel logLevel, EventId eventId, TState state, Exception exception, Func<TState, Exception, string> formatter)
        {
            if (!this.IsEnabled(logLevel))
                return;

            lock (_lock)
            {
                var ename = eventId.Name;
                ename = ename?.Length > 12 ? ename?.Substring(0, 12) : ename;
                Console.Write($"[{DateTimeOffset.Now.ToString(this.TimestampFormat)}] [{eventId.Id,-4}/{ename,-12}] ");

                switch (logLevel)
                {
                    case LogLevel.Trace:
                        Console.ForegroundColor = ConsoleColor.Gray;
                        break;

                    case LogLevel.Debug:
                        Console.ForegroundColor = ConsoleColor.DarkMagenta;
                        break;

                    case LogLevel.Information:
                        Console.ForegroundColor = ConsoleColor.DarkCyan;
                        break;

                    case LogLevel.Warning:
                        Console.ForegroundColor = ConsoleColor.Yellow;
                        break;

                    case LogLevel.Error:
                        Console.ForegroundColor = ConsoleColor.Red;
                        break;

                    case LogLevel.Critical:
                        Console.BackgroundColor = ConsoleColor.Red;
                        Console.ForegroundColor = ConsoleColor.Black;
                        break;
                }
                Console.Write(logLevel switch
                {
                    LogLevel.Trace => "[Trace] ",
                    LogLevel.Debug => "[Debug] ",
                    LogLevel.Information => "[Info ] ",
                    LogLevel.Warning => "[Warn ] ",
                    LogLevel.Error => "[Error] ",
                    LogLevel.Critical => "[Crit ]",
                    LogLevel.None => "[None ] ",
                    _ => "[?????] "
                });
                Console.ResetColor();

                //The foreground color is off.
                if (logLevel == LogLevel.Critical)
                    Console.Write(" ");

                var message = formatter(state, exception);
                Console.WriteLine(message);
                if (exception != null)
                    Console.WriteLine(exception);
            }

public void WriteLine(string line, ConsoleColor? colorCode = null)
        {
            Trace.Info($"WRITE LINE: {line}");
            if (!Silent)
            {
                if (colorCode != null)
                {
                    Console.ForegroundColor = colorCode.Value;
                    Console.WriteLine(line);
                    Console.ResetColor();
                }
                else
                {
                    Console.WriteLine(line);
                }
            }
        }

public static string DownloadRepository(string toolName, string url)
        {
            string path = "GitTools";
            try
            {
                if (!Directory.Exists(path))
                {
                    DirectoryInfo di = Directory.CreateDirectory(path);
                }
            }
            catch (Exception e)
            {
                Console.WriteLine("The process failed: {0}", e.ToString());
            }
            string toolPath = Path.Combine(new string[] { path, toolName });
            if (!Directory.Exists(toolPath))
            {
                Console.ForegroundColor = ConsoleColor.Yellow;
                Console.WriteLine("     Clonnig the repository: {0}", toolName);
                Console.ResetColor();
                Repository.Clone(url, toolPath);
                using (var repo = new Repository(toolPath))
                {
                    var commit = repo.Head.Tip;
                    Console.WriteLine(@"        Last commit: {0}", commit.Author.When.ToLocalTime());
                }
            }
            return toolPath;
        }

public void WriteSuccessMessage(string message)
        {
            if (!Silent)
            {
                Console.ForegroundColor = ConsoleColor.Green;
                Console.Write("√ ");
                Console.ResetColor();
                Console.WriteLine(message);
            }
        }

static void Error(string message)
        {
            Console.ForegroundColor = ConsoleColor.DarkRed;
            Console.WriteLine($"Error: {message}");
            Console.ResetColor();
        }

static void TestFrame(string replacedle, ZeroOperatorStateType state, params byte[][] frames)
        {
            Console.Error.Write(replacedle);
            Console.ForegroundColor = ConsoleColor.Red;
            TestFrameInner(replacedle, state, frames);
            Console.Error.WriteLine();
            Console.Error.WriteLine("**----**");
            Console.ResetColor();
        }

public async Task<JObject> CallPatchWebApiAndProcessResultASync(string webApiUrl, string accessToken, string data)
        {
            JObject result = null;
            if (!string.IsNullOrEmpty(accessToken))
            {
                var defaultRequetHeaders = HttpClient.DefaultRequestHeaders;
                if (defaultRequetHeaders.Accept == null || !defaultRequetHeaders.Accept.Any(m => m.MediaType == "application/json"))
                {
                    HttpClient.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json"));
                }
                defaultRequetHeaders.Authorization = new AuthenticationHeaderValue("bearer", accessToken);

                var body = new StringContent(data, Encoding.UTF8, "application/json");

                HttpResponseMessage response = await HttpClient.PatchAsync(webApiUrl, body);
                if (response.IsSuccessStatusCode)
                {
                    string json = await response.Content.ReadreplacedtringAsync();
                    result = JsonConvert.DeserializeObject(json) as JObject;
                    Console.ForegroundColor = ConsoleColor.Gray;
                }
                else
                {
                    Console.ForegroundColor = ConsoleColor.Red;
                    Console.WriteLine($"Failed to call the Web Api: {response.StatusCode}");
                    JObject content = JObject.Parse(await response.Content.ReadreplacedtringAsync());
                    Console.WriteLine($"Content: {content}");
                    result = content;
                }
                Console.ResetColor();
            }
            return result;
        }

private static void ExecuteQueryWithResult(string queryOrTable, bool isTable)
        {
            try
            {
                if (_dbPath == "empty")
                {
                    Console.WriteLine("\n => Welcome to sqlite .net core global tool version 1.1 <=");
                    Console.Write("       Check the help section by typing sqlite ");
                    Console.ForegroundColor = ConsoleColor.Green;
                    Console.Write("sqlite-tool --h \n");
                    Console.ResetColor();
                }
                else
                {
                    if (!TestConnectionDatabase()) return;
                    var connectionStringBuilder = new SqliteConnectionStringBuilder {DataSource = _dbPath};
                    using (var connection = new SqliteConnection(connectionStringBuilder.ConnectionString))
                    {
                        connection.Open();
                        var selectCmd = connection.CreateCommand();
                        if (!isTable)
                        {
                            selectCmd.CommandText = queryOrTable;
                        }
                        else
                        {
                            selectCmd.CommandText = "Select * from " + queryOrTable;
                        }

                        using (var reader = selectCmd.ExecuteReader())
                        {
                            var count = reader.FieldCount;
                            var numberRecord = 0;
                            while (reader.Read())
                            {
                                numberRecord++;
                            }

                            var arrValues = new string[numberRecord + 1, count];
                            for (var i = 0; i < count; i++)
                            {
                                arrValues[0, i] = " " + reader.GetName(i) + " ";
                                var j = 1;
                                while (reader.Read())
                                {
                                    arrValues[j, i] = " " + reader[reader.GetName(i)] + " ";
                                    j++;
                                }
                            }

                            Console.WriteLine();
                            ArrayPrinter.PrintToConsole(arrValues);
                        }
                    }
                }
            }
            catch (Exception ex)
            {
                Console.WriteLine("\n There is an error in your sql syntax");
                Console.ForegroundColor = ConsoleColor.Red;
                Console.WriteLine("  "+ex.Message + "\n");
                Console.ResetColor();
            }
        }

public static void PrintError(string error)
        {
            Console.ForegroundColor = ConsoleColor.Red;
            Console.WriteLine(error);
            Console.ResetColor();
        }

public static void CreateTarArchive(string sourceDirectory, string outputFile, bool verbose)
        {
            Chilkat.Tar tar = new Chilkat.Tar
            {
                WriteFormat = "gnu"
            };

            // Add a directory tree to be included in the output TAR archive:
            bool success = tar.AddDirRoot(sourceDirectory);
            if (success != true)
            {
                Console.ForegroundColor = ConsoleColor.Red;
                Console.Write("ERROR\n\n");
                Console.Write("error: ");
                Console.ResetColor();
                Console.Write(tar.LastErrorText + "\n");
                return;
            }

            // Create the TAR archive.
            success = tar.WriteTar(outputFile);
            if (success != true)
            {
                Console.ForegroundColor = ConsoleColor.Red;
                Console.Write("ERROR\n\n");
                Console.Write("error: ");
                Console.ResetColor();
                Console.Write(tar.LastErrorText + "\n");
                return;
            }

            if (verbose)
            {
                Console.ForegroundColor = ConsoleColor.Green;
                Console.Write("OK\n");
                Console.ResetColor();
            }
        }

void UpdateArchive(string path, bool verbose)
        {
            if (!verbose)
                Console.Write("Creating .tar archives ... ");

            foreach (var directory in DirectoriesDictionary(path + @"\customize", path))
            {
                if (verbose)
                    Console.Write("Creating " + directory.Value + ".tar archive ... ");

                ArchiveManager.CreateTarArchive(directory.Key, path + @"\themes\" + directory.Value + ".tar", verbose);
            }

            if (!verbose)
            {
                Console.ForegroundColor = ConsoleColor.Green;
                Console.Write("OK\n");
                Console.ResetColor();
            }
        }

static void printMenu(bool showMenu = false, string loadXlsPath = "")
        {
            Console.Clear();
            Console.ForegroundColor = ConsoleColor.Cyan; ;
            Console.WriteLine(xlsKami.Properties.Resources.banner);
            Console.WriteLine("   xlsKami [v1.]");
            Console.WriteLine("   Out-of-the-Box Tool to Obfuscate Excel 97-2003 XLS");
            Console.ResetColor();
            Console.WriteLine(@">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>");
            if (showMenu)
            {
                log("[v] Selected File: {0}\n", ConsoleColor.Magenta, loadXlsPath);
                log("[+] Menu \n", ConsoleColor.Cyan);
                log("\t[1] Masquerade Cell Labels\n", ConsoleColor.Cyan);
                log("\t[2] Masquerade Workbook Sheets\n", ConsoleColor.Cyan);
                log("\t[3] Save & Exit\n", ConsoleColor.Cyan);
                log("\t[4] Exit\n", ConsoleColor.Cyan);
                foreach (var szLog in historyList) log(szLog, ConsoleColor.Green);
                Console.WriteLine(@">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>");

                log("[?] choose action (index): ", ConsoleColor.Cyan);
            }

        }

public static void Confuse(string folder)
        {
            string[] exeList = Directory.GetFiles(folder, "*.exe");
            foreach (string exe in exeList)
            {
                string text = File.ReadAllText(Path.Combine(new string[] { Directory.GetCurrentDirectory(), "Resources", "template_confuserEx.crproj" }));
                text = text.Replace("{{BASE_DIR}}", folder);
                text = text.Replace("{{OUTPUT_DIR}}", Path.Combine(new string[] { folder, "Confused" }));
                text = text.Replace("{{EXE_FILE}}", exe);
                string crprojPath = Path.Combine(new string[] { folder, exe + ".crproj" });
                System.IO.File.WriteAllText(crprojPath, text);
                Console.ForegroundColor = ConsoleColor.Yellow;
                Console.WriteLine("     Confusing " + exe + "...");
                Console.ResetColor();
                if (Helpers.ExecuteCommand(
                    Path.Combine(new string[] { Directory.GetCurrentDirectory(), "Resources", "ConfuserEx", "Confuser.CLI.exe" }) + " " + crprojPath) != 0)
                {
                    Console.ForegroundColor = ConsoleColor.Red;
                    Console.WriteLine("         Error -> ConfuserEx: {0}", exe);
                    Console.ResetColor();
                }
                else
                {
                    Console.ForegroundColor = ConsoleColor.Green;
                    Console.WriteLine("         No errors!");
                    Console.ResetColor();
                }
            }
        }

public static void PrintInfo(string info)
        {
            Console.ForegroundColor = ConsoleColor.Blue;
            Console.WriteLine(info);
            Console.ResetColor();
        }

static void CheckStart()
        {
            int error = 0;
            if (!File.Exists(Path.Combine(new string[] { Directory.GetCurrentDirectory(), "Resources", "nuget.exe" })))
            {
                Console.ForegroundColor = ConsoleColor.Yellow;
                Console.WriteLine("   [*] Downloading nuget.exe...");
                Console.ResetColor();
                //Download nuget.exe
                error = Helpers.DownloadResources(@"https://dist.nuget.org/win-x86-commandline/latest/nuget.exe", "nuget.exe", "Resources");
                if (error != 0)
                {
                    System.Environment.Exit(1);
                }
            }
            if (!Directory.Exists(Path.Combine(new string[] { Directory.GetCurrentDirectory(), "Resources", "ConfuserEx" })))
            {
                Console.ForegroundColor = ConsoleColor.Yellow;
                Console.WriteLine("   [*] Downloading ConfuserEx...");
                Console.ResetColor();
                //Download ConfuserEx
                error = Helpers.DownloadResources(@"https://github.com/mkaring/ConfuserEx/releases/download/v1.4.1/ConfuserEx-CLI.zip", "ConfuserEx.zip", "Resources");
                if (error != 0)
                {
                    System.Environment.Exit(1);
                }
                error = Helpers.UnzipFile(
                    Path.Combine(new string[] { Directory.GetCurrentDirectory(), "Resources", "ConfuserEx.zip" }),
                    Path.Combine(new string[] { Directory.GetCurrentDirectory(), "Resources", "ConfuserEx" }));
                if (error != 0)
                {
                    System.Environment.Exit(1);
                }
                try
                {
                    File.Delete(Path.Combine(new string[] { Directory.GetCurrentDirectory(), "Resources", "ConfuserEx.zip" }));
                }
                catch (Exception ex)
                {
                    Console.WriteLine("         Error ->  deleting <" + Path.Combine(new string[] { Directory.GetCurrentDirectory(), "Resources", "ConfuserEx.zip" }) + "> - " + ex.ToString());
                    Helpers.LogToFile("CheckStart", "ERROR", "Deleting: <" + Path.Combine(new string[] { Directory.GetCurrentDirectory(), "Resources", "ConfuserEx.zip" }) + "> - " + ex.ToString());
                }
            }
            string buildToolsPath = @"C:\Program Files (x86)\Microsoft Visual Studio\2019\BuildTools\Common7\Tools\VsDevCmd.bat";
            if (!File.Exists(buildToolsPath))
            {
                Console.ForegroundColor = ConsoleColor.Red;
                Console.WriteLine("         Error -> File not found: {0}", buildToolsPath);
                Console.WriteLine("             Install -> Build Tools for Visual Studio 2019");
                Helpers.LogToFile("CheckStart", "ERROR", "File not found: <" + buildToolsPath + ">");
                Console.ResetColor();
                System.Environment.Exit(1);
            }
        }

static int Main(string[] args)
        {
            // When invoked w/o args, print usage and exit immediately (do not trigger ArgException)
            if ((args ?? new string[0]).Length == 0)
            {
                ArgUsage.GenerateUsageFromTemplate<CmdLineActions>().WriteLine();
                return (int)ExitCode.NoArgsProvided;
            }

            var result = default(ExitCode);
            try
            {
                var action = Args.ParseAction<CmdLineActions>(args);
                
                action.Invoke(); // throws ArgException (DuplicateArg, MissingArg, UnexpectedArg, UnknownArg, ValidationArg)

                // in Debug compilation, propagates any exceptions thrown by executing action
                // in Release compilation, a user friendly error message is displayed, and exceptions thrown are available via the HandledException property

                /* This branch only applies in Release (StandardExceptionHandling enabled) mode, and only to __parser__ exceptions */
                if (action.HandledException != null)
                {
                    // Standard output has been generated by PowerArgs framework already
                    Console.WriteLine();
                    Log.Verbose(action.HandledException, "PowerArgs exception");
                }

                // TODO Define and handle specific exceptions to report back to user directly (No PBI install, etc...)

                result = action.HandledException == null ? ExitCode.Success : ExitCode.InvalidArgs;
            }
            catch (ArgException ex)
            {
                // In RELEASE mode, the PowerArgs error has already been emitted, and the usage docs have been printed to the console at this stage
                
                if (!Environment.UserInteractive)
                {
                    Log.Fatal(ex, "Bad user input.");
                }
                else
                {
                    Console.ForegroundColor = ConsoleColor.Red;
                    Console.Error.WriteLine(ex.Message);
                    Console.ResetColor();
#if DEBUG
                    ArgUsage.GenerateUsageFromTemplate(ex.Context.Definition).WriteLine();
#endif
                }
                result = ExitCode.InvalidArgs;
            }
            catch (PbiToolsCliException ex)
            {
                Log.Error(ex.Message);
                result = ex.ErrorCode;
            }
            catch (Exception ex) /* Any unhandled exception */
            {
                // TODO Explicitly log into crash file...
                // If CWD is not writable, put into user profile and show path...

                Log.Fatal(ex, "An unhandled exception occurred.");
                result = ExitCode.UnexpectedError;
            }

            // Prevent closing of window when debugging
            if (Debugger.IsAttached && Environment.UserInteractive)
            {
                Console.WriteLine();
                Console.Write("Press ENTER to exit...");
                Console.ReadLine();
            }

            // ExitCode:
            return (int)result;
        }

public void WriteLine(string text = " ", ConsoleColor color = ConsoleColor.White)
        {
            Console.ForegroundColor = color;
            Console.WriteLine(text);
            Console.ResetColor();
        }

public async Task<JObject> CallPostWebApiAndProcessResultASync(string webApiUrl, string accessToken, string data)
        {
            JObject result = null;
            if (!string.IsNullOrEmpty(accessToken))
            {
                var defaultRequetHeaders = HttpClient.DefaultRequestHeaders;
                if (defaultRequetHeaders.Accept == null || !defaultRequetHeaders.Accept.Any(m => m.MediaType == "application/json"))
                {
                    HttpClient.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json"));
                }
                defaultRequetHeaders.Authorization = new AuthenticationHeaderValue("bearer", accessToken);

                var body = new StringContent(data, Encoding.UTF8, "application/json");

                HttpResponseMessage response = await HttpClient.PostAsync(webApiUrl, body);
                if (response.IsSuccessStatusCode)
                {
                    string json = await response.Content.ReadreplacedtringAsync();
                    result = JsonConvert.DeserializeObject(json) as JObject;
                    Console.ForegroundColor = ConsoleColor.Gray;
                }
                else
                {
                    Console.ForegroundColor = ConsoleColor.Red;
                    Console.WriteLine($"Failed to call the Web Api: {response.StatusCode}");
                    JObject content = JObject.Parse(await response.Content.ReadreplacedtringAsync());
                    Console.WriteLine($"Content: {content}");
                    result = content;
                }
                Console.ResetColor();
            }
            return result;
        }

private static void Main(string[] args)
        {
            _dbPath = ReadVariable();
            switch (args.Length)
            {
                case 2:
                    switch (args[0])
                    {
                        case "-db":
                            SaveValue(args[1]);
                            _dbPath = args[1];
                            break;
                        case "-q" when _dbPath == "empty":
                            Console.Write("\n Please Specify the sqlite database path first by typing ");
                            Console.ForegroundColor = ConsoleColor.Green;
                            Console.Write(@"-db ""path""" + Environment.NewLine + Environment.NewLine);
                            Console.ResetColor();
                            break;
                        case "-q":
                            ExecuteQuery(args[1]);
                            break;
                        case "-r" when _dbPath == "empty":
                            Console.Write("\n Please Specify the sqlite database path first by typing ");
                            Console.ForegroundColor = ConsoleColor.Green;
                            Console.Write(@"-db ""path""" + Environment.NewLine + Environment.NewLine);
                            Console.ResetColor();
                            break;
                        case "-r":
                            ExecuteQueryWithResult(args[1], false);
                            break;
                        case "-s":
                        {
                            if (args[1] != null)
                            {
                                ExecuteQueryWithResult(args[1], true);
                            }
                            break;
                        }
                        default:
                            Console.Write("\n  Command not found check the option ");
                            Console.ForegroundColor = ConsoleColor.Green;
                            Console.Write(@"--h");
                            Console.ResetColor();
                            Console.Write(" for more information \n\n");
                            break;
                    }

                    break;
                case 1 when args[0] == "--h":
                    Console.WriteLine("\n => Welcome to sqlite .net core global tool version 1.0");
                    Console.WriteLine("\nOptions:");
                    Console.WriteLine(@"   -db ""Sqlite Database Path""");
                    Console.WriteLine(@"   -q  ""Query to execute""");
                    Console.WriteLine(@"   -r  ""Query to execute with result""");
                    Console.WriteLine(@"   -s  ""the table that you want to show, its data""");
                    Console.WriteLine();
                    break;
                case 1:
                    Console.WriteLine("\n   Need to insert a value for the option\n");
                    break;
                default:
                    Console.Write("\n   Check the help section by typing ");
                    Console.ForegroundColor = ConsoleColor.Green;
                    Console.Write("sqlite-tool --h \n");
                    Console.ResetColor();
                    break;
            }
        }

public void WriteError(string line)
        {
            Trace.Error($"WRITE ERROR: {line}");
            if (!Silent)
            {
                Console.ForegroundColor = ConsoleColor.Red;
                Console.Error.WriteLine(line);
                Console.ResetColor();
            }
        }

public void WriteSection(string message)
        {
            if (!Silent)
            {
                Console.WriteLine();
                Console.ResetColor();
                Console.WriteLine($"# {message}");
                Console.WriteLine();
            }
        }

static void Main(string[] args)
        {
            try
            {
                RunAsync().GetAwaiter().GetResult();
            }
            catch (Exception ex)
            {
                Console.ForegroundColor = ConsoleColor.Red;
                Console.WriteLine(ex.Message);
                Console.ResetColor();
            }

            Console.WriteLine("Press any key to exit");
            Console.ReadKey();
        }

private static async Task SearchRun(string name, string ringName)
        {
            var res = await _edgeUpdate.GetLatestFiles(name);
            if (res.Success && !SharedDBcmd.UpdateExists(ringName, res.Value.Version))
            {
                Console.ForegroundColor = ConsoleColor.DarkCyan;
                Console.WriteLine($"[{DateTime.Now.ToString("MM/dd/yyyy HH:mm:ss")}] !!! New update !!! {ringName} - Version: {res.Value.Version}");
                Console.ResetColor();

                var edgeFileFull = res.Value.EdgeFile.Where(file => file.EdgeFileUpdateType == EdgeFileUpdateType.Full).First();
                var SHA1Hex = BitConverter.ToString(edgeFileFull.Sha1).Replace("-", "");
                var SHA256Hex = BitConverter.ToString(edgeFileFull.Sha256).Replace("-", "");

                SharedDBcmd.AddNewUpdate(ring: ringName, version: res.Value.Version,
                                                filename: edgeFileFull.FileName, filesize: edgeFileFull.Size,
                                                sha256: SHA256Hex, url: edgeFileFull.Url);

                Console.ForegroundColor = ConsoleColor.Magenta;
                Console.WriteLine($"[{DateTime.Now.ToString("MM/dd/yyyy HH:mm:ss")}] <<< Downloading from MSEdge fe3 server");
                Console.ResetColor();
                await Download(name, res.Value.Version, edgeFileFull);

                Console.ForegroundColor = ConsoleColor.Green;
                Console.WriteLine($"[{DateTime.Now.ToString("MM/dd/yyyy HH:mm:ss")}] >>> Uploading to Telegram via TDLib");
                Console.ResetColor();
                await UploadAndSendMessage(edgeFileFull, string.Format(messageEdgeUpdate, ringName, res.Value.Version, SHA1Hex));

            }
        }

public async Task<string> CallGetHTMLWebApiAndProcessResultASync(string webApiUrl, string accessToken)
        {
            string result = null;
            if (!string.IsNullOrEmpty(accessToken))
            {
                var defaultRequetHeaders = HttpClient.DefaultRequestHeaders;
                if (defaultRequetHeaders.Accept == null || !defaultRequetHeaders.Accept.Any(m => m.MediaType == "application/json"))
                {
                    HttpClient.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json"));
                }
                defaultRequetHeaders.Authorization = new AuthenticationHeaderValue("bearer", accessToken);

                HttpResponseMessage response = await HttpClient.GetAsync(webApiUrl);
                if (response.IsSuccessStatusCode)
                {
                    result = await response.Content.ReadreplacedtringAsync();
                    Console.ForegroundColor = ConsoleColor.Gray;
                }
                else
                {
                    Console.ForegroundColor = ConsoleColor.Red;
                    Console.WriteLine($"Failed to call the Web Api: {response.StatusCode}");
                    result = await response.Content.ReadreplacedtringAsync();
                    Console.WriteLine($"Content: {result}");
                }
                Console.ResetColor();
            }
            return result;
        }

string CheckRepoPath(string path)
        {
            if (Directory.Exists(path) && path.Contains("distro-grub-themes"))
            {
                int index = path.IndexOf("distro-grub-themes") + 18;
                return path.Substring(0, index);
            }

            else
            {
                Console.ForegroundColor = ConsoleColor.Red;
                Console.Write("error: ");
                Console.ResetColor();
                Console.Write("could not find repository in this path");
                Environment.Exit(1);
                return null;
            }
        }

void UpdateIcons(string iconsPath, string customizePath, bool verbose)
        {
            if (!verbose)
                Console.Write("Copying icons ... ");

            foreach (var directory in DirectoriesArray(customizePath))
            {
                foreach (var icon in FilesArray(iconsPath))
                {
                    if (verbose)
                        Console.Write("Copying " + icon + " ... ");

                    File.Copy(iconsPath + @"\" + icon, directory + @"\icons\" + icon, true);

                    if (verbose)
                    {
                        Console.ForegroundColor = ConsoleColor.Green;
                        Console.Write("OK\n");
                        Console.ResetColor();
                    }
                }
            }

            if (!verbose)
            {
                Console.ForegroundColor = ConsoleColor.Green;
                Console.Write("OK\n");
                Console.ResetColor();
            }
        }

static void log(string str2log, ConsoleColor wordColor = ConsoleColor.White, params object[] args)
        {
            Console.ForegroundColor = wordColor;
            Console.Write(str2log, args);
            Console.ResetColor();
        }

private static async Task<T> RetryOnFailure<T>(Func<Task<T>> task)
        {
            try
            {
                return await task();
            }
            catch (Exception ex)
            {
                Console.ForegroundColor = ConsoleColor.DarkYellow;
                Console.Error.WriteLine($"Caught exception - retrying once: {ex}");
                Console.ResetColor();
                return await task();
            }
        }

public static void PrintSuccess(string success)
        {
            Console.ForegroundColor = ConsoleColor.Green;
            Console.WriteLine(success);
            Console.ResetColor();
        }

public static string BuildTool(string solutionPath, string toolName)
        {
            string finalPath = string.Empty;
            string text = System.IO.File.ReadAllText(Path.Combine(new string[] { Directory.GetCurrentDirectory(), "Resources", "template_build.bat" }));
            string buildOptions = "/p:Platform=\"Any CPU\"";
            solutionPath = Path.Combine(new string[] { Directory.GetCurrentDirectory(), "GitTools", solutionPath });
            string outputDir = Path.Combine(new string[] { Directory.GetCurrentDirectory(), "Output" });
            if (File.Exists(solutionPath))
            {

                Console.ForegroundColor = ConsoleColor.Yellow;
                Console.WriteLine("     Solving dependences with nuget...");
                Console.ResetColor();
                if (Helpers.ExecuteCommand(@"Resources\nuget.exe restore " + solutionPath) != 0)
                {
                    Console.ForegroundColor = ConsoleColor.Red;
                    Console.WriteLine("         Error -> nuget.exe: {0}", solutionPath);
                    Console.ResetColor();
                }
                finalPath = Path.Combine(new string[] { outputDir, toolName + "_" + Helpers.GetRandomString() });

                text = text.Replace("{{SOLUTION_PATH}}", solutionPath);
                text = text.Replace("{{BUILD_OPTIONS}}", buildOptions);
                text = text.Replace("{{OUTPUT_DIR}}", finalPath);
                string batPath = Path.Combine(new string[] { Path.GetDirectoryName(solutionPath), "buildSolution.bat" });
                File.WriteAllText(batPath, text);
                Console.ForegroundColor = ConsoleColor.Yellow;
                Console.WriteLine("     Building solution...");
                Console.ResetColor();
                if (Helpers.ExecuteCommand(batPath) != 0)
                {
                    Console.ForegroundColor = ConsoleColor.Red;
                    Console.WriteLine("         Error -> msbuild.exe: {0}", solutionPath);
                    Console.ResetColor();
                }
                else
                {
                    Console.ForegroundColor = ConsoleColor.Green;
                    Console.WriteLine("         No errors!");
                    Console.ResetColor();
                }

                //Gets all references to the project to obfuscate it with confuser
                SolutionFile s = SolutionFile.Parse(solutionPath);
                foreach (ProjectInSolution p in s.ProjectsInOrder)
                {
                    if (File.Exists(p.AbsolutePath))
                    {
                        XNamespace msbuild = "http://schemas.microsoft.com/developer/msbuild/2003";
                        XDoreplacedent projDefinition = XDoreplacedent.Load(p.AbsolutePath);
                        IEnumerable<string> references = projDefinition
                            .Element(msbuild + "Project")
                            .Elements(msbuild + "ItemGroup")
                            .Elements(msbuild + "Reference")
                            .Elements(msbuild + "HintPath")
                            .Select(refElem => refElem.Value);
                        foreach (string reference in references)
                        {
                            string referenceFile = reference.Replace(@"..\", "");
                            if (File.Exists(Path.Combine(new string[] { Path.GetDirectoryName(solutionPath), referenceFile })))
                            {
                                File.Copy(
                                    Path.Combine(new string[] { Path.GetDirectoryName(solutionPath), referenceFile }),
                                    Path.Combine(new string[] { finalPath, Path.GetFileName(referenceFile) }),
                                    true);
                            }
                        }
                    }

                }
            }
            return finalPath;
        }

static int Main(string[] args)
    {
        var decode = false;
        var wrap = 76;
        var showHelp = false;
        var showVersion = false;

        var options = new OptionSet
        {
            { "usage: ecoji [OPTIONS]... [FILE]" },
            { "" },
            { "Encode or decode data as Unicode emojis. 😻🍹" },
            { "" },
            { "Options:" },
            {
                "d|decode",
                "Decode data.",
                v => decode = v != null
            },
            {
                "w|wrap=",
                "Wrap encoded lines after {COLS} characters (default 76). " +
                    "Use 0 to disable line wrapping.",
                (int v) => wrap = v
            },
            {
                "h|help",
                "Print this message.",
                v => showHelp = v != null
            },
            {
                "v|version",
                "Print version information.",
                v => showVersion = v != null
            }
        };

        void ShowHelp()
            => options.WriteOptionDescriptions(Console.Out);

        void ShowVersion()
        {
            Console.WriteLine($"Ecoji (.NET Core) version {version}");
            Console.WriteLine($"  Copyright   : {copyright}");
            Console.WriteLine($"  License     : MIT");
            Console.WriteLine($"  Source code : https://github.com/abock/dotnet-ecoji");
            Console.WriteLine();
            Console.WriteLine($"Based on Ecoji by Keith Turner:");
            Console.WriteLine($"  https://github.com/keith-turner/ecoji");
        }

        try
        {
            var positional = options.Parse(args);

            if (showHelp)
            {
                ShowHelp();
                return ExitShowHelp;
            }

            if (showVersion)
            {
                ShowVersion();
                return ExitShowVersion;
            }

            Stream inputStream;

            if (positional is null ||
                positional.Count == 0 ||
                positional[0] == "-")
                inputStream = Console.OpenStandardInput();
            else if (positional.Count == 1)
                inputStream = new FileStream(
                    positional[0],
                    FileMode.Open,
                    FileAccess.Read);
            else
                throw new Exception("more than one file was provided");

            try
            {
                using(inputStream)
                {
                    if (decode)
                    {
                        using var stdout = Console.OpenStandardOutput();
                        Ecoji.Decode(inputStream, stdout);
                    }
                    else
                    {
                        Ecoji.Encode(inputStream, Console.Out, wrap);
                    }
                }
            }
            catch (Exception e)
            {
                WriteError($"pipe or encoding/decoding error: {e}");
                return ExitDataError;
            }

            return ExitSuccess;
        }
        catch (Exception e)
        {
            WriteError(e.Message);
            ShowHelp();
            return ExitArgumentsError;
        }
        
        static void WriteError(string error)
        {
            Console.ForegroundColor = ConsoleColor.DarkRed;
            Console.Error.WriteLine($"error: {error}");
            Console.Error.WriteLine();
            Console.ResetColor();
        }
    }

public static void CalculateMD5Files(string folder)
        {
            Console.ForegroundColor = ConsoleColor.Yellow;
            Console.WriteLine("     Calculating md5...");
            Console.ResetColor();
            string[] fileList = Directory.GetFiles(folder, "*.*", SearchOption.AllDirectories);
            List<string> md5List = new List<string>();
            foreach (string filename in fileList)
            {
                using (var md5 = MD5.Create())
                {
                    using (var stream = File.OpenRead(filename))
                    {
                        var hash = md5.ComputeHash(stream);
                        md5List.Add(filename + " - " + BitConverter.ToString(hash).Replace("-", "").ToLowerInvariant());
                    }
                }
            }
            File.WriteAllLines(Path.Combine(new string[] { folder, "md5.txt" }), md5List);
        }

private static void Write(string str, ConsoleColor? color = null)
        {
            Sync.Wait();
            try
            {
                if (color is ConsoleColor c)
                    Console.ForegroundColor = c;
                Console.Write(str);
                if (color.HasValue)
                    Console.ResetColor();
            }
            finally
            {
                Sync.Release();
            }
        }

static void replacedyzeTools(string toolName)
        {
            string outputFolder = string.Empty;
            string toolPath = string.Empty;
            if (!File.Exists(@"Tools\" + toolName + ".yml"))
            {
                Console.ForegroundColor = ConsoleColor.Red;
                Console.WriteLine("         Error -> {0} tool not supported", toolName);
                Helpers.LogToFile("replacedyzeTools", "ERROR", "<" + toolName + "> not supported");
                Console.ResetColor();
                return;
            }
            string text = File.ReadAllText(@"Tools\" + toolName + ".yml");
            var stringReader = new StringReader(text);
            var yaml = new YamlStream();
            yaml.Load(stringReader);
            var mapping = (YamlMappingNode)yaml.Doreplacedents[0].RootNode;

            foreach (var entry in mapping.Children)
            {
                var items = (YamlSequenceNode)mapping.Children[new YamlScalarNode("tool")];
                foreach (YamlMappingNode item in items)
                {
                    Console.ForegroundColor = ConsoleColor.Cyan;
                    Console.WriteLine("\n[+] Name: {0}", item.Children[new YamlScalarNode("name")]);
                    Console.ResetColor();
                    Console.WriteLine("     - Description: {0}\n     - Git link: {1}\n     - Solution file: {2}\n",
                        item.Children[new YamlScalarNode("description")],
                        item.Children[new YamlScalarNode("gitLink")],
                        item.Children[new YamlScalarNode("solutionPath")]);
                    try
                    {
                        toolPath = Build.DownloadRepository(item.Children[new YamlScalarNode("name")].ToString()
                            , item.Children[new YamlScalarNode("gitLink")].ToString());
                        outputFolder = Build.BuildTool(
                                item.Children[new YamlScalarNode("solutionPath")].ToString(),
                                item.Children[new YamlScalarNode("name")].ToString());
                        if (Helpers.ExecuteCommand("RMDIR \"" + toolPath + "\" /S /Q") != 0)
                        {
                            Console.ForegroundColor = ConsoleColor.Red;
                            Console.WriteLine("         Error -> RMDIR: {0}", toolPath);
                            Helpers.LogToFile("replacedyzeTools", "ERROR", "RMDIR: <" + toolPath + ">");
                            Console.ResetColor();
                        }
                        Build.Confuse(outputFolder);
                        Helpers.CalculateMD5Files(outputFolder);
                        Console.ForegroundColor = ConsoleColor.Magenta;
                        Console.WriteLine("     Output folder: {0}", outputFolder);
                        Console.ResetColor();
                    }
                    catch (Exception ex)
                    {
                        Console.WriteLine("         Error -> replacedyzing: <{0}> -> {1}", item.Children[new YamlScalarNode("name")], ex.ToString());
                        Helpers.LogToFile("replacedyzeTools", "ERROR", "replacedyzing: <" + item.Children[new YamlScalarNode("name")] + "> -> " + ex.ToString());
                    }
                }
            }

        }

public static async Task LogAsync(LogMessage message)
        {
            while (IsLoggerLocked)
            {
                await Task.Delay(1).ConfigureAwait(false);
            }
            IsLoggerLocked = true;
            switch (message.Severity)
            {
                case LogSeverity.Critical:
                    Console.ForegroundColor = ConsoleColor.DarkRed;
                    break;
                case LogSeverity.Error:
                    Console.ForegroundColor = ConsoleColor.Red;
                    break;
                case LogSeverity.Warning:
                    Console.ForegroundColor = ConsoleColor.Yellow;
                    break;
                case LogSeverity.Info:
                    Console.ForegroundColor = ConsoleColor.Green;
                    break;
                case LogSeverity.Verbose:
                    Console.ForegroundColor = ConsoleColor.Cyan;
                    break;
                case LogSeverity.Debug:
                    Console.ForegroundColor = ConsoleColor.DarkGray;
                    break;
            }
            await Console.Out.WriteLineAsync($"[{message.Source}]{message.Message}").ConfigureAwait(false);
            Console.ResetColor();
            IsLoggerLocked = false;
        }

static void ListTools()
        {
            string[] toolList = Directory.GetFiles("Tools", "*.yml");
            foreach (string tool in toolList)
            {
                string text = File.ReadAllText(tool);
                var stringReader = new StringReader(text);
                var yaml = new YamlStream();
                yaml.Load(stringReader);
                var mapping = (YamlMappingNode)yaml.Doreplacedents[0].RootNode;
                foreach (var entry in mapping.Children)
                {
                    var items = (YamlSequenceNode)mapping.Children[new YamlScalarNode("tool")];
                    foreach (YamlMappingNode item in items)
                    {
                        Console.ForegroundColor = ConsoleColor.Cyan;
                        Console.WriteLine("\n   [+] Name: {0}", item.Children[new YamlScalarNode("name")]);
                        Console.ResetColor();
                        Console.WriteLine("     - Description: {0}\n     - Git: {1}",
                            item.Children[new YamlScalarNode("description")],
                            item.Children[new YamlScalarNode("gitLink")]);
                    }
                }
            }
            Console.WriteLine();
        }

public async Task<JObject> CallGetWebApiAndProcessResultASync(string webApiUrl, string accessToken)
        {
            JObject result = null;
            if (!string.IsNullOrEmpty(accessToken))
            {
                var defaultRequetHeaders = HttpClient.DefaultRequestHeaders;
                if (defaultRequetHeaders.Accept == null || !defaultRequetHeaders.Accept.Any(m => m.MediaType == "application/json"))
                {
                    HttpClient.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json"));
                }
                defaultRequetHeaders.Authorization = new AuthenticationHeaderValue("bearer", accessToken);

                HttpResponseMessage response = await HttpClient.GetAsync(webApiUrl);
                if (response.IsSuccessStatusCode)
                {
                    var json = await response.Content.ReadreplacedtringAsync();
                    result = JsonConvert.DeserializeObject(json) as JObject;
                    Console.ForegroundColor = ConsoleColor.Gray;
                }
                else
                {
                    Console.ForegroundColor = ConsoleColor.Red;
                    Console.WriteLine($"Failed to call the Web Api: {response.StatusCode}");
                    JObject content = JObject.Parse(await response.Content.ReadreplacedtringAsync());
                    Console.WriteLine($"Content: {content}");
                    result = content;

                }
                Console.ResetColor();
            }
            return result;
        }

public void Write(string text, ConsoleColor color = ConsoleColor.White)
        {
            Console.ForegroundColor = color;
            Console.Write(text);
            Console.ResetColor();
        }

public void Write(string message, ConsoleColor? colorCode = null)
        {
            Trace.Info($"WRITE: {message}");
            if (!Silent)
            {
                if (colorCode != null)
                {
                    Console.ForegroundColor = colorCode.Value;
                    Console.Write(message);
                    Console.ResetColor();
                }
                else
                {
                    Console.Write(message);
                }
            }
        }

private void PopColors()
        {
            Console.ResetColor();
        }

internal static async Task Main(string[] args)
        {
            try
            {
                if (args.Length == 0)
                {
                    Console.WriteLine("Drag .pkg files and/or folders onto this .exe to verify the packages.");
                    var isFirstChar = true;
                    var completedPath = false;
                    var path = new StringBuilder();
                    do
                    {
                        var keyInfo = Console.ReadKey(true);
                        if (isFirstChar)
                        {
                            isFirstChar = false;
                            if (keyInfo.KeyChar != '"')
                                return;
                        }
                        else
                        {
                            if (keyInfo.KeyChar == '"')
                            {
                                completedPath = true;
                                args = new[] {path.ToString()};
                            }
                            else
                                path.Append(keyInfo.KeyChar);
                        }
                    } while (!completedPath);
                    Console.Clear();
                }

                Console.OutputEncoding = new UTF8Encoding(false);
                Console.replacedle = replacedle;
                Console.CursorVisible = false;
                Console.WriteLine("Scanning for PKGs...");
                var pkgList = new List<FileInfo>();
                Console.ForegroundColor = ConsoleColor.Yellow;
                foreach (var item in args)
                {
                    var path = item.Trim('"');
                    if (File.Exists(path))
                        pkgList.Add(new FileInfo(path));
                    else if (Directory.Exists(path))
                        pkgList.AddRange(GetFilePaths(path, "*.pkg", SearchOption.AllDirectories).Select(p => new FileInfo(p)));
                    else
                        Console.WriteLine("Unknown path: " + path);
                }
                Console.ResetColor();
                if (pkgList.Count == 0)
                {
                    Console.WriteLine("No packages were found. Check paths, and try again.");
                    return;
                }

                var longestFilename = Math.Max(pkgList.Max(i => i.Name.Length), HeaderPkgName.Length);
                var sigWidth = Math.Max(HeaderSignature.Length, 8);
                var csumWidth = Math.Max(HeaderChecksum.Length, 5);
                var csumsWidth = 1 + sigWidth + 1 + csumWidth + 1;
                var idealWidth = longestFilename + csumsWidth;
                try
                {
                    if (idealWidth > Console.LargestWindowWidth)
                    {
                        longestFilename = Console.LargestWindowWidth - csumsWidth;
                        idealWidth = Console.LargestWindowWidth;
                    }
                    if (idealWidth > Console.WindowWidth)
                    {
                        Console.BufferWidth = Math.Max(Console.BufferWidth, idealWidth);
                        Console.WindowWidth = idealWidth;
                    }
                    Console.BufferHeight = Math.Max(Console.BufferHeight, Math.Min(9999, pkgList.Count + 10));
                }
                catch (PlatformNotSupportedException) { }
                Console.WriteLine($"{HeaderPkgName.Trim(longestFilename).PadRight(longestFilename)} {HeaderSignature.PadLeft(sigWidth)} {HeaderChecksum.PadLeft(csumWidth)}");
                using var cts = new CancellationTokenSource();
                Console.CancelKeyPress += (sender, eventArgs) => { cts.Cancel(); };
                var t = new Thread(() =>
                                   {
                                       try
                                       {
                                           var indicatorIdx = 0;
                                           while (!cts.Token.IsCancellationRequested)
                                           {
                                               Task.Delay(1000, cts.Token).ConfigureAwait(false).GetAwaiter().GetResult();
                                               if (cts.Token.IsCancellationRequested)
                                                   return;

                                               PkgChecker.Sync.Wait(cts.Token);
                                               try
                                               {
                                                   var frame = Animation[(indicatorIdx++) % Animation.Length];
                                                   var currentProgress = PkgChecker.CurrentFileProcessedBytes;
                                                   Console.replacedle = $"{replacedle} [{(double)(PkgChecker.ProcessedBytes + currentProgress) / PkgChecker.TotalFileSize * 100:0.00}%] {frame}";
                                                   if (PkgChecker.CurrentPadding > 0)
                                                   {
                                                       Console.CursorVisible = false;
                                                       var (top, left) = (Console.CursorTop, Console.CursorLeft);
                                                       Console.Write($"{(double)currentProgress / PkgChecker.CurrentFileSize * 100:0}%".PadLeft(PkgChecker.CurrentPadding));
                                                       Console.CursorTop = top;
                                                       Console.CursorLeft = left;
                                                       Console.CursorVisible = false;
                                                   }
                                               }
                                               finally
                                               {
                                                   PkgChecker.Sync.Release();
                                               }
                                           }
                                       }
                                       catch (TaskCanceledException)
                                       {
                                       }
                                   });
                t.Start();
                await PkgChecker.CheckAsync(pkgList, longestFilename, sigWidth, csumWidth, csumsWidth-2, cts.Token).ConfigureAwait(false);
                cts.Cancel(false);
                t.Join();
            }
            finally
            {
                Console.replacedle = replacedle;
                Console.WriteLine("Press any key to exit");
                Console.ReadKey();
                Console.WriteLine();
                Console.CursorVisible = true;
            }
        }

private static void LogMessage(string msg, string prefix, int indent, ConsoleColor color) {
            // Indent
            Console.Write(new String(' ', indent));
            Trace.Write(new String(' ', indent));

            // Color and prefix
            Trace.Write(prefix);
            Console.ForegroundColor = color;
            Console.Write(prefix);
            Console.ResetColor();

            // Message
            Console.WriteLine($" {msg}");
            Trace.WriteLine($" {msg}");
        }

public void WriteError(Exception ex)
        {
            Trace.Error("WRITE ERROR (exception):");
            Trace.Error(ex);
            if (!Silent)
            {
                Console.ForegroundColor = ConsoleColor.Red;
                Console.Error.WriteLine(ex.Message);
                Console.ResetColor();
            }
        }

public async Task<JObject> CallDeleteWebApiAndProcessResultASync(string webApiUrl, string accessToken)
        {
            JObject result = null;
            if (!string.IsNullOrEmpty(accessToken))
            {
                var defaultRequetHeaders = HttpClient.DefaultRequestHeaders;
                if (defaultRequetHeaders.Accept == null || !defaultRequetHeaders.Accept.Any(m => m.MediaType == "application/json"))
                {
                    HttpClient.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json"));
                }
                defaultRequetHeaders.Authorization = new AuthenticationHeaderValue("bearer", accessToken);

                HttpResponseMessage response = await HttpClient.DeleteAsync(webApiUrl);
                if (response.IsSuccessStatusCode)
                {
                    var json = await response.Content.ReadreplacedtringAsync();
                    result = JsonConvert.DeserializeObject(json) as JObject;
                    Console.ForegroundColor = ConsoleColor.Gray;
                }
                else
                {
                    Console.ForegroundColor = ConsoleColor.Red;
                    Console.WriteLine($"Failed to call the Web Api: {response.StatusCode}");
                    JObject content = JObject.Parse(await response.Content.ReadreplacedtringAsync());
                    Console.WriteLine($"Content: {content}");
                    result = content;

                }
                Console.ResetColor();
            }
            return result;
        }

private static void LogInternal(Exception e, string message, LogLevel level, ConsoleColor foregroundColor, ConsoleColor? backgroundColor = null)
        {
            try
            {
#if DEBUG
                const LogLevel minLevel = LogLevel.TRACE;
#else
                const LogLevel minLevel = LogLevel.DEBUG;
#endif
                if (level >= minLevel && message != null)
                {
                    Console.ForegroundColor = foregroundColor;
                    if (backgroundColor is ConsoleColor bg)
                        Console.BackgroundColor = bg;
                    Console.WriteLine(DateTime.Now.ToString("hh:mm:ss ") + message);
                    Console.ResetColor();
                }
                if (FileLog != null)
                {
                    if (message != null)
                        FileLog.WriteLine($"{DateTime.Now:yyyy-MM-dd hh:mm:ss}\t{(long)Timer.Elapsed.TotalMilliseconds}\t{level}\t{message}");
                    if (e != null)
                        FileLog.WriteLine(e.ToString());
                    FileLog.Flush();
                }
            }
            catch { }
        }

static async Task<int> Main(string[] args)
        {
            Log.Info("PS3 Disc Dumper v" + Dumper.Version);

            if (RuntimeInformation.IsOSPlatform(OSPlatform.Linux) && Console.WindowHeight < 1 && Console.WindowWidth < 1)
                try
                {
                    Log.Error("Looks like there's no console present, restarting...");
                    var launchArgs = Environment.GetCommandLineArgs()[0];
                    if (launchArgs.Contains("/var/tmp") || launchArgs.EndsWith(".dll"))
                    {
                        Log.Debug("Looks like we were launched from a single executable, looking for the parent...");
                        using var currentProcess = Process.GetCurrentProcess();
                        var pid = currentProcess.Id;
                        var procCmdlinePath = Path.Combine("/proc", pid.ToString(), "cmdline");
                        launchArgs = File.ReadAllLines(procCmdlinePath).FirstOrDefault()?.TrimEnd('\0');
                    }
                    Log.Debug($"Using cmdline '{launchArgs}'");
                    launchArgs = $"-e bash -c {launchArgs}";
                    var startInfo = new ProcessStartInfo("x-terminal-emulator", launchArgs);
                    using var proc = Process.Start(startInfo);
                    if (proc.WaitForExit(1_000))
                    {
                        if (proc.ExitCode != 0)
                        {
                            startInfo = new ProcessStartInfo("xdg-terminal", launchArgs);
                            using var proc2 = Process.Start(startInfo);
                            if (proc2.WaitForExit(1_000))
                            {
                                if (proc2.ExitCode != 0)
                                {
                                    startInfo = new ProcessStartInfo("gnome-terminal", launchArgs);
                                    using var proc3 = Process.Start(startInfo);
                                    if (proc3.WaitForExit(1_000))
                                    {
                                        if (proc3.ExitCode != 0)
                                        {
                                            startInfo = new ProcessStartInfo("konsole", launchArgs);
                                            using var _ = Process.Start(startInfo);
                                        }
                                    }
                                }
                            }
                        }
                    }
                    return -2;
                }
                catch (Exception e)
                {
                    Log.Error(e);
                    return -3;
                }
            var lastDiscId = "";
start:
            const string replacedleBase = "PS3 Disc Dumper";
            var replacedle = replacedleBase;
            Console.replacedle = replacedle;
            var output = ".";
            var inDir = "";
            var showHelp = false;
            var options = new OptionSet
            {
                {
                    "i|input=", "Path to the root of blu-ray disc mount", v =>
                    {
                        if (v is string ind)
                            inDir = ind;
                    }
                },
                {
                    "o|output=", "Path to the output folder. Subfolder for each disc will be created automatically", v =>
                    {
                        if (v is string outd)
                            output = outd;
                    }
                },
                {
                    "?|h|help", "Show help", v =>
                    {
                        if (v != null)
                            showHelp = true;
                    },
                    true
                },
            };
            try
            {
                var unknownParams = options.Parse(args);
                if (unknownParams.Count > 0)
                {
                    Log.Warn("Unknown parameters: ");
                    foreach (var p in unknownParams)
                        Log.Warn("\t" + p);
                    showHelp = true;
                }
                if (showHelp)
                {
                    ShowHelp(options);
                    return 0;
                }

                var dumper = new Dumper(ApiConfig.Cts);
                dumper.DetectDisc(inDir);
                await dumper.FindDiscKeyAsync(ApiConfig.IrdCachePath).ConfigureAwait(false);
                if (string.IsNullOrEmpty(dumper.OutputDir))
                {
                    Log.Info("No compatible disc was found, exiting");
                    return 2;
                }
                if (lastDiscId == dumper.ProductCode)
                {
                    Console.ForegroundColor = ConsoleColor.Yellow;
                    Console.WriteLine("You're dumping the same disc, are you sure you want to continue? (Y/N, default is N)");
                    Console.ResetColor();
                    var confirmKey = Console.ReadKey(true);
                    switch (confirmKey.Key)
                    {
                        case ConsoleKey.Y:
                            break;
                        default:
                            throw new OperationCanceledException("Aborting re-dump of the same disc");
                    }
                }
                lastDiscId = dumper.ProductCode;

                replacedle += " - " + dumper.replacedle;
                var monitor = new Thread(() =>
                {
                    try
                    {
                        do
                        {
                            if (dumper.CurrentSector > 0)
                                Console.replacedle = $"{replacedle} - File {dumper.CurrentFileNumber} of {dumper.TotalFileCount} - {dumper.CurrentSector * 100.0 / dumper.TotalSectors:0.00}%";
                            Task.Delay(1000, ApiConfig.Cts.Token).GetAwaiter().GetResult();
                        } while (!ApiConfig.Cts.Token.IsCancellationRequested);
                    }
                    catch (TaskCanceledException)
                    {
                    }
                    Console.replacedle = replacedle;
                });
                monitor.Start();

                await dumper.DumpAsync(output).ConfigureAwait(false);

                ApiConfig.Cts.Cancel(false);
                monitor.Join(100);

                if (dumper.BrokenFiles.Count > 0)
                {
                    Log.Fatal("Dump is not valid");
                    foreach (var file in dumper.BrokenFiles)
                        Log.Error($"{file.error}: {file.filename}");
                }
                else
                {
                    Console.ForegroundColor = ConsoleColor.Green;
                    Console.WriteLine("Dump is valid");
                    Console.ResetColor();
                }
            }
            catch (OptionException)
            {
                ShowHelp(options);
                return 1;
            }
            catch (Exception e)
            {
                Log.Error(e, e.Message);
            }
            Console.WriteLine("Press X or Ctrl-C to exit, any other key to start again...");
            var key = Console.ReadKey(true);
            switch (key.Key)
            {
                case ConsoleKey.X:
                    return 0;
                default:
                    goto start;
            }
        }

public async Task<JObject> CallPostWebApiAndProcessResultASync(string webApiUrl, string accessToken, string data)
        {
            JObject result = null;
            if (!string.IsNullOrEmpty(accessToken))
            {
                var defaultRequetHeaders = HttpClient.DefaultRequestHeaders;
                if (defaultRequetHeaders.Accept == null || !defaultRequetHeaders.Accept.Any(m => m.MediaType == "application/json"))
                {
                    HttpClient.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json"));
                }
                defaultRequetHeaders.Authorization = new AuthenticationHeaderValue("bearer", accessToken);

                var body = new StringContent(data, Encoding.UTF8, "application/json");

                HttpResponseMessage response = await HttpClient.PostAsync(webApiUrl, body);
                if (response.IsSuccessStatusCode)
                {
                    string json = await response.Content.ReadreplacedtringAsync();
                    result = JsonConvert.DeserializeObject(json) as JObject;
                    Console.ForegroundColor = ConsoleColor.Gray;
                }
                else
                {
                    Console.ForegroundColor = ConsoleColor.Red;
                    Console.WriteLine($"Failed to call the Web Api: {response.StatusCode}");
                    JObject content = JObject.Parse(await response.Content.ReadreplacedtringAsync());

                    Console.WriteLine($"Content: {content}");
                    result = content;
                }
                Console.ResetColor();
            }
            return result;
        }

static void Main(string[] args)
        {
            do
            {
                try
                {
                    Console.Clear();
                    Console.ForegroundColor = ConsoleColor.DarkYellow;
                    Console.WriteLine("=============================================================================");
                    Console.WriteLine("*            1      -      生成模型");
                    Console.WriteLine("=============================================================================");
                    Console.Write("请选择要执行的程序 : ");
                    Console.ResetColor();

                    switch (Int32.Parse(Console.ReadLine()))
                    {
                        case 1:

                            #region  生成模型
                            Task001.Execute();
                            #endregion

                            Console.ReadKey();

                            break;
                    }
                }
                catch (Exception ex)
                {
                    Console.WriteLine(ex.Message);
                    Console.ReadKey();
                }
            } while (true);
        }

void UpdateFonts(string fontsPath, string customizePath, bool verbose)
        {
            if (!verbose)
                Console.Write("Copying fonts ... ");

            foreach (var directory in DirectoriesArray(customizePath))
            {
                foreach (var font in FilesArray(fontsPath))
                {
                    if (verbose)
                        Console.Write("Copying " + font + " ... ");

                    File.Copy(fontsPath + @"\" + font, directory + @"\" + font, true);

                    if (verbose)
                    {
                        Console.ForegroundColor = ConsoleColor.Green;
                        Console.Write("OK\n");
                        Console.ResetColor();
                    }
                }
            }

            if (!verbose)
            {
                Console.ForegroundColor = ConsoleColor.Green;
                Console.Write("OK\n");
                Console.ResetColor();
            }
        }