PalacePal/Pal.Client/Configuration/Legacy/JsonMigration.cs

using System;
using System.Collections.Generic;
using System.IO;
using System.IO.Compression;
using System.Linq;
using System.Threading;
using System.Threading.Tasks;
using Dalamud.Plugin;
using Microsoft.EntityFrameworkCore;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Logging;
using Pal.Client.Database;
using Pal.Common;

namespace Pal.Client.Configuration.Legacy
{
    /// <summary>
    /// Imports legacy territoryType.json files into the database if it exists, and no markers for that territory exist.
    /// </summary>
    internal sealed class JsonMigration
    {
        private readonly ILogger<JsonMigration> _logger;
        private readonly IServiceScopeFactory _serviceScopeFactory;
        private readonly DalamudPluginInterface _pluginInterface;

        public JsonMigration(ILogger<JsonMigration> logger, IServiceScopeFactory serviceScopeFactory,
            DalamudPluginInterface pluginInterface)
        {
            _logger = logger;
            _serviceScopeFactory = serviceScopeFactory;
            _pluginInterface = pluginInterface;
        }

#pragma warning disable CS0612
        public async Task MigrateAsync(CancellationToken cancellationToken)
        {
            List<JsonFloorState> floorsToMigrate = new();
            JsonFloorState.ForEach(floorsToMigrate.Add);

            if (floorsToMigrate.Count == 0)
            {
                _logger.LogInformation("Found no floors to migrate");
                return;
            }

            cancellationToken.ThrowIfCancellationRequested();

            await using var scope = _serviceScopeFactory.CreateAsyncScope();
            await using var dbContext = scope.ServiceProvider.GetRequiredService<PalClientContext>();

            var fileStream = new FileStream(
                Path.Join(_pluginInterface.GetPluginConfigDirectory(),
                    $"territory-backup-{DateTime.Now:yyyyMMdd-HHmmss}.zip"),
                FileMode.CreateNew);
            using (var backup = new ZipArchive(fileStream, ZipArchiveMode.Create, false))
            {
                IReadOnlyDictionary<Guid, ImportHistory> imports =
                    await dbContext.Imports.ToDictionaryAsync(import => import.Id, cancellationToken);

                foreach (var floorToMigrate in floorsToMigrate)
                {
                    backup.CreateEntryFromFile(floorToMigrate.GetSaveLocation(),
                        Path.GetFileName(floorToMigrate.GetSaveLocation()), CompressionLevel.SmallestSize);
                    await MigrateFloor(dbContext, floorToMigrate, imports, cancellationToken);
                }

                await dbContext.SaveChangesAsync(cancellationToken);
            }

            _logger.LogInformation("Removing {Count} old json files", floorsToMigrate.Count);
            foreach (var floorToMigrate in floorsToMigrate)
                File.Delete(floorToMigrate.GetSaveLocation());
        }

        /// <returns>Whether to archive this file once complete</returns>
        private async Task MigrateFloor(
            PalClientContext dbContext,
            JsonFloorState floorToMigrate,
            IReadOnlyDictionary<Guid, ImportHistory> imports,
            CancellationToken cancellationToken)
        {
            using var logScope = _logger.BeginScope($"Import {(ETerritoryType)floorToMigrate.TerritoryType}");
            if (floorToMigrate.Markers.Count == 0)
            {
                _logger.LogInformation("Skipping migration, floor has no markers");
            }

            if (await dbContext.Locations.AnyAsync(o => o.TerritoryType == floorToMigrate.TerritoryType,
                    cancellationToken))
            {
                _logger.LogInformation("Skipping migration, floor already has locations in the database");
                return;
            }

            _logger.LogInformation("Starting migration of {Count} locations", floorToMigrate.Markers.Count);
            List<ClientLocation> clientLocations = floorToMigrate.Markers
                .Where(o => o.Type == JsonMarker.EType.Trap || o.Type == JsonMarker.EType.Hoard)
                .Select(o =>
                {
                    var clientLocation = new ClientLocation
                    {
                        TerritoryType = floorToMigrate.TerritoryType,
                        Type = MapJsonType(o.Type),
                        X = o.Position.X,
                        Y = o.Position.Y,
                        Z = o.Position.Z,
                        Seen = o.Seen,

                        // the SelectMany is misleading here, each import has either 0 or 1 associated db entry with that id
                        ImportedBy = o.Imports
                            .Select(importId =>
                                imports.TryGetValue(importId, out ImportHistory? import) ? import : null)
                            .Where(import => import != null)
                            .Cast<ImportHistory>()
                            .Distinct()
                            .ToList(),

                        // if we have a location not encountered locally, which also wasn't imported,
                        // it very likely is a download (but we have no information to track this).
                        Source = o.Seen ? ClientLocation.ESource.SeenLocally :
                            o.Imports.Count > 0 ? ClientLocation.ESource.Import : ClientLocation.ESource.Download,
                        SinceVersion = o.SinceVersion ?? "0.0",
                    };

                    clientLocation.RemoteEncounters = o.RemoteSeenOn
                        .Select(accountId => new RemoteEncounter(clientLocation, accountId))
                        .ToList();

                    return clientLocation;
                }).ToList();
            await dbContext.Locations.AddRangeAsync(clientLocations, cancellationToken);

            _logger.LogInformation("Migrated {Count} locations", clientLocations.Count);
        }

        private ClientLocation.EType MapJsonType(JsonMarker.EType type)
        {
            return type switch
            {
                JsonMarker.EType.Trap => ClientLocation.EType.Trap,
                JsonMarker.EType.Hoard => ClientLocation.EType.Hoard,
                _ => throw new ArgumentOutOfRangeException(nameof(type), type, null)
            };
        }
#pragma warning restore CS0612
    }
}