using System.Diagnostics;
using System.Threading.Channels;
using HSchool.Content;
using HSchool.People;
using HSchool.Protocol;
using HSchool.Schedule;
using HSchool.Server.Api;
using HSchool.Server.Net;
using HSchool.Simulation;

namespace HSchool.Server.Game;

/// <summary>
/// Dedicated thread for one school: fixed-step clock, that school's Arch world, that school's
/// frozen catalog, that school's save file. Awaits are resolved with <c>GetResult</c> so
/// <see cref="School.Tick"/> stays on this thread instead of hopping back onto the pool.
/// </summary>
internal sealed class SchoolWorker
{
    private const int MaxCatchUpSteps = 5;

    private readonly SimulationOptions _options;
    private readonly ClientRegistry _clients;
    private readonly GameMetrics _metrics;
    private readonly SchoolStore _store;
    private readonly ModContent _mods;
    private readonly ILogger _logger;
    private readonly Channel<WorkerCommand> _mailbox = Channel.CreateUnbounded<WorkerCommand>(
        new UnboundedChannelOptions { SingleReader = true, SingleWriter = false });
    private readonly TaskCompletionSource _started = new(TaskCreationOptions.RunContinuationsAsynchronously);
    private readonly CancellationTokenSource _stopping = new();
    private readonly bool _isNew;
    private readonly IReadOnlyList<string>? _modIds;
    private readonly MapLayout? _savedMap;
    private readonly string? _nameSetId;
    private string? _nativeLanguage;
    private readonly IReadOnlyList<PresenceSnapshot>? _savedPresence;
    private readonly Action<int> _onFailed;

    private readonly int _id;
    private readonly string _name;
    private readonly DateTime _time;
    private readonly bool _running;
    private readonly int _speedIndex;

    private SchoolState _snapshot;
    private Roster? _rosterSnapshot;
    private ApplicantPool? _applicantSnapshot;
    private DefCatalog? _catalogSnapshot;
    private Timetable? _timetableSnapshot;
    private MapLayout? _mapSnapshot;
    private int _presenceAge;
    private School? _school;
    private Task? _run;
    private bool _persistOnStop = true;
    private bool _settingsDirty;
    private long _lastSettingsSave;

    public SchoolWorker(
        int id,
        string name,
        DateTime time,
        bool running,
        int speedIndex,
        bool isNew,
        IReadOnlyList<string>? modIds,
        MapLayout? savedMap,
        string? nameSetId,
        string? nativeLanguage,
        IReadOnlyList<PresenceSnapshot>? savedPresence,
        SimulationOptions options,
        ClientRegistry clients,
        GameMetrics metrics,
        SchoolStore store,
        ModContent mods,
        Action<int> onFailed,
        ILogger logger)
    {
        _id = id;
        _name = name;
        _time = time;
        _running = running;
        _speedIndex = speedIndex;
        _isNew = isNew;
        _modIds = modIds;
        _savedMap = savedMap;
        _nameSetId = nameSetId;
        _nativeLanguage = nativeLanguage;
        _savedPresence = savedPresence;
        _options = options;
        _clients = clients;
        _metrics = metrics;
        _store = store;
        _mods = mods;
        _onFailed = onFailed;
        _logger = logger;
        _snapshot = new SchoolState(id, name, time, running, (byte)speedIndex, modIds ?? []);
    }

    public int Id => _id;

    public Task Started => _started.Task;

    /// <summary>Last clock the worker published. Menu requests read this; the live school stays here.</summary>
    public SchoolState Snapshot => Volatile.Read(ref _snapshot);

    /// <summary>Last roster composition. Published like <see cref="Snapshot"/>; needs live on entities.</summary>
    public Roster? RosterSnapshot => Volatile.Read(ref _rosterSnapshot);

    /// <summary>Last applicant pool. Same publication rules as the roster — not a live World query.</summary>
    public ApplicantPool? ApplicantSnapshot => Volatile.Read(ref _applicantSnapshot);

    /// <summary>Frozen catalog for this school. Safe to read from HTTP; it never mutates after load.</summary>
    public DefCatalog? CatalogSnapshot => Volatile.Read(ref _catalogSnapshot);

    /// <summary>Last built timetable. Published like the roster — HTTP never reads the live school.</summary>
    public Timetable? TimetableSnapshot => Volatile.Read(ref _timetableSnapshot);

    /// <summary>Frozen map instance. Safe to read from HTTP with the catalog; it does not mutate.</summary>
    public MapLayout? MapSnapshot => Volatile.Read(ref _mapSnapshot);

    public void Start()
    {
        _run = Task.Factory.StartNew(
            RunSync,
            CancellationToken.None,
            TaskCreationOptions.LongRunning | TaskCreationOptions.DenyChildAttach,
            TaskScheduler.Default);
    }

    public bool Post(WorkerCommand command)
    {
        if (_mailbox.Writer.TryWrite(command))
        {
            return true;
        }

        _logger.LogDebug("Dropped a command for school {SchoolId}: the mailbox is closed.", _id);
        return false;
    }

    public async Task StopAsync(bool persist)
    {
        Volatile.Write(ref _persistOnStop, persist);
        _mailbox.Writer.TryComplete();
        await _stopping.CancelAsync().ConfigureAwait(false);

        if (_run is not null)
        {
            try
            {
                await _run.ConfigureAwait(false);
            }
            catch (OperationCanceledException)
            {
                // Normal shutdown.
            }
        }
    }

    private void RunSync()
    {
        try
        {
            RunLoop(_stopping.Token);
        }
        catch (SchoolContentUnavailableException ex)
        {
            _logger.LogWarning(ex, "School {SchoolId} was not started; the save file is unchanged.", _id);
            _started.TrySetException(ex);
            ReportFailure();
        }
        catch (Exception ex)
        {
            _logger.LogError(ex, "School {SchoolId} worker died.", _id);
            _started.TrySetException(ex);
            ReportFailure();
        }
    }

    /// <summary>
    /// Tells the supervisor this school is gone. Without it a dead worker stayed in the table and
    /// the menu kept drawing its card with a frozen clock, as if the school were alive.
    /// </summary>
    private void ReportFailure()
    {
        if (_stopping.IsCancellationRequested)
        {
            // Already being torn down on purpose; the supervisor knows.
            return;
        }

        try
        {
            _onFailed(_id);
        }
        catch (Exception ex)
        {
            _logger.LogError(ex, "Could not report the failure of school {SchoolId}.", _id);
        }
    }

    private void RunLoop(CancellationToken cancellationToken)
    {
        var packIds = _mods.NormalizePackIds(_modIds);
        _logger.LogInformation("School {SchoolId} loading packs [{Packs}].", _id, string.Join(", ", packIds));
        foreach (var packId in packIds)
        {
            if (!_mods.PackExists(packId))
            {
                throw new SchoolContentUnavailableException(
                    $"School {_id} needs mod '{packId}', but that folder is missing.");
            }
        }

        var catalog = _mods.LoadCatalog(packIds, _logger);
        Volatile.Write(ref _catalogSnapshot, catalog);
        var map = _mods.LoadMap(packIds, _savedMap);
        Volatile.Write(ref _mapSnapshot, map);
        try
        {
            MapValidator.Validate(map, catalog);
        }
        catch (MapValidationException ex)
        {
            throw new SchoolContentUnavailableException(ex.Message, ex);
        }

        var school = _isNew
            ? School.Create(_id, _name, _time, catalog, map)
            : School.Load(_id, _name, _time, _running, _speedIndex, catalog, map);

        var peopleDirty = false;
        try
        {
            peopleDirty = InstallPeople(school, catalog, map);
        }
        catch
        {
            school.Dispose();
            throw;
        }

        _school = school;
        PublishSnapshot();

        if (_isNew)
        {
            Persist();
        }

        if (peopleDirty)
        {
            PersistPeople();
        }

        _started.TrySetResult();

        using var timer = new PeriodicTimer(_options.TickInterval);
        var fixedDelta = _options.FixedDeltaTime;
        var lastTimestamp = Stopwatch.GetTimestamp();
        var accumulator = 0d;
        var lastSave = lastTimestamp;
        var peopleChanged = false;

        try
        {
            while (!cancellationToken.IsCancellationRequested)
            {
                if (!WaitForTick(timer, cancellationToken))
                {
                    break;
                }

                DrainMailbox();

                var now = Stopwatch.GetTimestamp();
                accumulator += Stopwatch.GetElapsedTime(lastTimestamp, now).TotalSeconds;
                lastTimestamp = now;

                var steps = 0;
                peopleChanged = false;
                while (accumulator >= fixedDelta && steps < MaxCatchUpSteps)
                {
                    var stepStarted = Stopwatch.GetTimestamp();
                    peopleChanged |= school.Tick(fixedDelta, _options.GameMinutesPerRealSecond);
                    _metrics.RecordTick(Stopwatch.GetElapsedTime(stepStarted, Stopwatch.GetTimestamp()).TotalMilliseconds);

                    accumulator -= fixedDelta;
                    steps++;
                }

                if (steps == MaxCatchUpSteps && accumulator >= fixedDelta)
                {
                    _logger.LogWarning(
                        "School {SchoolId} is behind by {Backlog:F0} ms; dropping the backlog.",
                        _id,
                        accumulator * 1000);
                    accumulator = 0d;
                }

                if (peopleChanged)
                {
                    PersistPeople();
                    if (school.TimetableDirty)
                    {
                        RebuildTimetable(school);
                    }
                }

                if (steps > 0)
                {
                    PublishSnapshot();
                    BroadcastClock();
                    MaybeBroadcastPresence(school);
                }

                FlushSettings();

                if (Stopwatch.GetElapsedTime(lastSave) >= _options.SaveInterval)
                {
                    Persist();
                    lastSave = Stopwatch.GetTimestamp();
                }
            }
        }
        catch (OperationCanceledException)
        {
            // Normal shutdown.
        }
        finally
        {
            DrainMailbox();

            if (Volatile.Read(ref _persistOnStop))
            {
                Persist();
            }

            school.Dispose();
            _school = null;
        }
    }

    /// <summary>
    /// Blocks this dedicated thread until the next tick. Completing the wait on the pool is fine;
    /// <see cref="School.Tick"/> then runs here, not as a pool callback.
    /// </summary>
    private static bool WaitForTick(PeriodicTimer timer, CancellationToken cancellationToken)
    {
        try
        {
            return timer.WaitForNextTickAsync(cancellationToken).AsTask().GetAwaiter().GetResult();
        }
        catch (OperationCanceledException)
        {
            return false;
        }
    }

    private void DrainMailbox()
    {
        var school = _school;
        if (school is null)
        {
            while (_mailbox.Reader.TryRead(out var orphan))
            {
                CompleteOrphan(orphan);
            }

            return;
        }

        var dirty = false;

        while (_mailbox.Reader.TryRead(out var command))
        {
            // Every command here was triggered by a browser. One of them failing — an oversized
            // snapshot, a client that vanished mid-send — must cost that command, not the school.
            try
            {
                switch (command)
                {
                    case WorkerCommand.Open open:
                        open.Client.OpenSchoolId = _id;
                        SendMapSnapshot(open.Client, school);
                        BroadcastClockTo(open.Client, school);
                        SendPresence(open.Client, school);
                        break;

                    case WorkerCommand.Close close:
                        var leaving = _clients.Find(close.PlayerId);
                        if (leaving?.OpenSchoolId == _id)
                        {
                            leaving.OpenSchoolId = null;
                        }

                        break;

                    case WorkerCommand.SetRunning setRunning:
                        school.Clock.IsRunning = setRunning.Running;
                        dirty = true;
                        break;

                    case WorkerCommand.SetSpeed setSpeed:
                        school.Clock.SpeedIndex = setSpeed.SpeedIndex;
                        dirty = true;
                        break;

                    case WorkerCommand.SkipEmpty:
                        ApplySkip(school);
                        break;

                    case WorkerCommand.Dump dump:
                        dump.Result.TrySetResult(SchoolDumpReader.Read(school, _options.SchoolWeekDays));
                        break;

                    case WorkerCommand.GetPerson getPerson:
                        var card = PersonCardReader.Read(school, getPerson.PersonId, getPerson.Locale);
                        getPerson.Result.TrySetResult(
                            card is null
                                ? new PersonCardResult(null, PersonLookupError.UnknownPerson)
                                : new PersonCardResult(card, PersonLookupError.None));
                        break;

                    case WorkerCommand.HireStaff hire:
                        hire.Result.TrySetResult(ApplyHire(school, hire.PersonId, hire.Position));
                        break;

                    case WorkerCommand.AssignSubject assign:
                        assign.Result.TrySetResult(ApplyAssign(school, assign.PersonId, assign.Subject));
                        break;

                    case WorkerCommand.UnassignSubject unassign:
                        unassign.Result.TrySetResult(ApplyUnassign(school, unassign.PersonId, unassign.Subject));
                        break;

                    case WorkerCommand.PinLesson pin:
                        pin.Result.TrySetResult(
                            ApplyPin(school, pin.ClassId, pin.Subject, pin.RoomId, pin.Day, pin.Period));
                        break;

                    case WorkerCommand.UnpinLesson unpin:
                        unpin.Result.TrySetResult(
                            ApplyUnpin(school, unpin.ClassId, unpin.Subject, unpin.Day, unpin.Period));
                        break;
                }
            }
            catch (Exception ex)
            {
                FailCommand(command, ex);

                _logger.LogError(
                    ex,
                    "Command {Command} failed for school {SchoolId}; the school keeps running.",
                    command.GetType().Name,
                    _id);
            }
        }

        if (dirty)
        {
            PublishSnapshot();
            BroadcastClock();

            // Not written here: a client can send SetSpeed as fast as the socket allows, and each
            // one used to be a synchronous file write on this thread. FlushSettings coalesces them.
            _settingsDirty = true;
        }
    }

    private static void CompleteOrphan(WorkerCommand command)
    {
        switch (command)
        {
            case WorkerCommand.Dump dump:
                dump.Result.TrySetResult(null);
                break;
            case WorkerCommand.GetPerson getPerson:
                getPerson.Result.TrySetResult(new PersonCardResult(null, PersonLookupError.UnknownSchool));
                break;
            case WorkerCommand.HireStaff hire:
                hire.Result.TrySetResult(Staffing.UnknownSchool());
                break;
            case WorkerCommand.AssignSubject assign:
                assign.Result.TrySetResult(Staffing.UnknownSchool());
                break;
            case WorkerCommand.UnassignSubject unassign:
                unassign.Result.TrySetResult(Staffing.UnknownSchool());
                break;
            case WorkerCommand.PinLesson pin:
                pin.Result.TrySetResult(TimetableOutcome.Fail(TimetableError.UnknownSchool));
                break;
            case WorkerCommand.UnpinLesson unpin:
                unpin.Result.TrySetResult(TimetableOutcome.Fail(TimetableError.UnknownSchool));
                break;
        }
    }

    private static void FailCommand(WorkerCommand command, Exception exception)
    {
        switch (command)
        {
            case WorkerCommand.Dump dump:
                dump.Result.TrySetException(exception);
                break;
            case WorkerCommand.GetPerson getPerson:
                getPerson.Result.TrySetException(exception);
                break;
            case WorkerCommand.HireStaff hire:
                hire.Result.TrySetException(exception);
                break;
            case WorkerCommand.AssignSubject assign:
                assign.Result.TrySetException(exception);
                break;
            case WorkerCommand.UnassignSubject unassign:
                unassign.Result.TrySetException(exception);
                break;
            case WorkerCommand.PinLesson pin:
                pin.Result.TrySetException(exception);
                break;
            case WorkerCommand.UnpinLesson unpin:
                unpin.Result.TrySetException(exception);
                break;
        }
    }

    private StaffingOutcome ApplyHire(School school, string personId, string position) =>
        ApplyStaffingChange(school, (catalog, roster, pool) =>
            Staffing.Hire(catalog, school.Map, roster, pool, personId, position, _options.MonthlyPayrollCap));

    private StaffingOutcome ApplyAssign(School school, string personId, string subject) =>
        ApplyStaffingChange(school, (catalog, roster, pool) =>
            Staffing.AssignSubject(catalog, roster, pool, personId, subject, _options.MonthlyPayrollCap));

    private StaffingOutcome ApplyUnassign(School school, string personId, string subject) =>
        ApplyStaffingChange(school, (catalog, roster, pool) =>
            Staffing.UnassignSubject(catalog, roster, pool, personId, subject, _options.MonthlyPayrollCap));

    private StaffingOutcome ApplyStaffingChange(
        School school,
        Func<DefCatalog, Roster, ApplicantPool, StaffingOutcome> apply)
    {
        if (school.Roster is null || school.Applicants is null || school.Catalog is null)
        {
            return Staffing.UnknownSchool();
        }

        var outcome = apply(school.Catalog, school.Roster, school.Applicants);
        if (outcome.Error == StaffingError.None)
        {
            school.ApplyStaffing(outcome.Roster, outcome.Pool);
            PersistPeople();
            RebuildTimetable(school);
        }

        return outcome;
    }

    /// <summary>
    /// Writes pause/speed changes, at most once per <see cref="SimulationOptions.MinSaveInterval"/>.
    /// A single click still lands within that window; a burst collapses into one write.
    /// </summary>
    private void FlushSettings()
    {
        if (!_settingsDirty || Stopwatch.GetElapsedTime(_lastSettingsSave) < _options.MinSaveInterval)
        {
            return;
        }

        Persist();
        _settingsDirty = false;
        _lastSettingsSave = Stopwatch.GetTimestamp();
    }

    private void PublishSnapshot()
    {
        var school = _school;
        if (school is null)
        {
            return;
        }

        Volatile.Write(
            ref _snapshot,
            new SchoolState(
                school.Id,
                school.Name,
                school.Clock.Time,
                school.Clock.IsRunning,
                (byte)school.Clock.SpeedIndex,
                school.Catalog?.PackIds ?? _modIds ?? []));
        Volatile.Write(ref _rosterSnapshot, school.Roster);
        Volatile.Write(ref _applicantSnapshot, school.Applicants);
        Volatile.Write(ref _timetableSnapshot, school.Timetable);
        Volatile.Write(ref _mapSnapshot, school.Map);
    }

    /// <summary>
    /// Writes the composition file. Not called from the 30-second clock save — the roster and
    /// applicant pool change on create, hire, weekly refresh and yearly intake, not every tick.
    /// </summary>
    private void PersistPeople()
    {
        var school = _school;
        if (school?.Roster is null)
        {
            return;
        }

        try
        {
            _store.SavePeople(school.Id, RosterDocument.From(school.PeopleSeed, school.Roster, school.Applicants));
        }
        catch (Exception ex)
        {
            _logger.LogError(ex, "Could not save people for school {SchoolId}; composition stays in memory.", _id);
        }
    }

    private void InstallTimetable(School school)
    {
        if (!_isNew)
        {
            var saved = _store.TryReadTimetable(_id);
            if (saved is not null)
            {
                var restored = RestoreTimetable(school, saved);
                school.SetTimetable(restored);
                if (!saved.Lessons.SequenceEqual(restored.Lessons)
                    || !saved.Uncovered.SequenceEqual(restored.Uncovered))
                {
                    PersistTimetable(school);
                }

                return;
            }
        }

        RebuildTimetable(school, broadcast: false);
    }

    private Timetable RestoreTimetable(School school, Timetable saved)
    {
        if (school.Catalog is null || school.Map is null || school.Roster is null)
        {
            return saved;
        }

        var classIds = school.Roster.Classes.Select(item => item.Id).ToHashSet(StringComparer.Ordinal);
        var peopleIds = school.Roster.People.Select(person => person.Id).ToHashSet(StringComparer.Ordinal);
        var valid = saved.Lessons
            .Where(lesson => classIds.Contains(lesson.ClassId) && peopleIds.Contains(lesson.TeacherId))
            .ToArray();
        if (valid.Length == saved.Lessons.Count)
        {
            return saved;
        }

        var locks = valid.Where(lesson => lesson.Locked).ToArray();
        return SchoolTimetables.Build(
            school.Catalog,
            school.Map,
            school.Roster,
            locks,
            _options.SchoolWeekDays);
    }

    private void RebuildTimetable(School school, bool broadcast = true)
    {
        if (school.Catalog is null || school.Map is null || school.Roster is null)
        {
            return;
        }

        var locks = school.Timetable?.Lessons.Where(lesson => lesson.Locked).ToArray() ?? [];
        ApplyTable(
            school,
            SchoolTimetables.Build(school.Catalog, school.Map, school.Roster, locks, _options.SchoolWeekDays),
            broadcast);
    }

    private TimetableOutcome ApplyPin(
        School school,
        string classId,
        string subject,
        string roomId,
        int day,
        int period)
    {
        if (school.Catalog is null || school.Map is null || school.Roster is null)
        {
            return TimetableOutcome.Fail(TimetableError.UnknownSchool);
        }

        if (school.Roster.Classes.All(item => item.Id != classId))
        {
            return TimetableOutcome.Fail(TimetableError.UnknownClass);
        }

        if (!school.Catalog.Subjects.TryGetValue(subject, out var subjectDef) || subjectDef.Abstract)
        {
            return TimetableOutcome.Fail(TimetableError.UnknownSubject);
        }

        if (school.Map.Rooms.All(room => room.Id != roomId))
        {
            return TimetableOutcome.Fail(TimetableError.UnknownRoom);
        }

        var teacherId = TeacherFor(school, classId, subject);
        if (teacherId is null)
        {
            return TimetableOutcome.Fail(TimetableError.NoTeacher);
        }

        var pin = new LessonPlacement(classId, subject, teacherId, roomId, day, period, Locked: true);
        var locks = (school.Timetable?.Lessons.Where(lesson => lesson.Locked) ?? [])
            .Where(lesson => lesson.ClassId != classId || lesson.Subject != subject
                || lesson.Day != day || lesson.Period != period)
            .Append(pin)
            .ToArray();
        var table = SchoolTimetables.Build(
            school.Catalog,
            school.Map,
            school.Roster,
            locks,
            _options.SchoolWeekDays);
        if (!table.Lessons.Any(lesson =>
                lesson.Locked
                && lesson.ClassId == classId
                && lesson.Subject == subject
                && lesson.RoomId == roomId
                && lesson.Day == day
                && lesson.Period == period))
        {
            return TimetableOutcome.Fail(TimetableError.PinRejected);
        }

        ApplyTable(school, table, broadcast: true);
        return TimetableOutcome.Ok(table);
    }

    private TimetableOutcome ApplyUnpin(School school, string classId, string subject, int day, int period)
    {
        if (school.Catalog is null || school.Map is null || school.Roster is null)
        {
            return TimetableOutcome.Fail(TimetableError.UnknownSchool);
        }

        var locks = school.Timetable?.Lessons.Where(lesson => lesson.Locked).ToArray() ?? [];
        var match = locks.FirstOrDefault(lesson =>
            lesson.ClassId == classId && lesson.Subject == subject && lesson.Day == day && lesson.Period == period);
        if (match is null)
        {
            return TimetableOutcome.Fail(TimetableError.UnknownLesson);
        }

        var next = SchoolTimetables.Build(
            school.Catalog,
            school.Map,
            school.Roster,
            locks.Where(lesson => lesson != match).ToArray(),
            _options.SchoolWeekDays);
        ApplyTable(school, next, broadcast: true);
        return TimetableOutcome.Ok(next);
    }

    private static string? TeacherFor(School school, string classId, string subject)
    {
        var existing = school.Timetable?.Lessons.FirstOrDefault(lesson =>
            lesson.ClassId == classId && lesson.Subject == subject);
        if (existing is not null)
        {
            return existing.TeacherId;
        }

        return school.Roster?.People
            .Where(person => person.IsStaff && person.Subjects.Contains(subject, StringComparer.Ordinal))
            .OrderBy(person => person.Id, StringComparer.Ordinal)
            .Select(person => person.Id)
            .FirstOrDefault();
    }

    private void ApplyTable(School school, Timetable table, bool broadcast)
    {
        school.SetTimetable(table);
        PersistTimetable(school);
        PublishSnapshot();
        if (broadcast)
        {
            BroadcastPresence();
        }
    }

    /// <summary>
    /// Writes the lesson table. Not called from the 30-second clock save — the table changes on
    /// hire, unassign, pin and yearly intake, not every tick.
    /// </summary>
    private void PersistTimetable(School school)
    {
        if (school.Timetable is null)
        {
            return;
        }

        try
        {
            _store.SaveTimetable(school.Id, school.Timetable);
        }
        catch (Exception ex)
        {
            _logger.LogError(ex, "Could not save the timetable for school {SchoolId}; it stays in memory.", _id);
        }
    }

    private void MaybeBroadcastPresence(School school)
    {
        _presenceAge++;
        var interval = Math.Max(1, _options.TickRate / 2);
        if (_presenceAge < interval)
        {
            return;
        }

        _presenceAge = 0;
        BroadcastPresence();
    }

    private void ApplySkip(School school)
    {
        var result = school.TrySkipEmpty();
        if (!result.Succeeded)
        {
            return;
        }

        if (result.PeopleChanged)
        {
            PersistPeople();
            if (school.TimetableDirty)
            {
                RebuildTimetable(school);
            }
        }

        PublishSnapshot();
        Persist();
        BroadcastClock();
        BroadcastPresence();
        _presenceAge = 0;
    }

    private bool InstallPeople(School school, DefCatalog catalog, MapLayout map)
    {
        var nameSetId = ResolveNameSetId(catalog, _nameSetId);
        if (nameSetId is null)
        {
            throw new SchoolContentUnavailableException($"School {_id} has no name set in its catalog.");
        }

        var demand = SchoolDemand.From(catalog, map);
        Roster roster;
        ApplicantPool applicants;
        int seed;
        var generated = false;
        string? native;

        if (_isNew)
        {
            seed = school.Id;
            native = ResolveNative(catalog, nameSetId, seed, _nativeLanguage, generating: true);
            _nativeLanguage = native;
            roster = RosterGenerator.Generate(catalog, map, seed, nameSetId, school.Clock.Time, native);
            applicants = ApplicantPool.Create(catalog, roster, seed, nameSetId, school.Clock.Time, native);
            generated = true;
        }
        else
        {
            var loaded = _store.TryReadPeople(_id);
            if (loaded is null)
            {
                seed = school.Id;
                native = ResolveNative(catalog, nameSetId, seed, _nativeLanguage, generating: true);
                _nativeLanguage = native;
                roster = RosterGenerator.Generate(catalog, map, seed, nameSetId, school.Clock.Time, native);
                applicants = ApplicantPool.Create(catalog, roster, seed, nameSetId, school.Clock.Time, native);
                generated = true;
            }
            else
            {
                seed = loaded.Seed;
                native = ResolveNative(catalog, nameSetId, seed, _nativeLanguage, generating: false);
                _nativeLanguage = native;
                roster = loaded.ToRoster();
                if (loaded.Applicants is { Applicants.Count: > 0 })
                {
                    applicants = loaded.Applicants;
                }
                else
                {
                    applicants = ApplicantPool.Create(catalog, roster, seed, nameSetId, school.Clock.Time, native);
                    generated = true;
                }
            }
        }

        if (!RosterFit.Matches(roster, demand))
        {
            throw new SchoolContentUnavailableException(
                $"School {_id} roster does not match its map; the people file was left untouched.");
        }

        school.InstallPeople(roster, seed, nameSetId, applicants, _nativeLanguage);
        InstallTimetable(school);
        school.ConfigurePresence(_options.SchoolWeekDays, _options.MaxDecisionsPerTick);
        school.RestorePresence(_savedPresence);
        return generated;
    }

    private static string? ResolveNameSetId(DefCatalog catalog, string? requested)
    {
        var available = catalog.NameSets.Values
            .Where(def => !def.Abstract)
            .Select(def => def.DefName)
            .OrderBy(name => name, StringComparer.Ordinal)
            .ToArray();
        if (available.Length == 0)
        {
            return null;
        }

        if (string.IsNullOrWhiteSpace(requested))
        {
            return available[0];
        }

        return available.Contains(requested, StringComparer.Ordinal) ? requested : null;
    }

    private static string? ResolveNative(
        DefCatalog catalog,
        string nameSetId,
        int schoolSeed,
        string? requested,
        bool generating)
    {
        if (!catalog.NameSets.TryGetValue(nameSetId, out var names))
        {
            return null;
        }

        return NativeLanguages.Pick(names, schoolSeed, requested, rollIfOmitted: generating && string.IsNullOrWhiteSpace(requested));
    }

    private void Persist()
    {
        var school = _school;
        if (school is null)
        {
            return;
        }

        // A full disk or a locked file must not end the school; the next save will try again.
        try
        {
            _store.Save(new SchoolSave
            {
                Format = SchoolStore.CurrentFormat,
                Id = school.Id,
                Name = school.Name,
                GameTime = school.Clock.Time,
                Running = school.Clock.IsRunning,
                SpeedIndex = school.Clock.SpeedIndex,
                ModIds = school.Catalog?.PackIds,
                Map = school.Map,
                NameSetId = _nameSetId,
                NativeLanguage = _nativeLanguage,
                Presence = school.CapturePresence(),
            });
        }
        catch (Exception ex)
        {
            _logger.LogError(ex, "Could not save school {SchoolId}; it keeps running unsaved.", _id);
        }
    }

    private void BroadcastClock()
    {
        var school = _school;
        if (school is null)
        {
            return;
        }

        foreach (var client in _clients.All)
        {
            if (client.IsReady && client.OpenSchoolId == _id)
            {
                BroadcastClockTo(client, school);
            }
        }
    }

    private void SendMapSnapshot(GameClient client, School school)
    {
        if (school.Catalog is null || school.Map is null)
        {
            return;
        }

        var locale = ProtocolConstants.CatalogLocale(client.Locale);
        var view = MapView.Build(school.Catalog, school.Map, locale);
        var nodes = new MapSnapshotNode[view.Count];
        for (var i = 0; i < view.Count; i++)
        {
            var node = view[i];
            var items = new MapSnapshotItem[node.Items.Count];
            for (var item = 0; item < node.Items.Count; item++)
            {
                items[item] = new MapSnapshotItem(node.Items[item].Name, (byte)node.Items[item].Count);
            }

            nodes[i] = new MapSnapshotNode(
                (byte)node.Kind,
                node.Id,
                node.ParentId,
                node.Name,
                (ushort)node.PupilSlots,
                items,
                node.Positions);
        }

        // Sized from the message, not from the inbound frame limit: a map the player enlarged in
        // the create editor outgrows 8 KiB somewhere past sixty furnished rooms.
        var message = new ServerMapSnapshotMessage(school.Id, nodes);
        var frame = new byte[ProtocolCodec.MapSnapshotSize(message)];
        var length = ProtocolCodec.WriteMapSnapshot(frame, message);
        client.TrySendReliable(frame.AsMemory(0, length));
    }

    private void BroadcastClockTo(GameClient client, School school)
    {
        var skip = school.PeekSkipEmpty();
        var frame = new byte[ProtocolCodec.MaxFrameSize];
        var length = ProtocolCodec.WriteClock(frame, new ServerClockMessage(
            school.Id,
            new DateTimeOffset(school.Clock.Time).ToUnixTimeMilliseconds(),
            school.Clock.IsRunning,
            (byte)school.Clock.SpeedIndex,
            skip.Allowed,
            skip.Time is { } target ? new DateTimeOffset(target).ToUnixTimeMilliseconds() : 0));

        client.TrySend(frame.AsMemory(0, length));
    }

    private void BroadcastPresence()
    {
        var school = _school;
        if (school is null)
        {
            return;
        }

        foreach (var client in _clients.All)
        {
            if (client.IsReady && client.OpenSchoolId == _id)
            {
                SendPresence(client, school);
            }
        }
    }

    private void SendPresence(GameClient client, School school)
    {
        var locale = ProtocolConstants.CatalogLocale(client.Locale);
        var message = PresenceFrame.Build(school, _options.SchoolWeekDays, locale);
        var frame = new byte[ProtocolCodec.PresenceSize(message)];
        var length = ProtocolCodec.WritePresence(frame, message);
        client.TrySendReliable(frame.AsMemory(0, length));
    }
}