using Arch.Core;
using HSchool.Ai;
using HSchool.Content;
using HSchool.People;
using HSchool.Protocol;
using HSchool.Simulation;

namespace HSchool.Simulation.Tests;

public class DirectorSummonTests
{
    private static readonly DateTime TuesdayMorning = new(2012, 4, 3, 6, 0, 0, DateTimeKind.Utc);

    [Fact]
    public void FightBrokenByStaff_WithPrincipal_SummonsPupils()
    {
        var (school, first, second, _) = TwoPupilsPrincipalAndTeacherOnBreak();
        using (school)
        {
            BreakFight(school, first, second);
            Assert.True(DirectorSummonSystem.IsSummoned(school, first.Id));
            Assert.True(DirectorSummonSystem.IsSummoned(school, second.Id));
            Assert.Equal(2, school.DirectorSummons.Count);
        }
    }

    [Fact]
    public void TwoSummoned_OneInOffice_OtherWaitsInCorridor()
    {
        var (school, first, second, _) = TwoPupilsPrincipalAndTeacherOnBreak();
        using (school)
        {
            Assert.True(DirectorSummonSystem.TryEnqueue(school, first.Id, chance: 1f));
            Assert.True(DirectorSummonSystem.TryEnqueue(school, second.Id, chance: 1f));
            DirectorSummonSystem.Apply(school);

            var ordered = school.DirectorSummons.OrderBy(row => row.Order).ToArray();
            Assert.Equal(2, ordered.Length);
            Assert.True(ordered[0].Admitted);
            Assert.False(ordered[1].Admitted);

            Assert.True(DirectorSummonSystem.TryDutyRoom(school, ordered[0].PersonId, out var admittedDuty));
            Assert.Equal("principals-office", admittedDuty);
            Assert.True(DirectorSummonSystem.TryDutyRoom(school, ordered[1].PersonId, out var waitingDuty));
            Assert.Equal("corridor-1", waitingDuty);

            PlaceAt(school, ordered[0].PersonId, "principals-office");
            PlaceAt(school, ordered[1].PersonId, "corridor-1");
            Assert.Equal("principals-office", NodeOf(school, ordered[0].PersonId));
            Assert.Equal("corridor-1", NodeOf(school, ordered[1].PersonId));
            Assert.False(
                "principals-office".Equals(NodeOf(school, ordered[1].PersonId), StringComparison.Ordinal));
        }
    }

    [Fact]
    public void FreeingOffice_AdmitsNextFromQueue()
    {
        var (school, first, second, _) = TwoPupilsPrincipalAndTeacherOnBreak();
        using (school)
        {
            Assert.True(DirectorSummonSystem.TryEnqueue(school, first.Id, chance: 1f));
            Assert.True(DirectorSummonSystem.TryEnqueue(school, second.Id, chance: 1f));
            DirectorSummonSystem.Apply(school);

            var head = school.DirectorSummons.OrderBy(row => row.Order).First();
            var next = school.DirectorSummons.OrderBy(row => row.Order).Skip(1).First();
            PlaceAt(school, head.PersonId, "principals-office");
            DirectorSummonSystem.Apply(school);
            Assert.True(ActivitySystem.IsPrincipalHearing(ActivityOf(school, head.PersonId)));

            DirectorSummonSystem.CompleteHearing(school, head.PersonId);
            DirectorSummonSystem.Apply(school);

            Assert.False(DirectorSummonSystem.IsSummoned(school, head.PersonId));
            Assert.True(DirectorSummonSystem.IsSummoned(school, next.PersonId));
            var remaining = Assert.Single(school.DirectorSummons);
            Assert.True(remaining.Admitted);
            Assert.Equal(next.PersonId, remaining.PersonId);
        }
    }

    [Fact]
    public void SameSeedAndEvents_SameQueueOrder()
    {
        var firstOrder = QueueOrderFromFight(seed: 42);
        var secondOrder = QueueOrderFromFight(seed: 42);
        Assert.Equal(firstOrder, secondOrder);
        Assert.Equal(2, firstOrder.Count);
    }

    [Fact]
    public void WithoutPrincipal_SummonDoesNotHangForever()
    {
        var (school, first, second, _) = TwoPupilsAndStaffOnBreak();
        using (school)
        {
            Assert.False(DirectorSummons.HasHiredPrincipal(school.Roster!));
            BreakFight(school, first, second);
            Assert.Empty(school.DirectorSummons);
            Assert.False(DirectorSummonSystem.IsSummoned(school, first.Id));
            Assert.False(DirectorSummonSystem.TryEnqueue(school, first.Id, chance: 1f));
            Assert.Empty(school.DirectorSummons);
        }
    }

    [Fact]
    public void PlayerCannotSendSummon_NoProtocolIntent()
    {
        Assert.DoesNotContain(
            Enum.GetNames<MessageType>(),
            name => name.Contains("Summon", StringComparison.OrdinalIgnoreCase));
        Assert.DoesNotContain(
            typeof(School).GetMethods(System.Reflection.BindingFlags.Instance | System.Reflection.BindingFlags.Public),
            method => method.Name.StartsWith("Set", StringComparison.Ordinal)
                && method.Name.Contains("Summon", StringComparison.OrdinalIgnoreCase));
        Assert.DoesNotContain(
            typeof(School).GetMethods(System.Reflection.BindingFlags.Instance | System.Reflection.BindingFlags.Public),
            method => method.Name.StartsWith("Send", StringComparison.Ordinal)
                && method.Name.Contains("Summon", StringComparison.OrdinalIgnoreCase));
        Assert.DoesNotContain(
            typeof(School).GetMethods(System.Reflection.BindingFlags.Instance | System.Reflection.BindingFlags.Public),
            method => method.Name.StartsWith("Enqueue", StringComparison.Ordinal)
                && method.Name.Contains("Summon", StringComparison.OrdinalIgnoreCase));
    }

    [Fact]
    public void WaitNode_IsCorridorAdjacentToOffice()
    {
        var (_, map) = Vanilla();
        Assert.Equal("principals-office", DirectorSummons.OfficeNodeId(map));
        Assert.Equal("corridor-1", DirectorSummons.WaitNodeId(map));
    }

    [Fact]
    public void QualifyingSummon_RaisesDirectorSummonWorldEvent()
    {
        var (school, first, _, _) = TwoPupilsPrincipalAndTeacherOnBreak();
        using (school)
        {
            school.DrainWorldEvents();
            Assert.True(DirectorSummonSystem.TryEnqueue(school, first.Id, chance: 1f));

            var facts = school.DrainWorldEvents();
            var fact = Assert.Single(facts, row => row.Trigger.Equals(EventTriggers.DirectorSummon, StringComparison.Ordinal));
            Assert.Equal(first.Id, fact.PersonKey);
        }
    }

    [Fact]
    public void QueueAdvancesWithoutOpenClient()
    {
        var (school, first, second, _) = TwoPupilsPrincipalAndTeacherOnBreak();
        using (school)
        {
            Assert.True(DirectorSummonSystem.TryEnqueue(school, first.Id, chance: 1f));
            Assert.True(DirectorSummonSystem.TryEnqueue(school, second.Id, chance: 1f));
            DirectorSummonSystem.Apply(school);

            var head = school.DirectorSummons.OrderBy(row => row.Order).First();
            var next = school.DirectorSummons.OrderBy(row => row.Order).Skip(1).First();
            PlaceAt(school, head.PersonId, "principals-office");
            DirectorSummonSystem.Apply(school);
            Assert.True(ActivitySystem.IsPrincipalHearing(ActivityOf(school, head.PersonId)));

            DirectorSummonSystem.CompleteHearing(school, head.PersonId);
            DirectorSummonSystem.Apply(school);

            Assert.False(DirectorSummonSystem.IsSummoned(school, head.PersonId));
            Assert.True(DirectorSummonSystem.IsSummoned(school, next.PersonId));
            PlaceAt(school, next.PersonId, "corridor-1");
            Assert.Equal(DirectorSummons.PresenceWaiting, school.DirectorSummonPresencePhase(next.PersonId));
        }
    }

    [Fact]
    public void SummonPresencePhase_WaitingInCorridor_HearingInOffice()
    {
        var (school, first, second, _) = TwoPupilsPrincipalAndTeacherOnBreak();
        using (school)
        {
            Assert.True(DirectorSummonSystem.TryEnqueue(school, first.Id, chance: 1f));
            Assert.True(DirectorSummonSystem.TryEnqueue(school, second.Id, chance: 1f));
            DirectorSummonSystem.Apply(school);

            var ordered = school.DirectorSummons.OrderBy(row => row.Order).ToArray();
            PlaceAt(school, ordered[0].PersonId, "principals-office");
            PlaceAt(school, ordered[1].PersonId, "corridor-1");
            DirectorSummonSystem.Apply(school);

            Assert.Equal(DirectorSummons.PresenceHearing, school.DirectorSummonPresencePhase(ordered[0].PersonId));
            Assert.Equal(DirectorSummons.PresenceWaiting, school.DirectorSummonPresencePhase(ordered[1].PersonId));
        }
    }

    private static IReadOnlyList<string> QueueOrderFromFight(int seed)
    {
        var (school, first, second, _) = TwoPupilsPrincipalAndTeacherOnBreak(seed);
        using (school)
        {
            BreakFight(school, first, second);
            return school.DirectorSummons
                .OrderBy(row => row.Order)
                .Select(row => row.PersonId)
                .ToArray();
        }
    }

    private static void BreakFight(School school, Person first, Person second)
    {
        OpinionStore.Set(first, second.Id, -55);
        OpinionStore.Set(second, first.Id, -55);
        var staffId = school.Roster!.People.First(person =>
            person.IsStaff && Staffing.TeacherPosition.Equals(person.Position, StringComparison.Ordinal)).Id;
        PlaceAt(school, first.Id, "yard");
        PlaceAt(school, second.Id, "yard");
        PlaceAt(school, staffId, "yard");
        Assert.True(school.TryStartAction(first.Id, TalkActions.Fight));
        PlaceAt(school, staffId, "yard");
        TalkCircleSystem.Apply(school, 1d);
        DirectorSummonSystem.Apply(school);
    }

    private static (School School, Person First, Person Second, string PrincipalId) TwoPupilsPrincipalAndTeacherOnBreak(
        int seed = 42)
    {
        var (school, first, second, _) = TwoPupilsAndStaffOnBreak(seed);
        var principalId = HirePrincipal(school);
        first = school.Roster!.People.First(person => person.Id == first.Id);
        second = school.Roster.People.First(person => person.Id == second.Id);
        return (school, first, second, principalId);
    }

    private static (School School, Person First, Person Second, string StaffId) TwoPupilsAndStaffOnBreak(int seed = 42)
    {
        var (school, first, second) = TwoPupilsOnBreak(seed);
        const float cap = 100_000f;
        var roster = school.Roster!;
        var pool = school.Applicants!;
        var hired = Staffing.Hire(
            school.Catalog!,
            school.Map!,
            roster,
            pool,
            pool.Applicants[0].Person.Id,
            Staffing.TeacherPosition,
            cap);
        Assert.Equal(StaffingError.None, hired.Error);
        school.ApplyStaffing(hired.Roster, hired.Pool);
        first = school.Roster!.People.First(person => person.Id == first.Id);
        second = school.Roster.People.First(person => person.Id == second.Id);
        var staffId = school.Roster.People.First(person =>
            person.IsStaff && Staffing.TeacherPosition.Equals(person.Position, StringComparison.Ordinal)).Id;
        return (school, first, second, staffId);
    }

    private static string HirePrincipal(School school)
    {
        const float cap = 100_000f;
        var pool = school.Applicants!;
        var applicantId = pool.Applicants[0].Person.Id;
        var hired = Staffing.Hire(
            school.Catalog!,
            school.Map!,
            school.Roster!,
            pool,
            applicantId,
            Staffing.PrincipalPosition,
            cap);
        Assert.Equal(StaffingError.None, hired.Error);
        school.ApplyStaffing(hired.Roster, hired.Pool);
        return school.Roster!.People.First(person =>
            Staffing.PrincipalPosition.Equals(person.Position, StringComparison.Ordinal)).Id;
    }

    private static (School School, Person First, Person Second) TwoPupilsOnBreak(int seed = 42)
    {
        var (catalog, map) = Vanilla();
        var school = OpenSchool(catalog, map, seed, TuesdayMorning, advanceToBreak: true);
        var schoolClass = school.Roster!.Classes.First(row => row.RoomId == "classroom-101");
        var pupils = schoolClass.PupilIds
            .Select(id => school.Roster.People.First(person => person.Id == id))
            .Take(2)
            .ToArray();
        return (school, pupils[0], pupils[1]);
    }

    private static School OpenSchool(DefCatalog catalog, MapLayout map, int seed, DateTime start, bool advanceToBreak)
    {
        var roster = RosterGenerator.Generate(catalog, map, seed, "Russia", start);
        var pool = ApplicantPool.Create(catalog, roster, seed, "Russia", start);
        var schoolClass = roster.Classes.First(row => row.RoomId == "classroom-101");
        var school = School.Create(seed, "DirectorSummon", start, catalog, map);
        school.InstallPeople(roster, seed, "Russia", pool);
        school.SetTimetable(new HSchool.Schedule.Timetable(
            [
                new HSchool.Schedule.LessonPlacement(schoolClass.Id, "Mathematics", "t1", schoolClass.RoomId, Day: 1, Period: 1),
            ],
            []));
        school.ConfigurePresence(weekDays: 5, maxDecisionsPerTick: 10_000);
        if (advanceToBreak)
        {
            AdvanceTo(school, new DateTime(2012, 4, 3, 9, 18, 0, DateTimeKind.Utc));
        }

        return school;
    }

    private static void AdvanceTo(School school, DateTime until)
    {
        while (school.Clock.Time < until)
        {
            school.Tick(0.2d, 5d);
        }
    }

    private static void PlaceAt(School school, string personId, string? nodeId)
    {
        TalkCircleSystem.Interrupt(school, personId);
        var query = new QueryDescription().WithAll<PersonIdentity, Presence, PersonActivity, Intent>();
        school.World.Query(in query, (ref PersonIdentity identity, ref Presence presence, ref PersonActivity activity, ref Intent intent) =>
        {
            if (identity.Id.Equals(personId, StringComparison.Ordinal))
            {
                presence = nodeId is null ? Presence.OffCampus : new Presence(nodeId, 0f, nodeId, false, []);
                activity = PersonActivity.Idle;
                intent = Intent.None;
            }
        });
    }

    private static string? NodeOf(School school, string personId)
    {
        string? found = null;
        var query = new QueryDescription().WithAll<PersonIdentity, Presence>();
        school.World.Query(in query, (ref PersonIdentity identity, ref Presence presence) =>
        {
            if (identity.Id.Equals(personId, StringComparison.Ordinal))
            {
                found = presence.NodeId;
            }
        });
        return found;
    }

    private static string? ActivityOf(School school, string personId)
    {
        string? found = null;
        var query = new QueryDescription().WithAll<PersonIdentity, PersonActivity>();
        school.World.Query(in query, (ref PersonIdentity identity, ref PersonActivity activity) =>
        {
            if (identity.Id.Equals(personId, StringComparison.Ordinal) && activity.IsActive)
            {
                found = activity.ActionId;
            }
        });
        return found;
    }

    private static (DefCatalog Catalog, MapLayout Map) Vanilla()
    {
        var root = Path.Combine(AppContext.BaseDirectory, "vanilla");
        var documents = new List<ContentDocument>();
        foreach (var path in Directory.EnumerateFiles(root, "*.*", SearchOption.AllDirectories))
        {
            if (!path.EndsWith(".jsonc", StringComparison.OrdinalIgnoreCase)
                && !path.EndsWith(".json", StringComparison.OrdinalIgnoreCase))
            {
                continue;
            }

            documents.Add(new ContentDocument(
                CatalogLoader.CorePackId,
                Path.GetRelativePath(root, path).Replace('\\', '/'),
                File.ReadAllText(path)));
        }

        var catalog = new CatalogLoader().Load([CatalogLoader.CorePackId], documents);
        var map = CatalogLoader.LastDefaultMap([CatalogLoader.CorePackId], documents);
        Assert.NotNull(map);
        return (catalog, map);
    }
}