voice-cat/clients/apple/dotnet/VoiceCat.Mac/MainWindowController.cs

using AppKit;
using CoreGraphics;
using Foundation;
using VoiceCat.Audio;
using VoiceCat.Core;
using Voicecat.V1;

namespace VoiceCat.Mac;

internal sealed class MainWindowController : NSWindowController
{
    private readonly VoiceCatClient client;
    private readonly MacAudioBackend audioBackend = new();
    private readonly uint selfId;
    private readonly NSPopUpButton channels = new(new CGRect(20, 515, 300, 28), false);
    private readonly NSTextView users = new(new CGRect(0, 0, 190, 430)) { Editable = false, Selectable = true };
    private readonly NSTextView chat = new(new CGRect(0, 0, 510, 390)) { Editable = false, Selectable = true };
    private readonly NSTextField compose = new(new CGRect(230, 55, 400, 28)) { PlaceholderString = "Message to current channel" };
    private readonly NSButton send = new(new CGRect(640, 53, 90, 32)) { Title = "Send" };
    private readonly NSButton voice = new(new CGRect(630, 510, 100, 32)) { Title = "Join voice" };
    private readonly NSTextField status = NSTextField.CreateLabel("Connected");
    private readonly NSTimer timer;
    private uint currentChannel = 1;
    private uint microphoneStreamId;
    private bool joinedVoice;
    private IAudioCapture? microphone;
    private IAudioPlayback? playback;

    internal MainWindowController(VoiceCatClient client, uint selfId, string nickname) : base(new NSWindow(new CGRect(0, 0, 760, 570),
        NSWindowStyle.Titled | NSWindowStyle.Closable | NSWindowStyle.Resizable | NSWindowStyle.Miniaturizable, NSBackingStore.Buffered, false))
    {
        this.client = client; this.selfId = selfId;
        Window!.Title = $"VoiceCat — {nickname}"; Window.Center(); Window.MinSize = new CGSize(680, 480);
        var content = Window.ContentView!;
        ((INSAccessibility)channels).AccessibilityLabel = "Channel"; channels.Activated += ChangeChannel; content.AddSubview(channels);
        ((INSAccessibility)voice).AccessibilityLabel = "Join or leave voice"; voice.Activated += ToggleVoice; content.AddSubview(voice);
        var userScroll = new NSScrollView(new CGRect(20, 90, 190, 410)) { HasVerticalScroller = true, DocumentView = users }; userScroll.AccessibilityLabel = "Users in channel"; content.AddSubview(userScroll);
        var chatScroll = new NSScrollView(new CGRect(230, 90, 500, 410)) { HasVerticalScroller = true, DocumentView = chat }; chatScroll.AccessibilityLabel = "Channel messages"; content.AddSubview(chatScroll);
        ((INSAccessibility)compose).AccessibilityLabel = "Message"; compose.Activated += Send; content.AddSubview(compose);
        ((INSAccessibility)send).AccessibilityLabel = "Send message"; send.Activated += Send; content.AddSubview(send);
        status.Frame = new CGRect(20, 22, 700, 22); status.AccessibilityLabel = "Connection status"; content.AddSubview(status);
        timer = NSTimer.CreateRepeatingScheduledTimer(TimeSpan.FromMilliseconds(50), _ => Pump());
        RefreshState();
    }

    private void Pump()
    {
        while (client.TryReadEvent(out Envelope? envelope))
        {
            if (envelope!.TextMessage is { } text) Append($"[{DateTime.Now:t}] {Name(text.SenderId)}: {text.Body}");
            if (envelope.ServerState is not null || envelope.ChannelEvent is not null || envelope.UserEvent is not null) RefreshState();
            if (envelope.Disconnect is { } disconnected)
            {
                StopAudioDevices(); joinedVoice = false; voice.Title = "Join voice";
                status.StringValue = "Disconnected: " + disconnected.Reason; voice.Enabled = send.Enabled = false;
            }
        }
        if (client.Audio.Failure is { } failure) status.StringValue = "Audio stopped: " + failure.Message;
        if (audioBackend.Failure is { } deviceFailure) status.StringValue = "Audio device stopped: " + deviceFailure.Message;
    }
    private void RefreshState()
    {
        channels.RemoveAllItems();
        foreach (var channel in client.Channels.OrderBy(c => c.Order).ThenBy(c => c.Name)) { channels.AddItem(channel.Name); channels.LastItem!.RepresentedObject = new NSString(channel.Id.ToString()); }
        currentChannel = client.Users.FirstOrDefault(u => u.Id == selfId)?.ChannelId ?? currentChannel;
        int selectedIndex = client.Channels.ToList().FindIndex(c => c.Id == currentChannel); if (selectedIndex >= 0) channels.SelectItem(selectedIndex);
        users.Value = string.Join("\n", client.Users.Where(u => u.ChannelId == currentChannel).OrderBy(u => u.Nickname).Select(u => (u.Id == selfId ? "You — " : "") + u.Nickname));
        status.StringValue = $"Connected · {client.Users.Count} users";
    }
    private async void ChangeChannel(object? sender, EventArgs args)
    {
        if (!uint.TryParse(channels.SelectedItem?.RepresentedObject?.ToString(), out uint id) || id == currentChannel) return;
        try
        {
            bool resumeVoice = joinedVoice;
            if (resumeVoice) await LeaveVoice();
            var result = (await client.RequestAsync(new() { JoinChannel = new() { ChannelId = id } })).JoinChannelResult;
            if (!result.Ok) status.StringValue = result.Error;
            if (resumeVoice) await JoinVoice();
        }
        catch (Exception exception) { status.StringValue = exception.Message; }
    }
    private void Send(object? sender, EventArgs args)
    {
        string body = compose.StringValue.Trim(); if (body.Length == 0) return;
        try { client.Send(new() { TextMessage = new() { Scope = TextScope.TextChannel, TargetId = currentChannel, Body = body, ClientMsgId = Guid.NewGuid().ToString("N") } }); compose.StringValue = ""; }
        catch (Exception exception) { status.StringValue = exception.Message; }
    }
    private async void ToggleVoice(object? sender, EventArgs args)
    {
        try
        {
            voice.Enabled = false;
            if (!joinedVoice) await JoinVoice();
            else await LeaveVoice();
        }
        catch (Exception exception) { status.StringValue = exception.Message; }
        finally { voice.Enabled = true; }
    }

    private async Task JoinVoice()
    {
        var result = await client.SubscribeVoiceAsync();
        if (!result.Ok) throw new InvalidOperationException(result.Error);
        try
        {
            playback = audioBackend.OpenPlayback();
            client.Audio.MixedPcm += PlayMixedPcm;
            StreamInfo stream = await client.StartStreamAsync(StreamKind.StreamMic, "Microphone");
            microphoneStreamId = stream.StreamId;
            microphone = audioBackend.OpenCapture(null, false, FeedMicrophone);
            joinedVoice = true; voice.Title = "Leave voice"; status.StringValue = "Voice connected";
        }
        catch
        {
            try { if (microphoneStreamId != 0) client.StopStream(microphoneStreamId); } catch { }
            StopAudioDevices();
            try { await client.SubscribeVoiceAsync(false); } catch { }
            throw;
        }
    }

    private async Task LeaveVoice()
    {
        uint streamId = microphoneStreamId;
        joinedVoice = false; voice.Title = "Join voice";
        StopAudioDevices();
        if (streamId != 0) client.StopStream(streamId);
        await client.SubscribeVoiceAsync(false);
        status.StringValue = "Voice disconnected";
    }

    private void FeedMicrophone(ReadOnlySpan<short> pcm, int channels)
    {
        uint streamId = microphoneStreamId;
        if (streamId != 0) client.Audio.FeedPcm(streamId, pcm, channels);
    }

    private void PlayMixedPcm(ReadOnlySpan<short> pcm) => Volatile.Read(ref playback)?.Write(pcm);

    private void StopAudioDevices()
    {
        microphoneStreamId = 0;
        Interlocked.Exchange(ref microphone, null)?.Dispose();
        client.Audio.MixedPcm -= PlayMixedPcm;
        Interlocked.Exchange(ref playback, null)?.Dispose();
    }
    private string Name(uint id) => client.Users.FirstOrDefault(u => u.Id == id)?.Nickname ?? $"User {id}";
    private void Append(string line)
    {
        chat.Value = chat.Value.Length == 0 ? line : chat.Value + "\n" + line;
        chat.ScrollRangeToVisible(new NSRange(chat.Value.Length, 0));
    }
    protected override void Dispose(bool disposing)
    {
        if (disposing) { timer.Invalidate(); StopAudioDevices(); client.DisposeAsync().AsTask().GetAwaiter().GetResult(); }
        base.Dispose(disposing);
    }
}