UpdateManager.cs

using System;
using System.Collections.Generic;
using System.IO;
using System.IO.Compression;
using System.Linq;
using System.Net.Http;
using System.Threading.Tasks;
using Octokit;

namespace PoCXPlotterGui
{
    /// <summary>
    /// Result of update check operation
    /// </summary>
    public class UpdateCheckResult
    {
        public bool UpdateAvailable { get; set; }
        public string LatestVersion { get; set; }
        public string CurrentVersion { get; set; }
        public string ReleaseNotes { get; set; }
        public DateTime? PublishedAt { get; set; }
        public bool IsCpuAvailable { get; set; }
        public bool IsGpuAvailable { get; set; }
        public List<ReleaseInfo> AvailableReleases { get; set; }
    }

    /// <summary>
    /// Information about a specific release
    /// </summary>
    public class ReleaseInfo
    {
        public string Version { get; set; }
        public string ReleaseNotes { get; set; }
        public DateTime? PublishedAt { get; set; }
        public bool IsPrerelease { get; set; }
        public bool IsCpuAvailable { get; set; }
        public bool IsGpuAvailable { get; set; }
        internal Release GitHubRelease { get; set; }

        public override string ToString()
        {
            string prefix = IsPrerelease ? "⚠ " : "";
            string date = PublishedAt.HasValue ? PublishedAt.Value.ToString("yyyy-MM-dd") : "Unknown";
            return $"{prefix}{Version} ({date})";
        }
    }

    /// <summary>
    /// Type of executable to download
    /// </summary>
    public enum ExecutableType
    {
        CPU,
        GPU,
        Both
    }

    /// <summary>
    /// Progress information for download operation
    /// </summary>
    public class DownloadProgressEventArgs : EventArgs
    {
        public long BytesReceived { get; set; }
        public long TotalBytes { get; set; }
        public int ProgressPercentage { get; set; }
        public string FileName { get; set; }
    }

    /// <summary>
    /// Manages checking for updates and downloading executables from GitHub releases
    /// </summary>
    public class UpdateManager : IDisposable
    {
        private const string GITHUB_OWNER = "PoC-Consortium";
        private const string GITHUB_REPO = "pocx";
        private const string CPU_ASSET_PATTERN = "windows-msvc.zip";
        private const string GPU_ASSET_PATTERN = "windows-msvc-opencl.zip";
        private const string PLOTTER_EXE_NAME = "pocx_plotter.exe";
        private const string CPU_TARGET_NAME = "pocx_plotter_cpu.exe";
        private const string GPU_TARGET_NAME = "pocx_plotter_gpu.exe";

        private readonly GitHubClient _githubClient;
        private Release _latestRelease;
        private bool _disposed = false;

        public event EventHandler<DownloadProgressEventArgs> DownloadProgressChanged;

        public UpdateManager()
        {
            _githubClient = new GitHubClient(new ProductHeaderValue("PoCXPlotterGUI"));
        }

        public void Dispose()
        {
            Dispose(true);
            GC.SuppressFinalize(this);
        }

        protected virtual void Dispose(bool disposing)
        {
            if (!_disposed)
            {
                if (disposing)
                {
                    // GitHubClient doesn't implement IDisposable in Octokit 14.0.0
                    // but we set the flag to prevent use after disposal
                }
                _disposed = true;
            }
        }

        /// <summary>
        /// Checks if executables are present in the application directory
        /// </summary>
        public static bool AreExecutablesPresent(out bool cpuMissing, out bool gpuMissing)
        {
            cpuMissing = !File.Exists(CPU_TARGET_NAME);
            gpuMissing = !File.Exists(GPU_TARGET_NAME);
            return !cpuMissing && !gpuMissing;
        }

        /// <summary>
        /// Checks for available updates from GitHub releases
        /// </summary>
        public async Task<UpdateCheckResult> CheckForUpdatesAsync()
        {
            try
            {
                // Get all releases
                var allReleases = await _githubClient.Repository.Release.GetAll(GITHUB_OWNER, GITHUB_REPO);

                // Get latest release
                _latestRelease = allReleases.FirstOrDefault();

                if (_latestRelease == null)
                {
                    throw new Exception("No releases found");
                }

                var result = new UpdateCheckResult
                {
                    LatestVersion = _latestRelease.TagName,
                    CurrentVersion = GetCurrentVersion(),
                    ReleaseNotes = _latestRelease.Body,
                    PublishedAt = _latestRelease.PublishedAt?.DateTime,
                    AvailableReleases = new List<ReleaseInfo>()
                };

                // Check if CPU and GPU assets are available
                result.IsCpuAvailable = _latestRelease.Assets.Any(a =>
                    a.Name.Contains(CPU_ASSET_PATTERN) && !a.Name.Contains("opencl"));
                result.IsGpuAvailable = _latestRelease.Assets.Any(a =>
                    a.Name.Contains(GPU_ASSET_PATTERN));

                // Compare versions
                result.UpdateAvailable = CompareVersions(result.CurrentVersion, result.LatestVersion) < 0;

                // Build list of all available releases
                foreach (var release in allReleases)
                {
                    var releaseInfo = new ReleaseInfo
                    {
                        Version = release.TagName,
                        ReleaseNotes = release.Body,
                        PublishedAt = release.PublishedAt?.DateTime,
                        IsPrerelease = release.Prerelease,
                        IsCpuAvailable = release.Assets.Any(a => a.Name.Contains(CPU_ASSET_PATTERN) && !a.Name.Contains("opencl")),
                        IsGpuAvailable = release.Assets.Any(a => a.Name.Contains(GPU_ASSET_PATTERN)),
                        GitHubRelease = release
                    };
                    result.AvailableReleases.Add(releaseInfo);
                }

                return result;
            }
            catch (Exception ex)
            {
                throw new Exception($"Failed to check for updates: {ex.Message}", ex);
            }
        }

        /// <summary>
        /// Downloads and installs the specified executable type(s) from latest release
        /// </summary>
        public async Task DownloadAndInstallAsync(ExecutableType type)
        {
            if (_latestRelease == null)
            {
                await CheckForUpdatesAsync();
            }

            await DownloadAndInstallAsync(type, null);
        }

        /// <summary>
        /// Downloads and installs the specified executable type(s) from a specific release
        /// </summary>
        public async Task DownloadAndInstallAsync(ExecutableType type, ReleaseInfo releaseInfo)
        {
            Release targetRelease;

            if (releaseInfo != null)
            {
                targetRelease = releaseInfo.GitHubRelease;
            }
            else
            {
                if (_latestRelease == null)
                {
                    await CheckForUpdatesAsync();
                }
                targetRelease = _latestRelease;
            }

            if (type == ExecutableType.CPU || type == ExecutableType.Both)
            {
                await DownloadAndInstallExecutableAsync(targetRelease, CPU_ASSET_PATTERN, CPU_TARGET_NAME, false);
            }

            if (type == ExecutableType.GPU || type == ExecutableType.Both)
            {
                await DownloadAndInstallExecutableAsync(targetRelease, GPU_ASSET_PATTERN, GPU_TARGET_NAME, true);
            }

            // Update stored version
            SaveCurrentVersion(targetRelease.TagName);
        }

        /// <summary>
        /// Downloads and installs a specific executable from a given release
        /// </summary>
        private async Task DownloadAndInstallExecutableAsync(Release release, string assetPattern, string targetName, bool isOpenCl)
        {
            // Find the asset
            var asset = release.Assets.FirstOrDefault(a =>
                a.Name.Contains(assetPattern) && (isOpenCl ? a.Name.Contains("opencl") : !a.Name.Contains("opencl")));

            if (asset == null)
            {
                throw new Exception($"Could not find {assetPattern} asset in release {release.TagName}");
            }

            // Download to temp directory
            string tempZipPath = Path.Combine(Path.GetTempPath(), asset.Name);
            string tempExtractPath = Path.Combine(Path.GetTempPath(), $"pocx_extract_{Guid.NewGuid()}");

            try
            {
                // Download ZIP file
                await DownloadFileAsync(asset.BrowserDownloadUrl, tempZipPath, asset.Name);

                // Extract ZIP
                Directory.CreateDirectory(tempExtractPath);
                ZipFile.ExtractToDirectory(tempZipPath, tempExtractPath);

                // Find pocx_plotter.exe in extracted files
                string extractedPlotter = Path.Combine(tempExtractPath, PLOTTER_EXE_NAME);
                if (!File.Exists(extractedPlotter))
                {
                    throw new Exception($"{PLOTTER_EXE_NAME} not found in downloaded archive");
                }

                // Backup existing file if present
                if (File.Exists(targetName))
                {
                    string backupName = $"{targetName}.bak";
                    if (File.Exists(backupName))
                    {
                        File.Delete(backupName);
                    }
                    File.Move(targetName, backupName);
                }

                // Copy new file
                File.Copy(extractedPlotter, targetName, true);
            }
            finally
            {
                // Cleanup temp files
                if (File.Exists(tempZipPath))
                {
                    File.Delete(tempZipPath);
                }
                if (Directory.Exists(tempExtractPath))
                {
                    Directory.Delete(tempExtractPath, true);
                }
            }
        }

        /// <summary>
        /// Downloads a file with progress reporting
        /// </summary>
        private async Task DownloadFileAsync(string url, string destinationPath, string fileName)
        {
            using (var httpClient = new HttpClient())
            {
                httpClient.Timeout = TimeSpan.FromMinutes(10);

                using (var response = await httpClient.GetAsync(url, HttpCompletionOption.ResponseHeadersRead))
                {
                    response.EnsureSuccessStatusCode();

                    var totalBytes = response.Content.Headers.ContentLength ?? -1;
                    var canReportProgress = totalBytes != -1;

                    using (var contentStream = await response.Content.ReadAsStreamAsync())
                    using (var fileStream = new FileStream(destinationPath, System.IO.FileMode.Create, FileAccess.Write, FileShare.None, 8192, true))
                    {
                        var buffer = new byte[8192];
                        long totalRead = 0;
                        int bytesRead;

                        while ((bytesRead = await contentStream.ReadAsync(buffer, 0, buffer.Length)) > 0)
                        {
                            await fileStream.WriteAsync(buffer, 0, bytesRead);
                            totalRead += bytesRead;

                            if (canReportProgress)
                            {
                                var progressPercentage = (int)((totalRead * 100) / totalBytes);
                                DownloadProgressChanged?.Invoke(this, new DownloadProgressEventArgs
                                {
                                    BytesReceived = totalRead,
                                    TotalBytes = totalBytes,
                                    ProgressPercentage = progressPercentage,
                                    FileName = fileName
                                });
                            }
                        }
                    }
                }
            }
        }

        /// <summary>
        /// Gets the currently installed version
        /// </summary>
        private string GetCurrentVersion()
        {
            return Properties.Settings.Default.InstalledPlotterVersion ?? "unknown";
        }

        /// <summary>
        /// Saves the current version to settings
        /// </summary>
        private void SaveCurrentVersion(string version)
        {
            Properties.Settings.Default.InstalledPlotterVersion = version;
            Properties.Settings.Default.Save();
        }

        /// <summary>
        /// Compares two version strings (format: v1.0.0-rc1 or v1.0.0)
        /// Returns: -1 if current < latest, 0 if equal, 1 if current > latest
        /// </summary>
        private int CompareVersions(string current, string latest)
        {
            if (current == "unknown") return -1;

            try
            {
                // Remove 'v' prefix and prerelease suffix for comparison
                var currentClean = CleanVersion(current);
                var latestClean = CleanVersion(latest);

                var currentParts = currentClean.Split('.').Select(int.Parse).ToArray();
                var latestParts = latestClean.Split('.').Select(int.Parse).ToArray();

                for (int i = 0; i < Math.Min(currentParts.Length, latestParts.Length); i++)
                {
                    if (currentParts[i] < latestParts[i]) return -1;
                    if (currentParts[i] > latestParts[i]) return 1;
                }

                return currentParts.Length.CompareTo(latestParts.Length);
            }
            catch
            {
                // If parsing fails, assume update is available
                return -1;
            }
        }

        /// <summary>
        /// Cleans version string by removing 'v' prefix and prerelease suffixes
        /// Example: v1.0.0-rc1 -> 1.0.0
        /// </summary>
        private string CleanVersion(string version)
        {
            if (string.IsNullOrEmpty(version)) return "0.0.0";

            // Remove 'v' prefix
            version = version.TrimStart('v', 'V');

            // Remove prerelease suffix (-rc1, -alpha, -beta, etc.)
            int dashIndex = version.IndexOf('-');
            if (dashIndex > 0)
            {
                version = version.Substring(0, dashIndex);
            }

            return version;
        }
    }
}