ModUpdater.cs

using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Net;
using System.Reflection;
using System.Runtime.InteropServices;
using System.Threading.Tasks;
using BepInEx.Logging;
using Newtonsoft.Json;
using UnityEngine;

namespace ModUpdater
{
    public class ModUpdater
    {
        private readonly string remoteManifestUrl;
        private readonly string pluginsPath;
        private readonly Action<UpdateResult> onComplete;
        private readonly ModStatusTracker statusTracker;
        private readonly ManualLogSource logger;

        private volatile string currentStatus = "Idle";

        private static readonly WebClient http = CreateNoCacheClient();

        private static WebClient CreateNoCacheClient()
        {
            var client = new WebClient();
            client.Headers[HttpRequestHeader.CacheControl] = "no-cache, no-store";
            client.Headers[HttpRequestHeader.Pragma] = "no-cache";
            client.Headers[HttpRequestHeader.UserAgent] = "ModUpdater/1.0";
            client.CachePolicy = new System.Net.Cache.RequestCachePolicy(
                System.Net.Cache.RequestCacheLevel.NoCacheNoStore);
            return client;
        }

        public ModUpdater(string remoteManifestUrl,
                          string pluginsPath,
                          Action<UpdateResult> onComplete,
                          ModStatusTracker statusTracker,
                          ManualLogSource logger)
        {
            this.remoteManifestUrl = remoteManifestUrl;
            this.pluginsPath       = pluginsPath;
            this.onComplete        = onComplete;
            this.statusTracker     = statusTracker;
            this.logger            = logger;
        }

        public void StartUpdate()
        {
            MainThreadDispatcher.Initialise();
            Task.Run(RunUpdatePipeline);
        }

        public string GetCurrentStatus() => currentStatus;

        public ModStatusTracker StatusTracker => statusTracker;

        private async Task RunUpdatePipeline()
        {
            List<string> failedMods = new List<string>();
            int updatedCount = 0;

            try
            {
                logger.LogInfo("[Pipeline] Step 1: Update pipeline started.");

                currentStatus = "Fetching mod list…";
                logger.LogInfo($"[Pipeline] Step 2: Fetching remote manifest from {remoteManifestUrl}");
                List<RemoteModEntry> remoteList = await FetchRemoteManifest();
                logger.LogInfo("[Pipeline] Step 2: FetchRemoteManifest returned.");

                if(remoteList == null)
                {
                    currentStatus = "Remove list didn't deserialize correctly.";
                    Complete(UpdateResult.WithErrors(new List<string>() { " remote list was NULL"}, 0));
                    return;
                }

                if(remoteList.Count == 0)
                {
                    logger.LogInfo("Remote manifest returned no mods.");
                    currentStatus = "No remote mods found.";
                    Complete(UpdateResult.AllCurrent());
                    return;
                }
                logger.LogInfo($"[Pipeline] Step 2: Remote manifest returned {remoteList.Count} mod(s).");

                currentStatus = "Scanning installed plugins…";
                logger.LogInfo("[Pipeline] Step 3: Scanning installed plugins…");
                Dictionary<string, string> installedPlugins = ScanInstalledPlugins();
                logger.LogInfo($"[Pipeline] Step 3: Found {installedPlugins.Count} installed BepInEx plugin(s).");

                logger.LogInfo("[Pipeline] Step 4: Computing mods to update…");
                List<RemoteModEntry> toUpdate = GetModsToUpdate(remoteList, installedPlugins);
                logger.LogInfo($"[Pipeline] Step 4: {toUpdate.Count} mod(s) need updating.");

                logger.LogInfo("[Pipeline] Step 5: Populating tracker…");
                PopulateTracker(remoteList, toUpdate);
                logger.LogInfo("[Pipeline] Step 5: Tracker populated.");

                if (toUpdate.Count == 0)
                {
                    logger.LogInfo("All mods are up to date — nothing to download.");
                    currentStatus = "All mods are up to date.";
                    Complete(UpdateResult.AllCurrent());
                    return;
                }

                logger.LogInfo("[Pipeline] Step 6: Starting downloads…");
                for (int i = 0; i < toUpdate.Count; i++)
                {
                    RemoteModEntry mod = toUpdate[i];
                    currentStatus = $"Downloading {mod.Name} ({i + 1}/{toUpdate.Count})…";
                    logger.LogInfo($"[Pipeline] Step 6: Downloading {mod.Name} ({i + 1}/{toUpdate.Count})…");
                    statusTracker.SetMod(mod.Name, mod.ModNumber, ModStatus.Downloading);
                    int progress = i + 1;
                    int count = toUpdate.Count;
                    MainThreadDispatcher.Enqueue(() => TextOverlay.SetText($"Downloading mods ({progress}/{count})..."));

                    DownloadResult downloadResult = await DownloadAndExtract(mod);
                    if (downloadResult == DownloadResult.Success)
                    {
                        logger.LogInfo($"Successfully updated {mod.Name}.");
                        statusTracker.SetMod(mod.Name, mod.ModNumber, ModStatus.Downloaded);
                        updatedCount++;
                    }
                    else if (downloadResult == DownloadResult.Unreachable)
                    {
                        logger.LogWarning($"Skipping {mod.Name}: URL was unreachable ({mod.URL}).");
                        statusTracker.SetMod(mod.Name, mod.ModNumber, ModStatus.Skipped);
                    }
                    else
                    {
                        logger.LogWarning($"Failed to update {mod.Name}.");
                        statusTracker.SetMod(mod.Name, mod.ModNumber, ModStatus.Failed);
                        failedMods.Add(mod.Name);
                    }
                }

                currentStatus = failedMods.Count == 0
                    ? $"Done — {updatedCount} mod(s) updated."
                    : $"Done with {failedMods.Count} error(s).";

                logger.LogInfo($"Update pipeline finished. Updated: {updatedCount}, Failed: {failedMods.Count}.");
            }
            catch (Exception ex)
            {
                logger.LogError($"[Pipeline] FATAL: {ex.GetType().Name}: {ex.Message}");
                logger.LogError($"[Pipeline] Stack trace: {ex.StackTrace}");
                if (ex.InnerException != null)
                    logger.LogError($"[Pipeline] Inner: {ex.InnerException.GetType().Name}: {ex.InnerException.Message}");
                currentStatus = "Update failed (see log).";
                failedMods.Add("PIPELINE_FATAL");
            }

            UpdateResult result = failedMods.Count == 0
                ? UpdateResult.AllGood(updatedCount)
                : UpdateResult.WithErrors(failedMods, updatedCount);

            Complete(result);
        }

        // ── Tracker population ──────────────────────────────────────────

        private void PopulateTracker(
            List<RemoteModEntry> remoteList,
            List<RemoteModEntry> toUpdate)
        {
            var toUpdateUUIDs = new HashSet<string>();
            foreach (var mod in toUpdate)
                toUpdateUUIDs.Add(mod.UUID);

            foreach (var mod in remoteList)
            {
                if (!toUpdateUUIDs.Contains(mod.UUID))
                    statusTracker.SetMod(mod.Name, mod.ModNumber, ModStatus.Installed);
            }

            foreach (var mod in toUpdate)
                statusTracker.SetMod(mod.Name, mod.ModNumber, ModStatus.Queued);
        }

        // ── Remote manifest ─────────────────────────────────────────────

        private async Task<List<RemoteModEntry>> FetchRemoteManifest()
        {
            try
            {
                string bustUrl = remoteManifestUrl
                    + (remoteManifestUrl.Contains("?") ? "&" : "?")
                    + "_t=" + DateTimeOffset.UtcNow.ToUnixTimeMilliseconds();
                string json = await http.DownloadStringTaskAsync(bustUrl);
                logger.LogInfo($"Fetched remote manifest:\n{json}");
                return JsonConvert.DeserializeObject<List<RemoteModEntry>>(json);
            }
            catch (Exception ex)
            {
                Debug.LogError($"[ModUpdater] Failed to fetch remote manifest: {ex.Message}");
                return null;
            }
        }

        // ── Installed plugin scan ───────────────────────────────────────

        private Dictionary<string, string> ScanInstalledPlugins()
        {
            var installed = new Dictionary<string, string>();

            foreach (string dllPath in Directory.GetFiles(pluginsPath, "*.dll", SearchOption.AllDirectories))
            {
                try
                {
                    var asm = Assembly.LoadFrom(dllPath);
                    var guidAttr = (GuidAttribute)Attribute.GetCustomAttribute(asm, typeof(GuidAttribute));
                    if (guidAttr == null)
                        continue;

                    string version = asm.GetName().Version.ToString();
                    var infoAttr = (AssemblyInformationalVersionAttribute)
                        Attribute.GetCustomAttribute(asm, typeof(AssemblyInformationalVersionAttribute));
                    if (infoAttr != null && !string.IsNullOrWhiteSpace(infoAttr.InformationalVersion))
                        version = infoAttr.InformationalVersion;

                    installed[guidAttr.Value] = version;
                    logger.LogInfo($"Found installed plugin: {guidAttr.Value} v{version} at {dllPath}");
                }
                catch
                {
                }
            }

            return installed;
        }

        // ── Version diff ────────────────────────────────────────────────

        private List<RemoteModEntry> GetModsToUpdate(
            List<RemoteModEntry> remote,
            Dictionary<string, string> installedPlugins)
        {
            var result = new List<RemoteModEntry>();
            foreach (var mod in remote)
            {
                if (installedPlugins.TryGetValue(mod.UUID, out string installedVersion))
                {
                    if (SemVer.IsNewer(mod.ModNumber, installedVersion))
                        result.Add(mod);
                }
                else
                {
                    logger.LogInfo($"{mod.Name}: not found in loaded plugins, queuing install.");
                    result.Add(mod);
                }
            }
            return result;
        }

        // ── Download + extract ──────────────────────────────────────────

        private async Task<DownloadResult> DownloadAndExtract(RemoteModEntry mod)
        {
            try
            {
                logger.LogInfo($"[DownloadAndExtract] Starting for {mod.Name} v{mod.ModNumber}");
                logger.LogInfo($"[DownloadAndExtract] URL: {mod.URL}");

                byte[] zipBytes = await http.DownloadDataTaskAsync(mod.URL);
                logger.LogInfo($"[DownloadAndExtract] Downloaded {zipBytes.Length} bytes for {mod.Name}");

                var entries = MiniZip.Extract(zipBytes);
                logger.LogInfo($"[DownloadAndExtract] Zip contains {entries.Count} entries");

                bool hasBepInExStructure = HasBepInExFolderStructure(entries);
                string bepInExRoot = Directory.GetParent(pluginsPath).FullName;

                string destDir;
                if (hasBepInExStructure)
                {
                    destDir = bepInExRoot;
                    logger.LogInfo($"[DownloadAndExtract] Detected BepInEx folder structure, extracting to: {destDir}");
                }
                else
                {
                    destDir = Path.Combine(pluginsPath, SanitiseFolderName(mod.Name));
                    logger.LogInfo($"[DownloadAndExtract] Standard mod, extracting to: {destDir}");

                    if (Directory.Exists(destDir))
                    {
                        logger.LogInfo($"[DownloadAndExtract] Deleting existing directory: {destDir}");
                        Directory.Delete(destDir, true);
                    }
                    Directory.CreateDirectory(destDir);
                }

                foreach (var entry in entries)
                {
                    string destPath = Path.Combine(destDir, entry.FileName);
                    string entryDir = Path.GetDirectoryName(destPath);
                    if (!Directory.Exists(entryDir))
                        Directory.CreateDirectory(entryDir);

                    if (File.Exists(destPath))
                        File.Delete(destPath);

                    logger.LogInfo($"[DownloadAndExtract] Extracting: {entry.FileName} -> {destPath}");
                    File.WriteAllBytes(destPath, entry.Data);
                }

                logger.LogInfo($"[DownloadAndExtract] Successfully installed {mod.Name} v{mod.ModNumber}");
                return DownloadResult.Success;
            }
            catch (WebException ex)
            {
                logger.LogWarning($"[DownloadAndExtract] URL unreachable for {mod.Name}: {ex.Message}");
                logger.LogWarning($"[DownloadAndExtract] ---- DID YOU REMEMBER TO MAKE THE REPO PUBILC?? ----");
                return DownloadResult.Unreachable;
            }
            catch (Exception ex)
            {
                logger.LogError($"[DownloadAndExtract] Failed for {mod.Name}: {ex.GetType().Name}: {ex.Message}");
                logger.LogError($"[DownloadAndExtract] Stack trace: {ex.StackTrace}");
                if (ex.InnerException != null)
                    logger.LogError($"[DownloadAndExtract] Inner: {ex.InnerException.GetType().Name}: {ex.InnerException.Message}");
                return DownloadResult.Failed;
            }
        }

        // ── Helpers ─────────────────────────────────────────────────────

        private void Complete(UpdateResult result)
        {
            MainThreadDispatcher.Enqueue(() => onComplete?.Invoke(result));
        }

        private static bool HasBepInExFolderStructure(List<MiniZip.ZipEntry> entries)
        {
            foreach (var entry in entries)
            {
                if (entry.FileName.StartsWith("plugins/") || entry.FileName.StartsWith("plugins\\") ||
                    entry.FileName.StartsWith("config/") || entry.FileName.StartsWith("config\\"))
                    return true;
            }
            return false;
        }

        private static string SanitiseFolderName(string name)
        {
            char[] invalid = Path.GetInvalidFileNameChars();
            return new string(name.Select(c => invalid.Contains(c) ? '_' : c).ToArray());
        }
    }
}