using System;
using System.Collections.Generic;
using System.Linq;

namespace spplus;

public class CourseCrafter
{
    public class CourseInstance
    {
        public Sport Sport = null!;
        public int Remaining;
        public List<string> Students = new();
    }
    public static List<(int Semester, CourseInstance Instance)> GeneratedCourses 
        = new();

    private static Sport? ResolveSportFromCourseName(string courseName)
    {
        if (string.IsNullOrWhiteSpace(courseName) ||
            string.Equals(courseName, "null", StringComparison.OrdinalIgnoreCase))
        {
            return null;
        }

        return Settings.Instance.Sports.FirstOrDefault(sport =>
            string.Equals(sport.Name, courseName, StringComparison.OrdinalIgnoreCase) ||
            sport.AlternativeNames.Any(alt => string.Equals(alt, courseName, StringComparison.OrdinalIgnoreCase)));
    }

    public static void RebuildGeneratedCoursesFromResults(IEnumerable<Student> importedResults)
    {
        var importedById = importedResults
            .Where(student => !string.IsNullOrWhiteSpace(student.ID))
            .GroupBy(student => student.ID, StringComparer.OrdinalIgnoreCase)
            .ToDictionary(group => group.Key, group => group.First(), StringComparer.OrdinalIgnoreCase);

        var generatedCourses = new Dictionary<(int Semester, string SportName), CourseInstance>();

        foreach (var student in Settings.Instance.Students)
        {
            if (!importedById.TryGetValue(student.ID, out var importedStudent))
                continue;

            for (int semesterIndex = 0; semesterIndex < 4; semesterIndex++)
            {
                if (importedStudent.Result.Length <= semesterIndex)
                    continue;

                var resultName = importedStudent.Result[semesterIndex];
                var sport = ResolveSportFromCourseName(resultName);
                if (sport == null)
                    continue;

                var key = (semesterIndex + 1, sport.Name);
                if (!generatedCourses.TryGetValue(key, out var course))
                {
                    course = new CourseInstance
                    {
                        Sport = sport,
                        Students = new List<string>()
                    };
                    generatedCourses[key] = course;
                }

                if (!course.Students.Contains(student.ID))
                    course.Students.Add(student.ID);
            }
        }

        GeneratedCourses = generatedCourses
            .Select(entry => (Semester: entry.Key.Semester, Instance: entry.Value))
            .OrderBy(course => course.Semester)
            .ThenBy(course => course.Instance.Sport.Name)
            .ToList();
    }

    public static void Craft()
{
    GeneratedCourses = new();
    int globalCount = 0;
    List<(Sport, List<string>)> initial_sportlist = new();
    List<string>[] students_in_semester = new List<string>[4] { new(), new(), new(), new() };
    foreach (var sp in Settings.Instance.Sports)
    {
        initial_sportlist.Add((sp, new()));
    }

    foreach (Student s in Settings.Instance.Students)
    {
        foreach (var sp in s.SelectedCourseNames)
        {
            foreach (var item in initial_sportlist)
            {
                if (item.Item1.AlternativeNames.Contains(sp))
                {
                    item.Item2.Add(s.ID);
                    break;
                }
            }
        }
    }

    while (!requestExit())
    {
        Console.WriteLine($"Calculating... ({globalCount})");
        foreach (var item in initial_sportlist)
        {
            if (item.Item2.Count >= item.Item1.MinStudents)
            {
                int semester = getSemesterForSport(item.Item1, item.Item2);
                if (semester <= 0) goto semeq0;
                var inst = new CourseInstance();
                inst.Sport = item.Item1;
                inst.Students = new List<string>();
                for (int i = item.Item2.Count - 1; i >= 0; i--)
                {
                    if (inst.Students.Count >= inst.Sport.MaxStudents)
                        break;

                    string stud = item.Item2[i];

                    if (!students_in_semester[semester - 1].Contains(stud))
                    {
                        inst.Students.Add(stud);
                        students_in_semester[semester - 1].Add(stud);
                        item.Item2.RemoveAt(i);
                    }
                }
                if (inst.Students.Count < getEffectiveMinStudents(inst.Sport, semester))
                {
                    // Rückgängig machen
                    foreach (var s in inst.Students)
                    {
                        students_in_semester[semester - 1].Remove(s);
                        item.Item2.Add(s);
                    }
                    continue; // Kurs nicht erstellen
                }
                GeneratedCourses.Add((semester, inst));
            }

            semeq0: ;
        }
    }

    FillExistingCourses();

    // Kurs umdisponieren (besser verteilen)
    bool changed;
    int maxIterations = 20;
    int iteration = 0;

    do
    {
        changed = false;
        iteration++;

        var sports = GeneratedCourses
            .GroupBy(c => c.Instance.Sport.Name);

        foreach (var sportGroup in sports)
        {
            var courses = sportGroup.ToList();

            for (int i = 0; i < courses.Count; i++)
            {
                for (int j = 0; j < courses.Count; j++)
                {
                    if (i == j) continue;

                    var cA = courses[i];
                    var cB = courses[j];

                    if (cA.Instance.Students.Count <= cB.Instance.Students.Count + 1)
                        continue;

                    for (int k = cA.Instance.Students.Count - 1; k >= 0; k--)
                    {
                        string stud = cA.Instance.Students[k];

                        if (!isStudentFree(cB.Semester, stud))
                            continue;

                        if (cB.Instance.Students.Count >= cB.Instance.Sport.MaxStudents)
                            continue;

                        // Quellkurs darf nicht unter effektives Min fallen
                        if (cA.Instance.Students.Count - 1 < getEffectiveMinStudents(cA.Instance.Sport, cA.Semester))
                            continue;

                        cA.Instance.Students.RemoveAt(k);
                        students_in_semester[cA.Semester - 1].Remove(stud);

                        cB.Instance.Students.Add(stud);
                        students_in_semester[cB.Semester - 1].Add(stud);

                        changed = true;
                        break;
                    }
                }
            }
        }

    } while (changed && iteration < maxIterations);

    // --- Kurse nachträglich aufteilen, um NumCoursesPerSemester exakt zu erreichen ---
    for (int semester = 1; semester <= 4; semester++)
    {
        int cancel = 0;
        while (GeneratedCourses.Count(c => c.Semester == semester) < Settings.Instance.NumCoursesPerSemester[semester-1])
        {
            cancel++;
            if (cancel >= 20) break;

            var candidate = GeneratedCourses
                .Where(c => c.Semester == semester)
                .Where(c => c.Instance.Students.Count >= getEffectiveMinStudents(c.Instance.Sport, c.Semester) * 2)
                .Where(c =>
                {
                    int sportCount = GeneratedCourses.Count(g =>
                        g.Semester == semester &&
                        g.Instance.Sport.Name == c.Instance.Sport.Name);

                    int allowed = c.Instance.Sport.Semester[semester - 1];
                    return sportCount < allowed;
                })
                .OrderByDescending(c => c.Instance.Students.Count)
                .FirstOrDefault();

            if (candidate.Instance == null)
                break;

            var students = candidate.Instance.Students;
            int totalStudents = students.Count;
            int movedCount = totalStudents / 2;
            int remainingCount = totalStudents - movedCount;

            if (movedCount < getEffectiveMinStudents(candidate.Instance.Sport, candidate.Semester) ||
                remainingCount < getEffectiveMinStudents(candidate.Instance.Sport, candidate.Semester))
            {
                break;
            }

            var newCourse = new CourseInstance
            {
                Sport = candidate.Instance.Sport,
                Students = new List<string>()
            };

            var moved = students
                .Skip(remainingCount)
                .Take(movedCount)
                .ToList();

            foreach (var s in moved)
            {
                candidate.Instance.Students.Remove(s);
                newCourse.Students.Add(s);
            }

            GeneratedCourses.Add((semester, newCourse));
        }
    }

    bool rescueChanged;
    do
    {
        rescueChanged = FillExistingCourses();

        foreach (var item in initial_sportlist)
        {
            if (TryCreateRescueCourse(item.Item1, item.Item2))
            {
                rescueChanged = true;
            }
        }
    } while (rescueChanged);

    OptimizeStudentWishCoverage();

    // --- Ringtausch: Schüler mit 4 Wünschen aber < 4 Zuteilungen neu zuordnen ---
    foreach (var student in Settings.Instance.Students)
    {
        if (student.SelectedCourseNames.Count < 4)
            continue;

        var currentAssignments = GetAssignmentsBySemester(student.ID);
        int currentCount = currentAssignments.Count(a => a != null);

        if (currentCount >= 4)
            continue;

        // Alle aktuellen Zuteilungen entfernen (temporär)
        foreach (var assignment in currentAssignments)
        {
            if (assignment == null) continue;
            assignment.Value.Instance.Students.Remove(student.ID);
            students_in_semester[assignment.Value.Semester - 1].Remove(student.ID);
        }

        // Alle gewünschten Sports ermitteln
        var desiredSports = student.SelectedCourseNames
            .Select(ResolveSportFromSelection)
            .Where(s => s != null)
            .DistinctBy(s => s!.Name)
            .Select(s => s!)
            .ToList();

        // Kandidatenkurse pro Semester: Kurse mit freiem Platz, die einem Wunschsport entsprechen
        var candidatesPerSemester = new List<(int Semester, CourseInstance Instance)>[4];
        for (int si = 0; si < 4; si++)
        {
            candidatesPerSemester[si] = GeneratedCourses
                .Where(c => c.Semester == si + 1)
                .Where(c => c.Instance.Students.Count < c.Instance.Sport.MaxStudents)
                .Where(c => desiredSports.Any(ds => ds.Name == c.Instance.Sport.Name))
                .ToList();
            candidatesPerSemester[si].Insert(0, default); // default = kein Kurs
        }

        (int Semester, CourseInstance Instance)?[] bestAssignment = currentAssignments;
        int bestScore = currentCount;

        int s0 = candidatesPerSemester[0].Count;
        int s1 = candidatesPerSemester[1].Count;
        int s2 = candidatesPerSemester[2].Count;
        int s3 = candidatesPerSemester[3].Count;

        var sportSelectedCounts = student.SelectedCourseNames
            .Select(ResolveSportFromSelection)
            .Where(sp => sp != null)
            .GroupBy(sp => sp!.Name)
            .ToDictionary(g => g.Key, g => g.Count());

        for (int i0 = 0; i0 < s0; i0++)
        for (int i1 = 0; i1 < s1; i1++)
        for (int i2 = 0; i2 < s2; i2++)
        for (int i3 = 0; i3 < s3; i3++)
        {
            var c0 = candidatesPerSemester[0][i0];
            var c1 = candidatesPerSemester[1][i1];
            var c2 = candidatesPerSemester[2][i2];
            var c3 = candidatesPerSemester[3][i3];

            var chosen = new (int Semester, CourseInstance Instance)?[]
            {
                c0.Instance != null ? (c0.Semester, c0.Instance) : null,
                c1.Instance != null ? (c1.Semester, c1.Instance) : null,
                c2.Instance != null ? (c2.Semester, c2.Instance) : null,
                c3.Instance != null ? (c3.Semester, c3.Instance) : null
            };

            bool valid = true;
            var sportUsageCounts = new Dictionary<string, int>();

            for (int si = 0; si < 4; si++)
            {
                if (chosen[si] == null) continue;
                string sportName = chosen[si]!.Value.Instance.Sport.Name;
                sportUsageCounts.TryGetValue(sportName, out int used);
                int allowed = sportSelectedCounts.GetValueOrDefault(sportName, 0);
                if (used >= allowed) { valid = false; break; }
                sportUsageCounts[sportName] = used + 1;
            }

            if (!valid) continue;

            int score = chosen.Count(c => c != null);
            if (score > bestScore)
            {
                bestScore = score;
                bestAssignment = chosen;
            }
        }

        // Beste Zuteilung anwenden
        foreach (var assignment in bestAssignment)
        {
            if (assignment == null) continue;
            assignment.Value.Instance.Students.Add(student.ID);
            students_in_semester[assignment.Value.Semester - 1].Add(student.ID);
        }
    }

    // ---------------------------------------------------------------------------
    // Lokale Hilfsfunktionen
    // ---------------------------------------------------------------------------

    int getEffectiveMinStudents(Sport sport, int semester)
    {
        int reduction = (semester >= 3) ? 2 : 0;
        return Math.Max(1, sport.MinStudents - reduction);
    }

    bool isStudentFree(int semester, string studentID)
    {
        foreach (var inst in GeneratedCourses)
        {
            if (semester != inst.Semester) continue;
            foreach (string stud in inst.Instance.Students)
            {
                if (stud == studentID) return false;
            }
        }
        return true;
    }

    bool requestExit()
    {
        globalCount++;
        int sum = Settings.Instance.NumCoursesPerSemester[0] + Settings.Instance.NumCoursesPerSemester[1] +
                  Settings.Instance.NumCoursesPerSemester[2] + Settings.Instance.NumCoursesPerSemester[3];
        if (GeneratedCourses.Count >= sum) return true;

        int low = 0;
        foreach (var item in initial_sportlist)
        {
            if (item.Item2.Count < item.Item1.MinStudents) low++;
        }

        if (low >= initial_sportlist.Count) return true;
        if (globalCount >= 20) return true;
        return false;
    }

    int total_missing = 0;
    foreach (var tuple in initial_sportlist)
    {
        int[] missingPerSemester = new int[4];
        foreach (var studentId in tuple.Item2.Distinct())
        {
            for (int semesterIndex = 0; semesterIndex < 4; semesterIndex++)
            {
                if (!students_in_semester[semesterIndex].Contains(studentId))
                {
                    missingPerSemester[semesterIndex]++;
                    total_missing++;
                }
            }
        }

        MainWindow.Instance.TbResultTextout.Text +=
            $"{tuple.Item1}: {tuple.Item2.Count} remaining ({missingPerSemester[0]},{missingPerSemester[1]},{missingPerSemester[2]},{missingPerSemester[3]})\n";
    }
    MainWindow.Instance.TbResultTextout.Text += $"\n total remaining: {total_missing}";

    bool FillExistingCourses()
    {
        bool changed = false;

        foreach (var item in initial_sportlist)
        {
            if (item.Item2.Count == 0)
                continue;

            foreach (var ci in GeneratedCourses
                         .Where(ci => ci.Instance.Sport.Name == item.Item1.Name)
                         .OrderBy(ci => ci.Instance.Students.Count))
            {
                int semester = ci.Semester;
                List<string> added = new();

                foreach (string stud in item.Item2)
                {
                    if (ci.Instance.Students.Count >= ci.Instance.Sport.MaxStudents)
                        break;

                    if (students_in_semester[semester - 1].Contains(stud))
                        continue;

                    ci.Instance.Students.Add(stud);
                    students_in_semester[semester - 1].Add(stud);
                    added.Add(stud);
                }

                foreach (string s in added)
                {
                    item.Item2.Remove(s);
                    changed = true;
                }
            }
        }

        return changed;
    }

    bool TryCreateRescueCourse(Sport sport, List<string> remainingStudents)
    {
        if (remainingStudents.Count == 0)
            return false;

        for (int semester = 1; semester <= 4; semester++)
        {
            int semesterIndex = semester - 1;

            if (sport.Semester[semesterIndex] == 0)
                continue;

            int sportCoursesInSemester = GeneratedCourses.Count(c =>
                c.Semester == semester && c.Instance.Sport.Name == sport.Name);
            if (sportCoursesInSemester >= sport.Semester[semesterIndex])
                continue;

            if (GeneratedCourses.Count(c => c.Semester == semester) >= Settings.Instance.NumCoursesPerSemester[semester-1])
                continue;

            var directlyPlaceable = remainingStudents
                .Distinct()
                .Where(studentId => !students_in_semester[semesterIndex].Contains(studentId))
                .ToList();

            var donorMoves = new List<((int Semester, CourseInstance Instance) Course, string StudentId)>();
            foreach (var course in GeneratedCourses
                         .Where(c => c.Instance.Sport.Name == sport.Name && c.Semester != semester)
                         .OrderByDescending(c => c.Instance.Students.Count))
            {
                int movableCount = course.Instance.Students.Count - getEffectiveMinStudents(sport, course.Semester);
                if (movableCount <= 0)
                    continue;

                foreach (var studentId in course.Instance.Students.ToList())
                {
                    if (movableCount <= 0)
                        break;

                    if (students_in_semester[semesterIndex].Contains(studentId))
                        continue;

                    donorMoves.Add((course, studentId));
                    movableCount--;
                }
            }

            if (directlyPlaceable.Count + donorMoves.Count < getEffectiveMinStudents(sport, semester))
                continue;

            var newCourse = new CourseInstance
            {
                Sport = sport,
                Students = new List<string>()
            };

            foreach (var studentId in directlyPlaceable)
            {
                if (newCourse.Students.Count >= sport.MaxStudents)
                    break;

                newCourse.Students.Add(studentId);
            }

            foreach (var move in donorMoves)
            {
                if (newCourse.Students.Count >= sport.MaxStudents)
                    break;

                if (newCourse.Students.Contains(move.StudentId))
                    continue;

                move.Course.Instance.Students.Remove(move.StudentId);
                students_in_semester[move.Course.Semester - 1].Remove(move.StudentId);
                newCourse.Students.Add(move.StudentId);
            }

            if (newCourse.Students.Count < getEffectiveMinStudents(sport, semester))
                continue;

            foreach (var studentId in newCourse.Students)
            {
                remainingStudents.Remove(studentId);
                students_in_semester[semesterIndex].Add(studentId);
            }

            GeneratedCourses.Add((semester, newCourse));
            return true;
        }

        return false;
    }

    void OptimizeStudentWishCoverage()
    {
        bool changed;
        int iterations = 0;

        do
        {
            changed = false;
            iterations++;

            foreach (var student in Settings.Instance.Students)
            {
                if (TryImproveStudentCoverage(student))
                {
                    changed = true;
                }
            }
        } while (changed && iterations < 20);
    }

    bool TryImproveStudentCoverage(Student student)
    {
        var assignments = GetAssignmentsBySemester(student.ID);
        if (assignments.All(a => a != null))
            return false;

        var openSemesters = Enumerable.Range(0, 4)
            .Where(i => assignments[i] == null)
            .Select(i => i + 1)
            .ToList();
        if (openSemesters.Count == 0)
            return false;

        var assignedSports = assignments
            .Where(a => a != null)
            .Select(a => a!.Value.Instance.Sport.Name)
            .ToHashSet();

        var preferredSports = student.SelectedCourseNames
            .Select(ResolveSportFromSelection)
            .Where(sport => sport != null)
            .DistinctBy(sport => sport!.Name)
            .Select(sport => sport!)
            .Where(sport => !assignedSports.Contains(sport.Name))
            .ToList();

        foreach (var desiredSport in preferredSports)
        {
            for (int sourceSemester = 1; sourceSemester <= 4; sourceSemester++)
            {
                var currentCourse = assignments[sourceSemester - 1];
                if (currentCourse == null)
                    continue;

                var currentCourseValue = currentCourse.Value;

                var desiredCourse = GeneratedCourses
                    .FirstOrDefault(course =>
                        course.Semester == sourceSemester &&
                        course.Instance.Sport.Name == desiredSport.Name &&
                        course.Instance.Students.Count < course.Instance.Sport.MaxStudents);

                if (desiredCourse.Instance == null)
                    continue;

                foreach (var targetSemester in openSemesters)
                {
                    var relocationTarget = GeneratedCourses
                        .FirstOrDefault(course =>
                            course.Semester == targetSemester &&
                            course.Instance.Sport.Name == currentCourseValue.Instance.Sport.Name &&
                            course.Instance.Students.Count < course.Instance.Sport.MaxStudents);

                    if (relocationTarget.Instance == null)
                        continue;

                    if (!CanRelocateStudent(student.ID, currentCourseValue, relocationTarget))
                        continue;

                    currentCourseValue.Instance.Students.Remove(student.ID);
                    students_in_semester[sourceSemester - 1].Remove(student.ID);

                    relocationTarget.Instance.Students.Add(student.ID);
                    students_in_semester[targetSemester - 1].Add(student.ID);

                    desiredCourse.Instance.Students.Add(student.ID);
                    students_in_semester[sourceSemester - 1].Add(student.ID);

                    return true;
                }
            }
        }

        return false;
    }

    bool CanRelocateStudent(
        string studentId,
        (int Semester, CourseInstance Instance) sourceCourse,
        (int Semester, CourseInstance Instance) targetCourse)
    {
        if (sourceCourse.Semester == targetCourse.Semester)
            return false;

        if (sourceCourse.Instance.Students.Count - 1 < getEffectiveMinStudents(sourceCourse.Instance.Sport, sourceCourse.Semester))
            return false;

        if (targetCourse.Instance.Students.Count >= targetCourse.Instance.Sport.MaxStudents)
            return false;

        if (!isStudentFree(targetCourse.Semester, studentId))
            return false;

        return true;
    }

    (int Semester, CourseInstance Instance)?[] GetAssignmentsBySemester(string studentId)
    {
        var assignments = new (int Semester, CourseInstance Instance)?[4];

        foreach (var course in GeneratedCourses)
        {
            if (course.Instance.Students.Contains(studentId))
            {
                assignments[course.Semester - 1] = course;
            }
        }

        return assignments;
    }

    Sport? ResolveSportFromSelection(string selectedCourseName)
    {
        return ResolveSportFromCourseName(selectedCourseName);
    }

    int getSemesterForSport(Sport sp, List<string> interestedStudents)
    {
        int[] totalCoursesPerSemester = new int[4];
        foreach (var inst in GeneratedCourses)
            totalCoursesPerSemester[inst.Semester - 1]++;

        int bestSem = 0;
        int minCourses = int.MaxValue;
        int maxFreeInterestedStudents = -1;

        for (int i = 0; i < 4; i++)
        {
            if (sp.Semester[i] == 0)
                continue;

            int semesterNumber = i + 1;

            int sportCoursesInThisSemester = GeneratedCourses
                .Count(g => g.Semester == semesterNumber &&
                            g.Instance.Sport.Name == sp.Name);

            if (sportCoursesInThisSemester >= sp.Semester[i])
                continue;

            if (totalCoursesPerSemester[i] >= Settings.Instance.NumCoursesPerSemester[i])
                continue;

            int freeInterestedStudents = interestedStudents
                .Distinct()
                .Count(studentId => !students_in_semester[i].Contains(studentId));

            if (freeInterestedStudents < getEffectiveMinStudents(sp, semesterNumber))
                continue;

            if (freeInterestedStudents > maxFreeInterestedStudents ||
                (freeInterestedStudents == maxFreeInterestedStudents &&
                 totalCoursesPerSemester[i] < minCourses))
            {
                maxFreeInterestedStudents = freeInterestedStudents;
                minCourses = totalCoursesPerSemester[i];
                bestSem = semesterNumber;
            }
        }

        return bestSem;
    }

    ReloadResult();
}

    public static void ReloadResult()
    {
        var errors = ValidateCourses(GeneratedCourses);

        if (errors.Count == 0)
        {
            MainWindow.Instance.TbResultLog.Text = "--- Alle generierten Kursen erfüllen die gegebenen Voraussetzungen ---";
        }
        else
        {
            MainWindow.Instance.TbResultLog.Text = "--- Bei der Generierung sind folgende Fehler aufgetreten: ---\n\n";
            foreach (var e in errors)
                MainWindow.Instance.TbResultLog.Text += e + "\n";
        }

        foreach (var student in Settings.Instance.Students)
        {
            student.Result = new string[4];
        }

        foreach (var course in GeneratedCourses)
        {
            foreach (var student in Settings.Instance.Students)
            {
                if (course.Instance.Students.Contains(student.ID))
                {
                    student.Result[course.Semester - 1] = course.Instance.Sport.Name;
                }
            }
        }
    }
    public static string GenerateStatistics()
    {
        GeneratedCourses.Sort((x,y) => x.Semester.CompareTo(y.Semester) );
        string sb = $"Generierte Kurse: {GeneratedCourses.Count}\n\n";
        foreach (var genc in GeneratedCourses)
        {
            sb += $"Sem. {genc.Semester}: {genc.Instance.Sport.Name} ({genc.Instance.Students.Count} SuS)\n";
        }
        
        

        return sb;
    }
    
    public static List<string> ValidateCourses(List<(int Semester, CourseInstance Instance)> courses)
    {
        List<string> errors = new();

        // --- 1. Min/Max + Semester erlaubt ---
        foreach (var tuple in courses)
        {
            int semester = tuple.Semester;
            var inst = tuple.Instance;
            var sport = inst.Sport;

            if (inst.Students.Count < sport.MinStudents)
            {
                errors.Add($"[Min] {sport.Name} (Sem {semester}): {inst.Students.Count} < {sport.MinStudents}");
            }

            if (inst.Students.Count > sport.MaxStudents)
            {
                errors.Add($"[Max] {sport.Name} (Sem {semester}): {inst.Students.Count} > {sport.MaxStudents}");
            }

            if (sport.Semester[semester - 1] == 0)
            {
                errors.Add($"[Semester] {sport.Name} darf nicht in Semester {semester} stattfinden");
            }

            // --- doppelte Schüler im selben Kurs ---
            for (int i = 0; i < inst.Students.Count; i++)
            {
                for (int j = i + 1; j < inst.Students.Count; j++)
                {
                    if (inst.Students[i] == inst.Students[j])
                    {
                        errors.Add($"[Kurs-Duplikat] {inst.Students[i]} mehrfach in {sport.Name} (Sem {semester})");
                    }
                }
            }
        }

        // --- 2. Schüler doppelt im Semester ---
        for (int sem = 1; sem <= 4; sem++)
        {
            List<string> students = new();

            foreach (var tuple in courses)
            {
                if (tuple.Semester != sem) continue;

                foreach (var stud in tuple.Instance.Students)
                {
                    // prüfen ob schon drin
                    bool exists = false;
                    foreach (var s in students)
                    {
                        if (s == stud)
                        {
                            exists = true;
                            break;
                        }
                    }

                    if (exists)
                    {
                        errors.Add($"[Doppelt] Schüler {stud} doppelt in Semester {sem}");
                    }
                    else
                    {
                        students.Add(stud);
                    }
                }
            }
        }

        // --- 3. Sport-Angebote pro Semester zählen ---
        // (ohne Dictionary: wir iterieren über alle Kurse und zählen jeweils erneut)

        foreach (var tuple in courses)
        {
            int semester = tuple.Semester;
            var sport = tuple.Instance.Sport;

            int count = 0;

            foreach (var other in courses)
            {
                if (other.Semester == semester &&
                    other.Instance.Sport.Name == sport.Name)
                {
                    count++;
                }
            }

            int allowed = sport.Semester[semester - 1];

            if (count > allowed)
            {
                errors.Add($"[Sport-Semester] {sport.Name} in Sem {semester}: {count} Kurse > erlaubt {allowed}");
            }
        }

        return errors;
    }
}