using System;
using System.Collections.Generic;
using System.Diagnostics.CodeAnalysis;
using System.Globalization;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Text;
using System.Text.RegularExpressions;
using System.Threading;
using MinecraftClient.Protocol;
using MinecraftClient.Proxy;
using Tomlet;
using Tomlet.Attributes;
using Tomlet.Models;
using static MinecraftClient.Settings.AppVarConfigHelper;
using static MinecraftClient.Settings.ChatBotConfigHealper;
using static MinecraftClient.Settings.ChatFormatConfigHelper;
using static MinecraftClient.Settings.ConsoleConfigHealper;
using static MinecraftClient.Settings.HeadCommentHealper;
using static MinecraftClient.Settings.LoggingConfigHealper;
using static MinecraftClient.Settings.MainConfigHelper;
using static MinecraftClient.Settings.MainConfigHelper.MainConfig;
using static MinecraftClient.Settings.MainConfigHelper.MainConfig.AdvancedConfig;
using static MinecraftClient.Settings.MCSettingsConfigHealper;
using static MinecraftClient.Settings.SignatureConfigHelper;

namespace MinecraftClient
{
    public static class Settings
    {
        private const int CommentsAlignPosition = 45;
        private readonly static Regex CommentRegex = new(@"^(.*)\s?#\s\$([\w\.]+)\$\s*$$", RegexOptions.Compiled);

        // Other Settings
        public const string TranslationsFile_Version = "1.19.3";
        public const string TranslationsFile_Website_Index = "https://piston-meta.mojang.com/v1/packages/c492375ded5da34b646b8c5c0842a0028bc69cec/2.json";
        public const string TranslationsFile_Website_Download = "https://resources.download.minecraft.net";

        public const string TranslationProjectUrl = "https://crowdin.com/project/minecraft-console-client";
        public const int ClientTicksPerSecond = 20;
        public const int ClientTickIntervalMilliseconds = 1000 / ClientTicksPerSecond;

        public static GlobalConfig Config = new();

        public static class InternalConfig
        {
            public static string ServerIP = String.Empty;

            public static ushort ServerPort = 25565;

            public static AccountInfoConfig Account = new();

            public static string Username = string.Empty;

            public static string MinecraftVersion = string.Empty;

            public static bool InteractiveMode = true;

            public static bool GravityEnabled = true;

            public static bool KeepAccountSettings = false;

            public static bool KeepServerSettings = false;
        }

        public class GlobalConfig
        {
            [TomlPrecedingComment("$Head$")]
            public HeadComment Head
            {
                get { return HeadCommentHealper.Config; }
                set { HeadCommentHealper.Config = value; HeadCommentHealper.Config.OnSettingUpdate(); }
            }

            public MainConfig Main
            {
                get { return MainConfigHelper.Config; }
                set { MainConfigHelper.Config = value; MainConfigHelper.Config.OnSettingUpdate(); }
            }

            [TomlPrecedingComment("$Signature$")]
            public SignatureConfig Signature
            {
                get { return SignatureConfigHelper.Config; }
                set { SignatureConfigHelper.Config = value; SignatureConfigHelper.Config.OnSettingUpdate(); }
            }

            [TomlPrecedingComment("$Logging$")]
            public LoggingConfig Logging
            {
                get { return LoggingConfigHealper.Config; }
                set { LoggingConfigHealper.Config = value; LoggingConfigHealper.Config.OnSettingUpdate(); }
            }

            public ConsoleConfig Console
            {
                get { return ConsoleConfigHealper.Config; }
                set { ConsoleConfigHealper.Config = value; ConsoleConfigHealper.Config.OnSettingUpdate(); }
            }

            public AppVarConfig AppVar
            {
                get { return AppVarConfigHelper.Config; }
                set { AppVarConfigHelper.Config = value; AppVarConfigHelper.Config.OnSettingUpdate(); }
            }

            [TomlPrecedingComment("$Proxy$")]
            public ProxyHandler.Configs Proxy
            {
                get { return ProxyHandler.Config; }
                set { ProxyHandler.Config = value; ProxyHandler.Config.OnSettingUpdate(); }
            }

            [TomlPrecedingComment("$MCSettings$")]
            public MCSettingsConfig MCSettings
            {
                get { return MCSettingsConfigHealper.Config; }
                set { MCSettingsConfigHealper.Config = value; MCSettingsConfigHealper.Config.OnSettingUpdate(); }
            }

            [TomlPrecedingComment("$ChatFormat$")]
            public ChatFormatConfig ChatFormat
            {
                get { return ChatFormatConfigHelper.Config; }
                set { ChatFormatConfigHelper.Config = value; ChatFormatConfigHelper.Config.OnSettingUpdate(); }
            }

            [TomlPrecedingComment("$ChatBot$")]
            public ChatBotConfig ChatBot
            {
                get { return ChatBotConfigHealper.Config; }
                set { ChatBotConfigHealper.Config = value; }
            }

        }

        /// <summary>
        /// Structured result returned by <see cref="LoadFromFile(string, bool)"/>.
        /// </summary>
        public readonly struct ConfigLoadResult
        {
            public bool Success { get; init; }
            public bool NeedWriteDefault { get; init; }
            /// <summary>True when a pre-TOML legacy config was detected, backed up, and a fresh default is needed.</summary>
            public bool IsLegacyUpgrade { get; init; }
            /// <summary>Non-null when the load failed due to a parse/IO error (not a legacy upgrade).</summary>
            public string? ErrorMessage { get; init; }
            /// <summary>Path where the old config was backed up (legacy upgrade case).</summary>
            public string? LegacyBackupPath { get; init; }
        }

        public static ConfigLoadResult LoadFromFile(string filepath, bool keepAccountAndServerSettings = false)
        {
            bool keepAccountSettings = InternalConfig.KeepAccountSettings;
            bool keepServerSettings = InternalConfig.KeepServerSettings;
            if (keepAccountAndServerSettings)
                InternalConfig.KeepAccountSettings = InternalConfig.KeepServerSettings = true;

            Thread.CurrentThread.CurrentCulture = CultureInfo.InvariantCulture;
            TomlDocument document;
            try
            {
                document = TomlParser.ParseFile(filepath);
                Thread.CurrentThread.CurrentCulture = Program.ActualCulture;

                Config = TomletMain.To<GlobalConfig>(document);
            }
            catch (Exception ex)
            {
                Thread.CurrentThread.CurrentCulture = Program.ActualCulture;
                try
                {
                    string configString = File.ReadAllText(filepath);
                    if (configString.Contains("Some settings missing here after an upgrade?"))
                    {
                        string newFilePath = Path.ChangeExtension(filepath, ".old.ini");
                        File.Copy(filepath, newFilePath, true);
                        return new ConfigLoadResult
                        {
                            Success = false,
                            NeedWriteDefault = true,
                            IsLegacyUpgrade = true,
                            LegacyBackupPath = newFilePath
                        };
                    }
                }
                catch { }
                return new ConfigLoadResult
                {
                    Success = false,
                    NeedWriteDefault = false,
                    ErrorMessage = ex.GetFullMessage()
                };
            }
            finally
            {
                if (!keepAccountSettings)
                    InternalConfig.KeepAccountSettings = false;
                if (!keepServerSettings)
                    InternalConfig.KeepServerSettings = false;
            }
            return new ConfigLoadResult { Success = true, NeedWriteDefault = false };
        }

        public static void WriteToFile(string filepath, bool backupOldFile)
        {
            Thread.CurrentThread.CurrentCulture = CultureInfo.InvariantCulture;
            string tomlString = TomletMain.TomlStringFrom(Config);
            Thread.CurrentThread.CurrentCulture = Program.ActualCulture;
            tomlString = RemoveLegacyAuthServerSection(tomlString);

            string[] tomlList = tomlString.Split('\n');
            StringBuilder newConfig = new();
            foreach (string line in tomlList)
            {
                Match matchComment = CommentRegex.Match(line);
                if (matchComment.Success && matchComment.Groups.Count == 3)
                {
                    string config = matchComment.Groups[1].Value, comment = matchComment.Groups[2].Value;
                    if (config.Length > 0)
                        newConfig.Append(config).Append(' ', Math.Max(1, CommentsAlignPosition - config.Length) - 1);
                    string? comment_trans = ConfigComments.ResourceManager.GetString(comment);
                    if (string.IsNullOrEmpty(comment_trans))
                        newConfig.Append("# ").AppendLine(comment.ReplaceLineEndings());
                    else
                        newConfig.Append("# ").AppendLine(comment_trans.Replace("\n", "\n# ").ReplaceLineEndings());
                }
                else
                {
                    newConfig.AppendLine(line);
                }
            }

            bool needUpdate = true;
            byte[] newConfigByte = Encoding.UTF8.GetBytes(newConfig.ToString());
            if (File.Exists(filepath))
            {
                try
                {
                    if (new FileInfo(filepath).Length == newConfigByte.Length)
                        if (File.ReadAllBytes(filepath).SequenceEqual(newConfigByte))
                            needUpdate = false;
                }
                catch { }
            }

            if (needUpdate)
            {
                bool backupSuccessed = true;
                if (backupOldFile && File.Exists(filepath))
                {
                    string backupFilePath = Path.ChangeExtension(filepath, ".backup.ini");
                    try { File.Copy(filepath, backupFilePath, true); }
                    catch (Exception ex)
                    {
                        backupSuccessed = false;
                        ConsoleIO.WriteLineFormatted("§c" + string.Format(Translations.config_backup_fail, backupFilePath));
                        ConsoleIO.WriteLine(ex.Message);
                    }
                }

                if (backupSuccessed)
                {
                    try { File.WriteAllBytes(filepath, newConfigByte); }
                    catch (Exception ex)
                    {
                        ConsoleIO.WriteLineFormatted("§c" + string.Format(Translations.config_write_fail, filepath));
                        ConsoleIO.WriteLine(ex.Message);
                    }
                }
            }
        }

        private static string RemoveLegacyAuthServerSection(string tomlString)
        {
            const string legacySection = "[Main.General.AuthServer]";
            int sectionStart = tomlString.IndexOf(legacySection, StringComparison.Ordinal);
            if (sectionStart < 0)
                return tomlString;

            int nextSection = tomlString.IndexOf("\n[", sectionStart + legacySection.Length, StringComparison.Ordinal);
            return nextSection < 0
                ? tomlString[..sectionStart]
                : tomlString.Remove(sectionStart, nextSection - sectionStart + 1);
        }

        /// <summary>
        /// Load settings from the command line
        /// </summary>
        /// <param name="args">Command-line arguments</param>
        /// <exception cref="System.ArgumentException">Thrown on invalid arguments</exception>
        public static void LoadArguments(string[] args)
        {
            int positionalIndex = 0;
            bool skipPassword = false;

            foreach (string argument in args)
            {
                if (argument.StartsWith("--"))
                {
                    //Load settings as --setting=value and --section.setting=value
                    if (!argument.Contains('='))
                        throw new ArgumentException(string.Format(Translations.error_setting_argument_syntax, argument));

                    string argumentBody = argument[2..];
                    int separatorIndex = argumentBody.IndexOf('=');
                    if (separatorIndex < 1)
                        throw new ArgumentException(string.Format(Translations.error_setting_argument_syntax, argument));

                    string settingName = argumentBody[..separatorIndex].Trim();
                    string settingValue = argumentBody[(separatorIndex + 1)..].Trim();

                    if (!TryApplyArgumentSetting(settingName, settingValue))
                        throw new ArgumentException(string.Format(Translations.error_setting_argument_syntax, argument));
                }
                else if (argument.StartsWith("-") && argument.Length > 1)
                {
                    //Keep single dash arguments as unsupported for now (future use)
                    throw new ArgumentException(string.Format(Translations.error_setting_argument_syntax, argument));
                }
                else
                {
                    switch (positionalIndex)
                    {
                        case 0:
                            if (Config.Main.Advanced.AccountList.TryGetValue(argument, out AccountInfoConfig accountInfo))
                            {
                                InternalConfig.Account = accountInfo;
                                skipPassword = true;
                            }
                            else
                            {
                                InternalConfig.Account.Login = argument;
                            }
                            InternalConfig.KeepAccountSettings = true;
                            break;
                        case 1:
                            if (!skipPassword)
                                InternalConfig.Account.Password = argument;
                            break;
                        case 2:
                            Config.Main.SetServerIP(new MainConfig.ServerInfoConfig(argument), true);
                            InternalConfig.KeepServerSettings = true;
                            break;
                        case 3:
                            // SingleCommand = argument; 
                            break;
                    }
                    positionalIndex++;
                }
            }
        }

        private static readonly string[][] s_argumentSettingSearchPrefixes =
        [
            [],
            ["Main", "Advanced"],
            ["Main", "General"],
            ["Main"],
            ["Logging"],
            ["Console", "General"],
            ["Console", "CommandSuggestion"],
            ["Console"],
            ["MCSettings"],
            ["ChatFormat"],
            ["ChatBot"],
            ["Signature"],
            ["Proxy"],
            ["AppVar"]
        ];

        private static bool TryApplyArgumentSetting(string settingPath, string settingValue)
        {
            if (string.IsNullOrWhiteSpace(settingPath))
                return false;

            string[] settingParts = settingPath
                .Split('.', StringSplitOptions.RemoveEmptyEntries | StringSplitOptions.TrimEntries);

            if (settingParts.Length == 0)
                return false;

            HashSet<string> triedPaths = new(StringComparer.Ordinal);
            foreach (string[] prefix in s_argumentSettingSearchPrefixes)
            {
                string[] fullPath = [.. prefix, .. settingParts];
                string pathKey = string.Join('.', fullPath.Select(NormalizeArgumentToken));
                if (!triedPaths.Add(pathKey))
                    continue;

                if (!TryResolveArgumentSettingPath(fullPath, out object owner, out MemberInfo member, out List<object> objectPath))
                    continue;

                if (!TryConvertArgumentValue(settingValue, GetMemberType(member), out object? convertedValue))
                    return false;

                if (!TrySetMemberValue(owner, member, convertedValue))
                    return false;

                ApplyOnSettingUpdate(objectPath);
                return true;
            }

            return false;
        }

        private static bool TryResolveArgumentSettingPath(string[] fullPath, out object owner, out MemberInfo member, out List<object> objectPath)
        {
            owner = Config;
            objectPath = [owner];
            member = null!;

            for (int i = 0; i < fullPath.Length; i++)
            {
                if (!TryGetArgumentMember(owner.GetType(), fullPath[i], out MemberInfo currentMember))
                    return false;

                if (i == fullPath.Length - 1)
                {
                    member = currentMember;
                    return true;
                }

                object? nextObject = GetMemberValue(owner, currentMember);
                if (nextObject is null)
                    return false;

                owner = nextObject;
                objectPath.Add(owner);
            }

            return false;
        }

        private static bool TryGetArgumentMember(Type ownerType, string token, out MemberInfo member)
        {
            ArgumentNullException.ThrowIfNull(ownerType);

            string normalizedToken = NormalizeArgumentToken(token);
            BindingFlags flags = BindingFlags.Instance | BindingFlags.Public;

            foreach (PropertyInfo property in ownerType.GetProperties(flags))
            {
                if (!property.CanRead || !property.CanWrite || property.GetIndexParameters().Length > 0)
                    continue;

                if (NormalizeArgumentToken(property.Name) == normalizedToken)
                {
                    member = property;
                    return true;
                }
            }

            foreach (FieldInfo field in ownerType.GetFields(flags))
            {
                if (NormalizeArgumentToken(field.Name) == normalizedToken)
                {
                    member = field;
                    return true;
                }
            }

            member = null!;
            return false;
        }

        private static string NormalizeArgumentToken(string token)
        {
            return ToLowerIfNeed(token.Replace("_", string.Empty, StringComparison.Ordinal)
                                       .Replace("-", string.Empty, StringComparison.Ordinal));
        }

        private static Type GetMemberType(MemberInfo member)
        {
            return member switch
            {
                PropertyInfo property => property.PropertyType,
                FieldInfo field => field.FieldType,
                _ => throw new ArgumentException($"Unsupported member type: {member.MemberType}", nameof(member))
            };
        }

        private static object? GetMemberValue(object owner, MemberInfo member)
        {
            return member switch
            {
                PropertyInfo property => property.GetValue(owner),
                FieldInfo field => field.GetValue(owner),
                _ => null
            };
        }

        private static bool TrySetMemberValue(object owner, MemberInfo member, object? value)
        {
            switch (member)
            {
                case PropertyInfo property:
                    property.SetValue(owner, value);
                    return true;
                case FieldInfo field:
                    field.SetValue(owner, value);
                    return true;
                default:
                    return false;
            }
        }

        private static bool TryConvertArgumentValue(string input, Type targetType, out object? converted)
        {
            Type effectiveType = Nullable.GetUnderlyingType(targetType) ?? targetType;

            if (effectiveType == typeof(string))
            {
                converted = input;
                return true;
            }

            if (effectiveType == typeof(bool))
            {
                bool success = bool.TryParse(input, out bool value);
                converted = value;
                return success;
            }

            if (effectiveType.IsEnum)
            {
                bool success = Enum.TryParse(effectiveType, input, true, out object? value);
                converted = value;
                return success;
            }

            try
            {
                converted = Convert.ChangeType(input, effectiveType, CultureInfo.InvariantCulture);
                return true;
            }
            catch (InvalidCastException)
            {
                converted = null;
                return false;
            }
            catch (FormatException)
            {
                converted = null;
                return false;
            }
            catch (OverflowException)
            {
                converted = null;
                return false;
            }
        }

        private static void ApplyOnSettingUpdate(List<object> objectPath)
        {
            HashSet<object> calledObjects = new(ReferenceEqualityComparer.Instance);

            for (int i = objectPath.Count - 1; i >= 0; i--)
            {
                object target = objectPath[i];
                if (!calledObjects.Add(target))
                    continue;

                MethodInfo? onSettingUpdate = target.GetType().GetMethod(nameof(MainConfig.OnSettingUpdate), BindingFlags.Instance | BindingFlags.Public, []);
                onSettingUpdate?.Invoke(target, null);
            }
        }

        public static class HeadCommentHealper
        {
            public static HeadComment Config = new();

            [TomlDoNotInlineObject]
            public class HeadComment
            {
                [TomlProperty("Current Version")]
                public string CurrentVersion { get; set; } = Program.BuildInfo ?? "Development Build";

                [TomlProperty("Latest Version")]
                public string LatestVersion { get; set; } = "Unknown";

                public void OnSettingUpdate()
                {
                    CurrentVersion = Program.BuildInfo ?? "Development Build";
                    LatestVersion ??= "Unknown";
                }
            }
        }

        public static class MainConfigHelper
        {
            public static MainConfig Config = new();

            [TomlDoNotInlineObject]
            public class MainConfig
            {
                public GeneralConfig General = new();

                [TomlPrecedingComment("$Main.Advanced$")]
                public AdvancedConfig Advanced = new();


                [NonSerialized]
                public static readonly string[] AvailableLang =
                {
                    "af_za", "ar_sa", "ast_es", "az_az", "ba_ru", "bar", "be_by", "bg_bg",
                    "br_fr", "brb", "bs_ba", "ca_es", "cs_cz", "cy_gb", "da_dk", "de_at",
                    "de_ch", "de_de", "el_gr", "en_au", "en_ca", "en_gb", "en_nz", "en_pt",
                    "en_ud", "en_us", "enp", "enws", "eo_uy", "es_ar", "es_cl", "es_ec",
                    "es_es", "es_mx", "es_uy", "es_ve", "esan", "et_ee", "eu_es", "fa_ir",
                    "fi_fi", "fil_ph", "fo_fo", "fr_ca", "fr_fr", "fra_de", "fur_it", "fy_nl",
                    "ga_ie", "gd_gb", "gl_es", "haw_us", "he_il", "hi_in", "hr_hr", "hu_hu",
                    "hy_am", "id_id", "ig_ng", "io_en", "is_is", "isv", "it_it", "ja_jp",
                    "jbo_en", "ka_ge", "kk_kz", "kn_in", "ko_kr", "ksh", "kw_gb", "la_la",
                    "lb_lu", "li_li", "lmo", "lol_us", "lt_lt", "lv_lv", "lzh", "mk_mk",
                    "mn_mn", "ms_my", "mt_mt", "nah", "nds_de", "nl_be", "nl_nl", "nn_no",
                    "no_no", "oc_fr", "ovd", "pl_pl", "pt_br", "pt_pt", "qya_aa", "ro_ro",
                    "rpr", "ru_ru", "ry_ua", "se_no", "sk_sk", "sl_si", "so_so", "sq_al",
                    "sr_sp", "sv_se", "sxu", "szl", "ta_in", "th_th", "tl_ph", "tlh_aa",
                    "tok", "tr_tr", "tt_ru", "uk_ua", "val_es", "vec_it", "vi_vn", "yi_de",
                    "yo_ng", "zh_cn", "zh_hk", "zh_tw", "zlm_arab"
                };

                /// <summary>
                /// Load server information in ServerIP and ServerPort variables from a "serverip:port" couple or server alias
                /// </summary>
                /// <returns>True if the server IP was valid and loaded, false otherwise</returns>
                public bool SetServerIP(ServerInfoConfig serverInfo, bool checkAlias)
                {
                    string[] sip = serverInfo.Host.Split(new[] { ":", "：" }, StringSplitOptions.None);
                    string host = ToLowerIfNeed(sip[0]);
                    ushort port = 25565;

                    if (serverInfo.Port.HasValue)
                    {
                        port = serverInfo.Port.Value;
                    }
                    else if (sip.Length > 1)
                    {
                        try { port = Convert.ToUInt16(sip[1]); }
                        catch (FormatException) { return false; }
                    }

                    if (host == "localhost" || host.Contains('.'))
                    {
                        //Server IP (IP or domain names contains at least a dot)
                        if (sip.Length == 1 && !serverInfo.Port.HasValue && host.Contains('.') && host.Any(c => char.IsLetter(c)) &&
                            Settings.Config.Main.Advanced.ResolveSrvRecords != ResolveSrvRecordType.no)
                            //Domain name without port may need Minecraft SRV Record lookup
                            ProtocolHandler.MinecraftServiceLookup(ref host, ref port);
                        InternalConfig.ServerIP = host;
                        InternalConfig.ServerPort = port;
                        return true;
                    }
                    else if (checkAlias && Advanced.ServerList.TryGetValue(sip[0], out ServerInfoConfig serverStr2))
                    {
                        return SetServerIP(serverStr2, false);
                    }

                    return false;
                }

                public void OnSettingUpdate()
                {
                    ConsoleIO.EnableTimestamps = Advanced.Timestamps;

                    InternalConfig.InteractiveMode = !Advanced.ExitOnFailure;

                    General.Account.Login ??= string.Empty;
                    General.Account.Password ??= string.Empty;
                    if (!General.MigrateLegacyAuthServer())
                        ConsoleIO.WriteLogLine(Translations.config_auth_server_url_invalid);
                    if (!InternalConfig.KeepAccountSettings)
                    {
                        if (Advanced.AccountList.TryGetValue(General.Account.Login, out AccountInfoConfig account))
                            InternalConfig.Account = account;
                        else
                            InternalConfig.Account = General.Account;
                    }

                    General.Server.Host ??= string.Empty;

                    if (Advanced.MessageCooldown < 0)
                        Advanced.MessageCooldown = 0;

                    if (Advanced.MaxChatMessageLength < 0)
                        Advanced.MaxChatMessageLength = 0;
                    else if (Advanced.MaxChatMessageLength > 32767)
                        Advanced.MaxChatMessageLength = 32767;

                    if (Advanced.MaxChatMessageLength > 0)
                        ConsoleIO.WriteLineFormatted("§e[Settings] MaxChatMessageLength is set to " + Advanced.MaxChatMessageLength + ". Setting this incorrectly may cause you to be kicked from the server.");

                    if (Advanced.TcpTimeout < 1)
                        Advanced.TcpTimeout = 1;

                    Advanced.ForgeModTranslationPath = Advanced.ForgeModTranslationPath.Trim();

                    if (Advanced.MovementSpeed < 1)
                        Advanced.MovementSpeed = 1;

                    if (!Advanced.LoadMccTranslation)
                    {
                        CultureInfo culture = CultureInfo.CreateSpecificCulture("en-US");
                        CultureInfo.DefaultThreadCurrentCulture = culture;
                        CultureInfo.DefaultThreadCurrentUICulture = culture;
                        Program.ActualCulture = culture;
                        Thread.CurrentThread.CurrentCulture = culture;
                        Thread.CurrentThread.CurrentUICulture = culture;
                    }

                    Advanced.Language = Regex.Replace(Advanced.Language, @"[^-^_^\w^*\d]", string.Empty).Replace('-', '_');
                    Advanced.Language = ToLowerIfNeed(Advanced.Language);
                    if (!AvailableLang.Contains(Advanced.Language))
                    {
                        Advanced.Language = GetDefaultGameLanguage();
                        ConsoleIO.WriteLogLine("[Settings] " + Translations.config_Main_Advanced_language_invaild);
                    }

                    if (!InternalConfig.KeepServerSettings)
                    {
                        if (!string.IsNullOrWhiteSpace(General.Server.Host))
                        {
                            string[] sip = General.Server.Host.Split(new[] { ":", "：" }, StringSplitOptions.None);
                            General.Server.Host = sip[0];
                            InternalConfig.ServerIP = General.Server.Host;

                            if (sip.Length > 1)
                            {
                                try { General.Server.Port = Convert.ToUInt16(sip[1]); }
                                catch (FormatException) { }
                            }
                        }

                        if (General.Server.Port.HasValue)
                            InternalConfig.ServerPort = General.Server.Port.Value;
                        else
                            SetServerIP(General.Server, true);
                    }

                    for (int i = 0; i < Advanced.BotOwners.Count; ++i)
                        Advanced.BotOwners[i] = ToLowerIfNeed(Advanced.BotOwners[i]);

                    if (Advanced.MinTerminalWidth < 1)
                        Advanced.MinTerminalWidth = 1;
                    if (Advanced.MinTerminalHeight < 1)
                        Advanced.MinTerminalHeight = 1;

                    if (Advanced.TemporaryFixBadpacket && !Advanced.TerrainAndMovements)
                    {
                        Advanced.TerrainAndMovements = true;
                        ConsoleIO.WriteLineFormatted("§c[Settings]You need to enable TerrainAndMovements before enabling TemporaryFixBadpacket.");
                    }
                }

                [TomlDoNotInlineObject]
                public class GeneralConfig
                {
                    [TomlInlineComment("$Main.General.account$")]
                    public AccountInfoConfig Account = new(string.Empty, string.Empty);

                    [TomlInlineComment("$Main.General.login$")]
                    public ServerInfoConfig Server = new(string.Empty);

                    [TomlInlineComment("$Main.General.server_info$")]
                    public LoginType AccountType = LoginType.microsoft;

                    [TomlInlineComment("$Main.General.method$")]
                    public LoginMethod Method = LoginMethod.mcc;

                    [TomlInlineComment("$Main.General.AuthServerUrl$")]
                    public string AuthServerUrl = string.Empty;

                    // Retained only to deserialize pre-URL configs. WriteToFile() removes this legacy section.
                    [TomlInlineComment("$Main.General.AuthlibServer$")]
                    public AuthlibServer AuthServer = new();

                    [TomlInlineComment("$Main.General.AuthlibUser$")]
                    public string AuthUser = "";

                    public bool MigrateLegacyAuthServer()
                    {
                        AuthServerUrl ??= string.Empty;
                        if (TrySetAuthServerUrl(AuthServerUrl))
                            return true;

                        if (!string.IsNullOrWhiteSpace(AuthServerUrl))
                            return false;

                        if (!string.IsNullOrWhiteSpace(AuthServer.Host))
                        {
                            string path = AuthServer.AuthlibInjectorAPIPath ?? string.Empty;
                            if (!path.StartsWith('/'))
                                path = '/' + path;

                            string legacyUrl = $"{(AuthServer.UseHttps ? "https" : "http")}://{AuthServer.Host}:{AuthServer.Port}{path}";
                            return TrySetAuthServerUrl(legacyUrl);
                        }

                        return true;
                    }

                    public bool TrySetAuthServerUrl(string url)
                    {
                        if (!TryGetNormalizedAuthServerUri(url, out Uri? authServerUri))
                            return false;

                        AuthServerUrl = authServerUri.AbsoluteUri;
                        return true;
                    }

                    public bool TryGetAuthServerUri([NotNullWhen(true)] out Uri? authServerUri)
                        => TryGetNormalizedAuthServerUri(AuthServerUrl, out authServerUri);

                    private static bool TryGetNormalizedAuthServerUri(string? url, [NotNullWhen(true)] out Uri? authServerUri)
                    {
                        authServerUri = null;
                        if (!Uri.TryCreate(url?.Trim(), UriKind.Absolute, out Uri? parsedUri)
                            || (!parsedUri.Scheme.Equals(Uri.UriSchemeHttp, StringComparison.OrdinalIgnoreCase)
                                && !parsedUri.Scheme.Equals(Uri.UriSchemeHttps, StringComparison.OrdinalIgnoreCase))
                            || string.IsNullOrWhiteSpace(parsedUri.Host)
                            || !string.IsNullOrEmpty(parsedUri.UserInfo)
                            || !string.IsNullOrEmpty(parsedUri.Query)
                            || !string.IsNullOrEmpty(parsedUri.Fragment))
                        {
                            return false;
                        }

                        var builder = new UriBuilder(parsedUri)
                        {
                            Path = parsedUri.AbsolutePath.TrimEnd('/') + "/"
                        };
                        authServerUri = builder.Uri;
                        return true;
                    }

                    public enum LoginType { mojang, microsoft, yggdrasil };

                    public enum LoginMethod { mcc, browser };
                }

                [TomlDoNotInlineObject]
                public class AdvancedConfig
                {
                    [TomlInlineComment("$Main.Advanced.enable_sentry$")]
                    public bool EnableSentry = true;

                    [TomlInlineComment("$Main.Advanced.language$")]
                    public string Language = "en_us";

                    [TomlInlineComment("$Main.Advanced.LoadMccTrans$")]
                    public bool LoadMccTranslation = true;

                    [TomlInlineComment("$Main.Advanced.load_resourcepack_translations$")]
                    public bool LoadResourcePackTranslations = true;

                    [TomlInlineComment("$Main.Advanced.load_forge_mod_translations$")]
                    public bool LoadForgeModTranslations = false;

                    [TomlInlineComment("$Main.Advanced.auto_discover_forge_mod_translation_sources$")]
                    public bool AutoDiscoverForgeModTranslationSources = true;

                    [TomlInlineComment("$Main.Advanced.forge_mod_translation_path$")]
                    public string ForgeModTranslationPath = "";

                    // [TomlInlineComment("$Main.Advanced.console_title$")]
                    public string ConsoleTitle = "%username%@%serverip% - Minecraft Console Client";

                    [TomlInlineComment("$Main.Advanced.internal_cmd_char$")]
                    public InternalCmdCharType InternalCmdChar = InternalCmdCharType.slash;

                    [TomlInlineComment("$Main.Advanced.message_cooldown$")]
                    public double MessageCooldown = 1.0;

                    [TomlInlineComment("$Main.Advanced.max_chat_message_length$")]
                    public int MaxChatMessageLength = 0;

                    [TomlInlineComment("$Main.Advanced.bot_owners$")]
                    public List<string> BotOwners = new() { "Player1", "Player2" };

                    [TomlInlineComment("$Main.Advanced.mc_version$")]
                    public string MinecraftVersion = "auto";

                    [TomlInlineComment("$Main.Advanced.mc_forge$")]
                    public ForgeConfigType EnableForge = ForgeConfigType.no;

                    [TomlInlineComment("$Main.Advanced.brand_info$")]
                    public BrandInfoType BrandInfo = BrandInfoType.mcc;

                    [TomlInlineComment("$Main.Advanced.chatbot_log_file$")]
                    public string ChatbotLogFile = "";

                    [TomlInlineComment("$Main.Advanced.private_msgs_cmd_name$")]
                    public string PrivateMsgsCmdName = "tell";

                    [TomlInlineComment("$Main.Advanced.show_system_messages$")]
                    public bool ShowSystemMessages = true;

                    [TomlInlineComment("$Main.Advanced.show_xpbar_messages$")]
                    public bool ShowXPBarMessages = true;

                    [TomlInlineComment("$Main.Advanced.show_chat_links$")]
                    public bool ShowChatLinks = true;

                    [TomlInlineComment("$Main.Advanced.show_inventory_layout$")]
                    public bool ShowInventoryLayout = true;

                    [TomlInlineComment("$Main.Advanced.show_effect_messages$")]
                    public bool ShowEffectMessages = true;

                    [TomlInlineComment("$Main.Advanced.show_effect_names_in_tui$")]
                    public bool ShowEffectNamesInTUI = false;

                    [TomlInlineComment("$Main.Advanced.show_github_star_reminder$")]
                    public bool ShowGithubStarReminder = true;

                    [TomlInlineComment("$Main.Advanced.terrain_and_movements$")]
                    public bool TerrainAndMovements = false;

                    [TomlInlineComment("$Main.Advanced.move_head_while_walking$")]
                    public bool MoveHeadWhileWalking = true;

                    [TomlInlineComment("$Main.Advanced.movement_speed$")]
                    public int MovementSpeed = 2;

                    [TomlInlineComment("$Main.Advanced.temporary_fix_badpacket$")]
                    public bool TemporaryFixBadpacket = false;

                    [TomlInlineComment("$Main.Advanced.inventory_handling$")]
                    public bool InventoryHandling = false;

                    [TomlInlineComment("$Main.Advanced.entity_handling$")]
                    public bool EntityHandling = false;

                    [TomlInlineComment("$Main.Advanced.session_cache$")]
                    public CacheType SessionCache = CacheType.disk;

                    [TomlInlineComment("$Main.Advanced.profilekey_cache$")]
                    public CacheType ProfileKeyCache = CacheType.disk;

                    [TomlInlineComment("$Main.Advanced.resolve_srv_records$")]
                    public ResolveSrvRecordType ResolveSrvRecords = ResolveSrvRecordType.fast;

                    [TomlPrecedingComment("$Main.Advanced.account_list$")]
                    public Dictionary<string, AccountInfoConfig> AccountList = new() {
                        { "AccountNikename1", new AccountInfoConfig("playerone@email.com", "thepassword") },
                        { "AccountNikename2", new AccountInfoConfig("TestBot", "-") },
                    };

                    [TomlPrecedingComment("$Main.Advanced.server_list$")]
                    public Dictionary<string, ServerInfoConfig> ServerList = new() {
                        { "ServerAlias1", new ServerInfoConfig("mc.awesomeserver.com") },
                        { "ServerAlias2", new ServerInfoConfig("192.168.1.27", 12345) },
                    };

                    [TomlInlineComment("$Main.Advanced.player_head_icon$")]
                    public bool PlayerHeadAsIcon = true;

                    [TomlInlineComment("$Main.Advanced.exit_on_failure$")]
                    public bool ExitOnFailure = false;

                    [TomlInlineComment("$Main.Advanced.script_cache$")]
                    public bool CacheScript = true;

                    [TomlInlineComment("$Main.Advanced.timestamps$")]
                    public bool Timestamps = false;

                    [TomlInlineComment("$Main.Advanced.auto_respawn$")]
                    public bool AutoRespawn = false;

                    [TomlInlineComment("$Main.Advanced.minecraft_realms$")]
                    public bool MinecraftRealms = false;

                    [TomlInlineComment("$Main.Advanced.timeout$")]
                    public int TcpTimeout = 30;

                    [TomlInlineComment("$Main.Advanced.enable_emoji$")]
                    public bool EnableEmoji = true;

                    [TomlInlineComment("$Main.Advanced.MinTerminalWidth$")]
                    public int MinTerminalWidth = 16;

                    [TomlInlineComment("$Main.Advanced.MinTerminalHeight$")]
                    public int MinTerminalHeight = 10;

                    [TomlInlineComment("$Main.Advanced.ignore_invalid_playername$")]
                    public bool IgnoreInvalidPlayerName = true;

                    /// <summary>
                    /// Load login/password using an account alias
                    /// </summary>
                    /// <returns>True if the account was found and loaded</returns>
                    public bool SetAccount(string accountAlias)
                    {
                        if (AccountList.TryGetValue(accountAlias, out AccountInfoConfig accountInfo))
                        {
                            InternalConfig.Account = accountInfo;
                            return true;
                        }
                        else
                        {
                            return false;
                        }
                    }

                    public enum InternalCmdCharType { none, slash, backslash };

                    public enum BrandInfoType { mcc, vanilla, empty };

                    public enum CacheType { none, memory, disk };

                    public enum ResolveSrvRecordType { no, fast, yes };

                    public enum ForgeConfigType { no, auto, force };
                }

                public struct AccountInfoConfig
                {
                    public string Login = string.Empty, Password = string.Empty;

                    public AccountInfoConfig()
                    {
                        Login = string.Empty;
                        Password = string.Empty;
                    }

                    public AccountInfoConfig(string Login)
                    {
                        this.Login = Login;
                        this.Password = "-";
                    }

                    public AccountInfoConfig(string Login, string Password)
                    {
                        this.Login = Login;
                        this.Password = Password;
                    }
                }

                public struct ServerInfoConfig
                {
                    public string Host = string.Empty;
                    public ushort? Port = null;

                    public ServerInfoConfig()
                    {
                        Host = string.Empty;
                        Port = null;
                    }

                    public ServerInfoConfig(string Host)
                    {
                        string[] sip = Host.Split(new[] { ":", "：" }, StringSplitOptions.None);
                        this.Host = sip[0];

                        if (sip.Length > 1)
                        {
                            try { this.Port = Convert.ToUInt16(sip[1]); }
                            catch (FormatException) { }
                        }
                    }

                    public ServerInfoConfig(string Host, ushort Port)
                    {
                        this.Host = Host.Split(new[] { ":", "：" }, StringSplitOptions.None)[0];
                        this.Port = Port;
                    }
                }
                [TomlDoNotInlineObject]
                public class AuthlibServer
                {
                    [NonSerialized]
                    private string _host = string.Empty;

                    [TomlInlineComment("$AuthlibServer.Host$")]
                    public string Host
                    {
                        get => _host;
                        set
                        {
                            string[] split = value.Split(new[] { ":", "：" }, StringSplitOptions.None);
                            if (split.Length >= 1)
                                _host = split[0];
                            if (split.Length >= 2)
                            {
                                try { Port = Convert.ToUInt16(split[1]); }
                                catch (FormatException) { }
                            }
                        }
                    }

                    [TomlInlineComment("$AuthlibServer.Port$")]
                    public int Port = 443;

                    [TomlInlineComment("$AuthlibServer.AuthlibInjectorAPIPath$")]
                    public string AuthlibInjectorAPIPath = "/api/yggdrasil";

                    [TomlInlineComment("$AuthlibServer.UseHttps$")]
                    public bool UseHttps = true;


                }
            }
        }

        public static class SignatureConfigHelper
        {
            public static SignatureConfig Config = new();

            [TomlDoNotInlineObject]
            public class SignatureConfig
            {
                [TomlInlineComment("$Signature.LoginWithSecureProfile$")]
                public bool LoginWithSecureProfile = true;

                [TomlInlineComment("$Signature.SignChat$")]
                public bool SignChat = true;

                [TomlInlineComment("$Signature.SignMessageInCommand$")]
                public bool SignMessageInCommand = true;

                [TomlInlineComment("$Signature.MarkLegallySignedMsg$")]
                public bool MarkLegallySignedMsg = true;

                [TomlInlineComment("$Signature.MarkModifiedMsg$")]
                public bool MarkModifiedMsg = true;

                [TomlInlineComment("$Signature.MarkIllegallySignedMsg$")]
                public bool MarkIllegallySignedMsg = true;

                [TomlInlineComment("$Signature.MarkSystemMessage$")]
                public bool MarkSystemMessage = true;

                [TomlInlineComment("$Signature.ShowModifiedChat$")]
                public bool ShowModifiedChat = true;

                [TomlInlineComment("$Signature.ShowIllegalSignedChat$")]
                public bool ShowIllegalSignedChat = true;

                public void OnSettingUpdate() { }
            }
        }

        public static class LoggingConfigHealper
        {
            public static LoggingConfig Config = new();

            [TomlDoNotInlineObject]
            public class LoggingConfig
            {
                [TomlInlineComment("$Logging.DebugMessages$")]
                public bool DebugMessages = false;

                [TomlInlineComment("$Logging.PacketDebugMessages$")]
                public bool PacketDebugMessages = false;

                [TomlInlineComment("$Logging.PacketDebugExclusions$")]
                public List<string> PacketDebugExclusions = new();

                [TomlInlineComment("$Logging.ChatMessages$")]
                public bool ChatMessages = true;

                [TomlInlineComment("$Logging.InfoMessages$")]
                public bool InfoMessages = true;

                [TomlInlineComment("$Logging.WarningMessages$")]
                public bool WarningMessages = true;

                [TomlInlineComment("$Logging.ErrorMessages$")]
                public bool ErrorMessages = true;

                [TomlInlineComment("$Logging.ChatFilter$")]
                public string ChatFilterRegex = @".*";

                [TomlInlineComment("$Logging.DebugFilter$")]
                public string DebugFilterRegex = @".*";

                [TomlInlineComment("$Logging.FilterMode$")]
                public FilterModeEnum FilterMode = FilterModeEnum.disable;

                [TomlInlineComment("$Logging.LogToFile$")]
                public bool LogToFile = false;

                [TomlInlineComment("$Logging.LogFile$")]
                public string LogFile = @"console-log.txt";

                [TomlInlineComment("$Logging.PrependTimestamp$")]
                public bool PrependTimestamp = false;

                [TomlInlineComment("$Logging.SaveColorCodes$")]
                public bool SaveColorCodes = false;

                public void OnSettingUpdate() { }

                public enum FilterModeEnum { disable, blacklist, whitelist }
            }
        }

        public static class ConsoleConfigHealper
        {
            public static ConsoleConfig Config = new();

            [TomlDoNotInlineObject]
            public class ConsoleConfig
            {
                public MainConfig General = new();

                [TomlPrecedingComment("$Console.CommandSuggestion$")]
                public CommandSuggestionConfig CommandSuggestion = new();

                [TomlPrecedingComment("$Console.Minimap$")]
                public MinimapConfig Minimap = new();

                [TomlPrecedingComment("$Console.TabList$")]
                public TabListConfig TabList = new();

                public void OnSettingUpdate()
                {
                    ConsoleIO.ChatVisible = General.Display_Chat;

                    var backend = ConsoleIO.Backend;
                    if (backend == null) return;

                    backend.DisplayUserInput = General.Display_Input;
                    backend.SetBackreadBufferLimit(General.History_Input_Records);

                    if (backend is ClassicConsoleBackend classic)
                    {
                        classic.EnableWriterColor = General.ConsoleColorMode != ConsoleColorModeType.disable;
                        classic.UseVT100ColorCode = General.ConsoleColorMode != ConsoleColorModeType.legacy_4bit;

                        if (General.ConsoleColorMode == ConsoleColorModeType.disable)
                            CommandSuggestion.Enable_Color = false;

                        classic.EnableSuggestionColor = CommandSuggestion.Enable_Color;
                        classic.Enable24bitColor = General.ConsoleColorMode == ConsoleColorModeType.vt100_24bit;
                        classic.UseBasicArrow = CommandSuggestion.Use_Basic_Arrow;

                        CommandSuggestion.Max_Suggestion_Width =
                            classic.SetMaxSuggestionLength(CommandSuggestion.Max_Suggestion_Width);
                        CommandSuggestion.Max_Displayed_Suggestions =
                            classic.SetMaxSuggestionCount(CommandSuggestion.Max_Displayed_Suggestions);

                        if (!CheckColorCode(CommandSuggestion.Text_Color))
                        {
                            ConsoleIO.WriteLine(string.Format(Translations.config_commandsuggestion_illegal_color, "CommandSuggestion.TextColor", CommandSuggestion.Text_Color));
                            CommandSuggestion.Text_Color = "#f8fafc";
                        }
                        if (!CheckColorCode(CommandSuggestion.Text_Background_Color))
                        {
                            ConsoleIO.WriteLine(string.Format(Translations.config_commandsuggestion_illegal_color, "CommandSuggestion.TextBackgroundColor", CommandSuggestion.Text_Background_Color));
                            CommandSuggestion.Text_Background_Color = "#64748b";
                        }
                        if (!CheckColorCode(CommandSuggestion.Highlight_Text_Color))
                        {
                            ConsoleIO.WriteLine(string.Format(Translations.config_commandsuggestion_illegal_color, "CommandSuggestion.HighlightTextColor", CommandSuggestion.Highlight_Text_Color));
                            CommandSuggestion.Highlight_Text_Color = "#334155";
                        }
                        if (!CheckColorCode(CommandSuggestion.Highlight_Text_Background_Color))
                        {
                            ConsoleIO.WriteLine(string.Format(Translations.config_commandsuggestion_illegal_color, "CommandSuggestion.HighlightTextBackgroundColor", CommandSuggestion.Highlight_Text_Background_Color));
                            CommandSuggestion.Highlight_Text_Background_Color = "#fde047";
                        }
                        if (!CheckColorCode(CommandSuggestion.Tooltip_Color))
                        {
                            ConsoleIO.WriteLine(string.Format(Translations.config_commandsuggestion_illegal_color, "CommandSuggestion.TooltipColor", CommandSuggestion.Tooltip_Color));
                            CommandSuggestion.Tooltip_Color = "#7dd3fc";
                        }
                        if (!CheckColorCode(CommandSuggestion.Highlight_Tooltip_Color))
                        {
                            ConsoleIO.WriteLine(string.Format(Translations.config_commandsuggestion_illegal_color, "CommandSuggestion.HighlightTooltipColor", CommandSuggestion.Highlight_Tooltip_Color));
                            CommandSuggestion.Highlight_Tooltip_Color = "#3b82f6";
                        }
                        if (!CheckColorCode(CommandSuggestion.Arrow_Symbol_Color))
                        {
                            ConsoleIO.WriteLine(string.Format(Translations.config_commandsuggestion_illegal_color, "CommandSuggestion.ArrowSymbolColor", CommandSuggestion.Arrow_Symbol_Color));
                            CommandSuggestion.Arrow_Symbol_Color = "#d1d5db";
                        }

                        classic.SetSuggestionColors(
                            CommandSuggestion.Text_Color, CommandSuggestion.Text_Background_Color,
                            CommandSuggestion.Highlight_Text_Color, CommandSuggestion.Highlight_Text_Background_Color,
                            CommandSuggestion.Tooltip_Color, CommandSuggestion.Highlight_Tooltip_Color,
                            CommandSuggestion.Arrow_Symbol_Color);
                    }
                }

                private static bool CheckColorCode(string? input)
                {
                    if (string.IsNullOrWhiteSpace(input))
                        return false;
                    if (input.Length < 6 || input.Length > 7)
                        return false;
                    if (input.Length == 6 && input[0] == '#')
                        return false;
                    if (input.Length == 7 && input[0] != '#')
                        return false;
                    try
                    {
                        Convert.ToInt32(input.Length == 7 ? input[1..] : input, 16);
                        return true;
                    }
                    catch
                    {
                        return false;
                    }
                }

                [TomlDoNotInlineObject]
                public class MainConfig
                {
                    [TomlInlineComment("$Console.General.ConsoleMode$")]
                    public ConsoleModeType ConsoleMode = ConsoleModeType.classic;

                    [TomlInlineComment("$Console.General.ConsoleColorMode$")]
                    public ConsoleColorModeType ConsoleColorMode = ConsoleColorModeType.vt100_24bit;

                    [TomlInlineComment("$Console.General.Display_Icon_Banner$")]
                    public bool Display_Icon_Banner = true;

                    [TomlInlineComment("$Console.General.Display_Input$")]
                    public bool Display_Input = true;

                    [TomlInlineComment("$Console.General.Display_Chat$")]
                    public bool Display_Chat = true;

                    [TomlInlineComment("$Console.General.History_Input_Records$")]
                    public int History_Input_Records = 32;

                    [TomlInlineComment("$Console.General.TUI_Log_Scrollback$")]
                    public int TUI_Log_Scrollback = 0;
                }

                [TomlDoNotInlineObject]
                public class CommandSuggestionConfig
                {
                    [TomlInlineComment("$Console.CommandSuggestion.Enable$")]
                    public bool Enable = true;

                    public bool Enable_Color = true;

                    [TomlInlineComment("$Console.CommandSuggestion.Use_Basic_Arrow$")]
                    public bool Use_Basic_Arrow = false;

                    public int Max_Suggestion_Width = 30;

                    public int Max_Displayed_Suggestions = 10;

                    public string Text_Color = "#f8fafc";

                    public string Text_Background_Color = "#64748b";

                    public string Highlight_Text_Color = "#334155";

                    public string Highlight_Text_Background_Color = "#fde047";

                    public string Tooltip_Color = "#7dd3fc";

                    public string Highlight_Tooltip_Color = "#3b82f6";

                    public string Arrow_Symbol_Color = "#d1d5db";
                }

                public enum ConsoleModeType { classic, tui };
                public enum ConsoleColorModeType { disable, legacy_4bit, vt100_4bit, vt100_8bit, vt100_24bit };

                [TomlDoNotInlineObject]
                public class MinimapConfig
                {
                    [TomlInlineComment("$Console.Minimap.Enabled$")]
                    public bool Enabled = false;

                    [TomlInlineComment("$Console.Minimap.Zoom$")]
                    public int Zoom = Tui.MinimapControl.DefaultZoom;

                    [TomlInlineComment("$Console.Minimap.Width$")]
                    public int Width = Tui.MinimapControl.DefaultWidth;

                    [TomlInlineComment("$Console.Minimap.Height$")]
                    public int Height = Tui.MinimapControl.DefaultHeight;

                    [TomlInlineComment("$Console.Minimap.Position$")]
                    public Tui.MinimapPosition Position = Tui.MinimapPosition.top_right;

                    [TomlInlineComment("$Console.Minimap.ShowPlayerNames$")]
                    public bool ShowPlayerNames = false;

                    [TomlInlineComment("$Console.Minimap.ShowHostileNames$")]
                    public bool ShowHostileNames = false;

                    [TomlInlineComment("$Console.Minimap.ShowNeutralNames$")]
                    public bool ShowNeutralNames = false;

                    [TomlInlineComment("$Console.Minimap.ShowPassiveNames$")]
                    public bool ShowPassiveNames = false;

                    [TomlInlineComment("$Console.Minimap.RefreshInterval$")]
                    public int RefreshInterval = Tui.MinimapControl.DefaultRefreshMs;

                    [TomlInlineComment("$Console.Minimap.CaveMode$")]
                    public Tui.CaveModeOption CaveMode = Tui.CaveModeOption.auto;

                    public void OnSettingUpdate()
                    {
                        Zoom = Math.Clamp(Zoom, Tui.MinimapControl.MinZoom, Tui.MinimapControl.MaxZoom);
                        Width = Math.Clamp(Width, 10, 120);
                        Height = Math.Clamp(Height, 4, 80);
                        if (Height % 2 != 0) Height++;
                        RefreshInterval = Math.Clamp(RefreshInterval,
                            Tui.MinimapControl.MinRefreshMs, Tui.MinimapControl.MaxRefreshMs);
                    }
                }

                [TomlDoNotInlineObject]
                public class TabListConfig
                {
                    [TomlInlineComment("$Console.TabList.ShowTeams$")]
                    public bool ShowTeams = false;
                }
            }
        }

        public static class AppVarConfigHelper
        {
            public static AppVarConfig Config = new();

            [TomlDoNotInlineObject]
            public class AppVarConfig
            {
                [TomlPrecedingComment("$AppVars.Variables$")]
                private readonly Dictionary<string, string> VarStirng = new() {
                    { "your_var", "your_value" },
                    { "your var 2", "your value 2" },
                };

                public void OnSettingUpdate() { }


                [NonSerialized]
                private readonly Dictionary<string, object> VarObject = new();

                [NonSerialized]
                readonly Lock varLock = new();

                private static bool TryGetReadOnlyVar(string varName, [NotNullWhen(true)] out object? varData)
                {
                    switch (Settings.ToLowerIfNeed(varName))
                    {
                        case "username":
                            varData = InternalConfig.Username;
                            return true;
                        case "login":
                            varData = InternalConfig.Account.Login;
                            return true;
                        case "serverip":
                            varData = InternalConfig.ServerIP;
                            return true;
                        case "serverport":
                            varData = InternalConfig.ServerPort;
                            return true;
                        case "datetime":
                            varData = DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss");
                            return true;
                        case "date":
                            varData = DateTime.Now.ToString("yyyy-MM-dd");
                            return true;
                        case "players":
                            varData = string.Join(", ", McClient.Instance?.GetOnlinePlayers() ?? []);
                            return true;
                        default:
                            varData = null;
                            return false;
                    }
                }

                /// <summary>
                /// Set a custom %variable% which will be available through expandVars()
                /// </summary>
                /// <param name="varName">Name of the variable</param>
                /// <param name="varData">Value of the variable</param>
                /// <returns>True if the parameters were valid</returns>
                public bool SetVar(string varName, object varData)
                {
                    varName = Settings.ToLowerIfNeed(new string(varName.TakeWhile(char.IsLetterOrDigit).ToArray()));
                    if (varName.Length > 0)
                    {
                        bool isString = varData.GetType() == typeof(string);
                        lock (varLock)
                        {
                            if (isString)
                            {
                                if (VarObject.ContainsKey(varName))
                                    VarObject.Remove(varName);
                                VarStirng[varName] = (string)varData;
                            }
                            else
                            {
                                if (VarStirng.ContainsKey(varName))
                                    VarStirng.Remove(varName);
                                VarObject[varName] = varData;
                            }
                        }
                        return true;
                    }
                    else
                    {
                        return false;
                    }
                }

                /// <summary>
                /// Get a custom %variable% or null if the variable does not exist
                /// </summary>
                /// <param name="varName">Variable name</param>
                /// <returns>The value or null if the variable does not exists</returns>
                public object? GetVar(string varName)
                {
                    if (TryGetReadOnlyVar(varName, out object? readOnlyVar))
                        return readOnlyVar;
                    if (VarStirng.TryGetValue(varName, out string? valueString))
                        return valueString;
                    else if (VarObject.TryGetValue(varName, out object? valueObject))
                        return valueObject;
                    else
                        return null;
                }

                /// <summary>
                /// Get a custom %variable% or null if the variable does not exist
                /// </summary>
                /// <param name="varName">Variable name</param>
                /// <returns>The value or null if the variable does not exists</returns>
                public bool TryGetVar(string varName, [NotNullWhen(true)] out object? varData)
                {
                    if (TryGetReadOnlyVar(varName, out varData))
                        return true;
                    if (VarStirng.TryGetValue(varName, out string? valueString))
                    {
                        varData = valueString;
                        return true;
                    }
                    else if (VarObject.TryGetValue(varName, out object? valueObject))
                    {
                        varData = valueObject;
                        return true;
                    }
                    else
                    {
                        varData = null;
                        return false;
                    }
                }

                /// <summary>
                /// Get a dictionary containing variables (names and value)
                /// </summary>
                /// <returns>A IDictionary<string, object> containing a name and a vlaue key pairs of variables</returns>
                public Dictionary<string, object> GetVariables()
                {
                    Dictionary<string, object> res = new(VarObject);
                    foreach ((string varName, string varData) in VarStirng)
                        res.Add(varName, varData);
                    return res;
                }

                /// <summary>
                /// Replace %variables% with their value from global AppVars
                /// </summary>
                /// <param name="str">String to parse</param>
                /// <param name="localContext">Optional local variables overriding global variables</param>
                /// <returns>Modifier string</returns>
                public string ExpandVars(string str, Dictionary<string, object>? localVars = null)
                {
                    StringBuilder result = new();
                    for (int i = 0; i < str.Length; i++)
                    {
                        if (str[i] == '%')
                        {
                            bool varname_ok = false;
                            StringBuilder var_name = new();

                            for (int j = i + 1; j < str.Length; j++)
                            {
                                if (!char.IsLetterOrDigit(str[j]) && str[j] != '_')
                                {
                                    if (str[j] == '%')
                                        varname_ok = var_name.Length > 0;
                                    break;
                                }
                                else var_name.Append(str[j]);
                            }

                            if (varname_ok)
                            {
                                string varname = var_name.ToString();
                                string varname_lower = Settings.ToLowerIfNeed(varname);
                                i = i + varname.Length + 1;

                                if (TryGetReadOnlyVar(varname_lower, out object? readOnlyVar))
                                {
                                    result.Append(readOnlyVar.ToString());
                                }
                                else if (localVars is not null && localVars.ContainsKey(varname_lower))
                                {
                                    result.Append(localVars[varname_lower].ToString());
                                }
                                else if (TryGetVar(varname_lower, out object? var_value))
                                {
                                    result.Append(var_value.ToString());
                                }
                                else
                                {
                                    result.Append("%" + varname + '%');
                                }
                            }
                            else result.Append(str[i]);
                        }
                        else result.Append(str[i]);
                    }
                    return result.ToString();
                }
            }
        }

        public static class MCSettingsConfigHealper
        {
            public static MCSettingsConfig Config = new();

            [TomlDoNotInlineObject]
            public class MCSettingsConfig
            {
                [TomlInlineComment("$MCSettings.Enabled$")]
                public bool Enabled = true;

                [TomlInlineComment("$MCSettings.Locale$")]
                public string Locale = "en_US";

                [TomlInlineComment("$MCSettings.RenderDistance$")]
                public byte RenderDistance = 8;

                [TomlInlineComment("$MCSettings.Difficulty$")]
                public DifficultyType Difficulty = DifficultyType.peaceful;

                [TomlInlineComment("$MCSettings.ChatMode$")]
                public ChatModeType ChatMode = ChatModeType.enabled;

                [TomlInlineComment("$MCSettings.ChatColors$")]
                public bool ChatColors = true;

                [TomlInlineComment("$MCSettings.MainHand$")]
                public MainHandType MainHand = MainHandType.left;

                public SkinInfo Skin = new();

                public void OnSettingUpdate() { }

                public enum DifficultyType { peaceful, easy, normal, difficult };

                public enum ChatModeType { enabled, commands, disabled };

                public enum MainHandType { left, right };

                public struct SkinInfo
                {
                    public bool Cape = true, Hat = true, Jacket = false;
                    public bool Sleeve_Left = false, Sleeve_Right = false;
                    public bool Pants_Left = false, Pants_Right = false;

                    public SkinInfo() { }

                    public SkinInfo(bool Cape, bool Hat, bool Jacket, bool Sleeve_Left, bool Sleeve_Right, bool Pants_Left, bool Pants_Right)
                    {
                        this.Cape = Cape;
                        this.Hat = Hat;
                        this.Jacket = Jacket;
                        this.Sleeve_Left = Sleeve_Left;
                        this.Sleeve_Right = Sleeve_Right;
                        this.Pants_Left = Pants_Left;
                        this.Pants_Right = Pants_Right;
                    }

                    public byte GetByte()
                    {
                        return (byte)(
                              ((Cape ? 1 : 0) << 0)
                            | ((Jacket ? 1 : 0) << 1)
                            | ((Sleeve_Left ? 1 : 0) << 2)
                            | ((Sleeve_Right ? 1 : 0) << 3)
                            | ((Pants_Left ? 1 : 0) << 4)
                            | ((Pants_Right ? 1 : 0) << 5)
                            | ((Hat ? 1 : 0) << 6)
                        );
                    }
                }
            }
        }

        public static class ChatFormatConfigHelper
        {
            public static ChatFormatConfig Config = new();

            [TomlDoNotInlineObject]
            public class ChatFormatConfig
            {
                [TomlInlineComment("$ChatFormat.Builtins$")]
                public bool Builtins = true;

                [TomlInlineComment("$ChatFormat.UserDefined$")]
                public bool UserDefined = false;

                public string Public = @"^<([a-zA-Z0-9_]+)> (.+)$";

                public string Private = @"^([a-zA-Z0-9_]+) whispers to you: (.+)$";

                public string TeleportRequest = @"^([a-zA-Z0-9_]+) has requested (?:to|that you) teleport to (?:you|them)\.$";

                public void OnSettingUpdate()
                {
                    if (UserDefined)
                    {
                        bool checkResult = true;

                        try { _ = new Regex(Public); }
                        catch (ArgumentException)
                        {
                            checkResult = false;
                            ConsoleIO.WriteLineFormatted("§c[Settings]Illegal regular expression: ChatFormat.Public = " + Public);
                        }

                        try { _ = new Regex(Private); }
                        catch (ArgumentException)
                        {
                            checkResult = false;
                            ConsoleIO.WriteLineFormatted("§c[Settings]Illegal regular expression: ChatFormat.Private = " + Private);
                        }

                        try { _ = new Regex(TeleportRequest); }
                        catch (ArgumentException)
                        {
                            checkResult = false;
                            ConsoleIO.WriteLineFormatted("§c[Settings]Illegal regular expression: ChatFormat.TeleportRequest = " + TeleportRequest);
                        }

                        if (!checkResult)
                        {
                            UserDefined = false;
                            ConsoleIO.WriteLineFormatted("§c[Settings]ChatFormat: User-defined regular expressions are disabled.");
                        }
                    }
                }
            }
        }

        public static class ChatBotConfigHealper
        {
            public static ChatBotConfig Config = new();

            [TomlDoNotInlineObject]
            public class ChatBotConfig
            {
                [TomlPrecedingComment("$ChatBot.Alerts$")]
                public ChatBots.Alerts.Configs Alerts
                {
                    get { return ChatBots.Alerts.Config; }
                    set { ChatBots.Alerts.Config = value; ChatBots.Alerts.Config.OnSettingUpdate(); }
                }

                [TomlPrecedingComment("$ChatBot.AntiAfk$")]
                public ChatBots.AntiAFK.Configs AntiAFK
                {
                    get { return ChatBots.AntiAFK.Config; }
                    set { ChatBots.AntiAFK.Config = value; ChatBots.AntiAFK.Config.OnSettingUpdate(); }
                }

                [TomlPrecedingComment("$ChatBot.AutoAttack$")]
                public ChatBots.AutoAttack.Configs AutoAttack
                {
                    get { return ChatBots.AutoAttack.Config; }
                    set { ChatBots.AutoAttack.Config = value; ChatBots.AutoAttack.Config.OnSettingUpdate(); }
                }

                [TomlPrecedingComment("$ChatBot.AutoCraft$")]
                public ChatBots.AutoCraft.Configs AutoCraft
                {
                    get { return ChatBots.AutoCraft.Config; }
                    set { ChatBots.AutoCraft.Config = value; ChatBots.AutoCraft.Config.OnSettingUpdate(); }
                }

                [TomlPrecedingComment("$ChatBot.AutoDig$")]
                public ChatBots.AutoDig.Configs AutoDig
                {
                    get { return ChatBots.AutoDig.Config; }
                    set { ChatBots.AutoDig.Config = value; ChatBots.AutoDig.Config.OnSettingUpdate(); }
                }

                [TomlPrecedingComment("$ChatBot.AutoDrop$")]
                public ChatBots.AutoDrop.Configs AutoDrop
                {
                    get { return ChatBots.AutoDrop.Config; }
                    set { ChatBots.AutoDrop.Config = value; ChatBots.AutoDrop.Config.OnSettingUpdate(); }
                }

                [TomlPrecedingComment("$ChatBot.AutoEat$")]
                public ChatBots.AutoEat.Configs AutoEat
                {
                    get { return ChatBots.AutoEat.Config; }
                    set { ChatBots.AutoEat.Config = value; ChatBots.AutoEat.Config.OnSettingUpdate(); }
                }

                [TomlPrecedingComment("$ChatBot.AutoFishing$")]
                public ChatBots.AutoFishing.Configs AutoFishing
                {
                    get { return ChatBots.AutoFishing.Config; }
                    set { ChatBots.AutoFishing.Config = value; ChatBots.AutoFishing.Config.OnSettingUpdate(); }
                }

                [TomlPrecedingComment("$ChatBot.AutoRelog$")]
                public ChatBots.AutoRelog.Configs AutoRelog
                {
                    get { return ChatBots.AutoRelog.Config; }
                    set { ChatBots.AutoRelog.Config = value; ChatBots.AutoRelog.Config.OnSettingUpdate(); }
                }

                [TomlPrecedingComment("$ChatBot.AutoRespond$")]
                public ChatBots.AutoRespond.Configs AutoRespond
                {
                    get { return ChatBots.AutoRespond.Config; }
                    set { ChatBots.AutoRespond.Config = value; ChatBots.AutoRespond.Config.OnSettingUpdate(); }
                }

                [TomlPrecedingComment("$ChatBot.ChatLog$")]
                public ChatBots.ChatLog.Configs ChatLog
                {
                    get { return ChatBots.ChatLog.Config; }
                    set { ChatBots.ChatLog.Config = value; ChatBots.ChatLog.Config.OnSettingUpdate(); }
                }

                [TomlPrecedingComment("$ChatBot.DiscordBridge$")]
                public ChatBots.DiscordBridge.Configs DiscordBridge
                {
                    get { return ChatBots.DiscordBridge.Config; }
                    set { ChatBots.DiscordBridge.Config = value; ChatBots.DiscordBridge.Config.OnSettingUpdate(); }
                }

                [TomlPrecedingComment("$ChatBot.Farmer$")]
                public ChatBots.Farmer.Configs Farmer
                {
                    get { return ChatBots.Farmer.Config; }
                    set { ChatBots.Farmer.Config = value; ChatBots.Farmer.Config.OnSettingUpdate(); }
                }

                [TomlPrecedingComment("$ChatBot.FollowPlayer$")]
                public ChatBots.FollowPlayer.Configs FollowPlayer
                {
                    get { return ChatBots.FollowPlayer.Config; }
                    set { ChatBots.FollowPlayer.Config = value; ChatBots.FollowPlayer.Config.OnSettingUpdate(); }
                }

                [TomlPrecedingComment("$ChatBot.HangmanGame$")]
                public ChatBots.HangmanGame.Configs HangmanGame
                {
                    get { return ChatBots.HangmanGame.Config; }
                    set { ChatBots.HangmanGame.Config = value; ChatBots.HangmanGame.Config.OnSettingUpdate(); }
                }

                [TomlPrecedingComment("$ChatBot.Mailer$")]
                public ChatBots.Mailer.Configs Mailer
                {
                    get { return ChatBots.Mailer.Config; }
                    set { ChatBots.Mailer.Config = value; ChatBots.Mailer.Config.OnSettingUpdate(); }
                }

                [TomlPrecedingComment("$ChatBot.Map$")]
                public ChatBots.Map.Configs Map
                {
                    get { return ChatBots.Map.Config; }
                    set { ChatBots.Map.Config = value; ChatBots.Map.Config.OnSettingUpdate(); }
                }

                [TomlPrecedingComment("$ChatBot.PlayerListLogger$")]
                public ChatBots.PlayerListLogger.Configs PlayerListLogger
                {
                    get { return ChatBots.PlayerListLogger.Config; }
                    set { ChatBots.PlayerListLogger.Config = value; ChatBots.PlayerListLogger.Config.OnSettingUpdate(); }
                }

                [TomlPrecedingComment("$ChatBot.RemoteControl$")]
                public ChatBots.RemoteControl.Configs RemoteControl
                {
                    get { return ChatBots.RemoteControl.Config; }
                    set { ChatBots.RemoteControl.Config = value; ChatBots.RemoteControl.Config.OnSettingUpdate(); }
                }

                [TomlPrecedingComment("$ChatBot.ReplayCapture$")]
                public ChatBots.ReplayCapture.Configs ReplayCapture
                {
                    get { return ChatBots.ReplayCapture.Config; }
                    set { ChatBots.ReplayCapture.Config = value; ChatBots.ReplayCapture.Config.OnSettingUpdate(); }
                }

                [TomlPrecedingComment("$ChatBot.ScriptScheduler$")]
                public ChatBots.ScriptScheduler.Configs ScriptScheduler
                {
                    get { return ChatBots.ScriptScheduler.Config; }
                    set { ChatBots.ScriptScheduler.Config = value; ChatBots.ScriptScheduler.Config.OnSettingUpdate(); }
                }

                [TomlPrecedingComment("$ChatBot.TelegramBridge$")]
                public ChatBots.TelegramBridge.Configs TelegramBridge
                {
                    get { return ChatBots.TelegramBridge.Config; }
                    set { ChatBots.TelegramBridge.Config = value; ChatBots.TelegramBridge.Config.OnSettingUpdate(); }
                }

                [TomlPrecedingComment("$ChatBot.ItemsCollector$")]
                public ChatBots.ItemsCollector.Configs ItemsCollector
                {
                    get { return ChatBots.ItemsCollector.Config; }
                    set
                    {
                        ChatBots.ItemsCollector.Config = value;
                        ChatBots.ItemsCollector.Config.OnSettingUpdate();
                    }
                }

                [TomlPrecedingComment("$ChatBot.DiscordRpc$")]
                public ChatBots.DiscordRpc.Configs DiscordRpc
                {
                    get { return ChatBots.DiscordRpc.Config; }
                    set { ChatBots.DiscordRpc.Config = value; ChatBots.DiscordRpc.Config.OnSettingUpdate(); }
                }

                [TomlPrecedingComment("$ChatBot.McpServer$")]
                public ChatBots.McpServer.Configs McpServer
                {
                    get { return ChatBots.McpServer.Config; }
                    set
                    {
                        ChatBots.McpServer.Config = value ?? new ChatBots.McpServer.Configs();
                        ChatBots.McpServer.Config.OnSettingUpdate();
                    }
                }
            }
        }

        /// <summary>
        /// Map the system CultureInfo name to a Minecraft game language code.
        /// </summary>
        /// <remarks>
        /// Culture name reference (language-COUNTRY):
        ///   https://learn.microsoft.com/en-us/previous-versions/commerce-server/ee797784(v=cs.20)
        /// Full LCID / language-tag spec (MS-LCID, includes fil-PH, nb-NO, etc.):
        ///   https://learn.microsoft.com/en-us/openspecs/windows_protocols/ms-lcid/70feba9f-294e-491e-b6eb-56532684c37f
        /// </remarks>
        public static string GetDefaultGameLanguage()
        {
            string gameLanguage = "en_us";
            string systemLanguage = string.IsNullOrWhiteSpace(Program.ActualCulture.Name)
                    ? Program.ActualCulture.Parent.Name
                    : Program.ActualCulture.Name;
            switch (systemLanguage)
            {
                case "af":
                case "af-ZA":
                    gameLanguage = "af_za";
                    break;
                case "ar":
                case "ar-AE":
                case "ar-BH":
                case "ar-DZ":
                case "ar-EG":
                case "ar-IQ":
                case "ar-JO":
                case "ar-KW":
                case "ar-LB":
                case "ar-LY":
                case "ar-MA":
                case "ar-OM":
                case "ar-QA":
                case "ar-SA":
                case "ar-SY":
                case "ar-TN":
                case "ar-YE":
                    gameLanguage = "ar_sa";
                    break;
                case "az":
                case "az-Cyrl-AZ":
                case "az-Latn-AZ":
                    gameLanguage = "az_az";
                    break;
                case "be":
                case "be-BY":
                    gameLanguage = "be_by";
                    break;
                case "bg":
                case "bg-BG":
                    gameLanguage = "bg_bg";
                    break;
                case "bs-Latn-BA":
                    gameLanguage = "bs_ba";
                    break;
                case "ca":
                case "ca-ES":
                    gameLanguage = "ca_es";
                    break;
                case "cs":
                case "cs-CZ":
                    gameLanguage = "cs_cz";
                    break;
                case "cy-GB":
                    gameLanguage = "cy_gb";
                    break;
                case "da":
                case "da-DK":
                    gameLanguage = "da_dk";
                    break;
                case "de":
                case "de-DE":
                case "de-LI":
                case "de-LU":
                    gameLanguage = "de_de";
                    break;
                case "de-AT":
                    gameLanguage = "de_at";
                    break;
                case "de-CH":
                    gameLanguage = "de_ch";
                    break;
                case "dv":
                case "dv-MV":
                    break;
                case "el":
                case "el-GR":
                    gameLanguage = "el_gr";
                    break;
                case "en":
                case "en-029":
                case "en-BZ":
                case "en-IE":
                case "en-JM":
                case "en-PH":
                case "en-TT":
                case "en-ZA":
                case "en-ZW":
                case "en-US":
                    gameLanguage = "en_us";
                    break;
                case "en-GB":
                    gameLanguage = "en_gb";
                    break;
                case "en-AU":
                    gameLanguage = "en_au";
                    break;
                case "en-CA":
                    gameLanguage = "en_ca";
                    break;
                case "en-NZ":
                    gameLanguage = "en_nz";
                    break;
                case "es":
                case "es-BO":
                case "es-CO":
                case "es-CR":
                case "es-DO":
                case "es-ES":
                case "es-GT":
                case "es-HN":
                case "es-NI":
                case "es-PA":
                case "es-PE":
                case "es-PR":
                case "es-PY":
                case "es-SV":
                    gameLanguage = "es_es";
                    break;
                case "es-AR":
                    gameLanguage = "es_ar";
                    break;
                case "es-CL":
                    gameLanguage = "es_cl";
                    break;
                case "es-EC":
                    gameLanguage = "es_ec";
                    break;
                case "es-MX":
                    gameLanguage = "es_mx";
                    break;
                case "es-UY":
                    gameLanguage = "es_uy";
                    break;
                case "es-VE":
                    gameLanguage = "es_ve";
                    break;
                case "et":
                case "et-EE":
                    gameLanguage = "et_ee";
                    break;
                case "eu":
                case "eu-ES":
                    gameLanguage = "eu_es";
                    break;
                case "fa":
                case "fa-IR":
                    gameLanguage = "fa_ir";
                    break;
                case "fi":
                case "fi-FI":
                    gameLanguage = "fi_fi";
                    break;
                case "fil":
                case "fil-PH":
                    gameLanguage = "fil_ph";
                    break;
                case "tl":
                case "tl-PH":
                    gameLanguage = "tl_ph";
                    break;
                case "fo":
                case "fo-FO":
                    gameLanguage = "fo_fo";
                    break;
                case "fr":
                case "fr-BE":
                case "fr-FR":
                case "fr-CH":
                case "fr-LU":
                case "fr-MC":
                    gameLanguage = "fr_fr";
                    break;
                case "fr-CA":
                    gameLanguage = "fr_ca";
                    break;
                case "gl":
                case "gl-ES":
                    gameLanguage = "gl_es";
                    break;
                case "gu":
                case "gu-IN":
                    break;
                case "he":
                case "he-IL":
                    gameLanguage = "he_il";
                    break;
                case "hi":
                case "hi-IN":
                    gameLanguage = "hi_in";
                    break;
                case "hr":
                case "hr-BA":
                case "hr-HR":
                    gameLanguage = "hr_hr";
                    break;
                case "hu":
                case "hu-HU":
                    gameLanguage = "hu_hu";
                    break;
                case "hy":
                case "hy-AM":
                    gameLanguage = "hy_am";
                    break;
                case "id":
                case "id-ID":
                    gameLanguage = "id_id";
                    break;
                case "is":
                case "is-IS":
                    gameLanguage = "is_is";
                    break;
                case "it":
                case "it-CH":
                case "it-IT":
                    gameLanguage = "it_it";
                    break;
                case "ja":
                case "ja-JP":
                    gameLanguage = "ja_jp";
                    break;
                case "ka":
                case "ka-GE":
                    gameLanguage = "ka_ge";
                    break;
                case "kk":
                case "kk-KZ":
                    gameLanguage = "kk_kz";
                    break;
                case "kn":
                case "kn-IN":
                    gameLanguage = "kn_in";
                    break;
                case "kok":
                case "kok-IN":
                    break;
                case "ko":
                case "ko-KR":
                    gameLanguage = "ko_kr";
                    break;
                case "ky":
                case "ky-KG":
                    break;
                case "lt":
                case "lt-LT":
                    gameLanguage = "lt_lt";
                    break;
                case "lv":
                case "lv-LV":
                    gameLanguage = "lv_lv";
                    break;
                case "mi-NZ":
                    break;
                case "mk":
                case "mk-MK":
                    gameLanguage = "mk_mk";
                    break;
                case "mn":
                case "mn-MN":
                    gameLanguage = "mn_mn";
                    break;
                case "mr":
                case "mr-IN":
                    break;
                case "ms":
                case "ms-BN":
                case "ms-MY":
                    gameLanguage = "ms_my";
                    break;
                case "mt-MT":
                    gameLanguage = "mt_mt";
                    break;
                case "nb-NO":
                    gameLanguage = "no_no";
                    break;
                case "nl":
                case "nl-NL":
                    gameLanguage = "nl_nl";
                    break;
                case "nl-BE":
                    gameLanguage = "nl_be";
                    break;
                case "nn-NO":
                    gameLanguage = "nn_no";
                    break;
                case "no":
                    gameLanguage = "no_no";
                    break;
                case "ns-ZA":
                    break;
                case "pa":
                case "pa-IN":
                    break;
                case "pl":
                case "pl-PL":
                    gameLanguage = "pl_pl";
                    break;
                case "pt":
                case "pt-PT":
                    gameLanguage = "pt_pt";
                    break;
                case "pt-BR":
                    gameLanguage = "pt_br";
                    break;
                case "quz-BO":
                    break;
                case "quz-EC":
                    break;
                case "quz-PE":
                    break;
                case "ro":
                case "ro-RO":
                    gameLanguage = "ro_ro";
                    break;
                case "ru":
                case "ru-RU":
                    gameLanguage = "ru_ru";
                    break;
                case "sa":
                case "sa-IN":
                    break;
                case "se-FI":
                case "se-NO":
                case "se-SE":
                    gameLanguage = "se_no";
                    break;
                case "sk":
                case "sk-SK":
                    gameLanguage = "sk_sk";
                    break;
                case "sl":
                case "sl-SI":
                    gameLanguage = "sl_si";
                    break;
                case "sma-NO":
                    break;
                case "sma-SE":
                    break;
                case "smj-NO":
                    break;
                case "smj-SE":
                    break;
                case "smn-FI":
                    break;
                case "sms-FI":
                    break;
                case "sq":
                case "sq-AL":
                    gameLanguage = "sq_al";
                    break;
                case "sr":
                case "sr-Cyrl-BA":
                case "sr-Cyrl-CS":
                case "sr-Latn-BA":
                case "sr-Latn-CS":
                    gameLanguage = "sr_sp";
                    break;
                case "sv":
                case "sv-FI":
                case "sv-SE":
                    gameLanguage = "sv_se";
                    break;
                case "sw":
                case "sw-KE":
                    break;
                case "syr":
                case "syr-SY":
                    break;
                case "ta":
                case "ta-IN":
                    gameLanguage = "ta_in";
                    break;
                case "te":
                case "te-IN":
                    break;
                case "th":
                case "th-TH":
                    gameLanguage = "th_th";
                    break;
                case "tn-ZA":
                    break;
                case "tr":
                case "tr-TR":
                    gameLanguage = "tr_tr";
                    break;
                case "tt":
                case "tt-RU":
                    gameLanguage = "tt_ru";
                    break;
                case "uk":
                case "uk-UA":
                    gameLanguage = "uk_ua";
                    break;
                case "ur":
                case "ur-PK":
                    break;
                case "uz":
                case "uz-Cyrl-UZ":
                case "uz-Latn-UZ":
                    break;
                case "vi":
                case "vi-VN":
                    gameLanguage = "vi_vn";
                    break;
                case "xh-ZA":
                    break;
                case "zh-Hans": /* CurrentCulture.Parent.Name */
                case "zh":
                case "zh-CN":
                case "zh-CHS":
                case "zh-SG":
                    gameLanguage = "zh_cn";
                    break;
                case "zh-Hant": /* CurrentCulture.Parent.Name */
                case "zh-HK":
                case "zh-CHT":
                case "zh-MO":
                    gameLanguage = "zh_hk";
                    break;
                case "zh-TW":
                    gameLanguage = "zh_tw";
                    break;
                case "zu-ZA":
                    break;
            }
            return gameLanguage;
        }

        [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
        public static string ToLowerIfNeed(string str)
        {
            const string lookupStringL = "---------------------------------!-#$%&-()*+,-./0123456789:;<=>?@abcdefghijklmnopqrstuvwxyz[-]^_`abcdefghijklmnopqrstuvwxyz{|}~-";

            bool needLower = false;
            foreach (Char c in str)
            {
                if (Char.IsUpper(c))
                {
                    needLower = true;
                    break;
                }
            }

            if (needLower)
            {
                StringBuilder sb = new(str);
                for (int i = 0; i < str.Length; ++i)
                    if (char.IsUpper(sb[i]))
                        sb[i] = lookupStringL[sb[i]];
                return sb.ToString();
            }
            else
            {
                return str;
            }
        }

        public static int DoubleToTick(double time)
        {
            time = Math.Min(int.MaxValue / (double)ClientTicksPerSecond, time);
            return (int)Math.Round(time * ClientTicksPerSecond);
        }
    }

    public static class InternalCmdCharTypeExtensions
    {
        public static char ToChar(this InternalCmdCharType type)
        {
            return type switch
            {
                InternalCmdCharType.none => ' ',
                InternalCmdCharType.slash => '/',
                InternalCmdCharType.backslash => '\\',
                _ => '/',
            };
        }

        public static string ToLogString(this InternalCmdCharType type)
        {
            return type switch
            {
                InternalCmdCharType.none => string.Empty,
                InternalCmdCharType.slash => @"/",
                InternalCmdCharType.backslash => @"\",
                _ => @"/",
            };
        }
    }

    public static class BrandInfoTypeExtensions
    {
        public static string? ToBrandString(this BrandInfoType info)
        {
            return info switch
            {
                BrandInfoType.mcc => "Minecraft-Console-Client/" + Program.Version,
                BrandInfoType.vanilla => "vanilla",
                BrandInfoType.empty => null,
                _ => null,
            };
        }
    }

    public static class ExceptionExtensions
    {
        public static string GetFullMessage(this Exception ex)
        {
            string msg = ex.Message.Replace("+", "->");
            return ex.InnerException is null
                 ? msg
                 : msg + "\n --> " + ex.InnerException.GetFullMessage();
        }
    }
}