Program.cs

// LEDder - ThinkPad LED control (.NET 8 WinForms port)
//
// BUILD:   dotnet build -c Release
// SILENT:  LEDder.exe --silent   (or config SilentOnLaunch=true)
//
// WinRing0x64.dll AND WinRing0x64.sys must be next to the .exe.
// App self-elevates via UAC on first launch.

using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Drawing;
using System.Drawing.Drawing2D;
using System.IO;
using System.Linq;
using System.Runtime.InteropServices;
using System.Security.Principal;
using System.Text;
using System.Text.Json;
using System.Windows.Forms;

namespace LEDder;

// ============================================================
// Entry point
// ============================================================
internal static class Program
{
    public const string AppTitle = "LEDder \u2013 ThinkPad LED control";

    [STAThread]
    static void Main(string[] args)
    {
        bool cliSilent = args.Any(a =>
            a.Equals("--silent", StringComparison.OrdinalIgnoreCase) ||
            a.Equals("-s", StringComparison.OrdinalIgnoreCase) ||
            a.Equals("/silent", StringComparison.OrdinalIgnoreCase));

        if (!IsAdmin())
        {
            try
            {
                var psi = new ProcessStartInfo
                {
                    FileName = Environment.ProcessPath ?? Application.ExecutablePath,
                    UseShellExecute = true,
                    Verb = "runas",
                    Arguments = cliSilent ? "--silent" : "",
                };
                Process.Start(psi);
            }
            catch
            {
                MessageBox.Show("This app must run as Administrator.",
                    AppTitle, MessageBoxButtons.OK, MessageBoxIcon.Error);
            }
            return;
        }

        Application.EnableVisualStyles();
        Application.SetCompatibleTextRenderingDefault(false);

        var exeDir = Path.GetDirectoryName(Environment.ProcessPath ?? "")!;
        if (!File.Exists(Path.Combine(exeDir, "WinRing0x64.dll")) ||
            !File.Exists(Path.Combine(exeDir, "WinRing0x64.sys")))
        {
            MessageBox.Show(
                $"WinRing0x64.dll and WinRing0x64.sys must be in:\n\n{exeDir}\n\n" +
                "Copy both files there and retry.",
                AppTitle, MessageBoxButtons.OK, MessageBoxIcon.Error);
            return;
        }

        try { Ec.Initialize(); }
        catch (Exception e)
        {
            MessageBox.Show(
                $"WinRing0 driver failed to load:\n\n{e.Message}\n\n" +
                "Common causes:\n" +
                " \u2022 HVCI / Memory Integrity enabled\n" +
                " \u2022 Defender blocked the driver\n" +
                " \u2022 Unsigned / old WinRing0 build",
                AppTitle, MessageBoxButtons.OK, MessageBoxIcon.Error);
            return;
        }

        AudioMute.Initialize();

        try
        {
            var form = new MainForm { StartHidden = cliSilent };
            Application.Run(form);
        }
        catch (Exception e)
        {
            MessageBox.Show(e.ToString(), AppTitle,
                MessageBoxButtons.OK, MessageBoxIcon.Error);
        }
        finally { Ec.Shutdown(); }
    }

    static bool IsAdmin()
    {
        using var identity = WindowsIdentity.GetCurrent();
        return new WindowsPrincipal(identity).IsInRole(WindowsBuiltInRole.Administrator);
    }
}

// ============================================================
// Style palette
// ============================================================
internal static class Style
{
    // palette
    public static readonly Color Bg           = Color.FromArgb(244, 245, 247);
    public static readonly Color Panel        = Color.White;
    public static readonly Color Border       = Color.FromArgb(224, 226, 230);
    public static readonly Color BorderHover  = Color.FromArgb(180, 183, 188);
    public static readonly Color TextPrimary  = Color.FromArgb(28, 28, 32);
    public static readonly Color TextMuted    = Color.FromArgb(120, 120, 128);
    public static readonly Color Accent       = Color.FromArgb(0, 113, 227);
    public static readonly Color StatusOn     = Color.FromArgb(48, 164, 80);
    public static readonly Color StatusAlert  = Color.FromArgb(220, 52, 50);
    public static readonly Color BtnBg        = Color.FromArgb(250, 250, 252);
    public static readonly Color BtnHover     = Color.FromArgb(235, 236, 240);
    public static readonly Color BtnPressed   = Color.FromArgb(220, 222, 227);

    // typography
    public static readonly Font Body    = new("Segoe UI", 9f);
    public static readonly Font Header  = new("Segoe UI Semibold", 10f);
    public static readonly Font Mono    = new("Consolas", 9f);
    public static readonly Font AppName = new("Segoe UI Semibold", 11f);

    /// <summary>Creates a bordered white panel with a header label at top.</summary>
    public static Panel MakeSection(string title, out int contentTopY)
    {
        const int HEADER_H = 34;
        contentTopY = HEADER_H;

        var p = new Panel
        {
            BackColor = Panel,
        };
        p.Paint += (_, e) =>
        {
            e.Graphics.SmoothingMode = SmoothingMode.AntiAlias;
            using var pen = new Pen(Border, 1);
            e.Graphics.DrawRectangle(pen, 0, 0, p.Width - 1, p.Height - 1);
        };

        var hdr = new Label
        {
            Text = title,
            Location = new Point(12, 9),
            AutoSize = true,
            Font = Header,
            ForeColor = TextPrimary,
            BackColor = Color.Transparent,
        };
        p.Controls.Add(hdr);

        // subtle separator under header
        var sep = new Label
        {
            BackColor = Border,
            Location = new Point(1, HEADER_H - 1),
            Size = new Size(1, 1), // will be resized in Layout event
        };
        p.Controls.Add(sep);
        p.Layout += (_, _) => sep.Size = new Size(p.Width - 2, 1);

        return p;
    }

    public static Button FlatButton(string text, int x, int y, int w, int h, Action click)
    {
        var b = new Button
        {
            Text = text,
            Location = new Point(x, y),
            Size = new Size(w, h),
            FlatStyle = FlatStyle.Flat,
            BackColor = BtnBg,
            ForeColor = TextPrimary,
            Font = Body,
            Cursor = Cursors.Hand,
            UseVisualStyleBackColor = false,
        };
        b.FlatAppearance.BorderColor = Border;
        b.FlatAppearance.BorderSize = 1;
        b.FlatAppearance.MouseOverBackColor = BtnHover;
        b.FlatAppearance.MouseDownBackColor = BtnPressed;
        b.Click += (_, _) => click();
        return b;
    }
}

// ============================================================
// EC protocol via WinRing0
// ============================================================
internal static class Ec
{
    const ushort EC_DATAPORT       = 0x62;
    const ushort EC_CTRLPORT       = 0x66;
    const byte   EC_STAT_OBF       = 0x01;
    const byte   EC_STAT_IBF       = 0x02;
    const byte   EC_CTRLPORT_READ  = 0x80;
    const byte   EC_CTRLPORT_WRITE = 0x81;

    public const byte TP_LED_OFFSET    = 0x0C;
    public const byte KBD_LIGHT_OFFSET = 0x0D;

    public const byte POWER_ON    = 0x80;
    public const byte POWER_OFF   = 0x00;
    public const byte POWER_BLINK = 0xC0;

    public const byte KBD_OFF  = 0x00;
    public const byte KBD_LOW  = 0x40;
    public const byte KBD_HIGH = 0x80;

    [DllImport("WinRing0x64.dll")] static extern bool InitializeOls();
    [DllImport("WinRing0x64.dll")] static extern uint GetDllStatus();
    [DllImport("WinRing0x64.dll")] static extern void DeinitializeOls();
    [DllImport("WinRing0x64.dll")] static extern byte ReadIoPortByte(ushort port);
    [DllImport("WinRing0x64.dll")] static extern void WriteIoPortByte(ushort port, byte value);

    static bool initialized;

    public static void Initialize()
    {
        if (initialized) return;
        bool ok = InitializeOls();
        uint status = GetDllStatus();
        if (!ok || status != 0)
            throw new InvalidOperationException(
                $"InitializeOls={ok}, GetDllStatus={status}");
        initialized = true;
    }

    public static void Shutdown()
    {
        if (!initialized) return;
        try { DeinitializeOls(); } catch { }
        initialized = false;
    }

    static void WaitPort(byte bits, bool wantSet, int timeoutMs = 1000)
    {
        int elapsed = 0;
        while (elapsed < timeoutMs)
        {
            byte data = ReadIoPortByte(EC_CTRLPORT);
            if (((data & bits) != 0) == wantSet) return;
            System.Threading.Thread.Sleep(10);
            elapsed += 10;
        }
    }

    public static void WriteByte(byte offset, byte value)
    {
        WaitPort((byte)(EC_STAT_IBF | EC_STAT_OBF), false);
        WriteIoPortByte(EC_CTRLPORT, EC_CTRLPORT_WRITE);
        WaitPort(EC_STAT_IBF, false);
        WriteIoPortByte(EC_DATAPORT, offset);
        WaitPort(EC_STAT_IBF, false);
        WriteIoPortByte(EC_DATAPORT, value);
        WaitPort(EC_STAT_IBF, false);
    }

    public static byte ReadByte(byte offset)
    {
        WaitPort((byte)(EC_STAT_IBF | EC_STAT_OBF), false);
        WriteIoPortByte(EC_CTRLPORT, EC_CTRLPORT_READ);
        WaitPort(EC_STAT_IBF, false);
        WriteIoPortByte(EC_DATAPORT, offset);
        WaitPort(EC_STAT_IBF, false);
        return ReadIoPortByte(EC_DATAPORT);
    }

    public static void SetLed(byte ledId, byte powerBits)
        => WriteByte(TP_LED_OFFSET, (byte)(ledId | powerBits));
    public static void SetKbdLight(byte level) => WriteByte(KBD_LIGHT_OFFSET, level);
    public static byte GetKbdLightRaw() => ReadByte(KBD_LIGHT_OFFSET);

    public static byte KbdRawToLevel(byte raw)
    {
        if (raw < 50)  return KBD_OFF;
        if (raw < 100) return KBD_LOW;
        if (raw < 150) return KBD_HIGH;
        return KBD_OFF;
    }

    public static string KbdLevelName(byte level) => level switch
    {
        KBD_OFF  => "Off",
        KBD_LOW  => "Low",
        KBD_HIGH => "High",
        _        => $"0x{level:X2}",
    };
}

// ============================================================
// Win32 interop
// ============================================================
internal static class Win32
{
    [StructLayout(LayoutKind.Sequential)]
    public struct RECT { public int Left, Top, Right, Bottom; }

    [DllImport("user32.dll")] public static extern IntPtr GetForegroundWindow();
    [DllImport("user32.dll")] public static extern bool   GetWindowRect(IntPtr hWnd, out RECT rect);
    [DllImport("user32.dll")] public static extern int    GetSystemMetrics(int index);
    [DllImport("user32.dll", CharSet = CharSet.Unicode)]
    public static extern int GetWindowTextLength(IntPtr hWnd);
    [DllImport("user32.dll", CharSet = CharSet.Unicode)]
    public static extern int GetWindowText(IntPtr hWnd, StringBuilder lpString, int nMaxCount);
    [DllImport("user32.dll")] public static extern short  GetKeyState(int vKey);

    const int SM_CXSCREEN = 0;
    const int SM_CYSCREEN = 1;
    const int VK_CAPITAL  = 0x14;
    const int VK_NUMLOCK  = 0x90;

    public static bool IsCapsLockOn() => (GetKeyState(VK_CAPITAL) & 0x0001) != 0;
    public static bool IsNumLockOn()  => (GetKeyState(VK_NUMLOCK) & 0x0001) != 0;

    public static string GetForegroundTitle()
    {
        var hwnd = GetForegroundWindow();
        if (hwnd == IntPtr.Zero) return "";
        int len = GetWindowTextLength(hwnd);
        var sb = new StringBuilder(len + 1);
        GetWindowText(hwnd, sb, sb.Capacity);
        return sb.ToString();
    }

    public static bool IsForegroundFullscreen()
    {
        var hwnd = GetForegroundWindow();
        if (hwnd == IntPtr.Zero) return false;
        var title = GetForegroundTitle();
        if (title is "" or "Windows Default Lock Screen" or "Program Manager")
            return false;
        if (!GetWindowRect(hwnd, out RECT rect)) return false;
        int w = GetSystemMetrics(SM_CXSCREEN);
        int h = GetSystemMetrics(SM_CYSCREEN);
        return rect.Left <= 0 && rect.Top <= 0
            && rect.Right >= w && rect.Bottom >= h;
    }
}

// ============================================================
// Core Audio COM interop
// ============================================================
internal static class AudioMute
{
    static IAudioEndpointVolume? speakerVol;
    static IAudioEndpointVolume? micVol;
    public static string? InitError { get; private set; }

    public static void Initialize()
    {
        try
        {
            var enumType = Type.GetTypeFromCLSID(
                new Guid("BCDE0395-E52F-467C-8E3D-C4579291692E"));
            if (enumType == null) { InitError = "MMDeviceEnumerator CLSID not registered"; return; }
            var enumObj = Activator.CreateInstance(enumType);
            if (enumObj is not IMMDeviceEnumerator enumerator)
            { InitError = "CoCreateInstance returned null"; return; }

            var iid = typeof(IAudioEndpointVolume).GUID;

            try
            {
                int hr = enumerator.GetDefaultAudioEndpoint(
                    EDataFlow.eRender, ERole.eMultimedia, out var dev);
                if (hr == 0 && dev != null)
                {
                    hr = dev.Activate(ref iid, 0x17, IntPtr.Zero, out object obj);
                    if (hr == 0) speakerVol = (IAudioEndpointVolume)obj;
                }
            }
            catch (Exception e) { InitError = $"speaker: {e.Message}"; }

            try
            {
                int hr = enumerator.GetDefaultAudioEndpoint(
                    EDataFlow.eCapture, ERole.eMultimedia, out var dev);
                if (hr == 0 && dev != null)
                {
                    hr = dev.Activate(ref iid, 0x17, IntPtr.Zero, out object obj);
                    if (hr == 0) micVol = (IAudioEndpointVolume)obj;
                }
            }
            catch (Exception e) { InitError ??= $"mic: {e.Message}"; }
        }
        catch (Exception e) { InitError = $"COM init: {e.Message}"; }
    }

    public static bool? SpeakerMuted()
    {
        if (speakerVol == null) return null;
        try { speakerVol.GetMute(out bool m); return m; } catch { return null; }
    }
    public static bool? MicMuted()
    {
        if (micVol == null) return null;
        try { micVol.GetMute(out bool m); return m; } catch { return null; }
    }

    enum EDataFlow { eRender, eCapture, eAll, EDataFlow_enum_count }
    enum ERole { eConsole, eMultimedia, eCommunications, ERole_enum_count }

    [ComImport, Guid("A95664D2-9614-4F35-A746-DE8DB63617E6"),
     InterfaceType(ComInterfaceType.InterfaceIsIUnknown)]
    interface IMMDeviceEnumerator
    {
        int EnumAudioEndpoints(EDataFlow dataFlow, uint dwStateMask, out IntPtr ppDevices);
        int GetDefaultAudioEndpoint(EDataFlow dataFlow, ERole role, out IMMDevice ppEndpoint);
        int GetDevice([MarshalAs(UnmanagedType.LPWStr)] string pwstrId, out IMMDevice ppDevice);
        int RegisterEndpointNotificationCallback(IntPtr pClient);
        int UnregisterEndpointNotificationCallback(IntPtr pClient);
    }

    [ComImport, Guid("D666063F-1587-4E43-81F1-B948E807363F"),
     InterfaceType(ComInterfaceType.InterfaceIsIUnknown)]
    interface IMMDevice
    {
        int Activate(ref Guid iid, uint dwClsCtx, IntPtr pActivationParams,
            [MarshalAs(UnmanagedType.IUnknown)] out object ppInterface);
        int OpenPropertyStore(uint stgmAccess, out IntPtr ppProperties);
        int GetId([MarshalAs(UnmanagedType.LPWStr)] out string ppstrId);
        int GetState(out uint pdwState);
    }

    [ComImport, Guid("5CDF2C82-841E-4546-9722-0CF74078229A"),
     InterfaceType(ComInterfaceType.InterfaceIsIUnknown)]
    interface IAudioEndpointVolume
    {
        int RegisterControlChangeNotify(IntPtr pNotify);
        int UnregisterControlChangeNotify(IntPtr pNotify);
        int GetChannelCount(out uint pnChannelCount);
        int SetMasterVolumeLevel(float fLevelDB, ref Guid pguidEventContext);
        int SetMasterVolumeLevelScalar(float fLevel, ref Guid pguidEventContext);
        int GetMasterVolumeLevel(out float pfLevelDB);
        int GetMasterVolumeLevelScalar(out float pfLevel);
        int SetChannelVolumeLevel(uint nChannel, float fLevelDB, ref Guid pguidEventContext);
        int SetChannelVolumeLevelScalar(uint nChannel, float fLevel, ref Guid pguidEventContext);
        int GetChannelVolumeLevel(uint nChannel, out float pfLevelDB);
        int GetChannelVolumeLevelScalar(uint nChannel, out float pfLevel);
        int SetMute([MarshalAs(UnmanagedType.Bool)] bool bMute, ref Guid pguidEventContext);
        int GetMute([MarshalAs(UnmanagedType.Bool)] out bool pbMute);
        int GetVolumeStepInfo(out uint pnStep, out uint pnStepCount);
        int VolumeStepUp(ref Guid pguidEventContext);
        int VolumeStepDown(ref Guid pguidEventContext);
        int QueryHardwareSupport(out uint pdwHardwareSupportMask);
        int GetVolumeRange(out float pflVolumeMindB, out float pflVolumeMaxdB, out float pflVolumeIncrementdB);
    }
}

// ============================================================
// Config
// ============================================================
public class Config
{
    public bool MonitorEnabled { get; set; } = false;
    public bool SilentOnLaunch { get; set; } = false;
    public int PollIntervalMs { get; set; } = 500;
    public Dictionary<string, string> Mapping { get; set; } = new()
    {
        ["0x00"] = "always_on",
        ["0x06"] = "none",
        ["0x07"] = "speaker_mute",
        ["0x0A"] = "caps_lock",
        ["0x0E"] = "mic_mute",
    };

    static string FilePath => Path.Combine(
        Path.GetDirectoryName(Environment.ProcessPath ?? "")!,
        "ledder.cfg");

    public static Config Load()
    {
        try
        {
            if (File.Exists(FilePath))
            {
                var cfg = JsonSerializer.Deserialize<Config>(File.ReadAllText(FilePath), Opts);
                if (cfg != null)
                {
                    foreach (var kv in new Config().Mapping)
                        if (!cfg.Mapping.ContainsKey(kv.Key))
                            cfg.Mapping[kv.Key] = kv.Value;
                    return cfg;
                }
            }
            // also look at legacy name
            var legacy = Path.Combine(Path.GetDirectoryName(FilePath)!, "thinkpad_led.cfg");
            if (File.Exists(legacy))
            {
                var cfg = JsonSerializer.Deserialize<Config>(File.ReadAllText(legacy), Opts);
                if (cfg != null) { cfg.Save(); return cfg; }
            }
        }
        catch (Exception e) { Debug.WriteLine($"[cfg] load: {e.Message}"); }
        return new Config();
    }

    public void Save()
    {
        try { File.WriteAllText(FilePath, JsonSerializer.Serialize(this, Opts)); }
        catch (Exception e) { Debug.WriteLine($"[cfg] save: {e.Message}"); }
    }

    static readonly JsonSerializerOptions Opts = new()
    {
        WriteIndented = true,
        PropertyNamingPolicy = JsonNamingPolicy.SnakeCaseLower,
    };
}

// ============================================================
// MainForm
// ============================================================
internal class MainForm : Form
{
    // ---- settable before Show ----
    public bool StartHidden { get; set; }

    static readonly (string Name, byte Id)[] Leds =
    {
        ("Power",      0x00),
        ("Fn",         0x06),
        ("Sleep",      0x07),
        ("RedDot",     0x0A),
        ("Microphone", 0x0E),
    };

    static readonly (string Key, string Label)[] Sources =
    {
        ("none",         "None"),
        ("always_on",    "Always On"),
        ("caps_lock",    "Caps Lock"),
        ("num_lock",     "Num Lock"),
        ("mic_mute",     "Mic Mute"),
        ("speaker_mute", "Speaker Mute"),
    };

    readonly Config cfg;
    readonly System.Windows.Forms.Timer timer = new();
    NotifyIcon? trayIcon;
    ToolStripMenuItem? trayMonitorItem;
    ToolStripMenuItem? traySilentItem;
    bool exiting;
    bool firstShown;

    // UI references
    CheckBox monitorEnabledCb = null!;
    Label monitorStatus = null!;
    NumericUpDown pollInterval = null!;
    CheckBox silentLaunchCb = null!;
    Dictionary<byte, ComboBox> mappingCombos = new();
    Dictionary<string, Label> statusLabels = new();

    // monitor runtime state
    bool inFullscreen = false;
    byte? savedKbd = null;
    Dictionary<byte, byte> lastTarget = new();
    Dictionary<byte, (string Src, bool? Val)> overrides = new();

    // --- layout constants ---
    const int FORM_W     = 380;
    const int PAD        = 12;
    const int SECTION_W  = FORM_W - PAD * 2;
    const int GAP        = 8;
    const int ROW_H      = 28;
    const int NAME_W     = 78;
    const int HEX_W      = 38;
    const int HEX_X      = 12 + NAME_W + 4;
    const int CONTROL_X  = HEX_X + HEX_W + 10;
    const int BTN_W      = 54;
    const int BTN_H      = 24;

    public MainForm()
    {
        cfg = Config.Load();
        Icon = BuildAppIcon();
        BuildUi();
        BuildTray();

        timer.Interval = Math.Max(100, cfg.PollIntervalMs);
        timer.Tick += (_, _) => Tick();
        timer.Start();

        RefreshMonitorStatusLabel();
    }

    // ============================================================
    // Start-hidden mechanism (--silent / SilentOnLaunch)
    // ============================================================
    protected override void SetVisibleCore(bool value)
    {
        if (!firstShown)
        {
            firstShown = true;
            bool wantHidden = StartHidden || cfg.SilentOnLaunch;
            if (wantHidden)
            {
                // ensure handle is created so timer/tray run
                if (!IsHandleCreated) CreateHandle();
                ShowInTaskbar = false;
                base.SetVisibleCore(false);
                return;
            }
        }
        base.SetVisibleCore(value);
    }

    // ============================================================
    // UI construction
    // ============================================================
    void BuildUi()
    {
        Text = Program.AppTitle;
        FormBorderStyle = FormBorderStyle.FixedSingle;
        MaximizeBox = false;
        StartPosition = FormStartPosition.CenterScreen;
        Font = Style.Body;
        AutoScaleMode = AutoScaleMode.Font;
        BackColor = Style.Bg;
        ForeColor = Style.TextPrimary;

        int y = PAD;

        var sMonitor = BuildMonitorSection();
        sMonitor.SetBounds(PAD, y, SECTION_W, 120);
        Controls.Add(sMonitor);
        y += sMonitor.Height + GAP;

        var sMapping = BuildMappingSection();
        sMapping.SetBounds(PAD, y, SECTION_W, 34 + Leds.Length * ROW_H + 8);
        Controls.Add(sMapping);
        y += sMapping.Height + GAP;

        var sManual = BuildManualSection();
        int manualH = 34 + Leds.Length * ROW_H + 10 + ROW_H + 10 + BTN_H + 10;
        sManual.SetBounds(PAD, y, SECTION_W, manualH);
        Controls.Add(sManual);
        y += sManual.Height + GAP;

        var sStatus = BuildStatusSection();
        sStatus.SetBounds(PAD, y, SECTION_W, 34 + 6 * 22 + 8);
        Controls.Add(sStatus);
        y += sStatus.Height + GAP;

        var tools = BuildToolsRow();
        tools.SetBounds(PAD, y, SECTION_W, 32);
        Controls.Add(tools);
        y += tools.Height + PAD;

        ClientSize = new Size(FORM_W, y);
    }

    Panel BuildMonitorSection()
    {
        var p = Style.MakeSection("Lights Out — turns off all LEDs in fullscreen", out int ty);

        monitorEnabledCb = new CheckBox
        {
            Text = "Enable",
            Location = new Point(12, ty + 4),
            AutoSize = true,
            Checked = cfg.MonitorEnabled,
            BackColor = Color.Transparent,
            ForeColor = Style.TextPrimary,
            Font = Style.Body,
        };
        monitorEnabledCb.CheckedChanged += (_, _) => OnMonitorToggle();
        p.Controls.Add(monitorEnabledCb);

        monitorStatus = new Label
        {
            Text = "Off",
            Location = new Point(SECTION_W - 130, ty + 4),
            Size = new Size(120, 18),
            TextAlign = ContentAlignment.MiddleRight,
            ForeColor = Style.TextMuted,
            Font = new Font("Segoe UI Semibold", 9f),
            BackColor = Color.Transparent,
        };
        p.Controls.Add(monitorStatus);

        silentLaunchCb = new CheckBox
        {
            Text = "Start minimized to tray on launch",
            Location = new Point(12, ty + 32),
            AutoSize = true,
            Checked = cfg.SilentOnLaunch,
            BackColor = Color.Transparent,
            ForeColor = Style.TextPrimary,
            Font = Style.Body,
        };
        silentLaunchCb.CheckedChanged += (_, _) =>
        {
            cfg.SilentOnLaunch = silentLaunchCb.Checked;
            cfg.Save();
            if (traySilentItem != null) traySilentItem.Checked = silentLaunchCb.Checked;
        };
        p.Controls.Add(silentLaunchCb);

        p.Controls.Add(new Label
        {
            Text = "Poll (ms):",
            Location = new Point(12, ty + 62),
            AutoSize = true,
            ForeColor = Style.TextMuted,
            BackColor = Color.Transparent,
        });
        pollInterval = new NumericUpDown
        {
            Location = new Point(82, ty + 60),
            Size = new Size(80, 22),
            Minimum = 100, Maximum = 5000, Increment = 100,
            Value = Math.Clamp(cfg.PollIntervalMs, 100, 5000),
            BorderStyle = BorderStyle.FixedSingle,
        };
        pollInterval.ValueChanged += (_, _) =>
        {
            cfg.PollIntervalMs = (int)pollInterval.Value;
            timer.Interval = cfg.PollIntervalMs;
            cfg.Save();
        };
        p.Controls.Add(pollInterval);

        return p;
    }

    Panel BuildMappingSection()
    {
        var p = Style.MakeSection("LED ↔ system state", out int ty);
        int y = ty + 4;

        foreach (var (name, lid) in Leds)
        {
            p.Controls.Add(NameLbl(name, y));
            p.Controls.Add(HexLbl(lid, y));

            var cb = new ComboBox
            {
                Location = new Point(CONTROL_X, y),
                Size = new Size(SECTION_W - CONTROL_X - 14, 22),
                DropDownStyle = ComboBoxStyle.DropDownList,
                FlatStyle = FlatStyle.Flat,
                BackColor = Style.BtnBg,
                Font = Style.Body,
            };
            foreach (var (_, lbl) in Sources) cb.Items.Add(lbl);
            var curKey = cfg.Mapping.GetValueOrDefault($"0x{lid:X2}", "none");
            cb.SelectedItem = Sources.FirstOrDefault(s => s.Key == curKey).Label ?? "None";
            byte capLid = lid;
            cb.SelectedIndexChanged += (_, _) => OnMappingChange(capLid, (string)cb.SelectedItem!);
            mappingCombos[lid] = cb;
            p.Controls.Add(cb);

            y += ROW_H;
        }
        return p;
    }

    Panel BuildManualSection()
    {
        var p = Style.MakeSection("Manual control", out int ty);
        int y = ty + 4;

        foreach (var (name, lid) in Leds)
        {
            p.Controls.Add(NameLbl(name, y));
            p.Controls.Add(HexLbl(lid, y));
            byte capLid = lid;
            p.Controls.Add(Style.FlatButton("On",    CONTROL_X,               y, BTN_W, BTN_H, () => ManualLed(capLid, Ec.POWER_ON)));
            p.Controls.Add(Style.FlatButton("Off",   CONTROL_X + BTN_W + 6,   y, BTN_W, BTN_H, () => ManualLed(capLid, Ec.POWER_OFF)));
            p.Controls.Add(Style.FlatButton("Blink", CONTROL_X + (BTN_W+6)*2, y, BTN_W, BTN_H, () => ManualLed(capLid, Ec.POWER_BLINK)));
            y += ROW_H;
        }

        var sep = new Panel
        {
            BackColor = Style.Border,
            Location = new Point(12, y + 4),
            Size = new Size(SECTION_W - 24, 1),
        };
        p.Controls.Add(sep);
        y += 12;

        p.Controls.Add(NameLbl("Keyboard", y));
        p.Controls.Add(new Label
        {
            Text = "0x0D",
            Location = new Point(HEX_X, y + 4),
            Size = new Size(HEX_W, 18),
            ForeColor = Style.TextMuted,
            Font = Style.Mono,
            BackColor = Color.Transparent,
        });
        p.Controls.Add(Style.FlatButton("Off",  CONTROL_X,               y, BTN_W, BTN_H, () => ManualKbd(Ec.KBD_OFF)));
        p.Controls.Add(Style.FlatButton("Low",  CONTROL_X + BTN_W + 6,   y, BTN_W, BTN_H, () => ManualKbd(Ec.KBD_LOW)));
        p.Controls.Add(Style.FlatButton("High", CONTROL_X + (BTN_W+6)*2, y, BTN_W, BTN_H, () => ManualKbd(Ec.KBD_HIGH)));
        y += ROW_H;

        var allOff = Style.FlatButton("All off", 12, y + 6, SECTION_W - 24, BTN_H, AllOff);
        p.Controls.Add(allOff);

        return p;
    }

    Panel BuildStatusSection()
    {
        var p = Style.MakeSection("System state", out int ty);
        int y = ty + 4;
        foreach (var label in new[] { "Caps Lock", "Num Lock", "Mic mute",
                                      "Speaker mute", "Fullscreen", "Keyboard" })
        {
            p.Controls.Add(new Label
            {
                Text = label,
                Location = new Point(12, y),
                Size = new Size(130, 18),
                Font = Style.Body,
                ForeColor = Style.TextMuted,
                BackColor = Color.Transparent,
            });
            var v = new Label
            {
                Text = "—",
                Location = new Point(150, y),
                Size = new Size(SECTION_W - 164, 18),
                Font = new Font("Segoe UI Semibold", 9f),
                ForeColor = Style.TextPrimary,
                BackColor = Color.Transparent,
            };
            statusLabels[label] = v;
            p.Controls.Add(v);
            y += 22;
        }
        return p;
    }

    Panel BuildToolsRow()
    {
        var p = new Panel { BackColor = Color.Transparent };
        int x = 0;
        foreach (var (txt, act) in new (string, Action)[]
        {
            ("Scan LED IDs", ScanDialog),
            ("Read EC byte", ReadEcDialog),
            ("About",        AboutDialog),
        })
        {
            p.Controls.Add(Style.FlatButton(txt, x, 4, 100, 26, act));
            x += 106;
        }
        return p;
    }

    Label NameLbl(string text, int y) => new()
    {
        Text = text,
        Location = new Point(12, y + 4),
        Size = new Size(NAME_W, 18),
        Font = Style.Body,
        ForeColor = Style.TextPrimary,
        BackColor = Color.Transparent,
    };

    Label HexLbl(byte lid, int y) => new()
    {
        Text = $"0x{lid:X2}",
        Location = new Point(HEX_X, y + 4),
        Size = new Size(HEX_W, 18),
        ForeColor = Style.TextMuted,
        Font = Style.Mono,
        BackColor = Color.Transparent,
    };

    // ============================================================
    // System tray
    // ============================================================
    void BuildTray()
    {
        var menu = new ContextMenuStrip
        {
            Font = Style.Body,
            ShowImageMargin = false,
        };

        var showItem = new ToolStripMenuItem("Show window");
        showItem.Click += (_, _) => ShowFromTray();
        menu.Items.Add(showItem);

        menu.Items.Add(new ToolStripSeparator());

        trayMonitorItem = new ToolStripMenuItem("Lights Out (fullscreen dim)")
        {
            Checked = cfg.MonitorEnabled,
            CheckOnClick = true,
        };
        trayMonitorItem.CheckedChanged += (_, _) =>
            monitorEnabledCb.Checked = trayMonitorItem.Checked;
        menu.Items.Add(trayMonitorItem);

        traySilentItem = new ToolStripMenuItem("Start minimized on launch")
        {
            Checked = cfg.SilentOnLaunch,
            CheckOnClick = true,
        };
        traySilentItem.CheckedChanged += (_, _) =>
            silentLaunchCb.Checked = traySilentItem.Checked;
        menu.Items.Add(traySilentItem);

        menu.Items.Add(new ToolStripSeparator());

        var allOffItem = new ToolStripMenuItem("All LEDs off");
        allOffItem.Click += (_, _) => AllOff();
        menu.Items.Add(allOffItem);

        menu.Items.Add(new ToolStripSeparator());

        var exitItem = new ToolStripMenuItem("Exit");
        exitItem.Click += (_, _) => { exiting = true; Close(); };
        menu.Items.Add(exitItem);

        trayIcon = new NotifyIcon
        {
            Icon = Icon,
            Text = Program.AppTitle,
            Visible = true,
            ContextMenuStrip = menu,
        };
        trayIcon.DoubleClick += (_, _) => ShowFromTray();
    }

    Icon BuildAppIcon()
    {
        // draw a 32x32 "L" in a red rounded square (ThinkPad red)
        using var bmp = new Bitmap(32, 32);
        using (var g = Graphics.FromImage(bmp))
        {
            g.SmoothingMode = SmoothingMode.AntiAlias;
            g.Clear(Color.Transparent);
            using var brush = new SolidBrush(Color.FromArgb(220, 40, 40));
            using var path = new GraphicsPath();
            int r = 6;
            path.AddArc(0, 0, r, r, 180, 90);
            path.AddArc(32 - r - 1, 0, r, r, 270, 90);
            path.AddArc(32 - r - 1, 32 - r - 1, r, r, 0, 90);
            path.AddArc(0, 32 - r - 1, r, r, 90, 90);
            path.CloseFigure();
            g.FillPath(brush, path);

            using var font = new Font("Segoe UI Black", 16f, FontStyle.Bold, GraphicsUnit.Pixel);
            using var txtBrush = new SolidBrush(Color.White);
            var sf = new StringFormat { Alignment = StringAlignment.Center, LineAlignment = StringAlignment.Center };
            g.DrawString("L", font, txtBrush, new RectangleF(0, 0, 32, 32), sf);
        }
        return Icon.FromHandle(bmp.GetHicon());
    }

    void HideToTray()
    {
        Hide();
        ShowInTaskbar = false;
    }

    void ShowFromTray()
    {
        Show();
        WindowState = FormWindowState.Normal;
        ShowInTaskbar = true;
        BringToFront();
        Activate();
    }

    protected override void OnFormClosing(FormClosingEventArgs e)
    {
        if (e.CloseReason == CloseReason.UserClosing && !exiting)
        {
            // close button = hide to tray instead of exit
            e.Cancel = true;
            HideToTray();
            return;
        }
        if (trayIcon != null) { trayIcon.Visible = false; trayIcon.Dispose(); }
        base.OnFormClosing(e);
    }

    // ============================================================
    // Event handlers
    // ============================================================
    void OnMonitorToggle()
    {
        bool enabled = monitorEnabledCb.Checked;
        cfg.MonitorEnabled = enabled;
        cfg.Save();

        if (trayMonitorItem != null && trayMonitorItem.Checked != enabled)
            trayMonitorItem.Checked = enabled;

        inFullscreen = false;
        savedKbd = null;
        lastTarget.Clear();
        overrides.Clear();

        RefreshMonitorStatusLabel();
    }

    void RefreshMonitorStatusLabel()
    {
        if (monitorEnabledCb.Checked)
        {
            if (inFullscreen)
            {
                monitorStatus.Text = "● fullscreen";
                monitorStatus.ForeColor = Style.StatusAlert;
            }
            else
            {
                monitorStatus.Text = "● active";
                monitorStatus.ForeColor = Style.StatusOn;
            }
        }
        else
        {
            monitorStatus.Text = "○ off";
            monitorStatus.ForeColor = Style.TextMuted;
        }
    }

    void OnMappingChange(byte lid, string label)
    {
        var key = Sources.FirstOrDefault(s => s.Label == label).Key ?? "none";
        cfg.Mapping[$"0x{lid:X2}"] = key;
        cfg.Save();
        lastTarget.Remove(lid);
        overrides.Remove(lid);
    }

    void ManualLed(byte lid, byte powerBits)
    {
        try
        {
            Ec.SetLed(lid, powerBits);
            lastTarget[lid] = powerBits;
        }
        catch (Exception e)
        {
            MessageBox.Show($"EC error: {e.Message}", Program.AppTitle,
                MessageBoxButtons.OK, MessageBoxIcon.Error);
            return;
        }

        if (!monitorEnabledCb.Checked) return;
        var src = cfg.Mapping.GetValueOrDefault($"0x{lid:X2}", "none");
        if (src == "none") return;
        bool? val = src switch
        {
            "always_on"    => true,
            "caps_lock"    => Win32.IsCapsLockOn(),
            "num_lock"     => Win32.IsNumLockOn(),
            "mic_mute"     => AudioMute.MicMuted(),
            "speaker_mute" => AudioMute.SpeakerMuted(),
            _              => null,
        };
        overrides[lid] = (src, val);
    }

    void ManualKbd(byte level)
    {
        try { Ec.SetKbdLight(level); }
        catch (Exception e)
        {
            MessageBox.Show($"EC error: {e.Message}", Program.AppTitle,
                MessageBoxButtons.OK, MessageBoxIcon.Error);
        }
    }

    void AllOff()
    {
        try
        {
            foreach (var (_, lid) in Leds) Ec.SetLed(lid, Ec.POWER_OFF);
            Ec.SetKbdLight(Ec.KBD_OFF);
            foreach (var (_, lid) in Leds) lastTarget[lid] = Ec.POWER_OFF;
        }
        catch (Exception e)
        {
            MessageBox.Show($"EC error: {e.Message}", Program.AppTitle,
                MessageBoxButtons.OK, MessageBoxIcon.Error);
        }
    }

    void ScanDialog()
    {
        if (MessageBox.Show(
            "Lights each LED ID 0x00..0x1F for 1.5 s then off (0.3 s).\n" +
            "Window will freeze while scanning (~1 minute).\n\nContinue?",
            "Scan LED IDs", MessageBoxButtons.OKCancel, MessageBoxIcon.Question)
            != DialogResult.OK) return;

        bool wasOn = monitorEnabledCb.Checked;
        if (wasOn) monitorEnabledCb.Checked = false;
        try
        {
            for (byte lid = 0; lid < 0x20; lid++)
            {
                Ec.SetLed(lid, Ec.POWER_ON);
                Application.DoEvents();
                System.Threading.Thread.Sleep(1500);
                Ec.SetLed(lid, Ec.POWER_OFF);
                System.Threading.Thread.Sleep(300);
            }
        }
        catch (Exception e) { MessageBox.Show(e.Message, "Scan error"); }
        finally { if (wasOn) monitorEnabledCb.Checked = true; }
    }

    void ReadEcDialog()
    {
        using var dlg = new InputDialog("Read EC byte", "EC offset (hex, e.g. 0x0D):");
        if (dlg.ShowDialog(this) != DialogResult.OK) return;
        var txt = dlg.Value.Trim();
        if (txt.Length == 0) return;
        int offset;
        try
        {
            offset = Convert.ToInt32(
                txt.StartsWith("0x", StringComparison.OrdinalIgnoreCase) ? txt[2..] : txt, 16);
        }
        catch { MessageBox.Show($"Bad format: {txt}"); return; }
        try
        {
            var v = Ec.ReadByte((byte)offset);
            MessageBox.Show(
                $"EC[0x{offset:X2}] = 0x{v:X2}  ({v},  0b{Convert.ToString(v, 2).PadLeft(8, '0')})",
                "EC read");
        }
        catch (Exception e) { MessageBox.Show($"EC error: {e.Message}"); }
    }

    void AboutDialog()
    {
        MessageBox.Show(
            $"{Program.AppTitle}\n\n" +
            "EC protocol ported 1:1 from valinet/ThinkPadLEDControl.\n" +
            "Uses WinRing0 for kernel-level port I/O.\n\n" +
            $"Audio: {(AudioMute.InitError == null ? "OK" : AudioMute.InitError)}\n" +
            $"Config: {Path.Combine(Path.GetDirectoryName(Environment.ProcessPath ?? "")!, "ledder.cfg")}\n\n" +
            "Command-line flags:\n" +
            "  --silent    start minimized to tray",
            "About");
    }

    // ============================================================
    // Polling tick
    // ============================================================
    void Tick()
    {
        try { DoTick(); } catch (Exception e) { Debug.WriteLine($"Tick: {e}"); }
    }

    void DoTick()
    {
        bool  caps = Win32.IsCapsLockOn();
        bool  num  = Win32.IsNumLockOn();
        bool? mic  = AudioMute.MicMuted();
        bool? spk  = AudioMute.SpeakerMuted();
        bool  fs   = Win32.IsForegroundFullscreen();
        byte? kbdRaw = null;
        try { kbdRaw = Ec.GetKbdLightRaw(); } catch { }

        static string Tri(bool? v) => v == null ? "— n/a" : (v.Value ? "ON" : "off");
        statusLabels["Caps Lock"].Text    = caps ? "ON" : "off";
        statusLabels["Num Lock"].Text     = num  ? "ON" : "off";
        statusLabels["Mic mute"].Text     = Tri(mic);
        statusLabels["Speaker mute"].Text = Tri(spk);
        statusLabels["Fullscreen"].Text   = fs   ? "YES" : "no";
        statusLabels["Keyboard"].Text = kbdRaw == null
            ? "?"
            : $"{Ec.KbdLevelName(Ec.KbdRawToLevel(kbdRaw.Value))}  0x{kbdRaw.Value:X2}";

        // colorize meaningful ON states (green = active/lit, muted otherwise)
        statusLabels["Caps Lock"].ForeColor    = caps ? Style.StatusOn : Style.TextMuted;
        statusLabels["Num Lock"].ForeColor     = num  ? Style.StatusOn : Style.TextMuted;
        statusLabels["Mic mute"].ForeColor     = mic == true ? Style.StatusAlert : Style.TextMuted;
        statusLabels["Speaker mute"].ForeColor = spk == true ? Style.StatusAlert : Style.TextMuted;
        statusLabels["Fullscreen"].ForeColor   = fs   ? Style.StatusAlert : Style.TextMuted;
        statusLabels["Keyboard"].ForeColor     = Style.TextPrimary;

        if (monitorEnabledCb.Checked) ApplyMonitor(fs, caps, num, mic, spk);
    }

    void ApplyMonitor(bool fs, bool caps, bool num, bool? mic, bool? spk)
    {
        if (fs && !inFullscreen)
        {
            try { savedKbd = Ec.GetKbdLightRaw(); } catch { savedKbd = null; }
            try { Ec.SetKbdLight(Ec.KBD_OFF); } catch { }
            foreach (var (_, lid) in Leds)
            {
                try { Ec.SetLed(lid, Ec.POWER_OFF); } catch { }
            }
            lastTarget.Clear();
            overrides.Clear();
            inFullscreen = true;
            RefreshMonitorStatusLabel();
            return;
        }

        if (!fs && inFullscreen)
        {
            if (savedKbd != null)
            {
                try { Ec.SetKbdLight(Ec.KbdRawToLevel(savedKbd.Value)); } catch { }
            }
            inFullscreen = false;
            RefreshMonitorStatusLabel();
        }

        if (fs) return;

        var values = new Dictionary<string, bool?>
        {
            ["always_on"]    = true,
            ["caps_lock"]    = caps,
            ["num_lock"]     = num,
            ["mic_mute"]     = mic,
            ["speaker_mute"] = spk,
        };

        foreach (var kv in cfg.Mapping)
        {
            var src = kv.Value;
            if (src == "none") continue;
            if (!byte.TryParse(kv.Key.Replace("0x", ""),
                System.Globalization.NumberStyles.HexNumber, null, out byte lid)) continue;

            if (overrides.TryGetValue(lid, out var ov))
            {
                var curVal = values.GetValueOrDefault(ov.Src);
                if (ov.Src == src && Equals(ov.Val, curVal)) continue;
                overrides.Remove(lid);
            }

            var v = values.GetValueOrDefault(src);
            if (v == null) continue;
            byte desired = v.Value ? Ec.POWER_ON : Ec.POWER_OFF;
            if (!lastTarget.TryGetValue(lid, out var last) || last != desired)
            {
                try { Ec.SetLed(lid, desired); lastTarget[lid] = desired; } catch { }
            }
        }
    }
}

// ============================================================
// Styled input dialog for "Read EC byte"
// ============================================================
internal class InputDialog : Form
{
    readonly TextBox tb;
    public string Value => tb.Text;

    public InputDialog(string title, string prompt)
    {
        Text = title;
        FormBorderStyle = FormBorderStyle.FixedDialog;
        StartPosition = FormStartPosition.CenterParent;
        MaximizeBox = false; MinimizeBox = false;
        Font = Style.Body;
        BackColor = Style.Bg;
        ClientSize = new Size(320, 120);

        Controls.Add(new Label { Text = prompt, Left = 14, Top = 14, AutoSize = true, BackColor = Color.Transparent });
        tb = new TextBox { Left = 14, Top = 38, Width = 292, BorderStyle = BorderStyle.FixedSingle };
        Controls.Add(tb);

        var ok = Style.FlatButton("OK", 146, 78, 78, 26, () => { DialogResult = DialogResult.OK; Close(); });
        var cancel = Style.FlatButton("Cancel", 228, 78, 78, 26, () => { DialogResult = DialogResult.Cancel; Close(); });
        AcceptButton = ok; CancelButton = cancel;
        Controls.Add(ok); Controls.Add(cancel);
    }
}