LightlessClient/LightlessSync/PlayerData/Pairs/Pair.cs

using Dalamud.Game.Gui.ContextMenu;
using Dalamud.Game.Text.SeStringHandling;
using LightlessSync.API.Data;
using LightlessSync.API.Data.Enum;
using LightlessSync.API.Data.Extensions;
using LightlessSync.API.Dto.User;
using LightlessSync.Services.Mediator;
using LightlessSync.Services.ServerConfiguration;
using LightlessSync.UI;
using LightlessSync.WebAPI;
using Microsoft.Extensions.Logging;

namespace LightlessSync.PlayerData.Pairs;

/// <summary>
///     ui wrapper around a pair connection
/// </summary>
public class Pair
{
    private readonly PairLedger _pairLedger;
    private readonly ILogger<Pair> _logger;
    private readonly LightlessMediator _mediator;
    private readonly ServerConfigurationManager _serverConfigurationManager;
    private readonly Lazy<ApiController> _apiController;

    private const int _lightlessPrefixColor = 708;

    public Pair(
        ILogger<Pair> logger,
        UserFullPairDto userPair,
        PairLedger pairLedger,
        LightlessMediator mediator,
        ServerConfigurationManager serverConfigurationManager,
        Lazy<ApiController> apiController)
    {
        _logger = logger;
        UserPair = userPair;
        _pairLedger = pairLedger;
        _mediator = mediator;
        _serverConfigurationManager = serverConfigurationManager;
        _apiController = apiController;
    }

    private PairUniqueIdentifier PairIdent => UniqueIdent;

    private IPairHandlerAdapter? TryGetHandler()
    {
        return _pairLedger.GetHandler(PairIdent);
    }

    private PairConnection? TryGetConnection()
    {
        return _pairLedger.TryGetEntry(PairIdent, out var entry) && entry is not null
            ? entry.Connection
            : null;
    }

    public bool HasCachedPlayer => TryGetHandler() is not null;
    public IndividualPairStatus IndividualPairStatus => UserPair.IndividualPairStatus;
    public bool IsDirectlyPaired => IndividualPairStatus != IndividualPairStatus.None;
    public bool IsOneSidedPair => IndividualPairStatus == IndividualPairStatus.OneSided;

    public bool IsOnline => TryGetConnection()?.IsOnline ?? false;

    public bool IsPaired => IndividualPairStatus == IndividualPairStatus.Bidirectional || UserPair.Groups.Any();
    public bool IsPaused => UserPair.OwnPermissions.IsPaused();
    public bool IsVisible => _pairLedger.IsPairVisible(PairIdent);
    public CharacterData? LastReceivedCharacterData => TryGetHandler()?.LastReceivedCharacterData;
    public string? PlayerName => TryGetHandler()?.PlayerName ?? UserPair.User.AliasOrUID;
    public long LastAppliedDataBytes => TryGetHandler()?.LastAppliedDataBytes ?? -1;
    public long LastAppliedDataTris => TryGetHandler()?.LastAppliedDataTris ?? -1;
    public long LastAppliedApproximateEffectiveTris => TryGetHandler()?.LastAppliedApproximateEffectiveTris ?? -1;
    public long LastAppliedApproximateVRAMBytes => TryGetHandler()?.LastAppliedApproximateVRAMBytes ?? -1;
    public long LastAppliedApproximateEffectiveVRAMBytes => TryGetHandler()?.LastAppliedApproximateEffectiveVRAMBytes ?? -1;
    public string Ident => TryGetHandler()?.Ident ?? TryGetConnection()?.Ident ?? string.Empty;
    public uint PlayerCharacterId => TryGetHandler()?.PlayerCharacterId ?? uint.MaxValue;
    public PairUniqueIdentifier UniqueIdent => new(UserData.UID);

    public UserData UserData => UserPair.User;

    public UserFullPairDto UserPair { get; set; }

    public void AddContextMenu(IMenuOpenedArgs args)
    {

        var handler = TryGetHandler();
        if (handler is null)
            return;

        if (args.Target is not MenuTargetDefault target)
            return;

        var obj = target.TargetObject;
        if (obj is null)
            return;

        var eid = obj.EntityId;

        var isPlayerTarget = eid != 0 && eid != uint.MaxValue && eid == handler.PlayerCharacterId;

        if (!(isPlayerTarget))
            return;

        if (isPlayerTarget)
        {
            if (!IsPaused)
            {
                UiSharedService.AddContextMenuItem(
                    args,
                    name: "Open Profile",
                    prefixChar: 'L',
                    colorMenuItem: _lightlessPrefixColor,
                    onClick: () =>
                    {
                        _mediator.Publish(new ProfileOpenStandaloneMessage(this));
                        return Task.CompletedTask;
                    });

                UiSharedService.AddContextMenuItem(
                    args,
                    name: "(Soft) - Reapply last data",
                    prefixChar: 'L',
                    colorMenuItem: _lightlessPrefixColor,
                    onClick: () =>
                    {
                        ApplyLastReceivedData(forced: true);
                        return Task.CompletedTask;
                    });

                UiSharedService.AddContextMenuItem(
                    args,
                    name: "(Hard) - Reapply last data",
                    prefixChar: 'L',
                    colorMenuItem: _lightlessPrefixColor,
                    onClick: () =>
                    {
                        HardApplyLastReceivedData();
                        return Task.CompletedTask;
                    });
            }

            UiSharedService.AddContextMenuItem(
                args,
                name: "Change Permissions",
                prefixChar: 'L',
                colorMenuItem: _lightlessPrefixColor,
                onClick: () =>
                {
                    _mediator.Publish(new OpenPermissionWindow(this));
                    return Task.CompletedTask;
                });

            if (IsPaused)
            {
                UiSharedService.AddContextMenuItem(
                    args,
                    name: "Toggle Unpause State",
                    prefixChar: 'L',
                    colorMenuItem: _lightlessPrefixColor,
                    onClick: () =>
                    {
                        _ = _apiController.Value.UnpauseAsync(UserData);
                        return Task.CompletedTask;
                    });
            }
            else
            {
                UiSharedService.AddContextMenuItem(
                    args,
                    name: "Toggle Pause State",
                    prefixChar: 'L',
                    colorMenuItem: _lightlessPrefixColor,
                    onClick: () =>
                    {
                        _ = _apiController.Value.PauseAsync(UserData);
                        return Task.CompletedTask;
                    });
            }

            UiSharedService.AddContextMenuItem(
                args,
                name: "Cycle Pause State",
                prefixChar: 'L',
                colorMenuItem: _lightlessPrefixColor,
                onClick: () =>
                {
                    TriggerCyclePause();
                    return Task.CompletedTask;
                });

            return;
        }
    }

    public void ApplyData(OnlineUserCharaDataDto data)
    {
        _logger.LogTrace("Character data received for {Uid}; handler will process via registry.", UserData.UID);
    }

    private void TriggerCyclePause()
    {
        _ = _apiController.Value.CyclePauseAsync(this);
    }

    public void ApplyLastReceivedData(bool forced = false)
    {
        var handler = TryGetHandler();
        if (handler is null)
        {
            _logger.LogTrace("ApplyLastReceivedData skipped for {Uid}: handler missing.", UserData.UID);
            return;
        }

        handler.ApplyLastReceivedData(forced);
    }

    public void HardApplyLastReceivedData()
    {
        var handler = TryGetHandler();
        if (handler is null)
        {
            _logger.LogTrace("ApplyLastReceivedData skipped for {Uid}: handler missing.", UserData.UID);
            return;
        }

        handler.HardReapplyLastData();
    }

    public void CreateCachedPlayer(OnlineUserIdentDto? dto = null)
    {
        var handler = TryGetHandler();
        if (handler is null)
        {
            _logger.LogTrace("CreateCachedPlayer skipped for {Uid}: handler unavailable.", UserData.UID);
            return;
        }

        if (!handler.Initialized)
        {
            handler.Initialize();
        }
    }

    public string? GetNote()
    {
        return _serverConfigurationManager.GetNoteForUid(UserData.UID);
    }

    public string GetPlayerNameHash()
    {
        return TryGetHandler()?.PlayerNameHash ?? string.Empty;
    }

    public bool HasAnyConnection()
    {
        return UserPair.Groups.Any() || UserPair.IndividualPairStatus != IndividualPairStatus.None;
    }

    public void MarkOffline(bool wait = true)
    {
        _logger.LogTrace("MarkOffline invoked for {Uid} (wait: {Wait}). New registry handles handler disposal.", UserData.UID, wait);
    }

    public void SetNote(string note)
    {
        _serverConfigurationManager.SetNoteForUid(UserData.UID, note);
    }

    internal void SetIsUploading()
    {
        var handler = TryGetHandler();
        if (handler is null)
        {
            return;
        }

        handler.SetUploading(true);
    }

    public PairDebugInfo GetDebugInfo()
    {
        var handler = TryGetHandler();
        if (handler is null)
            return PairDebugInfo.Empty;

        var now = DateTime.UtcNow;
        var dueAt = handler.VisibilityEvictionDueAtUtc;
        var remainingSeconds = dueAt.HasValue
            ? Math.Max(0, (dueAt.Value - now).TotalSeconds)
            : (double?)null;

        return new PairDebugInfo(
            true,
            handler.Initialized,
            handler.IsVisible,
            handler.ScheduledForDeletion,
            handler.LastDataReceivedAt,
            handler.LastApplyAttemptAt,
            handler.LastSuccessfulApplyAt,
            handler.InvisibleSinceUtc,
            handler.VisibilityEvictionDueAtUtc,
            remainingSeconds,
            handler.LastFailureReason,
            handler.LastBlockingConditions,
            handler.IsApplying,
            handler.IsDownloading,
            handler.PendingDownloadCount,
            handler.ForbiddenDownloadCount,
            handler.PendingModReapply,
            handler.ModApplyDeferred,
            handler.MissingCriticalMods,
            handler.MissingNonCriticalMods,
            handler.MissingForbiddenMods,

            handler.MinionAddressHex,
            handler.MinionObjectIndex,
            handler.MinionResolvedAtUtc,
            handler.MinionResolveStage,
            handler.MinionResolveFailureReason,
            handler.MinionPendingRetry,
            handler.MinionPendingRetryChanges,
            handler.MinionHasAppearanceData,
            handler.OwnedPenumbraCollectionId,
            handler.NeedsCollectionRebuildDebug);
    }
}