fix(matchers): match to the last matching profile deterministically (#16)

## What does this PR do?

Match to the last profile deterministically.

## Related issues

<!--
Closes #234
-->

Author: fiffeek

README.md

@@ -361,6 +361,8 @@ monitor_tag = "laptop"  # Assign a tag for template use
 Use `hyprctl monitors` to see available monitors and their properties.
 To understand scoring and profile matching more see [`examples/scoring`](https://github.com/fiffeek/hyprdynamicmonitors/tree/main/examples/scoring).
 
+**Profile Selection**: When multiple profiles have equal scores, the last profile defined in the TOML configuration file is selected.
+
 ### Configuration File Types
 
 - **Static**: Creates symlinks to existing configuration files

internal/config/config.go

@@ -6,6 +6,7 @@ import (
 	"fmt"
 	"os"
 	"path/filepath"
+	"slices"
 	"strings"
 	"sync"
 	"time"
@@ -64,6 +65,7 @@ type RawConfig struct {
 	HotReload            *HotReloadSection   `toml:"hot_reload_section"`
 	Notifications        *Notifications      `toml:"notifications"`
 	StaticTemplateValues map[string]string   `toml:"static_template_values"`
+	KeysOrder            []string            `toml:"-"`
 }
 
 type HotReloadSection struct {
@@ -172,6 +174,7 @@ type Profile struct {
 	IsFallbackProfile    bool              `toml:"-"`
 	PostApplyExec        *string           `toml:"post_apply_exec"`
 	PreApplyExec         *string           `toml:"pre_apply_exec"`
+	KeyOrder             int               `toml:"-"`
 }
 
 type PowerStateType int
@@ -246,12 +249,18 @@ func Load(configPath string) (*RawConfig, error) {
 	logrus.Debugf("Config contents: %s", contents)
 
 	var config RawConfig
-	if _, err := toml.DecodeFile(configPath, &config); err != nil {
+	m, err := toml.DecodeFile(configPath, &config)
+	if err != nil {
 		return nil, fmt.Errorf("failed to decode TOML: %w", err)
 	}
+	keys := []string{}
+	for _, k := range m.Keys() {
+		keys = append(keys, strings.Join(k, "."))
+	}
 
 	config.ConfigPath = absConfig
 	config.ConfigDirPath = filepath.Dir(config.ConfigPath)
+	config.KeysOrder = keys
 
 	if err := config.Validate(); err != nil {
 		return nil, fmt.Errorf("invalid configuration: %w", err)
@@ -262,6 +271,22 @@ func Load(configPath string) (*RawConfig, error) {
 	return &config, nil
 }
 
+// OrderedProfileKeys returns the profile names in the order they appear in the toml file
+func (c *RawConfig) OrderedProfileKeys() []string {
+	profileNames := make([]string, 0, len(c.Profiles))
+	for name := range c.Profiles {
+		profileNames = append(profileNames, name)
+	}
+
+	slices.SortFunc(profileNames, func(a, b string) int {
+		orderA := c.Profiles[a].KeyOrder
+		orderB := c.Profiles[b].KeyOrder
+		return orderA - orderB
+	})
+
+	return profileNames
+}
+
 func (c *RawConfig) Validate() error {
 	if c.ConfigPath == "" {
 		return errors.New("config path cant be empty")
@@ -292,6 +317,8 @@ func (c *RawConfig) Validate() error {
 	for name, profile := range c.Profiles {
 		profile.Name = name
 		profile.IsFallbackProfile = false
+		profile.KeyOrder = slices.Index(c.KeysOrder, "profiles."+name)
+		logrus.Debugf("Profile %s has order %d", profile.Name, profile.KeyOrder)
 		if err := profile.Validate(c.ConfigDirPath); err != nil {
 			return fmt.Errorf("profile %s validation failed: %w", name, err)
 		}

internal/config/config_test.go

@@ -984,6 +984,59 @@ func TestPowerSectionDbusQueryObjectDefaults(t *testing.T) {
 	assert.Equal(t, expectedCollectedArgs, collectedArgs, "collected args should match expected")
 }
 
+func TestOrderedProfileKeys(t *testing.T) {
+	tests := []struct {
+		name     string
+		profiles map[string]*config.Profile
+		expected []string
+	}{
+		{
+			name:     "empty profiles",
+			profiles: map[string]*config.Profile{},
+			expected: []string{},
+		},
+		{
+			name: "sorted by key order",
+			profiles: map[string]*config.Profile{
+				"third":  {Name: "third", KeyOrder: 2},
+				"first":  {Name: "first", KeyOrder: 0},
+				"second": {Name: "second", KeyOrder: 1},
+			},
+			expected: []string{"first", "second", "third"},
+		},
+		{
+			name: "negative key order comes first",
+			profiles: map[string]*config.Profile{
+				"missing": {Name: "missing", KeyOrder: -1},
+				"first":   {Name: "first", KeyOrder: 0},
+			},
+			expected: []string{"missing", "first"},
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			config := &config.RawConfig{Profiles: tt.profiles}
+			result := config.OrderedProfileKeys()
+
+			assert.Equal(t, tt.expected, result)
+		})
+	}
+
+	// Test with actual TOML file
+	t.Run("order from TOML file", func(t *testing.T) {
+		cfg, err := config.Load(filepath.Join("testdata", "valid_basic.toml"))
+		if err != nil {
+			t.Fatalf("failed to load test config: %v", err)
+		}
+
+		result := cfg.OrderedProfileKeys()
+		expected := []string{"laptop_only", "dual_monitor", "ac_power_profile"}
+
+		assert.Equal(t, expected, result)
+	})
+}
+
 func containsString(haystack, needle string) bool {
 	return len(haystack) >= len(needle) &&
 		(haystack == needle ||

internal/matchers/matcher.go

@@ -2,6 +2,8 @@
 package matchers
 
 import (
+	"slices"
+
 	"github.com/fiffeek/hyprdynamicmonitors/internal/config"
 	"github.com/fiffeek/hyprdynamicmonitors/internal/hypr"
 	"github.com/fiffeek/hyprdynamicmonitors/internal/power"
@@ -44,7 +46,11 @@ func (m *Matcher) Match(cfg *config.RawConfig, connectedMonitors []*hypr.Monitor
 		return ok, fallbackProfile, nil
 	}
 
-	for name, profile := range profiles {
+	// match from the last entry in the toml config
+	ascProfiles := cfg.OrderedProfileKeys()
+	slices.Reverse(ascProfiles)
+	for _, name := range ascProfiles {
+		profile := cfg.Profiles[name]
 		if score[name] == bestScore {
 			return true, profile, nil
 		}

internal/matchers/matcher_test.go

@@ -278,6 +278,33 @@ func TestMatcher_Match(t *testing.T) {
 			expectedProfile: "",
 			description:     "Profile should not match when name comes from one monitor and description from another",
 		},
+		{
+			name: "last_profile_wins_when_scores_equal",
+			config: createTestConfig(t, map[string]*config.Profile{
+				"first_profile": {
+					Name: "first_profile",
+					Conditions: &config.ProfileCondition{
+						RequiredMonitors: []*config.RequiredMonitor{
+							{Name: utils.StringPtr("eDP-1")},
+						},
+					},
+				},
+				"second_profile": {
+					Name: "second_profile",
+					Conditions: &config.ProfileCondition{
+						RequiredMonitors: []*config.RequiredMonitor{
+							{Name: utils.StringPtr("eDP-1")},
+						},
+					},
+				},
+			}).Get(),
+			connectedMonitors: []*hypr.MonitorSpec{
+				{Name: "eDP-1", ID: utils.IntPtr(0), Description: "Built-in Display"},
+			},
+			powerState:      power.ACPowerState,
+			expectedProfile: "second_profile",
+			description:     "When two profiles have equal scores, the last one in TOML order should win",
+		},
 	}
 
 	for _, tt := range tests {