lct2025-lonolith/LctMonolith/Services/RankService.cs

using LctMonolith.Database.UnitOfWork;
using LctMonolith.Models.Database;
using LctMonolith.Services.Interfaces;
using Microsoft.EntityFrameworkCore;
using Serilog;

namespace LctMonolith.Services;

public class RankService : IRankService
{
    private readonly IUnitOfWork _uow;

    public RankService(IUnitOfWork uow)
    {
        _uow = uow;
    }

    public async Task<Rank?> GetRankByIdAsync(Guid rankId)
    {
        try
        {
            return await _uow.Ranks.GetByIdAsync(rankId);
        }
        catch (Exception ex)
        {
            Log.Error(ex, "GetRankByIdAsync failed {RankId}", rankId);
            throw;
        }
    }

    public async Task<Rank?> GetRankByTitleAsync(string title)
    {
        try
        {
            return await _uow.Ranks.Query(r => r.Title == title).FirstOrDefaultAsync();
        }
        catch (Exception ex)
        {
            Log.Error(ex, "GetRankByTitleAsync failed {Title}", title);
            throw;
        }
    }

    public async Task<IEnumerable<Rank>> GetAllRanksAsync()
    {
        try
        {
            return await _uow.Ranks.Query().OrderBy(r => r.ExpNeeded).ToListAsync();
        }
        catch (Exception ex)
        {
            Log.Error(ex, "GetAllRanksAsync failed");
            throw;
        }
    }

    public async Task<Rank> CreateRankAsync(Rank rank)
    {
        try
        {
            rank.Id = Guid.NewGuid();
            await _uow.Ranks.AddAsync(rank);
            await _uow.SaveChangesAsync();
            return rank;
        }
        catch (Exception ex)
        {
            Log.Error(ex, "CreateRankAsync failed {Title}", rank.Title);
            throw;
        }
    }

    public async Task<Rank> UpdateRankAsync(Rank rank)
    {
        try
        {
            _uow.Ranks.Update(rank);
            await _uow.SaveChangesAsync();
            return rank;
        }
        catch (Exception ex)
        {
            Log.Error(ex, "UpdateRankAsync failed {RankId}", rank.Id);
            throw;
        }
    }

    public async Task<bool> DeleteRankAsync(Guid rankId)
    {
        try
        {
            var r = await _uow.Ranks.GetByIdAsync(rankId);
            if (r == null)
            {
                return false;
            }

            _uow.Ranks.Remove(r);
            await _uow.SaveChangesAsync();
            return true;
        }
        catch (Exception ex)
        {
            Log.Error(ex, "DeleteRankAsync failed {RankId}", rankId);
            throw;
        }
    }

    public async Task<bool> CanPlayerAdvanceToRankAsync(Guid playerId, Guid rankId)
    {
        try
        {
            var player = await _uow.Players.GetByIdAsync(playerId) ?? throw new KeyNotFoundException("Player not found");
            var rank = await _uow.Ranks.GetByIdAsync(rankId) ?? throw new KeyNotFoundException("Rank not found");
            if (player.Experience < rank.ExpNeeded)
            {
                return false;
            }

            var missionReqs = await _uow.RankMissionRules.Query(rmr => rmr.RankId == rankId).Select(r => r.MissionId).ToListAsync();
            if (missionReqs.Count > 0)
            {
                var completed = await _uow.PlayerMissions.Query(pm => pm.PlayerId == playerId && pm.Completed != null).Select(pm => pm.MissionId).ToListAsync();
                if (missionReqs.Except(completed).Any())
                {
                    return false;
                }
            }

            var skillReqs = await _uow.RankSkillRules.Query(rsr => rsr.RankId == rankId).ToListAsync();
            if (skillReqs.Count > 0)
            {
                var playerSkills = await _uow.PlayerSkills.Query(ps => ps.PlayerId == playerId).ToListAsync();
                foreach (var req in skillReqs)
                {
                    var ps = playerSkills.FirstOrDefault(s => s.SkillId == req.SkillId);
                    if (ps == null || ps.Score < req.Min)
                    {
                        return false;
                    }
                }
            }

            return true;
        }
        catch (Exception ex)
        {
            Log.Error(ex, "CanPlayerAdvanceToRankAsync failed {PlayerId}->{RankId}", playerId, rankId);
            throw;
        }
    }

    public async Task<Rank?> GetNextRankAsync(Guid currentRankId)
    {
        try
        {
            var current = await _uow.Ranks.GetByIdAsync(currentRankId);
            if (current == null)
            {
                return null;
            }

            return await _uow.Ranks.Query(r => r.ExpNeeded > current.ExpNeeded).OrderBy(r => r.ExpNeeded).FirstOrDefaultAsync();
        }
        catch (Exception ex)
        {
            Log.Error(ex, "GetNextRankAsync failed {RankId}", currentRankId);
            throw;
        }
    }
}