UpdateService.cs

using System;
using System.Diagnostics;
using System.IO;
using System.IO.Compression;
using System.Net;
using System.Net.Http;
using System.Reflection;
using System.Text.Json;
using System.Threading.Tasks;

namespace WindowsPrivacyTools
{
    public class UpdateInfo
    {
        public string Version { get; set; } = "";
        public string DownloadUrl { get; set; } = "";
        public string Changelog { get; set; } = "";
        public DateTime ReleaseDate { get; set; }
    }

    public static class UpdateService
    {
        private const string GitHubOwner = "JusteSEB";
        private const string GitHubRepo = "WindowsPrivacyTools";
        private static readonly string CurrentVersion = GetAppVersion();

        private static string GetAppVersion()
        {
            var asm = Assembly.GetExecutingAssembly();
            var attr = asm.GetCustomAttribute<AssemblyInformationalVersionAttribute>();
            if (attr != null)
            {
                var ver = attr.InformationalVersion.Split('+')[0].Trim();
                if (Version.TryParse(ver, out _)) return ver;
            }
            return asm.GetName().Version?.ToString() ?? "1.0.0";
        }
        private static readonly string AppDir = AppDomain.CurrentDomain.BaseDirectory;

        public static string GetCurrentVersion() => CurrentVersion;

        public static async Task<UpdateInfo?> CheckForUpdateAsync()
        {
            try
            {
                using var client = new HttpClient();
                client.DefaultRequestHeaders.UserAgent.ParseAdd("WindowsPrivacyTools");

                var releasesUrl = $"https://api.github.com/repos/{GitHubOwner}/{GitHubRepo}/releases/latest";
                var response = await client.GetAsync(releasesUrl);
                if (!response.IsSuccessStatusCode) return null;

                var json = await response.Content.ReadAsStringAsync();
                using var doc = JsonDocument.Parse(json);
                var root = doc.RootElement;

                var tagName = root.GetProperty("tag_name").GetString() ?? "";
                var body = root.GetProperty("body").GetString() ?? "";
                var published = root.GetProperty("published_at").GetString() ?? "";

                string latestVersion = tagName.TrimStart('v', 'V');
                if (!Version.TryParse(latestVersion, out var latest) || !Version.TryParse(CurrentVersion, out var current))
                    return null;

                if (latest <= current) return null;

                string downloadUrl = "";
                if (root.TryGetProperty("assets", out var assets) && assets.GetArrayLength() > 0)
                {
                    downloadUrl = assets[0].GetProperty("browser_download_url").GetString() ?? "";
                }

                if (string.IsNullOrEmpty(downloadUrl)) return null;

                DateTime.TryParse(published, out var releaseDate);

                return new UpdateInfo
                {
                    Version = latestVersion,
                    DownloadUrl = downloadUrl,
                    Changelog = body,
                    ReleaseDate = releaseDate
                };
            }
            catch
            {
                return null;
            }
        }

        public static async Task<bool> DownloadAndInstallAsync(UpdateInfo update, Action<double>? progressCallback = null)
        {
            try
            {
                string tempDir = Path.Combine(Path.GetTempPath(), "WPT_Update");
                if (Directory.Exists(tempDir))
                    Directory.Delete(tempDir, true);
                Directory.CreateDirectory(tempDir);

                string zipPath = Path.Combine(tempDir, "update.zip");
                string extractDir = Path.Combine(tempDir, "extracted");

                using (var client = new HttpClient())
                {
                    client.DefaultRequestHeaders.UserAgent.ParseAdd("WindowsPrivacyTools");
                    var response = await client.GetAsync(update.DownloadUrl);
                    response.EnsureSuccessStatusCode();

                    var totalBytes = response.Content.Headers.ContentLength ?? -1;
                    var stream = await response.Content.ReadAsStreamAsync();

                    using var fileStream = File.Create(zipPath);
                    var buffer = new byte[8192];
                    long totalRead = 0;
                    int bytesRead;

                    while ((bytesRead = await stream.ReadAsync(buffer, 0, buffer.Length)) > 0)
                    {
                        await fileStream.WriteAsync(buffer, 0, bytesRead);
                        totalRead += bytesRead;
                        if (totalBytes > 0)
                            progressCallback?.Invoke((double)totalRead / totalBytes * 100);
                    }
                }

                ZipFile.ExtractToDirectory(zipPath, extractDir);

                string batchPath = Path.Combine(tempDir, "update.bat");
                string currentExe = Process.GetCurrentProcess().MainModule?.FileName ?? "";
                string exeName = Path.GetFileName(currentExe);

                string batchContent = $@"
@echo off
timeout /t 2 /nobreak >nul
taskkill /F /IM ""{exeName}"" 2>nul
timeout /t 1 /nobreak >nul
xcopy /E /Y /I ""{extractDir}\*"" ""{AppDir}""
del ""{zipPath}""
rmdir /S /Q ""{tempDir}"" 2>nul
start """" ""{currentExe}""
";
                File.WriteAllText(batchPath, batchContent);

                Process.Start(new ProcessStartInfo
                {
                    FileName = batchPath,
                    UseShellExecute = true,
                    Verb = "runas",
                    CreateNoWindow = true
                });

                return true;
            }
            catch
            {
                return false;
            }
        }
    }
}