dragon-iso/src/TeamsISO.App/ViewModels/MainViewModel.cs

using System.Collections.ObjectModel;
using System.Reactive.Concurrency;
using System.Reactive.Linq;
using System.Windows.Threading;
using TeamsISO.Engine.Controller;
using TeamsISO.Engine.Domain;

namespace TeamsISO.App.ViewModels;

/// <summary>
/// Top-level view model for the main window. Owns the live collection of <see cref="ParticipantViewModel"/>,
/// the global settings panel, and the alert banner. Subscribes to <see cref="IIsoController"/>'s observables
/// and marshals updates onto the UI dispatcher.
/// </summary>
public sealed class MainViewModel : ObservableObject, IDisposable
{
    private readonly IIsoController _controller;
    private readonly Dispatcher _dispatcher;
    private readonly IDisposable _participantsSub;
    private readonly IDisposable _alertsSub;
    private readonly Dictionary<Guid, ParticipantViewModel> _byId = new();
    private string _statusText = "Starting…";

    public ObservableCollection<ParticipantViewModel> Participants { get; } = new();
    public GlobalSettingsViewModel Settings { get; }
    public AlertBannerViewModel AlertBanner { get; } = new();

    public string StatusText
    {
        get => _statusText;
        set => SetField(ref _statusText, value);
    }

    public MainViewModel(IIsoController controller, Dispatcher dispatcher)
    {
        _controller = controller;
        _dispatcher = dispatcher;
        Settings = new GlobalSettingsViewModel(controller);

        _participantsSub = controller.Participants
            .ObserveOn(new SynchronizationContextScheduler(
                System.Threading.SynchronizationContext.Current ?? new DispatcherSynchronizationContext(_dispatcher)))
            .Subscribe(OnParticipantsChanged);

        _alertsSub = controller.Alerts
            .ObserveOn(new SynchronizationContextScheduler(
                System.Threading.SynchronizationContext.Current ?? new DispatcherSynchronizationContext(_dispatcher)))
            .Subscribe(alert =>
            {
                AlertBanner.Current = alert;
            });
    }

    public async Task InitializeAsync(CancellationToken cancellationToken)
    {
        StatusText = "Discovering NDI sources…";
        await _controller.StartAsync(cancellationToken);
        StatusText = $"Engine running at {_controller.GlobalSettings.FramerateHz:F2} fps target.";
    }

    private void OnParticipantsChanged(IReadOnlyList<Participant> incoming)
    {
        var seenIds = new HashSet<Guid>();
        var hideLocal = Settings.HideLocalSelf;
        foreach (var p in incoming)
        {
            // The new Teams client emits a "(Local)" pseudo-participant for the user's
            // own preview — operators rarely want it as a routable ISO. Suppress when
            // HideLocalSelf is on (default).
            if (hideLocal && IsLocalSelf(p)) continue;

            seenIds.Add(p.Id);
            if (_byId.TryGetValue(p.Id, out var vm))
            {
                vm.Update(p);
            }
            else
            {
                vm = new ParticipantViewModel(_controller, p);
                _byId[p.Id] = vm;
                Participants.Add(vm);
            }
        }

        // Remove participants no longer present (or now hidden by the filter).
        for (var i = Participants.Count - 1; i >= 0; i--)
        {
            var vm = Participants[i];
            if (!seenIds.Contains(vm.Id))
            {
                _byId.Remove(vm.Id);
                Participants.RemoveAt(i);
            }
        }
    }

    private static bool IsLocalSelf(Participant p) =>
        string.Equals(p.DisplayName, "(Local)", StringComparison.Ordinal);

    public void Dispose()
    {
        _participantsSub.Dispose();
        _alertsSub.Dispose();
    }
}