LightlessClient/LightlessSync/PlayerData/Pairs/PairState.cs

using System;
using System.Collections.Generic;
using LightlessSync.API.Data;
using LightlessSync.API.Data.Enum;
using LightlessSync.API.Data.Extensions;
using LightlessSync.API.Dto.Group;

namespace LightlessSync.PlayerData.Pairs;

public readonly struct PairOperationResult
{
    private PairOperationResult(bool success, string? error)
    {
        Success = success;
        Error = error;
    }

    public bool Success { get; }
    public string? Error { get; }

    public static PairOperationResult Ok() => new(true, null);

    public static PairOperationResult Fail(string error) => new(false, error);
}

public readonly struct PairOperationResult<T>
{
    private PairOperationResult(bool success, T value, string? error)
    {
        Success = success;
        Value = value;
        Error = error;
    }

    public bool Success { get; }
    public T Value { get; }
    public string? Error { get; }

    public static PairOperationResult<T> Ok(T value) => new(true, value, null);

    public static PairOperationResult<T> Fail(string error) => new(false, default!, error);
}

public sealed record PairRegistration(PairUniqueIdentifier PairIdent, string? CharacterIdent);

public sealed class GroupPairRelationship
{
    public GroupPairRelationship(string groupId, GroupPairUserInfo? info)
    {
        GroupId = groupId;
        UserInfo = info;
    }

    public string GroupId { get; }
    public GroupPairUserInfo? UserInfo { get; private set; }

    public void SetUserInfo(GroupPairUserInfo? info)
    {
        UserInfo = info;
    }
}

public sealed class PairConnection
{
    public PairConnection(UserData user)
    {
        User = user;
        Groups = new Dictionary<string, GroupPairRelationship>(StringComparer.Ordinal);
    }

    public UserData User { get; }
    public bool IsOnline { get; private set; }
    public string? Ident { get; private set; }
    public UserPermissions SelfToOtherPermissions { get; private set; } = UserPermissions.NoneSet;
    public UserPermissions OtherToSelfPermissions { get; private set; } = UserPermissions.NoneSet;
    public IndividualPairStatus? IndividualPairStatus { get; private set; }
    public Dictionary<string, GroupPairRelationship> Groups { get; }

    public bool IsPaused => SelfToOtherPermissions.IsPaused();
    public bool IsDirectlyPaired => IndividualPairStatus is not null && IndividualPairStatus != API.Data.Enum.IndividualPairStatus.None;
    public bool IsOneSided => IndividualPairStatus == API.Data.Enum.IndividualPairStatus.OneSided;
    public bool HasAnyConnection => IsDirectlyPaired || Groups.Count > 0;

    public void SetOnline(string? ident)
    {
        IsOnline = true;
        Ident = ident;
    }

    public void SetOffline()
    {
        IsOnline = false;
    }

    public void UpdatePermissions(UserPermissions own, UserPermissions other)
    {
        SelfToOtherPermissions = own;
        OtherToSelfPermissions = other;
    }

    public void UpdateStatus(IndividualPairStatus? status)
    {
        IndividualPairStatus = status;
    }

    public void EnsureGroupRelationship(string groupId, GroupPairUserInfo? info)
    {
        if (Groups.TryGetValue(groupId, out var relationship))
        {
            relationship.SetUserInfo(info);
        }
        else
        {
            Groups[groupId] = new GroupPairRelationship(groupId, info);
        }
    }

    public void RemoveGroupRelationship(string groupId)
    {
        Groups.Remove(groupId);
    }
}

public sealed class Syncshell
{
    public Syncshell(GroupFullInfoDto dto)
    {
        GroupFullInfo = dto;
        Users = new Dictionary<string, PairConnection>(StringComparer.Ordinal);
    }

    public GroupFullInfoDto GroupFullInfo { get; private set; }
    public Dictionary<string, PairConnection> Users { get; }

    public void Update(GroupFullInfoDto dto)
    {
        GroupFullInfo = dto;
    }
}

public sealed class PairState
{
    public CharacterData? CharacterData { get; set; }
    public Guid? TemporaryCollectionId { get; set; }

    public bool IsEmpty => CharacterData is null && (TemporaryCollectionId is null || TemporaryCollectionId == Guid.Empty);
}

public readonly record struct PairUniqueIdentifier(string UserId);