LehrerApp/LehrerApp.Tests/ExamPriorityServiceTests.cs

using LehrerApp.Core.Models;
using LehrerApp.Core.Services;
using Xunit;

namespace LehrerApp.Tests;

public class ExamPriorityServiceTests
{
    private static Exam MakeExam(ExamStatus status, DateOnly date) => new()
    {
        GroupId = Guid.NewGuid(), Title = "Klausur", Status = status, Date = date,
    };

    [Fact]
    public void Evaluate_UnbearbeiteteKorrekturSteigtMitAlter()
    {
        var today = new DateOnly(2026, 8, 29);
        var exam = MakeExam(ExamStatus.Conducted, today.AddDays(-10));

        var result = ExamPriorityService.Evaluate(exam, expected: 20, evaluated: 0, today);

        Assert.Equal(ExamListStatus.AwaitingCorrection, result.Status);
    }

    [Fact]
    public void Evaluate_UnbearbeiteteKorrekturIstDringenderAlsLaufendeKorrektur()
    {
        var today = new DateOnly(2026, 8, 29);
        var untouched = MakeExam(ExamStatus.Conducted, today.AddDays(-10));
        var inProgress = MakeExam(ExamStatus.Conducted, today.AddDays(-10));

        var untouchedResult = ExamPriorityService.Evaluate(untouched, expected: 20, evaluated: 0, today);
        var progressResult  = ExamPriorityService.Evaluate(inProgress, expected: 20, evaluated: 10, today);

        Assert.True(untouchedResult.Score > progressResult.Score);
    }

    [Fact]
    public void Evaluate_LaufendeKorrekturIstDringenderAlsGeplanteKlausur()
    {
        var today = new DateOnly(2026, 8, 29);
        var inProgress = MakeExam(ExamStatus.Conducted, today.AddDays(-2));
        var planned     = MakeExam(ExamStatus.Planned, today.AddDays(1));

        var progressResult = ExamPriorityService.Evaluate(inProgress, expected: 20, evaluated: 10, today);
        var plannedResult  = ExamPriorityService.Evaluate(planned, expected: 20, evaluated: 0, today);

        Assert.True(progressResult.Score > plannedResult.Score);
    }

    [Fact]
    public void Evaluate_HängengebliebeneKorrekturFälltAusDerDringlichenZone()
    {
        var today = new DateOnly(2026, 8, 29);
        var stuck = MakeExam(ExamStatus.Conducted, today.AddDays(-(ExamPriorityService.StuckAfterDays + 5)));
        var fresh = MakeExam(ExamStatus.Conducted, today.AddDays(-2));

        // Ein einzelner nie nachschreibender Schüler: 19 von 20 erledigt, seit Wochen unverändert.
        var stuckResult = ExamPriorityService.Evaluate(stuck, expected: 20, evaluated: 19, today);
        var freshResult = ExamPriorityService.Evaluate(fresh, expected: 20, evaluated: 10, today);

        Assert.Equal(ExamListStatus.CorrectionStuck, stuckResult.Status);
        Assert.True(stuckResult.Score < freshResult.Score);
    }

    [Fact]
    public void Evaluate_VollständigBewertetGiltAlsBereitZurRückgabe()
    {
        var today = new DateOnly(2026, 8, 29);
        var exam = MakeExam(ExamStatus.Conducted, today.AddDays(-5));

        var result = ExamPriorityService.Evaluate(exam, expected: 20, evaluated: 20, today);

        Assert.Equal(ExamListStatus.AwaitingReturn, result.Status);
    }

    [Fact]
    public void Evaluate_ZurückgegebenIstAmWenigstenDringlich()
    {
        var today = new DateOnly(2026, 8, 29);
        var returned = MakeExam(ExamStatus.Returned, today.AddDays(-30));
        var planned   = MakeExam(ExamStatus.Planned, today.AddDays(60));

        var returnedResult = ExamPriorityService.Evaluate(returned, expected: 20, evaluated: 20, today);
        var plannedResult  = ExamPriorityService.Evaluate(planned, expected: 20, evaluated: 0, today);

        Assert.True(returnedResult.Score < plannedResult.Score);
    }

    [Fact]
    public void Count_AbwesenderSchülerGiltAlsErledigt()
    {
        var exam = MakeExam(ExamStatus.Conducted, new DateOnly(2026, 8, 20));
        var membership = new GroupMembership { GroupId = exam.GroupId, StudentId = Guid.NewGuid() };
        var results = new List<ExamResult> { new() { ExamId = exam.Id, StudentId = membership.StudentId, Absent = true } };

        var (expected, evaluated) = ExamCorrectionCounter.Count(exam, [membership], results);

        Assert.Equal(1, expected);
        Assert.Equal(1, evaluated);
    }
}