Merge remote-tracking branch 'origin/main' into feat/update-prompt-history

Author: carterscode

src/GamerGuardian/Services/CpuPlanDetails.cs

@@ -1,4 +1,6 @@
+using System.Globalization;
 using GamerGuardian.Models;
+using GamerGuardian.Native;
 
 namespace GamerGuardian.Services;
 
@@ -27,6 +29,74 @@ public static string BaseSummary(CpuTuneResult r) =>
     public static IReadOnlyList<string> Changes(CpuTuneResult r) =>
         r.Overrides.Select(o => o.Label).ToList();
 
+    /// <summary>One row of the side-by-side "Windows Balanced vs GamerGuardian"
+    /// comparison: the setting's friendly name and its value under each plan.
+    /// <paramref name="Differs"/> is true only when the base value is known AND
+    /// differs from the GamerGuardian value, so the UI can highlight the real
+    /// differences without falsely flagging a value it couldn't read.</summary>
+    public sealed record PlanComparisonRow(string Setting, string WindowsValue, string GamerGuardianValue, bool Differs);
+
+    /// <summary>
+    /// Builds the side-by-side comparison of the stock Windows base plan against the
+    /// GamerGuardian tune, one row per processor setting the tune touches. The base
+    /// (plugged-in) value is read through the injected <paramref name="readBaseAcValue"/>
+    /// delegate — the UI passes a live Powrprof reader against the installed Balanced
+    /// scheme; tests pass a stub. When a base value can't be read (setting hidden or
+    /// scheme missing) the row shows "Windows default" and is not flagged as differing.
+    /// </summary>
+    public static IReadOnlyList<PlanComparisonRow> Comparison(
+        CpuTuneResult r, Func<Guid, Guid, uint?> readBaseAcValue)
+    {
+        var rows = new List<PlanComparisonRow>(r.Overrides.Count);
+        foreach (var o in r.Overrides)
+        {
+            var (name, fmt) = DescribeSetting(o.Setting);
+            uint? baseVal = null;
+            if (readBaseAcValue is not null)
+            {
+                try { baseVal = readBaseAcValue(o.Subgroup, o.Setting); }
+                catch { baseVal = null; }
+            }
+            rows.Add(new PlanComparisonRow(
+                Setting: name,
+                WindowsValue: baseVal is uint w ? fmt(w) : "Windows default",
+                GamerGuardianValue: fmt(o.Value),
+                Differs: baseVal is uint b && b != o.Value));
+        }
+        return rows;
+    }
+
+    /// <summary>Friendly name + value formatter for each processor power setting the
+    /// tunes use. Keyed on the well-known setting GUID so it never drifts from what
+    /// the catalog actually writes.</summary>
+    private static (string name, Func<uint, string> fmt) DescribeSetting(Guid setting)
+    {
+        if (setting == Powrprof.SettingBoostMode) return ("Processor boost mode", BoostModeText);
+        if (setting == Powrprof.SettingCoreParkingMinCores) return ("Core parking — minimum cores", Percent);
+        if (setting == Powrprof.SettingCoreParkingMaxCores) return ("Core parking — maximum cores", Percent);
+        if (setting == Powrprof.SettingPerfIncreaseThreshold) return ("Performance-increase threshold", Percent);
+        if (setting == Powrprof.SettingIdleDemoteThreshold) return ("Idle-demote threshold", Percent);
+        if (setting == Powrprof.SettingMinProcessorState) return ("Minimum processor state", Percent);
+        if (setting == Powrprof.SettingMaxProcessorState) return ("Maximum processor state", Percent);
+        return ("Processor setting", Raw);
+    }
+
+    private static string Percent(uint v) => v.ToString(CultureInfo.InvariantCulture) + "%";
+    private static string Raw(uint v) => v.ToString(CultureInfo.InvariantCulture);
+
+    /// <summary>Windows PERFBOOSTMODE value names.</summary>
+    private static string BoostModeText(uint v) => v switch
+    {
+        0 => "Disabled",
+        1 => "Enabled",
+        2 => "Aggressive",
+        3 => "Efficient Enabled",
+        4 => "Efficient Aggressive",
+        5 => "Aggressive at guaranteed",
+        6 => "Efficient Aggressive at guaranteed",
+        _ => v.ToString(CultureInfo.InvariantCulture),
+    };
+
     /// <summary>Why this specific recipe is a good fit for the detected CPU. Keyed
     /// on the parking strategy (the one dimension that actually changes the shape of
     /// the tune), with a generic-fallback and a hybrid-Intel special case.</summary>

src/GamerGuardian/UI/SettingsWindow.xaml.cs

@@ -1493,22 +1493,22 @@ private void BuildPlanDetails(CpuTuneResult r)
 
         PlanDetailsList.Children.Add(new System.Windows.Controls.TextBlock
         {
-            Text = "Changes from stock (applied to both plugged-in and on-battery):",
+            Text = $"Side by side (plugged in) — bold values are what GamerGuardian changes:",
             FontWeight = FontWeights.SemiBold,
             FontSize = 12,
             TextWrapping = TextWrapping.Wrap,
-            Margin = new Thickness(0, 10, 0, 0),
+            Margin = new Thickness(0, 12, 0, 4),
         });
-        foreach (var change in CpuPlanDetails.Changes(r))
-        {
-            PlanDetailsList.Children.Add(new System.Windows.Controls.TextBlock
-            {
-                Text = "•  " + change,
-                FontSize = 12,
-                TextWrapping = TextWrapping.Wrap,
-                Margin = new Thickness(8, 2, 0, 0),
-            });
-        }
+
+        // Read the stock values live from the installed base scheme so the "Windows"
+        // column reflects this machine rather than a hardcoded guess (the app never
+        // trusts hardcoded power values — see the Power Saver GUID gotcha).
+        var baseGuid = PowerPlanMonitor.ResolveBalancedBase();
+        Func<Guid, Guid, uint?> readBase = baseGuid == Guid.Empty
+            ? (_, _) => null
+            : (sub, set) => Powrprof.ReadAcValue(baseGuid, sub, set);
+        var comparison = CpuPlanDetails.Comparison(r, readBase);
+        PlanDetailsList.Children.Add(BuildComparisonTable(comparison, r.BasePlanDisplayName));
 
         PlanDetailsList.Children.Add(new System.Windows.Controls.TextBlock
         {
@@ -1528,6 +1528,70 @@ private void BuildPlanDetails(CpuTuneResult r)
         });
     }
 
+    /// <summary>
+    /// Builds the "Windows base vs GamerGuardian" comparison as a 3-column grid.
+    /// A value that GamerGuardian changes from the stock value is shown bold so the
+    /// real differences stand out from settings it merely pins to the same value.
+    /// </summary>
+    private System.Windows.Controls.Grid BuildComparisonTable(
+        IReadOnlyList<CpuPlanDetails.PlanComparisonRow> rows, string baseName)
+    {
+        var grid = new System.Windows.Controls.Grid();
+        grid.ColumnDefinitions.Add(new System.Windows.Controls.ColumnDefinition { Width = new GridLength(1, GridUnitType.Star) });
+        grid.ColumnDefinitions.Add(new System.Windows.Controls.ColumnDefinition { Width = new GridLength(120) });
+        grid.ColumnDefinitions.Add(new System.Windows.Controls.ColumnDefinition { Width = new GridLength(120) });
+
+        var secondary = (System.Windows.Media.Brush)FindResource("TextFillColorSecondaryBrush");
+
+        void AddCell(int row, int col, string text, FontWeight weight, System.Windows.Media.Brush? fg)
+        {
+            var tb = new System.Windows.Controls.TextBlock
+            {
+                Text = text,
+                FontSize = 12,
+                FontWeight = weight,
+                TextWrapping = TextWrapping.Wrap,
+                Margin = new Thickness(col == 0 ? 0 : 8, 3, 8, 3),
+            };
+            if (fg is not null) tb.Foreground = fg;
+            System.Windows.Controls.Grid.SetRow(tb, row);
+            System.Windows.Controls.Grid.SetColumn(tb, col);
+            grid.Children.Add(tb);
+        }
+
+        // Header row.
+        grid.RowDefinitions.Add(new System.Windows.Controls.RowDefinition { Height = GridLength.Auto });
+        AddCell(0, 0, "Setting", FontWeights.SemiBold, null);
+        AddCell(0, 1, $"Windows {baseName}", FontWeights.SemiBold, null);
+        AddCell(0, 2, "GamerGuardian", FontWeights.SemiBold, null);
+
+        // Separator under the header.
+        grid.RowDefinitions.Add(new System.Windows.Controls.RowDefinition { Height = GridLength.Auto });
+        var sep = new System.Windows.Controls.Border
+        {
+            Height = 1,
+            Background = (System.Windows.Media.Brush)FindResource("ControlStrokeColorDefaultBrush"),
+            Margin = new Thickness(0, 1, 0, 3),
+        };
+        System.Windows.Controls.Grid.SetRow(sep, 1);
+        System.Windows.Controls.Grid.SetColumn(sep, 0);
+        System.Windows.Controls.Grid.SetColumnSpan(sep, 3);
+        grid.Children.Add(sep);
+
+        for (int i = 0; i < rows.Count; i++)
+        {
+            int row = i + 2;
+            grid.RowDefinitions.Add(new System.Windows.Controls.RowDefinition { Height = GridLength.Auto });
+            AddCell(row, 0, rows[i].Setting, FontWeights.Normal, null);
+            AddCell(row, 1, rows[i].WindowsValue, FontWeights.Normal, secondary);
+            // Bold the GamerGuardian value only where it actually differs from stock.
+            AddCell(row, 2, rows[i].GamerGuardianValue,
+                rows[i].Differs ? FontWeights.SemiBold : FontWeights.Normal, null);
+        }
+
+        return grid;
+    }
+
     private void BuildDependencyRows(CpuTuneResult r)
     {
         CcdDependencyList.Children.Clear();

tests/GamerGuardian.Tests/CpuPlanDetailsTests.cs

@@ -113,4 +113,67 @@ public void ResolveDesiredGuid_FreshPref_ResolvesToBalanced()
         var guid = GamerGuardian.Monitors.PowerPlanMonitor.ResolveDesiredGuid(new PowerPlanPref());
         Assert.Equal(GamerGuardian.Monitors.PowerPlanMonitor.Balanced, guid);
     }
+
+    // ---- Side-by-side comparison (Windows base vs GamerGuardian) ----
+
+    [Fact]
+    public void Comparison_HasOneRowPerOverride_WithFriendlyNamesAndValues()
+    {
+        var r = Amd("9950X3D"); // boost=Aggressive(2), min cores=50, max cores=100
+        // Derive each setting's GUID from the recipe's own overrides (Powrprof's GUIDs
+        // are internal), then stub the base reader: boost=Enabled(1), min=100, max=100.
+        Guid Setting(string labelPart) =>
+            r.Overrides.First(o => o.Label.Contains(labelPart, StringComparison.OrdinalIgnoreCase)).Setting;
+        var boostSetting = Setting("boost");
+        var minSetting = Setting("min cores");
+        var maxSetting = Setting("max cores");
+        var rows = CpuPlanDetails.Comparison(r, (sub, set) =>
+            set == boostSetting ? 1u :
+            set == minSetting ? 100u :
+            set == maxSetting ? 100u : (uint?)null);
+
+        Assert.Equal(r.Overrides.Count, rows.Count);
+
+        var boost = rows.Single(x => x.Setting.Contains("boost", StringComparison.OrdinalIgnoreCase));
+        Assert.Equal("Enabled", boost.WindowsValue);
+        Assert.Equal("Aggressive", boost.GamerGuardianValue);
+        Assert.True(boost.Differs);
+
+        var minCores = rows.Single(x => x.Setting.Contains("minimum cores", StringComparison.OrdinalIgnoreCase));
+        Assert.Equal("100%", minCores.WindowsValue);
+        Assert.Equal("50%", minCores.GamerGuardianValue);
+        Assert.True(minCores.Differs);
+
+        var maxCores = rows.Single(x => x.Setting.Contains("maximum cores", StringComparison.OrdinalIgnoreCase));
+        Assert.Equal("100%", maxCores.WindowsValue);
+        Assert.Equal("100%", maxCores.GamerGuardianValue);
+        Assert.False(maxCores.Differs); // same value -> pinned, not a difference
+    }
+
+    [Fact]
+    public void Comparison_UnreadableBaseValue_ShowsWindowsDefault_AndNotFlagged()
+    {
+        var r = Amd("9950X3D");
+        var rows = CpuPlanDetails.Comparison(r, (_, _) => null);
+
+        Assert.All(rows, x => Assert.Equal("Windows default", x.WindowsValue));
+        Assert.All(rows, x => Assert.False(x.Differs));
+    }
+
+    [Fact]
+    public void Comparison_NullReader_DoesNotThrow()
+    {
+        var r = Amd("9800X3D");
+        var rows = CpuPlanDetails.Comparison(r, null!);
+        Assert.Equal(r.Overrides.Count, rows.Count);
+        Assert.All(rows, x => Assert.Equal("Windows default", x.WindowsValue));
+    }
+
+    [Fact]
+    public void Comparison_ReaderThatThrows_IsSwallowedPerRow()
+    {
+        var r = Amd("9800X3D");
+        var rows = CpuPlanDetails.Comparison(r, (_, _) => throw new InvalidOperationException("boom"));
+        Assert.All(rows, x => Assert.Equal("Windows default", x.WindowsValue));
+    }
 }