DynamicKeyStateProvider.cs

using System.Diagnostics;
using NAudio.CoreAudioApi;
using NAudio.CoreAudioApi.Interfaces;
using AmpUp.Core.Services;

namespace AmpUp;

/// <summary>
/// Resolves "is this dynamic state active right now?" for Stream Controller
/// LCD keys configured with <c>DisplayKeyType.DynamicState</c>.
///
/// Supported sources:
///   mute_master       — default render endpoint is muted
///   mute_mic          — default communications capture endpoint is muted
///   obs_recording     — OBS is recording
///   obs_streaming     — OBS is streaming
///   spotify_playing   — Spotify has an active (non-paused) audio session on the default output
///   discord_mic       — Discord mic muted (NOT implemented — always false for MVP)
/// </summary>
internal static class DynamicKeyStateProvider
{
    private static readonly MMDeviceEnumerator _enumerator = new();
    private static readonly object _enumLock = new();

    public static bool IsActive(string source, ObsIntegration? obs, AudioMixer? mixer)
    {
        if (string.IsNullOrWhiteSpace(source)) return false;

        try
        {
            switch (source)
            {
                case "mute_master":
                    return GetDefaultEndpointMute(DataFlow.Render, Role.Multimedia);

                case "mute_mic":
                    return GetDefaultEndpointMute(DataFlow.Capture, Role.Communications);

                case "obs_recording":
                    return obs?.IsRecording == true;

                case "obs_streaming":
                    return obs?.IsStreaming == true;

                case "obs_virtualcam":
                    return obs?.IsVirtualCamActive == true;

                case "obs_replay_buffer":
                    return obs?.IsReplayBufferActive == true;

                case "obs_record_paused":
                    return obs?.IsRecordingPaused == true;

                case "spotify_playing":
                    return IsProcessSessionActive("spotify");

                case "discord_mic":
                    // TODO: no reliable public API for Discord mic mute — MVP returns false.
                    return App.DiscordRpc?.LastKnownMute == true;

                case "discord_deafen":
                    return App.DiscordRpc?.LastKnownDeafen == true;

                case "room_lights_on":
                    // Any Govee device currently powered on, or Corsair
                    // active in a non-off mode, counts as "lights on".
                    return AreRoomLightsOn();

                default:
                    return false;
            }
        }
        catch
        {
            return false;
        }
    }

    private static bool GetDefaultEndpointMute(DataFlow flow, Role role)
    {
        try
        {
            MMDevice? dev;
            lock (_enumLock)
                dev = _enumerator.GetDefaultAudioEndpoint(flow, role);
            if (dev == null) return false;
            bool muted = dev.AudioEndpointVolume.Mute;
            dev.Dispose();
            return muted;
        }
        catch
        {
            return false;
        }
    }

    /// <summary>
    /// True when any WASAPI session on the default render endpoint whose process name
    /// contains <paramref name="processNameFragment"/> reports <c>AudioSessionStateActive</c>
    /// (i.e. producing audio right now — not paused or inactive).
    /// </summary>
    private static bool IsProcessSessionActive(string processNameFragment)
    {
        try
        {
            MMDevice? device;
            lock (_enumLock)
                device = _enumerator.GetDefaultAudioEndpoint(DataFlow.Render, Role.Multimedia);
            if (device == null) return false;
            using (device)
            {
                var sessions = device.AudioSessionManager.Sessions;
                for (int i = 0; i < sessions.Count; i++)
                {
                    using var s = sessions[i];
                    try
                    {
                        if (s.State != AudioSessionState.AudioSessionStateActive) continue;
                        var pid = (int)s.GetProcessID;
                        if (pid == 0) continue;
                        using var process = Process.GetProcessById(pid);
                        var procName = process.ProcessName;
                        if (procName.Contains(processNameFragment, StringComparison.OrdinalIgnoreCase))
                            return true;
                    }
                    catch { }
                }
            }
        }
        catch { }
        return false;
    }

    /// <summary>Labels for the editor UI. Keep order stable.</summary>
    public static readonly (string Source, string Label)[] Sources =
    {
        ("mute_master",     "Master Muted"),
        ("mute_mic",        "Mic Muted"),
        ("obs_recording",   "OBS Recording"),
        ("obs_streaming",   "OBS Streaming"),
        ("obs_virtualcam",  "OBS Virtual Camera On"),
        ("obs_replay_buffer", "OBS Replay Buffer On"),
        ("obs_record_paused", "OBS Recording Paused"),
        ("spotify_playing", "Spotify Playing"),
        ("discord_mic",     "Discord Mic Muted"),
        ("discord_deafen",  "Discord Deafened"),
        ("room_lights_on",  "Room Lights On"),
    };

    /// <summary>
    /// Auto-derive the dynamic state source that matches a bound button action.
    /// Returns empty string if the action has no meaningful on/off state to track.
    /// </summary>
    public static string DeriveSourceFromAction(string? action)
    {
        if (string.IsNullOrWhiteSpace(action)) return "";
        switch (action)
        {
            case "mute_master":
                return "mute_master";
            case "mute_mic":
                return "mute_mic";
            case "discord_toggle_mute":
            case "discord_mute_on":
            case "discord_mute_off":
                return "discord_mic";
            case "discord_toggle_deafen":
            case "discord_deafen_on":
            case "discord_deafen_off":
                return "discord_deafen";
            case "obs_record":
                return "obs_recording";
            case "obs_stream":
                return "obs_streaming";
            case "obs_virtualcam":
                return "obs_virtualcam";
            case "obs_replay_buffer":
            case "obs_replay_save":
                return "obs_replay_buffer";
            case "obs_record_pause":
                return "obs_record_paused";
            case "spotify_play_pause":
            case "spotify_next":
            case "spotify_prev":
            case "spotify_shuffle":
            case "spotify_like":
                return "spotify_playing";
            case "room_toggle":
            case "corsair_toggle":
            case "govee_toggle":
            case "govee_white_toggle":
            case "govee_color":
            case "govee_scene":
            case "room_effect":
            case "group_toggle":
                return "room_lights_on";
            default:
                return "";
        }
    }

    /// <summary>Human label for a source key, or empty string if unknown.</summary>
    public static string GetSourceLabel(string source)
    {
        foreach (var (s, l) in Sources)
            if (s == source) return l;
        return "";
    }

    /// <summary>True when any room light (Govee LAN/Cloud or Corsair)
    /// is currently in a powered-on state.</summary>
    private static bool AreRoomLightsOn()
    {
        var app = System.Windows.Application.Current as App;
        if (app == null) return false;
        try
        {
            var cfg = App.Config;
            if (cfg != null)
            {
                // Any Govee device reporting PoweredOn?
                foreach (var dev in cfg.Ambience.GoveeDevices)
                    if (dev.PoweredOn) return true;

                // Enabled Corsair lighting counts as "on" even in static mode
                // (e.g. forced white). Only explicit "off" should read false.
                if (cfg.Corsair.Enabled
                    && !string.Equals(cfg.Corsair.LightSyncMode, "off", StringComparison.OrdinalIgnoreCase))
                    return true;
            }
        }
        catch { }
        return false;
    }
}