using System;
using System.Collections.Concurrent; 
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Management;
using System.Net;
using System.Net.Http;
using System.Net.NetworkInformation; 
using System.Net.Sockets;
using System.Net.Security;
using System.Numerics;
using System.Reflection;
using System.Security.Cryptography;
using System.Security.Cryptography.X509Certificates;
using System.Text;
using System.Text.Json;
using System.Text.Json.Serialization;
using System.Threading; 
using System.Threading.Tasks;
using YamlDotNet.Serialization;
using YamlDotNet.Serialization.NamingConventions;

namespace SinmaiLauncher
{
    public static class AntiDebug
    {
        private static readonly string[] BadProcessNames =
        {
            "dnspy",
            "dnspy-x86",
            "dnspy-x64",
            "ilspy",
            "dotpeek",
            "reflector",
            "x64dbg",
            "x32dbg",
            "ollydbg",
            "idaq",
            "idaq64",
            "idaw",
            "idaw64",
            "charles",
            "fiddler",
            "wireshark",
            "cheatengine",
        };

        public static void PerformChecks()
        {
            try
            {
                if (Debugger.IsAttached)
                {
                    Environment.Exit(0xBAD);
                }
                if (IsAnyBadProcessRunning())
                {
                    Environment.Exit(0xDEAD);
                }
            }
            catch (Exception)
            {
                Environment.Exit(0xE);
            }
        }

        private static bool IsAnyBadProcessRunning()
        {
            try
            {
                Process[] allProcesses = Process.GetProcesses();
                foreach (var process in allProcesses)
                {
                    try
                    {
                        string processName = process.ProcessName.ToLowerInvariant();
                        foreach (var badName in BadProcessNames)
                        {
                            if (processName.Contains(badName))
                            {
                                return true;
                            }
                        }
                    }
                    catch (Exception) { }
                }
            }
            catch (Exception) { }
            return false;
        }
    }
    #endregion


    public class ServerNode
    {
        public int Id { get; set; }
        public string Name { get; set; } = "";
        public string BaseUrl { get; set; } = "";
        public string Hash { get; set; } = "";
    }

    class Program
    {
        private static readonly ServerNode NodeBeijing = new ServerNode
        {
            Id = 1,
            Name = "ZheJiang-10Gb",
            BaseUrl = "",
            Hash = "",
        };

        private static readonly ServerNode NodeTokyo = new ServerNode
        {
            Id = 2,
            Name = "Tokyo-200Mb",
            BaseUrl = "",
            Hash = "",
        };

        private static readonly ServerNode NodeShanghai = new ServerNode
        {
            Id = 3,
            Name = "Beijing-1Mb",
            BaseUrl = "",
            Hash = "",
        };

        private static ServerNode CurrentNode = NodeTokyo;

        private enum GameMode
        {
            Mai,
            Chuni,
            Ongeki,
            Unknown,
        }

        private static GameMode CurrentGameMode = GameMode.Unknown;

        private static string ApiVersionPrefix => (CurrentNode != null && CurrentNode.Id == 1) ? "" : "";
        private static string LauncherManifestUrl => $"{CurrentNode.BaseUrl}/{ApiVersionPrefix}/";
        private static string ApiVerificationUrl => $"{CurrentNode.BaseUrl}/{ApiVersionPrefix}/";
        private static string ApiDownloadUrl => $"{CurrentNode.BaseUrl}/{ApiVersionPrefix}/";
        private static string AnnouncementUrl => $"{CurrentNode.BaseUrl}/{ApiVersionPrefix}/";

        private const string LocalSecretKey =
            "";
        private static string ExpectedPublicKeyHash =
            "";

        private static readonly string ExecutablePath = Assembly.GetExecutingAssembly().Location;
        private static readonly string LauncherDir = AppContext.BaseDirectory;
        private static readonly string GameDir = Path.GetFullPath(Path.Combine(LauncherDir, ".."));
        private static readonly string ConfigPath = Path.Combine(LauncherDir, "config.yml");
        
        private static readonly string IcfDir = Path.Combine(GameDir, "amfs");

        private static readonly HttpClient HttpClient = CreateHttpClientWithPinning();

        private static readonly JsonSerializerOptions JsonOptions = new JsonSerializerOptions
        {
            PropertyNameCaseInsensitive = true,
        };

        public static void Main(string[] args)
        {
            AntiDebug.PerformChecks();
            ServicePointManager.SecurityProtocol =
                SecurityProtocolType.Tls12 | SecurityProtocolType.Tls13;
            MainAsync().GetAwaiter().GetResult();
        }

        private static async Task SelectServerNodeAsync()
        {
            Console.WriteLine("正在测试节点延迟...");
            Console.WriteLine();

            var nodes = new List<ServerNode> { NodeBeijing, NodeTokyo, NodeShanghai };

            var pingTasks = nodes.Select(async node =>
            {
                long latency = await PingHostAsync(node);
                return (node, latency);
            }).ToList();

            var results = await Task.WhenAll(pingTasks);

            Console.WriteLine("┌─────┬──────────────────────────────┬─────────────┐");
            Console.WriteLine("│ ID  │ 节点名称                     │ 延迟状态    │");
            Console.WriteLine("├─────┼──────────────────────────────┼─────────────┤");

            foreach (var (node, latency) in results)
            {
                string latencyStr;
                ConsoleColor color;

                if (latency < 0)
                {
                    latencyStr = "超时";
                    color = ConsoleColor.Red;
                }
                else if (latency < 100)
                {
                    latencyStr = $"{latency} ms";
                    color = ConsoleColor.Green;
                }
                else if (latency < 200)
                {
                    latencyStr = $"{latency} ms";
                    color = ConsoleColor.Yellow;
                }
                else
                {
                    latencyStr = $"{latency} ms";
                    color = ConsoleColor.Red;
                }

                int nameWidth = GetVisualWidth(node.Name);
                int padding = 28 - nameWidth;
                string paddedName = node.Name + new string(' ', Math.Max(0, padding));

                Console.Write("│ ");
                Console.Write($"{node.Id,-3}");
                Console.Write(" │ ");
                Console.Write(paddedName);
                Console.Write(" │ ");

                Console.ForegroundColor = color;
                Console.Write($"{latencyStr,-11}");
                Console.ResetColor();
                Console.WriteLine(" │");
            }
            Console.WriteLine("└─────┴──────────────────────────────┴─────────────┘");
            Console.WriteLine(" F1  | 国服绿网");
            Console.WriteLine("\n按数字选择节点（默认 2 = Tokyo）：");

            ConsoleKeyInfo key = Console.ReadKey(true);

            if (key.Key == ConsoleKey.F1)
            {
                await RunGreenNetTool();
                PauseAndExit();
                return; 
            }

            ServerNode selected = key.Key switch
            {
                ConsoleKey.D1 => NodeBeijing,
                ConsoleKey.NumPad1 => NodeBeijing,
                ConsoleKey.D2 => NodeTokyo,
                ConsoleKey.NumPad2 => NodeTokyo,
                ConsoleKey.D3 => NodeShanghai,
                ConsoleKey.NumPad3 => NodeShanghai,
                _ => NodeTokyo,
            };

            if (selected.Id == 1)
            {
                selected.BaseUrl = NodeTokyo.BaseUrl;
                selected.Hash = NodeTokyo.Hash;
            }

            CurrentNode = selected;
            ExpectedPublicKeyHash = selected.Hash;

            Console.ForegroundColor = ConsoleColor.Cyan;
            Console.WriteLine($"\n已选择节点：{selected.Name}");
            Console.ResetColor();

            await Task.Delay(800);
            Console.Clear();
        }
        private static int GetVisualWidth(string s)
        {
            int len = 0;
            foreach (var c in s)
            {
                len += (c < 128) ? 1 : 2;
            }
            return len;
        }
        private static async Task<long> PingHostAsync(ServerNode node)
        {
            try
            {
                var uri = new Uri(node.BaseUrl);
                string host = uri.Host;
                if (node.Id == 1)
                {
                    try
                    {
                        var sw = Stopwatch.StartNew();
                        using (var client = new TcpClient())
                        {
                            var connectTask = client.ConnectAsync(host, 443);
                            var timeoutTask = Task.Delay(5000);

                            if (await Task.WhenAny(connectTask, timeoutTask) == connectTask)
                            {
                                await connectTask; 
                                if (client.Connected)
                                {
                                    sw.Stop();
                                    return sw.ElapsedMilliseconds;
                                }
                            }
                        }
                    }
                    catch
                    {
                        return -1;
                    }
                    return -1; 
                }

                using (var ping = new Ping())
                {
                    PingReply reply = await ping.SendPingAsync(host, 5000);
                    if (reply.Status == IPStatus.Success)
                    {
                        return reply.RoundtripTime;
                    }
                }
            }
            catch { }
            return -1;
        }

        static async Task MainAsync()
        {
            Console.ForegroundColor = ConsoleColor.White;
            Console.Clear();
            string currentVersion =
                Assembly.GetExecutingAssembly().GetName().Version?.ToString(3) ?? "N/A";

            DetectGameMode();
            await SelectServerNodeAsync();
            if (CurrentGameMode == GameMode.Unknown)
            {
                Console.ForegroundColor = ConsoleColor.Red;
                Console.WriteLine("baka~baka~");
                Console.WriteLine("工具放错位置了哦");
                Console.ResetColor();
                PauseAndExit();
                return;
            }

            string gameModeName;
            switch (CurrentGameMode)
            {
                case GameMode.Mai:
                    gameModeName = "maimai";
                    break;
                case GameMode.Chuni:
                    gameModeName = "CHUNITHM";
                    break;
                case GameMode.Ongeki:
                    gameModeName = "ONGEKI Re:Fresh";
                    break;
                default:
                    gameModeName = "未知";
                    break;
            }
            Console.WriteLine($"当前运行游戏: {gameModeName}");

            string gameId = GetGameIdString(CurrentGameMode);
            if (gameId == "SDEZ")
            {
                Console.WriteLine("当前运行游戏SDEZ喵");
            }
            else if (gameId == "SDGB")
            {
                Console.WriteLine("当前运行游戏SDGB喵");
            }

            Console.Title = $"启动器 v{currentVersion} - [{gameModeName}] - [{gameId}]";

            if (await CheckAndApplySelfUpdate())
            {
                return;
            }
            await ShowAnnouncement();

            try
            {
                Config cfg = LoadOrCreateConfig();
                Console.WriteLine("正在验证机器码ing...");

                GamePermissions? permissions = await VerifyApiAsync(cfg.Mc);

                if (permissions == null)
                {
                    Console.ForegroundColor = ConsoleColor.Red;
                    Console.WriteLine("啊嘞？机器码或通信验证失败惹");
                    Console.WriteLine("请联系群主授权喵");
                    Console.ResetColor();
                    PauseAndExit();
                    return;
                }

                Console.WriteLine("验证成功");

                bool hasPermission = false;
                switch (gameId)
                {
                    case "SDGB":
                        hasPermission = permissions.SDGB;
                        break;
                    case "SDEZ":
                        hasPermission = permissions.SDEZ;
                        break;
                    case "SDHD":
                        hasPermission = permissions.SDHD;
                        break;
                    case "SDDT":
                        hasPermission = permissions.SDDT;
                        break;
                }

                if (!hasPermission)
                {
                    Console.ForegroundColor = ConsoleColor.Red;
                    Console.WriteLine(
                        $"啊哦，您的账户没有 [{gameId}] ({gameModeName}) 的游戏权限喵"
                    );
                    Console.WriteLine("请联系群主开通哦");
                    Console.ResetColor();
                    PauseAndExit();
                    return;
                }

                await CheckAndApplyGameUpdates(cfg.Mc, gameId);
                Console.WriteLine("\n正在启动游戏...");
                StartGame(cfg);
            }
            catch (Exception ex)
            {
                Console.ForegroundColor = ConsoleColor.Red;
                Console.WriteLine("\n启动器运行期间发生严重错误");
                LogExceptionDetails(ex);
                Console.ResetColor();
                PauseAndExit();
            }
        }

        private static async Task RunGreenNetTool()
        {
            Console.Clear();
            Console.ForegroundColor = ConsoleColor.Cyan;
            Console.WriteLine("=== 国服绿网工具 ===");
            Console.ResetColor();

            Config cfg = LoadOrCreateConfig();
            Console.WriteLine("正在验证权限...");

            try
            {
                GamePermissions? permissions = await VerifyApiAsync(cfg.Mc);
                if (permissions == null || !permissions.LV)
                {
                    Console.ForegroundColor = ConsoleColor.Red;
                    Console.WriteLine("权限验证失败喵");
                    Console.WriteLine("5r喵~需要请联系群主喵");
                    Console.ResetColor();
                    Console.WriteLine("\n按任意键返回...");
                    Console.ReadKey(true);
                    return;
                }
            }
            catch (Exception ex)
            {
                Console.ForegroundColor = ConsoleColor.Red;
                Console.WriteLine($"验证过程出错: {ex.Message}");
                Console.ResetColor();
                Console.WriteLine("\n按任意键返回...");
                Console.ReadKey(true);
                return;
            }

            Console.WriteLine("权限验证通过，开始修改 hosts...");
            try
            {
                await ModifyHostsFile();
                Console.ForegroundColor = ConsoleColor.Green;
                Console.WriteLine("\n操作成功完成！");
                Console.WriteLine("请重启游戏或电脑以确保生效。");
                Console.ResetColor();
            }
            catch (Exception ex)
            {
                Console.ForegroundColor = ConsoleColor.Red;
                Console.WriteLine($"\n操作失败: {ex.Message}");
                if (ex is UnauthorizedAccessException)
                {
                    Console.WriteLine("请尝试以管理员身份运行此程序。");
                }
                Console.ResetColor();
            }

            Console.WriteLine("\n按任意键退出...");
            Console.ReadKey(true);
        }

        private static async Task ModifyHostsFile()
        {
            Config cfg = LoadOrCreateConfig();
            string hostsPath = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.System), @"");

            if (!File.Exists(hostsPath))
            {
                throw new FileNotFoundException("未找到系统 hosts 文件", hostsPath);
            }
            var lines = File.ReadAllLines(hostsPath).ToList();
            var domainsToRemove = new HashSet<string> { "" };
            int removedCount = lines.RemoveAll(line =>
            {
                if (string.IsNullOrWhiteSpace(line)) return false;
                if (line.TrimStart().StartsWith("#")) return false;

                foreach (var domain in domainsToRemove)
                {
                    if (line.Contains(domain)) return true;
                }
                return false;
            });
            
            Console.WriteLine($"已清理 {removedCount} 条旧记录");
            Console.WriteLine($"正在从服务器获取最新数据...");

            string localR2f = GenerateLocalR2FCode(cfg.Mc);
            var hostsRequestPayload = new
            {
                r2f_code = localR2f,
                request_hosts = true,
                mc = cfg.Mc
            };

            string jsonPayload = JsonSerializer.Serialize(hostsRequestPayload);
            string encryptedPayload = AuthCipher.Encrypt(jsonPayload, cfg.Mc);

            var requestBody = new
            {
                mc = cfg.Mc,
                payload = encryptedPayload
            };

            var content = new StringContent(
                JsonSerializer.Serialize(requestBody),
                Encoding.UTF8,
                "application/json"
            );

            string newData = "";
            try
            {
                HttpResponseMessage response = await HttpClient.PostAsync(ApiDownloadUrl, content);
                response.EnsureSuccessStatusCode();
                string encryptedResponse = await response.Content.ReadAsStringAsync();
                string decryptedJson = AuthCipher.Decrypt(encryptedResponse, cfg.Mc);
                if (decryptedJson == null)
                {
                    try
                    {
                        using (JsonDocument doc = JsonDocument.Parse(encryptedResponse))
                        {
                            if (doc.RootElement.TryGetProperty("message", out JsonElement msg))
                            {
                                throw new Exception($"服务器返回错误: {msg.GetString()}");
                            }
                        }
                    }
                    catch (JsonException) { }
                    throw new Exception("解密服务器响应失败");
                }
                HostsResponse? hostsResp = JsonSerializer.Deserialize<HostsResponse>(decryptedJson, JsonOptions);
                if (hostsResp == null || !hostsResp.Success)
                {
                    throw new Exception(hostsResp?.Message ?? "未知错误");
                }
                newData = hostsResp.HostsContent ?? "";
            }
            catch (Exception ex)
            {
                throw new Exception($"获取 hosts 数据失败: {ex.Message}");
            }
            var newLines = newData.Split(new[] { '\r', '\n' }, StringSplitOptions.RemoveEmptyEntries);
            int addedCount = 0;
            foreach (var line in newLines)
            {
                var parts = line.Split(new[] { ' ', '\t' }, StringSplitOptions.RemoveEmptyEntries);
                if (parts.Length >= 2)
                {
                    string p1 = parts[0];
                    string p2 = parts[1];
                    string ip = "";
                    string domain = "";
                    if (IPAddress.TryParse(p2, out _))
                    {
                        domain = p1;
                        ip = p2;
                    }
                    else if (IPAddress.TryParse(p1, out _))
                    {
                        ip = p1;
                        domain = p2;
                    }
                    if (!string.IsNullOrEmpty(ip) && !string.IsNullOrEmpty(domain))
                    {
                        lines.Add($"{ip} {domain}");
                        addedCount++;
                    }
                }
            }
            if (addedCount == 0)
            {
                Console.WriteLine("警告: 未能从服务器数据中解析出有效的 hosts 记录");
            }
            File.WriteAllLines(hostsPath, lines);
            Console.WriteLine("hosts 文件写入完成");
            try
            {
                Process.Start(new ProcessStartInfo
                {
                    FileName = "ipconfig",
                    Arguments = "/flushdns",
                    CreateNoWindow = true,
                    UseShellExecute = false
                })?.WaitForExit();
                Console.WriteLine("DNS 缓存已刷新");
            }
            catch { }
        }
        private static async Task ShowAnnouncement()
        {
            string lastGgPath = Path.Combine(LauncherDir, "");
            try
            {
                Console.WriteLine("\n正在获取公告信息...");
                string announcement = await HttpClient.GetStringAsync(AnnouncementUrl);
                announcement = announcement.Trim();
                if (string.IsNullOrWhiteSpace(announcement))
                    return;
                string last = "";
                if (File.Exists(lastGgPath))
                    last = File.ReadAllText(lastGgPath).Trim();
                if (last == announcement)
                    return;
                Console.ForegroundColor = ConsoleColor.Cyan;
                Console.WriteLine("\n" + new string('-', 70));
                Console.WriteLine("公告");
                Console.WriteLine(new string('-', 70));
                Console.ForegroundColor = ConsoleColor.Yellow;
                Console.WriteLine(announcement);
                Console.ForegroundColor = ConsoleColor.Cyan;
                Console.WriteLine(new string('-', 70));
                Console.ResetColor();
                Console.WriteLine("\n按任意键继续...");
                Console.ReadKey();
                Console.Clear();
                File.WriteAllText(lastGgPath, announcement);
            }
            catch
            {
                Console.ForegroundColor = ConsoleColor.DarkGray;
                Console.WriteLine("无法获取公告信息，跳过显示");
                Console.ResetColor();
            }
        }
        private static HttpClient CreateHttpClientWithPinning()
        {
            var handler = new HttpClientHandler
            {
                ServerCertificateCustomValidationCallback = (request, cert, chain, errors) =>
                {
                    if (CurrentNode != null && CurrentNode.Id == 3)
                    {
                        return true;
                    }
                    if (CurrentNode != null && request != null)
                    {
                        try
                        {
                            string requestHost = request.RequestUri.Host;
                            string apiHost = new Uri(CurrentNode.BaseUrl).Host;
                            if (!string.Equals(requestHost, apiHost, StringComparison.OrdinalIgnoreCase))
                            {
                                return true;
                            }
                        }
                        catch { }
                    }
                    if (errors != SslPolicyErrors.None || cert == null)
                    {
                        Console.WriteLine($"SSL错误: {errors}");
                        return false;
                    }
                    try
                    {
                        using var sha256 = SHA256.Create();
                        var publicKeyHash = sha256.ComputeHash(cert.GetPublicKey());
                        var hashString = BitConverter
                            .ToString(publicKeyHash)
                            .Replace("-", "")
                            .ToLowerInvariant();
                        if (hashString == ExpectedPublicKeyHash)
                        {
                            return true;
                        }
                        Console.ForegroundColor = ConsoleColor.Red;
                        Console.WriteLine($"\n[SSL 验证失败] 证书 Hash 不匹配!");
                        Console.ResetColor();
                        return false;
                    }
                    catch (Exception ex)
                    {
                        Console.ForegroundColor = ConsoleColor.Red;
                        Console.WriteLine($"[SSL 验证异常]: {ex.Message}");
                        Console.ResetColor();
                        return false;
                    }
                },
            };
            var client = new HttpClient(handler);
            client.DefaultRequestHeaders.UserAgent.ParseAdd("xiaoxin/baka");
            return client;
        }
        private static async Task<bool> CheckAndApplySelfUpdate()
        {
            Console.WriteLine("正在检查启动器更新...");
            try
            {
                string json = await HttpClient.GetStringAsync(LauncherManifestUrl);
                var manifest = JsonSerializer.Deserialize<UpdateManifest>(json, JsonOptions);
                if (
                    manifest?.Launcher == null
                    || string.IsNullOrEmpty(manifest.Launcher.Name)
                    || string.IsNullOrEmpty(manifest.Launcher.Hash)
                    || string.IsNullOrEmpty(manifest.Launcher.Url)
                )
                {
                    Console.WriteLine("启动器清单文件中缺少信息");
                    return false;
                }
                string fileToCheck = manifest.Launcher.Name;
                string serverHash = manifest.Launcher.Hash;
                string localFilePath = Path.Combine(LauncherDir, fileToCheck);
                Console.WriteLine($" -> 正在校验本地核心文件: {localFilePath}");
                bool needsUpdate = false;
                if (!File.Exists(localFilePath))
                {
                    needsUpdate = true;
                    Console.ForegroundColor = ConsoleColor.Yellow;
                    Console.WriteLine(" -> 状态: 核心文件不存在，需要更新");
                    Console.ResetColor();
                }
                else if (!VerifyFileHash(localFilePath, serverHash))
                {
                    needsUpdate = true;
                    Console.ForegroundColor = ConsoleColor.Yellow;
                    Console.WriteLine(" -> 状态: 有新版本啦~");
                    Console.ResetColor();
                }
                if (needsUpdate)
                {
                    Console.ForegroundColor = ConsoleColor.Green;
                    Console.WriteLine("正在准备下载ing...");
                    Console.ResetColor();
                    await ApplySelfUpdate(manifest.Launcher);
                    return true;
                }
                else
                {
                    Console.WriteLine("已经是最新版了哦");
                    return false;
                }
            }
            catch (HttpRequestException ex)
            {
                Console.ForegroundColor = ConsoleColor.Red;
                Console.WriteLine("无法连接到更新服务器，请检查网络配置");
                LogExceptionDetails(ex);
                Console.ResetColor();
                PauseAndExit();
                return false;
            }
            catch (Exception ex)
            {
                Console.ForegroundColor = ConsoleColor.Red;
                Console.WriteLine($"呜哇！检查更新时发生错误惹:");
                LogExceptionDetails(ex);
                Console.ResetColor();
                return false;
            }
        }
        private static async Task ApplySelfUpdate(LauncherInfo newLauncher)
        {
            string batPath = Path.Combine(LauncherDir, "updater.bat");
            string downloadPath = Path.Combine(LauncherDir, "update_new.dll");

            try
            {
                await DownloadFileAsync(
                    newLauncher.Url,
                    downloadPath,
                    "新版核心 update.dll",
                    newLauncher.Hash
                );
                string batchContent =
                    @"";
                File.WriteAllText(batPath, batchContent, Encoding.Default);

                Process.Start(
                    new ProcessStartInfo(batPath) { CreateNoWindow = true, UseShellExecute = false }
                );
                Environment.Exit(0);
            }
            catch (Exception ex)
            {
                Console.ForegroundColor = ConsoleColor.Red;
                Console.WriteLine("自动更新失败");
                LogExceptionDetails(ex);
                Console.ResetColor();
                PauseAndExit();
            }
        }
        private static async Task CheckAndApplyGameUpdates(string mc, string gameId)
        {
            if (string.IsNullOrEmpty(gameId) || gameId == "unknown")
            {
                Console.ForegroundColor = ConsoleColor.Red;
                Console.WriteLine("内部错误：无法识别的游戏ID，无法更新。");
                Console.ResetColor();
                return;
            }
            try
            {
                string localR2f = GenerateLocalR2FCode(mc);
                var treeRequestPayload = new { r2f_code = localR2f, request_tree = gameId };
                string decryptedTreeJson = await PostToDownloadApiAsync(mc, treeRequestPayload);
                if (string.IsNullOrEmpty(decryptedTreeJson))
                {
                    Console.ForegroundColor = ConsoleColor.Red;
                    Console.WriteLine("获取文件列表失败");
                    Console.ResetColor();
                    return;
                }
                var treeResponse = JsonSerializer.Deserialize<FileNameListResponse>(
                    decryptedTreeJson,
                    JsonOptions
                );
                if (treeResponse == null || !treeResponse.Success || treeResponse.FileTree == null)
                {
                    Console.ForegroundColor = ConsoleColor.Red;
                    if (
                        treeResponse?.Message != null
                        && treeResponse.Message.Contains("permission denied")
                    )
                    {
                        Console.WriteLine("获取文件列表失败: 游戏权限被服务器拒绝。");
                    }
                    else
                    {
                        Console.WriteLine(
                            "获取文件列表失败: " + (treeResponse?.Message ?? "未知错误")
                        );
                    }
                    Console.ResetColor();
                    return;
                }
                Console.WriteLine(
                    $"成功获取到 {treeResponse.FileTree.Count} 个文件信息，正在比对本地文件..."
                );
                var filesToRequestBag = new ConcurrentBag<string>();
                int totalFiles = treeResponse.FileTree.Count;
                int processedFiles = 0;
                try { Console.CursorVisible = false; } catch { }
                Parallel.ForEach(treeResponse.FileTree, new ParallelOptions { MaxDegreeOfParallelism = Environment.ProcessorCount * 2 }, entry =>
                {
                    string serverFileName = entry.Key;
                    FileNodeInfo? nodeInfo = entry.Value;
                    string? serverHash = nodeInfo?.Hash;
                    string? category = nodeInfo?.Category; 
                    if (!string.IsNullOrEmpty(serverFileName))
                    {
                        string localPath = GetLocalPathForFile(serverFileName, category);
                        bool needsUpdate = false;
                        if (!File.Exists(localPath))
                        {
                            needsUpdate = true;
                        }
                        else if (!string.IsNullOrEmpty(serverHash))
                        {
                            string localHash = GetFileHash(localPath);
                            if (!localHash.Equals(serverHash, StringComparison.OrdinalIgnoreCase))
                            {
                                needsUpdate = true;
                            }
                        }
                        if (needsUpdate)
                        {
                            filesToRequestBag.Add(serverFileName);
                        }
                    }
                    int current = Interlocked.Increment(ref processedFiles);
                    if (current % 5 == 0 || current == totalFiles)
                    {
                        Console.Write($"\r       -> 校验进度: {current}/{totalFiles} ({(int)((float)current / totalFiles * 100)}%)");
                    }
                });
                try { Console.CursorVisible = true; } catch { }
                Console.WriteLine(); 
                var filesToRequest = filesToRequestBag.ToList();
                if (filesToRequest.Count == 0)
                {
                    Console.WriteLine("\n所有必要的游戏文件都存在哦");
                    return;
                }
                Console.ForegroundColor = ConsoleColor.Yellow;
                Console.WriteLine(
                    $"\n发现 {filesToRequest.Count} 个本地缺失或需要更新的文件，正在请求下载链接..."
                );
                Console.ResetColor();
                localR2f = GenerateLocalR2FCode(mc);
                var linksRequestPayload = new
                {
                    r2f_code = localR2f,
                    request_files = new { game = gameId, files = filesToRequest },
                };
                string decryptedLinksJson = await PostToDownloadApiAsync(mc, linksRequestPayload);
                if (string.IsNullOrEmpty(decryptedLinksJson))
                {
                    Console.ForegroundColor = ConsoleColor.Red;
                    Console.WriteLine("获取下载链接失败");
                    Console.ResetColor();
                    return;
                }
                var linksResponse = JsonSerializer.Deserialize<FileLinksResponse>(
                    decryptedLinksJson,
                    JsonOptions
                );
                if (
                    linksResponse == null
                    || !linksResponse.Success
                    || linksResponse.FileLinks == null
                )
                {
                    Console.ForegroundColor = ConsoleColor.Red;
                    if (
                        linksResponse?.Message != null
                        && linksResponse.Message.Contains("permission denied")
                    )
                    {
                        Console.WriteLine("获取下载链接失败: 游戏权限被服务器拒绝。");
                    }
                    else
                    {
                        Console.WriteLine(
                            "获取下载链接失败: " + (linksResponse?.Message ?? "未知错误")
                        );
                    }
                    Console.ResetColor();
                    return;
                }
                long totalSize = 0;
                long totalDownloaded = 0;
                Console.WriteLine("正在计算总下载大小...");
                var sizeTasks = linksResponse.FileLinks.Select(async kvp => 
                {
                    if(kvp.Value?.Url != null) 
                    {
                        long size = await GetFileSizeAsync(kvp.Value.Url);
                        Interlocked.Add(ref totalSize, size);
                    }
                });
                await Task.WhenAll(sizeTasks);
                Console.WriteLine($"总计大小: {FormatBytes(totalSize)}，开始下载...");
                try { Console.CursorVisible = false; } catch { }
                var stopwatch = Stopwatch.StartNew();
                int updatedCount = 0;
                foreach (var entry in linksResponse.FileLinks)
                {
                    string fileName = entry.Key;
                    FileLinkInfo? linkInfo = entry.Value;
                    string? category = null;
                    if (treeResponse.FileTree.TryGetValue(fileName, out var originalNode))
                    {
                        category = originalNode.Category;
                    }
                    string localPath = GetLocalPathForFile(fileName, category);
                    if (linkInfo == null || string.IsNullOrEmpty(linkInfo.Url))
                    {
                        Console.WriteLine(); 
                        Console.ForegroundColor = ConsoleColor.Red;
                        Console.WriteLine($" -> 服务器未返回文件 {fileName} 的有效 URL，跳过");
                        Console.ResetColor();
                        continue;
                    }
                    string? expectedHash = linkInfo.Hash;
                    if (string.IsNullOrEmpty(expectedHash) && originalNode != null)
                    {
                        expectedHash = originalNode.Hash;
                    }
                    try
                    {
                        await DownloadFileAsync(linkInfo.Url, localPath, fileName, expectedHash, (readBytes) =>
                        {
                            long newTotal = Interlocked.Add(ref totalDownloaded, readBytes);
                            DrawGlobalProgressBar(newTotal, totalSize, stopwatch.Elapsed);
                        });
                        updatedCount++;
                    }
                    catch (Exception ex)
                    {
                        Console.WriteLine(); 
                        Console.ForegroundColor = ConsoleColor.Red;
                        Console.WriteLine($" -> 下载 {fileName} 失败: {ex.Message}");
                        Console.ResetColor();
                    }
                }
                try { Console.CursorVisible = true; } catch { }
                Console.WriteLine(); 
                Console.WriteLine(
                    $"\n游戏文件更新完成，总计下载了 {updatedCount} 个缺失文件呢，哼哼ᗜˬᗜ"
                );
            }
            catch (JsonException jsonEx)
            {
                Console.ForegroundColor = ConsoleColor.Red;
                Console.WriteLine($"解析服务器响应时出错 (可能是通信密钥不同步): {jsonEx.Message}");
                Console.ResetColor();
            }
            catch (Exception ex)
            {
                Console.ForegroundColor = ConsoleColor.Red;
                Console.WriteLine("检查游戏更新时发生严重错误QAQ");
                LogExceptionDetails(ex);
                Console.ResetColor();
            }
        }
        private static string GetLocalPathForFile(string name, string? category)
        {
            string relativePath = name.Replace('/', Path.DirectorySeparatorChar);

            if (string.IsNullOrEmpty(category))
            {
                return Path.Combine(GameDir, relativePath);
            }
            switch (category.ToLowerInvariant())
            {
                case "option":
                    return Path.Combine(GameDir, "option", relativePath);
                case "file":
                    return Path.Combine(GameDir, relativePath);
                case "amfs":
                    return Path.Combine(GameDir, "amfs", relativePath);
                case "dll":
                    return Path.Combine(GameDir, "Sinmai_Data", "Managed", relativePath);
                case "opt":
                    return Path.Combine(GameDir, "Sinmai_Data", "StreamingAssets", relativePath);
                default:
                    return Path.Combine(GameDir, relativePath);
            }
        }
        private static async Task<string?> PostToDownloadApiAsync(string mc, object payloadObject)
        {
            try
            {
                string payloadJson = JsonSerializer.Serialize(payloadObject);
                string encryptedPayload = AuthCipher.Encrypt(payloadJson, mc);
                var apiRequest = new ApiAuthRequest { Mc = mc, Payload = encryptedPayload };
                string jsonRequest = JsonSerializer.Serialize(apiRequest);
                var httpContent = new StringContent(jsonRequest, Encoding.UTF8, "application/json");
                var response = await HttpClient.PostAsync(ApiDownloadUrl, httpContent);
                response.EnsureSuccessStatusCode();
                string encryptedResponse = await response.Content.ReadAsStringAsync();
                string decryptedJson = AuthCipher.Decrypt(encryptedResponse, mc);
                return decryptedJson;
            }
            catch (Exception ex)
            {
                Console.ForegroundColor = ConsoleColor.Red;
                Console.WriteLine($"[Download API] 请求失败: {ex.Message}");
                Console.ResetColor();
                return null;
            }
        }
        private static async Task DownloadFileAsync(
            string? url,
            string localPath,
            string? displayName,
            string? expectedHash,
            Action<int>? progressCallback = null
        )
        {
            if (string.IsNullOrEmpty(url) || string.IsNullOrEmpty(displayName))
            {
                return;
            }
            bool quiet = progressCallback != null;
            if (!quiet) Console.WriteLine($"    -> 准备下载: {displayName}");
            string? directory = Path.GetDirectoryName(localPath);
            if (!string.IsNullOrEmpty(directory))
            {
                Directory.CreateDirectory(directory);
            }
            try
            {
                using var response = await HttpClient.GetAsync(
                    url,
                    HttpCompletionOption.ResponseHeadersRead
                );
                response.EnsureSuccessStatusCode();
                using var stream = await response.Content.ReadAsStreamAsync();
                Stopwatch? sw = quiet ? null : Stopwatch.StartNew();
                using (
                    var fileStream = new FileStream(
                        localPath,
                        FileMode.Create,
                        FileAccess.Write,
                        FileShare.None
                    )
                )
                {
                    byte[] buffer = new byte[8192];
                    long totalBytes = response.Content.Headers.ContentLength ?? -1;
                    long totalRead = 0;
                    int bytesRead;
                    while ((bytesRead = await stream.ReadAsync(buffer, 0, buffer.Length)) > 0)
                    {
                        await fileStream.WriteAsync(buffer, 0, bytesRead);
                        totalRead += bytesRead;
                        if (quiet)
                        {
                            progressCallback?.Invoke(bytesRead);
                        }
                        else if (totalBytes > 0)
                        {
                            var percentage = (int)((double)totalRead * 100 / totalBytes);
                            Console.Write(
                                $"\r       -> 正在下载... {percentage}% ({totalRead / 1024 / 1024}MB / {totalBytes / 1024 / 1024}MB)"
                            );
                        }
                    }
                }
                sw?.Stop();
                if (!quiet)
                {
                    Console.WriteLine(
                        $"\r       -> 下载完成: {displayName} ({sw?.Elapsed.TotalSeconds:F2}s)      "
                    );
                }
                if (!string.IsNullOrEmpty(expectedHash))
                {
                    if (!VerifyFileHash(localPath, expectedHash, false))
                    {
                        throw new Exception("文件校验失败，可能已损坏惹QAQ");
                    }
                    if (!quiet) Console.WriteLine("       -> 文件校验成功");
                }
                else
                {}
            }
            catch (Exception ex)
            {
                if (!quiet)
                {
                    Console.ForegroundColor = ConsoleColor.Red;
                    Console.WriteLine($"\n       -> 下载 {displayName} 时发生错误QAQ: {ex.Message}");
                    Console.ResetColor();
                }
                if (File.Exists(localPath))
                {
                    try
                    {
                        File.Delete(localPath);
                    }
                    catch { }
                }
                throw;
            }
        }
        private static async Task<long> GetFileSizeAsync(string url)
        {
            try
            {
                using var request = new HttpRequestMessage(HttpMethod.Head, url);
                using var response = await HttpClient.SendAsync(request, HttpCompletionOption.ResponseHeadersRead);
                if (response.IsSuccessStatusCode)
                {
                    return response.Content.Headers.ContentLength ?? 0;
                }
            }
            catch { }
            return 0;
        }
        private static void DrawGlobalProgressBar(long currentBytes, long totalBytes, TimeSpan elapsed)
        {
            if (totalBytes <= 0) return;
            double progress = (double)currentBytes / totalBytes;
            progress = Math.Min(1.0, Math.Max(0.0, progress));
            int barWidth = 30; 
            int filledChars = (int)(progress * barWidth);
            double seconds = elapsed.TotalSeconds;
            string speedStr = "0 B/s";
            if (seconds > 0)
            {
                double speed = currentBytes / seconds;
                speedStr = $"{FormatBytes((long)speed)}/s";
            }
            string bar = new string('=', filledChars) + new string(' ', barWidth - filledChars);
            if (filledChars > 0 && filledChars < barWidth)
            {
                bar = bar.Remove(filledChars - 1, 1).Insert(filledChars - 1, ">");
            }
            else if (filledChars == barWidth) 
            {
                bar = new string('=', barWidth); 
            }
            string arrowBar = new string('=', filledChars); 
            if (filledChars < barWidth) arrowBar += ">";
            string barDisplay = arrowBar.PadRight(barWidth + 1); 
            Console.Write($"\r{barDisplay}   {FormatBytes(currentBytes)}/{FormatBytes(totalBytes)} {speedStr}   ");
        }
        private static string FormatBytes(long bytes)
        {
            string[] sizes = { "B", "KB", "MB", "GB", "TB" };
            double len = bytes;
            int order = 0;
            while (len >= 1024 && order < sizes.Length - 1)
            {
                order++;
                len = len / 1024;
            }
            return $"{len:0.##} {sizes[order]}";
        }
        private static bool VerifyFileHash(
            string filePath,
            string? expectedHash,
            bool quiet = false
        )
        {
            if (string.IsNullOrEmpty(expectedHash))
            {
                return true;
            }
            if (expectedHash.StartsWith("在此填入"))
            {
                if (!quiet)
                {
                    Console.ForegroundColor = ConsoleColor.DarkGray;
                    Console.WriteLine($"    -> 跳过校验: {Path.GetFileName(filePath)}");
                    Console.ResetColor();
                }
                return true;
            }
            string actualHash = GetFileHash(filePath);
            bool isMatch = actualHash.Equals(expectedHash, StringComparison.OrdinalIgnoreCase);
            if (!isMatch && !quiet)
            {
                Console.ForegroundColor = ConsoleColor.Yellow;
                Console.WriteLine($"    -> 文件不匹配!");
                Console.WriteLine($"       本地: {actualHash}");
                Console.ResetColor();
            }
            return isMatch;
        }
        private static Config LoadOrCreateConfig()
        {
            var deserializer = new DeserializerBuilder()
                .WithNamingConvention(UnderscoredNamingConvention.Instance)
                .Build();
            var serializer = new SerializerBuilder()
                .WithNamingConvention(UnderscoredNamingConvention.Instance)
                .Build();
            Config cfg;
            string newMc = GenerateMachineCode();
            if (File.Exists(ConfigPath))
            {
                string yaml = File.ReadAllText(ConfigPath);
                cfg = deserializer.Deserialize<Config>(yaml);
                bool configUpdated = false;
                if (cfg.Mc != newMc)
                {
                    cfg.Mc = newMc;
                    configUpdated = true;
                }
                if (cfg.MaiArgs == null)
                {
                    cfg.MaiArgs =
                        "";
                    configUpdated = true;
                }
                if (configUpdated)
                {
                    string newYaml = serializer.Serialize(cfg);
                    File.WriteAllText(ConfigPath, newYaml);
                }
            }
            else
            {
                cfg = new Config
                {
                    MaiArgs =
                        "",
                    Mc = newMc,
                };
                string yaml = serializer.Serialize(cfg);
                File.WriteAllText(ConfigPath, yaml);
                Console.ForegroundColor = ConsoleColor.Yellow;
                Console.WriteLine("首次运行：已在启动器目录创建 config.yml");
                Console.WriteLine("请将您的机器码提供给猫猫进行授权");
                Console.WriteLine("价格请看Q群公告");
                Console.WriteLine("机器码：");
                Console.ResetColor();
                Console.WriteLine(cfg.Mc);
                PauseAndExit();
            }
            return cfg;
        }
        private static string GenerateMachineCode()
        {
            try
            {
                string boardSerial = "";
                string cpuId = "";
                using (
                    var searcher = new ManagementObjectSearcher(
                        "SELECT SerialNumber FROM Win32_BaseBoard"
                    )
                )
                {
                    foreach (var obj in searcher.Get())
                    {
                        boardSerial = obj["SerialNumber"]?.ToString() ?? "";
                        break;
                    }
                }
                using (
                    var searcher = new ManagementObjectSearcher(
                        "SELECT ProcessorId FROM Win32_Processor"
                    )
                )
                {
                    foreach (var obj in searcher.Get())
                    {
                        cpuId = obj["ProcessorId"]?.ToString() ?? "";
                        break;
                    }
                }
                string combined = boardSerial + cpuId;
                using var sha256 = SHA256.Create();
                byte[] hash = sha256.ComputeHash(Encoding.UTF8.GetBytes(combined));
                string finalMc = BitConverter.ToString(hash).Replace("-", "").ToLowerInvariant();
                return finalMc;
            }
            catch (Exception)
            {
                return "wmi_error_" + Guid.NewGuid().ToString("N");
            }
        }
        static async Task<GamePermissions?> VerifyApiAsync(string mc)
        {
            try
            {
                string url = ApiVerificationUrl;
                string staticPayload = "";
                string encryptedPayload = AuthCipher.Encrypt(staticPayload, mc);
                var requestData = new ApiAuthRequest { Mc = mc, Payload = encryptedPayload };
                string jsonRequest = JsonSerializer.Serialize(requestData);
                var httpContent = new StringContent(jsonRequest, Encoding.UTF8, "application/json");

                var response = await HttpClient.PostAsync(url, httpContent);
                response.EnsureSuccessStatusCode();
                string encryptedResponse = await response.Content.ReadAsStringAsync();
                string decryptedJson = AuthCipher.Decrypt(encryptedResponse, mc);
                var jsonDoc = JsonDocument.Parse(
                    decryptedJson,
                    new JsonDocumentOptions { AllowTrailingCommas = true }
                );
                var root = jsonDoc.RootElement;
                if (
                    !root.TryGetProperty("success", out var successProp)
                    || !successProp.GetBoolean()
                )
                {
                    return null;
                }
                if (
                    !root.TryGetProperty("r2f_code", out var r2fCodeProp)
                    || r2fCodeProp.ValueKind != JsonValueKind.String
                )
                {
                    return null;
                }
                string serverR2fCode = r2fCodeProp.GetString() ?? "";
                bool isR2fValid = false;
                for (int offset = -1; offset <= 1; offset++)
                {
                    string localR2fCode = GenerateLocalR2FCode(mc, offset);
                    if (serverR2fCode == localR2fCode)
                    {
                        isR2fValid = true;
                        break;
                    }
                }
                if (!isR2fValid)
                {
                    Console.ForegroundColor = ConsoleColor.Red;
                    Console.WriteLine("错误: 认证码校验失败 (可能是本地时间与服务器差异过大)");
                    Console.ResetColor();
                    return null;
                }
                if (!root.TryGetProperty("permissions", out var permsProp))
                {
                    Console.ForegroundColor = ConsoleColor.Red;
                    Console.WriteLine("警告: 验证服务器未返回权限信息");
                    Console.ResetColor();
                    return null;
                }
                var permissions = JsonSerializer.Deserialize<GamePermissions>(
                    permsProp.GetRawText(),
                    JsonOptions
                );
                if (permissions == null)
                {
                    return null;
                }
                return permissions;
            }
            catch (HttpRequestException)
            {
                Console.ForegroundColor = ConsoleColor.Red;
                Console.WriteLine("API 验证请求失败喵，请检查网络配置");
                Console.ResetColor();
                return null;
            }
            catch (Exception ex)
            {
                Console.ForegroundColor = ConsoleColor.Red;
                Console.WriteLine($"API 验证期间发生错误喵");
                Console.ResetColor();
                return null;
            }
        }
        private static string GenerateLocalR2FCode(string machineCode, int timeStepOffset = 0)
        {
            var key = Encoding.UTF8.GetBytes(LocalSecretKey);
            using var hmac = new HMACSHA1(key);
            long timeStep = (DateTimeOffset.UtcNow.ToUnixTimeSeconds() / 30) + timeStepOffset;
            var timeStepBytes = BitConverter.GetBytes(timeStep);
            if (BitConverter.IsLittleEndian)
            {
                Array.Reverse(timeStepBytes);
            }
            var machineCodeBytes = Encoding.UTF8.GetBytes(machineCode);
            var combinedBytes = new byte[timeStepBytes.Length + machineCodeBytes.Length];
            Buffer.BlockCopy(timeStepBytes, 0, combinedBytes, 0, timeStepBytes.Length);
            Buffer.BlockCopy(
                machineCodeBytes,
                0,
                combinedBytes,
                timeStepBytes.Length,
                machineCodeBytes.Length
            );
            var hash = hmac.ComputeHash(combinedBytes);
            int offset = hash[19] & 0x0A;
            var chunk = new byte[10];
            Buffer.BlockCopy(hash, offset, chunk, 0, 10);
            Array.Reverse(chunk);
            var positiveChunk = new byte[chunk.Length + 1];
            Buffer.BlockCopy(chunk, 0, positiveChunk, 0, chunk.Length);
            positiveChunk[chunk.Length] = 0x00;
            var binary = new BigInteger(positiveChunk);
            var modulo = BigInteger.Pow(10, 20);
            var otp = BigInteger.Remainder(binary, modulo);
            if (otp.Sign < 0)
            {
                otp += modulo;
            }
            string finalOtp = otp.ToString();
            return finalOtp;
        }
        static void StartGame(Config cfg)
        {
            try
            {
                string batPath = Path.Combine(GameDir, "start_temp.bat");
                string batchContent;

                if (CurrentGameMode == GameMode.Chuni)
                {
                    batchContent =
                        $@"";
                }
                else if (CurrentGameMode == GameMode.Ongeki)
                {
                    batchContent =
                        $@"";
                }
                else 
                {
                    batchContent =
                        $@"";
                }
                File.WriteAllText(batPath, batchContent, Encoding.Default);
                var psi = new ProcessStartInfo(batPath)
                {
                    WorkingDirectory = GameDir,
                    UseShellExecute = true,
                };
                Process.Start(psi);
                Environment.Exit(0);
            }
            catch (Exception ex)
            {
                Console.ForegroundColor = ConsoleColor.Red;
                Console.WriteLine("启动游戏时发生错误");
                LogExceptionDetails(ex);
                Console.ResetColor();
            }
        }
        private static void DetectGameMode()
        {
            if (File.Exists(Path.Combine(GameDir, "chusanhook.dll")))
            {
                CurrentGameMode = GameMode.Chuni;
            }
            else if (File.Exists(Path.Combine(GameDir, "mai2hook.dll")))
            {
                CurrentGameMode = GameMode.Mai;
            }
            else if (File.Exists(Path.Combine(GameDir, "mu3hook.dll")))
            {
                CurrentGameMode = GameMode.Ongeki;
            }
            else
            {
                CurrentGameMode = GameMode.Unknown;
            }
        }
        private static string GetGameIdString(GameMode mode)
        {
            switch (mode)
            {
                case GameMode.Chuni:
                    return "SDHD";
                case GameMode.Ongeki:
                    return "SDDT";
                case GameMode.Mai:
                    string caPemPath = Path.Combine(GameDir, "ca.pem");
                    if (File.Exists(caPemPath))
                    {
                        return "SDEZ";
                    }
                    else
                    {
                        return "SDGB";
                    }
                default:
                    return "unknown";
            }
        }
        private static string GetFileHash(string filePath)
        {
            if (!File.Exists(filePath))
            {
                return "文件不存在";
            }
            try
            {
                using var sha256 = SHA256.Create();
                using var stream = File.OpenRead(filePath);
                byte[] hash = sha256.ComputeHash(stream);
                return BitConverter.ToString(hash).Replace("-", "").ToLowerInvariant();
            }
            catch (Exception ex)
            {
                return $"无法计算哈希: {ex.Message}";
            }
        }
        private static void PauseAndExit()
        {
            Console.WriteLine("\n按任意键退出...");
            Console.ReadKey();
            Environment.Exit(1);
        }
        private static void LogExceptionDetails(Exception ex, string indent = "")
        {
            if (ex == null)
                return;
            string errorType = $"{indent}类型: {ex.GetType().FullName}";
            string errorMessage = $"{indent}信息: {ex.Message}";
            Console.ForegroundColor = ConsoleColor.DarkYellow;
            Console.WriteLine($"{indent}--- 详细错误日志 ---");
            Console.WriteLine(errorType);
            Console.WriteLine(errorMessage);
            Console.ResetColor();
            if (ex.InnerException != null)
            {
                LogExceptionDetails(ex.InnerException, indent + "  ");
            }
        }
        public static class AuthCipher
        {
            private const int AesKeySize = 32;
            private const int AesIvSize = 16;

            private static byte[] GenerateSessionToken(string mc)
            {
                try
                {
                    string combinedString = LocalSecretKey + mc;
                    using (SHA256 sha256 = SHA256.Create())
                    {
                        byte[] combinedBytes = Encoding.UTF8.GetBytes(combinedString);
                        return sha256.ComputeHash(combinedBytes);
                    }
                }
                catch (Exception)
                {
                    return new byte[AesKeySize];
                }
            }
            public static string Encrypt(string plainText, string mc)
            {
                byte[] key = GenerateSessionToken(mc);
                byte[] plainBytes = Encoding.UTF8.GetBytes(plainText);
                using (Aes aes = Aes.Create())
                {
                    aes.Key = key;
                    aes.Mode = CipherMode.CBC;
                    aes.Padding = PaddingMode.PKCS7;
                    aes.GenerateIV();
                    byte[] iv = aes.IV;
                    using (ICryptoTransform encryptor = aes.CreateEncryptor(aes.Key, iv))
                    using (MemoryStream ms = new MemoryStream())
                    {
                        ms.Write(iv, 0, iv.Length);
                        using (
                            CryptoStream cs = new CryptoStream(
                                ms,
                                encryptor,
                                CryptoStreamMode.Write
                            )
                        )
                        {
                            cs.Write(plainBytes, 0, plainBytes.Length);
                            cs.FlushFinalBlock();
                        }
                        return Convert.ToBase64String(ms.ToArray());
                    }
                }
            }
            public static string Decrypt(string cipherTextBase64, string mc)
            {
                byte[] key = GenerateSessionToken(mc);
                byte[] combinedBytes = Convert.FromBase64String(cipherTextBase64);
                if (combinedBytes.Length < AesIvSize)
                {
                    throw new CryptographicException("无效");
                }
                using (Aes aes = Aes.Create())
                {
                    aes.Key = key;
                    aes.Mode = CipherMode.CBC;
                    aes.Padding = PaddingMode.PKCS7;
                    byte[] iv = new byte[AesIvSize];
                    Buffer.BlockCopy(combinedBytes, 0, iv, 0, iv.Length);
                    aes.IV = iv;
                    int cipherBytesLength = combinedBytes.Length - AesIvSize;
                    byte[] cipherBytes = new byte[cipherBytesLength];
                    Buffer.BlockCopy(combinedBytes, AesIvSize, cipherBytes, 0, cipherBytesLength);
                    using (ICryptoTransform decryptor = aes.CreateDecryptor(aes.Key, aes.IV))
                    using (MemoryStream msDecrypt = new MemoryStream(cipherBytes))
                    using (
                        CryptoStream csDecrypt = new CryptoStream(
                            msDecrypt,
                            decryptor,
                            CryptoStreamMode.Read
                        )
                    )
                    using (StreamReader srDecrypt = new StreamReader(csDecrypt))
                    {
                        return srDecrypt.ReadToEnd();
                    }
                }
            }
        }
    }
    public class Config
    {
        [YamlMember(Alias = "sinmaiargs")]
        public string MaiArgs { get; set; } = "";

        [YamlMember(Alias = "mc")]
        public string Mc { get; set; } = "";
        public int server_line { get; set; } = 2;
    }
    public class UpdateManifest
    {
        [JsonPropertyName("dll")]
        public List<UpdateFile>? Dll { get; set; }

        [JsonPropertyName("Launcher")]
        public LauncherInfo? Launcher { get; set; }

        [JsonPropertyName("opt")]
        public List<UpdateFile>? Opt { get; set; }

        [JsonPropertyName("option")]
        public List<UpdateFile>? Option { get; set; }

        [JsonPropertyName("file")]
        public List<UpdateFile>? File { get; set; }

        [JsonPropertyName("amfs")]
        public JsonElement Amfs { get; set; }
    }
    public class LauncherInfo
    {
        [JsonPropertyName("name")]
        public string? Name { get; set; }

        [JsonPropertyName("version")]
        public string? Version { get; set; }

        [JsonPropertyName("url")]
        public string? Url { get; set; }

        [JsonPropertyName("hash")]
        public string? Hash { get; set; }
    }
    public class UpdateFile
    {
        [JsonPropertyName("name")]
        public string? Name { get; set; }

        [JsonPropertyName("url")]
        public string? Url { get; set; }

        [JsonPropertyName("hash")]
        public string? Hash { get; set; }
    }
    public class ApiAuthRequest
    {
        [JsonPropertyName("mc")]
        public string Mc { get; set; } = "";

        [JsonPropertyName("payload")]
        public string Payload { get; set; } = "";
    }

    public class FileNameListResponse
    {
        [JsonPropertyName("success")]
        public bool Success { get; set; }

        [JsonPropertyName("message")]
        public string? Message { get; set; }

        [JsonPropertyName("file_tree")]
        public Dictionary<string, FileNodeInfo>? FileTree { get; set; }
    }

    public class FileNodeInfo
    {
        [JsonPropertyName("hash")]
        public string? Hash { get; set; }

        [JsonPropertyName("category")]
        public string? Category { get; set; }
    }

    public class HostsResponse
    {
        [JsonPropertyName("success")]
        public bool Success { get; set; }

        [JsonPropertyName("message")]
        public string? Message { get; set; }

        [JsonPropertyName("hosts_content")]
        public string? HostsContent { get; set; }
    }

    public class FileLinksResponse
    {
        [JsonPropertyName("success")]
        public bool Success { get; set; }

        [JsonPropertyName("message")]
        public string? Message { get; set; }

        [JsonPropertyName("file_links")]
        public Dictionary<string, FileLinkInfo?>? FileLinks { get; set; }
    }

    public class FileLinkInfo
    {
        [JsonPropertyName("url")]
        public string? Url { get; set; }

        [JsonPropertyName("hash")]
        public string? Hash { get; set; }
    }

    public class GamePermissions
    {
        [JsonPropertyName("SDGB")]
        public bool SDGB { get; set; }

        [JsonPropertyName("SDEZ")]
        public bool SDEZ { get; set; }

        [JsonPropertyName("SDHD")]
        public bool SDHD { get; set; }

        [JsonPropertyName("SDDT")]
        public bool SDDT { get; set; }

        [JsonPropertyName("lv")]
        public bool LV { get; set; }
    }
}