PalacePal/Pal.Client/DependencyInjection/ImportService.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Numerics;
using System.Threading;
using System.Threading.Tasks;
using Export;
using Microsoft.EntityFrameworkCore;
using Microsoft.Extensions.DependencyInjection;
using Pal.Client.Database;
using Pal.Client.Floors;
using Pal.Client.Floors.Tasks;
using Pal.Common;

namespace Pal.Client.DependencyInjection;

internal sealed class ImportService
{
    private readonly IServiceProvider _serviceProvider;
    private readonly FloorService _floorService;
    private readonly Cleanup _cleanup;

    public ImportService(
        IServiceProvider serviceProvider,
        FloorService floorService,
        Cleanup cleanup)
    {
        _serviceProvider = serviceProvider;
        _floorService = floorService;
        _cleanup = cleanup;
    }

    public async Task<ImportHistory?> FindLast(CancellationToken token = default)
    {
        await using var scope = _serviceProvider.CreateAsyncScope();
        await using var dbContext = scope.ServiceProvider.GetRequiredService<PalClientContext>();

        return await dbContext.Imports.OrderByDescending(x => x.ImportedAt).ThenBy(x => x.Id)
            .FirstOrDefaultAsync(cancellationToken: token);
    }

    public (int traps, int hoard) Import(ExportRoot import)
    {
        try
        {
            _floorService.SetToImportState();

            using var scope = _serviceProvider.CreateScope();
            using var dbContext = scope.ServiceProvider.GetRequiredService<PalClientContext>();

            dbContext.Imports.RemoveRange(dbContext.Imports.Where(x => x.RemoteUrl == import.ServerUrl).ToList());
            dbContext.SaveChanges();

            ImportHistory importHistory = new ImportHistory
            {
                Id = Guid.Parse(import.ExportId),
                RemoteUrl = import.ServerUrl,
                ExportedAt = import.CreatedAt.ToDateTime(),
                ImportedAt = DateTime.UtcNow,
            };
            dbContext.Imports.Add(importHistory);

            int traps = 0;
            int hoard = 0;
            foreach (var floor in import.Floors)
            {
                ETerritoryType territoryType = (ETerritoryType)floor.TerritoryType;

                List<PersistentLocation> existingLocations = dbContext.Locations
                    .Where(loc => loc.TerritoryType == floor.TerritoryType)
                    .ToList()
                    .Select(LoadTerritory.ToMemoryLocation)
                    .ToList();
                foreach (var exportLocation in floor.Objects)
                {
                    PersistentLocation persistentLocation = new PersistentLocation
                    {
                        Type = ToMemoryType(exportLocation.Type),
                        Position = new Vector3(exportLocation.X, exportLocation.Y, exportLocation.Z),
                        Source = ClientLocation.ESource.Unknown,
                    };

                    var existingLocation = existingLocations.FirstOrDefault(x => x == persistentLocation);
                    if (existingLocation != null)
                    {
                        var clientLoc = dbContext.Locations.FirstOrDefault(o => o.LocalId == existingLocation.LocalId);
                        clientLoc?.ImportedBy.Add(importHistory);

                        continue;
                    }

                    ClientLocation clientLocation = new ClientLocation
                    {
                        TerritoryType = (ushort)territoryType,
                        Type = ToClientLocationType(exportLocation.Type),
                        X = exportLocation.X,
                        Y = exportLocation.Y,
                        Z = exportLocation.Z,
                        Seen = false,
                        Source = ClientLocation.ESource.Import,
                        ImportedBy = new List<ImportHistory> { importHistory },
                        SinceVersion = typeof(Plugin).Assembly.GetName().Version!.ToString(2),
                    };
                    dbContext.Locations.Add(clientLocation);

                    if (exportLocation.Type == ExportObjectType.Trap)
                        traps++;
                    else if (exportLocation.Type == ExportObjectType.Hoard)
                        hoard++;
                }
            }

            dbContext.SaveChanges();

            _cleanup.Purge(dbContext);
            dbContext.SaveChanges();

            return (traps, hoard);
        }
        finally
        {
            _floorService.ResetAll();
        }
    }

    private MemoryLocation.EType ToMemoryType(ExportObjectType exportLocationType)
    {
        return exportLocationType switch
        {
            ExportObjectType.Trap => MemoryLocation.EType.Trap,
            ExportObjectType.Hoard => MemoryLocation.EType.Hoard,
            _ => throw new ArgumentOutOfRangeException(nameof(exportLocationType), exportLocationType, null)
        };
    }

    private ClientLocation.EType ToClientLocationType(ExportObjectType exportLocationType)
    {
        return exportLocationType switch
        {
            ExportObjectType.Trap => ClientLocation.EType.Trap,
            ExportObjectType.Hoard => ClientLocation.EType.Hoard,
            _ => throw new ArgumentOutOfRangeException(nameof(exportLocationType), exportLocationType, null)
        };
    }

    public void RemoveById(Guid id)
    {
        try
        {
            _floorService.SetToImportState();
            using var scope = _serviceProvider.CreateScope();
            using var dbContext = scope.ServiceProvider.GetRequiredService<PalClientContext>();

            dbContext.RemoveRange(dbContext.Imports.Where(x => x.Id == id));
            dbContext.SaveChanges();

            _cleanup.Purge(dbContext);
            dbContext.SaveChanges();
        }
        finally
        {
            _floorService.ResetAll();
        }
    }
}