RpgRoller/RpgRoller/Services/GameCharacterService.cs

using RpgRoller.Contracts;
using RpgRoller.Domain;

namespace RpgRoller.Services;

public sealed class GameCharacterService
{
    public GameCharacterService(GameStateStore stateStore, GamePersistenceService persistenceService)
    {
        m_StateStore = stateStore;
        m_PersistenceService = persistenceService;
    }

    public ServiceResult<CharacterSummary> CreateCharacter(string sessionToken, string name, Guid campaignId)
    {
        if (string.IsNullOrWhiteSpace(name))
            return ServiceResult<CharacterSummary>.Failure("invalid_character_name", "Character name is required.");

        lock (m_StateStore.Gate)
        {
            var user = ResolveUserLocked(sessionToken);
            if (user is null)
                return ServiceResult<CharacterSummary>.Failure("unauthorized", "You must be logged in.");

            if (!m_StateStore.CampaignsById.ContainsKey(campaignId))
                return ServiceResult<CharacterSummary>.Failure("campaign_not_found", "Campaign was not found.");

            var character = new Character
            {
                Id = Guid.NewGuid(),
                OwnerUserId = user.Id,
                CampaignId = campaignId,
                Name = name.Trim()
            };

            m_StateStore.CharactersById[character.Id] = character;
            AddCharacterStateLocked(character.CampaignId, character.Id);
            TouchRosterLocked(character.CampaignId);

            m_PersistenceService.PersistStateLocked();
            return ServiceResult<CharacterSummary>.Success(ToCharacterSummary(character));
        }
    }

    public ServiceResult<CharacterSummary> UpdateCharacter(string sessionToken, Guid characterId, string name, Guid? campaignId, string? ownerUsername = null)
    {
        if (string.IsNullOrWhiteSpace(name))
            return ServiceResult<CharacterSummary>.Failure("invalid_character_name", "Character name is required.");

        lock (m_StateStore.Gate)
        {
            var user = ResolveUserLocked(sessionToken);
            if (user is null)
                return ServiceResult<CharacterSummary>.Failure("unauthorized", "You must be logged in.");

            if (!m_StateStore.CharactersById.TryGetValue(characterId, out var character))
                return ServiceResult<CharacterSummary>.Failure("character_not_found", "Character was not found.");

            Campaign? targetCampaign = null;
            if (campaignId.HasValue && !m_StateStore.CampaignsById.TryGetValue(campaignId.Value, out targetCampaign))
                return ServiceResult<CharacterSummary>.Failure("campaign_not_found", "Campaign was not found.");

            var isOwner = character.OwnerUserId == user.Id;
            var isAdmin = RoleSerializer.HasRole(user.Roles, UserRoles.Admin);
            var isSourceGm = character.CampaignId.HasValue &&
                             m_StateStore.CampaignsById.TryGetValue(character.CampaignId.Value, out var sourceCampaign) &&
                             sourceCampaign.GmUserId == user.Id;
            var isTargetGm = targetCampaign is not null && targetCampaign.GmUserId == user.Id;
            if (!isOwner && !isAdmin && !isSourceGm && !isTargetGm)
                return ServiceResult<CharacterSummary>.Failure("forbidden", "Only the owner, GM, or admin can edit this character.");

            var sourceCampaignId = character.CampaignId;
            var previousOwnerUserId = character.OwnerUserId;
            character.Name = name.Trim();
            character.CampaignId = campaignId;

            if (!string.IsNullOrWhiteSpace(ownerUsername))
            {
                var trimmedOwnerUsername = ownerUsername.Trim();
                var normalizedOwnerUsername = NormalizeUsername(trimmedOwnerUsername);
                if (!m_StateStore.UserIdsByUsername.TryGetValue(normalizedOwnerUsername, out var targetOwnerUserId))
                    return ServiceResult<CharacterSummary>.Failure("owner_not_found", "Owner username was not found.");

                if (targetOwnerUserId != character.OwnerUserId && !isAdmin && !isSourceGm && !isTargetGm)
                    return ServiceResult<CharacterSummary>.Failure("forbidden", "Only the GM or admin can change character owner.");

                character.OwnerUserId = targetOwnerUserId;
                if (character.OwnerUserId != previousOwnerUserId &&
                    m_StateStore.UsersById.TryGetValue(previousOwnerUserId, out var previousOwner) &&
                    previousOwner.ActiveCharacterId == character.Id)
                {
                    previousOwner.ActiveCharacterId = null;
                }
            }

            if (sourceCampaignId != character.CampaignId)
            {
                RemoveCharacterStateLocked(sourceCampaignId, character.Id);
                AddCharacterStateLocked(character.CampaignId, character.Id);
            }

            TouchRosterLocked(sourceCampaignId);
            if (sourceCampaignId != character.CampaignId)
                TouchRosterLocked(character.CampaignId);

            m_PersistenceService.PersistStateLocked();
            return ServiceResult<CharacterSummary>.Success(ToCharacterSummary(character));
        }
    }

    public ServiceResult<bool> DeleteCharacter(string sessionToken, Guid characterId)
    {
        lock (m_StateStore.Gate)
        {
            var user = ResolveUserLocked(sessionToken);
            if (user is null)
                return ServiceResult<bool>.Failure("unauthorized", "You must be logged in.");

            if (!m_StateStore.CharactersById.TryGetValue(characterId, out var character))
                return ServiceResult<bool>.Failure("character_not_found", "Character was not found.");

            var isOwner = character.OwnerUserId == user.Id;
            var isAdmin = RoleSerializer.HasRole(user.Roles, UserRoles.Admin);
            if (!isOwner && !isAdmin)
                return ServiceResult<bool>.Failure("forbidden", "Only the owner or admin can delete this character.");

            DeleteCharacterLocked(characterId);
            m_PersistenceService.PersistStateLocked();
            return ServiceResult<bool>.Success(true);
        }
    }

    public ServiceResult<bool> ActivateCharacter(string sessionToken, Guid characterId)
    {
        lock (m_StateStore.Gate)
        {
            var user = ResolveUserLocked(sessionToken);
            if (user is null)
                return ServiceResult<bool>.Failure("unauthorized", "You must be logged in.");

            if (!m_StateStore.CharactersById.TryGetValue(characterId, out var character))
                return ServiceResult<bool>.Failure("character_not_found", "Character was not found.");

            if (character.OwnerUserId != user.Id)
                return ServiceResult<bool>.Failure("forbidden", "You can activate only your own character.");

            user.ActiveCharacterId = character.Id;
            m_PersistenceService.PersistStateLocked();
            return ServiceResult<bool>.Success(true);
        }
    }

    public ServiceResult<IReadOnlyList<CharacterSummary>> GetOwnCharacters(string sessionToken)
    {
        lock (m_StateStore.Gate)
        {
            var user = ResolveUserLocked(sessionToken);
            if (user is null)
                return ServiceResult<IReadOnlyList<CharacterSummary>>.Failure("unauthorized", "You must be logged in.");

            var characters = m_StateStore.CharactersById.Values
                .Where(character => character.OwnerUserId == user.Id)
                .OrderBy(character => character.Name, StringComparer.OrdinalIgnoreCase)
                .Select(ToCharacterSummary)
                .ToArray();

            return ServiceResult<IReadOnlyList<CharacterSummary>>.Success(characters);
        }
    }

    private UserAccount? ResolveUserLocked(string sessionToken)
    {
        if (string.IsNullOrWhiteSpace(sessionToken))
            return null;

        if (!m_StateStore.SessionsByToken.TryGetValue(sessionToken, out var session))
            return null;

        return m_StateStore.UsersById.GetValueOrDefault(session.UserId);
    }

    private void AddCharacterStateLocked(Guid? campaignId, Guid characterId)
    {
        if (!campaignId.HasValue || !m_StateStore.CampaignsById.ContainsKey(campaignId.Value))
            return;

        var state = GetOrCreateCampaignStateLocked(campaignId.Value);
        state.CharacterVersions[characterId] = 1;
    }

    private void RemoveCharacterStateLocked(Guid? campaignId, Guid characterId)
    {
        if (!campaignId.HasValue || !m_StateStore.CampaignStateById.TryGetValue(campaignId.Value, out var state))
            return;

        state.CharacterVersions.Remove(characterId);
    }

    private void TouchRosterLocked(Guid? campaignId)
    {
        if (!campaignId.HasValue || !m_StateStore.CampaignsById.ContainsKey(campaignId.Value))
            return;

        var state = GetOrCreateCampaignStateLocked(campaignId.Value);
        state.TotalVersion += 1;
        state.RosterVersion += 1;
    }

    private GameCampaignStateTracker GetOrCreateCampaignStateLocked(Guid campaignId)
    {
        if (!m_StateStore.CampaignStateById.TryGetValue(campaignId, out var state))
        {
            state = new GameCampaignStateTracker();
            m_StateStore.CampaignStateById[campaignId] = state;
        }

        return state;
    }

    private void DeleteCharacterLocked(Guid characterId)
    {
        if (!m_StateStore.CharactersById.TryGetValue(characterId, out var character))
            return;

        var campaignId = character.CampaignId;
        m_StateStore.CharactersById.Remove(characterId);

        var skillGroupIds = m_StateStore.SkillGroupsById.Values.Where(group => group.CharacterId == characterId).Select(group => group.Id).ToHashSet();
        foreach (var skillGroupId in skillGroupIds)
            m_StateStore.SkillGroupsById.Remove(skillGroupId);

        var skillIds = m_StateStore.SkillsById.Values.Where(skill => skill.CharacterId == characterId).Select(skill => skill.Id).ToHashSet();
        foreach (var skillId in skillIds)
            m_StateStore.SkillsById.Remove(skillId);

        m_StateStore.RollLog.RemoveAll(entry => entry.CharacterId == characterId || skillIds.Contains(entry.SkillId));

        foreach (var user in m_StateStore.UsersById.Values.Where(account => account.ActiveCharacterId == characterId))
            user.ActiveCharacterId = null;

        RemoveCharacterStateLocked(campaignId, characterId);
        TouchRosterLocked(campaignId);
    }

    private CharacterSummary ToCharacterSummary(Character character)
    {
        return new(character.Id, character.Name, character.OwnerUserId, character.CampaignId, ResolveOwnerDisplayName(character.OwnerUserId));
    }

    private string ResolveOwnerDisplayName(Guid ownerUserId)
    {
        return m_StateStore.UsersById.TryGetValue(ownerUserId, out var user)
            ? user.DisplayName
            : "Unknown user";
    }

    private static string NormalizeUsername(string username)
    {
        return username.ToUpperInvariant();
    }

    private readonly GamePersistenceService m_PersistenceService;
    private readonly GameStateStore m_StateStore;
}