using YD_Event.Application.Auth;
using YD_Event.Application.Scoring.Dtos;

namespace YD_Event.Application.Scoring;

/// <summary>
/// 裁判评分与成绩计算（后台记分台）
/// </summary>
[ApiDescriptionSettings("打分系统")]
public class JudgeScoreService : IDynamicApiController, ITransient
{
    /// <summary>
    /// 修正状态：0-已申请
    /// </summary>
    private const int CorrectionStatusApplied = 0;

    /// <summary>
    /// 修正状态：10-已批准
    /// </summary>
    private const int CorrectionStatusApproved = 10;

    /// <summary>
    /// 修正状态：20-已拒绝
    /// </summary>
    private const int CorrectionStatusRejected = 20;

    /// <summary>
    /// 修正状态：30-裁判修改中
    /// </summary>
    private const int CorrectionStatusEditing = 30;

    /// <summary>
    /// 修正状态：40-已完成
    /// </summary>
    private const int CorrectionStatusCompleted = 40;

    /// <summary>
    /// 修正状态：90-已取消
    /// </summary>
    private const int CorrectionStatusCancelled = 90;

    /// <summary>
    /// 评分单状态：20-已确认
    /// </summary>
    private const int SheetStatusConfirmed = 20;

    /// <summary>
    /// 场次状态：60-已结束
    /// </summary>
    private const int SessionStatusFinished = 60;

    /// <summary>
    /// 消息类型：1-成绩修正提醒
    /// </summary>
    private const int MessageTypeCorrection = 1;

    private readonly ISqlSugarRepository<EventSession> _sessionRepository;
    private readonly ISqlSugarRepository<EventSessionEntry> _entryRepository;
    private readonly ISqlSugarRepository<EventVenue> _venueRepository;
    private readonly ISqlSugarRepository<YD_Event.Core.Entities.ScoreRule> _ruleRepository;
    private readonly ISqlSugarRepository<EventJudgeAssignment> _assignmentRepository;
    private readonly ISqlSugarRepository<EventJudgeScoreSheet> _sheetRepository;
    private readonly ISqlSugarRepository<EventScoreCorrection> _correctionRepository;
    private readonly ISqlSugarRepository<EventJudgeMessage> _messageRepository;
    private readonly ISqlSugarRepository<YD_Event.Core.Entities.Referee> _refereeRepository;
    private readonly ISqlSugarRepository<EventResult> _resultRepository;
    private readonly EventScoreCalculationService _calculationService;
    private readonly IIdGenerator _idGenerator;
    private readonly AuthManager _authManager;

    public JudgeScoreService(ISqlSugarRepository<EventSession> sessionRepository,
        ISqlSugarRepository<EventSessionEntry> entryRepository, ISqlSugarRepository<EventVenue> venueRepository,
        ISqlSugarRepository<YD_Event.Core.Entities.ScoreRule> ruleRepository,
        ISqlSugarRepository<EventJudgeAssignment> assignmentRepository,
        ISqlSugarRepository<EventJudgeScoreSheet> sheetRepository,
        ISqlSugarRepository<EventScoreCorrection> correctionRepository,
        ISqlSugarRepository<EventJudgeMessage> messageRepository,
        ISqlSugarRepository<YD_Event.Core.Entities.Referee> refereeRepository,
        ISqlSugarRepository<EventResult> resultRepository,
        EventScoreCalculationService calculationService, IIdGenerator idGenerator, AuthManager authManager)
    {
        _sessionRepository = sessionRepository; _entryRepository = entryRepository; _venueRepository = venueRepository;
        _ruleRepository = ruleRepository; _assignmentRepository = assignmentRepository; _sheetRepository = sheetRepository;
        _correctionRepository = correctionRepository; _messageRepository = messageRepository;
        _refereeRepository = refereeRepository; _resultRepository = resultRepository;
        _calculationService = calculationService; _idGenerator = idGenerator; _authManager = authManager;
    }

    /// <summary>
    /// 获取场次记分台。按当前已提交的评分单实时算分，不写库，可随时刷新查看进度。
    /// </summary>
    [HttpGet("judge-scores/board/{sessionId}")]
    [DisplayName("获取场次记分台")]
    public async Task<JudgeScoreBoardOutput> GetBoard(long sessionId)
    {
        var ctx = await _calculationService.LoadContextAsync(sessionId);
        var outcomes = await _calculationService.EvaluateSessionAsync(sessionId, ctx);
        return await BuildBoardAsync(ctx, outcomes);
    }

    /// <summary>
    /// 重算整场成绩。所有应到裁判都已提交的出场写入成绩并按规则重排名次，未评满的出场只返回进度。
    /// </summary>
    [HttpPost("judge-scores/recalculate/{sessionId}")]
    [DisplayName("重算场次成绩")]
    [UnitOfWork]
    public async Task<JudgeScoreBoardOutput> Recalculate(long sessionId)
    {
        var ctx = await _calculationService.LoadContextAsync(sessionId);
        var outcomes = await _calculationService.RecalculateSessionAsync(sessionId,
            EventScoreCalculationService.SourceTypeNormal, _authManager.UserId, ctx);
        return await BuildBoardAsync(ctx, outcomes);
    }

    /// <summary>
    /// 成绩排名查询。按项目、组别筛选，名次为 0 的（未评满、退赛、取消资格）排在最后。
    /// </summary>
    [HttpGet("judge-scores/ranking")]
    [DisplayName("成绩排名查询")]
    public async Task<List<JudgeRankingRowOutput>> GetRanking([FromQuery] JudgeRankingQueryInput input)
    {
        if (input.EventId <= 0) throw Oops.Bah("请指定赛事");
        var results = await _resultRepository.AsQueryable()
            .Where(x => x.EventId == input.EventId && x.Status == AvailabilityStatus.Enable)
            .WhereIF(input.ProjectId.HasValue, x => x.ProjectId == input.ProjectId!.Value)
            .WhereIF(!string.IsNullOrWhiteSpace(input.GroupName), x => x.GroupName == input.GroupName)
            .WhereIF(input.ResultStatus.HasValue, x => x.ResultStatus == input.ResultStatus!.Value)
            .ToListAsync();

        return results
            .OrderBy(x => x.ProjectId).ThenBy(x => x.GroupName)
            // 名次 0 表示尚未参与排名，统一沉到组内末尾，避免占据第一名的位置。
            .ThenBy(x => x.Rank == 0 ? int.MaxValue : x.Rank)
            .ThenByDescending(x => x.TotalScore ?? 0m).ThenBy(x => x.ParticipantName)
            .Select(x => new JudgeRankingRowOutput
            {
                ResultId = x.Id,
                SessionEntryId = x.SessionEntryId,
                ProjectId = x.ProjectId,
                ProjectTypeName = x.ProjectTypeName ?? string.Empty,
                GroupName = x.GroupName ?? string.Empty,
                ParticipantName = x.ParticipantName ?? string.Empty,
                Rank = x.Rank,
                TotalScore = x.Score ?? string.Empty,
                DifficultyScore = x.DifficultyScore,
                PerformanceScore = x.PerformanceScore,
                RequiredScore = x.RequiredScore,
                DeductionScore = x.DeductionScore,
                IsDisqualified = x.IsDisqualified,
                ResultStatus = x.ResultStatus,
                ResultStatusName = ResultStatusName(x.ResultStatus),
                ResultVersion = x.ResultVersion,
                ReviewUserId = x.ReviewUserId,
                ReviewTime = x.ReviewTime
            }).ToList();
    }

    /// <summary>
    /// 确认场次成绩。仅在全场都已评满时确认，确认后裁判端不能再自行申请修正。
    /// </summary>
    [HttpPost("judge-scores/confirm/{sessionId}")]
    [DisplayName("确认场次成绩")]
    [UnitOfWork]
    public async Task<ConfirmSessionScoreOutput> ConfirmSession(long sessionId)
    {
        var session = await _sessionRepository.GetFirstAsync(x => x.Id == sessionId);
        if (session == null) throw Oops.Bah("比赛场次不存在");
        var ctx = await _calculationService.LoadContextAsync(session);

        // 先只算不写：确认被拒时不留下任何写库痕迹，也不会把已确认的成绩打回待复核。
        var preview = await _calculationService.EvaluateSessionAsync(sessionId, ctx);
        var output = new ConfirmSessionScoreOutput
        {
            PendingEntries = preview.Where(x => !x.IsSkipped && !x.IsCompleted).Select(x => x.EntryNo).ToList()
        };
        // 有出场没评满就不确认，否则先确认的成绩会挡住后到的评分。
        if (output.PendingEntries.Count > 0) return output;

        var outcomes = await _calculationService.RecalculateSessionAsync(sessionId,
            EventScoreCalculationService.SourceTypeNormal, _authManager.UserId, ctx);

        var entryIds = outcomes.Select(x => (long?)x.SessionEntryId).ToList();
        var results = await _resultRepository.GetListAsync(x => entryIds.Contains(x.SessionEntryId)
            && x.ResultStatus == EventScoreCalculationService.ResultStatusPendingReview);
        var now = DateTime.Now;
        foreach (var result in results)
        {
            result.ResultStatus = EventScoreCalculationService.ResultStatusConfirmed;
            result.ReviewUserId = _authManager.UserId;
            result.ReviewTime = now;
            result.UpdatedUserId = _authManager.UserId;
            result.UpdatedTime = now;
        }
        if (results.Count > 0) await _resultRepository.UpdateRangeAsync(results);
        output.ConfirmedCount = results.Count;

        // 评分单一并置为已确认，裁判端据此禁用修正入口。
        var plainIds = outcomes.Select(x => x.SessionEntryId).ToList();
        var sheets = await _sheetRepository.GetListAsync(x => plainIds.Contains(x.SessionEntryId)
            && x.IsCurrent && x.SheetStatus == EventScoreCalculationService.SheetStatusSubmitted);
        foreach (var sheet in sheets)
        {
            sheet.SheetStatus = SheetStatusConfirmed;
            sheet.UpdatedUserId = _authManager.UserId;
            sheet.UpdatedTime = now;
        }
        if (sheets.Count > 0) await _sheetRepository.UpdateRangeAsync(sheets);

        if (session.SessionStatus != SessionStatusFinished)
        {
            session.SessionStatus = SessionStatusFinished;
            session.Version++;
            session.EndTime ??= now;
            session.UpdatedUserId = _authManager.UserId;
            session.UpdatedTime = now;
            await _sessionRepository.UpdateAsync(session);
        }
        output.SessionFinished = true;
        return output;
    }

    /// <summary>
    /// 获取成绩修正申请列表
    /// </summary>
    [HttpGet("judge-scores/corrections/{eventId}")]
    [DisplayName("获取成绩修正申请列表")]
    public async Task<List<JudgeCorrectionOutput>> GetCorrections(long eventId, [FromQuery] int? correctionStatus = null)
    {
        var corrections = (await _correctionRepository.AsQueryable()
                .Where(x => x.EventId == eventId)
                .WhereIF(correctionStatus.HasValue, x => x.CorrectionStatus == correctionStatus!.Value)
                .ToListAsync())
            .OrderByDescending(x => x.CreatedTime).ToList();
        if (corrections.Count == 0) return new List<JudgeCorrectionOutput>();

        var sessionIds = corrections.Select(x => x.SessionId).Distinct().ToList();
        var sessions = await _sessionRepository.GetListAsync(x => sessionIds.Contains(x.Id));
        var ruleIds = sessions.Select(x => x.ScoreRuleId).Distinct().ToList();
        var rules = await _ruleRepository.GetListAsync(x => ruleIds.Contains(x.Id));
        // 每个场次的小数位取自各自的计分规则，避免跨规则显示口径不一致。
        var configs = sessions.GroupBy(x => x.Id).ToDictionary(x => x.Key,
            x => ScoreRuleConfigService.Parse(rules.FirstOrDefault(r => r.Id == x.First().ScoreRuleId)?.RuleConfigJson));

        var entryIds = corrections.Select(x => x.SessionEntryId).Distinct().ToList();
        var entries = await _entryRepository.GetListAsync(x => entryIds.Contains(x.Id));
        var sheetIds = corrections.Select(x => x.OriginalScoreSheetId)
            .Concat(corrections.Where(x => x.NewScoreSheetId.HasValue).Select(x => x.NewScoreSheetId!.Value))
            .Distinct().ToList();
        var sheets = await _sheetRepository.GetListAsync(x => sheetIds.Contains(x.Id));
        var assignmentIds = corrections.Select(x => x.JudgeAssignmentId).Distinct().ToList();
        var assignments = await _assignmentRepository.GetListAsync(x => assignmentIds.Contains(x.Id));
        var refereeIds = assignments.Select(x => x.RefereeId).Distinct().ToList();
        var referees = await _refereeRepository.GetListAsync(x => refereeIds.Contains(x.Id));

        return corrections.Select(correction =>
        {
            var session = sessions.FirstOrDefault(x => x.Id == correction.SessionId);
            var entry = entries.FirstOrDefault(x => x.Id == correction.SessionEntryId);
            var original = sheets.FirstOrDefault(x => x.Id == correction.OriginalScoreSheetId);
            var updated = correction.NewScoreSheetId.HasValue
                ? sheets.FirstOrDefault(x => x.Id == correction.NewScoreSheetId!.Value)
                : null;
            var assignment = assignments.FirstOrDefault(x => x.Id == correction.JudgeAssignmentId);
            var referee = assignment == null ? null : referees.FirstOrDefault(x => x.Id == assignment.RefereeId);
            var config = configs.TryGetValue(correction.SessionId, out var found) ? found : ScoreRuleConfigService.Parse(null);
            return new JudgeCorrectionOutput
            {
                Id = correction.Id,
                SessionId = correction.SessionId,
                SessionName = session == null ? string.Empty : session.SessionName ?? session.SessionNo,
                SessionEntryId = correction.SessionEntryId,
                EntryNo = entry?.EntryNo ?? string.Empty,
                ParticipantName = entry == null
                    ? string.Empty
                    : string.IsNullOrWhiteSpace(entry.TeamName) ? entry.ParticipantName : entry.TeamName!,
                OriginalScoreSheetId = correction.OriginalScoreSheetId,
                NewScoreSheetId = correction.NewScoreSheetId,
                JudgeRole = correction.JudgeRole,
                RefereeName = referee?.Name ?? string.Empty,
                OriginalScore = original == null ? string.Empty : config.Format(original.TotalScore),
                NewScore = updated == null ? null : config.Format(updated.TotalScore),
                ApplyReason = correction.ApplyReason,
                ApproveRemark = correction.ApproveRemark,
                CorrectionStatus = correction.CorrectionStatus,
                CorrectionStatusName = CorrectionStatusName(correction.CorrectionStatus),
                CreatedTime = correction.CreatedTime,
                ApproveTime = correction.ApproveTime,
                CompletedTime = correction.CompletedTime
            };
        }).ToList();
    }

    /// <summary>
    /// 后台发起成绩修正。发起后该裁判可重新提交这张评分单，原评分在新评分提交时才失效。
    /// </summary>
    [HttpPost("judge-scores/corrections/initiate")]
    [DisplayName("发起成绩修正")]
    [UnitOfWork]
    public async Task<long> InitiateCorrection([FromBody] InitiateJudgeCorrectionInput input)
    {
        if (string.IsNullOrWhiteSpace(input.Reason)) throw Oops.Bah("请填写修正原因");
        var sheet = await _sheetRepository.GetFirstAsync(x => x.Id == input.ScoreSheetId);
        if (sheet == null) throw Oops.Bah("评分单不存在");
        if (!sheet.IsCurrent || sheet.SheetStatus < EventScoreCalculationService.SheetStatusSubmitted)
            throw Oops.Bah("该评分单不是当前生效的已提交评分，无需修正");
        if (await HasOpenCorrectionAsync(sheet.Id)) throw Oops.Bah("该评分单已有修正流程在处理中");

        var now = DateTime.Now;
        var correction = new EventScoreCorrection
        {
            Id = _idGenerator.NextId(),
            EventId = sheet.EventId,
            SessionId = sheet.SessionId,
            SessionEntryId = sheet.SessionEntryId,
            OriginalScoreSheetId = sheet.Id,
            JudgeAssignmentId = sheet.JudgeAssignmentId,
            JudgeRole = sheet.JudgeRole,
            ApplyUserId = _authManager.UserId,
            ApplyReason = input.Reason.Trim(),
            // 后台发起本身即代表已批准，裁判端可直接重新评分。
            CorrectionStatus = CorrectionStatusApproved,
            ApproveUserId = _authManager.UserId,
            ApproveRemark = "赛事管理员发起",
            ApproveTime = now,
            CreatedUserId = _authManager.UserId,
            CreatedTime = now
        };
        await _correctionRepository.InsertAsync(correction);
        await NotifyRefereeAsync(correction, sheet, "成绩修正通知",
            $"请对{sheet.JudgeRole}号位的评分重新提交，原因：{correction.ApplyReason}");
        return correction.Id;
    }

    /// <summary>
    /// 审批裁判提交的成绩修正申请
    /// </summary>
    [HttpPost("judge-scores/corrections/approve")]
    [DisplayName("审批成绩修正申请")]
    [UnitOfWork]
    public async Task ApproveCorrection([FromBody] ApproveJudgeCorrectionInput input)
    {
        var correction = await _correctionRepository.GetFirstAsync(x => x.Id == input.CorrectionId);
        if (correction == null) throw Oops.Bah("修正申请不存在");
        if (correction.CorrectionStatus != CorrectionStatusApplied)
            throw Oops.Bah($"该申请当前为“{CorrectionStatusName(correction.CorrectionStatus)}”，不能重复审批");
        var sheet = await _sheetRepository.GetFirstAsync(x => x.Id == correction.OriginalScoreSheetId);
        if (sheet == null) throw Oops.Bah("被修正的评分单不存在");

        var now = DateTime.Now;
        correction.CorrectionStatus = input.Approved ? CorrectionStatusApproved : CorrectionStatusRejected;
        correction.ApproveUserId = _authManager.UserId;
        correction.ApproveRemark = input.ApproveRemark;
        correction.ApproveTime = now;
        if (!input.Approved) correction.CompletedTime = now;
        correction.UpdatedUserId = _authManager.UserId;
        correction.UpdatedTime = now;
        await _correctionRepository.UpdateAsync(correction);

        await NotifyRefereeAsync(correction, sheet,
            input.Approved ? "成绩修正申请已通过" : "成绩修正申请被驳回",
            input.Approved
                ? $"{sheet.JudgeRole}号位的修正申请已通过，请重新提交评分。"
                : $"{sheet.JudgeRole}号位的修正申请未通过。{input.ApproveRemark}");
    }

    /// <summary>
    /// 组装记分台数据，名次与成绩状态取已落库的成绩
    /// </summary>
    private async Task<JudgeScoreBoardOutput> BuildBoardAsync(ScoringContext ctx, List<EntryCalculationOutcome> outcomes)
    {
        var venue = await _venueRepository.GetFirstAsync(x => x.Id == ctx.Session.VenueId);
        var output = new JudgeScoreBoardOutput
        {
            SessionId = ctx.Session.Id,
            EventId = ctx.Session.EventId,
            SessionName = ctx.Session.SessionName ?? ctx.Session.SessionNo,
            VenueName = venue?.VenueName ?? string.Empty,
            ProjectName = ctx.Project.Name,
            RuleName = ctx.Rule.RuleName,
            Formula = EntryResultCalculationService.BuildFormula(ctx.Config),
            SessionStatus = ctx.Session.SessionStatus,
            EntryCount = outcomes.Count,
            CompletedCount = outcomes.Count(x => x.IsCompleted)
        };
        if (outcomes.Count == 0) return output;

        var entryIds = outcomes.Select(x => (long?)x.SessionEntryId).ToList();
        var results = await _resultRepository.GetListAsync(x => entryIds.Contains(x.SessionEntryId)
            && x.ResultStatus != EventScoreCalculationService.ResultStatusVoided);
        // 一个出场（队伍）的多名运动员共享同一名次，取任意一条即可。
        var resultByEntry = results.Where(x => x.SessionEntryId.HasValue)
            .GroupBy(x => x.SessionEntryId!.Value).ToDictionary(x => x.Key, x => x.First());

        foreach (var outcome in outcomes)
        {
            resultByEntry.TryGetValue(outcome.SessionEntryId, out var result);
            var entry = new JudgeScoreBoardEntryOutput
            {
                SessionEntryId = outcome.SessionEntryId,
                EntryNo = outcome.EntryNo,
                ParticipantName = outcome.ParticipantName,
                GroupName = outcome.GroupName,
                IsCompleted = outcome.IsCompleted,
                IsSkipped = outcome.IsSkipped,
                SkipReason = outcome.SkipReason,
                IsDisqualified = outcome.IsDisqualified,
                TotalScore = outcome.IsDisqualified
                    ? "取消资格"
                    : outcome.IsCompleted ? ctx.Config.Format(outcome.TotalScore) : string.Empty,
                Rank = result?.Rank ?? 0,
                ResultStatus = result?.ResultStatus ?? 0,
                ResultStatusName = ResultStatusName(result?.ResultStatus ?? 0),
                Progress = outcome.Roles.Select(role => new JudgeBoardRoleProgressOutput
                {
                    RoleType = role.RoleType, RoleName = role.RoleName, Symbol = role.Symbol,
                    ExpectedCount = role.ExpectedCount, SubmittedCount = role.SubmittedCount,
                    PendingJudges = role.PendingJudges
                }).ToList()
            };
            if (outcome.Aggregate != null)
            {
                entry.Symbols = outcome.Aggregate.Symbols.Select(symbol => new JudgeSymbolScoreOutput
                {
                    Symbol = symbol.Symbol, Label = symbol.Label, RoleType = symbol.RoleType,
                    Aggregate = symbol.Aggregate, Sign = symbol.Sign, Value = ctx.Config.Format(symbol.Value),
                    Judges = symbol.Judges.Select(judge => new JudgeBoardSheetScoreOutput
                    {
                        ScoreSheetId = judge.ScoreSheetId, RefereeId = judge.RefereeId,
                        RefereeName = judge.JudgeName ?? string.Empty, JudgeRole = judge.JudgeRole,
                        JudgeRoleType = judge.JudgeRoleType, Value = ctx.Config.Format(judge.Value),
                        IsDisqualified = judge.IsDisqualified
                    }).ToList()
                }).ToList();
            }
            output.Entries.Add(entry);
        }

        // 出场状态不在计算结果里，单独回填，前端据此区分退赛与未上场。
        var plainIds = outcomes.Select(x => x.SessionEntryId).ToList();
        var entries = await _entryRepository.GetListAsync(x => plainIds.Contains(x.Id));
        foreach (var row in output.Entries)
        {
            var source = entries.FirstOrDefault(x => x.Id == row.SessionEntryId);
            if (source == null) continue;
            row.EntryStatus = source.EntryStatus;
            row.PlayOrder = source.PlayOrder;
        }
        return output;
    }

    /// <summary>
    /// 该评分单是否已有未结束的修正流程
    /// </summary>
    private async Task<bool> HasOpenCorrectionAsync(long scoreSheetId) =>
        await _correctionRepository.IsAnyAsync(x => x.OriginalScoreSheetId == scoreSheetId
            && (x.CorrectionStatus == CorrectionStatusApplied
                || x.CorrectionStatus == CorrectionStatusApproved
                || x.CorrectionStatus == CorrectionStatusEditing));

    /// <summary>
    /// 给被修正的裁判发一条站内消息，裁判端在消息列表里看到修正提醒
    /// </summary>
    private async Task NotifyRefereeAsync(EventScoreCorrection correction, EventJudgeScoreSheet sheet,
        string title, string content)
    {
        var receiverUserId = sheet.JudgeUserId;
        if (!receiverUserId.HasValue)
        {
            var assignment = await _assignmentRepository.GetFirstAsync(x => x.Id == correction.JudgeAssignmentId);
            receiverUserId = assignment?.JudgeUserId;
        }
        if (!receiverUserId.HasValue)
        {
            var referee = await _refereeRepository.GetFirstAsync(x => x.Id == sheet.RefereeId);
            receiverUserId = referee?.AppUserId;
        }
        // 裁判还没绑定小程序账号时消息无处投递，此时只留修正记录，不阻断主流程。
        if (!receiverUserId.HasValue) return;

        await _messageRepository.InsertAsync(new EventJudgeMessage
        {
            Id = _idGenerator.NextId(),
            EventId = correction.EventId,
            ReceiverUserId = receiverUserId.Value,
            RefereeId = sheet.RefereeId,
            MessageType = MessageTypeCorrection,
            Title = title,
            Content = content.Length > 512 ? content[..512] : content,
            RelationType = nameof(EventScoreCorrection),
            RelationId = correction.Id,
            IsRead = false,
            CreatedUserId = _authManager.UserId,
            CreatedTime = DateTime.Now
        });
    }

    /// <summary>
    /// 成绩状态名称
    /// </summary>
    private static string ResultStatusName(int status) => status switch
    {
        0 => "未生成",
        EventScoreCalculationService.ResultStatusPendingReview => "待复核",
        EventScoreCalculationService.ResultStatusConfirmed => "已确认",
        EventScoreCalculationService.ResultStatusVoided => "已作废",
        _ => status.ToString()
    };

    /// <summary>
    /// 修正状态名称
    /// </summary>
    private static string CorrectionStatusName(int status) => status switch
    {
        CorrectionStatusApplied => "已申请",
        CorrectionStatusApproved => "已批准",
        CorrectionStatusRejected => "已拒绝",
        CorrectionStatusEditing => "裁判修改中",
        CorrectionStatusCompleted => "已完成",
        CorrectionStatusCancelled => "已取消",
        _ => status.ToString()
    };
}