using AcDream.Core.Net.Messages;
using AcDream.Runtime.Gameplay;

namespace AcDream.Runtime.Tests.Gameplay;

/// <summary>
/// Campaign FA slice FA2 (2026-08-12): lifecycle rules for
/// <see cref="RuntimeFellowshipState"/> — full-update assembly, incremental
/// upsert, self-vs-other quit/dismiss removal, disband clear, revision
/// monotonicity, and ownership convergence.
/// </summary>
public sealed class RuntimeFellowshipStateTests
{
    private const uint SelfGuid = 0x50000001u;
    private const uint LeaderGuid = 0x50000002u;
    private const uint OtherGuid = 0x50000003u;

    private static GameEvents.FellowMember Member(
        uint guid,
        string name = "Fellow",
        uint currentHealth = 100u,
        uint shareLoot = 0u) =>
        new(
            guid,
            CpCache: 0u,
            LumCache: 0u,
            Level: 10u,
            MaxHealth: 100u,
            MaxStamina: 100u,
            MaxMana: 100u,
            CurrentHealth: currentHealth,
            CurrentStamina: 100u,
            CurrentMana: 100u,
            ShareLoot: shareLoot,
            Name: name);

    private static GameEvents.FellowshipFullUpdate FullUpdate(
        params GameEvents.FellowMember[] members) =>
        new(
            members,
            Name: "The Fellows",
            LeaderGuid: LeaderGuid,
            ShareXp: true,
            EvenXpSplit: false,
            OpenFellow: true,
            Locked: false,
            Departed: []);

    [Fact]
    public void ApplyFullUpdate_ReplacesTheWholeRosterAndFlags()
    {
        var state = new RuntimeFellowshipState();

        state.ApplyFullUpdate(FullUpdate(
            Member(SelfGuid, "Self"),
            Member(LeaderGuid, "Leader"),
            Member(OtherGuid, "Other")));

        RuntimeFellowshipSnapshot snapshot = state.View.Snapshot;
        Assert.True(snapshot.IsInFellowship);
        Assert.Equal("The Fellows", snapshot.Name);
        Assert.Equal(LeaderGuid, snapshot.LeaderGuid);
        Assert.True(snapshot.ShareXp);
        Assert.False(snapshot.EvenXpSplit);
        Assert.True(snapshot.IsOpen);
        Assert.False(snapshot.Locked);
        Assert.Equal(3, snapshot.MemberCount);
        Assert.True(state.View.TryGetMember(OtherGuid, out RuntimeFellowMemberSnapshot other));
        Assert.Equal("Other", other.Name);

        // A SECOND full update REPLACES, not merges — the departed member
        // must disappear.
        state.ApplyFullUpdate(FullUpdate(Member(SelfGuid, "Self")));
        Assert.Equal(1, state.View.Snapshot.MemberCount);
        Assert.False(state.View.TryGetMember(OtherGuid, out _));
    }

    [Fact]
    public void ApplyUpdateFellow_UpsertsExactlyOneMemberByGuid()
    {
        var state = new RuntimeFellowshipState();
        state.ApplyFullUpdate(FullUpdate(
            Member(SelfGuid, "Self", currentHealth: 100u),
            Member(LeaderGuid, "Leader")));

        state.ApplyUpdateFellow(new GameEvents.FellowshipUpdateFellow(
            SelfGuid,
            Member(SelfGuid, "Self", currentHealth: 42u),
            UpdateType: 3u));

        Assert.True(state.View.TryGetMember(SelfGuid, out RuntimeFellowMemberSnapshot self));
        Assert.Equal(42u, self.CurrentHealth);
        // The other member is untouched.
        Assert.True(state.View.TryGetMember(LeaderGuid, out RuntimeFellowMemberSnapshot leader));
        Assert.Equal("Leader", leader.Name);
        Assert.Equal(2, state.View.Snapshot.MemberCount);
    }

    [Fact]
    public void ApplyUpdateFellow_BeforeAnyFullUpdate_IsANoOp()
    {
        var state = new RuntimeFellowshipState();
        long before = state.View.Snapshot.Revision;

        state.ApplyUpdateFellow(new GameEvents.FellowshipUpdateFellow(
            SelfGuid, Member(SelfGuid), UpdateType: 1u));

        Assert.Equal(before, state.View.Snapshot.Revision);
        Assert.False(state.View.Snapshot.IsInFellowship);
    }

    [Theory]
    [InlineData(false)] // Quit
    [InlineData(true)]  // Dismiss
    public void SelfRemoval_ClearsTheWholeSnapshot(bool viaDismiss)
    {
        var state = new RuntimeFellowshipState();
        state.ApplyFullUpdate(FullUpdate(
            Member(SelfGuid),
            Member(LeaderGuid),
            Member(OtherGuid)));

        if (viaDismiss)
            state.ApplyDismiss(SelfGuid, SelfGuid);
        else
            state.ApplyQuit(SelfGuid, SelfGuid);

        RuntimeFellowshipSnapshot snapshot = state.View.Snapshot;
        Assert.False(snapshot.IsInFellowship);
        Assert.Equal(0, snapshot.MemberCount);
        Assert.Equal(string.Empty, snapshot.Name);
        Assert.Equal(0u, snapshot.LeaderGuid);
    }

    [Theory]
    [InlineData(false)] // Quit
    [InlineData(true)]  // Dismiss
    public void OtherMemberRemoval_RemovesOnlyThatMember(bool viaDismiss)
    {
        var state = new RuntimeFellowshipState();
        state.ApplyFullUpdate(FullUpdate(
            Member(SelfGuid),
            Member(LeaderGuid),
            Member(OtherGuid)));

        if (viaDismiss)
            state.ApplyDismiss(OtherGuid, SelfGuid);
        else
            state.ApplyQuit(OtherGuid, SelfGuid);

        RuntimeFellowshipSnapshot snapshot = state.View.Snapshot;
        Assert.True(snapshot.IsInFellowship);
        Assert.Equal(2, snapshot.MemberCount);
        Assert.False(state.View.TryGetMember(OtherGuid, out _));
        Assert.True(state.View.TryGetMember(SelfGuid, out _));
    }

    [Fact]
    public void ApplyDisband_AlwaysClears()
    {
        var state = new RuntimeFellowshipState();
        state.ApplyFullUpdate(FullUpdate(Member(SelfGuid), Member(LeaderGuid)));

        state.ApplyDisband();

        Assert.False(state.View.Snapshot.IsInFellowship);
        Assert.Equal(0, state.View.Snapshot.MemberCount);
    }

    [Fact]
    public void RequiresLeaderHandoffBeforeQuit_OnlyWhenSelfIsLeaderAndNotDisbanding()
    {
        var state = new RuntimeFellowshipState();
        state.ApplyFullUpdate(FullUpdate(
            Member(SelfGuid),
            Member(LeaderGuid),
            Member(OtherGuid)));

        // Not the leader (SelfGuid isn't the leader here) — no handoff.
        Assert.False(state.RequiresLeaderHandoffBeforeQuit(SelfGuid, disband: false, out _));

        // The leader disbanding — no handoff needed (the fellowship dissolves).
        Assert.False(state.RequiresLeaderHandoffBeforeQuit(LeaderGuid, disband: true, out _));

        // The leader quitting WITHOUT disbanding — hand off to a non-leader fellow.
        Assert.True(state.RequiresLeaderHandoffBeforeQuit(LeaderGuid, disband: false, out uint newLeader));
        Assert.NotEqual(LeaderGuid, newLeader);
        Assert.True(newLeader is SelfGuid or OtherGuid);

        // Sole member (no one else to hand off to) — no handoff, even as leader.
        var solo = new RuntimeFellowshipState();
        solo.ApplyFullUpdate(new GameEvents.FellowshipFullUpdate(
            [Member(LeaderGuid)],
            "Solo",
            LeaderGuid,
            ShareXp: false,
            EvenXpSplit: false,
            OpenFellow: false,
            Locked: false,
            Departed: []));
        Assert.False(solo.RequiresLeaderHandoffBeforeQuit(LeaderGuid, disband: false, out _));
    }

    [Fact]
    public void Revision_IsMonotonicAcrossEveryMutationKind()
    {
        var state = new RuntimeFellowshipState();
        long r0 = state.View.Snapshot.Revision;

        state.ApplyFullUpdate(FullUpdate(Member(SelfGuid), Member(LeaderGuid)));
        long r1 = state.View.Snapshot.Revision;
        Assert.True(r1 > r0);

        state.ApplyUpdateFellow(new GameEvents.FellowshipUpdateFellow(
            SelfGuid, Member(SelfGuid, currentHealth: 1u), UpdateType: 3u));
        long r2 = state.View.Snapshot.Revision;
        Assert.True(r2 > r1);

        state.ApplyQuit(LeaderGuid, SelfGuid);
        long r3 = state.View.Snapshot.Revision;
        Assert.True(r3 > r2);

        state.ApplyDisband();
        long r4 = state.View.Snapshot.Revision;
        Assert.True(r4 > r3);
    }

    [Fact]
    public void ShareLoot_ReadsTheRawWireBitAsNonZero_NeverEqualsOne()
    {
        // D5 (lane B §4.1): ACE encodes ShareLoot two mutually-inconsistent
        // ways (0x10 full update, <<1 incremental) — the only safe read is
        // != 0.
        var state = new RuntimeFellowshipState();
        state.ApplyFullUpdate(FullUpdate(Member(SelfGuid, shareLoot: 0x10u)));

        Assert.True(state.View.TryGetMember(SelfGuid, out RuntimeFellowMemberSnapshot member));
        Assert.True(member.ShareLoot);
    }

    [Fact]
    public void CaptureOwnership_ConvergesOnlyAfterDisposeAndEmptyRoster()
    {
        var state = new RuntimeFellowshipState();
        state.ApplyFullUpdate(FullUpdate(Member(SelfGuid), Member(LeaderGuid)));

        Assert.False(state.CaptureOwnership().IsConverged);

        state.Dispose();

        RuntimeFellowshipOwnershipSnapshot retired = state.CaptureOwnership();
        Assert.True(retired.IsConverged);
        Assert.True(retired.IsDisposed);
        Assert.False(retired.IsInFellowship);
        Assert.Equal(0, retired.MemberCount);
    }

    [Fact]
    public void ResetSession_ClearsSessionScopedRoster_MatchingTheExternalContainerPrecedent()
    {
        // D2: fellowship is session-scoped — cleared at generation reset
        // exactly like RuntimeInventoryState.ResetExternalContainer, unlike
        // RuntimeAllegianceState which survives reconnect.
        var state = new RuntimeFellowshipState();
        state.ApplyFullUpdate(FullUpdate(Member(SelfGuid), Member(LeaderGuid)));

        state.ResetSession();

        RuntimeFellowshipSnapshot snapshot = state.View.Snapshot;
        Assert.False(snapshot.IsInFellowship);
        Assert.Equal(0, snapshot.MemberCount);
        Assert.False(state.IsDisposed);
    }

    [Fact]
    public void MutatingAfterDispose_Throws()
    {
        var state = new RuntimeFellowshipState();
        state.Dispose();

        Assert.Throws<ObjectDisposedException>(
            () => state.ApplyFullUpdate(FullUpdate(Member(SelfGuid))));
        Assert.Throws<ObjectDisposedException>(
            () => state.ApplyQuit(SelfGuid, SelfGuid));
        Assert.Throws<ObjectDisposedException>(state.ApplyDisband);
        Assert.Throws<ObjectDisposedException>(state.ResetSession);
    }
}