acdream/tests/AcDream.UI.Abstractions.Tests/Panels/Settings/SettingsVMTests.cs

using System.IO;
using System.Linq;
using AcDream.UI.Abstractions.Input;
using AcDream.UI.Abstractions.Panels.Settings;
using AcDream.UI.Abstractions.Tests.Input;
using Silk.NET.Input;

namespace AcDream.UI.Abstractions.Tests.Panels.Settings;

/// <summary>
/// K.3: <see cref="SettingsVM"/> owns the click-to-rebind state machine
/// for the Settings panel. It holds a <b>draft</b> copy of the active
/// <see cref="KeyBindings"/>; rebinds modify the draft. Save commits to
/// the supplied callback (which writes to disk + replaces the live
/// dispatcher's table); Cancel reverts the draft.
/// </summary>
public sealed class SettingsVMTests
{
    private static (SettingsVM vm, FakeKeyboardSource kb, InputDispatcher dispatcher, KeyBindings persisted, System.Collections.Generic.List<KeyBindings> savedHistory, System.Collections.Generic.List<DisplaySettings> savedDisplayHistory, System.Collections.Generic.List<AudioSettings> savedAudioHistory, System.Collections.Generic.List<GameplaySettings> savedGameplayHistory)
        Build(KeyBindings? persisted = null, DisplaySettings? persistedDisplay = null, AudioSettings? persistedAudio = null, GameplaySettings? persistedGameplay = null)
    {
        persisted ??= MakeMinimalBindings();
        var kb = new FakeKeyboardSource();
        var mouse = new FakeMouseSource();
        var dispatcher = new InputDispatcher(kb, mouse, persisted);
        var savedHistory = new System.Collections.Generic.List<KeyBindings>();
        var savedDisplayHistory = new System.Collections.Generic.List<DisplaySettings>();
        var savedAudioHistory = new System.Collections.Generic.List<AudioSettings>();
        var savedGameplayHistory = new System.Collections.Generic.List<GameplaySettings>();
        var vm = new SettingsVM(
            persisted, dispatcher,
            b => savedHistory.Add(b),
            persistedDisplay ?? DisplaySettings.Default,
            d => savedDisplayHistory.Add(d),
            persistedAudio ?? AudioSettings.Default,
            a => savedAudioHistory.Add(a),
            persistedGameplay ?? GameplaySettings.Default,
            g => savedGameplayHistory.Add(g));
        return (vm, kb, dispatcher, persisted, savedHistory, savedDisplayHistory, savedAudioHistory, savedGameplayHistory);
    }

    private static KeyBindings MakeMinimalBindings()
    {
        var b = new KeyBindings();
        b.Add(new Binding(new KeyChord(Key.W, ModifierMask.None), InputAction.MovementForward));
        b.Add(new Binding(new KeyChord(Key.A, ModifierMask.None), InputAction.MovementTurnLeft));
        b.Add(new Binding(new KeyChord(Key.S, ModifierMask.None), InputAction.MovementStop));
        return b;
    }

    [Fact]
    public void Constructor_clones_persisted_into_draft()
    {
        var (vm, _, _, persisted, _, _, _, _) = Build();
        Assert.Equal(persisted.All.Count, vm.Draft.All.Count);
        Assert.False(vm.HasUnsavedChanges);
    }

    [Fact]
    public void BeginRebind_enters_capture_mode()
    {
        var (vm, _, dispatcher, _, _, _, _, _) = Build();
        var original = vm.Draft.ForAction(InputAction.MovementForward).First();

        vm.BeginRebind(InputAction.MovementForward, original);

        Assert.True(dispatcher.IsCapturing);
        Assert.Equal(InputAction.MovementForward, vm.RebindInProgress);
        Assert.Equal(original, vm.RebindOriginal);
    }

    [Fact]
    public void BeginRebind_then_chord_with_no_conflict_applies_rebind()
    {
        var (vm, kb, _, _, _, _, _, _) = Build();
        var original = vm.Draft.ForAction(InputAction.MovementForward).First();

        vm.BeginRebind(InputAction.MovementForward, original);
        // User presses Q — not bound to anything in our minimal table.
        kb.EmitKeyDown(Key.Q, ModifierMask.None);

        Assert.Null(vm.RebindInProgress);
        Assert.Null(vm.PendingConflict);
        var binds = vm.Draft.ForAction(InputAction.MovementForward).ToList();
        Assert.Single(binds);
        Assert.Equal(new KeyChord(Key.Q, ModifierMask.None), binds[0].Chord);
        Assert.True(vm.HasUnsavedChanges);
    }

    [Fact]
    public void BeginRebind_then_Escape_cancels_with_no_change()
    {
        var (vm, kb, _, _, _, _, _, _) = Build();
        var original = vm.Draft.ForAction(InputAction.MovementForward).First();

        vm.BeginRebind(InputAction.MovementForward, original);
        kb.EmitKeyDown(Key.Escape, ModifierMask.None);

        Assert.Null(vm.RebindInProgress);
        Assert.Null(vm.PendingConflict);
        var binds = vm.Draft.ForAction(InputAction.MovementForward).ToList();
        Assert.Single(binds);
        Assert.Equal(new KeyChord(Key.W, ModifierMask.None), binds[0].Chord);
        Assert.False(vm.HasUnsavedChanges);
    }

    [Fact]
    public void BeginRebind_with_conflict_surfaces_PendingConflict()
    {
        var (vm, kb, _, _, _, _, _, _) = Build();
        var original = vm.Draft.ForAction(InputAction.MovementForward).First();

        // Bind chord that conflicts with MovementTurnLeft (which has Key.A).
        vm.BeginRebind(InputAction.MovementForward, original);
        kb.EmitKeyDown(Key.A, ModifierMask.None);

        Assert.NotNull(vm.PendingConflict);
        var c = vm.PendingConflict!.Value;
        Assert.Equal(InputAction.MovementForward, c.NewAction);
        Assert.Equal(new KeyChord(Key.A, ModifierMask.None), c.NewChord);
        Assert.Equal(InputAction.MovementTurnLeft, c.ConflictingAction);
        // Rebind has NOT been applied yet — still on W.
        var binds = vm.Draft.ForAction(InputAction.MovementForward).ToList();
        Assert.Equal(new KeyChord(Key.W, ModifierMask.None), binds[0].Chord);
    }

    [Fact]
    public void ResolveConflict_replace_true_removes_conflict_and_applies_rebind()
    {
        var (vm, kb, _, _, _, _, _, _) = Build();
        var original = vm.Draft.ForAction(InputAction.MovementForward).First();

        vm.BeginRebind(InputAction.MovementForward, original);
        kb.EmitKeyDown(Key.A, ModifierMask.None);
        vm.ResolveConflict(replace: true);

        Assert.Null(vm.PendingConflict);
        Assert.Null(vm.RebindInProgress);
        // MovementForward now bound to A.
        var fwd = vm.Draft.ForAction(InputAction.MovementForward).ToList();
        Assert.Single(fwd);
        Assert.Equal(new KeyChord(Key.A, ModifierMask.None), fwd[0].Chord);
        // MovementTurnLeft no longer bound to A (conflict removed).
        var left = vm.Draft.ForAction(InputAction.MovementTurnLeft).ToList();
        Assert.Empty(left);
    }

    [Fact]
    public void ResolveConflict_replace_false_cancels_rebind()
    {
        var (vm, kb, _, _, _, _, _, _) = Build();
        var original = vm.Draft.ForAction(InputAction.MovementForward).First();

        vm.BeginRebind(InputAction.MovementForward, original);
        kb.EmitKeyDown(Key.A, ModifierMask.None);
        vm.ResolveConflict(replace: false);

        Assert.Null(vm.PendingConflict);
        Assert.Null(vm.RebindInProgress);
        // MovementForward still bound to W.
        var fwd = vm.Draft.ForAction(InputAction.MovementForward).ToList();
        Assert.Equal(new KeyChord(Key.W, ModifierMask.None), fwd[0].Chord);
        // MovementTurnLeft still bound to A.
        var left = vm.Draft.ForAction(InputAction.MovementTurnLeft).ToList();
        Assert.Equal(new KeyChord(Key.A, ModifierMask.None), left[0].Chord);
    }

    [Fact]
    public void ResetActionToDefault_restores_single_action_to_RetailDefaults()
    {
        // Build a draft that's been mutated for MovementForward; ensure
        // ResetActionToDefault restores W (and Up-arrow per retail).
        var (vm, kb, _, _, _, _, _, _) = Build(KeyBindings.RetailDefaults());
        var original = vm.Draft.ForAction(InputAction.MovementForward).First();
        vm.BeginRebind(InputAction.MovementForward, original);
        // F7 is unbound in retail-default (only Ctrl+F7 is acdream debug);
        // pick it deliberately to avoid triggering a conflict prompt that
        // would block the rebind from applying.
        kb.EmitKeyDown(Key.F7, ModifierMask.None);

        Assert.True(vm.HasUnsavedChanges);

        vm.ResetActionToDefault(InputAction.MovementForward);

        var fwd = vm.Draft.ForAction(InputAction.MovementForward).ToList();
        Assert.Contains(fwd, x => x.Chord == new KeyChord(Key.W, ModifierMask.None));
        Assert.Contains(fwd, x => x.Chord == new KeyChord(Key.Up, ModifierMask.None));
    }

    [Fact]
    public void ResetAllToDefaults_replaces_entire_draft()
    {
        var (vm, _, _, _, _, _, _, _) = Build();
        vm.ResetAllToDefaults();

        // Should now include retail-default size set (~149 bindings).
        Assert.True(vm.Draft.All.Count >= 100);
        Assert.True(vm.HasUnsavedChanges);
    }

    [Fact]
    public void Save_invokes_callback_with_draft()
    {
        var (vm, kb, _, _, savedHistory, _, _, _) = Build();
        var original = vm.Draft.ForAction(InputAction.MovementForward).First();
        vm.BeginRebind(InputAction.MovementForward, original);
        kb.EmitKeyDown(Key.Q, ModifierMask.None);

        vm.Save();

        Assert.Single(savedHistory);
        var saved = savedHistory[0];
        var fwd = saved.ForAction(InputAction.MovementForward).ToList();
        Assert.Equal(new KeyChord(Key.Q, ModifierMask.None), fwd[0].Chord);
    }

    [Fact]
    public void Cancel_reverts_draft_to_persisted()
    {
        var (vm, kb, _, _, _, _, _, _) = Build();
        var original = vm.Draft.ForAction(InputAction.MovementForward).First();
        vm.BeginRebind(InputAction.MovementForward, original);
        kb.EmitKeyDown(Key.Q, ModifierMask.None);
        Assert.True(vm.HasUnsavedChanges);

        vm.Cancel();

        Assert.False(vm.HasUnsavedChanges);
        var fwd = vm.Draft.ForAction(InputAction.MovementForward).ToList();
        Assert.Equal(new KeyChord(Key.W, ModifierMask.None), fwd[0].Chord);
    }

    [Fact]
    public void Cancel_during_active_capture_clears_dispatcher_capture_state()
    {
        var (vm, _, dispatcher, _, _, _, _, _) = Build();
        var original = vm.Draft.ForAction(InputAction.MovementForward).First();
        vm.BeginRebind(InputAction.MovementForward, original);

        Assert.True(dispatcher.IsCapturing);
        vm.Cancel();
        Assert.False(dispatcher.IsCapturing);
        Assert.Null(vm.RebindInProgress);
    }

    [Fact]
    public void HasUnsavedChanges_false_initially_and_after_save_sync()
    {
        var (vm, _, _, _, _, _, _, _) = Build();
        Assert.False(vm.HasUnsavedChanges);
    }

    // -- Display tab state ------------------------------------------------

    [Fact]
    public void DisplayDraft_initial_value_matches_persisted()
    {
        var custom = DisplaySettings.Default with { FieldOfView = 90f, ShowFps = true };
        var (vm, _, _, _, _, _, _, _) = Build(persistedDisplay: custom);
        Assert.Equal(custom, vm.DisplayDraft);
        Assert.False(vm.HasUnsavedChanges);
    }

    [Fact]
    public void SetDisplay_marks_unsaved_changes()
    {
        var (vm, _, _, _, _, _, _, _) = Build();
        vm.SetDisplay(vm.DisplayDraft with { ShowFps = true });
        Assert.True(vm.HasUnsavedChanges);
    }

    [Fact]
    public void Save_invokes_display_callback_with_draft()
    {
        var (vm, _, _, _, _, savedDisplayHistory, _, _) = Build();
        vm.SetDisplay(vm.DisplayDraft with { Resolution = "2560x1440", FieldOfView = 100f });

        vm.Save();

        Assert.Single(savedDisplayHistory);
        Assert.Equal("2560x1440", savedDisplayHistory[0].Resolution);
        Assert.Equal(100f, savedDisplayHistory[0].FieldOfView);
        Assert.False(vm.HasUnsavedChanges);
    }

    [Fact]
    public void Cancel_reverts_display_draft_to_persisted()
    {
        var custom = DisplaySettings.Default with { FieldOfView = 90f };
        var (vm, _, _, _, _, _, _, _) = Build(persistedDisplay: custom);
        vm.SetDisplay(vm.DisplayDraft with { FieldOfView = 30f, ShowFps = true });
        Assert.True(vm.HasUnsavedChanges);

        vm.Cancel();

        Assert.Equal(custom, vm.DisplayDraft);
        Assert.False(vm.HasUnsavedChanges);
    }

    [Fact]
    public void ResetAllToDefaults_resets_display_to_default()
    {
        var custom = DisplaySettings.Default with { FieldOfView = 30f, ShowFps = true };
        var (vm, _, _, _, _, _, _, _) = Build(persistedDisplay: custom);
        Assert.NotEqual(DisplaySettings.Default, vm.DisplayDraft);

        vm.ResetAllToDefaults();

        Assert.Equal(DisplaySettings.Default, vm.DisplayDraft);
        Assert.True(vm.HasUnsavedChanges);
    }

    [Fact]
    public void Save_then_Cancel_does_not_revert()
    {
        // After Save the persisted snapshot equals the draft, so Cancel
        // is a no-op. This guards the Save/Cancel ordering — a regression
        // would surface as Cancel reverting to pre-Save values.
        var (vm, _, _, _, _, _, _, _) = Build();
        vm.SetDisplay(vm.DisplayDraft with { ShowFps = true });
        vm.Save();
        Assert.False(vm.HasUnsavedChanges);

        vm.Cancel();

        Assert.True(vm.DisplayDraft.ShowFps);
        Assert.False(vm.HasUnsavedChanges);
    }

    // -- Audio tab state --------------------------------------------------

    [Fact]
    public void AudioDraft_initial_value_matches_persisted()
    {
        var custom = AudioSettings.Default with { Master = 0.3f, Music = 0.1f };
        var (vm, _, _, _, _, _, _, _) = Build(persistedAudio: custom);
        Assert.Equal(custom, vm.AudioDraft);
        Assert.False(vm.HasUnsavedChanges);
    }

    [Fact]
    public void SetAudio_marks_unsaved_changes()
    {
        var (vm, _, _, _, _, _, _, _) = Build();
        vm.SetAudio(vm.AudioDraft with { Master = 0.5f });
        Assert.True(vm.HasUnsavedChanges);
    }

    [Fact]
    public void Save_invokes_audio_callback_with_draft()
    {
        var (vm, _, _, _, _, _, savedAudioHistory, _) = Build();
        vm.SetAudio(vm.AudioDraft with { Master = 0.4f, Sfx = 0.6f });

        vm.Save();

        Assert.Single(savedAudioHistory);
        Assert.Equal(0.4f, savedAudioHistory[0].Master);
        Assert.Equal(0.6f, savedAudioHistory[0].Sfx);
        Assert.False(vm.HasUnsavedChanges);
    }

    [Fact]
    public void Cancel_reverts_audio_draft_to_persisted()
    {
        var custom = AudioSettings.Default with { Music = 0.2f };
        var (vm, _, _, _, _, _, _, _) = Build(persistedAudio: custom);
        vm.SetAudio(vm.AudioDraft with { Music = 0.9f, Master = 0.3f });
        Assert.True(vm.HasUnsavedChanges);

        vm.Cancel();

        Assert.Equal(custom, vm.AudioDraft);
        Assert.False(vm.HasUnsavedChanges);
    }

    [Fact]
    public void ResetAllToDefaults_resets_audio_to_default()
    {
        var custom = AudioSettings.Default with { Master = 0.1f };
        var (vm, _, _, _, _, _, _, _) = Build(persistedAudio: custom);
        Assert.NotEqual(AudioSettings.Default, vm.AudioDraft);

        vm.ResetAllToDefaults();

        Assert.Equal(AudioSettings.Default, vm.AudioDraft);
        Assert.True(vm.HasUnsavedChanges);
    }

    // -- Gameplay tab state -----------------------------------------------

    [Fact]
    public void GameplayDraft_initial_value_matches_persisted()
    {
        var custom = GameplaySettings.Default with { AutoTarget = false, LockUI = true };
        var (vm, _, _, _, _, _, _, _) = Build(persistedGameplay: custom);
        Assert.Equal(custom, vm.GameplayDraft);
        Assert.False(vm.HasUnsavedChanges);
    }

    [Fact]
    public void SetGameplay_marks_unsaved_changes()
    {
        var (vm, _, _, _, _, _, _, _) = Build();
        vm.SetGameplay(vm.GameplayDraft with { LockUI = true });
        Assert.True(vm.HasUnsavedChanges);
    }

    [Fact]
    public void Save_invokes_gameplay_callback_with_draft()
    {
        var (vm, _, _, _, _, _, _, savedGameplayHistory) = Build();
        vm.SetGameplay(vm.GameplayDraft with
        {
            AutoTarget = false,
            ShowTooltips = false,
            UseMouseTurning = true,
        });

        vm.Save();

        Assert.Single(savedGameplayHistory);
        Assert.False(savedGameplayHistory[0].AutoTarget);
        Assert.False(savedGameplayHistory[0].ShowTooltips);
        Assert.True(savedGameplayHistory[0].UseMouseTurning);
        Assert.False(vm.HasUnsavedChanges);
    }

    [Fact]
    public void Cancel_reverts_gameplay_draft_to_persisted()
    {
        var custom = GameplaySettings.Default with { LockUI = true };
        var (vm, _, _, _, _, _, _, _) = Build(persistedGameplay: custom);
        vm.SetGameplay(vm.GameplayDraft with { LockUI = false, ShowHelm = false });
        Assert.True(vm.HasUnsavedChanges);

        vm.Cancel();

        Assert.Equal(custom, vm.GameplayDraft);
        Assert.False(vm.HasUnsavedChanges);
    }

    [Fact]
    public void ResetAllToDefaults_resets_gameplay_to_default()
    {
        var custom = GameplaySettings.Default with { AutoTarget = false, LockUI = true };
        var (vm, _, _, _, _, _, _, _) = Build(persistedGameplay: custom);
        Assert.NotEqual(GameplaySettings.Default, vm.GameplayDraft);

        vm.ResetAllToDefaults();

        Assert.Equal(GameplaySettings.Default, vm.GameplayDraft);
        Assert.True(vm.HasUnsavedChanges);
    }
}