using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Drawing;
using System.Drawing.Drawing2D;
using System.IO;
using System.Net;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
using System.Windows.Forms;
using Microsoft.Win32;

namespace R0Installer
{
    public class MainForm : Form
    {
        private Panel totalProgressBar;
        private Panel totalProgressFill;
        private Panel stepProgressBar;
        private Panel stepProgressFill;
        private Label titleLabel;
        private Label totalStatusLabel;
        private Label stepStatusLabel;
        private Label totalPercentLabel;
        private Label stepPercentLabel;
        private Label versionLabel;

        private Label[] stepLabels;
        private Panel[] stepIndicators;

        private string projectId;
        private string projectConfig;
        private string installConfigJson;
        private string versionData;

        private int maxThreads = 8;
        private string userAgent = "r0_installer";

        private string mainVersion = "";
        private InstallMode installMode = InstallMode.Full;

        private List<StepInfo> enabledSteps = new List<StepInfo>();
        private List<string> runtimeConfigs = new List<string>();

        private readonly Color primaryGreen = Color.FromArgb(76, 175, 80);
        private readonly Color brightGreen = Color.FromArgb(111, 255, 99);
        private readonly Color darkBg = Color.FromArgb(18, 18, 18);
        private readonly Color panelBg = Color.FromArgb(28, 28, 28);
        private readonly Color textGray = Color.FromArgb(180, 180, 180);
        private readonly Color textDark = Color.FromArgb(100, 100, 100);

        private bool isDragging = false;
        private Point dragStart;

        private int currentStep = 0;
        private int totalStepCount = 3;

        private string windowTitle = "安装程序";

        // total progress tracking: each step occupies a fraction of [0,100]
        private int currentStepIndex = 0;
        private double currentStepSubProgress = 0; // 0..1 within current step

        private class StepInfo
        {
            public string ConfigJson;
            public string DisplayName;
            public string StepType;
            public bool ShouldExecute;
        }

        public MainForm(InstallMode mode, string projectId)
        {
            this.installMode = mode;
            this.projectId = projectId;
            InitializeComponent();
            SetupUI();
            this.Load += MainForm_Load;
        }

        private async void MainForm_Load(object sender, EventArgs e)
        {
            await StartInstallProcess();
        }

        private void InitializeComponent()
        {
            this.SuspendLayout();
            this.Text = windowTitle;
            this.Size = new Size(500, 380);
            this.StartPosition = FormStartPosition.CenterScreen;
            this.FormBorderStyle = FormBorderStyle.None;
            this.BackColor = darkBg;
            this.DoubleBuffered = true;
            try { this.Icon = Icon.ExtractAssociatedIcon(System.Reflection.Assembly.GetExecutingAssembly().Location); } catch { }
            this.Region = CreateRoundedRegion(this.Width, this.Height, 12);
            this.MouseDown += Form_MouseDown;
            this.MouseMove += Form_MouseMove;
            this.MouseUp += Form_MouseUp;
            this.ResumeLayout(false);
        }

        private Region CreateRoundedRegion(int width, int height, int radius)
        {
            GraphicsPath path = new GraphicsPath();
            path.AddArc(0, 0, radius * 2, radius * 2, 180, 90);
            path.AddArc(width - radius * 2, 0, radius * 2, radius * 2, 270, 90);
            path.AddArc(width - radius * 2, height - radius * 2, radius * 2, radius * 2, 0, 90);
            path.AddArc(0, height - radius * 2, radius * 2, radius * 2, 90, 90);
            path.CloseAllFigures();
            return new Region(path);
        }

        private void SetupUI()
        {
            Label closeBtn = new Label();
            closeBtn.Text = "×";
            closeBtn.Font = new Font("Segoe UI", 14, FontStyle.Regular);
            closeBtn.ForeColor = textGray;
            closeBtn.Size = new Size(36, 36);
            closeBtn.Location = new Point(this.Width - 40, 4);
            closeBtn.TextAlign = ContentAlignment.MiddleCenter;
            closeBtn.Cursor = Cursors.Hand;
            closeBtn.Click += (s, ev) => Application.Exit();
            closeBtn.MouseEnter += (s, ev) => ((Label)s).ForeColor = Color.White;
            closeBtn.MouseLeave += (s, ev) => ((Label)s).ForeColor = textGray;
            this.Controls.Add(closeBtn);

            titleLabel = new Label();
            titleLabel.Text = windowTitle;
            titleLabel.Font = new Font("Microsoft YaHei", 20, FontStyle.Bold);
            titleLabel.ForeColor = primaryGreen;
            titleLabel.AutoSize = true;
            titleLabel.BackColor = Color.Transparent;
            this.Controls.Add(titleLabel);
            titleLabel.Location = new Point((this.Width - 240) / 2, 40);

            this.Paint += MainForm_Paint;

            int progressY = 180;

            totalStatusLabel = new Label();
            totalStatusLabel.Text = "总进度";
            totalStatusLabel.Font = new Font("Microsoft YaHei", 10, FontStyle.Regular);
            totalStatusLabel.ForeColor = textGray;
            totalStatusLabel.AutoSize = true;
            totalStatusLabel.Location = new Point(40, progressY);
            this.Controls.Add(totalStatusLabel);

            totalPercentLabel = new Label();
            totalPercentLabel.Text = "0%";
            totalPercentLabel.Font = new Font("Microsoft YaHei", 10, FontStyle.Bold);
            totalPercentLabel.ForeColor = primaryGreen;
            totalPercentLabel.AutoSize = true;
            totalPercentLabel.Location = new Point(this.Width - 80, progressY);
            this.Controls.Add(totalPercentLabel);

            totalProgressBar = new Panel();
            totalProgressBar.Size = new Size(this.Width - 80, 8);
            totalProgressBar.Location = new Point(40, progressY + 25);
            totalProgressBar.BackColor = panelBg;
            this.Controls.Add(totalProgressBar);

            totalProgressFill = new Panel();
            totalProgressFill.Size = new Size(0, 8);
            totalProgressFill.Location = new Point(0, 0);
            totalProgressFill.BackColor = primaryGreen;
            totalProgressBar.Controls.Add(totalProgressFill);

            int stepProgressY = progressY + 60;

            stepStatusLabel = new Label();
            stepStatusLabel.Text = "正在初始化...";
            stepStatusLabel.Font = new Font("Microsoft YaHei", 9, FontStyle.Regular);
            stepStatusLabel.ForeColor = textGray;
            stepStatusLabel.AutoSize = false;
            stepStatusLabel.Size = new Size(300, 20);
            stepStatusLabel.Location = new Point(40, stepProgressY);
            this.Controls.Add(stepStatusLabel);

            stepPercentLabel = new Label();
            stepPercentLabel.Text = "";
            stepPercentLabel.Font = new Font("Microsoft YaHei", 9, FontStyle.Regular);
            stepPercentLabel.ForeColor = brightGreen;
            stepPercentLabel.AutoSize = false;
            stepPercentLabel.Size = new Size(160, 20);
            stepPercentLabel.TextAlign = ContentAlignment.MiddleRight;
            stepPercentLabel.Location = new Point(this.Width - 200, stepProgressY);
            this.Controls.Add(stepPercentLabel);

            stepProgressBar = new Panel();
            stepProgressBar.Size = new Size(this.Width - 80, 4);
            stepProgressBar.Location = new Point(40, stepProgressY + 22);
            stepProgressBar.BackColor = panelBg;
            this.Controls.Add(stepProgressBar);

            stepProgressFill = new Panel();
            stepProgressFill.Size = new Size(0, 4);
            stepProgressFill.Location = new Point(0, 0);
            stepProgressFill.BackColor = brightGreen;
            stepProgressBar.Controls.Add(stepProgressFill);

            versionLabel = new Label();
            versionLabel.Text = "v1.0";
            versionLabel.Font = new Font("Segoe UI", 8, FontStyle.Regular);
            versionLabel.ForeColor = textDark;
            versionLabel.AutoSize = true;
            versionLabel.Location = new Point(this.Width - 50, this.Height - 25);
            versionLabel.BackColor = Color.Transparent;
            this.Controls.Add(versionLabel);
        }

        private void BuildStepIndicators()
        {
            if (this.InvokeRequired) { this.Invoke(new Action(BuildStepIndicators)); return; }

            if (stepLabels != null)
            {
                foreach (Label l in stepLabels) this.Controls.Remove(l);
                foreach (Panel p in stepIndicators) this.Controls.Remove(p);
            }

            totalStepCount = enabledSteps.Count;
            if (totalStepCount == 0) totalStepCount = 1;

            stepLabels = new Label[totalStepCount];
            stepIndicators = new Panel[totalStepCount];

            int stepY = 100;
            int maxStepWidth = (this.Width - 40) / totalStepCount;
            int stepWidth = Math.Min(140, maxStepWidth);
            int startX = (this.Width - stepWidth * totalStepCount) / 2;

            for (int i = 0; i < totalStepCount; i++)
            {
                stepIndicators[i] = new Panel();
                stepIndicators[i].Size = new Size(24, 24);
                stepIndicators[i].Location = new Point(startX + i * stepWidth + (stepWidth - 24) / 2, stepY);
                stepIndicators[i].BackColor = Color.Transparent;
                stepIndicators[i].Tag = i;
                stepIndicators[i].Paint += StepIndicator_Paint;
                this.Controls.Add(stepIndicators[i]);

                string name = i < enabledSteps.Count ? enabledSteps[i].DisplayName : "";
                stepLabels[i] = new Label();
                stepLabels[i].Text = String.Format("{0}. {1}", i + 1, name);
                stepLabels[i].Font = new Font("Microsoft YaHei", 9, FontStyle.Regular);
                stepLabels[i].ForeColor = textDark;
                stepLabels[i].AutoSize = true;
                stepLabels[i].BackColor = Color.Transparent;
                this.Controls.Add(stepLabels[i]);
                stepLabels[i].Location = new Point(startX + i * stepWidth + (stepWidth - stepLabels[i].Width) / 2, stepY + 30);
            }

            titleLabel.Text = windowTitle;
            this.Text = windowTitle;
            this.Invalidate();
        }

        private void StepIndicator_Paint(object sender, PaintEventArgs e)
        {
            Panel panel = (Panel)sender;
            int index = (int)panel.Tag;
            Graphics g = e.Graphics;
            g.SmoothingMode = SmoothingMode.AntiAlias;
            Rectangle rect = new Rectangle(2, 2, 20, 20);

            if (index < currentStep)
            {
                using (SolidBrush brush = new SolidBrush(primaryGreen)) { g.FillEllipse(brush, rect); }
                using (Pen pen = new Pen(Color.White, 2)) { g.DrawLine(pen, 7, 12, 10, 15); g.DrawLine(pen, 10, 15, 16, 8); }
            }
            else if (index == currentStep)
            {
                using (Pen pen = new Pen(primaryGreen, 2)) { g.DrawEllipse(pen, rect); }
                using (SolidBrush brush = new SolidBrush(primaryGreen)) { g.FillEllipse(brush, 8, 8, 8, 8); }
            }
            else
            {
                using (Pen pen = new Pen(textDark, 2)) { g.DrawEllipse(pen, rect); }
            }
        }

        private void MainForm_Paint(object sender, PaintEventArgs e)
        {
            Graphics g = e.Graphics;
            g.SmoothingMode = SmoothingMode.AntiAlias;

            if (stepIndicators != null && totalStepCount > 1)
            {
                int stepY = 112;
                int maxStepWidth = (this.Width - 40) / totalStepCount;
                int stepWidth = Math.Min(140, maxStepWidth);
                int startX = (this.Width - stepWidth * totalStepCount) / 2;

                for (int i = 0; i < totalStepCount - 1; i++)
                {
                    int x1 = startX + i * stepWidth + (stepWidth + 24) / 2;
                    int x2 = startX + (i + 1) * stepWidth + (stepWidth - 24) / 2;
                    Color lineColor = i < currentStep ? primaryGreen : textDark;
                    using (Pen pen = new Pen(lineColor, 2)) { g.DrawLine(pen, x1, stepY, x2, stepY); }
                }
            }

            using (Pen pen = new Pen(Color.FromArgb(50, 255, 255, 255), 1))
            {
                Rectangle rect = new Rectangle(0, 0, this.Width - 1, this.Height - 1);
                using (GraphicsPath path = CreateRoundedPath(rect, 12)) { g.DrawPath(pen, path); }
            }
        }

        private GraphicsPath CreateRoundedPath(Rectangle rect, int radius)
        {
            GraphicsPath path = new GraphicsPath();
            path.AddArc(rect.X, rect.Y, radius * 2, radius * 2, 180, 90);
            path.AddArc(rect.Right - radius * 2, rect.Y, radius * 2, radius * 2, 270, 90);
            path.AddArc(rect.Right - radius * 2, rect.Bottom - radius * 2, radius * 2, radius * 2, 0, 90);
            path.AddArc(rect.X, rect.Bottom - radius * 2, radius * 2, radius * 2, 90, 90);
            path.CloseAllFigures();
            return path;
        }

        #region Window drag
        private void Form_MouseDown(object sender, MouseEventArgs e) { if (e.Button == MouseButtons.Left) { isDragging = true; dragStart = e.Location; } }
        private void Form_MouseMove(object sender, MouseEventArgs e) { if (isDragging) { this.Location = new Point(this.Location.X + e.X - dragStart.X, this.Location.Y + e.Y - dragStart.Y); } }
        private void Form_MouseUp(object sender, MouseEventArgs e) { isDragging = false; }
        #endregion

        #region UI updates

        private void SetCurrentStep(int step)
        {
            if (this.InvokeRequired) { this.Invoke(new Action<int>(SetCurrentStep), step); return; }
            currentStep = step;
            currentStepIndex = step;
            currentStepSubProgress = 0;
            if (stepIndicators != null)
            {
                for (int i = 0; i < totalStepCount; i++)
                {
                    stepIndicators[i].Invalidate();
                    stepLabels[i].ForeColor = i <= currentStep ? primaryGreen : textDark;
                }
            }
            this.Invalidate();
        }

        private void RecalcTotalProgress()
        {
            if (totalStepCount <= 0) return;
            double total = (currentStepIndex + currentStepSubProgress) / totalStepCount * 100.0;
            int pct = Math.Min(100, Math.Max(0, (int)total));
            UpdateTotalProgress(pct);
        }

        private void UpdateTotalProgress(int percent)
        {
            if (this.InvokeRequired) { this.Invoke(new Action<int>(UpdateTotalProgress), percent); return; }
            int targetWidth = (int)(totalProgressBar.Width * percent / 100.0);
            totalProgressFill.Width = targetWidth;
            totalPercentLabel.Text = String.Format("{0}%", percent);
        }

        private void UpdateStepProgress(int percent, string message)
        {
            UpdateStepProgress(percent, message, null);
        }

        private void UpdateStepProgress(int percent, string message, string rightText)
        {
            if (this.InvokeRequired) { this.Invoke(new Action<int, string, string>(UpdateStepProgress), percent, message, rightText); return; }
            int targetWidth = (int)(stepProgressBar.Width * percent / 100.0);
            stepProgressFill.Width = targetWidth;
            if (message != null) stepStatusLabel.Text = message;
            if (rightText != null)
                stepPercentLabel.Text = rightText;
            else
                stepPercentLabel.Text = percent > 0 ? String.Format("{0}%", percent) : "";

            currentStepSubProgress = percent / 100.0;
            RecalcTotalProgress();
        }

        private void UpdateStepStatus(string message)
        {
            if (this.InvokeRequired) { this.Invoke(new Action<string>(UpdateStepStatus), message); return; }
            stepStatusLabel.Text = message;
        }

        #endregion

        #region Install process

        private void CloseProjectProcesses()
        {
            CloseProcessesFromUpdateTarget("update");
            CloseProcessesFromUpdateTarget("update_ac");
        }

        private void CloseProcessesFromUpdateTarget(string updateTargetKey)
        {
            if (projectConfig == null) return;
            string updateJson = ConfigManager.ExtractJsonObject(projectConfig, updateTargetKey);
            if (string.IsNullOrEmpty(updateJson)) return;
            string procArray = ConfigManager.ExtractJsonArray(updateJson, "processes_to_close");
            if (string.IsNullOrEmpty(procArray)) return;
            List<string> processNames = ConfigManager.ParseJsonStringArray(procArray);
            foreach (string name in processNames)
            {
                try
                {
                    Process[] processes = Process.GetProcessesByName(name);
                    foreach (Process proc in processes)
                    {
                        try { proc.Kill(); proc.WaitForExit(5000); } catch { } finally { proc.Dispose(); }
                    }
                }
                catch { }
            }
        }

        private async Task StartInstallProcess()
        {
            Exception installError = null;
            try
            {
                UpdateStepStatus("正在获取项目配置...");
                projectConfig = await ConfigManager.GetProjectConfig(projectId);
                if (projectConfig == null)
                {
                    MessageBox.Show("无法获取项目配置，请检查网络连接", "错误", MessageBoxButtons.OK, MessageBoxIcon.Error);
                    Application.Exit();
                    return;
                }

                installConfigJson = ConfigManager.ExtractJsonObject(projectConfig, "install");
                if (!string.IsNullOrEmpty(installConfigJson))
                {
                    windowTitle = ConfigManager.ExtractJsonValue(installConfigJson, "window_title");
                    if (string.IsNullOrEmpty(windowTitle)) windowTitle = "安装程序";
                }

                string downloadConfig = ConfigManager.ExtractJsonObject(projectConfig, "download_config");
                if (!string.IsNullOrEmpty(downloadConfig))
                {
                    maxThreads = ConfigManager.ExtractJsonInt(downloadConfig, "max_threads", 8);
                    userAgent = ConfigManager.ExtractJsonValue(downloadConfig, "user_agent");
                    if (string.IsNullOrEmpty(userAgent)) userAgent = "r0_installer";
                }

                string stepsArray = ConfigManager.ExtractJsonArray(installConfigJson, "steps");
                List<string> stepConfigs = new List<string>();
                if (!string.IsNullOrEmpty(stepsArray))
                    stepConfigs = ConfigManager.ParseJsonObjectArray(stepsArray);

                enabledSteps.Clear();
                foreach (string step in stepConfigs)
                {
                    bool enabled = ConfigManager.ExtractJsonBool(step, "enabled");
                    if (!enabled) continue;

                    string stepType = ConfigManager.ExtractJsonValue(step, "type");
                    string displayName = ConfigManager.ExtractJsonValue(step, "display_name");
                    string stepId = ConfigManager.ExtractJsonValue(step, "step_id");

                    bool shouldExecute = true;
                    if (installMode == InstallMode.ClientOnly && stepType == "runtime_check")
                        shouldExecute = false;
                    if (installMode == InstallMode.ClientOnly && stepId != "main" && stepType == "download_and_run")
                        shouldExecute = false;
                    if (installMode == InstallMode.AcOnly && stepId == "main" && stepType == "download_and_run")
                        shouldExecute = false;

                    if (!shouldExecute) continue;

                    enabledSteps.Add(new StepInfo
                    {
                        ConfigJson = step,
                        DisplayName = displayName,
                        StepType = stepType,
                        ShouldExecute = true,
                    });
                }

                string runtimeArray = ConfigManager.ExtractJsonArray(projectConfig, "runtime_requirements");
                if (!string.IsNullOrEmpty(runtimeArray))
                    runtimeConfigs = ConfigManager.ParseJsonObjectArray(runtimeArray);

                BuildStepIndicators();

                UpdateStepStatus("正在关闭相关程序...");
                CloseProjectProcesses();
                await Task.Delay(500);

                UpdateStepStatus("正在获取版本信息...");
                versionData = await ConfigManager.GetVersionIndex(projectId);
                if (versionData == null)
                {
                    MessageBox.Show("无法获取版本信息，请检查网络连接", "错误", MessageBoxButtons.OK, MessageBoxIcon.Error);
                    Application.Exit();
                    return;
                }

                mainVersion = ConfigManager.ExtractJsonValue(versionData, "version");
                string threadsStr = ConfigManager.ExtractJsonValue(versionData, "threads");
                if (!string.IsNullOrEmpty(threadsStr)) { int t; if (int.TryParse(threadsStr, out t) && t > 0) maxThreads = t; }

                this.Invoke(new Action(() => { versionLabel.Text = String.Format("v{0}", mainVersion); }));

                await ExecuteSteps();

                UpdateTotalProgress(100);
                await Task.Delay(2000);
                Application.Exit();
            }
            catch (Exception ex) { installError = ex; }

            if (installError != null)
            {
                MessageBox.Show(String.Format("安装过程中出错: {0}", installError.Message), "错误", MessageBoxButtons.OK, MessageBoxIcon.Error);
                Application.Exit();
            }
        }

        private async Task ExecuteSteps()
        {
            for (int i = 0; i < enabledSteps.Count; i++)
            {
                StepInfo si = enabledSteps[i];
                SetCurrentStep(i);

                if (!si.ShouldExecute)
                {
                    UpdateStepProgress(100, String.Format("跳过{0}...", si.DisplayName));
                    await Task.Delay(300);
                }
                else
                {
                    switch (si.StepType)
                    {
                        case "runtime_check":
                            await CheckAndInstallRuntimeEnvironments();
                            break;
                        case "download_and_run":
                            await ExecuteDownloadAndRunStep(si.ConfigJson);
                            break;
                        default:
                            UpdateStepProgress(100, String.Format("未知步骤类型: {0}", si.StepType));
                            await Task.Delay(1000);
                            break;
                    }
                }

                currentStepSubProgress = 1.0;
                RecalcTotalProgress();
            }
        }

        private async Task ExecuteDownloadAndRunStep(string stepJson)
        {
            string displayName = ConfigManager.ExtractJsonValue(stepJson, "display_name");
            string downloadUrlField = ConfigManager.ExtractJsonValue(stepJson, "download_url_field");
            string tempFilename = ConfigManager.ExtractJsonValue(stepJson, "temp_filename");
            string tempFilenameTemplate = ConfigManager.ExtractJsonValue(stepJson, "temp_filename_template");
            string installerArgs = ConfigManager.ExtractJsonValue(stepJson, "installer_args");
            bool waitForExit = ConfigManager.ExtractJsonBool(stepJson, "wait_for_exit");

            string downloadUrl = "";
            if (!string.IsNullOrEmpty(downloadUrlField) && versionData != null)
            {
                string raw = ConfigManager.ExtractJsonValue(versionData, downloadUrlField);
                if (!string.IsNullOrEmpty(raw))
                    downloadUrl = raw.Replace("\\/", "/");
            }

            if (string.IsNullOrEmpty(downloadUrl))
            {
                UpdateStepProgress(100, String.Format("{0}: 下载地址为空，跳过", displayName));
                await Task.Delay(1000);
                return;
            }

            string saveName;
            if (!string.IsNullOrEmpty(tempFilenameTemplate))
                saveName = tempFilenameTemplate.Replace("{version}", mainVersion);
            else if (!string.IsNullOrEmpty(tempFilename))
            {
                if (!string.IsNullOrEmpty(mainVersion) && tempFilename.EndsWith(".exe", StringComparison.OrdinalIgnoreCase))
                {
                    string baseName = Path.GetFileNameWithoutExtension(tempFilename);
                    saveName = baseName + "_v" + mainVersion + ".exe";
                }
                else
                    saveName = tempFilename;
            }
            else
                saveName = "download_" + Guid.NewGuid().ToString("N") + ".exe";

            string savePath = ConfigManager.ResolveWritableDownloadPath(
                Path.Combine(ConfigManager.GetWorkDirectory(), saveName));

            CloseProjectProcesses();
            await Task.Delay(300);

            UpdateStepProgress(0, String.Format("正在下载{0}...", displayName));
            string actualPath = await DownloadWithRetry(downloadUrl, savePath, displayName);

            if (!ConfigManager.IsDownloadedFileValid(actualPath))
            {
                UpdateStepProgress(100, String.Format("{0}: 下载文件无效，跳过", displayName));
                await Task.Delay(1500);
                return;
            }

            UpdateStepProgress(100, String.Format("正在安装{0}...", displayName));
            ProcessStartInfo psi = new ProcessStartInfo();
            psi.FileName = actualPath;
            if (!string.IsNullOrEmpty(installerArgs)) psi.Arguments = installerArgs;
            psi.UseShellExecute = true;
            psi.WorkingDirectory = Path.GetDirectoryName(actualPath);
            using (Process process = Process.Start(psi))
            {
                if (process != null && waitForExit)
                    await Task.Run(new Action(process.WaitForExit));
            }
            UpdateStepProgress(100, String.Format("{0}完成", displayName));
        }

        #endregion

        #region Runtime environment

        private async Task CheckAndInstallRuntimeEnvironments()
        {
            try
            {
                UpdateStepProgress(5, "正在检测运行环境...");
                bool installationNeeded = false;
                int progressPerRuntime = runtimeConfigs.Count > 0 ? 90 / runtimeConfigs.Count : 90;
                int currentProgress = 5;

                foreach (string rtConfig in runtimeConfigs)
                {
                    bool enabled = ConfigManager.ExtractJsonBool(rtConfig, "enabled");
                    if (!enabled) { currentProgress += progressPerRuntime; continue; }

                    string displayName = ConfigManager.ExtractJsonValue(rtConfig, "display_name");
                    bool alwaysInstall = ConfigManager.ExtractJsonBool(rtConfig, "always_install");
                    bool isInstalled = alwaysInstall ? false : CheckRuntimeInstalled(rtConfig);

                    if (alwaysInstall || !isInstalled)
                    {
                        UpdateStepProgress(currentProgress, String.Format("正在安装{0}...", displayName));
                        bool success = await InstallRuntimeFromConfig(rtConfig);
                        if (!success)
                        {
                            UpdateStepProgress(currentProgress + progressPerRuntime / 2, String.Format("{0}安装失败，但程序将继续运行...", displayName));
                            await Task.Delay(2000);
                        }
                        installationNeeded = true;
                    }

                    currentProgress += progressPerRuntime;
                    UpdateStepProgress(currentProgress, String.Format("{0}完成", displayName));
                }

                UpdateStepProgress(100, installationNeeded ? "运行环境安装完成" : "运行环境检测完成");
                await Task.Delay(installationNeeded ? 1000 : 500);
            }
            catch (Exception ex)
            {
                Debug.WriteLine("运行环境检测失败: " + ex.Message);
                UpdateStepProgress(100, "运行环境检测失败，程序将继续运行...");
                Thread.Sleep(2000);
            }
        }

        private bool CheckRuntimeInstalled(string rtConfig)
        {
            string detectionJson = ConfigManager.ExtractJsonObject(rtConfig, "detection");
            if (string.IsNullOrEmpty(detectionJson)) return false;
            string detectionType = ConfigManager.ExtractJsonValue(detectionJson, "type");
            switch (detectionType)
            {
                case "registry": return CheckRegistryDetection(detectionJson);
                case "dotnet_runtime": return CheckDotNetRuntimeDetection(detectionJson);
                default: return false;
            }
        }

        private bool CheckRegistryDetection(string detectionJson)
        {
            string keysArray = ConfigManager.ExtractJsonArray(detectionJson, "keys");
            string valueName = ConfigManager.ExtractJsonValue(detectionJson, "value_name");
            int expectedValue = ConfigManager.ExtractJsonInt(detectionJson, "expected_value", 1);
            if (string.IsNullOrEmpty(keysArray)) return false;
            List<string> keys = ConfigManager.ParseJsonStringArray(keysArray);
            foreach (string keyPath in keys)
            {
                try
                {
                    using (RegistryKey key = Registry.LocalMachine.OpenSubKey(keyPath))
                    {
                        if (key != null)
                        {
                            object installed = key.GetValue(valueName);
                            if (installed != null && (int)installed == expectedValue) return true;
                        }
                    }
                }
                catch { }
            }
            return false;
        }

        private bool CheckDotNetRuntimeDetection(string detectionJson)
        {
            string runtimeName = ConfigManager.ExtractJsonValue(detectionJson, "runtime_name");
            string version = ConfigManager.ExtractJsonValue(detectionJson, "version");
            try
            {
                ProcessStartInfo psi = new ProcessStartInfo();
                psi.FileName = "dotnet"; psi.Arguments = "--list-runtimes";
                psi.RedirectStandardOutput = true; psi.RedirectStandardError = true;
                psi.UseShellExecute = false; psi.CreateNoWindow = true;
                using (Process process = Process.Start(psi))
                {
                    if (process == null) return false;
                    string output = process.StandardOutput.ReadToEnd();
                    process.WaitForExit();
                    string[] lines = output.Split('\n');
                    foreach (string line in lines)
                        if (line.Contains(runtimeName) && line.Contains(version)) return true;
                }
            }
            catch { }
            return false;
        }

        private async Task<bool> InstallRuntimeFromConfig(string rtConfig)
        {
            string displayName = ConfigManager.ExtractJsonValue(rtConfig, "display_name");
            bool is64 = Environment.Is64BitOperatingSystem;
            string url = is64 ? ConfigManager.ExtractJsonValue(rtConfig, "download_url_x64") : ConfigManager.ExtractJsonValue(rtConfig, "download_url_x86");
            string arch = is64 ? "x64" : "x86";
            string filenameTemplate = ConfigManager.ExtractJsonValue(rtConfig, "temp_filename_template");
            string installArgs = ConfigManager.ExtractJsonValue(rtConfig, "install_args");
            string fileName = filenameTemplate.Replace("{arch}", arch).Replace("{version}", ConfigManager.ExtractJsonValue(ConfigManager.ExtractJsonObject(rtConfig, "detection"), "version"));
            string filePath = ConfigManager.ResolveWritableDownloadPath(
                Path.Combine(ConfigManager.GetWorkDirectory(), fileName));

            try
            {
                string actualPath = await DownloadWithRetry(url, filePath, displayName);

                if (!ConfigManager.IsDownloadedFileValid(actualPath))
                    throw new Exception(String.Format("{0}下载文件无效", displayName));

                UpdateStepStatus(String.Format("正在安装{0}...", displayName));
                ProcessStartInfo psi = new ProcessStartInfo();
                psi.FileName = actualPath;
                if (!string.IsNullOrEmpty(installArgs)) psi.Arguments = installArgs;
                // 本程序的 manifest 已要求管理员权限，子进程会继承提权；
                // 这里不再设置 Verb="runas"，避免冗余的二次提权（杀软会将其当作可疑提权行为）。
                psi.UseShellExecute = true;
                psi.WorkingDirectory = Path.GetDirectoryName(actualPath);
                using (Process process = Process.Start(psi))
                {
                    if (process != null)
                    {
                        await Task.Run(new Action(process.WaitForExit));
                        int exitCode = process.ExitCode;
                        if (exitCode != 0 && exitCode != 3010)
                            throw new Exception(String.Format("{0}安装失败，退出代码: {1}", displayName, exitCode));
                    }
                }
                if (File.Exists(actualPath)) { try { await Task.Delay(500); File.Delete(actualPath); } catch { } }
                return true;
            }
            catch (Exception ex) { Debug.WriteLine(String.Format("{0}安装失败: {1}", displayName, ex.Message)); return false; }
        }

        #endregion

        #region Download with retry and resume

        private const int DOWNLOAD_MAX_RETRIES = 10;
        private const int RETRY_DELAY_BASE_MS = 2000;

        private long speedCalcLastBytes = 0;
        private DateTime speedCalcLastTime = DateTime.Now;
        private double currentSpeed = 0;

        private class ChunkInfo
        {
            public int Index;
            public long StartPos;
            public long EndPos;
            public long Downloaded;
        }

        private string FormatFileSize(long bytes)
        {
            if (bytes >= 1073741824) return String.Format("{0:F2} GB", bytes / 1073741824.0);
            if (bytes >= 1048576) return String.Format("{0:F2} MB", bytes / 1048576.0);
            if (bytes >= 1024) return String.Format("{0:F2} KB", bytes / 1024.0);
            return String.Format("{0} B", bytes);
        }

        private string FormatSpeed(double bytesPerSecond)
        {
            if (bytesPerSecond <= 0) return "";
            if (bytesPerSecond >= 1073741824) return String.Format("{0:F2} GB/s", bytesPerSecond / 1073741824.0);
            if (bytesPerSecond >= 1048576) return String.Format("{0:F2} MB/s", bytesPerSecond / 1048576.0);
            if (bytesPerSecond >= 1024) return String.Format("{0:F2} KB/s", bytesPerSecond / 1024.0);
            return String.Format("{0:F0} B/s", bytesPerSecond);
        }

        /// <summary>
        /// Top-level download with full retry logic. Never throws - retries until success.
        /// </summary>
        private async Task<string> DownloadWithRetry(string url, string savePath, string displayName)
        {
            string downloadPath = ConfigManager.ResolveWritableDownloadPath(savePath);

            for (int attempt = 1; ; attempt++)
            {
                Exception caught = null;
                try
                {
                    ConfigManager.PrepareDownloadFile(downloadPath);
                    await DownloadFile(url, downloadPath, displayName);
                    return downloadPath;
                }
                catch (Exception ex)
                {
                    caught = ex;
                    if (IsFileAccessError(ex) && attempt < DOWNLOAD_MAX_RETRIES)
                        downloadPath = ConfigManager.ResolveWritableDownloadPath(savePath);
                }

                Debug.WriteLine(String.Format("下载失败 (第{0}次): {1}\nURL: {2}", attempt, caught.Message, url));
                if (attempt >= DOWNLOAD_MAX_RETRIES)
                    throw new Exception(String.Format("下载{0}失败，已重试{1}次: {2}", displayName, DOWNLOAD_MAX_RETRIES, caught.Message));

                int delay = Math.Min(RETRY_DELAY_BASE_MS * attempt, 15000);
                UpdateStepProgress(0, String.Format("下载中断({0})，{1}秒后第{2}次重试...", caught.Message, delay / 1000, attempt));
                await Task.Delay(delay);
            }
        }

        private static bool IsFileAccessError(Exception ex)
        {
            while (ex != null)
            {
                if (ex is UnauthorizedAccessException || ex is IOException)
                    return true;
                ex = ex.InnerException;
            }
            return false;
        }

        private class ProbeResult
        {
            public long FileSize = -1;
            public bool SupportsRange = false;
        }

        private async Task DownloadFile(string url, string savePath, string displayName)
        {
            speedCalcLastBytes = 0;
            speedCalcLastTime = DateTime.Now;
            currentSpeed = 0;

            if (maxThreads <= 1)
            {
                await DownloadSingleThreadNoRange(url, savePath, displayName);
                return;
            }

            ProbeResult probe = await ProbeUrl(url);

            if (probe.FileSize <= 0 || !probe.SupportsRange)
            {
                await DownloadSingleThreadNoRange(url, savePath, displayName);
                return;
            }

            long fileSize = probe.FileSize;
            int chunkCount = maxThreads;
            long chunkBytes = fileSize / chunkCount;
            ChunkInfo[] allChunks = new ChunkInfo[chunkCount];
            for (int i = 0; i < chunkCount; i++)
            {
                allChunks[i] = new ChunkInfo
                {
                    Index = i,
                    StartPos = (long)i * chunkBytes,
                    EndPos = (i == chunkCount - 1) ? fileSize - 1 : (long)i * chunkBytes + chunkBytes - 1,
                    Downloaded = 0,
                };
            }

            if (File.Exists(savePath))
            {
                try
                {
                    if (new FileInfo(savePath).Length != fileSize)
                    {
                        File.Delete(savePath);
                        using (FileStream fs = new FileStream(savePath, FileMode.Create, FileAccess.Write, FileShare.Write))
                            fs.SetLength(fileSize);
                    }
                }
                catch
                {
                    if (File.Exists(savePath)) File.Delete(savePath);
                    using (FileStream fs = new FileStream(savePath, FileMode.Create, FileAccess.Write, FileShare.Write))
                        fs.SetLength(fileSize);
                }
            }
            else
            {
                using (FileStream fs = new FileStream(savePath, FileMode.Create, FileAccess.Write, FileShare.Write))
                    fs.SetLength(fileSize);
            }

            object progressLock = new object();
            Task[] workers = new Task[chunkCount];
            for (int i = 0; i < chunkCount; i++)
            {
                ChunkInfo chunk = allChunks[i];
                workers[i] = Task.Run(async () =>
                {
                    await DownloadChunkWithRetry(url, savePath, chunk, allChunks, progressLock, fileSize, displayName);
                });
            }
            await Task.WhenAll(workers);
        }

        private async Task<ProbeResult> ProbeUrl(string url)
        {
            ProbeResult result = new ProbeResult();
            try
            {
                HttpWebRequest req = (HttpWebRequest)WebRequest.Create(url);
                req.Method = "HEAD";
                req.Timeout = 15000;
                req.UserAgent = userAgent;
                using (HttpWebResponse resp = (HttpWebResponse)await Task.Factory.FromAsync<WebResponse>(req.BeginGetResponse, req.EndGetResponse, null))
                {
                    result.FileSize = resp.ContentLength;
                    string acceptRanges = resp.Headers["Accept-Ranges"];
                    result.SupportsRange = !string.IsNullOrEmpty(acceptRanges)
                        && acceptRanges.IndexOf("none", StringComparison.OrdinalIgnoreCase) < 0;
                }
            }
            catch { }
            return result;
        }

        private async Task DownloadChunkWithRetry(string url, string savePath, ChunkInfo chunk, ChunkInfo[] allChunks, object progressLock, long totalSize, string displayName)
        {
            int maxRetries = DOWNLOAD_MAX_RETRIES;

            for (int attempt = 0; attempt < maxRetries; attempt++)
            {
                HttpWebResponse response = null;
                Stream responseStream = null;
                FileStream fs = null;

                try
                {
                    long resumeFrom = chunk.StartPos + chunk.Downloaded;
                    if (resumeFrom > chunk.EndPos) return;

                    HttpWebRequest request = (HttpWebRequest)WebRequest.Create(url);
                    request.AddRange(resumeFrom, chunk.EndPos);
                    request.Timeout = 60000;
                    request.ReadWriteTimeout = 60000;
                    request.KeepAlive = true;
                    request.UserAgent = userAgent;

                    response = (HttpWebResponse)await Task.Factory.FromAsync<WebResponse>(request.BeginGetResponse, request.EndGetResponse, null);
                    responseStream = response.GetResponseStream();

                    byte[] buffer = new byte[65536];
                    fs = new FileStream(savePath, FileMode.Open, FileAccess.Write, FileShare.Write);
                    fs.Seek(resumeFrom, SeekOrigin.Begin);

                    int bytesRead;
                    while ((bytesRead = await ReadStreamAsync(responseStream, buffer, 0, buffer.Length)) > 0)
                    {
                        await WriteStreamAsync(fs, buffer, 0, bytesRead);
                        chunk.Downloaded += bytesRead;

                        lock (progressLock)
                        {
                            long totalDownloaded = 0;
                            foreach (ChunkInfo c in allChunks) totalDownloaded += c.Downloaded;

                            DateTime now = DateTime.Now;
                            double elapsed = (now - speedCalcLastTime).TotalSeconds;
                            if (elapsed >= 0.3)
                            {
                                long delta = totalDownloaded - speedCalcLastBytes;
                                if (delta > 0)
                                {
                                    double instantSpeed = delta / elapsed;
                                    currentSpeed = currentSpeed <= 0 ? instantSpeed : currentSpeed * 0.3 + instantSpeed * 0.7;
                                }
                                speedCalcLastBytes = totalDownloaded;
                                speedCalcLastTime = now;
                            }

                            int percent = (int)(totalDownloaded * 100 / totalSize);
                            string sizeInfo = String.Format("{0}/{1}", FormatFileSize(totalDownloaded), FormatFileSize(totalSize));
                            string speedInfo = FormatSpeed(currentSpeed);
                            string rightLabel = string.IsNullOrEmpty(speedInfo) ? String.Format("{0}%", percent) : String.Format("{0}% {1}", percent, speedInfo);
                            UpdateStepProgress(percent, String.Format("正在下载{0} {1}", displayName, sizeInfo), rightLabel);
                        }
                    }
                    return;
                }
                catch (Exception ex)
                {
                    Debug.WriteLine(String.Format("分片{0}下载失败(第{1}次): {2}", chunk.Index, attempt + 1, ex.Message));

                    WebException webEx = ex as WebException;
                    if (webEx == null && ex.InnerException != null)
                        webEx = ex.InnerException as WebException;
                    if (webEx != null && webEx.Response is HttpWebResponse)
                    {
                        HttpStatusCode code = ((HttpWebResponse)webEx.Response).StatusCode;
                        if (code == HttpStatusCode.NotFound || code == HttpStatusCode.Forbidden || code == HttpStatusCode.Unauthorized)
                            throw new Exception(String.Format("服务器返回 {0}，URL: {1}", (int)code, url));
                    }
                }
                finally
                {
                    if (fs != null) { try { fs.Close(); fs.Dispose(); } catch { } }
                    if (responseStream != null) { try { responseStream.Close(); responseStream.Dispose(); } catch { } }
                    if (response != null) { try { response.Close(); } catch { } }
                }

                if (attempt + 1 < maxRetries)
                    await Task.Delay(Math.Min(RETRY_DELAY_BASE_MS * (attempt + 1), 10000));
            }

            throw new Exception(String.Format("分片{0}下载失败，已达最大重试次数", chunk.Index));
        }

        private async Task DownloadSingleThreadNoRange(string url, string savePath, string displayName)
        {
            speedCalcLastBytes = 0;
            speedCalcLastTime = DateTime.Now;
            currentSpeed = 0;

            if (File.Exists(savePath)) { try { File.Delete(savePath); } catch { } }

            for (int attempt = 0; ; attempt++)
            {
                HttpWebResponse response = null;
                Stream responseStream = null;
                FileStream fs = null;
                Exception caught = null;

                try
                {
                    HttpWebRequest request = (HttpWebRequest)WebRequest.Create(url);
                    request.Timeout = 60000;
                    request.ReadWriteTimeout = 60000;
                    request.UserAgent = userAgent;

                    response = (HttpWebResponse)await Task.Factory.FromAsync<WebResponse>(request.BeginGetResponse, request.EndGetResponse, null);

                    long totalSize = response.ContentLength > 0 ? response.ContentLength : 0;
                    fs = new FileStream(savePath, FileMode.Create, FileAccess.Write);

                    responseStream = response.GetResponseStream();
                    byte[] buffer = new byte[65536];
                    long downloaded = 0;

                    int bytesRead;
                    while ((bytesRead = await ReadStreamAsync(responseStream, buffer, 0, buffer.Length)) > 0)
                    {
                        await WriteStreamAsync(fs, buffer, 0, bytesRead);
                        downloaded += bytesRead;

                        DateTime now = DateTime.Now;
                        double elapsed = (now - speedCalcLastTime).TotalSeconds;
                        if (elapsed >= 0.3)
                        {
                            long delta = downloaded - speedCalcLastBytes;
                            if (delta > 0)
                            {
                                double instantSpeed = delta / elapsed;
                                currentSpeed = currentSpeed <= 0 ? instantSpeed : currentSpeed * 0.3 + instantSpeed * 0.7;
                            }
                            speedCalcLastBytes = downloaded;
                            speedCalcLastTime = now;
                        }

                        int percent = totalSize > 0 ? (int)(downloaded * 100 / totalSize) : 0;
                        string sizeInfo = totalSize > 0 ? String.Format("{0}/{1}", FormatFileSize(downloaded), FormatFileSize(totalSize)) : FormatFileSize(downloaded);
                        string speedInfo = FormatSpeed(currentSpeed);
                        string rightLabel = string.IsNullOrEmpty(speedInfo) ? String.Format("{0}%", percent) : String.Format("{0}% {1}", percent, speedInfo);
                        UpdateStepProgress(percent, String.Format("正在下载{0} {1}", displayName, sizeInfo), rightLabel);
                    }

                    return;
                }
                catch (Exception ex)
                {
                    caught = ex;
                }
                finally
                {
                    if (fs != null) { try { fs.Close(); fs.Dispose(); } catch { } }
                    if (responseStream != null) { try { responseStream.Close(); responseStream.Dispose(); } catch { } }
                    if (response != null) { try { response.Close(); } catch { } }
                }

                WebException singleWebEx = caught as WebException;
                if (singleWebEx == null && caught.InnerException != null)
                    singleWebEx = caught.InnerException as WebException;
                if (singleWebEx != null && singleWebEx.Response is HttpWebResponse)
                {
                    HttpStatusCode code = ((HttpWebResponse)singleWebEx.Response).StatusCode;
                    if (code == HttpStatusCode.NotFound || code == HttpStatusCode.Forbidden || code == HttpStatusCode.Unauthorized)
                        throw new Exception(String.Format("服务器返回 {0}，URL: {1}", (int)code, url));
                }

                Debug.WriteLine(String.Format("单线程下载失败(第{0}次): {1}", attempt + 1, caught.Message));
                if (attempt >= DOWNLOAD_MAX_RETRIES - 1)
                    throw caught;

                int delay = Math.Min(RETRY_DELAY_BASE_MS * (attempt + 1), 15000);
                UpdateStepProgress(0, String.Format("下载中断({0})，{1}秒后重试...", caught.Message, delay / 1000));
                await Task.Delay(delay);
            }
        }

        private Task<int> ReadStreamAsync(Stream stream, byte[] buffer, int offset, int count)
        {
            return Task.Factory.FromAsync<int>(
                (callback, state) => stream.BeginRead(buffer, offset, count, callback, state),
                stream.EndRead, null);
        }

        private Task WriteStreamAsync(Stream stream, byte[] buffer, int offset, int count)
        {
            return Task.Factory.FromAsync(
                (callback, state) => stream.BeginWrite(buffer, offset, count, callback, state),
                stream.EndWrite, null);
        }

        #endregion
    }
}