namespace HSchool.People.Tests;

public class OpinionGeneratorTests
{
    [Fact]
    public void ParentAndChild_HavePositiveOpinionsBothWays_AfterGeneration()
    {
        var roster = Fixtures.Generate(Fixtures.Classrooms(4));
        var people = roster.People.ToDictionary(person => person.Id, StringComparer.Ordinal);

        var child = roster.People.First(person => person.IsStudent && !person.IsParent);
        var family = roster.Families.Single(row => row.Id.Equals(child.FamilyId, StringComparison.Ordinal));
        Assert.NotEmpty(family.ParentIds);

        foreach (var parentId in family.ParentIds)
        {
            Assert.True(child.Opinions.TryGetValue(parentId, out var toParent));
            Assert.True(toParent > 0);

            var parent = people[parentId];
            Assert.True(parent.Opinions.TryGetValue(child.Id, out var toChild));
            Assert.True(toChild > 0);
        }
    }

    [Fact]
    public void Classmates_HaveNoOpinionEntry_AfterGeneration()
    {
        var roster = Fixtures.Generate(Fixtures.Classrooms(4));
        var pupils = roster.People.Where(person => person.IsStudent).ToArray();
        Assert.True(pupils.Length >= 2);

        var first = pupils[0];
        var classmate = pupils.First(person =>
            person.Id != first.Id
            && !OpinionStore.FamilyMemberIds(roster, first).Contains(person.Id));

        Assert.False(first.Opinions.ContainsKey(classmate.Id));
        Assert.False(classmate.Opinions.ContainsKey(first.Id));
    }

    [Fact]
    public void ParentToChild_AndChildToParent_CanDiffer()
    {
        var roster = Fixtures.Generate(Fixtures.Classrooms(4));
        var people = roster.People.ToDictionary(person => person.Id, StringComparer.Ordinal);
        var child = roster.People.First(person => person.IsStudent && !person.IsParent);
        var parentId = roster.Families.Single(row => row.Id.Equals(child.FamilyId, StringComparison.Ordinal)).ParentIds[0];
        var parent = people[parentId];

        Assert.True(parent.Opinions.TryGetValue(child.Id, out var parentView));
        Assert.True(child.Opinions.TryGetValue(parentId, out var childView));
        Assert.NotEqual(parentView, childView);
    }

    [Fact]
    public void RosterJson_RoundTripsFamilyOpinions()
    {
        var roster = Fixtures.Generate(Fixtures.Classrooms(4));
        var child = roster.People.First(person => person.IsStudent && !person.IsParent);
        var parentId = roster.Families.Single(row => row.Id.Equals(child.FamilyId, StringComparison.Ordinal)).ParentIds[0];
        Assert.True(child.Opinions.TryGetValue(parentId, out var before));

        var loaded = RosterJson.Parse(RosterJson.Serialize(RosterDocument.From(1, roster))).ToRoster();
        var loadedChild = loaded.People.First(person => person.Id.Equals(child.Id, StringComparison.Ordinal));
        Assert.Equal(before, loadedChild.Opinions[parentId]);
    }

    [Fact]
    public void RosterJson_RoundTripsBullyVictimId()
    {
        var roster = Fixtures.Generate(Fixtures.Classrooms(4));
        var bully = roster.People.First(person => person.IsStudent && !person.IsParent);
        var victim = roster.People.First(person =>
            person.IsStudent && !person.Id.Equals(bully.Id, StringComparison.Ordinal));
        bully.BullyVictimId = victim.Id;

        var json = RosterJson.Serialize(RosterDocument.From(1, roster));
        Assert.Contains("\"bullyVictimId\"", json, StringComparison.Ordinal);
        var loaded = RosterJson.Parse(json).ToRoster();
        var loadedBully = loaded.People.First(person => person.Id.Equals(bully.Id, StringComparison.Ordinal));
        Assert.Equal(victim.Id, loadedBully.BullyVictimId);
    }

    [Fact]
    public void SaveWithoutOpinionsField_SeedsFamilyOnLoad()
    {
        var roster = Fixtures.Generate(Fixtures.Classrooms(4));
        var json = RosterJson.Serialize(RosterDocument.From(1, roster));
        var node = System.Text.Json.Nodes.JsonNode.Parse(json)!;
        foreach (var person in node["people"]!.AsArray())
        {
            person!.AsObject().Remove("opinions");
        }

        var stripped = RosterJson.Parse(node.ToJsonString()).ToRoster();
        Assert.True(OpinionGenerator.NeedsFamilyOpinions(stripped));
        Assert.All(stripped.People, person => Assert.Empty(person.Opinions));

        var seeded = OpinionGenerator.SeedFamily(Fixtures.Catalog(), stripped);
        Assert.False(OpinionGenerator.NeedsFamilyOpinions(seeded));
        var child = seeded.People.First(person => person.IsStudent && !person.IsParent);
        var family = seeded.Families.Single(row => row.Id.Equals(child.FamilyId, StringComparison.Ordinal));
        Assert.NotEmpty(family.ParentIds);
        foreach (var parentId in family.ParentIds)
        {
            Assert.True(child.Opinions.TryGetValue(parentId, out var toParent));
            Assert.True(toParent > 0);
        }
    }
}