PalacePal/Pal.Client/Scheduled/QueuedSyncResponse.cs

using System;
using System.Collections.Generic;
using System.Linq;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Logging;
using Pal.Client.Configuration;
using Pal.Client.DependencyInjection;
using Pal.Client.Extensions;
using Pal.Client.Floors;
using Pal.Client.Floors.Tasks;
using Pal.Client.Net;
using Pal.Common;

namespace Pal.Client.Scheduled
{
    internal sealed class QueuedSyncResponse : IQueueOnFrameworkThread
    {
        public required SyncType Type { get; init; }
        public required ushort TerritoryType { get; init; }
        public required bool Success { get; init; }
        public required IReadOnlyList<PersistentLocation> Locations { get; init; }

        internal sealed class Handler : IQueueOnFrameworkThread.Handler<QueuedSyncResponse>
        {
            private readonly IServiceScopeFactory _serviceScopeFactory;
            private readonly IPalacePalConfiguration _configuration;
            private readonly FloorService _floorService;
            private readonly TerritoryState _territoryState;
            private readonly DebugState _debugState;

            public Handler(
                ILogger<Handler> logger,
                IServiceScopeFactory serviceScopeFactory,
                IPalacePalConfiguration configuration,
                FloorService floorService,
                TerritoryState territoryState,
                DebugState debugState)
                : base(logger)
            {
                _serviceScopeFactory = serviceScopeFactory;
                _configuration = configuration;
                _floorService = floorService;
                _territoryState = territoryState;
                _debugState = debugState;
            }

            protected override void Run(QueuedSyncResponse queued, ref bool recreateLayout)
            {
                recreateLayout = true;

                _logger.LogDebug(
                    "Sync response for territory {Territory} of type {Type}, success = {Success}, response objects = {Count}",
                    (ETerritoryType)queued.TerritoryType, queued.Type, queued.Success, queued.Locations.Count);
                var memoryTerritory = _floorService.GetTerritoryIfReady(queued.TerritoryType);
                if (memoryTerritory == null)
                {
                    _logger.LogWarning("Discarding sync response for territory {Territory} as it isn't ready",
                        (ETerritoryType)queued.TerritoryType);
                    return;
                }

                try
                {
                    var remoteMarkers = queued.Locations;
                    if (_configuration.Mode == EMode.Online && queued.Success && remoteMarkers.Count > 0)
                    {
                        switch (queued.Type)
                        {
                            case SyncType.Download:
                            case SyncType.Upload:
                                List<PersistentLocation> newLocations = new();
                                foreach (var remoteMarker in remoteMarkers)
                                {
                                    // Both uploads and downloads return the network id to be set, but only the downloaded marker is new as in to-be-saved.
                                    PersistentLocation? localLocation =
                                        memoryTerritory.Locations.SingleOrDefault(x => x == remoteMarker);
                                    if (localLocation != null)
                                    {
                                        localLocation.NetworkId = remoteMarker.NetworkId;
                                        continue;
                                    }

                                    if (queued.Type == SyncType.Download)
                                    {
                                        memoryTerritory.Locations.Add(remoteMarker);
                                        newLocations.Add(remoteMarker);
                                    }
                                }

                                if (newLocations.Count > 0)
                                    new SaveNewLocations(_serviceScopeFactory, memoryTerritory, newLocations).Start();

                                break;

                            case SyncType.MarkSeen:
                                var partialAccountId =
                                    _configuration.FindAccount(RemoteApi.RemoteUrl)?.AccountId.ToPartialId();
                                if (partialAccountId == null)
                                    break;

                                List<PersistentLocation> locationsToUpdate = new();
                                foreach (var remoteMarker in remoteMarkers)
                                {
                                    PersistentLocation? localLocation =
                                        memoryTerritory.Locations.SingleOrDefault(x => x == remoteMarker);
                                    if (localLocation != null)
                                    {
                                        localLocation.RemoteSeenOn.Add(partialAccountId);
                                        locationsToUpdate.Add(localLocation);
                                    }
                                }

                                if (locationsToUpdate.Count > 0)
                                {
                                    new MarkRemoteSeen(_serviceScopeFactory, memoryTerritory, locationsToUpdate,
                                        partialAccountId).Start();
                                }

                                break;
                        }
                    }

                    // don't modify state for outdated floors
                    if (_territoryState.LastTerritory != queued.TerritoryType)
                        return;

                    if (queued.Type == SyncType.Download)
                    {
                        if (queued.Success)
                            memoryTerritory.SyncState = ESyncState.Complete;
                        else
                            memoryTerritory.SyncState = ESyncState.Failed;
                    }
                }
                catch (Exception e)
                {
                    _logger.LogError(e, "Sync failed for territory {Territory}", (ETerritoryType)queued.TerritoryType);
                    _debugState.SetFromException(e);
                    if (queued.Type == SyncType.Download)
                        memoryTerritory.SyncState = ESyncState.Failed;
                }
            }
        }
    }

    public enum ESyncState
    {
        NotAttempted,
        NotNeeded,
        Started,
        Complete,
        Failed,
    }

    public enum SyncType
    {
        Upload,
        Download,
        MarkSeen,
    }
}