SPT-AKI-Installer/SPTInstaller/Installer Tasks/DownloadTask.cs

using CG.Web.MegaApiClient;
using Newtonsoft.Json;
using SPTInstaller.Aki.Helper;
using SPTInstaller.Interfaces;
using SPTInstaller.Models;
using System;
using System.Collections.Generic;
using System.IO;
using System.Threading.Tasks;

namespace SPTInstaller.Installer_Tasks
{
    public class DownloadTask : InstallerTaskBase
    {
        private InternalData _data;

        public DownloadTask(InternalData data) : base("Download Files")
        {
            _data = data;
        }

        private async Task<IResult> BuildMirrorList()
        {
            var progress = new Progress<double>((d) => { SetStatus("Downloading Mirror List", "", (int)Math.Floor(d));});

            var file = await DownloadCacheHelper.GetOrDownloadFileAsync("mirrors.json", _data.PatcherMirrorsLink, progress);

            if (file == null)
            {
                return Result.FromError("Failed to download mirror list");
            }

            var mirrorsList = JsonConvert.DeserializeObject<List<DownloadMirror>>(File.ReadAllText(file.FullName));

            if (mirrorsList is List<DownloadMirror> mirrors)
            {
                _data.PatcherReleaseMirrors = mirrors;

                return Result.FromSuccess();
            }

            return Result.FromError("Failed to deserialize mirrors list");
        }

        private async Task<IResult> DownloadPatcherFromMirrors(IProgress<double> progress)
        {
            foreach (var mirror in _data.PatcherReleaseMirrors)
            {
                SetStatus($"Downloading Patcher", mirror.Link);

                // mega is a little weird since they use encryption, but thankfully there is a great library for their api :)
                if (mirror.Link.StartsWith("https://mega"))
                {
                    var megaClient = new MegaApiClient();
                    await megaClient.LoginAnonymousAsync();

                    // if mega fails to connect, try the next mirror
                    if (!megaClient.IsLoggedIn) continue;

                    try
                    {
                        using var megaDownloadStream = await megaClient.DownloadAsync(new Uri(mirror.Link), progress);

                        _data.PatcherZipInfo = await DownloadCacheHelper.GetOrDownloadFileAsync("patcher.zip", megaDownloadStream, mirror.Hash);

                        if(_data.PatcherZipInfo == null)
                        {
                            continue;
                        }

                        return Result.FromSuccess();
                    }
                    catch
                    {
                        //most likely a 509 (Bandwidth limit exceeded) due to mega's user quotas.
                        continue;
                    }
                }

                _data.PatcherZipInfo = await DownloadCacheHelper.GetOrDownloadFileAsync("patcher.zip", mirror.Link, progress, mirror.Hash);

                if (_data.PatcherZipInfo != null)
                {
                    return Result.FromSuccess();
                }
            }

            return Result.FromError("Failed to download Patcher");
        }

        public override async Task<IResult> TaskOperation()
        {
            var progress = new Progress<double>((d) => { SetStatus(null, null, (int)Math.Floor(d)); });

            if (_data.PatchNeeded)
            {
                var buildResult = await BuildMirrorList();

                if (!buildResult.Succeeded)
                {
                    return buildResult;
                }

                SetStatus(null, null, 0);

                var patcherDownloadRresult = await DownloadPatcherFromMirrors(progress);

                if (!patcherDownloadRresult.Succeeded)
                {
                    return patcherDownloadRresult;
                }
            }

            SetStatus("Downloading SPT-AKI", _data.AkiReleaseDownloadLink, 0);

            _data.AkiZipInfo = await DownloadCacheHelper.GetOrDownloadFileAsync("sptaki.zip", _data.AkiReleaseDownloadLink, progress, _data.AkiReleaseHash);

            if (_data.AkiZipInfo == null)
            {
                return Result.FromError("Failed to download spt-aki");
            }

            return Result.FromSuccess();
        }
    }
}