ButtonHandler.cs

using System.Diagnostics;
using System.IO;
using System.Runtime.InteropServices;
using NAudio.CoreAudioApi;
using AmpUp.Core.Engine;
using AmpUp.Core.Models;
using AmpUp.Core.Services;
using AmpUp.Services;

namespace AmpUp;

public class ButtonHandler : IDisposable
{
    // P/Invoke declarations consolidated in NativeMethods.cs

    // ── Virtual key constants ─────────────────────────────────────────

    private const byte VK_MEDIA_PLAY_PAUSE = 0xB3;
    private const byte VK_MEDIA_NEXT_TRACK = 0xB0;
    private const byte VK_MEDIA_PREV_TRACK = 0xB1;
    private const byte VK_VOLUME_MUTE = 0xAD;
    private const byte VK_CONTROL = 0xA2;
    private const byte VK_SHIFT = 0xA0;
    private const byte VK_MENU = 0xA4;   // Alt
    private const byte VK_LWIN = 0x5B;
    private const byte VK_RETURN = 0x0D;
    private const byte VK_TAB = 0x09;
    private const byte VK_ESCAPE = 0x1B;
    private const byte VK_SPACE = 0x20;
    private const byte VK_UP = 0x26;
    private const byte VK_DOWN = 0x28;
    private const byte VK_LEFT = 0x25;
    private const byte VK_RIGHT = 0x27;
    private const byte VK_DELETE = 0x2E;
    private const byte VK_BACK = 0x08;
    private const byte VK_INSERT = 0x2D;
    private const byte VK_HOME = 0x24;
    private const byte VK_END = 0x23;
    private const byte VK_PRIOR = 0x21; // Page Up
    private const byte VK_NEXT = 0x22;  // Page Down
    private const byte VK_SNAPSHOT = 0x2C; // Print Screen
    private const uint KEYEVENTF_KEYUP = 0x0002;

    // ── Fields ────────────────────────────────────────────────────────

    private HAIntegration? _ha;
    private ObsIntegration? _obs;
    private VoiceMeeterIntegration? _vm;
    private readonly MMDeviceEnumerator _enumerator = new();
    private readonly ButtonGestureEngine _gestureEngine = new();

    // Stash config ref for action execution (needed by MuteAppGroup etc.)
    private volatile AppConfig? _lastConfig;

    // Cycle state: tracks current index per button for cycle_output / cycle_input
    private readonly Dictionary<int, int> _cycleIndex = new();
    private readonly Dictionary<string, int> _signalRgbCycleIndex = new(StringComparer.OrdinalIgnoreCase);

    // ── Events (forwarded from gesture engine) ──────────────────────

    public void SetHAIntegration(HAIntegration? ha) => _ha = ha;
    public void SetObsIntegration(ObsIntegration? obs) => _obs = obs;
    public void SetVoiceMeeterIntegration(VoiceMeeterIntegration? vm) => _vm = vm;

    /// <summary>Fires when room_toggle action is triggered — toggle all room lights.</summary>
    public event Action? OnRoomToggle;
    /// <summary>Fires when corsair_toggle action is triggered — toggle Corsair iCUE lights on/off.</summary>
    public event Action? OnCorsairToggle;
    /// <summary>Fires when govee_white_toggle action is triggered — flips the
    /// room between "forced white at 100%" and "all off". Any other room-
    /// control path (room_toggle / group_toggle) clears the forced state.</summary>
    public event Action? OnRoomWhiteToggle;
    /// <summary>Spotify control events — the handler in App forwards to the
    /// SpotifyIntegration service.</summary>
    public event Action? OnSpotifyPlayPause;
    public event Action? OnSpotifyNext;
    public event Action? OnSpotifyPrev;
    public event Action? OnSpotifyShuffleToggle;
    public event Action? OnSpotifyLikeToggle;
    /// <summary>Fires when room_effect action is triggered — set the active room effect by name (LightEffect enum string).</summary>
    public event Action<string>? OnRoomEffectSet;
    /// <summary>Fires with group name when group_toggle action is triggered — toggle a device group.</summary>
    public event Action<string>? OnGroupToggle;
    /// <summary>Fires with button index when quick_wheel is triggered.</summary>
    public event Action<int>? OnQuickWheelOpen;
    /// <summary>Fires with button index when the quick_wheel button is released.</summary>
    public event Action<int>? OnQuickWheelClose;
    /// <summary>Fires with page delta (-1, +1) or absolute page (0-based) for SC page nav.</summary>
    public event Action<int, bool>? OnScPageChange;
    /// <summary>Fires after a button action mutates an app group.</summary>
    public event Action? OnAppGroupChanged;

    // Track which button opened the wheel (for release detection)
    private int _quickWheelActiveButton = -1;

    public event Action<string>? OnProfileSwitch
    {
        add => _gestureEngine.OnProfileSwitch += value;
        remove => _gestureEngine.OnProfileSwitch -= value;
    }
    /// <summary>Fires with (deviceName, isOutput) when the default audio device changes.</summary>
    public event Action<string, bool>? OnDeviceSwitched
    {
        add => _gestureEngine.OnDeviceSwitched += value;
        remove => _gestureEngine.OnDeviceSwitched -= value;
    }
    /// <summary>Fires with new brightness percentage when cycle_brightness is triggered.</summary>
    public event Action<int>? OnBrightnessCycle
    {
        add => _gestureEngine.OnBrightnessCycle += value;
        remove => _gestureEngine.OnBrightnessCycle -= value;
    }

    // Brightness cycle presets (matches Turn Up behavior)
    private static readonly int[] BrightnessPresets = { 100, 75, 50, 25, 0 };
    private int _brightnessPresetIndex = 0;

    // ── IPolicyConfig COM interface for changing default audio device ──

    [ComImport]
    [Guid("f8679f50-850a-41cf-9c72-430f290290c8")]
    [InterfaceType(ComInterfaceType.InterfaceIsIUnknown)]
    private interface IPolicyConfig
    {
        // We only need SetDefaultEndpoint; pad the vtable with placeholder slots.
        // IPolicyConfig has many methods before SetDefaultEndpoint.
        // The exact vtable layout varies by Windows version. The commonly used
        // approach puts SetDefaultEndpoint at slot index 0 in a minimal interface.
        // We use the "IPolicyConfigVista" compatible layout:
        int GetMixFormat(string pszDeviceName, IntPtr ppFormat);
        int GetDeviceFormat(string pszDeviceName, int bDefault, IntPtr ppFormat);
        int ResetDeviceFormat(string pszDeviceName);
        int SetDeviceFormat(string pszDeviceName, IntPtr pEndpointFormat, IntPtr mixFormat);
        int GetProcessingPeriod(string pszDeviceName, int bDefault, IntPtr pmftDefaultPeriod, IntPtr pmftMinimumPeriod);
        int SetProcessingPeriod(string pszDeviceName, IntPtr pmftPeriod);
        int GetShareMode(string pszDeviceName, IntPtr pMode);
        int SetShareMode(string pszDeviceName, IntPtr mode);
        int GetPropertyValue(string pszDeviceName, int bFx, IntPtr pKey, IntPtr pValue);
        int SetPropertyValue(string pszDeviceName, int bFx, IntPtr pKey, IntPtr pValue);
        int SetDefaultEndpoint(string pszDeviceName, int role);
        int SetEndpointVisibility(string pszDeviceName, int bVisible);
    }

    private static readonly Guid CLSID_PolicyConfigClient = new("870af99c-171d-4f9e-af0d-e63df40c2bc9");

    // ── Constructor ─────────────────────────────────────────────────

    public ButtonHandler()
    {
        _gestureEngine.OnGestureAction += HandleGestureAction;
    }

    // ── Gesture forwarding (delegates to core engine) ───────────────

    public void HandleDown(int idx, AppConfig config)
    {
        _lastConfig = config;
        _gestureEngine.HandleDown(idx, config);
    }

    public void HandleUp(int idx, AppConfig config)
    {
        _lastConfig = config;
        _gestureEngine.HandleUp(idx, config);

        // If this button was holding the wheel open, fire close event
        if (_quickWheelActiveButton == idx)
        {
            _quickWheelActiveButton = -1;
            OnQuickWheelClose?.Invoke(idx);
        }
    }

    private void HandleGestureAction(int idx, string gesture, string action, ButtonConfig btn)
    {
        // Auto-trigger Quick Wheel on hold if this is a configured trigger button
        if (gesture == "hold" && _lastConfig?.Osd?.QuickWheels != null)
        {
            foreach (var qw in _lastConfig.Osd.QuickWheels)
            {
                if (qw.Enabled && idx == qw.GetVirtualButtonIdx())
                {
                    _quickWheelActiveButton = idx;
                    OnQuickWheelOpen?.Invoke(idx);
                    return; // override the button's normal hold action
                }
            }
        }

        ExecuteAction(action, btn.Path ?? "", btn);
    }

    /// <summary>Execute an action by name string, without needing a full ButtonConfig.</summary>
    public void ExecuteActionByName(string action, string path = "")
    {
        ExecuteAction(action, path, null);
    }

    // ── Action dispatcher ─────────────────────────────────────────────

    public void ExecuteAction(string action, string path, ButtonConfig? btn = null)
    {
        try
        {
            switch (action.ToLowerInvariant())
            {
                case "media_play_pause":
                    PressKey(VK_MEDIA_PLAY_PAUSE); break;
                case "media_next":
                    PressKey(VK_MEDIA_NEXT_TRACK); break;
                case "media_prev":
                    PressKey(VK_MEDIA_PREV_TRACK); break;
                case "mute_master":
                    PressKey(VK_VOLUME_MUTE); break;
                case "mute_mic":
                    ToggleMicMute(); break;
                case "launch_exe":
                    LaunchExe(path); break;
                case "mute_program":
                    MuteProgram(path); break;
                case "mute_active_window":
                    MuteActiveWindow(); break;
                case "mute_app_group":
                    MuteAppGroup(btn); break;
                case "add_active_app_to_group":
                    AddForegroundAppToGroup(btn); break;
                case "mute_device":
                    MuteDevice(btn?.DeviceId ?? ""); break;
                case "cycle_output":
                    CycleOutputDevice(btn); break;
                case "cycle_input":
                    CycleInputDevice(btn); break;
                case "select_output":
                    SelectDevice(btn?.DeviceId ?? "", DataFlow.Render); break;
                case "select_input":
                    SelectDevice(btn?.DeviceId ?? "", DataFlow.Capture); break;
                case "close_program":
                    CloseProgram(path); break;
                case "macro":
                    ExecuteMacro(btn?.MacroKeys ?? ""); break;
                case "switch_profile":
                    SwitchProfile(btn?.ProfileName ?? ""); break;
                case "cycle_profile":
                    CycleProfile(btn); break;
                case "system_power":
                    ExecuteSystemPower(btn?.PowerAction ?? ""); break;
                // Individual power actions (no sub-picker needed)
                case "power_sleep":
                    ExecuteSystemPower("sleep"); break;
                case "power_lock":
                    ExecuteSystemPower("lock"); break;
                case "power_off":
                    ExecuteSystemPower("shutdown"); break;
                case "power_restart":
                    ExecuteSystemPower("restart"); break;
                case "power_logoff":
                    ExecuteSystemPower("logoff"); break;
                case "power_hibernate":
                    ExecuteSystemPower("hibernate"); break;
                case "cycle_brightness":
                    CycleBrightness(); break;
                case "ha_toggle":
                    if (_ha != null && !string.IsNullOrEmpty(path))
                        _ = _ha.ToggleEntityAsync(path);
                    break;
                case "ha_scene":
                    if (_ha != null && !string.IsNullOrEmpty(path))
                        _ = _ha.ActivateSceneAsync(path);
                    break;
                case "ha_color":
                    if (_ha != null && !string.IsNullOrEmpty(path))
                        _ = SetHomeAssistantLightColorAsync(path);
                    break;
                case "ha_color_temp":
                    if (_ha != null && !string.IsNullOrEmpty(path))
                        _ = SetHomeAssistantLightTemperatureAsync(path);
                    break;
                case "ha_service":
                    if (_ha != null && !string.IsNullOrEmpty(path))
                    {
                        // path format: "domain.service:entity_id" or just "entity_id" for toggle
                        var parts = path.Split(':', 2);
                        if (parts.Length == 2)
                        {
                            var domSvc = parts[0].Split('.', 2);
                            if (domSvc.Length == 2)
                                _ = _ha.CallServiceAsync(domSvc[0], domSvc[1], parts[1]);
                        }
                        else
                        {
                            _ = _ha.ToggleEntityAsync(path);
                        }
                    }
                    break;
                case "room_effect":
                    // path = LightEffect name (e.g. "Fire", "Ocean", "Aurora")
                    if (!string.IsNullOrEmpty(path))
                        OnRoomEffectSet?.Invoke(path);
                    break;
                case "room_toggle":
                    // Toggle ALL room lights (Govee + Corsair) on/off
                    OnRoomToggle?.Invoke();
                    break;
                case "corsair_toggle":
                    // Toggle Corsair iCUE lights on/off (flips config.Corsair.Enabled)
                    OnCorsairToggle?.Invoke();
                    break;
                case "group_toggle":
                    // path = group name
                    if (!string.IsNullOrEmpty(path))
                        OnGroupToggle?.Invoke(path);
                    break;
                case "govee_toggle":
                    // path = device IP (LAN) OR "cloud:<deviceId>" for cloud-only
                    // devices that Govee doesn't expose on LAN (e.g. H604C G1S Pro).
                    if (!string.IsNullOrEmpty(path))
                        _ = GoveeToggleAsync(path);
                    break;
                case "quick_wheel":
                    // Fired by gesture engine (hold gesture) — open the radial wheel
                    if (btn != null)
                    {
                        _quickWheelActiveButton = btn.Idx;
                        OnQuickWheelOpen?.Invoke(btn.Idx);
                    }
                    break;
                case "obs_record":
                    if (_obs != null && _obs.IsAvailable)
                        _ = _obs.ToggleRecordingAsync();
                    break;
                case "obs_stream":
                    if (_obs != null && _obs.IsAvailable)
                        _ = _obs.ToggleStreamingAsync();
                    break;
                case "obs_scene":
                    if (_obs != null && _obs.IsAvailable && !string.IsNullOrEmpty(path))
                        _ = _obs.SetSceneAsync(path);
                    break;
                case "obs_mute":
                    if (_obs != null && _obs.IsAvailable && !string.IsNullOrEmpty(path))
                        _ = _obs.ToggleMuteAsync(path);
                    break;
                case "vm_mute_strip":
                    if (_vm != null && _vm.IsAvailable && int.TryParse(path, out int vmStripIdx))
                        _vm.ToggleStripMute(vmStripIdx);
                    break;
                case "vm_mute_bus":
                    if (_vm != null && _vm.IsAvailable && int.TryParse(path, out int vmBusIdx))
                        _vm.ToggleBusMute(vmBusIdx);
                    break;
                case "govee_color":
                    // path = "ip|hexcolor" e.g. "192.168.1.50|FF0080"
                    if (!string.IsNullOrEmpty(path))
                    {
                        var govParts = path.Split('|', 2);
                        if (govParts.Length == 2 && !string.IsNullOrEmpty(govParts[0]) && !string.IsNullOrEmpty(govParts[1]))
                        {
                            var ip = govParts[0];
                            var hex = govParts[1].TrimStart('#');
                            if (hex.Length == 6 && int.TryParse(hex, System.Globalization.NumberStyles.HexNumber, null, out int rgb))
                            {
                                byte r = (byte)((rgb >> 16) & 0xFF);
                                byte g = (byte)((rgb >> 8) & 0xFF);
                                byte b = (byte)(rgb & 0xFF);
                                _ = AmbienceSync.SendColorAsync(ip, r, g, b);
                            }
                            else
                            {
                            }
                        }
                        else if (govParts.Length == 1 && !string.IsNullOrEmpty(govParts[0]))
                        {
                        }
                    }
                    break;
                case "govee_white_toggle":
                    // Now a room-wide toggle: press 1 = all room lights on at
                    // 100% white, press 2 = all room lights off. Any other
                    // room-control path (room_toggle / group_toggle) clears
                    // the forced-white state so the room effect resumes.
                    OnRoomWhiteToggle?.Invoke();
                    break;
                case "spotify_play_pause": OnSpotifyPlayPause?.Invoke(); break;
                case "spotify_next":       OnSpotifyNext?.Invoke();       break;
                case "spotify_prev":       OnSpotifyPrev?.Invoke();       break;
                case "spotify_shuffle":    OnSpotifyShuffleToggle?.Invoke(); break;
                case "spotify_like":       OnSpotifyLikeToggle?.Invoke(); break;
                case "signalrgb_effect":
                    SignalRgbEffectCatalog.ApplyEffect(path);
                    break;
                case "signalrgb_effect_cycle":
                    CycleSignalRgbEffect(btn, path);
                    break;
                case "signalrgb_blackout":
                    SignalRgbEffectCatalog.ApplyBlackout();
                    break;
                case "signalrgb_restore":
                    SignalRgbEffectCatalog.RestoreLastEffect(GetSignalRgbRestoreFallback(btn, path));
                    break;
                case "sc_page_next":
                    OnScPageChange?.Invoke(1, false);
                    break;
                case "sc_page_prev":
                    OnScPageChange?.Invoke(-1, false);
                    break;
                case "sc_page_home":
                    OnScPageChange?.Invoke(0, true);
                    break;
                case "sc_go_to_page":
                    if (int.TryParse(path, out int targetPage))
                        OnScPageChange?.Invoke(targetPage - 1, true); // path is 1-based
                    break;
                case "multi_action":
                    if (btn?.ActionSequence != null && btn.ActionSequence.Count > 0)
                        _ = RunMultiActionAsync(btn.ActionSequence);
                    break;
                case "toggle_action":
                    if (btn != null)
                        RunToggleAction(btn);
                    break;
                case "open_folder":
                    // Empty FolderName is a valid target — means "go Home".
                    // The user can explicitly bind a key to return to Home
                    // after removing the auto Back key via the Spaces list.
                    if (btn != null)
                        OnOpenFolder?.Invoke(btn.FolderName ?? "");
                    break;
                case "open_url":
                    OpenUrl(path);
                    break;
                case "type_text":
                    TypeTextSnippet(btn?.TextSnippet ?? path);
                    break;
                case "screenshot":
                    CaptureScreenshot();
                    break;
            }
        }
        catch (Exception ex)
        {
            Logger.Log($"ExecuteAction error ({action}): {ex.Message}");
        }
    }

    // ── Stream Controller extended actions (stubs; filled in by feature implementations) ─

    /// <summary>Fires with folder name when `open_folder` fires — UI handler navigates to that folder.</summary>
    public event Action<string>? OnOpenFolder;

    private async Task RunMultiActionAsync(List<MultiActionStep> steps)
    {
        foreach (var step in steps)
        {
            if (step.DelayMs > 0)
                await Task.Delay(step.DelayMs);
            var stepBtn = new ButtonConfig
            {
                Action = step.Action,
                Path = step.Path ?? "",
                MacroKeys = step.MacroKeys ?? "",
                DeviceId = step.DeviceId ?? "",
                ProfileName = step.ProfileName ?? "",
                PowerAction = step.PowerAction ?? "",
            };
            ExecuteAction(step.Action, step.Path ?? "", stepBtn);
        }
    }

    private void RunToggleAction(ButtonConfig btn)
    {
        bool runB = btn.ToggleStateIsB;
        var action = runB ? btn.ToggleActionB : btn.ToggleActionA;
        var path = runB ? btn.TogglePathB : btn.TogglePathA;
        btn.ToggleStateIsB = !runB;
        ExecuteAction(action, path ?? "", btn);
    }

    private void CycleSignalRgbEffect(ButtonConfig? btn, string path)
    {
        var effects = GetSignalRgbEffectNames(btn, path);
        if (effects.Count == 0) return;

        string key = $"{btn?.Idx ?? -1}:{string.Join("|", effects)}";
        int next = _signalRgbCycleIndex.GetValueOrDefault(key);
        if (next < 0 || next >= effects.Count) next = 0;

        SignalRgbEffectCatalog.ApplyEffect(effects[next]);
        _signalRgbCycleIndex[key] = (next + 1) % effects.Count;
    }

    private static string GetSignalRgbRestoreFallback(ButtonConfig? btn, string path)
    {
        var effects = GetSignalRgbEffectNames(btn, path);
        return effects.Count > 0 ? effects[0] : "";
    }

    private static List<string> GetSignalRgbEffectNames(ButtonConfig? btn, string path)
    {
        var names = btn?.SignalRgbEffectNames?
            .Where(n => !string.IsNullOrWhiteSpace(n))
            .Select(n => n.Trim())
            .Distinct(StringComparer.OrdinalIgnoreCase)
            .ToList() ?? new List<string>();

        if (names.Count > 0)
            return names;

        return SplitSignalRgbEffectPath(path);
    }

    private static List<string> SplitSignalRgbEffectPath(string path)
    {
        if (string.IsNullOrWhiteSpace(path)) return new();

        return path
            .Split(new[] { '|', ';', '\n', '\r', '\t' }, StringSplitOptions.RemoveEmptyEntries | StringSplitOptions.TrimEntries)
            .Where(p => !string.IsNullOrWhiteSpace(p))
            .Distinct(StringComparer.OrdinalIgnoreCase)
            .ToList();
    }

    private static void OpenUrl(string url)
    {
        if (string.IsNullOrWhiteSpace(url)) return;
        try
        {
            var trimmed = url.Trim();
            if (!trimmed.Contains("://"))
                trimmed = "https://" + trimmed;
            Process.Start(new ProcessStartInfo { FileName = trimmed, UseShellExecute = true });
        }
        catch (Exception ex) { Logger.Log($"open_url error: {ex.Message}"); }
    }

    private static void TypeTextSnippet(string text)
    {
        if (string.IsNullOrEmpty(text)) return;
        try
        {
            // SendKeys.SendWait escapes by default via System.Windows.Forms.
            // We use low-level keybd_event via ExecuteMacro's chain is keystroke-combo oriented,
            // so for plain text we use SendKeys.
            System.Windows.Forms.SendKeys.SendWait(EscapeSendKeys(text));
        }
        catch (Exception ex) { Logger.Log($"type_text error: {ex.Message}"); }
    }

    private static string EscapeSendKeys(string text)
    {
        // SendKeys treats +^%~(){}[] as special — escape with {}
        var sb = new System.Text.StringBuilder(text.Length + 8);
        foreach (var ch in text)
        {
            if ("+^%~(){}[]".IndexOf(ch) >= 0)
                sb.Append('{').Append(ch).Append('}');
            else if (ch == '\n')
                sb.Append('~'); // Enter
            else
                sb.Append(ch);
        }
        return sb.ToString();
    }

    private static void CaptureScreenshot()
    {
        try
        {
            var bounds = System.Windows.Forms.Screen.PrimaryScreen?.Bounds ?? new System.Drawing.Rectangle(0, 0, 1920, 1080);
            using var bmp = new System.Drawing.Bitmap(bounds.Width, bounds.Height);
            using (var g = System.Drawing.Graphics.FromImage(bmp))
                g.CopyFromScreen(bounds.Left, bounds.Top, 0, 0, bounds.Size);
            System.Windows.Forms.Clipboard.SetImage(bmp);
        }
        catch (Exception ex) { Logger.Log($"screenshot error: {ex.Message}"); }
    }

    // ── Govee on/off toggle (LAN or Cloud) ─────────────────────────────

    /// <summary>
    /// Toggle a Govee device on/off. Path is either a raw IP (LAN sync) or
    /// "cloud:&lt;deviceId&gt;" for devices Govee blocks from LAN control (e.g.
    /// DreamView G1S Pro / H604C — confirmed by Govee support). Cloud path
    /// looks up the matching config entry for SKU + current PoweredOn
    /// state, flips it via the REST API, and persists the new state.
    /// </summary>
    private async Task GoveeToggleAsync(string path)
    {
        try
        {
            if (path.StartsWith("cloud:", StringComparison.OrdinalIgnoreCase))
            {
                if (_lastConfig == null) return;
                var apiKey = _lastConfig.Ambience.GoveeApiKey;
                if (string.IsNullOrWhiteSpace(apiKey)) return;

                var deviceId = path.Substring("cloud:".Length);
                var dev = _lastConfig.Ambience.GoveeDevices
                    .FirstOrDefault(d => d.DeviceId == deviceId);
                if (dev == null || string.IsNullOrEmpty(dev.Sku)) return;

                bool newState = !dev.PoweredOn;
                using var api = new GoveeCloudApi(apiKey);
                await api.ControlDeviceAsync(deviceId, dev.Sku,
                    GoveeCloudApi.TurnOnOff(newState));
                dev.PoweredOn = newState;
                return;
            }

            await AmbienceSync.SendToggleAsync(path);
        }
        catch (Exception ex)
        {
            Logger.Log($"govee_toggle error: {ex.Message}");
        }
    }

    // ── Simple key press ──────────────────────────────────────────────

    private static void PressKey(byte vk)
    {
        NativeMethods.keybd_event(vk, 0, 0, UIntPtr.Zero);
        NativeMethods.keybd_event(vk, 0, KEYEVENTF_KEYUP, UIntPtr.Zero);
    }

    // ── Launch executable ─────────────────────────────────────────────

    private static void LaunchExe(string path)
    {
        if (string.IsNullOrWhiteSpace(path))
        {
            return;
        }
        try
        {
            // Support "path args" format (e.g. "C:\Update.exe --processStart Discord.exe")
            string fileName = path;
            string arguments = "";
            if (!File.Exists(path) && path.Contains(' '))
            {
                // Try splitting at first space to separate exe from args
                var parts = path.Split(' ', 2);
                if (File.Exists(parts[0]))
                {
                    fileName = parts[0];
                    arguments = parts[1];
                }
                // Also try quoted path: "path with spaces" args
                else if (path.StartsWith('"'))
                {
                    int closeQuote = path.IndexOf('"', 1);
                    if (closeQuote > 0)
                    {
                        fileName = path.Substring(1, closeQuote - 1);
                        arguments = path.Length > closeQuote + 1 ? path.Substring(closeQuote + 2) : "";
                    }
                }
            }

            Process.Start(new ProcessStartInfo
            {
                FileName = fileName,
                Arguments = arguments,
                UseShellExecute = true
            });
        }
        catch (Exception ex)
        {
            Logger.Log($"launch_exe error: {ex.Message}");
        }
    }

    // ── Mic mute toggle ───────────────────────────────────────────────

    private void ToggleMicMute()
    {
        try
        {
            using var mic = _enumerator.GetDefaultAudioEndpoint(DataFlow.Capture, Role.Communications);
            mic.AudioEndpointVolume.Mute = !mic.AudioEndpointVolume.Mute;
        }
        catch (Exception ex)
        {
            Logger.Log($"ToggleMicMute error: {ex.Message}");
        }
    }

    // ── Mute program by process name ──────────────────────────────────

    private void MuteProgram(string processName)
    {
        if (string.IsNullOrWhiteSpace(processName))
        {
            return;
        }
        try
        {
            using var device = _enumerator.GetDefaultAudioEndpoint(DataFlow.Render, Role.Multimedia);
            var sessions = device.AudioSessionManager.Sessions;
            for (int i = 0; i < sessions.Count; i++)
            {
                var session = sessions[i];
                try
                {
                    var pid = (int)session.GetProcessID;
                    if (pid == 0) continue;
                    var proc = Process.GetProcessById(pid);
                    if (proc.ProcessName.Contains(processName, StringComparison.OrdinalIgnoreCase)
                        || proc.ProcessName.Replace(" ", "").Contains(processName.Replace(" ", ""), StringComparison.OrdinalIgnoreCase))
                    {
                        session.SimpleAudioVolume.Mute = !session.SimpleAudioVolume.Mute;
                        return;
                    }
                }
                catch
                {
                    // Process may have exited
                }
            }
        }
        catch (Exception ex)
        {
            Logger.Log($"mute_program error: {ex.Message}");
        }
    }

    // ── Mute active (foreground) window ───────────────────────────────

    private void MuteActiveWindow()
    {
        try
        {
            var hwnd = NativeMethods.GetForegroundWindow();
            if (hwnd == IntPtr.Zero)
            {
                return;
            }

            NativeMethods.GetWindowThreadProcessId(hwnd, out uint pid);
            if (pid == 0)
            {
                return;
            }

            using var device = _enumerator.GetDefaultAudioEndpoint(DataFlow.Render, Role.Multimedia);
            var sessions = device.AudioSessionManager.Sessions;
            for (int i = 0; i < sessions.Count; i++)
            {
                var session = sessions[i];
                if (session.GetProcessID == pid)
                {
                    session.SimpleAudioVolume.Mute = !session.SimpleAudioVolume.Mute;
                    return;
                }
            }

            // Some apps spawn child processes for audio — try matching by process name
            try
            {
                var fgProc = Process.GetProcessById((int)pid);
                var fgName = fgProc.ProcessName;
                for (int i = 0; i < sessions.Count; i++)
                {
                    var session = sessions[i];
                    try
                    {
                        var sPid = (int)session.GetProcessID;
                        if (sPid == 0) continue;
                        var sProc = Process.GetProcessById(sPid);
                        if (sProc.ProcessName.Contains(fgName, StringComparison.OrdinalIgnoreCase))
                        {
                            session.SimpleAudioVolume.Mute = !session.SimpleAudioVolume.Mute;
                            return;
                        }
                    }
                    catch { }
                }
            }
            catch { }
        }
        catch (Exception ex)
        {
            Logger.Log($"mute_active_window error: {ex.Message}");
        }
    }

    // ── Mute all apps in a knob's app group ───────────────────────────

    private void MuteAppGroup(ButtonConfig? btn)
    {
        if (btn == null || _lastConfig == null)
        {
            return;
        }

        int knobIdx = btn.LinkedKnobIdx;
        if (knobIdx < 0 || knobIdx > 4)
        {
            return;
        }

        var knob = _lastConfig.Knobs.FirstOrDefault(k => k.Idx == knobIdx);
        if (knob == null || knob.Apps == null || knob.Apps.Count == 0)
        {
            return;
        }

        try
        {
            using var device = _enumerator.GetDefaultAudioEndpoint(DataFlow.Render, Role.Multimedia);
            var sessions = device.AudioSessionManager.Sessions;

            var matchingSessions = new List<NAudio.CoreAudioApi.AudioSessionControl>();
            for (int i = 0; i < sessions.Count; i++)
            {
                var session = sessions[i];
                try
                {
                    var pid = (int)session.GetProcessID;
                    if (pid == 0) continue;
                    var proc = Process.GetProcessById(pid);
                    var procName = proc.ProcessName.ToLowerInvariant();

                    foreach (var appName in knob.Apps)
                    {
                        var appLower = appName.ToLowerInvariant();
                        if (procName.Contains(appLower)
                            || procName.Replace(" ", "").Contains(appLower.Replace(" ", "")))
                        {
                            matchingSessions.Add(session);
                            break;
                        }
                    }
                }
                catch { }
            }

            if (matchingSessions.Count == 0)
            {
                return;
            }

            // Toggle: if ANY session is unmuted → mute all. If ALL muted → unmute all.
            bool anyUnmuted = matchingSessions.Any(s => !s.SimpleAudioVolume.Mute);
            bool newMuteState = anyUnmuted;

            foreach (var session in matchingSessions)
            {
                try { session.SimpleAudioVolume.Mute = newMuteState; } catch { }
            }

        }
        catch (Exception ex)
        {
            Logger.Log($"mute_app_group error: {ex.Message}");
        }
    }

    // ── Add foreground app to a knob app group ───────────────────────

    private void AddForegroundAppToGroup(ButtonConfig? btn)
    {
        if (btn == null || _lastConfig == null)
        {
            return;
        }

        int knobIdx = btn.LinkedKnobIdx;
        if (knobIdx < 0 || knobIdx > 4)
        {
            return;
        }

        try
        {
            var hwnd = NativeMethods.GetForegroundWindow();
            if (hwnd == IntPtr.Zero)
            {
                return;
            }

            NativeMethods.GetWindowThreadProcessId(hwnd, out uint pid);
            if (pid == 0 || pid == Environment.ProcessId)
            {
                return;
            }

            using var proc = Process.GetProcessById((int)pid);
            var processName = proc.ProcessName.Trim();
            if (string.IsNullOrWhiteSpace(processName)
                || processName.Equals("AmpUp", StringComparison.OrdinalIgnoreCase))
            {
                return;
            }

            var knob = _lastConfig.Knobs.FirstOrDefault(k => k.Idx == knobIdx);
            if (knob == null)
            {
                return;
            }

            knob.Target = "apps";
            knob.Apps ??= new List<string>();
            if (knob.Apps.Any(a => a.Equals(processName, StringComparison.OrdinalIgnoreCase)))
            {
                return;
            }

            knob.Apps.Add(processName.ToLowerInvariant());
            Logger.Log($"Added focused app '{processName}' to knob {knobIdx + 1} app group");
            OnAppGroupChanged?.Invoke();
        }
        catch (Exception ex)
        {
            Logger.Log($"add_active_app_to_group error: {ex.Message}");
        }
    }

    private async Task SetHomeAssistantLightColorAsync(string path)
    {
        try
        {
            var parts = path.Split('|', 2);
            if (parts.Length != 2) return;

            var entityId = parts[0].Trim();
            var hex = parts[1].Trim().TrimStart('#');
            if (string.IsNullOrWhiteSpace(entityId) || hex.Length != 6)
                return;

            if (!int.TryParse(hex, System.Globalization.NumberStyles.HexNumber, null, out int rgb))
                return;

            byte r = (byte)((rgb >> 16) & 0xFF);
            byte g = (byte)((rgb >> 8) & 0xFF);
            byte b = (byte)(rgb & 0xFF);
            await _ha!.SetLightColorAsync(entityId, r, g, b);
        }
        catch (Exception ex)
        {
            Logger.Log($"ha_color error: {ex.Message}");
        }
    }

    // ── Mute specific audio device by DeviceId ───────────────────────

    private async Task SetHomeAssistantLightTemperatureAsync(string path)
    {
        try
        {
            var parts = path.Split('|', 2);
            if (parts.Length != 2) return;

            var entityId = parts[0].Trim();
            var rawKelvin = parts[1].Trim();
            if (rawKelvin.StartsWith("temp:", StringComparison.OrdinalIgnoreCase))
                rawKelvin = rawKelvin.Substring(5);

            if (string.IsNullOrWhiteSpace(entityId) || !int.TryParse(rawKelvin, out int kelvin))
                return;

            await _ha!.SetLightColorTemperatureAsync(entityId, kelvin);
        }
        catch (Exception ex)
        {
            Logger.Log($"ha_color_temp error: {ex.Message}");
        }
    }

    private void MuteDevice(string deviceId)
    {
        if (string.IsNullOrWhiteSpace(deviceId))
        {
            return;
        }

        try
        {
            // Try Render (output) devices first, then Capture (input)
            foreach (var flow in new[] { DataFlow.Render, DataFlow.Capture })
            {
                try
                {
                    var devices = _enumerator.EnumerateAudioEndPoints(flow, DeviceState.Active);
                    for (int i = 0; i < devices.Count; i++)
                    {
                        var device = devices[i];
                        if (device.ID == deviceId)
                        {
                            bool newMute = !device.AudioEndpointVolume.Mute;
                            device.AudioEndpointVolume.Mute = newMute;
                            return;
                        }
                    }
                }
                catch { }
            }
        }
        catch (Exception ex)
        {
            Logger.Log($"mute_device error: {ex.Message}");
        }
    }

    // ── Cycle output devices ──────────────────────────────────────────

    private void CycleOutputDevice(ButtonConfig? btn)
    {
        try
        {
            CycleDevice(DataFlow.Render, btn?.DeviceIds, btn?.Idx ?? -1, btn?.CycleDeviceType ?? CycleDeviceType.Both);
        }
        catch (Exception ex)
        {
            Logger.Log($"cycle_output error: {ex.Message}");
        }
    }

    // ── Cycle input devices ───────────────────────────────────────────

    private void CycleInputDevice(ButtonConfig? btn)
    {
        try
        {
            CycleDevice(DataFlow.Capture, btn?.DeviceIds, btn?.Idx ?? -1, btn?.CycleDeviceType ?? CycleDeviceType.Both);
        }
        catch (Exception ex)
        {
            Logger.Log($"cycle_input error: {ex.Message}");
        }
    }

    private void CycleDevice(DataFlow flow, List<string>? allowedIds, int buttonIdx, CycleDeviceType deviceType = CycleDeviceType.Both)
    {
        var role = flow == DataFlow.Render ? Role.Multimedia : Role.Communications;
        using var currentDevice = _enumerator.GetDefaultAudioEndpoint(flow, role);
        var currentId = currentDevice.ID;

        List<string> deviceIds;
        if (allowedIds != null && allowedIds.Count > 0)
        {
            // Use only the specified subset, but verify they exist
            var allDevices = _enumerator.EnumerateAudioEndPoints(flow, DeviceState.Active);
            var activeIds = new HashSet<string>();
            for (int i = 0; i < allDevices.Count; i++)
            {
                using var d = allDevices[i];
                activeIds.Add(d.ID);
            }
            deviceIds = allowedIds.Where(id => activeIds.Contains(id)).ToList();
        }
        else
        {
            var allDevices = _enumerator.EnumerateAudioEndPoints(flow, DeviceState.Active);
            deviceIds = new List<string>();
            for (int i = 0; i < allDevices.Count; i++)
            {
                using var d = allDevices[i];
                deviceIds.Add(d.ID);
            }
        }

        if (deviceIds.Count < 2)
        {
            return;
        }

        // Find current position and advance
        int currentIdx = deviceIds.IndexOf(currentId);
        int nextIdx = (currentIdx + 1) % deviceIds.Count;
        var nextId = deviceIds[nextIdx];

        SetDefaultAudioDevice(nextId, deviceType);

        // Log friendly name and fire event
        try
        {
            var allDevs = _enumerator.EnumerateAudioEndPoints(flow, DeviceState.Active);
            for (int i = 0; i < allDevs.Count; i++)
            {
                using var d = allDevs[i];
                if (d.ID == nextId)
                {
                    var name = d.FriendlyName;
                    _gestureEngine.RaiseDeviceSwitched(name, flow == DataFlow.Render);
                    break;
                }
            }
        }
        catch { }
    }

    // ── Select specific device ────────────────────────────────────────

    private void SelectDevice(string deviceId, DataFlow flow)
    {
        if (string.IsNullOrWhiteSpace(deviceId))
        {
            return;
        }
        try
        {
            SetDefaultAudioDevice(deviceId);
            // Resolve friendly name for notification
            try
            {
                var allDevs = _enumerator.EnumerateAudioEndPoints(flow, DeviceState.Active);
                for (int i = 0; i < allDevs.Count; i++)
                {
                    using var d = allDevs[i];
                    if (d.ID == deviceId)
                    {
                        _gestureEngine.RaiseDeviceSwitched(d.FriendlyName, flow == DataFlow.Render);
                        break;
                    }
                }
            }
            catch { }
        }
        catch (Exception ex)
        {
            Logger.Log($"select_{(flow == DataFlow.Render ? "output" : "input")} error: {ex.Message}");
        }
    }

    // ── Set default audio device via IPolicyConfig COM ─────────────────

    internal static void SetDefaultAudioDevice(string deviceId, CycleDeviceType deviceType = CycleDeviceType.Both)
    {
        var policyConfigType = Type.GetTypeFromCLSID(CLSID_PolicyConfigClient);
        if (policyConfigType == null)
            throw new InvalidOperationException("Could not get PolicyConfigClient type from CLSID");

        var policyConfig = (IPolicyConfig)Activator.CreateInstance(policyConfigType)!;

        switch (deviceType)
        {
            case CycleDeviceType.Media:
                policyConfig.SetDefaultEndpoint(deviceId, 0); // Console
                policyConfig.SetDefaultEndpoint(deviceId, 1); // Multimedia
                break;
            case CycleDeviceType.Communications:
                policyConfig.SetDefaultEndpoint(deviceId, 2); // Communications
                break;
            default: // Both
                policyConfig.SetDefaultEndpoint(deviceId, 0);
                policyConfig.SetDefaultEndpoint(deviceId, 1);
                policyConfig.SetDefaultEndpoint(deviceId, 2);
                break;
        }
    }

    // ── Close / kill program ──────────────────────────────────────────

    private static void CloseProgram(string processName)
    {
        if (string.IsNullOrWhiteSpace(processName))
        {
            return;
        }
        try
        {
            // Strip .exe if user included it
            var name = processName.EndsWith(".exe", StringComparison.OrdinalIgnoreCase)
                ? processName[..^4]
                : processName;

            var procs = Process.GetProcessesByName(name);
            if (procs.Length == 0)
            {
                // Fallback: substring match across all processes
                procs = Process.GetProcesses()
                    .Where(p =>
                    {
                        try { return p.ProcessName.Contains(processName, StringComparison.OrdinalIgnoreCase); }
                        catch { return false; }
                    })
                    .ToArray();
            }

            if (procs.Length > 0)
            {
                procs[0].Kill();
            }
        }
        catch (Exception ex)
        {
            Logger.Log($"close_program error: {ex.Message}");
        }
    }

    // ── Macro (keyboard combo) ────────────────────────────────────────

    private static void ExecuteMacro(string macroKeys)
    {
        if (string.IsNullOrWhiteSpace(macroKeys))
        {
            return;
        }

        try
        {
            var parts = macroKeys.ToLowerInvariant().Split('+', StringSplitOptions.RemoveEmptyEntries | StringSplitOptions.TrimEntries);
            var modifiers = new List<byte>();
            var keys = new List<byte>();

            foreach (var part in parts)
            {
                switch (part)
                {
                    case "ctrl" or "control":
                        modifiers.Add(VK_CONTROL); break;
                    case "shift":
                        modifiers.Add(VK_SHIFT); break;
                    case "alt":
                        modifiers.Add(VK_MENU); break;
                    case "win" or "windows" or "super":
                        modifiers.Add(VK_LWIN); break;
                    default:
                        var vk = ResolveKeyCode(part);
                        if (vk != 0) keys.Add(vk);
                        break;
                }
            }

            // Press modifiers down
            foreach (var mod in modifiers)
                NativeMethods.keybd_event(mod, 0, 0, UIntPtr.Zero);

            // Press and release each key
            foreach (var key in keys)
            {
                NativeMethods.keybd_event(key, 0, 0, UIntPtr.Zero);
                NativeMethods.keybd_event(key, 0, KEYEVENTF_KEYUP, UIntPtr.Zero);
            }

            // Release modifiers in reverse order
            for (int i = modifiers.Count - 1; i >= 0; i--)
                NativeMethods.keybd_event(modifiers[i], 0, KEYEVENTF_KEYUP, UIntPtr.Zero);
        }
        catch (Exception ex)
        {
            Logger.Log($"macro error: {ex.Message}");
        }
    }

    private static byte ResolveKeyCode(string keyName)
    {
        return keyName switch
        {
            "enter" or "return" => VK_RETURN,
            "tab" => VK_TAB,
            "escape" or "esc" => VK_ESCAPE,
            "space" or "spacebar" => VK_SPACE,
            "up" => VK_UP,
            "down" => VK_DOWN,
            "left" => VK_LEFT,
            "right" => VK_RIGHT,
            "delete" or "del" => VK_DELETE,
            "backspace" => VK_BACK,
            "insert" or "ins" => VK_INSERT,
            "home" => VK_HOME,
            "end" => VK_END,
            "pageup" or "pgup" => VK_PRIOR,
            "pagedown" or "pgdn" => VK_NEXT,
            "printscreen" or "prtsc" => VK_SNAPSHOT,
            "f1" => 0x70, "f2" => 0x71, "f3" => 0x72, "f4" => 0x73,
            "f5" => 0x74, "f6" => 0x75, "f7" => 0x76, "f8" => 0x77,
            "f9" => 0x78, "f10" => 0x79, "f11" => 0x7A, "f12" => 0x7B,
            "0" => 0x30, "1" => 0x31, "2" => 0x32, "3" => 0x33, "4" => 0x34,
            "5" => 0x35, "6" => 0x36, "7" => 0x37, "8" => 0x38, "9" => 0x39,
            _ => ResolveKeyCodeFallback(keyName)
        };
    }

    private static byte ResolveKeyCodeFallback(string keyName)
    {
        // Single character — use VkKeyScan to resolve to virtual key code
        if (keyName.Length == 1)
        {
            short result = NativeMethods.VkKeyScan(keyName[0]);
            byte vk = (byte)(result & 0xFF);
            if (vk != 0xFF)
                return vk;
            // VkKeyScan failed; fall back to uppercase ASCII for letter keys
            if (char.IsAsciiLetter(keyName[0]))
                return (byte)char.ToUpperInvariant(keyName[0]);
        }

        return 0;
    }

    // ── Switch profile ────────────────────────────────────────────────

    private void SwitchProfile(string profileName)
    {
        if (string.IsNullOrWhiteSpace(profileName))
        {
            return;
        }
        _gestureEngine.RaiseProfileSwitch(profileName);
    }

    // ── Cycle profiles ──────────────────────────────────────────────

    private readonly Dictionary<int, int> _profileCycleIndex = new();

    private void CycleProfile(ButtonConfig? btn)
    {
        if (btn == null || _lastConfig == null) return;

        // Get the profile subset (or all profiles if none specified)
        var profileNames = btn.ProfileNames?.Count > 0
            ? btn.ProfileNames
            : _lastConfig.Profiles;

        if (profileNames == null || profileNames.Count < 2)
        {
            return;
        }

        // Find current index
        int currentIdx = _profileCycleIndex.GetValueOrDefault(btn.Idx, -1);
        // If current profile is in the list, start from there
        var activeProfile = _lastConfig.ActiveProfile;
        if (currentIdx < 0 || currentIdx >= profileNames.Count
            || !string.Equals(profileNames[currentIdx], activeProfile, StringComparison.OrdinalIgnoreCase))
        {
            currentIdx = profileNames.FindIndex(p => string.Equals(p, activeProfile, StringComparison.OrdinalIgnoreCase));
        }

        int nextIdx = (currentIdx + 1) % profileNames.Count;
        _profileCycleIndex[btn.Idx] = nextIdx;

        var nextProfile = profileNames[nextIdx];
        _gestureEngine.RaiseProfileSwitch(nextProfile);
    }

    // ── LED brightness cycle ──────────────────────────────────────────

    private void CycleBrightness()
    {
        _brightnessPresetIndex = (_brightnessPresetIndex + 1) % BrightnessPresets.Length;
        var pct = BrightnessPresets[_brightnessPresetIndex];
        _gestureEngine.RaiseBrightnessCycle(pct);
    }

    // ── Dispose ───────────────────────────────────────────────────────

    public void Dispose()
    {
        _gestureEngine.OnGestureAction -= HandleGestureAction;
        _gestureEngine.Dispose();
        _enumerator.Dispose();
    }

    // ── System power actions ──────────────────────────────────────────

    private static void ExecuteSystemPower(string powerAction)
    {
        if (string.IsNullOrWhiteSpace(powerAction))
        {
            return;
        }

        try
        {
            switch (powerAction.ToLowerInvariant())
            {
                case "sleep":
                    // forceCritical=false allows apps to prepare for sleep properly
                    // (GPU, USB devices, etc. get clean suspend notifications)
                    NativeMethods.SetSuspendState(false, false, false);
                    break;
                case "hibernate":
                    NativeMethods.SetSuspendState(true, false, false);
                    break;
                case "lock":
                    NativeMethods.LockWorkStation();
                    break;
                case "shutdown":
                    Process.Start("shutdown", "/s /t 0");
                    break;
                case "restart":
                    Process.Start("shutdown", "/r /t 0");
                    break;
                case "logoff":
                    NativeMethods.ExitWindowsEx(0, 0);
                    break;
                default:
                    break;
            }
        }
        catch (Exception ex)
        {
            Logger.Log($"system_power error: {ex.Message}");
        }
    }
}