using CommunityToolkit.Mvvm.ComponentModel; using CommunityToolkit.Mvvm.Input; using LehrerApp.Core.Interfaces; using LehrerApp.Core.Models; using LehrerApp.Core.Services; using System.Collections.ObjectModel; using System.Globalization; namespace LehrerApp.Desktop.ViewModels.Groups; // ── Punkteeingabe & Korrektur (1.4) ────────────────────────────────────────── /// Tastatur-Bewegung im Punkteraster: Next/Previous folgen dem gewählten Korrekturmodus /// (Enter / Umschalt+Enter), die übrigen bewegen sich räumlich (Pfeiltasten). public enum GradingMove { Next, Previous, Up, Down, Left, Right } public partial class ExamGradingDialogViewModel : ObservableObject { private readonly IExamResultRepository _results; private readonly GradingService _grading; private readonly Exam _exam; private readonly ExamGradingSettingsService? _settings; public string ExamTitle => _exam.Title; public string ExamDateLabel => _exam.Date.ToString("dd.MM.yyyy"); public string NiveauLabel => _exam.Niveau.HasValue ? NiveauDisplay.ToName(_exam.Niveau) : ""; public List Tasks { get; } public bool HasVariants => Tasks.Any(t => t.Variant is not null); /// Spaltenüberschriften — Bonusaufgaben zählen bei der Nummerierung nicht mit. public List TaskHeaders { get; } public ObservableCollection Rows { get; } = []; public string[] EntryOrderOptions => ["Schüler für Schüler", "Aufgabe für Aufgabe"]; [ObservableProperty] private string _entryOrderName; public GradingEntryOrder EntryOrder => EntryOrderName == EntryOrderOptions[1] ? GradingEntryOrder.ByTask : GradingEntryOrder.ByStudent; public ExamGradingDialogViewModel(IExamResultRepository results, IStudentRepository students, IGroupMembershipRepository memberships, GradingService grading, Exam exam, Guid groupId, ExamGradingSettingsService? settings = null) { _results = results; _grading = grading; _exam = exam; _settings = settings; Tasks = exam.Tasks.OrderBy(t => t.Nr).ToList(); TaskHeaders = ExamScoringService.TaskLabels(Tasks) .Select((label, i) => (Tasks[i].IsBonus ? "★ " : "") + label + (Tasks[i].Variant is null ? "" : $" ({Tasks[i].Variant})")) .ToList(); _entryOrderName = EntryOrderOptions[ settings?.Load().EntryOrder == GradingEntryOrder.ByTask ? 1 : 0]; var enrolled = students.GetByGroup(groupId); var membershipList = memberships.GetByGroup(groupId); var existing = results.GetByExam(exam.Id).ToDictionary(r => r.StudentId); // Nachschreibarbeit: nur Schüler, die die erste Arbeit nicht mitgeschrieben haben. Wer dort // schon eine Note hat, taucht nicht auf — außer es gibt hier bereits ein Ergebnis (nichts // verstecken, was schon eingetragen wurde). var wroteOriginal = new HashSet(); if (exam.IsMakeUp && exam.RepeatOfExamId is { } originalId) foreach (var r in results.GetByExam(originalId).Where(r => !r.Absent && r.Grade is not null)) wroteOriginal.Add(r.StudentId); foreach (var s in enrolled.OrderBy(s => s.LastName).ThenBy(s => s.FirstName)) { var membership = membershipList.FirstOrDefault(e => e.StudentId == s.Id); if (membership is not null && !GroupMembershipService.IsActiveOn(membership, exam.Date)) continue; // Niveau-Klausur: nur Schüler mit passendem Niveau zeigen. Klausuren ohne // Niveau-Zuordnung gelten weiterhin für die ganze Gruppe. if (exam.Niveau.HasValue && membership?.Niveau != exam.Niveau) continue; existing.TryGetValue(s.Id, out var result); if (result is null && wroteOriginal.Contains(s.Id)) continue; var row = new ExamResultRow(s.Id, s.FullName, Tasks, result, _exam.GradingKey, ExamScoringService.Maximum(Tasks, ExamVariant.A), _grading); row.OnChanged = SaveRow; Rows.Add(row); } } private void SaveRow(ExamResultRow row) => _results.Save(row.ToModel(_exam.Id)); partial void OnEntryOrderNameChanged(string value) => _settings?.Save(new ExamGradingSettings { EntryOrder = EntryOrder }); /// Nur Felder, in die tatsächlich etwas eingetragen werden kann: abwesende Schüler und /// Aufgaben der jeweils anderen Fassung werden beim Weiterspringen übersprungen. public bool IsEditable(int rowIdx, int taskIdx) => rowIdx >= 0 && rowIdx < Rows.Count && taskIdx >= 0 && taskIdx < Tasks.Count && !Rows[rowIdx].Absent && Rows[rowIdx].Cells[taskIdx].IsApplicable; /// Erstes Feld in Korrekturreihenfolge — dort steht der Cursor beim Öffnen des Dialogs. public (int Row, int Task)? FirstCell() => IsEditable(0, 0) ? (0, 0) : NextCell(0, 0, GradingMove.Next); /// Zielfeld für eine Tastatur-Bewegung oder null am Rand. Enter läuft je nach Modus /// zeilen- oder spaltenweise und am Ende einer Zeile/Spalte in die nächste weiter; /// Pfeiltasten bewegen sich nur innerhalb der Zeile bzw. Spalte und halten am Rand an. public (int Row, int Task)? NextCell(int rowIdx, int taskIdx, GradingMove move) { if (move is GradingMove.Next or GradingMove.Previous) { var step = move == GradingMove.Next ? 1 : -1; var byTask = EntryOrder == GradingEntryOrder.ByTask; var total = Rows.Count * Tasks.Count; var pos = byTask ? taskIdx * Rows.Count + rowIdx : rowIdx * Tasks.Count + taskIdx; for (pos += step; pos >= 0 && pos < total; pos += step) { var (r, t) = byTask ? (pos % Rows.Count, pos / Rows.Count) : (pos / Tasks.Count, pos % Tasks.Count); if (IsEditable(r, t)) return (r, t); } return null; } var (dRow, dTask) = move switch { GradingMove.Up => (-1, 0), GradingMove.Down => (1, 0), GradingMove.Left => (0, -1), _ => (0, 1), }; for (int r = rowIdx + dRow, t = taskIdx + dTask; r >= 0 && r < Rows.Count && t >= 0 && t < Tasks.Count; r += dRow, t += dTask) { if (IsEditable(r, t)) return (r, t); } return null; } /// Rest als abwesend markieren (Nutzerwunsch): Schüler, die nie nachschreiben, blockieren /// sonst dauerhaft den live abgeleiteten Korrekturstatus (ExamPriorityService), weil niemand /// eine leere Zeile anfasst, für die es nichts einzutragen gibt. Rührt bewusst nur unberührte /// Zeilen an — bereits eingetragene Punkte/Kommentare bleiben unangetastet. [RelayCommand] private void MarkRemainingAbsent() { foreach (var row in Rows.Where(r => !r.Absent && r.Cells.All(c => c.Value is null))) row.Absent = true; } } // ── Zeile im Punkteraster ────────────────────────────────────────────────── public partial class ExamResultRow : ObservableObject { private readonly Guid _resultId; private readonly List _gradingKey; private readonly double _examMaxPoints; private readonly List _tasks; private readonly GradingService _grading; public Guid StudentId { get; } public string Name { get; } public ObservableCollection Cells { get; } = []; [ObservableProperty] private bool _absent; [ObservableProperty] private string _comment = ""; [ObservableProperty] private double _totalPoints; [ObservableProperty] private string _gradeDisplay = ""; [ObservableProperty] private string _variantName = "A"; public string[] VariantOptions => ["A", "B"]; private ExamVariant Variant => VariantName == "B" ? ExamVariant.B : ExamVariant.A; public string TotalPointsDisplay => TotalPoints.ToString("0.##", CultureInfo.InvariantCulture); public Action? OnChanged { get; set; } public ExamResultRow(Guid studentId, string name, List tasks, ExamResult? existing, List gradingKey, double examMaxPoints, GradingService grading) { StudentId = studentId; Name = name; _gradingKey = gradingKey; _examMaxPoints = examMaxPoints; _grading = grading; _tasks = tasks; _resultId = existing?.Id ?? Guid.NewGuid(); _absent = existing?.Absent ?? false; _comment = existing?.Comment ?? ""; _variantName = existing?.Variant.ToString() ?? "A"; for (var i = 0; i < tasks.Count; i++) { double? pts = existing is not null && i < existing.Points.Count ? existing.Points[i] : null; var cell = new PointsCell(tasks[i].MaxPoints, pts) { IsApplicable = ExamScoringService.AppliesTo(tasks[i], Variant), }; cell.OnChanged = () => { RecomputeTotals(); OnChanged?.Invoke(this); }; Cells.Add(cell); } RecomputeTotals(); } partial void OnAbsentChanged(bool value) { RecomputeTotals(); OnChanged?.Invoke(this); } partial void OnCommentChanged(string value) => OnChanged?.Invoke(this); partial void OnVariantNameChanged(string value) { for (var i = 0; i < Cells.Count; i++) Cells[i].IsApplicable = ExamScoringService.AppliesTo(_tasks[i], Variant); RecomputeTotals(); OnChanged?.Invoke(this); } private void RecomputeTotals() { TotalPoints = Cells.Sum(c => c.IsApplicable && !c.IsInvalid ? (c.Value ?? 0) : 0); OnPropertyChanged(nameof(TotalPointsDisplay)); GradeDisplay = Absent ? "abwesend" : _grading.CalculateGrade(TotalPoints, ExamScoringService.Maximum(_tasks, Variant), _gradingKey); } public ExamResult ToModel(Guid examId) => new() { Id = _resultId, ExamId = examId, StudentId = StudentId, Points = Cells.Select(c => c.Value ?? 0).ToList(), TotalPoints = TotalPoints, Grade = Absent ? null : GradeDisplay, Absent = Absent, Variant = Variant, Comment = string.IsNullOrWhiteSpace(Comment) ? null : Comment.Trim(), }; } // ── Eine Punktezelle ───────────────────────────────────────────────────────── public partial class PointsCell : ObservableObject { public double MaxPoints { get; } [ObservableProperty] private double? _value; [ObservableProperty] private bool _isInvalid; [ObservableProperty] private bool _isApplicable = true; public Action? OnChanged { get; set; } public PointsCell(double maxPoints, double? value) { MaxPoints = maxPoints; _value = value; _isInvalid = IsOutOfRange(value); } /// Setzt den Wert; bei Punkten außerhalb 0..Maximalpunkte wird nur rot markiert, /// aber nicht gespeichert (1.4.5) — OnChanged (und damit Autosave) wird dann nicht ausgelöst. public void TrySetValue(double? value) { Value = value; IsInvalid = IsOutOfRange(value); if (!IsInvalid) OnChanged?.Invoke(); } private bool IsOutOfRange(double? value) => value.HasValue && (value.Value < 0 || value.Value > MaxPoints + 0.0001); }