using Core.Entities;
using Core.Printing;
using Tests.Builders;

namespace Tests.Printing;

[TestFixture]
public class PrintRankBadgeHtml_Tests
{
    [Test]
    public void ForStudentEvents_Empty_IsEmpty()
    {
        Assert.That(PrintRankBadgeHtml.ForStudentEvents([]), Is.EqualTo(string.Empty));
        Assert.That(PrintRankBadgeHtml.ForStudentEvents(null), Is.EqualTo(string.Empty));
    }

    [Test]
    public void ForStudentEvents_RendersShortNameDotAndAttributes()
    {
        var coding = EventDefinitionBuilder.Individual("Coding")
            .WithShortName("Code")
            .AsRegionalEvent()
            .Build();
        var student = StudentBuilder.Create("Aria", "Cole")
            .WithRanking(coding, 1)
            .Build();

        var html = PrintRankBadgeHtml.ForStudentEvents(student.EventRankings);

        Assert.That(html, Does.Contain("print-rank-badges"));
        Assert.That(html, Does.Contain("event-rank-1"));
        Assert.That(html, Does.Contain("Code"));
        Assert.That(html, Does.Contain(EventAttributeMarks.Individual));
        Assert.That(html, Does.Contain(EventAttributeMarks.Regional));
        Assert.That(html, Does.Not.Contain("{{"));
    }

    [Test]
    public void ForEventStudents_SortsByRankThenSeniority()
    {
        var evt = EventDefinitionBuilder.Individual("Coding").Build();
        var younger = StudentBuilder.Create("Bea", "Young").Build();
        younger.Grade = 9;
        younger.TsaYear = 1;
        var older = StudentBuilder.Create("Aria", "Cole").Build();
        older.Grade = 12;
        older.TsaYear = 4;

        var rankings = new List<StudentEventRanking>
        {
            new() { Student = younger, EventDefinition = evt, Rank = 1 },
            new() { Student = older, EventDefinition = evt, Rank = 1 }
        };

        var html = PrintRankBadgeHtml.ForEventStudents(rankings);
        var ariaAt = html.IndexOf("Aria", StringComparison.Ordinal);
        var beaAt = html.IndexOf("Bea", StringComparison.Ordinal);

        Assert.That(ariaAt, Is.GreaterThanOrEqualTo(0));
        Assert.That(beaAt, Is.GreaterThan(ariaAt));
    }

    [Test]
    public void EventAttributeMarks_IncludesEffortAndFlags()
    {
        var evt = EventDefinitionBuilder.Individual("Coding")
            .AsOnSite()
            .AsRegionalEvent()
            .WithPresubmission()
            .WithLevelOfEffort(2)
            .Build();

        var marks = EventAttributeMarks.For(evt);

        Assert.That(marks, Does.Contain(EventAttributeMarks.LevelOfEffort2));
        Assert.That(marks, Does.Contain(EventAttributeMarks.Individual));
        Assert.That(marks, Does.Contain(EventAttributeMarks.OnSite));
        Assert.That(marks, Does.Contain(EventAttributeMarks.Regional));
        Assert.That(marks, Does.Contain(EventAttributeMarks.Presubmission));
    }

    [Test]
    public void EscapeHtml_MasksTags()
    {
        Assert.That(PrintTokenMap.EscapeHtml("A <b>"), Is.EqualTo("A &lt;b&gt;"));
    }

    [Test]
    public void For_UsesTheSameMarksAsTheLegend()
    {
        var evt = EventDefinitionBuilder.Individual("Coding")
            .AsOnSite()
            .AsRegionalEvent()
            .WithPresubmission()
            .WithLevelOfEffort(2)
            .Build();

        var fromCatalog = string.Join(
            " ",
            EventAttributeMarks.LegendItems.Where(m => m.Applies(evt)).Select(m => m.Symbol));

        Assert.That(EventAttributeMarks.For(evt), Is.EqualTo(fromCatalog));
    }

    [Test]
    public void Legend_IncludesRankDotsAndAttributeMarks()
    {
        var html = PrintRankBadgeHtml.Legend();

        Assert.That(html, Does.Contain("print-badge-legend"));
        Assert.That(html, Does.Contain("&middot;"));
        Assert.That(html, Does.Not.Contain(EventRankLegend.Ordinal(1)));
        Assert.That(html, Does.Not.Contain("event-rank-1"));
        foreach (var mark in EventAttributeMarks.LegendItems)
        {
            Assert.That(html, Does.Contain(mark.Symbol));
            Assert.That(html, Does.Contain(mark.Label));
        }
    }
}