PalacePal/Pal.Client/Floors/Tasks/LoadTerritory.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Numerics;
using Microsoft.EntityFrameworkCore;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Logging;
using Pal.Client.Database;

namespace Pal.Client.Floors.Tasks;

internal sealed class LoadTerritory : DbTask<LoadTerritory>
{
    private readonly Cleanup _cleanup;
    private readonly MemoryTerritory _territory;

    public LoadTerritory(IServiceScopeFactory serviceScopeFactory,
        Cleanup cleanup,
        MemoryTerritory territory)
        : base(serviceScopeFactory)
    {
        _cleanup = cleanup;
        _territory = territory;
    }

    protected override void Run(PalClientContext dbContext, ILogger<LoadTerritory> logger)
    {
        lock (_territory.LockObj)
        {
            if (_territory.ReadyState != MemoryTerritory.EReadyState.Loading)
            {
                logger.LogInformation("Territory {Territory} is in state {State}", _territory.TerritoryType,
                    _territory.ReadyState);
                return;
            }

            logger.LogInformation("Loading territory {Territory}", _territory.TerritoryType);

            // purge outdated locations
            _cleanup.Purge(dbContext, _territory.TerritoryType);

            // load good locations
            List<ClientLocation> locations = dbContext.Locations
                .Where(o => o.TerritoryType == (ushort)_territory.TerritoryType)
                .Include(o => o.ImportedBy)
                .Include(o => o.RemoteEncounters)
                .AsSplitQuery()
                .ToList();
            _territory.Initialize(locations.Select(ToMemoryLocation));

            logger.LogInformation("Loaded {Count} locations for territory {Territory}", locations.Count,
                _territory.TerritoryType);
        }
    }

    public static PersistentLocation ToMemoryLocation(ClientLocation location)
    {
        return new PersistentLocation
        {
            LocalId = location.LocalId,
            Type = ToMemoryLocationType(location.Type),
            Position = new Vector3(location.X, location.Y, location.Z),
            Seen = location.Seen,
            Source = location.Source,
            RemoteSeenOn = location.RemoteEncounters.Select(o => o.AccountId).ToList(),
        };
    }

    private static MemoryLocation.EType ToMemoryLocationType(ClientLocation.EType type)
    {
        return type switch
        {
            ClientLocation.EType.Trap => MemoryLocation.EType.Trap,
            ClientLocation.EType.Hoard => MemoryLocation.EType.Hoard,
            _ => throw new ArgumentOutOfRangeException(nameof(type), type, null)
        };
    }
}