feat(bests): Add support for collaborative charts and theoretical score processing

- Add DfGatewayService and LxnsGatewayService for unified handling of external API calls
- Add ServiceExecutionHelper to provide common utility methods (parameter validation, HTTP status mapping, etc.)
- Refactor BestsService and add ProcessBestsByTagsAsync method to support collaborative chart processing
- Implement collaborative chart score calculation logic in DfBestsService and LxnsBestsService
- Add theoretical score (riren) generation feature for displaying theoretical maximum scores
- Refactor list service and extract BuildListRecords method to reuse record filtering logic
- Optimize list statistics counting implementation, using arrays and Interlocked for improved performance

Author: Yushu2606

src/Services/BestsService.cs

@@ -1,5 +1,7 @@
+using Grpc.Core;
 using Limekuma.Prober.Common;
 using Limekuma.Utils;
+using System.Collections.Immutable;
 
 namespace Limekuma.Services;
 
@@ -12,4 +14,41 @@ private static async Task PrepareDataAsync(CommonUser user, IReadOnlyList<Common
         await ServiceHelper.PrepareRecordDataAsync(bestsEver);
         await ServiceHelper.PrepareRecordDataAsync(bestsCurrent);
     }
-}
+
+    private static async Task<(ImmutableArray<CommonRecord> BestEver, ImmutableArray<CommonRecord> BestCurrent, int EverTotal, int CurrentTotal, CommonUser?)>
+        ProcessBestsByTagsAsync(
+            IReadOnlyList<string> tags,
+            string condition,
+            ImmutableArray<CommonRecord> records,
+            Func<string, Task<(CommonUser, ImmutableArray<CommonRecord>)>> secondDataProvider)
+    {
+        if (ScoreProcesserHelper.GetProcesserByTags(tags) is not { } selectedProcesser)
+        {
+            throw new RpcException(new(StatusCode.InvalidArgument, "Invalid arguments"));
+        }
+
+        CommonUser? user2p = null;
+        bool mayMask = ServiceExecutionHelper.HasMaskedScores(records);
+        ServiceExecutionHelper.EnsurePermission(!(mayMask && selectedProcesser.MaskMutex), "Mask enabled");
+
+        ImmutableArray<CommonRecord> bestEver;
+        ImmutableArray<CommonRecord> bestCurrent;
+        if (selectedProcesser.RequireSecondData)
+        {
+            (user2p, ImmutableArray<CommonRecord> records2p) = await secondDataProvider(condition);
+            (bestEver, bestCurrent) = selectedProcesser.Processer.Process(records, records2p);
+        }
+        else
+        {
+            (Func<CommonRecord, bool> predicate, bool maskMutex) = ScoreFilterHelper.GetPredicateByTags(tags, condition);
+            ServiceExecutionHelper.EnsurePermission(!(mayMask && maskMutex), "Mask enabled");
+
+            ImmutableArray<CommonRecord> filteredRecords = [.. records.Where(predicate).SortRecordForBests()];
+            (bestEver, bestCurrent) = selectedProcesser.Processer.Process(filteredRecords);
+        }
+
+        int everTotal = bestEver.Sum(x => x.DXRating);
+        int currentTotal = bestCurrent.Sum(x => x.DXRating);
+        return (bestEver, bestCurrent, everTotal, currentTotal, user2p);
+    }
+}

src/Services/DfBestsService.cs

@@ -1,39 +1,39 @@
 using Grpc.Core;
 using Limekuma.Prober.Common;
-using Limekuma.Prober.DivingFish;
+using Limekuma.Prober.DivingFish.Enums;
 using Limekuma.Prober.DivingFish.Models;
 using Limekuma.Render;
 using Limekuma.Utils;
 using SixLabors.ImageSharp;
 using System.Collections.Immutable;
-using System.Net;
+using System.Text.Json.Serialization;
 
 namespace Limekuma.Services;
 
 public partial class BestsService
 {
+    private static async Task<(CommonUser, ImmutableArray<CommonRecord>)> PrepareDfRecordsForProcessAsync(string token, uint? qq, int? frame, int? plate, int? icon)
+    {
+        ServiceExecutionHelper.EnsureArgument(qq.HasValue && frame.HasValue && plate.HasValue && icon.HasValue);
+        PlayerData player = await DfGatewayService.GetPlayerDataAsync(token, qq!.Value);
+
+        CommonUser user = player;
+        user.FrameId = frame!.Value;
+        user.PlateId = plate!.Value;
+        user.IconId = icon!.Value;
+        return (user, [.. player.Records.ConvertAll<CommonRecord>(_ => _)]);
+    }
+
     private static async Task<(CommonUser, ImmutableArray<CommonRecord>, ImmutableArray<CommonRecord>, int, int)> PrepareDfDataAsync(
-        uint qq, int frame, int plate, int icon)
+        uint? qq, int? frame, int? plate, int? icon)
     {
-        DfResourceClient df = new();
-        Player player;
-        try
-        {
-            player = await df.GetPlayerAsync(qq);
-        }
-        catch (HttpRequestException ex) when (ex.StatusCode is HttpStatusCode.BadRequest)
-        {
-            throw new RpcException(new(StatusCode.NotFound, ex.Message, ex));
-        }
-        catch (HttpRequestException ex) when (ex.StatusCode is HttpStatusCode.Forbidden)
-        {
-            throw new RpcException(new(StatusCode.PermissionDenied, ex.Message, ex));
-        }
+        ServiceExecutionHelper.EnsureArgument(qq.HasValue && frame.HasValue && plate.HasValue && icon.HasValue);
+        Player player = await DfGatewayService.GetPlayerAsync(qq!.Value);
 
         CommonUser user = player;
-        user.FrameId = frame;
-        user.PlateId = plate;
-        user.IconId = icon;
+        user.FrameId = frame!.Value;
+        user.PlateId = plate!.Value;
+        user.IconId = icon!.Value;
 
         ImmutableArray<CommonRecord> bestEver = [.. player.Bests.Ever.ConvertAll<CommonRecord>(_ => _).SortRecordForBests()];
         int everTotal = bestEver.Sum(x => x.DXRating);
@@ -46,14 +46,100 @@ public partial class BestsService
         return (user, bestEver, bestCurrent, everTotal, currentTotal);
     }
 
+    private static async Task<(CommonUser, ImmutableArray<CommonRecord>, ImmutableArray<CommonRecord>, int, int)> PrepareRiRenDfDataAsync()
+    {
+        List<CommonRecord> allRecords = [];
+        foreach (Song song in Songs.Shared)
+        {
+            if (!int.TryParse(song.Id, out int id))
+            {
+                continue;
+            }
+
+            int chartCount = Math.Min(song.Charts.Count, Math.Min(song.LevelValues.Count, song.Levels.Count));
+            for (int i = 0; i < chartCount; i++)
+            {
+                allRecords.Add(new Record()
+                {
+                    Achievements = 101,
+                    ComboFlag = ComboFlags.AllPerfectPlus,
+                    Difficulty = song.Type is SongTypes.Utage ? Difficulties.Utage : (Difficulties)(i + 1),
+                    DifficultyIndex = i,
+                    DXRating = (int)(song.LevelValues[i] * 22.512),
+                    DXScore = song.Charts[i].Notes.Total * 3,
+                    Id = id,
+                    Level = song.Levels[i],
+                    LevelValue = song.LevelValues[i],
+                    Rank = Ranks.SSSPlus,
+                    SyncFlag = SyncFlags.FullSyncDXPlus,
+                    Title = song.Title,
+                    Type = song.Type
+                });
+            }
+        }
+
+        IEnumerable<CommonRecord> sortedRecords = allRecords.SortRecordForBests();
+        ImmutableArray<CommonRecord> bestEver = [.. sortedRecords.Where(record => !record.Chart.Song.InCurrentGenre).Take(35)];
+        ImmutableArray<CommonRecord> bestCurrent = [.. sortedRecords.Where(record => record.Chart.Song.InCurrentGenre).Take(15)];
+        int everTotal = bestEver.Sum(x => x.DXRating);
+        int currentTotal = bestCurrent.Sum(x => x.DXRating);
+        CommonUser user = new()
+        {
+            Name = "ＤＸＫｕｍａ",
+            Rating = everTotal + currentTotal,
+            TrophyColor = TrophyColor.Rainbow,
+            TrophyText = "でらっくま",
+            CourseRank = CommonCourseRank.Urakaiden,
+            ClassRank = ClassRank.LEGEND,
+            IconId = 1,
+            PlateId = 1,
+            FrameId = 1
+        };
+
+        await PrepareDataAsync(user, bestEver, bestCurrent);
+        return (user, bestEver, bestCurrent, everTotal, currentTotal);
+    }
+
     public override async Task GetFromDivingFish(DivingFishBestsRequest request,
         IServerStreamWriter<ImageResponse> responseStream, ServerCallContext context)
     {
-        (CommonUser user, ImmutableArray<CommonRecord> bestEver, ImmutableArray<CommonRecord> bestCurrent, int everTotal,
-            int currentTotal) = await PrepareDfDataAsync(request.Qq, request.Frame, request.Plate, request.Icon);
+        CommonUser user;
+        CommonUser? user2p = null;
+        ImmutableArray<CommonRecord> bestEver;
+        ImmutableArray<CommonRecord> bestCurrent;
+        int everTotal;
+        int currentTotal;
+        if (ScoreProcesserHelper.GetProcesserByTags(request.Tags) is not null)
+        {
+            (user, ImmutableArray<CommonRecord> records) = await PrepareDfRecordsForProcessAsync(request.Token, request.Qq, request.Frame, request.Plate, request.Icon);
+            (bestEver, bestCurrent, everTotal, currentTotal, user2p) = await ProcessBestsByTagsAsync(
+                request.Tags,
+                request.Condition,
+                records,
+                async condition =>
+                {
+                    CoopExtraInfo extraInfo = ServiceExecutionHelper.DeserializeOrThrow<CoopExtraInfo>(condition, "Invalid arguments");
+                    return await PrepareDfRecordsForProcessAsync(request.Token, extraInfo.Qq, extraInfo.Frame, extraInfo.Plate, extraInfo.Icon);
+                });
+        }
+        else if (request.Tags.Contains("common"))
+        {
+            (user, bestEver, bestCurrent, everTotal, currentTotal) = await PrepareDfDataAsync(request.Qq, request.Frame, request.Plate, request.Icon);
+        }
+        else if (request.Tags.Contains("riren"))
+        {
+            (user, bestEver, bestCurrent, everTotal, currentTotal) = await PrepareRiRenDfDataAsync();
+        }
+        else
+        {
+            throw new RpcException(new(StatusCode.InvalidArgument, "Invalid arguments"));
+        }
+
         using Image bestsImage = await new Drawer().DrawBestsAsync(user, bestEver, bestCurrent, everTotal, currentTotal,
-            request.Condition, "divingfish", request.Tags);
+            request.Condition, "divingfish", request.Tags, user2p);
 
         await responseStream.WriteToResponseAsync(bestsImage);
     }
-}
+
+    public record CoopExtraInfo([property: JsonPropertyName("qq")] uint Qq, [property: JsonPropertyName("frame")] int Frame, [property: JsonPropertyName("plate")] int Plate, [property: JsonPropertyName("icon")] int Icon);
+}

src/Services/DfGatewayService.cs

@@ -0,0 +1,27 @@
+using Grpc.Core;
+using Limekuma.Prober.DivingFish;
+using Limekuma.Prober.DivingFish.Models;
+using System.Net;
+
+namespace Limekuma.Services;
+
+internal static class DfGatewayService
+{
+    internal static Task<PlayerData> GetPlayerDataAsync(string token, uint qq)
+    {
+        DfDeveloperClient client = new(token);
+        return ServiceExecutionHelper.ExecuteWithHttpMappingAsync(
+            () => client.GetPlayerDataAsync(qq),
+            (HttpStatusCode.BadRequest, StatusCode.NotFound),
+            (HttpStatusCode.Forbidden, StatusCode.PermissionDenied));
+    }
+
+    internal static Task<Player> GetPlayerAsync(uint qq)
+    {
+        DfResourceClient client = new();
+        return ServiceExecutionHelper.ExecuteWithHttpMappingAsync(
+            () => client.GetPlayerAsync(qq),
+            (HttpStatusCode.BadRequest, StatusCode.NotFound),
+            (HttpStatusCode.Forbidden, StatusCode.PermissionDenied));
+    }
+}

src/Services/DfListService.cs

@@ -1,12 +1,10 @@
 using Grpc.Core;
 using Limekuma.Prober.Common;
-using Limekuma.Prober.DivingFish;
 using Limekuma.Prober.DivingFish.Models;
 using Limekuma.Render;
 using Limekuma.Utils;
 using SixLabors.ImageSharp;
 using System.Collections.Immutable;
-using System.Net;
 
 namespace Limekuma.Services;
 
@@ -15,38 +13,20 @@ public partial class ListService
     public override async Task GetFromDivingFish(DivingFishListRequest request,
         IServerStreamWriter<ImageResponse> responseStream, ServerCallContext context)
     {
-        DfDeveloperClient df = new(request.Token);
-        PlayerData player;
-        try
-        {
-            player = await df.GetPlayerDataAsync(request.Qq);
-        }
-        catch (HttpRequestException ex) when (ex.StatusCode is HttpStatusCode.BadRequest)
-        {
-            throw new RpcException(new(StatusCode.NotFound, ex.Message, ex));
-        }
-        catch (HttpRequestException ex) when (ex.StatusCode is HttpStatusCode.Forbidden)
-        {
-            throw new RpcException(new(StatusCode.PermissionDenied, ex.Message, ex));
-        }
+        PlayerData player = await DfGatewayService.GetPlayerDataAsync(request.Token, request.Qq);
 
         CommonUser user = player;
         user.PlateId = request.Plate;
         user.IconId = request.Icon;
 
-        (Func<CommonRecord, bool> predicate, bool maskMutex) = ScoreFilterHelper.GetPredicateByTags(request.Tags, request.Condition);
-        bool mayMask = player.Records.Any(r => r.DXScore is 0 && (r.DXScoreRank > 0 || r.Rank > Ranks.A));
-        if (mayMask && maskMutex)
-        {
-            throw new RpcException(new(StatusCode.PermissionDenied, "Mask enabled"));
-        }
+        (ImmutableArray<CommonRecord> records, bool mayMask) =
+            BuildListRecords(request.Tags, request.Condition, player.Records.ConvertAll<CommonRecord>(_ => _));
 
-        ImmutableArray<CommonRecord> records = [.. player.Records.ConvertAll<CommonRecord>(_ => _).Where(predicate).SortRecordForList()];
         (ImmutableArray<int> counts, int startIndex, int endIndex) = await PrepareDataAsync(user, records, request.Page);
 
         using Image listImage = await new Drawer().DrawListAsync(user, records[startIndex..endIndex], request.Page, counts,
             records.Length, startIndex, request.Condition, mayMask, "divingfish", request.Tags);
 
         await responseStream.WriteToResponseAsync(listImage);
     }
-}
+}