using HSchool.Content;

namespace HSchool.People.Tests;

public class ClassTeacherTests
{
    private const float Cap = 100_000f;

    [Fact]
    public void Assign_WritesIdIntoRoster_AndSurvivesPeopleJsonRoundTrip()
    {
        var (catalog, map, roster, pool) = Fresh();
        var hired = HireTeacher(catalog, map, roster, pool);
        var schoolClass = hired.Roster.Classes[0];

        var assigned = ClassTeachers.Assign(hired.Roster, schoolClass.Id, hired.TeacherId);
        Assert.Equal(ClassTeacherError.None, assigned.Error);
        Assert.Equal(hired.TeacherId, assigned.Roster.Classes.Single(row => row.Id == schoolClass.Id).ClassTeacherId);

        var json = RosterJson.Serialize(RosterDocument.From(Fixtures.SchoolSeed, assigned.Roster, hired.Pool));
        var loaded = RosterJson.Parse(json);
        Assert.Equal(hired.TeacherId, loaded.Classes.Single(row => row.Id == schoolClass.Id).ClassTeacherId);
    }

    [Fact]
    public void Assign_RejectsNonTeacherAndUnknownPerson()
    {
        var (catalog, map, roster, pool) = Fresh();
        var hired = HireTeacher(catalog, map, roster, pool);
        var schoolClass = hired.Roster.Classes[0];
        var pupil = Assert.Single(hired.Roster.People.Where(person => person.IsStudent).Take(1));

        Assert.Equal(
            ClassTeacherError.NotTeacher,
            ClassTeachers.Assign(hired.Roster, schoolClass.Id, pupil.Id).Error);
        Assert.Equal(
            ClassTeacherError.UnknownPerson,
            ClassTeachers.Assign(hired.Roster, schoolClass.Id, "nobody").Error);
        Assert.Null(hired.Roster.Classes.Single(row => row.Id == schoolClass.Id).ClassTeacherId);
    }

    [Fact]
    public void Clear_EmptiesSlot_AndClassWithoutTeacherIsValid()
    {
        var (catalog, map, roster, pool) = Fresh();
        var hired = HireTeacher(catalog, map, roster, pool);
        var schoolClass = hired.Roster.Classes[0];
        var assigned = ClassTeachers.Assign(hired.Roster, schoolClass.Id, hired.TeacherId);
        Assert.Equal(ClassTeacherError.None, assigned.Error);

        var cleared = ClassTeachers.Clear(assigned.Roster, schoolClass.Id);
        Assert.Equal(ClassTeacherError.None, cleared.Error);
        Assert.Null(cleared.Roster.Classes.Single(row => row.Id == schoolClass.Id).ClassTeacherId);
        Assert.Contains(cleared.Roster.Classes, row => row.Id == schoolClass.Id);
    }

    [Fact]
    public void TwoClasses_MayShareTheSameTeacher()
    {
        var (catalog, map, roster, pool) = Fresh();
        var hired = HireTeacher(catalog, map, roster, pool);
        Assert.True(hired.Roster.Classes.Count >= 2);

        var first = hired.Roster.Classes[0];
        var second = hired.Roster.Classes[1];
        var one = ClassTeachers.Assign(hired.Roster, first.Id, hired.TeacherId);
        Assert.Equal(ClassTeacherError.None, one.Error);
        var two = ClassTeachers.Assign(one.Roster, second.Id, hired.TeacherId);
        Assert.Equal(ClassTeacherError.None, two.Error);

        Assert.Equal(hired.TeacherId, two.Roster.Classes.Single(row => row.Id == first.Id).ClassTeacherId);
        Assert.Equal(hired.TeacherId, two.Roster.Classes.Single(row => row.Id == second.Id).ClassTeacherId);
    }

    private static (DefCatalog Catalog, MapLayout Map, Roster Roster, ApplicantPool Pool) Fresh()
    {
        var catalog = Fixtures.Catalog();
        var map = Fixtures.VanillaMap();
        var roster = Fixtures.Generate(map);
        var pool = ApplicantPool.Create(catalog, roster, Fixtures.SchoolSeed, "Russia", Fixtures.AsOf);
        return (catalog, map, roster, pool);
    }

    private static (Roster Roster, ApplicantPool Pool, string TeacherId) HireTeacher(
        DefCatalog catalog,
        MapLayout map,
        Roster roster,
        ApplicantPool pool)
    {
        var applicant = pool.Applicants[0];
        var hired = Staffing.Hire(catalog, map, roster, pool, applicant.Person.Id, Staffing.TeacherPosition, Cap);
        Assert.Equal(StaffingError.None, hired.Error);
        return (hired.Roster, hired.Pool, applicant.Person.Id);
    }
}