LehrerApp/LehrerApp.Desktop.Tests/ExamDialogViewModelTests.cs

using LehrerApp.Core.Models;
using LehrerApp.Core.Services;
using LehrerApp.Desktop.ViewModels.Groups;
using Xunit;

namespace LehrerApp.Desktop.Tests;

public sealed class ExamDialogViewModelTests
{
    private static ExamDialogViewModel BuildViewModel(List<Exam> existingExams, string dateText,
        Exam? editingExam = null)
    {
        var vm = new ExamDialogViewModel(new FakeExams(existingExams), new FakeCompetencyDomains(),
            new FakeGradingKeyTemplates(), new GradingService(), Guid.NewGuid(), null, 9,
            GradingSystem.Grades1To6, "Chemie", isDifferentiated: false, editingExam, null);
        vm.DateText = dateText;
        return vm;
    }

    private static Exam MakeExam(DateOnly date) => new() { GroupId = Guid.NewGuid(), Title = "x", Date = date };

    [Fact]
    public void WeekLoadHint_WenigeKlausurenInDerWoche_BleibtLeer()
    {
        var monday = new DateOnly(2026, 3, 16);
        var existing = new List<Exam> { MakeExam(monday) };

        var vm = BuildViewModel(existing, monday.AddDays(1).ToString("dd.MM.yyyy"));

        Assert.Equal("", vm.WeekLoadHint);
    }

    [Fact]
    public void WeekLoadHint_DritteKlausurInDerWoche_ZeigtHinweis()
    {
        var monday = new DateOnly(2026, 3, 16);
        var existing = new List<Exam> { MakeExam(monday), MakeExam(monday.AddDays(1)) };

        var vm = BuildViewModel(existing, monday.AddDays(2).ToString("dd.MM.yyyy"));

        Assert.Contains("3 Klausuren", vm.WeekLoadHint);
    }

    [Fact]
    public void WeekLoadHint_BearbeiteteKlausurZaehltNichtDoppelt()
    {
        var monday = new DateOnly(2026, 3, 16);
        var editing = MakeExam(monday);
        var existing = new List<Exam> { editing, MakeExam(monday.AddDays(1)) };

        // Nur die eigene Klausur (editing) + eine weitere -> 2 insgesamt, kein Hinweis.
        var vm = BuildViewModel(existing, monday.ToString("dd.MM.yyyy"), editing);

        Assert.Equal("", vm.WeekLoadHint);
    }

    [Fact]
    public void WeekLoadHint_UngueltigesDatum_BleibtLeer()
    {
        var vm = BuildViewModel([], "keindatum");

        Assert.Equal("", vm.WeekLoadHint);
    }

    [Fact]
    public void BonusNachtraeglichMarkiert_BerechnetGespeichertesErgebnisNeu()
    {
        var exam = MakeExam(new DateOnly(2026, 5, 12));
        exam.Tasks = [new ExamTask { Nr = 1, MaxPoints = 10 }, new ExamTask { Nr = 2, MaxPoints = 2 }];
        exam.GradingKey = GradingService.DefaultKey1To6();
        var result = new ExamResult { ExamId = exam.Id, StudentId = Guid.NewGuid(),
            Points = [8, 2], TotalPoints = 10, Grade = "2" };
        var results = new FakeResults();
        results.Add(result);
        var vm = new ExamDialogViewModel(new FakeExams([exam]), new FakeCompetencyDomains(),
            new FakeGradingKeyTemplates(), new GradingService(), exam.GroupId, null, 9,
            GradingSystem.Grades1To6, "Chemie", false, exam, null,
            results: results);
        vm.Tasks[1].IsBonus = true;

        vm.SaveCommand.Execute(null);

        Assert.True(exam.Tasks[1].IsBonus);
        Assert.Equal(10, result.TotalPoints);
        Assert.Equal("1", result.Grade);
    }

    // ── Förderarbeit ─────────────────────────────────────────────────────────

    private static (ExamDialogViewModel Vm, Exam Original) BuildFollowUpViewModel(DateOnly originalDate)
    {
        var original = new Exam { GroupId = Guid.NewGuid(), Title = "Atombau", Date = originalDate };
        var vm = new ExamDialogViewModel(new FakeExams([original]), new FakeCompetencyDomains(),
            new FakeGradingKeyTemplates(), new GradingService(), original.GroupId, null, 9,
            GradingSystem.Grades1To6, "Chemie", false, null, null);
        vm.Title = "Atombau (Förder)";
        vm.Tasks.Add(new ExamTaskEditItem("A1", 10, 1, [], []) { OnChanged = () => { } });
        vm.Tasks[0].MaxPoints = 10;
        vm.SelectedOriginalExam = original;
        return (vm, original);
    }

    [Fact]
    public void Foerderarbeit_UebernimmtDatumDerErstenArbeitUndDarfAmSelbenTagLiegen()
    {
        var (vm, original) = BuildFollowUpViewModel(new DateOnly(2026, 10, 14));

        vm.FollowUpKindName = "Förderarbeit";

        Assert.Equal("14.10.2026", vm.DateText);
        vm.SaveCommand.Execute(null);
        Assert.Equal("", vm.RepeatError);
        Assert.NotNull(vm.Result);
        Assert.True(vm.Result!.IsSupportWork);
        Assert.False(vm.Result.IsMakeUp);
        Assert.Equal(original.Id, vm.Result.RepeatOfExamId);
        Assert.Equal(original.Date, vm.Result.Date);
    }

    [Fact]
    public void Foerderarbeit_VorDerErstenArbeit_WirdAbgelehnt()
    {
        var (vm, _) = BuildFollowUpViewModel(new DateOnly(2026, 10, 14));
        vm.FollowUpKindName = "Förderarbeit";

        vm.DateText = "13.10.2026";
        vm.SaveCommand.Execute(null);

        Assert.Contains("Förderarbeit", vm.RepeatError);
        Assert.Null(vm.Result);
    }

    [Fact]
    public void Nachschreibarbeit_AmSelbenTag_BleibtAbgelehnt()
    {
        var (vm, _) = BuildFollowUpViewModel(new DateOnly(2026, 10, 14));
        vm.FollowUpKindName = "Nachschreibarbeit";

        vm.DateText = "14.10.2026";
        vm.SaveCommand.Execute(null);

        Assert.Contains("Nachschreibarbeit", vm.RepeatError);
        Assert.Null(vm.Result);
    }

    [Fact]
    public void Foerderarbeit_WirdBeimBearbeitenWiederhergestelltOhneDatumZuUeberschreiben()
    {
        var original = new Exam { GroupId = Guid.NewGuid(), Title = "Atombau", Date = new DateOnly(2026, 10, 14) };
        var support = new Exam
        {
            GroupId = original.GroupId, Title = "Förder", Date = new DateOnly(2026, 10, 16),
            RepeatOfExamId = original.Id, IsSupportWork = true,
        };

        var vm = new ExamDialogViewModel(new FakeExams([original, support]), new FakeCompetencyDomains(),
            new FakeGradingKeyTemplates(), new GradingService(), original.GroupId, null, 9,
            GradingSystem.Grades1To6, "Chemie", false, support, null);

        Assert.True(vm.IsSupportWork);
        Assert.Equal("16.10.2026", vm.DateText);
        Assert.False(vm.ShowRepeatRule);
    }
}