acdream/tests/AcDream.Core.Tests/Input/AutoEnterPlayerModeTests.cs

using AcDream.App.Input;

namespace AcDream.Core.Tests.Input;

/// <summary>
/// Phase K.2 — guard logic for auto-entering player mode at login.
/// The trigger fires exactly once when:
/// <list type="number">
/// <item>It has been <see cref="PlayerModeAutoEntry.Arm"/>'d (login
/// succeeded).</item>
/// <item>The live session is in <c>InWorld</c>.</item>
/// <item>The player entity has been streamed into the local
/// dictionary.</item>
/// <item>The player movement controller is ready to attach.</item>
/// </list>
/// All four predicates are passed as <see cref="Func{bool}"/>; tests
/// flip plain boolean fields and assert against an entry-counter that
/// the entry callback bumps.
/// </summary>
public sealed class AutoEnterPlayerModeTests
{
    private sealed class State
    {
        public bool LiveInWorld;
        public bool PlayerEntityPresent;
        public bool PlayerControllerReady;
        // Defaults TRUE: the hydration hold is not under test in the
        // original K.2 cases (see SpawnGroundNotReady test for it).
        public bool SpawnGroundReady = true;
        public int  EnteredCount;

        public PlayerModeAutoEntry Build() =>
            new(
                isLiveInWorld:           () => LiveInWorld,
                isPlayerEntityPresent:   () => PlayerEntityPresent,
                isPlayerControllerReady: () => PlayerControllerReady,
                isSpawnGroundReady:      () => SpawnGroundReady,
                enterPlayerMode:         () => EnteredCount++);
    }

    [Fact]
    public void TryEnter_Armed_SpawnGroundNotReady_DoesNotFire()
    {
        // #106 gate-2 (2026-06-09): player physics must not start before
        // the terrain under the spawn position has streamed in — entering
        // earlier free-falls the player into the void (gravity integrates
        // against an empty world; retail never has this state because it
        // loads cells synchronously). The guard holds until the streaming
        // pipeline registers the spawn landblock.
        var s = new State
        {
            LiveInWorld = true, PlayerEntityPresent = true,
            PlayerControllerReady = true, SpawnGroundReady = false,
        };
        var guard = s.Build();
        guard.Arm();

        Assert.False(guard.TryEnter());
        Assert.Equal(0, s.EnteredCount);
        Assert.True(guard.IsArmed);

        // Terrain hydrates → fires on the next tick.
        s.SpawnGroundReady = true;
        Assert.True(guard.TryEnter());
        Assert.Equal(1, s.EnteredCount);
    }

    [Fact]
    public void TryEnter_NotArmed_DoesNotFire()
    {
        var s = new State { LiveInWorld = true, PlayerEntityPresent = true, PlayerControllerReady = true };
        var guard = s.Build();

        // Not armed → must NOT fire even though every precondition is true.
        Assert.False(guard.TryEnter());
        Assert.Equal(0, s.EnteredCount);
        Assert.False(guard.IsArmed);
    }

    [Fact]
    public void TryEnter_Armed_LiveNotInWorld_DoesNotFire()
    {
        var s = new State { LiveInWorld = false, PlayerEntityPresent = true, PlayerControllerReady = true };
        var guard = s.Build();
        guard.Arm();

        Assert.False(guard.TryEnter());
        Assert.Equal(0, s.EnteredCount);
        Assert.True(guard.IsArmed);
    }

    [Fact]
    public void TryEnter_Armed_PlayerEntityNotPresent_DoesNotFire()
    {
        var s = new State { LiveInWorld = true, PlayerEntityPresent = false, PlayerControllerReady = true };
        var guard = s.Build();
        guard.Arm();

        Assert.False(guard.TryEnter());
        Assert.Equal(0, s.EnteredCount);
        Assert.True(guard.IsArmed);
    }

    [Fact]
    public void TryEnter_Armed_PlayerControllerNotReady_DoesNotFire()
    {
        var s = new State { LiveInWorld = true, PlayerEntityPresent = true, PlayerControllerReady = false };
        var guard = s.Build();
        guard.Arm();

        Assert.False(guard.TryEnter());
        Assert.Equal(0, s.EnteredCount);
        Assert.True(guard.IsArmed);
    }

    [Fact]
    public void TryEnter_AllConditionsSatisfied_FiresExactlyOnce()
    {
        var s = new State { LiveInWorld = true, PlayerEntityPresent = true, PlayerControllerReady = true };
        var guard = s.Build();
        guard.Arm();

        Assert.True(guard.TryEnter());
        Assert.Equal(1, s.EnteredCount);
        Assert.False(guard.IsArmed);

        // Subsequent tick must not re-fire — one-shot semantics.
        Assert.False(guard.TryEnter());
        Assert.Equal(1, s.EnteredCount);
    }

    [Fact]
    public void TryEnter_FiresOnLaterTickWhenPreconditionsBecomeTrue()
    {
        var s = new State();
        var guard = s.Build();
        guard.Arm();

        // Tick 1: only LiveInWorld true.
        s.LiveInWorld = true;
        Assert.False(guard.TryEnter());

        // Tick 2: + PlayerEntityPresent.
        s.PlayerEntityPresent = true;
        Assert.False(guard.TryEnter());

        // Tick 3: + PlayerControllerReady → fires.
        s.PlayerControllerReady = true;
        Assert.True(guard.TryEnter());
        Assert.Equal(1, s.EnteredCount);
    }

    [Fact]
    public void Cancel_BeforeFiring_SuppressesAutoEntry()
    {
        // Manual fly-mode toggle BEFORE the auto-entry fires must
        // disarm the trigger; the user's choice wins.
        var s = new State();
        var guard = s.Build();
        guard.Arm();

        // User opts out before any precondition is true.
        guard.Cancel();
        Assert.False(guard.IsArmed);

        // Even when every precondition flips true, the guard stays
        // silent — the user's manual fly-mode choice wins.
        s.LiveInWorld = true;
        s.PlayerEntityPresent = true;
        s.PlayerControllerReady = true;
        Assert.False(guard.TryEnter());
        Assert.Equal(0, s.EnteredCount);
    }

    [Fact]
    public void Arm_WhileAlreadyArmed_IsIdempotent()
    {
        var s = new State { LiveInWorld = true, PlayerEntityPresent = true, PlayerControllerReady = true };
        var guard = s.Build();
        guard.Arm();
        guard.Arm();   // second Arm() — no-op.

        Assert.True(guard.TryEnter());
        Assert.Equal(1, s.EnteredCount);
    }
}