GoldbergGUI/GoldbergGUI.Core/Services/GoldbergService.cs

using GoldbergGUI.Core.Models;
using GoldbergGUI.Core.Utils;
using Microsoft.Extensions.Logging;
using System;
using System.Collections.Generic;
using System.IO;
using System.IO.Compression;
using System.Linq;
using System.Net.Http;
using System.Text.RegularExpressions;
using System.Threading.Tasks;
using System.Windows;

namespace GoldbergGUI.Core.Services
{
    // downloads and updates goldberg emu
    // sets up config files
    // does file copy stuff
    public interface IGoldbergService
    {
        public Task<GoldbergGlobalConfiguration> Initialize(ILogger<IGoldbergService> log);
        public Task<GoldbergConfiguration> Read(string path);
        public Task Save(string path, GoldbergConfiguration configuration);
        public Task<GoldbergGlobalConfiguration> GetGlobalSettings();
        public Task SetGlobalSettings(GoldbergGlobalConfiguration configuration);
        public bool GoldbergApplied(string path);
        public Task GenerateInterfacesFile(string filePath);
        public List<string> Languages();
    }

    // ReSharper disable once UnusedType.Global
    // ReSharper disable once ClassNeverInstantiated.Global
    public class GoldbergService : IGoldbergService
    {
        private ILogger<IGoldbergService> _log;
        private const string DefaultAccountName = "Mr_Goldberg";
        private const long DefaultSteamId = 76561197960287930;
        private const string DefaultLanguage = "english";
        private const string GoldbergUrl = "https://mr_goldberg.gitlab.io/goldberg_emulator/";
        private readonly string _goldbergZipPath = Path.Combine(Directory.GetCurrentDirectory(), "goldberg.zip");
        private readonly string _goldbergPath = Path.Combine(Directory.GetCurrentDirectory(), "goldberg");

        private static readonly string GlobalSettingsPath =
            Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.ApplicationData),
                "Goldberg SteamEmu Saves");

        private readonly string _accountNamePath = Path.Combine(GlobalSettingsPath, "settings/account_name.txt");
        private readonly string _userSteamIdPath = Path.Combine(GlobalSettingsPath, "settings/user_steam_id.txt");
        private readonly string _languagePath = Path.Combine(GlobalSettingsPath, "settings/language.txt");

        private readonly string _customBroadcastIpsPath =
            Path.Combine(GlobalSettingsPath, "settings/custom_broadcasts.txt");

        // ReSharper disable StringLiteralTypo
        private readonly List<string> _interfaceNames = new List<string>
        {
            "SteamClient",
            "SteamGameServer",
            "SteamGameServerStats",
            "SteamUser",
            "SteamFriends",
            "SteamUtils",
            "SteamMatchMaking",
            "SteamMatchMakingServers",
            "STEAMUSERSTATS_INTERFACE_VERSION",
            "STEAMAPPS_INTERFACE_VERSION",
            "SteamNetworking",
            "STEAMREMOTESTORAGE_INTERFACE_VERSION",
            "STEAMSCREENSHOTS_INTERFACE_VERSION",
            "STEAMHTTP_INTERFACE_VERSION",
            "STEAMUNIFIEDMESSAGES_INTERFACE_VERSION",
            "STEAMUGC_INTERFACE_VERSION",
            "STEAMAPPLIST_INTERFACE_VERSION",
            "STEAMMUSIC_INTERFACE_VERSION",
            "STEAMMUSICREMOTE_INTERFACE_VERSION",
            "STEAMHTMLSURFACE_INTERFACE_VERSION_",
            "STEAMINVENTORY_INTERFACE_V",
            "SteamController",
            "SteamMasterServerUpdater",
            "STEAMVIDEO_INTERFACE_V"
        };

        // Call Download
        // Get global settings
        public async Task<GoldbergGlobalConfiguration> Initialize(ILogger<IGoldbergService> log)
        {
            _log = log;

            var download = await Download().ConfigureAwait(false);
            if (download)
            {
                await Extract(_goldbergZipPath).ConfigureAwait(false);
            }

            return await GetGlobalSettings().ConfigureAwait(false);
        }

        public async Task<GoldbergGlobalConfiguration> GetGlobalSettings()
        {
            _log.LogInformation("Getting global settings...");
            var accountName = DefaultAccountName;
            var steamId = DefaultSteamId;
            var language = DefaultLanguage;
            var customBroadcastIps = new List<string>();
            if (!File.Exists(GlobalSettingsPath)) Directory.CreateDirectory(Path.Join(GlobalSettingsPath, "settings"));
            await Task.Run(() =>
            {
                if (File.Exists(_accountNamePath)) accountName = File.ReadLines(_accountNamePath).First().Trim();
                if (File.Exists(_userSteamIdPath) &&
                    !long.TryParse(File.ReadLines(_userSteamIdPath).First().Trim(), out steamId) &&
                    steamId < 76561197960265729 && steamId > 76561202255233023)
                {
                    _log.LogError("Invalid User Steam ID! Using default Steam ID...");
                    steamId = DefaultSteamId;
                }

                if (File.Exists(_languagePath)) language = File.ReadLines(_languagePath).First().Trim();
                if (File.Exists(_customBroadcastIpsPath))
                    customBroadcastIps.AddRange(
                        File.ReadLines(_customBroadcastIpsPath).Select(line => line.Trim()));
            }).ConfigureAwait(false);
            _log.LogInformation("Got global settings.");
            return new GoldbergGlobalConfiguration
            {
                AccountName = accountName,
                UserSteamId = steamId,
                Language = language,
                CustomBroadcastIps = customBroadcastIps
            };
        }

        public async Task SetGlobalSettings(GoldbergGlobalConfiguration c)
        {
            var accountName = c.AccountName;
            var userSteamId = c.UserSteamId;
            var language = c.Language;
            var customBroadcastIps = c.CustomBroadcastIps;
            _log.LogInformation("Setting global settings...");
            // Account Name
            if (!string.IsNullOrEmpty(accountName))
            {
                _log.LogInformation("Setting account name...");
                if (!File.Exists(_accountNamePath))
                    await File.Create(_accountNamePath).DisposeAsync().ConfigureAwait(false);
                await File.WriteAllTextAsync(_accountNamePath, accountName).ConfigureAwait(false);
            }
            else
            {
                _log.LogInformation("Invalid account name! Skipping...");
                if (!File.Exists(_accountNamePath))
                    await File.Create(_accountNamePath).DisposeAsync().ConfigureAwait(false);
                await File.WriteAllTextAsync(_accountNamePath, DefaultAccountName).ConfigureAwait(false);
            }

            // User SteamID
            if (userSteamId >= 76561197960265729 && userSteamId <= 76561202255233023)
            {
                _log.LogInformation("Setting user Steam ID...");
                if (!File.Exists(_userSteamIdPath))
                    await File.Create(_userSteamIdPath).DisposeAsync().ConfigureAwait(false);
                await File.WriteAllTextAsync(_userSteamIdPath, userSteamId.ToString()).ConfigureAwait(false);
            }
            else
            {
                _log.LogInformation("Invalid user Steam ID! Skipping...");
                if (!File.Exists(_userSteamIdPath))
                    await File.Create(_userSteamIdPath).DisposeAsync().ConfigureAwait(false);
                await File.WriteAllTextAsync(_userSteamIdPath, DefaultSteamId.ToString()).ConfigureAwait(false);
            }

            // Language
            if (!string.IsNullOrEmpty(language))
            {
                _log.LogInformation("Setting language...");
                if (!File.Exists(_languagePath))
                    await File.Create(_languagePath).DisposeAsync().ConfigureAwait(false);
                await File.WriteAllTextAsync(_languagePath, language).ConfigureAwait(false);
            }
            else
            {
                _log.LogInformation("Invalid language! Skipping...");
                if (!File.Exists(_languagePath))
                    await File.Create(_languagePath).DisposeAsync().ConfigureAwait(false);
                await File.WriteAllTextAsync(_languagePath, DefaultLanguage).ConfigureAwait(false);
            }

            // Custom Broadcast IPs
            if (customBroadcastIps != null && customBroadcastIps.Count > 0)
            {
                _log.LogInformation("Setting custom broadcast IPs...");
                var result =
                    customBroadcastIps.Aggregate("", (current, address) => $"{current}{address}\n");
                if (!File.Exists(_customBroadcastIpsPath))
                    await File.Create(_customBroadcastIpsPath).DisposeAsync().ConfigureAwait(false);
                await File.WriteAllTextAsync(_customBroadcastIpsPath, result).ConfigureAwait(false);
            }
            else
            {
                _log.LogInformation("Empty list of custom broadcast IPs! Skipping...");
                await Task.Run(() => File.Delete(_customBroadcastIpsPath)).ConfigureAwait(false);
            }
            _log.LogInformation("Setting global configuration finished.");
        }

        // If first time, call GenerateInterfaces
        // else try to read config
        public async Task<GoldbergConfiguration> Read(string path)
        {
            _log.LogInformation("Reading configuration...");
            var appId = -1;
            var achievementList = new List<Achievement>();
            var dlcList = new List<DlcApp>();
            var steamAppidTxt = Path.Combine(path, "steam_appid.txt");
            if (File.Exists(steamAppidTxt))
            {
                _log.LogInformation("Getting AppID...");
                await Task.Run(() => int.TryParse(File.ReadLines(steamAppidTxt).First().Trim(), out appId))
                    .ConfigureAwait(false);
            }
            else
            {
                _log.LogInformation(@"""steam_appid.txt"" missing! Skipping...");
            }

            var achievementJson = Path.Combine(path, "steam_settings", "achievements.json");
            if (File.Exists(achievementJson))
            {
                _log.LogInformation("Getting achievements...");
                var json = await File.ReadAllTextAsync(achievementJson)
                    .ConfigureAwait(false);
                achievementList = System.Text.Json.JsonSerializer.Deserialize<List<Achievement>>(json);
            }
            else
            {
                _log.LogInformation(@"""steam_settings/achievements.json"" missing! Skipping...");
            }

            var dlcTxt = Path.Combine(path, "steam_settings", "DLC.txt");
            var appPathTxt = Path.Combine(path, "steam_settings", "app_paths.txt");
            if (File.Exists(dlcTxt))
            {
                _log.LogInformation("Getting DLCs...");
                var readAllLinesAsync = await File.ReadAllLinesAsync(dlcTxt).ConfigureAwait(false);
                var expression = new Regex(@"(?<id>.*) *= *(?<name>.*)");
                // ReSharper disable once LoopCanBeConvertedToQuery
                foreach (var line in readAllLinesAsync)
                {
                    var match = expression.Match(line);
                    if (match.Success)
                        dlcList.Add(new DlcApp()
                        {
                            AppId = Convert.ToInt32(match.Groups["id"].Value),
                            Name = match.Groups["name"].Value
                        });
                }

                // ReSharper disable once InvertIf
                if (File.Exists(appPathTxt))
                {
                    var appPathAllLinesAsync = await File.ReadAllLinesAsync(appPathTxt).ConfigureAwait(false);
                    var appPathExpression = new Regex(@"(?<id>.*) *= *(?<appPath>.*)");
                    foreach (var line in appPathAllLinesAsync)
                    {
                        var match = appPathExpression.Match(line);
                        if (!match.Success) continue;
                        var i = dlcList.FindIndex(x =>
                            x.AppId.Equals(Convert.ToInt32(match.Groups["id"].Value)));
                        dlcList[i].AppPath = match.Groups["appPath"].Value;
                    }
                }
            }
            else
            {
                _log.LogInformation(@"""steam_settings/DLC.txt"" missing! Skipping...");
            }

            return new GoldbergConfiguration
            {
                AppId = appId,
                Achievements = achievementList,
                DlcList = dlcList,
                Offline = File.Exists(Path.Combine(path, "steam_settings", "offline.txt")),
                DisableNetworking = File.Exists(Path.Combine(path, "steam_settings", "disable_networking.txt")),
                DisableOverlay = File.Exists(Path.Combine(path, "steam_settings", "disable_overlay.txt"))
            };
        }

        // If first time, rename original SteamAPI DLL to steam_api(64)_o.dll
        // If not, rename current SteamAPI DLL to steam_api(64).dll.backup
        // Copy Goldberg DLL to path
        // Save configuration files
        public async Task Save(string path, GoldbergConfiguration c)
        {
            _log.LogInformation("Saving configuration...");
            // DLL setup
            _log.LogInformation("Running DLL setup...");
            const string x86Name = "steam_api";
            const string x64Name = "steam_api64";
            if (File.Exists(Path.Combine(path, $"{x86Name}.dll")))
            {
                CopyDllFiles(path, x86Name);
            }

            if (File.Exists(Path.Combine(path, $"{x64Name}.dll")))
            {
                CopyDllFiles(path, x64Name);
            }
            _log.LogInformation("DLL setup finished!");

            // Create steam_settings folder if missing
            _log.LogInformation("Saving settings...");
            if (!Directory.Exists(Path.Combine(path, "steam_settings")))
            {
                Directory.CreateDirectory(Path.Combine(path, "steam_settings"));
            }

            // create steam_appid.txt
            await File.WriteAllTextAsync(Path.Combine(path, "steam_appid.txt"), c.AppId.ToString())
                .ConfigureAwait(false);

            // Achievements + Images
            if (c.Achievements.Count > 0)
            {
                _log.LogInformation("Downloading images...");
                var imagePath = Path.Combine(path, "steam_settings", "images");
                Directory.CreateDirectory(imagePath);

                foreach (var achievement in c.Achievements)
                {
                    await DownloadImageAsync(imagePath, achievement.Icon);
                    await DownloadImageAsync(imagePath, achievement.IconGray);

                    // Update achievement list to point to local images instead
                    achievement.Icon = $"images/{Path.GetFileName(achievement.Icon)}";
                    achievement.IconGray = $"images/{Path.GetFileName(achievement.IconGray)}";
                }

                _log.LogInformation("Saving achievements...");

                var achievementJson = System.Text.Json.JsonSerializer.Serialize(
                    c.Achievements,
                    new System.Text.Json.JsonSerializerOptions
                    {
                        Encoder = System.Text.Encodings.Web.JavaScriptEncoder.UnsafeRelaxedJsonEscaping,
                        WriteIndented = true
                    });
                await File.WriteAllTextAsync(Path.Combine(path, "steam_settings", "achievements.json"), achievementJson)
                    .ConfigureAwait(false);

                _log.LogInformation("Finished saving achievements.");
            }
            else
            {
                _log.LogInformation("No achievements set! Removing achievement files...");
                var imagePath = Path.Combine(path, "steam_settings", "images");
                if (Directory.Exists(imagePath))
                {
                    Directory.Delete(imagePath);
                }
                var achievementPath = Path.Combine(path, "steam_settings", "achievements");
                if (File.Exists(achievementPath))
                {
                    File.Delete(achievementPath);
                }
                _log.LogInformation("Removed achievement files.");
            }

            // DLC + App path
            if (c.DlcList.Count > 0)
            {
                _log.LogInformation("Saving DLC settings...");
                var dlcContent = "";
                //var depotContent = "";
                var appPathContent = "";
                c.DlcList.ForEach(x =>
                {
                    dlcContent += $"{x}\n";
                    //depotContent += $"{x.DepotId}\n";
                    if (!string.IsNullOrEmpty(x.AppPath))
                        appPathContent += $"{x.AppId}={x.AppPath}\n";
                });
                await File.WriteAllTextAsync(Path.Combine(path, "steam_settings", "DLC.txt"), dlcContent)
                    .ConfigureAwait(false);

                /*if (!string.IsNullOrEmpty(depotContent))
                {
                    await File.WriteAllTextAsync(Path.Combine(path, "steam_settings", "depots.txt"), depotContent)
                        .ConfigureAwait(false);
                }*/


                if (!string.IsNullOrEmpty(appPathContent))
                {
                    await File.WriteAllTextAsync(Path.Combine(path, "steam_settings", "app_paths.txt"), appPathContent)
                        .ConfigureAwait(false);
                }
                else
                {
                    if (File.Exists(Path.Combine(path, "steam_settings", "app_paths.txt")))
                        File.Delete(Path.Combine(path, "steam_settings", "app_paths.txt"));
                }
                _log.LogInformation("Saved DLC settings.");
            }
            else
            {
                _log.LogInformation("No DLC set! Removing DLC configuration files...");
                if (File.Exists(Path.Combine(path, "steam_settings", "DLC.txt")))
                    File.Delete(Path.Combine(path, "steam_settings", "DLC.txt"));
                if (File.Exists(Path.Combine(path, "steam_settings", "app_paths.txt")))
                    File.Delete(Path.Combine(path, "steam_settings", "app_paths.txt"));
                _log.LogInformation("Removed DLC configuration files.");
            }

            // Offline
            if (c.Offline)
            {
                _log.LogInformation("Create offline.txt");
                await File.Create(Path.Combine(path, "steam_settings", "offline.txt")).DisposeAsync()
                    .ConfigureAwait(false);
            }
            else
            {
                _log.LogInformation("Delete offline.txt if it exists");
                File.Delete(Path.Combine(path, "steam_settings", "offline.txt"));
            }

            // Disable Networking
            if (c.DisableNetworking)
            {
                _log.LogInformation("Create disable_networking.txt");
                await File.Create(Path.Combine(path, "steam_settings", "disable_networking.txt")).DisposeAsync()
                    .ConfigureAwait(false);
            }
            else
            {
                _log.LogInformation("Delete disable_networking.txt if it exists");
                File.Delete(Path.Combine(path, "steam_settings", "disable_networking.txt"));
            }

            // Disable Overlay
            if (c.DisableOverlay)
            {
                _log.LogInformation("Create disable_overlay.txt");
                await File.Create(Path.Combine(path, "steam_settings", "disable_overlay.txt")).DisposeAsync()
                    .ConfigureAwait(false);
            }
            else
            {
                _log.LogInformation("Delete disable_overlay.txt if it exists");
                File.Delete(Path.Combine(path, "steam_settings", "disable_overlay.txt"));
            }
        }

        private void CopyDllFiles(string path, string name)
        {
            var steamApiDll = Path.Combine(path, $"{name}.dll");
            var originalDll = Path.Combine(path, $"{name}_o.dll");
            var guiBackup = Path.Combine(path, $".{name}.dll.GOLDBERGGUIBACKUP");
            var goldbergDll = Path.Combine(_goldbergPath, $"{name}.dll");

            if (!File.Exists(originalDll))
            {
                _log.LogInformation("Back up original Steam API DLL...");
                File.Move(steamApiDll, originalDll);
            }
            else
            {
                File.Move(steamApiDll, guiBackup, true);
                File.SetAttributes(guiBackup, FileAttributes.Hidden);
            }

            _log.LogInformation("Copy Goldberg DLL to target path...");
            File.Copy(goldbergDll, steamApiDll);
        }

        public bool GoldbergApplied(string path)
        {
            var steamSettingsDirExists = Directory.Exists(Path.Combine(path, "steam_settings"));
            var steamAppIdTxtExists = File.Exists(Path.Combine(path, "steam_appid.txt"));
            _log.LogDebug($"Goldberg applied? {steamSettingsDirExists && steamAppIdTxtExists}");
            return steamSettingsDirExists && steamAppIdTxtExists;
        }

        private async Task<bool> Download()
        {
            // Get webpage
            // Get job id, compare with local if exists, save it if false or missing
            // Get latest archive if mismatch, call Extract
            _log.LogInformation("Initializing download...");
            if (!Directory.Exists(_goldbergPath)) Directory.CreateDirectory(_goldbergPath);
            var client = new HttpClient();
            var response = await client.GetAsync(GoldbergUrl).ConfigureAwait(false);
            var body = await response.Content.ReadAsStringAsync().ConfigureAwait(false);
            var regex = new Regex(
                @"https:\/\/gitlab\.com\/Mr_Goldberg\/goldberg_emulator\/-\/jobs\/(?<jobid>.*)\/artifacts\/download");
            var jobIdPath = Path.Combine(_goldbergPath, "job_id");
            var match = regex.Match(body);
            if (File.Exists(jobIdPath))
            {
                try
                {
                    _log.LogInformation("Check if update is needed...");
                    var jobIdLocal = Convert.ToInt32(File.ReadLines(jobIdPath).First().Trim());
                    var jobIdRemote = Convert.ToInt32(match.Groups["jobid"].Value);
                    _log.LogDebug($"job_id: local {jobIdLocal}; remote {jobIdRemote}");
                    if (jobIdLocal.Equals(jobIdRemote))
                    {
                        _log.LogInformation("Latest Goldberg emulator is already available! Skipping...");
                        return false;
                    }
                }
                catch (Exception)
                {
                    _log.LogError("An error occured, local Goldberg setup might be broken!");
                }
            }

            _log.LogInformation("Starting download...");
            await StartDownload(match.Value).ConfigureAwait(false);
            return true;
        }

        private async Task StartDownload(string downloadUrl)
        {
            try
            {
                var client = new HttpClient();
                _log.LogDebug(downloadUrl);
                await using var fileStream = File.OpenWrite(_goldbergZipPath);
                //client.GetAsync(downloadUrl, HttpCompletionOption.ResponseHeadersRead)
                var httpRequestMessage = new HttpRequestMessage(HttpMethod.Head, downloadUrl);
                var headResponse = await client.SendAsync(httpRequestMessage).ConfigureAwait(false);
                var contentLength = headResponse.Content.Headers.ContentLength;
                await client.GetFileAsync(downloadUrl, fileStream).ContinueWith(async t =>
                {
                    // ReSharper disable once AccessToDisposedClosure
                    await fileStream.DisposeAsync().ConfigureAwait(false);
                    var fileLength = new FileInfo(_goldbergZipPath).Length;
                    // Environment.Exit(128);
                    if (contentLength == fileLength)
                    {
                        _log.LogInformation("Download finished!");
                    }
                    else
                    {
                        throw new Exception("File size does not match!");
                    }
                }).ConfigureAwait(false);
            }
            catch (Exception e)
            {
                ShowErrorMessage();
                _log.LogError(e.ToString());
                Environment.Exit(1);
            }
        }

        // Empty subfolder ./goldberg/
        // Extract all from archive to subfolder ./goldberg/
        private async Task Extract(string archivePath)
        {
            var errorOccured = false;
            _log.LogDebug("Start extraction...");
            Directory.Delete(_goldbergPath, true);
            Directory.CreateDirectory(_goldbergPath);
            using (var archive = await Task.Run(() => ZipFile.OpenRead(archivePath)).ConfigureAwait(false))
            {
                foreach (var entry in archive.Entries)
                {
                    await Task.Run(() =>
                    {
                        try
                        {
                            var fullPath = Path.Combine(_goldbergPath, entry.FullName);
                            if (string.IsNullOrEmpty(entry.Name))
                            {
                                Directory.CreateDirectory(fullPath);
                            }
                            else
                            {
                                entry.ExtractToFile(fullPath, true);
                            }
                        }
                        catch (Exception e)
                        {
                            errorOccured = true;
                            _log.LogError($"Error while trying to extract {entry.FullName}");
                            _log.LogError(e.ToString());
                        }
                    }).ConfigureAwait(false);
                }
            }

            if (errorOccured)
            {
                ShowErrorMessage();
                _log.LogWarning("Error occured while extraction! Please setup Goldberg manually");
            }
            _log.LogInformation("Extraction was successful!");
        }

        private void ShowErrorMessage()
        {
            if (Directory.Exists(_goldbergPath))
            {
                Directory.Delete(_goldbergPath, true);
            }

            Directory.CreateDirectory(_goldbergPath);
            MessageBox.Show("Could not setup Goldberg Emulator!\n" +
                            "Please download it manually and extract its content into the \"goldberg\" subfolder!");
        }

        // https://gitlab.com/Mr_Goldberg/goldberg_emulator/-/blob/master/generate_interfaces_file.cpp
        // (maybe) check DLL date first
        public async Task GenerateInterfacesFile(string filePath)
        {
            _log.LogDebug($"GenerateInterfacesFile {filePath}");
            //throw new NotImplementedException();
            // Get DLL content
            var result = new HashSet<string>();
            var dllContent = await File.ReadAllTextAsync(filePath).ConfigureAwait(false);
            // find interfaces
            foreach (var name in _interfaceNames)
            {
                FindInterfaces(ref result, dllContent, new Regex($"{name}\\d{{3}}"));
                if (!FindInterfaces(ref result, dllContent, new Regex(@"STEAMCONTROLLER_INTERFACE_VERSION\d{3}")))
                {
                    FindInterfaces(ref result, dllContent, new Regex("STEAMCONTROLLER_INTERFACE_VERSION"));
                }
            }

            var dirPath = Path.GetDirectoryName(filePath);
            if (dirPath == null) return;
            await using var destination = File.CreateText(dirPath + "/steam_interfaces.txt");
            foreach (var s in result)
            {
                await destination.WriteLineAsync(s).ConfigureAwait(false);
            }
        }

        public List<string> Languages() => new List<string>
        {
            DefaultLanguage,
            "arabic",
            "bulgarian",
            "schinese",
            "tchinese",
            "czech",
            "danish",
            "dutch",
            "finnish",
            "french",
            "german",
            "greek",
            "hungarian",
            "italian",
            "japanese",
            "koreana",
            "norwegian",
            "polish",
            "portuguese",
            "brazilian",
            "romanian",
            "russian",
            "spanish",
            "swedish",
            "thai",
            "turkish",
            "ukrainian"
        };

        private static bool FindInterfaces(ref HashSet<string> result, string dllContent, Regex regex)
        {
            var success = false;
            var matches = regex.Matches(dllContent);
            foreach (Match match in matches)
            {
                success = true;
                //result += $@"{match.Value}\n";
                result.Add(match.Value);
            }

            return success;
        }

        private async Task DownloadImageAsync(string imageFolder, string imageUrl)
        {
            var fileName = Path.GetFileName(imageUrl);
            var targetPath = Path.Combine(imageFolder, fileName);
            if (File.Exists(targetPath))
            {
                return;
            }
            else if (imageUrl.StartsWith("images/"))
            {
                _log.LogWarning($"Previously downloaded image '{imageUrl}' is now missing!");
            }

            var wc = new System.Net.WebClient();
            await wc.DownloadFileTaskAsync(new Uri(imageUrl, UriKind.Absolute), targetPath);
        }
    }
}