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

namespace LehrerApp.Tests;

public sealed class CompetencyAnalysisServiceTests
{
    private readonly CompetencyAnalysisService _service = new();

    [Fact]
    public void Analyze_UnterscheidetPlanungBehandlungUndPruefung()
    {
        var groupId = Guid.NewGuid();
        var catalog = Catalog();
        var units = new List<Unit>
        {
            new() { GroupId = groupId, Status = UnitStatus.Planned, Competencies = ["K1"] },
            new() { GroupId = groupId, Status = UnitStatus.Active, Competencies = ["K1"] },
            new() { GroupId = groupId, Status = UnitStatus.Completed, Competencies = ["K1"] },
        };
        var exams = new List<Exam>
        {
            new() { GroupId = groupId, Status = ExamStatus.Planned,
                Tasks = [new ExamTask { MaxPoints = 10, CompetencyCodes = ["K1"] }] },
            new() { GroupId = groupId, Status = ExamStatus.Graded,
                Tasks = [new ExamTask { MaxPoints = 10, CompetencyCodes = ["K1"] }] },
        };

        var item = Assert.Single(_service.Analyze(catalog, units, exams, []));

        Assert.Equal(1, item.PlannedUnitCount);
        Assert.Equal(2, item.TaughtUnitCount);
        Assert.Equal(1, item.PlannedExamCount);
        Assert.Equal(1, item.AssessedExamCount);
    }

    [Fact]
    public void Analyze_BerechnetGewichteteGruppenUndSchuelerprofileAusAufgabenpunkten()
    {
        var firstStudent = Guid.NewGuid();
        var secondStudent = Guid.NewGuid();
        var absentStudent = Guid.NewGuid();
        var exam = new Exam
        {
            Status = ExamStatus.Graded,
            Tasks =
            [
                new ExamTask { MaxPoints = 10, CompetencyCodes = ["K1"] },
                new ExamTask { MaxPoints = 20, CompetencyCodes = ["K1"] },
            ],
        };
        var results = new List<ExamResult>
        {
            new() { ExamId = exam.Id, StudentId = firstStudent, Points = [5, 10] },
            new() { ExamId = exam.Id, StudentId = secondStudent, Points = [10, 20] },
            new() { ExamId = exam.Id, StudentId = absentStudent, Points = [0, 0], Absent = true },
        };

        var item = Assert.Single(_service.Analyze(Catalog(), [], [exam], results));

        Assert.NotNull(item.GroupScore);
        Assert.Equal(75, item.GroupScore.Percent, 6);
        Assert.Equal(2, item.GroupScore.ParticipantCount);
        Assert.Equal(4, item.GroupScore.EvidenceCount);
        Assert.Equal(50, item.StudentScores[firstStudent].Percent, 6);
        Assert.Equal(100, item.StudentScores[secondStudent].Percent, 6);
        Assert.False(item.StudentScores.ContainsKey(absentStudent));
    }

    [Fact]
    public void Analyze_AufgabeMitMehrerenCodes_WertetJedeZugeordneteKompetenzAus()
    {
        var studentId = Guid.NewGuid();
        var exam = new Exam
        {
            Status = ExamStatus.Returned,
            Tasks = [new ExamTask { MaxPoints = 8, CompetencyCodes = ["K1", "K2"] }],
        };
        var result = new ExamResult { ExamId = exam.Id, StudentId = studentId, Points = [6] };

        var analysis = _service.Analyze(Catalog(includeSecond: true), [], [exam], [result]);

        Assert.All(analysis, item => Assert.Equal(75, item.StudentScores[studentId].Percent, 6));
    }

    [Fact]
    public void Analyze_DurchgefuehrteAberNichtKorrigierteKlausur_LiefertNochKeinProfil()
    {
        var studentId = Guid.NewGuid();
        var exam = new Exam
        {
            Status = ExamStatus.Conducted,
            Tasks = [new ExamTask { MaxPoints = 10, CompetencyCodes = ["K1"] }],
        };
        var result = new ExamResult { ExamId = exam.Id, StudentId = studentId, Points = [5] };

        var item = Assert.Single(_service.Analyze(Catalog(), [], [exam], [result]));

        Assert.Equal(1, item.AssessedExamCount);
        Assert.Null(item.GroupScore);
        Assert.Empty(item.StudentScores);
    }

    [Fact]
    public void Analyze_VerwendeterUnbekannterCode_BleibtInUebersichtSichtbar()
    {
        var unit = new Unit { Status = UnitStatus.Active, Competencies = ["ALT1"] };

        var analysis = _service.Analyze(Catalog(), [unit], [], []);

        var unknown = Assert.Single(analysis, x => x.Code == "ALT1");
        Assert.Equal("Nicht im Katalog", unknown.DomainName);
        Assert.Equal(1, unknown.TaughtUnitCount);
    }

    private static List<CompetencyDomain> Catalog(bool includeSecond = false) =>
    [
        new CompetencyDomain
        {
            Name = "Bereich",
            Code = "B",
            Items = includeSecond
                ?
                [
                    new CompetencyItem { Code = "K1", Description = "Erste Kompetenz", SortOrder = 0 },
                    new CompetencyItem { Code = "K2", Description = "Zweite Kompetenz", SortOrder = 1 },
                ]
                : [new CompetencyItem { Code = "K1", Description = "Erste Kompetenz" }],
        },
    ];
}