Multi-Mode Game Profile Sorting & Custom Reordering (Recently Played, Date Created, Alphabetical, Free/Custom)

[undead2146]

[Feature] Multi-Mode Game Profile Sorting & Custom Reordering (Recently Played, Date Created, Alphabetical, Free/Custom)

1. Problem Statement & Context

In GameProfileLauncherView.axaml and GameProfileLauncherViewModel.cs:

• Profiles are loaded from disk via Directory.GetFiles() and appended to ObservableCollection<GameProfileItemViewModel> Profiles in non-deterministic filesystem order.
• GameProfile.cs contains a LastPlayedAt timestamp property (line 73), but it is never updated when a profile is launched via ProfileLauncherFacade.cs.
• There is no mechanism or UI selector to sort or manually reorder profiles.

---

2. User Stories & Use Cases

• UC-1 (Recently Played / Time): As an active player, I want my most recently launched profile displayed first so I can immediately jump back into my current mod without searching.
• UC-2 (Date Created / Date): As a mod tester, I want to sort by creation date to find new profiles I recently created.
• UC-3 (Alphabetical / Name): As a player with 15+ profiles, I want to sort them alphabetically (A–Z / Z–A) for predictable visual scanning.
• UC-4 (Free / Custom Order): As a user with specific favorite mods, I want to freely arrange my profiles in a custom order using drag-and-drop or Move Up/Down buttons.

---

3. Proposed Enums & Data Model Updates

namespace GenHub.Core.Models.Enums;

public enum ProfileSortMode
{
    LastPlayed = 0,       // Time (most recently launched first)
    DateCreated = 1,      // Date (newest created first)
    Alphabetical = 2,     // Name A to Z
    AlphabeticalDesc = 3, // Name Z to A
    Free = 4              // Custom manual order (DisplayOrder property)
}

Model Extensions

• GameProfile.cs:

  public int DisplayOrder { get; set; } = 0;

• UserSettings.cs:

  public ProfileSortMode ProfileSortMode { get; set; } = ProfileSortMode.LastPlayed;

---

4. Active Launch Tracking in ProfileLauncherFacade.cs

In ProfileLauncherFacade.cs (LaunchProfileAsync):

// Record last played timestamp upon successful launch
profile.LastPlayedAt = DateTime.UtcNow;
await profileManager.UpdateProfileAsync(profile, cancellationToken);

---

5. UI/UX Wireframe (GameProfileLauncherView.axaml)

+------------------------------------------------------------------------------------+
| GAME PROFILES                      Sort by: [ 🕒 Recently Played  ▼ ]  [ + SCAN ]  |
+------------------------------------------------------------------------------------+
|  +-----------------+  +-----------------+  +-----------------+  +---------------+  |
|  | Generals Online |  | ShockWave Chaos |  | Reborn Omega    |  | [ + ]         |  |
|  | 60Hz Client     |  | Mod v1.2        |  | 1.04 Patch      |  | Add New       |  |
|  | Played 10m ago  |  | Played Yesterday|  | Played 3 days ago|  | Profile       |  |
|  | [  LAUNCH  ]    |  | [  LAUNCH  ]    |  | [  LAUNCH  ]    |  |               |  |
|  +-----------------+  +-----------------+  +-----------------+  +---------------+  |
+------------------------------------------------------------------------------------+

---

6. Acceptance Criteria

• ProfileSortMode enum added with LastPlayed, DateCreated, Alphabetical, AlphabeticalDesc, and Free.
• ProfileLauncherFacade.LaunchProfileAsync updates LastPlayedAt timestamp and persists it.
• GameProfileItemViewModel exposes LastPlayedAt, CreatedAt, and DisplayOrder.
• Sort ComboBox in GameProfileLauncherView.axaml updates the active sorting mode and persists selection to UserSettings.
• In Free mode, users can adjust DisplayOrder using card hover controls (◀ / ▶) or drag-and-drop.
• "Add Profile" card remains pinned as the final item in the collection regardless of the active sort mode.
• Unit tests in GameProfileLauncherViewModelTests verify collection reordering for all 4 sort modes.

[coderabbitai]

🔗 Related PRs

#267 - feat: Implement copy profile functionality [merged]
#332 - feat(launching): launch the native BGFX client against retail archives [merged]
#374 - feat(userdata): deploy GeneralsOnline game data patch to user documents with safe backup and restore [merged]
#375 - feat(gameprofiles): enable runtime content hot-swapping for active game sessions [open]
#382 - fix(launching): only rewrite GeneralsOnline settings for GeneralsOnline profiles [open]

---

📝 Issue Planner

_{Check the box below or use the @coderabbitai plan command to generate an implementation plan and prompts that you can use with your favorite coding assistant.}

• Create Plan

---

🧪 Issue enrichment is currently in open beta.

To disable automatic issue enrichment, add the following to your .coderabbit.yaml:

issue_enrichment:
  auto_enrich:
    enabled: false

💬 Have feedback or questions? Drop into our discord!

[coderabbitai]

Coding Plan

Summary

Add a ProfileSortMode enum, a persisted UserSettings.ProfileSortMode, and a GameProfile.DisplayOrder field. Reuse the existing UpdateProfileRequest/UpdateProfileAsync pattern to persist LastPlayedAt and DisplayOrder.

Write LastPlayedAt in ProfileLauncherFacade.LaunchProfileAsync on successful launch.

Apply sorting in GameProfileLauncherViewModel through a SortBy extension. Support Free ordering with Move Up/Down commands plus drag-and-drop that share one reorder-and-persist helper. Always keep the "Add Profile" card last.

Verify all four sort modes and custom reordering with unit tests.

Design Choices

Design Choice 1: How should LastPlayedAt and DisplayOrder be persisted?

Options Considered:

1. Extend UpdateProfileRequest with nullable LastPlayedAt and DisplayOrder, then call the existing UpdateProfileAsync overload.
2. Add a new direct UpdateProfileAsync(GameProfile, ct) overload that saves the whole object.

Chosen Option: 1

Rationale: This option reuses the established DTO mapping pattern already used three times inside ProfileLauncherFacade, and it avoids adding a redundant manager overload. Note: the ticket pseudo-code calls UpdateProfileAsync(profile, ct), but the real signature is UpdateProfileAsync(string profileId, UpdateProfileRequest request, ct).

Design Choice 2: How should the sort-mode display name be provided to the UI?

Options Considered:

1. Add a ProfileSortModeExtensions.GetDisplayName() extension and expose display strings from the ViewModel.
2. Add an Avalonia IValueConverter referenced from AXAML.

Chosen Option: 1

Rationale: The display strings are straightforward, and extension methods are the preferred style for simple display names in this codebase.

Design Choice 3: Should reordering support drag-and-drop in addition to Move Up/Down buttons?

Options Considered:

1. Implement Move Up/Move Down buttons only.
2. Implement Move Up/Move Down buttons plus pointer drag-and-drop.

Chosen Option: 2

Rationale: The ticket requires both. Move Up/Move Down is the primary mechanism, and drag-and-drop is layered on top using the same underlying reorder command.

💡 User Tips

Regenerate the plan with different choices with @coderabbitai <feedback>.

Implementation Steps

Phase 1: Data Model and Persistence Foundation

This phase adds the enum, the persisted fields, and the plumbing to save them. It gives every later phase a stable data contract.

Task 1: Add the ProfileSortMode enum and display helper

Create the sort-mode type and its display names.

• Create GenHub/GenHub.Core/Models/Enums/ProfileSortMode.cs. Use file-scoped namespace GenHub.Core.Models.Enums and add XML doc comments per member.
• Define members LastPlayed = 0, DateCreated = 1, Alphabetical = 2, AlphabeticalDesc = 3, Free = 4.
• Create GenHub/GenHub.Core/Extensions/Enums/ProfileSortModeExtensions.cs with a GetDisplayName() extension. Return user-facing text such as "Recently Played", "Date Created", "Name (A-Z)", "Name (Z-A)", and "Custom".

Task 2: Add DisplayOrder to the profile model and interface

Add the field that supports Free ordering.

• Add public int DisplayOrder { get; set; } = 0; to GenHub/GenHub.Core/Models/GameProfile/GameProfile.cs.
• Add DateTime CreatedAt { get; }, DateTime LastPlayedAt { get; }, and int DisplayOrder { get; set; } to GenHub/GenHub.Core/Interfaces/GameProfiles/IGameProfile.cs. This exposes the fields through the interface, consistent with existing members like BuildInfo.

Task 3: Add ProfileSortMode to user settings

Persist the selected sort mode.

• Add public ProfileSortMode ProfileSortMode { get; set; } = ProfileSortMode.LastPlayed; to GenHub/GenHub.Core/Models/Common/UserSettings.cs.
• Add the new property to the Clone() object initializer. If this step is omitted, the value is lost on every settings round-trip.
• Add a case for "profileSortMode" in UserSettingsService.ConvertJsonPropertyNameToCSharp so explicit-set tracking works.

Task 4: Extend the update request and manager mapping

Enable persistence of LastPlayedAt and DisplayOrder.

• Add public DateTime? LastPlayedAt { get; set; } and public int? DisplayOrder { get; set; } to GenHub/GenHub.Core/Models/GameProfile/UpdateProfileRequest.cs.
• In GenHub/GenHub/Features/GameProfiles/Services/GameProfileManager.cs UpdateProfileAsync, add if (request.LastPlayedAt.HasValue) profile.LastPlayedAt = request.LastPlayedAt.Value; and if (request.DisplayOrder.HasValue) profile.DisplayOrder = request.DisplayOrder.Value;. Follow the existing HasValue mapping idiom, before the SaveProfileAsync call.
• In GameProfileManager.CreateProfileAsync, load existing profiles, compute max(DisplayOrder) + 1, and assign it to the new GameProfile so new profiles append at the end of Free order.

🤖 Prompt for AI agents

Implement the data model and persistence foundation for multi-mode profile
sorting. The goal is to define the sort-mode contract and add the fields
required for custom ordering and last-played tracking.

1. Create `GenHub/GenHub.Core/Models/Enums/ProfileSortMode.cs` with a
file-scoped namespace `GenHub.Core.Models.Enums`. Define enum members
`LastPlayed = 0`, `DateCreated = 1`, `Alphabetical = 2`, `AlphabeticalDesc = 3`,
`Free = 4`, each with an XML doc comment.

2. Create `GenHub/GenHub.Core/Extensions/Enums/ProfileSortModeExtensions.cs`
with a `GetDisplayName()` extension method returning: "Recently Played" for
`LastPlayed`, "Date Created" for `DateCreated`, "Name (A-Z)" for `Alphabetical`,
"Name (Z-A)" for `AlphabeticalDesc`, and "Custom" for `Free`.

3. Add `public int DisplayOrder { get; set; } = 0;` to `GameProfile.cs`
(`GenHub/GenHub.Core/Models/GameProfile/GameProfile.cs`).

4. Add `DateTime CreatedAt { get; }`, `DateTime LastPlayedAt { get; }`, and `int
DisplayOrder { get; set; }` to `IGameProfile.cs`, consistent with the existing
member style (for example `BuildInfo`).

5. Add `public ProfileSortMode ProfileSortMode { get; set; } =
ProfileSortMode.LastPlayed;` to `UserSettings.cs`. Include this property in the
`Clone()` object initializer. Add a case for `"profileSortMode"` in
`UserSettingsService.ConvertJsonPropertyNameToCSharp` to support explicit-set
tracking.

6. Add `public DateTime? LastPlayedAt { get; set; }` and `public int?
DisplayOrder { get; set; }` to `UpdateProfileRequest.cs`.

7. In `GameProfileManager.UpdateProfileAsync`, add conditional assignment of
`LastPlayedAt` and `DisplayOrder` from the request using the `HasValue` idiom,
placed before the `SaveProfileAsync` call.

8. In `GameProfileManager.CreateProfileAsync`, load existing profiles, compute
the maximum `DisplayOrder` plus one, and assign it to the new profile so new
profiles append at the end of `Free` order.

Phase 2: Launch Tracking

This phase records when a profile was last launched.

Update LastPlayedAt on successful launch

Write the timestamp after a profile launch succeeds.

• In GenHub/GenHub/Features/GameProfiles/Services/ProfileLauncherFacade.cs LaunchProfileAsync, after the launch succeeds, call profileManager.UpdateProfileAsync(profileId, new UpdateProfileRequest { LastPlayedAt = DateTime.UtcNow }, ct).
• Mirror the existing UpdateProfileAsync calls already used for installation rebind and workspace strategy fallback. Do not fail the launch if the timestamp update fails; log the failure and continue.

🤖 Prompt for AI agents

Implement launch tracking so that `LastPlayedAt` is recorded whenever a profile
launches successfully.

- In `ProfileLauncherFacade.LaunchProfileAsync`, after a successful launch, call
`profileManager.UpdateProfileAsync(profileId, new UpdateProfileRequest {
LastPlayedAt = DateTime.UtcNow }, ct)`.
- Follow the pattern of the existing `UpdateProfileAsync` calls already used for
installation rebind and workspace strategy fallback.
- If the timestamp update fails, log the failure and continue. Do not fail the
launch because of this update.

Phase 3: ViewModel Sorting and Reordering Logic

This phase adds the sort state, the reorder commands, and the item properties. It contains the core behavior that the UI binds to.

Task 1: Expose date and order fields on the item ViewModel

Surface the values the UI needs.

• In GenHub/GenHub/Features/GameProfiles/ViewModels/GameProfileItemViewModel.cs, add [ObservableProperty] fields _createdAt, _lastPlayedAt, and _displayOrder. Set them in the constructor from the profile argument, following the existing is GameProfile block pattern.
• Add a derived read-only LastPlayedText property that formats LastPlayedAt as relative time (for example, "Played 10m ago"). Return a "Never played" style value when LastPlayedAt is the default DateTime.
• Add an UpdateLastPlayedAt(DateTime) mutator that raises change notifications for LastPlayedAt and LastPlayedText, following the existing UpdateWorkspaceStatus pattern.

Task 2: Add a relative-time formatting helper

Provide the "time ago" text. No such helper exists today.

• Create a static helper (for example GenHub/GenHub.Core/Helpers/TimeAgoHelper.cs) with a Format(DateTime) method. Follow the style of ByteFormatHelper.
• Return short relative strings such as "just now", "10m ago", "Yesterday", and "3 days ago". Use this helper from GameProfileItemViewModel.LastPlayedText.

Task 3: Add sort state and sorting logic to the launcher ViewModel

Apply the active sort mode to the profile collection.

• Add a SortBy(this IEnumerable<GameProfile> profiles, ProfileSortMode mode) extension in GenHub/GenHub.Core/Extensions/GameProfileExtensions.cs. Use a switch expression with OrderBy/OrderByDescending, following ContentOrchestrator.ApplySorting. Sort Free by DisplayOrder.
• In GenHub/GenHub/Features/GameProfiles/ViewModels/GameProfileLauncherViewModel.cs, add [ObservableProperty] private ProfileSortMode _selectedSortMode; and initialize it from IUserSettingsService.Get().
• Add public static IEnumerable<ProfileSortMode> AvailableSortModes => Enum.GetValues<ProfileSortMode>();.
• Add a private ApplySort() method that reorders Profiles in place by the item ViewModels' underlying values, then always moves the AddProfileItemViewModel sentinel to the last position.
• Add a partial OnSelectedSortModeChanged method that calls ApplySort(), and persists the value via _userSettingsService.Update(...) plus SaveAsync().
• Call ApplySort() at the end of InitializeAsync, after profiles load and before or after the sentinel is added, so the initial order matches the persisted sort mode.

Task 4: Add Move Up / Move Down and reorder commands

Support custom ordering in Free mode.

• In GameProfileLauncherViewModel, add [RelayCommand] methods MoveProfileUp(GameProfileItemViewModel) and MoveProfileDown(GameProfileItemViewModel).
• Each command moves the item one position within Profiles, never past the AddProfileItemViewModel sentinel.
• After moving, recompute DisplayOrder for all real profile items from their new positions, and persist each changed profile via UpdateProfileAsync with UpdateProfileRequest { DisplayOrder = ... }. There is no batch save method, so persist per changed profile in a loop.
• Add a ReorderProfile(GameProfileItemViewModel item, int newIndex) helper that the drag-and-drop handler reuses, so both mechanisms share the same reorder-and-persist logic.
• Expose a computed flag (for example IsFreeSortMode) so the UI can enable reorder controls only in Free mode.

🤖 Prompt for AI agents

Implement the ViewModel-level sorting and reordering logic that the view binds
to. This is the core behavior for the four sort modes and for custom Free-mode
reordering.

1. In `GameProfileItemViewModel.cs`, add `[ObservableProperty]` backing fields
`_createdAt`, `_lastPlayedAt`, and `_displayOrder`. Set these from the `profile`
constructor argument, following the existing `is GameProfile` block pattern. Add
a derived read-only `LastPlayedText` property that formats `LastPlayedAt` as
relative time (for example "Played 10m ago"), returning a "Never played" style
value when `LastPlayedAt` is the default `DateTime`. Add an
`UpdateLastPlayedAt(DateTime)` mutator that raises change notifications for
`LastPlayedAt` and `LastPlayedText`, following the existing
`UpdateWorkspaceStatus` pattern.

2. Create a static helper, for example
`GenHub/GenHub.Core/Helpers/TimeAgoHelper.cs`, with a `Format(DateTime)` method,
styled like `ByteFormatHelper`. It must return short relative strings such as
"just now", "10m ago", "Yesterday", and "3 days ago". Use this helper from
`GameProfileItemViewModel.LastPlayedText`.

3. Add a `SortBy(this IEnumerable<GameProfile> profiles, ProfileSortMode mode)`
extension method in `GameProfileExtensions.cs`. Use a `switch` expression with
`OrderBy`/`OrderByDescending` per mode, following the
`ContentOrchestrator.ApplySorting` pattern. Sort the `Free` mode by
`DisplayOrder`.

4. In `GameProfileLauncherViewModel.cs`, add `[ObservableProperty] private
ProfileSortMode _selectedSortMode;` initialized from
`IUserSettingsService.Get()`. Add `public static IEnumerable<ProfileSortMode>
AvailableSortModes => Enum.GetValues<ProfileSortMode>();`.

5. Add a private `ApplySort()` method that reorders `Profiles` in place using
the item ViewModels' underlying values, then always moves the
`AddProfileItemViewModel` sentinel to the last position. Add a partial
`OnSelectedSortModeChanged` method that calls `ApplySort()` and persists the new
value through `_userSettingsService.Update(...)` and `SaveAsync()`. Call
`ApplySort()` at the end of `InitializeAsync`, after profiles load, so the
initial order matches the persisted sort mode.

6. Add `[RelayCommand]` methods `MoveProfileUp(GameProfileItemViewModel)` and
`MoveProfileDown(GameProfileItemViewModel)`. Each moves the item one position
within `Profiles`, never past the `AddProfileItemViewModel` sentinel. After a
move, recompute `DisplayOrder` for all real profile items from their new
positions, and persist each changed profile via `UpdateProfileAsync` with
`UpdateProfileRequest { DisplayOrder = ... }` in a loop, since there is no batch
save method.

7. Add a `ReorderProfile(GameProfileItemViewModel item, int newIndex)` helper
shared by the drag-and-drop handler in Phase 4, so both mechanisms use the same
reorder-and-persist logic. Expose a computed flag, for example `IsFreeSortMode`,
so the view can enable reorder controls only in `Free` mode.

Phase 4: View and User Interaction

This phase adds the sort selector, the reorder controls, and the last-played label.

Task 1: Add the sort ComboBox to the launcher view

Let users choose the sort mode.

• In GenHub/GenHub/Features/GameProfiles/Views/GameProfileLauncherView.axaml, add a ComboBox in the header, near the Scan button.
• Bind ItemsSource to AvailableSortModes and SelectedItem to SelectedSortMode. Follow the SettingsView.axaml pattern used for AvailableWorkspaceStrategies.
• Render display text with ProfileSortModeExtensions.GetDisplayName() through an item template or a small converter.

Task 2: Add Move Up / Move Down controls and last-played label to the card

Add per-card reorder controls and the played-time text.

• In GenHub/GenHub/Features/GameProfiles/Views/GameProfileCardView.axaml, add two Buttons with Classes="action-button" in the existing action-buttons StackPanel.
• Bind IsVisible to the launcher VM's IsFreeSortMode, following the existing IsEditMode-gated pattern for the Edit and Delete buttons.
• Bind their commands to MoveProfileUpCommand/MoveProfileDownCommand with CommandParameter="{Binding}". Disable Move Up on the first item and Move Down on the last real item.
• Add a TextBlock bound to LastPlayedText to show text such as "Played 10m ago".

Task 3: Add drag-and-drop reordering

Provide drag-and-drop as a secondary reorder mechanism.

• Add a pointer-based drag handler in GenHub/GenHub/Features/GameProfiles/Views/GameProfileCardView.axaml.cs or the launcher view code-behind. Start the drag only after a movement threshold, per Avalonia guidance.
• On drop, resolve the source item and target index, then call the shared ReorderProfile(...) helper from Phase 3 through a command or exposed method.
• Enable drag-and-drop only when IsFreeSortMode is true. Do not allow dropping after the AddProfileItemViewModel sentinel.

🤖 Prompt for AI agents

Implement the view-level controls for choosing a sort mode, reordering profile
cards, and showing last-played information.

1. In `GameProfileLauncherView.axaml`, add a `ComboBox` in the header, near the
Scan button. Bind `ItemsSource` to `AvailableSortModes` and `SelectedItem` to
`SelectedSortMode`, following the `SettingsView.axaml` pattern used for
`AvailableWorkspaceStrategies`. Render the display text using
`ProfileSortModeExtensions.GetDisplayName()` through an item template or a small
converter.

2. In `GameProfileCardView.axaml`, add two `Button`s with
`Classes="action-button"` inside the existing action-buttons `StackPanel`. Bind
their `IsVisible` property to the launcher ViewModel's `IsFreeSortMode`,
following the existing `IsEditMode`-gated pattern used for the Edit and Delete
buttons. Bind their commands to `MoveProfileUpCommand`/`MoveProfileDownCommand`
with `CommandParameter="{Binding}"`. Disable Move Up on the first item and Move
Down on the last real item. Add a `TextBlock` bound to `LastPlayedText` to
display text such as "Played 10m ago".

3. Add drag-and-drop reordering as a secondary mechanism. Add a pointer-based
drag handler in `GameProfileCardView.axaml.cs` or the launcher view code-behind,
starting the drag only after a movement threshold, per Avalonia guidance. On
drop, resolve the source item and the target index, then call the shared
`ReorderProfile(...)` helper from Phase 3 through a command or exposed method.
Enable drag-and-drop only when `IsFreeSortMode` is true, and do not allow
dropping after the `AddProfileItemViewModel` sentinel.

Phase 5: Tests

This phase verifies sorting and reordering behavior.

Add sort and reorder unit tests

Verify all sort modes and custom reordering.

• In GenHub/GenHub.Tests/GenHub.Tests.Core/Features/GameProfiles/ViewModels/GameProfileLauncherViewModelTests.cs, add tests that set GetAllProfilesAsync to return manually built GameProfile objects with distinct Name, CreatedAt, LastPlayedAt, and DisplayOrder values.
• Add a shared private factory for the full VM constructor to reduce repetition, and mock IUserSettingsService.Get() to return a UserSettings with the desired ProfileSortMode.
• Add one test per sort mode (LastPlayed, DateCreated, Alphabetical, AlphabeticalDesc) that asserts the resulting Profiles order.
• Add tests for MoveProfileUpCommand/MoveProfileDownCommand that assert the reordered positions and that AddProfileItemViewModel remains last.
• Add a test that asserts ProfileLauncherFacade calls UpdateProfileAsync with a set LastPlayedAt on successful launch.

🤖 Prompt for AI agents

Implement unit tests that verify sort-mode behavior, custom reordering, and
last-played tracking.

1. In `GameProfileLauncherViewModelTests.cs`, add tests that configure
`GetAllProfilesAsync` to return manually built `GameProfile` objects with
distinct `Name`, `CreatedAt`, `LastPlayedAt`, and `DisplayOrder` values.

2. Add a shared private factory method for constructing the full ViewModel to
reduce repetition, and mock `IUserSettingsService.Get()` to return a
`UserSettings` object with the desired `ProfileSortMode`.

3. Add one test per sort mode (`LastPlayed`, `DateCreated`, `Alphabetical`,
`AlphabeticalDesc`) asserting the resulting order of `Profiles`.

4. Add tests for `MoveProfileUpCommand` and `MoveProfileDownCommand` asserting
the reordered positions and asserting that `AddProfileItemViewModel` remains
last after each move.

5. Add a test asserting that `ProfileLauncherFacade` calls `UpdateProfileAsync`
with a set `LastPlayedAt` value after a successful launch.

Research

GenHub is an Avalonia MVVM application that uses CommunityToolkit.Mvvm. Game profiles live under GenHub/Features/GameProfiles.

GameProfileLauncherViewModel loads profiles from IGameProfileManager into an ObservableCollection<GameProfileItemViewModel> and appends an AddProfileItemViewModel sentinel last.

Persistence uses one JSON file per profile through GameProfileRepository. Profile updates use a load-mutate-save pattern through GameProfileManager.UpdateProfileAsync(profileId, UpdateProfileRequest, ct).

GameProfile already has CreatedAt and LastPlayedAt fields, but LastPlayedAt is never written and no DisplayOrder field exists.

UserSettings is a flat POCO with Clone() and explicit-set tracking. Enum settings like WorkspaceStrategy and UpdateChannel are the model to follow.

ContentOrchestrator.ApplySorting and SettingsViewModel provide existing sort-mode and settings-editing patterns.

No move-up/down or drag-and-drop precedent exists in the codebase.

---

🚀 Next Steps

🤖 All AI agent prompts combined

Task: 1

Implement the data model and persistence foundation for multi-mode profile
sorting. The goal is to define the sort-mode contract and add the fields
required for custom ordering and last-played tracking.

1. Create `GenHub/GenHub.Core/Models/Enums/ProfileSortMode.cs` with a
file-scoped namespace `GenHub.Core.Models.Enums`. Define enum members
`LastPlayed = 0`, `DateCreated = 1`, `Alphabetical = 2`, `AlphabeticalDesc = 3`,
`Free = 4`, each with an XML doc comment.

2. Create `GenHub/GenHub.Core/Extensions/Enums/ProfileSortModeExtensions.cs`
with a `GetDisplayName()` extension method returning: "Recently Played" for
`LastPlayed`, "Date Created" for `DateCreated`, "Name (A-Z)" for `Alphabetical`,
"Name (Z-A)" for `AlphabeticalDesc`, and "Custom" for `Free`.

3. Add `public int DisplayOrder { get; set; } = 0;` to `GameProfile.cs`
(`GenHub/GenHub.Core/Models/GameProfile/GameProfile.cs`).

4. Add `DateTime CreatedAt { get; }`, `DateTime LastPlayedAt { get; }`, and `int
DisplayOrder { get; set; }` to `IGameProfile.cs`, consistent with the existing
member style (for example `BuildInfo`).

5. Add `public ProfileSortMode ProfileSortMode { get; set; } =
ProfileSortMode.LastPlayed;` to `UserSettings.cs`. Include this property in the
`Clone()` object initializer. Add a case for `"profileSortMode"` in
`UserSettingsService.ConvertJsonPropertyNameToCSharp` to support explicit-set
tracking.

6. Add `public DateTime? LastPlayedAt { get; set; }` and `public int?
DisplayOrder { get; set; }` to `UpdateProfileRequest.cs`.

7. In `GameProfileManager.UpdateProfileAsync`, add conditional assignment of
`LastPlayedAt` and `DisplayOrder` from the request using the `HasValue` idiom,
placed before the `SaveProfileAsync` call.

8. In `GameProfileManager.CreateProfileAsync`, load existing profiles, compute
the maximum `DisplayOrder` plus one, and assign it to the new profile so new
profiles append at the end of `Free` order.
===============================================================================

Task: 2

Implement launch tracking so that `LastPlayedAt` is recorded whenever a profile
launches successfully.

- In `ProfileLauncherFacade.LaunchProfileAsync`, after a successful launch, call
`profileManager.UpdateProfileAsync(profileId, new UpdateProfileRequest {
LastPlayedAt = DateTime.UtcNow }, ct)`.
- Follow the pattern of the existing `UpdateProfileAsync` calls already used for
installation rebind and workspace strategy fallback.
- If the timestamp update fails, log the failure and continue. Do not fail the
launch because of this update.
===============================================================================

Task: 3

Implement the ViewModel-level sorting and reordering logic that the view binds
to. This is the core behavior for the four sort modes and for custom Free-mode
reordering.

1. In `GameProfileItemViewModel.cs`, add `[ObservableProperty]` backing fields
`_createdAt`, `_lastPlayedAt`, and `_displayOrder`. Set these from the `profile`
constructor argument, following the existing `is GameProfile` block pattern. Add
a derived read-only `LastPlayedText` property that formats `LastPlayedAt` as
relative time (for example "Played 10m ago"), returning a "Never played" style
value when `LastPlayedAt` is the default `DateTime`. Add an
`UpdateLastPlayedAt(DateTime)` mutator that raises change notifications for
`LastPlayedAt` and `LastPlayedText`, following the existing
`UpdateWorkspaceStatus` pattern.

2. Create a static helper, for example
`GenHub/GenHub.Core/Helpers/TimeAgoHelper.cs`, with a `Format(DateTime)` method,
styled like `ByteFormatHelper`. It must return short relative strings such as
"just now", "10m ago", "Yesterday", and "3 days ago". Use this helper from
`GameProfileItemViewModel.LastPlayedText`.

3. Add a `SortBy(this IEnumerable<GameProfile> profiles, ProfileSortMode mode)`
extension method in `GameProfileExtensions.cs`. Use a `switch` expression with
`OrderBy`/`OrderByDescending` per mode, following the
`ContentOrchestrator.ApplySorting` pattern. Sort the `Free` mode by
`DisplayOrder`.

4. In `GameProfileLauncherViewModel.cs`, add `[ObservableProperty] private
ProfileSortMode _selectedSortMode;` initialized from
`IUserSettingsService.Get()`. Add `public static IEnumerable<ProfileSortMode>
AvailableSortModes => Enum.GetValues<ProfileSortMode>();`.

5. Add a private `ApplySort()` method that reorders `Profiles` in place using
the item ViewModels' underlying values, then always moves the
`AddProfileItemViewModel` sentinel to the last position. Add a partial
`OnSelectedSortModeChanged` method that calls `ApplySort()` and persists the new
value through `_userSettingsService.Update(...)` and `SaveAsync()`. Call
`ApplySort()` at the end of `InitializeAsync`, after profiles load, so the
initial order matches the persisted sort mode.

6. Add `[RelayCommand]` methods `MoveProfileUp(GameProfileItemViewModel)` and
`MoveProfileDown(GameProfileItemViewModel)`. Each moves the item one position
within `Profiles`, never past the `AddProfileItemViewModel` sentinel. After a
move, recompute `DisplayOrder` for all real profile items from their new
positions, and persist each changed profile via `UpdateProfileAsync` with
`UpdateProfileRequest { DisplayOrder = ... }` in a loop, since there is no batch
save method.

7. Add a `ReorderProfile(GameProfileItemViewModel item, int newIndex)` helper
shared by the drag-and-drop handler in Phase 4, so both mechanisms use the same
reorder-and-persist logic. Expose a computed flag, for example `IsFreeSortMode`,
so the view can enable reorder controls only in `Free` mode.
===============================================================================

Task: 4

Implement the view-level controls for choosing a sort mode, reordering profile
cards, and showing last-played information.

1. In `GameProfileLauncherView.axaml`, add a `ComboBox` in the header, near the
Scan button. Bind `ItemsSource` to `AvailableSortModes` and `SelectedItem` to
`SelectedSortMode`, following the `SettingsView.axaml` pattern used for
`AvailableWorkspaceStrategies`. Render the display text using
`ProfileSortModeExtensions.GetDisplayName()` through an item template or a small
converter.

2. In `GameProfileCardView.axaml`, add two `Button`s with
`Classes="action-button"` inside the existing action-buttons `StackPanel`. Bind
their `IsVisible` property to the launcher ViewModel's `IsFreeSortMode`,
following the existing `IsEditMode`-gated pattern used for the Edit and Delete
buttons. Bind their commands to `MoveProfileUpCommand`/`MoveProfileDownCommand`
with `CommandParameter="{Binding}"`. Disable Move Up on the first item and Move
Down on the last real item. Add a `TextBlock` bound to `LastPlayedText` to
display text such as "Played 10m ago".

3. Add drag-and-drop reordering as a secondary mechanism. Add a pointer-based
drag handler in `GameProfileCardView.axaml.cs` or the launcher view code-behind,
starting the drag only after a movement threshold, per Avalonia guidance. On
drop, resolve the source item and the target index, then call the shared
`ReorderProfile(...)` helper from Phase 3 through a command or exposed method.
Enable drag-and-drop only when `IsFreeSortMode` is true, and do not allow
dropping after the `AddProfileItemViewModel` sentinel.
===============================================================================

Task: 5

Implement unit tests that verify sort-mode behavior, custom reordering, and
last-played tracking.

1. In `GameProfileLauncherViewModelTests.cs`, add tests that configure
`GetAllProfilesAsync` to return manually built `GameProfile` objects with
distinct `Name`, `CreatedAt`, `LastPlayedAt`, and `DisplayOrder` values.

2. Add a shared private factory method for constructing the full ViewModel to
reduce repetition, and mock `IUserSettingsService.Get()` to return a
`UserSettings` object with the desired `ProfileSortMode`.

3. Add one test per sort mode (`LastPlayed`, `DateCreated`, `Alphabetical`,
`AlphabeticalDesc`) asserting the resulting order of `Profiles`.

4. Add tests for `MoveProfileUpCommand` and `MoveProfileDownCommand` asserting
the reordered positions and asserting that `AddProfileItemViewModel` remains
last after each move.

5. Add a test asserting that `ProfileLauncherFacade` calls `UpdateProfileAsync`
with a set `LastPlayedAt` value after a successful launch.

💡 Iterate on the plan with: `@coderabbitai` <feedback>

Example Feedback
- `@coderabbitai` You can skip phase 3. Add a simple unit test case for phase 2.
- `@coderabbitai` For design choice 1 go ahead with option 3 and replan.

---

💬 Have feedback or questions? Drop into our discord!